diff --git a/.editorconfig b/.editorconfig
index 7bbf913b62..ca5732e7e5 100644
--- a/.editorconfig
+++ b/.editorconfig
@@ -159,12 +159,23 @@ csharp_space_between_square_brackets = false
 # License header
 file_header_template = Licensed to the .NET Foundation under one or more agreements.\nThe .NET Foundation licenses this file to you under the MIT license.
 
+# ADN0057 is informational for NuGet consumers, whose custom initialization-only constructor
+# arguments may be intentional. In this repository it is an acceptance gate: every shipped layer
+# must either preserve the value or classify its entropy semantics explicitly.
+dotnet_diagnostic.ADN0057.severity = error
+
+# Concrete models and layers in the shipped source must use generated/base lifecycle plumbing.
+# The analyzer remains informational for external consumers, whose own base contracts may require
+# an override; this repository raises it to an acceptance error.
+dotnet_diagnostic.ADN0063.severity = error
+
 # Dedicated test doubles deliberately override parameter surfaces to simulate malformed,
 # throwing, or streaming implementations. Production descriptors remain compiler errors; this
 # explicit path-scoped policy keeps those fixtures buildable without an assembly-name heuristic.
 [tests/AiDotNet.Tests/**/*.cs]
 dotnet_diagnostic.AIDN081.severity = warning
 dotnet_diagnostic.AIDN082.severity = warning
+dotnet_diagnostic.ADN0063.severity = warning
 
 [src/libraries/System.Net.Http/src/System/Net/Http/{SocketsHttpHandler/Http3RequestStream.cs,BrowserHttpHandler/BrowserHttpHandler.cs}]
 # disable CA2025, the analyzer throws a NullReferenceException when processing this file: https://github.com/dotnet/roslyn-analyzers/issues/7652
diff --git a/.github/scripts/find-pr-new-failures.ps1 b/.github/scripts/find-pr-new-failures.ps1
new file mode 100644
index 0000000000..e3057cfcd4
--- /dev/null
+++ b/.github/scripts/find-pr-new-failures.ps1
@@ -0,0 +1,108 @@
+<#
+.SYNOPSIS
+Builds a VSTest filter for failures present in a PR shard but absent from the exact master baseline.
+
+.DESCRIPTION
+This is deliberately a retry selector, not a verdict engine. It reads the initial shard TRX and
+either the compact baseline ledger or the legacy baseline TRX, writes the candidate inventory, and
+publishes rerun_count/filter outputs. The aggregate analyzer consumes both the original and retry
+TRX and owns the final policy decision.
+#>
+
+[CmdletBinding()]
+param(
+    [Parameter(Mandatory = $true)]
+    [string] $CurrentResultsPath,
+    [string] $BaselineResultsPath,
+    [string] $BaselineLedgerPath,
+    [Parameter(Mandatory = $true)]
+    [string] $OutputFile
+)
+
+$ErrorActionPreference = 'Stop'
+
+function Get-TrxResults {
+    param([string] $Root)
+
+    $results = New-Object System.Collections.Generic.List[object]
+    foreach ($trx in @(Get-ChildItem -LiteralPath $Root -Recurse -Filter '*.trx' -File -ErrorAction SilentlyContinue)) {
+        [xml] $document = Get-Content -LiteralPath $trx.FullName -Raw
+        $definitions = @{}
+        foreach ($unitTest in @($document.SelectNodes('//*[local-name()="UnitTest"]'))) {
+            $method = $unitTest.SelectSingleNode('./*[local-name()="TestMethod"]')
+            if ($method -and $unitTest.id) {
+                $className = [string] $method.className
+                $methodName = [string] $method.name
+                $definitions[[string] $unitTest.id] = if ($className) {
+                    "$className.$methodName"
+                } else { $methodName }
+            }
+        }
+
+        foreach ($result in @($document.SelectNodes('//*[local-name()="UnitTestResult"]'))) {
+            $display = [string] $result.testName
+            $fullyQualified = $definitions[[string] $result.testId]
+            if ([string]::IsNullOrWhiteSpace($fullyQualified)) { $fullyQualified = $display }
+            $identity = if ($display -and $display -ne $fullyQualified) {
+                "$fullyQualified::$display"
+            } else { $fullyQualified }
+            if (-not [string]::IsNullOrWhiteSpace($identity)) {
+                $results.Add([PSCustomObject]@{
+                    identity = $identity
+                    fullyQualifiedName = $fullyQualified
+                    displayName = $display
+                    outcome = [string] $result.outcome
+                })
+            }
+        }
+    }
+    return $results.ToArray()
+}
+
+function Set-ActionOutput {
+    param([string] $Name, [string] $Value)
+    Write-Host "$Name=$Value"
+    if ($env:GITHUB_OUTPUT) { Add-Content -LiteralPath $env:GITHUB_OUTPUT -Value "$Name=$Value" }
+}
+
+if (-not (Test-Path -LiteralPath $CurrentResultsPath)) {
+    throw "Current result directory not found: $CurrentResultsPath"
+}
+
+$current = @(Get-TrxResults $CurrentResultsPath)
+$baseline = if ($BaselineLedgerPath) {
+    if (-not (Test-Path -LiteralPath $BaselineLedgerPath)) {
+        throw "Baseline ledger not found: $BaselineLedgerPath"
+    }
+    @((Get-Content -LiteralPath $BaselineLedgerPath -Raw | ConvertFrom-Json).tests)
+} elseif ($BaselineResultsPath) {
+    if (-not (Test-Path -LiteralPath $BaselineResultsPath)) {
+        throw "Baseline result directory not found: $BaselineResultsPath"
+    }
+    @(Get-TrxResults $BaselineResultsPath)
+} else {
+    throw 'BaselineLedgerPath or BaselineResultsPath is required.'
+}
+
+$baselineFailures = New-Object System.Collections.Generic.HashSet[string]([StringComparer]::Ordinal)
+foreach ($failure in @($baseline | Where-Object outcome -eq 'Failed')) {
+    [void] $baselineFailures.Add([string] $failure.identity)
+}
+
+$candidates = @($current |
+    Where-Object { $_.outcome -eq 'Failed' -and -not $baselineFailures.Contains([string] $_.identity) } |
+    Sort-Object identity -Unique)
+$methods = @($candidates.fullyQualifiedName | Where-Object { $_ } | Sort-Object -Unique)
+$filterParts = @($methods | ForEach-Object { "FullyQualifiedName=$_" })
+$filter = $filterParts -join '|'
+
+$outputParent = Split-Path -Parent $OutputFile
+if ($outputParent) { New-Item -Path $outputParent -ItemType Directory -Force | Out-Null }
+[PSCustomObject]@{
+    candidateCount = $candidates.Count
+    methodCount = $methods.Count
+    candidates = $candidates
+} | ConvertTo-Json -Depth 6 | Set-Content -LiteralPath $OutputFile -Encoding utf8
+
+Set-ActionOutput 'rerun_count' ([string] $methods.Count)
+Set-ActionOutput 'filter' $filter
diff --git a/.github/scripts/find-test-baseline.ps1 b/.github/scripts/find-test-baseline.ps1
new file mode 100644
index 0000000000..97f5a77377
--- /dev/null
+++ b/.github/scripts/find-test-baseline.ps1
@@ -0,0 +1,73 @@
+<#
+.SYNOPSIS
+Finds the exact Actions run/artifact that represents a pull request's base SHA.
+
+.DESCRIPTION
+Prefers the compact TRX ledger emitted by the aggregate job. For the first run
+after this feature is introduced, falls back to the legacy coverage/TRX artifacts
+from the exact master SHA so the rollout does not require a manual baseline.
+#>
+
+[CmdletBinding()]
+param(
+    [Parameter(Mandatory = $true)]
+    [string] $BaseSha,
+    [string] $Repository = $env:GITHUB_REPOSITORY,
+    [string] $Workflow = 'sonarcloud.yml',
+    [string] $ShardSlug
+)
+
+$ErrorActionPreference = 'Stop'
+if (-not $Repository) { throw 'Repository is required (owner/name).' }
+if (-not $env:GITHUB_STEP_SUMMARY -and -not $env:GITHUB_OUTPUT) {
+    Write-Verbose 'Running outside Actions; outputs will be written to the console only.'
+}
+
+function Invoke-GhJson {
+    param([string] $Endpoint)
+    $raw = & gh api $Endpoint
+    if ($LASTEXITCODE -ne 0) { throw "gh api failed for '$Endpoint'." }
+    return $raw | ConvertFrom-Json
+}
+
+function Set-ActionOutput {
+    param([string] $Name, [string] $Value)
+    Write-Host "$Name=$Value"
+    if ($env:GITHUB_OUTPUT) { Add-Content -LiteralPath $env:GITHUB_OUTPUT -Value "$Name=$Value" }
+}
+
+$artifactName = "test-outcome-ledger-$BaseSha"
+$encodedName = [Uri]::EscapeDataString($artifactName)
+$artifactResponse = Invoke-GhJson "repos/$Repository/actions/artifacts?name=$encodedName&per_page=100"
+$ledgerArtifact = @($artifactResponse.artifacts |
+    Where-Object {
+        -not $_.expired -and $_.name -eq $artifactName -and
+        $_.workflow_run -and $_.workflow_run.head_sha -eq $BaseSha
+    } |
+    Sort-Object created_at -Descending | Select-Object -First 1)
+
+if ($ledgerArtifact.Count -gt 0) {
+    Set-ActionOutput 'baseline_mode' 'ledger'
+    Set-ActionOutput 'baseline_run_id' ([string] $ledgerArtifact[0].workflow_run.id)
+    Set-ActionOutput 'baseline_sha' $BaseSha
+    if ($ShardSlug) { Set-ActionOutput 'baseline_artifact_name' $artifactName }
+    exit 0
+}
+
+# Bootstrap path: this base SHA predates compact ledgers. Locate the exact push
+# run and let download-artifact fetch its coverage-<sha>-* artifacts. Conclusion
+# is intentionally unrestricted: master workflows can be cancelled by CodeQL
+# after every test shard has already uploaded a valid TRX.
+$encodedWorkflow = [Uri]::EscapeDataString($Workflow)
+$runs = Invoke-GhJson "repos/$Repository/actions/workflows/$encodedWorkflow/runs?head_sha=$BaseSha&event=push&per_page=100"
+$run = @($runs.workflow_runs |
+    Where-Object { $_.head_sha -eq $BaseSha -and $_.status -eq 'completed' } |
+    Sort-Object run_attempt, created_at -Descending | Select-Object -First 1)
+if ($run.Count -eq 0) {
+    throw "No completed '$Workflow' push run exists for exact baseline SHA $BaseSha."
+}
+
+Set-ActionOutput 'baseline_mode' 'trx'
+Set-ActionOutput 'baseline_run_id' ([string] $run[0].id)
+Set-ActionOutput 'baseline_sha' $BaseSha
+if ($ShardSlug) { Set-ActionOutput 'baseline_artifact_name' "coverage-$BaseSha-$ShardSlug" }
diff --git a/.github/scripts/report-test-totals.ps1 b/.github/scripts/report-test-totals.ps1
new file mode 100644
index 0000000000..8e8659416f
--- /dev/null
+++ b/.github/scripts/report-test-totals.ps1
@@ -0,0 +1,158 @@
+# Report aggregate test totals across every shard artifact downloaded by CI.
+#
+# This is a reporter, not a gate. It always exits zero and writes stable outputs for the CI Gate.
+# Counts are explicitly labelled as a floor when a TRX is missing/unreadable, a blame-hang sequence
+# is present, or the TRX counters show that not every discovered test executed.
+
+[CmdletBinding()]
+param(
+    [string]$ResultsPath = 'TestResults',
+    [string]$WorkflowPath = '.github/workflows/sonarcloud.yml',
+    [int]$ExpectedShardCount = 0
+)
+
+$ErrorActionPreference = 'Stop'
+
+function Add-Summary {
+    param([string]$Line)
+    Write-Host $Line
+    if ($env:GITHUB_STEP_SUMMARY) {
+        try { Add-Content -LiteralPath $env:GITHUB_STEP_SUMMARY -Value $Line -ErrorAction Stop }
+        catch { Write-Host "::warning::Could not append aggregate test totals to the step summary: $($_.Exception.Message)" }
+    }
+}
+
+function Set-CiOutput {
+    param([string]$Name, [string]$Value)
+    if ($env:GITHUB_OUTPUT) {
+        try { Add-Content -LiteralPath $env:GITHUB_OUTPUT -Value "$Name=$Value" -ErrorAction Stop }
+        catch { Write-Host "::warning::Could not write aggregate output '$Name': $($_.Exception.Message)" }
+    }
+}
+
+$body = {
+    $expectedShards = $ExpectedShardCount
+    if ($expectedShards -le 0 -and (Test-Path -LiteralPath $WorkflowPath)) {
+        # Keep this self-updating with the matrix instead of hard-coding 110. Job keys are indented
+        # two spaces and shard entries ten, so the next job key closes the section unambiguously.
+        $insideShardedJob = $false
+        foreach ($line in Get-Content -LiteralPath $WorkflowPath) {
+            if ($line -match '^  test-net10-sharded:\s*$') {
+                $insideShardedJob = $true
+                continue
+            }
+            if ($insideShardedJob -and $line -match '^  [A-Za-z0-9_-]+:\s*$') { break }
+            if ($insideShardedJob -and $line -match '^          - name:\s+') { $expectedShards++ }
+        }
+    }
+
+    $trxFiles = @(Get-ChildItem -LiteralPath $ResultsPath -Recurse -Filter '*.trx' -ErrorAction SilentlyContinue)
+    $sequenceFiles = @(Get-ChildItem -LiteralPath $ResultsPath -Recurse -Filter 'Sequence_*.xml' -ErrorAction SilentlyContinue)
+    $failedOccurrences = 0
+    $failedNames = [System.Collections.Generic.HashSet[string]]::new([System.StringComparer]::Ordinal)
+    $hangVictims = [System.Collections.Generic.HashSet[string]]::new([System.StringComparer]::Ordinal)
+    $unparseableTrx = [System.Collections.Generic.List[string]]::new()
+    $unparseableSequence = [System.Collections.Generic.List[string]]::new()
+    $executed = 0
+    $discovered = 0
+    $missingCounters = 0
+
+    foreach ($trx in $trxFiles) {
+        try {
+            [xml]$document = Get-Content -LiteralPath $trx.FullName -Raw
+            $failures = @($document.SelectNodes("//*[local-name()='UnitTestResult' and @outcome='Failed']"))
+            $failedOccurrences += $failures.Count
+            foreach ($failure in $failures) {
+                $name = [string]$failure.testName
+                if (-not [string]::IsNullOrWhiteSpace($name)) { [void]$failedNames.Add($name) }
+            }
+
+            $counters = $document.SelectSingleNode("//*[local-name()='Counters']")
+            if ($counters) {
+                $executed += [int]$counters.executed
+                $discovered += [int]$counters.total
+            } else {
+                $missingCounters++
+            }
+        } catch {
+            $unparseableTrx.Add("$($trx.FullName): $($_.Exception.Message)")
+        }
+    }
+
+    foreach ($sequence in $sequenceFiles) {
+        try {
+            [xml]$document = Get-Content -LiteralPath $sequence.FullName -Raw
+            $elements = @($document.SelectNodes("//*[local-name()='UnitTestElement']"))
+            if ($elements.Count -eq 0) { continue }
+            $last = $elements[$elements.Count - 1]
+            $name = [string]$last.FullyQualifiedName
+            if ([string]::IsNullOrWhiteSpace($name)) { $name = [string]$last.InnerText }
+            if (-not [string]::IsNullOrWhiteSpace($name)) { [void]$hangVictims.Add($name.Trim()) }
+        } catch {
+            $unparseableSequence.Add("$($sequence.FullName): $($_.Exception.Message)")
+        }
+    }
+
+    # A blame-hang victim normally has no failed TRX row because the host was killed while it ran.
+    # Count only victims not already present so the aggregate matches the normalized baseline logic.
+    $additionalHangFailures = 0
+    foreach ($victim in $hangVictims) {
+        if ($failedNames.Add($victim)) { $additionalHangFailures++ }
+    }
+
+    $knownFailures = $failedOccurrences + $additionalHangFailures
+    $incomplete = $trxFiles.Count -eq 0 -or $expectedShards -le 0 -or
+        $trxFiles.Count -ne $expectedShards -or $unparseableTrx.Count -gt 0 -or
+        $unparseableSequence.Count -gt 0 -or
+        $missingCounters -gt 0 -or $hangVictims.Count -gt 0 -or
+        ($discovered -gt 0 -and $executed -lt $discovered)
+
+    $failureOutput = if ($trxFiles.Count -eq 0) { 'unknown' } else { [string]$knownFailures }
+    $distinctOutput = if ($trxFiles.Count -eq 0) { 'unknown' } else { [string]$failedNames.Count }
+    $expectedShardOutput = if ($expectedShards -gt 0) { [string]$expectedShards } else { 'unknown' }
+    Set-CiOutput 'failed_test_occurrences' $failureOutput
+    Set-CiOutput 'distinct_failing_tests' $distinctOutput
+    Set-CiOutput 'executed_tests' ([string]$executed)
+    Set-CiOutput 'discovered_tests' ([string]$discovered)
+    Set-CiOutput 'reported_shards' ([string]$trxFiles.Count)
+    Set-CiOutput 'expected_shards' $expectedShardOutput
+    Set-CiOutput 'test_totals_incomplete' $incomplete.ToString().ToLowerInvariant()
+
+    Add-Summary '## Aggregate test totals'
+    Add-Summary ''
+    Add-Summary '| Metric | Total |'
+    Add-Summary '|---|---:|'
+    Add-Summary "| Failed test occurrences (including unique hang victims) | $failureOutput |"
+    Add-Summary "| Distinct failing tests | $distinctOutput |"
+    Add-Summary "| Executed tests | $executed |"
+    Add-Summary "| Discovered tests | $discovered |"
+    Add-Summary "| Parsed TRX files | $($trxFiles.Count - $unparseableTrx.Count) / $($trxFiles.Count) |"
+    Add-Summary "| Reported shards | $($trxFiles.Count) / $expectedShardOutput |"
+    Add-Summary "| Blame-hang victims | $($hangVictims.Count) |"
+
+    if ($incomplete) {
+        Add-Summary ''
+        Add-Summary ':warning: **These failure totals are incomplete or unknown.** Treat numeric values as a floor.'
+    }
+    if ($unparseableTrx.Count -gt 0) {
+        foreach ($errorText in $unparseableTrx) { Add-Summary ('    ' + $errorText) }
+    }
+    if ($unparseableSequence.Count -gt 0) {
+        foreach ($errorText in $unparseableSequence) { Add-Summary ('    ' + $errorText) }
+    }
+}
+
+try {
+    & $body
+} catch {
+    Write-Host "::warning::report-test-totals.ps1 could not complete: $($_.Exception.Message)"
+    Set-CiOutput 'failed_test_occurrences' 'unknown'
+    Set-CiOutput 'distinct_failing_tests' 'unknown'
+    Set-CiOutput 'executed_tests' 'unknown'
+    Set-CiOutput 'discovered_tests' 'unknown'
+    Set-CiOutput 'reported_shards' 'unknown'
+    Set-CiOutput 'expected_shards' 'unknown'
+    Set-CiOutput 'test_totals_incomplete' 'true'
+}
+
+exit 0
diff --git a/.github/scripts/test-regression-analysis.ps1 b/.github/scripts/test-regression-analysis.ps1
new file mode 100644
index 0000000000..92821e427f
--- /dev/null
+++ b/.github/scripts/test-regression-analysis.ps1
@@ -0,0 +1,704 @@
+<#
+.SYNOPSIS
+Builds a machine-readable test ledger from TRX files and, when a baseline is
+available, evaluates AiDotNet's regression policy.
+
+.DESCRIPTION
+The script intentionally treats a shard with missing/unparseable/incomplete
+TRX as incomplete. A short failure list from a killed test host is never
+allowed to look like an improvement.
+
+The comparison policy is the repository's hybrid rule:
+  * no confirmed-new failures, or explicitly fixed failures must outnumber them;
+  * incomplete shards must not increase;
+  * a previously-green shard may not become red/incomplete; and
+  * a new failure on a touched type/test method is a hard regression.
+
+It always writes ledger.json, comparison.json, and summary.md before returning
+a policy failure, so the final CI status remains diagnosable from one artifact.
+#>
+
+[CmdletBinding()]
+param(
+    [Parameter(Mandatory = $true)]
+    [string] $CurrentResultsPath,
+
+    [string] $BaselineResultsPath,
+    [string] $BaselineLedgerPath,
+
+    [Parameter(Mandatory = $true)]
+    [string] $OutputDirectory,
+
+    [string] $CurrentSha = $env:GITHUB_SHA,
+    [string] $BaselineSha,
+    [string] $RepositoryPath = '.',
+    [string] $CurrentWorkflowPath,
+    [string] $BaselineWorkflowPath,
+    [switch] $FailOnPolicy
+)
+
+$ErrorActionPreference = 'Stop'
+$schemaVersion = 1
+
+function ConvertTo-ShardKey {
+    param([string] $Name)
+    return ($Name -replace '[\\/:*?"<>|\s-]+', '_').Trim('_')
+}
+
+function Read-WorkflowShardInventory {
+    param([string] $Path)
+
+    if ([string]::IsNullOrWhiteSpace($Path)) { return @() }
+    if (-not (Test-Path -LiteralPath $Path)) { throw "Workflow file not found: $Path" }
+
+    $insideJob = $false
+    $items = New-Object System.Collections.Generic.List[object]
+    $keys = New-Object System.Collections.Generic.HashSet[string]([StringComparer]::Ordinal)
+    foreach ($line in Get-Content -LiteralPath $Path) {
+        if (-not $insideJob) {
+            if ($line -match '^  test-net10-sharded:\s*$') { $insideJob = $true }
+            continue
+        }
+        if ($line -match '^  [A-Za-z0-9_-]+:\s*$') { break }
+        # Matrix entries are indented ten spaces. Workflow steps use six, so this does not
+        # accidentally count the many "- name" entries under steps.
+        if ($line -notmatch '^          - name:\s*(.+?)\s*$') { continue }
+        $name = $Matches[1].Trim().Trim('"').Trim("'")
+        $key = ConvertTo-ShardKey $name
+        if (-not $keys.Add($key)) {
+            throw "Workflow '$Path' contains duplicate shard key '$key'."
+        }
+        $items.Add([PSCustomObject]@{ key = $key; name = $name })
+    }
+    if (-not $insideJob -or $items.Count -eq 0) {
+        throw "Workflow '$Path' contains no test-net10-sharded matrix inventory."
+    }
+    return $items.ToArray()
+}
+
+function Add-MissingExpectedShards {
+    param($Ledger, [object[]] $ExpectedShards)
+
+    if (-not $ExpectedShards -or $ExpectedShards.Count -eq 0) { return $Ledger }
+    $observed = New-Object System.Collections.Generic.HashSet[string]([StringComparer]::Ordinal)
+    foreach ($shard in @($Ledger.shards)) { [void] $observed.Add([string] $shard.key) }
+    $allShards = New-Object System.Collections.Generic.List[object]
+    foreach ($shard in @($Ledger.shards)) { $allShards.Add($shard) }
+    foreach ($expected in $ExpectedShards) {
+        if ($observed.Contains([string] $expected.key)) { continue }
+        $allShards.Add([PSCustomObject]@{
+            key = [string] $expected.key
+            name = [string] $expected.name
+            status = 'Incomplete'
+            policyStatus = 'Incomplete'
+            total = 0
+            executed = 0
+            notExecuted = 0
+            aborted = 0
+            failed = 0
+            confirmedFailed = 0
+            rerunPassedFailures = 0
+            missingTrx = $true
+            parseErrors = @('The expected matrix shard uploaded no outcome artifact.')
+            testStepOutcome = 'missing-artifact'
+        })
+    }
+    $Ledger.shards = @($allShards.ToArray() | Sort-Object key)
+    return $Ledger
+}
+
+function Get-IntAttribute {
+    param($Node, [string] $Name)
+    $value = $Node.GetAttribute($Name)
+    if ([string]::IsNullOrWhiteSpace($value)) { return 0 }
+    $parsed = 0
+    if ([int]::TryParse($value, [ref] $parsed)) { return $parsed }
+    return 0
+}
+
+function Get-ShardContainers {
+    param([string] $Root)
+
+    if (-not (Test-Path -LiteralPath $Root)) { return @() }
+
+    $rootItem = Get-Item -LiteralPath $Root
+    $children = @(Get-ChildItem -LiteralPath $rootItem.FullName -Directory -ErrorAction SilentlyContinue)
+    $rootHasResults = @(Get-ChildItem -LiteralPath $rootItem.FullName -Recurse -Filter '*.trx' -File -ErrorAction SilentlyContinue).Count -gt 0
+    $rootHasMetadata = @(Get-ChildItem -LiteralPath $rootItem.FullName -Recurse -Filter 'shard-metadata.json' -File -ErrorAction SilentlyContinue).Count -gt 0
+
+    # actions/download-artifact keeps one directory per artifact. Synthetic/local
+    # callers commonly pass one result tree directly, so support both layouts.
+    if ($children.Count -eq 0 -or (($rootHasResults -or $rootHasMetadata) -and
+        -not ($children | Where-Object { $_.Name -match '^(coverage|test-outcome)-[0-9a-f]+-' }))) {
+        return @($rootItem)
+    }
+
+    return @($children | Where-Object {
+        @(Get-ChildItem -LiteralPath $_.FullName -Recurse -Filter '*.trx' -File -ErrorAction SilentlyContinue).Count -gt 0 -or
+        @(Get-ChildItem -LiteralPath $_.FullName -Recurse -Filter 'shard-metadata.json' -File -ErrorAction SilentlyContinue).Count -gt 0
+    })
+}
+
+function Read-TestLedger {
+    param([string] $Root, [string] $Sha)
+
+    $shards = New-Object System.Collections.Generic.List[object]
+    $allTests = New-Object System.Collections.Generic.List[object]
+
+    foreach ($container in @(Get-ShardContainers $Root)) {
+        $metadataFile = Get-ChildItem -LiteralPath $container.FullName -Recurse -Filter 'shard-metadata.json' -File -ErrorAction SilentlyContinue |
+            Select-Object -First 1
+        $metadata = $null
+        $metadataError = $null
+        if ($metadataFile) {
+            try { $metadata = Get-Content -LiteralPath $metadataFile.FullName -Raw | ConvertFrom-Json }
+            catch { $metadataError = $_.Exception.Message }
+        }
+
+        $displayName = if ($metadata -and $metadata.shard) { [string] $metadata.shard } else { $container.Name }
+        $key = if ($metadata -and $metadata.slug) {
+            [string] $metadata.slug
+        } else {
+            ConvertTo-ShardKey ($container.Name -replace '^(coverage|test-outcome)-[0-9a-f]+-', '')
+        }
+
+        $trxFiles = @(Get-ChildItem -LiteralPath $container.FullName -Recurse -Filter '*.trx' -File -ErrorAction SilentlyContinue)
+        $parseErrors = New-Object System.Collections.Generic.List[string]
+        if ($metadataError) { $parseErrors.Add("shard-metadata.json: $metadataError") }
+        $total = 0
+        $executed = 0
+        $notExecuted = 0
+        $aborted = 0
+        $failedCounter = 0
+
+        foreach ($trx in $trxFiles) {
+            try {
+                [xml] $document = Get-Content -LiteralPath $trx.FullName -Raw
+                $counters = $document.SelectSingleNode('//*[local-name()="Counters"]')
+                if ($counters) {
+                    $total += Get-IntAttribute $counters 'total'
+                    $executed += Get-IntAttribute $counters 'executed'
+                    $notExecuted += Get-IntAttribute $counters 'notExecuted'
+                    $aborted += Get-IntAttribute $counters 'aborted'
+                    $failedCounter += Get-IntAttribute $counters 'failed'
+                } else {
+                    $parseErrors.Add("$($trx.Name): no ResultSummary/Counters element")
+                }
+
+                $definitions = @{}
+                foreach ($unitTest in @($document.SelectNodes('//*[local-name()="UnitTest"]'))) {
+                    $method = $unitTest.SelectSingleNode('./*[local-name()="TestMethod"]')
+                    if ($method -and $unitTest.id) {
+                        $className = [string] $method.className
+                        $methodName = [string] $method.name
+                        $definitions[[string] $unitTest.id] = if ($className) { "$className.$methodName" } else { $methodName }
+                    }
+                }
+
+                foreach ($result in @($document.SelectNodes('//*[local-name()="UnitTestResult"]'))) {
+                    $display = [string] $result.testName
+                    $fullyQualified = $definitions[[string] $result.testId]
+                    if ([string]::IsNullOrWhiteSpace($fullyQualified)) { $fullyQualified = $display }
+                    $identity = if ($display -and $display -ne $fullyQualified) {
+                        "$fullyQualified::$display"
+                    } else {
+                        $fullyQualified
+                    }
+                    if ([string]::IsNullOrWhiteSpace($identity)) {
+                        $identity = "unknown::$($trx.Name)::$($result.executionId)"
+                    }
+
+                    $messageNode = $result.SelectSingleNode('.//*[local-name()="ErrorInfo"]/*[local-name()="Message"]')
+                    $message = if ($messageNode) { ([string] $messageNode.InnerText -split "`r?`n")[0].Trim() } else { '' }
+                    $allTests.Add([PSCustomObject]@{
+                        identity = $identity
+                        fullyQualifiedName = $fullyQualified
+                        displayName = $display
+                        outcome = [string] $result.outcome
+                        shard = $key
+                        duration = [string] $result.duration
+                        message = $message
+                    })
+                }
+            } catch {
+                $parseErrors.Add("$($trx.Name): $($_.Exception.Message)")
+            }
+        }
+
+        $shardTests = @($allTests | Where-Object shard -eq $key)
+        $failures = @($shardTests | Where-Object outcome -eq 'Failed')
+        $distinctFailures = @($failures | Group-Object identity | ForEach-Object { $_.Group[0] })
+        $passedIds = New-Object System.Collections.Generic.HashSet[string]([StringComparer]::Ordinal)
+        foreach ($passed in @($shardTests | Where-Object outcome -eq 'Passed')) {
+            [void] $passedIds.Add([string] $passed.identity)
+        }
+        $rerunPassedFailures = @($distinctFailures | Where-Object {
+            $passedIds.Contains([string] $_.identity)
+        })
+        $confirmedFailures = @($distinctFailures | Where-Object {
+            -not $passedIds.Contains([string] $_.identity)
+        })
+        $notExecutedResults = @($allTests | Where-Object {
+            $_.shard -eq $key -and $_.outcome -eq 'NotExecuted'
+        }).Count
+        $accountedNotExecuted = [Math]::Max($notExecuted, $notExecutedResults)
+        $missingTrx = $trxFiles.Count -eq 0
+        # VSTest intentionally records skipped tests as notExecuted. Those are fully accounted
+        # results, not truncation. A killed host leaves tests unaccounted (or marks them aborted),
+        # which is the incomplete condition the policy needs to catch.
+        $counterGap = $total -gt 0 -and ($executed + $accountedNotExecuted) -lt $total
+        $abnormalTermination = $aborted -gt 0
+        $stepOutcome = if ($metadata -and $metadata.testStepOutcome) { [string] $metadata.testStepOutcome } else { '' }
+        $nonTestFailure = $stepOutcome -and $stepOutcome -ne 'success' -and $failures.Count -eq 0
+        $incomplete = $missingTrx -or $parseErrors.Count -gt 0 -or $counterGap -or
+            $abnormalTermination -or $nonTestFailure
+        $status = if ($incomplete) { 'Incomplete' } elseif ($failures.Count -gt 0 -or $failedCounter -gt 0) { 'Failed' } else { 'Passed' }
+        $policyStatus = if ($incomplete) {
+            'Incomplete'
+        } elseif ($confirmedFailures.Count -gt 0 -or $failedCounter -gt $distinctFailures.Count) {
+            'Failed'
+        } else {
+            'Passed'
+        }
+
+        $shards.Add([PSCustomObject]@{
+            key = $key
+            name = $displayName
+            status = $status
+            policyStatus = $policyStatus
+            total = $total
+            executed = $executed
+            notExecuted = $accountedNotExecuted
+            aborted = $aborted
+            failed = [Math]::Max($failures.Count, $failedCounter)
+            confirmedFailed = $confirmedFailures.Count
+            rerunPassedFailures = $rerunPassedFailures.Count
+            missingTrx = $missingTrx
+            parseErrors = @($parseErrors)
+            testStepOutcome = $stepOutcome
+        })
+    }
+
+    $distinctTests = @($allTests | Sort-Object identity, outcome, shard -Unique)
+    return [PSCustomObject]@{
+        schemaVersion = $schemaVersion
+        sha = $Sha
+        generatedUtc = [DateTime]::UtcNow.ToString('o')
+        shards = @($shards | Sort-Object key)
+        tests = $distinctTests
+    }
+}
+
+function Read-LedgerFile {
+    param([string] $Path)
+    if (-not (Test-Path -LiteralPath $Path)) { throw "Baseline ledger not found: $Path" }
+    $ledger = Get-Content -LiteralPath $Path -Raw | ConvertFrom-Json
+    if ([int] $ledger.schemaVersion -ne $schemaVersion) {
+        throw "Unsupported baseline ledger schema '$($ledger.schemaVersion)'; expected '$schemaVersion'."
+    }
+    return $ledger
+}
+
+function Get-TouchedTokens {
+    param([string] $Repo, [string] $Base, [string] $Head)
+
+    $tokens = New-Object System.Collections.Generic.HashSet[string]([StringComparer]::OrdinalIgnoreCase)
+    if (-not $Base -or -not $Head -or -not (Test-Path -LiteralPath (Join-Path $Repo '.git'))) { return @() }
+
+    $generic = @('Dispose', 'Initialize', 'CreateNetwork', 'GetParameters', 'SetParameters',
+        'UpdateParameters', 'Forward', 'Backward', 'Predict', 'Train', 'Clone')
+    try {
+        $files = & git -C $Repo diff --name-only "$Base...$Head" -- '*.cs'
+        if ($LASTEXITCODE -ne 0) { throw "git diff could not compare $Base...$Head" }
+        foreach ($file in @($files)) {
+            $name = [IO.Path]::GetFileNameWithoutExtension([string] $file)
+            if ($name.Length -ge 5) { [void] $tokens.Add($name) }
+        }
+
+        $diff = & git -C $Repo diff --unified=0 "$Base...$Head" -- '*.cs'
+        if ($LASTEXITCODE -ne 0) { throw "git diff could not inspect $Base...$Head" }
+        $currentFile = $null
+        foreach ($diffLine in @($diff)) {
+            if ($diffLine -match '^\+\+\+ b/(.+\.cs)$') {
+                $currentFile = Join-Path $Repo $Matches[1]
+                continue
+            }
+
+            if ($diffLine -match '^@@ -[^ ]+ \+(\d+)' -and $currentFile -and
+                (Test-Path -LiteralPath $currentFile)) {
+                # Git's built-in C# hunk context commonly names only the enclosing class. Walk
+                # backward from the changed line to capture the actual test/method containing the
+                # edit, so a common base-test change is still recognized as touched when the TRX
+                # identity belongs to a generated derived fixture.
+                $lineNumber = [int] $Matches[1]
+                $source = @(Get-Content -LiteralPath $currentFile)
+                $lowerBound = [Math]::Max(0, $lineNumber - 201)
+                for ($index = [Math]::Min($source.Count - 1, $lineNumber - 1); $index -ge $lowerBound; $index--) {
+                    if ($source[$index] -match '^\s*(?:(?:public|protected|private|internal|static|virtual|override|sealed|async|partial|new)\s+)+(?:[A-Za-z_][A-Za-z0-9_<>,.?\[\]]*\s+)+([A-Za-z_][A-Za-z0-9_]*)\s*\(') {
+                        $methodName = $Matches[1]
+                        if ($methodName.Length -ge 5 -and $generic -notcontains $methodName) {
+                            [void] $tokens.Add($methodName)
+                        }
+                        break
+                    }
+                }
+            }
+        }
+        foreach ($line in @($diff | Where-Object { $_ -match '^[+-](?![+-])' })) {
+            foreach ($match in [regex]::Matches($line, '\b(?:class|struct|interface|record)\s+([A-Za-z_][A-Za-z0-9_]*)|\b(?:Task|ValueTask|void|bool|double|float|int|long|Tensor<[^>]+>)\s+([A-Za-z_][A-Za-z0-9_]*)\s*\(')) {
+                $token = if ($match.Groups[1].Success) { $match.Groups[1].Value } else { $match.Groups[2].Value }
+                if ($token.Length -ge 5 -and $generic -notcontains $token) { [void] $tokens.Add($token) }
+            }
+        }
+    } catch {
+        Write-Warning "Could not derive touched test/type tokens: $($_.Exception.Message)"
+    }
+    return @($tokens | Sort-Object)
+}
+
+function Test-MatchesToken {
+    param($Failure, [string[]] $Tokens)
+    $haystack = "$($Failure.identity) $($Failure.fullyQualifiedName) $($Failure.displayName)"
+    foreach ($token in $Tokens) {
+        if ($haystack.IndexOf($token, [StringComparison]::OrdinalIgnoreCase) -ge 0) { return $true }
+    }
+    return $false
+}
+
+function Write-JsonFile {
+    param($Value, [string] $Path)
+    $Value | ConvertTo-Json -Depth 10 | Set-Content -LiteralPath $Path -Encoding utf8
+}
+
+function Get-LedgerStatistics {
+    param($Ledger)
+
+    $failures = @($Ledger.tests | Where-Object outcome -eq 'Failed')
+    return [PSCustomObject]@{
+        shardCount = @($Ledger.shards).Count
+        passedShards = @($Ledger.shards | Where-Object status -eq 'Passed').Count
+        failedShards = @($Ledger.shards | Where-Object status -eq 'Failed').Count
+        incompleteShards = @($Ledger.shards | Where-Object status -eq 'Incomplete').Count
+        policyPassedShards = @($Ledger.shards | Where-Object {
+            $status = if ($_.PSObject.Properties['policyStatus']) { $_.policyStatus } else { $_.status }
+            $status -eq 'Passed'
+        }).Count
+        policyFailedShards = @($Ledger.shards | Where-Object {
+            $status = if ($_.PSObject.Properties['policyStatus']) { $_.policyStatus } else { $_.status }
+            $status -eq 'Failed'
+        }).Count
+        rerunPassedFailures = [int](@($Ledger.shards | Measure-Object -Property rerunPassedFailures -Sum).Sum)
+        reportedFailureResults = [int](@($Ledger.shards | Measure-Object -Property failed -Sum).Sum)
+        distinctFailures = @($failures | Group-Object identity).Count
+        totalTests = [int](@($Ledger.shards | Measure-Object -Property total -Sum).Sum)
+        executedTests = [int](@($Ledger.shards | Measure-Object -Property executed -Sum).Sum)
+    }
+}
+
+function Get-FailureCategories {
+    param([object[]] $Failures)
+
+    return @($Failures |
+        Group-Object {
+            if ([string]::IsNullOrWhiteSpace($_.message)) { return '<no error message>' }
+            # Values, durations, indices and seeds differ across tests even when the assertion and
+            # root cause are identical. Normalize numeric literals so one loss-domain bug across
+            # many model families appears as one category instead of dozens of one-off messages.
+            return ([string] $_.message) -replace '(?<![A-Za-z_])[-+]?(?:\d+(?:\.\d*)?|\.\d+)(?:[Ee][-+]?\d+)?', '<n>'
+        } |
+        Sort-Object -Property @{ Expression = 'Count'; Descending = $true }, @{ Expression = 'Name'; Ascending = $true } |
+        ForEach-Object {
+            [PSCustomObject]@{
+                message = [string] $_.Name
+                count = $_.Count
+                examples = @($_.Group | Select-Object -First 5 | ForEach-Object { [string] $_.identity })
+            }
+        })
+}
+
+function ConvertTo-MarkdownCell {
+    param([string] $Value)
+    if ($null -eq $Value) { return '' }
+    return (($Value -replace '\|', '\|') -replace "`r?`n", ' ').Trim()
+}
+
+function Add-MarkdownList {
+    param([System.Collections.Generic.List[string]] $Lines, [string] $Heading, [object[]] $Items, [int] $Limit = 100)
+    $Lines.Add("### $Heading")
+    $Lines.Add('')
+    if (-not $Items -or $Items.Count -eq 0) {
+        $Lines.Add('_None._')
+        $Lines.Add('')
+        return
+    }
+    foreach ($item in @($Items | Select-Object -First $Limit)) { $Lines.Add("- $item") }
+    if ($Items.Count -gt $Limit) { $Lines.Add("- ...and $($Items.Count - $Limit) more (see comparison.json)") }
+    $Lines.Add('')
+}
+
+New-Item -Path $OutputDirectory -ItemType Directory -Force | Out-Null
+$ledgerPath = Join-Path $OutputDirectory 'ledger.json'
+$comparisonPath = Join-Path $OutputDirectory 'comparison.json'
+$summaryPath = Join-Path $OutputDirectory 'summary.md'
+$failureCsvPath = Join-Path $OutputDirectory 'failures.csv'
+$shardCsvPath = Join-Path $OutputDirectory 'shards.csv'
+
+$currentInventory = @(Read-WorkflowShardInventory $CurrentWorkflowPath)
+$baselineInventory = @(Read-WorkflowShardInventory $BaselineWorkflowPath)
+$current = Read-TestLedger -Root $CurrentResultsPath -Sha $CurrentSha
+$current = Add-MissingExpectedShards $current $currentInventory
+Write-JsonFile $current $ledgerPath
+$current.shards |
+    Select-Object key, name, status, policyStatus, total, executed, notExecuted, aborted,
+        failed, confirmedFailed, rerunPassedFailures, missingTrx, testStepOutcome |
+    Export-Csv -LiteralPath $shardCsvPath -NoTypeInformation -Encoding utf8
+$current.tests |
+    Where-Object outcome -eq 'Failed' |
+    Select-Object identity, fullyQualifiedName, displayName, shard, duration, message |
+    Export-Csv -LiteralPath $failureCsvPath -NoTypeInformation -Encoding utf8
+
+$currentFailures = @($current.tests | Where-Object outcome -eq 'Failed' | Group-Object identity | ForEach-Object { $_.Group[0] })
+$currentPassIds = New-Object System.Collections.Generic.HashSet[string]([StringComparer]::Ordinal)
+foreach ($passed in @($current.tests | Where-Object outcome -eq 'Passed')) {
+    [void] $currentPassIds.Add([string] $passed.identity)
+}
+$currentRerunPassedFailures = @($currentFailures | Where-Object {
+    $currentPassIds.Contains([string] $_.identity)
+})
+$currentIncomplete = @($current.shards | Where-Object status -eq 'Incomplete')
+$currentStats = Get-LedgerStatistics $current
+$currentCategories = @(Get-FailureCategories $currentFailures)
+$lines = New-Object System.Collections.Generic.List[string]
+$lines.Add('# Test regression analysis')
+$lines.Add('')
+
+$baseline = $null
+if ($BaselineLedgerPath) { $baseline = Read-LedgerFile $BaselineLedgerPath }
+elseif ($BaselineResultsPath) { $baseline = Read-TestLedger -Root $BaselineResultsPath -Sha $BaselineSha }
+if ($baseline) { $baseline = Add-MissingExpectedShards $baseline $baselineInventory }
+
+if (-not $baseline) {
+    $summary = [PSCustomObject]@{
+        mode = 'inventory'
+        currentSha = $CurrentSha
+        counts = $currentStats
+        failureCategories = $currentCategories
+        policyPassed = $true
+    }
+    $lines.Add("Current master ledger: **$($currentStats.shardCount) shards**, **$($currentStats.passedShards) passed**, **$($currentStats.failedShards) failed**, **$($currentStats.incompleteShards) incomplete**.")
+    $lines.Add('')
+    $lines.Add("The TRX files report **$($currentStats.reportedFailureResults) failing results** representing **$($currentStats.distinctFailures) distinct failing tests**.")
+    $lines.Add('')
+    $lines.Add('This push establishes the TRX baseline artifact used by later pull requests.')
+    $lines.Add('')
+    $lines.Add('## Failure categories')
+    $lines.Add('')
+    $lines.Add('| Count | First error line |')
+    $lines.Add('|---:|---|')
+    foreach ($category in @($currentCategories | Select-Object -First 30)) {
+        $lines.Add("| $($category.count) | $(ConvertTo-MarkdownCell $category.message) |")
+    }
+    if ($currentCategories.Count -eq 0) { $lines.Add('| 0 | _None_ |') }
+    Write-JsonFile $summary $comparisonPath
+} else {
+    $baselineFailures = @($baseline.tests | Where-Object outcome -eq 'Failed' | Group-Object identity | ForEach-Object { $_.Group[0] })
+    $baselineFailureIds = @{}
+    foreach ($failure in $baselineFailures) { $baselineFailureIds[[string] $failure.identity] = $failure }
+    $currentFailureIds = @{}
+    foreach ($failure in $currentFailures) { $currentFailureIds[[string] $failure.identity] = $failure }
+
+    $persistent = @($currentFailures | Where-Object { $baselineFailureIds.ContainsKey([string] $_.identity) })
+    $newFailures = @($currentFailures | Where-Object { -not $baselineFailureIds.ContainsKey([string] $_.identity) })
+    $rerunPassedNew = @($newFailures | Where-Object {
+        $currentPassIds.Contains([string] $_.identity)
+    })
+    $confirmedNew = @($newFailures | Where-Object {
+        -not $currentPassIds.Contains([string] $_.identity)
+    })
+    $fixed = @($baselineFailures | Where-Object {
+        if ($currentFailureIds.ContainsKey([string] $_.identity)) { return $false }
+        $id = [string] $_.identity
+        return @($current.tests | Where-Object { $_.identity -eq $id -and $_.outcome -eq 'Passed' }).Count -gt 0
+    })
+    $notObserved = @($baselineFailures | Where-Object {
+        -not $currentFailureIds.ContainsKey([string] $_.identity) -and
+        -not (@($fixed | Where-Object identity -eq $_.identity).Count -gt 0)
+    })
+
+    $baselineShardMap = @{}
+    foreach ($shard in $baseline.shards) { $baselineShardMap[[string] $shard.key] = $shard }
+    $currentShardMap = @{}
+    foreach ($shard in $current.shards) { $currentShardMap[[string] $shard.key] = $shard }
+
+    # An absent artifact is an incomplete shard, even when that shard was already red on master.
+    # Without this synthetic entry, dropping a red artifact also drops its failures and can make a
+    # killed run look like an improvement. Baseline green shards are additionally caught below.
+    $missingCurrentShards = @($baseline.shards | Where-Object {
+        -not $currentShardMap.ContainsKey([string] $_.key)
+    } | ForEach-Object {
+        [PSCustomObject]@{
+            key = [string] $_.key
+            name = [string] $_.name
+            status = 'Missing'
+            policyStatus = 'Missing'
+            total = [int] $_.total
+            executed = 0
+            notExecuted = 0
+            aborted = 0
+            failed = 0
+            confirmedFailed = 0
+            rerunPassedFailures = 0
+            missingTrx = $true
+            parseErrors = @('No current artifact was uploaded for this baseline shard.')
+            testStepOutcome = 'missing'
+        }
+    })
+
+    $greenToRed = New-Object System.Collections.Generic.List[object]
+    foreach ($entry in $baselineShardMap.GetEnumerator()) {
+        $beforeStatus = if ($entry.Value.PSObject.Properties['policyStatus']) {
+            [string] $entry.Value.policyStatus
+        } else { [string] $entry.Value.status }
+        if ($beforeStatus -ne 'Passed') { continue }
+        $now = $currentShardMap[$entry.Key]
+        $nowStatus = if (-not $now) {
+            'Missing'
+        } elseif ($now.PSObject.Properties['policyStatus']) {
+            [string] $now.policyStatus
+        } else { [string] $now.status }
+        if ($nowStatus -ne 'Passed') {
+            $greenToRed.Add([PSCustomObject]@{
+                key = $entry.Key
+                name = [string] $entry.Value.name
+                currentStatus = $nowStatus
+            })
+        }
+    }
+
+    $touchedTokens = @(Get-TouchedTokens -Repo $RepositoryPath -Base $BaselineSha -Head $CurrentSha)
+    $touchedNew = @($confirmedNew | Where-Object { Test-MatchesToken $_ $touchedTokens })
+    $baselineIncomplete = @($baseline.shards | Where-Object status -eq 'Incomplete')
+    $effectiveCurrentIncomplete = @($currentIncomplete) + @($missingCurrentShards)
+    $baselineStats = Get-LedgerStatistics $baseline
+    $baselineCategories = @(Get-FailureCategories $baselineFailures)
+    $greenToRedArray = @($greenToRed | ForEach-Object { $_ })
+    # A missing result never earns credit as a fix. The verified balance shrinks only when explicit
+    # current passes for baseline failures outnumber genuinely new failures.
+    $netImproved = $fixed.Count -gt $confirmedNew.Count
+    # A neutral PR with zero confirmed-new failures must remain mergeable even when it does not
+    # promise to fix a baseline failure. When new failures exist, require the verified distinct
+    # failure balance to shrink: explicit current passes must outnumber confirmed-new failures.
+    $failureBalanceAccepted = $confirmedNew.Count -eq 0 -or $netImproved
+    $incompleteNotIncreased = $effectiveCurrentIncomplete.Count -le $baselineIncomplete.Count
+    $policyPassed = $failureBalanceAccepted -and $incompleteNotIncreased -and $greenToRed.Count -eq 0 -and $touchedNew.Count -eq 0
+
+    $resolvedBaselineSha = [string] $baseline.sha
+    if ($BaselineSha) { $resolvedBaselineSha = [string] $BaselineSha }
+    $comparison = [PSCustomObject]@{
+        mode = 'comparison'
+        currentSha = $CurrentSha
+        baselineSha = $resolvedBaselineSha
+        policyPassed = $policyPassed
+        criteria = [PSCustomObject]@{
+            noConfirmedNewFailures = $confirmedNew.Count -eq 0
+            verifiedFailureBalanceShrank = $netImproved
+            failureBalanceAccepted = $failureBalanceAccepted
+            incompleteShardsDidNotIncrease = $incompleteNotIncreased
+            noPreviouslyGreenShardRegressed = $greenToRed.Count -eq 0
+            noTouchedSurfaceRegression = $touchedNew.Count -eq 0
+        }
+        counts = [PSCustomObject]@{
+            baselineShards = $baselineStats.shardCount
+            currentShards = $currentStats.shardCount
+            baselinePassedShards = $baselineStats.passedShards
+            currentPassedShards = $currentStats.passedShards
+            baselineFailedShards = $baselineStats.failedShards
+            currentFailedShards = $currentStats.failedShards
+            baselinePolicyFailedShards = $baselineStats.policyFailedShards
+            currentPolicyFailedShards = $currentStats.policyFailedShards
+            baselineDistinctFailures = $baselineFailures.Count
+            currentDistinctFailures = $currentFailures.Count
+            baselineReportedFailureResults = $baselineStats.reportedFailureResults
+            currentReportedFailureResults = $currentStats.reportedFailureResults
+            netFailureDelta = $currentFailures.Count - $baselineFailures.Count
+            persistentFailures = $persistent.Count
+            fixedFailures = $fixed.Count
+            newFailures = $newFailures.Count
+            confirmedNewFailures = $confirmedNew.Count
+            rerunPassedNewFailures = $rerunPassedNew.Count
+            baselineFailuresNotObserved = $notObserved.Count
+            baselineIncompleteShards = $baselineIncomplete.Count
+            currentIncompleteShards = $effectiveCurrentIncomplete.Count
+            missingCurrentShardArtifacts = $missingCurrentShards.Count
+            greenToRedShards = $greenToRed.Count
+            touchedNewFailures = $touchedNew.Count
+        }
+        greenToRedShards = $greenToRedArray
+        newFailures = @($newFailures)
+        confirmedNewFailures = @($confirmedNew)
+        rerunPassedNewFailures = @($rerunPassedNew)
+        touchedNewFailures = @($touchedNew)
+        fixedFailures = @($fixed)
+        persistentFailures = @($persistent)
+        baselineFailuresNotObserved = @($notObserved)
+        currentIncompleteShards = @($effectiveCurrentIncomplete)
+        missingCurrentShardArtifacts = @($missingCurrentShards)
+        baselineFailureCategories = $baselineCategories
+        currentFailureCategories = $currentCategories
+        touchedTokens = $touchedTokens
+    }
+    Write-JsonFile $comparison $comparisonPath
+
+    $verdict = if ($policyPassed) { 'PASSED' } else { 'FAILED' }
+    $lines.Add("## Policy $verdict")
+    $lines.Add('')
+    $lines.Add('| Metric | Baseline | Current | Delta |')
+    $lines.Add('|---|---:|---:|---:|')
+    $lines.Add("| Passed shards | $($baselineStats.passedShards) | $($currentStats.passedShards) | $($currentStats.passedShards - $baselineStats.passedShards) |")
+    $lines.Add("| Failed shards | $($baselineStats.failedShards) | $($currentStats.failedShards) | $($currentStats.failedShards - $baselineStats.failedShards) |")
+    $lines.Add("| Reproducibly failed shards after targeted retry | $($baselineStats.policyFailedShards) | $($currentStats.policyFailedShards) | $($currentStats.policyFailedShards - $baselineStats.policyFailedShards) |")
+    $lines.Add("| Distinct failing tests | $($baselineFailures.Count) | $($currentFailures.Count) | $($currentFailures.Count - $baselineFailures.Count) |")
+    $lines.Add("| Reported failing results | $($baselineStats.reportedFailureResults) | $($currentStats.reportedFailureResults) | $($currentStats.reportedFailureResults - $baselineStats.reportedFailureResults) |")
+    $lines.Add("| Incomplete/missing shards | $($baselineIncomplete.Count) | $($effectiveCurrentIncomplete.Count) | $($effectiveCurrentIncomplete.Count - $baselineIncomplete.Count) |")
+    $lines.Add('')
+    $lines.Add('| Acceptance criterion | Result |')
+    $lines.Add('|---|---|')
+    $lines.Add("| Strict: no confirmed-new failures | $(if ($confirmedNew.Count -eq 0) { 'PASS' } else { 'FAIL' }) |")
+    $lines.Add("| No confirmed-new failures, or explicit fixes outnumber them | $(if ($failureBalanceAccepted) { 'PASS' } else { 'FAIL' }) |")
+    $lines.Add("| Incomplete shards do not increase | $(if ($incompleteNotIncreased) { 'PASS' } else { 'FAIL' }) |")
+    $lines.Add("| Previously-green shards stay green | $(if ($greenToRed.Count -eq 0) { 'PASS' } else { 'FAIL' }) |")
+    $lines.Add("| No new failure on a touched type/test | $(if ($touchedNew.Count -eq 0) { 'PASS' } else { 'FAIL' }) |")
+    $lines.Add('')
+    $lines.Add("Persistent: **$($persistent.Count)**; fixed and explicitly passing: **$($fixed.Count)**; new: **$($newFailures.Count)**; baseline failures not observed because their result/shard is missing: **$($notObserved.Count)**.")
+    $lines.Add("Of the new failures, **$($confirmedNew.Count)** reproduced and **$($rerunPassedNew.Count)** explicitly passed the targeted retry.")
+    $lines.Add('')
+
+    $lines.Add('## Current failure categories')
+    $lines.Add('')
+    $lines.Add('| Count | First error line |')
+    $lines.Add('|---:|---|')
+    foreach ($category in @($currentCategories | Select-Object -First 30)) {
+        $lines.Add("| $($category.count) | $(ConvertTo-MarkdownCell $category.message) |")
+    }
+    if ($currentCategories.Count -eq 0) { $lines.Add('| 0 | _None_ |') }
+    $lines.Add('')
+
+    Add-MarkdownList $lines 'Previously-green shards that regressed' @($greenToRedArray | ForEach-Object { "$($_.name) -> $($_.currentStatus)" })
+    Add-MarkdownList $lines 'New failures on the touched surface' @($touchedNew | ForEach-Object { "$($_.identity) [$($_.shard)]" })
+    Add-MarkdownList $lines 'Confirmed new failures' @($confirmedNew | ForEach-Object { "$($_.identity) [$($_.shard)]" })
+    Add-MarkdownList $lines 'One-run new failures that passed targeted retry' @($rerunPassedNew | ForEach-Object { "$($_.identity) [$($_.shard)]" })
+    Add-MarkdownList $lines 'Fixed failures (explicit pass required)' @($fixed | ForEach-Object { "$($_.identity) [$($_.shard)]" })
+    Add-MarkdownList $lines 'Incomplete or missing current shards' @($effectiveCurrentIncomplete | ForEach-Object { "$($_.name): executed $($_.executed)/$($_.total), status $($_.testStepOutcome)" })
+}
+
+$lines | Set-Content -LiteralPath $summaryPath -Encoding utf8
+Get-Content -LiteralPath $summaryPath | Write-Host
+if ($env:GITHUB_STEP_SUMMARY) {
+    try { Get-Content -LiteralPath $summaryPath | Add-Content -LiteralPath $env:GITHUB_STEP_SUMMARY }
+    catch { Write-Warning "Could not write GitHub step summary: $($_.Exception.Message)" }
+}
+
+if ($FailOnPolicy -and $baseline) {
+    $result = Get-Content -LiteralPath $comparisonPath -Raw | ConvertFrom-Json
+    if (-not $result.policyPassed) { exit 1 }
+}
diff --git a/.github/scripts/test-regression-analysis.tests.ps1 b/.github/scripts/test-regression-analysis.tests.ps1
new file mode 100644
index 0000000000..0cc0f8c60a
--- /dev/null
+++ b/.github/scripts/test-regression-analysis.tests.ps1
@@ -0,0 +1,178 @@
+$ErrorActionPreference = 'Stop'
+
+$analyzer = Join-Path $PSScriptRoot 'test-regression-analysis.ps1'
+$retrySelector = Join-Path $PSScriptRoot 'find-pr-new-failures.ps1'
+$testRoot = Join-Path ([IO.Path]::GetTempPath()) ("aidotnet-trx-analysis-" + [Guid]::NewGuid().ToString('N'))
+
+function Assert-Equal {
+    param($Expected, $Actual, [string] $Because)
+    if ($Expected -ne $Actual) {
+        throw "Expected '$Expected', got '$Actual': $Because"
+    }
+}
+
+function Write-SyntheticShard {
+    param(
+        [string] $Root,
+        [string] $Sha,
+        [string] $Name,
+        [string] $TestName,
+        [ValidateSet('Passed', 'Failed')] [string] $Outcome,
+        [int] $Total = 1,
+        [int] $Executed = 1,
+        [int] $NotExecuted = 0,
+        [string] $FileName = 'test-results.trx',
+        [ValidateSet('coverage', 'test-outcome')] [string] $ArtifactPrefix = 'coverage'
+    )
+
+    $slug = ($Name -replace '[\\/:*?"<>|\s-]+', '_').Trim('_')
+    $directory = Join-Path $Root "$ArtifactPrefix-$Sha-$slug/TestResults/$slug"
+    New-Item -Path $directory -ItemType Directory -Force | Out-Null
+    [PSCustomObject]@{
+        shard = $Name
+        slug = $slug
+        testStepOutcome = if ($Outcome -eq 'Failed') { 'failure' } else { 'success' }
+    } | ConvertTo-Json | Set-Content -LiteralPath (Join-Path (Split-Path $directory -Parent) 'shard-metadata.json') -Encoding utf8
+
+    $failed = if ($Outcome -eq 'Failed') { 1 } else { 0 }
+    $error = if ($Outcome -eq 'Failed') {
+        '<Output><ErrorInfo><Message>synthetic assertion</Message></ErrorInfo></Output>'
+    } else { '' }
+    $trx = @"
+<?xml version="1.0" encoding="utf-8"?>
+<TestRun xmlns="http://microsoft.com/schemas/VisualStudio/TeamTest/2010">
+  <TestDefinitions>
+    <UnitTest name="$TestName" id="test-id">
+      <TestMethod className="Synthetic.Fixture" name="$TestName" />
+    </UnitTest>
+  </TestDefinitions>
+  <Results>
+    <UnitTestResult executionId="execution-id" testId="test-id" testName="$TestName" outcome="$Outcome">$error</UnitTestResult>
+  </Results>
+  <ResultSummary outcome="$Outcome">
+    <Counters total="$Total" executed="$Executed" passed="$($Executed - $failed)" failed="$failed" notExecuted="$NotExecuted" />
+  </ResultSummary>
+</TestRun>
+"@
+    $trx | Set-Content -LiteralPath (Join-Path $directory $FileName) -Encoding utf8
+}
+
+try {
+    $baselineRoot = Join-Path $testRoot 'baseline'
+    $currentRoot = Join-Path $testRoot 'current'
+    $baselineOutput = Join-Path $testRoot 'baseline-output'
+    $comparisonOutput = Join-Path $testRoot 'comparison-output'
+    $roundTripOutput = Join-Path $testRoot 'roundtrip-output'
+
+    Write-SyntheticShard $baselineRoot 'aaaa' 'Shard Green' 'GreenTest' 'Passed' -Total 2 -Executed 1 -NotExecuted 1
+    Write-SyntheticShard $baselineRoot 'aaaa' 'Shard Existing Red' 'ExistingFailure' 'Failed'
+    Write-SyntheticShard $currentRoot 'bbbb' 'Shard Green' 'NewFailure' 'Failed'
+    Write-SyntheticShard $currentRoot 'bbbb' 'Shard Existing Red' 'ExistingFailure' 'Passed' -Total 2 -Executed 1
+
+    & $analyzer -CurrentResultsPath $baselineRoot -OutputDirectory $baselineOutput -CurrentSha 'aaaa'
+    & $analyzer -CurrentResultsPath $currentRoot -BaselineResultsPath $baselineRoot `
+        -OutputDirectory $comparisonOutput -CurrentSha 'bbbb'
+
+    $comparison = Get-Content -LiteralPath (Join-Path $comparisonOutput 'comparison.json') -Raw | ConvertFrom-Json
+    Assert-Equal 1 $comparison.counts.baselineDistinctFailures 'baseline failure count comes from TRX'
+    Assert-Equal 1 $comparison.counts.currentDistinctFailures 'current failure count comes from TRX'
+    Assert-Equal 1 $comparison.counts.baselinePassedShards 'baseline passed-shard count comes from TRX'
+    Assert-Equal 0 $comparison.counts.currentPassedShards 'an incomplete or failed shard is not counted as passed'
+    Assert-Equal 1 $comparison.counts.currentReportedFailureResults 'reported failing results remain visible separately from distinct tests'
+    Assert-Equal 1 $comparison.counts.newFailures 'a failure absent from the baseline is classified as new'
+    Assert-Equal 1 $comparison.counts.fixedFailures 'an explicit current pass classifies the old failure as fixed'
+    Assert-Equal 1 $comparison.counts.greenToRedShards 'a previously-green shard becoming red is a hard regression'
+    Assert-Equal 1 $comparison.counts.currentIncompleteShards 'executed < total is never treated as a complete shard'
+    Assert-Equal $false $comparison.criteria.noConfirmedNewFailures 'the strict verdict exposes any confirmed-new failure'
+    Assert-Equal $false $comparison.policyPassed 'the hybrid policy blocks the synthetic regression'
+    Assert-Equal 1 $comparison.currentFailureCategories[0].count 'failures are grouped into error categories'
+    Assert-Equal 'synthetic assertion' $comparison.currentFailureCategories[0].message 'the first error line names the category'
+    Assert-Equal $true (Test-Path -LiteralPath (Join-Path $comparisonOutput 'failures.csv')) 'a spreadsheet-ready failure inventory is emitted'
+    Assert-Equal $true (Test-Path -LiteralPath (Join-Path $comparisonOutput 'shards.csv')) 'a spreadsheet-ready shard inventory is emitted'
+
+    $retryOutput = Join-Path $testRoot 'retry-candidates.json'
+    $actionOutput = Join-Path $testRoot 'github-output.txt'
+    $previousActionOutput = $env:GITHUB_OUTPUT
+    try {
+        $env:GITHUB_OUTPUT = $actionOutput
+        & $retrySelector -CurrentResultsPath $currentRoot -BaselineResultsPath $baselineRoot `
+            -OutputFile $retryOutput
+    }
+    finally {
+        $env:GITHUB_OUTPUT = $previousActionOutput
+    }
+    $retry = Get-Content -LiteralPath $retryOutput -Raw | ConvertFrom-Json
+    Assert-Equal 1 $retry.candidateCount 'only the PR-new failure is selected for retry'
+    Assert-Equal 'Synthetic.Fixture.NewFailure' $retry.candidates[0].fullyQualifiedName 'retry uses the TRX definition FQN'
+    Assert-Equal $true ((Get-Content -LiteralPath $actionOutput -Raw) -match 'rerun_count=1') 'retry count is published to Actions'
+
+    & $analyzer -CurrentResultsPath $currentRoot `
+        -BaselineLedgerPath (Join-Path $baselineOutput 'ledger.json') `
+        -OutputDirectory $roundTripOutput -CurrentSha 'bbbb'
+    $roundTrip = Get-Content -LiteralPath (Join-Path $roundTripOutput 'comparison.json') -Raw | ConvertFrom-Json
+    Assert-Equal $comparison.counts.newFailures $roundTrip.counts.newFailures 'serialized ledger comparison matches direct TRX comparison'
+    Assert-Equal $comparison.counts.greenToRedShards $roundTrip.counts.greenToRedShards 'shard transitions survive ledger round-trip'
+
+    $workflowPath = Join-Path $testRoot 'synthetic-workflow.yml'
+    $inventoryOutput = Join-Path $testRoot 'inventory-output'
+    $inventoryRoot = Join-Path $testRoot 'inventory-current'
+    Write-SyntheticShard $inventoryRoot 'cccc' 'Shard Green' 'GreenTest' 'Passed' `
+        -ArtifactPrefix 'test-outcome'
+    @'
+jobs:
+  test-net10-sharded:
+    strategy:
+      matrix:
+        shard:
+          - name: Shard Green
+            project: tests.csproj
+          - name: Shard Never Uploaded
+            project: tests.csproj
+    steps:
+      - name: This workflow step is not a shard
+        run: echo test
+  next-job:
+    runs-on: ubuntu-latest
+'@ | Set-Content -LiteralPath $workflowPath -Encoding utf8
+    & $analyzer -CurrentResultsPath $inventoryRoot -OutputDirectory $inventoryOutput `
+        -CurrentSha 'cccc' -CurrentWorkflowPath $workflowPath
+    $inventoryLedger = Get-Content -LiteralPath (Join-Path $inventoryOutput 'ledger.json') -Raw | ConvertFrom-Json
+    Assert-Equal 2 @($inventoryLedger.shards).Count 'the ledger contains every expected matrix shard'
+    Assert-Equal 1 @($inventoryLedger.shards | Where-Object status -eq 'Incomplete').Count 'an expected shard with no artifact is synthesized as incomplete'
+    Assert-Equal 'missing-artifact' @($inventoryLedger.shards | Where-Object name -eq 'Shard Never Uploaded')[0].testStepOutcome 'the missing shard is identifiable in the proof'
+
+    $missingOutput = Join-Path $testRoot 'missing-output'
+    $missingRoot = Join-Path $testRoot 'missing-current'
+    Write-SyntheticShard $missingRoot 'cccc' 'Shard Green' 'GreenTest' 'Passed'
+    & $analyzer -CurrentResultsPath $missingRoot -BaselineResultsPath $baselineRoot `
+        -OutputDirectory $missingOutput -CurrentSha 'cccc'
+    $missing = Get-Content -LiteralPath (Join-Path $missingOutput 'comparison.json') -Raw | ConvertFrom-Json
+    Assert-Equal 1 $missing.counts.missingCurrentShardArtifacts 'an absent red shard artifact is explicitly counted'
+    Assert-Equal 1 $missing.counts.currentIncompleteShards 'a missing artifact cannot hide a baseline failure'
+    Assert-Equal $false $missing.criteria.verifiedFailureBalanceShrank 'a missing failure result does not earn fix credit'
+
+    $flakeBaselineRoot = Join-Path $testRoot 'flake-baseline'
+    $flakeCurrentRoot = Join-Path $testRoot 'flake-current'
+    $flakeOutput = Join-Path $testRoot 'flake-output'
+    Write-SyntheticShard $flakeBaselineRoot 'dddd' 'Shard Retry' 'RetryTest' 'Passed'
+    Write-SyntheticShard $flakeCurrentRoot 'eeee' 'Shard Retry' 'RetryTest' 'Failed'
+    Write-SyntheticShard $flakeCurrentRoot 'eeee' 'Shard Retry' 'RetryTest' 'Passed' -FileName 'rerun.trx'
+    & $analyzer -CurrentResultsPath $flakeCurrentRoot -BaselineResultsPath $flakeBaselineRoot `
+        -OutputDirectory $flakeOutput -CurrentSha 'eeee'
+    $flake = Get-Content -LiteralPath (Join-Path $flakeOutput 'comparison.json') -Raw | ConvertFrom-Json
+    Assert-Equal 1 $flake.counts.newFailures 'the original failure remains visible in the report'
+    Assert-Equal 0 $flake.counts.confirmedNewFailures 'an identical explicit retry pass clears reproducibility'
+    Assert-Equal 1 $flake.counts.rerunPassedNewFailures 'the retry pass is classified as a one-run failure'
+    Assert-Equal 0 $flake.counts.greenToRedShards 'a successful targeted retry keeps a green shard green for policy'
+    Assert-Equal $true $flake.criteria.noConfirmedNewFailures 'an identical retry pass clears the strict confirmed-new verdict'
+
+    Write-Host 'test-regression-analysis.tests.ps1: all assertions passed.'
+}
+finally {
+    $resolvedTemp = [IO.Path]::GetFullPath([IO.Path]::GetTempPath())
+    $resolvedTestRoot = [IO.Path]::GetFullPath($testRoot)
+    if ($resolvedTestRoot.StartsWith($resolvedTemp, [StringComparison]::OrdinalIgnoreCase) -and
+        (Test-Path -LiteralPath $resolvedTestRoot)) {
+        Remove-Item -LiteralPath $resolvedTestRoot -Recurse -Force
+    }
+}
diff --git a/.github/workflows/release-please.yml b/.github/workflows/release-please.yml
index f08af77444..82ee8240c6 100644
--- a/.github/workflows/release-please.yml
+++ b/.github/workflows/release-please.yml
@@ -151,8 +151,15 @@ jobs:
               echo "$files" | grep -qE "^lib/${tfm}/.+\.dll$" || { echo "Error: Missing ${tfm} lib in $pkg"; exit 1; }
               echo "Found ${tfm} in $(basename "$pkg")"
             done
+            echo "$files" | grep -q '^analyzers/dotnet/cs/AiDotNet.Generators.dll$' || {
+              echo "Error: Missing packaged source generator in $pkg"; exit 1;
+            }
           done
 
+      - name: Verify PackageReference consumer gets generated factories automatically
+        shell: pwsh
+        run: ./scripts/Verify-NuGetGenerator.ps1 -PackagePath "out/AiDotNet.${{ needs.release-please.outputs.version }}.nupkg"
+
       - name: Push to NuGet
         run: |
           shopt -s nullglob
diff --git a/coverlet.runsettings b/coverlet.runsettings
index 9e5d529c9b..9af42919e5 100644
--- a/coverlet.runsettings
+++ b/coverlet.runsettings
@@ -11,7 +11,15 @@
             the size of the instrumented surface and was adding ~14 minutes to every shard.
           -->
           <Exclude>[*Tests*]*,[*Benchmark*]*,[xunit.*]*,[AiDotNet.Generators]*,[AiDotNet.ProgramSynthesis.Tooling]*,[AiDotNet.Playground*]*,[AiDotNet.Dashboard]*</Exclude>
-          <ExcludeByAttribute>Obsolete,GeneratedCodeAttribute,CompilerGeneratedAttribute</ExcludeByAttribute>
+          <!--
+            Roslyn output is excluded by its generated-document path below instead of by
+            GeneratedCodeAttribute. Coverlet performs state-machine/lambda analysis for every
+            method-level attribute exclusion; with thousands of generated parameter/state methods
+            that path becomes quadratic enough to consume an entire shard budget before tests start.
+            File exclusion is checked before method-body/branch instrumentation and preserves
+            coverage for the hand-written members of the same partial model or layer type.
+          -->
+          <ExcludeByAttribute>Obsolete,CompilerGeneratedAttribute</ExcludeByAttribute>
           <!--
             File exclusions mirror sonar.coverage.exclusions in sonarcloud.yml — Sonar discards
             these anyway, so there is no point instrumenting or serializing them.
@@ -26,7 +34,7 @@
             (per master's narrower-than-the-folder convention) to catch I-prefixed
             interface files anywhere under that project tree.
           -->
-          <ExcludeByFile>**/ProgramSynthesis/Models/**/*.cs,**/ProgramSynthesis/Execution/**/*.cs,**/ProgramSynthesis/Requests/**/*.cs,**/ProgramSynthesis/Results/**/*.cs,**/ProgramSynthesis/Interfaces/**/*.cs,**/ProgramSynthesis/Enums/**/*.cs,**/AiDotNet.Serving/Configuration/**/*.cs,**/AiDotNet.Serving/Models/**/*.cs,**/AiDotNet.Serving/Persistence/Entities/**/*.cs,**/AiDotNet.Serving/Persistence/Migrations/**/*.cs,**/AiDotNet.Serving/**/I*.cs</ExcludeByFile>
+          <ExcludeByFile>**/*.g.cs,**/Onnx/Protobuf/Generated/**/*.cs,**/ProgramSynthesis/Models/**/*.cs,**/ProgramSynthesis/Execution/**/*.cs,**/ProgramSynthesis/Requests/**/*.cs,**/ProgramSynthesis/Results/**/*.cs,**/ProgramSynthesis/Interfaces/**/*.cs,**/ProgramSynthesis/Enums/**/*.cs,**/AiDotNet.Serving/Configuration/**/*.cs,**/AiDotNet.Serving/Models/**/*.cs,**/AiDotNet.Serving/Persistence/Entities/**/*.cs,**/AiDotNet.Serving/Persistence/Migrations/**/*.cs,**/AiDotNet.Serving/**/I*.cs</ExcludeByFile>
           <!-- SingleHit: record only whether each line was hit, not the hit count. Smaller XML, faster write. -->
           <SingleHit>true</SingleHit>
           <!-- SkipAutoProps: don't instrument trivial compiler-generated property accessors. -->
diff --git a/scripts/Verify-NuGetGenerator.ps1 b/scripts/Verify-NuGetGenerator.ps1
new file mode 100644
index 0000000000..269113a6c8
--- /dev/null
+++ b/scripts/Verify-NuGetGenerator.ps1
@@ -0,0 +1,146 @@
+param(
+    [Parameter(Mandatory = $true)]
+    [string] $PackagePath
+)
+
+$ErrorActionPreference = 'Stop'
+$resolvedPackage = (Resolve-Path -LiteralPath $PackagePath).Path
+$packageDirectory = Split-Path -Parent $resolvedPackage
+$nugetOrgSource = 'https://api.nuget.org/v3/index.json'
+$probeRoot = Join-Path ([System.IO.Path]::GetTempPath()) ("aidotnet-generator-probe-" + [guid]::NewGuid().ToString('N'))
+$probePackages = Join-Path $probeRoot '.packages'
+$nugetConfig = Join-Path $probeRoot 'NuGet.Config'
+
+try {
+    Add-Type -AssemblyName System.IO.Compression.FileSystem
+    $archive = [System.IO.Compression.ZipFile]::OpenRead($resolvedPackage)
+    try {
+        $generatorEntry = $archive.Entries | Where-Object {
+            $_.FullName -eq 'analyzers/dotnet/cs/AiDotNet.Generators.dll'
+        }
+        if ($null -eq $generatorEntry) {
+            throw "Package does not contain analyzers/dotnet/cs/AiDotNet.Generators.dll."
+        }
+
+        $generatorStream = $generatorEntry.Open()
+        $sha256 = [System.Security.Cryptography.SHA256]::Create()
+        try {
+            $packagedGeneratorHash = [System.BitConverter]::ToString(
+                $sha256.ComputeHash($generatorStream)).Replace('-', '')
+        }
+        finally {
+            $sha256.Dispose()
+            $generatorStream.Dispose()
+        }
+
+        $nuspecEntry = $archive.Entries | Where-Object { $_.FullName -like '*.nuspec' } |
+            Select-Object -First 1
+        if ($null -eq $nuspecEntry) {
+            throw 'Package does not contain a NuGet manifest.'
+        }
+
+        $reader = [System.IO.StreamReader]::new($nuspecEntry.Open())
+        try {
+            [xml] $nuspec = $reader.ReadToEnd()
+        }
+        finally {
+            $reader.Dispose()
+        }
+
+        $packageId = $nuspec.SelectSingleNode(
+            "/*[local-name()='package']/*[local-name()='metadata']/*[local-name()='id']").InnerText
+        $packageVersion = $nuspec.SelectSingleNode(
+            "/*[local-name()='package']/*[local-name()='metadata']/*[local-name()='version']").InnerText
+        if ([string]::IsNullOrWhiteSpace($packageId) -or [string]::IsNullOrWhiteSpace($packageVersion)) {
+            throw 'Package manifest does not contain an id and version.'
+        }
+    }
+    finally {
+        $archive.Dispose()
+    }
+
+    New-Item -ItemType Directory -Path $probeRoot | Out-Null
+    $escapedPackageDirectory = [System.Security.SecurityElement]::Escape($packageDirectory)
+    $configText = @"
+<?xml version="1.0" encoding="utf-8"?>
+<configuration>
+  <packageSources>
+    <clear />
+    <add key="package-under-test" value="$escapedPackageDirectory" />
+    <add key="nuget.org" value="$nugetOrgSource" protocolVersion="3" />
+  </packageSources>
+</configuration>
+"@
+    Set-Content -LiteralPath $nugetConfig -Value $configText -Encoding utf8
+
+    & dotnet new classlib --framework net8.0 --output $probeRoot --no-restore
+    if ($LASTEXITCODE -ne 0) { throw 'dotnet new failed.' }
+
+    # Pin the exact archive under test. Without --version, a configured remote feed could
+    # satisfy the request with a different package and turn this probe into a false positive.
+    & dotnet add $probeRoot package $packageId --version $packageVersion --no-restore
+    if ($LASTEXITCODE -ne 0) { throw 'Adding the packed AiDotNet package failed.' }
+
+    & dotnet restore $probeRoot --configfile $nugetConfig --packages $probePackages `
+        --force --no-http-cache --verbosity minimal
+    if ($LASTEXITCODE -ne 0) { throw 'Restoring the packed AiDotNet package failed.' }
+
+    $restoredGenerator = Join-Path $probePackages $packageId.ToLowerInvariant()
+    $restoredGenerator = Join-Path $restoredGenerator $packageVersion.ToLowerInvariant()
+    $restoredGenerator = Join-Path $restoredGenerator 'analyzers'
+    $restoredGenerator = Join-Path $restoredGenerator 'dotnet'
+    $restoredGenerator = Join-Path $restoredGenerator 'cs'
+    $restoredGenerator = Join-Path $restoredGenerator 'AiDotNet.Generators.dll'
+    if (!(Test-Path -LiteralPath $restoredGenerator)) {
+        throw 'The restored package does not expose AiDotNet.Generators.dll as a C# analyzer.'
+    }
+    if ((Get-FileHash -LiteralPath $restoredGenerator -Algorithm SHA256).Hash -ne $packagedGeneratorHash) {
+        throw 'Restore selected a different generator binary than the package under test.'
+    }
+
+    $probeSource = @'
+using AiDotNet.NeuralNetworks.Layers;
+
+namespace PackedConsumer;
+
+[AiDotNet.Attributes.ElementWiseShape]
+public sealed partial class PackedLayer<T> : LayerBase<T>
+{
+    private readonly int _units;
+    private readonly bool _useBias;
+
+    public PackedLayer(int units, bool useBias = true) : base([units], [units])
+    {
+        _units = units;
+        _useBias = useBias;
+    }
+
+    public override bool SupportsTraining => false;
+    public override void ResetState() { }
+}
+
+public static class GeneratorProof
+{
+    // This type is emitted into THIS assembly by LayerStateGenerator. The package's runtime
+    // reflection fallback cannot make this compile, so a successful build proves the analyzer
+    // asset flowed automatically through PackageReference.
+    public static int FactoryCount => AiDotNet.Serialization.GeneratedLayerFactories<double>.Count;
+}
+'@
+    Set-Content -LiteralPath (Join-Path $probeRoot 'Class1.cs') -Value $probeSource -Encoding utf8
+
+    & dotnet build $probeRoot --no-restore --configuration Release --verbosity minimal -nologo -clp:ErrorsOnly
+    if ($LASTEXITCODE -ne 0) {
+        throw 'The PackageReference consumer did not compile with generated layer factories.'
+    }
+}
+finally {
+    if (Test-Path -LiteralPath $probeRoot) {
+        $resolvedProbe = [System.IO.Path]::GetFullPath($probeRoot)
+        $resolvedTemp = [System.IO.Path]::GetFullPath([System.IO.Path]::GetTempPath())
+        if (!$resolvedProbe.StartsWith($resolvedTemp, [System.StringComparison]::OrdinalIgnoreCase)) {
+            throw "Refusing to remove probe outside the system temp directory: $resolvedProbe"
+        }
+        Remove-Item -LiteralPath $resolvedProbe -Recurse -Force
+    }
+}
diff --git a/src/ActiveLearning/Batch/GradientBatchStrategy.cs b/src/ActiveLearning/Batch/GradientBatchStrategy.cs
index bb613f10e1..79dbab74b1 100644
--- a/src/ActiveLearning/Batch/GradientBatchStrategy.cs
+++ b/src/ActiveLearning/Batch/GradientBatchStrategy.cs
@@ -49,6 +49,7 @@ public class GradientBatchStrategy<T, TInput, TOutput> : IGradientBatchStrategy<
 
     private readonly bool _useHypotheticalGradients;
     private T _diversityTradeoff;
+    [Scratch]
     private Matrix<T>? _cachedEmbeddings;
 
     /// <inheritdoc/>
diff --git a/src/ActiveLearning/Batch/SubmodularBatchStrategy.cs b/src/ActiveLearning/Batch/SubmodularBatchStrategy.cs
index ac5471987b..c3f218a5c3 100644
--- a/src/ActiveLearning/Batch/SubmodularBatchStrategy.cs
+++ b/src/ActiveLearning/Batch/SubmodularBatchStrategy.cs
@@ -58,6 +58,7 @@ public class SubmodularBatchStrategy<T, TInput, TOutput> : ISubmodularBatchStrat
     private readonly SubmodularObjective _objective;
     private readonly T _lambda; // Informativeness weight
     private T _diversityTradeoff;
+    [Scratch]
     private List<Vector<T>>? _cachedFeatures;
 
     /// <inheritdoc/>
diff --git a/src/AdversarialRobustness/Attacks/AdversarialAttackBase.cs b/src/AdversarialRobustness/Attacks/AdversarialAttackBase.cs
index 72731da3c3..a7da215f33 100644
--- a/src/AdversarialRobustness/Attacks/AdversarialAttackBase.cs
+++ b/src/AdversarialRobustness/Attacks/AdversarialAttackBase.cs
@@ -18,8 +18,51 @@ namespace AiDotNet.AdversarialRobustness.Attacks;
 /// <remarks>
 /// <para><b>For Beginners:</b> This provides AI safety functionality. Default values follow the original paper settings.</para>
 /// </remarks>
-public abstract class AdversarialAttackBase<T, TInput, TOutput> : IAdversarialAttack<T, TInput, TOutput>, IModelShape
+public abstract partial class AdversarialAttackBase<T, TInput, TOutput> : IAdversarialAttack<T, TInput, TOutput>, IModelShape
 {
+    // --- declared state (ModelStateRegistry) ---
+    // Identical in every model base because these bases are siblings over the same interfaces rather
+    // than one hierarchy; the logic itself lives once in ModelStateRegistry/ModelStateEnvelope.
+
+    /// <summary>State that is not a parameter vector, declared once and persisted by this base.</summary>
+    private readonly AiDotNet.Models.ModelStateRegistry<T> _declaredState = new();
+    private bool _declaredStateRegistered;
+
+    /// <summary>
+    /// Declare state here that the parameter vector does not carry -- a retained training set,
+    /// fitted knots, kernel centres, an ensemble's children. Both halves of the payload are driven
+    /// by the declaration, so they cannot drift.
+    /// </summary>
+    /// <param name="state">The registry to declare into.</param>
+    protected virtual void RegisterState(AiDotNet.Models.ModelStateRegistry<T> state)
+    {
+    }
+    /// <summary>Generated state declarations for fields declared across this model's hierarchy.</summary>
+    /// <param name="state">The registry to declare into.</param>
+    /// <remarks>
+    /// Emitted by ModelStateGenerator into the partial model, so a model author declares nothing. The
+    /// hand-written <c>RegisterState</c> beside it exists only for state the classifier genuinely
+    /// cannot place; anything it CAN place belongs here, where it cannot be forgotten.
+    /// </remarks>
+    protected virtual void RegisterGeneratedState(AiDotNet.Models.ModelStateRegistry<T> state)
+    {
+        RegisterGeneratedStateCore(state);
+    }
+
+    /// <summary>The declared state, registered once and lazily so it runs after the constructor.</summary>
+    protected AiDotNet.Models.ModelStateRegistry<T> DeclaredState
+    {
+        get
+        {
+            if (!_declaredStateRegistered)
+            {
+                _declaredStateRegistered = true;
+                RegisterGeneratedState(_declaredState);
+                RegisterState(_declaredState);
+            }
+            return _declaredState;
+        }
+    }
     /// <summary>
     /// Gets the global execution engine for vectorized operations.
     /// </summary>
@@ -101,12 +144,15 @@ public virtual byte[] Serialize()
     {
         ModelPersistenceGuard.EnforceBeforeSerialize();
         var json = JsonConvert.SerializeObject(Options, Formatting.None);
-        return Encoding.UTF8.GetBytes(json);
+        return AiDotNet.Models.ModelStateEnvelope.Append(DeclaredState, Encoding.UTF8.GetBytes(json));
     }
 
     /// <inheritdoc/>
     public virtual void Deserialize(byte[] data)
     {
+        // Strips and applies any declared-state trailer, so the body below reads the payload
+        // exactly as it did before this existed.
+        data = AiDotNet.Models.ModelStateEnvelope.Extract(DeclaredState, data);
         ModelPersistenceGuard.EnforceBeforeDeserialize();
         if (data == null)
         {
diff --git a/src/AdversarialRobustness/Attacks/AutoAttack.cs b/src/AdversarialRobustness/Attacks/AutoAttack.cs
index 0606b1a1d1..44870b306c 100644
--- a/src/AdversarialRobustness/Attacks/AutoAttack.cs
+++ b/src/AdversarialRobustness/Attacks/AutoAttack.cs
@@ -41,7 +41,7 @@ namespace AiDotNet.AdversarialRobustness.Attacks;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Reliable Evaluation of Adversarial Robustness with an Ensemble of Diverse Parameter-Free Attacks", "https://arxiv.org/abs/2003.01690", Year = 2020, Authors = "Francesco Croce, Matthias Hein")]
-public class AutoAttack<T, TInput, TOutput> : AdversarialAttackBase<T, TInput, TOutput>
+public partial class AutoAttack<T, TInput, TOutput> : AdversarialAttackBase<T, TInput, TOutput>
 {
     private readonly PGDAttack<T, TInput, TOutput> pgdAttack;
     private readonly CWAttack<T, TInput, TOutput> cwAttack;
diff --git a/src/AdversarialRobustness/Defenses/AdversarialPromptDefense.cs b/src/AdversarialRobustness/Defenses/AdversarialPromptDefense.cs
index 90e7b02d61..fa88b6d06a 100644
--- a/src/AdversarialRobustness/Defenses/AdversarialPromptDefense.cs
+++ b/src/AdversarialRobustness/Defenses/AdversarialPromptDefense.cs
@@ -57,6 +57,7 @@ public class AdversarialPromptDefense<T, TInput, TOutput> : IAdversarialDefense<
     private static readonly INumericOperations<T> NumOps = MathHelper.GetNumericOperations<T>();
 
     private AdversarialDefenseOptions<T> _options;
+    [AiDotNet.Attributes.Scratch]
     private Vector<T>? _defensePrompt;
     private readonly int _promptLength;
     private readonly double _promptLearningRate;
diff --git a/src/AdversarialRobustness/Safety/ContentClassifierBase.cs b/src/AdversarialRobustness/Safety/ContentClassifierBase.cs
index 85014ef6d6..c074a9a9cd 100644
--- a/src/AdversarialRobustness/Safety/ContentClassifierBase.cs
+++ b/src/AdversarialRobustness/Safety/ContentClassifierBase.cs
@@ -20,8 +20,51 @@ namespace AiDotNet.AdversarialRobustness.Safety;
 /// on the actual classification logic in your subclass.</para>
 /// </remarks>
 /// <typeparam name="T">The numeric data type used for calculations.</typeparam>
-public abstract class ContentClassifierBase<T> : IContentClassifier<T>, IModelSerializer, IModelShape
+public abstract partial class ContentClassifierBase<T> : IContentClassifier<T>, IModelSerializer, IModelShape
 {
+    // --- declared state (ModelStateRegistry) ---
+    // Identical in every model base because these bases are siblings over the same interfaces rather
+    // than one hierarchy; the logic itself lives once in ModelStateRegistry/ModelStateEnvelope.
+
+    /// <summary>State that is not a parameter vector, declared once and persisted by this base.</summary>
+    private readonly AiDotNet.Models.ModelStateRegistry<T> _declaredState = new();
+    private bool _declaredStateRegistered;
+
+    /// <summary>
+    /// Declare state here that the parameter vector does not carry -- a retained training set,
+    /// fitted knots, kernel centres, an ensemble's children. Both halves of the payload are driven
+    /// by the declaration, so they cannot drift.
+    /// </summary>
+    /// <param name="state">The registry to declare into.</param>
+    protected virtual void RegisterState(AiDotNet.Models.ModelStateRegistry<T> state)
+    {
+    }
+    /// <summary>Generated state declarations for fields declared across this model's hierarchy.</summary>
+    /// <param name="state">The registry to declare into.</param>
+    /// <remarks>
+    /// Emitted by ModelStateGenerator into the partial model, so a model author declares nothing. The
+    /// hand-written <c>RegisterState</c> beside it exists only for state the classifier genuinely
+    /// cannot place; anything it CAN place belongs here, where it cannot be forgotten.
+    /// </remarks>
+    protected virtual void RegisterGeneratedState(AiDotNet.Models.ModelStateRegistry<T> state)
+    {
+        RegisterGeneratedStateCore(state);
+    }
+
+    /// <summary>The declared state, registered once and lazily so it runs after the constructor.</summary>
+    protected AiDotNet.Models.ModelStateRegistry<T> DeclaredState
+    {
+        get
+        {
+            if (!_declaredStateRegistered)
+            {
+                _declaredStateRegistered = true;
+                RegisterGeneratedState(_declaredState);
+                RegisterState(_declaredState);
+            }
+            return _declaredState;
+        }
+    }
     /// <summary>
     /// Gets the hardware-accelerated computation engine for vectorized operations.
     /// </summary>
@@ -97,6 +140,22 @@ public virtual ContentClassificationResult<T>[] ClassifyBatch(Matrix<T> contents
     /// <inheritdoc/>
     public abstract bool IsReady();
 
+    /// <summary>
+    /// Serializes a concrete classifier entirely from its generated state declarations.
+    /// Concrete classifiers receive their public override from <c>ModelStateGenerator</c>.
+    /// </summary>
+    protected byte[] SerializeGeneratedModelState()
+        => AiDotNet.Models.ModelStateEnvelope.Append(DeclaredState, Array.Empty<byte>());
+
+    /// <summary>
+    /// Restores a concrete classifier entirely from its generated state declarations.
+    /// </summary>
+    protected void DeserializeGeneratedModelState(byte[] data)
+    {
+        if (data is null) throw new ArgumentNullException(nameof(data));
+        _ = AiDotNet.Models.ModelStateEnvelope.Extract(DeclaredState, data);
+    }
+
     /// <inheritdoc/>
     public abstract byte[] Serialize();
 
diff --git a/src/AdversarialRobustness/Safety/RuleBasedContentClassifier.cs b/src/AdversarialRobustness/Safety/RuleBasedContentClassifier.cs
index c68f22450a..2c7861c8db 100644
--- a/src/AdversarialRobustness/Safety/RuleBasedContentClassifier.cs
+++ b/src/AdversarialRobustness/Safety/RuleBasedContentClassifier.cs
@@ -1,10 +1,7 @@
-using System.Text;
 using System.Text.RegularExpressions;
 using AiDotNet.Attributes;
 using AiDotNet.Enums;
-using AiDotNet.Serialization;
 using AiDotNet.Tensors.LinearAlgebra;
-using Newtonsoft.Json;
 using AiDotNet.Validation;
 
 namespace AiDotNet.AdversarialRobustness.Safety;
@@ -29,7 +26,7 @@ namespace AiDotNet.AdversarialRobustness.Safety;
 [ModelComplexity(ModelComplexity.Low)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Automated Hate Speech Detection and the Problem of Offensive Language", "https://arxiv.org/abs/1703.04009", Year = 2017, Authors = "Thomas Davidson, Dana Warmsley, Michael Macy, Ingmar Weber")]
-public class RuleBasedContentClassifier<T> : ContentClassifierBase<T>
+public partial class RuleBasedContentClassifier<T> : ContentClassifierBase<T>
 {
     /// <summary>
     /// Timeout for regex operations to prevent ReDoS attacks.
@@ -128,85 +125,6 @@ public override ContentClassificationResult<T> ClassifyText(string text)
     /// <inheritdoc/>
     public override bool IsReady() => _isReady;
 
-    /// <inheritdoc/>
-    public override byte[] Serialize()
-    {
-        var data = new SerializationData
-        {
-            Threshold = NumOps.ToDouble(DetectionThreshold),
-            CategoryPatterns = _categoryPatterns
-        };
-
-        var json = JsonConvert.SerializeObject(data, Formatting.None);
-        return Encoding.UTF8.GetBytes(json);
-    }
-
-    /// <inheritdoc/>
-    public override void Deserialize(byte[] data)
-    {
-        if (data == null)
-        {
-            throw new ArgumentNullException(nameof(data));
-        }
-
-        var json = Encoding.UTF8.GetString(data);
-
-        var settings = new JsonSerializerSettings
-        {
-            TypeNameHandling = TypeNameHandling.Auto,
-            SerializationBinder = new SafeSerializationBinder()
-        };
-
-        var deserialized = JsonConvert.DeserializeObject<SerializationData>(json, settings);
-        if (deserialized != null)
-        {
-            DetectionThreshold = NumOps.FromDouble(deserialized.Threshold);
-            _categoryPatterns = deserialized.CategoryPatterns ?? new Dictionary<string, List<string>>();
-            SupportedCategories = _categoryPatterns.Keys.ToArray();
-        }
-
-        _isReady = true;
-    }
-
-    /// <inheritdoc/>
-    public override void SaveModel(string filePath)
-    {
-        Helpers.ModelPersistenceGuard.EnforceBeforeSave();
-
-        if (string.IsNullOrWhiteSpace(filePath))
-        {
-            throw new ArgumentException("File path cannot be null or empty.", nameof(filePath));
-        }
-
-        var fullPath = Path.GetFullPath(filePath);
-        var directory = Path.GetDirectoryName(fullPath);
-        if (!string.IsNullOrEmpty(directory) && !Directory.Exists(directory))
-        {
-            Directory.CreateDirectory(directory);
-        }
-
-        File.WriteAllBytes(fullPath, Serialize());
-    }
-
-    /// <inheritdoc/>
-    public override void LoadModel(string filePath)
-    {
-        Helpers.ModelPersistenceGuard.EnforceBeforeLoad();
-
-        if (string.IsNullOrWhiteSpace(filePath))
-        {
-            throw new ArgumentException("File path cannot be null or empty.", nameof(filePath));
-        }
-
-        var fullPath = Path.GetFullPath(filePath);
-        if (!File.Exists(fullPath))
-        {
-            throw new FileNotFoundException("Model file not found.", fullPath);
-        }
-
-        Deserialize(File.ReadAllBytes(fullPath));
-    }
-
     /// <summary>
     /// Adds a detection pattern for a category.
     /// </summary>
@@ -335,12 +253,4 @@ private void InitializeDefaultPatterns()
         SupportedCategories = _categoryPatterns.Keys.ToArray();
     }
 
-    /// <summary>
-    /// Serialization data structure.
-    /// </summary>
-    private class SerializationData
-    {
-        public double Threshold { get; set; }
-        public Dictionary<string, List<string>>? CategoryPatterns { get; set; }
-    }
 }
diff --git a/src/AiDotNet.Generators/AnalyzerReleases.Unshipped.md b/src/AiDotNet.Generators/AnalyzerReleases.Unshipped.md
index 3fead6c384..33fa00b12a 100644
--- a/src/AiDotNet.Generators/AnalyzerReleases.Unshipped.md
+++ b/src/AiDotNet.Generators/AnalyzerReleases.Unshipped.md
@@ -32,6 +32,7 @@ ADN0053 | AiDotNet.Serialization | Error | LayerStateGenerator, Required constru
 ADN0054 | AiDotNet.Serialization | Warning | LayerStateGenerator, Hand-written GetMetadata may drift from [LayerState]
 ADN0055 | AiDotNet.Serialization | Warning | LayerStateGenerator, [LayerState] layer cannot be registered in the generated factory
 ADN0056 | AiDotNet.Serialization | Error | LayerStateGenerator, [LayerState] is only supported on a class deriving from LayerBase
+ADN0057 | AiDotNet.Serialization | Info | LayerStateGenerator, Optional constructor parameter is pinned to its default in the generated factory
 ADNTEST001 | AiDotNet.TestScaffold | Warning | TestScaffoldGenerator, Float test scaffold rewrite was a no-op
 ADNTEST002 | AiDotNet.TestScaffold | Disabled | TestScaffoldGenerator, Generated scaffold architecture size disagrees with its InputShape
 ADNTEST003 | AiDotNet.TestScaffold | Error | TestScaffoldGenerator, Two models share a simple name with no registered owner
@@ -55,6 +56,9 @@ ADNPORT007 | AiDotNet.TensorPorts | Error | TensorPortContractGenerator, Generat
 ADNPORT008 | AiDotNet.TensorPorts | Error | TensorPortContractGenerator, Tensor-contract member has an incompatible signature
 ADNPORT009 | AiDotNet.TensorPorts | Error | TensorPortContractGenerator, Generated forward contract is ambiguous or uses unsupported parameters
 ADNPORT010 | AiDotNet.TensorPorts | Error | TensorPortContractGenerator, Stable input port identity collides across inherited/local declarations
+ADN0058 | AiDotNet.Serialization | Error | CloneAutomationAnalyzer, Clone override duplicates what the base class already does
+ADN0059 | AiDotNet.Serialization | Info | CloneAutomationAnalyzer, Model cannot be rebuilt from its own state
+ADN0060 | AiDotNet.Serialization | Error | CloneAutomationAnalyzer, Serialization is hand-written instead of declared
 ADNPORT011 | AiDotNet.TensorPorts | Error | TensorPortContractGenerator, Derived/defaulted port or SameShapeAs relationship cannot be resolved
 ADNPORT012 | AiDotNet.TensorPorts | Error | TensorPortContractGenerator, Input variants have indistinguishable required external signatures
 ADNBUF001 | AiDotNet.ParameterAutomation | Error | TrainableParameterGenerator, Distinct persistent fields declare the same generated buffer identity
@@ -76,3 +80,4 @@ AIDN096 | AiDotNet.FacadeConfiguration | Warning | FacadeConfigurationValidation
 AIDN097 | AiDotNet.FacadeConfiguration | Warning | FacadeConfigurationValidationGenerator, Configured value is only reachable through an accessor nobody calls
 AIDN098 | AiDotNet.ParameterAutomation | Warning | TrainableParameterGenerator, Declared parameter axis cannot be proven resolved
 AIDN099 | AiDotNet.ParameterAutomation | Warning | TrainableParameterGenerator, [TrainableParameter] on a non-partial class does nothing
+AIDN046 | AiDotNet.TestCoverage | Warning | TestScaffoldGenerator, Layer cannot be scaffolded and produces no generated tests
diff --git a/src/AiDotNet.Generators/CloneAutomationAnalyzer.cs b/src/AiDotNet.Generators/CloneAutomationAnalyzer.cs
new file mode 100644
index 0000000000..0d36f53d6a
--- /dev/null
+++ b/src/AiDotNet.Generators/CloneAutomationAnalyzer.cs
@@ -0,0 +1,509 @@
+using System.Collections.Immutable;
+using System.Linq;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
+
+namespace AiDotNet.Generators;
+
+/// <summary>
+/// Keeps cloning automated: reports a hand-written clone the base already reproduces, and reports a
+/// model the clone plan cannot rebuild.
+/// </summary>
+/// <remarks>
+/// <para>
+/// Without this the overrides grow back. <c>CreateNewInstance</c>, <c>DeepCopy</c> and <c>Clone</c>
+/// were abstract on eleven base classes, so every concrete model was compelled to write one, and
+/// 1465 of them did. Making the bases concrete removes the compulsion but not the habit: the next
+/// model added to the library will still be written with a copy of its neighbour's override, and
+/// nothing would say otherwise.
+/// </para>
+/// <para>
+/// The two rules are deliberately different in severity, because they describe different situations.
+/// A redundant override is a mistake with a mechanical fix -- delete it -- and there are currently
+/// none, so it is an error and stays at zero. A model the plan cannot rebuild is a backlog item with
+/// a real fix (store the constructor argument in a field so it can be read back), and there are
+/// hundreds, so it is informational and names the parameter that blocks each one.
+/// </para>
+/// </remarks>
+[DiagnosticAnalyzer(LanguageNames.CSharp)]
+public class CloneAutomationAnalyzer : DiagnosticAnalyzer
+{
+    /// <summary>A hand-written clone the base class already reproduces.</summary>
+    private static readonly DiagnosticDescriptor RedundantOverride = new(
+        "ADN0058",
+        "Clone override duplicates what the base class already does",
+        "'{0}.{1}' only reconstructs the type, and the clone plan already records the constructor to "
+            + "do that. Delete the override: the base reproduces it, and a hand-written copy is a "
+            + "place a future constructor argument can be dropped without anything failing",
+        "AiDotNet.Serialization",
+        DiagnosticSeverity.Error,
+        isEnabledByDefault: true);
+
+    /// <summary>A model whose constructor cannot be replayed from what the instance still holds.</summary>
+    private static readonly DiagnosticDescriptor Unreproducible = new(
+        "ADN0059",
+        "Model cannot be rebuilt from its own state",
+        "'{0}' cannot be rebuilt by the clone plan, so it still needs a hand-written clone. {1} "
+            + "Store each one in a field named after it ('_name') and the generator will replay the "
+            + "constructor instead",
+        "AiDotNet.Serialization",
+        DiagnosticSeverity.Info,
+        isEnabledByDefault: true);
+
+    /// <summary>State a layer persists by hand instead of declaring it.</summary>
+    /// <remarks>
+    /// <para>
+    /// Every hand-written <c>Serialize</c> in this library was inspected, and not one writes state
+    /// that lacks a declaration mechanism. They write constructor parameters (<c>[LayerState]</c>
+    /// already generates both halves), tensors (<c>RegisterTrainableParameter</c> and
+    /// <c>RegisterBuffer</c> already own those), or the resolved shape (the base payload now carries
+    /// it). They exist because the state was never declared, so nothing generated it.
+    /// </para>
+    /// <para>
+    /// ERROR, DELIBERATELY, AND RED UNTIL THE BACKLOG IS ZERO. This rule exists to verify FULL
+    /// compliance, and a warning is the thing everyone learns to scroll past -- 368 hand-written
+    /// halves accumulated under exactly that kind of silence. The build stays red until every one of
+    /// them declares its state, which is the point: the count is the work, and it is not allowed to
+    /// be invisible.
+    /// </para>
+    /// </remarks>
+    private static readonly DiagnosticDescriptor HandWrittenSerialization = new(
+        "ADN0060",
+        "Serialization is hand-written instead of declared",
+        "'{0}.{1}' persists state by hand. Declare the state instead and the generator writes and "
+            + "reads it: mark constructor parameters [LayerState], register tensors with "
+            + "RegisterTrainableParameter or RegisterBuffer, and let the base carry the resolved "
+            + "shape. A hand-written pair is two places to forget the same field",
+        "AiDotNet.Serialization",
+        DiagnosticSeverity.Error,
+        isEnabledByDefault: true);
+
+    /// <summary>A concrete model has taken ownership of framework lifecycle plumbing.</summary>
+    /// <remarks>
+    /// A method can be non-redundant only because the shared generator/base path still has a gap.
+    /// Keeping the method makes that gap permanent and lets the next model copy it. Concrete models
+    /// therefore declare state and construction inputs; only abstract family bases may implement a
+    /// lifecycle policy. The rule is intentionally independent of body shape and plan availability.
+    /// </remarks>
+    private static readonly DiagnosticDescriptor ConcreteLifecycleOverride = new(
+        "ADN0063",
+        "Concrete model lifecycle must be generated",
+        "'{0}.{1}' is model-owned lifecycle plumbing. Delete the override and express its construction, "
+            + "clone, serialization, or parameter ownership through generated declarations and shared "
+            + "base infrastructure",
+        "AiDotNet.Serialization",
+        DiagnosticSeverity.Info,
+        isEnabledByDefault: true);
+
+    /// <inheritdoc/>
+    public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics
+        => ImmutableArray.Create(
+            RedundantOverride,
+            Unreproducible,
+            HandWrittenSerialization,
+            ConcreteLifecycleOverride);
+
+    /// <inheritdoc/>
+    public override void Initialize(AnalysisContext context)
+    {
+        context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
+        context.EnableConcurrentExecution();
+        context.RegisterSyntaxNodeAction(AnalyzeMethod, SyntaxKind.MethodDeclaration);
+        context.RegisterSyntaxNodeAction(AnalyzeType, SyntaxKind.ClassDeclaration);
+    }
+
+    /// <summary>
+    /// Reports an override whose whole body is a reconstruction the plan already performs.
+    /// </summary>
+    /// <param name="context">The analysis context.</param>
+    /// <remarks>
+    /// Only a body that is exactly one <c>return new ...;</c> is reported. An override that also
+    /// resolves a shape, branches on a mode or copies a field is doing something the base does not,
+    /// and telling someone to delete it would be wrong -- that work has to move deliberately.
+    /// </remarks>
+    private static void AnalyzeMethod(SyntaxNodeAnalysisContext context)
+    {
+        var method = (MethodDeclarationSyntax)context.Node;
+
+        if (!method.Modifiers.Any(m => m.ValueText == "override")) return;
+
+        var name = method.Identifier.ValueText;
+
+        // The acceptance boundary is architectural, not syntactic. A complicated override is not
+        // evidence that model-owned lifecycle code is necessary; it is evidence that the common
+        // path still needs to learn that state shape. Abstract family bases remain the right home
+        // for genuinely shared policy, while concrete models only declare their unique state.
+        bool isParameterOwnershipHook = name is "GetExtraTrainableLayers" or "GetExtraTrainableTensors";
+        if ((name is "Clone" or "DeepCopy" or "CreateNewInstance"
+                or "Serialize" or "Deserialize"
+                or "SerializeNetworkSpecificData" or "DeserializeNetworkSpecificData"
+                || isParameterOwnershipHook)
+            && context.ContainingSymbol is IMethodSymbol { ContainingType: { IsAbstract: false } lifecycleOwner }
+            && (IsModel(lifecycleOwner) || IsLayer(lifecycleOwner) || isParameterOwnershipHook))
+        {
+            context.ReportDiagnostic(Diagnostic.Create(
+                ConcreteLifecycleOverride,
+                method.Identifier.GetLocation(),
+                lifecycleOwner.Name,
+                name));
+            return;
+        }
+
+        // Serialization is reported wherever it is hand-written, without asking whether the base
+        // "already reproduces" it. That question is the wrong one: the state a layer persists by
+        // hand is state nothing declared, so the base COULD not reproduce it, and treating that as
+        // justification is what let 297 hand-written halves accumulate. The remedy is to declare the
+        // state, not to prove the override earns its place.
+        if (name is "Serialize" or "Deserialize")
+        {
+            // An override that hands the work to base is a DECORATOR, not a second copy of the
+            // persistence. Counting calls, logging, timing or taking a lock around
+            // `base.Serialize()` adds no field that anyone can forget, because the base still
+            // writes every declared member. Reporting those said "declare your state instead" to
+            // code that already does exactly that.
+            //
+            // Deliberately narrow: this exempts a body only when it CALLS base. A body that calls
+            // base and then appends its own hand-written payload is still reported, which is the
+            // shape that actually risks drift.
+            if (DelegatesToBase(method, name)) return;
+
+            if (context.ContainingSymbol is IMethodSymbol { OverriddenMethod: not null and not { IsAbstract: true } }
+                && context.ContainingSymbol.ContainingType is INamedTypeSymbol owner)
+            {
+                context.ReportDiagnostic(Diagnostic.Create(
+                    HandWrittenSerialization, method.Identifier.GetLocation(), owner.Name, name));
+            }
+
+            return;
+        }
+
+        // CreateInstanceForCopy belongs here for exactly the same reason as the other three: it is a
+        // factory hook whose whole body is "build one of me", which is what the recorded constructor
+        // already does. Leaving it out of the list was an omission rather than a decision -- 14 sites
+        // sat in the same shape as the 607 that went, and nothing was naming them.
+        if (name is not ("CreateNewInstance" or "DeepCopy" or "Clone" or "CreateInstanceForCopy")) return;
+        if (method.ParameterList.Parameters.Count != 0) return;
+
+        if (!IsSingleReturnOfNewObject(method) && !IsPureForwarder(method, name)) return;
+
+        if (context.ContainingSymbol is not IMethodSymbol symbol) return;
+
+        // An override that satisfies an abstract member is not optional, whatever its body looks
+        // like. A test file declares its own MockModelBase with `public abstract Clone()`, and
+        // telling three mocks to delete the only implementation of it produced CS0534 instead of a
+        // cleaner tree. Redundancy is a property of the base being CONCRETE, not of the body alone.
+        if (symbol.OverriddenMethod is null || symbol.OverriddenMethod.IsAbstract) return;
+
+        if (symbol.ContainingType is not INamedTypeSymbol type) return;
+        if (ClonePlanGenerator.CollectConstructorParameters(type, IsModel(type)) is null) return;
+
+        context.ReportDiagnostic(Diagnostic.Create(
+            RedundantOverride, method.Identifier.GetLocation(), type.Name, name));
+    }
+
+    /// <summary>
+    /// Reports a model the plan cannot rebuild, naming the constructor parameters that block it.
+    /// </summary>
+    /// <param name="context">The analysis context.</param>
+    private static void AnalyzeType(SyntaxNodeAnalysisContext context)
+    {
+        var declaration = (ClassDeclarationSyntax)context.Node;
+
+        if (declaration.Modifiers.Any(m => m.ValueText is "abstract" or "static")) return;
+        // GetDeclaredSymbol, not ContainingSymbol: for a class declaration the containing symbol is
+        // the namespace, so the cast below silently never matched and this rule reported nothing.
+        if (context.SemanticModel.GetDeclaredSymbol(declaration) is not INamedTypeSymbol type) return;
+        if (!IsModel(type)) return;
+        if (ClonePlanGenerator.CollectConstructorParameters(type, isModel: true) is not null) return;
+
+        var constructors = type.InstanceConstructors
+            .Where(c => c.DeclaredAccessibility is Accessibility.Public or Accessibility.Internal)
+            .Where(c => !c.IsStatic && c.Parameters.Length > 0)
+            .ToList();
+
+        if (constructors.Count == 0) return;
+
+        var widest = constructors.Max(c => c.Parameters.Length);
+        var candidates = constructors.Where(c => c.Parameters.Length == widest).ToList();
+
+        // An ambiguous overload set is a different situation from a missing field, and saying
+        // "add a backing field" would send someone to fix the wrong thing.
+        var reason = candidates.Count > 1
+            ? $"It declares {candidates.Count} constructors taking {widest} arguments, so nothing "
+              + "records which one this instance was built with."
+            : "These constructor parameters have no member holding their value: "
+              + string.Join(", ", candidates[0].Parameters
+                  .Where(p => p.RefKind != RefKind.None || ClonePlanGenerator.FindAnySource(type, p) is null)
+                  .Select(p => $"'{p.Name}'"))
+              + ".";
+
+        context.ReportDiagnostic(Diagnostic.Create(
+            Unreproducible, declaration.Identifier.GetLocation(), type.Name, reason));
+    }
+
+    /// <summary>
+    /// Determines whether the body is exactly one object creation returned.
+    /// </summary>
+    /// <param name="method">The override to inspect.</param>
+    /// <returns><see langword="true"/> when the body reconstructs and does nothing else.</returns>
+    /// <summary>
+    /// Determines whether a call only moves parameters onto a freshly built copy.
+    /// </summary>
+    /// <param name="call">The invocation to classify.</param>
+    /// <returns><see langword="true"/> when it is one of the base's own parameter-transfer methods.</returns>
+    /// <remarks>
+    /// By simple name, because the receiver varies -- <c>clone.SetParameters(...)</c>,
+    /// <c>clone._projectionLayer.SetParameters(...)</c>, a bare <c>TryShareParametersFrom(this)</c> --
+    /// and the receiver is not what makes the call redundant. What makes it redundant is that
+    /// Serialize already carries every declared parameter, so restating the transfer by hand restates
+    /// the payload. The list is closed on purpose: a fourth name is a decision to make deliberately,
+    /// not something to add because a body happened to contain it.
+    /// </remarks>
+    private static bool IsParameterTransfer(InvocationExpressionSyntax call)
+    {
+        var name = call.Expression switch
+        {
+            MemberAccessExpressionSyntax member => member.Name.Identifier.ValueText,
+            IdentifierNameSyntax identifier => identifier.Identifier.ValueText,
+            _ => null,
+        };
+
+        return name is "SetParameters" or "SetParameterChunks" or "TryShareParametersFrom";
+    }
+
+    private static bool IsSingleReturnOfNewObject(MethodDeclarationSyntax method)
+    {
+        var expression = method.ExpressionBody?.Expression;
+
+        if (expression is not null)
+        {
+            return expression is ObjectCreationExpressionSyntax { Initializer: null };
+        }
+
+        if (method.Body is null || method.Body.Statements.Count == 0) return false;
+
+        // EVERY return must hand back a plain construction, and nothing else may happen. A body that
+        // only chooses BETWEEN constructors is still pure reconstruction, and that is by far the
+        // commonest shape here: 584 of these pick an ONNX constructor when a model path is present
+        // and a native one when it is not.
+        //
+        //     if (!_useNativeMode && _options.ModelPath is { } mp) return new AudioMAE<T>(Architecture, mp, _options);
+        //     return new AudioMAE<T>(Architecture, _options);
+        //
+        // The plan already decides that at runtime -- it records every satisfiable constructor and
+        // picks the one the INSTANCE can supply, which is exactly what taking the widest one
+        // unconditionally got wrong when it passed null for onnxModelPath and made 51 models throw.
+        // So the base reproduces this body, and reporting only the one-liner left 584 of them
+        // invisible to the deletion loop.
+        var returns = 0;
+
+        // Which locals hold a plain construction, so `return clone;` can be told apart from
+        // `return _cachedThing;`. Only the former is still pure reconstruction.
+        var constructed = new System.Collections.Generic.HashSet<string>(System.StringComparer.Ordinal);
+
+        foreach (var local in method.Body.DescendantNodes().OfType<LocalDeclarationStatementSyntax>())
+        {
+            foreach (var declarator in local.Declaration.Variables)
+            {
+                if (declarator.Initializer?.Value is ObjectCreationExpressionSyntax { Initializer: null })
+                {
+                    constructed.Add(declarator.Identifier.ValueText);
+                }
+            }
+        }
+
+        foreach (var statement in method.Body.DescendantNodes().OfType<StatementSyntax>())
+        {
+            switch (statement)
+            {
+                case ReturnStatementSyntax { Expression: ObjectCreationExpressionSyntax { Initializer: null } }:
+                    returns++;
+                    break;
+
+                // `return clone;` where clone was built above and nothing else was done to it.
+                case ReturnStatementSyntax { Expression: IdentifierNameSyntax id }
+                    when constructed.Contains(id.Identifier.ValueText):
+                    returns++;
+                    break;
+
+                // A local holding a constructor argument, e.g. `var options = new ASTOptions(_options);`
+                // or `var unetClone = (UNetNoisePredictor<T>)_unet.Clone();`.
+                case LocalDeclarationStatementSyntax:
+                // The branch itself; its own statements are visited separately.
+                case IfStatementSyntax:
+                case BlockSyntax:
+                    break;
+
+                // MOVING PARAMETERS ACROSS IS NOT EXTRA WORK -- it is the copy the base already makes.
+                // The diffusion family's Clone overrides construct, then transfer, then return:
+                //
+                //     var clone = new OSDSModel<T>(...);
+                //     if (!clone.TryShareParametersFrom(this)) clone.SetParameterChunks(GetParameterChunks());
+                //     return clone;
+                //
+                // DeepCopy routes through Serialize and Deserialize, which carry every parameter the
+                // model declared, so those two lines restate what the payload does. They were written
+                // because the engine handed sub-modules across by reference and the copy shared its
+                // U-Net with the original -- and the engine now clones them. The allowlist is
+                // deliberately these three names and nothing else: anything further is real work the
+                // base cannot know about, and still disqualifies the body.
+                case ExpressionStatementSyntax { Expression: InvocationExpressionSyntax call }
+                    when IsParameterTransfer(call):
+                    break;
+
+                // COPYING A CONFIGURATION VALUE ONTO THE NEW INSTANCE IS NOT EXTRA WORK EITHER. The
+                // clone plan copies every configuration member, so `clone.ContextLength = ContextLength;`
+                // only restates what CopyConfiguration already did.
+                //
+                // This is the shape that hid the real damage. Requiring the body to be pure
+                // reconstruction meant a single field copy bought silence, and the override that
+                // looked the most deliberate was the most dangerous: AnimateDiffModel rebuilt itself
+                // with `options: null, scheduler: null`, patched three fields back, and dropped its
+                // options and scheduler on every clone -- while the analyzer that exists to find
+                // exactly that stayed quiet because line four was an assignment.
+                //
+                // Restricted to members of a local this body CONSTRUCTED: assigning to anything else
+                // reaches outside the new instance, which the base cannot stand in for.
+                case ExpressionStatementSyntax
+                {
+                    Expression: AssignmentExpressionSyntax
+                    {
+                        Left: MemberAccessExpressionSyntax { Expression: IdentifierNameSyntax target }
+                    }
+                }
+                    when constructed.Contains(target.Identifier.ValueText):
+                    break;
+
+                // A loop, or any other call -- work the constructor did not do -- means the body is
+                // not pure reconstruction and the base cannot stand in for it. Invocations on the new
+                // instance stay disqualifying even when they look like setters: this rule is an
+                // ERROR, and a method can do work no plan reproduces.
+                default:
+                    return false;
+            }
+        }
+
+        return returns > 0;
+    }
+
+    /// <summary>
+    /// True when the override only calls its own sibling and adds nothing.
+    /// </summary>
+    /// <param name="method">The override being analysed.</param>
+    /// <param name="name">The override's name.</param>
+    /// <returns><see langword="true"/> for a body that is exactly <c>SomeSibling()</c>.</returns>
+    /// <remarks>
+    /// <para>
+    /// This class is not merely redundant, it is FATAL. The bases define
+    /// <c>Clone() =&gt; DeepCopy()</c>, so a type that also defines <c>DeepCopy() =&gt; Clone()</c>
+    /// closes a two-frame cycle as soon as its own real <c>Clone</c> is removed. 227 types carried
+    /// that forwarder and 85 of them were already cyclic; <c>SuperNet</c> crashed the test host with
+    /// a stack overflow after 12015 repetitions.
+    /// </para>
+    /// <para>
+    /// It is also the deletion hazard the rest of this analyzer does not model. Proving the BASE
+    /// reproduces an override says nothing about whether a SIBLING in the same type delegates to
+    /// what is being removed, so removing <c>Clone</c> is correct in isolation and fatal next to a
+    /// forwarder. Reporting the forwarder means the deletion loop removes BOTH, and the pair cannot
+    /// regrow into a cycle.
+    /// </para>
+    /// </remarks>
+    /// <summary>
+    /// True when the body calls <c>base.&lt;name&gt;(...)</c> and writes nothing itself.
+    /// </summary>
+    /// <param name="method">The override being analysed.</param>
+    /// <param name="name">Its name, so the call must be to the SAME member on the base.</param>
+    /// <remarks>
+    /// The second condition matters. A body may call base and then append its own payload -
+    /// <c>ModelWrapperBase</c> does exactly that with the declared-state trailer - and that body IS
+    /// a place a field can be forgotten, so it stays reported. Constructing a <c>BinaryWriter</c> or
+    /// <c>BinaryReader</c> is the tell, and it is the tell every hand-written pair in this codebase
+    /// exhibits.
+    /// </remarks>
+    private static bool DelegatesToBase(MethodDeclarationSyntax method, string name)
+    {
+        SyntaxNode? body = method.Body ?? (SyntaxNode?)method.ExpressionBody?.Expression;
+        if (body is null) return false;
+
+        var callsBase = body.DescendantNodesAndSelf()
+            .OfType<InvocationExpressionSyntax>()
+            .Any(call => call.Expression is MemberAccessExpressionSyntax
+            {
+                Expression: BaseExpressionSyntax,
+                Name.Identifier.ValueText: { } called
+            } && called == name);
+
+        if (!callsBase) return false;
+
+        var writesItself = body.DescendantNodesAndSelf()
+            .OfType<ObjectCreationExpressionSyntax>()
+            .Any(created => created.Type.ToString() is var t
+                && (t.EndsWith("BinaryWriter", System.StringComparison.Ordinal)
+                    || t.EndsWith("BinaryReader", System.StringComparison.Ordinal)));
+
+        return !writesItself;
+    }
+
+    private static bool IsPureForwarder(MethodDeclarationSyntax method, string name)
+    {
+        var expression = method.ExpressionBody?.Expression;
+
+        if (expression is null)
+        {
+            if (method.Body is null || method.Body.Statements.Count != 1) return false;
+            if (method.Body.Statements[0] is not ReturnStatementSyntax { Expression: { } returned })
+            {
+                return false;
+            }
+
+            expression = returned;
+        }
+
+        // Only an unqualified or this-qualified call, and never to itself -- `Clone() => Clone()`
+        // would be its own infinite recursion rather than a forwarder to a sibling.
+        var invoked = expression switch
+        {
+            InvocationExpressionSyntax { ArgumentList.Arguments.Count: 0 } call => call.Expression switch
+            {
+                IdentifierNameSyntax id => id.Identifier.ValueText,
+                MemberAccessExpressionSyntax { Expression: ThisExpressionSyntax } member
+                    => member.Name.Identifier.ValueText,
+                _ => null,
+            },
+            _ => null,
+        };
+
+        return invoked is "Clone" or "DeepCopy" or "CreateNewInstance" && invoked != name;
+    }
+
+    /// <summary>
+    /// Determines whether the library treats this type as a model.
+    /// </summary>
+    /// <param name="type">The type to classify.</param>
+    /// <returns><see langword="true"/> when it declares a model persistence surface.</returns>
+    private static bool IsModel(INamedTypeSymbol type)
+    {
+        // Optimizers also expose serializer + shape contracts, but their lifecycle belongs to the
+        // optimizer hierarchy. Treating that structural overlap as a model made ADN0063 demand
+        // deletion of distributed optimizer checkpoint payloads that this generator does not own.
+        if (type.AllInterfaces.Any(i => i.Name == "IOptimizer")) return false;
+
+        bool isFullModel = type.AllInterfaces.Any(i => i.Name == "IFullModel");
+        bool isSerializableShapedModel = type.AllInterfaces.Any(i => i.Name == "IModelSerializer")
+            && type.AllInterfaces.Any(i => i.Name == "IModelShape");
+        return isFullModel || isSerializableShapedModel;
+    }
+
+    /// <summary>Determines whether a type belongs to the generated layer lifecycle.</summary>
+    private static bool IsLayer(INamedTypeSymbol type)
+    {
+        for (var current = type; current is not null; current = current.BaseType)
+        {
+            if (current.Name == "LayerBase") return true;
+        }
+
+        return false;
+    }
+}
diff --git a/src/AiDotNet.Generators/ClonePlanGenerator.cs b/src/AiDotNet.Generators/ClonePlanGenerator.cs
new file mode 100644
index 0000000000..62e4956e81
--- /dev/null
+++ b/src/AiDotNet.Generators/ClonePlanGenerator.cs
@@ -0,0 +1,975 @@
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Linq;
+using System.Text;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+
+namespace AiDotNet.Generators;
+
+/// <summary>
+/// Emits a compile-time clone plan for every cloneable type, so a clone carries the right members
+/// without anyone hand-writing a copy constructor.
+/// </summary>
+/// <remarks>
+/// <para>
+/// The problem this removes: 464 of 594 options classes have no copy constructor, and 1802
+/// hand-written clone paths exist across the library. Every one is a place a property can be
+/// dropped silently, which is the defect behind the Tacotron2 and TimeBridge clone bugs and behind
+/// the 71 copy constructors that omitted the inherited <c>ModelOptions.Seed</c>. Generating 464
+/// more constructors would multiply that surface rather than remove it.
+/// </para>
+/// <para>
+/// A <b>plan</b> is emitted rather than copy code because a Roslyn generator can only add members
+/// to a <c>partial</c> type and none of the options classes are partial. Registering a plan leaves
+/// every existing class untouched, and means a class written by a consumer works without them
+/// declaring anything.
+/// </para>
+/// <para>
+/// <b>What counts as configuration.</b> Everything publicly settable, unless provably otherwise.
+/// Read-only, privately set, and computed properties are skipped because they are constructor-owned
+/// or derived from what is carried, so re-deriving them keeps a clone consistent rather than merely
+/// equal. Delegates and
+/// interfaces are deliberately <i>kept</i>: activation functions, kernels and schedules arrive that
+/// way and are genuine configuration, so excluding them by type shape would produce a clone that
+/// behaves differently while looking correct.
+/// </para>
+/// <para>
+/// <b>What is not configuration.</b> Learned parameters travel through
+/// <c>GetParameters()</c>/<c>UpdateParameters(Vector&lt;T&gt;)</c>, which every layer implements and
+/// which training exercises on every step; optimizer state travels through the optimizer's own
+/// <c>Serialize</c>/<c>Deserialize</c>. Neither is inferred here, because inferring learned state
+/// from a property's type would misread a <c>Tensor&lt;T&gt;</c> that is genuinely configuration --
+/// a fixed prior or a mask.
+/// </para>
+/// </remarks>
+[Generator]
+public class ClonePlanGenerator : IIncrementalGenerator
+{
+    /// <summary>
+    /// Stands in a recorded constructor for "pass this parameter's declared default".
+    /// </summary>
+    /// <remarks>
+    /// Not a member name -- no C# member can be called this -- so it cannot collide with one. The
+    /// same literal is spelled out in <c>CloneEngine</c>, which is in a different assembly and cannot
+    /// reference this one; changing it here requires changing it there.
+    /// </remarks>
+    internal const string UseDefault = "=default";
+
+    private const string NotConfiguration = "NotConfigurationAttribute";
+    private const string ExternalResource = "ExternalResourceAttribute";
+
+    /// <inheritdoc/>
+    public void Initialize(IncrementalGeneratorInitializationContext context)
+    {
+        var candidates = context.SyntaxProvider.CreateSyntaxProvider(
+                static (node, _) => node is ClassDeclarationSyntax { BaseList: not null } c
+                    && !c.Modifiers.Any(m => m.ValueText == "abstract")
+                    && !c.Modifiers.Any(m => m.ValueText == "static"),
+                static (ctx, _) => (INamedTypeSymbol?)ctx.SemanticModel.GetDeclaredSymbol(ctx.Node))
+            .Where(static symbol => IsCloneable(symbol));
+
+        var collected = candidates.Collect();
+        context.RegisterSourceOutput(collected, static (spc, types) => Execute(spc, types!));
+    }
+
+    /// <summary>
+    /// Determines whether a type participates in cloning.
+    /// </summary>
+    /// <param name="symbol">The candidate type.</param>
+    /// <returns><see langword="true"/> when a plan should be emitted.</returns>
+    /// <remarks>
+    /// Membership is decided by the base chain rather than by a naming convention so that a
+    /// consumer's own subclass is included automatically -- which is the point of the feature. A
+    /// name-based rule would silently exclude anyone who named their class differently.
+    /// </remarks>
+    private static bool IsCloneable(INamedTypeSymbol? symbol)
+    {
+        // Roslyn normally supplies a symbol for a class declaration, but incomplete/error
+        // compilations are valid generator inputs. Keep that nullable boundary explicit instead
+        // of hiding it with null-forgiving syntax before this callback.
+        if (symbol is null) return false;
+        if (!IsNameableFromGeneratedCode(symbol)) return false;
+
+        // Anything the library treats as a model. The base-name list below predates this and covers
+        // options classes, whose root is not an interface; models are reached by interface instead so
+        // that a family added later -- or a model written in a consumer's own assembly -- is included
+        // without anyone editing this list. Every model family's root already declares IFullModel,
+        // which is what makes it the membership test rather than a convention about class names.
+        if (symbol.AllInterfaces.Any(i => i.Name == "IFullModel")) return true;
+
+        for (var b = symbol.BaseType; b is not null; b = b.BaseType)
+        {
+            switch (b.Name)
+            {
+                case "ModelOptions":
+                case "NeuralNetworkOptions":
+                case "RegressionOptions":
+                case "TimeSeriesRegressionOptions":
+                case "RiskModelOptions":
+                case "LayerBase":
+                case "NeuralNetworkBase":
+                    return true;
+            }
+        }
+
+        return false;
+    }
+
+    /// <summary>
+    /// Determines whether generated code in the same assembly can name this type.
+    /// </summary>
+    /// <param name="symbol">The candidate type.</param>
+    /// <returns><see langword="true"/> when <c>typeof(...)</c> would compile against it.</returns>
+    /// <remarks>
+    /// <para>
+    /// A type nested inside another as <c>private</c> or <c>protected</c> is invisible outside its
+    /// declaring type, so emitting <c>typeof(Outer.Inner)</c> produces CS0122 no matter how
+    /// cloneable the type is. <c>STCConnectorLayer&lt;T&gt;.RegStageBlock</c> is exactly that: a
+    /// nested helper deriving from <c>LayerBase</c>, matched by the base-chain rule and then
+    /// unnameable.
+    /// </para>
+    /// <para>
+    /// Every containing type is checked, not just the type itself: an accessible class nested in an
+    /// inaccessible one is still unreachable. Internal is fine, since generated code lands in the
+    /// same assembly.
+    /// </para>
+    /// <para>
+    /// Such a type is not left without a clone — it falls back to the reflected plan at runtime,
+    /// which reflection can reach precisely because it does not have to name the type in source.
+    /// </para>
+    /// </remarks>
+    private static bool IsNameableFromGeneratedCode(INamedTypeSymbol symbol)
+    {
+        for (var current = symbol; current is not null; current = current.ContainingType)
+        {
+            if (current.DeclaredAccessibility is not (Accessibility.Public or Accessibility.Internal))
+            {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    private static void Execute(SourceProductionContext context, ImmutableArray<INamedTypeSymbol?> types)
+    {
+        // Deduplicate: a partial class surfaces once per syntax tree, and the same symbol reached
+        // through different trees must not register two plans.
+        var distinct = types
+            .Where(t => t is not null)
+            .Select(t => t!)
+            .GroupBy(t => t.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat))
+            .Select(g => g.First())
+            .OrderBy(t => t.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat), System.StringComparer.Ordinal)
+            .ToList();
+
+        var sb = new StringBuilder();
+        sb.AppendLine("// <auto-generated/>");
+        sb.AppendLine("#nullable enable");
+        sb.AppendLine();
+        sb.AppendLine("using System;");
+        sb.AppendLine("using System.Collections.Generic;");
+        sb.AppendLine("using System.Reflection;");
+        sb.AppendLine("using AiDotNet.Models;");
+        sb.AppendLine();
+        sb.AppendLine("namespace AiDotNet.Generated;");
+        sb.AppendLine();
+        sb.AppendLine("/// <summary>");
+        sb.AppendLine("/// Compile-time clone plans. Registered once, on first use of the clone registry.");
+        sb.AppendLine("/// </summary>");
+        sb.AppendLine("[global::System.CodeDom.Compiler.GeneratedCode(\"AiDotNet.Generators.ClonePlanGenerator\", \"1.0.0\")]");
+        sb.AppendLine("internal static class CloneRegistrations");
+        sb.AppendLine("{");
+        sb.AppendLine("    private static bool _done;");
+        sb.AppendLine();
+        sb.AppendLine("    /// <summary>Registers every generated plan. Idempotent.</summary>");
+        sb.AppendLine("    internal static void RegisterAll()");
+        sb.AppendLine("    {");
+        sb.AppendLine("        if (_done) return;");
+        sb.AppendLine("        _done = true;");
+        sb.AppendLine();
+
+        var registrationMethods = new StringBuilder();
+        int registrationIndex = 0;
+        foreach (var type in distinct)
+        {
+            if (EmitRegistration(registrationMethods, type, registrationIndex))
+            {
+                sb.AppendLine($"        Register_{registrationIndex:D6}();");
+                registrationIndex++;
+            }
+        }
+
+        sb.AppendLine("    }");
+        sb.AppendLine();
+        sb.Append(registrationMethods);
+        sb.AppendLine("    /// <summary>");
+        sb.AppendLine("    /// Binds one configuration property, skipping it if the shape changed since generation.");
+        sb.AppendLine("    /// </summary>");
+        sb.AppendLine("    /// <remarks>");
+        sb.AppendLine("    /// A null result means the generated plan and the runtime type disagree, which the");
+        sb.AppendLine("    /// analyzer is there to prevent. Skipping rather than throwing keeps a stale plan from");
+        sb.AppendLine("    /// taking down an application that is otherwise working.");
+        sb.AppendLine("    /// </remarks>");
+        sb.AppendLine("    private static void Add(List<ClonePlanEntry> entries, Type owner, string name, CloneCopyKind kind)");
+        sb.AppendLine("    {");
+        sb.AppendLine("        var p = owner.GetProperty(name, BindingFlags.Public | BindingFlags.Instance);");
+        sb.AppendLine("        if (p is not null && p.CanRead && p.SetMethod?.IsPublic == true) entries.Add(new ClonePlanEntry(p, kind));");
+        sb.AppendLine("    }");
+        sb.AppendLine("}");
+
+        context.AddSource("CloneRegistrations.g.cs", sb.ToString());
+    }
+
+    private static bool EmitRegistration(StringBuilder sb, INamedTypeSymbol type, int registrationIndex)
+    {
+        var entries = CollectConfiguration(type);
+        var candidates = CollectConstructorCandidates(
+            type, type.AllInterfaces.Any(i => i.Name == "IFullModel"));
+        var constructor = candidates is null || candidates.Count == 0 ? null : candidates[0];
+
+        // A type with no settable configuration is still worth a plan when its constructor was
+        // recorded. That is the normal shape of a model: the arguments it was built from live in
+        // private fields, so the property scan finds nothing, and skipping it here is what left
+        // every model without a plan and forced a hand-written CreateNewInstance.
+        if (entries.Count == 0 && constructor is null) return false;
+
+        // An open generic cannot be reified here; typeof(Foo<>) is the runtime handle the registry
+        // keys on, and a closed instantiation resolves through it.
+        var display = type.IsGenericType
+            ? type.ConstructUnboundGenericType().ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat)
+            : type.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat);
+
+        // Keep each plan in its own method. A single RegisterAll body containing every plan grew
+        // beyond 1.1 MB of IL in the main assembly. Coverage and static-analysis tools construct a
+        // control-flow graph before applying generated-code exclusions, so that monolith consumed
+        // an entire CI shard budget even when the shard never cloned a model. Small generated
+        // methods keep total work linear while RegisterAll remains the one idempotent entry point.
+        sb.AppendLine($"    private static void Register_{registrationIndex:D6}()");
+        sb.AppendLine("    {");
+        sb.AppendLine($"        var t = typeof({display});");
+        sb.AppendLine("        var e = new List<ClonePlanEntry>();");
+
+        foreach (var (name, kind) in entries)
+        {
+            sb.AppendLine($"        Add(e, t, \"{name}\", CloneCopyKind.{kind});");
+        }
+        if (constructor is null)
+        {
+            sb.AppendLine("        CloneRegistry.Register(new ClonePlan(t, e));");
+        }
+        else
+        {
+            var names = string.Join(", ", constructor.Select(n => $"\"{n}\""));
+            var all = string.Join(", ", candidates!.Select(c =>
+                "new string[] { " + string.Join(", ", c.Select(n => $"\"{n}\"")) + " }"));
+            sb.AppendLine(
+                $"        CloneRegistry.Register(new ClonePlan(t, e, new[] {{ {names} }}, "
+                + $"new IReadOnlyList<string>[] {{ {all} }}));");
+        }
+        sb.AppendLine("    }");
+        sb.AppendLine();
+        return true;
+    }
+
+    /// <summary>
+    /// Collects the configuration surface, walking the full inheritance chain.
+    /// </summary>
+    /// <param name="type">The type to inspect.</param>
+    /// <returns>Property names paired with how each is carried, base first.</returns>
+    /// <remarks>
+    /// The chain is walked explicitly rather than read off the derived type alone. A
+    /// declaration-only view is precisely what omitted <c>ModelOptions.Seed</c> from 71 hand-written
+    /// copy constructors: the property is real and settable, but it is declared somewhere else.
+    /// </remarks>
+    private static List<(string Name, string Kind)> CollectConfiguration(INamedTypeSymbol type)
+    {
+        var result = new List<(string, string)>();
+        var seen = new HashSet<string>(System.StringComparer.Ordinal);
+        var chain = new List<INamedTypeSymbol>();
+
+        for (var current = type; current is not null && current.SpecialType != SpecialType.System_Object; current = current.BaseType)
+        {
+            chain.Add(current);
+        }
+
+        chain.Reverse();
+
+        foreach (var level in chain)
+        {
+            var properties = level.GetMembers()
+                .OfType<IPropertySymbol>()
+                .Where(p => p.DeclaredAccessibility == Accessibility.Public)
+                .Where(p => !p.IsStatic && !p.IsIndexer)
+                .Where(p => p.GetMethod is not null
+                            && p.SetMethod?.DeclaredAccessibility == Accessibility.Public)
+                .Where(p => !IsExcluded(p))
+                .OrderBy(p => p.Name, System.StringComparer.Ordinal);
+
+            foreach (var property in properties)
+            {
+                if (seen.Add(property.Name))
+                {
+                    result.Add((property.Name, CopyKindFor(property.Type)));
+                }
+            }
+        }
+
+        return result;
+    }
+
+    private static bool IsExcluded(IPropertySymbol property)
+        => property.GetAttributes().Any(a =>
+            a.AttributeClass?.Name is NotConfiguration or ExternalResource);
+
+    /// <summary>
+    /// Chooses how a value is carried: duplicated, or shared.
+    /// </summary>
+    /// <param name="type">The property type.</param>
+    /// <returns>The <c>CloneCopyKind</c> member name.</returns>
+    /// <remarks>
+    /// Mutable containers are duplicated, because a bare assignment leaves the clone and the
+    /// original writing through one buffer -- a difference invisible to a property-by-property
+    /// equality check, which is why the generated tests also assert that mutating a clone cannot
+    /// affect its original. Strings are shared: reference types, but immutable, so copying is waste.
+    /// </remarks>
+    private static string CopyKindFor(ITypeSymbol type)
+    {
+        if (type.SpecialType == SpecialType.System_String) return "ByReference";
+        if (type.TypeKind == TypeKind.Array) return "Deep";
+
+        if (type is INamedTypeSymbol { IsGenericType: true } named)
+        {
+            switch (named.ConstructedFrom.Name)
+            {
+                case "List":
+                case "Dictionary":
+                case "HashSet":
+                case "IList":
+                case "ICollection":
+                    return "Deep";
+            }
+        }
+
+        return "ByReference";
+    }
+
+    /// <summary>
+    /// Records the constructor a clone should call, when calling one is the only way to rebuild.
+    /// </summary>
+    /// <param name="type">The type being planned.</param>
+    /// <returns>
+    /// The constructor's parameters, in order, named by the member that supplies each; or
+    /// <see langword="null"/> when the type is rebuilt by allocating and assigning instead.
+    /// </returns>
+    /// <remarks>
+    /// <para>
+    /// <b>Only when there is no parameterless constructor.</b> A type that can be allocated bare was
+    /// already cloning correctly through assignment, and recording a constructor for it would change
+    /// working behaviour for no gain. Models are the types this exists for: a diffusion model takes
+    /// its scheduler and its noise predictor as arguments and offers no bare constructor at all, so
+    /// before this the only way to rebuild one was to hand-write a <c>CreateNewInstance</c> override
+    /// -- which is the 1147 overrides this removes.
+    /// </para>
+    /// <para>
+    /// <b>Every parameter must map, or none are recorded.</b> A partially satisfiable constructor is
+    /// worse than no constructor: it would compile, run, and quietly leave the unmapped arguments at
+    /// their defaults, producing a clone that differs from its original in a way no property
+    /// comparison detects. When the match fails the type keeps the assignment path and, if it has no
+    /// bare constructor either, <c>CloneEngine</c> says so by name at runtime rather than guessing.
+    /// </para>
+    /// <para>
+    /// <b>Candidates are ordered widest first, and chosen at run time.</b> A constructor derives
+    /// things from its arguments -- buffers sized from a layer count, sub-models built from a depth
+    /// setting -- so re-deriving from more state is better. But which constructor applies depends on
+    /// the instance: a model built natively has no ONNX path stored, and rebuilding it through the
+    /// wider ONNX constructor passes null and throws. <c>CloneEngine</c> makes that choice.
+    /// </para>
+    /// </remarks>
+    internal static List<string>? CollectConstructorParameters(INamedTypeSymbol type, bool isModel)
+    {
+        var candidates = CollectConstructorCandidates(type, isModel);
+        return candidates is null || candidates.Count == 0 ? null : candidates[0];
+    }
+
+    /// <summary>
+    /// Records every constructor a clone could call, widest first.
+    /// </summary>
+    /// <param name="type">The type being planned.</param>
+    /// <param name="isModel">Whether the library treats this type as a model.</param>
+    /// <returns>One entry per satisfiable constructor, or <see langword="null"/> when none is.</returns>
+    internal static List<List<string>>? CollectConstructorCandidates(INamedTypeSymbol type, bool isModel)
+    {
+        var constructors = type.InstanceConstructors
+            .Where(c => c.DeclaredAccessibility is Accessibility.Public or Accessibility.Internal)
+            .Where(c => !c.IsStatic)
+            .Where(c => c.Parameters.Length > 0)
+            .ToList();
+
+        if (constructors.Count == 0) return null;
+
+        // A type that can be allocated bare kept working through assignment, so leave it alone --
+        // unless it is a model, whose configuration lives in fields that assignment cannot reach.
+        if (!isModel && type.InstanceConstructors.Any(c => c.Parameters.Length == 0)) return null;
+
+        // EVERY satisfiable constructor is recorded, widest first -- not just the widest.
+        //
+        // Recording only the widest was wrong, and the sweep proved it: 51 models failed to clone
+        // with "onnxModelPath cannot be null". Those models take a model path in one constructor and
+        // an optimizer in another, the ONNX one is wider, and a natively-built instance has no path
+        // stored -- so rebuilding it through the widest constructor passed null and threw. Which
+        // constructor applies is a property of the INSTANCE, and nothing known here can decide it.
+        //
+        // Width still orders the candidates, because a narrower overload usually forwards to the
+        // wider one with defaults filled in and re-deriving from more state is better. CloneEngine
+        // walks them in this order and takes the first whose required arguments the instance holds.
+        var candidates = new List<List<string>>();
+
+        foreach (var constructor in constructors.OrderByDescending(c => c.Parameters.Length))
+        {
+            var mapped = new string?[constructor.Parameters.Length];
+            var satisfied = true;
+
+            // RESOLVE BY ELIMINATION, IN TWO PASSES. A parameter named after a member takes it
+            // first; only then does the type fallback run, and it ignores anything already spoken
+            // for. Resolving each parameter in isolation made a constructor with two arguments of
+            // one type unresolvable even when only one was ambiguous: a self-supervised method
+            // takes a studentProjector and a teacherProjector, the teacher matches the base's
+            // TeacherProjector by name, and the student -- which is the only projector left -- was
+            // still refused as "not unique" because the claimed member was counted against it.
+            for (int i = 0; i < constructor.Parameters.Length; i++)
+            {
+                // ref/out cannot be reproduced from reading a stored value.
+                if (constructor.Parameters[i].RefKind != RefKind.None) { satisfied = false; break; }
+
+                mapped[i] = FindDirectConstructorAssignment(type, constructor, constructor.Parameters[i])
+                    ?? FindNestedSource(type, constructor.Parameters[i])
+                    ?? FindSource(type, constructor.Parameters[i]);
+            }
+
+            var claimed = new HashSet<string>(System.StringComparer.Ordinal);
+            foreach (var already in mapped)
+            {
+                if (already is not null) claimed.Add(already);
+            }
+
+            for (int i = 0; satisfied && i < constructor.Parameters.Length; i++)
+            {
+                if (mapped[i] is not null) continue;
+
+                var parameter = constructor.Parameters[i];
+
+                // Ignoring claimed members is a PREFERENCE, not a rule. Two parameters may legitimately
+                // read the same member, and banning it outright took the GAN family's resolutions away:
+                // a parameter that used to source a member by type now found it spoken for and refused
+                // the whole constructor. Falling back to the unrestricted search makes this strictly
+                // additive -- it can only resolve parameters that were unresolvable before.
+                var member = FindUniqueByType(type, parameter, claimed)
+                    ?? FindUniqueByType(type, parameter, NothingClaimed);
+
+                if (member is null)
+                {
+                    // An OPTIONAL parameter nothing stores gets its declared default. That is not a
+                    // concession -- it is exactly what the hand-written override did: `new Foo(_options)`
+                    // left every unstored argument at its default too. 240 models are blocked on a
+                    // `seed` and 67 on a `maxGradNorm` that is passed to an initializer and never kept,
+                    // and refusing them bought nothing, because there is no value to preserve. A
+                    // REQUIRED parameter still refuses: onnxModelPath is required, which is what keeps
+                    // an ONNX model from being rebuilt as a native one.
+                    if (!parameter.IsOptional) { satisfied = false; break; }
+
+                    mapped[i] = UseDefault;
+                    continue;
+                }
+
+                mapped[i] = member;
+                claimed.Add(member);
+            }
+
+            if (!satisfied) continue;
+
+            var resolved = new List<string>(mapped.Length);
+            foreach (var member in mapped)
+            {
+                // Only reachable with every slot decided: pass one leaves a name or null, and pass
+                // two replaces every remaining null with a member or the default sentinel, or the
+                // constructor was abandoned above.
+                resolved.Add(member ?? UseDefault);
+            }
+
+            candidates.Add(resolved);
+        }
+
+        return candidates.Count == 0 ? null : candidates;
+    }
+
+    /// <summary>
+    /// Finds a member that the selected constructor directly assigns from a parameter, even when
+    /// their names intentionally differ (for example <c>ImageSize = imageWidth</c>).
+    /// </summary>
+    /// <remarks>
+    /// This is stronger evidence than a naming heuristic: it reads the constructor's actual storage
+    /// operation. Only a direct parameter RHS is accepted. Derived expressions remain unresolved so
+    /// the generator cannot mistake a computed runtime value for the original argument.
+    /// </remarks>
+    private static string? FindDirectConstructorAssignment(
+        INamedTypeSymbol type,
+        IMethodSymbol constructor,
+        IParameterSymbol parameter)
+    {
+        string? found = null;
+        foreach (var syntaxReference in constructor.DeclaringSyntaxReferences)
+        {
+            if (syntaxReference.GetSyntax() is not ConstructorDeclarationSyntax declaration)
+                continue;
+
+            foreach (var assignment in declaration.DescendantNodes().OfType<AssignmentExpressionSyntax>())
+            {
+                // Optional constructor arguments are normally stored through
+                // `member = parameter ?? new DefaultOptions()`. That is still direct storage of the
+                // effective constructor configuration: after construction the member is the only
+                // authoritative value, and replaying it reproduces both the explicit and default
+                // cases. Requiring a bare identifier dropped exactly these option members and let a
+                // same-named base property win later by heuristic.
+                ExpressionSyntax carried = assignment.Right is BinaryExpressionSyntax coalesce
+                        && coalesce.IsKind(SyntaxKind.CoalesceExpression)
+                    ? coalesce.Left
+                    : assignment.Right;
+                if (carried is not IdentifierNameSyntax right
+                    || !string.Equals(right.Identifier.ValueText, parameter.Name,
+                        System.StringComparison.Ordinal))
+                    continue;
+
+                string? memberName = assignment.Left switch
+                {
+                    IdentifierNameSyntax identifier => identifier.Identifier.ValueText,
+                    MemberAccessExpressionSyntax
+                    {
+                        Expression: ThisExpressionSyntax,
+                        Name: SimpleNameSyntax name
+                    } => name.Identifier.ValueText,
+                    _ => null,
+                };
+                if (memberName is null) continue;
+
+                bool isReadableMember = false;
+                for (var current = type; current is not null && !isReadableMember; current = current.BaseType)
+                {
+                    isReadableMember = current.GetMembers(memberName).Any(member => member switch
+                    {
+                        IPropertySymbol { IsStatic: false, IsIndexer: false } property
+                            when property.GetMethod is not null
+                                 && IsCloneConstructionSource(property)
+                                 && IsCarriedAs(property.Type, parameter.Type) => true,
+                        IFieldSymbol { IsStatic: false, IsConst: false } field
+                            when IsCloneConstructionSource(field)
+                                 && IsCarriedAs(field.Type, parameter.Type) => true,
+                        _ => false,
+                    });
+                }
+                if (!isReadableMember) continue;
+
+                if (found is not null
+                    && !string.Equals(found, memberName, System.StringComparison.Ordinal))
+                    return null;
+                found = memberName;
+            }
+        }
+
+        return found;
+    }
+
+    /// <summary>
+    /// Finds a constructor value held one ownership boundary below the model.
+    /// </summary>
+    /// <remarks>
+    /// Composite models commonly accept values such as <c>generatorArchitecture</c> and
+    /// <c>criticArchitecture</c>, then retain them on <c>Generator.Architecture</c> and
+    /// <c>Critic.Architecture</c>. A direct member search sees only the parent's general
+    /// <c>Architecture</c> property and maps both parameters to it. The resulting clone is
+    /// constructible but structurally wrong. A one-level path whose concatenated member names
+    /// exactly equal the parameter name is stronger evidence than that direct suffix match.
+    /// </remarks>
+    private static string? FindNestedSource(INamedTypeSymbol type, IParameterSymbol parameter)
+    {
+        string parameterName = parameter.Name.Replace("_", string.Empty);
+        string? found = null;
+
+        for (var current = type; current is not null; current = current.BaseType)
+        {
+            foreach (var owner in current.GetMembers())
+            {
+                string ownerName = owner.Name.TrimStart('_');
+                if (ownerName.Length == 0
+                    || parameterName.Length <= ownerName.Length
+                    || !parameterName.StartsWith(ownerName, System.StringComparison.OrdinalIgnoreCase))
+                {
+                    continue;
+                }
+
+                string nestedName = parameterName.Substring(ownerName.Length);
+                ITypeSymbol? ownerType = owner switch
+                {
+                    IPropertySymbol { IsStatic: false, IsIndexer: false } property
+                        when property.GetMethod is not null && IsCloneConstructionSource(property)
+                        => property.Type,
+                    IFieldSymbol { IsStatic: false, IsConst: false } field
+                        when IsCloneConstructionSource(field) => field.Type,
+                    _ => null,
+                };
+                if (ownerType is not INamedTypeSymbol namedOwner) continue;
+
+                foreach (var nested in namedOwner.GetMembers())
+                {
+                    if (!string.Equals(nested.Name.TrimStart('_'), nestedName,
+                            System.StringComparison.OrdinalIgnoreCase))
+                    {
+                        continue;
+                    }
+
+                    ITypeSymbol? nestedType = nested switch
+                    {
+                        IPropertySymbol { IsStatic: false, IsIndexer: false } property
+                            when property.GetMethod is not null => property.Type,
+                        IFieldSymbol { IsStatic: false, IsConst: false } field => field.Type,
+                        _ => null,
+                    };
+                    if (nestedType is null || !IsCarriedAs(nestedType, parameter.Type)) continue;
+
+                    string path = owner.Name + "." + nested.Name;
+                    if (found is not null
+                        && !string.Equals(found, path, System.StringComparison.Ordinal))
+                        return null;
+                    found = path;
+                }
+            }
+
+            if (found is not null) return found;
+        }
+
+        return null;
+    }
+
+    /// <summary>
+    /// Finds the member that holds what was passed for a constructor parameter.
+    /// </summary>
+    /// <param name="type">The type being planned.</param>
+    /// <param name="parameter">The constructor parameter to source.</param>
+    /// <returns>The member's name, or <see langword="null"/> when nothing holds the value.</returns>
+    /// <remarks>
+    /// <para>
+    /// Fields are searched, not only properties, because that is where a model keeps what it was
+    /// built from. <c>DDPMModel</c> takes a scheduler and a U-Net and stores them in <c>_unet</c>
+    /// and a base-class property; a property-only scan finds one of the two and gives up, which is
+    /// why models had no plan at all before this.
+    /// </para>
+    /// <para>
+    /// The naming rule is the one <c>LayerStateGenerator</c> already proved on the layers: the
+    /// parameter name itself, an underscore prefix, or the PascalCase form. It is deliberately not a
+    /// search for "a field of the right type" -- two constructor parameters of the same type would
+    /// then bind in whichever order the members happened to be declared, and the clone would silently
+    /// swap them.
+    /// </para>
+    /// <para>
+    /// The type must match, which is what makes a name coincidence harmless: a field that happens to
+    /// share a parameter's name but not its type is rejected and the constructor goes unrecorded.
+    /// </para>
+    /// </remarks>
+    internal static string? FindSource(INamedTypeSymbol type, IParameterSymbol parameter)
+    {
+        var candidates = new[]
+        {
+            parameter.Name,
+            "_" + parameter.Name,
+            char.ToUpperInvariant(parameter.Name[0]) + parameter.Name.Substring(1),
+        };
+
+        for (var current = type; current is not null; current = current.BaseType)
+        {
+            foreach (var candidate in candidates)
+            {
+                foreach (var member in current.GetMembers(candidate))
+                {
+                    switch (member)
+                    {
+                        case IPropertySymbol { IsStatic: false, IsIndexer: false } property
+                            when property.GetMethod is not null
+                                 && IsCloneConstructionSource(property)
+                                 && IsCarriedAs(property.Type, parameter.Type):
+                            return property.Name;
+
+                        case IFieldSymbol { IsStatic: false, IsConst: false } field
+                            when IsCloneConstructionSource(field)
+                                 && IsCarriedAs(field.Type, parameter.Type):
+                            return field.Name;
+                    }
+                }
+            }
+        }
+
+        // The type fallback is NOT tried here. It runs in a second pass over the whole constructor,
+        // once every name match is known, so it can ignore members another parameter already claimed.
+        return FindByNameSuffix(type, parameter);
+    }
+
+    /// <summary>
+    /// Finds the member whose name ends with the parameter's, when the exact name did not match.
+    /// </summary>
+    /// <param name="type">The type being planned.</param>
+    /// <param name="parameter">The constructor parameter to source.</param>
+    /// <returns>That member's name, or <see langword="null"/> when there is not exactly one.</returns>
+    /// <remarks>
+    /// <para>
+    /// A qualifying prefix is the common way this library disambiguates a stored argument:
+    /// <c>AttentiveNAS</c> keeps its <c>searchSpace</c> in <c>_nasSearchSpace</c>, and
+    /// <c>BayTransProtoAlgorithm</c> keeps its <c>options</c> in <c>_algoOptions</c>. Both hold
+    /// exactly what the constructor was given; only the name is decorated.
+    /// </para>
+    /// <para>
+    /// Tried BEFORE the type search and preferred over it, because a name that ends with the
+    /// parameter's is evidence about THIS parameter, where a unique type is only evidence that
+    /// nothing else could be meant. Where two members qualify, neither is chosen.
+    /// </para>
+    /// </remarks>
+    private static string? FindByNameSuffix(INamedTypeSymbol type, IParameterSymbol parameter)
+    {
+        var suffix = char.ToUpperInvariant(parameter.Name[0]) + parameter.Name.Substring(1);
+        string? found = null;
+
+        for (var current = type; current is not null; current = current.BaseType)
+        {
+            var fields = new List<string>();
+            var properties = new List<string>();
+
+            foreach (var member in current.GetMembers())
+            {
+                var name = member switch
+                {
+                    IPropertySymbol { IsStatic: false, IsIndexer: false } p
+                        when p.GetMethod is not null && IsCloneConstructionSource(p)
+                             && IsCarriedAs(p.Type, parameter.Type) => p.Name,
+                    IFieldSymbol { IsStatic: false, IsConst: false } f
+                        when IsCloneConstructionSource(f)
+                             && IsCarriedAs(f.Type, parameter.Type) => f.Name,
+                    _ => null,
+                };
+
+                if (name is null) continue;
+
+                // A STORED ARGUMENT IS DECORATED AT EITHER END. A qualifying prefix is the common
+                // case (_nasSearchSpace, _bayesOptions); a qualifying suffix is the other one --
+                // StackingClassifier takes a `Func<IClassifier<T>> finalEstimator` and keeps it in
+                // _finalEstimatorFactory, which holds exactly what the constructor was given.
+                //
+                // The type check above is what makes this safe rather than loose: the same class
+                // also declares _finalEstimator, and that one is refused on TYPE (a classifier, not
+                // the factory) before its name is ever considered.
+                var bare = name.TrimStart('_');
+                var decorated = name.EndsWith(suffix, System.StringComparison.Ordinal)
+                    || (bare.Length > parameter.Name.Length
+                        && bare.StartsWith(parameter.Name, System.StringComparison.OrdinalIgnoreCase));
+                if (!decorated) continue;
+
+                if (member is IFieldSymbol) fields.Add(name); else properties.Add(name);
+            }
+
+            // A PROPERTY AND ITS OWN BACKING FIELD ARE ONE VALUE, NOT TWO CANDIDATES. Counting them
+            // separately is what made the pair ambiguous, and the ambiguity rule then refused BOTH.
+            // Every NAS model is shaped this way -- AttentiveNAS declares `_nasSearchSpace` and
+            // exposes `NasSearchSpace => _nasSearchSpace` beside it -- so all eight were reported
+            // unrebuildable over a parameter they do store, by the very lookup written to find it.
+            // The field is preferred because it is the slot the constructor assigned.
+            properties.RemoveAll(p => fields.Any(
+                f => string.Equals(f.TrimStart('_'), p, System.StringComparison.OrdinalIgnoreCase)));
+
+            // Anything still standing alongside another is genuinely ambiguous, and neither is chosen.
+            var matches = fields.Count + properties.Count;
+            if (matches > 1) return null;
+            if (matches == 1) found = fields.Count == 1 ? fields[0] : properties[0];
+
+            // Most-derived wins. AttentiveNAS keeps its searchSpace in _nasSearchSpace while a base
+            // also exposes SearchSpace; both hold it, and the one the constructor assigned is the one
+            // declared alongside that constructor. Refusing the pair left the model unrebuildable
+            // over a naming decision that changes nothing about its state.
+            if (found is not null) return found;
+        }
+
+        return null;
+    }
+
+    /// <summary>
+    /// Finds the single member of a parameter's exact type, when the name did not match.
+    /// </summary>
+    /// <param name="type">The type being planned.</param>
+    /// <param name="parameter">The constructor parameter to source.</param>
+    /// <returns>That member's name, or <see langword="null"/> when there is not exactly one.</returns>
+    /// <remarks>
+    /// <para>
+    /// The name rule alone missed 132 models, all the same way: the constructor takes
+    /// <c>options</c> and the field is <c>_algoOptions</c>. The value IS stored -- just not under a
+    /// name the rule guesses -- so refusing produced a model that needed a hand-written clone for a
+    /// naming choice rather than for anything about its state.
+    /// </para>
+    /// <para>
+    /// EXACTLY ONE, and by exact type. Two members of the same type would bind in whichever order
+    /// they happen to be declared, so a clone could silently swap a generator for a discriminator.
+    /// Uniqueness is what makes this unambiguous, and it is checked across the whole inheritance
+    /// chain rather than one level, because the member usually lives on a base.
+    /// </para>
+    /// <para>
+    /// Base types are excluded from the exact-type search only for very common primitives, where a
+    /// unique match is a coincidence rather than a correspondence.
+    /// </para>
+    /// </remarks>
+    /// <summary>
+    /// Name-then-type sourcing for a parameter considered on its own, with nothing claimed.
+    /// </summary>
+    /// <remarks>
+    /// For the analyzer, which reports which parameters block a model and must answer that per
+    /// parameter. The plan itself resolves a constructor as a whole, so it uses the two passes.
+    /// </remarks>
+    internal static string? FindAnySource(INamedTypeSymbol type, IParameterSymbol parameter)
+        => FindSource(type, parameter) ?? FindUniqueByType(type, parameter, NothingClaimed);
+
+    private static readonly HashSet<string> NothingClaimed = new(System.StringComparer.Ordinal);
+
+    private static string? FindUniqueByType(
+        INamedTypeSymbol type,
+        IParameterSymbol parameter,
+        HashSet<string> claimed)
+    {
+        // A lone int or string field matching a lone int or string parameter says nothing: those
+        // types recur, and the match would be luck. Richer types are genuinely identifying.
+        if (parameter.Type.SpecialType is not SpecialType.None) return null;
+        if (parameter.Type.TypeKind == TypeKind.Enum) return null;
+
+        var fields = new List<string>();
+        var properties = new List<string>();
+
+        for (var current = type; current is not null; current = current.BaseType)
+        {
+            foreach (var member in current.GetMembers())
+            {
+                string? name = member switch
+                {
+                    IPropertySymbol { IsStatic: false, IsIndexer: false } p
+                        when p.GetMethod is not null && IsCloneConstructionSource(p)
+                             && IsSameType(p.Type, parameter.Type) => p.Name,
+                    IFieldSymbol { IsStatic: false, IsConst: false } f
+                        when IsCloneConstructionSource(f)
+                             && IsSameType(f.Type, parameter.Type) => f.Name,
+                    _ => null,
+                };
+
+                if (name is null) continue;
+
+                // Spoken for by a parameter that matched it by name, so it is not evidence about
+                // this one -- that is what lets the last unclaimed member of a repeated type resolve.
+                if (claimed.Contains(name)) continue;
+
+                if (member is IFieldSymbol) fields.Add(name); else properties.Add(name);
+            }
+        }
+
+        // A property and its own backing field are one value here too, for the same reason they are
+        // in FindByNameSuffix: counting them separately made a type that occurs exactly once look
+        // like it occurred twice, and "not unique" then refused it. The projector a self-supervised
+        // method is built with is stored as _projector and read back through Projector, so the pair
+        // alone was enough to lose it.
+        properties.RemoveAll(p => fields.Any(
+            f => string.Equals(f.TrimStart('_'), p, System.StringComparison.OrdinalIgnoreCase)));
+
+        if (fields.Count + properties.Count != 1) return null;
+
+        return fields.Count == 1 ? fields[0] : properties[0];
+    }
+
+    /// <summary>Scratch storage is derived runtime state, never constructor configuration.</summary>
+    private static bool IsCloneConstructionSource(ISymbol member)
+        => ParameterMemberSemanticModel.Classify(member).Kind
+            != ParameterMemberSemanticModel.Kind.Scratch;
+
+    /// <summary>
+    /// Compares two types ignoring nullable annotation.
+    /// </summary>
+    /// <param name="a">The first type.</param>
+    /// <param name="b">The second type.</param>
+    /// <returns><see langword="true"/> when they are the same type.</returns>
+    private static bool IsSameType(ITypeSymbol a, ITypeSymbol b)
+        => SymbolEqualityComparer.Default.Equals(
+            a.WithNullableAnnotation(NullableAnnotation.None),
+            b.WithNullableAnnotation(NullableAnnotation.None));
+
+    /// <summary>
+    /// Determines whether a member's value can be passed for a parameter without a conversion.
+    /// </summary>
+    /// <param name="property">The member's type.</param>
+    /// <param name="parameter">The parameter type.</param>
+    /// <returns><see langword="true"/> when the value is passable as-is.</returns>
+    /// <remarks>
+    /// Reference conversions only -- a base class or an implemented interface. Numeric and
+    /// user-defined conversions are deliberately refused: the value is passed through
+    /// <c>ConstructorInfo.Invoke</c>, which performs no user-defined conversion, so accepting one
+    /// here would produce a plan that compiles and then throws at the point of cloning.
+    /// </remarks>
+    private static bool IsCarriedAs(ITypeSymbol property, ITypeSymbol parameter)
+    {
+        var from = property.WithNullableAnnotation(NullableAnnotation.None);
+        var to = parameter.WithNullableAnnotation(NullableAnnotation.None);
+
+        if (SymbolEqualityComparer.Default.Equals(from, to)) return true;
+
+        // A resolved optional value is commonly stored in a non-nullable field: constructors spell
+        // `int? outputChannels = null` and then persist `_outputChannels = outputChannels ?? input`.
+        // Passing that stored int back to ConstructorInfo for Nullable<int> is the exact CLR boxing
+        // representation of a nullable with HasValue=true. Refusing it pinned outputChannels (and
+        // similar shape-bearing options) to null, rebuilding custom predictors with default widths.
+        if (to is INamedTypeSymbol
+            {
+                OriginalDefinition.SpecialType: SpecialType.System_Nullable_T,
+                TypeArguments.Length: 1
+            } nullable
+            && SymbolEqualityComparer.Default.Equals(
+                from, nullable.TypeArguments[0].WithNullableAnnotation(NullableAnnotation.None)))
+        {
+            return true;
+        }
+
+        for (var b = (from as INamedTypeSymbol)?.BaseType; b is not null; b = b.BaseType)
+        {
+            if (SymbolEqualityComparer.Default.Equals(b.WithNullableAnnotation(NullableAnnotation.None), to))
+            {
+                return true;
+            }
+        }
+
+        if (from.AllInterfaces.Any(i =>
+            SymbolEqualityComparer.Default.Equals(i.WithNullableAnnotation(NullableAnnotation.None), to)))
+        {
+            return true;
+        }
+
+        // THE MEMBER MAY HOLD THE ARGUMENT MORE GENERALLY THAN THE CONSTRUCTOR TAKES IT. A time
+        // series model passes its ARModelOptions to the base and reads it back off the base's
+        // Options property, whose type is the general options base -- the model's own clone did
+        // `new ARModel<T>((ARModelOptions<T>)Options)`, downcasting exactly this way. Refusing the
+        // pair left three models unrebuildable over a value they never stopped holding.
+        //
+        // Safe because it is the RUNTIME value that settles it: CloneEngine now skips a candidate
+        // constructor whose argument is not an instance of the parameter type, so a member that
+        // happens to hold something else moves on to the next candidate instead of throwing.
+        for (var b = (to as INamedTypeSymbol)?.BaseType; b is not null; b = b.BaseType)
+        {
+            if (SymbolEqualityComparer.Default.Equals(b.WithNullableAnnotation(NullableAnnotation.None), from))
+            {
+                return true;
+            }
+        }
+
+        return to.AllInterfaces.Any(i =>
+            SymbolEqualityComparer.Default.Equals(i.WithNullableAnnotation(NullableAnnotation.None), from));
+    }
+
+}
diff --git a/src/AiDotNet.Generators/LayerStateGenerator.cs b/src/AiDotNet.Generators/LayerStateGenerator.cs
index 0a563dbac2..accfebc83c 100644
--- a/src/AiDotNet.Generators/LayerStateGenerator.cs
+++ b/src/AiDotNet.Generators/LayerStateGenerator.cs
@@ -20,7 +20,7 @@ namespace AiDotNet.Generators;
 /// correctly declared an axis dynamic, the branch handed its constructor a <c>-1</c>.
 /// </para>
 /// <para>
-/// For each annotated constructor this emits (a) an <c>internal override void WriteConstructionState</c>
+/// For each annotated constructor this emits (a) a <c>protected override void WriteConstructionState</c>
 /// on the layer writing every marked parameter, and (b) an entry in a central factory keyed by open
 /// generic type that reconstructs the layer by calling that same constructor. Because both halves are
 /// derived from one declaration, they cannot drift apart — which is the failure mode Keras's
@@ -40,6 +40,7 @@ namespace AiDotNet.Generators;
 public class LayerStateGenerator : IIncrementalGenerator
 {
     private const string StateAttribute = "AiDotNet.Attributes.LayerStateAttribute";
+    private const string CloneRandomSeedKey = "__aidotnet_clone_random_seed";
 
     private static readonly DiagnosticDescriptor NotPartial = new(
         "ADN0050",
@@ -60,6 +61,16 @@ public class LayerStateGenerator : IIncrementalGenerator
             + "string, enum, int[] and interface values can round-trip through layer metadata",
         "AiDotNet.Serialization", DiagnosticSeverity.Error, true);
 
+    // Informational by design: pinning an optional argument is sometimes intentional, but it must
+    // never be invisible because a non-default value would otherwise be lost during reconstruction.
+    private static readonly DiagnosticDescriptor PinnedDefault = new(
+        "ADN0057",
+        "Optional constructor parameter is pinned to its default in the generated factory",
+        "'{0}' pins optional constructor parameter '{1}' to its declared default, so a rebuilt layer "
+            + "will not preserve a non-default value. Store it in a field named '{1}', '_{1}' or its "
+            + "PascalCase form and the generator will round-trip it",
+        "AiDotNet.Serialization", DiagnosticSeverity.Info, true);
+
     private static readonly DiagnosticDescriptor Unsuppliable = new(
         "ADN0053",
         "Required constructor parameter cannot be restored",
@@ -78,7 +89,7 @@ public class LayerStateGenerator : IIncrementalGenerator
         "ADN0055",
         "[LayerState] layer cannot be registered in the generated factory",
         "'{0}' has [LayerState] parameters and {1} type parameter(s), but the generated factory "
-            + "only registers layers with exactly one (the numeric type). Its state IS saved and "
+            + "only registers non-generic layers and layers with exactly one (the numeric type). Its state IS saved and "
             + "nothing can rebuild it, so deserialization falls back to the shape-inference path "
             + "this generator exists to replace; give the layer a single type parameter or exclude it",
         "AiDotNet.Serialization", DiagnosticSeverity.Warning, true);
@@ -94,8 +105,18 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
     {
         var candidates = context.SyntaxProvider
             .CreateSyntaxProvider(
+                // Any constructor that takes arguments. It used to require a parameter carrying an
+                // ATTRIBUTE, which is the first of the two gates that made this generator only
+                // able to see layers which had already opted in -- a rule that by construction
+                // cannot report the layers that did not. Inference in Analyze is unreachable
+                // without widening this, because a layer with no attributes never arrives here.
+                //
+                // Analyze does the real filtering, and it needs the semantic model to do it: it
+                // rejects a host type that is not a LayerBase-derived class, and declines any
+                // constructor with nothing restorable. A parameterless constructor is excluded
+                // here because it carries no construction state by definition.
                 static (node, _) => node is ConstructorDeclarationSyntax c
-                    && c.ParameterList.Parameters.Any(p => p.AttributeLists.Count > 0),
+                    && c.ParameterList.Parameters.Count > 0,
                 static (ctx, _) => Analyze(ctx))
             .Where(static m => m is not null)
             .Select(static (m, _) => m!);
@@ -109,19 +130,110 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
         if (ctx.SemanticModel.GetDeclaredSymbol(syntax) is not IMethodSymbol ctor) return null;
 
         var marked = ctor.Parameters.Where(HasStateAttribute).ToList();
+
+        // Captured BEFORE the inference block below reassigns `marked`, because afterwards the two
+        // origins are indistinguishable. An author who wrote [LayerState] on a constructor stated
+        // that this is the one to rebuild through; inference only guesses. Selection uses that.
+        bool explicitlyMarked = marked.Count > 0;
+
+        var safelyInferred = ctor.Parameters.Where(p =>
+            // Activations use LayerBase's ordered scalar/vector construction channel. Treating
+            // vectorActivation as ordinary component state merely because the inherited
+            // VectorActivation property has the same name made that overload outrank its scalar
+            // twin, even when the live layer was built with a scalar activation.
+            !IsActivation(p.Type, out _)
+            && Classify(p.Type) is not ValueKind.Unsupported
+            // Interface-valued components are state too. The in-memory path supplies the live
+            // configured object through WriteConstructionObjects; durable restoration records the
+            // concrete type and either constructs it or fails loudly. Pinning a strategy/activation
+            // to null is never safer: it silently changes the rebuilt layer.
+            && FindBackingMember(
+                ctor.ContainingType, p, ctx.SemanticModel, syntax,
+                out _, out _) is not null).ToList();
+
+        if (marked.Count == 0)
+        {
+            // INFERENCE. A constructor argument the layer stores in a field of the same name IS
+            // construction state, whether or not anyone wrote the attribute. Gating on the
+            // attribute alone meant a layer that stored every argument correctly was discarded
+            // with no factory, no clone and no error -- a green build that had silently opted the
+            // layer out. Requiring an opt-in is precisely what cannot report the layers that did
+            // not opt in.
+            //
+            // Restricted to parameters that are BOTH restorable and backed by a non-nullable
+            // member, which is not an optimisation: those three conditions are exactly the three
+            // that raise ADN0053 / NoBackingMember below, so an inferred parameter cannot reach a
+            // diagnostic. Reporting stays the exclusive province of an explicit [LayerState]
+            // claim, which is the same narrowing ADN0056 already needed.
+            marked = safelyInferred;
+
+            // A factory can only call this constructor if EVERY required argument can be supplied.
+            // Layers whose constructor takes another layer (DenseLoRAAdapter's baseLayer,
+            // QuantizedDenseLayer's source) cannot be rebuilt from string metadata yet, so infer
+            // nothing for them and leave the existing path in place. Emitting a partial factory
+            // would trade a clear "no factory" for a call that cannot compile, and REPORTING it
+            // would be a diagnostic against a layer whose author claimed nothing.
+            if (marked.Count > 0
+                && ctor.Parameters.Any(p => !p.IsOptional
+                    && !marked.Contains(p, SymbolEqualityComparer.Default)))
+            {
+                return null;
+            }
+        }
+        else
+        {
+            // An explicit attribute selects the constructor; it must not disable safe inference for
+            // its other arguments. The old either/or rule preserved the marked dimensions while
+            // silently pinning an unmarked padding, epsilon, momentum, or enum in the same call.
+            foreach (var parameter in safelyInferred)
+            {
+                if (!marked.Contains(parameter, SymbolEqualityComparer.Default)) marked.Add(parameter);
+            }
+        }
+
+        // A constructor with nothing restorable is still declined: emitting a factory that cannot
+        // rebuild the layer would replace a clear "no factory" with a silent wrong reconstruction.
         if (marked.Count == 0) return null;
 
+        var inferredState = new HashSet<string>(marked.Select(p => p.Name), System.StringComparer.Ordinal);
+
         var type = ctor.ContainingType;
 
+        // An abstract layer has a constructor but cannot be instantiated, so a factory naming it
+        // emits `new AbstractLayer<T>(...)` and fails with CS0144 inside generated source. Declined
+        // silently and before the diagnostic below: an abstract base is not a mistake the author
+        // made, it is a type that is only ever built through a derived class -- and that derived
+        // class gets its own factory.
+        if (type.IsAbstract) return null;
+
+        // A type the generated table cannot NAME. GeneratedLayerFactories is a separate static
+        // class, so a private nested layer (STCConnectorLayer's RegStageBlock) is unreachable from
+        // it however correct its state declarations are. Declined rather than reported: the author
+        // of a private helper layer has done nothing wrong, and ADN0055 firing on it is a
+        // diagnostic about the table's reach rather than about their code.
+        for (var scope = type; scope is not null; scope = scope.ContainingType)
+        {
+            if (scope.DeclaredAccessibility is Accessibility.Private or Accessibility.ProtectedAndInternal)
+                return null;
+        }
+
         // THE HOST TYPE MUST BE ABLE TO CARRY THE GENERATED MEMBER. Analyze accepted any
         // constructor whose parameters carried [LayerState] and then emitted
-        // `partial class {TypeName}` with `internal override void WriteConstructionState`.
+        // `partial class {TypeName}` with `protected override void WriteConstructionState`.
         // A struct, a record, or a class not derived from LayerBase produced a raw C#
         // compiler error pointing INTO generated source -- an error about code the author
         // never wrote and cannot open. Refused here with a diagnostic on the declaration
         // instead.
         if (type.TypeKind != TypeKind.Class || type.IsRecord || !DerivesFromLayerBase(type))
         {
+            // Report ONLY an explicit claim. Now that every parameterized constructor is analysed
+            // rather than only attributed ones, an unguarded report here tells every ordinary
+            // class in the compilation to stop marking parameters it never marked -- measured at
+            // 4,716 errors on the first build after widening the predicate. Declining silently is
+            // the correct answer for a type that made no claim; the diagnostic exists for an
+            // author who wrote [LayerState] somewhere it cannot work.
+            if (!ctor.Parameters.Any(HasStateAttribute)) return null;
+
             return new LayerModel
             {
                 TypeName = type.Name,
@@ -150,6 +262,7 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
                 ? null
                 : type.ContainingNamespace.ToDisplayString(),
             TypeName = type.Name,
+            HasExplicitState = explicitlyMarked,
             ContainingTypes = ContainingChain(type),
             TypeParameters = type.TypeParameters.Select(tp => tp.Name).ToList(),
             BaseFqn = type.ConstructedFrom.ToDisplayString(UnqualifiedGenerics),
@@ -174,23 +287,28 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
                     })),
         };
 
-        // One restored activation per kind, because TryCreate only receives one of each: the
-        // activation metadata records the function handed to base(...), and there is only ever one
-        // of those. So the FIRST activation parameter of a kind takes the restored value and any
-        // further one falls back to its own default -- LSTMLayer's `recurrentActivation` (sigmoid
-        // gates) must not be handed `activation` (tanh cell state). A required second activation
-        // slot has no value to fall back to and is reported by ADN0053.
-        var scalarActivationBound = false;
-        var vectorActivationBound = false;
+        // Activation slots are ordinal per kind. LayerBase records the distinct activation objects
+        // exposed by the layer and its immediate registered children in the same order, which lets
+        // a composite preserve both hidden and output activations without per-layer backing fields.
+        // The old one-per-kind gate silently defaulted every second activation.
+        var scalarActivationIndex = 0;
+        var vectorActivationIndex = 0;
 
         foreach (var p in ctor.Parameters)
         {
             var info = new ParamModel { Name = p.Name, TypeFqn = p.Type.ToDisplayString(FullyQualified) };
 
-            if (HasStateAttribute(p))
+            // Membership rather than the attribute: `marked` is the attributed set when there is
+            // one and the inferred set otherwise, so this one condition serves both. Testing
+            // HasStateAttribute here instead would collect inferred parameters above and then emit
+            // none of them -- the change would appear applied and do nothing.
+            if (inferredState.Contains(p.Name))
             {
                 info.IsState = true;
+                info.IsOptionalState = p.IsOptional;
+                if (p.IsOptional) info.DefaultExpression = RenderDefault(p);
                 info.Key = StateKey(p) ?? p.Name;
+                info.OmitWhenNonPositive = OmitWhenNonPositive(p);
                 info.Kind = Classify(p.Type);
                 if (info.Kind == ValueKind.Unsupported)
                 {
@@ -200,8 +318,12 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
                     return model;
                 }
 
-                info.BackingMember = FindBackingMember(type, p, out var needsConvert, out var memberIsNullable);
+                info.BackingMember = FindBackingMember(
+                    type, p, ctx.SemanticModel, syntax,
+                    out var needsConvert, out var memberIsNullable);
                 info.NeedsConvert = needsConvert;
+                info.IsNullable = IsNullableType(p.Type);
+                info.BackingMemberIsNullable = memberIsNullable;
                 if (info.BackingMember is null)
                 {
                     model.Diagnostics.Add(new PendingDiagnostic(
@@ -210,29 +332,34 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
                     return model;
                 }
 
-                // An `int?` parameter is fine when the layer stores it as a plain `int`, which is the
-                // common case. A nullable BACKING member is not: LayerStateBag.Format has no nullable
-                // overload and the format cannot express null.
-                if (memberIsNullable)
-                {
-                    model.Diagnostics.Add(new PendingDiagnostic(
-                        UnsupportedType, SpanFor(p, model),
-                        type.Name, p.Name, p.Type.ToDisplayString()));
-                    return model;
-                }
             }
-            else if (IsActivation(p.Type, out var vector)
-                && !(vector ? vectorActivationBound : scalarActivationBound))
+            else if (IsActivation(p.Type, out var vector))
             {
                 info.IsActivation = true;
                 info.IsVectorActivation = vector;
+                if (p.IsOptional) info.DefaultExpression = RenderDefault(p);
+
+                // Prefer the constructor argument's own stored member when one exists. Composite
+                // layers frequently expose LayerBase.ScalarActivation as Identity while storing a
+                // different activation for an internal FFN (PreLNTransformerBlock is the canonical
+                // case). Binding such an argument to ordered slot zero silently reconstructed GELU
+                // as Identity. The ordered channel remains the fallback for composites whose
+                // constructor activation is represented only by child layers.
+                info.BackingMember = FindBackingMember(
+                    type, p, ctx.SemanticModel, syntax,
+                    out _, out _);
+                if (info.BackingMember is not null)
+                {
+                    info.UseBackedActivation = true;
+                    info.Key = StateKey(p) ?? p.Name;
+                }
                 if (vector)
                 {
-                    vectorActivationBound = true;
+                    info.ActivationIndex = vectorActivationIndex++;
                 }
                 else
                 {
-                    scalarActivationBound = true;
+                    info.ActivationIndex = scalarActivationIndex++;
                 }
             }
             else if (p.IsOptional)
@@ -241,6 +368,22 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
                 // Taken from the symbol, so the emitted argument is the value the
                 // constructor signature actually promises.
                 info.DefaultExpression = RenderDefault(p);
+
+                // Entropy is deliberately NOT construction configuration. A Full clone installs
+                // the original tensors and then applies the requested random-stream semantics;
+                // an Architecture clone needs a fresh initialization. LayerCloning supplies its
+                // derived seed under the reserved key below, so replaying the source constructor's
+                // literal seed would be the wrong behaviour and reporting it as lost state would
+                // tell authors to persist something the clone contract explicitly replaces.
+                if (IsEntropyParameter(p))
+                {
+                    info.UseCloneRandomSeed = true;
+                }
+                else
+                {
+                    model.Diagnostics.Add(new PendingDiagnostic(
+                        PinnedDefault, SpanFor(p, model), type.Name, p.Name));
+                }
             }
             else
             {
@@ -279,11 +422,28 @@ private static bool HasStateAttribute(IParameterSymbol p)
         return string.IsNullOrWhiteSpace(named) ? null : named;
     }
 
+    /// <summary>
+    /// Whether the author declared this parameter's zero to mean "not resolved yet", so the writer
+    /// must skip it rather than save a value the constructor would reject.
+    /// </summary>
+    private static bool OmitWhenNonPositive(IParameterSymbol p)
+    {
+        var attr = p.GetAttributes().FirstOrDefault(a => a.AttributeClass?.ToDisplayString() == StateAttribute);
+        return attr?.NamedArguments.FirstOrDefault(n => n.Key == "OmitWhenNonPositive").Value.Value is true;
+    }
+
     private static ValueKind Classify(ITypeSymbol type)
     {
         type = Unwrap(type);
 
         if (type.TypeKind == TypeKind.Enum) return ValueKind.Enum;
+        if (type is ITypeParameterSymbol) return ValueKind.NumericTypeParameter;
+
+        // Owned layer/delegate constructor values exist only on the in-memory channel. Layers must
+        // be cloned recursively (not returned as aliases), while delegates are immutable callable
+        // construction state. Classify these before the general interface component case so an
+        // ILayer<T> parameter cannot quietly reuse the source child.
+        if (IsCloneObject(type)) return ValueKind.CloneObject;
 
         // A pluggable strategy: record which implementation was used and rebuild that one.
         if (type.TypeKind == TypeKind.Interface) return ValueKind.Component;
@@ -291,6 +451,16 @@ private static ValueKind Classify(ITypeSymbol type)
         if (type is IArrayTypeSymbol { Rank: 1 } arr && arr.ElementType.SpecialType == SpecialType.System_Int32)
             return ValueKind.Int32Array;
 
+        if (type is IArrayTypeSymbol { Rank: 1, ElementType: IArrayTypeSymbol { Rank: 1 } row }
+            && row.ElementType.SpecialType == SpecialType.System_Int32)
+            return ValueKind.Int32Jagged;
+
+        if (type is IArrayTypeSymbol { Rank: 1 } enumArray
+            && enumArray.ElementType.TypeKind == TypeKind.Enum)
+            return ValueKind.EnumArray;
+
+        if (IsJsonConfiguration(type)) return ValueKind.JsonObject;
+
         return type.SpecialType switch
         {
             SpecialType.System_Int32 => ValueKind.Int32,
@@ -320,7 +490,102 @@ private static bool IsActivation(ITypeSymbol type, out bool vector)
         return vector || fqn == "AiDotNet.Interfaces.IActivationFunction";
     }
 
-    private static string? FindBackingMember(INamedTypeSymbol type, IParameterSymbol p, out bool needsConvert, out bool memberIsNullable)
+    /// <summary>Whether a fixed compile-time type is safe to round-trip as JSON configuration.</summary>
+    private static bool IsJsonConfiguration(ITypeSymbol type)
+    {
+        if (type is not INamedTypeSymbol named || named.TypeKind != TypeKind.Class
+            || !(named.Name.EndsWith("Config", System.StringComparison.Ordinal)
+                 || named.Name.EndsWith("Options", System.StringComparison.Ordinal)))
+            return false;
+
+        var properties = named.GetMembers().OfType<IPropertySymbol>()
+            .Where(p => !p.IsStatic && !p.IsIndexer && p.DeclaredAccessibility == Accessibility.Public)
+            .Where(p => p.GetMethod is not null && p.SetMethod is not null)
+            .ToList();
+        return properties.Count > 0 && properties.All(p => IsJsonScalar(p.Type));
+    }
+
+    private static bool IsJsonScalar(ITypeSymbol type)
+    {
+        type = Unwrap(type);
+        return type.TypeKind == TypeKind.Enum
+            || type.SpecialType is SpecialType.System_Int32
+                or SpecialType.System_Int64
+                or SpecialType.System_Double
+                or SpecialType.System_Single
+                or SpecialType.System_Boolean
+                or SpecialType.System_String;
+    }
+
+    /// <summary>
+    /// Whether the in-memory construction-object channel can make an independent structural copy.
+    /// </summary>
+    private static bool IsCloneObject(ITypeSymbol type)
+    {
+        if (type.TypeKind == TypeKind.Delegate) return true;
+        if (type is not INamedTypeSymbol named) return false;
+
+        string open = named.ConstructedFrom.ToDisplayString(UnqualifiedGenerics);
+        if (open == "AiDotNet.Tensors.LinearAlgebra.Tensor") return true;
+        if (open is "AiDotNet.Interfaces.ILayer" or "AiDotNet.NeuralNetworks.Layers.LayerBase"
+            || named.AllInterfaces.Any(i =>
+                i.ConstructedFrom.ToDisplayString(UnqualifiedGenerics) == "AiDotNet.Interfaces.ILayer")
+            || DerivesFromLayerBase(named))
+            return true;
+
+        // Composite layer constructors commonly accept IEnumerable<ILayer<T>> while retaining a
+        // private List<ILayer<T>>. Treat every one-argument layer collection abstraction as owned
+        // construction topology, before the general interface classification can reduce it to a
+        // type name. LayerStateBag clones the elements independently in memory and persists the
+        // same allowlisted layer payload for durable restoration.
+        if (named.TypeArguments.Length == 1
+            && IsLayerValue(named.TypeArguments[0])
+            && open is "System.Collections.Generic.IEnumerable"
+                or "System.Collections.Generic.ICollection"
+                or "System.Collections.Generic.IList"
+                or "System.Collections.Generic.IReadOnlyCollection"
+                or "System.Collections.Generic.IReadOnlyList")
+        {
+            return true;
+        }
+
+        // A list supplied to a composite constructor represents owned/shared child structure. The
+        // base cloner duplicates every element (layers through Clone, other stateful components
+        // through their generated/reflected configuration plan) and copies attributed state.
+        return open == "System.Collections.Generic.List";
+    }
+
+    private static bool IsLayerValue(ITypeSymbol type)
+    {
+        if (type is not INamedTypeSymbol named) return false;
+        string open = named.ConstructedFrom.ToDisplayString(UnqualifiedGenerics);
+        return open is "AiDotNet.Interfaces.ILayer" or "AiDotNet.NeuralNetworks.Layers.LayerBase"
+            || named.AllInterfaces.Any(i =>
+                i.ConstructedFrom.ToDisplayString(UnqualifiedGenerics) == "AiDotNet.Interfaces.ILayer")
+            || DerivesFromLayerBase(named);
+    }
+
+    /// <summary>Whether cloning intentionally replaces this optional entropy source.</summary>
+    private static bool IsEntropyParameter(IParameterSymbol parameter)
+    {
+        if (string.Equals(parameter.Name, "seed", System.StringComparison.OrdinalIgnoreCase)
+            && Unwrap(parameter.Type).SpecialType == SpecialType.System_Int32)
+        {
+            return true;
+        }
+
+        return string.Equals(parameter.Name, "random", System.StringComparison.OrdinalIgnoreCase)
+            && Unwrap(parameter.Type).ToDisplayString(FullyQualified)
+                == "global::System.Random";
+    }
+
+    private static string? FindBackingMember(
+        INamedTypeSymbol type,
+        IParameterSymbol p,
+        SemanticModel semanticModel,
+        ConstructorDeclarationSyntax constructor,
+        out bool needsConvert,
+        out bool memberIsNullable)
     {
         needsConvert = false;
         memberIsNullable = false;
@@ -341,10 +606,10 @@ private static bool IsActivation(ITypeSymbol type, out bool vector)
                     switch (member)
                     {
                         case IFieldSymbol f when SameType(f.Type, p.Type):
-                            memberIsNullable = IsNullableValueType(f.Type);
+                            memberIsNullable = IsNullableType(f.Type);
                             return f.Name;
                         case IPropertySymbol { GetMethod: not null } prop when SameType(prop.Type, p.Type):
-                            memberIsNullable = IsNullableValueType(prop.Type);
+                            memberIsNullable = IsNullableType(prop.Type);
                             return prop.Name;
 
                         // Layers routinely keep a numeric constructor argument converted to their
@@ -361,9 +626,62 @@ private static bool IsActivation(ITypeSymbol type, out bool vector)
             }
         }
 
+        // Names are a convention, not a contract. Resolve the member the constructor actually
+        // assigns from this parameter so `_epsilon = Normalize(epsilon)`, `_config = config ??
+        // Default`, and differently-named legacy fields remain generator-owned state rather than
+        // requiring one-off annotations in every layer. The left side must be a readable member on
+        // the layer and its type must be the same after unwrapping Nullable<T>; assignments hidden
+        // in lambdas are ignored because they need not run during construction.
+        foreach (var assignment in constructor.DescendantNodes().OfType<AssignmentExpressionSyntax>())
+        {
+            if (!assignment.IsKind(SyntaxKind.SimpleAssignmentExpression)
+                || assignment.Ancestors().Any(a => a is AnonymousFunctionExpressionSyntax))
+                continue;
+
+            bool readsParameter = assignment.Right.DescendantNodesAndSelf()
+                .OfType<IdentifierNameSyntax>()
+                .Any(id => SymbolEqualityComparer.Default.Equals(
+                    semanticModel.GetSymbolInfo(id).Symbol, p));
+            if (!readsParameter) continue;
+
+            var assigned = semanticModel.GetSymbolInfo(assignment.Left).Symbol;
+            switch (assigned)
+            {
+                case IFieldSymbol field
+                    when IsMemberOnLayerHierarchy(field.ContainingType, type)
+                        && SameType(field.Type, p.Type):
+                    memberIsNullable = IsNullableType(field.Type);
+                    return field.Name;
+                case IPropertySymbol { GetMethod: not null, IsIndexer: false } property
+                    when IsMemberOnLayerHierarchy(property.ContainingType, type)
+                        && SameType(property.Type, p.Type):
+                    memberIsNullable = IsNullableType(property.Type);
+                    return property.Name;
+                case IFieldSymbol numericField
+                    when IsMemberOnLayerHierarchy(numericField.ContainingType, type)
+                        && IsNumericTypeParameter(numericField.Type, p.Type, type):
+                    needsConvert = true;
+                    return numericField.Name;
+                case IPropertySymbol { GetMethod: not null, IsIndexer: false } numericProperty
+                    when IsMemberOnLayerHierarchy(numericProperty.ContainingType, type)
+                        && IsNumericTypeParameter(numericProperty.Type, p.Type, type):
+                    needsConvert = true;
+                    return numericProperty.Name;
+            }
+        }
+
         return null;
     }
 
+    private static bool IsMemberOnLayerHierarchy(INamedTypeSymbol? memberType, INamedTypeSymbol layerType)
+    {
+        for (var current = layerType; current is not null; current = current.BaseType)
+        {
+            if (SymbolEqualityComparer.Default.Equals(current, memberType)) return true;
+        }
+        return false;
+    }
+
     /// <summary>True when the member is held as THE LAYER'S numeric type parameter.</summary>
     /// <remarks>
     /// WHICH type parameter is the whole question, and the old test did not ask it:
@@ -386,11 +704,14 @@ or SpecialType.System_Single
     }
 
     private static bool SameType(ITypeSymbol a, ITypeSymbol b)
-        => Unwrap(a).ToDisplayString(FullyQualified) == Unwrap(b).ToDisplayString(FullyQualified);
+        => SymbolEqualityComparer.Default.Equals(
+            Unwrap(a).WithNullableAnnotation(NullableAnnotation.None),
+            Unwrap(b).WithNullableAnnotation(NullableAnnotation.None));
 
-    /// <summary>True for <c>Nullable&lt;T&gt;</c>, whose null the metadata format cannot represent.</summary>
-    private static bool IsNullableValueType(ITypeSymbol type)
-        => type is INamedTypeSymbol { OriginalDefinition.SpecialType: SpecialType.System_Nullable_T };
+    /// <summary>True when the saved member can carry null and the format must preserve that fact.</summary>
+    private static bool IsNullableType(ITypeSymbol type)
+        => type is INamedTypeSymbol { OriginalDefinition.SpecialType: SpecialType.System_Nullable_T }
+            || (type.IsReferenceType && type.NullableAnnotation == NullableAnnotation.Annotated);
 
     /// <summary>Strips <c>Nullable&lt;T&gt;</c> so an <c>int?</c> parameter matches an <c>int</c> field.</summary>
     private static ITypeSymbol Unwrap(ITypeSymbol type)
@@ -403,14 +724,21 @@ private static string Pascal(string name)
 
     private static void Emit(SourceProductionContext spc, ImmutableArray<LayerModel> models)
     {
-        foreach (var d in models.SelectMany(m => m.Diagnostics).Select(d => d.ToDiagnostic()))
-        {
-            spc.ReportDiagnostic(d);
-        }
-
-        // One constructor per type: if a layer annotates several, the first by source order wins so
-        // the generated factory is deterministic.
-        var byType = models
+        // One constructor per type: if a layer offers several, the one that RESTORES THE MOST wins,
+        // with source order kept only as the final tie-break.
+        //
+        // Source order alone chose the constructor that happened to be written first, which is not a
+        // statement about fidelity. A layer whose narrow convenience overload precedes its fuller one
+        // had the narrow one selected and every parameter only the fuller one carries was dropped from
+        // the save with no diagnostic -- the factory still compiled and still returned a layer, just a
+        // differently-configured one. FeatureTokenizerLayer(embeddingDim) at line 102 beat
+        // FeatureTokenizerLayer([LayerState] numFeatures, [LayerState] embeddingDim) at line 116, so a
+        // restored tokenizer kept numFeatures = -1, never allocated its [F,E] weights, reported
+        // ParameterCount 0, and let SetParameters discard 512 trained values in silence.
+        //
+        // Explicit [LayerState] outranks inference because it is an author's claim about which
+        // constructor rebuilds the layer, and inference is only this generator's guess.
+        var candidatesByType = models
             .Where(m => m.IsValid)
             .GroupBy(TypeKey, System.StringComparer.Ordinal)
             // DETERMINISTIC. `g.First()` took whatever order Collect() yielded, and Roslyn
@@ -419,11 +747,49 @@ private static void Emit(SourceProductionContext spc, ImmutableArray<LayerModel>
             // constructors could generate a different factory between builds. Ordering on the
             // constructor's own location also makes "first by source order" true.
             .Select(g => g
-                .OrderBy(m => m.Location.FilePath, System.StringComparer.Ordinal)
+                .OrderByDescending(m => m.HasExplicitState)
+                .ThenByDescending(m => m.StateCount)
+                .ThenBy(m => m.Location.FilePath, System.StringComparer.Ordinal)
                 .ThenBy(m => m.Location.Start)
-                .First())
-            .OrderBy(TypeKey, System.StringComparer.Ordinal)
+                .ToList())
+            .OrderBy(g => TypeKey(g[0]), System.StringComparer.Ordinal)
             .ToList();
+        var byType = candidatesByType.Select(g => g[0]).ToList();
+
+        // A required positive dimension can coexist with a lazy convenience constructor that
+        // omits it. The live object then legitimately stores the dimension sentinel as zero even
+        // after its tensors have materialized (BatchNormalizationLayer is the canonical case).
+        // Infer the existing OmitWhenNonPositive contract only when another generated constructor
+        // for the same type can rebuild without that key; ordinary zero-valued state such as axis
+        // remains serialized exactly.
+        foreach (var candidates in candidatesByType)
+        {
+            var writer = candidates[0];
+            foreach (var parameter in writer.Parameters.Where(p =>
+                         p.IsState && p.Kind == ValueKind.Int32 && IsPositiveDimensionName(p.Name)))
+            {
+                if (candidates.Any(candidate => candidate.Parameters.All(p =>
+                        !p.IsState || !string.Equals(p.Key, parameter.Key, System.StringComparison.Ordinal))))
+                {
+                    parameter.OmitWhenNonPositive = true;
+                }
+            }
+        }
+
+        // Diagnostics on a valid constructor describe the factory that is actually emitted, not
+        // every convenience overload on the type. Reporting them before selection made a correct
+        // wide constructor fail ADN0057 because a narrower forwarding overload pinned a value the
+        // generated factory never consumed (PatchGANDiscriminator.receptiveField is one example).
+        // Invalid candidates still report: an explicit [LayerState] claim must not disappear just
+        // because another overload happens to be usable.
+        var selected = new HashSet<LayerModel>(byType);
+        foreach (var model in models.Where(m => !m.IsValid || selected.Contains(m)))
+        {
+            foreach (var diagnostic in model.Diagnostics)
+            {
+                spc.ReportDiagnostic(diagnostic.ToDiagnostic());
+            }
+        }
 
         foreach (var model in byType)
         {
@@ -432,11 +798,11 @@ private static void Emit(SourceProductionContext spc, ImmutableArray<LayerModel>
             // both named DenseLayer in different namespaces emitted the same file name and
             // AddSource threw on the duplicate. Derived from the same key the grouping uses.
             // A LAYER THAT SAVES BUT CANNOT BE REBUILT IS REPORTED, not skipped in silence.
-            // The factory registers only single-type-parameter layers, so a non-generic layer
-            // or one declared Foo<T, TState> wrote its [LayerState] values to metadata and had
+            // The factory registers non-generic layers and single-type-parameter layers. A type
+            // declared Foo<T, TState> wrote its [LayerState] values to metadata and had
             // no TryCreate entry: deserialization silently fell back to the shape-inference
             // path this generator was built to replace, which is the -1 bug it fixes.
-            if (model.TypeParameters.Count != 1)
+            if (model.TypeParameters.Count > 1)
             {
                 spc.ReportDiagnostic(Diagnostic.Create(
                     UnsupportedArity, model.Location.ToLocation(), model.TypeName, model.TypeParameters.Count));
@@ -445,7 +811,20 @@ private static void Emit(SourceProductionContext spc, ImmutableArray<LayerModel>
             spc.AddSource($"{HintName(model)}.LayerState.g.cs", SourceText(EmitWriter(model)));
         }
 
-        spc.AddSource("GeneratedLayerFactories.g.cs", SourceText(EmitFactories(byType)));
+        spc.AddSource(
+            "GeneratedLayerFactories.g.cs",
+            SourceText(EmitFactories(candidatesByType.SelectMany(group => group).ToList())));
+    }
+
+    private static bool IsPositiveDimensionName(string name)
+    {
+        string lowered = name.ToLowerInvariant();
+        return lowered.Contains("size") || lowered.Contains("count")
+            || lowered.Contains("feature") || lowered.Contains("dimension")
+            || lowered.EndsWith("dim", System.StringComparison.Ordinal)
+            || lowered.Contains("width") || lowered.Contains("height")
+            || lowered.Contains("depth") || lowered.Contains("channels")
+            || lowered.Contains("heads");
     }
 
     private static Microsoft.CodeAnalysis.Text.SourceText SourceText(string text)
@@ -481,23 +860,102 @@ private static string EmitWriter(LayerModel model)
         sb.AppendLine($"partial class {model.TypeName}{generics}");
         sb.AppendLine("{");
         sb.AppendLine("    /// <inheritdoc/>");
-        sb.AppendLine("    internal override void WriteConstructionState(global::System.Collections.Generic.Dictionary<string, string> __metadata)");
+        sb.AppendLine("    [global::System.CodeDom.Compiler.GeneratedCode(\"AiDotNet.Generators.LayerStateGenerator\", \"1.0.0\")]");
+        sb.AppendLine("    protected override void WriteConstructionState(global::System.Collections.Generic.Dictionary<string, string> __metadata)");
         sb.AppendLine("    {");
         sb.AppendLine("        base.WriteConstructionState(__metadata);");
+        foreach (var p in model.Parameters.Where(p => p.UseBackedActivation))
+        {
+            sb.AppendLine($"        if (this.{p.BackingMember} is not null)");
+            sb.AppendLine("        {");
+            sb.AppendLine($"            __metadata[\"{p.Key}\"] = global::AiDotNet.Serialization.LayerStateBag.FormatType(this.{p.BackingMember});");
+            sb.AppendLine("        }");
+        }
         foreach (var p in model.Parameters.Where(p => p.IsState))
         {
-            if (p.Kind == ValueKind.Component)
+            if (p.Kind is ValueKind.Component or ValueKind.CloneObject)
+            {
+                // A null component is ABSENT state, not an empty type name. Keeping an empty key
+                // made HasAll succeed and selected a vector-activation constructor for a scalar
+                // layer, which then failed while resolving the empty component.
+                sb.AppendLine($"        if (this.{p.BackingMember} is not null)");
+                sb.AppendLine("        {");
+                string componentFormatter = p.Kind == ValueKind.CloneObject
+                    ? "FormatCloneObject"
+                    : "FormatType";
+                sb.AppendLine($"            __metadata[\"{p.Key}\"] = global::AiDotNet.Serialization.LayerStateBag.{componentFormatter}(this.{p.BackingMember});");
+                sb.AppendLine("        }");
+                continue;
+            }
+
+            if (p.Kind == ValueKind.JsonObject)
+            {
+                sb.AppendLine($"        __metadata[\"{p.Key}\"] = global::AiDotNet.Serialization.LayerStateBag.FormatJson(this.{p.BackingMember});");
+                continue;
+            }
+
+            if (p.Kind == ValueKind.EnumArray)
+            {
+                sb.AppendLine($"        __metadata[\"{p.Key}\"] = global::AiDotNet.Serialization.LayerStateBag.FormatEnumArray(this.{p.BackingMember});");
+                continue;
+            }
+
+            if (p.Kind == ValueKind.NumericTypeParameter)
             {
-                sb.AppendLine($"        __metadata[\"{p.Key}\"] = global::AiDotNet.Serialization.LayerStateBag.FormatType(this.{p.BackingMember});");
+                string numeric = model.TypeParameters.Count > 0 ? model.TypeParameters[0] : "T";
+                sb.AppendLine($"        __metadata[\"{p.Key}\"] = global::AiDotNet.Serialization.LayerStateBag.Format(global::AiDotNet.Tensors.Helpers.MathHelper.GetNumericOperations<{numeric}>().ToDouble(this.{p.BackingMember}));");
                 continue;
             }
 
             var read = p.NeedsConvert
                 ? ConvertExpression(p, model.TypeParameters.Count > 0 ? model.TypeParameters[0] : "T")
                 : $"this.{p.BackingMember}";
-            sb.AppendLine($"        __metadata[\"{p.Key}\"] = global::AiDotNet.Serialization.LayerStateBag.Format({read});");
+
+            // A size the layer has not resolved yet is written as NOTHING, not as 0. Saving the 0
+            // produced a state the layer's own constructor rejects ("featureSize must be positive,
+            // got 0"), because for a lazily-shaped layer 0 is the truth and the constructor still
+            // refuses it. Omitting the key makes the generated factory's state.HasAll(...) check
+            // fail, so TryCreate returns false and the caller falls through to the lazy build path,
+            // which is exactly right for a layer with no width yet.
+            if (p.OmitWhenNonPositive)
+            {
+                var positive = p.BackingMemberIsNullable
+                    ? $"this.{p.BackingMember}.HasValue && this.{p.BackingMember}.Value > 0"
+                    : $"this.{p.BackingMember} > 0";
+                var omitFormatter = p.BackingMemberIsNullable ? "FormatNullable" : "Format";
+                sb.AppendLine($"        if ({positive})");
+                sb.AppendLine("        {");
+                sb.AppendLine($"            __metadata[\"{p.Key}\"] = global::AiDotNet.Serialization.LayerStateBag.{omitFormatter}({read});");
+                sb.AppendLine("        }");
+                continue;
+            }
+
+            var formatter = p.BackingMemberIsNullable ? "FormatNullable" : "Format";
+            sb.AppendLine($"        __metadata[\"{p.Key}\"] = global::AiDotNet.Serialization.LayerStateBag.{formatter}({read});");
         }
         sb.AppendLine("    }");
+
+        var components = model.Parameters
+            .Where(p => p.UseBackedActivation
+                || (p.IsState && p.Kind is ValueKind.Component or ValueKind.JsonObject or ValueKind.CloneObject))
+            .ToList();
+        if (components.Count > 0)
+        {
+            sb.AppendLine();
+            sb.AppendLine("    /// <inheritdoc/>");
+            sb.AppendLine("    [global::System.CodeDom.Compiler.GeneratedCode(\"AiDotNet.Generators.LayerStateGenerator\", \"1.0.0\")]");
+            sb.AppendLine("    protected override void WriteConstructionObjects(global::System.Collections.Generic.Dictionary<string, object> __values)");
+            sb.AppendLine("    {");
+            sb.AppendLine("        base.WriteConstructionObjects(__values);");
+            foreach (var p in components)
+            {
+                sb.AppendLine($"        if (this.{p.BackingMember} is object __component_{p.Name})");
+                sb.AppendLine("        {");
+                sb.AppendLine($"            __values[\"{p.Key}\"] = __component_{p.Name};");
+                sb.AppendLine("        }");
+            }
+            sb.AppendLine("    }");
+        }
         sb.AppendLine("}");
         // Close the outer types opened above.
         for (int i = 0; i < model.ContainingTypes.Count; i++)
@@ -553,10 +1011,11 @@ private static string EmitFactories(List<LayerModel> models)
         sb.AppendLine("/// no dimension is inferred from the saved shape and a dynamic axis cannot corrupt a rebuild.");
         sb.AppendLine("/// </remarks>");
         sb.AppendLine("/// <typeparam name=\"T\">The layer's numeric type.</typeparam>");
+        sb.AppendLine("[global::System.CodeDom.Compiler.GeneratedCode(\"AiDotNet.Generators.LayerStateGenerator\", \"1.0.0\")]");
         sb.AppendLine("internal static class GeneratedLayerFactories<T>");
         sb.AppendLine("{");
         sb.AppendLine("    /// <summary>Number of layer types with generated factories.</summary>");
-        sb.AppendLine($"    internal const int Count = {models.Count(m => m.TypeParameters.Count == 1)};");
+        sb.AppendLine($"    internal const int Count = {models.Where(m => m.TypeParameters.Count <= 1).Select(TypeKey).Distinct(System.StringComparer.Ordinal).Count()};");
         sb.AppendLine();
         sb.AppendLine("    /// <summary>Attempts to rebuild a layer of the given open generic type.</summary>");
         sb.AppendLine("    /// <param name=\"genericDefinition\">The layer's open generic type, e.g. <c>typeof(DenseLayer&lt;&gt;)</c>.</param>");
@@ -570,36 +1029,78 @@ private static string EmitFactories(List<LayerModel> models)
         sb.AppendLine("        global::AiDotNet.Serialization.LayerStateBag state,");
         sb.AppendLine("        object? scalarActivation,");
         sb.AppendLine("        object? vectorActivation,");
-        sb.AppendLine("        out object layer)");
+        sb.AppendLine("        out object? layer)");
         sb.AppendLine("    {");
 
-        foreach (var model in models.Where(m => m.TypeParameters.Count == 1))
+        foreach (var candidates in models
+                     .Where(m => m.TypeParameters.Count <= 1)
+                     .GroupBy(TypeKey, System.StringComparer.Ordinal)
+                     .OrderBy(g => g.Key, System.StringComparer.Ordinal))
         {
-            var args = string.Join(", ", model.Parameters.Select(p => Argument(p)));
-            var closed = model.ClosedFqn;
-            var required = model.Parameters
-                .Where(p => p.IsState)
-                .Select(p => "\"" + p.Key + "\"")
+            var first = candidates.First();
+            var ordered = candidates
+                .OrderByDescending(m => m.HasExplicitState)
+                .ThenByDescending(m => m.StateCount)
+                .ThenBy(m => m.Location.FilePath, System.StringComparer.Ordinal)
+                .ThenBy(m => m.Location.Start)
                 .ToList();
+            var closed = first.ClosedFqn;
 
-            sb.AppendLine($"        if (genericDefinition == typeof({model.OpenGenericFqn}))");
+            sb.AppendLine($"        if (genericDefinition == typeof({first.OpenGenericFqn}))");
             sb.AppendLine("        {");
-            if (required.Count > 0)
+
+            foreach (var model in ordered)
             {
-                sb.AppendLine($"            if (!state.HasAll({string.Join(", ", required)}))");
+                var args = string.Join(", ", model.Parameters.Select(p => Argument(p)));
+                var required = model.Parameters
+                    // An optional state slot is absent when its live backing member is null. Requiring
+                    // that omitted key made the factory reject the very constructor whose declared
+                    // default can rebuild it (LambdaLayer's optional backward delegate is the minimal
+                    // example). Required state remains fail-closed.
+                    .Where(p => p.IsState && !p.IsOptionalState)
+                    .Select(p => "state.Has(\"" + p.Key + "\")")
+                    .ToList();
+
+                bool scalar = model.Parameters.Any(p => p.IsActivation && !p.IsVectorActivation);
+                bool vector = model.Parameters.Any(p => p.IsActivation && p.IsVectorActivation);
+                if (scalar)
+                {
+                    required.Add("vectorActivation is null");
+                    var slot = model.Parameters.First(p => p.IsActivation && !p.IsVectorActivation);
+                    if (slot.DefaultExpression is null)
+                        required.Add(slot.UseBackedActivation
+                            ? $"state.Has(\"{slot.Key}\")"
+                            : "scalarActivation is not null || state.Has(\"__aidotnet_scalar_activation_0\")");
+                }
+                else if (vector)
+                {
+                    required.Add("scalarActivation is null");
+                    var slot = model.Parameters.First(p => p.IsActivation && p.IsVectorActivation);
+                    if (slot.DefaultExpression is null)
+                        required.Add("vectorActivation is not null || state.Has(\"__aidotnet_vector_activation_0\")");
+                }
+                else
+                {
+                    required.Add("scalarActivation is null");
+                    required.Add("vectorActivation is null");
+                }
+
+                string condition = required.Count == 0 ? "true" : string.Join(" && ", required);
+                sb.AppendLine($"            if ({condition})");
                 sb.AppendLine("            {");
-                sb.AppendLine("                layer = null!;");
-                sb.AppendLine("                return false;");
+                sb.AppendLine($"                layer = new {closed}({args});");
+                sb.AppendLine("                return true;");
                 sb.AppendLine("            }");
-                sb.AppendLine();
             }
-            sb.AppendLine($"            layer = new {closed}({args});");
-            sb.AppendLine("            return true;");
+
+            sb.AppendLine();
+            sb.AppendLine("            layer = null;");
+            sb.AppendLine("            return false;");
             sb.AppendLine("        }");
             sb.AppendLine();
         }
 
-        sb.AppendLine("        layer = null!;");
+        sb.AppendLine("        layer = null;");
         sb.AppendLine("        return false;");
         sb.AppendLine("    }");
         sb.AppendLine("}");
@@ -614,27 +1115,79 @@ private static string Argument(ParamModel p)
                 ? "global::AiDotNet.Interfaces.IVectorActivationFunction<T>"
                 : "global::AiDotNet.Interfaces.IActivationFunction<T>";
             var source = p.IsVectorActivation ? "vectorActivation" : "scalarActivation";
-            return $"{p.Name}: {source} as {iface}";
+            var kind = p.IsVectorActivation ? "vector" : "scalar";
+            var key = $"__aidotnet_{kind}_activation_{p.ActivationIndex}";
+            if (p.UseBackedActivation) key = p.Key;
+            var fallback = p.ActivationIndex == 0
+                ? $"{source} as {iface}"
+                : p.DefaultExpression ?? "default";
+            var expression = $"state.Has(\"{key}\") "
+                + $"? state.Component<{iface}>(\"{key}\") : {fallback}";
+
+            // The factory predicate proves a required activation exists, but nullable flow state
+            // does not cross the generated if-condition into this separately rendered argument.
+            // Assert only for a required constructor slot; optional/nullable slots retain null.
+            if (p.DefaultExpression is null) expression = $"({expression})!";
+            return $"{p.Name}: {expression}";
+        }
+
+        if (p.UseCloneRandomSeed)
+        {
+            var fallback = p.DefaultExpression ?? "default!";
+            return p.TypeFqn.TrimEnd('?') == "global::System.Random"
+                ? $"{p.Name}: state.Has(\"{CloneRandomSeedKey}\") "
+                    + $"? global::AiDotNet.Tensors.Helpers.RandomHelper.CreateSeededRandom(state.Int32(\"{CloneRandomSeedKey}\")) "
+                    + $": {fallback}"
+                : $"{p.Name}: state.Has(\"{CloneRandomSeedKey}\") "
+                    + $"? state.Int32(\"{CloneRandomSeedKey}\") : {fallback}";
         }
 
         // THE PARAMETER'S DEFAULT, NOT THE TYPE'S. Falls back to `default!` only when the
         // declaration genuinely has no value to render.
         if (p.UseDefault) return $"{p.Name}: {p.DefaultExpression ?? "default!"}";
 
-        var read = p.Kind switch
-        {
-            ValueKind.Int32 => $"state.Int32(\"{p.Key}\")",
-            ValueKind.Int64 => $"state.Int64(\"{p.Key}\")",
-            ValueKind.Double => $"state.Double(\"{p.Key}\")",
-            ValueKind.Single => $"state.Single(\"{p.Key}\")",
-            ValueKind.Boolean => $"state.Boolean(\"{p.Key}\")",
-            ValueKind.String => $"state.String(\"{p.Key}\")",
-            ValueKind.Int32Array => $"state.Int32Array(\"{p.Key}\")",
-            ValueKind.Enum => $"state.Enum<{p.TypeFqn.TrimEnd('?')}>(\"{p.Key}\")",
-            ValueKind.Component => $"state.Component<{p.TypeFqn.TrimEnd('?')}>(\"{p.Key}\")",
+        var read = (p.Kind, p.IsNullable) switch
+        {
+            (ValueKind.Int32, false) => $"state.Int32(\"{p.Key}\")",
+            (ValueKind.Int32, true) => $"state.NullableInt32(\"{p.Key}\")",
+            (ValueKind.Int64, false) => $"state.Int64(\"{p.Key}\")",
+            (ValueKind.Int64, true) => $"state.NullableInt64(\"{p.Key}\")",
+            (ValueKind.Double, false) => $"state.Double(\"{p.Key}\")",
+            (ValueKind.Double, true) => $"state.NullableDouble(\"{p.Key}\")",
+            (ValueKind.Single, false) => $"state.Single(\"{p.Key}\")",
+            (ValueKind.Single, true) => $"state.NullableSingle(\"{p.Key}\")",
+            (ValueKind.Boolean, false) => $"state.Boolean(\"{p.Key}\")",
+            (ValueKind.Boolean, true) => $"state.NullableBoolean(\"{p.Key}\")",
+            (ValueKind.String, false) => $"state.String(\"{p.Key}\")",
+            (ValueKind.String, true) => $"state.NullableString(\"{p.Key}\")",
+            (ValueKind.Int32Array, false) => $"state.Int32Array(\"{p.Key}\")",
+            (ValueKind.Int32Array, true) => $"state.NullableInt32Array(\"{p.Key}\")",
+            (ValueKind.Int32Jagged, _) => $"state.Int32Jagged(\"{p.Key}\")",
+            (ValueKind.EnumArray, _) => $"state.EnumArray<{p.TypeFqn.TrimEnd('?', '[', ']')}>(\"{p.Key}\")",
+            (ValueKind.Enum, false) => $"state.Enum<{p.TypeFqn.TrimEnd('?')}>(\"{p.Key}\")",
+            (ValueKind.Enum, true) => $"state.NullableEnum<{p.TypeFqn.TrimEnd('?')}>(\"{p.Key}\")",
+            (ValueKind.JsonObject, _) => $"state.JsonObject<{p.TypeFqn.TrimEnd('?')}>(\"{p.Key}\")",
+            (ValueKind.CloneObject, _) => $"state.CloneObject<{p.TypeFqn.TrimEnd('?')}>(\"{p.Key}\")",
+            (ValueKind.NumericTypeParameter, _) => $"global::AiDotNet.Tensors.Helpers.MathHelper.GetNumericOperations<T>().FromDouble(state.Double(\"{p.Key}\"))",
+            // Component returns null when the key is absent, which is correct for an optional
+            // slot and a nullable-warning error (CS8604) when the constructor parameter is not
+            // nullable. The factory already guards the whole call with state.HasAll(...), so a
+            // null here means the payload disagreed with the layer AFTER that check passed --
+            // worth an exception naming the key rather than a NullReferenceException from inside
+            // the constructor. Not suppressed with `!`: that would hand the constructor a null and
+            // fail somewhere less informative.
+            (ValueKind.Component, false) when !p.TypeFqn.EndsWith("?", System.StringComparison.Ordinal) =>
+                $"state.Component<{p.TypeFqn}>(\"{p.Key}\") ?? throw new global::System.InvalidOperationException("
+                    + $"\"Saved state for '{p.Key}' is missing or names a type that could not be loaded.\")",
+            (ValueKind.Component, _) => $"state.Component<{p.TypeFqn.TrimEnd('?')}>(\"{p.Key}\")",
             _ => "default!",
         };
 
+        if (p.IsOptionalState)
+        {
+            read = $"state.Has(\"{p.Key}\") ? {read} : {p.DefaultExpression ?? "default!"}";
+        }
+
         return $"{p.Name}: {read}";
     }
 
@@ -668,7 +1221,12 @@ private enum ValueKind
         String,
         Enum,
         Int32Array,
+        Int32Jagged,
+        EnumArray,
         Component,
+        JsonObject,
+        CloneObject,
+        NumericTypeParameter,
     }
 
     /// <summary>The symbol's own span when it has one, else the model's.</summary>
@@ -742,7 +1300,16 @@ private static string TypeKey(LayerModel model)
         if (!p.HasExplicitDefaultValue) return null;
         var v = p.ExplicitDefaultValue;
 
-        if (v is null) return p.Type.IsValueType ? "default" : "null";
+        if (v is null)
+        {
+            // For an unconstrained T? Roslyn reports the explicit `default` value as null, but
+            // `T-value : null` cannot be target-typed back to T?. Spell the type's default out so
+            // both branches of the generated conditional have the same T type. Reference types
+            // retain the literal null promised by their declarations.
+            return p.Type.TypeKind == TypeKind.TypeParameter
+                ? $"default({p.Type.ToDisplayString(FullyQualified).TrimEnd('?')})"
+                : p.Type.IsValueType ? "default" : "null";
+        }
 
         // Enums arrive as their underlying integral value, so the declared enum type is cast
         // back on -- a bare number does not compile against an enum-typed parameter.
@@ -759,7 +1326,13 @@ private static string TypeKey(LayerModel model)
             bool b => b ? "true" : "false",
             string str => SymbolDisplay.FormatLiteral(str, quote: true),
             char c => SymbolDisplay.FormatLiteral(c, quote: true),
+            float f when float.IsNaN(f) => "global::System.Single.NaN",
+            float f when float.IsPositiveInfinity(f) => "global::System.Single.PositiveInfinity",
+            float f when float.IsNegativeInfinity(f) => "global::System.Single.NegativeInfinity",
             float f => f.ToString("R", System.Globalization.CultureInfo.InvariantCulture) + "f",
+            double d when double.IsNaN(d) => "global::System.Double.NaN",
+            double d when double.IsPositiveInfinity(d) => "global::System.Double.PositiveInfinity",
+            double d when double.IsNegativeInfinity(d) => "global::System.Double.NegativeInfinity",
             double d => d.ToString("R", System.Globalization.CultureInfo.InvariantCulture) + "d",
             decimal m => m.ToString(System.Globalization.CultureInfo.InvariantCulture) + "m",
             long l => l.ToString(System.Globalization.CultureInfo.InvariantCulture) + "L",
@@ -774,8 +1347,14 @@ private sealed class ParamModel
         public string Key = string.Empty;
         public string? BackingMember;
         public bool IsState;
+        /// <summary>Whether an inferred/declared state slot has a constructor default.</summary>
+        public bool IsOptionalState;
         public bool IsActivation;
         public bool IsVectorActivation;
+        /// <summary>Whether this activation has an exact constructor-argument backing member.</summary>
+        public bool UseBackedActivation;
+        /// <summary>Zero-based position among scalar or vector activation constructor slots.</summary>
+        public int ActivationIndex;
         public bool UseDefault;
         /// <summary>The parameter's DECLARED default rendered as C#, or null if it has none.</summary>
         /// <remarks>
@@ -786,7 +1365,18 @@ private sealed class ParamModel
         /// </remarks>
         public string? DefaultExpression;
         public bool NeedsConvert;
+        /// <summary>Whether the clone adapter supplies a derived entropy seed for this slot.</summary>
+        public bool UseCloneRandomSeed;
+        /// <summary>Whether the readable backing member itself can carry null.</summary>
+        public bool IsNullable;
+        /// <summary>Whether the writer's member, as opposed to the constructor parameter, can be null.</summary>
+        public bool BackingMemberIsNullable;
         public ValueKind Kind;
+
+        /// <summary>
+        /// The author declared that a zero here means "not resolved yet", so the writer guards it.
+        /// </summary>
+        public bool OmitWhenNonPositive;
     }
 
     /// <summary>A location reduced to primitives, so it neither roots a Compilation nor breaks equality.</summary>
@@ -923,6 +1513,12 @@ private sealed class LayerModel : System.IEquatable<LayerModel>
         public bool HasHandWrittenMetadata;
         public bool IsValid;
 
+        /// <summary>Whether this constructor's state came from [LayerState], not from inference.</summary>
+        public bool HasExplicitState;
+
+        /// <summary>How much construction state rebuilding through this constructor restores.</summary>
+        public int StateCount => Parameters.Count(p => p.IsState);
+
         /// <summary>Value equality, which is what lets Roslyn cache this pipeline step.</summary>
         /// <remarks>
         /// Reference equality on a mutable class means two structurally identical models from
@@ -938,6 +1534,7 @@ public bool Equals(LayerModel? other)
                 && TypeName == other.TypeName
                 && BaseFqn == other.BaseFqn
                 && IsPartial == other.IsPartial
+                && HasExplicitState == other.HasExplicitState
                 && HasHandWrittenMetadata == other.HasHandWrittenMetadata
                 && IsValid == other.IsValid
                 && Location.Equals(other.Location)
diff --git a/src/AiDotNet.Generators/ModelParameterGenerator.cs b/src/AiDotNet.Generators/ModelParameterGenerator.cs
index 6ba9718f6b..ac463082c4 100644
--- a/src/AiDotNet.Generators/ModelParameterGenerator.cs
+++ b/src/AiDotNet.Generators/ModelParameterGenerator.cs
@@ -55,6 +55,8 @@ public class ModelParameterGenerator : IIncrementalGenerator
     private const string ExtraTensorsHook = "GetExtraTrainableTensors";
     private const string ExtraLayersHook = "GetExtraTrainableLayers";
     private const string RebindLayerAliasesHook = "RebindLayerAliases";
+    private const string AdditionalLayerGroupsHook = "GetGeneratedAdditionalLayerGroups";
+    private const string NestedNetworkLayerViewsHook = "GetGeneratedNestedNetworkLayerViews";
 
     public void Initialize(IncrementalGeneratorInitializationContext context)
     {
@@ -126,6 +128,8 @@ private static void Execute(Compilation compilation,
             bool emitTensors = onNetworkTrunk && !DeclaresOwn(classSymbol, ExtraTensorsHook);
             bool emitLayers = onNetworkTrunk && !DeclaresOwn(classSymbol, ExtraLayersHook);
             bool emitLayerAliasRebinding = onNetworkTrunk && !DeclaresLayerAliasRebinding(classSymbol);
+            bool publishesFlatParameterGradients = PublishesFlatParameterGradients(classSymbol);
+            bool publishesParameterGradients = PublishesParameterGradients(classSymbol);
             if (!hasRegistry && !emitTensors && !emitLayers && !emitLayerAliasRebinding) continue;
 
             if (!processed.Add(classSymbol.ToDisplayString())) continue;
@@ -134,7 +138,12 @@ private static void Execute(Compilation compilation,
             {
                 var tensors = new List<string>();
                 var layerGroups = new List<string>();
+                var nestedNetworkLayerViews = new List<string>();
+                var additionalLayerGroups = new List<string>();
                 var layerAliasRebinders = new List<string>();
+                var layerAliasCopiers = new List<string>();
+                var trainableTensorCopiers = new List<string>();
+                var ownedTensorEnumerators = new List<string>();
                 var persistentFields = new List<(string Name, string SourceExpression, string Role, string Availability)>();
                 foreach (var member in classSymbol.GetMembers())
                 {
@@ -146,8 +155,14 @@ private static void Execute(Compilation compilation,
                         {
                             var rebinder = LayerAliasRebinderFor(tf, elem);
                             if (rebinder is not null) layerAliasRebinders.Add(rebinder);
+                            var copier = LayerAliasCopierFor(tf, elem);
+                            if (copier is not null) layerAliasCopiers.Add(copier);
                         }
+                        var additionalGroup = AdditionalLayerGroupFor(tf, elem, classSymbol);
+                        if (additionalGroup is not null) additionalLayerGroups.Add(additionalGroup);
                         var classification = ParameterMemberSemanticModel.Classify(tf);
+                        var trainableCopier = TrainableTensorCopierFor(tf, elem, classification.Kind);
+                        if (trainableCopier is not null) trainableTensorCopiers.Add(trainableCopier);
                         if (IsNonOptimizerPersistentState(classification.Kind) && hasRegistry)
                         {
                             var persistentSource = SourceExpressionFor(
@@ -168,6 +183,19 @@ private static void Execute(Compilation compilation,
                         {
                             var nestedTensors = NestedNetworkTensorAccessorFor(tf.Type, tf.Name, elem);
                             if (nestedTensors is not null) tensors.Add(nestedTensors);
+                            if (publishesParameterGradients)
+                            {
+                                var ownedEnumerator = OwnedTensorEnumeratorAccessorFor(
+                                    tf.Type, tf.Name, elem);
+                                if (ownedEnumerator is not null)
+                                    ownedTensorEnumerators.Add(ownedEnumerator);
+                            }
+                            if (publishesFlatParameterGradients)
+                            {
+                                var nestedRecord = NestedParameterRecordTensorAccessorFor(
+                                    tf.Type, tf.Name, elem);
+                                if (nestedRecord is not null) tensors.Add(nestedRecord);
+                            }
                         }
                         var tensorAccessor = classification.Kind == ParameterMemberSemanticModel.Kind.Trainable
                             ? TensorAccessorFor(tf.Type, tf.Name, elem)
@@ -178,8 +206,11 @@ private static void Execute(Compilation compilation,
                             continue;
                         }
                         if (!emitLayers) continue;
-                        var acc = LayerAccessorFor(tf.Type, tf.Name, elem);
+                        var nestedNetworkLayers = NestedNetworkLayerAccessorFor(tf.Type, tf.Name, elem);
+                        var acc = nestedNetworkLayers ?? LayerAccessorFor(tf.Type, tf.Name, elem);
                         if (acc is not null) layerGroups.Add(acc);
+                        if (nestedNetworkLayers is not null)
+                            nestedNetworkLayerViews.Add(nestedNetworkLayers);
                     }
                     else if (member is IPropertySymbol tp)
                     {
@@ -190,9 +221,15 @@ private static void Execute(Compilation compilation,
                         {
                             var rebinder = LayerAliasRebinderFor(tp, elem);
                             if (rebinder is not null) layerAliasRebinders.Add(rebinder);
+                            var copier = LayerAliasCopierFor(tp, elem);
+                            if (copier is not null) layerAliasCopiers.Add(copier);
                         }
+                        var additionalGroup = AdditionalLayerGroupFor(tp, elem, classSymbol);
+                        if (additionalGroup is not null) additionalLayerGroups.Add(additionalGroup);
                         if (!emitLayers) continue;
                         var classification = ParameterMemberSemanticModel.Classify(tp);
+                        var trainableCopier = TrainableTensorCopierFor(tp, elem, classification.Kind);
+                        if (trainableCopier is not null) trainableTensorCopiers.Add(trainableCopier);
                         if (IsNonOptimizerPersistentState(classification.Kind) && hasRegistry)
                         {
                             var persistentSource = SourceExpressionFor(
@@ -213,6 +250,19 @@ private static void Execute(Compilation compilation,
                         {
                             var nestedTensors = NestedNetworkTensorAccessorFor(tp.Type, tp.Name, elem);
                             if (nestedTensors is not null) tensors.Add(nestedTensors);
+                            if (publishesParameterGradients)
+                            {
+                                var ownedEnumerator = OwnedTensorEnumeratorAccessorFor(
+                                    tp.Type, tp.Name, elem);
+                                if (ownedEnumerator is not null)
+                                    ownedTensorEnumerators.Add(ownedEnumerator);
+                            }
+                            if (publishesFlatParameterGradients)
+                            {
+                                var nestedRecord = NestedParameterRecordTensorAccessorFor(
+                                    tp.Type, tp.Name, elem);
+                                if (nestedRecord is not null) tensors.Add(nestedRecord);
+                            }
                         }
                         if (classification.Kind == ParameterMemberSemanticModel.Kind.Trainable)
                         {
@@ -224,17 +274,39 @@ private static void Execute(Compilation compilation,
                             }
                         }
                         if (classification.IsDeclared) continue;
-                        var acc = LayerAccessorFor(tp.Type, tp.Name, elem);
+                        var nestedNetworkLayers = NestedNetworkLayerAccessorFor(tp.Type, tp.Name, elem);
+                        var acc = nestedNetworkLayers ?? LayerAccessorFor(tp.Type, tp.Name, elem);
                         if (acc is not null) layerGroups.Add(acc);
+                        if (nestedNetworkLayers is not null)
+                            nestedNetworkLayerViews.Add(nestedNetworkLayers);
                     }
                 }
 
-                if (tensors.Count > 0 || layerGroups.Count > 0 || layerAliasRebinders.Count > 0)
+                // Publishing model-owned gradients is an explicit claim that the class owns an
+                // optimizer surface. Recover unclassified, non-null numeric storage not already
+                // admitted by attributes, then append nested records that expose their own stable
+                // EnumerateTensors contract. Attribute-backed tensors retain declaration order;
+                // inferred storage follows them, matching the model's checked gradient surface.
+                if (emitTensors && publishesParameterGradients)
+                {
+                    if (!publishesFlatParameterGradients
+                        || (tensors.Count == 0 && layerGroups.Count == 0
+                            && additionalLayerGroups.Count == 0))
+                    {
+                        tensors.AddRange(InferredFlatGradientTensorAccessors(classSymbol, elem));
+                    }
+                    tensors.AddRange(ownedTensorEnumerators);
+                }
+
+                if (tensors.Count > 0 || layerGroups.Count > 0 || layerAliasRebinders.Count > 0
+                    || layerAliasCopiers.Count > 0 || trainableTensorCopiers.Count > 0
+                    || additionalLayerGroups.Count > 0)
                 {
                     context.AddSource(
                         HintName(classSymbol) + ".ModelExtraTensors.g.cs",
                         GenerateExtraTensorsSource(
-                            classSymbol, elem, tensors, layerGroups, layerAliasRebinders));
+                            classSymbol, elem, tensors, layerGroups, nestedNetworkLayerViews, layerAliasRebinders,
+                            layerAliasCopiers, trainableTensorCopiers, additionalLayerGroups));
                 }
                 if (persistentFields.Count > 0)
                 {
@@ -248,6 +320,7 @@ private static void Execute(Compilation compilation,
 
             var fields = new List<(string Name, string SourceExpression, string Role, string Availability)>();
             var components = new List<(string Name, string SourceExpression, string Role, string Availability)>();
+            var manualRegistrations = ParameterMemberSemanticModel.GetRegistrationClassifications(classSymbol);
             foreach (var member in classSymbol.GetMembers())
             {
                 // A member that IS a parameterized component, or a collection of them. Every
@@ -256,14 +329,28 @@ private static void Execute(Compilation compilation,
                 // discovery. The collection form is re-read on each access rather than snapshotted,
                 // because members are routinely added after the one lazy registration has run.
                 var classification = ParameterMemberSemanticModel.Classify(member);
+                if (manualRegistrations.ContainsKey(member.Name))
+                {
+                    // One owner per member. Legacy RegisterComponents overrides remain valid while
+                    // they are migrated, but the generated chain must never register the same
+                    // storage a second time. The semantic analyzer separately validates conflicts.
+                    continue;
+                }
+
+                var memberType = MemberType(member);
                 if (member is IFieldSymbol or IPropertySymbol
                     && !member.IsStatic && !member.IsImplicitlyDeclared
+                    && memberType is not null
+                    // Tensor/Matrix/Vector implement IParameterSource<T> as a convenience, but they
+                    // are raw numeric STORAGE rather than nested model components. Their role must
+                    // be declared explicitly and is handled by SourceExpressionFor below.
+                    && !ParameterMemberSemanticModel.IsNumericStateStorage(memberType)
                     && classification.Kind is not ParameterMemberSemanticModel.Kind.Scratch
                         and not ParameterMemberSemanticModel.Kind.Alias
                         and not ParameterMemberSemanticModel.Kind.External
                         and not ParameterMemberSemanticModel.Kind.Conflicting)
                 {
-                    var kind = ComponentKindFor(MemberType(member), elem);
+                    var kind = ComponentKindFor(memberType, elem);
                     if (kind == "one")
                     {
                         components.Add((member.Name,
@@ -409,7 +496,11 @@ private static bool InheritsExtraTensorsHook(INamedTypeSymbol type)
 
     private static string GenerateExtraTensorsSource(INamedTypeSymbol classSymbol, string elem,
                                                      List<string> tensors, List<string> layerGroups,
-                                                     List<string> layerAliasRebinders)
+                                                     List<string> nestedNetworkLayerViews,
+                                                     List<string> layerAliasRebinders,
+                                                     List<string> layerAliasCopiers,
+                                                     List<string> trainableTensorCopiers,
+                                                     List<string> additionalLayerGroups)
     {
         var sb = OpenPartial(classSymbol, out var closers);
 
@@ -424,6 +515,7 @@ private static string GenerateExtraTensorsSource(INamedTypeSymbol classSymbol, s
             sb.AppendLine("    /// rather than yielded -- an unfitted model has no weights there yet. Declare");
             sb.AppendLine($"    /// {ExtraTensorsHook}() by hand to take ownership and this disappears.");
             sb.AppendLine("    /// </remarks>");
+            sb.AppendLine("    [global::System.CodeDom.Compiler.GeneratedCode(\"AiDotNet.Generators.ModelParameterGenerator\", \"1.0.0\")]");
             sb.AppendLine($"    protected override global::System.Collections.Generic.IEnumerable<Tensor<{elem}>> {ExtraTensorsHook}()");
             sb.AppendLine("    {");
             sb.AppendLine($"        foreach (var __t in base.{ExtraTensorsHook}()) yield return __t;");
@@ -459,6 +551,7 @@ private static string GenerateExtraTensorsSource(INamedTypeSymbol classSymbol, s
             sb.AppendLine("    /// twice in ParameterCount and emit them twice from GetParameters.");
             sb.AppendLine("    /// </para>");
             sb.AppendLine("    /// </remarks>");
+            sb.AppendLine("    [global::System.CodeDom.Compiler.GeneratedCode(\"AiDotNet.Generators.ModelParameterGenerator\", \"1.0.0\")]");
             sb.AppendLine("    protected override global::System.Collections.Generic.IEnumerable<"
                           + "global::AiDotNet.NeuralNetworks.Layers.LayerBase<" + elem + ">?> GetExtraTrainableLayers()");
             sb.AppendLine("    {");
@@ -494,6 +587,25 @@ private static string GenerateExtraTensorsSource(INamedTypeSymbol classSymbol, s
             sb.AppendLine("    }");
         }
 
+        if (nestedNetworkLayerViews.Count > 0)
+        {
+            sb.AppendLine();
+            sb.AppendLine("    /// <summary>Auto-generated live layer views owned by nested networks.</summary>");
+            sb.AppendLine("    [global::System.CodeDom.Compiler.GeneratedCode(\"AiDotNet.Generators.ModelParameterGenerator\", \"1.0.0\")]");
+            sb.AppendLine("    protected override global::System.Collections.Generic.IEnumerable<"
+                          + "global::AiDotNet.Interfaces.ILayer<" + elem + ">?> "
+                          + NestedNetworkLayerViewsHook + "()");
+            sb.AppendLine("    {");
+            foreach (var group in nestedNetworkLayerViews)
+            {
+                sb.AppendLine($"        foreach (var __layer in {group})");
+                sb.AppendLine("        {");
+                sb.AppendLine("            yield return __layer;");
+                sb.AppendLine("        }");
+            }
+            sb.AppendLine("    }");
+        }
+
         if (layerAliasRebinders.Count > 0)
         {
             if (tensors.Count > 0 || layerGroups.Count > 0) sb.AppendLine();
@@ -501,6 +613,7 @@ private static string GenerateExtraTensorsSource(INamedTypeSymbol classSymbol, s
             sb.AppendLine("    /// Auto-generated: rebinds named fields and collection views when the canonical");
             sb.AppendLine("    /// <c>Layers</c> graph is replaced by deserialization or eager cloning.");
             sb.AppendLine("    /// </summary>");
+            sb.AppendLine("    [global::System.CodeDom.Compiler.GeneratedCode(\"AiDotNet.Generators.ModelParameterGenerator\", \"1.0.0\")]");
             sb.AppendLine($"    protected override void {RebindLayerAliasesHook}(");
             sb.AppendLine($"        global::System.Collections.Generic.IReadOnlyList<global::AiDotNet.Interfaces.ILayer<{elem}>> previousLayers,");
             sb.AppendLine($"        global::System.Collections.Generic.IReadOnlyList<global::AiDotNet.Interfaces.ILayer<{elem}>> replacementLayers)");
@@ -511,6 +624,64 @@ private static string GenerateExtraTensorsSource(INamedTypeSymbol classSymbol, s
             sb.AppendLine("    }");
         }
 
+        if (layerAliasCopiers.Count > 0)
+        {
+            if (tensors.Count > 0 || layerGroups.Count > 0 || layerAliasRebinders.Count > 0)
+                sb.AppendLine();
+            sb.AppendLine("    /// <summary>");
+            sb.AppendLine("    /// Auto-generated: transfers the source model's canonical-layer alias map to a clone");
+            sb.AppendLine("    /// whose canonical Layers graph has already been reconstructed.");
+            sb.AppendLine("    /// </summary>");
+            sb.AppendLine("    [global::System.CodeDom.Compiler.GeneratedCode(\"AiDotNet.Generators.ModelParameterGenerator\", \"1.0.0\")]");
+            sb.AppendLine("    protected override void CopyGeneratedLayerAliasesTo(");
+            sb.AppendLine($"        global::AiDotNet.NeuralNetworks.NeuralNetworkBase<{elem}> destination)");
+            sb.AppendLine("    {");
+            sb.AppendLine("        base.CopyGeneratedLayerAliasesTo(destination);");
+            sb.AppendLine($"        if (destination is not {classSymbol.ToDisplayString()} __destination)");
+            sb.AppendLine("            throw new global::System.InvalidOperationException(\"Generated layer aliases can only be copied between models of the same concrete type.\");");
+            foreach (var copier in layerAliasCopiers)
+                sb.AppendLine("        " + copier);
+            sb.AppendLine("    }");
+        }
+
+        if (trainableTensorCopiers.Count > 0)
+        {
+            if (tensors.Count > 0 || layerGroups.Count > 0 || layerAliasRebinders.Count > 0
+                || layerAliasCopiers.Count > 0)
+                sb.AppendLine();
+            sb.AppendLine("    /// <summary>");
+            sb.AppendLine("    /// Auto-generated: transfers model-owned trainable tensors that live outside Layers.");
+            sb.AppendLine("    /// </summary>");
+            sb.AppendLine("    [global::System.CodeDom.Compiler.GeneratedCode(\"AiDotNet.Generators.ModelParameterGenerator\", \"1.0.0\")]");
+            sb.AppendLine("    protected override void CopyGeneratedTrainableTensorsTo(");
+            sb.AppendLine($"        global::AiDotNet.NeuralNetworks.NeuralNetworkBase<{elem}> destination)");
+            sb.AppendLine("    {");
+            sb.AppendLine("        base.CopyGeneratedTrainableTensorsTo(destination);");
+            sb.AppendLine($"        if (destination is not {classSymbol.ToDisplayString()} __destination)");
+            sb.AppendLine("            throw new global::System.InvalidOperationException(\"Generated trainable tensors can only be copied between models of the same concrete type.\");");
+            foreach (var copier in trainableTensorCopiers)
+                sb.AppendLine("        " + copier);
+            sb.AppendLine("    }");
+        }
+
+        if (additionalLayerGroups.Count > 0)
+        {
+            if (tensors.Count > 0 || layerGroups.Count > 0 || layerAliasRebinders.Count > 0
+                || layerAliasCopiers.Count > 0 || trainableTensorCopiers.Count > 0)
+                sb.AppendLine();
+            sb.AppendLine("    /// <summary>");
+            sb.AppendLine("    /// Auto-generated: describes stable layer-member groups so the base can rebuild");
+            sb.AppendLine("    /// fitted auxiliary topology during save/load without a model serialization hook.");
+            sb.AppendLine("    /// </summary>");
+            sb.AppendLine("    [global::System.CodeDom.Compiler.GeneratedCode(\"AiDotNet.Generators.ModelParameterGenerator\", \"1.0.0\")]");
+            sb.AppendLine("    protected override global::System.Collections.Generic.IEnumerable<GeneratedAdditionalLayerGroup> " + AdditionalLayerGroupsHook + "()");
+            sb.AppendLine("    {");
+            sb.AppendLine("        foreach (var __group in base." + AdditionalLayerGroupsHook + "()) yield return __group;");
+            foreach (var group in additionalLayerGroups)
+                sb.AppendLine("        yield return " + group + ";");
+            sb.AppendLine("    }");
+        }
+
         sb.AppendLine("}");
         for (int i = 0; i < closers; i++) sb.AppendLine("}");
         return sb.ToString();
@@ -531,6 +702,13 @@ private static string GenerateExtraTensorsSource(INamedTypeSymbol classSymbol, s
     {
         var bare = type.WithNullableAnnotation(NullableAnnotation.NotAnnotated);
 
+        // A model helper may own a real layer graph without itself being a LayerBase. Detection
+        // backbones commonly encapsulate stages this way and expose the ownership boundary through
+        // a conventional zero-argument EnumerateLayers method. Consume that declaration just like a
+        // direct layer field so optimizer, checkpoint and clone surfaces all see one graph.
+        if (HasConventionalLayerEnumerator(bare, elem))
+            return $"{name}.EnumerateLayers()";
+
         // A sub-network: yield the layers it owns.
         for (var c = bare as INamedTypeSymbol; c is not null; c = c.BaseType)
         {
@@ -568,6 +746,14 @@ private static string GenerateExtraTensorsSource(INamedTypeSymbol classSymbol, s
         }
         if (element is null) return null;
 
+        var concreteElement = element.WithNullableAnnotation(NullableAnnotation.NotAnnotated);
+        if (HasConventionalLayerEnumerator(concreteElement, elem))
+        {
+            string elementName = concreteElement.ToDisplayString();
+            return $"({name} ?? (global::System.Collections.Generic.IEnumerable<{elementName}>)" +
+                   $"global::System.Array.Empty<{elementName}>()).SelectMany(__owner => __owner.EnumerateLayers())";
+        }
+
         // A collection of sub-networks owns a collection of layer collections. Flatten those in
         // the author's stable collection order so multi-scale networks and expert banks do not
         // disappear merely because the network boundary is one level deeper.
@@ -587,6 +773,49 @@ private static string GenerateExtraTensorsSource(INamedTypeSymbol classSymbol, s
         return $"{name} ?? (global::System.Collections.Generic.IEnumerable<{et}>)global::System.Array.Empty<{et}>()";
     }
 
+    /// <summary>Returns the live layer view for a nested network or network collection.</summary>
+    private static string? NestedNetworkLayerAccessorFor(ITypeSymbol type, string name, string elem)
+    {
+        var bare = type.WithNullableAnnotation(NullableAnnotation.NotAnnotated);
+        for (var current = bare as INamedTypeSymbol; current is not null; current = current.BaseType)
+        {
+            if (current.OriginalDefinition.ToDisplayString()
+                .StartsWith("AiDotNet.NeuralNetworks.NeuralNetworkBase<", System.StringComparison.Ordinal))
+                return $"EnumerateNestedNetworkLayers({name})";
+        }
+
+        ITypeSymbol? element = CollectionElementType(bare);
+        if (element is null) return null;
+        element = element.WithNullableAnnotation(NullableAnnotation.NotAnnotated);
+        for (var current = element as INamedTypeSymbol; current is not null; current = current.BaseType)
+        {
+            if (!current.OriginalDefinition.ToDisplayString()
+                    .StartsWith("AiDotNet.NeuralNetworks.NeuralNetworkBase<", System.StringComparison.Ordinal))
+                continue;
+
+            string networkType = element.ToDisplayString();
+            return $"({name} ?? (global::System.Collections.Generic.IEnumerable<{networkType}>)"
+                   + $"global::System.Array.Empty<{networkType}>()).SelectMany(__n => EnumerateNestedNetworkLayers(__n))";
+        }
+
+        return null;
+    }
+
+    private static bool HasConventionalLayerEnumerator(ITypeSymbol type, string elem)
+    {
+        if (type is not INamedTypeSymbol named) return false;
+        foreach (var method in named.GetMembers("EnumerateLayers").OfType<IMethodSymbol>())
+        {
+            if (method.IsStatic || method.Parameters.Length != 0
+                || method.DeclaredAccessibility is not (Accessibility.Public or Accessibility.Internal))
+                continue;
+            var element = CollectionElementType(method.ReturnType)
+                ?.WithNullableAnnotation(NullableAnnotation.NotAnnotated);
+            if (element is not null && IsLayerOf(element, elem)) return true;
+        }
+        return false;
+    }
+
     /// <summary>
     /// An expression yielding raw trainable tensors owned by a nested network. Nested models are a
     /// graph boundary, not a layer-only boundary: omitting their model-owned tensors makes a parent
@@ -620,6 +849,215 @@ private static string GenerateExtraTensorsSource(INamedTypeSymbol classSymbol, s
         return null;
     }
 
+    /// <summary>
+    /// Discovers a collection of nested parameter records from a declaration inside the record.
+    /// </summary>
+    /// <remarks>
+    /// A nested record is opted in by at least one <c>[TrainableParameter]</c> member. Once opted in,
+    /// its non-null public Tensor/Vector properties are storage, not arbitrary model fields; private
+    /// storage still requires the annotation. This is the collection analogue of a layer's generated
+    /// parameter walk and is what lets explicit representations such as Gaussian splats participate
+    /// without a model-owned <c>GetExtraTrainableTensors</c> override.
+    /// </remarks>
+    private static string? NestedParameterRecordTensorAccessorFor(
+        ITypeSymbol collectionType,
+        string name,
+        string elem)
+    {
+        var element = CollectionElementType(collectionType)
+            ?.WithNullableAnnotation(NullableAnnotation.NotAnnotated) as INamedTypeSymbol;
+        if (element is null || element.TypeKind != TypeKind.Class) return null;
+
+        var annotatedStorage = element.GetMembers()
+            .Where(member => ParameterMemberSemanticModel.Classify(member).Kind
+                == ParameterMemberSemanticModel.Kind.Trainable)
+            .ToList();
+        if (annotatedStorage.Count == 0) return null;
+
+        var slots = new List<(string Name, ITypeSymbol Type, int Position)>();
+        foreach (var member in element.GetMembers())
+        {
+            ITypeSymbol? memberType = null;
+            bool include = false;
+            if (member is IFieldSymbol field && !field.IsStatic && !field.IsImplicitlyDeclared)
+            {
+                memberType = field.Type;
+                include = ParameterMemberSemanticModel.Classify(field).Kind
+                    == ParameterMemberSemanticModel.Kind.Trainable
+                    && field.DeclaredAccessibility != Accessibility.Private;
+            }
+            else if (member is IPropertySymbol property
+                && !property.IsStatic && !property.IsIndexer && property.GetMethod is not null
+                && property.DeclaredAccessibility == Accessibility.Public)
+            {
+                memberType = property.Type;
+                include = !AliasesAccessibleAnnotatedStorage(property, annotatedStorage);
+            }
+
+            if (!include || memberType is null
+                || memberType.NullableAnnotation == NullableAnnotation.Annotated
+                || NumericFamilyFor(memberType, elem) is not ("Tensor" or "Vector"))
+            {
+                continue;
+            }
+
+            int position = member.Locations.FirstOrDefault(location => location.IsInSource)
+                ?.SourceSpan.Start ?? int.MaxValue;
+            slots.Add((member.Name, memberType, position));
+        }
+
+        if (slots.Count == 0) return null;
+        slots = slots
+            .OrderBy(slot => ParameterSemanticOrder(slot.Name))
+            .ThenBy(slot => slot.Position)
+            .ToList();
+
+        var expressions = new List<string>(slots.Count);
+        foreach (var slot in slots)
+        {
+            var access = $"__item.{slot.Name}";
+            expressions.Add(NumericFamilyFor(slot.Type, elem) == "Tensor"
+                ? access
+                : $"new Tensor<{elem}>([{access}.Length], {access})");
+        }
+
+        var elementName = element.ToDisplayString();
+        return $"({name} ?? (global::System.Collections.Generic.IEnumerable<{elementName}>)"
+            + $"global::System.Array.Empty<{elementName}>()).SelectMany(__item => "
+            + $"new Tensor<{elem}>?[] {{ {string.Join(", ", expressions)} }})";
+    }
+
+    /// <summary>
+    /// Discovers a nested owned-record collection that explicitly publishes its tensor order.
+    /// </summary>
+    private static string? OwnedTensorEnumeratorAccessorFor(
+        ITypeSymbol collectionType,
+        string name,
+        string elem)
+    {
+        var element = CollectionElementType(collectionType)
+            ?.WithNullableAnnotation(NullableAnnotation.NotAnnotated) as INamedTypeSymbol;
+        if (element is null) return null;
+
+        var enumerator = element.GetMembers("EnumerateTensors")
+            .OfType<IMethodSymbol>()
+            .FirstOrDefault(method => !method.IsStatic && method.Parameters.Length == 0
+                && method.DeclaredAccessibility != Accessibility.Private
+                && CollectionElementType(method.ReturnType) is ITypeSymbol returned
+                && NumericFamilyFor(returned, elem) == "Tensor");
+        if (enumerator is null) return null;
+
+        string elementName = element.ToDisplayString();
+        return $"({name} ?? (global::System.Collections.Generic.IEnumerable<{elementName}>)"
+            + $"global::System.Array.Empty<{elementName}>()).SelectMany(__item => __item.EnumerateTensors())";
+    }
+
+    private static bool AliasesAccessibleAnnotatedStorage(
+        IPropertySymbol property,
+        IReadOnlyList<ISymbol> annotatedStorage)
+    {
+        var annotatedNames = new HashSet<string>(
+            annotatedStorage
+                .Where(member => member.DeclaredAccessibility != Accessibility.Private)
+                .Select(member => member.Name),
+            System.StringComparer.Ordinal);
+        foreach (var syntaxReference in property.DeclaringSyntaxReferences)
+        {
+            if (syntaxReference.GetSyntax() is not PropertyDeclarationSyntax declaration) continue;
+            if (declaration.ExpressionBody?.Expression is IdentifierNameSyntax expression
+                && annotatedNames.Contains(expression.Identifier.ValueText))
+            {
+                return true;
+            }
+
+            if (declaration.AccessorList is null) continue;
+            var getter = declaration.AccessorList.Accessors.FirstOrDefault(accessor =>
+                accessor.Keyword.ValueText == "get");
+            if (getter?.ExpressionBody?.Expression is IdentifierNameSyntax getterExpression
+                && annotatedNames.Contains(getterExpression.Identifier.ValueText))
+            {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    /// <summary>
+    /// Infers direct numeric storage only for a class that explicitly publishes a checked flat
+    /// gradient and has no other discoverable optimizer surface.
+    /// </summary>
+    private static IEnumerable<string> InferredFlatGradientTensorAccessors(
+        INamedTypeSymbol type,
+        string elem)
+    {
+        return type.GetMembers()
+            .Where(member => !member.IsStatic && !member.IsImplicitlyDeclared)
+            .Select(member => (Member: member, Type: MemberType(member)))
+            .Where(candidate => candidate.Type is not null
+                && candidate.Type.NullableAnnotation != NullableAnnotation.Annotated
+                && NumericFamilyFor(candidate.Type, elem) is "Tensor" or "Vector"
+                && ParameterMemberSemanticModel.Classify(candidate.Member).Kind
+                    is ParameterMemberSemanticModel.Kind.Unclassified)
+            .OrderBy(candidate => ParameterSemanticOrder(candidate.Member.Name))
+            .ThenBy(candidate => candidate.Member.Locations
+                .FirstOrDefault(location => location.IsInSource)?.SourceSpan.Start ?? int.MaxValue)
+            .Select(candidate => candidate.Type is null
+                ? null
+                : TensorAccessorFor(candidate.Type, candidate.Member.Name, elem))
+            .Where(accessor => accessor is not null)
+            .Select(accessor => accessor ?? string.Empty);
+    }
+
+    private static bool PublishesFlatParameterGradients(INamedTypeSymbol type)
+        => PublishesParameterGradients(type, flatOnly: true);
+
+    private static bool PublishesParameterGradients(INamedTypeSymbol type)
+        => PublishesParameterGradients(type, flatOnly: false);
+
+    private static bool PublishesParameterGradients(INamedTypeSymbol type, bool flatOnly)
+    {
+        foreach (var syntaxReference in type.DeclaringSyntaxReferences)
+        {
+            if (syntaxReference.GetSyntax() is not ClassDeclarationSyntax declaration) continue;
+            if (declaration.DescendantNodes().OfType<InvocationExpressionSyntax>().Any(invocation =>
+                invocation.Expression switch
+                {
+                    IdentifierNameSyntax identifier =>
+                        identifier.Identifier.ValueText == "PublishFlatParameterGradients"
+                        || (!flatOnly && identifier.Identifier.ValueText == "PublishParameterGradients"),
+                    MemberAccessExpressionSyntax { Name: IdentifierNameSyntax identifier } =>
+                        identifier.Identifier.ValueText == "PublishFlatParameterGradients"
+                        || (!flatOnly && identifier.Identifier.ValueText == "PublishParameterGradients"),
+                    _ => false,
+                }))
+            {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    /// <summary>
+    /// Stable family order for conventional flat-gradient records. It affects ordering only; entry
+    /// into the generated graph still requires the explicit publish/annotation evidence above.
+    /// </summary>
+    private static int ParameterSemanticOrder(string name)
+    {
+        string key = name.TrimStart('_').ToLowerInvariant();
+        if (key.Contains("weight")) return 0;
+        if (key.Contains("position")) return 10;
+        if (key.Contains("rotation")) return 20;
+        if (key.Contains("scale")) return 30;
+        if (key.Contains("opacity")) return 40;
+        if (key.Contains("color")) return 50;
+        if (key.Contains("visible") && key.Contains("bias")) return 60;
+        if (key.Contains("hidden") && key.Contains("bias")) return 70;
+        if (key.Contains("bias")) return 80;
+        return 100;
+    }
+
     /// <summary>
     /// Emits type-safe lifecycle repair for a field/property that may be a view into Layers.
     /// Independent layer ownership is preserved because the base helpers only replace references
@@ -631,6 +1069,11 @@ private static string GenerateExtraTensorsSource(INamedTypeSymbol classSymbol, s
         if (type is null) return null;
         var bare = type.WithNullableAnnotation(NullableAnnotation.NotAnnotated);
 
+        if (IsNeuralNetworkBase(bare))
+        {
+            return $"RebindNestedNetworkCanonicalLayerAliases({member.Name}, previousLayers, replacementLayers, nameof({member.Name}));";
+        }
+
         if (IsLayerOf(bare, elem))
         {
             bool writable = member switch
@@ -655,6 +1098,147 @@ private static string GenerateExtraTensorsSource(INamedTypeSymbol classSymbol, s
         return $"RebindLayerAliasCollection({member.Name}, previousLayers, replacementLayers, nameof({member.Name}));";
     }
 
+    /// <summary>
+    /// Emits one stable auxiliary-layer ownership group. Canonical Layers aliases are filtered by
+    /// the base at runtime; the replacement callback therefore handles only independently-owned
+    /// layers and can rebuild lists whose fitted count differs from the constructor count.
+    /// </summary>
+    private static string? AdditionalLayerGroupFor(
+        ISymbol member,
+        string elem,
+        INamedTypeSymbol owner)
+    {
+        var type = MemberType(member);
+        if (type is null) return null;
+        var bare = type.WithNullableAnnotation(NullableAnnotation.NotAnnotated);
+        string id = owner.ToDisplayString() + "::" + member.Name;
+
+        if (IsLayerOf(bare, elem))
+        {
+            bool writable = member switch
+            {
+                IFieldSymbol field => !field.IsReadOnly,
+                IPropertySymbol property => property.SetMethod is not null && !property.SetMethod.IsInitOnly,
+                _ => false,
+            };
+            bool nullable = ParameterMemberSemanticModel.IsNullable(member);
+            string replace = writable
+                ? nullable
+                    ? $"__layers => {member.Name} = RestoreGeneratedAdditionalLayer({member.Name}, __layers, nameof({member.Name}))"
+                    : $"__layers => {member.Name} = RestoreRequiredGeneratedAdditionalLayer({member.Name}, __layers, nameof({member.Name}))"
+                : "null";
+            return $"new GeneratedAdditionalLayerGroup(\"{id}\", " +
+                   $"() => new global::AiDotNet.Interfaces.ILayer<{elem}>?[] {{ {member.Name} }}, {replace})";
+        }
+
+        if (bare is not INamedTypeSymbol { Name: "List", TypeArguments.Length: 1 } list)
+            return null;
+        var element = list.TypeArguments[0].WithNullableAnnotation(NullableAnnotation.NotAnnotated);
+        if (!IsLayerOf(element, elem)) return null;
+        string elementName = element.ToDisplayString();
+        bool collectionNullable = ParameterMemberSemanticModel.IsNullable(member);
+        bool collectionWritable = member switch
+        {
+            IFieldSymbol field => !field.IsReadOnly,
+            IPropertySymbol property => property.SetMethod is not null && !property.SetMethod.IsInitOnly,
+            _ => false,
+        };
+        string getter = collectionNullable
+            ? $"() => {member.Name} ?? (global::System.Collections.Generic.IEnumerable<{elementName}>)global::System.Array.Empty<{elementName}>()"
+            : $"() => {member.Name}";
+        string collectionReplace = collectionNullable
+            ? collectionWritable
+                ? $"__layers => {member.Name} = RestoreGeneratedAdditionalLayerCollection({member.Name}, __layers, nameof({member.Name}))"
+                : "null"
+            : $"__layers => ReplaceGeneratedAdditionalLayerCollection({member.Name}, __layers, nameof({member.Name}))";
+
+        return $"new GeneratedAdditionalLayerGroup(\"{id}\", {getter}, {collectionReplace})";
+    }
+
+    /// <summary>
+    /// Emits source-driven alias transfer for clone paths. Unlike replacement-time rebinding, this
+    /// also repairs aliases created only after fitting, where a fresh destination has no old alias
+    /// instance whose identity could reveal the canonical layer index.
+    /// </summary>
+    private static string? LayerAliasCopierFor(ISymbol member, string elem)
+    {
+        var type = MemberType(member);
+        if (type is null) return null;
+        var bare = type.WithNullableAnnotation(NullableAnnotation.NotAnnotated);
+
+        // A nested NeuralNetworkBase is a layer-graph view, not an independent serialized copy of
+        // those layers. ModelStateGenerator restores readonly child models in place, which can
+        // replace the child's canonical Layers list after the parent constructor already aliased
+        // that list into its own Layers (SpeakerVerifier is the minimal example). Emit the same
+        // source-driven canonical-index repair used for ordinary layer fields so parent and child
+        // return to one graph before parameters are cloned.
+        if (IsNeuralNetworkBase(bare))
+        {
+            return $"CopyNestedNetworkCanonicalLayerAliases({member.Name}, __destination.{member.Name}, Layers, __destination.Layers, nameof({member.Name}));";
+        }
+
+        if (IsLayerOf(bare, elem))
+        {
+            bool writable = member switch
+            {
+                IFieldSymbol field => !field.IsReadOnly,
+                IPropertySymbol property => property.SetMethod is not null && !property.SetMethod.IsInitOnly,
+                _ => false,
+            };
+            bool nullable = ParameterMemberSemanticModel.IsNullable(member);
+            if (!writable)
+            {
+                return $"ValidateCopiedReadonlyLayerAlias({member.Name}, __destination.{member.Name}, Layers, __destination.Layers, nameof({member.Name}));";
+            }
+
+            return nullable
+                ? $"__destination.{member.Name} = CopyLayerAlias({member.Name}, __destination.{member.Name}, Layers, __destination.Layers, nameof({member.Name}));"
+                : $"__destination.{member.Name} = CopyRequiredLayerAlias({member.Name}, __destination.{member.Name}, Layers, __destination.Layers, nameof({member.Name}));";
+        }
+
+        var element = LayerCollectionElementType(bare);
+        if (element is null || !IsLayerOf(
+                element.WithNullableAnnotation(NullableAnnotation.NotAnnotated), elem))
+            return null;
+
+        return $"CopyLayerAliasCollection({member.Name}, __destination.{member.Name}, Layers, __destination.Layers, nameof({member.Name}));";
+    }
+
+    /// <summary>Emits clone transfer for one explicitly-declared model-owned tensor or vector.</summary>
+    private static string? TrainableTensorCopierFor(
+        ISymbol member,
+        string elem,
+        ParameterMemberSemanticModel.Kind kind)
+    {
+        if (kind != ParameterMemberSemanticModel.Kind.Trainable) return null;
+        var type = MemberType(member);
+        if (type is null) return null;
+        string? family = NumericFamilyFor(type, elem);
+        if (family is not ("Tensor" or "Vector")) return null;
+
+        bool writable = member switch
+        {
+            IFieldSymbol field => !field.IsReadOnly,
+            IPropertySymbol property => property.SetMethod is not null && !property.SetMethod.IsInitOnly,
+            _ => false,
+        };
+        bool nullable = ParameterMemberSemanticModel.IsNullable(member);
+        if (family == "Vector")
+        {
+            return writable
+                ? nullable
+                    ? $"__destination.{member.Name} = CloneGeneratedTrainableVector({member.Name});"
+                    : $"__destination.{member.Name} = CloneRequiredGeneratedTrainableVector({member.Name});"
+                : $"CopyGeneratedTrainableVectorValues({member.Name}, __destination.{member.Name}, nameof({member.Name}));";
+        }
+
+        return writable
+            ? nullable
+                ? $"__destination.{member.Name} = CloneGeneratedTrainableTensor({member.Name});"
+                : $"__destination.{member.Name} = CloneRequiredGeneratedTrainableTensor({member.Name});"
+            : $"CopyGeneratedTrainableTensorValues({member.Name}, __destination.{member.Name}, nameof({member.Name}));";
+    }
+
     /// <summary>Returns the element type for a supported layer collection shape.</summary>
     private static ITypeSymbol? LayerCollectionElementType(ITypeSymbol type)
     {
@@ -941,6 +1525,13 @@ private static bool HasFitAvailability(
         if (NumericFamilyFor(type, elem) == "Tensor")
             return $"new Tensor<{elem}>?[] {{ {name} }}";
 
+        // NeuralNetworkBase's extension hook is tensor-shaped, but a model-owned Vector is valid
+        // trainable storage too. Tensor's vector constructor is a write-through view, so generated
+        // discovery can expose it without a concrete parameter-ownership override.
+        if (NumericFamilyFor(type, elem) == "Vector")
+            return $"{name} is null ? global::System.Array.Empty<Tensor<{elem}>?>() : "
+                + $"new Tensor<{elem}>?[] {{ new Tensor<{elem}>([{name}.Length], {name}) }}";
+
         var element = CollectionElementType(type);
         if (element is not null && NumericFamilyFor(element, elem) == "Tensor")
             return $"global::AiDotNet.Models.Parameters.ParameterCollectionOrdering.PresentNonNull({name})";
@@ -1033,9 +1624,60 @@ private static string AvailabilityExpression(
             }
         }
 
-        return kind == ParameterMemberSemanticModel.Kind.Fitted
-            ? "global::AiDotNet.Models.Parameters.ParameterAvailability.Fit"
-            : "global::AiDotNet.Models.Parameters.ParameterAvailability.Construction";
+        if (kind == ParameterMemberSemanticModel.Kind.Fitted)
+            return "global::AiDotNet.Models.Parameters.ParameterAvailability.Fit";
+
+        // A buffer holding no value at construction is produced by Fit, and calling it
+        // "Construction" is simply false. The distinction is not cosmetic: an ABSENT buffer is
+        // normalized by availability, and Construction sends it to ConditionalAbsent — "an optional
+        // branch that is switched off" — so a freshly built model reported a concrete zero-parameter
+        // surface instead of one whose parameters had not been fitted yet. That is exactly the
+        // ambiguity ParameterCountContractTests rejects, and it failed all eight of the classifiers
+        // that store fit-produced state this way (the five NaiveBayes variants, KNeighbors, Voting,
+        // SelfTraining) while SupportVectorClassifier — structurally identical, but annotated
+        // [Buffer(Availability = Fit)] by hand — passed.
+        //
+        // Derived rather than annotated, for the same reason ParametersAreConstructionSized is: the
+        // declaration already answers the question. A buffer that is nullable and has no initializer
+        // holds null until something assigns it, and for a buffer that something is Fit. Anything
+        // with a construction-time value keeps Construction, so this only reclassifies members for
+        // which Construction could not have been true.
+        if (kind == ParameterMemberSemanticModel.Kind.Buffer && !HasConstructionValue(member))
+            return "global::AiDotNet.Models.Parameters.ParameterAvailability.Fit";
+
+        return "global::AiDotNet.Models.Parameters.ParameterAvailability.Construction";
+    }
+
+    /// <summary>
+    /// Whether a member already holds a value once the constructor has run.
+    /// </summary>
+    /// <remarks>
+    /// Deliberately conservative: it answers true unless the member is BOTH nullable-annotated and
+    /// without an initializer. A non-nullable member always has some value, and an initialized one
+    /// has it before Fit is ever called, so neither can be described as fit-produced.
+    /// </remarks>
+    private static bool HasConstructionValue(ISymbol member)
+    {
+        var nullability = member switch
+        {
+            IFieldSymbol field => field.NullableAnnotation,
+            IPropertySymbol property => property.NullableAnnotation,
+            _ => NullableAnnotation.None
+        };
+
+        if (nullability != NullableAnnotation.Annotated) return true;
+
+        foreach (var reference in member.DeclaringSyntaxReferences)
+        {
+            switch (reference.GetSyntax())
+            {
+                case VariableDeclaratorSyntax { Initializer: not null }:
+                case PropertyDeclarationSyntax { Initializer: not null }:
+                    return true;
+            }
+        }
+
+        return false;
     }
 
     private static string GenerateSource(INamedTypeSymbol classSymbol, string elem,
@@ -1076,6 +1718,7 @@ private static string GenerateSource(INamedTypeSymbol classSymbol, string elem,
         sb.AppendLine("    /// <summary>");
         sb.AppendLine("    /// Auto-generated stable-ID registration for this model's weight-bearing members.");
         sb.AppendLine("    /// </summary>");
+        sb.AppendLine("    [global::System.CodeDom.Compiler.GeneratedCode(\"AiDotNet.Generators.ModelParameterGenerator\", \"1.0.0\")]");
         sb.AppendLine($"    void global::AiDotNet.Models.Parameters.IGeneratedParameterRegistrar<{elem}>.RegisterGeneratedParameters(");
         sb.AppendLine($"        global::AiDotNet.Models.Parameters.ParameterComponentRegistry<{elem}> registry)");
         sb.AppendLine("    {");
@@ -1083,6 +1726,7 @@ private static string GenerateSource(INamedTypeSymbol classSymbol, string elem,
         sb.AppendLine("    }");
         sb.AppendLine();
         sb.AppendLine("    /// <summary>Composes this type's generated parameter fields with inherited fields.</summary>");
+        sb.AppendLine("    [global::System.CodeDom.Compiler.GeneratedCode(\"AiDotNet.Generators.ModelParameterGenerator\", \"1.0.0\")]");
         sb.AppendLine("    protected override void RegisterGeneratedParameterComponents(");
         sb.AppendLine($"        global::AiDotNet.Models.Parameters.ParameterComponentRegistry<{elem}> registry)");
         sb.AppendLine("    {");
diff --git a/src/AiDotNet.Generators/ModelStateGenerator.cs b/src/AiDotNet.Generators/ModelStateGenerator.cs
new file mode 100644
index 0000000000..a0eb89d271
--- /dev/null
+++ b/src/AiDotNet.Generators/ModelStateGenerator.cs
@@ -0,0 +1,1487 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+
+namespace AiDotNet.Generators;
+
+/// <summary>
+/// Emits each model's state declarations into the model, so a model author writes none.
+/// </summary>
+/// <remarks>
+/// <para>
+/// A hand-written <c>RegisterState</c> that lists every field is the same boilerplate as a
+/// hand-written <c>Serialize</c> wearing a different hat: it is common behaviour living in the model,
+/// and it is one more place to forget the field somebody adds next year. The generator already knows
+/// the type's members and already classifies them, so it can write both halves and the author can
+/// write nothing at all.
+/// </para>
+/// <para>
+/// Reuses <see cref="ParameterMemberSemanticModel"/> rather than inventing a second opinion about
+/// what a member is. Its vocabulary already answers the question this generator asks:
+/// <c>Trainable</c> is in the parameter vector and must NOT be written twice; <c>Fitted</c>,
+/// <c>Frozen</c> and <c>Buffer</c> are learned state that the vector does not carry; <c>Scratch</c>
+/// is recomputable; <c>Alias</c> is a view of something else; <c>External</c> belongs to another
+/// runtime. Unclassified numeric state is already an error under AIDN088, which is what makes
+/// "persist everything I can place" safe -- there is nothing it cannot place and silently skip.
+/// </para>
+/// <para>
+/// Emits into a <c>partial</c> declaration, the same way the parameter generator does, because that
+/// is the only way generated code can reach a private field. AIDN085 already establishes that
+/// convention for weights and 1099 types in this library are already partial.
+/// </para>
+/// </remarks>
+[Generator]
+public class ModelStateGenerator : IIncrementalGenerator
+{
+    /// <summary>A model owns state the generator can persist, but is not partial.</summary>
+    private static readonly DiagnosticDescriptor MustBePartial = new(
+        "ADN0061",
+        "Model must be partial for its state to be persisted automatically",
+        "'{0}' owns state that is not in its parameter vector ({1}) but is not declared 'partial', so "
+            + "the state generator cannot reach it and nothing persists it. Add 'partial' and the "
+            + "declarations are written for you",
+        "AiDotNet.Serialization",
+        DiagnosticSeverity.Error,
+        isEnabledByDefault: true);
+
+    /// <summary>State was annotated, and the registry has no way to carry its type.</summary>
+    private static readonly DiagnosticDescriptor UnsupportedStateShape = new(
+        "ADN0062",
+        "Declared state has a shape the registry cannot carry",
+        "'{0}.{1}' is annotated as state but its type '{2}' has no ModelStateRegistry declaration, so "
+            + "nothing would persist it. Add an overload for that shape, or hold the value in one the "
+            + "registry already carries",
+        "AiDotNet.Serialization",
+        DiagnosticSeverity.Error,
+        isEnabledByDefault: true);
+
+    /// <inheritdoc/>
+    public void Initialize(IncrementalGeneratorInitializationContext context)
+    {
+        var candidates = context.SyntaxProvider.CreateSyntaxProvider(
+                predicate: static (node, _) => node is ClassDeclarationSyntax { BaseList: not null },
+                transform: static (ctx, _) =>
+                    ctx.SemanticModel.GetDeclaredSymbol((ClassDeclarationSyntax)ctx.Node) as INamedTypeSymbol)
+            .Where(static symbol => symbol is not null);
+
+        context.RegisterSourceOutput(candidates, static (spc, symbol) => Emit(spc, symbol));
+    }
+
+    private static void Emit(SourceProductionContext spc, INamedTypeSymbol? type)
+    {
+        // A semantic model can legitimately return no declared symbol while the user's
+        // compilation is incomplete. Treat that as no candidate; never assert it away with !.
+        if (type is null) return;
+
+        // ABSTRACT BASES ARE INCLUDED. Skipping them meant state declared on a shared base was never
+        // generated for anyone: every decision-tree model keeps its structure in
+        // DecisionTreeRegressionBase.Root, and no concrete model declares it, so nothing persisted it
+        // and each model wrote its own Serialize to walk the tree by hand. An abstract class can carry
+        // an override perfectly well, and RegisterGeneratedState chains through base calls, so putting
+        // the declaration where the member actually lives is both correct and the only place it can go.
+        if (type.IsStatic) return;
+
+        // The numeric type comes from the base hook's own signature rather than from a guess about
+        // which type parameter is "the" numeric one.
+        var hook = FindHook(type);
+        if (hook is null) return;
+        if (hook.Parameters.Length != 1) return;
+        if (hook.Parameters[0].Type is not INamedTypeSymbol { TypeArguments.Length: 1 } registry) return;
+
+        var numeric = registry.TypeArguments[0].ToDisplayString();
+        bool persistsParametersSeparately = PersistsParametersSeparately(type);
+        bool onNeuralNetworkTrunk = InheritsNeuralNetworkBase(type);
+        bool emitSerializationSurface = NeedsGeneratedSerializationSurface(type);
+
+        // The type that DECLARES the hook cannot also override it. It gets a Core method instead,
+        // which its own hand-written hook calls -- so the class holding the state finally gets
+        // declarations generated for it without disturbing the override chain below it.
+        var declaresHook = SymbolEqualityComparer.Default.Equals(hook.ContainingType, type);
+
+        var members = new List<(string Name, string Call)>();
+        bool hasExplicitState = false;
+        bool hasScratchState = false;
+        var registrations = ParameterMemberSemanticModel.GetRegistrationClassifications(type);
+
+        foreach (var member in type.GetMembers())
+        {
+            if (member.IsStatic || member.IsImplicitlyDeclared) continue;
+
+            var memberType = member switch
+            {
+                IFieldSymbol f when !f.IsConst => f.Type,
+                IPropertySymbol { IsIndexer: false } p when p.GetMethod is not null && p.SetMethod is not null => p.Type,
+                _ => null,
+            };
+            if (memberType is null) continue;
+
+            // NeuralNetworkBase already owns its canonical layer graph and serializes each layer's
+            // layout, parameters and buffers. ModelParameterGenerator also emits the alias rebinding
+            // and extra-layer traversal used by clone/parameter operations. Declaring those same
+            // layer fields here gives them a SECOND persistence owner: canonical aliases are restored
+            // twice, large stacks are duplicated into the state envelope, and a destination whose
+            // runtime layout differs can receive a flat vector meant for the old alias. RWKV exposed
+            // this as an exact 21,120-vs-21,440 parameter mismatch; large diffusion models paid for
+            // the duplicate graph with shard-wide timeouts.
+            //
+            // This exclusion is specific to the neural-network trunk. A sibling model base that owns
+            // a plain list of layers has no canonical graph serializer, so DeclareLayerList remains
+            // its generated persistence mechanism.
+            if (onNeuralNetworkTrunk
+                && (IsLayer(memberType) || IsLayerCollection(memberType)))
+            {
+                continue;
+            }
+
+            // These booleans are lazy-registration LATCHES owned by the framework plumbing, not
+            // model state. Restoring `_componentsRegistered = true` into a fresh instance leaves its
+            // new registry empty while preventing the registration callback from ever running. The
+            // same pattern exists on every model-base trunk, so exclude it once here rather than
+            // requiring every base and every future model family to annotate identical machinery.
+            if (IsRegistryLifecycleLatch(member)) continue;
+
+            // Readonly storage cannot be REASSIGNED on restore, so declaring it would produce a
+            // payload nothing could apply -- true of a vector or a matrix, and false of anything
+            // restored IN PLACE. DeclareChild already fills a readonly child by calling Deserialize
+            // on the instance the constructor built, and DeclareOptions does the same for settings.
+            //
+            // Excluding on mutability alone hid a real defect: KNearestNeighborsRegression holds
+            // `private readonly KNearestNeighborsOptions _options` and answers with _options.K, and
+            // the field was dropped here before anything could ask what it was -- so the payload
+            // carried the training data, not the K, and the model restored and answered differently.
+            // A LIST OF LAYERS belongs with them: DeclareLayerList restores each layer through its own
+            // Deserialize, on the instance the constructor built, so the list reference is never
+            // reassigned and readonly is no obstacle. Excluding it dropped DeepANT's `private readonly
+            // List<ConvLayerTensor<T>> _convLayers` before the type was ever consulted, which is the
+            // same shape as the KNearestNeighbors defect above: the payload carried everything except
+            // the part that decides the answer.
+            // Imperative parameter-component registration is a state-ownership declaration too.
+            // Treating it as unclassified makes the declared-state envelope serialize the same
+            // child a second time after the parameter/clone path has already restored it. That is
+            // both redundant and unsafe for a materialized lazy child whose constructor clone owns
+            // the exact runtime layout.
+            var classification = ParameterMemberSemanticModel.ClassifyWithRegistrations(
+                member, registrations);
+            hasScratchState |= classification.Kind == ParameterMemberSemanticModel.Kind.Scratch;
+            if (member is IFieldSymbol { IsReadOnly: true }
+                && !IsModelOptions(memberType)
+                && !IsSerializableModel(memberType)
+                && !IsSerializableModelList(memberType)
+                && !IsObjectCollection(memberType)
+                && !IsLayerList(memberType)
+                && !CanRestoreReadonlyNumericArray(memberType))
+            {
+                continue;
+            }
+
+            // ONE OWNER PER PIECE OF STATE. A model that still hand-writes its serialization already
+            // carries its layers, so declaring them too would write the same state twice and restore it
+            // twice. The two halves cannot be assumed to agree: a hand-written DeserializeCore
+            // typically rebuilds its layers through a placeholder constructor, so a declared restore
+            // landing on those same layers would be applying trained values to whatever shape the
+            // placeholder happened to have.
+            //
+            // Skipping here makes the migration INCREMENTAL rather than a flag day: deleting a model's
+            // hand-written pair is the single act that switches it onto declared state, with no other
+            // edit and no window in which both mechanisms own the same fields. ADN0060 is what makes
+            // that deletion happen; this is what makes it safe.
+            if (IsLayerList(memberType) && DeclaresHandWrittenSerialization(type))
+            {
+                continue;
+            }
+
+            // OPT-OUT, NOT OPT-IN, and this is the whole reason 330 hand-written Serialize/Deserialize
+            // pairs exist. Requiring [Fitted], [Frozen] or [Buffer] before a member is persisted means
+            // an author who adds a field and annotates nothing gets a model that serialises
+            // incompletely and no error -- so the only way to be sure was to write the pair by hand,
+            // which is two places to forget the same field instead of one. Storage is now persisted by
+            // DEFAULT and a member has to say why it should not be.
+            //
+            // The four exclusions are the ones that would be wrong to persist, not the ones nobody
+            // annotated:
+            //   Trainable  already in the parameter vector; writing it again would restore it twice
+            //   Scratch    a work buffer whose value between calls means nothing
+            //   Alias      another name for a member already carried
+            //   External   not this model's to save
+            // Conflicting is excluded too, because a member carrying contradictory annotations is a
+            // question for AIDN089 to answer rather than something to guess at here.
+            // ModelBase and NeuralNetworkBase have a separate generated parameter registry, so
+            // trainable storage on those trunks must not be written twice. Their legacy sibling
+            // bases do not: their ordinary payload knows only the base fields. On those trunks the
+            // declared-state envelope is the generated persistence mechanism for trainable storage
+            // too. Treating every trunk as if it owned a parameter registry dropped the learned
+            // coefficients from GAMLSS and ZeroInflatedRegression while their clones appeared to
+            // deserialize successfully.
+            bool carryTrainableAsState = classification.Kind == ParameterMemberSemanticModel.Kind.Trainable
+                && !persistsParametersSeparately;
+            bool carryNativePrecisionShadow =
+                (classification.Kind is ParameterMemberSemanticModel.Kind.Trainable
+                    or ParameterMemberSemanticModel.Kind.Fitted
+                    or ParameterMemberSemanticModel.Kind.Frozen
+                    or ParameterMemberSemanticModel.Kind.Buffer)
+                && persistsParametersSeparately
+                && RequiresNativePrecisionShadow(memberType, numeric);
+            if ((classification.Kind == ParameterMemberSemanticModel.Kind.Trainable
+                    && persistsParametersSeparately
+                    && !carryNativePrecisionShadow)
+                || classification.Kind is ParameterMemberSemanticModel.Kind.Scratch
+                or ParameterMemberSemanticModel.Kind.Alias
+                or ParameterMemberSemanticModel.Kind.External
+                or ParameterMemberSemanticModel.Kind.Conflicting)
+            {
+                continue;
+            }
+
+            // Whether somebody ASKED for this member to be state, as opposed to it being swept in by
+            // the default. It decides how loudly an unsupported shape is reported, below.
+            var annotated = classification.Kind is ParameterMemberSemanticModel.Kind.Fitted
+                or ParameterMemberSemanticModel.Kind.Frozen
+                or ParameterMemberSemanticModel.Kind.Buffer
+                || carryTrainableAsState
+                || carryNativePrecisionShadow;
+
+            // Keyed by DECLARING TYPE and member, not by member alone. A name is unique within one
+            // class and nothing more: VectorAutoRegressionModel and VARMAModel each keep a private
+            // Matrix<T> _residuals, which is ordinary C# and means the derived model's generated
+            // registration met the base's under the same key and threw "State '_residuals' is
+            // already declared". Every model with a field that shares a name with one further up its
+            // own hierarchy had the same fault waiting in it.
+            var call = DeclareCall(member.Name, $"{type.Name}.{member.Name}", memberType, numeric, annotated,
+                nullableTarget: memberType.NullableAnnotation == NullableAnnotation.Annotated
+                    || memberType.IsValueType,
+                restoreInPlace: member is IFieldSymbol { IsReadOnly: true },
+                exactPrecisionShadow: carryNativePrecisionShadow,
+                childFactory: ChildFactoryExpression(type, memberType));
+
+            if (call is null)
+            {
+                // A member the default swept in whose type the registry cannot carry is passed over in
+                // silence, because that is exactly what happened to it before persistence became the
+                // default -- reporting it would turn "no change" into hundreds of new build errors
+                // about members nobody claimed were state. An ANNOTATED member is the opposite case and
+                // is still reported below.
+                if (!annotated) continue;
+
+                // LOUD, NOT SILENT. This member was CLASSIFIED as state -- somebody annotated it --
+                // and the generator cannot express its type. Skipping quietly would drop annotated
+                // state from the payload and produce a model that restores almost everything, which
+                // is the exact failure this work exists to remove. GeneralizedAdditiveModel proved
+                // it: its List<Vector<T>> knots were annotated, silently skipped, and Predict then
+                // refused with "loaded without its fitted knot vectors".
+                spc.ReportDiagnostic(Diagnostic.Create(
+                    UnsupportedStateShape,
+                    member.Locations.FirstOrDefault() ?? type.Locations.FirstOrDefault(),
+                    type.Name,
+                    member.Name,
+                    memberType.ToDisplayString()));
+                continue;
+            }
+
+            members.Add((member.Name, call));
+            hasExplicitState |= annotated;
+        }
+
+        var fittedInfrastructureRepairs = FittedInfrastructureRepairs(type);
+        if (fittedInfrastructureRepairs.Count > 0)
+        {
+            var repair = new StringBuilder();
+            repair.Append($"state.DeclareAfterRestore(\"{type.Name}.$fittedInfrastructure\", () => {{ if (IsFitted) {{ ");
+            foreach (var (field, expression) in fittedInfrastructureRepairs)
+            {
+                repair.Append($"if ({field} is null) {field} = {expression}; ");
+            }
+            repair.Append("} });");
+            members.Add(("$fittedInfrastructure", repair.ToString()));
+        }
+
+        // Scratch caches are deliberately absent from persisted state, but a constructor can fill
+        // them from its fresh parameters before a restore replaces the authoritative fields. A
+        // conventional zero-argument Refresh*Cache(s) method is an existing declaration of how to
+        // rebuild those derived values. Register it after the parameter phase so clone/checkpoint
+        // restoration cannot leave the cache describing the constructor's discarded weights.
+        if (hasScratchState)
+        {
+            foreach (var refresh in type.GetMembers().OfType<IMethodSymbol>()
+                         .Where(method => !method.IsStatic
+                                          && method.Parameters.Length == 0
+                                          && method.TypeParameters.Length == 0
+                                          && method.ReturnsVoid
+                                          && method.Name.StartsWith("Refresh", System.StringComparison.Ordinal)
+                                          && (method.Name.EndsWith("Cache", System.StringComparison.Ordinal)
+                                              || method.Name.EndsWith("Caches", System.StringComparison.Ordinal)))
+                         .OrderBy(method => method.Name, System.StringComparer.Ordinal))
+            {
+                string name = $"{type.Name}.$derivedCache.{refresh.Name}";
+                members.Add(($"$derivedCache.{refresh.Name}",
+                    $"state.DeclareAfterParameterRestore(\"{name}\", {refresh.Name});"));
+            }
+        }
+
+        // A declaring type ALWAYS gets its Core method, even empty: its hand-written hook calls it
+        // unconditionally, so omitting it would leave that call with no target.
+        if (members.Count == 0 && !declaresHook && !emitSerializationSurface) return;
+
+        // The type AND everything containing it. A nested partial can only be reopened inside partial
+        // outers, so reporting only the inner one would name a fix that does not compile on its own.
+        for (var scope = type; scope is not null; scope = scope.ContainingType)
+        {
+            if (IsPartial(scope)) continue;
+
+            // The opt-out sweep is an automation benefit for types already participating in source
+            // generation, not a flag-day migration for every legacy type in the assembly. An
+            // explicitly annotated state member must still fail loudly when generation is
+            // impossible; an unannotated collection on a non-partial legacy type keeps its previous
+            // behavior until that type opts in by becoming partial.
+            if (!hasExplicitState) return;
+
+            spc.ReportDiagnostic(Diagnostic.Create(
+                MustBePartial,
+                scope.Locations.FirstOrDefault(),
+                scope.Name,
+                string.Join(", ", members.Select(m => m.Name))));
+            return;
+        }
+
+        spc.AddSource($"{type.ToDisplayString().Replace('<', '_').Replace('>', '_').Replace(',', '_')}.State.g.cs",
+            Render(type, numeric, members, declaresHook, emitSerializationSurface));
+    }
+
+    /// <summary>Whether a field is one of the framework's lazy registry initialization latches.</summary>
+    private static bool IsRegistryLifecycleLatch(ISymbol member)
+        => member is IFieldSymbol { Type.SpecialType: SpecialType.System_Boolean }
+           && member.Name is "_componentsRegistered" or "_declaredStateRegistered" or "_stateRegistered";
+
+    /// <summary>Whether this hierarchy persists trainable storage outside declared model state.</summary>
+    private static bool PersistsParametersSeparately(INamedTypeSymbol type)
+    {
+        for (var current = type; current is not null; current = current.BaseType)
+        {
+            if (current.GetMembers("RegisterGeneratedParameterComponents")
+                .OfType<IMethodSymbol>()
+                .Any(method => method.Parameters.Length == 1))
+            {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    /// <summary>Whether the type inherits the canonical neural-network graph owner.</summary>
+    private static bool InheritsNeuralNetworkBase(INamedTypeSymbol type)
+    {
+        for (var current = type; current is not null; current = current.BaseType)
+        {
+            if (current.OriginalDefinition.ToDisplayString()
+                .StartsWith("AiDotNet.NeuralNetworks.NeuralNetworkBase<", System.StringComparison.Ordinal))
+            {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    /// <summary>
+    /// Whether an abstract public serializer can be implemented by delegating to common protected
+    /// base helpers. The capability is detected structurally, so the generator does not know or care
+    /// which model-family base supplies it.
+    /// </summary>
+    private static bool NeedsGeneratedSerializationSurface(INamedTypeSymbol type)
+    {
+        if (type.IsAbstract) return false;
+        if (type.GetMembers().OfType<IMethodSymbol>().Any(method =>
+            method.Name is "Serialize" or "Deserialize"))
+        {
+            return false;
+        }
+
+        bool hasSerializeHelper = false;
+        bool hasDeserializeHelper = false;
+        bool hasAbstractSerialize = false;
+        bool hasAbstractDeserialize = false;
+
+        for (var current = type.BaseType; current is not null; current = current.BaseType)
+        {
+            foreach (var method in current.GetMembers().OfType<IMethodSymbol>())
+            {
+                hasSerializeHelper |= method.Name == "SerializeGeneratedModelState"
+                    && method.Parameters.Length == 0
+                    && method.ReturnType is IArrayTypeSymbol
+                    {
+                        ElementType.SpecialType: SpecialType.System_Byte,
+                    };
+                hasDeserializeHelper |= method.Name == "DeserializeGeneratedModelState"
+                    && method.Parameters.Length == 1
+                    && method.Parameters[0].Type is IArrayTypeSymbol
+                    {
+                        ElementType.SpecialType: SpecialType.System_Byte,
+                    };
+                hasAbstractSerialize |= method.Name == "Serialize"
+                    && method.IsAbstract
+                    && method.Parameters.Length == 0;
+                hasAbstractDeserialize |= method.Name == "Deserialize"
+                    && method.IsAbstract
+                    && method.Parameters.Length == 1
+                    && method.Parameters[0].Type is IArrayTypeSymbol
+                    {
+                        ElementType.SpecialType: SpecialType.System_Byte,
+                    };
+            }
+        }
+
+        return hasSerializeHelper && hasDeserializeHelper
+            && hasAbstractSerialize && hasAbstractDeserialize;
+    }
+
+    /// <summary>True when the member is itself something that can serialize its own state.</summary>
+    private static bool IsSerializableModel(ITypeSymbol type)
+    {
+        if (type.AllInterfaces.Any(i => i.Name is "IModelSerializer" or "IFullModel" or "INeuralNetwork")
+            || type.Name is "IModelSerializer" or "IFullModel" or "INeuralNetwork")
+        {
+            return true;
+        }
+
+        return false;
+    }
+
+    /// <summary>Whether the type still persists state by hand, and so already owns its layers.</summary>
+    /// <remarks>
+    /// Checks the type's OWN members, not inherited ones: an inherited hook is the base doing the work,
+    /// which is exactly the state this asks about being declared rather than hand-written.
+    /// </remarks>
+    private static bool DeclaresHandWrittenSerialization(INamedTypeSymbol type)
+        => type.GetMembers().Any(m => m is IMethodSymbol
+        {
+            Name: "SerializeCore" or "DeserializeCore"
+                or "SerializeModelSpecificData" or "DeserializeModelSpecificData"
+                or "SerializeNetworkSpecificData" or "DeserializeNetworkSpecificData",
+        });
+
+    /// <summary>Whether a type is a <c>List</c> of layers, which restores in place.</summary>
+    private static bool IsLayerList(ITypeSymbol type)
+        => type is INamedTypeSymbol { Name: "List", TypeArguments.Length: 1 } list
+           && IsLayer(list.TypeArguments[0]);
+
+    /// <summary>Whether a supported collection carries layers.</summary>
+    private static bool IsLayerCollection(ITypeSymbol type)
+    {
+        if (type is IArrayTypeSymbol array) return IsLayer(array.ElementType);
+        if (type is not INamedTypeSymbol { TypeArguments.Length: 1 } collection) return false;
+
+        if (collection.Name is not ("List" or "IList" or "IReadOnlyList" or "IEnumerable"
+            or "ICollection" or "IReadOnlyCollection"))
+        {
+            return false;
+        }
+
+        return IsLayer(collection.TypeArguments[0]);
+    }
+
+    /// <summary>Whether a list carries nested models through their own serialization contract.</summary>
+    private static bool IsSerializableModelList(ITypeSymbol type)
+        => type is INamedTypeSymbol { Name: "List", TypeArguments.Length: 1 } list
+           && IsSerializableModel(list.TypeArguments[0]);
+
+    /// <summary>Whether a collection can be cleared and refilled through its readonly reference.</summary>
+    private static bool IsObjectCollection(ITypeSymbol type)
+        => type is INamedTypeSymbol { TypeArguments.Length: > 0 } named
+           && named.Name is "List" or "Dictionary";
+
+    /// <summary>
+    /// Numeric arrays own mutable contents even when their field reference is readonly. The state
+    /// registry has explicit in-place readers for these shapes, so readonly is not a reason to drop
+    /// them from generated persistence.
+    /// </summary>
+    private static bool CanRestoreReadonlyNumericArray(ITypeSymbol type)
+        => IsDoubleArray(type) || IsJaggedDoubleArray(type);
+
+    /// <summary>
+    /// A flat Vector&lt;T&gt; checkpoint cannot preserve a double-backed working value when T is float.
+    /// Emit a post-vector precision shadow for the CLR-double shapes the parameter generator owns.
+    /// Closed double models need no duplicate because their public vector is already lossless.
+    /// </summary>
+    private static bool RequiresNativePrecisionShadow(ITypeSymbol type, string numeric)
+        => numeric != "double"
+           && (type.SpecialType == SpecialType.System_Double
+               || IsDoubleArray(type)
+               || IsJaggedDoubleArray(type));
+
+    private static bool IsDoubleArray(ITypeSymbol type)
+        => type is IArrayTypeSymbol
+        {
+            Rank: 1,
+            ElementType.SpecialType: SpecialType.System_Double
+        };
+
+    private static bool IsJaggedDoubleArray(ITypeSymbol type)
+        => type is IArrayTypeSymbol
+        {
+            Rank: 1,
+            ElementType: IArrayTypeSymbol
+            {
+                Rank: 1,
+                ElementType.SpecialType: SpecialType.System_Double
+            }
+        };
+
+    /// <summary>Whether a type is a layer, i.e. derives from LayerBase.</summary>
+    /// <remarks>
+    /// Tested by walking the base chain rather than by interface, because a layer's identity is its
+    /// base class: ILayer is implemented by wrappers and adapters that are not themselves storage, and
+    /// DeclareLayerList restores THROUGH LayerBase.Serialize/Deserialize, so the declaration is only
+    /// sound for something that actually inherits that pair.
+    /// </remarks>
+    private static bool IsLayer(ITypeSymbol type)
+    {
+        for (var t = type as INamedTypeSymbol; t is not null; t = t.BaseType)
+        {
+            if (t.Name == "LayerBase") return true;
+        }
+
+        return false;
+    }
+
+    /// <summary>Finds the inherited hook this generator overrides, and with it the numeric type.</summary>
+    private static IMethodSymbol? FindHook(INamedTypeSymbol type)
+    {
+        // Starts at the TYPE so a class that declares the hook is recognised as the root of its
+        // hierarchy. Safe because every hook is HAND-WRITTEN and therefore visible here; a marker
+        // that lived only in generated source would be invisible to the generator, which is why
+        // deleting the hooks made every derived type look like a root and broke the chain.
+        for (var current = type; current is not null; current = current.BaseType)
+        {
+            var hook = current.GetMembers("RegisterGeneratedState").OfType<IMethodSymbol>().FirstOrDefault();
+            if (hook is not null) return hook;
+        }
+
+        return null;
+    }
+
+    /// <summary>Maps a member's type onto the registry call that persists it.</summary>
+    /// <remarks>
+    /// Returns null for a shape the registry cannot express. That is deliberately silent HERE and
+    /// loud elsewhere: AIDN088 already refuses to let numeric state go unclassified, so a member that
+    /// reaches this point and has no mapping is a container the registry has not learned yet, and the
+    /// model keeps its own declaration until it does.
+    /// </remarks>
+    private static string? DeclareCall(
+        string name,
+        string id,
+        ITypeSymbol memberType,
+        string numeric,
+        bool annotated,
+        bool nullableTarget,
+        bool restoreInPlace,
+        bool exactPrecisionShadow,
+        string? childFactory)
+    {
+        // A nullable value type has a state the registry cannot express: "not set" is not a number,
+        // and the getter cannot hand an int? to something expecting an int. MOMENT proved it -- the
+        // display string had its '?' trimmed before matching, so an int? matched the int case and the
+        // generated lambda would not compile. Declining is the honest answer; inventing a zero for it
+        // would silently turn "never configured" into "configured to zero" on every round trip.
+        if (memberType is INamedTypeSymbol { OriginalDefinition.SpecialType: SpecialType.System_Nullable_T })
+        {
+            return null;
+        }
+
+        // A NULLABLE `T?` IS THE SAME SITUATION. DeclareScalar takes Func<T>, and no Func<T?> overload
+        // can sit beside it because for an unconstrained T the two differ only by nullability. A getter
+        // for a `T?` member therefore returns a possible null into a non-null contract, and the registry
+        // has no way to say "not set" for it. Declining is the same honest answer given to Nullable<T>
+        // above: ClusteringBase.Inertia and NeuralNetworkBase.LastLoss are exactly this shape and
+        // neither was persisted before.
+        if (memberType is ITypeParameterSymbol
+            && memberType.NullableAnnotation == NullableAnnotation.Annotated)
+        {
+            return null;
+        }
+
+        // Namespaces stripped before matching. The display string is fully qualified, so
+        // List<AiDotNet.Tensors.LinearAlgebra.Vector<T>> does not end with "List<Vector<T>>" and a
+        // naive suffix test silently declined it -- which is how the knots got dropped.
+        var display = memberType.ToDisplayString().TrimEnd('?');
+        var key = System.Text.RegularExpressions.Regex
+            .Replace(display, @"\b[A-Za-z_][A-Za-z0-9_]*\.", string.Empty)
+            .Replace($"<{numeric}>", "<T>");
+
+        // A non-nullable field cannot be handed a null, and the null-forgiving operator is not an
+        // option here -- AIDN071 rejects it precisely because it suppresses the question rather than
+        // answering it. So a null in the payload leaves the constructed value in place, which is the
+        // honest reading: the saving model had nothing there to restore.
+        var setter = nullableTarget
+            ? $"v => {name} = v"
+            : $"v => {{ if (v is not null) {name} = v; }}";
+        var getter = $"() => {name}";
+
+        // The public parameter vector is typed as T. A float model whose implementation keeps
+        // double working weights therefore cannot make a bit-identical checkpoint through that
+        // vector alone. These declarations are a precision shadow, restored in a distinct phase
+        // after the vector; they are generated from the storage type and require no model hook.
+        if (exactPrecisionShadow)
+        {
+            return key switch
+            {
+                "double" => $"state.DeclareExactDouble(\"{id}\", {getter}, {setter});",
+                "double[]" when restoreInPlace =>
+                    $"state.DeclareExactInPlace(\"{id}\", {getter});",
+                "double[]" => $"state.DeclareExact(\"{id}\", {getter}, {setter});",
+                "double[][]" when restoreInPlace =>
+                    $"state.DeclareExactInPlace(\"{id}\", {getter});",
+                "double[][]" => $"state.DeclareExact(\"{id}\", {getter}, {setter});",
+                _ => null,
+            };
+        }
+
+        // Numeric collections have purpose-built binary declarations. A readonly field still owns
+        // mutable contents, so select their in-place counterparts before the ordinary switch can
+        // emit a setter that cannot compile. Keeping these on the binary path also avoids routing
+        // Tensor/Matrix/Vector through JSON, which cannot reconstruct their internal storage.
+        if (restoreInPlace)
+        {
+            var inPlaceNumericCollection = key switch
+            {
+                "List<Vector<T>>" or "List<Matrix<T>>" or "List<Tensor<T>>"
+                    or "Dictionary<string, Vector<T>>" or "Dictionary<int, Vector<T>>" =>
+                    $"state.DeclareInPlace(\"{id}\", {getter});",
+                "double[]" or "double[][]" =>
+                    $"state.DeclareInPlace(\"{id}\", {getter});",
+                _ => null,
+            };
+            if (inPlaceNumericCollection is not null) return inPlaceNumericCollection;
+        }
+
+        // A readonly collection owns fitted CONTENTS even though its reference cannot be assigned.
+        // Lists of models and layers retain their purpose-built restore paths; every other list or
+        // dictionary is reconstructed by the registry and copied into the constructor-created
+        // instance. This is what carries known-class tables, nested tree records and per-class
+        // statistics without making the model author write a hook.
+        if (restoreInPlace && IsSerializableModelList(memberType)
+            && memberType is INamedTypeSymbol { TypeArguments.Length: 1 } inPlaceChildList)
+        {
+            return $"state.DeclareChildList<{inPlaceChildList.TypeArguments[0].ToDisplayString().TrimEnd('?')}>(\"{id}\", {getter});";
+        }
+
+        if (restoreInPlace && IsLayerList(memberType)
+            && memberType is INamedTypeSymbol { TypeArguments.Length: 1 } inPlaceLayerList)
+        {
+            return $"state.DeclareLayerList<{inPlaceLayerList.TypeArguments[0].ToDisplayString().TrimEnd('?')}>(\"{id}\", {getter});";
+        }
+
+        if (restoreInPlace && IsObjectCollection(memberType)
+            && IsGeneratedObjectState(memberType, numeric))
+        {
+            return $"state.DeclareObjectInPlace(\"{id}\", {getter});";
+        }
+
+        return key switch
+        {
+            // A DECISION TREE, carried whole instead of walked by hand: the shared hand-written
+            // walk dropped Threshold and the per-leaf LinearModel.
+            var k when k.EndsWith(".DecisionTreeNode<T>") || k == "DecisionTreeNode<T>" =>
+                $"state.DeclareTree(\"{id}\", {getter}, {setter});",
+
+            var k when k.EndsWith(".Vector<T>") || k == "Vector<T>" => $"state.Declare(\"{id}\", {getter}, {setter});",
+            var k when k.EndsWith(".Matrix<T>") || k == "Matrix<T>" => $"state.Declare(\"{id}\", {getter}, {setter});",
+            var k when k.EndsWith(".Tensor<T>") || k == "Tensor<T>" => $"state.Declare(\"{id}\", {getter}, {setter});",
+            "Vector<byte>" => $"state.DeclareByteVector(\"{id}\", {getter}, {setter});",
+            "Vector<double>" => $"state.DeclareDoubleVector(\"{id}\", {getter}, {setter});",
+            "List<Vector<T>>" => $"state.Declare(\"{id}\", {getter}, {setter});",
+            "List<Matrix<T>>" => $"state.Declare(\"{id}\", {getter}, {setter});",
+            "List<Tensor<T>>" => $"state.Declare(\"{id}\", {getter}, {setter});",
+            "Matrix<T>[]" => $"state.Declare(\"{id}\", {getter}, {setter});",
+            "Vector<int>" => $"state.Declare(\"{id}\", {getter}, {setter});",
+            "Dictionary<string, Vector<T>>" => $"state.Declare(\"{id}\", {getter}, {setter});",
+            "Dictionary<int, Vector<T>>" => $"state.Declare(\"{id}\", {getter}, {setter});",
+            "Vector<T>[]" => $"state.Declare(\"{id}\", {getter}, {setter});",
+            "int[]" => $"state.Declare(\"{id}\", {getter}, {setter});",
+            "double[]" => $"state.Declare(\"{id}\", {getter}, {setter});",
+            "T[]" => $"state.DeclareArray(\"{id}\", {getter}, {setter});",
+            "int" => $"state.DeclareInt32(\"{id}\", {getter}, {setter});",
+            "long" => $"state.DeclareInt64(\"{id}\", {getter}, {setter});",
+            "double" => $"state.DeclareDouble(\"{id}\", {getter}, {setter});",
+            "bool" => $"state.DeclareBoolean(\"{id}\", {getter}, {setter});",
+            "string" => $"state.DeclareString(\"{id}\", {getter}, {setter});",
+            "T" => $"state.DeclareScalar(\"{id}\", {getter}, {setter});",
+
+            // A nested model carries its own state through its own Serialize, so the parent only has
+            // to say that it is there. Restored IN PLACE, because the parent builds it and what
+            // travels is its state rather than its identity.
+            // A parameter source keeps its state in a vector rather than a payload.
+            // A RECURSIVE NODE GRAPH -- a decision tree. The registry has carried these all along
+            // through DeclareGraph; nothing could reach it, because describing a node meant writing the
+            // description by hand, which is the boilerplate this work removes rather than relocates.
+            // The node type says everything needed: its own properties give the fields, the ones typed
+            // as itself give the children, and its parameterless constructor gives Create. Eight
+            // tree and ensemble model families hand-wrote a Serialize to walk this structure, and
+            // deleting those pairs without this failed 26 tests -- exactly the silent state loss the
+            // deleter's own design warns about.
+            _ when IsRecursiveNode(memberType, numeric) is { } node => GraphCall(id, name, node, numeric, setter),
+
+            // A fitted forest is the same recursive shape repeated. Its element type describes the
+            // walk; the list count and roots are registry concerns. This carries private tree records
+            // such as DART's without a model-specific SerializeTree/DeserializeTree pair.
+            _ when !restoreInPlace && memberType is INamedTypeSymbol { Name: "List", TypeArguments.Length: 1 } graphList
+                   && IsRecursiveNode(graphList.TypeArguments[0], numeric) is { } graphNode =>
+                GraphListCall(id, name, graphNode, numeric, setter),
+
+            // A node derived from the library's common DecisionTreeNode has children typed as the
+            // base node rather than as its own derived type, so it is not self-recursive in Roslyn's
+            // exact-type sense. Generate the predictive base fields plus derived scalar fields and
+            // cast the child links back to the concrete node type.
+            _ when IsDerivedDecisionTreeNode(memberType) is { } derivedTree =>
+                DerivedDecisionTreeGraphCall(id, name, derivedTree, numeric, setter),
+
+            // THE CHILD PATHS STAY OPT-IN even though storage is now opt-out, and the difference is
+            // real rather than cautious. Storage is state by its nature -- a Matrix<T> a model holds
+            // between calls is something it learned. An object is not: a model also holds its
+            // optimizer, its scheduler, its loss function, and none of those are state to restore.
+            // Sweeping them in on the default is how three networks came to persist a _trainOptimizer
+            // that is never assigned, which the compiler reported as CS0649 and which would have
+            // travelled in every payload as a null. So a nested model is carried when somebody says it
+            // is state, and otherwise left alone.
+            _ when !IsInfrastructure(memberType) && memberType.AllInterfaces.Any(i => i.Name == "IParameterSource")
+                   && !IsSerializableModel(memberType) =>
+                $"state.DeclareParameterSource(\"{id}\", {getter});",
+
+            _ when (!IsInfrastructure(memberType) || IsFittedSerializer(memberType))
+                   && IsSerializableModel(memberType)
+                   && nullableTarget && !restoreInPlace =>
+                childFactory is null
+                    ? $"state.DeclareChild<{memberType.ToDisplayString().TrimEnd('?')}>(\"{id}\", {getter}, {setter});"
+                    : $"state.DeclareChild<{memberType.ToDisplayString().TrimEnd('?')}>(\"{id}\", {getter}, {setter}, {childFactory});",
+
+            _ when (!IsInfrastructure(memberType) || IsFittedSerializer(memberType))
+                   && IsSerializableModel(memberType) =>
+                $"state.DeclareChild<{memberType.ToDisplayString().TrimEnd('?')}>(\"{id}\", {getter});",
+
+            // A list of nested models -- an agent's per-actor target networks, a mixer's per-agent
+            // heads. Same rule as a single child: each carries its own state, restored in place.
+            // A LIST of models is carried by default, unlike a single one, and the split is not
+            // arbitrary. The reason single children stay opt-in is the optimizer a model holds, and an
+            // optimizer is held in a field of its own -- nobody keeps a list of them. A list of models
+            // is an ensemble's members: a random forest IS its trees, and dropping them leaves a
+            // forest that restores with nothing to predict from. RandomForest, DART and
+            // ExtremelyRandomizedTrees all failed their round trip on exactly that.
+            _ when memberType is INamedTypeSymbol { Name: "List", TypeArguments.Length: 1 } list
+                   && IsSerializableModel(list.TypeArguments[0]) =>
+                $"state.DeclareChildList<{list.TypeArguments[0].ToDisplayString().TrimEnd('?')}>(\"{id}\", {getter});",
+
+            // A list of LAYERS the model owns directly. Networks never reach this arm -- their layers
+            // belong to the network base -- but a model on another base that keeps a conv stack or an
+            // encoder stack in a plain List had NO declaration available at all: every other arm wants
+            // a vector, a matrix, a tensor or an IModelSerializer, and a layer is none of those. So the
+            // member was skipped in silence and the layers' learned values travelled nowhere. DeepANT
+            // came back holding the placeholder-shaped convolutions its deserialization constructor
+            // builds -- 96 kernel values collapsed to 1 -- and its prediction changed sign across a
+            // round trip while every other declared member restored perfectly.
+            //
+            // Restored in place, like the child list above: the constructor already builds these at
+            // their configured widths, so only the learned values need to travel.
+            _ when memberType is INamedTypeSymbol { Name: "List", TypeArguments.Length: 1 } layerList
+                   && IsLayer(layerList.TypeArguments[0]) =>
+                $"state.DeclareLayerList<{layerList.TypeArguments[0].ToDisplayString().TrimEnd('?')}>(\"{id}\", {getter});",
+
+            // THE SETTINGS A MODEL PREDICTS WITH, carried for the same reason a list of children is:
+            // they decide the answer. KNearestNeighborsRegression predicts with _options.K, so a
+            // payload holding its training data but not its K restored a model that ran and answered
+            // differently -- the silent kind of wrong. Only scalar settings travel, which
+            // DeclareOptions states and enforces; anything object-shaped is rebuilt by the
+            // constructor the clone plan already replays.
+            _ when IsModelOptions(memberType) =>
+                $"state.DeclareOptions(\"{id}\", {getter});",
+
+            // General fitted object state. The boundary is intentionally structural: arrays,
+            // lists, dictionaries and a model's own nested record/node types are state-shaped;
+            // arbitrary services are not. Nested IModelSerializer values inside these objects use
+            // their canonical byte payload rather than being reduced to public JSON properties.
+            _ when !IsInfrastructure(memberType) && IsGeneratedObjectState(memberType, numeric) =>
+                $"state.DeclareObject(\"{id}\", {getter}, {setter});",
+
+            _ => null,
+        };
+    }
+
+    /// <summary>Whether an assignable member has a generated general-object state representation.</summary>
+    private static bool IsGeneratedObjectState(ITypeSymbol type, string numeric)
+    {
+        if (type is not IArrayTypeSymbol
+            && !IsObjectCollection(type)
+            && type is not INamedTypeSymbol { TypeKind: TypeKind.Class })
+        {
+            return false;
+        }
+
+        return CanCarryObjectState(type, numeric, new HashSet<string>(), depth: 0);
+    }
+
+    /// <summary>
+    /// Proves the JSON-backed fallback can reconstruct the complete reachable public shape.
+    /// </summary>
+    /// <remarks>
+    /// This is deliberately a proof, not a guess. A broad "every List is JSON" rule captured the
+    /// neural-network layer graph, tensor-keyed gradient dictionaries and POCOs containing Matrix,
+    /// all of which Json.NET can write but cannot reconstruct. Declining an unproven shape lets its
+    /// purpose-built base serialization remain the sole owner instead of adding a broken second copy.
+    /// </remarks>
+    private static bool CanCarryObjectState(
+        ITypeSymbol type,
+        string numeric,
+        HashSet<string> visiting,
+        int depth)
+    {
+        if (depth > 24) return false;
+        if (type.NullableAnnotation == NullableAnnotation.Annotated)
+            type = type.WithNullableAnnotation(NullableAnnotation.NotAnnotated);
+
+        if (type is ITypeParameterSymbol) return true;
+        if (type.TypeKind == TypeKind.Enum) return true;
+        if (type.SpecialType is SpecialType.System_Boolean
+            or SpecialType.System_Byte or SpecialType.System_SByte
+            or SpecialType.System_Int16 or SpecialType.System_UInt16
+            or SpecialType.System_Int32 or SpecialType.System_UInt32
+            or SpecialType.System_Int64 or SpecialType.System_UInt64
+            or SpecialType.System_Single or SpecialType.System_Double
+            or SpecialType.System_Decimal or SpecialType.System_Char
+            or SpecialType.System_String)
+        {
+            return true;
+        }
+
+        if (type is IArrayTypeSymbol array)
+            return CanCarryObjectState(array.ElementType, numeric, visiting, depth + 1);
+
+        if (type is not INamedTypeSymbol named) return false;
+        if (named.OriginalDefinition.SpecialType == SpecialType.System_Nullable_T)
+            return CanCarryObjectState(named.TypeArguments[0], numeric, visiting, depth + 1);
+
+        if (named.IsTupleType)
+        {
+            return named.TupleElements.All(element =>
+                CanCarryObjectState(element.Type, numeric, visiting, depth + 1));
+        }
+
+        if (ParameterMemberSemanticModel.IsNumericStateStorage(type)) return false;
+        if (IsInfrastructure(type)) return false;
+        if (IsSerializableModel(type)) return true;
+
+        if (named.Name is "List" or "IList" or "IReadOnlyList" or "IEnumerable"
+                or "ICollection" or "IReadOnlyCollection"
+                or "HashSet" or "ISet" or "IReadOnlySet"
+            && named.TypeArguments.Length == 1)
+            return CanCarryObjectState(named.TypeArguments[0], numeric, visiting, depth + 1);
+
+        if (named.Name == "Dictionary" && named.TypeArguments.Length == 2)
+        {
+            var key = named.TypeArguments[0];
+            bool safeKey = key.TypeKind == TypeKind.Enum
+                || key.SpecialType is SpecialType.System_Boolean
+                    or SpecialType.System_Byte or SpecialType.System_SByte
+                    or SpecialType.System_Int16 or SpecialType.System_UInt16
+                    or SpecialType.System_Int32 or SpecialType.System_UInt32
+                    or SpecialType.System_Int64 or SpecialType.System_UInt64
+                    or SpecialType.System_Char or SpecialType.System_String;
+            return safeKey
+                && CanCarryObjectState(named.TypeArguments[1], numeric, visiting, depth + 1);
+        }
+
+        if (named.TypeKind != TypeKind.Class || named.IsAbstract) return false;
+        bool hasJsonConstructor = named.InstanceConstructors.Any(c => c.GetAttributes().Any(a =>
+            a.AttributeClass?.ToDisplayString() == "Newtonsoft.Json.JsonConstructorAttribute"));
+        if (!hasJsonConstructor
+            && !named.InstanceConstructors.Any(c => c.Parameters.Length == 0
+                || c.Parameters.All(p => p.IsOptional))
+            && !HasSingleJsonMappableConstructor(named))
+        {
+            return false;
+        }
+
+        string identity = named.ToDisplayString();
+        if (!visiting.Add(identity)) return true;
+
+        for (var current = named; current is not null && current.SpecialType != SpecialType.System_Object;
+            current = current.BaseType)
+        {
+            foreach (var property in current.GetMembers().OfType<IPropertySymbol>())
+            {
+                if (property.IsStatic || property.IsIndexer || property.GetMethod is null
+                    || property.GetMethod.DeclaredAccessibility != Accessibility.Public)
+                {
+                    continue;
+                }
+
+                if (!CanCarryObjectState(property.Type, numeric, visiting, depth + 1))
+                    return false;
+            }
+
+            foreach (var field in current.GetMembers().OfType<IFieldSymbol>())
+            {
+                if (field.IsStatic || field.DeclaredAccessibility != Accessibility.Public) continue;
+                if (!CanCarryObjectState(field.Type, numeric, visiting, depth + 1))
+                    return false;
+            }
+        }
+
+        visiting.Remove(identity);
+        return true;
+    }
+
+    /// <summary>
+    /// Whether Json.NET can reconstruct a class through its single public value constructor.
+    /// </summary>
+    /// <remarks>
+    /// Json.NET binds a lone public parameterized constructor by member name. Requiring every
+    /// object-state type to also expose a parameterless or explicitly attributed constructor
+    /// excluded immutable value records such as NEAT Genome/Connection even though their complete
+    /// public shape is constructor-mappable. Keep the proof narrow: exactly one public constructor,
+    /// and every required argument must have a same-typed readable public property or field.
+    /// Remaining writable properties and constructor-created collections are populated by Json.NET
+    /// after construction and are validated by the ordinary public-shape walk below.
+    /// </remarks>
+    private static bool HasSingleJsonMappableConstructor(INamedTypeSymbol type)
+    {
+        var constructors = type.InstanceConstructors
+            .Where(c => c.DeclaredAccessibility == Accessibility.Public)
+            .ToList();
+        if (constructors.Count != 1 || constructors[0].Parameters.Length == 0) return false;
+
+        foreach (var parameter in constructors[0].Parameters)
+        {
+            bool matched = false;
+            for (var current = type; current is not null
+                && current.SpecialType != SpecialType.System_Object; current = current.BaseType)
+            {
+                foreach (var member in current.GetMembers())
+                {
+                    if (!string.Equals(member.Name, parameter.Name,
+                            System.StringComparison.OrdinalIgnoreCase))
+                    {
+                        continue;
+                    }
+
+                    ITypeSymbol? memberType = member switch
+                    {
+                        IPropertySymbol { IsStatic: false, IsIndexer: false,
+                            GetMethod.DeclaredAccessibility: Accessibility.Public } property => property.Type,
+                        IFieldSymbol { IsStatic: false,
+                            DeclaredAccessibility: Accessibility.Public } field => field.Type,
+                        _ => null,
+                    };
+                    if (memberType is null) continue;
+                    if (!SymbolEqualityComparer.Default.Equals(
+                            memberType.WithNullableAnnotation(NullableAnnotation.NotAnnotated),
+                            parameter.Type.WithNullableAnnotation(NullableAnnotation.NotAnnotated)))
+                    {
+                        continue;
+                    }
+
+                    matched = true;
+                    break;
+                }
+
+                if (matched) break;
+            }
+
+            if (!matched && !parameter.IsOptional) return false;
+        }
+
+        return true;
+    }
+
+    /// <summary>Whether a member holds a model's options.</summary>
+    /// <param name="type">The member's type.</param>
+    /// <returns><see langword="true"/> when it derives from <c>ModelOptions</c>.</returns>
+    private static bool IsModelOptions(ITypeSymbol type)
+    {
+        for (var current = type as INamedTypeSymbol; current is not null; current = current.BaseType)
+        {
+            if (current.Name == "ModelOptions") return true;
+        }
+
+        return false;
+    }
+
+    /// <summary>
+    /// Finds a configured factory already owned by the parent for an assignable fitted child.
+    /// </summary>
+    private static string? ChildFactoryExpression(INamedTypeSymbol owner, ITypeSymbol childType)
+    {
+        var expected = childType.WithNullableAnnotation(NullableAnnotation.NotAnnotated);
+        foreach (var member in owner.GetMembers())
+        {
+            ITypeSymbol? factoryType = member switch
+            {
+                IFieldSymbol { IsStatic: false } field => field.Type,
+                IPropertySymbol { IsStatic: false, GetMethod: not null } property => property.Type,
+                _ => null,
+            };
+            if (factoryType is not INamedTypeSymbol { IsGenericType: true, TypeArguments.Length: 1 } factory
+                || factory.OriginalDefinition.ToDisplayString() != "System.Func<TResult>")
+            {
+                continue;
+            }
+
+            var produced = factory.TypeArguments[0]
+                .WithNullableAnnotation(NullableAnnotation.NotAnnotated);
+            if (!SymbolEqualityComparer.Default.Equals(produced, expected)) continue;
+
+            return $"() => {member.Name} is null "
+                + $"? throw new global::System.InvalidOperationException(\"Configured child factory '{member.Name}' is not available during restore.\") "
+                + $": {member.Name}()";
+        }
+
+        return null;
+    }
+
+    /// <summary>
+    /// True when an infrastructure component is itself fitted state with a canonical serializer.
+    /// </summary>
+    private static bool IsFittedSerializer(ITypeSymbol type)
+    {
+        if (!IsSerializableModel(type)) return false;
+        return type.GetMembers("IsFitted").OfType<IPropertySymbol>().Any(property =>
+            property.GetMethod is not null
+            && property.Type.SpecialType == SpecialType.System_Boolean);
+    }
+
+    /// <summary>
+    /// Recovers constructor expressions already used by Fit for derived helper components.
+    /// </summary>
+    /// <remarks>
+    /// The generator reuses source construction rather than reverse-engineering constructor
+    /// arguments. Expressions that read a method local are rejected; only owner members, type
+    /// parameters, literals and member names rooted in those owner members are safe to replay.
+    /// </remarks>
+    private static List<(string Field, string Expression)> FittedInfrastructureRepairs(
+        INamedTypeSymbol owner)
+    {
+        bool hasFittedLatch = false;
+        for (var current = owner; current is not null; current = current.BaseType)
+        {
+            hasFittedLatch |= current.GetMembers("IsFitted").OfType<IPropertySymbol>().Any(property =>
+                property.GetMethod is not null
+                && property.Type.SpecialType == SpecialType.System_Boolean);
+        }
+        if (!hasFittedLatch) return new List<(string, string)>();
+
+        var ownerNames = new HashSet<string>(owner.GetMembers()
+            .Where(member => !member.IsStatic)
+            .Select(member => member.Name), System.StringComparer.Ordinal);
+        foreach (var parameter in owner.TypeParameters) ownerNames.Add(parameter.Name);
+
+        var repairs = new List<(string Field, string Expression)>();
+        foreach (var field in owner.GetMembers().OfType<IFieldSymbol>())
+        {
+            if (field.IsStatic || field.IsReadOnly || field.IsImplicitlyDeclared
+                || field.NullableAnnotation != NullableAnnotation.Annotated
+                || field.Type is not INamedTypeSymbol { TypeKind: TypeKind.Class, IsAbstract: false } fieldType
+                || IsSerializableModel(field.Type) || IsLayer(field.Type)
+                || !IsDerivedFittedHelperType(fieldType))
+            {
+                continue;
+            }
+
+            string? construction = null;
+            foreach (var syntaxReference in owner.DeclaringSyntaxReferences)
+            {
+                if (syntaxReference.GetSyntax() is not ClassDeclarationSyntax declaration) continue;
+                foreach (var assignment in declaration.DescendantNodes().OfType<AssignmentExpressionSyntax>())
+                {
+                    string assignedName = assignment.Left switch
+                    {
+                        IdentifierNameSyntax identifier => identifier.Identifier.ValueText,
+                        MemberAccessExpressionSyntax { Name: IdentifierNameSyntax identifier } =>
+                            identifier.Identifier.ValueText,
+                        _ => string.Empty,
+                    };
+                    if (assignedName != field.Name
+                        || assignment.Right is not ObjectCreationExpressionSyntax creation
+                        || !CanReplayConstructionExpression(creation, ownerNames))
+                    {
+                        continue;
+                    }
+
+                    construction = creation.ToString();
+                    break;
+                }
+                if (construction is not null) break;
+            }
+
+            if (construction is not null) repairs.Add((field.Name, construction));
+        }
+
+        return repairs;
+    }
+
+    private static bool IsDerivedFittedHelperType(INamedTypeSymbol type)
+        => IsInfrastructure(type)
+           || type.GetAttributes().Any(attribute => attribute.AttributeClass?.Name is
+               "ComponentTypeAttribute" or "PipelineStageAttribute");
+
+    private static bool CanReplayConstructionExpression(
+        ObjectCreationExpressionSyntax creation,
+        HashSet<string> ownerNames)
+    {
+        foreach (var identifier in creation.DescendantNodes().OfType<IdentifierNameSyntax>())
+        {
+            // The constructed type and the right-hand names of member accesses are type/property
+            // syntax, not captured locals. Only unqualified value roots need ownership proof.
+            if (identifier.Parent is GenericNameSyntax
+                || identifier.Parent is QualifiedNameSyntax
+                || identifier.Parent is MemberAccessExpressionSyntax access
+                    && ReferenceEquals(access.Name, identifier))
+            {
+                continue;
+            }
+
+            if (!ownerNames.Contains(identifier.Identifier.ValueText)) return false;
+        }
+
+        return true;
+    }
+
+    private static int StateRestorePriority(string call)
+    {
+        if (call.IndexOf(".DeclareOptions(", System.StringComparison.Ordinal) >= 0) return -100;
+        if (call.IndexOf(".DeclareAfterRestore(", System.StringComparison.Ordinal) >= 0
+            || call.IndexOf(".DeclareAfterParameterRestore(", System.StringComparison.Ordinal) >= 0)
+            return 100;
+        return 0;
+    }
+
+    private static string Render(
+        INamedTypeSymbol type,
+        string numeric,
+        List<(string Name, string Call)> members,
+        bool declaresHook,
+        bool emitSerializationSurface)
+    {
+        var sb = new StringBuilder();
+        sb.AppendLine("// <auto-generated/>");
+        sb.AppendLine("#nullable enable");
+        sb.AppendLine();
+
+        var ns = type.ContainingNamespace.IsGlobalNamespace ? null : type.ContainingNamespace.ToDisplayString();
+        if (ns is not null)
+        {
+            sb.AppendLine($"namespace {ns};");
+            sb.AppendLine();
+        }
+
+        // A NESTED type has to be reopened through the types that contain it. Emitting `partial class
+        // Inner` at namespace level declares a DIFFERENT type -- one with no base -- and the override
+        // then has nothing to override, which is what CS0115 was reporting for five model classes
+        // declared inside their test fixtures. Outermost first, so the chain reads the way it is
+        // written in the source.
+        var chain = new List<INamedTypeSymbol>();
+        for (var outer = type.ContainingType; outer is not null; outer = outer.ContainingType)
+        {
+            chain.Insert(0, outer);
+        }
+
+        var indent = string.Empty;
+
+        foreach (var outer in chain)
+        {
+            sb.AppendLine($"{indent}partial class {outer.Name}{TypeParametersOf(outer)}");
+            sb.AppendLine($"{indent}{{");
+            indent += "    ";
+        }
+
+        sb.AppendLine($"{indent}partial class {type.Name}{TypeParametersOf(type)}");
+        sb.AppendLine($"{indent}{{");
+        sb.AppendLine($"{indent}    /// <summary>Auto-generated state declarations for this model's own members.</summary>");
+        if (declaresHook)
+        {
+            sb.AppendLine($"{indent}    [global::System.CodeDom.Compiler.GeneratedCode(\"AiDotNet.Generators.ModelStateGenerator\", \"1.0.0\")]");
+            sb.AppendLine($"{indent}    private void RegisterGeneratedStateCore(global::AiDotNet.Models.ModelStateRegistry<{numeric}> state)");
+            sb.AppendLine($"{indent}    {{");
+        }
+        else
+        {
+            sb.AppendLine($"{indent}    [global::System.CodeDom.Compiler.GeneratedCode(\"AiDotNet.Generators.ModelStateGenerator\", \"1.0.0\")]");
+            sb.AppendLine($"{indent}    protected override void RegisterGeneratedState(global::AiDotNet.Models.ModelStateRegistry<{numeric}> state)");
+            sb.AppendLine($"{indent}    {{");
+            sb.AppendLine($"{indent}        base.RegisterGeneratedState(state);");
+        }
+
+        // Ordered by name so the payload does not depend on declaration order, which a refactor can
+        // change without anybody meaning to.
+        foreach (var member in members
+            .OrderBy(m => StateRestorePriority(m.Call))
+            .ThenBy(m => m.Name, System.StringComparer.Ordinal))
+        {
+            sb.AppendLine($"{indent}        {member.Call}");
+        }
+
+        sb.AppendLine($"{indent}    }}");
+
+        if (emitSerializationSurface)
+        {
+            sb.AppendLine();
+            sb.AppendLine($"{indent}    /// <summary>Auto-generated common model serialization surface.</summary>");
+            sb.AppendLine($"{indent}    [global::System.CodeDom.Compiler.GeneratedCode(\"AiDotNet.Generators.ModelStateGenerator\", \"1.0.0\")]");
+            sb.AppendLine($"{indent}    public override byte[] Serialize() => SerializeGeneratedModelState();");
+            sb.AppendLine();
+            sb.AppendLine($"{indent}    /// <summary>Auto-generated common model deserialization surface.</summary>");
+            sb.AppendLine($"{indent}    [global::System.CodeDom.Compiler.GeneratedCode(\"AiDotNet.Generators.ModelStateGenerator\", \"1.0.0\")]");
+            sb.AppendLine($"{indent}    public override void Deserialize(byte[] data) => DeserializeGeneratedModelState(data);");
+        }
+
+        sb.AppendLine($"{indent}}}");
+
+        for (var i = chain.Count - 1; i >= 0; i--)
+        {
+            indent = indent.Substring(0, indent.Length - 4);
+            sb.AppendLine($"{indent}}}");
+        }
+
+        return sb.ToString();
+    }
+
+    /// <summary>The node type, when a member holds the root of a graph whose nodes point at their own kind.</summary>
+    /// <remarks>
+    /// Recognised by shape rather than by name, so a consumer's own tree is carried on the same terms
+    /// as ours. Three things have to hold: it is a class, it can be built with no arguments -- the
+    /// registry has to make one per node on restore -- and at least one settable property is typed as
+    /// the node itself, which is what makes it a graph rather than a plain object.
+    /// </remarks>
+    private static INamedTypeSymbol? IsRecursiveNode(ITypeSymbol memberType, string numeric)
+    {
+        if (memberType is not INamedTypeSymbol { TypeKind: TypeKind.Class } named) return null;
+        if (named.IsAbstract) return null;
+
+        var self = named.ToDisplayString().TrimEnd('?');
+
+        if (GraphNodeFactory(named, numeric) is null)
+        {
+            return null;
+        }
+
+        var properties = named.GetMembers().OfType<IPropertySymbol>()
+            .Where(p => !p.IsStatic && p.GetMethod is not null)
+            .ToList();
+
+        // The typed graph path must be COMPLETE. Its former best-effort behavior recognized a
+        // recursive node and then silently skipped dictionaries, long counters and getter-only
+        // collections. HoeffdingTree consequently restored the shape of its tree but none of the
+        // class statistics that decide a leaf prediction. When even one readable property cannot be
+        // represented, decline the typed path so the general object-state declaration carries the
+        // whole node instead.
+        foreach (var property in properties)
+        {
+            if (property.SetMethod is null) return null;
+
+            var propertyType = property.Type.ToDisplayString().TrimEnd('?');
+            var bare = System.Text.RegularExpressions.Regex
+                .Replace(propertyType, @"\b[A-Za-z_][A-Za-z0-9_]*\.", string.Empty)
+                .Replace($"<{numeric}>", "<T>");
+
+            if (propertyType != self
+                && bare is not ("int" or "long" or "double" or "double[]" or "bool" or "T" or "Vector<T>"))
+            {
+                return null;
+            }
+        }
+
+        var recursive = properties.Any(p => p.Type.ToDisplayString().TrimEnd('?') == self);
+
+        return recursive ? named : null;
+    }
+
+    /// <summary>A recursive node factory expressible without model-specific code.</summary>
+    private static string? GraphNodeFactory(INamedTypeSymbol node, string numeric)
+    {
+        var qualified = "global::" + node.ToDisplayString().TrimEnd('?');
+        if (node.InstanceConstructors.Any(c => c.Parameters.Length == 0
+            && c.DeclaredAccessibility == Accessibility.Public))
+        {
+            return $"new {qualified}()";
+        }
+
+        // Tree records often take the model's numeric zero solely to initialize generic scalar
+        // properties. default(T) is exactly numeric zero for the supported numeric types and lets
+        // the generated graph factory rebuild them without requiring a ceremonial parameterless
+        // constructor on every nested node type.
+        if (node.InstanceConstructors.Any(c => c.DeclaredAccessibility == Accessibility.Public
+            && c.Parameters.Length == 1
+            && c.Parameters[0].Type.ToDisplayString() == numeric))
+        {
+            return $"new {qualified}(default!)";
+        }
+
+        return null;
+    }
+
+    private static INamedTypeSymbol? IsDerivedDecisionTreeNode(ITypeSymbol type)
+    {
+        if (type is not INamedTypeSymbol { TypeKind: TypeKind.Class } named) return null;
+        for (var current = named.BaseType; current is not null; current = current.BaseType)
+        {
+            if (current.OriginalDefinition.ToDisplayString()
+                .StartsWith("AiDotNet.LinearAlgebra.DecisionTreeNode<", System.StringComparison.Ordinal))
+            {
+                return named.InstanceConstructors.Any(c => c.Parameters.Length == 0
+                    && c.DeclaredAccessibility == Accessibility.Public)
+                    ? named
+                    : null;
+            }
+        }
+
+        return null;
+    }
+
+    /// <summary>Builds the DeclareGraph call that carries a node graph.</summary>
+    /// <remarks>
+    /// Only the property shapes NodeShape can carry are described. What is left out is left out on
+    /// purpose: a decision node also holds the training samples that produced it and, in a model-tree,
+    /// a fitted sub-model, and neither is needed to reproduce a prediction. Carrying the samples would
+    /// put the training set inside every saved model.
+    /// </remarks>
+    private static string GraphCall(
+        string id,
+        string name,
+        INamedTypeSymbol node,
+        string numeric,
+        string setter)
+    {
+        var qualified = "global::" + node.ToDisplayString().TrimEnd('?');
+        var shape = GraphShape(node, numeric);
+        return $"state.DeclareGraph<{qualified}>(\"{id}\", () => {name}, {setter}, n => n{shape});";
+    }
+
+    private static string GraphListCall(
+        string id,
+        string name,
+        INamedTypeSymbol node,
+        string numeric,
+        string setter)
+    {
+        var qualified = "global::" + node.ToDisplayString().TrimEnd('?');
+        var shape = GraphShape(node, numeric);
+        return $"state.DeclareGraphList<{qualified}>(\"{id}\", () => {name}, {setter}, n => n{shape});";
+    }
+
+    private static string GraphShape(INamedTypeSymbol node, string numeric)
+    {
+        var self = node.ToDisplayString().TrimEnd('?');
+        var shape = new StringBuilder();
+
+        shape.Append($".Create(() => {GraphNodeFactory(node, numeric)})");
+
+        foreach (var property in node.GetMembers().OfType<IPropertySymbol>()
+            .Where(p => !p.IsStatic && p.GetMethod is not null && p.SetMethod is not null)
+            .OrderBy(p => p.Name, System.StringComparer.Ordinal))
+        {
+            var propertyType = property.Type.ToDisplayString().TrimEnd('?');
+            var bare = System.Text.RegularExpressions.Regex
+                .Replace(propertyType, @"\b[A-Za-z_][A-Za-z0-9_]*\.", string.Empty)
+                .Replace($"<{numeric}>", "<T>");
+
+            var call = propertyType == self ? "Child"
+                : bare switch
+                {
+                    "int" => "Int32",
+                    "long" => "Int64",
+                    "double" => "Double",
+                    "double[]" => "DoubleArray",
+                    "bool" => "Boolean",
+                    "T" => "Scalar",
+                    "Vector<T>" => "Vector",
+                    _ => null,
+                };
+
+            if (call is null) continue;
+
+            shape.Append($".{call}(n => n.{property.Name}, (n, v) => n.{property.Name} = v)");
+        }
+
+        return shape.ToString();
+    }
+
+    private static string DerivedDecisionTreeGraphCall(
+        string id,
+        string name,
+        INamedTypeSymbol node,
+        string numeric,
+        string setter)
+    {
+        var qualified = "global::" + node.ToDisplayString().TrimEnd('?');
+        var shape = new StringBuilder()
+            .Append($".Create(() => new {qualified}())")
+            .Append(".Int32(n => n.FeatureIndex, (n, v) => n.FeatureIndex = v)")
+            .Append(".Scalar(n => n.SplitValue, (n, v) => n.SplitValue = v)")
+            .Append(".Scalar(n => n.Threshold, (n, v) => n.Threshold = v)")
+            .Append(".Scalar(n => n.Prediction, (n, v) => n.Prediction = v)")
+            .Append(".Boolean(n => n.IsLeaf, (n, v) => n.IsLeaf = v)");
+
+        foreach (var property in node.GetMembers().OfType<IPropertySymbol>()
+            .Where(p => !p.IsStatic && p.GetMethod is not null && p.SetMethod is not null)
+            .OrderBy(p => p.Name, System.StringComparer.Ordinal))
+        {
+            var bare = System.Text.RegularExpressions.Regex
+                .Replace(property.Type.ToDisplayString().TrimEnd('?'), @"\b[A-Za-z_][A-Za-z0-9_]*\.", string.Empty)
+                .Replace($"<{numeric}>", "<T>");
+            var call = bare switch
+            {
+                "int" => "Int32",
+                "long" => "Int64",
+                "double" => "Double",
+                "double[]" => "DoubleArray",
+                "bool" => "Boolean",
+                "T" => "Scalar",
+                "Vector<T>" => "Vector",
+                _ => null,
+            };
+            if (call is not null)
+                shape.Append($".{call}(n => n.{property.Name}, (n, v) => n.{property.Name} = v)");
+        }
+
+        shape
+            .Append($".Child(n => ({qualified}?)n.Left, (n, v) => n.Left = v)")
+            .Append($".Child(n => ({qualified}?)n.Right, (n, v) => n.Right = v)");
+
+        return $"state.DeclareGraph<{qualified}>(\"{id}\", () => {name}, {setter}, n => n{shape});";
+    }
+
+    /// <summary>True for a member that is training machinery rather than state to restore.</summary>
+    /// <remarks>
+    /// THE RIGHT DISCRIMINATOR, replacing "single children are opt-in". That gate was written to keep a
+    /// model's optimizer out of the payload, and it did -- along with every legitimate sub-model held in
+    /// a field of its own. SiameseNetwork keeps its twin in <c>_subnetwork</c> and its head in
+    /// <c>_outputLayer</c>, both single, and lost both: clone output moved 0.585 -> 0.502. Its optimizer
+    /// sits in the very next field, which is what makes the distinction clear -- it is not arity that
+    /// separates them, it is WHAT THEY ARE.
+    /// <para>
+    /// Matched by interface name so a consumer's own optimizer is excluded on the same terms as ours,
+    /// and kept short on purpose: everything not on this list is state, which is the direction the
+    /// default should fail in.
+    /// </para>
+    /// </remarks>
+    private static bool IsInfrastructure(ITypeSymbol type)
+    {
+        static bool Machinery(string name)
+            => name is "IOptimizer" or "IGradientBasedOptimizer" or "ILossFunction"
+                or "ILearningRateScheduler" or "IRegularization" or "IActivationFunction"
+                or "IAudioFeatureExtractor" or "Random";
+
+        return Machinery(type.Name) || type.AllInterfaces.Any(i => Machinery(i.Name));
+    }
+
+    private static bool IsPartial(INamedTypeSymbol type)
+        => type.DeclaringSyntaxReferences
+            .Select(r => r.GetSyntax())
+            .OfType<ClassDeclarationSyntax>()
+            .Any(d => d.Modifiers.Any(m => m.ValueText == "partial"));
+
+    private static string TypeParametersOf(INamedTypeSymbol type)
+    {
+        return type.TypeParameters.Length > 0
+            ? "<" + string.Join(", ", type.TypeParameters.Select(p => p.Name)) + ">"
+            : string.Empty;
+    }
+}
diff --git a/src/AiDotNet.Generators/ParameterAutomationAnalyzer.cs b/src/AiDotNet.Generators/ParameterAutomationAnalyzer.cs
index 45561b3cbf..bb4ac2cc1b 100644
--- a/src/AiDotNet.Generators/ParameterAutomationAnalyzer.cs
+++ b/src/AiDotNet.Generators/ParameterAutomationAnalyzer.cs
@@ -492,8 +492,11 @@ when dimensionProperty.GetMethod is not null
                                 var targetClassification =
                                     ParameterMemberSemanticModel.ClassifyWithRegistrations(
                                         targets[0], registrations);
-                                if (targetClassification.Kind is ParameterMemberSemanticModel.Kind.Unclassified
-                                    or ParameterMemberSemanticModel.Kind.Conflicting
+                                bool layerAlias = IsLayerLike(memberType) && IsLayerLike(
+                                    ParameterMemberSemanticModel.GetMemberType(targets[0])!);
+                                if ((targetClassification.Kind is ParameterMemberSemanticModel.Kind.Unclassified
+                                     && !layerAlias)
+                                    || targetClassification.Kind is ParameterMemberSemanticModel.Kind.Conflicting
                                     or ParameterMemberSemanticModel.Kind.Scratch
                                     or ParameterMemberSemanticModel.Kind.Alias
                                     or ParameterMemberSemanticModel.Kind.External)
@@ -645,10 +648,16 @@ m.Name is "GetExtraTrainableTensors" or "GetExtraTrainableLayers"
                                 if (f.IsStatic || f.IsImplicitlyDeclared || f.AssociatedSymbol is not null) continue;
                                 if (HasAnyAttribute(f, "BufferAttribute", "Buffer", "ScratchAttribute", "Scratch",
                                                        "ParameterAliasAttribute", "ParameterAlias")) continue;
-                                if (!IsWeightCapableType(f.Type)) continue;
-                                if (generatorWillRegister && GeneratorHandles(f, type)) continue;
-                                if (generatorWillYieldTensors && GeneratorHandles(f, type)
-                                    && IsTensorType(f.Type)) continue;
+                                if (!IsWeightCapableType(f.Type)) continue;
+                                if (generatorWillRegister && GeneratorHandles(f, type)) continue;
+                                var classification = ParameterMemberSemanticModel.Classify(f);
+                                if (InheritsRegistry(type) && GeneratorHandles(f, type)
+                                    && classification.Kind is ParameterMemberSemanticModel.Kind.Fitted
+                                        or ParameterMemberSemanticModel.Kind.Frozen
+                                        or ParameterMemberSemanticModel.Kind.Buffer)
+                                    continue;
+                                if (generatorWillYieldTensors && GeneratorHandles(f, type)
+                                    && (IsTensorType(f.Type) || IsVectorType(f.Type))) continue;
 
                                 var fl = f.Locations.FirstOrDefault(l => l.IsInSource);
                                 if (fl is not null)
@@ -847,12 +856,21 @@ private static bool DeclaresStableParameterRegistration(INamedTypeSymbol type, s
     /// so weights held in them reach no parameter surface. LoRALayer held its A and B this way and
     /// derived a ParameterCount of zero.
     /// </summary>
-    private static bool IsMatrixOrVectorType(ITypeSymbol type)
+    private static bool IsMatrixOrVectorType(ITypeSymbol type)
     {
         var name = type.OriginalDefinition.ToDisplayString();
         return name.StartsWith("AiDotNet.Tensors.LinearAlgebra.Matrix<", System.StringComparison.Ordinal)
-            || name.StartsWith("AiDotNet.Tensors.LinearAlgebra.Vector<", System.StringComparison.Ordinal);
-    }
+            || name.StartsWith("AiDotNet.Tensors.LinearAlgebra.Vector<", System.StringComparison.Ordinal);
+    }
+
+    /// <summary>A direct Vector&lt;T&gt; field can be exposed as a write-through Tensor view.</summary>
+    private static bool IsVectorType(ITypeSymbol type)
+    {
+        var normalized = type.WithNullableAnnotation(NullableAnnotation.NotAnnotated);
+        return normalized is INamedTypeSymbol named
+            && named.OriginalDefinition.ToDisplayString().StartsWith(
+                "AiDotNet.Tensors.LinearAlgebra.Vector<", System.StringComparison.Ordinal);
+    }
     /// <summary>
     /// Numeric containers that can hold weights: <c>Tensor&lt;T&gt;</c>, <c>Matrix&lt;T&gt;</c> and
     /// <c>Vector&lt;T&gt;</c>, including arrays and the common collections of them.
diff --git a/src/AiDotNet.Generators/TestScaffoldGenerator.cs b/src/AiDotNet.Generators/TestScaffoldGenerator.cs
index 7c57239c25..2d45ae31f1 100644
--- a/src/AiDotNet.Generators/TestScaffoldGenerator.cs
+++ b/src/AiDotNet.Generators/TestScaffoldGenerator.cs
@@ -648,6 +648,15 @@ public class TestScaffoldGenerator : IIncrementalGenerator
             // Only the memorization probe is affected; its other probes already pass.
             { "MusicTaggingTransformer", new WarmupIterationOverride(memorization: 12) },
 
+            // Madmom's FP32 audio policy previously stopped MoreData after two AdamW updates,
+            // exactly inside its deterministic initial overshoot (0.679 -> 1.324). Its ordinary
+            // six-update loss-reduction invariant is already green; ten updates keep the fixture
+            // inexpensive while judging the settled trajectory instead of the warm-up transient.
+            {
+                "MadmomBeatTracker",
+                new WarmupIterationOverride(moreDataLong: 10)
+            },
+
             // VMamba includes dropout by default. Its first/final training-mode loss samples can
             // therefore reverse under an unlucky mask even while the fixed example is learning.
             // Measure the same fixed example in evaluation mode at both endpoints; the strict
@@ -2145,6 +2154,24 @@ internal WarmupIterationOverride(
         defaultSeverity: DiagnosticSeverity.Warning,
         isEnabledByDefault: true);
 
+    private static readonly DiagnosticDescriptor UnscaffoldableLayer = new(
+        id: "AIDN046",
+        title: "Layer cannot be scaffolded and produces no generated tests",
+        messageFormat: "'{0}' has no parameterless constructor and declares no "
+                     + "[LayerProperty(TestConstructorArgs = \"...\")], so the scaffold generator "
+                     + "emits NO tests for it at all. Declare TestConstructorArgs, and "
+                     + "TestInputShape alongside it so the generated tests can drive a forward.",
+        category: "AiDotNet.TestCoverage",
+        defaultSeverity: DiagnosticSeverity.Warning,
+        isEnabledByDefault: true,
+        description: "A layer the generator cannot construct was previously skipped in silence, so "
+                   + "it did not fail, appear in the coverage count, or show up anywhere as "
+                   + "missing -- the skip read exactly like coverage. Four layers reached master "
+                   + "that way, and two of them carried real defects: one never built its "
+                   + "convolutions on the single-input path, so a checkpoint held none of its "
+                   + "weights, and one severed its input gradient while its parameter gradients "
+                   + "still looked healthy.");
+
     private static readonly DiagnosticDescriptor AlgorithmCoverageSummary = new(
         id: "AIDN045",
         title: "Non-model algorithm test coverage summary",
@@ -2212,6 +2239,19 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
         context.RegisterSourceOutput(combined, static (spc, source) =>
         {
             var ((((((models, tests), activations), losses), layers), algorithms), compilation) = source;
+
+            // This generator owns AiDotNet's repository test census and emits fixtures that
+            // depend on AiDotNetTests-only base classes and xUnit. The generator assembly is also
+            // shipped to PackageReference consumers so production generators (layer state,
+            // registries, schemas, etc.) activate automatically. Do not leak these repository-only
+            // fixtures or coverage diagnostics into arbitrary consumer compilations.
+            string assemblyName = compilation.AssemblyName ?? string.Empty;
+            if (!string.Equals(assemblyName, "AiDotNet", System.StringComparison.Ordinal) &&
+                !string.Equals(assemblyName, "AiDotNetTests", System.StringComparison.Ordinal))
+            {
+                return;
+            }
+
             Execute(spc, models, tests, compilation);
             ExecuteActivationAndLossGeneration(spc, activations, losses, compilation);
             ExecuteLayerGeneration(spc, layers, compilation);
@@ -15445,9 +15485,22 @@ private static void ExecuteLayerGeneration(
                     continue;
                 }
 
-                // Skip if no accessible constructor
+                // Skip if no accessible constructor -- but say so. This was a bare continue, and a
+                // silent skip is indistinguishable from coverage: the layer did not fail, was not
+                // counted as untested, and appeared nowhere as missing.
                 if (!layer.HasParameterlessConstructor && string.IsNullOrEmpty(layer.TestConstructorArgs))
+                {
+                    // Reported with whatever location exists, NOT gated on having one. This loop
+                    // runs in the TEST project, where layers arrive from the referenced assembly and
+                    // carry no source location -- so gating on a location silenced the diagnostic
+                    // everywhere it could actually fire, which is how the first version of it
+                    // reported zero. The message names the class, which is enough to find it.
+                    context.ReportDiagnostic(Diagnostic.Create(
+                        UnscaffoldableLayer,
+                        layer.DeclarationLocation ?? Location.None,
+                        layer.ClassName));
                     continue;
+                }
 
                 var testClassName = StripBacktick(layer.ClassName) + "Tests";
                 if (!generatedNames.Add(testClassName))
@@ -15556,6 +15609,7 @@ private static void ExecuteLayerGeneration(
             FullyQualifiedName = symbol.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat),
             TypeParameterCount = symbol.TypeParameters.Length,
             HasParameterlessConstructor = hasParameterlessCtor,
+            DeclarationLocation = symbol.Locations.FirstOrDefault(location => location.IsInSource),
             IsTrainable = isTrainable,
             SupportsBackpropagation = supportsBackprop,
             HasTrainingMode = hasTrainingMode,
@@ -15949,6 +16003,13 @@ private class LayerTestInfo
         public bool UsesSurrogateGradient { get; set; }
         public bool ProducesNonFiniteOutput { get; set; }
         public bool TrainsViaCustomLoss { get; set; }
+
+        /// <summary>Where the layer is declared, or null when it came from a referenced assembly.</summary>
+        /// <remarks>
+        /// Gates the AIDN046 report. A layer discovered in a referenced assembly cannot be annotated
+        /// from this compilation, so warning about it would be noise nobody here can act on.
+        /// </remarks>
+        public Location? DeclarationLocation { get; set; }
     }
 
     /// <summary>
diff --git a/src/AiDotNet.Generators/TrainableParameterGenerator.cs b/src/AiDotNet.Generators/TrainableParameterGenerator.cs
index 4bc72be88c..95b919d9e8 100644
--- a/src/AiDotNet.Generators/TrainableParameterGenerator.cs
+++ b/src/AiDotNet.Generators/TrainableParameterGenerator.cs
@@ -234,7 +234,10 @@ private static void Execute(Compilation compilation, ImmutableArray<string> clas
             // annotated field caused the generator to emit a field-only override that HID every
             // dynamically registered tensor. HeterogeneousGraphLayer consequently registered all
             // of its per-type weights and then reported an empty parameter surface.
-            bool useRuntimeParameterRegistry = HasAnyUnmappableRegistration(compilation, classSymbol);
+            bool useConventionalTensorEnumerator =
+                HasUnclassifiedConventionalTensorEnumerator(compilation, classSymbol);
+            bool useRuntimeParameterRegistry = HasAnyUnmappableRegistration(compilation, classSymbol)
+                || useConventionalTensorEnumerator;
 
             // Skip if already processed (multiple partial files)
             var fullName = classSymbol.ToDisplayString();
@@ -245,12 +248,23 @@ private static void Execute(Compilation compilation, ImmutableArray<string> clas
             var gradientFields = new Dictionary<string, GradientFieldInfo>();
             var subLayerFields = new List<SubLayerFieldInfo>();
 
-            var bufferFields = new List<(string Field, string Name, string Role, string StateRole)>();
+            var bufferFields = new List<(string Field, string Name, string Role, string StateRole, bool InputSized, bool ReadOnly)>();
 
             foreach (var member in classSymbol.GetMembers())
             {
                 if (member is not IFieldSymbol field) continue;
 
+                // COMPILER-GENERATED BACKING FIELDS ARE NOT MEMBERS THE AUTHOR WROTE. An auto-property
+                // is backed by a field literally named `<Prop>k__BackingField`, which is not a legal
+                // C# identifier, so emitting it produced source that could not compile at all
+                // ("Invalid expression term '<'"). The property is the member; its backing store is an
+                // implementation detail of the language.
+                //
+                // This generator already filters them correctly elsewhere -- the guard existed and this
+                // loop simply never reached it, which is why the defect stayed invisible until a class
+                // holding auto-properties was first made partial.
+                if (field.IsImplicitlyDeclared) continue;
+
                 var classification = ParameterMemberSemanticModel.Classify(field);
 
                 // Check for [TrainableParameter]
@@ -296,7 +310,8 @@ private static void Execute(Compilation compilation, ImmutableArray<string> clas
                             // unannotated nullable tensor into the graph.
                             Optional: optional || explicitNullable, Nullable: explicitNullable,
                             Shape: shape, Condition: condition,
-                            LowPrecisionBacking: lowPrecisionBacking));
+                            LowPrecisionBacking: lowPrecisionBacking,
+                            IsReadOnly: field.IsReadOnly));
                     }
                     else if (TryGetTensorCollection(field.Type, classSymbol, out var collectionKind))
                     {
@@ -320,13 +335,18 @@ private static void Execute(Compilation compilation, ImmutableArray<string> clas
                 // Marking alone is not enough -- without emitting RegisterBuffer the tensors leave
                 // the trainable set and join nothing, disappearing from ParameterCount and the flat
                 // vector entirely. ReservoirLayer proved it: "Expected 320 parameters, got 0".
+                bool hasRegisteredBufferDeclaration = TryGetRegisteredBufferDeclaration(
+                    classSymbol, field.Name, out string registeredBufferName, out string registeredBufferRole);
                 if (!field.IsStatic && IsTensorType(field.Type)
-                    && classification.Kind is ParameterMemberSemanticModel.Kind.Fitted
+                    && (classification.Kind is ParameterMemberSemanticModel.Kind.Fitted
                         or ParameterMemberSemanticModel.Kind.Frozen
-                        or ParameterMemberSemanticModel.Kind.Buffer)
+                        or ParameterMemberSemanticModel.Kind.Buffer
+                        || hasRegisteredBufferDeclaration))
                 {
                     var bufRole = "PersistentTensorRole.Constant";
-                    var bufName = field.Name.TrimStart('_');
+                    var bufName = hasRegisteredBufferDeclaration
+                        ? registeredBufferName
+                        : field.Name.TrimStart('_');
                     var bAttr = field.GetAttributes().FirstOrDefault(a =>
                         SymbolEqualityComparer.Default.Equals(a.AttributeClass, bufferSymbol));
                     if (bAttr is not null)
@@ -339,15 +359,48 @@ or ParameterMemberSemanticModel.Kind.Frozen
                                 bufName = bn;
                         }
                     }
+                    else if (hasRegisteredBufferDeclaration)
+                    {
+                        // RegisterBuffer is itself an explicit semantic declaration. Preserve its
+                        // role in the generated early registration so a lazy placeholder is not
+                        // first published as Constant and later rejected when the layer replaces it
+                        // under the author's Weights role.
+                        bufRole = registeredBufferRole;
+                    }
+                    // [FittedParameter(InputSized = true)] separates "persist this" from "count
+                    // this". A member whose extent comes from the caller's DATA cannot be part of
+                    // the flat vector: its width would change under a forward pass, and every
+                    // count-versus-vector contract in the base is written against a width that
+                    // only construction can move. It still registers as a buffer below, which is
+                    // what serializes and deep-copies it by name.
+                    bool inputSized = false;
+                    var fittedAttr = field.GetAttributes().FirstOrDefault(a =>
+                        a.AttributeClass?.ToDisplayString()
+                            == ParameterMemberSemanticModel.FittedAttribute);
+                    if (fittedAttr is not null)
+                    {
+                        foreach (var na in fittedAttr.NamedArguments)
+                        {
+                            if (na.Key == "InputSized" && na.Value.Value is bool flag)
+                                inputSized = flag;
+                        }
+                    }
+
                     string stateRole = classification.Kind switch
                     {
+                        // InputSized fitted state registers under its own role. The base sweep that
+                        // declares every registered buffer keys off exactly this value to leave it
+                        // out of the component list, so the role -- not the generated declaration
+                        // alone -- is what keeps a caller-sized tensor out of the parameter vector.
+                        ParameterMemberSemanticModel.Kind.Fitted when inputSized =>
+                            "global::AiDotNet.Models.Parameters.ParameterSlotRole.InputSizedState",
                         ParameterMemberSemanticModel.Kind.Fitted =>
                             "global::AiDotNet.Models.Parameters.ParameterSlotRole.LearnedState",
                         ParameterMemberSemanticModel.Kind.Frozen =>
                             "global::AiDotNet.Models.Parameters.ParameterSlotRole.Frozen",
                         _ => "global::AiDotNet.Models.Parameters.ParameterSlotRole.Buffer"
                     };
-                    bufferFields.Add((field.Name, bufName, bufRole, stateRole));
+                    bufferFields.Add((field.Name, bufName, bufRole, stateRole, inputSized, field.IsReadOnly));
                 }
 
                 // Check for gradient fields (convention: {name}Gradient)
@@ -360,7 +413,14 @@ or ParameterMemberSemanticModel.Kind.Frozen
                 }
 
                 // Check for sub-layer fields
-                if (IsLayerType(field.Type) && !field.IsStatic)
+                // A layer field is owned by default, but [ParameterAlias] explicitly says that the
+                // same child is already owned through another member. Registering both names makes
+                // the allocation-free manifest count the child's parameters twice even though the
+                // runtime registry correctly deduplicates the shared reference.
+                if (IsLayerType(field.Type) && !field.IsStatic
+                    && classification.Kind is not (ParameterMemberSemanticModel.Kind.Alias
+                        or ParameterMemberSemanticModel.Kind.Scratch
+                        or ParameterMemberSemanticModel.Kind.External))
                 {
                     var isNullable = field.NullableAnnotation == NullableAnnotation.Annotated ||
                                      field.Type.NullableAnnotation == NullableAnnotation.Annotated;
@@ -375,14 +435,54 @@ or ParameterMemberSemanticModel.Kind.Frozen
                 // in Forward, and they silently never trained. CitrinetBlockLayer reported 0 children
                 // while holding 9. This is what PyTorch's nn.ModuleList exists to prevent -- a plain
                 // Python list of modules is likewise invisible to .parameters().
-                else if (!field.IsStatic && IsLayerCollectionType(field.Type))
+                else if (!field.IsStatic && IsLayerCollectionType(field.Type)
+                         && !IsAliasLayerCollection(compilation, classSymbol, field)
+                         && classification.Kind is not (ParameterMemberSemanticModel.Kind.Alias
+                             or ParameterMemberSemanticModel.Kind.Scratch
+                             or ParameterMemberSemanticModel.Kind.External))
                 {
                     var isNullable = field.NullableAnnotation == NullableAnnotation.Annotated ||
                                      field.Type.NullableAnnotation == NullableAnnotation.Annotated;
-                    subLayerFields.Add(new SubLayerFieldInfo(field.Name, isNullable, IsCollection: true));
+                    // The declaration is read here too. It was only read on the single-layer branch,
+                    // so a collection carrying [SubLayerInput] recorded no shape and was silently
+                    // dropped from DeclaredSubLayerShapes -- the attribute compiled, appeared to
+                    // apply, and did nothing.
+                    var collectionShape = field.GetAttributes()
+                        .FirstOrDefault(a => a.AttributeClass?.Name == "SubLayerInputAttribute")
+                        ?.ConstructorArguments.FirstOrDefault().Value as string;
+                    subLayerFields.Add(new SubLayerFieldInfo(
+                        field.Name, isNullable, IsCollection: true, InputShape: collectionShape));
                 }
             }
 
+            // A lazy layer often declares its tensor shapes at the allocation boundary rather
+            // than repeating them in attribute strings. Recover the simple, field-only collection
+            // expressions used there so the generated restore contract can split a flat checkpoint
+            // before the first real input arrives. Only adopt the inferred set when at least one
+            // formula binds a canonical input axis; this keeps ordinary construction-sized tensors
+            // on their existing zero-overhead path.
+            var inferredShapes = new string?[paramFields.Count];
+            bool hasInferredInputBinding = false;
+            for (int i = 0; i < paramFields.Count; i++)
+            {
+                if (paramFields[i].CollectionKind != ParameterCollectionKind.Direct
+                    || !string.IsNullOrWhiteSpace(paramFields[i].Shape))
+                    continue;
+                inferredShapes[i] = TryInferAllocationShape(
+                    compilation, classSymbol, paramFields[i].Name);
+                if (inferredShapes[i]?.IndexOf("InputShape[", System.StringComparison.Ordinal) >= 0)
+                    hasInferredInputBinding = true;
+            }
+            if (hasInferredInputBinding
+                && Enumerable.Range(0, paramFields.Count).All(index =>
+                    !string.IsNullOrWhiteSpace(paramFields[index].Shape)
+                    || !string.IsNullOrWhiteSpace(inferredShapes[index])))
+            {
+                for (int i = 0; i < paramFields.Count; i++)
+                    if (string.IsNullOrWhiteSpace(paramFields[i].Shape))
+                        paramFields[i] = paramFields[i] with { Shape = inferredShapes[i] };
+            }
+
             foreach (var duplicate in bufferFields
                          .GroupBy(item => item.Name, System.StringComparer.Ordinal)
                          .Where(group => group.Count() > 1))
@@ -433,14 +533,34 @@ or ParameterMemberSemanticModel.Kind.Frozen
                 // exactly these layers, which is how they already worked.
                 if (registeredFields.Count > 0)
                 {
-                    var seen = new HashSet<string>(paramFields.Select(parameter => parameter.Name));
-                    int nextOrder = paramFields.Count == 0
-                        ? 0
-                        : paramFields.Max(parameter => parameter.Order) + 1;
+                    // Registration order is the live optimizer/tape contract. A partially migrated
+                    // layer can annotate most fields and still register all of them imperatively;
+                    // appending only the unannotated discoveries after every attributed field made
+                    // the generated getter/setter use a different order from the runtime registry.
+                    // MambaBlock exposed the consequence: A_log/D were registered before the output
+                    // projection but generated after it, so clone adoption paired equal-sized tensors
+                    // with the wrong semantic slots while all aggregate counts still agreed.
+                    //
+                    // Rebuild the local declaration order from the explicit registration sequence,
+                    // retaining attribute metadata (shape/optional/backing) for matching fields, then
+                    // append genuinely declaration-only parameters. This makes one stable order drive
+                    // optimizer collection, flat persistence, copy-on-write adoption and manifests.
+                    var declaredByName = paramFields.ToDictionary(
+                        parameter => parameter.Name,
+                        System.StringComparer.Ordinal);
+                    var orderedFields = new List<ParameterFieldInfo>(paramFields.Count);
+                    var seen = new HashSet<string>(System.StringComparer.Ordinal);
+                    int nextOrder = 0;
                     foreach (var (fieldName, role) in registeredFields)
                     {
                         if (!seen.Add(fieldName)) continue;
 
+                        if (declaredByName.TryGetValue(fieldName, out var declared))
+                        {
+                            orderedFields.Add(declared with { Order = nextOrder++ });
+                            continue;
+                        }
+
                         // A nullable registered field remains explicit trainable state. Preserve
                         // its conditional presence in the generated manifest; AIDN090 separately
                         // requires the author to declare the lifecycle that explains the null.
@@ -451,15 +571,48 @@ or ParameterMemberSemanticModel.Kind.Frozen
                         {
                             bool nullable = matchingField.NullableAnnotation == NullableAnnotation.Annotated
                                 || matchingField.Type.NullableAnnotation == NullableAnnotation.Annotated;
-                            paramFields.Add(new ParameterFieldInfo(
+                            orderedFields.Add(new ParameterFieldInfo(
                                 matchingField.Name, role, nextOrder++, DeclIndex: 0,
                                 TypeName: matchingField.Type.ToDisplayString(),
                                 Optional: nullable, Nullable: nullable));
                         }
                     }
+
+                    foreach (var declared in paramFields)
+                    {
+                        if (seen.Add(declared.Name))
+                            orderedFields.Add(declared with { Order = nextOrder++ });
+                    }
+
+                    paramFields = orderedFields;
                 }
             }
 
+            // Imperative registration can add fields that were not present during the first
+            // allocation-shape pass above. Complete the formulas after that merge so a deferred
+            // restore solves against the same full tensor set that Get/SetParameters folds.
+            inferredShapes = new string?[paramFields.Count];
+            hasInferredInputBinding = false;
+            for (int i = 0; i < paramFields.Count; i++)
+            {
+                if (paramFields[i].CollectionKind != ParameterCollectionKind.Direct
+                    || !string.IsNullOrWhiteSpace(paramFields[i].Shape))
+                    continue;
+                inferredShapes[i] = TryInferAllocationShape(
+                    compilation, classSymbol, paramFields[i].Name);
+                if (inferredShapes[i]?.IndexOf("InputShape[", System.StringComparison.Ordinal) >= 0)
+                    hasInferredInputBinding = true;
+            }
+            if (hasInferredInputBinding
+                && Enumerable.Range(0, paramFields.Count).All(index =>
+                    !string.IsNullOrWhiteSpace(paramFields[index].Shape)
+                    || !string.IsNullOrWhiteSpace(inferredShapes[index])))
+            {
+                for (int i = 0; i < paramFields.Count; i++)
+                    if (string.IsNullOrWhiteSpace(paramFields[i].Shape))
+                        paramFields[i] = paramFields[i] with { Shape = inferredShapes[i] };
+            }
+
             bool hasImperativePersistentRegistration =
                 ParameterMemberSemanticModel.GetRegistrationClassifications(classSymbol).Count > 0
                 || HasPersistentRegistrationInvocation(classSymbol);
@@ -476,10 +629,14 @@ or ParameterMemberSemanticModel.Kind.Frozen
                 && paramFields.Count == 0
                 && subLayerFields.Count == 0
                 && bufferFields.Count == 0;
-
             if (paramFields.Count == 0 && subLayerFields.Count == 0 && bufferFields.Count == 0
                 && !emitParameterFreeContract) continue;
 
+            // Only a generated child-layer graph can duplicate a legacy flat snapshot. Keep this
+            // syntax/semantic inspection off the overwhelmingly common leaf-layer path.
+            bool legacyParametersAreDerivedSnapshot = subLayerFields.Count > 0
+                && HasDerivedLegacyParameterSnapshot(compilation, classSymbol);
+
             // Stable sort by Order, preserving declaration order for equal Order values.
             // List.Sort is not stable, so we use a secondary key (original index).
             for (int idx = 0; idx < paramFields.Count; idx++)
@@ -494,7 +651,8 @@ or ParameterMemberSemanticModel.Kind.Frozen
             var unguardableAxes = new List<string>();
             var source = GenerateSource(
                 classSymbol, paramFields, gradientFields, subLayerFields, bufferFields,
-                useRuntimeParameterRegistry, emitParameterFreeContract, unguardableAxes);
+                useRuntimeParameterRegistry, useConventionalTensorEnumerator,
+                emitParameterFreeContract, legacyParametersAreDerivedSnapshot, unguardableAxes);
 
             // A declared axis the generator could not trace back to a guardable dimension. Emitting
             // the declaration anyway is what let ConvolutionalLayer publish [8, 0, 3, 3] from an
@@ -514,14 +672,69 @@ or ParameterMemberSemanticModel.Kind.Frozen
         }
     }
 
+    /// <summary>
+    /// Finds the legacy migration pattern where a composite caches its already-declared parameter
+    /// graph in <c>LayerBase.Parameters</c>. That vector is a derived snapshot, not another owned
+    /// component, and publishing both representations duplicates every nested parameter.
+    /// </summary>
+    private static bool HasDerivedLegacyParameterSnapshot(
+        Compilation compilation,
+        INamedTypeSymbol classSymbol)
+    {
+        foreach (var reference in classSymbol.DeclaringSyntaxReferences)
+        {
+            if (reference.GetSyntax() is not ClassDeclarationSyntax declaration) continue;
+
+            foreach (var assignment in declaration.DescendantNodes().OfType<AssignmentExpressionSyntax>())
+            {
+                // Reject nearly every assignment syntactically before requesting Roslyn's semantic
+                // model. Asking it to bind every assignment in every generated layer dominated the
+                // solution build even though only a handful use this migration pattern.
+                if (!assignment.IsKind(SyntaxKind.SimpleAssignmentExpression)
+                    || !IsIdentifierOrMemberNamed(assignment.Left, "Parameters")
+                    || assignment.Right is not InvocationExpressionSyntax invocation
+                    || invocation.ArgumentList.Arguments.Count != 0
+                    || !IsIdentifierOrMemberNamed(invocation.Expression, "GetParameters"))
+                {
+                    continue;
+                }
+
+                var semanticModel = compilation.GetSemanticModel(declaration.SyntaxTree);
+                if (semanticModel.GetSymbolInfo(assignment.Left).Symbol is not IFieldSymbol target
+                    || target.Name != "Parameters"
+                    || !IsOnTypeHierarchy(target.ContainingType, classSymbol)
+                    || semanticModel.GetSymbolInfo(invocation).Symbol is not IMethodSymbol method
+                    || method.Name != "GetParameters"
+                    || !IsOnTypeHierarchy(method.ContainingType, classSymbol))
+                {
+                    continue;
+                }
+
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    private static bool IsIdentifierOrMemberNamed(ExpressionSyntax expression, string name)
+        => expression switch
+        {
+            IdentifierNameSyntax identifier => identifier.Identifier.ValueText == name,
+            MemberAccessExpressionSyntax member => member.Name.Identifier.ValueText == name,
+            _ => false,
+        };
+
     private static string GenerateSource(
         INamedTypeSymbol classSymbol,
         List<ParameterFieldInfo> paramFields,
         Dictionary<string, GradientFieldInfo> gradientFields,
         List<SubLayerFieldInfo> subLayerFields,
-        List<(string Field, string Name, string Role, string StateRole)> bufferFields,
+        List<(string Field, string Name, string Role, string StateRole, bool InputSized, bool ReadOnly)> bufferFields,
         bool useRuntimeParameterRegistry,
+        bool useConventionalTensorEnumerator,
         bool emitParameterFreeContract,
+        bool legacyParametersAreDerivedSnapshot,
         ICollection<string>? unguardableAxes = null)
     {
         var ns = classSymbol.ContainingNamespace.ToDisplayString();
@@ -563,9 +776,18 @@ private static string GenerateSource(
         sb.AppendLine($"partial class {className}{typeParams}");
         sb.AppendLine("{");
 
+        if (legacyParametersAreDerivedSnapshot)
+        {
+            sb.AppendLine("    /// <summary>Auto-generated: the legacy flat vector is a derived view of declared parameter components.</summary>");
+            sb.AppendLine("    [global::System.CodeDom.Compiler.GeneratedCode(\"AiDotNet.Generators.TrainableParameterGenerator\", \"1.0.0\")]");
+            sb.AppendLine("    protected override bool LegacyParametersAreDerivedSnapshot => true;");
+            sb.AppendLine();
+        }
+
         if (emitParameterFreeContract)
         {
             sb.AppendLine("    /// <summary>Auto-generated: this migrated layer declares no persistent parameter state.</summary>");
+            sb.AppendLine("    [global::System.CodeDom.Compiler.GeneratedCode(\"AiDotNet.Generators.TrainableParameterGenerator\", \"1.0.0\")]");
             sb.AppendLine("    protected override bool IsDeclaredParameterFree => true;");
             sb.AppendLine();
         }
@@ -575,7 +797,9 @@ private static string GenerateSource(
         // order. This is what keeps a derived adapter's own tensors after the factors declared by
         // its base class without teaching the generator any model or adapter names.
         EmitOrderedParameterManifest(
-            sb, classSymbol, paramFields, subLayerFields, bufferFields);
+            sb, classSymbol,
+            useRuntimeParameterRegistry ? new List<ParameterFieldInfo>() : paramFields,
+            subLayerFields, bufferFields);
 
         // A complete local shape declaration can recover one deferred input axis from a flat
         // checkpoint length exactly. Emit the algebra from the author's Shape expressions so a
@@ -590,6 +814,7 @@ private static string GenerateSource(
         if (bufferFields.Count > 0)
         {
             sb.AppendLine("    /// <summary>Auto-generated: registers [Buffer] fields as persistent non-trainable state.</summary>");
+            sb.AppendLine("    [global::System.CodeDom.Compiler.GeneratedCode(\"AiDotNet.Generators.TrainableParameterGenerator\", \"1.0.0\")]");
             sb.AppendLine("    private void EnsureBuffersRegistered()");
             sb.AppendLine("    {");
             foreach (var bf in bufferFields)
@@ -599,12 +824,62 @@ private static string GenerateSource(
             sb.AppendLine("    }");
             sb.AppendLine();
             sb.AppendLine("    /// <inheritdoc />");
+            sb.AppendLine("    [global::System.CodeDom.Compiler.GeneratedCode(\"AiDotNet.Generators.TrainableParameterGenerator\", \"1.0.0\")]");
             sb.AppendLine($"    public override System.Collections.Generic.IReadOnlyList<(string Name, Tensor<{GetTypeParamName(classSymbol)}> Tensor)> GetRegisteredBuffers()");
             sb.AppendLine("    {");
             sb.AppendLine("        EnsureBuffersRegistered();");
             sb.AppendLine("        return base.GetRegisteredBuffers();");
             sb.AppendLine("    }");
             sb.AppendLine();
+
+            sb.AppendLine("    /// <inheritdoc />");
+            sb.AppendLine("    [global::System.CodeDom.Compiler.GeneratedCode(\"AiDotNet.Generators.TrainableParameterGenerator\", \"1.0.0\")]");
+            sb.AppendLine("    protected override bool CanRestoreBufferField(string name)");
+            sb.AppendLine("    {");
+            sb.AppendLine("        switch (name)");
+            sb.AppendLine("        {");
+            foreach (var bf in bufferFields)
+            {
+                if (bf.ReadOnly) continue;
+                sb.AppendLine($"            case \"{EscapeStringLiteral(bf.Name)}\":");
+                sb.AppendLine("                return true;");
+            }
+            sb.AppendLine("            default:");
+            sb.AppendLine("                return base.CanRestoreBufferField(name);");
+            sb.AppendLine("        }");
+            sb.AppendLine("    }");
+            sb.AppendLine();
+
+            // Restoring a buffer means writing the FIELD, not just the registry: EnsureBuffersRegistered
+            // reads each buffer out of its field, so a registration the field does not back is invisible
+            // to the layer's own code. The name-to-field mapping is emitted because only the generator
+            // has it; reflecting over it at runtime would turn a rename into a silent no-op.
+            sb.AppendLine("    /// <inheritdoc />");
+            sb.AppendLine("    [global::System.CodeDom.Compiler.GeneratedCode(\"AiDotNet.Generators.TrainableParameterGenerator\", \"1.0.0\")]");
+            sb.AppendLine($"    protected override bool TryRestoreBufferField(string name, Tensor<{GetTypeParamName(classSymbol)}> tensor)");
+            sb.AppendLine("    {");
+            sb.AppendLine("        switch (name)");
+            sb.AppendLine("        {");
+            foreach (var bf in bufferFields)
+            {
+                // A readonly buffer is assigned once, by the constructor, so it is ALWAYS live and
+                // the caller's write-through path restores it in place. Emitting a case for it
+                // would not compile, and would answer a question the restore never has to ask.
+                if (bf.ReadOnly) continue;
+
+                sb.AppendLine($"            case \"{EscapeStringLiteral(bf.Name)}\":");
+                sb.AppendLine($"                {bf.Field} = tensor;");
+                // Register HERE, not in the caller. A bare RegisterBuffer(tensor, name) takes the
+                // default state role, which silently promoted an input-sized slot back into the
+                // parameter vector the moment a clone or a restore installed one.
+                sb.AppendLine("                EnsureBuffersRegistered();");
+                sb.AppendLine("                return true;");
+            }
+            sb.AppendLine("            default:");
+            sb.AppendLine("                return base.TryRestoreBufferField(name, tensor);");
+            sb.AppendLine("        }");
+            sb.AppendLine("    }");
+            sb.AppendLine();
         }
 
 
@@ -613,8 +888,14 @@ private static string GenerateSource(
         // A composite's children do not all receive the composite's own input, and only the
         // composite knows which gets what. Declaring it on the field lets the generator supply that
         // fact to LayerBase.BringUpDeclaredSubLayers, so no composite implements the method.
+        // Collections included. A declaration names ONE width, which is exactly right for a bank of
+        // siblings that all read the same tensor -- an MoE's experts, for instance. Excluding them
+        // left those children to chained sizing, which walks the registration order and hands each
+        // expert whatever the PREVIOUS child emitted: MoEFeedForwardLayer registers its router
+        // first, so every expert was built against the router's numExperts-wide output instead of
+        // the hidden width, and a restore then rejected the saved weights outright.
         var shapedSubLayers = subLayerFields
-            .Where(sl => !sl.IsCollection && !string.IsNullOrWhiteSpace(sl.InputShape))
+            .Where(sl => !string.IsNullOrWhiteSpace(sl.InputShape))
             .ToList();
         if (shapedSubLayers.Count > 0)
         {
@@ -627,32 +908,58 @@ private static string GenerateSource(
             sb.AppendLine("    /// Auto-generated — do not modify. Edit the [SubLayerInput(\"...\")] arguments instead.");
             sb.AppendLine("    /// </summary>");
             sb.AppendLine("    /// <remarks>");
-            sb.AppendLine("    /// Empty while any declared child is still null or any axis is still negative: a composite");
-            sb.AppendLine("    /// builds its children inside its initializer, so both are ordinary states before that runs.");
-            sb.AppendLine("    /// Cached, because the initializer deliberately re-enters.");
+            sb.AppendLine("    /// Empty while a REQUIRED declared child is still null or any axis is still negative: a");
+            sb.AppendLine("    /// composite builds its children inside its initializer, so both are ordinary states before");
+            sb.AppendLine("    /// that runs. Cached, because the initializer deliberately re-enters.");
+            sb.AppendLine("    /// <para>");
+            sb.AppendLine("    /// A NULLABLE declared child is skipped instead, because null is a configuration there rather");
+            sb.AppendLine("    /// than a not-built-yet: a transformer block whose dropout rate is zero never constructs its");
+            sb.AppendLine("    /// dropout layers. Treating that as \"declaration not ready\" abandoned the whole declaration");
+            sb.AppendLine("    /// for the common configuration, so the composite fell back to chained sizing and its counted");
+            sb.AppendLine("    /// and materialized surfaces disagreed again.");
+            sb.AppendLine("    /// </para>");
             sb.AppendLine("    /// </remarks>");
+            sb.AppendLine("    [global::System.CodeDom.Compiler.GeneratedCode(\"AiDotNet.Generators.TrainableParameterGenerator\", \"1.0.0\")]");
             sb.AppendLine($"    protected override System.Collections.Generic.IReadOnlyList<{subTuple}> DeclaredSubLayerShapes()");
             sb.AppendLine("    {");
             sb.AppendLine("        if (__declaredSubLayerShapes is not null) return __declaredSubLayerShapes;");
-            foreach (var sl in shapedSubLayers)
+            foreach (var sl in shapedSubLayers.Where(sl => !sl.IsNullable && !sl.IsCollection))
             {
                 sb.AppendLine($"        if ({sl.Name} is null) return System.Array.Empty<{subArray}>();");
             }
-            sb.AppendLine($"        var __sub = new {subArray}[]");
-            sb.AppendLine("        {");
+            sb.AppendLine($"        var __sub = new System.Collections.Generic.List<{subArray}>({shapedSubLayers.Count});");
+            string tp = GetTypeParamName(classSymbol);
             foreach (var sl in shapedSubLayers)
             {
                 var axes = string.Join(", ", sl.InputShape!.Split(',').Select(a => a.Trim()).Where(a => a.Length > 0));
-                sb.AppendLine($"            ({sl.Name}, ShapeOf({axes})),");
+                if (sl.IsCollection)
+                {
+                    // Every element gets the declared width. Elements are filtered by type because a
+                    // collection may be declared as ILayer<T>, which carries no shape resolution.
+                    sb.AppendLine($"        if ({sl.Name} is not null)");
+                    sb.AppendLine("        {");
+                    sb.AppendLine($"            foreach (var __child in {sl.Name})");
+                    sb.AppendLine($"                if (__child is LayerBase<{tp}> __element)");
+                    sb.AppendLine($"                    __sub.Add((__element, ShapeOf({axes})));");
+                    sb.AppendLine("        }");
+                    continue;
+                }
+
+                string entry = $"__sub.Add(({sl.Name}, ShapeOf({axes})));";
+                if (sl.IsNullable) sb.AppendLine($"        if ({sl.Name} is not null) {entry}");
+                else sb.AppendLine($"        {entry}");
             }
-            sb.AppendLine("        };");
-            sb.AppendLine("        for (int __i = 0; __i < __sub.Length; __i++)");
+            sb.AppendLine("        for (int __i = 0; __i < __sub.Count; __i++)");
             sb.AppendLine("        {");
             sb.AppendLine("            var __s = __sub[__i].Item2;");
             sb.AppendLine("            for (int __d = 0; __d < __s.Length; __d++)");
-            sb.AppendLine($"                if (__s[__d] < 0) return System.Array.Empty<{subArray}>();");
+            // <= 0, not < 0. Every int field reads ZERO before the constructor assigns it, so a
+            // declaration consulted mid-construction produced a zero-width shape that passed a
+            // negative-only check and was then CACHED for the life of the layer. A width of zero is
+            // never a real one, so treating it as "not ready yet" is correct either way.
+            sb.AppendLine($"                if (__s[__d] <= 0) return System.Array.Empty<{subArray}>();");
             sb.AppendLine("        }");
-            sb.AppendLine("        __declaredSubLayerShapes = __sub;");
+            sb.AppendLine("        __declaredSubLayerShapes = __sub.ToArray();");
             sb.AppendLine("        return __declaredSubLayerShapes;");
             sb.AppendLine("    }");
             sb.AppendLine();
@@ -680,6 +987,7 @@ private static string GenerateSource(
                 ? "true"
                 : string.Join(" || ", shapedFields.Select(field => $"({field.Condition})"));
             sb.AppendLine("    /// <summary>Whether an active parameter declaration is waiting for its shape.</summary>");
+            sb.AppendLine("    [global::System.CodeDom.Compiler.GeneratedCode(\"AiDotNet.Generators.TrainableParameterGenerator\", \"1.0.0\")]");
             sb.AppendLine($"    protected override bool HasActiveDeclaredParameterShapes => {activeShapeDeclarations};");
             sb.AppendLine();
 
@@ -692,6 +1000,7 @@ private static string GenerateSource(
             sb.AppendLine("    /// signal that this layer cannot answer yet. An axis written as * becomes -2, meaning the layer");
             sb.AppendLine("    /// adapts that axis and a mismatch there is normal rather than a broken restore.");
             sb.AppendLine("    /// </remarks>");
+            sb.AppendLine("    [global::System.CodeDom.Compiler.GeneratedCode(\"AiDotNet.Generators.TrainableParameterGenerator\", \"1.0.0\")]");
             sb.AppendLine($"    protected override System.Collections.Generic.IReadOnlyList<{tupleType}> DeclaredParameterShapes()");
             sb.AppendLine("    {");
 
@@ -788,6 +1097,7 @@ private static string GenerateSource(
             string tensorTupleType = $"(Tensor<{tp2}>? Tensor, PersistentTensorRole Role)";
             sb.AppendLine("    /// <summary>The declared parameter slots and roles, without their shapes.</summary>");
             sb.AppendLine("    /// <remarks>Auto-generated — computes no axis, so an unresolved layer can still answer.</remarks>");
+            sb.AppendLine("    [global::System.CodeDom.Compiler.GeneratedCode(\"AiDotNet.Generators.TrainableParameterGenerator\", \"1.0.0\")]");
             sb.AppendLine($"    protected override System.Collections.Generic.IReadOnlyList<{tensorTupleType}> DeclaredParameterTensors()");
             sb.AppendLine("    {");
             sb.AppendLine($"        var __declared = new System.Collections.Generic.List<{tensorTupleType}>({tensorFields.Count});");
@@ -816,6 +1126,7 @@ private static string GenerateSource(
         {
             const string countShapeType = "AiDotNet.Tensors.LinearAlgebra.TensorShape";
             sb.AppendLine("    /// <summary>Concrete sizing view for bound adaptive parameter axes.</summary>");
+            sb.AppendLine("    [global::System.CodeDom.Compiler.GeneratedCode(\"AiDotNet.Generators.TrainableParameterGenerator\", \"1.0.0\")]");
             sb.AppendLine($"    protected override System.Collections.Generic.IReadOnlyList<{countShapeType}> DeclaredParameterCountShapes()");
             sb.AppendLine("    {");
             sb.AppendLine($"        var __declared = new System.Collections.Generic.List<{countShapeType}>({shapedFields.Count});");
@@ -837,6 +1148,29 @@ private static string GenerateSource(
             sb.AppendLine();
         }
 
+        // A few legacy layers already maintain a deliberate, complete parameter order in a
+        // parameterless GetAllTensors() helper. When that helper includes unclassified storage,
+        // the annotated fields are necessarily only a subset; emitting the subset would hide
+        // real weights from serialization and cloning. Reuse the author's explicit enumeration
+        // and let LayerBase perform the identity-based field/container rebind.
+        if (useConventionalTensorEnumerator)
+        {
+            string tensorType = $"Tensor<{GetTypeParamName(classSymbol)}>";
+            sb.AppendLine("    /// <summary>Returns the complete convention-enumerated trainable tensor surface.</summary>");
+            sb.AppendLine("    [global::System.CodeDom.Compiler.GeneratedCode(\"AiDotNet.Generators.TrainableParameterGenerator\", \"1.0.0\")]");
+            sb.AppendLine($"    public override System.Collections.Generic.IReadOnlyList<{tensorType}> GetTrainableParameters()");
+            sb.AppendLine("        => GetAllTensors();");
+            sb.AppendLine();
+            sb.AppendLine("    [global::System.CodeDom.Compiler.GeneratedCode(\"AiDotNet.Generators.TrainableParameterGenerator\", \"1.0.0\")]");
+            sb.AppendLine($"    protected override System.Collections.Generic.IReadOnlyList<{tensorType}> GetTrainableParametersUnmaterialized()");
+            sb.AppendLine("        => GetAllTensors();");
+            sb.AppendLine();
+            sb.AppendLine("    [global::System.CodeDom.Compiler.GeneratedCode(\"AiDotNet.Generators.TrainableParameterGenerator\", \"1.0.0\")]");
+            sb.AppendLine($"    public override void SetTrainableParameters(System.Collections.Generic.IReadOnlyList<{tensorType}> parameters)");
+            sb.AppendLine("        => SetConventionEnumeratedTrainableParameters(GetAllTensors(), parameters);");
+            sb.AppendLine();
+        }
+
         // GetTrainableParameters
         bool hasCollections = paramFields.Any(p => p.CollectionKind != ParameterCollectionKind.Direct);
         bool hasOptional = paramFields.Any(p =>
@@ -851,6 +1185,7 @@ private static string GenerateSource(
                 sb.AppendLine($"    private System.Collections.ObjectModel.ReadOnlyCollection<{tensorType}>? __aidnTrainableParameterView;");
                 sb.AppendLine();
                 sb.AppendLine("    /// <summary>Returns the stable, allocation-free view of fixed generated parameter fields.</summary>");
+                sb.AppendLine("    [global::System.CodeDom.Compiler.GeneratedCode(\"AiDotNet.Generators.TrainableParameterGenerator\", \"1.0.0\")]");
                 sb.AppendLine($"    private System.Collections.Generic.IReadOnlyList<{tensorType}> __aidnGetTrainableParameterView()");
                 sb.AppendLine("    {");
                 sb.AppendLine("        var __storage = System.Threading.Volatile.Read(ref __aidnTrainableParameterViewStorage);");
@@ -872,6 +1207,7 @@ private static string GenerateSource(
                 sb.AppendLine("        return __view;");
                 sb.AppendLine("    }");
                 sb.AppendLine();
+                sb.AppendLine("    [global::System.CodeDom.Compiler.GeneratedCode(\"AiDotNet.Generators.TrainableParameterGenerator\", \"1.0.0\")]");
                 sb.AppendLine("    private void __aidnRefreshTrainableParameterViewIfCreated()");
                 sb.AppendLine("    {");
                 sb.AppendLine("        var __storage = System.Threading.Volatile.Read(ref __aidnTrainableParameterViewStorage);");
@@ -906,6 +1242,7 @@ private static string GenerateSource(
                 sb.AppendLine("    /// emitted symmetrically (consumes a slot only for currently-present fields).");
             }
             sb.AppendLine("    /// </remarks>");
+            sb.AppendLine("    [global::System.CodeDom.Compiler.GeneratedCode(\"AiDotNet.Generators.TrainableParameterGenerator\", \"1.0.0\")]");
             sb.AppendLine($"    public override System.Collections.Generic.IReadOnlyList<Tensor<{GetTypeParamName(classSymbol)}>> GetTrainableParameters()");
             sb.AppendLine("    {");
             if (subLayerFields.Count > 0)
@@ -940,6 +1277,7 @@ private static string GenerateSource(
             // 774M-parameter model. Sub-layer registration is still performed -- it allocates
             // nothing and the count would otherwise miss children.
             sb.AppendLine("    /// <summary>Field list for ParameterCount: no lazy materialization.</summary>");
+            sb.AppendLine("    [global::System.CodeDom.Compiler.GeneratedCode(\"AiDotNet.Generators.TrainableParameterGenerator\", \"1.0.0\")]");
             sb.AppendLine($"    protected override System.Collections.Generic.IReadOnlyList<Tensor<{GetTypeParamName(classSymbol)}>> GetTrainableParametersUnmaterialized()");
             sb.AppendLine("    {");
             if (subLayerFields.Count > 0)
@@ -967,6 +1305,7 @@ private static string GenerateSource(
             sb.AppendLine("    /// Replaces trainable parameter tensors (e.g., with ParameterBuffer views).");
             sb.AppendLine("    /// Auto-generated — updates both the field and the registered tensor list.");
             sb.AppendLine("    /// </summary>");
+            sb.AppendLine("    [global::System.CodeDom.Compiler.GeneratedCode(\"AiDotNet.Generators.TrainableParameterGenerator\", \"1.0.0\")]");
             sb.AppendLine($"    public override void SetTrainableParameters(System.Collections.Generic.IReadOnlyList<Tensor<{GetTypeParamName(classSymbol)}>> parameters)");
             sb.AppendLine("    {");
             // Local helper: emit the assignment of a field from a parameters[idx]
@@ -975,6 +1314,29 @@ private static string GenerateSource(
             // or a post-increment cursor (optional path).
             void EmitFieldAssign(ParameterFieldInfo pf, string indexExpr, string idxLabel)
             {
+                // A READONLY field cannot be REASSIGNED outside its constructor, so the assignment below
+                // does not compile for one (CS0191). Skipping such a field instead would be far worse:
+                // these are genuine trainable weights, and dropping them from the surface is exactly the
+                // silent weight loss this generator exists to prevent.
+                //
+                // So the VALUES are copied into the tensor the constructor already built. That is not
+                // merely a workaround for readonly -- it is the better restore in general, because
+                // replacing the tensor breaks the REFERENCE IDENTITY the tape and ParameterBuffer align
+                // on, which is the hazard CifAlignmentLayer's own remarks describe. A shape
+                // disagreement is a real disagreement and says so rather than silently resizing.
+                if (pf.IsReadOnly)
+                {
+                    sb.AppendLine("        {");
+                    sb.AppendLine($"            var __src = parameters[{indexExpr}] ?? throw new System.ArgumentNullException(nameof(parameters), \"Parameter at index {idxLabel} is null.\");");
+                    sb.AppendLine($"            if (__src.Length != {pf.Name}.Length)");
+                    sb.AppendLine($"                throw new System.ArgumentException($\"Parameter at index {idxLabel} has {{__src.Length}} values but '{pf.Name}' holds {{{pf.Name}.Length}}.\", nameof(parameters));");
+                    sb.AppendLine($"            for (int __c = 0; __c < {pf.Name}.Length; __c++) {{ {pf.Name}[__c] = __src[__c]; }}");
+                    sb.AppendLine("        }");
+                    if (pf.LowPrecisionBacking is not null)
+                        sb.AppendLine($"        {pf.LowPrecisionBacking} = null;");
+                    return;
+                }
+
                 bool needsCast = pf.TypeName is not null
                     && !(pf.TypeName.StartsWith(TensorTypeName + "<") || pf.TypeName == TensorTypeName);
                 if (needsCast)
@@ -1132,6 +1494,7 @@ void EmitFieldAssign(ParameterFieldInfo pf, string indexExpr, string idxLabel)
             sb.AppendLine("    /// Clears all gradient fields discovered by convention ({paramName}Gradient).");
             sb.AppendLine("    /// Auto-generated from [TrainableParameter] field naming conventions.");
             sb.AppendLine("    /// </summary>");
+            sb.AppendLine("    [global::System.CodeDom.Compiler.GeneratedCode(\"AiDotNet.Generators.TrainableParameterGenerator\", \"1.0.0\")]");
             sb.AppendLine("    public override void ZeroGrad()");
             sb.AppendLine("    {");
             sb.AppendLine("        base.ZeroGrad();");
@@ -1166,6 +1529,7 @@ void EmitFieldAssign(ParameterFieldInfo pf, string indexExpr, string idxLabel)
             sb.AppendLine("    /// Auto-generated from [TrainableParameter] fields per issue #1136 plan part 3.");
             sb.AppendLine("    /// Called from <see cref=\"LayerBase{T}.Dispose(bool)\"/>; do not call directly.");
             sb.AppendLine("    /// </summary>");
+            sb.AppendLine("    [global::System.CodeDom.Compiler.GeneratedCode(\"AiDotNet.Generators.TrainableParameterGenerator\", \"1.0.0\")]");
             sb.AppendLine("    protected override void ReturnPooledParameters()");
             sb.AppendLine("    {");
             sb.AppendLine("        // Lazy-init layers that never received a Forward have zero-length");
@@ -1208,6 +1572,7 @@ void EmitFieldAssign(ParameterFieldInfo pf, string indexExpr, string idxLabel)
             // layers -- ColumnParallelLinear, RowParallelLinear, Stage3ShardedLinear -- hit
             // exactly that once they became partial. A sealed class cannot be derived from, so
             // the modifier carries no meaning there anyway.
+            sb.AppendLine("    [global::System.CodeDom.Compiler.GeneratedCode(\"AiDotNet.Generators.TrainableParameterGenerator\", \"1.0.0\")]");
             sb.AppendLine($"    public {(classSymbol.IsSealed ? "" : "virtual ")}System.Collections.Generic.Dictionary<string, string> GetParameterRoles()");
             sb.AppendLine("    {");
             sb.AppendLine($"        return new System.Collections.Generic.Dictionary<string, string>");
@@ -1228,6 +1593,7 @@ void EmitFieldAssign(ParameterFieldInfo pf, string indexExpr, string idxLabel)
         {
             sb.AppendLine();
             sb.AppendLine("    /// <summary>Auto-generated: this layer owns child-module structure.</summary>");
+            sb.AppendLine("    [global::System.CodeDom.Compiler.GeneratedCode(\"AiDotNet.Generators.TrainableParameterGenerator\", \"1.0.0\")]");
             sb.AppendLine("    protected override bool HasDeclaredSubLayerStructure => true;");
             sb.AppendLine();
             sb.AppendLine("    private bool _subLayersRegistered;");
@@ -1244,6 +1610,7 @@ void EmitFieldAssign(ParameterFieldInfo pf, string indexExpr, string idxLabel)
             sb.AppendLine("    /// Register what exists and latch only when nothing was missing — registration is");
             sb.AppendLine("    /// identity-based and idempotent, so the retry after initialization is free.");
             sb.AppendLine("    /// </remarks>");
+            sb.AppendLine("    [global::System.CodeDom.Compiler.GeneratedCode(\"AiDotNet.Generators.TrainableParameterGenerator\", \"1.0.0\")]");
             sb.AppendLine("    private void EnsureSubLayersRegistered()");
             sb.AppendLine("    {");
             sb.AppendLine("        if (_subLayersRegistered) return;");
@@ -1281,6 +1648,7 @@ void EmitFieldAssign(ParameterFieldInfo pf, string indexExpr, string idxLabel)
                 sb.AppendLine("    /// Auto-generated EnsureInitialized: registers sub-layers (cheap), then");
                 sb.AppendLine("    /// delegates to base for weight allocation.");
                 sb.AppendLine("    /// </summary>");
+                sb.AppendLine("    [global::System.CodeDom.Compiler.GeneratedCode(\"AiDotNet.Generators.TrainableParameterGenerator\", \"1.0.0\")]");
                 sb.AppendLine("    protected override void EnsureInitialized()");
                 sb.AppendLine("    {");
                 sb.AppendLine("        EnsureSubLayersRegistered();");
@@ -1300,6 +1668,7 @@ void EmitFieldAssign(ParameterFieldInfo pf, string indexExpr, string idxLabel)
                 // constructor: that places children in front of the pre-step buffer-view walk
                 // beside the parent that already handles them, which silently breaks training.
                 sb.AppendLine("    /// <inheritdoc />");
+                sb.AppendLine("    [global::System.CodeDom.Compiler.GeneratedCode(\"AiDotNet.Generators.TrainableParameterGenerator\", \"1.0.0\")]");
                 sb.AppendLine($"    public override System.Collections.Generic.IReadOnlyList<ILayer<{GetTypeParamName(classSymbol)}>> GetSubLayers()");
                 sb.AppendLine("    {");
                 sb.AppendLine("        EnsureSubLayersRegistered();");
@@ -1324,7 +1693,7 @@ private static void EmitOrderedParameterManifest(
         INamedTypeSymbol classSymbol,
         List<ParameterFieldInfo> paramFields,
         List<SubLayerFieldInfo> subLayerFields,
-        List<(string Field, string Name, string Role, string StateRole)> bufferFields)
+        List<(string Field, string Name, string Role, string StateRole, bool InputSized, bool ReadOnly)> bufferFields)
     {
         if (paramFields.Count == 0 && subLayerFields.Count == 0 && bufferFields.Count == 0)
             return;
@@ -1348,6 +1717,7 @@ private static void EmitOrderedParameterManifest(
         var emittedParameters = new HashSet<string>(System.StringComparer.Ordinal);
 
         sb.AppendLine("    /// <summary>Appends generated parameter components in inheritance and declaration order.</summary>");
+        sb.AppendLine("    [global::System.CodeDom.Compiler.GeneratedCode(\"AiDotNet.Generators.TrainableParameterGenerator\", \"1.0.0\")]");
         sb.AppendLine("    protected override void AppendDeclaredParameterComponents(");
         sb.AppendLine("        System.Collections.Generic.List<DeclaredParameterComponent> components)");
         sb.AppendLine("    {");
@@ -1365,6 +1735,15 @@ private static void EmitOrderedParameterManifest(
 
             if (buffersByName.TryGetValue(field.Name, out var buffer))
             {
+                // An input-sized member is registered (and therefore serialized and deep-copied)
+                // but never declared as a component, so it contributes no width to the parameter
+                // vector and ParameterCount stays a function of construction alone.
+                if (buffer.InputSized)
+                {
+                    sb.AppendLine($"        // {buffer.Field}: [FittedParameter(InputSized = true)] -- persisted as a buffer, not a parameter.");
+                    continue;
+                }
+
                 sb.AppendLine($"        DeclareParameterBuffer(components, {buffer.Field}, \"{EscapeStringLiteral(buffer.Name)}\", {buffer.StateRole});");
                 continue;
             }
@@ -1430,11 +1809,15 @@ private static void EmitDeferredInputShapeInference(
         INamedTypeSymbol classSymbol,
         List<ParameterFieldInfo> paramFields,
         List<SubLayerFieldInfo> subLayerFields,
-        List<(string Field, string Name, string Role, string StateRole)> bufferFields)
+        List<(string Field, string Name, string Role, string StateRole, bool InputSized, bool ReadOnly)> bufferFields)
     {
+        // Buffers no longer disqualify the formula outright; the emitted method checks at RUNTIME
+        // that none is live. Excluding them statically cost DenseLayer -- the most restored layer in
+        // the library -- its inference, purely because it declares two optimizer-velocity buffers
+        // that are null until training allocates them, and training cannot precede the resolution
+        // this infers. A restore into a fresh deferred layer therefore always sees them empty.
         bool completeLocalFormula = paramFields.Count > 0
             && subLayerFields.Count == 0
-            && bufferFields.Count == 0
             && paramFields.All(field => field.CollectionKind == ParameterCollectionKind.Direct
                 && !field.Optional
                 && field.Condition is null
@@ -1454,9 +1837,27 @@ private static void EmitDeferredInputShapeInference(
         if (referencedAxes.Count == 0) return;
 
         sb.AppendLine("    /// <summary>Infers one deferred input axis from complete generated parameter-shape formulas.</summary>");
+        sb.AppendLine("    [global::System.CodeDom.Compiler.GeneratedCode(\"AiDotNet.Generators.TrainableParameterGenerator\", \"1.0.0\")]");
         sb.AppendLine("    protected override bool TryInferInputShapeFromParameterCount(int parameterCount, out int[] inputShape)");
         sb.AppendLine("    {");
-        sb.AppendLine("        if (Parameters.Length == 0)");
+        var countedBuffers = bufferFields.Where(buffer => !buffer.InputSized).ToList();
+        if (countedBuffers.Count > 0)
+        {
+            sb.AppendLine("        // The formula below counts this layer's PARAMETERS. A live buffer is counted too, so");
+            sb.AppendLine("        // inferring while one exists would solve the wrong equation and resolve to a wrong width.");
+            sb.AppendLine("        // Input-sized buffers are absent from the vector, so they never perturb the equation");
+            sb.AppendLine("        // and must NOT block inference -- a graph layer holds one for its whole life.");
+            sb.AppendLine("        bool __noLiveBuffer = true;");
+            foreach (var buffer in countedBuffers)
+            {
+                sb.AppendLine($"        if ({buffer.Field} is not null) __noLiveBuffer = false;");
+            }
+            sb.AppendLine("        if (__noLiveBuffer && Parameters.Length == 0)");
+        }
+        else
+        {
+            sb.AppendLine("        if (Parameters.Length == 0)");
+        }
         sb.AppendLine("        {");
 
         foreach (int axis in referencedAxes)
@@ -1464,8 +1865,8 @@ private static void EmitDeferredInputShapeInference(
             sb.AppendLine($"            if (InputShape.Length > {axis} && InputShape[{axis}] <= 0)");
             sb.AppendLine("            {");
             sb.AppendLine("                bool __onlyUnknownAxis = true;");
-            sb.AppendLine("                for (int __axis = 0; __axis < InputShape.Length; __axis++)");
-            sb.AppendLine($"                    if (__axis != {axis} && InputShape[__axis] <= 0) __onlyUnknownAxis = false;");
+            foreach (int otherAxis in referencedAxes.Where(candidate => candidate != axis))
+                sb.AppendLine($"                if (InputShape.Length <= {otherAxis} || InputShape[{otherAxis}] <= 0) __onlyUnknownAxis = false;");
             sb.AppendLine("                if (__onlyUnknownAxis)");
             sb.AppendLine("                {");
             sb.AppendLine("                    long __atOne = 0;");
@@ -1508,6 +1909,193 @@ private static void EmitDeferredInputShapeInference(
         sb.AppendLine();
     }
 
+    /// <summary>
+    /// Finds the highest-information <c>[axis, ...]</c> expression assigned to one tensor field.
+    /// Locals and constructor parameters are rejected because generated members cannot read them;
+    /// literals and layer fields/properties remain valid construction formulas.
+    /// </summary>
+    private static string? TryInferAllocationShape(
+        Compilation compilation,
+        INamedTypeSymbol classSymbol,
+        string fieldName)
+    {
+        var field = classSymbol.GetMembers(fieldName).OfType<IFieldSymbol>().FirstOrDefault();
+        if (field is null) return null;
+
+        string? best = null;
+        int bestScore = -1;
+        foreach (var reference in classSymbol.DeclaringSyntaxReferences)
+        {
+            if (reference.GetSyntax() is not ClassDeclarationSyntax declaration) continue;
+            var semanticModel = compilation.GetSemanticModel(declaration.SyntaxTree);
+            foreach (var assignment in declaration.DescendantNodes().OfType<AssignmentExpressionSyntax>())
+            {
+                if (!assignment.IsKind(SyntaxKind.SimpleAssignmentExpression)
+                    || !SymbolEqualityComparer.Default.Equals(
+                        semanticModel.GetSymbolInfo(assignment.Left).Symbol, field))
+                    continue;
+
+                var collection = assignment.Right.DescendantNodesAndSelf()
+                    .OfType<CollectionExpressionSyntax>()
+                    .FirstOrDefault();
+                if (collection is null || collection.Elements.Count == 0
+                    || collection.Elements.Any(element => element is not ExpressionElementSyntax))
+                    continue;
+
+                var axes = collection.Elements.Cast<ExpressionElementSyntax>()
+                    .Select(element => element.Expression)
+                    .ToList();
+                bool safe = true;
+                foreach (var identifier in axes.SelectMany(axis =>
+                             axis.DescendantNodesAndSelf().OfType<IdentifierNameSyntax>()))
+                {
+                    ISymbol? symbol = semanticModel.GetSymbolInfo(identifier).Symbol;
+                    if (symbol is IFieldSymbol fieldSymbol
+                        && IsOnTypeHierarchy(fieldSymbol.ContainingType, classSymbol))
+                        continue;
+                    if (symbol is IPropertySymbol propertySymbol
+                        && IsOnTypeHierarchy(propertySymbol.ContainingType, classSymbol))
+                        continue;
+                    if (symbol is ITypeSymbol) continue;
+                    safe = false;
+                    break;
+                }
+                if (!safe) continue;
+
+                string rendered = string.Join(", ", axes.Select(axis => axis.ToString()));
+                string? inputChannels = InputChannelShapeExpression(classSymbol);
+                if (inputChannels is not null)
+                {
+                    rendered = Regex.Replace(
+                        rendered,
+                        @"\b_?inputDepth\b",
+                        inputChannels,
+                        RegexOptions.IgnoreCase);
+                }
+                int score = axes.Sum(axis =>
+                    axis.DescendantNodesAndSelf().OfType<IdentifierNameSyntax>().Count() * 10
+                    + axis.DescendantNodesAndSelf().OfType<LiteralExpressionSyntax>()
+                        .Count(literal => literal.Token.ValueText != "0"));
+                if (score <= bestScore) continue;
+                best = rendered;
+                bestScore = score;
+            }
+        }
+        return best;
+    }
+
+    /// <summary>
+    /// Resolves the declared input-channel axis without assuming a channels-first layout.
+    /// </summary>
+    /// <remarks>
+    /// <c>_inputDepth</c> is the historical name for input channel count in convolution layers. It
+    /// is not necessarily axis zero: NHWC places it last, NCHW places it third from last, and 3-D
+    /// NCDHW places it fourth from last. Measuring from the end also makes an optional leading batch
+    /// axis irrelevant. If declarations disagree, leave the field expression untouched so normal
+    /// deferred restoration can resolve it instead of generating a confidently wrong shape.
+    /// </remarks>
+    private static string? InputChannelShapeExpression(INamedTypeSymbol classSymbol)
+    {
+        int? offsetFromEnd = null;
+        bool foundInputLayout = false;
+        foreach (var attribute in classSymbol.GetAttributes())
+        {
+            if (attribute.AttributeClass?.ToDisplayString()
+                != "AiDotNet.Attributes.TensorLayoutAttribute")
+                continue;
+
+            bool isOutput = attribute.NamedArguments.Any(argument =>
+                argument.Key == "Direction"
+                && argument.Value.Value is int direction
+                && direction == 1);
+            if (isOutput) continue;
+            foundInputLayout = true;
+
+            if (attribute.ConstructorArguments.Length == 0
+                || attribute.ConstructorArguments[0].Kind != TypedConstantKind.Array)
+                return null;
+            var axes = attribute.ConstructorArguments[0].Values;
+            int channelIndex = -1;
+            for (int i = 0; i < axes.Length; i++)
+            {
+                if (EnumMemberName(axes[i]) == "Channels")
+                {
+                    channelIndex = i;
+                    break;
+                }
+            }
+            if (channelIndex < 0) return null;
+
+            int candidate = axes.Length - channelIndex;
+            if (offsetFromEnd.HasValue && offsetFromEnd.Value != candidate) return null;
+            offsetFromEnd = candidate;
+        }
+
+        if (!foundInputLayout || !offsetFromEnd.HasValue) return null;
+        return offsetFromEnd.Value == 1
+            ? "InputShape[InputShape.Length - 1]"
+            : $"InputShape[InputShape.Length - {offsetFromEnd.Value}]";
+    }
+
+    private static string? EnumMemberName(TypedConstant value)
+    {
+        if (value.Type is not INamedTypeSymbol enumType || value.Value is null) return null;
+        foreach (var member in enumType.GetMembers().OfType<IFieldSymbol>())
+        {
+            if (!member.HasConstantValue || member.ConstantValue is null) continue;
+            if (Equals(member.ConstantValue, value.Value)) return member.Name;
+        }
+        return null;
+    }
+
+    private static bool IsOnTypeHierarchy(INamedTypeSymbol? candidate, INamedTypeSymbol type)
+    {
+        for (var current = type; current is not null; current = current.BaseType)
+            if (SymbolEqualityComparer.Default.Equals(current, candidate)) return true;
+        return false;
+    }
+
+    private static bool TryGetRegisteredBufferDeclaration(
+        INamedTypeSymbol owner,
+        string fieldName,
+        out string name,
+        out string role)
+    {
+        foreach (var reference in owner.DeclaringSyntaxReferences)
+        {
+            if (reference.GetSyntax() is not ClassDeclarationSyntax declaration) continue;
+            foreach (var invocation in declaration.DescendantNodes().OfType<InvocationExpressionSyntax>())
+            {
+                string? callName = invocation.Expression switch
+                {
+                    IdentifierNameSyntax identifier => identifier.Identifier.ValueText,
+                    MemberAccessExpressionSyntax access => access.Name.Identifier.ValueText,
+                    _ => null
+                };
+                if (callName != "RegisterBuffer" || invocation.ArgumentList.Arguments.Count < 3)
+                    continue;
+                if (!invocation.ArgumentList.Arguments[0].Expression.DescendantNodesAndSelf()
+                    .OfType<IdentifierNameSyntax>()
+                    .Any(identifier => identifier.Identifier.ValueText == fieldName))
+                    continue;
+
+                string candidate = invocation.ArgumentList.Arguments[2].Expression.ToString();
+                if (candidate.IndexOf("PersistentTensorRole.", System.StringComparison.Ordinal) < 0)
+                    continue;
+                var nameExpression = invocation.ArgumentList.Arguments[1].Expression;
+                name = nameExpression is LiteralExpressionSyntax literal
+                    && literal.IsKind(SyntaxKind.StringLiteralExpression)
+                        ? literal.Token.ValueText
+                        : fieldName.TrimStart('_');
+                role = candidate;
+                return true;
+            }
+        }
+        name = string.Empty;
+        role = string.Empty;
+        return false;
+    }
+
     private static string ShapeProduct(string shape, int inputAxis, string replacement)
     {
         var axes = shape.Split(',')
@@ -1832,6 +2420,49 @@ private static bool DeclaresAny(INamedTypeSymbol type, params string[] names)
         return false;
     }
 
+    /// <summary>
+    /// Recognizes an explicit, ordered <c>GetAllTensors()</c> convention only when it closes a
+    /// real declaration gap. A helper whose referenced tensor fields are all already classified
+    /// does not change generated ordering; one that deliberately includes unclassified storage is
+    /// the authoritative compatibility surface for that legacy layer.
+    /// </summary>
+    private static bool HasUnclassifiedConventionalTensorEnumerator(
+        Compilation compilation,
+        INamedTypeSymbol classSymbol)
+    {
+        var method = classSymbol.GetMembers("GetAllTensors")
+            .OfType<IMethodSymbol>()
+            .FirstOrDefault(candidate =>
+                !candidate.IsStatic
+                && candidate.Parameters.Length == 0
+                && candidate.ReturnType is IArrayTypeSymbol array
+                && IsTensorOfLayerElement(array.ElementType, classSymbol));
+        if (method is null) return false;
+
+        foreach (var syntaxReference in method.DeclaringSyntaxReferences)
+        {
+            var syntax = syntaxReference.GetSyntax();
+            var semanticModel = compilation.GetSemanticModel(syntax.SyntaxTree);
+            foreach (var identifier in syntax.DescendantNodesAndSelf().OfType<IdentifierNameSyntax>())
+            {
+                if (semanticModel.GetSymbolInfo(identifier).Symbol is not IFieldSymbol field
+                    || !SymbolEqualityComparer.Default.Equals(field.ContainingType, classSymbol)
+                    || !ParameterMemberSemanticModel.IsNumericStateStorage(field.Type))
+                {
+                    continue;
+                }
+
+                if (ParameterMemberSemanticModel.Classify(field).Kind
+                    == ParameterMemberSemanticModel.Kind.Unclassified)
+                {
+                    return true;
+                }
+            }
+        }
+
+        return false;
+    }
+
     private static bool ExtendsLayerBase(INamedTypeSymbol type)
     {
         var current = type.BaseType;
@@ -1966,6 +2597,54 @@ private static bool IsLayerCollectionType(ITypeSymbol type)
         return false;
     }
 
+    /// <summary>
+    /// Recognizes a collection that is only an alternate traversal of child fields already owned
+    /// by the same layer. Publishing both the fields and the aggregate gives one object several
+    /// manifest slots; runtime registration cannot make that compile-time declaration unambiguous.
+    /// </summary>
+    private static bool IsAliasLayerCollection(
+        Compilation compilation,
+        INamedTypeSymbol owner,
+        IFieldSymbol collectionField)
+    {
+        foreach (var reference in owner.DeclaringSyntaxReferences)
+        {
+            if (reference.GetSyntax() is not ClassDeclarationSyntax declaration) continue;
+            var semanticModel = compilation.GetSemanticModel(declaration.SyntaxTree);
+
+            foreach (var assignment in declaration.DescendantNodes().OfType<AssignmentExpressionSyntax>())
+            {
+                if (!assignment.IsKind(SyntaxKind.SimpleAssignmentExpression)
+                    || !SymbolEqualityComparer.Default.Equals(
+                        semanticModel.GetSymbolInfo(assignment.Left).Symbol, collectionField)
+                    || assignment.Right is not CollectionExpressionSyntax collection
+                    || collection.Elements.Count == 0)
+                {
+                    continue;
+                }
+
+                bool aliasesOwnedFields = true;
+                foreach (var element in collection.Elements)
+                {
+                    if (element is not ExpressionElementSyntax expressionElement
+                        || semanticModel.GetSymbolInfo(expressionElement.Expression).Symbol
+                            is not IFieldSymbol childField
+                        || SymbolEqualityComparer.Default.Equals(childField, collectionField)
+                        || !SymbolEqualityComparer.Default.Equals(childField.ContainingType, owner)
+                        || !IsLayerType(childField.Type))
+                    {
+                        aliasesOwnedFields = false;
+                        break;
+                    }
+                }
+
+                if (aliasesOwnedFields) return true;
+            }
+        }
+
+        return false;
+    }
+
     /// <summary>
     /// A parameter-free declaration is a closed-world claim. Prove that no base type contributes
     /// trainable fields, buffers, registered state, or child modules before emitting it.
@@ -2030,7 +2709,8 @@ private static bool HasPersistentRegistrationInvocation(INamedTypeSymbol type)
                 };
                 if (callName is "RegisterTrainableParameter"
                     or "RegisterBuffer"
-                    or "RegisterParameterComponent")
+                    or "RegisterParameterComponent"
+                    or "RegisterSubLayer")
                 {
                     return true;
                 }
@@ -2387,7 +3067,8 @@ private record struct ParameterFieldInfo(
         string? Shape = null,
         ParameterCollectionKind CollectionKind = ParameterCollectionKind.Direct,
         string? Condition = null,
-        string? LowPrecisionBacking = null);
+        string? LowPrecisionBacking = null,
+        bool IsReadOnly = false);
     private record struct GradientFieldInfo(string Name, bool IsNullable);
     private record struct SubLayerFieldInfo(string Name, bool IsNullable, bool IsCollection, string? InputShape = null);
 }
diff --git a/src/AiDotNet.Serving/ProgramSynthesis/ServingHeuristicCodeModel.cs b/src/AiDotNet.Serving/ProgramSynthesis/ServingHeuristicCodeModel.cs
index ebcd62f63c..b80810249e 100644
--- a/src/AiDotNet.Serving/ProgramSynthesis/ServingHeuristicCodeModel.cs
+++ b/src/AiDotNet.Serving/ProgramSynthesis/ServingHeuristicCodeModel.cs
@@ -46,35 +46,6 @@ public override ModelMetadata<double> GetModelMetadata()
         };
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write((int)_architecture.TargetLanguage);
-        writer.Write(_architecture.MaxSequenceLength);
-        writer.Write(_architecture.VocabularySize);
-    }
-
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        var targetLanguage = (ProgramLanguage)reader.ReadInt32();
-        var maxSeqLength = reader.ReadInt32();
-        var vocabSize = reader.ReadInt32();
-
-        if (targetLanguage != _architecture.TargetLanguage ||
-            maxSeqLength != _architecture.MaxSequenceLength ||
-            vocabSize != _architecture.VocabularySize)
-        {
-            throw new InvalidOperationException(
-                $"Serialized model architecture does not match this instance. " +
-                $"Serialized: Language={targetLanguage}, MaxSequenceLength={maxSeqLength}, VocabularySize={vocabSize}. " +
-                $"Instance: Language={_architecture.TargetLanguage}, MaxSequenceLength={_architecture.MaxSequenceLength}, VocabularySize={_architecture.VocabularySize}.");
-        }
-    }
-
-    protected override IFullModel<double, Tensor<double>, Tensor<double>> CreateNewInstance()
-    {
-        return new ServingHeuristicCodeModel(_architecture);
-    }
-
     public static ServingHeuristicCodeModel CreateDefault(ProgramLanguage targetLanguage = ProgramLanguage.Generic)
     {
         var architecture = new CodeSynthesisArchitecture<double>(
diff --git a/src/AiDotNet.csproj b/src/AiDotNet.csproj
index 77db799e17..acf176e56f 100644
--- a/src/AiDotNet.csproj
+++ b/src/AiDotNet.csproj
@@ -241,6 +241,17 @@
 	  <None Remove="AiDotNet.Generators\**\*" />
 	</ItemGroup>
 
+	<!-- Ship the same generator/analyzer assembly to NuGet consumers. A ProjectReference makes it
+	     run only for source checkouts; placing it under NuGet's conventional analyzer path makes
+	     generated layer factories automatic for PackageReference consumers too. This Include must
+	     follow the broad generator-project exclusion above so it is not removed from the package. -->
+	<ItemGroup>
+	  <None Include="AiDotNet.Generators\bin\$(Configuration)\netstandard2.0\AiDotNet.Generators.dll"
+	        Pack="true"
+	        PackagePath="analyzers/dotnet/cs"
+	        Visible="false" />
+	</ItemGroup>
+
 	<!-- Emit generated source files to disk for inspection/debugging (Debug only) -->
 	<PropertyGroup Condition="'$(Configuration)'=='Debug'">
 	  <EmitCompilerGeneratedFiles>true</EmitCompilerGeneratedFiles>
diff --git a/src/AnomalyDetection/AngleBased/ABODDetector.cs b/src/AnomalyDetection/AngleBased/ABODDetector.cs
index c8ad47ca80..65bc9b43fa 100644
--- a/src/AnomalyDetection/AngleBased/ABODDetector.cs
+++ b/src/AnomalyDetection/AngleBased/ABODDetector.cs
@@ -43,7 +43,7 @@ namespace AiDotNet.AnomalyDetection.AngleBased;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
 [ResearchPaper("Angle-Based Outlier Detection in High-dimensional Data", "https://doi.org/10.1145/1401890.1401946", Year = 2008, Authors = "Hans-Peter Kriegel, Matthias Schubert, Arthur Zimek")]
-public class ABODDetector<T> : AnomalyDetectorBase<T>
+public partial class ABODDetector<T> : AnomalyDetectorBase<T>
 {
     [Buffer]
     private Matrix<T>? _trainingData;
diff --git a/src/AnomalyDetection/AngleBased/FastABODDetector.cs b/src/AnomalyDetection/AngleBased/FastABODDetector.cs
index e7ad2e2c44..34b1477fa1 100644
--- a/src/AnomalyDetection/AngleBased/FastABODDetector.cs
+++ b/src/AnomalyDetection/AngleBased/FastABODDetector.cs
@@ -43,7 +43,7 @@ namespace AiDotNet.AnomalyDetection.AngleBased;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
 [ResearchPaper("Angle-Based Outlier Detection in High-dimensional Data", "https://doi.org/10.1145/1401890.1401946", Year = 2008, Authors = "Hans-Peter Kriegel, Matthias Schubert, Arthur Zimek")]
-public class FastABODDetector<T> : AnomalyDetectorBase<T>
+public partial class FastABODDetector<T> : AnomalyDetectorBase<T>
 {
     private readonly int _k;
     [Buffer]
diff --git a/src/AnomalyDetection/AnomalyDetectorBase.cs b/src/AnomalyDetection/AnomalyDetectorBase.cs
index 6225be5a95..a5a1f42693 100644
--- a/src/AnomalyDetection/AnomalyDetectorBase.cs
+++ b/src/AnomalyDetection/AnomalyDetectorBase.cs
@@ -28,7 +28,7 @@ namespace AiDotNet.AnomalyDetection;
 /// - Random Seed: 42 - for reproducibility
 /// </para>
 /// </remarks>
-public abstract class AnomalyDetectorBase<T> : ModelBase<T, Matrix<T>, Vector<T>>, IAnomalyDetector<T>
+public abstract partial class AnomalyDetectorBase<T> : ModelBase<T, Matrix<T>, Vector<T>>, IAnomalyDetector<T>
 {
 
     /// <inheritdoc />
diff --git a/src/AnomalyDetection/ClusterBased/CBLOFDetector.cs b/src/AnomalyDetection/ClusterBased/CBLOFDetector.cs
index f883fdcca0..aa3cb19e0b 100644
--- a/src/AnomalyDetection/ClusterBased/CBLOFDetector.cs
+++ b/src/AnomalyDetection/ClusterBased/CBLOFDetector.cs
@@ -51,6 +51,7 @@ public partial class CBLOFDetector<T> : AnomalyDetectorBase<T>
     private readonly int _nClusters;
     private readonly double _alpha;
     private readonly int _beta;
+    [AiDotNet.Attributes.FittedParameter]
     private Matrix<T>? _centroids;
     private int[]? _clusterSizes;
     private bool[]? _isLargeCluster;
diff --git a/src/AnomalyDetection/ClusterBased/DBSCANDetector.cs b/src/AnomalyDetection/ClusterBased/DBSCANDetector.cs
index 50002ccab7..ac05dd110b 100644
--- a/src/AnomalyDetection/ClusterBased/DBSCANDetector.cs
+++ b/src/AnomalyDetection/ClusterBased/DBSCANDetector.cs
@@ -44,7 +44,7 @@ namespace AiDotNet.AnomalyDetection.ClusterBased;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
 [ResearchPaper("A Density-Based Algorithm for Discovering Clusters in Large Spatial Databases with Noise", "https://www.aaai.org/Papers/KDD/1996/KDD96-037.pdf", Year = 1996, Authors = "Martin Ester, Hans-Peter Kriegel, Joerg Sander, Xiaowei Xu")]
-public class DBSCANDetector<T> : AnomalyDetectorBase<T>
+public partial class DBSCANDetector<T> : AnomalyDetectorBase<T>
 {
     private readonly double? _epsilon;
     private readonly int? _minPts;
diff --git a/src/AnomalyDetection/ClusterBased/HDBSCANDetector.cs b/src/AnomalyDetection/ClusterBased/HDBSCANDetector.cs
index edc6a6180e..e7eaef3dae 100644
--- a/src/AnomalyDetection/ClusterBased/HDBSCANDetector.cs
+++ b/src/AnomalyDetection/ClusterBased/HDBSCANDetector.cs
@@ -46,7 +46,7 @@ namespace AiDotNet.AnomalyDetection.ClusterBased;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
 [ResearchPaper("Density-Based Clustering Based on Hierarchical Density Estimates", "https://doi.org/10.1007/978-3-642-37456-2_14", Year = 2013, Authors = "Ricardo J. G. B. Campello, Davide Moulavi, Jörg Sander")]
-public class HDBSCANDetector<T> : AnomalyDetectorBase<T>
+public partial class HDBSCANDetector<T> : AnomalyDetectorBase<T>
 {
     private readonly int _minClusterSize;
     private readonly int _minSamples;
diff --git a/src/AnomalyDetection/ClusterBased/KMeansDetector.cs b/src/AnomalyDetection/ClusterBased/KMeansDetector.cs
index 914a1952d4..06dd592328 100644
--- a/src/AnomalyDetection/ClusterBased/KMeansDetector.cs
+++ b/src/AnomalyDetection/ClusterBased/KMeansDetector.cs
@@ -46,6 +46,7 @@ public partial class KMeansDetector<T> : AnomalyDetectorBase<T>
 {
     private readonly int _k;
     private readonly int _maxIterations;
+    [AiDotNet.Attributes.FittedParameter]
     private Matrix<T>? _centroids;
     private int[]? _clusterSizes;
     private int _totalSamples;
diff --git a/src/AnomalyDetection/DistanceBased/COFDetector.cs b/src/AnomalyDetection/DistanceBased/COFDetector.cs
index 1ec89f0ba2..6ee680a90d 100644
--- a/src/AnomalyDetection/DistanceBased/COFDetector.cs
+++ b/src/AnomalyDetection/DistanceBased/COFDetector.cs
@@ -23,7 +23,7 @@ namespace AiDotNet.AnomalyDetection.DistanceBased;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
     [ResearchPaper("Connectivity-Based Outlier Factor", "https://dl.acm.org/doi/10.1145/775047.775149")]
-public class COFDetector<T> : AnomalyDetectorBase<T>
+public partial class COFDetector<T> : AnomalyDetectorBase<T>
 {
     private readonly int _k;
     [Buffer]
diff --git a/src/AnomalyDetection/DistanceBased/INFLODetector.cs b/src/AnomalyDetection/DistanceBased/INFLODetector.cs
index ae77d9931f..62842f3dfc 100644
--- a/src/AnomalyDetection/DistanceBased/INFLODetector.cs
+++ b/src/AnomalyDetection/DistanceBased/INFLODetector.cs
@@ -44,7 +44,7 @@ namespace AiDotNet.AnomalyDetection.DistanceBased;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
 [ResearchPaper("Mining Top-n Local Outliers in Large Databases", "https://doi.org/10.1145/1150402.1150438", Year = 2006, Authors = "Wen Jin, Anthony K. H. Tung, Jiawei Han, Wei Wang")]
-public class INFLODetector<T> : AnomalyDetectorBase<T>
+public partial class INFLODetector<T> : AnomalyDetectorBase<T>
 {
     private readonly int _k;
     [Buffer]
diff --git a/src/AnomalyDetection/DistanceBased/KNNDetector.cs b/src/AnomalyDetection/DistanceBased/KNNDetector.cs
index 12aeccb289..f5cc8fad78 100644
--- a/src/AnomalyDetection/DistanceBased/KNNDetector.cs
+++ b/src/AnomalyDetection/DistanceBased/KNNDetector.cs
@@ -40,7 +40,7 @@ namespace AiDotNet.AnomalyDetection.DistanceBased;
 [ModelComplexity(ModelComplexity.Low)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
 [ResearchPaper("Efficient Algorithms for Mining Outliers from Large Data Sets", "https://doi.org/10.1145/335191.335437", Year = 2000, Authors = "Sridhar Ramaswamy, Rajeev Rastogi, Kyuseok Shim")]
-public class KNNDetector<T> : AnomalyDetectorBase<T>
+public partial class KNNDetector<T> : AnomalyDetectorBase<T>
 {
     private readonly int _k;
     [Buffer]
diff --git a/src/AnomalyDetection/DistanceBased/LOCIDetector.cs b/src/AnomalyDetection/DistanceBased/LOCIDetector.cs
index fee7bf2ca4..40586eaa32 100644
--- a/src/AnomalyDetection/DistanceBased/LOCIDetector.cs
+++ b/src/AnomalyDetection/DistanceBased/LOCIDetector.cs
@@ -46,7 +46,7 @@ namespace AiDotNet.AnomalyDetection.DistanceBased;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
 [ResearchPaper("LOCI: Fast Outlier Detection Using the Local Correlation Integral", "https://doi.org/10.1109/ICDE.2003.1260802", Year = 2003, Authors = "Spiros Papadimitriou, Hiroyuki Kitagawa, Phillip B. Gibbons, Christos Faloutsos")]
-public class LOCIDetector<T> : AnomalyDetectorBase<T>
+public partial class LOCIDetector<T> : AnomalyDetectorBase<T>
 {
     /// <summary>Number of radius steps used to sweep from zero to <c>_maxRadius</c>.</summary>
     private const int NumRadiiSteps = 20;
diff --git a/src/AnomalyDetection/DistanceBased/LoOPDetector.cs b/src/AnomalyDetection/DistanceBased/LoOPDetector.cs
index 2905f8c679..294607766b 100644
--- a/src/AnomalyDetection/DistanceBased/LoOPDetector.cs
+++ b/src/AnomalyDetection/DistanceBased/LoOPDetector.cs
@@ -45,7 +45,7 @@ namespace AiDotNet.AnomalyDetection.DistanceBased;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
     [ResearchPaper("LoOP: Local Outlier Probabilities", "https://doi.org/10.1145/1645953.1646195")]
-public class LoOPDetector<T> : AnomalyDetectorBase<T>
+public partial class LoOPDetector<T> : AnomalyDetectorBase<T>
 {
     private readonly int _k;
     private readonly double _lambda;
diff --git a/src/AnomalyDetection/DistanceBased/LocalOutlierFactor.cs b/src/AnomalyDetection/DistanceBased/LocalOutlierFactor.cs
index d13fa72d5a..7a52319834 100644
--- a/src/AnomalyDetection/DistanceBased/LocalOutlierFactor.cs
+++ b/src/AnomalyDetection/DistanceBased/LocalOutlierFactor.cs
@@ -45,7 +45,7 @@ namespace AiDotNet.AnomalyDetection.DistanceBased;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
 [ResearchPaper("LOF: Identifying Density-Based Local Outliers", "https://doi.org/10.1145/335191.335388", Year = 2000, Authors = "Markus M. Breunig, Hans-Peter Kriegel, Raymond T. Ng, Joerg Sander")]
-public class LocalOutlierFactor<T> : AnomalyDetectorBase<T>
+public partial class LocalOutlierFactor<T> : AnomalyDetectorBase<T>
 {
     private readonly int _numNeighbors;
     [Buffer]
diff --git a/src/AnomalyDetection/DistanceBased/SOSDetector.cs b/src/AnomalyDetection/DistanceBased/SOSDetector.cs
index 820e4e720d..f252c406ba 100644
--- a/src/AnomalyDetection/DistanceBased/SOSDetector.cs
+++ b/src/AnomalyDetection/DistanceBased/SOSDetector.cs
@@ -44,7 +44,7 @@ namespace AiDotNet.AnomalyDetection.DistanceBased;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
     [ResearchPaper("Stochastic Outlier Selection", "https://jmlr.org/papers/v14/janssens13a.html")]
-public class SOSDetector<T> : AnomalyDetectorBase<T>
+public partial class SOSDetector<T> : AnomalyDetectorBase<T>
 {
     private readonly double _perplexity;
     [Buffer]
diff --git a/src/AnomalyDetection/Ensemble/XGBODDetector.cs b/src/AnomalyDetection/Ensemble/XGBODDetector.cs
index 068b0f081b..f205108e13 100644
--- a/src/AnomalyDetection/Ensemble/XGBODDetector.cs
+++ b/src/AnomalyDetection/Ensemble/XGBODDetector.cs
@@ -52,6 +52,7 @@ public partial class XGBODDetector<T> : AnomalyDetectorBase<T>
     private readonly int _nEstimators;
     private readonly int _boostingRounds;
     private List<IAnomalyDetector<T>>? _baseDetectors;
+    [AiDotNet.Attributes.FittedParameter]
     private Vector<T>? _weights; // Simplified boosting weights
     [Buffer]
     private Vector<T>? _featureMean;
diff --git a/src/AnomalyDetection/Linear/EllipticEnvelopeDetector.cs b/src/AnomalyDetection/Linear/EllipticEnvelopeDetector.cs
index c09a360b3d..e853992138 100644
--- a/src/AnomalyDetection/Linear/EllipticEnvelopeDetector.cs
+++ b/src/AnomalyDetection/Linear/EllipticEnvelopeDetector.cs
@@ -53,6 +53,7 @@ public partial class EllipticEnvelopeDetector<T> : AnomalyDetectorBase<T>
 {
     private readonly double _supportFraction;
     private Vector<T>? _location;
+    [AiDotNet.Attributes.FittedParameter]
     private Matrix<T>? _precisionMatrix;
 
     /// <summary>
diff --git a/src/AnomalyDetection/Linear/MCDDetector.cs b/src/AnomalyDetection/Linear/MCDDetector.cs
index adfe6ee3ae..a6068b01d6 100644
--- a/src/AnomalyDetection/Linear/MCDDetector.cs
+++ b/src/AnomalyDetection/Linear/MCDDetector.cs
@@ -50,7 +50,7 @@ namespace AiDotNet.AnomalyDetection.Linear;
     "https://doi.org/10.1080/00401706.1999.10485670",
     Year = 1999,
     Authors = "Peter J. Rousseeuw, Katrien Van Driessen")]
-public class MCDDetector<T> : AnomalyDetectorBase<T>
+public partial class MCDDetector<T> : AnomalyDetectorBase<T>
 {
     private readonly double _supportFraction;
     [Buffer]
diff --git a/src/AnomalyDetection/Linear/RobustPCADetector.cs b/src/AnomalyDetection/Linear/RobustPCADetector.cs
index db9c3c79a9..b04a52799c 100644
--- a/src/AnomalyDetection/Linear/RobustPCADetector.cs
+++ b/src/AnomalyDetection/Linear/RobustPCADetector.cs
@@ -52,7 +52,9 @@ public partial class RobustPCADetector<T> : AnomalyDetectorBase<T>
     private readonly double _lambda;
     private readonly int _maxIterations;
     private readonly double _tolerance;
+    [AiDotNet.Attributes.FittedParameter]
     private Matrix<T>? _lowRank;
+    [AiDotNet.Attributes.FittedParameter]
     private Matrix<T>? _sparse;
     [Buffer]
     private Vector<T>? _mean;
diff --git a/src/AnomalyDetection/NeuralNetwork/AnoGANDetector.cs b/src/AnomalyDetection/NeuralNetwork/AnoGANDetector.cs
index 1b30311bfb..81de181bd2 100644
--- a/src/AnomalyDetection/NeuralNetwork/AnoGANDetector.cs
+++ b/src/AnomalyDetection/NeuralNetwork/AnoGANDetector.cs
@@ -58,19 +58,31 @@ public partial class AnoGANDetector<T> : AnomalyDetectorBase<T>
     private readonly int _inferenceSteps;
 
     // Generator weights
+    [AiDotNet.Attributes.TrainableParameter]
     private Matrix<T>? _genW1;
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T>? _genB1;
+    [AiDotNet.Attributes.TrainableParameter]
     private Matrix<T>? _genW2;
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T>? _genB2;
+    [AiDotNet.Attributes.TrainableParameter]
     private Matrix<T>? _genW3;
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T>? _genB3;
 
     // Discriminator weights
+    [AiDotNet.Attributes.TrainableParameter]
     private Matrix<T>? _discW1;
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T>? _discB1;
+    [AiDotNet.Attributes.TrainableParameter]
     private Matrix<T>? _discW2;
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T>? _discB2;
+    [AiDotNet.Attributes.TrainableParameter]
     private Matrix<T>? _discW3;
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T>? _discB3;
 
     private int _inputDim;
diff --git a/src/AnomalyDetection/NeuralNetwork/AutoencoderDetector.cs b/src/AnomalyDetection/NeuralNetwork/AutoencoderDetector.cs
index 41c51c34e1..ceff53ad46 100644
--- a/src/AnomalyDetection/NeuralNetwork/AutoencoderDetector.cs
+++ b/src/AnomalyDetection/NeuralNetwork/AutoencoderDetector.cs
@@ -56,9 +56,13 @@ public partial class AutoencoderDetector<T> : AnomalyDetectorBase<T>
     private readonly int _batchSize;
 
     // Weights for the simple autoencoder
+    [AiDotNet.Attributes.TrainableParameter]
     private Matrix<T>? _encoderWeights;
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T>? _encoderBias;
+    [AiDotNet.Attributes.TrainableParameter]
     private Matrix<T>? _decoderWeights;
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T>? _decoderBias;
 
     private int _inputDim;
diff --git a/src/AnomalyDetection/NeuralNetwork/DAGMMDetector.cs b/src/AnomalyDetection/NeuralNetwork/DAGMMDetector.cs
index b68a2a5e69..f30ad4d1a0 100644
--- a/src/AnomalyDetection/NeuralNetwork/DAGMMDetector.cs
+++ b/src/AnomalyDetection/NeuralNetwork/DAGMMDetector.cs
@@ -63,21 +63,33 @@ public partial class DAGMMDetector<T> : AnomalyDetectorBase<T>
     private readonly double _learningRate;
 
     // Encoder weights
+    [AiDotNet.Attributes.TrainableParameter]
     private Matrix<T>? _encW1;
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T>? _encB1;
+    [AiDotNet.Attributes.TrainableParameter]
     private Matrix<T>? _encW2;
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T>? _encB2;
 
     // Decoder weights
+    [AiDotNet.Attributes.TrainableParameter]
     private Matrix<T>? _decW1;
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T>? _decB1;
+    [AiDotNet.Attributes.TrainableParameter]
     private Matrix<T>? _decW2;
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T>? _decB2;
 
     // Estimation network weights
+    [AiDotNet.Attributes.TrainableParameter]
     private Matrix<T>? _estW1;
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T>? _estB1;
+    [AiDotNet.Attributes.TrainableParameter]
     private Matrix<T>? _estW2;
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T>? _estB2;
 
     // GMM parameters (kept as double for numerical stability in probability computations)
diff --git a/src/AnomalyDetection/NeuralNetwork/DeepSVDDDetector.cs b/src/AnomalyDetection/NeuralNetwork/DeepSVDDDetector.cs
index 1efcdba7ec..70f1241022 100644
--- a/src/AnomalyDetection/NeuralNetwork/DeepSVDDDetector.cs
+++ b/src/AnomalyDetection/NeuralNetwork/DeepSVDDDetector.cs
@@ -56,11 +56,17 @@ public partial class DeepSVDDDetector<T> : AnomalyDetectorBase<T>
     private readonly double _learningRate;
 
     // Network weights
+    [AiDotNet.Attributes.TrainableParameter]
     private Matrix<T>? _w1;
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T>? _b1;
+    [AiDotNet.Attributes.TrainableParameter]
     private Matrix<T>? _w2;
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T>? _b2;
+    [AiDotNet.Attributes.TrainableParameter]
     private Matrix<T>? _w3;
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T>? _b3;
 
     // Hypersphere center
diff --git a/src/AnomalyDetection/NeuralNetwork/DevNetDetector.cs b/src/AnomalyDetection/NeuralNetwork/DevNetDetector.cs
index bf69a0b032..da90aa418f 100644
--- a/src/AnomalyDetection/NeuralNetwork/DevNetDetector.cs
+++ b/src/AnomalyDetection/NeuralNetwork/DevNetDetector.cs
@@ -55,11 +55,17 @@ public partial class DevNetDetector<T> : AnomalyDetectorBase<T>
     private readonly double _learningRate;
 
     // Network weights
+    [AiDotNet.Attributes.TrainableParameter]
     private Matrix<T>? _w1;
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T>? _b1;
+    [AiDotNet.Attributes.TrainableParameter]
     private Matrix<T>? _w2;
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T>? _b2;
+    [AiDotNet.Attributes.TrainableParameter]
     private Matrix<T>? _w3;
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T>? _b3;
 
     // Reference statistics (initialized in Fit, default to zero before that)
diff --git a/src/AnomalyDetection/NeuralNetwork/GANomalyDetector.cs b/src/AnomalyDetection/NeuralNetwork/GANomalyDetector.cs
index 3e45c0d4e3..7adab1c4a2 100644
--- a/src/AnomalyDetection/NeuralNetwork/GANomalyDetector.cs
+++ b/src/AnomalyDetection/NeuralNetwork/GANomalyDetector.cs
@@ -58,21 +58,33 @@ public partial class GANomalyDetector<T> : AnomalyDetectorBase<T>
     private readonly double _learningRate;
 
     // Encoder weights
+    [AiDotNet.Attributes.TrainableParameter]
     private Matrix<T>? _encW1;
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T>? _encB1;
+    [AiDotNet.Attributes.TrainableParameter]
     private Matrix<T>? _encW2;
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T>? _encB2;
 
     // Decoder weights
+    [AiDotNet.Attributes.TrainableParameter]
     private Matrix<T>? _decW1;
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T>? _decB1;
+    [AiDotNet.Attributes.TrainableParameter]
     private Matrix<T>? _decW2;
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T>? _decB2;
 
     // Re-encoder weights (separate encoder for reconstruction)
+    [AiDotNet.Attributes.TrainableParameter]
     private Matrix<T>? _reEncW1;
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T>? _reEncB1;
+    [AiDotNet.Attributes.TrainableParameter]
     private Matrix<T>? _reEncW2;
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T>? _reEncB2;
 
     private int _inputDim;
diff --git a/src/AnomalyDetection/NeuralNetwork/VAEDetector.cs b/src/AnomalyDetection/NeuralNetwork/VAEDetector.cs
index ac419ac098..52ea19d739 100644
--- a/src/AnomalyDetection/NeuralNetwork/VAEDetector.cs
+++ b/src/AnomalyDetection/NeuralNetwork/VAEDetector.cs
@@ -57,17 +57,27 @@ public partial class VAEDetector<T> : AnomalyDetectorBase<T>
     private readonly double _learningRate;
 
     // Encoder weights
+    [AiDotNet.Attributes.TrainableParameter]
     private Matrix<T>? _encoderW1;
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T>? _encoderB1;
+    [AiDotNet.Attributes.TrainableParameter]
     private Matrix<T>? _encoderWMean;
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T>? _encoderBMean;
+    [AiDotNet.Attributes.TrainableParameter]
     private Matrix<T>? _encoderWLogVar;
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T>? _encoderBLogVar;
 
     // Decoder weights
+    [AiDotNet.Attributes.TrainableParameter]
     private Matrix<T>? _decoderW1;
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T>? _decoderB1;
+    [AiDotNet.Attributes.TrainableParameter]
     private Matrix<T>? _decoderW2;
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T>? _decoderB2;
 
     // Normalization parameters
diff --git a/src/AnomalyDetection/Probabilistic/BayesianDetector.cs b/src/AnomalyDetection/Probabilistic/BayesianDetector.cs
index db6b47278c..e76c584e05 100644
--- a/src/AnomalyDetection/Probabilistic/BayesianDetector.cs
+++ b/src/AnomalyDetection/Probabilistic/BayesianDetector.cs
@@ -46,7 +46,7 @@ namespace AiDotNet.AnomalyDetection.Probabilistic;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
 [ResearchPaper("Bayesian Anomaly Detection Methods for Social Networks", "https://doi.org/10.1214/10-AOAS370", Year = 2010, Authors = "Savage, Coull, Heard")]
-public class BayesianDetector<T> : AnomalyDetectorBase<T>
+public partial class BayesianDetector<T> : AnomalyDetectorBase<T>
 {
     private readonly double _priorStrength;
     [Buffer]
diff --git a/src/AnomalyDetection/Probabilistic/COPODDetector.cs b/src/AnomalyDetection/Probabilistic/COPODDetector.cs
index 583a60382f..a42988caae 100644
--- a/src/AnomalyDetection/Probabilistic/COPODDetector.cs
+++ b/src/AnomalyDetection/Probabilistic/COPODDetector.cs
@@ -43,7 +43,7 @@ namespace AiDotNet.AnomalyDetection.Probabilistic;
 [ModelComplexity(ModelComplexity.Low)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
 [ResearchPaper("COPOD: Copula-Based Outlier Detection", "https://doi.org/10.1109/ICDM50108.2020.00135", Year = 2020, Authors = "Zheng Li, Yue Zhao, Nicola Botta, Cezar Ionescu, Xiyang Hu")]
-public class COPODDetector<T> : AnomalyDetectorBase<T>
+public partial class COPODDetector<T> : AnomalyDetectorBase<T>
 {
     [Buffer]
     private Vector<T>[]? _sortedFeatureValues;
diff --git a/src/AnomalyDetection/Probabilistic/ECODDetector.cs b/src/AnomalyDetection/Probabilistic/ECODDetector.cs
index 003779178e..40cf51877f 100644
--- a/src/AnomalyDetection/Probabilistic/ECODDetector.cs
+++ b/src/AnomalyDetection/Probabilistic/ECODDetector.cs
@@ -45,7 +45,7 @@ namespace AiDotNet.AnomalyDetection.Probabilistic;
 [ModelComplexity(ModelComplexity.Low)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
 [ResearchPaper("ECOD: Unsupervised Outlier Detection Using Empirical Cumulative Distribution Functions", "https://doi.org/10.1109/TKDE.2022.3159580", Year = 2022, Authors = "Zheng Li, Yue Zhao, Xiyang Hu, Nicola Botta, Cezar Ionescu, George H. Chen")]
-public class ECODDetector<T> : AnomalyDetectorBase<T>
+public partial class ECODDetector<T> : AnomalyDetectorBase<T>
 {
     [Buffer]
     private Vector<T>[]? _sortedFeatureValues;
diff --git a/src/AnomalyDetection/Probabilistic/GMMDetector.cs b/src/AnomalyDetection/Probabilistic/GMMDetector.cs
index 0367f92f9d..be394323c2 100644
--- a/src/AnomalyDetection/Probabilistic/GMMDetector.cs
+++ b/src/AnomalyDetection/Probabilistic/GMMDetector.cs
@@ -49,6 +49,7 @@ public partial class GMMDetector<T> : AnomalyDetectorBase<T>
     private readonly int _maxIterations;
     private Vector<T>[] _means = Array.Empty<Vector<T>>();
     private Matrix<T>[] _covariances = Array.Empty<Matrix<T>>();
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T> _weights = new Vector<T>(0);
     private int _nFeatures;
     [Buffer]
diff --git a/src/AnomalyDetection/Statistical/ChiSquareDetector.cs b/src/AnomalyDetection/Statistical/ChiSquareDetector.cs
index fcd06bdc76..283b2751fd 100644
--- a/src/AnomalyDetection/Statistical/ChiSquareDetector.cs
+++ b/src/AnomalyDetection/Statistical/ChiSquareDetector.cs
@@ -39,7 +39,7 @@ namespace AiDotNet.AnomalyDetection.Statistical;
 [ModelComplexity(ModelComplexity.Low)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
     [ResearchPaper("Contributions to the Mathematical Theory of Evolution", "https://doi.org/10.1098/rsta.1900.0009")]
-public class ChiSquareDetector<T> : AnomalyDetectorBase<T>
+public partial class ChiSquareDetector<T> : AnomalyDetectorBase<T>
 {
     private readonly double _alpha;
     [Buffer]
diff --git a/src/AnomalyDetection/Statistical/DixonQTestDetector.cs b/src/AnomalyDetection/Statistical/DixonQTestDetector.cs
index 7217b7556e..edc9ed7bb3 100644
--- a/src/AnomalyDetection/Statistical/DixonQTestDetector.cs
+++ b/src/AnomalyDetection/Statistical/DixonQTestDetector.cs
@@ -41,7 +41,7 @@ namespace AiDotNet.AnomalyDetection.Statistical;
 [ModelComplexity(ModelComplexity.Low)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
 [ResearchPaper("Analysis of Extreme Values", "https://doi.org/10.1214/aoms/1177729747", Year = 1950, Authors = "Wilfrid J. Dixon")]
-public class DixonQTestDetector<T> : AnomalyDetectorBase<T>
+public partial class DixonQTestDetector<T> : AnomalyDetectorBase<T>
 {
     private readonly double _alpha;
     [Buffer]
diff --git a/src/AnomalyDetection/Statistical/ESDDetector.cs b/src/AnomalyDetection/Statistical/ESDDetector.cs
index 3d4b6f7259..f2f2e74834 100644
--- a/src/AnomalyDetection/Statistical/ESDDetector.cs
+++ b/src/AnomalyDetection/Statistical/ESDDetector.cs
@@ -48,7 +48,9 @@ public partial class ESDDetector<T> : AnomalyDetectorBase<T>
 {
     private readonly double _alpha;
     private readonly int? _maxOutliers;
+    [AiDotNet.Attributes.FittedParameter]
     private Vector<T>? _means;
+    [AiDotNet.Attributes.FittedParameter]
     private Vector<T>? _stds;
     private int _nFeatures;
     private int _nSamples;
diff --git a/src/AnomalyDetection/Statistical/GESDDetector.cs b/src/AnomalyDetection/Statistical/GESDDetector.cs
index 859b65d332..123ce3bed6 100644
--- a/src/AnomalyDetection/Statistical/GESDDetector.cs
+++ b/src/AnomalyDetection/Statistical/GESDDetector.cs
@@ -42,7 +42,7 @@ namespace AiDotNet.AnomalyDetection.Statistical;
 [ModelComplexity(ModelComplexity.Low)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
 [ResearchPaper("Percentage Points for a Generalized ESD Many-Outlier Procedure", "https://doi.org/10.2307/1268549", Year = 1983, Authors = "Bernard Rosner")]
-public class GESDDetector<T> : AnomalyDetectorBase<T>
+public partial class GESDDetector<T> : AnomalyDetectorBase<T>
 {
     private readonly double _alpha;
     private readonly int _maxOutliers;
diff --git a/src/AnomalyDetection/Statistical/GrubbsTestDetector.cs b/src/AnomalyDetection/Statistical/GrubbsTestDetector.cs
index e903e42f20..497bc3b3b5 100644
--- a/src/AnomalyDetection/Statistical/GrubbsTestDetector.cs
+++ b/src/AnomalyDetection/Statistical/GrubbsTestDetector.cs
@@ -42,7 +42,7 @@ namespace AiDotNet.AnomalyDetection.Statistical;
 [ModelComplexity(ModelComplexity.Low)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
 [ResearchPaper("Sample Criteria for Testing Outlying Observations", "https://doi.org/10.1214/aoms/1177729885", Year = 1950, Authors = "Frank E. Grubbs")]
-public class GrubbsTestDetector<T> : AnomalyDetectorBase<T>
+public partial class GrubbsTestDetector<T> : AnomalyDetectorBase<T>
 {
     private readonly double _alpha;
     [Buffer]
diff --git a/src/AnomalyDetection/Statistical/IQRDetector.cs b/src/AnomalyDetection/Statistical/IQRDetector.cs
index 72ef9d116c..998ece904b 100644
--- a/src/AnomalyDetection/Statistical/IQRDetector.cs
+++ b/src/AnomalyDetection/Statistical/IQRDetector.cs
@@ -37,7 +37,7 @@ namespace AiDotNet.AnomalyDetection.Statistical;
 [ModelComplexity(ModelComplexity.Low)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
     [ResearchPaper("Exploratory Data Analysis", "https://doi.org/10.1002/bimj.4710230408")]
-public class IQRDetector<T> : AnomalyDetectorBase<T>
+public partial class IQRDetector<T> : AnomalyDetectorBase<T>
 {
     private readonly double _multiplier;
     [Buffer]
diff --git a/src/AnomalyDetection/Statistical/MADDetector.cs b/src/AnomalyDetection/Statistical/MADDetector.cs
index cdac031862..701d3d2234 100644
--- a/src/AnomalyDetection/Statistical/MADDetector.cs
+++ b/src/AnomalyDetection/Statistical/MADDetector.cs
@@ -46,7 +46,7 @@ namespace AiDotNet.AnomalyDetection.Statistical;
 [ModelComplexity(ModelComplexity.Low)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
 [ResearchPaper("Detecting outliers: Do not use standard deviation around the mean, use absolute deviation around the median", "https://doi.org/10.1016/j.jesp.2013.03.013", Year = 2013, Authors = "Christophe Leys, Christophe Ley, Olivier Klein, Philippe Bernard, Laurent Licata")]
-public class MADDetector<T> : AnomalyDetectorBase<T>
+public partial class MADDetector<T> : AnomalyDetectorBase<T>
 {
     private readonly double _madThreshold;
     private readonly double _scaleFactor;
diff --git a/src/AnomalyDetection/Statistical/ModifiedZScoreDetector.cs b/src/AnomalyDetection/Statistical/ModifiedZScoreDetector.cs
index 73c18d73bf..b2f9dedfc3 100644
--- a/src/AnomalyDetection/Statistical/ModifiedZScoreDetector.cs
+++ b/src/AnomalyDetection/Statistical/ModifiedZScoreDetector.cs
@@ -38,7 +38,7 @@ namespace AiDotNet.AnomalyDetection.Statistical;
 [ModelComplexity(ModelComplexity.Low)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
     [ResearchPaper("Alternatives to the Median Absolute Deviation", "https://doi.org/10.1080/01621459.1993.10476408")]
-public class ModifiedZScoreDetector<T> : AnomalyDetectorBase<T>
+public partial class ModifiedZScoreDetector<T> : AnomalyDetectorBase<T>
 {
     /// <summary>
     /// Scaling factor to make MAD comparable to standard deviation for normal distributions.
diff --git a/src/AnomalyDetection/Statistical/PercentileDetector.cs b/src/AnomalyDetection/Statistical/PercentileDetector.cs
index 374e958b13..5b9c465ac6 100644
--- a/src/AnomalyDetection/Statistical/PercentileDetector.cs
+++ b/src/AnomalyDetection/Statistical/PercentileDetector.cs
@@ -45,7 +45,9 @@ public partial class PercentileDetector<T> : AnomalyDetectorBase<T>
 {
     private readonly double _lowPercentile;
     private readonly double _highPercentile;
+    [AiDotNet.Attributes.FittedParameter]
     private Vector<T>? _lowThresholds;
+    [AiDotNet.Attributes.FittedParameter]
     private Vector<T>? _highThresholds;
     [Buffer]
     private Vector<T>? _ranges;
diff --git a/src/AnomalyDetection/Statistical/ZScoreDetector.cs b/src/AnomalyDetection/Statistical/ZScoreDetector.cs
index c0ff50d901..b3bc2ae97f 100644
--- a/src/AnomalyDetection/Statistical/ZScoreDetector.cs
+++ b/src/AnomalyDetection/Statistical/ZScoreDetector.cs
@@ -34,12 +34,15 @@ namespace AiDotNet.AnomalyDetection.Statistical;
 [ModelComplexity(ModelComplexity.Low)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
     [ResearchPaper("Exploratory Data Analysis", "https://doi.org/10.1002/bimj.4710230408")]
-public class ZScoreDetector<T> : AnomalyDetectorBase<T>
+public partial class ZScoreDetector<T> : AnomalyDetectorBase<T>
 {
     private readonly double _zThreshold;
-    [Buffer]
+    // These fitted statistics are absent on a fresh detector. They join the persistent state once
+    // Fit materializes them, but their absence must not make the independently constructed
+    // threshold slot unreadable.
+    [Buffer(Availability = AiDotNet.Models.Parameters.ParameterAvailability.Conditional)]
     private Vector<T>? _means;
-    [Buffer]
+    [Buffer(Availability = AiDotNet.Models.Parameters.ParameterAvailability.Conditional)]
     private Vector<T>? _stds;
 
     /// <summary>
diff --git a/src/AnomalyDetection/TimeSeries/ARIMADetector.cs b/src/AnomalyDetection/TimeSeries/ARIMADetector.cs
index a1c1ce4449..58adf194a1 100644
--- a/src/AnomalyDetection/TimeSeries/ARIMADetector.cs
+++ b/src/AnomalyDetection/TimeSeries/ARIMADetector.cs
@@ -56,7 +56,9 @@ public partial class ARIMADetector<T> : AnomalyDetectorBase<T>
     private readonly int _p;
     private readonly int _d;
     private readonly int _q;
+    [AiDotNet.Attributes.FittedParameter]
     private Vector<T>? _arCoeffs;
+    [AiDotNet.Attributes.FittedParameter]
     private Vector<T>? _maCoeffs;
 
     private T _mean;
diff --git a/src/AnomalyDetection/TimeSeries/AnomalyTransformerDetector.cs b/src/AnomalyDetection/TimeSeries/AnomalyTransformerDetector.cs
index 97cad650b8..da800eb5a4 100644
--- a/src/AnomalyDetection/TimeSeries/AnomalyTransformerDetector.cs
+++ b/src/AnomalyDetection/TimeSeries/AnomalyTransformerDetector.cs
@@ -64,18 +64,27 @@ public partial class AnomalyTransformerDetector<T> : AnomalyDetectorBase<T>
     private readonly double _learningRate;
 
     // Attention weights
+    [AiDotNet.Attributes.TrainableParameter]
     private Matrix<T>? _Wq; // Query projection
+    [AiDotNet.Attributes.TrainableParameter]
     private Matrix<T>? _Wk; // Key projection
+    [AiDotNet.Attributes.TrainableParameter]
     private Matrix<T>? _Wv; // Value projection
+    [AiDotNet.Attributes.TrainableParameter]
     private Matrix<T>? _Wo; // Output projection
 
     // Feed-forward weights
+    [AiDotNet.Attributes.TrainableParameter]
     private Matrix<T>? _W1;
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T>? _b1;
+    [AiDotNet.Attributes.TrainableParameter]
     private Matrix<T>? _W2;
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T>? _b2;
 
     // Input projection
+    [AiDotNet.Attributes.TrainableParameter]
     private Matrix<T>? _inputProj;
 
     // Prior association (learnable Gaussian kernel)
diff --git a/src/AnomalyDetection/TimeSeries/MatrixProfileDetector.cs b/src/AnomalyDetection/TimeSeries/MatrixProfileDetector.cs
index d89d27161e..ff7c1b54df 100644
--- a/src/AnomalyDetection/TimeSeries/MatrixProfileDetector.cs
+++ b/src/AnomalyDetection/TimeSeries/MatrixProfileDetector.cs
@@ -48,7 +48,7 @@ namespace AiDotNet.AnomalyDetection.TimeSeries;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
 [ResearchPaper("Matrix Profile I: All Pairs Similarity Joins for Time Series: A Unifying View", "https://doi.org/10.1109/ICDM.2016.0179", Year = 2016, Authors = "Chin-Chia Michael Yeh, Yan Zhu, Liudmila Ulanova, Nurjahan Begum, Yifei Ding, Hoang Anh Dau, Diego Furtado Silva, Abdullah Mueen, Eamonn Keogh")]
-public class MatrixProfileDetector<T> : AnomalyDetectorBase<T>
+public partial class MatrixProfileDetector<T> : AnomalyDetectorBase<T>
 {
     /// <summary>Weight for the value-deviation component in the combined anomaly score.</summary>
     private const double ValueDeviationWeight = 0.1;
diff --git a/src/AnomalyDetection/TimeSeries/NBEATSDetector.cs b/src/AnomalyDetection/TimeSeries/NBEATSDetector.cs
index 207c93d90d..6f42faac58 100644
--- a/src/AnomalyDetection/TimeSeries/NBEATSDetector.cs
+++ b/src/AnomalyDetection/TimeSeries/NBEATSDetector.cs
@@ -51,7 +51,7 @@ namespace AiDotNet.AnomalyDetection.TimeSeries;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
 [ResearchPaper("N-BEATS: Neural Basis Expansion Analysis for Interpretable Time Series Forecasting", "https://doi.org/10.48550/arXiv.1905.10437", Year = 2020, Authors = "Boris N. Oreshkin, Dmitri Carpov, Nicolas Chapados, Yoshua Bengio")]
-public class NBEATSDetector<T> : AnomalyDetectorBase<T>
+public partial class NBEATSDetector<T> : AnomalyDetectorBase<T>
 {
     private readonly int _numStacks;
     private readonly int _numBlocks;
diff --git a/src/AnomalyDetection/TimeSeries/STLDetector.cs b/src/AnomalyDetection/TimeSeries/STLDetector.cs
index 2fa4c5564c..39ac4f88a4 100644
--- a/src/AnomalyDetection/TimeSeries/STLDetector.cs
+++ b/src/AnomalyDetection/TimeSeries/STLDetector.cs
@@ -47,7 +47,7 @@ namespace AiDotNet.AnomalyDetection.TimeSeries;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
 [ResearchPaper("STL: A Seasonal-Trend Decomposition Procedure Based on Loess", "https://doi.org/10.6028/jres.095.015", Year = 1990, Authors = "Robert B. Cleveland, William S. Cleveland, Jean E. McRae, Irma Terpenning")]
-public class STLDetector<T> : AnomalyDetectorBase<T>
+public partial class STLDetector<T> : AnomalyDetectorBase<T>
 {
     private readonly int _seasonLength;
     private readonly int _trendSmoothness;
diff --git a/src/AnomalyDetection/TreeBased/ExtendedIsolationForest.cs b/src/AnomalyDetection/TreeBased/ExtendedIsolationForest.cs
index 571138758b..32bab685e8 100644
--- a/src/AnomalyDetection/TreeBased/ExtendedIsolationForest.cs
+++ b/src/AnomalyDetection/TreeBased/ExtendedIsolationForest.cs
@@ -46,7 +46,7 @@ namespace AiDotNet.AnomalyDetection.TreeBased;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
 [ResearchPaper("Extended Isolation Forest", "https://doi.org/10.1109/TKDE.2019.2947676", Year = 2019, Authors = "Sahand Hariri, Matias Carrasco Kind, Robert J. Brunner")]
-public class ExtendedIsolationForest<T> : AnomalyDetectorBase<T>
+public partial class ExtendedIsolationForest<T> : AnomalyDetectorBase<T>
 {
     private readonly int _numTrees;
     private readonly int _maxSamples;
@@ -225,11 +225,12 @@ private int[] SampleIndices(int total, int sampleSize, Random random)
         return indices.Take(sampleSize).ToArray();
     }
 
-    private class ExtendedIsolationTree
+    private partial class ExtendedIsolationTree
     {
         private readonly int _extensionLevel;
         private readonly Random _random;
         private readonly INumericOperations<T> _numOps;
+        [AiDotNet.Attributes.TrainableParameter]
         private Vector<T>? _normal;
 
         private T _intercept;
diff --git a/src/AnomalyDetection/TreeBased/FairCutForest.cs b/src/AnomalyDetection/TreeBased/FairCutForest.cs
index 419ff2053c..ae98002fbe 100644
--- a/src/AnomalyDetection/TreeBased/FairCutForest.cs
+++ b/src/AnomalyDetection/TreeBased/FairCutForest.cs
@@ -45,7 +45,7 @@ namespace AiDotNet.AnomalyDetection.TreeBased;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
     [ResearchPaper("Robust Random Cut Forest Based Anomaly Detection on Streams", "https://doi.org/10.1145/2806416.2806568")]
-public class FairCutForest<T> : AnomalyDetectorBase<T>
+public partial class FairCutForest<T> : AnomalyDetectorBase<T>
 {
     private readonly int _numTrees;
     private readonly int _maxSamples;
diff --git a/src/AnomalyDetection/TreeBased/IsolationForest.cs b/src/AnomalyDetection/TreeBased/IsolationForest.cs
index 73018c1b99..94c3fc617f 100644
--- a/src/AnomalyDetection/TreeBased/IsolationForest.cs
+++ b/src/AnomalyDetection/TreeBased/IsolationForest.cs
@@ -47,7 +47,7 @@ namespace AiDotNet.AnomalyDetection.TreeBased;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
 [ResearchPaper("Isolation Forest", "https://doi.org/10.1109/ICDM.2008.17", Year = 2008, Authors = "Fei Tony Liu, Kai Ming Ting, Zhi-Hua Zhou")]
-public class IsolationForest<T> : AnomalyDetectorBase<T>
+public partial class IsolationForest<T> : AnomalyDetectorBase<T>
 {
     private readonly int _numTrees;
     private readonly int _maxSamples;
diff --git a/src/AnomalyDetection/TreeBased/SCiForest.cs b/src/AnomalyDetection/TreeBased/SCiForest.cs
index 7fb29fb528..e4a3565d61 100644
--- a/src/AnomalyDetection/TreeBased/SCiForest.cs
+++ b/src/AnomalyDetection/TreeBased/SCiForest.cs
@@ -48,7 +48,7 @@ namespace AiDotNet.AnomalyDetection.TreeBased;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
 [ResearchPaper("Isolation-Based Anomaly Detection", "https://doi.org/10.1145/2133360.2133363", Year = 2012, Authors = "Fei Tony Liu, Kai Ming Ting, Zhi-Hua Zhou")]
-public class SCiForest<T> : AnomalyDetectorBase<T>
+public partial class SCiForest<T> : AnomalyDetectorBase<T>
 {
     private readonly int _numTrees;
     private readonly int _maxSamples;
@@ -222,7 +222,7 @@ private static int[] SampleIndices(int total, int sampleSize, Random random)
         return indices.Take(sampleSize).ToArray();
     }
 
-    private class SCiTree
+    private partial class SCiTree
     {
         private readonly INumericOperations<T> _ops;
 
@@ -232,6 +232,7 @@ private class SCiTree
         private readonly int _nFeatures;
         private readonly double _sparsity;
         private readonly Random _random;
+        [AiDotNet.Attributes.TrainableParameter]
         private Vector<T>? _sparseWeights;
         private T _threshold;
         private SCiTree? _left;
diff --git a/src/Attributes/FittedParameterAttribute.cs b/src/Attributes/FittedParameterAttribute.cs
index 2a98351352..a9ecfb4f9d 100644
--- a/src/Attributes/FittedParameterAttribute.cs
+++ b/src/Attributes/FittedParameterAttribute.cs
@@ -11,4 +11,32 @@ public sealed class FittedParameterAttribute : Attribute
     /// <summary>Gets the lifecycle for fitted state.</summary>
     public AiDotNet.Models.Parameters.ParameterAvailability Availability { get; set; }
         = AiDotNet.Models.Parameters.ParameterAvailability.Fit;
+
+    /// <summary>
+    /// Declares that this member's extent comes from the DATA the caller supplies rather than from
+    /// the layer's construction arguments, and so must be persisted without joining the flat
+    /// parameter vector.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// Ordinary fitted state -- a reservoir's fixed weights, a normalization layer's running
+    /// statistics -- is sized once at construction and never changes again, so carrying it in the
+    /// flat vector is what lets one vector describe the whole layer, which is the guarantee
+    /// <c>state_dict()</c> does not offer.
+    /// </para>
+    /// <para>
+    /// Input-sized state cannot honor that guarantee. A graph layer's adjacency matrix is
+    /// <c>[numNodes, numNodes]</c> for whatever graph was handed in last, so putting it in the
+    /// vector makes <c>ParameterCount</c> a function of the most recent input: the width changes
+    /// under a caller who only ran a forward pass, and a checkpoint taken on a ten-node graph
+    /// could never restore into a twenty-node one. Both are true of the same weights, which is
+    /// what makes it a property of the member rather than of the moment.
+    /// </para>
+    /// <para>
+    /// Marked members are still registered through <c>RegisterBuffer</c>, so they are written and
+    /// read by name in the layer's serialized buffer block and copied by <c>DeepCopy</c>. They are
+    /// simply absent from the parameter vector, where their width was never meaningful.
+    /// </para>
+    /// </remarks>
+    public bool InputSized { get; set; }
 }
diff --git a/src/Attributes/LayerStateAttribute.cs b/src/Attributes/LayerStateAttribute.cs
index 5a15536803..c268ec7036 100644
--- a/src/Attributes/LayerStateAttribute.cs
+++ b/src/Attributes/LayerStateAttribute.cs
@@ -57,4 +57,45 @@ public sealed class LayerStateAttribute : Attribute
     /// </para>
     /// </remarks>
     public string? Key { get; set; }
+
+    /// <summary>
+    /// Names the field or property holding this parameter, when it is not one the generator
+    /// would look for on its own.
+    /// </summary>
+    /// <remarks>
+    /// Inference looks for <c>name</c>, <c>_name</c>, <c>m_name</c>, <c>Name</c> or <c>_Name</c> of
+    /// the parameter's type. A layer that stores the argument anywhere else could not be rescued by
+    /// the attribute either, because the same five-name rule applied to it. Two cases needed this:
+    /// <c>EdgeConditionalConvolutionalLayer</c> keeps <c>int edgeFeatures</c> in
+    /// <c>_edgeFeaturesCount</c> because <c>_edgeFeatures</c> is already a cached tensor, and
+    /// <c>SetAbstractionLayer</c> has <c>int[]</c> and <c>int[][]</c> overloads of the same
+    /// parameter that cannot share one field. The named member is still type-checked.
+    /// </remarks>
+    public string? Member { get; set; }
+
+    /// <summary>
+    /// Skips writing this parameter when its backing member is zero or negative, meaning the layer
+    /// has not resolved it yet.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// For a lazily-shaped layer, a size of 0 is the TRUTH — the layer genuinely has not been given
+    /// an input yet — but it is a truth its own constructor rejects. Writing it produced a saved
+    /// state that could not be rebuilt: a <c>LayerNormalizationLayer</c> that was never forward-passed
+    /// saved <c>featureSize = 0</c> and its rebuild threw "featureSize must be positive, got 0".
+    /// </para>
+    /// <para>
+    /// Omitting the value instead makes the generated factory's <c>state.HasAll(...)</c> check fail,
+    /// so <c>TryCreate</c> returns false and the caller falls through to the path that builds the
+    /// layer lazily — which is the correct shape for a layer that has no width yet. The alternative,
+    /// calling the constructor and catching its exception, would use a throw for control flow and
+    /// hide genuine errors.
+    /// </para>
+    /// <para>
+    /// Set this ONLY on a parameter whose zero means "not yet known". A zero that is a legitimate
+    /// saved value — a padding of 0, an offset of 0 — must NOT carry it, or that value silently
+    /// stops round-tripping.
+    /// </para>
+    /// </remarks>
+    public bool OmitWhenNonPositive { get; set; }
 }
diff --git a/src/Audio/AudioGen/AudioGenModel.cs b/src/Audio/AudioGen/AudioGenModel.cs
index fdfe4160fa..efd7ec5c18 100644
--- a/src/Audio/AudioGen/AudioGenModel.cs
+++ b/src/Audio/AudioGen/AudioGenModel.cs
@@ -88,7 +88,7 @@ namespace AiDotNet.Audio.AudioGen;
 [ModelComplexity(ModelComplexity.VeryHigh)]
 [ModelInput(typeof(string), typeof(Tensor<>))]
 [ResearchPaper("AudioGen: Textually Guided Audio Generation", "https://doi.org/10.48550/arXiv.2209.15352", Year = 2022, Authors = "Felix Kreuk, Gabriel Synnaeve, Adam Polyak, Uriel Singer, Alexandre Défossez, Jade Copet, Devi Parikh, Yaniv Taigman, Yossi Adi")]
-public class AudioGenModel<T> : AudioNeuralNetworkBase<T>, IAudioGenerator<T>
+public partial class AudioGenModel<T> : AudioNeuralNetworkBase<T>, IAudioGenerator<T>
 {
     /// <inheritdoc />
     /// <remarks>
@@ -936,80 +936,12 @@ public override ModelMetadata<T> GetModelMetadata()
     /// <summary>
     /// Serializes network-specific data.
     /// </summary>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write((int)_modelSize);
-        writer.Write(_sampleRate);
-        writer.Write(_durationSeconds);
-        writer.Write(_maxDurationSeconds);
-        writer.Write(_temperature);
-        writer.Write(_topK);
-        writer.Write(_topP);
-        writer.Write(_guidanceScale);
-        writer.Write(_channels);
-        writer.Write(_textHiddenDim);
-        writer.Write(_lmHiddenDim);
-        writer.Write(_numLmLayers);
-        writer.Write(_numHeads);
-        writer.Write(_numCodebooks);
-        writer.Write(_codebookSize);
-        writer.Write(_maxTextLength);
-    }
+
 
     /// <summary>
     /// Deserializes network-specific data.
     /// </summary>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        // Read values to advance stream position (validation done in CreateNewInstance)
-        _ = reader.ReadBoolean();  // useNativeMode
-        _ = reader.ReadInt32();    // modelSize
-        _ = reader.ReadInt32();    // sampleRate
-        _ = reader.ReadDouble();   // durationSeconds
-        _ = reader.ReadDouble();   // maxDurationSeconds
-        _ = reader.ReadDouble();   // temperature
-        _ = reader.ReadInt32();    // topK
-        _ = reader.ReadDouble();   // topP
-        _ = reader.ReadDouble();   // guidanceScale
-        _ = reader.ReadInt32();    // channels
-        _ = reader.ReadInt32();    // textHiddenDim
-        _ = reader.ReadInt32();    // lmHiddenDim
-        _ = reader.ReadInt32();    // numLmLayers
-        _ = reader.ReadInt32();    // numHeads
-        _ = reader.ReadInt32();    // numCodebooks
-        _ = reader.ReadInt32();    // codebookSize
-        _ = reader.ReadInt32();    // maxTextLength
-    }
 
-    /// <summary>
-    /// Creates a new instance of this model for cloning.
-    /// </summary>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new AudioGenModel<T>(
-            Architecture,
-            _modelSize,
-            _sampleRate,
-            _durationSeconds,
-            _maxDurationSeconds,
-            _temperature,
-            _topK,
-            _topP,
-            _guidanceScale,
-            _channels,
-            _textHiddenDim,
-            _lmHiddenDim,
-            _numLmLayers,
-            _numHeads,
-            _numCodebooks,
-            _codebookSize,
-            _maxTextLength,
-            seed: null,
-            tokenizer: _tokenizer,
-            optimizer: null,
-            lossFunction: _lossFunction);
-    }
 
     #endregion
 
diff --git a/src/Audio/AudioLDM/AudioLDMModel.cs b/src/Audio/AudioLDM/AudioLDMModel.cs
index 166fdfd3c7..938a03fce7 100644
--- a/src/Audio/AudioLDM/AudioLDMModel.cs
+++ b/src/Audio/AudioLDM/AudioLDMModel.cs
@@ -67,7 +67,7 @@ namespace AiDotNet.Audio.AudioLDM;
 [ModelComplexity(ModelComplexity.VeryHigh)]
 [ModelInput(typeof(string), typeof(Tensor<>))]
 [ResearchPaper("AudioLDM: Text-to-Audio Generation with Latent Diffusion Models", "https://doi.org/10.48550/arXiv.2301.12503", Year = 2023, Authors = "Haohe Liu, Zehua Chen, Yi Yuan, Xinhao Mei, Xubo Liu, Danilo Mandic, Wenwu Wang, Mark D. Plumbley")]
-public class AudioLDMModel<T> : AudioNeuralNetworkBase<T>, IAudioGenerator<T>
+public partial class AudioLDMModel<T> : AudioNeuralNetworkBase<T>, IAudioGenerator<T>
 {
     /// <inheritdoc />
     /// <remarks>
@@ -1358,45 +1358,12 @@ public override ModelMetadata<T> GetModelMetadata()
     /// <summary>
     /// Serializes network-specific data.
     /// </summary>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write((int)_options.ModelSize);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.NumInferenceSteps);
-        writer.Write(_options.GuidanceScale);
-    }
+
 
     /// <summary>
     /// Deserializes network-specific data.
     /// </summary>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        // Restore deserialized values to the options (must not discard with _ =)
-        _ = reader.ReadBoolean(); // useNativeMode is readonly, cannot restore
-        _options.ModelSize = (AudioLDMModelSize)reader.ReadInt32();
-        _options.SampleRate = reader.ReadInt32();
-        _options.NumInferenceSteps = reader.ReadInt32();
-        _options.GuidanceScale = reader.ReadDouble();
-
-        // Note: SampleRate property is expression-bodied and returns _options.SampleRate,
-        // so setting _options.SampleRate above is sufficient.
-        // _useNativeMode is readonly and set in constructor, so we can't restore it here.
-        // The CreateNewInstance method should be used for proper cloning.
-    }
 
-    /// <summary>
-    /// Creates a new instance for cloning.
-    /// </summary>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new AudioLDMModel<T>(
-            Architecture,
-            _options,
-            _tokenizer,
-            null,
-            _lossFunction);
-    }
 
     #endregion
 
diff --git a/src/Audio/AudioNeuralNetworkBase.cs b/src/Audio/AudioNeuralNetworkBase.cs
index a88148d209..419f352408 100644
--- a/src/Audio/AudioNeuralNetworkBase.cs
+++ b/src/Audio/AudioNeuralNetworkBase.cs
@@ -40,7 +40,7 @@ namespace AiDotNet.Audio;
 // Batch tracks the input; the feature width is model-specific and comes from OutputFeatureWidth below.
 [TensorLayout(TensorAxis.Batch, TensorAxis.Features, Direction = TensorLayoutDirection.Input)]
 [TensorLayout(TensorAxis.Batch, TensorAxis.Features, Direction = TensorLayoutDirection.Output)]
-public abstract class AudioNeuralNetworkBase<T> : NeuralNetworkBase<T>, IShapeContract
+public abstract partial class AudioNeuralNetworkBase<T> : NeuralNetworkBase<T>, IShapeContract
 {
     /// <summary>
     /// The width of this model's output feature axis, or 0 when it has not been stated.
diff --git a/src/Audio/Classification/AST.cs b/src/Audio/Classification/AST.cs
index 5ffa437636..7627915656 100644
--- a/src/Audio/Classification/AST.cs
+++ b/src/Audio/Classification/AST.cs
@@ -101,7 +101,7 @@ namespace AiDotNet.Audio.Classification;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("AST: Audio Spectrogram Transformer", "https://arxiv.org/abs/2104.01778", Year = 2021, Authors = "Yuan Gong, Yu-An Chung, James Glass")]
-public class AST<T> : AudioClassifierBase<T>, IAudioEventDetector<T>
+public partial class AST<T> : AudioClassifierBase<T>, IAudioEventDetector<T>
 {
     #region Fields
 
@@ -569,92 +569,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.NumMels);
-        writer.Write(_options.FftSize);
-        writer.Write(_options.HopLength);
-        writer.Write(_options.EmbeddingDim);
-        writer.Write(_options.NumEncoderLayers);
-        writer.Write(_options.NumAttentionHeads);
-        writer.Write(_options.FeedForwardDim);
-        writer.Write(_options.PatchSize);
-        writer.Write(_options.PatchStride);
-        writer.Write(_options.Threshold);
-        writer.Write(_options.WindowSize);
-        writer.Write(_options.WindowOverlap);
-        writer.Write(_options.DropoutRate);
-        writer.Write((int)_options.FMin);
-        writer.Write((int)_options.FMax);
-
-        writer.Write(ClassLabels.Count);
-        foreach (var label in ClassLabels)
-        {
-            writer.Write(label);
-        }
-    }
-
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string modelPath = reader.ReadString();
-        if (!string.IsNullOrEmpty(modelPath))
-        {
-            _options.ModelPath = modelPath;
-        }
 
-        _options.SampleRate = reader.ReadInt32();
-        _options.NumMels = reader.ReadInt32();
-        _options.FftSize = reader.ReadInt32();
-        _options.HopLength = reader.ReadInt32();
-        _options.EmbeddingDim = reader.ReadInt32();
-        _options.NumEncoderLayers = reader.ReadInt32();
-        _options.NumAttentionHeads = reader.ReadInt32();
-        _options.FeedForwardDim = reader.ReadInt32();
-        _options.PatchSize = reader.ReadInt32();
-        _options.PatchStride = reader.ReadInt32();
-        _options.Threshold = reader.ReadDouble();
-        _options.WindowSize = reader.ReadDouble();
-        _options.WindowOverlap = reader.ReadDouble();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.FMin = reader.ReadInt32();
-        _options.FMax = reader.ReadInt32();
-
-        int numLabels = reader.ReadInt32();
-        var labels = new string[numLabels];
-        for (int i = 0; i < numLabels; i++)
-        {
-            labels[i] = reader.ReadString();
-        }
-        ClassLabels = labels;
-
-        _melSpectrogram = new MelSpectrogram<T>(
-            sampleRate: _options.SampleRate,
-            nMels: _options.NumMels,
-            nFft: _options.FftSize,
-            hopLength: _options.HopLength,
-            fMin: _options.FMin,
-            fMax: _options.FMax,
-            logMel: true);
-
-        if (!_useNativeMode && _options.ModelPath is { } onnxModelPath && !string.IsNullOrEmpty(onnxModelPath))
-        {
-            OnnxEncoder = new OnnxModel<T>(onnxModelPath, _options.OnnxOptions);
-        }
-    }
 
     /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var options = new ASTOptions(_options);
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new AST<T>(Architecture, mp, options);
-        return new AST<T>(Architecture, options);
-    }
+
 
     #endregion
 
diff --git a/src/Audio/Classification/AudioEventDetector.cs b/src/Audio/Classification/AudioEventDetector.cs
index d840124a66..746ec2dcd6 100644
--- a/src/Audio/Classification/AudioEventDetector.cs
+++ b/src/Audio/Classification/AudioEventDetector.cs
@@ -66,7 +66,7 @@ namespace AiDotNet.Audio.Classification;
 // detector implements. The previous entry paired that id with the title and author list of the
 // companion Audio Set dataset paper (Gemmeke et al., ICASSP 2017) — two different papers.
 [ResearchPaper("CNN Architectures for Large-Scale Audio Classification", "https://arxiv.org/abs/1609.09430", Year = 2017, Authors = "Shawn Hershey, Sourish Chaudhuri, Daniel P. W. Ellis, Jort F. Gemmeke, Aren Jansen, R. Channing Moore, Manoj Plakal, Devin Platt, Rif A. Saurous, Bryan Seybold, Malcolm Slaney, Ron J. Weiss, Kevin Wilson")]
-public class AudioEventDetector<T> : AudioClassifierBase<T>, IAudioEventDetector<T>
+public partial class AudioEventDetector<T> : AudioClassifierBase<T>, IAudioEventDetector<T>
 {
     #region Fields
 
@@ -634,80 +634,12 @@ public override ModelMetadata<T> GetModelMetadata()
     /// <summary>
     /// Serializes network-specific data.
     /// </summary>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        // Write ONNX mode state
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-
-        // Write options
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.NumMels);
-        writer.Write(_options.FftSize);
-        writer.Write(_options.HopLength);
-        writer.Write(_options.WindowSize);
-        writer.Write(_options.Threshold);
-        writer.Write(ClassLabels.Count);
-        foreach (var label in ClassLabels)
-        {
-            writer.Write(label);
-        }
-    }
+
 
     /// <summary>
     /// Deserializes network-specific data.
     /// </summary>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        // Restore ONNX mode state
-        _useNativeMode = reader.ReadBoolean();
-        string modelPath = reader.ReadString();
-        if (!string.IsNullOrEmpty(modelPath))
-        {
-            _options.ModelPath = modelPath;
-        }
-
-        // Restore options properties
-        _options.SampleRate = reader.ReadInt32();
-        _options.NumMels = reader.ReadInt32();
-        _options.FftSize = reader.ReadInt32();
-        _options.HopLength = reader.ReadInt32();
-        _options.WindowSize = reader.ReadDouble();
-        _options.Threshold = reader.ReadDouble();
-
-        // Read class labels
-        int numLabels = reader.ReadInt32();
-        var labels = new string[numLabels];
-        for (int i = 0; i < numLabels; i++)
-        {
-            labels[i] = reader.ReadString();
-        }
-        ClassLabels = labels;
-
-        // Reinitialize mel spectrogram with deserialized options
-        _melSpectrogram = new MelSpectrogram<T>(
-            sampleRate: _options.SampleRate,
-            nMels: _options.NumMels,
-            nFft: _options.FftSize,
-            hopLength: _options.HopLength,
-            fMin: _options.FMin,
-            fMax: _options.FMax,
-            logMel: true);
-
-        // Restore ONNX model if in ONNX inference mode
-        if (!_useNativeMode && _options.ModelPath is { } onnxModelPath && !string.IsNullOrEmpty(onnxModelPath))
-        {
-            OnnxEncoder = new OnnxModel<T>(onnxModelPath, _options.OnnxOptions);
-        }
-    }
 
-    /// <summary>
-    /// Creates a new instance for deserialization.
-    /// </summary>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new AudioEventDetector<T>(Architecture, _options);
-    }
 
     #endregion
 
diff --git a/src/Audio/Classification/AudioLDMClassifier.cs b/src/Audio/Classification/AudioLDMClassifier.cs
index b97d4ee7f4..2dc2bff05a 100644
--- a/src/Audio/Classification/AudioLDMClassifier.cs
+++ b/src/Audio/Classification/AudioLDMClassifier.cs
@@ -42,7 +42,7 @@ namespace AiDotNet.Audio.Classification;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("AudioLDM: Text-to-Audio Generation with Latent Diffusion Models", "https://arxiv.org/abs/2301.12503", Year = 2023, Authors = "Haohe Liu, Zehua Chen, Yi Yuan, Xinhao Mei, Xubo Liu, Danilo Mandic, Wenwu Wang, Mark D. Plumbley")]
-public class AudioLDMClassifier<T> : AudioClassifierBase<T>, IAudioEventDetector<T>
+public partial class AudioLDMClassifier<T> : AudioClassifierBase<T>, IAudioEventDetector<T>
 {
     #region Fields
 
@@ -269,39 +269,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty);
-        w.Write(_options.SampleRate); w.Write(_options.NumMels); w.Write(_options.FftSize); w.Write(_options.HopLength);
-        w.Write(_options.LatentDim); w.Write(_options.ClassifierDim); w.Write(_options.NumClassifierLayers);
-        w.Write(_options.Threshold); w.Write(_options.DetectionWindowSize); w.Write(_options.WindowOverlap);
-        w.Write(_options.DropoutRate);
-        w.Write(ClassLabels.Count);
-        foreach (var label in ClassLabels) w.Write(label);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.SampleRate = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.FftSize = r.ReadInt32(); _options.HopLength = r.ReadInt32();
-        _options.LatentDim = r.ReadInt32(); _options.ClassifierDim = r.ReadInt32(); _options.NumClassifierLayers = r.ReadInt32();
-        _options.Threshold = r.ReadDouble(); _options.DetectionWindowSize = r.ReadDouble(); _options.WindowOverlap = r.ReadDouble();
-        _options.DropoutRate = r.ReadDouble();
-        int numLabels = r.ReadInt32();
-        var labels = new string[numLabels]; for (int i = 0; i < numLabels; i++) labels[i] = r.ReadString();
-        ClassLabels = labels;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions);
-        else if (_useNativeMode)
-            _optimizer = new AdamOptimizer<T, Tensor<T>, Tensor<T>>(this);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new AudioLDMClassifier<T>(Architecture, mp, _options);
-        return new AudioLDMClassifier<T>(Architecture, _options);
-    }
+
 
     #endregion
 
diff --git a/src/Audio/Classification/AudioMAE.cs b/src/Audio/Classification/AudioMAE.cs
index d9ff679458..f0fd1e7929 100644
--- a/src/Audio/Classification/AudioMAE.cs
+++ b/src/Audio/Classification/AudioMAE.cs
@@ -49,7 +49,7 @@ namespace AiDotNet.Audio.Classification;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Masked Autoencoders that Listen", "https://arxiv.org/abs/2207.06405", Year = 2022, Authors = "Po-Yao Huang, Hu Xu, Juncheng Li, Alexei Baevski, Michael Auli, Wojciech Galuba, Florian Metze, Christoph Feichtenhofer")]
-public class AudioMAE<T> : AudioClassifierBase<T>, IAudioEventDetector<T>
+public partial class AudioMAE<T> : AudioClassifierBase<T>, IAudioEventDetector<T>
 {
     #region Fields
 
@@ -247,34 +247,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty);
-        w.Write(_options.SampleRate); w.Write(_options.NumMels); w.Write(_options.FftSize); w.Write(_options.HopLength);
-        w.Write(_options.EncoderEmbeddingDim); w.Write(_options.NumEncoderLayers); w.Write(_options.NumEncoderHeads);
-        w.Write(_options.PatchSize); w.Write(_options.PatchStride); w.Write(_options.Threshold); w.Write(_options.WindowSize); w.Write(_options.WindowOverlap); w.Write(_options.DropoutRate); w.Write(_options.MaskRatio);
-        w.Write((int)_options.FMin); w.Write((int)_options.FMax);
-        w.Write(ClassLabels.Count); foreach (var l in ClassLabels) w.Write(l);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.SampleRate = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.FftSize = r.ReadInt32(); _options.HopLength = r.ReadInt32();
-        _options.EncoderEmbeddingDim = r.ReadInt32(); _options.NumEncoderLayers = r.ReadInt32(); _options.NumEncoderHeads = r.ReadInt32();
-        _options.PatchSize = r.ReadInt32(); _options.PatchStride = r.ReadInt32(); _options.Threshold = r.ReadDouble(); _options.WindowSize = r.ReadDouble(); _options.WindowOverlap = r.ReadDouble(); _options.DropoutRate = r.ReadDouble(); _options.MaskRatio = r.ReadDouble();
-        _options.FMin = r.ReadInt32(); _options.FMax = r.ReadInt32();
-        int n = r.ReadInt32(); var labels = new string[n]; for (int i = 0; i < n; i++) labels[i] = r.ReadString(); ClassLabels = labels;
-        _melSpectrogram = new MelSpectrogram<T>(_options.SampleRate, _options.NumMels, _options.FftSize, _options.HopLength, _options.FMin, _options.FMax, logMel: true);
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new AudioMAE<T>(Architecture, mp, _options);
-        return new AudioMAE<T>(Architecture, _options);
-    }
+
 
     #endregion
 
diff --git a/src/Audio/Classification/AudioSep.cs b/src/Audio/Classification/AudioSep.cs
index 257c10d974..ca64fba5da 100644
--- a/src/Audio/Classification/AudioSep.cs
+++ b/src/Audio/Classification/AudioSep.cs
@@ -66,7 +66,7 @@ namespace AiDotNet.Audio.Classification;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Separate Anything You Describe", "https://arxiv.org/abs/2308.05037", Year = 2024, Authors = "Xubo Liu, Qiuqiang Kong, Yan Zhao, Haohe Liu, Yi Yuan, Yuzhuo Liu, Rui Xia, Yuxuan Wang, Mark D. Plumbley, Wenwu Wang")]
-public class AudioSep<T> : AudioClassifierBase<T>, IAudioEventDetector<T>
+public partial class AudioSep<T> : AudioClassifierBase<T>, IAudioEventDetector<T>
 {
     #region Fields
 
@@ -326,48 +326,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty);
-        w.Write(_options.SampleRate); w.Write(_options.NumMels);
-        w.Write(_options.FftSize); w.Write(_options.HopLength);
-        w.Write(_options.CLAPEmbeddingDim); w.Write(_options.SeparationDim);
-        w.Write(_options.NumSeparationLayers); w.Write(_options.NumHeads);
-        w.Write(_options.EncoderChannels.Length);
-        foreach (int ch in _options.EncoderChannels) w.Write(ch);
-        w.Write(_options.Threshold); w.Write(_options.DetectionWindowSize);
-        w.Write(_options.WindowOverlap); w.Write(_options.DropoutRate);
-        w.Write((int)_options.FMin); w.Write((int)_options.FMax);
-        w.Write(ClassLabels.Count);
-        foreach (var label in ClassLabels) w.Write(label);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.SampleRate = r.ReadInt32(); _options.NumMels = r.ReadInt32();
-        _options.FftSize = r.ReadInt32(); _options.HopLength = r.ReadInt32();
-        _options.CLAPEmbeddingDim = r.ReadInt32(); _options.SeparationDim = r.ReadInt32();
-        _options.NumSeparationLayers = r.ReadInt32(); _options.NumHeads = r.ReadInt32();
-        int nch = r.ReadInt32(); _options.EncoderChannels = new int[nch];
-        for (int i = 0; i < nch; i++) _options.EncoderChannels[i] = r.ReadInt32();
-        _options.Threshold = r.ReadDouble(); _options.DetectionWindowSize = r.ReadDouble();
-        _options.WindowOverlap = r.ReadDouble(); _options.DropoutRate = r.ReadDouble();
-        _options.FMin = r.ReadInt32(); _options.FMax = r.ReadInt32();
-        int numLabels = r.ReadInt32(); var labels = new string[numLabels];
-        for (int i = 0; i < numLabels; i++) labels[i] = r.ReadString();
-        ClassLabels = labels;
-        _melSpectrogram = new MelSpectrogram<T>(sampleRate: _options.SampleRate, nMels: _options.NumMels,
-            nFft: _options.FftSize, hopLength: _options.HopLength, fMin: _options.FMin, fMax: _options.FMax, logMel: true);
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new AudioSep<T>(Architecture, mp, _options);
-        return new AudioSep<T>(Architecture, _options);
-    }
+
 
     #endregion
 
diff --git a/src/Audio/Classification/BEATs.cs b/src/Audio/Classification/BEATs.cs
index 8cef03b95c..ade783715d 100644
--- a/src/Audio/Classification/BEATs.cs
+++ b/src/Audio/Classification/BEATs.cs
@@ -149,7 +149,7 @@ namespace AiDotNet.Audio.Classification;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("BEATs: Audio Pre-Training with Acoustic Tokenizers", "https://arxiv.org/abs/2212.09058", Year = 2023, Authors = "Sanyuan Chen, Yu Wu, Chengyi Wang, Shujie Liu, Daniel Tompkins, Zhuo Chen, Furu Wei")]
-public class BEATs<T> : AudioClassifierBase<T>, IAudioEventDetector<T>
+public partial class BEATs<T> : AudioClassifierBase<T>, IAudioEventDetector<T>
 {
     #region Fields
 
@@ -1227,39 +1227,7 @@ public override ModelMetadata<T> GetModelMetadata()
     /// <see cref="DeserializeNetworkSpecificData"/> to continue where you left off.
     /// </para>
     /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        // Write mode and model path
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-
-        // Write architecture hyperparameters
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.NumMels);
-        writer.Write(_options.FftSize);
-        writer.Write(_options.HopLength);
-        writer.Write(_options.EmbeddingDim);
-        writer.Write(_options.NumEncoderLayers);
-        writer.Write(_options.NumAttentionHeads);
-        writer.Write(_options.FeedForwardDim);
-        writer.Write(_options.PatchSize);
-        writer.Write(_options.PatchStride);
-        writer.Write(_options.Threshold);
-        writer.Write(_options.WindowSize);
-        writer.Write(_options.WindowOverlap);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.MaskProbability);
-        writer.Write(_options.CodebookSize);
-        writer.Write(_options.FMin);
-        writer.Write(_options.FMax);
-
-        // Write class labels
-        writer.Write(ClassLabels.Count);
-        foreach (var label in ClassLabels)
-        {
-            writer.Write(label);
-        }
-    }
+
 
     /// <summary>
     /// Deserializes BEATs-specific model data from a binary stream.
@@ -1280,80 +1248,7 @@ protected override void SerializeNetworkSpecificData(BinaryWriter writer)
     /// at the saved path.
     /// </para>
     /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        // Restore mode and model path
-        _useNativeMode = reader.ReadBoolean();
-        string modelPath = reader.ReadString();
-        if (!string.IsNullOrEmpty(modelPath))
-        {
-            _options.ModelPath = modelPath;
-        }
-
-        // Restore architecture hyperparameters
-        _options.SampleRate = reader.ReadInt32();
-        _options.NumMels = reader.ReadInt32();
-        _options.FftSize = reader.ReadInt32();
-        _options.HopLength = reader.ReadInt32();
-        _options.EmbeddingDim = reader.ReadInt32();
-        _options.NumEncoderLayers = reader.ReadInt32();
-        _options.NumAttentionHeads = reader.ReadInt32();
-        _options.FeedForwardDim = reader.ReadInt32();
-        _options.PatchSize = reader.ReadInt32();
-        _options.PatchStride = reader.ReadInt32();
-        _options.Threshold = reader.ReadDouble();
-        _options.WindowSize = reader.ReadDouble();
-        _options.WindowOverlap = reader.ReadDouble();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.MaskProbability = reader.ReadDouble();
-        _options.CodebookSize = reader.ReadInt32();
-        _options.FMin = reader.ReadInt32();
-        _options.FMax = reader.ReadInt32();
-
-        // Read class labels
-        int numLabels = reader.ReadInt32();
-        var labels = new string[numLabels];
-        for (int i = 0; i < numLabels; i++)
-        {
-            labels[i] = reader.ReadString();
-        }
-        ClassLabels = labels;
-
-        // Reinitialize mel spectrogram with deserialized options
-        _melSpectrogram = new MelSpectrogram<T>(
-            sampleRate: _options.SampleRate,
-            nMels: _options.NumMels,
-            nFft: _options.FftSize,
-            hopLength: _options.HopLength,
-            fMin: _options.FMin,
-            fMax: _options.FMax,
-            logMel: true);
-
-        // Restore ONNX model if in ONNX inference mode
-        if (!_useNativeMode && _options.ModelPath is { } onnxModelPath && !string.IsNullOrEmpty(onnxModelPath))
-        {
-            OnnxEncoder = new OnnxModel<T>(onnxModelPath, _options.OnnxOptions);
-        }
-    }
 
-    /// <summary>
-    /// Creates a new BEATs instance for the deserialization framework.
-    /// </summary>
-    /// <returns>A new BEATs instance configured with the same architecture and options.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> This is used internally by the serialization system. When loading
-    /// a saved model, the framework first creates a blank instance using this method, then
-    /// fills in the saved weights and configuration. You don't need to call this directly.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var options = new BEATsOptions(_options);
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new BEATs<T>(Architecture, mp, options);
-        return new BEATs<T>(Architecture, options);
-    }
 
     #endregion
 
diff --git a/src/Audio/Classification/CLAP.cs b/src/Audio/Classification/CLAP.cs
index 62011238bc..79c86b07b3 100644
--- a/src/Audio/Classification/CLAP.cs
+++ b/src/Audio/Classification/CLAP.cs
@@ -62,7 +62,7 @@ namespace AiDotNet.Audio.Classification;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Large-Scale Contrastive Language-Audio Pre-Training with Feature Fusion and Keyword-to-Caption Augmentation", "https://doi.org/10.1109/ICASSP49357.2023.10095969", Year = 2023, Authors = "Yusong Wu, Ke Chen, Tianyu Zhang, Yuchen Hui, Taylor Berg-Kirkpatrick, Shlomo Dubnov")]
-public class CLAP<T> : AudioClassifierBase<T>, IAudioEventDetector<T>
+public partial class CLAP<T> : AudioClassifierBase<T>, IAudioEventDetector<T>
 {
     #region Fields
 
@@ -433,78 +433,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc />
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode);
-        w.Write(_options.ModelPath ?? string.Empty);
-        w.Write(_options.TextEncoderModelPath ?? string.Empty);
-        w.Write(_options.SampleRate);
-        w.Write(_options.NumMels);
-        w.Write(_options.FftSize);
-        w.Write(_options.HopLength);
-        w.Write(_options.AudioEmbeddingDim);
-        w.Write(_options.ProjectionDim);
-        w.Write(_options.NumAudioEncoderLayers);
-        w.Write(_options.NumAudioAttentionHeads);
-        w.Write(_options.Temperature);
-        w.Write(_options.Threshold);
-        w.Write(_options.WindowSize);
-        w.Write(_options.WindowOverlap);
-        w.Write(_options.DropoutRate);
-        w.Write((int)_options.FMin); w.Write((int)_options.FMax);
-        w.Write(ClassLabels.Count);
-        foreach (var l in ClassLabels)
-            w.Write(l);
-        w.Write(_textPrompts.Length);
-        foreach (var p in _textPrompts)
-            w.Write(p);
-    }
 
-    /// <inheritdoc />
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean();
-        string mp = r.ReadString();
-        if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        string tp = r.ReadString();
-        if (!string.IsNullOrEmpty(tp)) _options.TextEncoderModelPath = tp;
-        _options.SampleRate = r.ReadInt32();
-        _options.NumMels = r.ReadInt32();
-        _options.FftSize = r.ReadInt32();
-        _options.HopLength = r.ReadInt32();
-        _options.AudioEmbeddingDim = r.ReadInt32();
-        _options.ProjectionDim = r.ReadInt32();
-        _options.NumAudioEncoderLayers = r.ReadInt32();
-        _options.NumAudioAttentionHeads = r.ReadInt32();
-        _options.Temperature = r.ReadDouble();
-        _options.Threshold = r.ReadDouble();
-        _options.WindowSize = r.ReadDouble();
-        _options.WindowOverlap = r.ReadDouble();
-        _options.DropoutRate = r.ReadDouble();
-        _options.FMin = r.ReadInt32(); _options.FMax = r.ReadInt32();
-        int n = r.ReadInt32();
-        var labels = new string[n];
-        for (int i = 0; i < n; i++) labels[i] = r.ReadString();
-        ClassLabels = labels;
-        int np = r.ReadInt32();
-        _textPrompts = new string[np];
-        for (int i = 0; i < np; i++) _textPrompts[i] = r.ReadString();
-        _melSpectrogram = new MelSpectrogram<T>(
-            _options.SampleRate, _options.NumMels, _options.FftSize,
-            _options.HopLength, _options.FMin, _options.FMax, logMel: true);
-        if (!_useNativeMode && _options.ModelPath is { } p2 && !string.IsNullOrEmpty(p2))
-            OnnxEncoder = new OnnxModel<T>(p2, _options.OnnxOptions);
-        if (_options.TextEncoderModelPath is { } tp2 && !string.IsNullOrEmpty(tp2))
-            _textEncoder = new OnnxModel<T>(tp2, _options.OnnxOptions);
-    }
 
     /// <inheritdoc />
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new CLAP<T>(Architecture, mp, _options);
-        return new CLAP<T>(Architecture, _options);
-    }
+
 
     #endregion
 
diff --git a/src/Audio/Classification/CRNNEventDetector.cs b/src/Audio/Classification/CRNNEventDetector.cs
index 4558b5057f..2f94b76fc8 100644
--- a/src/Audio/Classification/CRNNEventDetector.cs
+++ b/src/Audio/Classification/CRNNEventDetector.cs
@@ -62,7 +62,7 @@ namespace AiDotNet.Audio.Classification;
 // Title corrected to the published plural form ("Networks"). The arXiv id was already correct — this
 // entry surfaced in the citation audit only because the recorded title did not match arXiv's exactly.
 [ResearchPaper("Convolutional Recurrent Neural Networks for Polyphonic Sound Event Detection", "https://arxiv.org/abs/1702.06286", Year = 2017, Authors = "Emre Cakir, Giambattista Parascandolo, Toni Heittola, Heikki Huttunen, Tuomas Virtanen")]
-public class CRNNEventDetector<T> : AudioClassifierBase<T>, IAudioEventDetector<T>
+public partial class CRNNEventDetector<T> : AudioClassifierBase<T>, IAudioEventDetector<T>
 {
     #region Fields
 
@@ -321,46 +321,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty);
-        w.Write(_options.SampleRate); w.Write(_options.NumMels);
-        w.Write(_options.FftSize); w.Write(_options.HopLength);
-        w.Write(_options.CNNChannels.Length);
-        foreach (int ch in _options.CNNChannels) w.Write(ch);
-        w.Write(_options.RNNHiddenSize); w.Write(_options.NumRNNLayers);
-        w.Write(_options.Threshold); w.Write(_options.DetectionWindowSize);
-        w.Write(_options.WindowOverlap); w.Write(_options.DropoutRate);
-        w.Write((int)_options.FMin); w.Write((int)_options.FMax);
-        w.Write(ClassLabels.Count);
-        foreach (var label in ClassLabels) w.Write(label);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.SampleRate = r.ReadInt32(); _options.NumMels = r.ReadInt32();
-        _options.FftSize = r.ReadInt32(); _options.HopLength = r.ReadInt32();
-        int nch = r.ReadInt32(); _options.CNNChannels = new int[nch];
-        for (int i = 0; i < nch; i++) _options.CNNChannels[i] = r.ReadInt32();
-        _options.RNNHiddenSize = r.ReadInt32(); _options.NumRNNLayers = r.ReadInt32();
-        _options.Threshold = r.ReadDouble(); _options.DetectionWindowSize = r.ReadDouble();
-        _options.WindowOverlap = r.ReadDouble(); _options.DropoutRate = r.ReadDouble();
-        _options.FMin = r.ReadInt32(); _options.FMax = r.ReadInt32();
-        int numLabels = r.ReadInt32(); var labels = new string[numLabels];
-        for (int i = 0; i < numLabels; i++) labels[i] = r.ReadString();
-        ClassLabels = labels;
-        _melSpectrogram = new MelSpectrogram<T>(sampleRate: _options.SampleRate, nMels: _options.NumMels,
-            nFft: _options.FftSize, hopLength: _options.HopLength, fMin: _options.FMin, fMax: _options.FMax, logMel: true);
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new CRNNEventDetector<T>(Architecture, mp, _options);
-        return new CRNNEventDetector<T>(Architecture, _options);
-    }
+
 
     #endregion
 
diff --git a/src/Audio/Classification/EAT.cs b/src/Audio/Classification/EAT.cs
index 174856fd7c..820798daf2 100644
--- a/src/Audio/Classification/EAT.cs
+++ b/src/Audio/Classification/EAT.cs
@@ -57,7 +57,7 @@ namespace AiDotNet.Audio.Classification;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("EAT: Self-Supervised Pre-Training with Efficient Audio Transformer", "https://arxiv.org/abs/2401.03497", Year = 2024, Authors = "Wenxi Chen, Yuzhe Liang, Ziyang Ma, Zhisheng Zheng, Xie Chen")]
-public class EAT<T> : AudioClassifierBase<T>, IAudioEventDetector<T>
+public partial class EAT<T> : AudioClassifierBase<T>, IAudioEventDetector<T>
 {
     #region Fields
 
@@ -244,34 +244,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode); writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate); writer.Write(_options.NumMels); writer.Write(_options.FftSize); writer.Write(_options.HopLength);
-        writer.Write(_options.EmbeddingDim); writer.Write(_options.NumEncoderLayers); writer.Write(_options.NumAttentionHeads); writer.Write(_options.FeedForwardDim);
-        writer.Write(_options.PatchSize); writer.Write(_options.PatchStride); writer.Write(_options.Threshold); writer.Write(_options.WindowSize); writer.Write(_options.WindowOverlap); writer.Write(_options.DropoutRate);
-        writer.Write((int)_options.FMin); writer.Write((int)_options.FMax);
-        writer.Write(ClassLabels.Count); foreach (var label in ClassLabels) writer.Write(label);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean(); string mp = reader.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32(); _options.NumMels = reader.ReadInt32(); _options.FftSize = reader.ReadInt32(); _options.HopLength = reader.ReadInt32();
-        _options.EmbeddingDim = reader.ReadInt32(); _options.NumEncoderLayers = reader.ReadInt32(); _options.NumAttentionHeads = reader.ReadInt32(); _options.FeedForwardDim = reader.ReadInt32();
-        _options.PatchSize = reader.ReadInt32(); _options.PatchStride = reader.ReadInt32(); _options.Threshold = reader.ReadDouble(); _options.WindowSize = reader.ReadDouble(); _options.WindowOverlap = reader.ReadDouble(); _options.DropoutRate = reader.ReadDouble();
-        _options.FMin = reader.ReadInt32(); _options.FMax = reader.ReadInt32();
-        int n = reader.ReadInt32(); var labels = new string[n]; for (int i = 0; i < n; i++) labels[i] = reader.ReadString(); ClassLabels = labels;
-        _melSpectrogram = new MelSpectrogram<T>(_options.SampleRate, _options.NumMels, _options.FftSize, _options.HopLength, _options.FMin, _options.FMax, logMel: true);
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new EAT<T>(Architecture, mp, _options);
-        return new EAT<T>(Architecture, _options);
-    }
+
 
     #endregion
 
diff --git a/src/Audio/Classification/FDYSED.cs b/src/Audio/Classification/FDYSED.cs
index 251a10b2a9..432019257f 100644
--- a/src/Audio/Classification/FDYSED.cs
+++ b/src/Audio/Classification/FDYSED.cs
@@ -57,7 +57,7 @@ namespace AiDotNet.Audio.Classification;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Frequency Dynamic Convolution: Frequency-Adaptive Pattern Recognition for Sound Event Detection", "https://arxiv.org/abs/2203.15296", Year = 2022, Authors = "Hyeonuk Nam, Seong-Hu Kim, Byeong-Yun Ko, Yong-Hwa Park")]
-public class FDYSED<T> : AudioClassifierBase<T>, IAudioEventDetector<T>
+public partial class FDYSED<T> : AudioClassifierBase<T>, IAudioEventDetector<T>
 {
     #region Fields
 
@@ -309,46 +309,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty);
-        w.Write(_options.SampleRate); w.Write(_options.NumMels);
-        w.Write(_options.FftSize); w.Write(_options.HopLength);
-        w.Write(_options.EmbeddingDim); w.Write(_options.NumFrequencyGroups);
-        w.Write(_options.CNNChannels.Length);
-        foreach (int ch in _options.CNNChannels) w.Write(ch);
-        w.Write(_options.RNNHiddenSize); w.Write(_options.NumRNNLayers);
-        w.Write(_options.Threshold); w.Write(_options.DetectionWindowSize);
-        w.Write(_options.WindowOverlap); w.Write(_options.DropoutRate);
-        w.Write(ClassLabels.Count);
-        foreach (var label in ClassLabels) w.Write(label);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.SampleRate = r.ReadInt32(); _options.NumMels = r.ReadInt32();
-        _options.FftSize = r.ReadInt32(); _options.HopLength = r.ReadInt32();
-        _options.EmbeddingDim = r.ReadInt32(); _options.NumFrequencyGroups = r.ReadInt32();
-        int nch = r.ReadInt32(); _options.CNNChannels = new int[nch];
-        for (int i = 0; i < nch; i++) _options.CNNChannels[i] = r.ReadInt32();
-        _options.RNNHiddenSize = r.ReadInt32(); _options.NumRNNLayers = r.ReadInt32();
-        _options.Threshold = r.ReadDouble(); _options.DetectionWindowSize = r.ReadDouble();
-        _options.WindowOverlap = r.ReadDouble(); _options.DropoutRate = r.ReadDouble();
-        int numLabels = r.ReadInt32(); var labels = new string[numLabels];
-        for (int i = 0; i < numLabels; i++) labels[i] = r.ReadString();
-        ClassLabels = labels;
-        _melSpectrogram = new MelSpectrogram<T>(sampleRate: _options.SampleRate, nMels: _options.NumMels,
-            nFft: _options.FftSize, hopLength: _options.HopLength, fMin: _options.FMin, fMax: _options.FMax, logMel: true);
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new FDYSED<T>(Architecture, mp, _options);
-        return new FDYSED<T>(Architecture, _options);
-    }
+
 
     #endregion
 
diff --git a/src/Audio/Classification/GenreClassifier.cs b/src/Audio/Classification/GenreClassifier.cs
index 2b4846b569..8337e55ca9 100644
--- a/src/Audio/Classification/GenreClassifier.cs
+++ b/src/Audio/Classification/GenreClassifier.cs
@@ -51,7 +51,7 @@ namespace AiDotNet.Audio.Classification;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Musical Genre Classification of Audio Signals", "https://doi.org/10.1109/TSA.2002.800560", Year = 2002, Authors = "George Tzanetakis, Perry Cook")]
-public class GenreClassifier<T> : AudioClassifierBase<T>, IGenreClassifier<T>
+public partial class GenreClassifier<T> : AudioClassifierBase<T>, IGenreClassifier<T>
 {
     #region Fields
 
@@ -610,57 +610,6 @@ public override ModelMetadata<T> GetModelMetadata()
         return metadata;
     }
 
-    /// <summary>
-    /// Serializes network-specific data.
-    /// </summary>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(SampleRate);
-        writer.Write(ClassLabels.Count);
-        foreach (var label in ClassLabels)
-        {
-            writer.Write(label);
-        }
-        writer.Write(_options.NumMfccs);
-        writer.Write(_options.FftSize);
-        writer.Write(_options.HopLength);
-    }
-
-    /// <summary>
-    /// Deserializes network-specific data.
-    /// </summary>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        base.SampleRate = reader.ReadInt32();
-        int numLabels = reader.ReadInt32();
-        var labels = new string[numLabels];
-        for (int i = 0; i < numLabels; i++)
-        {
-            labels[i] = reader.ReadString();
-        }
-        ClassLabels = labels;
-        _options.NumMfccs = reader.ReadInt32();
-        _options.FftSize = reader.ReadInt32();
-        _options.HopLength = reader.ReadInt32();
-    }
-
-    /// <summary>
-    /// Creates a new instance of this model for cloning.
-    /// </summary>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode)
-        {
-            throw new NotSupportedException(
-                "CreateNewInstance is not supported for ONNX models. " +
-                "Create a new GenreClassifier with the model path instead.");
-        }
-
-        return new GenreClassifier<T>(
-            Architecture,
-            _options);
-    }
-
     #endregion
 
     #region Private Methods - Feature Extraction
diff --git a/src/Audio/Classification/HTSAT.cs b/src/Audio/Classification/HTSAT.cs
index e3dc2a417e..fe5c3c5229 100644
--- a/src/Audio/Classification/HTSAT.cs
+++ b/src/Audio/Classification/HTSAT.cs
@@ -62,7 +62,7 @@ namespace AiDotNet.Audio.Classification;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("HTS-AT: A Hierarchical Token-Semantic Audio Transformer for Sound Classification and Detection", "https://arxiv.org/abs/2202.00874", Year = 2022, Authors = "Ke Chen, Xingjian Du, Bilei Zhu, Zejun Ma, Taylor Berg-Kirkpatrick, Shlomo Dubnov")]
-public class HTSAT<T> : AudioClassifierBase<T>, IAudioEventDetector<T>
+public partial class HTSAT<T> : AudioClassifierBase<T>, IAudioEventDetector<T>
 {
     #region Fields
 
@@ -384,55 +384,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate); writer.Write(_options.NumMels);
-        writer.Write(_options.FftSize); writer.Write(_options.HopLength);
-        writer.Write(_options.EmbeddingDim); writer.Write(_options.WindowSize);
-        writer.Write(_options.PatchSize); writer.Write(_options.Threshold);
-        writer.Write(_options.DetectionWindowSize); writer.Write(_options.WindowOverlap);
-        writer.Write(_options.DropoutRate);
-        writer.Write((int)_options.FMin); writer.Write((int)_options.FMax);
-        writer.Write(ClassLabels.Count);
-        foreach (var label in ClassLabels) writer.Write(label);
-    }
-
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string modelPath = reader.ReadString();
-        if (!string.IsNullOrEmpty(modelPath)) _options.ModelPath = modelPath;
-        _options.SampleRate = reader.ReadInt32(); _options.NumMels = reader.ReadInt32();
-        _options.FftSize = reader.ReadInt32(); _options.HopLength = reader.ReadInt32();
-        _options.EmbeddingDim = reader.ReadInt32(); _options.WindowSize = reader.ReadInt32();
-        _options.PatchSize = reader.ReadInt32(); _options.Threshold = reader.ReadDouble();
-        _options.DetectionWindowSize = reader.ReadDouble(); _options.WindowOverlap = reader.ReadDouble();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.FMin = reader.ReadInt32(); _options.FMax = reader.ReadInt32();
-        int numLabels = reader.ReadInt32();
-        var labels = new string[numLabels];
-        for (int i = 0; i < numLabels; i++) labels[i] = reader.ReadString();
-        ClassLabels = labels;
 
-        _melSpectrogram = new MelSpectrogram<T>(
-            sampleRate: _options.SampleRate, nMels: _options.NumMels,
-            nFft: _options.FftSize, hopLength: _options.HopLength,
-            fMin: _options.FMin, fMax: _options.FMax, logMel: true);
-
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
     /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new HTSAT<T>(Architecture, mp, _options);
-        return new HTSAT<T>(Architecture, _options);
-    }
+
 
     #endregion
 
diff --git a/src/Audio/Classification/PANNs.cs b/src/Audio/Classification/PANNs.cs
index 78c93ad64f..881fed604b 100644
--- a/src/Audio/Classification/PANNs.cs
+++ b/src/Audio/Classification/PANNs.cs
@@ -60,7 +60,7 @@ namespace AiDotNet.Audio.Classification;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("PANNs: Large-Scale Pretrained Audio Neural Networks for Audio Pattern Recognition", "https://arxiv.org/abs/1912.10211", Year = 2020, Authors = "Qiuqiang Kong, Yin Cao, Turab Iqbal, Yuxuan Wang, Wenwu Wang, Mark D. Plumbley")]
-public class PANNs<T> : AudioClassifierBase<T>, IAudioEventDetector<T>
+public partial class PANNs<T> : AudioClassifierBase<T>, IAudioEventDetector<T>
 {
     #region Fields
 
@@ -232,28 +232,6 @@ public override ModelMetadata<T> GetModelMetadata()
         m.AdditionalInfo["NumBlocks"] = _options.NumBlocks.ToString(); m.AdditionalInfo["NumClasses"] = ClassLabels.Count.ToString();
         return m;
     }
-
-    protected override void SerializeNetworkSpecificData(BinaryWriter w) { w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty); w.Write(_options.SampleRate); w.Write(_options.NumMels); w.Write(_options.FftSize); w.Write(_options.HopLength); w.Write(_options.EmbeddingDim); w.Write(_options.NumBlocks); w.Write(_options.BaseChannels); w.Write(_options.Threshold); w.Write(_options.WindowSize); w.Write(_options.WindowOverlap); w.Write(_options.DropoutRate); w.Write((int)_options.FMin); w.Write((int)_options.FMax); w.Write(ClassLabels.Count); foreach (var l in ClassLabels) w.Write(l); }
-
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.SampleRate = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.FftSize = r.ReadInt32(); _options.HopLength = r.ReadInt32();
-        _options.EmbeddingDim = r.ReadInt32(); _options.NumBlocks = r.ReadInt32(); _options.BaseChannels = r.ReadInt32();
-        _options.Threshold = r.ReadDouble(); _options.WindowSize = r.ReadDouble(); _options.WindowOverlap = r.ReadDouble(); _options.DropoutRate = r.ReadDouble();
-        _options.FMin = r.ReadInt32(); _options.FMax = r.ReadInt32();
-        int n = r.ReadInt32(); var labels = new string[n]; for (int i = 0; i < n; i++) labels[i] = r.ReadString(); ClassLabels = labels;
-        _melSpectrogram = new MelSpectrogram<T>(_options.SampleRate, _options.NumMels, _options.FftSize, _options.HopLength, _options.FMin, _options.FMax, logMel: true);
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
-
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new PANNs<T>(Architecture, mp, new PANNsOptions(_options));
-        return new PANNs<T>(Architecture, new PANNsOptions(_options), lossFunction: LossFunction);
-    }
-
     #endregion
 
     #region Helpers
diff --git a/src/Audio/Classification/SceneClassifier.cs b/src/Audio/Classification/SceneClassifier.cs
index 8414afafa6..8d0a1822ee 100644
--- a/src/Audio/Classification/SceneClassifier.cs
+++ b/src/Audio/Classification/SceneClassifier.cs
@@ -52,7 +52,7 @@ namespace AiDotNet.Audio.Classification;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("A Large-Scale Evaluation of Acoustic and Subjective Music-Similarity Measures", "https://doi.org/10.1016/j.csl.2017.01.007", Year = 2017, Authors = "Annamaria Mesaros, Toni Heittola, Tuomas Virtanen")]
-public class SceneClassifier<T> : AudioClassifierBase<T>, ISceneClassifier<T>
+public partial class SceneClassifier<T> : AudioClassifierBase<T>, ISceneClassifier<T>
 {
     #region Fields
 
@@ -681,54 +681,12 @@ public override ModelMetadata<T> GetModelMetadata()
     /// <summary>
     /// Serializes network-specific data.
     /// </summary>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        // Write options
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.NumMels);
-        writer.Write(_options.FftSize);
-        writer.Write(_options.HopLength);
-        writer.Write(_options.NumMfccs);
-        writer.Write(_useNativeMode);
-
-        // Write class labels
-        writer.Write(ClassLabels.Count);
-        foreach (var label in ClassLabels)
-        {
-            writer.Write(label);
-        }
-    }
+
 
     /// <summary>
     /// Deserializes network-specific data.
     /// </summary>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        // Restore options properties
-        _options.SampleRate = reader.ReadInt32();
-        _options.NumMels = reader.ReadInt32();
-        _options.FftSize = reader.ReadInt32();
-        _options.HopLength = reader.ReadInt32();
-        _options.NumMfccs = reader.ReadInt32();
-        _useNativeMode = reader.ReadBoolean();
-
-        // Read class labels
-        int numLabels = reader.ReadInt32();
-        var labels = new string[numLabels];
-        for (int i = 0; i < numLabels; i++)
-        {
-            labels[i] = reader.ReadString();
-        }
-        ClassLabels = labels;
-    }
 
-    /// <summary>
-    /// Creates a new instance of this network type.
-    /// </summary>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new SceneClassifier<T>(Architecture, _options);
-    }
 
     #endregion
 
diff --git a/src/Audio/Effects/AudioSuperResolution.cs b/src/Audio/Effects/AudioSuperResolution.cs
index ab5d363e72..367b36a6fc 100644
--- a/src/Audio/Effects/AudioSuperResolution.cs
+++ b/src/Audio/Effects/AudioSuperResolution.cs
@@ -338,35 +338,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty);
-        w.Write(_options.InputSampleRate); w.Write(_options.OutputSampleRate);
-        w.Write(_options.UpsampleFactor); w.Write(_options.Variant);
-        w.Write(_options.HiddenDim); w.Write(_options.NumResBlocks);
-        w.Write(_options.NumHeads); w.Write(_options.NumAttentionLayers);
-        w.Write(_options.DropoutRate);
-        w.Write(_options.LearningRate);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.InputSampleRate = r.ReadInt32(); _options.OutputSampleRate = r.ReadInt32();
-        _options.UpsampleFactor = r.ReadInt32(); _options.Variant = r.ReadString();
-        _options.HiddenDim = r.ReadInt32(); _options.NumResBlocks = r.ReadInt32(); _numBlocks = _options.NumResBlocks;
-        _options.NumHeads = r.ReadInt32(); _options.NumAttentionLayers = r.ReadInt32();
-        _options.DropoutRate = r.ReadDouble();
-        _options.LearningRate = r.ReadDouble();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new AudioSuperResolution<T>(Architecture, mp, _options);
-        return new AudioSuperResolution<T>(Architecture, _options);
-    }
+
 
     #endregion
 
diff --git a/src/Audio/Effects/DAC.cs b/src/Audio/Effects/DAC.cs
index 3475782b23..c41aa94dab 100644
--- a/src/Audio/Effects/DAC.cs
+++ b/src/Audio/Effects/DAC.cs
@@ -52,7 +52,7 @@ namespace AiDotNet.Audio.Effects;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("High-Fidelity Audio Compression with Improved RVQGAN", "https://doi.org/10.48550/arXiv.2306.06546", Year = 2024, Authors = "Rithesh Kumar, Prem Seetharaman, Alejandro Luebs, Ishaan Kumar, Kundan Kumar")]
-public class DAC<T> : AudioNeuralNetworkBase<T>, IAudioCodec<T>
+public partial class DAC<T> : AudioNeuralNetworkBase<T>, IAudioCodec<T>
 {
     /// <inheritdoc />
     /// <remarks>
@@ -287,39 +287,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty);
-        w.Write(_options.SampleRate); w.Write(_options.NumChannels);
-        w.Write(_options.Variant);
-        w.Write(_options.EncoderDim);
-        w.Write(_options.EncoderChannels.Length);
-        foreach (int ch in _options.EncoderChannels) w.Write(ch);
-        w.Write(_options.NumCodebooks); w.Write(_options.CodebookSize);
-        w.Write(_options.CodebookDim); w.Write(_options.TokenFrameRate);
-        w.Write(_options.TargetBitrate); w.Write(_options.DropoutRate);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.SampleRate = r.ReadInt32(); _options.NumChannels = r.ReadInt32();
-        _options.Variant = r.ReadString();
-        _options.EncoderDim = r.ReadInt32();
-        int nch = r.ReadInt32(); _options.EncoderChannels = new int[nch];
-        for (int i = 0; i < nch; i++) _options.EncoderChannels[i] = r.ReadInt32();
-        _options.NumCodebooks = r.ReadInt32(); _options.CodebookSize = r.ReadInt32();
-        _options.CodebookDim = r.ReadInt32(); _options.TokenFrameRate = r.ReadInt32();
-        _options.TargetBitrate = r.ReadDouble(); _options.DropoutRate = r.ReadDouble();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new DAC<T>(Architecture, mp, _options);
-        return new DAC<T>(Architecture, _options);
-    }
+
 
     #endregion
 
diff --git a/src/Audio/Effects/DemucsNoise.cs b/src/Audio/Effects/DemucsNoise.cs
index f030b2c5ed..7e3bfa6580 100644
--- a/src/Audio/Effects/DemucsNoise.cs
+++ b/src/Audio/Effects/DemucsNoise.cs
@@ -46,7 +46,7 @@ namespace AiDotNet.Audio.Effects;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Real Time Speech Enhancement in the Waveform Domain", "https://doi.org/10.48550/arXiv.2006.12847", Year = 2020, Authors = "Alexandre Défossez, Gabriel Synnaeve, Yossi Adi")]
-public class DemucsNoise<T> : AudioNeuralNetworkBase<T>, IAudioEnhancer<T>
+public partial class DemucsNoise<T> : AudioNeuralNetworkBase<T>, IAudioEnhancer<T>
 {
     /// <inheritdoc />
     /// <remarks>
@@ -205,35 +205,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty);
-        w.Write(_options.SampleRate); w.Write(_options.Variant);
-        w.Write(_options.HiddenChannels); w.Write(_options.Depth);
-        w.Write(_options.LSTMHiddenSize); w.Write(_options.NumLSTMLayers);
-        w.Write(_options.ChannelGrowth); w.Write(_options.DropoutRate);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.SampleRate = r.ReadInt32(); _options.Variant = r.ReadString();
-        _options.HiddenChannels = r.ReadInt32(); _options.Depth = r.ReadInt32();
-        _options.LSTMHiddenSize = r.ReadInt32(); _options.NumLSTMLayers = r.ReadInt32();
-        _options.ChannelGrowth = r.ReadInt32(); _options.DropoutRate = r.ReadDouble();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-        {
-            OnnxEncoder?.Dispose();
-            OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions);
-        }
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new DemucsNoise<T>(Architecture, mp, _options);
-        return new DemucsNoise<T>(Architecture, _options);
-    }
+
 
     #endregion
 
diff --git a/src/Audio/Effects/NeuralParametricEQ.cs b/src/Audio/Effects/NeuralParametricEQ.cs
index e4fc0037fc..c3c8b4c753 100644
--- a/src/Audio/Effects/NeuralParametricEQ.cs
+++ b/src/Audio/Effects/NeuralParametricEQ.cs
@@ -41,7 +41,7 @@ namespace AiDotNet.Audio.Effects;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Style Transfer of Audio Effects with Differentiable Signal Processing", "https://arxiv.org/abs/2207.08759", Year = 2022, Authors = "Christian J. Steinmetz, Nicholas J. Bryan, Joshua D. Reiss")]
-public class NeuralParametricEQ<T> : AudioNeuralNetworkBase<T>, IAudioEnhancer<T>
+public partial class NeuralParametricEQ<T> : AudioNeuralNetworkBase<T>, IAudioEnhancer<T>
 {
     /// <inheritdoc />
     /// <remarks>
@@ -203,31 +203,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty);
-        w.Write(_options.SampleRate); w.Write(_options.Variant);
-        w.Write(_options.EncoderDim); w.Write(_options.NumEncoderLayers);
-        w.Write(_options.NumBands); w.Write(_options.FFTSize);
-        w.Write(_options.GainRange); w.Write(_options.DropoutRate);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.SampleRate = r.ReadInt32(); _options.Variant = r.ReadString();
-        _options.EncoderDim = r.ReadInt32(); _options.NumEncoderLayers = r.ReadInt32();
-        _options.NumBands = r.ReadInt32(); _options.FFTSize = r.ReadInt32();
-        _options.GainRange = r.ReadDouble(); _options.DropoutRate = r.ReadDouble();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new NeuralParametricEQ<T>(Architecture, mp, _options);
-        return new NeuralParametricEQ<T>(Architecture, _options);
-    }
+
 
     #endregion
 
diff --git a/src/Audio/Effects/RoomImpulseResponse.cs b/src/Audio/Effects/RoomImpulseResponse.cs
index 37a7451bd0..8e3be7f512 100644
--- a/src/Audio/Effects/RoomImpulseResponse.cs
+++ b/src/Audio/Effects/RoomImpulseResponse.cs
@@ -101,7 +101,7 @@ public partial class RoomImpulseResponse<T> : AudioNeuralNetworkBase<T>, IAudioE
     /// would fail for a reason that has nothing to do with the learned weights. Serialized with the
     /// model so a reload reproduces the same response.
     /// </remarks>
-    [Buffer]
+    [Buffer(Availability = AiDotNet.Models.Parameters.ParameterAvailability.Conditional)]
     private Tensor<T>? _noiseSignal;
 
     #endregion
@@ -735,40 +735,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty);
-        w.Write(_options.SampleRate); w.Write(_options.EncoderMaxChannels);
-        w.Write(_options.NumEncoderBlocks); w.Write(_options.RIRLength);
-        w.Write(_options.LatentDim); w.Write(_options.NumNoiseBands);
-        w.Write(_options.EarlyResponseLength); w.Write(_options.NumDecoderBlocks);
-        w.Write(_options.DereverberationStrength); w.Write(_options.RT60WindowSeconds);
-        w.Write(_options.NoiseFilterOrder);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.SampleRate = r.ReadInt32(); _options.EncoderMaxChannels = r.ReadInt32();
-        _options.NumEncoderBlocks = r.ReadInt32(); _options.RIRLength = r.ReadInt32();
-        _options.LatentDim = r.ReadInt32(); _options.NumNoiseBands = r.ReadInt32();
-        _options.EarlyResponseLength = r.ReadInt32(); _options.NumDecoderBlocks = r.ReadInt32();
-        _options.DereverberationStrength = r.ReadDouble(); _options.RT60WindowSeconds = r.ReadDouble();
-        _options.NoiseFilterOrder = r.ReadInt32();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions);
-
-        // The base deserializer has just replaced Layers with the restored instances. Rebind the
-        // per-stage views so FiNSForward consumes those weights and not the constructor's layers.
-        BindLayerViewsFromLayers();
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new RoomImpulseResponse<T>(Architecture, mp, _options);
-        return new RoomImpulseResponse<T>(Architecture, _options);
-    }
+
 
     #endregion
 
diff --git a/src/Audio/Emotion/Emotion2Vec.cs b/src/Audio/Emotion/Emotion2Vec.cs
index 7fc386cdef..0671edb60d 100644
--- a/src/Audio/Emotion/Emotion2Vec.cs
+++ b/src/Audio/Emotion/Emotion2Vec.cs
@@ -46,7 +46,7 @@ namespace AiDotNet.Audio.Emotion;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("emotion2vec: Self-Supervised Pre-Training for Speech Emotion Representation", "https://arxiv.org/abs/2312.15185", Year = 2023, Authors = "Ziyang Ma, Zhisheng Zheng, Jiaxin Ye, Jinchao Li, Zhifu Gao, Shiliang Zhang, Xie Chen")]
-public class Emotion2Vec<T> : AudioClassifierBase<T>, IEmotionRecognizer<T>
+public partial class Emotion2Vec<T> : AudioClassifierBase<T>, IEmotionRecognizer<T>
 {
     #region Fields
 
@@ -301,31 +301,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty);
-        w.Write(_options.SampleRate); w.Write(_options.NumMels); w.Write(_options.TransformerDim);
-        w.Write(_options.NumTransformerLayers); w.Write(_options.NumAttentionHeads);
-        w.Write(_options.FeedForwardDim); w.Write(_options.NumClasses); w.Write(_options.DropoutRate);
-        w.Write(_options.EmotionLabels.Length); foreach (var l in _options.EmotionLabels) w.Write(l);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.SampleRate = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.TransformerDim = r.ReadInt32();
-        _options.NumTransformerLayers = r.ReadInt32(); _options.NumAttentionHeads = r.ReadInt32();
-        _options.FeedForwardDim = r.ReadInt32(); _options.NumClasses = r.ReadInt32(); _options.DropoutRate = r.ReadDouble();
-        int n = r.ReadInt32(); _options.EmotionLabels = new string[n]; for (int i = 0; i < n; i++) _options.EmotionLabels[i] = r.ReadString();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new Emotion2Vec<T>(Architecture, mp, _options);
-        return new Emotion2Vec<T>(Architecture, _options);
-    }
+
 
     #endregion
 
diff --git a/src/Audio/Emotion/HuBERTSER.cs b/src/Audio/Emotion/HuBERTSER.cs
index 077bd50eff..570e046d16 100644
--- a/src/Audio/Emotion/HuBERTSER.cs
+++ b/src/Audio/Emotion/HuBERTSER.cs
@@ -45,7 +45,7 @@ namespace AiDotNet.Audio.Emotion;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("HuBERT: Self-Supervised Speech Representation Learning by Masked Prediction of Hidden Units", "https://arxiv.org/abs/2106.07447", Year = 2021, Authors = "Wei-Ning Hsu, Benjamin Bolte, Yao-Hung Hubert Tsai, Kushal Lakhotia, Ruslan Salakhutdinov, Abdelrahman Mohamed")]
-public class HuBERTSER<T> : AudioClassifierBase<T>, IEmotionRecognizer<T>
+public partial class HuBERTSER<T> : AudioClassifierBase<T>, IEmotionRecognizer<T>
 {
     #region Fields
 
@@ -326,33 +326,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty);
-        w.Write(_options.SampleRate); w.Write(_options.NumMels); w.Write(_options.TransformerDim);
-        w.Write(_options.NumTransformerLayers); w.Write(_options.NumAttentionHeads);
-        w.Write(_options.FeedForwardDim); w.Write(_options.ClassifierHiddenDim); w.Write(_options.NumClasses); w.Write(_options.DropoutRate);
-        w.Write(_options.Variant);
-        w.Write(_options.EmotionLabels.Length); foreach (var l in _options.EmotionLabels) w.Write(l);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.SampleRate = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.TransformerDim = r.ReadInt32();
-        _options.NumTransformerLayers = r.ReadInt32(); _options.NumAttentionHeads = r.ReadInt32();
-        _options.FeedForwardDim = r.ReadInt32(); _options.ClassifierHiddenDim = r.ReadInt32(); _options.NumClasses = r.ReadInt32(); _options.DropoutRate = r.ReadDouble();
-        _options.Variant = r.ReadString();
-        int n = r.ReadInt32(); _options.EmotionLabels = new string[n]; for (int i = 0; i < n; i++) _options.EmotionLabels[i] = r.ReadString();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new HuBERTSER<T>(Architecture, mp, _options);
-        return new HuBERTSER<T>(Architecture, _options);
-    }
+
 
     #endregion
 
diff --git a/src/Audio/Emotion/SpeechEmotionRecognizer.cs b/src/Audio/Emotion/SpeechEmotionRecognizer.cs
index b9e3ea429f..960f6e4237 100644
--- a/src/Audio/Emotion/SpeechEmotionRecognizer.cs
+++ b/src/Audio/Emotion/SpeechEmotionRecognizer.cs
@@ -870,37 +870,6 @@ protected override Tensor<T> PredictCore(Tensor<T> input)
         return result;
     }
 
-    /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (_isOnnxMode && _modelPath is not null)
-        {
-            return new SpeechEmotionRecognizer<T>(
-                Architecture,
-                _modelPath,
-                SampleRate,
-                NumMels,
-                _nFft,
-                _hopLength,
-                _emotionLabels,
-                _includeArousalValence);
-        }
-
-        return new SpeechEmotionRecognizer<T>(
-            Architecture,
-            SampleRate,
-            NumMels,
-            _nFft,
-            _hopLength,
-            _inputDurationSeconds,
-            _numConvBlocks,
-            _baseFilters,
-            _hiddenDim,
-            _dropoutRate,
-            _emotionLabels,
-            _includeArousalValence);
-    }
-
     /// <inheritdoc/>
     public override ModelMetadata<T> GetModelMetadata()
     {
@@ -924,65 +893,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_isOnnxMode);
-        writer.Write(SampleRate);
-        writer.Write(NumMels);
-        writer.Write(_nFft);
-        writer.Write(_hopLength);
-        writer.Write(_inputDurationSeconds);
-        writer.Write(_numConvBlocks);
-        writer.Write(_baseFilters);
-        writer.Write(_hiddenDim);
-        writer.Write(_dropoutRate);
-        writer.Write(_includeArousalValence);
-        writer.Write(_emotionLabels.Length);
-        foreach (var label in _emotionLabels)
-        {
-            writer.Write(label);
-        }
-    }
 
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        // Note: _isOnnxMode is readonly and set at construction, but we read to advance stream position
-        // The deserialized model will always be in native mode since ONNX models need model files
-        _ = reader.ReadBoolean(); // _isOnnxMode (read but not assigned - mode is set at construction)
-
-        // Restore audio configuration
-        SampleRate = reader.ReadInt32();
-        NumMels = reader.ReadInt32();
-        _nFft = reader.ReadInt32();
-        _hopLength = reader.ReadInt32();
-        _inputDurationSeconds = reader.ReadDouble();
-
-        // Restore architecture configuration
-        _numConvBlocks = reader.ReadInt32();
-        _baseFilters = reader.ReadInt32();
-        _hiddenDim = reader.ReadInt32();
-        _dropoutRate = reader.ReadDouble();
-        _includeArousalValence = reader.ReadBoolean();
-
-        // Restore emotion labels
-        int labelCount = reader.ReadInt32();
-        _emotionLabels = new string[labelCount];
-        for (int i = 0; i < labelCount; i++)
-        {
-            _emotionLabels[i] = reader.ReadString();
-        }
-        ClassLabels = _emotionLabels;
 
-        // Reinitialize mel spectrogram extractor with restored parameters
-        _melSpec = CreateMelSpectrogram(SampleRate, NumMels, _nFft, _hopLength);
+    /// <inheritdoc/>
 
-        // Reinitialize layers if needed (native mode)
-        if (_convLayers.Count == 0)
-        {
-            InitializeLayers();
-        }
-    }
 
     #endregion
 }
diff --git a/src/Audio/Emotion/Wav2Small.cs b/src/Audio/Emotion/Wav2Small.cs
index e27afbfba3..b351dcd4b0 100644
--- a/src/Audio/Emotion/Wav2Small.cs
+++ b/src/Audio/Emotion/Wav2Small.cs
@@ -42,7 +42,7 @@ namespace AiDotNet.Audio.Emotion;
 [ModelComplexity(ModelComplexity.Low)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Wav2Small: Distilling Wav2Vec2.0 to 72K Parameters for Low-Resource Speech Emotion Recognition", "https://arxiv.org/abs/2408.13920", Year = 2024, Authors = "Alejandro Gomez-Alanis, Jose A. Gonzalez-Lopez, S. Pavankumar Dubagunta")]
-public class Wav2Small<T> : AudioClassifierBase<T>, IEmotionRecognizer<T>
+public partial class Wav2Small<T> : AudioClassifierBase<T>, IEmotionRecognizer<T>
 {
     #region Fields
 
@@ -271,33 +271,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty);
-        w.Write(_options.SampleRate); w.Write(_options.NumMels); w.Write(_options.HiddenDim);
-        w.Write(_options.NumLayers); w.Write(_options.NumAttentionHeads);
-        w.Write(_options.FeedForwardDim); w.Write(_options.FeatureEncoderDim);
-        w.Write(_options.NumClasses); w.Write(_options.DropoutRate);
-        w.Write(_options.EmotionLabels.Length); foreach (var l in _options.EmotionLabels) w.Write(l);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.SampleRate = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.HiddenDim = r.ReadInt32();
-        _options.NumLayers = r.ReadInt32(); _options.NumAttentionHeads = r.ReadInt32();
-        _options.FeedForwardDim = r.ReadInt32(); _options.FeatureEncoderDim = r.ReadInt32();
-        _options.NumClasses = r.ReadInt32(); _options.DropoutRate = r.ReadDouble();
-        int n = r.ReadInt32(); _options.EmotionLabels = new string[n]; for (int i = 0; i < n; i++) _options.EmotionLabels[i] = r.ReadString();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new Wav2Small<T>(Architecture, mp, _options);
-        return new Wav2Small<T>(Architecture, _options);
-    }
+
 
     #endregion
 
diff --git a/src/Audio/Emotion/WavLMSER.cs b/src/Audio/Emotion/WavLMSER.cs
index 464b32fa5c..cccccc8f04 100644
--- a/src/Audio/Emotion/WavLMSER.cs
+++ b/src/Audio/Emotion/WavLMSER.cs
@@ -45,7 +45,7 @@ namespace AiDotNet.Audio.Emotion;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("WavLM: Large-Scale Self-Supervised Pre-Training for Full Stack Speech Processing", "https://arxiv.org/abs/2110.13900", Year = 2022, Authors = "Sanyuan Chen, Chengyi Wang, Zhengyang Chen, Yu Wu, Shujie Liu, Zhuo Chen, Jinyu Li, Naoyuki Kanda, Takuya Yoshioka, Xiong Xiao, Jian Wu, Long Zhou, Shuo Ren, Yanmin Qian, Yao Qian, Jian Wu, Michael Zeng, Xiangzhan Yu, Furu Wei")]
-internal class WavLMSER<T> : AudioClassifierBase<T>, IEmotionRecognizer<T>
+internal partial class WavLMSER<T> : AudioClassifierBase<T>, IEmotionRecognizer<T>
 {
     #region Fields
 
@@ -352,34 +352,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty);
-        w.Write(_options.SampleRate); w.Write(_options.Variant); w.Write(_options.NumMels);
-        w.Write(_options.HiddenDim); w.Write(_options.NumLayers); w.Write(_options.NumAttentionHeads);
-        w.Write(_options.FeedForwardDim); w.Write(_options.FeatureEncoderDim);
-        w.Write(_options.NumClasses); w.Write(_options.DropoutRate);
-        w.Write(_options.EmotionLabels.Length); foreach (var l in _options.EmotionLabels) w.Write(l);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.SampleRate = r.ReadInt32(); _options.Variant = r.ReadString(); _options.NumMels = r.ReadInt32();
-        _options.HiddenDim = r.ReadInt32(); _options.NumLayers = r.ReadInt32(); _options.NumAttentionHeads = r.ReadInt32();
-        _options.FeedForwardDim = r.ReadInt32(); _options.FeatureEncoderDim = r.ReadInt32();
-        _options.NumClasses = r.ReadInt32(); _options.DropoutRate = r.ReadDouble();
-        int n = r.ReadInt32(); _options.EmotionLabels = new string[n]; for (int i = 0; i < n; i++) _options.EmotionLabels[i] = r.ReadString();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var copiedOptions = new WavLMSEROptions(_options);
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new WavLMSER<T>(Architecture, mp, copiedOptions);
-        return new WavLMSER<T>(Architecture, copiedOptions);
-    }
+
 
     #endregion
 
diff --git a/src/Audio/Enhancement/BandSplitRNNEnhancer.cs b/src/Audio/Enhancement/BandSplitRNNEnhancer.cs
index c71966bb3d..7be31eb492 100644
--- a/src/Audio/Enhancement/BandSplitRNNEnhancer.cs
+++ b/src/Audio/Enhancement/BandSplitRNNEnhancer.cs
@@ -44,7 +44,7 @@ namespace AiDotNet.Audio.Enhancement;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Music Source Separation with Band-Split RNN", "https://arxiv.org/abs/2209.15174", Year = 2023, Authors = "Yi Luo, Jianwei Yu")]
-public class BandSplitRNNEnhancer<T> : AudioNeuralNetworkBase<T>, IAudioEnhancer<T>
+public partial class BandSplitRNNEnhancer<T> : AudioNeuralNetworkBase<T>, IAudioEnhancer<T>
 {
     /// <inheritdoc />
     /// <remarks>
@@ -62,7 +62,7 @@ public class BandSplitRNNEnhancer<T> : AudioNeuralNetworkBase<T>, IAudioEnhancer
     private readonly ShortTimeFourierTransform<T> _stft;
     [Scratch]
     private Tensor<T>? _lastPhase;
-    [Buffer]
+    [Buffer(Availability = AiDotNet.Models.Parameters.ParameterAvailability.Conditional)]
     private Tensor<T>? _noiseProfile;
     private bool _useNativeMode;
     private bool _disposed;
@@ -274,34 +274,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty);
-        w.Write(_options.SampleRate); w.Write(_options.Variant);
-        w.Write(_options.NumBands); w.Write(_options.BandRnnHiddenSize);
-        w.Write(_options.NumRnnLayers); w.Write(_options.FusionDim);
-        w.Write(_options.NumFreqBins); w.Write(_options.FFTSize);
-        w.Write(_options.HopLength); w.Write(_options.DropoutRate);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.SampleRate = r.ReadInt32(); _options.Variant = r.ReadString();
-        _options.NumBands = r.ReadInt32(); _options.BandRnnHiddenSize = r.ReadInt32();
-        _options.NumRnnLayers = r.ReadInt32(); _options.FusionDim = r.ReadInt32();
-        _options.NumFreqBins = r.ReadInt32(); _options.FFTSize = r.ReadInt32();
-        _options.HopLength = r.ReadInt32(); _options.DropoutRate = r.ReadDouble();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var cloneOptions = new BandSplitRNNEnhancerOptions(_options);
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new BandSplitRNNEnhancer<T>(Architecture, mp, cloneOptions);
-        return new BandSplitRNNEnhancer<T>(Architecture, cloneOptions);
-    }
+
 
     #endregion
 
diff --git a/src/Audio/Enhancement/CMGAN.cs b/src/Audio/Enhancement/CMGAN.cs
index bef1273f3b..33d46e8a0e 100644
--- a/src/Audio/Enhancement/CMGAN.cs
+++ b/src/Audio/Enhancement/CMGAN.cs
@@ -58,7 +58,7 @@ namespace AiDotNet.Audio.Enhancement;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("CMGAN: Conformer-based Metric GAN for Speech Enhancement", "https://arxiv.org/abs/2203.15149", Year = 2022, Authors = "Ruizhe Cao, Sherif Abdulatif, Bin Yang")]
-public class CMGAN<T> : AudioNeuralNetworkBase<T>, IAudioEnhancer<T>
+public partial class CMGAN<T> : AudioNeuralNetworkBase<T>, IAudioEnhancer<T>
 {
     /// <inheritdoc />
     /// <remarks>
@@ -79,7 +79,7 @@ public class CMGAN<T> : AudioNeuralNetworkBase<T>, IAudioEnhancer<T>
     private ShortTimeFourierTransform<T> _stft;
     [Scratch]
     private Tensor<T>? _lastPhase;
-    [Buffer]
+    [Buffer(Availability = AiDotNet.Models.Parameters.ParameterAvailability.Conditional)]
     private Tensor<T>? _noiseProfile;
     private bool _useNativeMode;
     private bool _disposed;
@@ -303,36 +303,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty);
-        w.Write(_options.SampleRate); w.Write(_options.FftSize); w.Write(_options.HopLength);
-        w.Write(_options.NumFreqBins); w.Write(_options.ConformerDim); w.Write(_options.NumConformerLayers);
-        w.Write(_options.NumAttentionHeads); w.Write(_options.EnhancementStrength); w.Write(_options.DropoutRate);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean();
-        string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.SampleRate = r.ReadInt32(); _options.FftSize = r.ReadInt32(); _options.HopLength = r.ReadInt32();
-        _options.NumFreqBins = r.ReadInt32(); _options.ConformerDim = r.ReadInt32(); _options.NumConformerLayers = r.ReadInt32();
-        _options.NumAttentionHeads = r.ReadInt32(); _options.EnhancementStrength = r.ReadDouble(); _options.DropoutRate = r.ReadDouble();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions);
-        int nFft = NextPowerOfTwo(_options.FftSize);
-        _stft = new ShortTimeFourierTransform<T>(nFft: nFft, hopLength: _options.HopLength,
-            windowLength: _options.FftSize <= nFft ? _options.FftSize : null);
-        _lastPhase = null;
-        _noiseProfile = null;
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new CMGAN<T>(Architecture, mp, _options);
-        return new CMGAN<T>(Architecture, _options);
-    }
+
 
     #endregion
 
diff --git a/src/Audio/Enhancement/ConvTasNet.cs b/src/Audio/Enhancement/ConvTasNet.cs
index bdcda8379c..8f6b0640f3 100644
--- a/src/Audio/Enhancement/ConvTasNet.cs
+++ b/src/Audio/Enhancement/ConvTasNet.cs
@@ -1,4 +1,4 @@
-using AiDotNet.Attributes;
+using AiDotNet.Attributes;
 using AiDotNet.Enums;
 using AiDotNet.Extensions;
 using AiDotNet.Interfaces;
@@ -76,7 +76,7 @@ namespace AiDotNet.Audio.Enhancement;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Conv-TasNet: Surpassing Ideal Time-Frequency Magnitude Masking for Speech Separation", "https://arxiv.org/abs/1809.07454", Year = 2019, Authors = "Yi Luo, Nima Mesgarani")]
-public class ConvTasNet<T> : AudioNeuralNetworkBase<T>, IAudioEnhancer<T>
+public partial class ConvTasNet<T> : AudioNeuralNetworkBase<T>, IAudioEnhancer<T>
 {
     private readonly ConvTasNetOptions _options;
 
@@ -89,7 +89,9 @@ public class ConvTasNet<T> : AudioNeuralNetworkBase<T>, IAudioEnhancer<T>
     private readonly int _encoderDim;
     private readonly int _kernelSize;
     private readonly int _stride;
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _encoderWeight;
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _encoderBias;
 
     // Separator (TCN) parameters
@@ -104,10 +106,13 @@ public class ConvTasNet<T> : AudioNeuralNetworkBase<T>, IAudioEnhancer<T>
     private readonly List<TcnBlock> _tcnBlocks;
 
     // Decoder parameters
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _decoderWeight;
 
     // Mask estimation
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _maskWeight;
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _maskBias;
 
     // Normalization layers
@@ -976,132 +981,6 @@ private void UpdateWeights(Dictionary<string, T[]> gradients)
 
     #region Serialization
 
-    /// <summary>
-    /// Serializes the model state to a byte array.
-    /// </summary>
-    public override byte[] Serialize()
-    {
-        using var stream = new MemoryStream();
-        using var writer = new BinaryWriter(stream);
-
-        // Write model configuration
-        writer.Write(SampleRate);
-        writer.Write(_encoderDim);
-        writer.Write(_kernelSize);
-        writer.Write(_bottleneckDim);
-        writer.Write(_hiddenDim);
-        writer.Write(_numBlocks);
-        writer.Write(_numRepeats);
-        writer.Write(_tcnKernelSize);
-        writer.Write(_numSources);
-
-        // Write encoder weights
-        writer.Write(_encoderWeight.Length);
-        foreach (var w in _encoderWeight)
-        {
-            writer.Write(_numOps.ToDouble(w));
-        }
-
-        // Write decoder weights
-        writer.Write(_decoderWeight.Length);
-        foreach (var w in _decoderWeight)
-        {
-            writer.Write(_numOps.ToDouble(w));
-        }
-
-        // Write mask weights
-        writer.Write(_maskWeight.Length);
-        foreach (var w in _maskWeight)
-        {
-            writer.Write(_numOps.ToDouble(w));
-        }
-
-        // Write normalization parameters
-        writer.Write(_normGamma.Length);
-        foreach (var g in _normGamma)
-        {
-            writer.Write(_numOps.ToDouble(g));
-        }
-        foreach (var b in _normBeta)
-        {
-            writer.Write(_numOps.ToDouble(b));
-        }
-
-        // The base Layers collection is intentionally empty for this manual graph.
-        // Persist the complete flat registry as well, including encoder/mask biases
-        // and every TCN block, which the legacy fields above omitted.
-        var parameters = GetParameters();
-        writer.Write(parameters.Length);
-        for (int i = 0; i < parameters.Length; i++)
-            writer.Write(_numOps.ToDouble(parameters[i]));
-
-        return stream.ToArray();
-    }
-
-    /// <summary>
-    /// Deserializes the model state from a byte array.
-    /// </summary>
-    public override void Deserialize(byte[] data)
-    {
-        using var stream = new MemoryStream(data);
-        using var reader = new BinaryReader(stream);
-
-        // Read and verify configuration
-        int sampleRate = reader.ReadInt32();
-        int encoderDim = reader.ReadInt32();
-        int kernelSize = reader.ReadInt32();
-        int bottleneckDim = reader.ReadInt32();
-        int hiddenDim = reader.ReadInt32();
-        int numBlocks = reader.ReadInt32();
-        int numRepeats = reader.ReadInt32();
-        int tcnKernelSize = reader.ReadInt32();
-        int numSources = reader.ReadInt32();
-
-        // Validate configuration matches
-        if (encoderDim != _encoderDim || kernelSize != _kernelSize || numSources != _numSources)
-        {
-            throw new InvalidOperationException("Serialized model configuration does not match current model.");
-        }
-
-        // Read encoder weights
-        int encoderLen = reader.ReadInt32();
-        for (int i = 0; i < encoderLen && i < _encoderWeight.Length; i++)
-        {
-            _encoderWeight[i] = _numOps.FromDouble(reader.ReadDouble());
-        }
-
-        // Read decoder weights
-        int decoderLen = reader.ReadInt32();
-        for (int i = 0; i < decoderLen && i < _decoderWeight.Length; i++)
-        {
-            _decoderWeight[i] = _numOps.FromDouble(reader.ReadDouble());
-        }
-
-        // Read mask weights
-        int maskLen = reader.ReadInt32();
-        for (int i = 0; i < maskLen && i < _maskWeight.Length; i++)
-        {
-            _maskWeight[i] = _numOps.FromDouble(reader.ReadDouble());
-        }
-
-        // Read normalization parameters
-        int normLen = reader.ReadInt32();
-        for (int i = 0; i < normLen && i < _normGamma.Length; i++)
-        {
-            _normGamma[i] = _numOps.FromDouble(reader.ReadDouble());
-        }
-        for (int i = 0; i < normLen && i < _normBeta.Length; i++)
-        {
-            _normBeta[i] = _numOps.FromDouble(reader.ReadDouble());
-        }
-
-        int parameterCount = reader.ReadInt32();
-        var parameters = new Vector<T>(parameterCount);
-        for (int i = 0; i < parameterCount; i++)
-            parameters[i] = _numOps.FromDouble(reader.ReadDouble());
-        SetParameters(parameters);
-    }
-
     #endregion
 
     #region Helper Methods
@@ -1133,48 +1012,6 @@ private Tensor<T> InitializeWeights(int size, double initValue = double.NaN)
 
     #region Abstract Method Implementations
 
-    /// <summary>
-    /// Declares every weight Conv-TasNet owns: the encoder, the separation mask, the decoder, the
-    /// layer-norm affine pair, and each temporal-convolution block's seven tensors.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// Conv-TasNet implements its signal path with model-owned tensors rather than
-    /// <see cref="NeuralNetworkBase{T}.Layers"/>, so the base walk finds nothing unless they are
-    /// declared. Declared in the order the deleted GetParameters concatenated them -- encoder
-    /// weight and bias, decoder weight, mask weight and bias, norm gamma and beta, then each TCN
-    /// block -- so existing checkpoints still restore.
-    /// </para>
-    /// <para>
-    /// This replaces ParameterCount, GetParameters, GetParameterChunks and SetParameters here, four
-    /// more on TcnBlock, and the four Copy/Read helpers that moved values one element at a time.
-    /// </para>
-    /// <para>
-    /// The weights are <c>Tensor&lt;T&gt;</c> now rather than raw <c>T[]</c>, which is what the rest
-    /// of the library uses and what the trainable-parameter walk can see. A bare array cannot be
-    /// declared: a <c>Vector&lt;T&gt;</c> built over one COPIES it, so a restore driven through such
-    /// a view would have written into a temporary and been discarded.
-    /// </para>
-    /// </remarks>
-    protected override IEnumerable<Tensor<T>> GetExtraTrainableTensors()
-    {
-        yield return _encoderWeight;
-        yield return _encoderBias;
-        yield return _decoderWeight;
-        yield return _maskWeight;
-        yield return _maskBias;
-        yield return _normGamma;
-        yield return _normBeta;
-
-        foreach (var block in _tcnBlocks)
-        {
-            foreach (var tensor in block.EnumerateTensors())
-            {
-                yield return tensor;
-            }
-        }
-    }
-
     // UpdateParameters is NOT overridden. It used to throw NotSupportedException; the base
     // implementation is virtual now and distributes a flat vector over the same enumeration
     // GetParameters folds, which this model already exposes correctly. The throw existed
@@ -1198,64 +1035,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(IsOnnxMode);
-        writer.Write(SampleRate);
-        writer.Write(_encoderDim);
-        writer.Write(_kernelSize);
-        writer.Write(_stride);
-        writer.Write(_numSources);
-        writer.Write(_bottleneckDim);
-        writer.Write(_hiddenDim);
-        writer.Write(_numBlocks);
-        writer.Write(_numRepeats);
-        writer.Write(_tcnKernelSize);
-        writer.Write(EnhancementStrength);
-        var parameters = GetParameters();
-        writer.Write(parameters.Length);
-        for (int i = 0; i < parameters.Length; i++)
-            writer.Write(_numOps.ToDouble(parameters[i]));
-    }
 
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        // Read configuration values for validation
-        _ = reader.ReadBoolean(); // IsOnnxMode
-        _ = reader.ReadInt32();   // SampleRate
-        _ = reader.ReadInt32();   // _encoderDim
-        _ = reader.ReadInt32();   // _kernelSize
-        _ = reader.ReadInt32();   // _stride
-        _ = reader.ReadInt32();   // _numSources
-        _ = reader.ReadInt32();   // _bottleneckDim
-        _ = reader.ReadInt32();   // _hiddenDim
-        _ = reader.ReadInt32();   // _numBlocks
-        _ = reader.ReadInt32();   // _numRepeats
-        _ = reader.ReadInt32();   // _tcnKernelSize
-        EnhancementStrength = reader.ReadDouble();
-        int parameterCount = reader.ReadInt32();
-        var parameters = new Vector<T>(parameterCount);
-        for (int i = 0; i < parameterCount; i++)
-            parameters[i] = _numOps.FromDouble(reader.ReadDouble());
-        SetParameters(parameters);
-    }
 
     /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new ConvTasNet<T>(
-            Architecture,
-            sampleRate: SampleRate,
-            encoderDim: _encoderDim,
-            kernelSize: _kernelSize,
-            bottleneckDim: _bottleneckDim,
-            hiddenDim: _hiddenDim,
-            numBlocks: _numBlocks,
-            numRepeats: _numRepeats,
-            tcnKernelSize: _tcnKernelSize,
-            numSources: _numSources);
-    }
+
 
     #endregion
 
diff --git a/src/Audio/Enhancement/DCCRN.cs b/src/Audio/Enhancement/DCCRN.cs
index c15e3eb790..d7b3b86966 100644
--- a/src/Audio/Enhancement/DCCRN.cs
+++ b/src/Audio/Enhancement/DCCRN.cs
@@ -859,24 +859,6 @@ private Tensor<T> ComputeInverseSTFT(Tensor<T> stft)
         return audio;
     }
 
-    /// <summary>
-    /// Applies complex mask to STFT.
-    /// </summary>
-    /// <summary>
-    /// Surfaces the complex-conv real/imaginary kernels as the model's raw trainable tensors so the base
-    /// gradient tape watches and updates them and GetParameters / serialization round-trip them (the same
-    /// mechanism ViT cls/pos tokens use). They are created lazily on first forward once input channel
-    /// counts are known, so this yields nothing until then; the base runs a warm-up forward before
-    /// collecting parameters, so they exist by collection time.
-    /// </summary>
-    protected override System.Collections.Generic.IEnumerable<Tensor<T>> GetExtraTrainableTensors()
-    {
-        foreach (var w in _encWr) if (w is not null) yield return w;
-        foreach (var w in _encWi) if (w is not null) yield return w;
-        foreach (var w in _decWr) if (w is not null) yield return w;
-        foreach (var w in _decWi) if (w is not null) yield return w;
-    }
-
     /// <summary>
     /// True complex convolution (Hu 2020): for complex input carried as [B, 2*Cin, F, T] (real channels
     /// first, imaginary second) and complex kernels Wr, Wi, computes
@@ -1054,33 +1036,7 @@ protected override void InitializeLayers()
     }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(IsOnnxMode);
-        writer.Write(SampleRate);
-        writer.Write(_numStages);
-        writer.Write(_baseChannels);
-        writer.Write(_lstmHiddenDim);
-        writer.Write(_numLstmLayers);
-        writer.Write(_fftSize);
-        writer.Write(_hopSize);
-        writer.Write(_useComplexMask);
-        writer.Write(_kernelSize);
-        writer.Write(_stride);
-        writer.Write(EnhancementStrength);
-
-        // Persist the complex-conv kernels (Wr/Wi). These are the model's trainable weights for the conv
-        // stages but live OUTSIDE Layers (raw tensors via GetExtraTrainableTensors), so the base layer
-        // serialization above does NOT capture them — we must write them here. They are created lazily on
-        // first forward, so at serialize time they exist iff a forward/train has run; an untrained,
-        // never-forwarded model writes empty lists (count 0) and re-lazy-initializes on load. This is the
-        // write half of the PyTorch LazyModule contract: lazy on the compute path, materialized from the
-        // checkpoint on load (see DeserializeNetworkSpecificData) — no eager materialization at construction.
-        WriteComplexKernels(writer, _encWr);
-        WriteComplexKernels(writer, _encWi);
-        WriteComplexKernels(writer, _decWr);
-        WriteComplexKernels(writer, _decWi);
-    }
+
 
     /// <summary>Writes a list of complex-conv kernels as [count]([rank][dims...][values...] | -1 for null).</summary>
     private static void WriteComplexKernels(BinaryWriter writer, System.Collections.Generic.List<Tensor<T>?> kernels)
@@ -1122,58 +1078,7 @@ private void ReadComplexKernels(BinaryReader reader, System.Collections.Generic.
     }
 
     /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        // Restore configuration values
-        _ = reader.ReadBoolean(); // IsOnnxMode (determined by constructor, cannot change)
-        SampleRate = reader.ReadInt32();
-        _numStages = reader.ReadInt32();
-        _baseChannels = reader.ReadInt32();
-        _lstmHiddenDim = reader.ReadInt32();
-        _numLstmLayers = reader.ReadInt32();
-        _fftSize = reader.ReadInt32();
-        _hopSize = reader.ReadInt32();
-        _useComplexMask = reader.ReadBoolean();
-        _kernelSize = reader.ReadInt32();
-        _stride = reader.ReadInt32();
-        EnhancementStrength = reader.ReadDouble();
-
-        // Re-derive the internal sub-lists from the layers the BASE already reconstructed and restored
-        // trained weights into. Do NOT call InitializeNativeLayers here — it would Layers.Clear() and
-        // rebuild FRESH layers, discarding the base-restored trained weights and dropping the trained
-        // state on a clone (Clone_AfterTraining, #1221 class). Only rebuild if the base produced no layers
-        // (e.g. a bare native model with nothing serialized).
-        if (!IsOnnxMode)
-        {
-            if (Layers.Count > 0)
-                DistributeLayers();
-            else
-                InitializeNativeLayers();
-        }
 
-        // Materialize the complex-conv kernels from the checkpoint (same order they were written). These
-        // live outside Layers, so the base did not restore them; recreating them here (from the serialized
-        // shapes) carries the trained conv weights into a deserialized clone.
-        ReadComplexKernels(reader, _encWr);
-        ReadComplexKernels(reader, _encWi);
-        ReadComplexKernels(reader, _decWr);
-        ReadComplexKernels(reader, _decWi);
-    }
-
-    /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new DCCRN<T>(
-            Architecture,
-            sampleRate: SampleRate,
-            numStages: _numStages,
-            baseChannels: _baseChannels,
-            lstmHiddenDim: _lstmHiddenDim,
-            numLstmLayers: _numLstmLayers,
-            fftSize: _fftSize,
-            hopSize: _hopSize,
-            useComplexMask: _useComplexMask);
-    }
 
     #endregion
 
diff --git a/src/Audio/Enhancement/DeepFilterNet.cs b/src/Audio/Enhancement/DeepFilterNet.cs
index 807c7b5a0a..87e9a8e7d1 100644
--- a/src/Audio/Enhancement/DeepFilterNet.cs
+++ b/src/Audio/Enhancement/DeepFilterNet.cs
@@ -97,7 +97,6 @@ public partial class DeepFilterNet<T> : AudioNeuralNetworkBase<T>, IAudioEnhance
     /// <summary>
     /// Convolution kernel size for feature extraction.
     /// </summary>
-    private readonly int _convKernelSize;
 
     /// <summary>
     /// FFT size for STFT analysis.
@@ -296,7 +295,6 @@ public DeepFilterNet(
         _dfOrder = 5;
         _dfBins = 96;
         _numGruLayers = 2;
-        _convKernelSize = 3;
         _lookahead = 2;
         // Load ONNX model
         OnnxModel = new OnnxModel<T>(modelPath, onnxOptions);
@@ -373,7 +371,6 @@ public DeepFilterNet(
         _fftSize = fftSize;
         _hopSize = hopSize;
         _lookahead = lookahead;
-        _convKernelSize = 3;
         _lossFunction = lossFunction ?? new MeanSquaredErrorLoss<T>();
         _optimizer = optimizer ?? new AdamOptimizer<T, Tensor<T>, Tensor<T>>(this);
 
@@ -1047,55 +1044,10 @@ protected override void InitializeLayers()
     }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(IsOnnxMode);
-        writer.Write(SampleRate);
-        writer.Write(_numErbBands);
-        writer.Write(_hiddenDim);
-        writer.Write(_dfOrder);
-        writer.Write(_dfBins);
-        writer.Write(_numGruLayers);
-        writer.Write(_convKernelSize);
-        writer.Write(_fftSize);
-        writer.Write(_hopSize);
-        writer.Write(_lookahead);
-        writer.Write(EnhancementStrength);
-    }
 
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        // Read configuration values for validation
-        _ = reader.ReadBoolean(); // IsOnnxMode
-        _ = reader.ReadInt32();   // SampleRate
-        _ = reader.ReadInt32();   // _numErbBands
-        _ = reader.ReadInt32();   // _hiddenDim
-        _ = reader.ReadInt32();   // _dfOrder
-        _ = reader.ReadInt32();   // _dfBins
-        _ = reader.ReadInt32();   // _numGruLayers
-        _ = reader.ReadInt32();   // _convKernelSize
-        _ = reader.ReadInt32();   // _fftSize
-        _ = reader.ReadInt32();   // _hopSize
-        _ = reader.ReadInt32();   // _lookahead
-        EnhancementStrength = reader.ReadDouble();
-    }
 
     /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new DeepFilterNet<T>(
-            Architecture,
-            sampleRate: SampleRate,
-            numErbBands: _numErbBands,
-            hiddenDim: _hiddenDim,
-            dfOrder: _dfOrder,
-            dfBins: _dfBins,
-            numGruLayers: _numGruLayers,
-            fftSize: _fftSize,
-            hopSize: _hopSize,
-            lookahead: _lookahead);
-    }
+
 
     #endregion
 
diff --git a/src/Audio/Enhancement/FRCRN.cs b/src/Audio/Enhancement/FRCRN.cs
index 209ff66411..66cf6a27d6 100644
--- a/src/Audio/Enhancement/FRCRN.cs
+++ b/src/Audio/Enhancement/FRCRN.cs
@@ -41,7 +41,7 @@ namespace AiDotNet.Audio.Enhancement;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("FRCRN: Boosting Feature Representation Using Frequency Recurrence for Monaural Speech Enhancement", "https://arxiv.org/abs/2206.07293", Year = 2022, Authors = "Shengkui Zhao, Bin Ma, Karn N. Watcharasupat, Woon-Seng Gan")]
-public class FRCRN<T> : AudioNeuralNetworkBase<T>, IAudioEnhancer<T>
+public partial class FRCRN<T> : AudioNeuralNetworkBase<T>, IAudioEnhancer<T>
 {
     /// <inheritdoc />
     /// <remarks>
@@ -61,7 +61,7 @@ public class FRCRN<T> : AudioNeuralNetworkBase<T>, IAudioEnhancer<T>
     private ShortTimeFourierTransform<T> _stft;
     [Scratch]
     private Tensor<T>? _lastPhase;
-    [Buffer]
+    [Buffer(Availability = AiDotNet.Models.Parameters.ParameterAvailability.Conditional)]
     private Tensor<T>? _noiseProfile;
     private bool _useNativeMode;
     private bool _disposed;
@@ -236,36 +236,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty);
-        w.Write(_options.SampleRate); w.Write(_options.Variant);
-        w.Write(_options.EncoderChannels); w.Write(_options.NumStages);
-        w.Write(_options.LstmHiddenSize); w.Write(_options.NumFreqBins);
-        w.Write(_options.FFTSize); w.Write(_options.HopLength);
-        w.Write(_options.DropoutRate);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.SampleRate = r.ReadInt32(); _options.Variant = r.ReadString();
-        _options.EncoderChannels = r.ReadInt32(); _options.NumStages = r.ReadInt32();
-        _options.LstmHiddenSize = r.ReadInt32(); _options.NumFreqBins = r.ReadInt32();
-        _options.FFTSize = r.ReadInt32(); _options.HopLength = r.ReadInt32();
-        _options.DropoutRate = r.ReadDouble();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions);
-        int nFft = NextPowerOfTwo(_options.FFTSize);
-        _stft = new ShortTimeFourierTransform<T>(nFft: nFft, hopLength: _options.HopLength,
-            windowLength: _options.FFTSize <= nFft ? _options.FFTSize : null);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new FRCRN<T>(Architecture, mp, _options);
-        return new FRCRN<T>(Architecture, _options);
-    }
+
 
     #endregion
 
diff --git a/src/Audio/Enhancement/FullSubNetPlus.cs b/src/Audio/Enhancement/FullSubNetPlus.cs
index cb2f477003..e80d3e6ab6 100644
--- a/src/Audio/Enhancement/FullSubNetPlus.cs
+++ b/src/Audio/Enhancement/FullSubNetPlus.cs
@@ -57,7 +57,7 @@ namespace AiDotNet.Audio.Enhancement;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("FullSubNet+: Channel Attention FullSubNet with Complex Spectrograms for Speech Enhancement", "https://arxiv.org/abs/2203.12188", Year = 2022, Authors = "Jun Chen, Zilin Wang, Deyi Tuo, Zhiyong Wu, Shiyin Kang, Helen Meng")]
-public class FullSubNetPlus<T> : AudioNeuralNetworkBase<T>, IAudioEnhancer<T>
+public partial class FullSubNetPlus<T> : AudioNeuralNetworkBase<T>, IAudioEnhancer<T>
 {
     /// <inheritdoc />
     /// <remarks>
@@ -76,7 +76,7 @@ public class FullSubNetPlus<T> : AudioNeuralNetworkBase<T>, IAudioEnhancer<T>
     private ShortTimeFourierTransform<T> _stft;
     [Scratch]
     private Tensor<T>? _lastPhase;
-    [Buffer]
+    [Buffer(Availability = AiDotNet.Models.Parameters.ParameterAvailability.Conditional)]
     private Tensor<T>? _noiseProfile;
     private bool _useNativeMode;
     private bool _disposed;
@@ -314,37 +314,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty);
-        w.Write(_options.SampleRate); w.Write(_options.FftSize); w.Write(_options.HopLength);
-        w.Write(_options.NumFreqBins); w.Write(_options.FullBandLayers); w.Write(_options.FullBandHiddenSize);
-        w.Write(_options.SubBandLayers); w.Write(_options.SubBandHiddenSize);
-        w.Write(_options.EnhancementStrength); w.Write(_options.DropoutRate);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean();
-        string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.SampleRate = r.ReadInt32(); base.SampleRate = _options.SampleRate;
-        _options.FftSize = r.ReadInt32(); _options.HopLength = r.ReadInt32();
-        _options.NumFreqBins = r.ReadInt32(); _options.FullBandLayers = r.ReadInt32(); _options.FullBandHiddenSize = r.ReadInt32();
-        _options.SubBandLayers = r.ReadInt32(); _options.SubBandHiddenSize = r.ReadInt32();
-        _options.EnhancementStrength = r.ReadDouble(); _options.DropoutRate = r.ReadDouble();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions);
-        int nFft = NextPowerOfTwo(_options.FftSize);
-        _stft = new ShortTimeFourierTransform<T>(nFft: nFft, hopLength: _options.HopLength,
-            windowLength: _options.FftSize <= nFft ? _options.FftSize : null);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new FullSubNetPlus<T>(Architecture, mp, _options);
-        return new FullSubNetPlus<T>(Architecture, _options);
-    }
+
 
     #endregion
 
diff --git a/src/Audio/Enhancement/MPSENet.cs b/src/Audio/Enhancement/MPSENet.cs
index 43d66831b7..e9a8c76bb1 100644
--- a/src/Audio/Enhancement/MPSENet.cs
+++ b/src/Audio/Enhancement/MPSENet.cs
@@ -41,7 +41,7 @@ namespace AiDotNet.Audio.Enhancement;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("MP-SENet: A Speech Enhancement Model with Parallel Denoising of Magnitude and Phase Spectra", "https://doi.org/10.48550/arXiv.2305.13686", Year = 2023, Authors = "Ye-Xin Lu, Yang Ai, Zhen-Hua Ling")]
-public class MPSENet<T> : AudioNeuralNetworkBase<T>, IAudioEnhancer<T>
+public partial class MPSENet<T> : AudioNeuralNetworkBase<T>, IAudioEnhancer<T>
 {
     /// <inheritdoc />
     /// <remarks>
@@ -60,7 +60,7 @@ public class MPSENet<T> : AudioNeuralNetworkBase<T>, IAudioEnhancer<T>
     private ShortTimeFourierTransform<T> _stft;
     [Scratch]
     private Tensor<T>? _lastPhase;
-    [Buffer]
+    [Buffer(Availability = AiDotNet.Models.Parameters.ParameterAvailability.Conditional)]
     private Tensor<T>? _noiseProfile;
     private bool _useNativeMode;
     private bool _disposed;
@@ -245,37 +245,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty);
-        w.Write(_options.SampleRate); w.Write(_options.Variant);
-        w.Write(_options.HiddenDim); w.Write(_options.NumLayers);
-        w.Write(_options.NumAttentionHeads); w.Write(_options.FeedForwardDim);
-        w.Write(_options.NumFreqBins); w.Write(_options.FFTSize);
-        w.Write(_options.HopLength); w.Write(_options.DropoutRate);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.SampleRate = r.ReadInt32(); _options.Variant = r.ReadString();
-        _options.HiddenDim = r.ReadInt32(); _options.NumLayers = r.ReadInt32();
-        _options.NumAttentionHeads = r.ReadInt32(); _options.FeedForwardDim = r.ReadInt32();
-        _options.NumFreqBins = r.ReadInt32(); _options.FFTSize = r.ReadInt32();
-        _options.HopLength = r.ReadInt32(); _options.DropoutRate = r.ReadDouble();
-        base.SampleRate = _options.SampleRate;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions);
-        int nFft = NextPowerOfTwo(_options.FFTSize);
-        _stft = new ShortTimeFourierTransform<T>(nFft: nFft, hopLength: _options.HopLength,
-            windowLength: _options.FFTSize <= nFft ? _options.FFTSize : null);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new MPSENet<T>(Architecture, mp, _options);
-        return new MPSENet<T>(Architecture, _options);
-    }
+
 
     #endregion
 
diff --git a/src/Audio/Enhancement/NeuralNoiseReducer.cs b/src/Audio/Enhancement/NeuralNoiseReducer.cs
index 4a21fdc468..62ccd9ba88 100644
--- a/src/Audio/Enhancement/NeuralNoiseReducer.cs
+++ b/src/Audio/Enhancement/NeuralNoiseReducer.cs
@@ -1004,22 +1004,6 @@ protected override Tensor<T> PredictCore(Tensor<T> input)
         return PostprocessOutput(output);
     }
 
-    /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new NeuralNoiseReducer<T>(
-            Architecture,
-            SampleRate,
-            _fftSize,
-            _hopSize,
-            NumChannels,
-            _numStages,
-            _baseFilters,
-            _bottleneckDim,
-            EnhancementStrength,
-            _lossFunction);
-    }
-
     /// <inheritdoc/>
     public override ModelMetadata<T> GetModelMetadata()
     {
@@ -1056,41 +1040,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(SampleRate);
-        writer.Write(_fftSize);
-        writer.Write(_hopSize);
-        writer.Write(NumChannels);
-        writer.Write(_numStages);
-        writer.Write(_baseFilters);
-        writer.Write(_bottleneckDim);
-        writer.Write(EnhancementStrength);
-    }
+
 
     /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        SampleRate = reader.ReadInt32();
-        _fftSize = reader.ReadInt32();
-        _hopSize = reader.ReadInt32();
-        NumChannels = reader.ReadInt32();
-        _numStages = reader.ReadInt32();
-        _baseFilters = reader.ReadInt32();
-        _bottleneckDim = reader.ReadInt32();
-        EnhancementStrength = reader.ReadDouble();
-
-        // Rebuild streaming buffers after FFT/hop size may have changed
-        InitializeStreamingBuffers();
 
-        // Reinitialize layers if needed for native mode
-        if (_useNativeMode && (_encoderLayers is null || _encoderLayers.Count == 0))
-        {
-            InitializeLayers();
-        }
-    }
 
     #endregion
 }
diff --git a/src/Audio/Enhancement/SpikingFullSubNet.cs b/src/Audio/Enhancement/SpikingFullSubNet.cs
index ac9b165521..8c27bf7279 100644
--- a/src/Audio/Enhancement/SpikingFullSubNet.cs
+++ b/src/Audio/Enhancement/SpikingFullSubNet.cs
@@ -43,7 +43,7 @@ namespace AiDotNet.Audio.Enhancement;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Spiking-FullSubNet: Spiking Neural Networks for Speech Enhancement", "https://arxiv.org/abs/2406.04662", Year = 2024, Authors = "Jiaying Lin, Rong Xie, Qi Liu")]
-public class SpikingFullSubNet<T> : AudioNeuralNetworkBase<T>, IAudioEnhancer<T>
+public partial class SpikingFullSubNet<T> : AudioNeuralNetworkBase<T>, IAudioEnhancer<T>
 {
     /// <inheritdoc />
     /// <remarks>
@@ -63,7 +63,7 @@ public class SpikingFullSubNet<T> : AudioNeuralNetworkBase<T>, IAudioEnhancer<T>
     private readonly ShortTimeFourierTransform<T> _stft;
     [Scratch]
     private Tensor<T>? _lastPhase;
-    [Buffer]
+    [Buffer(Availability = AiDotNet.Models.Parameters.ParameterAvailability.Conditional)]
     private Tensor<T>? _noiseProfile;
     private bool _useNativeMode;
     private bool _disposed;
@@ -282,34 +282,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty);
-        w.Write(_options.SampleRate); w.Write(_options.FftSize); w.Write(_options.HopLength);
-        w.Write(_options.NumFreqBins); w.Write(_options.NumFullBandLayers); w.Write(_options.FullBandHiddenSize);
-        w.Write(_options.NumSubBandLayers); w.Write(_options.SubBandHiddenSize);
-        w.Write(_options.SpikingThreshold); w.Write(_options.TimeConstant);
-        w.Write(_options.EnhancementStrength); w.Write(_options.DropoutRate);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.SampleRate = r.ReadInt32(); _options.FftSize = r.ReadInt32(); _options.HopLength = r.ReadInt32();
-        _options.NumFreqBins = r.ReadInt32(); _options.NumFullBandLayers = r.ReadInt32(); _options.FullBandHiddenSize = r.ReadInt32();
-        _options.NumSubBandLayers = r.ReadInt32(); _options.SubBandHiddenSize = r.ReadInt32();
-        _options.SpikingThreshold = r.ReadDouble(); _options.TimeConstant = r.ReadDouble();
-        _options.EnhancementStrength = r.ReadDouble(); _options.DropoutRate = r.ReadDouble();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new SpikingFullSubNet<T>(Architecture, mp, _options);
-        return new SpikingFullSubNet<T>(Architecture, _options);
-    }
+
 
     #endregion
 
diff --git a/src/Audio/Enhancement/TFGridNet.cs b/src/Audio/Enhancement/TFGridNet.cs
index 0a0069fec2..777171c1a7 100644
--- a/src/Audio/Enhancement/TFGridNet.cs
+++ b/src/Audio/Enhancement/TFGridNet.cs
@@ -58,7 +58,7 @@ namespace AiDotNet.Audio.Enhancement;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("TF-GridNet: Making Time-Frequency Domain Models Great Again for Monaural Speaker Separation", "https://arxiv.org/abs/2209.03952", Year = 2023, Authors = "Zhong-Qiu Wang, Samuele Cornell, Shukjae Choi, Younglo Lee, Byeong-Yeol Kim, Shinji Watanabe")]
-public class TFGridNet<T> : AudioNeuralNetworkBase<T>, IAudioEnhancer<T>
+public partial class TFGridNet<T> : AudioNeuralNetworkBase<T>, IAudioEnhancer<T>
 {
     /// <inheritdoc />
     /// <remarks>
@@ -79,7 +79,7 @@ public class TFGridNet<T> : AudioNeuralNetworkBase<T>, IAudioEnhancer<T>
     private readonly ShortTimeFourierTransform<T> _stft;
     [Scratch]
     private Tensor<T>? _lastPhase;
-    [Buffer]
+    [Buffer(Availability = AiDotNet.Models.Parameters.ParameterAvailability.Conditional)]
     private Tensor<T>? _noiseProfile;
     private bool _useNativeMode;
     private bool _disposed;
@@ -361,33 +361,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty);
-        w.Write(_options.SampleRate); w.Write(_options.FftSize); w.Write(_options.HopLength);
-        w.Write(_options.NumFreqBins); w.Write(_options.HiddenDim); w.Write(_options.EmbeddingDim);
-        w.Write(_options.NumBlocks); w.Write(_options.NumAttentionHeads);
-        w.Write(_options.EnhancementStrength); w.Write(_options.DropoutRate); w.Write(_options.NumSources);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean();
-        string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.SampleRate = r.ReadInt32(); _options.FftSize = r.ReadInt32(); _options.HopLength = r.ReadInt32();
-        _options.NumFreqBins = r.ReadInt32(); _options.HiddenDim = r.ReadInt32(); _options.EmbeddingDim = r.ReadInt32();
-        _options.NumBlocks = r.ReadInt32(); _options.NumAttentionHeads = r.ReadInt32();
-        _options.EnhancementStrength = r.ReadDouble(); _options.DropoutRate = r.ReadDouble(); _options.NumSources = r.ReadInt32();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new TFGridNet<T>(Architecture, mp, _options);
-        return new TFGridNet<T>(Architecture, _options);
-    }
+
 
     #endregion
 
diff --git a/src/Audio/Features/ConstantQTransform.cs b/src/Audio/Features/ConstantQTransform.cs
index b04af64b83..adb764cccb 100644
--- a/src/Audio/Features/ConstantQTransform.cs
+++ b/src/Audio/Features/ConstantQTransform.cs
@@ -365,9 +365,5 @@ public override IFullModel<T, Tensor<T>, Tensor<T>> WithParameters(Tensors.Linea
         return copy;
     }
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy()
-        => (ConstantQTransform<T>)MemberwiseClone();
-
     #endregion
 }
diff --git a/src/Audio/Fingerprinting/ASTModel.cs b/src/Audio/Fingerprinting/ASTModel.cs
index 23cd637891..8f3c987d4f 100644
--- a/src/Audio/Fingerprinting/ASTModel.cs
+++ b/src/Audio/Fingerprinting/ASTModel.cs
@@ -45,7 +45,7 @@ namespace AiDotNet.Audio.Fingerprinting;
 [PreprocessesInput("PreprocessAudio converts the caller's waveform into a rank-4 log-mel spectrogram before the AST patch embedding runs.")]
 [StackInputLayout(TensorAxis.Batch, TensorAxis.Channels, TensorAxis.Height, TensorAxis.Width,
     BatchOptional = true)]
-public class ASTModel<T> : AudioNeuralNetworkBase<T>, IAudioFingerprinter<T>
+public partial class ASTModel<T> : AudioNeuralNetworkBase<T>, IAudioFingerprinter<T>
 {
     /// <inheritdoc />
     /// <remarks>
@@ -65,7 +65,7 @@ public class ASTModel<T> : AudioNeuralNetworkBase<T>, IAudioFingerprinter<T>
     /// Cached Hann window for the STFT preprocessing step. Built once on the
     /// first <see cref="PreprocessAudio"/> call and reused.
     /// </summary>
-    [Buffer]
+    [Scratch]
     private Tensor<T>? _hannWindow;
 
     /// <inheritdoc/>
@@ -430,16 +430,6 @@ protected override void Dispose(bool disposing)
         base.Dispose(disposing);
     }
 
-    /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() =>
-        _useNativeMode
-            ? new ASTModel<T>(Architecture, _options)
-            // ONNX-backed instance: preserve the loaded model path so the
-            // clone keeps its execution mode. Without this, Clone() of an
-            // ONNX-mode AST silently downgrades to native (no weights,
-            // empty Layers) and changes inference behaviour.
-            : new ASTModel<T>(Architecture, _modelPath!, _options);
-
     /// <inheritdoc/>
     public override ModelMetadata<T> GetModelMetadata() =>
         new ModelMetadata<T>
@@ -461,45 +451,10 @@ public override ModelMetadata<T> GetModelMetadata() =>
         };
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.StftWindowSize);
-        writer.Write(_options.HopLength);
-        writer.Write(_options.NumMelBands);
-        writer.Write(_options.TargetLength);
-        writer.Write(_options.PatchSize);
-        writer.Write(_options.NumClasses);
-        writer.Write(_options.EmbeddingDim);
-        writer.Write(_options.NumLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.FeedForwardDim);
-        writer.Write(_options.DropoutRate);
-    }
+
 
     /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        bool useNativeMode = reader.ReadBoolean();
-        if (useNativeMode != _useNativeMode)
-            throw new InvalidOperationException(
-                $"Persisted AST mode (native={useNativeMode}) does not match this " +
-                $"instance's mode (native={_useNativeMode}). Reconstruct ASTModel " +
-                $"with the matching constructor before loading this checkpoint.");
-        VerifyEqual(reader.ReadInt32(),  _options.SampleRate,     nameof(_options.SampleRate));
-        VerifyEqual(reader.ReadInt32(),  _options.StftWindowSize, nameof(_options.StftWindowSize));
-        VerifyEqual(reader.ReadInt32(),  _options.HopLength,      nameof(_options.HopLength));
-        VerifyEqual(reader.ReadInt32(),  _options.NumMelBands,    nameof(_options.NumMelBands));
-        VerifyEqual(reader.ReadInt32(),  _options.TargetLength,   nameof(_options.TargetLength));
-        VerifyEqual(reader.ReadInt32(),  _options.PatchSize,      nameof(_options.PatchSize));
-        VerifyEqual(reader.ReadInt32(),  _options.NumClasses,     nameof(_options.NumClasses));
-        VerifyEqual(reader.ReadInt32(),  _options.EmbeddingDim,   nameof(_options.EmbeddingDim));
-        VerifyEqual(reader.ReadInt32(),  _options.NumLayers,      nameof(_options.NumLayers));
-        VerifyEqual(reader.ReadInt32(),  _options.NumHeads,       nameof(_options.NumHeads));
-        VerifyEqual(reader.ReadInt32(),  _options.FeedForwardDim, nameof(_options.FeedForwardDim));
-        VerifyEqual(reader.ReadDouble(), _options.DropoutRate,    nameof(_options.DropoutRate));
-    }
+
 
     private static void VerifyEqual<TValue>(TValue persisted, TValue current, string name)
         where TValue : IEquatable<TValue>
diff --git a/src/Audio/Fingerprinting/CLAPModel.cs b/src/Audio/Fingerprinting/CLAPModel.cs
index 0fb949832e..9d667612e6 100644
--- a/src/Audio/Fingerprinting/CLAPModel.cs
+++ b/src/Audio/Fingerprinting/CLAPModel.cs
@@ -68,17 +68,6 @@ namespace AiDotNet.Audio.Fingerprinting;
 public partial class CLAPModel<T> : AudioNeuralNetworkBase<T>, IAudioFingerprinter<T>
 {
 
-    // TextEncoderLayers is yielded by AudioNeuralNetworkBase.GetExtraTrainableLayers for every audio
-    // model that owns a text tower, so this override restated the base. Removed under AIDN082.
-
-    /// <inheritdoc />
-    /// <remarks>The learned logit scale (CLIP's temperature), a single value the contrastive
-    /// loss trains alongside the towers. The hand-written count added it as a bare "+ 1" and
-    /// the vector appended _logTemperature[0]; it is a one-element tensor, so the base fold
-    /// contributes the same single scalar in the same position.</remarks>
-    protected override IEnumerable<Tensor<T>> GetExtraTrainableTensors()
-        => new[] { _logTemperature };
-
     /// <inheritdoc />
     /// <remarks>
     /// Measured: <c>PredictCore</c> delegates to <c>EncodeAudio</c>, which folds the AUDIO stack
@@ -102,6 +91,7 @@ protected override IEnumerable<Tensor<T>> GetExtraTrainableTensors()
     // Trainable temperature parameter (stored in log space). Gradients flow
     // through the tape via Engine ops; the optimizer updates this alongside
     // the rest of the network.
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _logTemperature = null!;
 
     // Cached Hann window for the STFT preprocessing step. Built once on the
@@ -736,28 +726,7 @@ private void ThrowIfDisposed()
     // UpdateParameters restated a fold the base now derives from generated component registration.
     // Removed under AIDN082.
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.NumMelBands);
-        writer.Write(_options.StftWindowSize);
-        writer.Write(_options.HopLength);
-        writer.Write(_options.AudioPatchSize);
-        writer.Write(_options.AudioHiddenDim);
-        writer.Write(_options.AudioEncoderLayers);
-        writer.Write(_options.AudioEncoderHeads);
-        writer.Write(_options.SwinWindowSize);
-        writer.Write(_options.VocabSize);
-        writer.Write(_options.MaxTextLength);
-        writer.Write(_options.TextHiddenDim);
-        writer.Write(_options.TextEncoderLayers);
-        writer.Write(_options.TextEncoderHeads);
-        writer.Write(_options.ProjectionDim);
-        writer.Write(_options.InitialTemperature);
-        writer.Write(_options.DropoutRate);
-        writer.Write(Convert.ToDouble(_logTemperature[0]));
-    }
+
 
     /// <inheritdoc/>
     /// <remarks>
@@ -767,30 +736,7 @@ protected override void SerializeNetworkSpecificData(BinaryWriter writer)
     /// produce wrong-shape weight loads. Throwing with the offending field
     /// surfaces the issue immediately.
     /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        bool useNativeMode = reader.ReadBoolean();
-        VerifyEqual(reader.ReadInt32(),    _options.SampleRate,         nameof(_options.SampleRate));
-        VerifyEqual(reader.ReadInt32(),    _options.NumMelBands,        nameof(_options.NumMelBands));
-        VerifyEqual(reader.ReadInt32(),    _options.StftWindowSize,     nameof(_options.StftWindowSize));
-        VerifyEqual(reader.ReadInt32(),    _options.HopLength,          nameof(_options.HopLength));
-        VerifyEqual(reader.ReadInt32(),    _options.AudioPatchSize,     nameof(_options.AudioPatchSize));
-        VerifyEqual(reader.ReadInt32(),    _options.AudioHiddenDim,     nameof(_options.AudioHiddenDim));
-        VerifyEqual(reader.ReadInt32(),    _options.AudioEncoderLayers, nameof(_options.AudioEncoderLayers));
-        VerifyEqual(reader.ReadInt32(),    _options.AudioEncoderHeads,  nameof(_options.AudioEncoderHeads));
-        VerifyEqual(reader.ReadInt32(),    _options.SwinWindowSize,     nameof(_options.SwinWindowSize));
-        VerifyEqual(reader.ReadInt32(),    _options.VocabSize,          nameof(_options.VocabSize));
-        VerifyEqual(reader.ReadInt32(),    _options.MaxTextLength,      nameof(_options.MaxTextLength));
-        VerifyEqual(reader.ReadInt32(),    _options.TextHiddenDim,      nameof(_options.TextHiddenDim));
-        VerifyEqual(reader.ReadInt32(),    _options.TextEncoderLayers,  nameof(_options.TextEncoderLayers));
-        VerifyEqual(reader.ReadInt32(),    _options.TextEncoderHeads,   nameof(_options.TextEncoderHeads));
-        VerifyEqual(reader.ReadInt32(),    _options.ProjectionDim,      nameof(_options.ProjectionDim));
-        VerifyEqual(reader.ReadDouble(),   _options.InitialTemperature, nameof(_options.InitialTemperature));
-        VerifyEqual(reader.ReadDouble(),   _options.DropoutRate,        nameof(_options.DropoutRate));
-
-        double logTau = reader.ReadDouble();
-        _logTemperature[0] = NumOps.FromDouble(logTau);
-    }
+
 
     private static void VerifyEqual<TValue>(TValue persisted, TValue current, string name)
         where TValue : IEquatable<TValue>
@@ -801,12 +747,6 @@ private static void VerifyEqual<TValue>(TValue persisted, TValue current, string
                 "Reconstruct CLAPModel with matching CLAPModelOptions before loading this checkpoint.");
     }
 
-    /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() =>
-        _useNativeMode
-            ? new CLAPModel<T>(Architecture, new CLAPModelOptions(_options))
-            : new CLAPModel<T>(Architecture, _audioEncoderPath!, _textEncoderPath, new CLAPModelOptions(_options));
-
     /// <inheritdoc/>
     public override ModelMetadata<T> GetModelMetadata()
     {
diff --git a/src/Audio/Fingerprinting/ConformerFP.cs b/src/Audio/Fingerprinting/ConformerFP.cs
index 0343e705e8..0df8afea5e 100644
--- a/src/Audio/Fingerprinting/ConformerFP.cs
+++ b/src/Audio/Fingerprinting/ConformerFP.cs
@@ -45,7 +45,7 @@ namespace AiDotNet.Audio.Fingerprinting;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Conformer: Convolution-augmented Transformer for Speech Recognition", "https://arxiv.org/abs/2005.08100", Year = 2020, Authors = "Anmol Gulati, James Qin, Chung-Cheng Chiu, Niki Parmar, Yu Zhang, Jiahui Yu, Wei Han, Shibo Wang, Zhengdong Zhang, Yonghui Wu, Ruoming Pang")]
-public class ConformerFP<T> : AudioNeuralNetworkBase<T>, IAudioFingerprinter<T>
+public partial class ConformerFP<T> : AudioNeuralNetworkBase<T>, IAudioFingerprinter<T>
 {
     /// <inheritdoc />
     /// <remarks>
@@ -278,36 +278,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty);
-        w.Write(_options.SampleRate); w.Write(_options.NumMels); w.Write(_options.FftSize);
-        w.Write(_options.HopLength); w.Write(_options.SegmentDurationSec);
-        w.Write(_options.EmbeddingDim); w.Write(_options.HiddenDim);
-        w.Write(_options.NumLayers); w.Write(_options.NumAttentionHeads);
-        w.Write(_options.FeedForwardDim); w.Write(_options.ConvKernelSize);
-        w.Write(_options.Temperature); w.Write(_options.DropoutRate);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.SampleRate = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.FftSize = r.ReadInt32();
-        _options.HopLength = r.ReadInt32(); _options.SegmentDurationSec = r.ReadDouble();
-        _options.EmbeddingDim = r.ReadInt32(); _options.HiddenDim = r.ReadInt32();
-        _options.NumLayers = r.ReadInt32(); _options.NumAttentionHeads = r.ReadInt32();
-        _options.FeedForwardDim = r.ReadInt32(); _options.ConvKernelSize = r.ReadInt32();
-        _options.Temperature = r.ReadDouble(); _options.DropoutRate = r.ReadDouble();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions);
-        _melSpectrogram = new MelSpectrogram<T>(_options.SampleRate, _options.NumMels, _options.FftSize, _options.HopLength);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new ConformerFP<T>(Architecture, mp, _options);
-        return new ConformerFP<T>(Architecture, _options);
-    }
+
 
     #endregion
 
diff --git a/src/Audio/Fingerprinting/GraFPrint.cs b/src/Audio/Fingerprinting/GraFPrint.cs
index 71adf31b75..a03ef7691b 100644
--- a/src/Audio/Fingerprinting/GraFPrint.cs
+++ b/src/Audio/Fingerprinting/GraFPrint.cs
@@ -45,7 +45,7 @@ namespace AiDotNet.Audio.Fingerprinting;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("GraFPrint: A GNN-Based Approach for Audio Identification", "https://arxiv.org/abs/2410.10994", Year = 2025, Authors = "Aditya Bhattacharjee, Shubhr Singh, Emmanouil Benetos")]
-internal class GraFPrint<T> : AudioNeuralNetworkBase<T>, IAudioFingerprinter<T>
+internal partial class GraFPrint<T> : AudioNeuralNetworkBase<T>, IAudioFingerprinter<T>
 {
     #region Fields
 
@@ -465,28 +465,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty);
-        w.Write(_options.SampleRate); w.Write(_options.NumMels); w.Write(_options.FftSize);
-        w.Write(_options.HopLength); w.Write(_options.SegmentDurationSec);
-        w.Write(_options.EmbeddingDim); w.Write(_options.GnnHiddenDim);
-        w.Write(_options.NumGnnLayers); w.Write(_options.NumAttentionHeads);
-        w.Write(_options.KNeighbors); w.Write(_options.Temperature); w.Write(_options.DropoutRate);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.SampleRate = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.FftSize = r.ReadInt32();
-        _options.HopLength = r.ReadInt32(); _options.SegmentDurationSec = r.ReadDouble();
-        _options.EmbeddingDim = r.ReadInt32(); _options.GnnHiddenDim = r.ReadInt32();
-        _options.NumGnnLayers = r.ReadInt32(); _options.NumAttentionHeads = r.ReadInt32();
-        _options.KNeighbors = r.ReadInt32(); _options.Temperature = r.ReadDouble(); _options.DropoutRate = r.ReadDouble();
-        NormalizeEmbeddingDimFromArchitecture();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions);
-        _melSpectrogram = new MelSpectrogram<T>(_options.SampleRate, _options.NumMels, _options.FftSize, _options.HopLength);
-    }
+
+
 
     private void NormalizeEmbeddingDimFromArchitecture()
     {
@@ -497,13 +478,6 @@ private void NormalizeEmbeddingDimFromArchitecture()
         _options.EmbeddingDim = embeddingDim;
     }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new GraFPrint<T>(Architecture, mp, _options);
-        return new GraFPrint<T>(Architecture, _options);
-    }
-
     #endregion
 
     #region Disposal
diff --git a/src/Audio/Fingerprinting/NeuralFP.cs b/src/Audio/Fingerprinting/NeuralFP.cs
index fa95a7b4ca..45b1673586 100644
--- a/src/Audio/Fingerprinting/NeuralFP.cs
+++ b/src/Audio/Fingerprinting/NeuralFP.cs
@@ -45,7 +45,7 @@ namespace AiDotNet.Audio.Fingerprinting;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Neural Audio Fingerprint for High-Specific Audio Retrieval Based on Contrastive Learning", "https://arxiv.org/abs/2010.11910", Year = 2021, Authors = "Sungkyun Chang, Donmoon Lee, Jeongsoo Park, Hyungui Lim, Kyogu Lee, Karam Ko, Yoonchang Han")]
-internal class NeuralFP<T> : AudioNeuralNetworkBase<T>, IAudioFingerprinter<T>
+internal partial class NeuralFP<T> : AudioNeuralNetworkBase<T>, IAudioFingerprinter<T>
 {
     #region Fields
 
@@ -310,33 +310,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty);
-        w.Write(_options.SampleRate); w.Write(_options.NumMels); w.Write(_options.FftSize);
-        w.Write(_options.HopLength); w.Write(_options.SegmentDurationSec);
-        w.Write(_options.EmbeddingDim); w.Write(_options.NumConvBlocks);
-        w.Write(_options.BaseFilters); w.Write(_options.Temperature); w.Write(_options.DropoutRate);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.SampleRate = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.FftSize = r.ReadInt32();
-        _options.HopLength = r.ReadInt32(); _options.SegmentDurationSec = r.ReadDouble();
-        _options.EmbeddingDim = r.ReadInt32(); _options.NumConvBlocks = r.ReadInt32();
-        _options.BaseFilters = r.ReadInt32(); _options.Temperature = r.ReadDouble(); _options.DropoutRate = r.ReadDouble();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions);
-        _melSpectrogram = new MelSpectrogram<T>(_options.SampleRate, _options.NumMels,
-            _options.FftSize, _options.HopLength);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new NeuralFP<T>(Architecture, mp, _options);
-        return new NeuralFP<T>(Architecture, _options);
-    }
+
 
     #endregion
 
diff --git a/src/Audio/Fingerprinting/PANNsModel.cs b/src/Audio/Fingerprinting/PANNsModel.cs
index a176b6c8e6..ac9fed6f6c 100644
--- a/src/Audio/Fingerprinting/PANNsModel.cs
+++ b/src/Audio/Fingerprinting/PANNsModel.cs
@@ -45,7 +45,7 @@ namespace AiDotNet.Audio.Fingerprinting;
     "https://arxiv.org/abs/1912.10211",
     Year = 2020,
     Authors = "Qiuqiang Kong, Yin Cao, Turab Iqbal, Yuxuan Wang, Wenwu Wang, Mark D. Plumbley")]
-public class PANNsModel<T> : AudioNeuralNetworkBase<T>, IAudioFingerprinter<T>
+public partial class PANNsModel<T> : AudioNeuralNetworkBase<T>, IAudioFingerprinter<T>
 {
     /// <inheritdoc />
     /// <remarks>
@@ -603,16 +603,6 @@ protected override void Dispose(bool disposing)
         base.Dispose(disposing);
     }
 
-    /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() =>
-        _useNativeMode
-            ? new PANNsModel<T>(Architecture, new PANNsModelOptions(_options), lossFunction: LossFunction)
-            // ONNX-backed instance: reuse the loaded model path so the
-            // clone preserves its execution mode. Without this, Clone() of
-            // an ONNX-mode PANNs silently downgrades to native and
-            // changes inference behaviour.
-            : new PANNsModel<T>(Architecture, _modelPath!, new PANNsModelOptions(_options));
-
     /// <inheritdoc/>
     public override ModelMetadata<T> GetModelMetadata() =>
         new ModelMetadata<T>
@@ -637,56 +627,10 @@ public override ModelMetadata<T> GetModelMetadata() =>
         };
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.StftWindowSize);
-        writer.Write(_options.HopLength);
-        writer.Write(_options.NumMelBands);
-        writer.Write(_options.NumClasses);
-        writer.Write(_options.EmbeddingDim);
-        writer.Write(_options.DropoutRate);
-        writer.Write(2); // format version for fields appended after the legacy payload
-        writer.Write(_options.BaseChannels);
-        writer.Write(_options.NumBlocks);
-        writer.Write(_options.MinFrequency);
-        writer.Write(_options.MaxFrequency);
-        writer.Write(_options.HeadDropoutRate);
-    }
+
 
     /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        bool useNativeMode = reader.ReadBoolean();
-        if (useNativeMode != _useNativeMode)
-            throw new InvalidOperationException(
-                $"Persisted PANNs mode (native={useNativeMode}) does not match this " +
-                $"instance's mode (native={_useNativeMode}). Reconstruct PANNsModel " +
-                $"with the matching constructor before loading this checkpoint.");
-        VerifyEqual(reader.ReadInt32(),  _options.SampleRate,     nameof(_options.SampleRate));
-        VerifyEqual(reader.ReadInt32(),  _options.StftWindowSize, nameof(_options.StftWindowSize));
-        VerifyEqual(reader.ReadInt32(),  _options.HopLength,      nameof(_options.HopLength));
-        VerifyEqual(reader.ReadInt32(),  _options.NumMelBands,    nameof(_options.NumMelBands));
-        VerifyEqual(reader.ReadInt32(),  _options.NumClasses,     nameof(_options.NumClasses));
-        VerifyEqual(reader.ReadInt32(),  _options.EmbeddingDim,   nameof(_options.EmbeddingDim));
-        VerifyEqual(reader.ReadDouble(), _options.DropoutRate,    nameof(_options.DropoutRate));
-        if (reader.BaseStream.Position < reader.BaseStream.Length)
-        {
-            int version = reader.ReadInt32();
-            if (version >= 1)
-            {
-                VerifyEqual(reader.ReadInt32(), _options.BaseChannels, nameof(_options.BaseChannels));
-                VerifyEqual(reader.ReadInt32(), _options.NumBlocks, nameof(_options.NumBlocks));
-                if (version >= 2)
-                {
-                    VerifyEqual(reader.ReadDouble(), _options.MinFrequency, nameof(_options.MinFrequency));
-                    VerifyEqual(reader.ReadDouble(), _options.MaxFrequency, nameof(_options.MaxFrequency));
-                    VerifyEqual(reader.ReadDouble(), _options.HeadDropoutRate, nameof(_options.HeadDropoutRate));
-                }
-            }
-        }
-    }
+
 
     private static void VerifyEqual<TValue>(TValue persisted, TValue current, string name)
         where TValue : IEquatable<TValue>
diff --git a/src/Audio/Fingerprinting/PeakNetFP.cs b/src/Audio/Fingerprinting/PeakNetFP.cs
index 9a86a2b55f..62d71f03e3 100644
--- a/src/Audio/Fingerprinting/PeakNetFP.cs
+++ b/src/Audio/Fingerprinting/PeakNetFP.cs
@@ -43,7 +43,7 @@ namespace AiDotNet.Audio.Fingerprinting;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("An Industrial-Strength Audio Search Algorithm", "https://www.ee.columbia.edu/~dpwe/papers/Wang03-shazam.pdf", Year = 2003, Authors = "Avery Li-Chun Wang")]
-public class PeakNetFP<T> : AudioNeuralNetworkBase<T>, IAudioFingerprinter<T>
+public partial class PeakNetFP<T> : AudioNeuralNetworkBase<T>, IAudioFingerprinter<T>
 {
     /// <inheritdoc />
     /// <remarks>
@@ -271,34 +271,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty);
-        w.Write(_options.SampleRate); w.Write(_options.NumMels); w.Write(_options.FftSize);
-        w.Write(_options.HopLength); w.Write(_options.SegmentDurationSec);
-        w.Write(_options.EmbeddingDim); w.Write(_options.NumEncoderBlocks);
-        w.Write(_options.BaseFilters); w.Write(_options.PeaksPerFrame);
-        w.Write(_options.Temperature); w.Write(_options.DropoutRate);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.SampleRate = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.FftSize = r.ReadInt32();
-        _options.HopLength = r.ReadInt32(); _options.SegmentDurationSec = r.ReadDouble();
-        _options.EmbeddingDim = r.ReadInt32(); _options.NumEncoderBlocks = r.ReadInt32();
-        _options.BaseFilters = r.ReadInt32(); _options.PeaksPerFrame = r.ReadInt32();
-        _options.Temperature = r.ReadDouble(); _options.DropoutRate = r.ReadDouble();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions);
-        _melSpectrogram = new MelSpectrogram<T>(_options.SampleRate, _options.NumMels, _options.FftSize, _options.HopLength);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new PeakNetFP<T>(Architecture, mp, _options);
-        return new PeakNetFP<T>(Architecture, _options);
-    }
+
 
     #endregion
 
diff --git a/src/Audio/Foundations/Data2Vec2.cs b/src/Audio/Foundations/Data2Vec2.cs
index 779c864271..d4b08f710e 100644
--- a/src/Audio/Foundations/Data2Vec2.cs
+++ b/src/Audio/Foundations/Data2Vec2.cs
@@ -43,7 +43,7 @@ namespace AiDotNet.Audio.Foundations;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("data2vec 2.0: Highly Efficient Self-Supervised Learning for Vision, Speech and Text", "https://arxiv.org/abs/2212.07525", Year = 2023, Authors = "Alexei Baevski, Arun Babu, Wei-Ning Hsu, Michael Auli")]
-public class Data2Vec2<T> : AudioNeuralNetworkBase<T>, IAudioFoundationModel<T>
+public partial class Data2Vec2<T> : AudioNeuralNetworkBase<T>, IAudioFoundationModel<T>
 {
     /// <inheritdoc />
     /// <remarks>
@@ -285,35 +285,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty);
-        w.Write(_options.SampleRate); w.Write(_options.HiddenDim);
-        w.Write(_options.NumLayers); w.Write(_options.NumHeads);
-        w.Write(_options.FeedForwardDim); w.Write(_options.Variant);
-        w.Write(_options.EMADecay); w.Write(_options.MaskProbability);
-        w.Write(_options.MaskSpanLength); w.Write(_options.TopKLayers);
-        w.Write(_options.DropoutRate);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.SampleRate = r.ReadInt32(); _options.HiddenDim = r.ReadInt32();
-        _options.NumLayers = r.ReadInt32(); _options.NumHeads = r.ReadInt32();
-        _options.FeedForwardDim = r.ReadInt32(); _options.Variant = r.ReadString();
-        _options.EMADecay = r.ReadDouble(); _options.MaskProbability = r.ReadDouble();
-        _options.MaskSpanLength = r.ReadInt32(); _options.TopKLayers = r.ReadInt32();
-        _options.DropoutRate = r.ReadDouble();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new Data2Vec2<T>(Architecture, mp, _options);
-        return new Data2Vec2<T>(Architecture, _options);
-    }
+
 
     #endregion
 
diff --git a/src/Audio/Foundations/HuBERT.cs b/src/Audio/Foundations/HuBERT.cs
index d5f3c2615b..c2217a97d8 100644
--- a/src/Audio/Foundations/HuBERT.cs
+++ b/src/Audio/Foundations/HuBERT.cs
@@ -42,7 +42,7 @@ namespace AiDotNet.Audio.Foundations;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("HuBERT: Self-Supervised Speech Representation Learning by Masked Prediction of Hidden Units", "https://arxiv.org/abs/2106.07447", Year = 2021, Authors = "Wei-Ning Hsu, Benjamin Bolte, Yao-Hung Hubert Tsai, Kushal Lakhotia, Ruslan Salakhutdinov, Abdelrahman Mohamed")]
-public class HuBERT<T> : AudioNeuralNetworkBase<T>, IAudioFoundationModel<T>
+public partial class HuBERT<T> : AudioNeuralNetworkBase<T>, IAudioFoundationModel<T>
 {
     /// <inheritdoc />
     /// <remarks>
@@ -289,31 +289,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty);
-        w.Write(_options.SampleRate); w.Write(_options.Variant);
-        w.Write(_options.HiddenDim); w.Write(_options.NumLayers);
-        w.Write(_options.NumAttentionHeads); w.Write(_options.FeedForwardDim);
-        w.Write(_options.FeatureEncoderDim); w.Write(_options.DropoutRate);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.SampleRate = r.ReadInt32(); _options.Variant = r.ReadString();
-        _options.HiddenDim = r.ReadInt32(); _options.NumLayers = r.ReadInt32();
-        _options.NumAttentionHeads = r.ReadInt32(); _options.FeedForwardDim = r.ReadInt32();
-        _options.FeatureEncoderDim = r.ReadInt32(); _options.DropoutRate = r.ReadDouble();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new HuBERT<T>(Architecture, mp, _options);
-        return new HuBERT<T>(Architecture, _options);
-    }
+
 
     #endregion
 
diff --git a/src/Audio/Foundations/MERT.cs b/src/Audio/Foundations/MERT.cs
index ec3b80a6b8..ffa426a0a2 100644
--- a/src/Audio/Foundations/MERT.cs
+++ b/src/Audio/Foundations/MERT.cs
@@ -44,7 +44,7 @@ namespace AiDotNet.Audio.Foundations;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("MERT: Acoustic Music Understanding Model with Large-Scale Self-supervised Training", "https://doi.org/10.48550/arXiv.2306.00107", Year = 2024, Authors = "Yizhi Li, Ruibin Yuan, Ge Zhang, Yinghao Ma, Xingran Chen, Hanzhi Yin, Chenghua Lin, Anton Ragni, Emmanouil Benetos, Norbert Gyenge, Roger Sherr, Jie Fu")]
-public class MERT<T> : AudioNeuralNetworkBase<T>, IAudioFoundationModel<T>
+public partial class MERT<T> : AudioNeuralNetworkBase<T>, IAudioFoundationModel<T>
 {
     /// <inheritdoc />
     /// <remarks>
@@ -288,37 +288,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty);
-        w.Write(_options.SampleRate); w.Write(_options.HiddenDim);
-        w.Write(_options.NumLayers); w.Write(_options.NumHeads);
-        w.Write(_options.FeedForwardDim); w.Write(_options.Variant);
-        w.Write(_options.CQTBins); w.Write(_options.NumCodebooks);
-        w.Write(_options.CodebookSize); w.Write(_options.NumClusters);
-        w.Write(_options.MaskProbability); w.Write(_options.MaskSpanLength);
-        w.Write(_options.DropoutRate);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.SampleRate = r.ReadInt32(); _options.HiddenDim = r.ReadInt32();
-        _options.NumLayers = r.ReadInt32(); _options.NumHeads = r.ReadInt32();
-        _options.FeedForwardDim = r.ReadInt32(); _options.Variant = r.ReadString();
-        _options.CQTBins = r.ReadInt32(); _options.NumCodebooks = r.ReadInt32();
-        _options.CodebookSize = r.ReadInt32(); _options.NumClusters = r.ReadInt32();
-        _options.MaskProbability = r.ReadDouble(); _options.MaskSpanLength = r.ReadInt32();
-        _options.DropoutRate = r.ReadDouble();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new MERT<T>(Architecture, mp, _options);
-        return new MERT<T>(Architecture, _options);
-    }
+
 
     #endregion
 
diff --git a/src/Audio/Foundations/Wav2Vec2.cs b/src/Audio/Foundations/Wav2Vec2.cs
index f063c5fadb..eb1d5efa6b 100644
--- a/src/Audio/Foundations/Wav2Vec2.cs
+++ b/src/Audio/Foundations/Wav2Vec2.cs
@@ -46,7 +46,7 @@ namespace AiDotNet.Audio.Foundations;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("wav2vec 2.0: A Framework for Self-Supervised Learning of Speech Representations", "https://arxiv.org/abs/2006.11477", Year = 2020, Authors = "Alexei Baevski, Yuhao Zhou, Abdelrahman Mohamed, Michael Auli")]
-public class Wav2Vec2<T> : AudioNeuralNetworkBase<T>, IAudioFoundationModel<T>
+public partial class Wav2Vec2<T> : AudioNeuralNetworkBase<T>, IAudioFoundationModel<T>
 {
     /// <inheritdoc />
     /// <remarks>
@@ -248,33 +248,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty);
-        w.Write(_options.SampleRate); w.Write(_options.Variant);
-        w.Write(_options.HiddenDim); w.Write(_options.NumLayers);
-        w.Write(_options.NumAttentionHeads); w.Write(_options.FeedForwardDim);
-        w.Write(_options.FeatureEncoderDim); w.Write(_options.NumQuantizationGroups);
-        w.Write(_options.QuantizationCodebookSize); w.Write(_options.DropoutRate);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.SampleRate = r.ReadInt32(); _options.Variant = r.ReadString();
-        _options.HiddenDim = r.ReadInt32(); _options.NumLayers = r.ReadInt32();
-        _options.NumAttentionHeads = r.ReadInt32(); _options.FeedForwardDim = r.ReadInt32();
-        _options.FeatureEncoderDim = r.ReadInt32(); _options.NumQuantizationGroups = r.ReadInt32();
-        _options.QuantizationCodebookSize = r.ReadInt32(); _options.DropoutRate = r.ReadDouble();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new Wav2Vec2<T>(Architecture, mp, _options);
-        return new Wav2Vec2<T>(Architecture, _options);
-    }
+
 
     #endregion
 
diff --git a/src/Audio/Foundations/WavLM.cs b/src/Audio/Foundations/WavLM.cs
index 4fd42b7f99..f4d9445823 100644
--- a/src/Audio/Foundations/WavLM.cs
+++ b/src/Audio/Foundations/WavLM.cs
@@ -43,7 +43,7 @@ namespace AiDotNet.Audio.Foundations;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("WavLM: Large-Scale Self-Supervised Pre-Training for Full Stack Speech Processing", "https://arxiv.org/abs/2110.13900", Year = 2022, Authors = "Sanyuan Chen, Chengyi Wang, Zhengyang Chen, Yu Wu, Shujie Liu, Zhuo Chen, Jinyu Li, Naoyuki Kanda, Takuya Yoshioka, Xiong Xiao, Jian Wu, Long Zhou, Shuo Ren, Yanmin Qian, Yao Qian, Jian Wu, Michael Zeng, Xiangzhan Yu, Furu Wei")]
-public class WavLM<T> : AudioNeuralNetworkBase<T>, IAudioFoundationModel<T>
+public partial class WavLM<T> : AudioNeuralNetworkBase<T>, IAudioFoundationModel<T>
 {
     /// <inheritdoc />
     /// <remarks>
@@ -233,34 +233,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty);
-        w.Write(_options.SampleRate); w.Write(_options.Variant);
-        w.Write(_options.HiddenDim); w.Write(_options.NumLayers);
-        w.Write(_options.NumAttentionHeads); w.Write(_options.FeedForwardDim);
-        w.Write(_options.FeatureEncoderDim); w.Write(_options.UseGatedRelativePositionBias);
-        w.Write(_options.DropoutRate);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.SampleRate = r.ReadInt32(); _options.Variant = r.ReadString();
-        _options.HiddenDim = r.ReadInt32(); _options.NumLayers = r.ReadInt32();
-        _options.NumAttentionHeads = r.ReadInt32(); _options.FeedForwardDim = r.ReadInt32();
-        _options.FeatureEncoderDim = r.ReadInt32(); _options.UseGatedRelativePositionBias = r.ReadBoolean();
-        _options.DropoutRate = r.ReadDouble();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions);
-        base.SampleRate = _options.SampleRate;
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new WavLM<T>(Architecture, mp, _options);
-        return new WavLM<T>(Architecture, _options);
-    }
+
 
     #endregion
 
diff --git a/src/Audio/Generation/ACEStep.cs b/src/Audio/Generation/ACEStep.cs
index 7076e760ec..356869d245 100644
--- a/src/Audio/Generation/ACEStep.cs
+++ b/src/Audio/Generation/ACEStep.cs
@@ -42,7 +42,7 @@ namespace AiDotNet.Audio.Generation;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(string), typeof(Tensor<>))]
 [ResearchPaper("ACE-Step: A Step Towards Music Generation Foundation Model", "https://doi.org/10.48550/arXiv.2501.09263", Year = 2024, Authors = "Yushen Chen, Liwei Deng, Ziyang Ma, Kehan Chen, Yongqi Wang, Jianwei Yu, Dong Yu")]
-public class ACEStep<T> : AudioNeuralNetworkBase<T>, IAudioGenerator<T>
+public partial class ACEStep<T> : AudioNeuralNetworkBase<T>, IAudioGenerator<T>
 {
     /// <inheritdoc />
     /// <remarks>
@@ -257,32 +257,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty);
-        w.Write(_options.SampleRate); w.Write(_options.NumChannels);
-        w.Write(_options.LatentDim); w.Write(_options.UNetDim);
-        w.Write(_options.NumUNetLayers); w.Write(_options.NumSteps);
-        w.Write(_options.TextEncoderDim); w.Write(_options.DropoutRate);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.SampleRate = r.ReadInt32(); _options.NumChannels = r.ReadInt32();
-        _options.LatentDim = r.ReadInt32(); _options.UNetDim = r.ReadInt32();
-        _options.NumUNetLayers = r.ReadInt32(); _options.NumSteps = r.ReadInt32();
-        _options.TextEncoderDim = r.ReadInt32(); _options.DropoutRate = r.ReadDouble();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new ACEStep<T>(Architecture, mp, _options);
-        return new ACEStep<T>(Architecture, _options);
-    }
+
 
     #endregion
 
diff --git a/src/Audio/Generation/AudioLM.cs b/src/Audio/Generation/AudioLM.cs
index 9ac749ad22..33e21abd54 100644
--- a/src/Audio/Generation/AudioLM.cs
+++ b/src/Audio/Generation/AudioLM.cs
@@ -41,7 +41,7 @@ namespace AiDotNet.Audio.Generation;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("AudioLM: A Language Modeling Approach to Audio Generation", "https://arxiv.org/abs/2209.03143", Year = 2023, Authors = "Zalán Borsos, Raphaël Marinier, Damien Vincent, Eugene Kharitonov, Olivier Pietquin, Matt Sharifi, Dominik Roblek, Olivier Teboul, David Grangier, Marco Tagliasacchi, Neil Zeghidour")]
-public class AudioLM<T> : AudioNeuralNetworkBase<T>, IAudioGenerator<T>
+public partial class AudioLM<T> : AudioNeuralNetworkBase<T>, IAudioGenerator<T>
 {
     /// <inheritdoc />
     /// <remarks>
@@ -262,41 +262,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty);
-        w.Write(_options.SampleRate); w.Write(_options.MaxDurationSeconds);
-        w.Write(_options.SemanticVocabSize); w.Write(_options.SemanticDim);
-        w.Write(_options.NumSemanticLayers); w.Write(_options.NumSemanticHeads);
-        w.Write(_options.SemanticFrameRate); w.Write(_options.CoarseCodebookSize);
-        w.Write(_options.NumCoarseQuantizers); w.Write(_options.CoarseDim);
-        w.Write(_options.NumCoarseLayers); w.Write(_options.FineCodebookSize);
-        w.Write(_options.NumFineQuantizers); w.Write(_options.FineDim);
-        w.Write(_options.NumFineLayers); w.Write(_options.Temperature);
-        w.Write(_options.TopK); w.Write(_options.DropoutRate);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.SampleRate = r.ReadInt32(); _options.MaxDurationSeconds = r.ReadDouble();
-        _options.SemanticVocabSize = r.ReadInt32(); _options.SemanticDim = r.ReadInt32();
-        _options.NumSemanticLayers = r.ReadInt32(); _options.NumSemanticHeads = r.ReadInt32();
-        _options.SemanticFrameRate = r.ReadInt32(); _options.CoarseCodebookSize = r.ReadInt32();
-        _options.NumCoarseQuantizers = r.ReadInt32(); _options.CoarseDim = r.ReadInt32();
-        _options.NumCoarseLayers = r.ReadInt32(); _options.FineCodebookSize = r.ReadInt32();
-        _options.NumFineQuantizers = r.ReadInt32(); _options.FineDim = r.ReadInt32();
-        _options.NumFineLayers = r.ReadInt32(); _options.Temperature = r.ReadDouble();
-        _options.TopK = r.ReadInt32(); _options.DropoutRate = r.ReadDouble();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new AudioLM<T>(Architecture, mp, _options);
-        return new AudioLM<T>(Architecture, _options);
-    }
+
 
     #endregion
 
diff --git a/src/Audio/Generation/EnCodec.cs b/src/Audio/Generation/EnCodec.cs
index 7ecba62a95..473f0fe13d 100644
--- a/src/Audio/Generation/EnCodec.cs
+++ b/src/Audio/Generation/EnCodec.cs
@@ -42,7 +42,7 @@ namespace AiDotNet.Audio.Generation;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("High Fidelity Neural Audio Compression", "https://arxiv.org/abs/2210.13438", Year = 2022, Authors = "Alexandre Defossez, Jade Copet, Gabriel Synnaeve, Yossi Adi")]
-public class EnCodec<T> : AudioNeuralNetworkBase<T>, IAudioCodec<T>
+public partial class EnCodec<T> : AudioNeuralNetworkBase<T>, IAudioCodec<T>
 {
     /// <inheritdoc />
     /// <remarks>
@@ -275,34 +275,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty);
-        w.Write(_options.SampleRate); w.Write(_options.Channels);
-        w.Write(_options.EncoderChannels.Length);
-        foreach (int ch in _options.EncoderChannels) w.Write(ch);
-        w.Write(_options.DownsampleRatios.Length);
-        foreach (int r in _options.DownsampleRatios) w.Write(r);
-        w.Write(_options.EncoderDim); w.Write(_options.NumQuantizers);
-        w.Write(_options.CodebookSize); w.Write(_options.CodebookDim);
-        w.Write(_options.TargetBandwidthKbps); w.Write(_options.DropoutRate);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.SampleRate = r.ReadInt32(); _options.Channels = r.ReadInt32();
-        int nch = r.ReadInt32(); _options.EncoderChannels = new int[nch];
-        for (int i = 0; i < nch; i++) _options.EncoderChannels[i] = r.ReadInt32();
-        int ndr = r.ReadInt32(); _options.DownsampleRatios = new int[ndr];
-        for (int i = 0; i < ndr; i++) _options.DownsampleRatios[i] = r.ReadInt32();
-        _options.EncoderDim = r.ReadInt32(); _options.NumQuantizers = r.ReadInt32();
-        _options.CodebookSize = r.ReadInt32(); _options.CodebookDim = r.ReadInt32();
-        _options.TargetBandwidthKbps = r.ReadDouble(); _options.DropoutRate = r.ReadDouble();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() => new EnCodec<T>(Architecture, _options);
+
 
     #endregion
 
diff --git a/src/Audio/Generation/FishSpeech.cs b/src/Audio/Generation/FishSpeech.cs
index 61f319830d..8dcbceefc5 100644
--- a/src/Audio/Generation/FishSpeech.cs
+++ b/src/Audio/Generation/FishSpeech.cs
@@ -44,7 +44,7 @@ namespace AiDotNet.Audio.Generation;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Fish Speech: Leveraging Large Language Models for Advanced Multilingual Text-to-Speech Synthesis", "https://arxiv.org/abs/2411.01156", Year = 2024, Authors = "Shijia Liao, Yuxuan Wang, Tianyu Li, Yifan Hu, Ruobing Xie")]
-public class FishSpeech<T> : AudioNeuralNetworkBase<T>, IAudioGenerator<T>
+public partial class FishSpeech<T> : AudioNeuralNetworkBase<T>, IAudioGenerator<T>
 {
     /// <inheritdoc />
     /// <remarks>
@@ -310,34 +310,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty);
-        w.Write(_options.SampleRate); w.Write(_options.MaxDurationSeconds);
-        w.Write(_options.SemanticDim); w.Write(_options.NumSemanticLayers);
-        w.Write(_options.NumSemanticHeads); w.Write(_options.VocoderDim);
-        w.Write(_options.NumVocoderLayers); w.Write(_options.CodebookSize);
-        w.Write(_options.NumGroups); w.Write(_options.TextVocabSize);
-        w.Write(_options.NumMels); w.Write(_options.Temperature);
-        w.Write(_options.TopP); w.Write(_options.RepetitionPenalty);
-        w.Write(_options.MinReferenceSeconds); w.Write(_options.DropoutRate);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.SampleRate = r.ReadInt32(); _options.MaxDurationSeconds = r.ReadDouble();
-        _options.SemanticDim = r.ReadInt32(); _options.NumSemanticLayers = r.ReadInt32();
-        _options.NumSemanticHeads = r.ReadInt32(); _options.VocoderDim = r.ReadInt32();
-        _options.NumVocoderLayers = r.ReadInt32(); _options.CodebookSize = r.ReadInt32();
-        _options.NumGroups = r.ReadInt32(); _options.TextVocabSize = r.ReadInt32();
-        _options.NumMels = r.ReadInt32(); _options.Temperature = r.ReadDouble();
-        _options.TopP = r.ReadDouble(); _options.RepetitionPenalty = r.ReadDouble();
-        _options.MinReferenceSeconds = r.ReadDouble(); _options.DropoutRate = r.ReadDouble();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() => new FishSpeech<T>(Architecture, _options);
+
 
     #endregion
 
diff --git a/src/Audio/Generation/SoundStream.cs b/src/Audio/Generation/SoundStream.cs
index 8ed1c618a9..0d9b8f497c 100644
--- a/src/Audio/Generation/SoundStream.cs
+++ b/src/Audio/Generation/SoundStream.cs
@@ -44,7 +44,7 @@ namespace AiDotNet.Audio.Generation;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("SoundStream: An End-to-End Neural Audio Codec", "https://arxiv.org/abs/2107.03312", Year = 2021, Authors = "Neil Zeghidour, Alejandro Luebs, Ahmed Omran, Jan Skoglund, Marco Tagliasacchi")]
-public class SoundStream<T> : AudioNeuralNetworkBase<T>, IAudioCodec<T>
+public partial class SoundStream<T> : AudioNeuralNetworkBase<T>, IAudioCodec<T>
 {
     /// <inheritdoc />
     /// <remarks>
@@ -275,36 +275,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty);
-        w.Write(_options.SampleRate); w.Write(_options.Channels);
-        w.Write(_options.EncoderChannels.Length);
-        foreach (int ch in _options.EncoderChannels) w.Write(ch);
-        w.Write(_options.DownsampleRatios.Length);
-        foreach (int r in _options.DownsampleRatios) w.Write(r);
-        w.Write(_options.EncoderDim); w.Write(_options.NumResBlocks);
-        w.Write(_options.NumQuantizers); w.Write(_options.CodebookSize);
-        w.Write(_options.CodebookDim); w.Write(_options.TargetBitrateKbps);
-        w.Write(_options.DropoutRate);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.SampleRate = r.ReadInt32(); _options.Channels = r.ReadInt32();
-        int nch = r.ReadInt32(); _options.EncoderChannels = new int[nch];
-        for (int i = 0; i < nch; i++) _options.EncoderChannels[i] = r.ReadInt32();
-        int ndr = r.ReadInt32(); _options.DownsampleRatios = new int[ndr];
-        for (int i = 0; i < ndr; i++) _options.DownsampleRatios[i] = r.ReadInt32();
-        _options.EncoderDim = r.ReadInt32(); _options.NumResBlocks = r.ReadInt32();
-        _options.NumQuantizers = r.ReadInt32(); _options.CodebookSize = r.ReadInt32();
-        _options.CodebookDim = r.ReadInt32(); _options.TargetBitrateKbps = r.ReadDouble();
-        _options.DropoutRate = r.ReadDouble();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() => new SoundStream<T>(Architecture, _options);
+
 
     #endregion
 
diff --git a/src/Audio/Generation/VALLE.cs b/src/Audio/Generation/VALLE.cs
index 9a1c5db2d4..b03c527b06 100644
--- a/src/Audio/Generation/VALLE.cs
+++ b/src/Audio/Generation/VALLE.cs
@@ -45,7 +45,7 @@ namespace AiDotNet.Audio.Generation;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Neural Codec Language Models are Zero-Shot Text to Speech Synthesizers", "https://arxiv.org/abs/2301.02111", Year = 2023, Authors = "Chengyi Wang, Sanyuan Chen, Yu Wu, Ziqiang Zhang, Long Zhou, Shujie Liu, Zhuo Chen, Yanqing Liu, Huaming Wang, Jinyu Li, Lei He, Sheng Zhao, Furu Wei")]
-public class VALLE<T> : AudioNeuralNetworkBase<T>, IAudioGenerator<T>
+public partial class VALLE<T> : AudioNeuralNetworkBase<T>, IAudioGenerator<T>
 {
     /// <inheritdoc />
     /// <remarks>
@@ -301,34 +301,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty);
-        w.Write(_options.SampleRate); w.Write(_options.MaxDurationSeconds);
-        w.Write(_options.ARHiddenDim); w.Write(_options.NumARLayers);
-        w.Write(_options.NumARHeads); w.Write(_options.NARHiddenDim);
-        w.Write(_options.NumNARLayers); w.Write(_options.NumNARHeads);
-        w.Write(_options.PhonemeVocabSize); w.Write(_options.CodebookSize);
-        w.Write(_options.NumCodebooks); w.Write(_options.Temperature);
-        w.Write(_options.TopP); w.Write(_options.MinEnrollmentSeconds);
-        w.Write(_options.DropoutRate);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.SampleRate = r.ReadInt32(); _options.MaxDurationSeconds = r.ReadDouble();
-        _options.ARHiddenDim = r.ReadInt32(); _options.NumARLayers = r.ReadInt32();
-        _options.NumARHeads = r.ReadInt32(); _options.NARHiddenDim = r.ReadInt32();
-        _options.NumNARLayers = r.ReadInt32(); _options.NumNARHeads = r.ReadInt32();
-        _options.PhonemeVocabSize = r.ReadInt32(); _options.CodebookSize = r.ReadInt32();
-        _options.NumCodebooks = r.ReadInt32(); _options.Temperature = r.ReadDouble();
-        _options.TopP = r.ReadDouble(); _options.MinEnrollmentSeconds = r.ReadDouble();
-        _options.DropoutRate = r.ReadDouble();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() => new VALLE<T>(Architecture, _options);
+
 
     #endregion
 
diff --git a/src/Audio/Generation/VoiceCraft.cs b/src/Audio/Generation/VoiceCraft.cs
index 171bc5ec09..bc0962959f 100644
--- a/src/Audio/Generation/VoiceCraft.cs
+++ b/src/Audio/Generation/VoiceCraft.cs
@@ -43,7 +43,7 @@ namespace AiDotNet.Audio.Generation;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("VoiceCraft: Zero-Shot Speech Editing and Text-to-Speech in the Wild", "https://arxiv.org/abs/2403.16973", Year = 2024, Authors = "Puyuan Peng, Po-Yao Huang, Daniel Li, Abdelrahman Mohamed, David Harwath")]
-public class VoiceCraft<T> : AudioNeuralNetworkBase<T>, IAudioGenerator<T>
+public partial class VoiceCraft<T> : AudioNeuralNetworkBase<T>, IAudioGenerator<T>
 {
     /// <inheritdoc />
     /// <remarks>
@@ -304,34 +304,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty);
-        w.Write(_options.SampleRate); w.Write(_options.MaxDurationSeconds);
-        w.Write(_options.HiddenDim); w.Write(_options.NumLayers);
-        w.Write(_options.NumHeads); w.Write(_options.CodebookSize);
-        w.Write(_options.NumQuantizers); w.Write(_options.CodecEmbeddingDim);
-        w.Write(_options.NumMels); w.Write(_options.EditContextSeconds);
-        w.Write(_options.MaskRatio); w.Write(_options.Temperature);
-        w.Write(_options.TopP); w.Write(_options.CodecFrameRate);
-        w.Write(_options.DropoutRate);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.SampleRate = r.ReadInt32(); _options.MaxDurationSeconds = r.ReadDouble();
-        _options.HiddenDim = r.ReadInt32(); _options.NumLayers = r.ReadInt32();
-        _options.NumHeads = r.ReadInt32(); _options.CodebookSize = r.ReadInt32();
-        _options.NumQuantizers = r.ReadInt32(); _options.CodecEmbeddingDim = r.ReadInt32();
-        _options.NumMels = r.ReadInt32(); _options.EditContextSeconds = r.ReadDouble();
-        _options.MaskRatio = r.ReadDouble(); _options.Temperature = r.ReadDouble();
-        _options.TopP = r.ReadDouble(); _options.CodecFrameRate = r.ReadInt32();
-        _options.DropoutRate = r.ReadDouble();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() => new VoiceCraft<T>(Architecture, _options);
+
 
     #endregion
 
diff --git a/src/Audio/Generation/YuE.cs b/src/Audio/Generation/YuE.cs
index 97b73c4180..552ff1ea89 100644
--- a/src/Audio/Generation/YuE.cs
+++ b/src/Audio/Generation/YuE.cs
@@ -43,7 +43,7 @@ namespace AiDotNet.Audio.Generation;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("YuE: Open Music Foundation Models for Full-Song Generation", "https://arxiv.org/abs/2503.08638", Year = 2025, Authors = "Ruibin Yuan, Hanfeng Lin, Ge Zhang, Jiahao Pan, Jiatong Shi, Tian Yuan, Yinghao Ma, Xingjian Du, Haohe Liu, Yiming Liang, Ziyang Ma, Siqi Zheng, Zuoxian Liang, Ziyu Wang, Chenghua Lin, Tianyu Zheng, Yizhi Li, Yifei Yuan, Shangda Wu, Yifu Sun, Peng Li, Wenye Ma, Jie Fu, Roger Dannenberg, Xie Chen, Emmanouil Benetos, Wenwu Wang, Wei Xue, Yike Guo")]
-public class YuE<T> : AudioNeuralNetworkBase<T>, IAudioGenerator<T>
+public partial class YuE<T> : AudioNeuralNetworkBase<T>, IAudioGenerator<T>
 {
     /// <inheritdoc />
     /// <remarks>
@@ -295,36 +295,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty);
-        w.Write(_options.SampleRate); w.Write(_options.MaxDurationSeconds);
-        w.Write(_options.SemanticDim); w.Write(_options.NumSemanticLayers);
-        w.Write(_options.NumSemanticHeads); w.Write(_options.AcousticDim);
-        w.Write(_options.NumAcousticLayers); w.Write(_options.NumAcousticHeads);
-        w.Write(_options.LyricsVocabSize); w.Write(_options.SemanticVocabSize);
-        w.Write(_options.AcousticCodebookSize); w.Write(_options.NumAcousticQuantizers);
-        w.Write(_options.NumStyleTags); w.Write(_options.StyleEmbeddingDim);
-        w.Write(_options.Temperature); w.Write(_options.TopP);
-        w.Write(_options.RepetitionPenalty); w.Write(_options.DropoutRate);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.SampleRate = r.ReadInt32(); _options.MaxDurationSeconds = r.ReadDouble();
-        _options.SemanticDim = r.ReadInt32(); _options.NumSemanticLayers = r.ReadInt32();
-        _options.NumSemanticHeads = r.ReadInt32(); _options.AcousticDim = r.ReadInt32();
-        _options.NumAcousticLayers = r.ReadInt32(); _options.NumAcousticHeads = r.ReadInt32();
-        _options.LyricsVocabSize = r.ReadInt32(); _options.SemanticVocabSize = r.ReadInt32();
-        _options.AcousticCodebookSize = r.ReadInt32(); _options.NumAcousticQuantizers = r.ReadInt32();
-        _options.NumStyleTags = r.ReadInt32(); _options.StyleEmbeddingDim = r.ReadInt32();
-        _options.Temperature = r.ReadDouble(); _options.TopP = r.ReadDouble();
-        _options.RepetitionPenalty = r.ReadDouble(); _options.DropoutRate = r.ReadDouble();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() => new YuE<T>(Architecture, _options);
+
 
     #endregion
 
diff --git a/src/Audio/LanguageIdentification/ECAPATDNNLanguageIdentifier.cs b/src/Audio/LanguageIdentification/ECAPATDNNLanguageIdentifier.cs
index f3b7be2e45..826898e599 100644
--- a/src/Audio/LanguageIdentification/ECAPATDNNLanguageIdentifier.cs
+++ b/src/Audio/LanguageIdentification/ECAPATDNNLanguageIdentifier.cs
@@ -499,48 +499,10 @@ protected override void InitializeLayers()
     }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(IsOnnxMode);
-        writer.Write(SampleRate);
-        writer.Write(_options.EmbeddingDimension);
-        writer.Write(_options.TdnnChannels);
-        writer.Write(_languageIdToCode.Count);
 
-        foreach (var kvp in _languageIdToCode)
-        {
-            writer.Write(kvp.Key);
-            writer.Write(kvp.Value);
-        }
-    }
 
     /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        // Read configuration values for validation
-        _ = reader.ReadBoolean(); // IsOnnxMode
-        _ = reader.ReadInt32();   // SampleRate
-        _ = reader.ReadInt32();   // EmbeddingDimension
-        _ = reader.ReadInt32();   // TdnnChannels
-        int langCount = reader.ReadInt32();
-
-        for (int i = 0; i < langCount; i++)
-        {
-            _ = reader.ReadInt32();   // language id
-            _ = reader.ReadString();  // language code
-        }
-    }
 
-    /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new ECAPATDNNLanguageIdentifier<T>(
-            Architecture,
-            _languageIdToCode.Values.ToList(),
-            _options,
-            _optimizer,
-            _lossFunction);
-    }
 
     #endregion
 
diff --git a/src/Audio/LanguageIdentification/VoxLingua107Identifier.cs b/src/Audio/LanguageIdentification/VoxLingua107Identifier.cs
index 253209e7af..f4e1f3de61 100644
--- a/src/Audio/LanguageIdentification/VoxLingua107Identifier.cs
+++ b/src/Audio/LanguageIdentification/VoxLingua107Identifier.cs
@@ -554,35 +554,10 @@ protected override void InitializeLayers()
     }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(IsOnnxMode);
-        writer.Write(SampleRate);
-        writer.Write(_options.EmbeddingDimension);
-        writer.Write(_options.TdnnChannels);
-        writer.Write(_numLanguages); // classifier head width (paper default 107)
-    }
 
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        // Read configuration values for validation
-        _ = reader.ReadBoolean(); // IsOnnxMode
-        _ = reader.ReadInt32();   // SampleRate
-        _ = reader.ReadInt32();   // EmbeddingDimension
-        _ = reader.ReadInt32();   // TdnnChannels
-        _ = reader.ReadInt32();   // NumLanguages
-    }
 
     /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new VoxLingua107Identifier<T>(
-            Architecture,
-            _options,
-            optimizer: null,
-            _lossFunction);
-    }
+
 
     #endregion
 
diff --git a/src/Audio/LanguageIdentification/Wav2Vec2LanguageIdentifier.cs b/src/Audio/LanguageIdentification/Wav2Vec2LanguageIdentifier.cs
index ee3e5fceb6..8e4f6f3769 100644
--- a/src/Audio/LanguageIdentification/Wav2Vec2LanguageIdentifier.cs
+++ b/src/Audio/LanguageIdentification/Wav2Vec2LanguageIdentifier.cs
@@ -481,50 +481,10 @@ protected override void InitializeLayers()
     }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(IsOnnxMode);
-        writer.Write(SampleRate);
-        writer.Write(_options.HiddenSize);
-        writer.Write(_options.NumLayers);
-        writer.Write(_options.NumAttentionHeads);
-        writer.Write(_languageIdToCode.Count);
-
-        foreach (var kvp in _languageIdToCode)
-        {
-            writer.Write(kvp.Key);
-            writer.Write(kvp.Value);
-        }
-    }
 
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        // Read configuration values for validation
-        _ = reader.ReadBoolean(); // IsOnnxMode
-        _ = reader.ReadInt32();   // SampleRate
-        _ = reader.ReadInt32();   // HiddenSize
-        _ = reader.ReadInt32();   // NumLayers
-        _ = reader.ReadInt32();   // NumAttentionHeads
-        int langCount = reader.ReadInt32();
-
-        for (int i = 0; i < langCount; i++)
-        {
-            _ = reader.ReadInt32();   // language id
-            _ = reader.ReadString();  // language code
-        }
-    }
 
     /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new Wav2Vec2LanguageIdentifier<T>(
-            Architecture,
-            _languageIdToCode.Values.ToList(),
-            _options,
-            _optimizer,
-            _lossFunction);
-    }
+
 
     #endregion
 
diff --git a/src/Audio/Multimodal/AudioFlamingo2.cs b/src/Audio/Multimodal/AudioFlamingo2.cs
index 0b16d85841..42b6198bc8 100644
--- a/src/Audio/Multimodal/AudioFlamingo2.cs
+++ b/src/Audio/Multimodal/AudioFlamingo2.cs
@@ -45,7 +45,7 @@ namespace AiDotNet.Audio.Multimodal;
 [ModelComplexity(ModelComplexity.VeryHigh)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Audio Flamingo: A Novel Audio Language Model with Few-Shot Learning and Dialogue Abilities", "https://doi.org/10.48550/arXiv.2402.01831", Year = 2024, Authors = "Zhifeng Kong, Arushi Goel, Rohan Badlani, Wei Ping, Rafael Valle, Bryan Catanzaro")]
-public class AudioFlamingo2<T> : AudioNeuralNetworkBase<T>, IAudioLanguageModel<T>
+public partial class AudioFlamingo2<T> : AudioNeuralNetworkBase<T>, IAudioLanguageModel<T>
 {
     /// <inheritdoc />
     /// <remarks>
@@ -222,28 +222,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty);
-        w.Write(_options.SampleRate); w.Write(_options.AudioEncoderDim);
-        w.Write(_options.LLMHiddenDim); w.Write(_options.NumPerceiverLayers);
-        w.Write(_options.NumPerceiverTokens); w.Write(_options.MaxAudioDurationSeconds);
-        w.Write(_options.MaxResponseTokens); w.Write(_options.DropoutRate);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.SampleRate = r.ReadInt32(); _options.AudioEncoderDim = r.ReadInt32();
-        _options.LLMHiddenDim = r.ReadInt32(); _options.NumPerceiverLayers = r.ReadInt32();
-        _options.NumPerceiverTokens = r.ReadInt32(); _options.MaxAudioDurationSeconds = r.ReadDouble();
-        _options.MaxResponseTokens = r.ReadInt32(); _options.DropoutRate = r.ReadDouble();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-        => new AudioFlamingo2<T>(Architecture, new AudioFlamingo2Options(_options));
+
 
     #endregion
 
diff --git a/src/Audio/Multimodal/MusicFlamingo.cs b/src/Audio/Multimodal/MusicFlamingo.cs
index 409d537e16..4a4957b081 100644
--- a/src/Audio/Multimodal/MusicFlamingo.cs
+++ b/src/Audio/Multimodal/MusicFlamingo.cs
@@ -45,7 +45,7 @@ namespace AiDotNet.Audio.Multimodal;
 [ModelComplexity(ModelComplexity.VeryHigh)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("MusicFlamingo: Multimodal Music Understanding and Generation with Pretrained Language Models", "https://doi.org/10.48550/arXiv.2410.01250", Year = 2024, Authors = "Zhifeng Kong, Arushi Goel, Rohan Badlani, Wei Ping, Rafael Valle, Bryan Catanzaro")]
-public class MusicFlamingo<T> : AudioNeuralNetworkBase<T>, IAudioLanguageModel<T>
+public partial class MusicFlamingo<T> : AudioNeuralNetworkBase<T>, IAudioLanguageModel<T>
 {
     /// <inheritdoc />
     /// <remarks>
@@ -216,28 +216,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty);
-        w.Write(_options.SampleRate); w.Write(_options.MusicEncoderDim);
-        w.Write(_options.LLMHiddenDim); w.Write(_options.NumPerceiverLayers);
-        w.Write(_options.NumPerceiverTokens); w.Write(_options.MaxAudioDurationSeconds);
-        w.Write(_options.MaxResponseTokens); w.Write(_options.DropoutRate);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.SampleRate = r.ReadInt32(); _options.MusicEncoderDim = r.ReadInt32();
-        _options.LLMHiddenDim = r.ReadInt32(); _options.NumPerceiverLayers = r.ReadInt32();
-        _options.NumPerceiverTokens = r.ReadInt32(); _options.MaxAudioDurationSeconds = r.ReadDouble();
-        _options.MaxResponseTokens = r.ReadInt32(); _options.DropoutRate = r.ReadDouble();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-        => new MusicFlamingo<T>(Architecture, _options);
+
 
     #endregion
 
diff --git a/src/Audio/Multimodal/Pengi.cs b/src/Audio/Multimodal/Pengi.cs
index a559d84a68..07fc1aea35 100644
--- a/src/Audio/Multimodal/Pengi.cs
+++ b/src/Audio/Multimodal/Pengi.cs
@@ -46,7 +46,7 @@ namespace AiDotNet.Audio.Multimodal;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Pengi: An Audio Language Model for Audio Tasks", "https://doi.org/10.48550/arXiv.2305.11834", Year = 2023, Authors = "Soham Deshmukh, Benjamin Elizalde, Rita Singh, Huaming Wang")]
-public class Pengi<T> : AudioNeuralNetworkBase<T>, IAudioLanguageModel<T>
+public partial class Pengi<T> : AudioNeuralNetworkBase<T>, IAudioLanguageModel<T>
 {
     /// <inheritdoc />
     /// <remarks>
@@ -216,28 +216,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty);
-        w.Write(_options.SampleRate); w.Write(_options.AudioEncoderDim);
-        w.Write(_options.LLMHiddenDim); w.Write(_options.NumProjectionLayers);
-        w.Write(_options.MaxAudioDurationSeconds); w.Write(_options.MaxResponseTokens);
-        w.Write(_options.DropoutRate);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.SampleRate = r.ReadInt32(); _options.AudioEncoderDim = r.ReadInt32();
-        _options.LLMHiddenDim = r.ReadInt32(); _options.NumProjectionLayers = r.ReadInt32();
-        _options.MaxAudioDurationSeconds = r.ReadDouble(); _options.MaxResponseTokens = r.ReadInt32();
-        _options.DropoutRate = r.ReadDouble();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-        => new Pengi<T>(Architecture, _options);
+
 
     #endregion
 
diff --git a/src/Audio/Multimodal/Qwen2Audio.cs b/src/Audio/Multimodal/Qwen2Audio.cs
index 5da2e41067..8e7079128d 100644
--- a/src/Audio/Multimodal/Qwen2Audio.cs
+++ b/src/Audio/Multimodal/Qwen2Audio.cs
@@ -44,7 +44,7 @@ namespace AiDotNet.Audio.Multimodal;
 [ModelComplexity(ModelComplexity.VeryHigh)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Qwen2-Audio Technical Report", "https://doi.org/10.48550/arXiv.2407.10759", Year = 2024, Authors = "Yunfei Chu, Jin Xu, Qian Yang, Haojie Wei, Xipin Wei, Zhifang Guo, Yichong Leng, Yuanjun Lv, Jinzheng He, Junyang Lin, Chang Zhou, Jingren Zhou")]
-public class Qwen2Audio<T> : AudioNeuralNetworkBase<T>, IAudioLanguageModel<T>
+public partial class Qwen2Audio<T> : AudioNeuralNetworkBase<T>, IAudioLanguageModel<T>
 {
     /// <inheritdoc />
     /// <remarks>
@@ -233,34 +233,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty);
-        w.Write(_options.SampleRate); w.Write(_options.AudioEncoderDim);
-        w.Write(_options.NumAudioEncoderLayers); w.Write(_options.NumAudioEncoderHeads);
-        w.Write(_options.NumMels); w.Write(_options.MaxAudioDurationSeconds);
-        w.Write(_options.LMHiddenDim); w.Write(_options.NumLMLayers);
-        w.Write(_options.NumLMHeads); w.Write(_options.VocabSize);
-        w.Write(_options.MaxResponseTokens); w.Write(_options.AdapterDim);
-        w.Write(_options.NumLatentTokens); w.Write(_options.Temperature);
-        w.Write(_options.TopP); w.Write(_options.DropoutRate);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.SampleRate = r.ReadInt32(); _options.AudioEncoderDim = r.ReadInt32();
-        _options.NumAudioEncoderLayers = r.ReadInt32(); _options.NumAudioEncoderHeads = r.ReadInt32();
-        _options.NumMels = r.ReadInt32(); _options.MaxAudioDurationSeconds = r.ReadDouble();
-        _options.LMHiddenDim = r.ReadInt32(); _options.NumLMLayers = r.ReadInt32();
-        _options.NumLMHeads = r.ReadInt32(); _options.VocabSize = r.ReadInt32();
-        _options.MaxResponseTokens = r.ReadInt32(); _options.AdapterDim = r.ReadInt32();
-        _options.NumLatentTokens = r.ReadInt32(); _options.Temperature = r.ReadDouble();
-        _options.TopP = r.ReadDouble(); _options.DropoutRate = r.ReadDouble();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() => new Qwen2Audio<T>(Architecture, _options);
+
 
     #endregion
 
diff --git a/src/Audio/Multimodal/SALMONN.cs b/src/Audio/Multimodal/SALMONN.cs
index 7d38539839..37fc8b41cd 100644
--- a/src/Audio/Multimodal/SALMONN.cs
+++ b/src/Audio/Multimodal/SALMONN.cs
@@ -47,7 +47,7 @@ namespace AiDotNet.Audio.Multimodal;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("SALMONN: Towards Generic Hearing Abilities for Large Language Models", "https://arxiv.org/abs/2310.13289", Year = 2024, Authors = "Changli Tang, Wenyi Yu, Guangzhi Sun, Xianzhao Chen, Tian Tan, Wei Li, Lu Lu, Zejun Ma, Chao Zhang")]
-public class SALMONN<T> : AudioNeuralNetworkBase<T>, IAudioLanguageModel<T>
+public partial class SALMONN<T> : AudioNeuralNetworkBase<T>, IAudioLanguageModel<T>
 {
     /// <inheritdoc />
     /// <remarks>
@@ -249,38 +249,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty);
-        w.Write(_options.SampleRate); w.Write(_options.SpeechEncoderDim);
-        w.Write(_options.NumSpeechEncoderLayers); w.Write(_options.AudioEncoderDim);
-        w.Write(_options.NumAudioEncoderLayers); w.Write(_options.NumMels);
-        w.Write(_options.MaxAudioDurationSeconds); w.Write(_options.QFormerDim);
-        w.Write(_options.NumQFormerLayers); w.Write(_options.NumQueryTokens);
-        w.Write(_options.WindowSize); w.Write(_options.LMHiddenDim);
-        w.Write(_options.NumLMLayers); w.Write(_options.NumLMHeads);
-        w.Write(_options.VocabSize); w.Write(_options.MaxResponseTokens);
-        w.Write(_options.Temperature); w.Write(_options.TopP);
-        w.Write(_options.DropoutRate);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.SampleRate = r.ReadInt32(); _options.SpeechEncoderDim = r.ReadInt32();
-        _options.NumSpeechEncoderLayers = r.ReadInt32(); _options.AudioEncoderDim = r.ReadInt32();
-        _options.NumAudioEncoderLayers = r.ReadInt32(); _options.NumMels = r.ReadInt32();
-        _options.MaxAudioDurationSeconds = r.ReadDouble(); _options.QFormerDim = r.ReadInt32();
-        _options.NumQFormerLayers = r.ReadInt32(); _options.NumQueryTokens = r.ReadInt32();
-        _options.WindowSize = r.ReadInt32(); _options.LMHiddenDim = r.ReadInt32();
-        _options.NumLMLayers = r.ReadInt32(); _options.NumLMHeads = r.ReadInt32();
-        _options.VocabSize = r.ReadInt32(); _options.MaxResponseTokens = r.ReadInt32();
-        _options.Temperature = r.ReadDouble(); _options.TopP = r.ReadDouble();
-        _options.DropoutRate = r.ReadDouble();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() => new SALMONN<T>(Architecture, _options);
+
 
     #endregion
 
diff --git a/src/Audio/MusicAnalysis/BasicPitch.cs b/src/Audio/MusicAnalysis/BasicPitch.cs
index 63dd186fbf..68a7e82642 100644
--- a/src/Audio/MusicAnalysis/BasicPitch.cs
+++ b/src/Audio/MusicAnalysis/BasicPitch.cs
@@ -43,7 +43,7 @@ namespace AiDotNet.Audio.MusicAnalysis;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("A Lightweight Instrument-Agnostic Model for Polyphonic Note Transcription and Multipitch Estimation", "https://arxiv.org/abs/2203.09893", Year = 2022, Authors = "Rachel M. Bittner, Juan Jose Bosch, David Rubinstein, Gabriel Meseguer-Brocal, Sebastian Ewert")]
-public class BasicPitch<T> : AudioNeuralNetworkBase<T>, IMusicTranscriber<T>
+public partial class BasicPitch<T> : AudioNeuralNetworkBase<T>, IMusicTranscriber<T>
 {
     /// <inheritdoc />
     /// <remarks>
@@ -260,30 +260,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty);
-        w.Write(_options.SampleRate); w.Write(_options.NumHarmonicBins); w.Write(_options.BinsPerOctave);
-        w.Write(_options.HopLength); w.Write(_options.NumHarmonics);
-        w.Write(_options.NumMidiNotes); w.Write(_options.MidiOffset);
-        w.Write(_options.EncoderFilters); w.Write(_options.NumEncoderLayers);
-        w.Write(_options.OnsetThreshold); w.Write(_options.NoteThreshold);
-        w.Write(_options.MinNoteDurationSec); w.Write(_options.DropoutRate);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.SampleRate = r.ReadInt32(); _options.NumHarmonicBins = r.ReadInt32(); _options.BinsPerOctave = r.ReadInt32();
-        _options.HopLength = r.ReadInt32(); _options.NumHarmonics = r.ReadInt32();
-        _options.NumMidiNotes = r.ReadInt32(); _options.MidiOffset = r.ReadInt32();
-        _options.EncoderFilters = r.ReadInt32(); _options.NumEncoderLayers = r.ReadInt32();
-        _options.OnsetThreshold = r.ReadDouble(); _options.NoteThreshold = r.ReadDouble();
-        _options.MinNoteDurationSec = r.ReadDouble(); _options.DropoutRate = r.ReadDouble();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() => new BasicPitch<T>(Architecture, _options);
+
 
     #endregion
 
diff --git a/src/Audio/MusicAnalysis/CREPE.cs b/src/Audio/MusicAnalysis/CREPE.cs
index 3c65ac0217..7be0a2fc37 100644
--- a/src/Audio/MusicAnalysis/CREPE.cs
+++ b/src/Audio/MusicAnalysis/CREPE.cs
@@ -40,7 +40,7 @@ namespace AiDotNet.Audio.MusicAnalysis;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("CREPE: A Convolutional Representation for Pitch Estimation", "https://arxiv.org/abs/1802.06182", Year = 2018, Authors = "Jong Wook Kim, Justin Salamon, Peter Li, Juan Pablo Bello")]
-public class CREPE<T> : AudioNeuralNetworkBase<T>, IPitchDetector<T>
+public partial class CREPE<T> : AudioNeuralNetworkBase<T>, IPitchDetector<T>
 {
     /// <inheritdoc />
     /// <remarks>
@@ -308,28 +308,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty);
-        w.Write(_options.SampleRate); w.Write(_options.FrameSize); w.Write(_options.HopLength);
-        w.Write(_options.CapacityMultiplier); w.Write(_options.NumBins);
-        w.Write(_options.MinFrequency); w.Write(_options.MaxFrequency);
-        w.Write(_options.VoicingThreshold); w.Write(_options.DropoutRate);
-        w.Write(_options.Variant);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.SampleRate = r.ReadInt32(); _options.FrameSize = r.ReadInt32(); _options.HopLength = r.ReadInt32();
-        _options.CapacityMultiplier = r.ReadInt32(); _options.NumBins = r.ReadInt32();
-        _options.MinFrequency = r.ReadDouble(); _options.MaxFrequency = r.ReadDouble();
-        _options.VoicingThreshold = r.ReadDouble(); _options.DropoutRate = r.ReadDouble();
-        _options.Variant = r.ReadString();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() => new CREPE<T>(Architecture, _options);
+
 
     #endregion
 
diff --git a/src/Audio/MusicAnalysis/MT3.cs b/src/Audio/MusicAnalysis/MT3.cs
index 6fbbb747c4..933c62d6b7 100644
--- a/src/Audio/MusicAnalysis/MT3.cs
+++ b/src/Audio/MusicAnalysis/MT3.cs
@@ -42,7 +42,7 @@ namespace AiDotNet.Audio.MusicAnalysis;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("MT3: Multi-Task Multitrack Music Transcription", "https://arxiv.org/abs/2111.03017", Year = 2022, Authors = "Josh Gardner, Ian Simon, Ethan Manilow, Curtis Hawthorne, Jesse Engel")]
-public class MT3<T> : AudioNeuralNetworkBase<T>, IMusicTranscriber<T>
+public partial class MT3<T> : AudioNeuralNetworkBase<T>, IMusicTranscriber<T>
 {
     /// <inheritdoc />
     /// <remarks>
@@ -260,28 +260,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty);
-        w.Write(_options.SampleRate); w.Write(_options.NumMels); w.Write(_options.FftSize);
-        w.Write(_options.HopLength); w.Write(_options.EncoderDim); w.Write(_options.NumEncoderLayers);
-        w.Write(_options.DecoderDim); w.Write(_options.NumDecoderLayers);
-        w.Write(_options.NumAttentionHeads); w.Write(_options.VocabSize);
-        w.Write(_options.MaxInstruments); w.Write(_options.DropoutRate);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.SampleRate = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.FftSize = r.ReadInt32();
-        _options.HopLength = r.ReadInt32(); _options.EncoderDim = r.ReadInt32(); _options.NumEncoderLayers = r.ReadInt32();
-        _options.DecoderDim = r.ReadInt32(); _options.NumDecoderLayers = r.ReadInt32();
-        _options.NumAttentionHeads = r.ReadInt32(); _options.VocabSize = r.ReadInt32();
-        _options.MaxInstruments = r.ReadInt32(); _options.DropoutRate = r.ReadDouble();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() => new MT3<T>(Architecture, _options);
+
 
     #endregion
 
diff --git a/src/Audio/MusicAnalysis/MadmomBeatTracker.cs b/src/Audio/MusicAnalysis/MadmomBeatTracker.cs
index cc76663d00..b12c9f58c0 100644
--- a/src/Audio/MusicAnalysis/MadmomBeatTracker.cs
+++ b/src/Audio/MusicAnalysis/MadmomBeatTracker.cs
@@ -43,7 +43,7 @@ namespace AiDotNet.Audio.MusicAnalysis;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Joint Beat and Downbeat Tracking with Recurrent Neural Networks", "https://doi.org/10.5281/zenodo.1160264", Year = 2016, Authors = "Sebastian Böck, Florian Krebs, Gerhard Widmer")]
-public class MadmomBeatTracker<T> : AudioNeuralNetworkBase<T>, IBeatTracker<T>
+public partial class MadmomBeatTracker<T> : AudioNeuralNetworkBase<T>, IBeatTracker<T>
 {
     #region Fields
 
@@ -302,33 +302,9 @@ private AdamWOptimizer<T, Tensor<T>, Tensor<T>> CreateDefaultOptimizer()
                 MaxGradientNorm = _options.MaxGradientNorm
             });
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty);
-        w.Write(_options.SampleRate); w.Write(_options.FftSize); w.Write(_options.HopLength);
-        w.Write(_options.NumBands); w.Write(_options.RnnHiddenSize); w.Write(_options.NumRnnLayers);
-        w.Write(_options.PeakThreshold); w.Write(_options.MinBeatInterval); w.Write(_options.DropoutRate);
-        w.Write(_options.LearningRate); w.Write(_options.MaxGradientNorm);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.SampleRate = r.ReadInt32(); _options.FftSize = r.ReadInt32(); _options.HopLength = r.ReadInt32();
-        _options.NumBands = r.ReadInt32(); _options.RnnHiddenSize = r.ReadInt32(); _options.NumRnnLayers = r.ReadInt32();
-        _options.PeakThreshold = r.ReadDouble(); _options.MinBeatInterval = r.ReadDouble(); _options.DropoutRate = r.ReadDouble();
-        // Appended, so guarded: absent from payloads written before these were configurable.
-        if (r.BaseStream.Position < r.BaseStream.Length) _options.LearningRate = r.ReadDouble();
-        if (r.BaseStream.Position < r.BaseStream.Length) _options.MaxGradientNorm = r.ReadDouble();
-
-        // Rebuilt from the RESTORED options. Only when we own it -- an injected optimizer is the
-        // caller's object and replacing it here would discard their configuration on every load.
-        if (_useNativeMode && _optimizerIsDefault) _optimizer = CreateDefaultOptimizer();
-
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() => new MadmomBeatTracker<T>(Architecture, _options);
+
 
     #endregion
 
diff --git a/src/Audio/MusicAnalysis/MelodyExtractor.cs b/src/Audio/MusicAnalysis/MelodyExtractor.cs
index 39d38eb4db..69625a322e 100644
--- a/src/Audio/MusicAnalysis/MelodyExtractor.cs
+++ b/src/Audio/MusicAnalysis/MelodyExtractor.cs
@@ -40,7 +40,7 @@ namespace AiDotNet.Audio.MusicAnalysis;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
     [ResearchPaper("Melody Extraction from Polyphonic Music Signals Using Pitch Contour Characteristics", "https://doi.org/10.1109/TASLP.2012.2188515")]
-public class MelodyExtractor<T> : AudioNeuralNetworkBase<T>, IPitchDetector<T>
+public partial class MelodyExtractor<T> : AudioNeuralNetworkBase<T>, IPitchDetector<T>
 {
     /// <inheritdoc />
     /// <remarks>
@@ -304,26 +304,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty);
-        w.Write(_options.SampleRate); w.Write(_options.NumMels); w.Write(_options.FftSize);
-        w.Write(_options.HopLength); w.Write(_options.HiddenDim); w.Write(_options.NumLayers);
-        w.Write(_options.NumPitchBins); w.Write(_options.MinFrequency);
-        w.Write(_options.MaxFrequency); w.Write(_options.VoicingThreshold); w.Write(_options.DropoutRate);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.SampleRate = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.FftSize = r.ReadInt32();
-        _options.HopLength = r.ReadInt32(); _options.HiddenDim = r.ReadInt32(); _options.NumLayers = r.ReadInt32();
-        _options.NumPitchBins = r.ReadInt32(); _options.MinFrequency = r.ReadDouble();
-        _options.MaxFrequency = r.ReadDouble(); _options.VoicingThreshold = r.ReadDouble(); _options.DropoutRate = r.ReadDouble();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() => new MelodyExtractor<T>(Architecture, _options);
+
 
     #endregion
 
diff --git a/src/Audio/MusicAnalysis/MusicStructureAnalyzer.cs b/src/Audio/MusicAnalysis/MusicStructureAnalyzer.cs
index 6ebecc2ed5..b673bed0fb 100644
--- a/src/Audio/MusicAnalysis/MusicStructureAnalyzer.cs
+++ b/src/Audio/MusicAnalysis/MusicStructureAnalyzer.cs
@@ -41,7 +41,7 @@ namespace AiDotNet.Audio.MusicAnalysis;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
     [ResearchPaper("Music Structure Analysis: A Survey", "https://doi.org/10.1007/978-3-319-25226-1_12")]
-public class MusicStructureAnalyzer<T> : AudioNeuralNetworkBase<T>
+public partial class MusicStructureAnalyzer<T> : AudioNeuralNetworkBase<T>
 {
     /// <inheritdoc />
     /// <remarks>
@@ -262,32 +262,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty);
-        w.Write(_options.SampleRate); w.Write(_options.NumMels); w.Write(_options.FftSize);
-        w.Write(_options.HopLength); w.Write(_options.HiddenDim); w.Write(_options.NumLayers);
-        w.Write(_options.NumAttentionHeads); w.Write(_options.NumSections);
-        w.Write(_options.SectionLabels.Length);
-        foreach (var label in _options.SectionLabels) w.Write(label);
-        w.Write(_options.DropoutRate);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.SampleRate = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.FftSize = r.ReadInt32();
-        _options.HopLength = r.ReadInt32(); _options.HiddenDim = r.ReadInt32(); _options.NumLayers = r.ReadInt32();
-        _options.NumAttentionHeads = r.ReadInt32(); _options.NumSections = r.ReadInt32();
-        int labelCount = r.ReadInt32();
-        var labels = new string[labelCount];
-        for (int i = 0; i < labelCount; i++) labels[i] = r.ReadString();
-        _options.SectionLabels = labels;
-        _options.DropoutRate = r.ReadDouble();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() => new MusicStructureAnalyzer<T>(Architecture, _options);
+
 
     #endregion
 
diff --git a/src/Audio/MusicAnalysis/MusicTaggingTransformer.cs b/src/Audio/MusicAnalysis/MusicTaggingTransformer.cs
index d3e49bee10..1a2f122e5d 100644
--- a/src/Audio/MusicAnalysis/MusicTaggingTransformer.cs
+++ b/src/Audio/MusicAnalysis/MusicTaggingTransformer.cs
@@ -42,7 +42,7 @@ namespace AiDotNet.Audio.MusicAnalysis;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Transformer-based Tag Prediction for Music Auto-tagging", "https://doi.org/10.48550/arXiv.2106.02072", Year = 2021, Authors = "Minz Won, Keunwoo Choi, Xavier Serra")]
-public class MusicTaggingTransformer<T> : AudioNeuralNetworkBase<T>
+public partial class MusicTaggingTransformer<T> : AudioNeuralNetworkBase<T>
 {
     /// <inheritdoc />
     /// <remarks>
@@ -259,34 +259,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty);
-        w.Write(_options.SampleRate); w.Write(_options.NumMels); w.Write(_options.FftSize);
-        w.Write(_options.HopLength); w.Write(_options.HiddenDim); w.Write(_options.NumLayers);
-        w.Write(_options.NumAttentionHeads); w.Write(_options.FeedForwardDim);
-        w.Write(_options.NumTags);
-        w.Write(_options.TagLabels.Length);
-        foreach (var label in _options.TagLabels) w.Write(label);
-        w.Write(_options.DropoutRate);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.SampleRate = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.FftSize = r.ReadInt32();
-        _options.HopLength = r.ReadInt32(); _options.HiddenDim = r.ReadInt32(); _options.NumLayers = r.ReadInt32();
-        _options.NumAttentionHeads = r.ReadInt32(); _options.FeedForwardDim = r.ReadInt32();
-        _options.NumTags = r.ReadInt32();
-        int labelCount = r.ReadInt32();
-        var labels = new string[labelCount];
-        for (int i = 0; i < labelCount; i++) labels[i] = r.ReadString();
-        _options.TagLabels = labels;
-        _options.DropoutRate = r.ReadDouble();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() => new MusicTaggingTransformer<T>(Architecture, _options);
+
 
     #endregion
 
diff --git a/src/Audio/MusicAnalysis/OnsetsAndFrames.cs b/src/Audio/MusicAnalysis/OnsetsAndFrames.cs
index de49840ae9..d21126028d 100644
--- a/src/Audio/MusicAnalysis/OnsetsAndFrames.cs
+++ b/src/Audio/MusicAnalysis/OnsetsAndFrames.cs
@@ -44,7 +44,7 @@ namespace AiDotNet.Audio.MusicAnalysis;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Onsets and Frames: Dual-Objective Piano Transcription", "https://arxiv.org/abs/1710.11153", Year = 2018, Authors = "Curtis Hawthorne, Erich Elsen, Jialin Song, Adam Roberts, Ian Simon, Colin Raffel, Jesse Engel, Sageev Oore, Douglas Eck")]
-public class OnsetsAndFrames<T> : AudioNeuralNetworkBase<T>, IMusicTranscriber<T>
+public partial class OnsetsAndFrames<T> : AudioNeuralNetworkBase<T>, IMusicTranscriber<T>
 {
     /// <inheritdoc />
     /// <remarks>
@@ -279,32 +279,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty);
-        w.Write(_options.SampleRate); w.Write(_options.NumMels); w.Write(_options.FftSize);
-        w.Write(_options.HopLength); w.Write(_options.FMin); w.Write(_options.FMax);
-        w.Write(_options.NumMidiNotes); w.Write(_options.MidiOffset);
-        w.Write(_options.AcousticModelDim); w.Write(_options.LstmHiddenSize); w.Write(_options.NumLstmLayers);
-        w.Write(_options.OnsetThreshold); w.Write(_options.FrameThreshold);
-        w.Write(_options.MinNoteDurationSec); w.Write(_options.DropoutRate);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.SampleRate = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.FftSize = r.ReadInt32();
-        _options.HopLength = r.ReadInt32(); _options.FMin = r.ReadDouble(); _options.FMax = r.ReadDouble();
-        _options.NumMidiNotes = r.ReadInt32(); _options.MidiOffset = r.ReadInt32();
-        _options.AcousticModelDim = r.ReadInt32(); _options.LstmHiddenSize = r.ReadInt32(); _options.NumLstmLayers = r.ReadInt32();
-        _options.OnsetThreshold = r.ReadDouble(); _options.FrameThreshold = r.ReadDouble();
-        _options.MinNoteDurationSec = r.ReadDouble(); _options.DropoutRate = r.ReadDouble();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions);
-        _melSpectrogram = new MelSpectrogram<T>(_options.SampleRate, _options.NumMels,
-            _options.FftSize, _options.HopLength, _options.FMin, _options.FMax, logMel: true);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() => new OnsetsAndFrames<T>(Architecture, _options);
+
 
     #endregion
 
diff --git a/src/Audio/MusicAnalysis/Tempogram.cs b/src/Audio/MusicAnalysis/Tempogram.cs
index 47600df757..0c11dd2cdc 100644
--- a/src/Audio/MusicAnalysis/Tempogram.cs
+++ b/src/Audio/MusicAnalysis/Tempogram.cs
@@ -39,7 +39,7 @@ namespace AiDotNet.Audio.MusicAnalysis;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
     [ResearchPaper("Tempogram Toolbox: MATLAB Implementations for Tempo and Pulse Analysis", "https://doi.org/10.5281/zenodo.1416010")]
-public class Tempogram<T> : AudioNeuralNetworkBase<T>, IBeatTracker<T>
+public partial class Tempogram<T> : AudioNeuralNetworkBase<T>, IBeatTracker<T>
 {
     /// <inheritdoc />
     /// <remarks>
@@ -294,26 +294,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty);
-        w.Write(_options.SampleRate); w.Write(_options.FftSize); w.Write(_options.HopLength);
-        w.Write(_options.OnsetHiddenDim); w.Write(_options.NumOnsetLayers);
-        w.Write(_options.TempoWindowFrames); w.Write(_options.MinBPM);
-        w.Write(_options.MaxBPM); w.Write(_options.NumTempoBins); w.Write(_options.DropoutRate);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.SampleRate = r.ReadInt32(); _options.FftSize = r.ReadInt32(); _options.HopLength = r.ReadInt32();
-        _options.OnsetHiddenDim = r.ReadInt32(); _options.NumOnsetLayers = r.ReadInt32();
-        _options.TempoWindowFrames = r.ReadInt32(); _options.MinBPM = r.ReadDouble();
-        _options.MaxBPM = r.ReadDouble(); _options.NumTempoBins = r.ReadInt32(); _options.DropoutRate = r.ReadDouble();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() => new Tempogram<T>(Architecture, _options);
+
 
     #endregion
 
diff --git a/src/Audio/MusicGen/MusicGenModel.cs b/src/Audio/MusicGen/MusicGenModel.cs
index 6c372bdef2..e47257e546 100644
--- a/src/Audio/MusicGen/MusicGenModel.cs
+++ b/src/Audio/MusicGen/MusicGenModel.cs
@@ -64,7 +64,7 @@ namespace AiDotNet.Audio.MusicGen;
 [ModelComplexity(ModelComplexity.VeryHigh)]
 [ModelInput(typeof(string), typeof(Tensor<>))]
 [ResearchPaper("Simple and Controllable Music Generation", "https://doi.org/10.48550/arXiv.2306.05284", Year = 2023, Authors = "Jade Copet, Felix Kreuk, Itai Gat, Tal Remez, David Kant, Gabriel Synnaeve, Yossi Adi, Alexandre Défossez")]
-public class MusicGenModel<T> : AudioNeuralNetworkBase<T>, IAudioGenerator<T>
+public partial class MusicGenModel<T> : AudioNeuralNetworkBase<T>, IAudioGenerator<T>
 {
     /// <inheritdoc />
     /// <remarks>
@@ -1042,55 +1042,12 @@ public override ModelMetadata<T> GetModelMetadata()
     /// <summary>
     /// Serializes network-specific data.
     /// </summary>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write((int)_options.ModelSize);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.DurationSeconds);
-        writer.Write(_options.MaxDurationSeconds);
-        writer.Write(_options.Temperature);
-        writer.Write(_options.TopK);
-        writer.Write(_options.TopP);
-        writer.Write(_options.GuidanceScale);
-        writer.Write(_options.Stereo);
-        writer.Write(_options.NumCodebooks);
-        writer.Write(_options.CodebookSize);
-        writer.Write(_options.MaxTextLength);
-    }
+
 
     /// <summary>
     /// Deserializes network-specific data.
     /// </summary>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _ = reader.ReadBoolean();
-        _ = reader.ReadInt32();
-        _ = reader.ReadInt32();
-        _ = reader.ReadDouble();
-        _ = reader.ReadDouble();
-        _ = reader.ReadDouble();
-        _ = reader.ReadInt32();
-        _ = reader.ReadDouble();
-        _ = reader.ReadDouble();
-        _ = reader.ReadBoolean();
-        _ = reader.ReadInt32();
-        _ = reader.ReadInt32();
-        _ = reader.ReadInt32();
-    }
 
-    /// <summary>
-    /// Creates a new instance for cloning.
-    /// </summary>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new MusicGenModel<T>(
-            Architecture,
-            _options,
-            _tokenizer,
-            null,
-            _lossFunction);
-    }
 
     #endregion
 
diff --git a/src/Audio/SourceSeparation/BSRoFormer.cs b/src/Audio/SourceSeparation/BSRoFormer.cs
index c7e3d5fe8f..6f5624bd48 100644
--- a/src/Audio/SourceSeparation/BSRoFormer.cs
+++ b/src/Audio/SourceSeparation/BSRoFormer.cs
@@ -40,7 +40,7 @@ namespace AiDotNet.Audio.SourceSeparation;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Music Source Separation with Band-Split RNN", "https://doi.org/10.48550/arXiv.2309.02612", Year = 2023, Authors = "Wei-Tsung Lu, Ju-Chiang Wang, Qiuqiang Kong, Yun-Ning Hung")]
-public class BSRoFormer<T> : AudioNeuralNetworkBase<T>, IMusicSourceSeparator<T>
+public partial class BSRoFormer<T> : AudioNeuralNetworkBase<T>, IMusicSourceSeparator<T>
 {
     /// <inheritdoc />
     /// <remarks>
@@ -228,26 +228,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty);
-        w.Write(_options.SampleRate); w.Write(_options.FftSize); w.Write(_options.HopLength); w.Write(_options.NumFreqBins);
-        w.Write(_options.NumBands); w.Write(_options.TransformerDim); w.Write(_options.NumTransformerLayers);
-        w.Write(_options.NumStems); w.Write(_options.DropoutRate);
-        w.Write(_options.Sources.Length); foreach (var s in _options.Sources) w.Write(s);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.SampleRate = r.ReadInt32(); _options.FftSize = r.ReadInt32(); _options.HopLength = r.ReadInt32(); _options.NumFreqBins = r.ReadInt32();
-        _options.NumBands = r.ReadInt32(); _options.TransformerDim = r.ReadInt32(); _options.NumTransformerLayers = r.ReadInt32();
-        _options.NumStems = r.ReadInt32(); _options.DropoutRate = r.ReadDouble();
-        int n = r.ReadInt32(); _options.Sources = new string[n]; for (int i = 0; i < n; i++) _options.Sources[i] = r.ReadString();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() => new BSRoFormer<T>(Architecture, _options);
+
 
     #endregion
 
diff --git a/src/Audio/SourceSeparation/BandSplitRNN.cs b/src/Audio/SourceSeparation/BandSplitRNN.cs
index 5b765b9d70..36630eec03 100644
--- a/src/Audio/SourceSeparation/BandSplitRNN.cs
+++ b/src/Audio/SourceSeparation/BandSplitRNN.cs
@@ -43,7 +43,7 @@ namespace AiDotNet.Audio.SourceSeparation;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Music Source Separation with Band-Split RNN", "https://doi.org/10.48550/arXiv.2209.15174", Year = 2023, Authors = "Yi Luo, Jianwei Yu")]
-public class BandSplitRNN<T> : AudioNeuralNetworkBase<T>, IMusicSourceSeparator<T>
+public partial class BandSplitRNN<T> : AudioNeuralNetworkBase<T>, IMusicSourceSeparator<T>
 {
     /// <inheritdoc />
     /// <remarks>
@@ -248,28 +248,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty);
-        w.Write(_options.SampleRate); w.Write(_options.FftSize); w.Write(_options.HopLength); w.Write(_options.NumFreqBins);
-        w.Write(_options.NumBands); w.Write(_options.BandRnnHiddenSize); w.Write(_options.NumBandRnnLayers);
-        w.Write(_options.SequenceRnnHiddenSize); w.Write(_options.NumSequenceRnnLayers); w.Write(_options.FusionDim);
-        w.Write(_options.NumStems); w.Write(_options.DropoutRate);
-        w.Write(_options.Sources.Length); foreach (var s in _options.Sources) w.Write(s);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.SampleRate = r.ReadInt32(); _options.FftSize = r.ReadInt32(); _options.HopLength = r.ReadInt32(); _options.NumFreqBins = r.ReadInt32();
-        _options.NumBands = r.ReadInt32(); _options.BandRnnHiddenSize = r.ReadInt32(); _options.NumBandRnnLayers = r.ReadInt32();
-        _options.SequenceRnnHiddenSize = r.ReadInt32(); _options.NumSequenceRnnLayers = r.ReadInt32(); _options.FusionDim = r.ReadInt32();
-        _options.NumStems = r.ReadInt32(); _options.DropoutRate = r.ReadDouble();
-        int n = r.ReadInt32(); _options.Sources = new string[n]; for (int i = 0; i < n; i++) _options.Sources[i] = r.ReadString();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() => new BandSplitRNN<T>(Architecture, _options);
+
 
     #endregion
 
diff --git a/src/Audio/SourceSeparation/DannaSep.cs b/src/Audio/SourceSeparation/DannaSep.cs
index 307856a570..bab43f745f 100644
--- a/src/Audio/SourceSeparation/DannaSep.cs
+++ b/src/Audio/SourceSeparation/DannaSep.cs
@@ -43,7 +43,7 @@ namespace AiDotNet.Audio.SourceSeparation;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Danna-Sep: Unite to Separate - A Unified Model for Audio Source Separation", "https://doi.org/10.48550/arXiv.2410.11145", Year = 2024, Authors = "Dongchao Yang, Songxiang Liu, Yuanyuan Wang, Helen Meng")]
-public class DannaSep<T> : AudioNeuralNetworkBase<T>, IMusicSourceSeparator<T>
+public partial class DannaSep<T> : AudioNeuralNetworkBase<T>, IMusicSourceSeparator<T>
 {
     /// <inheritdoc />
     /// <remarks>
@@ -266,33 +266,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty);
-        w.Write(_options.SampleRate); w.Write(_options.FftSize); w.Write(_options.HopLength);
-        w.Write(_options.NumFreqBins); w.Write(_options.EncoderDim); w.Write(_options.NumDualPathBlocks);
-        w.Write(_options.ChunkSize); w.Write(_options.NumHeads); w.Write(_options.NumSources);
-        w.Write(_options.SourceNames.Length);
-        foreach (var s in _options.SourceNames) w.Write(s);
-        w.Write(_options.DropoutRate);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.SampleRate = r.ReadInt32(); _options.FftSize = r.ReadInt32(); _options.HopLength = r.ReadInt32();
-        _options.NumFreqBins = r.ReadInt32(); _options.EncoderDim = r.ReadInt32(); _options.NumDualPathBlocks = r.ReadInt32();
-        _options.ChunkSize = r.ReadInt32(); _options.NumHeads = r.ReadInt32(); _options.NumSources = r.ReadInt32();
-        int numNames = r.ReadInt32();
-        var names = new string[numNames]; for (int i = 0; i < numNames; i++) names[i] = r.ReadString();
-        _options.SourceNames = names;
-        _options.DropoutRate = r.ReadDouble();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-        => new DannaSep<T>(Architecture, _options);
+
 
     #endregion
 
diff --git a/src/Audio/SourceSeparation/HTDemucs.cs b/src/Audio/SourceSeparation/HTDemucs.cs
index f3661f5752..c9ff159751 100644
--- a/src/Audio/SourceSeparation/HTDemucs.cs
+++ b/src/Audio/SourceSeparation/HTDemucs.cs
@@ -196,26 +196,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty);
-        w.Write(_options.SampleRate); w.Write(_options.FftSize); w.Write(_options.HopLength); w.Write(_options.NumFreqBins);
-        w.Write(_options.TransformerDim); w.Write(_options.NumTransformerLayers); w.Write(_options.NumAttentionHeads);
-        w.Write(_options.NumStems); w.Write(_options.DropoutRate);
-        w.Write(_options.Sources.Length); foreach (var s in _options.Sources) w.Write(s);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.SampleRate = r.ReadInt32(); _options.FftSize = r.ReadInt32(); _options.HopLength = r.ReadInt32(); _options.NumFreqBins = r.ReadInt32();
-        _options.TransformerDim = r.ReadInt32(); _options.NumTransformerLayers = r.ReadInt32(); _options.NumAttentionHeads = r.ReadInt32();
-        _options.NumStems = r.ReadInt32(); _options.DropoutRate = r.ReadDouble();
-        int n = r.ReadInt32(); _options.Sources = new string[n]; for (int i = 0; i < n; i++) _options.Sources[i] = r.ReadString();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() => new HTDemucs<T>(Architecture, _options);
+
 
     #endregion
 
diff --git a/src/Audio/SourceSeparation/MelBandRoFormer.cs b/src/Audio/SourceSeparation/MelBandRoFormer.cs
index b3a72ec676..104db707b6 100644
--- a/src/Audio/SourceSeparation/MelBandRoFormer.cs
+++ b/src/Audio/SourceSeparation/MelBandRoFormer.cs
@@ -198,26 +198,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty);
-        w.Write(_options.SampleRate); w.Write(_options.FftSize); w.Write(_options.HopLength); w.Write(_options.NumFreqBins);
-        w.Write(_options.NumMelBands); w.Write(_options.TransformerDim); w.Write(_options.NumTransformerLayers);
-        w.Write(_options.NumStems); w.Write(_options.DropoutRate);
-        w.Write(_options.Sources.Length); foreach (var s in _options.Sources) w.Write(s);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.SampleRate = r.ReadInt32(); _options.FftSize = r.ReadInt32(); _options.HopLength = r.ReadInt32(); _options.NumFreqBins = r.ReadInt32();
-        _options.NumMelBands = r.ReadInt32(); _options.TransformerDim = r.ReadInt32(); _options.NumTransformerLayers = r.ReadInt32();
-        _options.NumStems = r.ReadInt32(); _options.DropoutRate = r.ReadDouble();
-        int n = r.ReadInt32(); _options.Sources = new string[n]; for (int i = 0; i < n; i++) _options.Sources[i] = r.ReadString();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() => new MelBandRoFormer<T>(Architecture, _options);
+
 
     #endregion
 
diff --git a/src/Audio/SourceSeparation/MusicSourceSeparator.cs b/src/Audio/SourceSeparation/MusicSourceSeparator.cs
index 21a6220c4c..89454db9db 100644
--- a/src/Audio/SourceSeparation/MusicSourceSeparator.cs
+++ b/src/Audio/SourceSeparation/MusicSourceSeparator.cs
@@ -798,15 +798,7 @@ public override ModelMetadata<T> GetModelMetadata()
     /// <summary>
     /// Serializes network-specific data.
     /// </summary>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.FftSize);
-        writer.Write(_options.HopLength);
-        writer.Write(_options.StemCount);
-        writer.Write(_options.HpssKernelSize);
-        writer.Write(_useNativeMode);
-    }
+
 
     /// <summary>
     /// Deserializes network-specific data — the inverse of
@@ -824,58 +816,7 @@ protected override void SerializeNetworkSpecificData(BinaryWriter writer)
     /// with the right options.
     /// </para>
     /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        int sampleRate = reader.ReadInt32();
-        int fftSize = reader.ReadInt32();
-        int hopLength = reader.ReadInt32();
-        int stemCount = reader.ReadInt32();
-        int hpssKernelSize = reader.ReadInt32();
-        bool useNativeMode = reader.ReadBoolean();
-
-        if (sampleRate != _options.SampleRate)
-            throw new InvalidOperationException(
-                $"Deserialized SampleRate ({sampleRate}) does not match constructor option ({_options.SampleRate}). " +
-                "Reconstruct MusicSourceSeparator with matching options before loading this model.");
-        if (fftSize != _options.FftSize)
-            throw new InvalidOperationException(
-                $"Deserialized FftSize ({fftSize}) does not match constructor option ({_options.FftSize}).");
-        if (hopLength != _options.HopLength)
-            throw new InvalidOperationException(
-                $"Deserialized HopLength ({hopLength}) does not match constructor option ({_options.HopLength}).");
-        if (stemCount != _options.StemCount)
-            throw new InvalidOperationException(
-                $"Deserialized StemCount ({stemCount}) does not match constructor option ({_options.StemCount}).");
-        if (hpssKernelSize != _options.HpssKernelSize)
-            throw new InvalidOperationException(
-                $"Deserialized HpssKernelSize ({hpssKernelSize}) does not match constructor option ({_options.HpssKernelSize}).");
-
-        _useNativeMode = useNativeMode;
-
-        // The base deserializer has just replaced Layers with the restored instances.
-        // Rebind the explicit Demucs forward to those instances so inference and
-        // training consume the restored weights rather than constructor-fresh layers.
-        // THE RETURN VALUE DECIDES WHETHER THE MODEL IS USABLE, so discarding it defeated the point
-        // of returning it. On failure the method has already cleared every typed list and set
-        // _demucsDepth to 0, so HasBoundDemucsTopology goes false, PredictCore silently routes to
-        // base.PredictCore, and the caller gets separations from a generic forward pass rather than
-        // Demucs -- from a model they just deserialized and have every reason to believe is intact.
-        if (_useNativeMode && !TryBindDemucsTopologyFromLayers())
-        {
-            throw new InvalidOperationException(
-                "Deserialization restored the layer list, but it does not match the Demucs topology, so " +
-                "the explicit Demucs forward could not be rebound. Continuing would silently fall back " +
-                "to a generic forward pass and return separations that are not Demucs's.");
-        }
-    }
 
-    /// <summary>
-    /// Creates a new instance of this network type.
-    /// </summary>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new MusicSourceSeparator<T>(Architecture, _options);
-    }
 
     #endregion
 
diff --git a/src/Audio/SourceSeparation/SCNet.cs b/src/Audio/SourceSeparation/SCNet.cs
index e4bed58531..5560588829 100644
--- a/src/Audio/SourceSeparation/SCNet.cs
+++ b/src/Audio/SourceSeparation/SCNet.cs
@@ -42,7 +42,7 @@ namespace AiDotNet.Audio.SourceSeparation;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("SCNet: Sparse Compression Network for Music Source Separation", "https://doi.org/10.48550/arXiv.2401.13276", Year = 2024, Authors = "Weinan Tong, Jiaxu Zhu, Jun Chen, Shiyin Kang, Tao Jiang, Yang Li, Zhiyong Wu, Helen Meng")]
-public class SCNet<T> : AudioNeuralNetworkBase<T>, IMusicSourceSeparator<T>
+public partial class SCNet<T> : AudioNeuralNetworkBase<T>, IMusicSourceSeparator<T>
 {
     /// <inheritdoc />
     /// <remarks>
@@ -320,34 +320,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty);
-        w.Write(_options.SampleRate); w.Write(_options.FftSize); w.Write(_options.HopLength); w.Write(_options.NumFreqBins);
-        w.Write(_options.NumClusters); w.Write(_options.CompressionDim);
-        w.Write(_options.NumEncoderBlocks); w.Write(_options.NumDecoderBlocks);
-        w.Write(_options.NumAttentionHeads);
-        w.Write(_options.NumStems); w.Write(_options.DropoutRate);
-        w.Write(_options.Sources.Length); foreach (var s in _options.Sources) w.Write(s);
-        w.Write(_options.LearningRate); w.Write(_options.WeightDecay);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.SampleRate = r.ReadInt32(); _options.FftSize = r.ReadInt32(); _options.HopLength = r.ReadInt32(); _options.NumFreqBins = r.ReadInt32();
-        _options.NumClusters = r.ReadInt32(); _options.CompressionDim = r.ReadInt32();
-        _options.NumEncoderBlocks = r.ReadInt32(); _options.NumDecoderBlocks = r.ReadInt32();
-        _options.NumAttentionHeads = r.ReadInt32();
-        _options.NumStems = r.ReadInt32(); _options.DropoutRate = r.ReadDouble();
-        int n = r.ReadInt32(); _options.Sources = new string[n]; for (int i = 0; i < n; i++) _options.Sources[i] = r.ReadString();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions);
-        if (r.BaseStream.Position < r.BaseStream.Length) _options.LearningRate = r.ReadDouble();
-        if (r.BaseStream.Position < r.BaseStream.Length) _options.WeightDecay = r.ReadDouble();
-        if (_useNativeMode) _optimizer = CreateDefaultOptimizer();
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() => new SCNet<T>(Architecture, new SCNetOptions(_options));
+
 
     #endregion
 
diff --git a/src/Audio/Speaker/CAMPlusPlus.cs b/src/Audio/Speaker/CAMPlusPlus.cs
index ce87053a98..2e21278c42 100644
--- a/src/Audio/Speaker/CAMPlusPlus.cs
+++ b/src/Audio/Speaker/CAMPlusPlus.cs
@@ -273,28 +273,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty);
-        w.Write(_options.SampleRate); w.Write(_options.NumMels);
-        w.Write(_options.InitialChannels); w.Write(_options.GrowthRate); w.Write(_options.NumBlocks);
-        w.Write(_options.BottleneckDim); w.Write(_options.MaskingDim);
-        w.Write(_options.PoolingDim); w.Write(_options.EmbeddingDim);
-        w.Write(_options.DropoutRate); w.Write(_options.DefaultThreshold);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.SampleRate = r.ReadInt32(); _options.NumMels = r.ReadInt32();
-        _options.InitialChannels = r.ReadInt32(); _options.GrowthRate = r.ReadInt32(); _options.NumBlocks = r.ReadInt32();
-        _options.BottleneckDim = r.ReadInt32(); _options.MaskingDim = r.ReadInt32();
-        _options.PoolingDim = r.ReadInt32(); _options.EmbeddingDim = r.ReadInt32();
-        _options.DropoutRate = r.ReadDouble(); _options.DefaultThreshold = r.ReadDouble();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() => new CAMPlusPlus<T>(Architecture, _options);
+
 
     #endregion
 
diff --git a/src/Audio/Speaker/ECAPATDNNSpeaker.cs b/src/Audio/Speaker/ECAPATDNNSpeaker.cs
index 0126252216..9aa39e000d 100644
--- a/src/Audio/Speaker/ECAPATDNNSpeaker.cs
+++ b/src/Audio/Speaker/ECAPATDNNSpeaker.cs
@@ -285,26 +285,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty);
-        w.Write(_options.SampleRate); w.Write(_options.NumMels); w.Write(_options.EmbeddingDim);
-        w.Write(_options.PoolingDim); w.Write(_options.SEBottleneckDim); w.Write(_options.Res2NetScale);
-        w.Write(_options.DropoutRate); w.Write(_options.DefaultThreshold);
-        w.Write(_options.Channels.Length); foreach (var c in _options.Channels) w.Write(c);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.SampleRate = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.EmbeddingDim = r.ReadInt32();
-        _options.PoolingDim = r.ReadInt32(); _options.SEBottleneckDim = r.ReadInt32(); _options.Res2NetScale = r.ReadInt32();
-        _options.DropoutRate = r.ReadDouble(); _options.DefaultThreshold = r.ReadDouble();
-        int n = r.ReadInt32(); _options.Channels = new int[n]; for (int i = 0; i < n; i++) _options.Channels[i] = r.ReadInt32();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() => new ECAPATDNNSpeaker<T>(Architecture, _options);
+
 
     #endregion
 
diff --git a/src/Audio/Speaker/PyAnnote.cs b/src/Audio/Speaker/PyAnnote.cs
index a0b8a1203b..32697af1e3 100644
--- a/src/Audio/Speaker/PyAnnote.cs
+++ b/src/Audio/Speaker/PyAnnote.cs
@@ -43,7 +43,7 @@ namespace AiDotNet.Audio.Speaker;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Powerset Multi-class Cross Entropy Loss for Neural Speaker Diarization", "https://doi.org/10.48550/arXiv.2310.13025", Year = 2023, Authors = "Alexis Plaquet, Hervé Bredin")]
-public class PyAnnote<T> : SpeakerRecognitionBase<T>, ISpeakerDiarizer<T>
+public partial class PyAnnote<T> : SpeakerRecognitionBase<T>, ISpeakerDiarizer<T>
 {
     #region Fields
 
@@ -345,30 +345,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty);
-        w.Write(_options.SampleRate); w.Write(_options.NumMels); w.Write(_options.EmbeddingDim);
-        w.Write(_options.SincNetFilters); w.Write(_options.LSTMHiddenSize); w.Write(_options.NumLSTMLayers);
-        w.Write(_options.LinearDim); w.Write(_options.MaxSpeakersPerChunk);
-        w.Write(_options.ChunkDurationSeconds); w.Write(_options.ChunkStepSeconds);
-        w.Write(_options.ClusteringThreshold); w.Write(_options.MinSegmentDuration);
-        w.Write(_options.EnableOverlapDetection); w.Write(_options.DropoutRate);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.SampleRate = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.EmbeddingDim = r.ReadInt32();
-        _options.SincNetFilters = r.ReadInt32(); _options.LSTMHiddenSize = r.ReadInt32(); _options.NumLSTMLayers = r.ReadInt32();
-        _options.LinearDim = r.ReadInt32(); _options.MaxSpeakersPerChunk = r.ReadInt32();
-        _options.ChunkDurationSeconds = r.ReadDouble(); _options.ChunkStepSeconds = r.ReadDouble();
-        _options.ClusteringThreshold = r.ReadDouble(); _options.MinSegmentDuration = r.ReadDouble();
-        _options.EnableOverlapDetection = r.ReadBoolean(); _options.DropoutRate = r.ReadDouble();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() => new PyAnnote<T>(Architecture, _options);
+
 
     #endregion
 
diff --git a/src/Audio/Speaker/SpeakerDiarizer.cs b/src/Audio/Speaker/SpeakerDiarizer.cs
index 7f3e8e86b9..338512bb03 100644
--- a/src/Audio/Speaker/SpeakerDiarizer.cs
+++ b/src/Audio/Speaker/SpeakerDiarizer.cs
@@ -1067,53 +1067,6 @@ public override ModelMetadata<T> GetModelMetadata()
         return metadata;
     }
 
-    /// <summary>
-    /// Serializes network-specific data.
-    /// </summary>
-    /// <param name="writer">Binary writer.</param>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(SampleRate);
-        writer.Write(EmbeddingDimension);
-        writer.Write(_options.ClusteringThreshold);
-        writer.Write(_options.MinTurnDuration);
-        writer.Write(_options.WindowDurationSeconds);
-        writer.Write(_options.HopDurationSeconds);
-    }
-
-    /// <summary>
-    /// Deserializes network-specific data.
-    /// </summary>
-    /// <param name="reader">Binary reader.</param>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        base.SampleRate = reader.ReadInt32();
-        EmbeddingDimension = reader.ReadInt32();
-        // Note: Options are readonly, values loaded for reference
-        _ = reader.ReadDouble(); // ClusteringThreshold
-        _ = reader.ReadDouble(); // MinTurnDuration
-        _ = reader.ReadDouble(); // WindowDurationSeconds
-        _ = reader.ReadDouble(); // HopDurationSeconds
-    }
-
-    /// <summary>
-    /// Creates a new instance of this model for cloning.
-    /// </summary>
-    /// <returns>New model instance.</returns>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode)
-        {
-            throw new NotSupportedException(
-                "CreateNewInstance is not supported for ONNX models. " +
-                "Create a new SpeakerDiarizer with the model path instead.");
-        }
-
-        return new SpeakerDiarizer<T>(
-            Architecture,
-            _options);
-    }
-
     #endregion
 
     #region IDisposable
diff --git a/src/Audio/Speaker/SpeakerEmbeddingExtractor.cs b/src/Audio/Speaker/SpeakerEmbeddingExtractor.cs
index 1331ae14d2..44b9041fe7 100644
--- a/src/Audio/Speaker/SpeakerEmbeddingExtractor.cs
+++ b/src/Audio/Speaker/SpeakerEmbeddingExtractor.cs
@@ -52,7 +52,7 @@ namespace AiDotNet.Audio.Speaker;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
     [ResearchPaper("X-Vectors: Robust DNN Embeddings for Speaker Recognition", "https://doi.org/10.1109/ICASSP.2018.8461375")]
-public class SpeakerEmbeddingExtractor<T> : SpeakerRecognitionBase<T>, ISpeakerEmbeddingExtractor<T>
+public partial class SpeakerEmbeddingExtractor<T> : SpeakerRecognitionBase<T>, ISpeakerEmbeddingExtractor<T>
 {
     #region Execution Mode
 
@@ -589,59 +589,12 @@ public override ModelMetadata<T> GetModelMetadata()
     /// <summary>
     /// Serializes network-specific data.
     /// </summary>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(SampleRate);
-        writer.Write(EmbeddingDimension);
-        writer.Write(MinimumDurationSeconds);
-        writer.Write(_useNativeMode);
-        writer.Write(_hiddenDim);
-        writer.Write(_numEncoderLayers);
-        writer.Write(_numHeads);
-    }
+
 
     /// <summary>
     /// Deserializes network-specific data.
     /// </summary>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        SampleRate = reader.ReadInt32();
-        EmbeddingDimension = reader.ReadInt32();
-        _ = reader.ReadDouble(); // MinimumDurationSeconds
-        _ = reader.ReadBoolean(); // useNativeMode
-        _ = reader.ReadInt32(); // hiddenDim
-        _ = reader.ReadInt32(); // numEncoderLayers
-        _ = reader.ReadInt32(); // numHeads
-    }
 
-    /// <summary>
-    /// Creates a new instance of this model for cloning.
-    /// </summary>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _modelPath is not null)
-        {
-            return new SpeakerEmbeddingExtractor<T>(
-                Architecture,
-                _modelPath,
-                SampleRate,
-                EmbeddingDimension,
-                MinimumDurationSeconds,
-                _options.OnnxOptions);
-        }
-        else
-        {
-            return new SpeakerEmbeddingExtractor<T>(
-                Architecture,
-                SampleRate,
-                EmbeddingDimension,
-                MinimumDurationSeconds,
-                _hiddenDim,
-                _numEncoderLayers,
-                _numHeads,
-                lossFunction: _lossFunction);
-        }
-    }
 
     #endregion
 
diff --git a/src/Audio/Speaker/SpeakerLM.cs b/src/Audio/Speaker/SpeakerLM.cs
index 2e23f52a54..fdada4624d 100644
--- a/src/Audio/Speaker/SpeakerLM.cs
+++ b/src/Audio/Speaker/SpeakerLM.cs
@@ -293,30 +293,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty);
-        w.Write(_options.SampleRate); w.Write(_options.NumMels);
-        w.Write(_options.EmbeddingDim); w.Write(_options.LMHiddenDim);
-        w.Write(_options.NumLMLayers); w.Write(_options.NumHeads);
-        w.Write(_options.MaxSpeakers); w.Write(_options.DefaultThreshold);
-        w.Write(_options.DropoutRate);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.SampleRate = r.ReadInt32(); _options.NumMels = r.ReadInt32();
-        _options.EmbeddingDim = r.ReadInt32(); _options.LMHiddenDim = r.ReadInt32();
-        _options.NumLMLayers = r.ReadInt32(); _options.NumHeads = r.ReadInt32();
-        _options.MaxSpeakers = r.ReadInt32(); _options.DefaultThreshold = r.ReadDouble();
-        _options.DropoutRate = r.ReadDouble();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-        => new SpeakerLM<T>(Architecture, _options);
+
 
     #endregion
 
diff --git a/src/Audio/Speaker/SpeakerRecognitionBase.cs b/src/Audio/Speaker/SpeakerRecognitionBase.cs
index 88824a51e6..c7d9f36107 100644
--- a/src/Audio/Speaker/SpeakerRecognitionBase.cs
+++ b/src/Audio/Speaker/SpeakerRecognitionBase.cs
@@ -27,7 +27,7 @@ namespace AiDotNet.Audio.Speaker;
 /// - Similarity computation methods
 /// </para>
 /// </remarks>
-public abstract class SpeakerRecognitionBase<T> : AudioNeuralNetworkBase<T>
+public abstract partial class SpeakerRecognitionBase<T> : AudioNeuralNetworkBase<T>
 {
     /// <summary>
     /// Gets the dimension of output speaker embeddings.
diff --git a/src/Audio/Speaker/SpeakerVerifier.cs b/src/Audio/Speaker/SpeakerVerifier.cs
index cf4d840e1f..4cdb907b62 100644
--- a/src/Audio/Speaker/SpeakerVerifier.cs
+++ b/src/Audio/Speaker/SpeakerVerifier.cs
@@ -528,63 +528,12 @@ public override ModelMetadata<T> GetModelMetadata()
     /// <summary>
     /// Serializes network-specific data.
     /// </summary>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(SampleRate);
-        writer.Write(EmbeddingDimension);
-        writer.Write(NumOps.ToDouble(DefaultThreshold));
-        writer.Write(_useNativeMode);
-        writer.Write(_hiddenDim);
-        writer.Write(_numEncoderLayers);
-        writer.Write(_numHeads);
-    }
+
 
     /// <summary>
     /// Deserializes network-specific data.
     /// </summary>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        SampleRate = reader.ReadInt32();
-        EmbeddingDimension = reader.ReadInt32();
-        _ = reader.ReadDouble(); // DefaultThreshold
-        _ = reader.ReadBoolean(); // useNativeMode
-        _ = reader.ReadInt32(); // hiddenDim
-        _ = reader.ReadInt32(); // numEncoderLayers
-        _ = reader.ReadInt32(); // numHeads
-
-        // Base deserialization replaces this instance's layer objects. Re-point the extractor
-        // at those restored (possibly trained) layers so Predict and Train remain one model.
-        _embeddingExtractor.Layers.Clear();
-        _embeddingExtractor.Layers.AddRange(Layers);
-    }
 
-    /// <summary>
-    /// Creates a new instance of this model for cloning.
-    /// </summary>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _embeddingModelPath is not null)
-        {
-            return new SpeakerVerifier<T>(
-                Architecture,
-                _embeddingModelPath,
-                SampleRate,
-                EmbeddingDimension,
-                NumOps.ToDouble(DefaultThreshold));
-        }
-        else
-        {
-            return new SpeakerVerifier<T>(
-                Architecture,
-                SampleRate,
-                EmbeddingDimension,
-                NumOps.ToDouble(DefaultThreshold),
-                _hiddenDim,
-                _numEncoderLayers,
-                _numHeads,
-                lossFunction: _lossFunction);
-        }
-    }
 
     #endregion
 
diff --git a/src/Audio/Speaker/TitaNet.cs b/src/Audio/Speaker/TitaNet.cs
index 0ef235440d..1f8504cfd4 100644
--- a/src/Audio/Speaker/TitaNet.cs
+++ b/src/Audio/Speaker/TitaNet.cs
@@ -330,26 +330,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty);
-        w.Write(_options.SampleRate); w.Write(_options.NumMels); w.Write(_options.EmbeddingDim);
-        w.Write(_options.EncoderDim); w.Write(_options.NumEncoderBlocks); w.Write(_options.ConvKernelSize);
-        w.Write(_options.AttentivePoolingDim); w.Write(_options.DropoutRate); w.Write(_options.DefaultThreshold);
-        w.Write(_options.Variant);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.SampleRate = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.EmbeddingDim = r.ReadInt32();
-        _options.EncoderDim = r.ReadInt32(); _options.NumEncoderBlocks = r.ReadInt32(); _options.ConvKernelSize = r.ReadInt32();
-        _options.AttentivePoolingDim = r.ReadInt32(); _options.DropoutRate = r.ReadDouble(); _options.DefaultThreshold = r.ReadDouble();
-        _options.Variant = r.ReadString();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() => new TitaNet<T>(Architecture, _options);
+
 
     #endregion
 
diff --git a/src/Audio/Speaker/WavLMSpeaker.cs b/src/Audio/Speaker/WavLMSpeaker.cs
index 16fffe2e15..f0fb27f58d 100644
--- a/src/Audio/Speaker/WavLMSpeaker.cs
+++ b/src/Audio/Speaker/WavLMSpeaker.cs
@@ -277,26 +277,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty);
-        w.Write(_options.SampleRate); w.Write(_options.Variant); w.Write(_options.NumMels);
-        w.Write(_options.HiddenDim); w.Write(_options.NumLayers); w.Write(_options.NumAttentionHeads);
-        w.Write(_options.FeedForwardDim); w.Write(_options.EmbeddingDim); w.Write(_options.DropoutRate);
-        w.Write(_options.DefaultThreshold);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.SampleRate = r.ReadInt32(); _options.Variant = r.ReadString(); _options.NumMels = r.ReadInt32();
-        _options.HiddenDim = r.ReadInt32(); _options.NumLayers = r.ReadInt32(); _options.NumAttentionHeads = r.ReadInt32();
-        _options.FeedForwardDim = r.ReadInt32(); _options.EmbeddingDim = r.ReadInt32(); _options.DropoutRate = r.ReadDouble();
-        _options.DefaultThreshold = r.ReadDouble();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() => new WavLMSpeaker<T>(Architecture, _options);
+
 
     #endregion
 
diff --git a/src/Audio/SpeechRecognition/CTCDecoder.cs b/src/Audio/SpeechRecognition/CTCDecoder.cs
index 1e85fd058f..282c159f63 100644
--- a/src/Audio/SpeechRecognition/CTCDecoder.cs
+++ b/src/Audio/SpeechRecognition/CTCDecoder.cs
@@ -51,7 +51,7 @@ namespace AiDotNet.Audio.SpeechRecognition;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Connectionist Temporal Classification: Labelling Unsegmented Sequence Data with Recurrent Neural Networks", "https://dl.acm.org/doi/10.1145/1143844.1143891", Year = 2006, Authors = "Alex Graves, Santiago Fernandez, Faustino Gomez, Jurgen Schmidhuber")]
-public class CTCDecoder<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
+public partial class CTCDecoder<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
 {
     /// <inheritdoc />
     /// <remarks>
@@ -226,30 +226,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty);
-        w.Write(_options.SampleRate); w.Write(_options.Variant);
-        w.Write(_options.EncoderDim); w.Write(_options.NumEncoderLayers);
-        w.Write(_options.NumAttentionHeads); w.Write(_options.FeedForwardDim);
-        w.Write(_options.NumMels); w.Write(_options.VocabSize);
-        w.Write(_options.BeamWidth); w.Write(_options.DropoutRate);
-        w.Write(_options.Language); w.Write(_options.BlankTokenIndex);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.SampleRate = r.ReadInt32(); _options.Variant = r.ReadString();
-        _options.EncoderDim = r.ReadInt32(); _options.NumEncoderLayers = r.ReadInt32();
-        _options.NumAttentionHeads = r.ReadInt32(); _options.FeedForwardDim = r.ReadInt32();
-        _options.NumMels = r.ReadInt32(); _options.VocabSize = r.ReadInt32();
-        _options.BeamWidth = r.ReadInt32(); _options.DropoutRate = r.ReadDouble();
-        _options.Language = r.ReadString(); _options.BlankTokenIndex = r.ReadInt32();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() => new CTCDecoder<T>(Architecture, _options);
+
 
     #endregion
 
diff --git a/src/Audio/SpeechRecognition/Canary.cs b/src/Audio/SpeechRecognition/Canary.cs
index a3dd36fafd..eb90e553e8 100644
--- a/src/Audio/SpeechRecognition/Canary.cs
+++ b/src/Audio/SpeechRecognition/Canary.cs
@@ -45,7 +45,7 @@ namespace AiDotNet.Audio.SpeechRecognition;
 [ModelComplexity(ModelComplexity.VeryHigh)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("NVIDIA Canary: An Open Multilingual Large ASR Model", "https://doi.org/10.48550/arXiv.2404.02592", Year = 2024, Authors = "Ankur Rekesh, Taejin Park, Subhankar Ghosh, Kolya Malkin, Samuel Kriman, Somshubra Majumdar, Boris Ginsburg")]
-public class Canary<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
+public partial class Canary<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
 {
     /// <inheritdoc />
     /// <remarks>
@@ -251,39 +251,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty);
-        w.Write(_options.SampleRate); w.Write(_options.Variant);
-        w.Write(_options.EncoderDim); w.Write(_options.NumEncoderLayers);
-        w.Write(_options.DecoderDim); w.Write(_options.NumDecoderLayers);
-        w.Write(_options.NumHeads); w.Write(_options.SubsamplingFactor);
-        w.Write(_options.VocabSize); w.Write(_options.BeamWidth);
-        w.Write(_options.MaxOutputTokens); w.Write(_options.TargetLanguage);
-        w.Write(_options.SupportedLanguages.Length);
-        foreach (var l in _options.SupportedLanguages) w.Write(l);
-        w.Write(_options.DropoutRate);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.SampleRate = r.ReadInt32(); _options.Variant = r.ReadString();
-        _options.EncoderDim = r.ReadInt32(); _options.NumEncoderLayers = r.ReadInt32();
-        _options.DecoderDim = r.ReadInt32(); _options.NumDecoderLayers = r.ReadInt32();
-        _options.NumHeads = r.ReadInt32(); _options.SubsamplingFactor = r.ReadInt32();
-        _options.VocabSize = r.ReadInt32(); _options.BeamWidth = r.ReadInt32();
-        _options.MaxOutputTokens = r.ReadInt32(); _options.TargetLanguage = r.ReadString();
-        int numLangs = r.ReadInt32();
-        var langs = new string[numLangs]; for (int i = 0; i < numLangs; i++) langs[i] = r.ReadString();
-        _options.SupportedLanguages = langs;
-        _options.DropoutRate = r.ReadDouble();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-        => new Canary<T>(Architecture, _options);
+
 
     #endregion
 
diff --git a/src/Audio/SpeechRecognition/Conformer.cs b/src/Audio/SpeechRecognition/Conformer.cs
index a50ae67c4f..239ac82059 100644
--- a/src/Audio/SpeechRecognition/Conformer.cs
+++ b/src/Audio/SpeechRecognition/Conformer.cs
@@ -47,7 +47,7 @@ namespace AiDotNet.Audio.SpeechRecognition;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Conformer: Convolution-augmented Transformer for Speech Recognition", "https://arxiv.org/abs/2005.08100", Year = 2020, Authors = "Anmol Gulati, James Qin, Chung-Cheng Chiu, Niki Parmar, Yu Zhang, Jiahui Yu, Wei Han, Shibo Wang, Zhengdong Zhang, Yonghui Wu, Ruoming Pang")]
-public class Conformer<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
+public partial class Conformer<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
 {
     /// <inheritdoc />
     /// <remarks>
@@ -226,31 +226,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty);
-        w.Write(_options.SampleRate); w.Write(_options.Variant);
-        w.Write(_options.EncoderDim); w.Write(_options.NumEncoderLayers);
-        w.Write(_options.NumAttentionHeads); w.Write(_options.FeedForwardExpansionFactor);
-        w.Write(_options.ConvKernelSize); w.Write(_options.NumMels);
-        w.Write(_options.VocabSize); w.Write(_options.DropoutRate);
-        w.Write(_options.Language);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.SampleRate = r.ReadInt32(); _options.Variant = r.ReadString();
-        _options.EncoderDim = r.ReadInt32(); _options.NumEncoderLayers = r.ReadInt32();
-        _options.NumAttentionHeads = r.ReadInt32(); _options.FeedForwardExpansionFactor = r.ReadInt32();
-        _options.ConvKernelSize = r.ReadInt32(); _options.NumMels = r.ReadInt32();
-        _options.VocabSize = r.ReadInt32(); _options.DropoutRate = r.ReadDouble();
-        _options.Language = r.ReadString();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-        => new Conformer<T>(Architecture, new ConformerOptions(_options));
+
 
     #endregion
 
diff --git a/src/Audio/SpeechRecognition/FastConformer.cs b/src/Audio/SpeechRecognition/FastConformer.cs
index c3a6ae407d..2b151b80cc 100644
--- a/src/Audio/SpeechRecognition/FastConformer.cs
+++ b/src/Audio/SpeechRecognition/FastConformer.cs
@@ -50,7 +50,7 @@ namespace AiDotNet.Audio.SpeechRecognition;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Fast Conformer with Linearly Scalable Attention for Efficient Speech Recognition", "https://doi.org/10.48550/arXiv.2305.05084", Year = 2023, Authors = "Dima Rekesh, Nithin Rao Koluguri, Samuel Kriman, Somshubra Majumdar, Vahid Noroozi, He Huang, Oleksii Hrinchuk, Krishna Puvvada, Ankur Kumar, Jagadeesh Balam, Boris Ginsburg")]
-public class FastConformer<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
+public partial class FastConformer<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
 {
     #region Fields
 
@@ -221,47 +221,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty);
-        w.Write(_options.SampleRate); w.Write(_options.Variant);
-        w.Write(_options.EncoderDim); w.Write(_options.NumLayers);
-        w.Write(_options.NumHeads); w.Write(_options.FeedForwardDim);
-        w.Write(_options.ConvKernelSize); w.Write(_options.DownsampleFactor);
-        w.Write(_options.NumMels); w.Write(_options.VocabSize);
-        w.Write(_options.DropoutRate); w.Write(_options.Language);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.SampleRate = r.ReadInt32(); _options.Variant = r.ReadString();
-        _options.EncoderDim = r.ReadInt32(); _options.NumLayers = r.ReadInt32();
-        _options.NumHeads = r.ReadInt32(); _options.FeedForwardDim = r.ReadInt32();
-        _options.ConvKernelSize = r.ReadInt32(); _options.DownsampleFactor = r.ReadInt32();
-        _options.NumMels = r.ReadInt32(); _options.VocabSize = r.ReadInt32();
-        _options.DropoutRate = r.ReadDouble(); _options.Language = r.ReadString();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } modelPath && !string.IsNullOrEmpty(modelPath))
-            return new FastConformer<T>(Architecture, modelPath, new FastConformerOptions(_options));
-
-        // A NON-ADAMW OPTIMIZER IS FORWARDED RATHER THAN DROPPED. The pattern-match rebuilds an AdamW
-        // from its options, which is the right thing when it matches -- the clone gets an independent
-        // optimizer with the same configuration. But the null on the other branch silently discarded a
-        // caller-supplied optimizer of any other type, so cloning an SGD- or Lion-trained model handed
-        // back one that had quietly reverted to the default. There is no generic way to deep-copy an
-        // arbitrary IGradientBasedOptimizer, so the instance is passed through: shared optimizer state
-        // between clone and original is a real limitation, and it is a smaller one than losing the
-        // caller's choice of algorithm without saying so.
-        var cloneOptimizer = _optimizer?.GetOptions() is AdamWOptimizerOptions<T, Tensor<T>, Tensor<T>> options
-            ? new AdamWOptimizer<T, Tensor<T>, Tensor<T>>(null, new AdamWOptimizerOptions<T, Tensor<T>, Tensor<T>>(options))
-            : _optimizer;
-        return new FastConformer<T>(Architecture, new FastConformerOptions(_options), cloneOptimizer);
-    }
+
 
     #endregion
 
diff --git a/src/Audio/SpeechRecognition/RNNTransducer.cs b/src/Audio/SpeechRecognition/RNNTransducer.cs
index 68e67bd87e..93ca14e96b 100644
--- a/src/Audio/SpeechRecognition/RNNTransducer.cs
+++ b/src/Audio/SpeechRecognition/RNNTransducer.cs
@@ -51,7 +51,7 @@ namespace AiDotNet.Audio.SpeechRecognition;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Sequence Transduction with Recurrent Neural Networks", "https://arxiv.org/abs/1211.3711", Year = 2012, Authors = "Alex Graves")]
-public class RNNTransducer<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
+public partial class RNNTransducer<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
 {
     /// <inheritdoc />
     /// <remarks>
@@ -229,32 +229,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty);
-        w.Write(_options.SampleRate); w.Write(_options.Variant);
-        w.Write(_options.EncoderDim); w.Write(_options.NumEncoderLayers);
-        w.Write(_options.NumEncoderHeads); w.Write(_options.PredictionDim);
-        w.Write(_options.NumPredictionLayers); w.Write(_options.EmbeddingDim);
-        w.Write(_options.JointDim); w.Write(_options.NumMels);
-        w.Write(_options.VocabSize); w.Write(_options.DropoutRate);
-        w.Write(_options.Language);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.SampleRate = r.ReadInt32(); _options.Variant = r.ReadString();
-        _options.EncoderDim = r.ReadInt32(); _options.NumEncoderLayers = r.ReadInt32();
-        _options.NumEncoderHeads = r.ReadInt32(); _options.PredictionDim = r.ReadInt32();
-        _options.NumPredictionLayers = r.ReadInt32(); _options.EmbeddingDim = r.ReadInt32();
-        _options.JointDim = r.ReadInt32(); _options.NumMels = r.ReadInt32();
-        _options.VocabSize = r.ReadInt32(); _options.DropoutRate = r.ReadDouble();
-        _options.Language = r.ReadString();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() => new RNNTransducer<T>(Architecture, _options);
+
 
     #endregion
 
diff --git a/src/Audio/SpeechRecognition/Wav2Vec2Model.cs b/src/Audio/SpeechRecognition/Wav2Vec2Model.cs
index 9b29ab85f9..59f90b0489 100644
--- a/src/Audio/SpeechRecognition/Wav2Vec2Model.cs
+++ b/src/Audio/SpeechRecognition/Wav2Vec2Model.cs
@@ -853,79 +853,12 @@ public override ModelMetadata<T> GetModelMetadata()
     /// <summary>
     /// Serializes network-specific data.
     /// </summary>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(SampleRate);
-        writer.Write(_maxAudioLengthSeconds);
-        writer.Write(_hiddenDim);
-        writer.Write(_numTransformerLayers);
-        writer.Write(_numHeads);
-        writer.Write(_ffDim);
-        writer.Write(_vocabSize);
-        writer.Write(_language ?? string.Empty);
-    }
+
 
     /// <summary>
     /// Deserializes network-specific data.
     /// </summary>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        SampleRate = reader.ReadInt32();
-        _maxAudioLengthSeconds = reader.ReadInt32();
-        _hiddenDim = reader.ReadInt32();
-        _numTransformerLayers = reader.ReadInt32();
-        _numHeads = reader.ReadInt32();
-        _ffDim = reader.ReadInt32();
-        _vocabSize = reader.ReadInt32();
-        _language = reader.ReadString();
-
-        // Reinitialize / re-link layers for native mode. The base deserialize has already populated
-        // Layers with the trained layers; re-link the typed forward-path sub-lists to THEM (the ctor
-        // populated them from fresh random layers, and the forward reads the sub-lists, not Layers —
-        // so without this a cloned/loaded model predicts untrained: #1221 Clone_AfterTraining).
-        if (_useNativeMode)
-        {
-            if (Layers.Count > 0)
-                DistributeLayersToSubLists();
-            else
-                // Layers.Count == 0 (older/empty native payload): rebuild the default native layers.
-                // InitializeLayers() is the ONNX no-op and would leave a native model with no
-                // feature-encoder/transformer/CTC layers at all — a silently broken model.
-                InitializeNativeLayers();
-        }
-    }
 
-    /// <summary>
-    /// Creates a new instance of this model for cloning.
-    /// </summary>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (_useNativeMode)
-        {
-            return new Wav2Vec2Model<T>(
-                Architecture,
-                language: _language,
-                sampleRate: SampleRate,
-                maxAudioLengthSeconds: _maxAudioLengthSeconds,
-                hiddenDim: _hiddenDim,
-                numTransformerLayers: _numTransformerLayers,
-                numHeads: _numHeads,
-                ffDim: _ffDim,
-                vocabulary: _vocabulary);
-        }
-        else
-        {
-            return new Wav2Vec2Model<T>(
-                Architecture,
-                modelPath: _modelPath!,
-                language: _language,
-                sampleRate: SampleRate,
-                maxAudioLengthSeconds: _maxAudioLengthSeconds,
-                vocabulary: _vocabulary);
-        }
-    }
 
     #endregion
 
diff --git a/src/Audio/SpeechRecognition/Zipformer.cs b/src/Audio/SpeechRecognition/Zipformer.cs
index ae698e58eb..90cf7f8350 100644
--- a/src/Audio/SpeechRecognition/Zipformer.cs
+++ b/src/Audio/SpeechRecognition/Zipformer.cs
@@ -49,7 +49,7 @@ namespace AiDotNet.Audio.SpeechRecognition;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Zipformer: A faster and better encoder for automatic speech recognition", "https://arxiv.org/abs/2310.11230", Year = 2023, Authors = "Zengwei Yao, Liyong Guo, Xiaoyu Yang, Wei Kang, Fangjun Kuang, Yifan Yang, Zengrui Jin, Long Lin, Daniel Povey")]
-public class Zipformer<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
+public partial class Zipformer<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
 {
     /// <inheritdoc />
     /// <remarks>
@@ -232,36 +232,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty);
-        w.Write(_options.SampleRate); w.Write(_options.Variant);
-        w.Write(_options.NumMels); w.Write(_options.VocabSize);
-        w.Write(_options.EncoderDims.Length);
-        foreach (int d in _options.EncoderDims) w.Write(d);
-        w.Write(_options.NumLayersPerStack.Length);
-        foreach (int n in _options.NumLayersPerStack) w.Write(n);
-        w.Write(_options.NumHeadsPerStack.Length);
-        foreach (int h in _options.NumHeadsPerStack) w.Write(h);
-        w.Write(_options.DownsampleFactors.Length);
-        foreach (int f in _options.DownsampleFactors) w.Write(f);
-        w.Write(_options.DropoutRate); w.Write(_options.Language);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.SampleRate = r.ReadInt32(); _options.Variant = r.ReadString();
-        _options.NumMels = r.ReadInt32(); _options.VocabSize = r.ReadInt32();
-        int dimsLen = r.ReadInt32(); _options.EncoderDims = new int[dimsLen]; for (int i = 0; i < dimsLen; i++) _options.EncoderDims[i] = r.ReadInt32();
-        int layersLen = r.ReadInt32(); _options.NumLayersPerStack = new int[layersLen]; for (int i = 0; i < layersLen; i++) _options.NumLayersPerStack[i] = r.ReadInt32();
-        int headsLen = r.ReadInt32(); _options.NumHeadsPerStack = new int[headsLen]; for (int i = 0; i < headsLen; i++) _options.NumHeadsPerStack[i] = r.ReadInt32();
-        int dsLen = r.ReadInt32(); _options.DownsampleFactors = new int[dsLen]; for (int i = 0; i < dsLen; i++) _options.DownsampleFactors[i] = r.ReadInt32();
-        _options.DropoutRate = r.ReadDouble(); _options.Language = r.ReadString();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() => new Zipformer<T>(Architecture, _options);
+
 
     #endregion
 
diff --git a/src/Audio/StableAudio/StableAudioModel.cs b/src/Audio/StableAudio/StableAudioModel.cs
index 5cbd020bff..dc1d48e168 100644
--- a/src/Audio/StableAudio/StableAudioModel.cs
+++ b/src/Audio/StableAudio/StableAudioModel.cs
@@ -67,7 +67,7 @@ namespace AiDotNet.Audio.StableAudio;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Stable Audio: Fast Timing-Conditioned Latent Audio Diffusion", "https://arxiv.org/abs/2402.04825", Year = 2024, Authors = "Zach Evans, CJ Carr, Josiah Taylor, Scott H. Hawley, Jordi Pons")]
-public class StableAudioModel<T> : AudioNeuralNetworkBase<T>, IAudioGenerator<T>
+public partial class StableAudioModel<T> : AudioNeuralNetworkBase<T>, IAudioGenerator<T>
 {
     /// <inheritdoc />
     /// <remarks>
@@ -1048,41 +1048,12 @@ public override ModelMetadata<T> GetModelMetadata()
     /// <summary>
     /// Serializes network-specific data.
     /// </summary>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write((int)_options.ModelSize);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.NumInferenceSteps);
-        writer.Write(_options.GuidanceScale);
-        writer.Write(_options.Stereo);
-    }
+
 
     /// <summary>
     /// Deserializes network-specific data.
     /// </summary>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _ = reader.ReadBoolean();
-        _ = reader.ReadInt32();
-        _ = reader.ReadInt32();
-        _ = reader.ReadInt32();
-        _ = reader.ReadDouble();
-        _ = reader.ReadBoolean();
-    }
 
-    /// <summary>
-    /// Creates a new instance for cloning.
-    /// </summary>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new StableAudioModel<T>(
-            Architecture,
-            _options,
-            _tokenizer,
-            null,
-            _lossFunction);
-    }
 
     #endregion
 
diff --git a/src/Audio/TextToSpeech/CosyVoice2.cs b/src/Audio/TextToSpeech/CosyVoice2.cs
index 4ce10b9e5d..7b6fdfdad7 100644
--- a/src/Audio/TextToSpeech/CosyVoice2.cs
+++ b/src/Audio/TextToSpeech/CosyVoice2.cs
@@ -46,7 +46,7 @@ namespace AiDotNet.Audio.TextToSpeech;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("CosyVoice 2: Scalable Streaming Speech Synthesis with Large Language Models", "https://arxiv.org/abs/2412.10117", Year = 2024, Authors = "Zhihao Du, Yuxuan Wang, Qian Chen, Xian Shi, Xiang Lv, Tianyu Zhao, Zhifu Gao, Yexin Yang, Changfeng Gao, Hui Wang, Fan Yu, Huadai Liu, Zhengyan Sheng, Yue Gu, Chong Deng, Wen Wang, Shiliang Zhang, Zhijie Yan, Jinren Zhou")]
-public class CosyVoice2<T> : AudioNeuralNetworkBase<T>, ITextToSpeech<T>
+public partial class CosyVoice2<T> : AudioNeuralNetworkBase<T>, ITextToSpeech<T>
 {
     /// <inheritdoc />
     /// <remarks>
@@ -252,30 +252,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty);
-        w.Write(_options.SampleRate); w.Write(_options.Variant);
-        w.Write(_options.TextEncoderDim); w.Write(_options.NumTextEncoderLayers);
-        w.Write(_options.DecoderDim); w.Write(_options.NumDecoderLayers);
-        w.Write(_options.NumMels); w.Write(_options.SpeakerEmbeddingDim);
-        w.Write(_options.DropoutRate);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.SampleRate = r.ReadInt32(); _options.Variant = r.ReadString();
-        _options.TextEncoderDim = r.ReadInt32(); _options.NumTextEncoderLayers = r.ReadInt32();
-        _options.DecoderDim = r.ReadInt32(); _options.NumDecoderLayers = r.ReadInt32();
-        _options.NumMels = r.ReadInt32(); _options.SpeakerEmbeddingDim = r.ReadInt32();
-        _options.DropoutRate = r.ReadDouble();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-        => new CosyVoice2<T>(Architecture, _options);
+
 
     #endregion
 
@@ -318,6 +297,7 @@ private sealed class CosyVoice2StreamingSession : IStreamingSynthesisSession<T>
     {
         private readonly CosyVoice2<T> _model;
         private readonly double _speakingRate;
+        [Scratch]
         private readonly List<Tensor<T>> _pendingAudio = [];
         private string _textBuffer = string.Empty;
         private bool _disposed;
diff --git a/src/Audio/TextToSpeech/MatchaTTS.cs b/src/Audio/TextToSpeech/MatchaTTS.cs
index 781baac874..62160a7b94 100644
--- a/src/Audio/TextToSpeech/MatchaTTS.cs
+++ b/src/Audio/TextToSpeech/MatchaTTS.cs
@@ -51,7 +51,7 @@ namespace AiDotNet.Audio.TextToSpeech;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Matcha-TTS: A fast TTS architecture with conditional flow matching", "https://arxiv.org/abs/2309.03199", Year = 2024, Authors = "Shivam Mehta, Ruibo Tu, Jonas Beskow, Eva Szekely, Gustav Eje Henter")]
-public class MatchaTTS<T> : AudioNeuralNetworkBase<T>, ITextToSpeech<T>
+public partial class MatchaTTS<T> : AudioNeuralNetworkBase<T>, ITextToSpeech<T>
 {
     /// <inheritdoc />
     /// <remarks>
@@ -229,30 +229,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty);
-        w.Write(_options.SampleRate); w.Write(_options.Variant);
-        w.Write(_options.TextEncoderDim); w.Write(_options.NumTextEncoderLayers);
-        w.Write(_options.NumTextEncoderHeads); w.Write(_options.DecoderDim);
-        w.Write(_options.NumDecoderLayers); w.Write(_options.NumSynthesisSteps);
-        w.Write(_options.Temperature); w.Write(_options.NumMels);
-        w.Write(_options.DropoutRate);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.SampleRate = r.ReadInt32(); _options.Variant = r.ReadString();
-        _options.TextEncoderDim = r.ReadInt32(); _options.NumTextEncoderLayers = r.ReadInt32();
-        _options.NumTextEncoderHeads = r.ReadInt32(); _options.DecoderDim = r.ReadInt32();
-        _options.NumDecoderLayers = r.ReadInt32(); _options.NumSynthesisSteps = r.ReadInt32();
-        _options.Temperature = r.ReadDouble(); _options.NumMels = r.ReadInt32();
-        _options.DropoutRate = r.ReadDouble();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() => new MatchaTTS<T>(Architecture, _options);
+
 
     #endregion
 
diff --git a/src/Audio/TextToSpeech/StyleTTS2.cs b/src/Audio/TextToSpeech/StyleTTS2.cs
index 61ee05f611..3a013a2c56 100644
--- a/src/Audio/TextToSpeech/StyleTTS2.cs
+++ b/src/Audio/TextToSpeech/StyleTTS2.cs
@@ -48,7 +48,7 @@ namespace AiDotNet.Audio.TextToSpeech;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("StyleTTS 2: Towards Human-Level Text-to-Speech through Style Diffusion and Adversarial Training with Large Speech Language Models", "https://arxiv.org/abs/2306.07691", Year = 2023, Authors = "Yinghao Aaron Li, Cong Han, Vinay S. Raber, Nima Mesgarani")]
-public class StyleTTS2<T> : AudioNeuralNetworkBase<T>, ITextToSpeech<T>
+public partial class StyleTTS2<T> : AudioNeuralNetworkBase<T>, ITextToSpeech<T>
 {
     /// <inheritdoc />
     /// <remarks>
@@ -253,30 +253,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty);
-        w.Write(_options.SampleRate); w.Write(_options.Variant);
-        w.Write(_options.TextEncoderDim); w.Write(_options.NumTextEncoderLayers);
-        w.Write(_options.StyleDim); w.Write(_options.ProsodyDim);
-        w.Write(_options.NumMels); w.Write(_options.NumAttentionHeads);
-        w.Write(_options.SpeakerEmbeddingDim); w.Write(_options.IsMultiSpeaker);
-        w.Write(_options.NumDiffusionSteps); w.Write(_options.DropoutRate);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.SampleRate = r.ReadInt32(); _options.Variant = r.ReadString();
-        _options.TextEncoderDim = r.ReadInt32(); _options.NumTextEncoderLayers = r.ReadInt32();
-        _options.StyleDim = r.ReadInt32(); _options.ProsodyDim = r.ReadInt32();
-        _options.NumMels = r.ReadInt32(); _options.NumAttentionHeads = r.ReadInt32();
-        _options.SpeakerEmbeddingDim = r.ReadInt32(); _options.IsMultiSpeaker = r.ReadBoolean();
-        _options.NumDiffusionSteps = r.ReadInt32(); _options.DropoutRate = r.ReadDouble();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() => new StyleTTS2<T>(Architecture, _options);
+
 
     #endregion
 
diff --git a/src/Audio/TextToSpeech/Tacotron2Model.cs b/src/Audio/TextToSpeech/Tacotron2Model.cs
index 3854609304..962e540b05 100644
--- a/src/Audio/TextToSpeech/Tacotron2Model.cs
+++ b/src/Audio/TextToSpeech/Tacotron2Model.cs
@@ -1,4 +1,4 @@
-using AiDotNet.ActivationFunctions;
+using AiDotNet.ActivationFunctions;
 using AiDotNet.Attributes;
 using AiDotNet.Diffusion.Audio;
 using AiDotNet.Enums;
@@ -1016,117 +1016,12 @@ public override ModelMetadata<T> GetModelMetadata()
     /// <summary>
     /// Serializes network-specific data.
     /// </summary>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(SampleRate);
-        writer.Write(NumMels);
-        writer.Write(_speakingRate);
-        writer.Write(_vocabSize);
-        writer.Write(_embeddingDim);
-        writer.Write(_encoderDim);
-        writer.Write(_decoderDim);
-        writer.Write(_attentionDim);
-        writer.Write(_prenetDim);
-        writer.Write(_postnetEmbeddingDim);
-        writer.Write(_numEncoderConvLayers);
-        writer.Write(_numPostnetConvLayers);
-        writer.Write(_numMelsPerFrame);
-        writer.Write(_maxDecoderSteps);
-        writer.Write(_stopThreshold);
-        writer.Write(_fftSize);
-        writer.Write(_hopLength);
-        writer.Write(_griffinLimIterations);
-        // Added at the tail for backward compatibility with model payloads
-        // written before attentionFilters was persisted.
-        writer.Write(_attentionFilters);
-    }
+
 
     /// <summary>
     /// Deserializes network-specific data.
     /// </summary>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        // Note: _useNativeMode is readonly and set at construction
-        // Deserialized models operate in native mode
-        _ = reader.ReadBoolean(); // useNativeMode (read but not assigned)
-
-        // Restore audio configuration
-        SampleRate = reader.ReadInt32();
-        NumMels = reader.ReadInt32();
-        _speakingRate = reader.ReadDouble();
-
-        // Restore architecture parameters
-        _vocabSize = reader.ReadInt32();
-        _embeddingDim = reader.ReadInt32();
-        _encoderDim = reader.ReadInt32();
-        _decoderDim = reader.ReadInt32();
-        _attentionDim = reader.ReadInt32();
-        _prenetDim = reader.ReadInt32();
-        _postnetEmbeddingDim = reader.ReadInt32();
-        _numEncoderConvLayers = reader.ReadInt32();
-        _numPostnetConvLayers = reader.ReadInt32();
-        _numMelsPerFrame = reader.ReadInt32();
-        _maxDecoderSteps = reader.ReadInt32();
-        _stopThreshold = reader.ReadDouble();
-        _fftSize = reader.ReadInt32();
-        _hopLength = reader.ReadInt32();
-        _griffinLimIterations = reader.ReadInt32();
-        if (reader.BaseStream.Position < reader.BaseStream.Length)
-            _attentionFilters = reader.ReadInt32();
-
-        // Base deserialization has recreated the published Layers list by this
-        // point. Rebind native component views to those restored instances.
-        if (_useNativeMode)
-            BindNativeLayersFromPublishedList();
-    }
 
-    /// <summary>
-    /// Creates a new instance of this model for cloning.
-    /// </summary>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _acousticModelPath is not null)
-        {
-            return new Tacotron2Model<T>(
-                Architecture,
-                _acousticModelPath,
-                _vocoderPath,
-                SampleRate,
-                NumMels,
-                _speakingRate,
-                _maxDecoderSteps,
-                _stopThreshold,
-                _fftSize,
-                _hopLength,
-                _griffinLimIterations);
-        }
-        else
-        {
-            return new Tacotron2Model<T>(
-                Architecture,
-                SampleRate,
-                NumMels,
-                _speakingRate,
-                _vocabSize,
-                _embeddingDim,
-                _encoderDim,
-                _decoderDim,
-                _attentionDim,
-                _attentionFilters,
-                _prenetDim,
-                _postnetEmbeddingDim,
-                _numEncoderConvLayers,
-                _numPostnetConvLayers,
-                _numMelsPerFrame,
-                _maxDecoderSteps,
-                _stopThreshold,
-                _fftSize,
-                _hopLength,
-                _griffinLimIterations,
-                lossFunction: _lossFunction);
-        }
-    }
 
     #endregion
 
diff --git a/src/Audio/TextToSpeech/TtsModel.cs b/src/Audio/TextToSpeech/TtsModel.cs
index 91ab54c95a..fc978199ad 100644
--- a/src/Audio/TextToSpeech/TtsModel.cs
+++ b/src/Audio/TextToSpeech/TtsModel.cs
@@ -63,7 +63,7 @@ namespace AiDotNet.Audio.TextToSpeech;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("FastSpeech 2: Fast and High-Quality End-to-End Text to Speech", "https://arxiv.org/abs/2006.04558", Year = 2021, Authors = "Yi Ren, Chenxu Hu, Xu Tan, Tao Qin, Sheng Zhao, Zhou Zhao, Tie-Yan Liu")]
-public class TtsModel<T> : AudioNeuralNetworkBase<T>, ITextToSpeech<T>
+public partial class TtsModel<T> : AudioNeuralNetworkBase<T>, ITextToSpeech<T>
 {
     private readonly TtsOptions _options;
 
@@ -755,86 +755,12 @@ public override ModelMetadata<T> GetModelMetadata()
     /// <summary>
     /// Serializes network-specific data.
     /// </summary>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(SampleRate);
-        writer.Write(NumMels);
-        writer.Write(_speakingRate);
-        writer.Write(_energy);
-        writer.Write(_useGriffinLimFallback);
-        writer.Write(_useNativeMode);
-        writer.Write(_hiddenDim);
-        writer.Write(_numHeads);
-        writer.Write(_numEncoderLayers);
-        writer.Write(_numDecoderLayers);
-        writer.Write(_maxPhonemeLength);
-    }
+
 
     /// <summary>
     /// Deserializes network-specific data.
     /// </summary>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        SampleRate = reader.ReadInt32();
-        NumMels = reader.ReadInt32();
-        // Other fields are readonly and set during construction
-        // Read them but don't assign
-        _ = reader.ReadDouble(); // speakingRate
-        _ = reader.ReadDouble(); // energy
-        _ = reader.ReadBoolean(); // useGriffinLimFallback
-        _ = reader.ReadBoolean(); // useNativeMode
-        _ = reader.ReadInt32(); // hiddenDim
-        _ = reader.ReadInt32(); // numHeads
-        _ = reader.ReadInt32(); // numEncoderLayers
-        _ = reader.ReadInt32(); // numDecoderLayers
-        _ = reader.ReadInt32(); // maxPhonemeLength
-    }
 
-    /// <summary>
-    /// Creates a new instance of this model for cloning.
-    /// </summary>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _acousticModelPath is not null)
-        {
-            return new TtsModel<T>(
-                Architecture,
-                _acousticModelPath,
-                _vocoderModelPath,
-                SampleRate,
-                NumMels,
-                _speakingRate,
-                _pitchShift,
-                _energy,
-                _speakerId,
-                _language,
-                _useGriffinLimFallback,
-                _griffinLimIterations,
-                _fftSize,
-                _hopLength);
-        }
-        else
-        {
-            return new TtsModel<T>(
-                Architecture,
-                SampleRate,
-                NumMels,
-                _speakingRate,
-                _pitchShift,
-                _energy,
-                _speakerId,
-                _language,
-                _hiddenDim,
-                _numHeads,
-                _numEncoderLayers,
-                _numDecoderLayers,
-                _maxPhonemeLength,
-                _fftSize,
-                _hopLength,
-                _griffinLimIterations,
-                lossFunction: _lossFunction);
-        }
-    }
 
     #endregion
 
diff --git a/src/Audio/TextToSpeech/VITSModel.cs b/src/Audio/TextToSpeech/VITSModel.cs
index 26a08ebe38..f1bbba6cab 100644
--- a/src/Audio/TextToSpeech/VITSModel.cs
+++ b/src/Audio/TextToSpeech/VITSModel.cs
@@ -842,121 +842,12 @@ public override ModelMetadata<T> GetModelMetadata()
     /// <summary>
     /// Serializes network-specific data.
     /// </summary>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(SampleRate);
-        writer.Write(NumMels);
-        writer.Write(_speakingRate);
-        writer.Write(_noiseScale);
-        writer.Write(_lengthScale);
-        writer.Write(_hiddenDim);
-        writer.Write(_numHeads);
-        writer.Write(_numEncoderLayers);
-        writer.Write(_numFlowLayers);
-        writer.Write(_speakerEmbeddingDim);
-        writer.Write(_numSpeakers);
-        writer.Write(_maxPhonemeLength);
-        writer.Write(_fftSize);
-        writer.Write(_hopLength);
-        writer.Write(_phonemeVocabSize);
-        writer.Write(_upsampleRates.Length);
-        foreach (var rate in _upsampleRates)
-        {
-            writer.Write(rate);
-        }
-    }
+
 
     /// <summary>
     /// Deserializes network-specific data.
     /// </summary>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        SampleRate = reader.ReadInt32();
-        NumMels = reader.ReadInt32();
-        _speakingRate = reader.ReadDouble();
-        _noiseScale = reader.ReadDouble();
-        _lengthScale = reader.ReadDouble();
-        _hiddenDim = reader.ReadInt32();
-        _numHeads = reader.ReadInt32();
-        _numEncoderLayers = reader.ReadInt32();
-        _numFlowLayers = reader.ReadInt32();
-        _speakerEmbeddingDim = reader.ReadInt32();
-        _numSpeakers = reader.ReadInt32();
-        _maxPhonemeLength = reader.ReadInt32();
-        _fftSize = reader.ReadInt32();
-        _hopLength = reader.ReadInt32();
-        if (reader.BaseStream.Position < reader.BaseStream.Length)
-        {
-            _phonemeVocabSize = reader.ReadInt32();
-            if (_phonemeVocabSize <= 0)
-                throw new InvalidDataException($"Invalid phonemeVocabSize: {_phonemeVocabSize}. Must be positive.");
-            // Maximum expected upsample rate entries (typical VITS uses 4-5 rates)
-            const int MaxUpsampleRatesLength = 64;
-            int ratesLen = reader.ReadInt32();
-            if (ratesLen <= 0 || ratesLen > MaxUpsampleRatesLength)
-                throw new InvalidDataException($"Invalid upsample rates length: {ratesLen}. Expected 1-{MaxUpsampleRatesLength}.");
-            _upsampleRates = new int[ratesLen];
-            for (int i = 0; i < ratesLen; i++)
-            {
-                _upsampleRates[i] = reader.ReadInt32();
-                if (_upsampleRates[i] <= 0)
-                    throw new InvalidDataException($"Invalid upsample rate at index {i}: {_upsampleRates[i]}. Must be positive.");
-            }
-        }
-        else
-        {
-            _phonemeVocabSize = 128;
-            _upsampleRates = [8, 8, 2, 2];
-        }
 
-        if (_useNativeMode)
-            RelinkNativeLayerViews();
-    }
-
-    /// <summary>
-    /// Creates a new instance of this model for cloning.
-    /// </summary>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _modelPath is not null)
-        {
-            return new VITSModel<T>(
-                Architecture,
-                _modelPath,
-                _speakerEncoderPath,
-                SampleRate,
-                NumMels,
-                _speakingRate,
-                _noiseScale,
-                _lengthScale,
-                _fftSize,
-                _hopLength);
-        }
-        else
-        {
-            return new VITSModel<T>(
-                Architecture,
-                SampleRate,
-                NumMels,
-                _speakingRate,
-                _noiseScale,
-                _lengthScale,
-                _hiddenDim,
-                _numHeads,
-                _numEncoderLayers,
-                _numFlowLayers,
-                _speakerEmbeddingDim,
-                _numSpeakers,
-                _maxPhonemeLength,
-                _phonemeVocabSize,
-                _upsampleRates,
-                _fftSize,
-                _hopLength,
-                lossFunction: _lossFunction);
-        }
-    }
 
     #endregion
 
diff --git a/src/Audio/VoiceActivity/MarbleNet.cs b/src/Audio/VoiceActivity/MarbleNet.cs
index 384902b8f4..b8401fdc3a 100644
--- a/src/Audio/VoiceActivity/MarbleNet.cs
+++ b/src/Audio/VoiceActivity/MarbleNet.cs
@@ -41,7 +41,7 @@ namespace AiDotNet.Audio.VoiceActivity;
 [ModelComplexity(ModelComplexity.Low)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("MarbleNet: Deep 1D Time-Channel Separable Convolutional Neural Network for Voice Activity Detection", "https://arxiv.org/abs/2010.13886", Year = 2021, Authors = "Fei Jia, Somshubra Majumdar, Boris Ginsburg")]
-public class MarbleNet<T> : AudioNeuralNetworkBase<T>, IVoiceActivityDetector<T>
+public partial class MarbleNet<T> : AudioNeuralNetworkBase<T>, IVoiceActivityDetector<T>
 {
     /// <inheritdoc />
     /// <remarks>
@@ -289,30 +289,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty);
-        w.Write(_options.SampleRate); w.Write(_options.NumMels); w.Write(_options.FftSize);
-        w.Write(_options.HopLength); w.Write(_options.FrameDurationMs);
-        w.Write(_options.InitialFilters); w.Write(_options.NumBlocks);
-        w.Write(_options.SubBlocksPerBlock); w.Write(_options.KernelSize);
-        w.Write(Threshold); w.Write(MinSpeechDurationMs); w.Write(MinSilenceDurationMs);
-        w.Write(_options.DropoutRate);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.SampleRate = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.FftSize = r.ReadInt32();
-        _options.HopLength = r.ReadInt32(); _options.FrameDurationMs = r.ReadInt32();
-        _options.InitialFilters = r.ReadInt32(); _options.NumBlocks = r.ReadInt32();
-        _options.SubBlocksPerBlock = r.ReadInt32(); _options.KernelSize = r.ReadInt32();
-        Threshold = r.ReadDouble(); MinSpeechDurationMs = r.ReadInt32(); MinSilenceDurationMs = r.ReadInt32();
-        _options.DropoutRate = r.ReadDouble();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() => new MarbleNet<T>(Architecture, _options);
+
 
     #endregion
 
diff --git a/src/Audio/VoiceActivity/QuailVad.cs b/src/Audio/VoiceActivity/QuailVad.cs
index 5473b603e2..4f69d12db7 100644
--- a/src/Audio/VoiceActivity/QuailVad.cs
+++ b/src/Audio/VoiceActivity/QuailVad.cs
@@ -42,7 +42,7 @@ namespace AiDotNet.Audio.VoiceActivity;
 [ModelComplexity(ModelComplexity.Low)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
     [ResearchPaper("Quality-Aware Voice Activity Detection", "https://doi.org/10.1109/ICASSP40776.2020.9053535")]
-public class QuailVad<T> : AudioNeuralNetworkBase<T>, IVoiceActivityDetector<T>
+public partial class QuailVad<T> : AudioNeuralNetworkBase<T>, IVoiceActivityDetector<T>
 {
     /// <inheritdoc />
     /// <remarks>
@@ -299,33 +299,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty);
-        w.Write(_options.SampleRate); w.Write(_options.HiddenDim);
-        w.Write(_options.NumCNNLayers); w.Write(_options.RNNHiddenSize);
-        w.Write(_options.FrameSizeMs); w.Write(_options.Threshold);
-        w.Write(_options.MinSpeechDuration); w.Write(_options.MinSilenceDuration);
-        w.Write(_options.DropoutRate);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.SampleRate = r.ReadInt32(); _options.HiddenDim = r.ReadInt32();
-        _options.NumCNNLayers = r.ReadInt32(); _options.RNNHiddenSize = r.ReadInt32();
-        _options.FrameSizeMs = r.ReadInt32(); _options.Threshold = r.ReadDouble();
-        _options.MinSpeechDuration = r.ReadDouble(); _options.MinSilenceDuration = r.ReadDouble();
-        _options.DropoutRate = r.ReadDouble();
-        Threshold = _options.Threshold;
-        MinSpeechDurationMs = (int)(_options.MinSpeechDuration * 1000);
-        MinSilenceDurationMs = (int)(_options.MinSilenceDuration * 1000);
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-        => new QuailVad<T>(Architecture, _options);
+
 
     #endregion
 
diff --git a/src/Audio/VoiceActivity/SileroVad.cs b/src/Audio/VoiceActivity/SileroVad.cs
index 0fdce21712..ceee336124 100644
--- a/src/Audio/VoiceActivity/SileroVad.cs
+++ b/src/Audio/VoiceActivity/SileroVad.cs
@@ -1,885 +1,846 @@
-using AiDotNet.Attributes;
-using AiDotNet.Diffusion.Audio;
-using AiDotNet.Enums;
-using AiDotNet.Helpers;
-using AiDotNet.Interfaces;
-using AiDotNet.LossFunctions;
-using AiDotNet.Models;
-using AiDotNet.NeuralNetworks;
-using AiDotNet.NeuralNetworks.Layers;
-using AiDotNet.Onnx;
-using AiDotNet.Tensors.Helpers;
-using AiDotNet.Tensors.LinearAlgebra;

+using AiDotNet.Attributes;
+using AiDotNet.Diffusion.Audio;
+using AiDotNet.Enums;
+using AiDotNet.Helpers;
+using AiDotNet.Interfaces;
+using AiDotNet.LossFunctions;
+using AiDotNet.Models;
+using AiDotNet.NeuralNetworks;
+using AiDotNet.NeuralNetworks.Layers;
+using AiDotNet.Onnx;
+using AiDotNet.Tensors.Helpers;
+using AiDotNet.Tensors.LinearAlgebra;
+
 using System.Collections.Generic;
-
-namespace AiDotNet.Audio.VoiceActivity;
-
-/// <summary>
-/// Silero Voice Activity Detection model - high accuracy neural network VAD.
-/// </summary>
-/// <typeparam name="T">The numeric type used for calculations.</typeparam>
-/// <remarks>
-/// <para>
-/// Silero VAD is a state-of-the-art voice activity detector that uses a lightweight
-/// neural network architecture to achieve high accuracy with low latency. It can:
-/// <list type="bullet">
-/// <item>Detect speech with very high accuracy (better than energy-based methods)</item>
-/// <item>Handle noisy environments well</item>
-/// <item>Run in real-time on CPU</item>
-/// <item>Work across multiple languages</item>
-/// </list>
-/// </para>
-/// <para><b>For Beginners:</b> Silero VAD tells you when someone is speaking vs silence.
-/// Unlike simple energy-based VAD, it uses a neural network that has learned what
-/// speech "looks like" from millions of examples.
-///
-/// Why use neural network VAD?
-/// - Much more accurate than energy/threshold-based methods
-/// - Handles background noise better (music, crowd noise, etc.)
-/// - Detects speech even when quiet
-/// - Doesn't false-trigger on non-speech sounds
-///
-/// Two ways to use this class:
-/// 1. ONNX Mode: Load pretrained Silero model for fast inference
-/// 2. Native Mode: Train your own VAD model from scratch
-///
-/// ONNX Mode Example (recommended):
-/// <code>
-/// var vad = new SileroVad&lt;float&gt;(
-///     architecture,
-///     modelPath: "path/to/silero_vad.onnx");
-/// var (isSpeech, probability) = vad.ProcessChunk(audioFrame);
-/// if (isSpeech)
-///     Console.WriteLine($"Speech detected! Confidence: {probability:P0}");
-/// </code>
-///
-/// Training Mode Example:
-/// <code>
-/// var vad = new SileroVad&lt;float&gt;(architecture);
-/// for (int epoch = 0; epoch &lt; 100; epoch++)
-/// {
-///     foreach (var (audio, labels) in trainingData)
-///     {
-///         vad.Train(audio, labels);
-///     }
-/// }
-/// </code>
-/// </para>
-/// </remarks>
-[ModelDomain(ModelDomain.Audio)]
-[ModelCategory(ModelCategory.NeuralNetwork)]
-[ModelTask(ModelTask.Classification)]
-[ModelTask(ModelTask.Detection)]
-[ModelComplexity(ModelComplexity.Low)]
-[ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
-    [ResearchPaper("Silero VAD: Pre-Trained Enterprise-Grade Voice Activity Detector", "https://github.com/snakers4/silero-vad")]
-public partial class SileroVad<T> : AudioNeuralNetworkBase<T>, IVoiceActivityDetector<T>
-{
-    private readonly SileroVadOptions _options;
-
-    /// <inheritdoc/>
-    public override ModelOptions GetOptions() => _options;
-
-    #region Execution Mode
-
-    /// <summary>
-    /// Indicates whether this network uses native layers (true) or ONNX model (false).
-    /// </summary>
-    private readonly bool _useNativeMode;
-
-    #endregion
-
-    #region ONNX Mode Fields
-
-    /// <summary>
-    /// Path to the ONNX model file.
-    /// </summary>
-    private readonly string? _modelPath;
-
-    #endregion
-
-    #region Native Mode Fields
-
-    /// <summary>
-    /// Convolutional feature extraction layers.
-    /// </summary>
-    private readonly List<ILayer<T>> _convLayers = [];
-
-    /// <summary>
-    /// LSTM layers for temporal modeling.
-    /// </summary>
-    private readonly List<ILayer<T>> _lstmLayers = [];
-
-    /// <summary>
-    /// Output classification layer.
-    /// </summary>
-    private ILayer<T>? _outputLayer;
-
-    #endregion
-
-    #region Configuration
-
-    /// <summary>
-    /// Loss function for training.
-    /// </summary>
-    private readonly ILossFunction<T> _lossFunction;
-
-    /// <summary>
-    /// Detection threshold (0-1).
-    /// </summary>
-    private readonly double _threshold;
-
-    /// <summary>
-    /// Frame size in samples.
-    /// </summary>
-    private readonly int _frameSize;
-
-    /// <summary>
-    /// Minimum speech duration in milliseconds.
-    /// </summary>
-    private readonly int _minSpeechDurationMs;
-
-    /// <summary>
-    /// Minimum silence duration in milliseconds.
-    /// </summary>
-    private readonly int _minSilenceDurationMs;
-
-    /// <summary>
-    /// Number of convolutional filters.
-    /// </summary>
-    private readonly int _convFilters;
-
-    /// <summary>
-    /// LSTM hidden dimension.
-    /// </summary>
-    private readonly int _lstmHiddenDim;
-
-    /// <summary>
-    /// Number of LSTM layers.
-    /// </summary>
-    private readonly int _numLstmLayers;
-
-    #endregion
-
-    #region Streaming State
-
-    /// <summary>
-    /// Number of consecutive speech frames.
-    /// </summary>
-    private int _speechFrameCount;
-
-    /// <summary>
-    /// Number of consecutive silence frames.
-    /// </summary>
-    private int _silenceFrameCount;
-
-    /// <summary>
-    /// Current speech state.
-    /// </summary>
-    private bool _inSpeech;
-
-    #endregion
-
-    /// <summary>
-    /// Disposed flag.
-    /// </summary>
-    private bool _disposed;
-
-    #region IVoiceActivityDetector Properties
-
-    /// <inheritdoc/>
-    public int FrameSize => _frameSize;
-
-    /// <inheritdoc/>
-    public double Threshold
-    {
-        get => _threshold;
-        set { }  // Threshold is readonly for Silero VAD
-    }
-
-    /// <inheritdoc/>
-    public int MinSpeechDurationMs
-    {
-        get => _minSpeechDurationMs;
-        set { }  // Read-only
-    }
-
-    /// <inheritdoc/>
-    public int MinSilenceDurationMs
-    {
-        get => _minSilenceDurationMs;
-        set { }  // Read-only
-    }
-
-    #endregion
-
-    #region Constructors
-
-    /// <summary>
-    /// Creates a Silero VAD in ONNX inference mode with a pretrained model.
-    /// </summary>
-    /// <param name="architecture">The neural network architecture.</param>
-    /// <param name="modelPath">Path to the Silero VAD ONNX model.</param>
-    /// <param name="sampleRate">Expected sample rate (default: 16000 Hz).</param>
-    /// <param name="frameSize">Frame size in samples (default: 512).</param>
-    /// <param name="threshold">Detection threshold 0-1 (default: 0.5).</param>
-    /// <param name="minSpeechDurationMs">Minimum speech duration in ms (default: 250).</param>
-    /// <param name="minSilenceDurationMs">Minimum silence duration in ms (default: 100).</param>
-    public SileroVad(
-        NeuralNetworkArchitecture<T> architecture,
-        string modelPath,
-        int sampleRate = 16000,
-        int frameSize = 512,
-        double threshold = 0.5,
-        int minSpeechDurationMs = 250,
-        int minSilenceDurationMs = 100,
-        SileroVadOptions? options = null)
-        : base(architecture, new BinaryCrossEntropyLoss<T>())
-    {
-        _options = options ?? new SileroVadOptions();
-        Options = _options;
-        if (string.IsNullOrWhiteSpace(modelPath))
-            throw new ArgumentException("Model path cannot be null or empty.", nameof(modelPath));
-
-        _useNativeMode = false;
-        _modelPath = modelPath;
-        _lossFunction = new BinaryCrossEntropyLoss<T>();
-
-        SampleRate = sampleRate;
-        _frameSize = frameSize;
-        _threshold = threshold;
-        _minSpeechDurationMs = minSpeechDurationMs;
-        _minSilenceDurationMs = minSilenceDurationMs;
-
-        // Default architecture parameters (not used in ONNX mode)
-        _convFilters = 64;
-        _lstmHiddenDim = 64;
-        _numLstmLayers = 2;
-
-        // Load ONNX model
-        OnnxModel = new OnnxModel<T>(modelPath);
-
-        ResetVadState();
-    }
-
-    /// <summary>
-    /// Creates a Silero VAD in native training mode for training from scratch.
-    /// </summary>
-    /// <param name="architecture">The neural network architecture.</param>
-    /// <param name="sampleRate">Expected sample rate (default: 16000 Hz).</param>
-    /// <param name="frameSize">Frame size in samples (default: 512).</param>
-    /// <param name="threshold">Detection threshold 0-1 (default: 0.5).</param>
-    /// <param name="minSpeechDurationMs">Minimum speech duration in ms (default: 250).</param>
-    /// <param name="minSilenceDurationMs">Minimum silence duration in ms (default: 100).</param>
-    /// <param name="convFilters">Number of convolutional filters (default: 64).</param>
-    /// <param name="lstmHiddenDim">LSTM hidden dimension (default: 64).</param>
-    /// <param name="numLstmLayers">Number of LSTM layers (default: 2).</param>
-    public SileroVad(
-        NeuralNetworkArchitecture<T> architecture,
-        int sampleRate = 16000,
-        int frameSize = 512,
-        double threshold = 0.5,
-        int minSpeechDurationMs = 250,
-        int minSilenceDurationMs = 100,
-        int convFilters = 64,
-        int lstmHiddenDim = 64,
-        int numLstmLayers = 2,
-        SileroVadOptions? options = null)
-        : base(architecture, new BinaryCrossEntropyLoss<T>())
-    {
-        _options = options ?? new SileroVadOptions();
-        Options = _options;
-        _useNativeMode = true;
-        _modelPath = null;
-        _lossFunction = new BinaryCrossEntropyLoss<T>();
-
-        SampleRate = sampleRate;
-        _frameSize = frameSize;
-        _threshold = threshold;
-        _minSpeechDurationMs = minSpeechDurationMs;
-        _minSilenceDurationMs = minSilenceDurationMs;
-
-        _convFilters = convFilters;
-        _lstmHiddenDim = lstmHiddenDim;
-        _numLstmLayers = numLstmLayers;
-
-        InitializeLayers();
-        ResetVadState();
-    }
-
-    #endregion
-
-    #region Layer Initialization
-
-    /// <inheritdoc/>
-    protected override void InitializeLayers()
-    {
-        if (!_useNativeMode)
-            return;
-
-        var layers = (Architecture.Layers != null && Architecture.Layers.Count > 0)
-            ? Architecture.Layers.ToList()
-            : LayerHelper<T>.CreateSileroVadLayers(
-                frameSize: _frameSize, convFilters: _convFilters,
-                numLstmLayers: _numLstmLayers, lstmHiddenDim: _lstmHiddenDim).ToList();
-
-        Layers.Clear();
-        Layers.AddRange(layers);
-
-        ExtractLayerReferences();
-    }
-
-    /// <summary>
-    /// (Re)populates the conv / LSTM / output sub-layer references from the
-    /// canonical <see cref="NeuralNetworkBase{T}.Layers"/> list and materializes
-    /// any lazy weights.
-    /// </summary>
-    /// <remarks>
-    /// Called both after <see cref="InitializeLayers"/> builds the layers and
-    /// after deserialization rebuilds <c>Layers</c>. Deserialization replaces the
-    /// <c>Layers</c> list with freshly reconstructed layers but does not know
-    /// about SileroVad's cached <c>_convLayers</c>/<c>_lstmLayers</c>/<c>_outputLayer</c>
-    /// references — without re-extracting them, a deserialized/cloned model would
-    /// keep running the constructor's randomly-initialized layers in Forward while
-    /// the loaded weights sit unused in <c>Layers</c> (the cause of
-    /// Clone_ShouldProduceIdenticalOutput diverging). Idempotent.
-    /// </remarks>
-    private void ExtractLayerReferences()
-    {
-        _convLayers.Clear();
-        _lstmLayers.Clear();
-
-        int expectedCount = 3 + _numLstmLayers + 1;
-        if (Layers.Count < expectedCount)
-        {
-            throw new ArgumentException(
-                $"Layer list must have at least {expectedCount} layers " +
-                $"(3 conv + {_numLstmLayers} LSTM + 1 output), but got {Layers.Count}.",
-                nameof(Layers));
-        }
-
-        for (int i = 0; i < 3; i++)
-            _convLayers.Add(Layers[i]);
-        for (int i = 0; i < _numLstmLayers; i++)
-            _lstmLayers.Add(Layers[3 + i]);
-        _outputLayer = Layers[3 + _numLstmLayers];
-
-        // Materialize the lazy LSTM weights now (their feature dim is known:
-        // convFilters into the first LSTM, lstmHiddenDim thereafter). Without
-        // this the LSTM weights stay at zero size until the first forward, so a
-        // clone/serialize of a never-yet-run model would capture no weights and
-        // the clone would resolve fresh random weights — diverging from the
-        // original (Clone_ShouldProduceIdenticalOutput).
-        int lstmInputDim = _convFilters;
-        foreach (var lstm in _lstmLayers)
-        {
-            if (lstm is LayerBase<T> lb && !lb.IsShapeResolved)
-            {
-                lb.ResolveFromShape(new[] { 1, 1, lstmInputDim });
-            }
-            lstmInputDim = _lstmHiddenDim;
-        }
-
-        // The output dense layer is also lazy (input size = lstmHiddenDim, the
-        // last-timestep feature width). Resolve it now for the same reason as
-        // the LSTMs.
-        if (_outputLayer is LayerBase<T> outLb && !outLb.IsShapeResolved)
-        {
-            outLb.ResolveFromShape(new[] { 1, _lstmHiddenDim });
-        }
-    }
-
-    #endregion
-
-    #region IVoiceActivityDetector Implementation
-
-    /// <inheritdoc/>
-    public bool DetectSpeech(Tensor<T> audioFrame)
-    {
-        var prob = GetSpeechProbability(audioFrame);
-        return NumOps.ToDouble(prob) >= _threshold;
-    }
-
-    /// <inheritdoc/>
-    public T GetSpeechProbability(Tensor<T> audioFrame)
-    {
-        var preprocessed = PreprocessAudio(audioFrame);
-        Tensor<T> output;
-
-        if (IsOnnxMode)
-        {
-            output = RunOnnxInference(preprocessed);
-        }
-        else
-        {
-            output = Forward(preprocessed);
-        }
-
-        // Get the probability value
-        var probabilities = output.ToVector().ToArray();
-        return probabilities.Length > 0 ? probabilities[0] : NumOps.FromDouble(0);
-    }
-
-    /// <inheritdoc/>
-    public IReadOnlyList<(int StartSample, int EndSample)> DetectSpeechSegments(Tensor<T> audio)
-    {
-        var samples = audio.ToVector().ToArray();
-        var segments = new List<(int, int)>();
-
-        int minSpeechFrames = (_minSpeechDurationMs * SampleRate) / (1000 * _frameSize);
-        int minSilenceFrames = (_minSilenceDurationMs * SampleRate) / (1000 * _frameSize);
-
-        int? segmentStart = null;
-        int speechCount = 0;
-        int silenceCount = 0;
-        bool inSpeech = false;
-
-        // Reset state for fresh analysis
-        ResetVadState();
-
-        for (int i = 0; i + _frameSize <= samples.Length; i += _frameSize)
-        {
-            var frame = new T[_frameSize];
-            Array.Copy(samples, i, frame, 0, _frameSize);
-
-            // Create tensor from frame data
-            var frameTensor = new Tensor<T>([_frameSize]);
-            var frameVector = frameTensor.ToVector();
-            for (int j = 0; j < _frameSize; j++)
-            {
-                frameVector[j] = frame[j];
-            }
-
-            var prob = GetSpeechProbability(frameTensor);
-            bool isSpeech = NumOps.ToDouble(prob) >= _threshold;
-
-            if (isSpeech)
-            {
-                speechCount++;
-                silenceCount = 0;
-
-                if (!inSpeech && speechCount >= minSpeechFrames)
-                {
-                    inSpeech = true;
-                    segmentStart = i - (speechCount - 1) * _frameSize;
-                }
-            }
-            else
-            {
-                silenceCount++;
-                speechCount = 0;
-
-                if (inSpeech && silenceCount >= minSilenceFrames)
-                {
-                    inSpeech = false;
-                    if (segmentStart.HasValue)
-                    {
-                        segments.Add((segmentStart.Value, i - (silenceCount - 1) * _frameSize));
-                        segmentStart = null;
-                    }
-                }
-            }
-        }
-
-        // Handle segment at end
-        if (inSpeech && segmentStart.HasValue)
-        {
-            segments.Add((segmentStart.Value, samples.Length));
-        }
-
-        return segments;
-    }
-
-    /// <inheritdoc/>
-    public T[] GetFrameProbabilities(Tensor<T> audio)
-    {
-        var samples = audio.ToVector().ToArray();
-        int numFrames = samples.Length / _frameSize;
-        var probabilities = new T[numFrames];
-
-        // Reset state for fresh analysis
-        ResetVadState();
-
-        for (int i = 0; i < numFrames; i++)
-        {
-            var frame = new T[_frameSize];
-            Array.Copy(samples, i * _frameSize, frame, 0, _frameSize);
-
-            // Create tensor from frame data
-            var frameTensor = new Tensor<T>([_frameSize]);
-            var frameVector = frameTensor.ToVector();
-            for (int j = 0; j < _frameSize; j++)
-            {
-                frameVector[j] = frame[j];
-            }
-
-            probabilities[i] = GetSpeechProbability(frameTensor);
-        }
-
-        return probabilities;
-    }
-
-    /// <inheritdoc/>
-    public (bool IsSpeech, T Probability) ProcessChunk(Tensor<T> audioChunk)
-    {
-        var prob = GetSpeechProbability(audioChunk);
-        var isSpeech = NumOps.ToDouble(prob) >= _threshold;
-
-        // Apply hangover logic
-        if (isSpeech)
-        {
-            _speechFrameCount++;
-            _silenceFrameCount = 0;
-        }
-        else
-        {
-            _silenceFrameCount++;
-            _speechFrameCount = 0;
-        }
-
-        int minSpeechFrames = (_minSpeechDurationMs * SampleRate) / (1000 * _frameSize);
-        int minSilenceFrames = (_minSilenceDurationMs * SampleRate) / (1000 * _frameSize);
-
-        if (!_inSpeech && _speechFrameCount >= minSpeechFrames)
-        {
-            _inSpeech = true;
-        }
-        else if (_inSpeech && _silenceFrameCount >= minSilenceFrames)
-        {
-            _inSpeech = false;
-        }
-
-        return (_inSpeech, prob);
-    }
-
-    /// <summary>
-    /// Resets the VAD streaming state (implements IVoiceActivityDetector).
-    /// </summary>
-    void IVoiceActivityDetector<T>.ResetState()
-    {
-        ResetVadState();
-    }
-
-    #endregion
-
-    #region AudioNeuralNetworkBase Implementation
-
-    /// <inheritdoc/>
-    protected override Tensor<T> PreprocessAudio(Tensor<T> rawAudio)
-    {
-        // Silero VAD (Silero Team, 2021) consumes float PCM already scaled to
-        // [-1, 1]; it does NOT re-normalize each chunk by its own peak amplitude.
-        // A per-chunk max-abs normalization would make the model amplitude-blind
-        // (a loud and a quiet copy of the same clip would map to identical
-        // features) and collapse a constant signal to all-ones, which is neither
-        // paper-faithful nor desirable. Reshape the waveform to the
-        // [batch, channels, samples] layout the 1-D conv frontend expects and
-        // leave the sample values intact.
-        var samples = rawAudio.ToVector().ToArray();
-        var result = new Tensor<T>([1, 1, samples.Length]);
-        // Write directly into the tensor's backing storage. Tensor.ToVector()
-        // returns a COPY, so assigning into that copy would leave `result` all
-        // zeros (the bug that made the conv frontend see a zero signal and emit
-        // a constant 0.5 for every input).
-        var resultSpan = result.Data.Span;
-        for (int i = 0; i < samples.Length; i++)
-        {
-            resultSpan[i] = samples[i];
-        }
-
-        return result;
-    }
-
-    /// <inheritdoc/>
-    protected override Tensor<T> PostprocessOutput(Tensor<T> modelOutput)
-    {
-        // Output is already a probability [0, 1] from sigmoid
-        return modelOutput;
-    }
-
-    /// <inheritdoc/>
-    protected override Tensor<T> PredictCore(Tensor<T> input)
-    {
-        var preprocessed = PreprocessAudio(input);
-        Tensor<T> output;
-
-        if (IsOnnxMode)
-        {
-            output = RunOnnxInference(preprocessed);
-        }
-        else
-        {
-            output = Forward(preprocessed);
-        }
-
-        return PostprocessOutput(output);
-    }
-
-    /// <inheritdoc/>
-    protected override Tensor<T> Forward(Tensor<T> input)
-    {
-        if (!_useNativeMode)
-            throw new InvalidOperationException("Forward pass only available in native mode.");
-
-        var output = input;
-
-        // Pass through 1-D conv layers: [batch, 1, samples] -> [batch, convFilters, T].
-        foreach (var layer in _convLayers)
-        {
-            output = layer.Forward(output);
-        }
-
-        // The conv stack emits [batch, channels, time]; the LSTM consumes a
-        // sequence [batch, time, features]. Transpose the channel and time axes
-        // so each timestep's convFilters-dim feature vector becomes the LSTM
-        // input (Silero Team, 2021 — conv frontend feeding a recurrent core).
-        // Use the engine's tape-aware permute so the gradient flows back into
-        // the conv frontend during training (a plain Tensor.Transpose would
-        // detach the tape and leave the convs/LSTM untrained).
-        if (output.Rank == 3)
-        {
-            output = Engine.TensorPermute(output, [0, 2, 1]).Contiguous();
-        }
-
-        // Pass through LSTM layers
-        foreach (var layer in _lstmLayers)
-        {
-            output = layer.Forward(output);
-        }
-
-        // Take the last timestep and pass through the dense layer. Use the
-        // tape-aware axis slice ([batch, seq, hidden] -> [batch, hidden]) so the
-        // gradient propagates back through the LSTM and conv frontend.
-        if (_outputLayer is not null)
-        {
-            var lastTimestep = output.Rank == 3
-                ? Engine.TensorSliceAxis(output, axis: 1, index: output.Shape[1] - 1)
-                : output;
-            output = _outputLayer.Forward(lastTimestep);
-        }
-
-        return output;
-    }
-
-    /// <inheritdoc/>
-    /// <remarks>
-    /// SileroVad's forward is the conv frontend → axis transpose → LSTM →
-    /// last-timestep → dense pipeline in <see cref="Forward"/>, not a sequential
-    /// pass over the flat <c>Layers</c> list (which would feed the conv output
-    /// straight into the LSTM with the wrong axis order and skip the
-    /// last-timestep reduction). Route the training forward through the real
-    /// pipeline so the gradient tape records the actual operations.
-    /// </remarks>
-    public override Tensor<T> ForwardForTraining(Tensor<T> input)
-    {
-        // Mirror Predict: normalize + reshape the raw waveform to [1, 1, samples]
-        // before running the conv frontend. Without this the training forward
-        // would feed the un-preprocessed input straight into the first 1-D conv
-        // (channel-count mismatch).
-        return Forward(PreprocessAudio(input));
-    }
-
-
-    /// <inheritdoc/>
-    /// <remarks>
-    /// The base implementation runs the flat <c>Layers</c> list sequentially on
-    /// the raw input, which neither preprocesses the waveform nor applies the
-    /// conv→LSTM axis transpose, so it fails on SileroVad's custom pipeline.
-    /// Capture activations along the model's actual forward path instead.
-    /// </remarks>
-    public override Dictionary<string, Tensor<T>> GetNamedLayerActivations(Tensor<T> input)
-    {
-        var activations = new Dictionary<string, Tensor<T>>();
-        if (!_useNativeMode)
-        {
-            return activations;
-        }
-
-        var current = PreprocessAudio(input);
-        int idx = 0;
-
-        foreach (var layer in _convLayers)
-        {
-            current = layer.Forward(current);
-            activations[$"Layer_{idx}_{layer.GetType().Name}"] = current.Clone();
-            idx++;
-        }
-
-        if (current.Rank == 3)
-        {
-            current = Engine.TensorPermute(current, [0, 2, 1]).Contiguous();
-        }
-
-        foreach (var layer in _lstmLayers)
-        {
-            current = layer.Forward(current);
-            activations[$"Layer_{idx}_{layer.GetType().Name}"] = current.Clone();
-            idx++;
-        }
-
-        if (_outputLayer is not null)
-        {
-            var lastTimestep = current.Rank == 3
-                ? Engine.TensorSliceAxis(current, axis: 1, index: current.Shape[1] - 1)
-                : current;
-            current = _outputLayer.Forward(lastTimestep);
-            activations[$"Layer_{idx}_{_outputLayer.GetType().Name}"] = current.Clone();
-        }
-
-        return activations;
-    }
-
-    /// <inheritdoc/>
-    public override void Train(Tensor<T> input, Tensor<T> expectedOutput)
-    {
-        if (!SupportsTraining)
-            throw new InvalidOperationException("Training not supported in ONNX mode.");
-
-        SetTrainingMode(true);
-        try
-        {
-            TrainWithTape(input, expectedOutput);
-        }
-        finally
-        {
-            SetTrainingMode(false);
-        }
-    }
-
-    // The layer streams this model holds outside Layers are discovered by ModelParameterGenerator and surfaced automatically; the hand-written hook that used to sit here was an override wearing a different name.
-
-    // UpdateParameters restated a fold the base now derives from generated component registration.
-    // Removed under AIDN082.
-    /// <inheritdoc/>
-    public override ModelMetadata<T> GetModelMetadata()
-    {
-        var metadata = new ModelMetadata<T>
-        {
-            Name = "SileroVad",
-            Version = "1.0",
-            Description = "Silero Voice Activity Detection neural network",
-            AdditionalInfo = BaseAudioMetadataInfo()
-        };
-
-        metadata.SetProperty("SampleRate", SampleRate);
-        metadata.SetProperty("FrameSize", _frameSize);
-        metadata.SetProperty("Threshold", _threshold);
-        metadata.SetProperty("ConvFilters", _convFilters);
-        metadata.SetProperty("LstmHiddenDim", _lstmHiddenDim);
-        metadata.SetProperty("NumLstmLayers", _numLstmLayers);
-        metadata.SetProperty("UseNativeMode", _useNativeMode);
-
-        return metadata;
-    }
-
-    /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(SampleRate);
-        writer.Write(_frameSize);
-        writer.Write(_threshold);
-        writer.Write(_minSpeechDurationMs);
-        writer.Write(_minSilenceDurationMs);
-        writer.Write(_convFilters);
-        writer.Write(_lstmHiddenDim);
-        writer.Write(_numLstmLayers);
-    }
-
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        // Read saved values (but don't reassign readonly fields)
-        _ = reader.ReadBoolean(); // _useNativeMode
-        SampleRate = reader.ReadInt32();
-        _ = reader.ReadInt32(); // _frameSize
-        _ = reader.ReadDouble(); // _threshold
-        _ = reader.ReadInt32(); // _minSpeechDurationMs
-        _ = reader.ReadInt32(); // _minSilenceDurationMs
-        _ = reader.ReadInt32(); // _convFilters
-        _ = reader.ReadInt32(); // _lstmHiddenDim
-        _ = reader.ReadInt32(); // _numLstmLayers
-
-        // Deserialization has already rebuilt the canonical Layers list with the
-        // loaded weights. Re-point the cached conv/LSTM/output references at those
-        // layers; otherwise Forward would keep running the constructor's
-        // randomly-initialized layers and ignore the loaded weights.
-        if (_useNativeMode && Layers.Count >= 3 + _numLstmLayers + 1)
-        {
-            ExtractLayerReferences();
-        }
-    }
-
-    /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new SileroVad<T>(
-            Architecture,
-            SampleRate,
-            _frameSize,
-            _threshold,
-            _minSpeechDurationMs,
-            _minSilenceDurationMs,
-            _convFilters,
-            _lstmHiddenDim,
-            _numLstmLayers);
-    }
-
-    #endregion
-
-    #region State Management
-
-    /// <summary>
-    /// Resets the VAD streaming state.
-    /// </summary>
-    private void ResetVadState()
-    {
-        _speechFrameCount = 0;
-        _silenceFrameCount = 0;
-        _inSpeech = false;
-
-        // Reset LSTM layer states
-        foreach (var layer in _lstmLayers)
-        {
-            if (layer is LSTMLayer<T> lstmLayer)
-            {
-                lstmLayer.ResetState();
-            }
-        }
-    }
-
-    #endregion
-
-    #region Dispose
-
-    /// <inheritdoc/>
-    protected override void Dispose(bool disposing)
-    {
-        if (!_disposed)
-        {
-            if (disposing)
-            {
-                OnnxModel?.Dispose();
-
-                foreach (var layer in _convLayers)
-                {
-                    if (layer is IDisposable disposable)
-                        disposable.Dispose();
-                }
-
-                foreach (var layer in _lstmLayers)
-                {
-                    if (layer is IDisposable disposable)
-                        disposable.Dispose();
-                }
-
-                if (_outputLayer is IDisposable disposableOutput)
-                    disposableOutput.Dispose();
-            }
-            _disposed = true;
-        }
-        base.Dispose(disposing);
-    }
-
-    #endregion
-}
+
+namespace AiDotNet.Audio.VoiceActivity;
+
+/// <summary>
+/// Silero Voice Activity Detection model - high accuracy neural network VAD.
+/// </summary>
+/// <typeparam name="T">The numeric type used for calculations.</typeparam>
+/// <remarks>
+/// <para>
+/// Silero VAD is a state-of-the-art voice activity detector that uses a lightweight
+/// neural network architecture to achieve high accuracy with low latency. It can:
+/// <list type="bullet">
+/// <item>Detect speech with very high accuracy (better than energy-based methods)</item>
+/// <item>Handle noisy environments well</item>
+/// <item>Run in real-time on CPU</item>
+/// <item>Work across multiple languages</item>
+/// </list>
+/// </para>
+/// <para><b>For Beginners:</b> Silero VAD tells you when someone is speaking vs silence.
+/// Unlike simple energy-based VAD, it uses a neural network that has learned what
+/// speech "looks like" from millions of examples.
+///
+/// Why use neural network VAD?
+/// - Much more accurate than energy/threshold-based methods
+/// - Handles background noise better (music, crowd noise, etc.)
+/// - Detects speech even when quiet
+/// - Doesn't false-trigger on non-speech sounds
+///
+/// Two ways to use this class:
+/// 1. ONNX Mode: Load pretrained Silero model for fast inference
+/// 2. Native Mode: Train your own VAD model from scratch
+///
+/// ONNX Mode Example (recommended):
+/// <code>
+/// var vad = new SileroVad&lt;float&gt;(
+///     architecture,
+///     modelPath: "path/to/silero_vad.onnx");
+/// var (isSpeech, probability) = vad.ProcessChunk(audioFrame);
+/// if (isSpeech)
+///     Console.WriteLine($"Speech detected! Confidence: {probability:P0}");
+/// </code>
+///
+/// Training Mode Example:
+/// <code>
+/// var vad = new SileroVad&lt;float&gt;(architecture);
+/// for (int epoch = 0; epoch &lt; 100; epoch++)
+/// {
+///     foreach (var (audio, labels) in trainingData)
+///     {
+///         vad.Train(audio, labels);
+///     }
+/// }
+/// </code>
+/// </para>
+/// </remarks>
+[ModelDomain(ModelDomain.Audio)]
+[ModelCategory(ModelCategory.NeuralNetwork)]
+[ModelTask(ModelTask.Classification)]
+[ModelTask(ModelTask.Detection)]
+[ModelComplexity(ModelComplexity.Low)]
+[ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
+    [ResearchPaper("Silero VAD: Pre-Trained Enterprise-Grade Voice Activity Detector", "https://github.com/snakers4/silero-vad")]
+public partial class SileroVad<T> : AudioNeuralNetworkBase<T>, IVoiceActivityDetector<T>
+{
+    private readonly SileroVadOptions _options;
+
+    /// <inheritdoc/>
+    public override ModelOptions GetOptions() => _options;
+
+    #region Execution Mode
+
+    /// <summary>
+    /// Indicates whether this network uses native layers (true) or ONNX model (false).
+    /// </summary>
+    private readonly bool _useNativeMode;
+
+    #endregion
+
+    #region ONNX Mode Fields
+
+    /// <summary>
+    /// Path to the ONNX model file.
+    /// </summary>
+    private readonly string? _modelPath;
+
+    #endregion
+
+    #region Native Mode Fields
+
+    /// <summary>
+    /// Convolutional feature extraction layers.
+    /// </summary>
+    private readonly List<ILayer<T>> _convLayers = [];
+
+    /// <summary>
+    /// LSTM layers for temporal modeling.
+    /// </summary>
+    private readonly List<ILayer<T>> _lstmLayers = [];
+
+    /// <summary>
+    /// Output classification layer.
+    /// </summary>
+    private ILayer<T>? _outputLayer;
+
+    #endregion
+
+    #region Configuration
+
+    /// <summary>
+    /// Loss function for training.
+    /// </summary>
+    private readonly ILossFunction<T> _lossFunction;
+
+    /// <summary>
+    /// Detection threshold (0-1).
+    /// </summary>
+    private readonly double _threshold;
+
+    /// <summary>
+    /// Frame size in samples.
+    /// </summary>
+    private readonly int _frameSize;
+
+    /// <summary>
+    /// Minimum speech duration in milliseconds.
+    /// </summary>
+    private readonly int _minSpeechDurationMs;
+
+    /// <summary>
+    /// Minimum silence duration in milliseconds.
+    /// </summary>
+    private readonly int _minSilenceDurationMs;
+
+    /// <summary>
+    /// Number of convolutional filters.
+    /// </summary>
+    private readonly int _convFilters;
+
+    /// <summary>
+    /// LSTM hidden dimension.
+    /// </summary>
+    private readonly int _lstmHiddenDim;
+
+    /// <summary>
+    /// Number of LSTM layers.
+    /// </summary>
+    private readonly int _numLstmLayers;
+
+    #endregion
+
+    #region Streaming State
+
+    /// <summary>
+    /// Number of consecutive speech frames.
+    /// </summary>
+    private int _speechFrameCount;
+
+    /// <summary>
+    /// Number of consecutive silence frames.
+    /// </summary>
+    private int _silenceFrameCount;
+
+    /// <summary>
+    /// Current speech state.
+    /// </summary>
+    private bool _inSpeech;
+
+    #endregion
+
+    /// <summary>
+    /// Disposed flag.
+    /// </summary>
+    private bool _disposed;
+
+    #region IVoiceActivityDetector Properties
+
+    /// <inheritdoc/>
+    public int FrameSize => _frameSize;
+
+    /// <inheritdoc/>
+    public double Threshold
+    {
+        get => _threshold;
+        set { }  // Threshold is readonly for Silero VAD
+    }
+
+    /// <inheritdoc/>
+    public int MinSpeechDurationMs
+    {
+        get => _minSpeechDurationMs;
+        set { }  // Read-only
+    }
+
+    /// <inheritdoc/>
+    public int MinSilenceDurationMs
+    {
+        get => _minSilenceDurationMs;
+        set { }  // Read-only
+    }
+
+    #endregion
+
+    #region Constructors
+
+    /// <summary>
+    /// Creates a Silero VAD in ONNX inference mode with a pretrained model.
+    /// </summary>
+    /// <param name="architecture">The neural network architecture.</param>
+    /// <param name="modelPath">Path to the Silero VAD ONNX model.</param>
+    /// <param name="sampleRate">Expected sample rate (default: 16000 Hz).</param>
+    /// <param name="frameSize">Frame size in samples (default: 512).</param>
+    /// <param name="threshold">Detection threshold 0-1 (default: 0.5).</param>
+    /// <param name="minSpeechDurationMs">Minimum speech duration in ms (default: 250).</param>
+    /// <param name="minSilenceDurationMs">Minimum silence duration in ms (default: 100).</param>
+    public SileroVad(
+        NeuralNetworkArchitecture<T> architecture,
+        string modelPath,
+        int sampleRate = 16000,
+        int frameSize = 512,
+        double threshold = 0.5,
+        int minSpeechDurationMs = 250,
+        int minSilenceDurationMs = 100,
+        SileroVadOptions? options = null)
+        : base(architecture, new BinaryCrossEntropyLoss<T>())
+    {
+        _options = options ?? new SileroVadOptions();
+        Options = _options;
+        if (string.IsNullOrWhiteSpace(modelPath))
+            throw new ArgumentException("Model path cannot be null or empty.", nameof(modelPath));
+
+        _useNativeMode = false;
+        _modelPath = modelPath;
+        _lossFunction = new BinaryCrossEntropyLoss<T>();
+
+        SampleRate = sampleRate;
+        _frameSize = frameSize;
+        _threshold = threshold;
+        _minSpeechDurationMs = minSpeechDurationMs;
+        _minSilenceDurationMs = minSilenceDurationMs;
+
+        // Default architecture parameters (not used in ONNX mode)
+        _convFilters = 64;
+        _lstmHiddenDim = 64;
+        _numLstmLayers = 2;
+
+        // Load ONNX model
+        OnnxModel = new OnnxModel<T>(modelPath);
+
+        ResetVadState();
+    }
+
+    /// <summary>
+    /// Creates a Silero VAD in native training mode for training from scratch.
+    /// </summary>
+    /// <param name="architecture">The neural network architecture.</param>
+    /// <param name="sampleRate">Expected sample rate (default: 16000 Hz).</param>
+    /// <param name="frameSize">Frame size in samples (default: 512).</param>
+    /// <param name="threshold">Detection threshold 0-1 (default: 0.5).</param>
+    /// <param name="minSpeechDurationMs">Minimum speech duration in ms (default: 250).</param>
+    /// <param name="minSilenceDurationMs">Minimum silence duration in ms (default: 100).</param>
+    /// <param name="convFilters">Number of convolutional filters (default: 64).</param>
+    /// <param name="lstmHiddenDim">LSTM hidden dimension (default: 64).</param>
+    /// <param name="numLstmLayers">Number of LSTM layers (default: 2).</param>
+    public SileroVad(
+        NeuralNetworkArchitecture<T> architecture,
+        int sampleRate = 16000,
+        int frameSize = 512,
+        double threshold = 0.5,
+        int minSpeechDurationMs = 250,
+        int minSilenceDurationMs = 100,
+        int convFilters = 64,
+        int lstmHiddenDim = 64,
+        int numLstmLayers = 2,
+        SileroVadOptions? options = null)
+        : base(architecture, new BinaryCrossEntropyLoss<T>())
+    {
+        _options = options ?? new SileroVadOptions();
+        Options = _options;
+        _useNativeMode = true;
+        _modelPath = null;
+        _lossFunction = new BinaryCrossEntropyLoss<T>();
+
+        SampleRate = sampleRate;
+        _frameSize = frameSize;
+        _threshold = threshold;
+        _minSpeechDurationMs = minSpeechDurationMs;
+        _minSilenceDurationMs = minSilenceDurationMs;
+
+        _convFilters = convFilters;
+        _lstmHiddenDim = lstmHiddenDim;
+        _numLstmLayers = numLstmLayers;
+
+        InitializeLayers();
+        ResetVadState();
+    }
+
+    #endregion
+
+    #region Layer Initialization
+
+    /// <inheritdoc/>
+    protected override void InitializeLayers()
+    {
+        if (!_useNativeMode)
+            return;
+
+        var layers = (Architecture.Layers != null && Architecture.Layers.Count > 0)
+            ? Architecture.Layers.ToList()
+            : LayerHelper<T>.CreateSileroVadLayers(
+                frameSize: _frameSize, convFilters: _convFilters,
+                numLstmLayers: _numLstmLayers, lstmHiddenDim: _lstmHiddenDim).ToList();
+
+        Layers.Clear();
+        Layers.AddRange(layers);
+
+        ExtractLayerReferences();
+    }
+
+    /// <summary>
+    /// (Re)populates the conv / LSTM / output sub-layer references from the
+    /// canonical <see cref="NeuralNetworkBase{T}.Layers"/> list and materializes
+    /// any lazy weights.
+    /// </summary>
+    /// <remarks>
+    /// Called both after <see cref="InitializeLayers"/> builds the layers and
+    /// after deserialization rebuilds <c>Layers</c>. Deserialization replaces the
+    /// <c>Layers</c> list with freshly reconstructed layers but does not know
+    /// about SileroVad's cached <c>_convLayers</c>/<c>_lstmLayers</c>/<c>_outputLayer</c>
+    /// references — without re-extracting them, a deserialized/cloned model would
+    /// keep running the constructor's randomly-initialized layers in Forward while
+    /// the loaded weights sit unused in <c>Layers</c> (the cause of
+    /// Clone_ShouldProduceIdenticalOutput diverging). Idempotent.
+    /// </remarks>
+    private void ExtractLayerReferences()
+    {
+        _convLayers.Clear();
+        _lstmLayers.Clear();
+
+        int expectedCount = 3 + _numLstmLayers + 1;
+        if (Layers.Count < expectedCount)
+        {
+            throw new ArgumentException(
+                $"Layer list must have at least {expectedCount} layers " +
+                $"(3 conv + {_numLstmLayers} LSTM + 1 output), but got {Layers.Count}.",
+                nameof(Layers));
+        }
+
+        for (int i = 0; i < 3; i++)
+            _convLayers.Add(Layers[i]);
+        for (int i = 0; i < _numLstmLayers; i++)
+            _lstmLayers.Add(Layers[3 + i]);
+        _outputLayer = Layers[3 + _numLstmLayers];
+
+        // Materialize the lazy LSTM weights now (their feature dim is known:
+        // convFilters into the first LSTM, lstmHiddenDim thereafter). Without
+        // this the LSTM weights stay at zero size until the first forward, so a
+        // clone/serialize of a never-yet-run model would capture no weights and
+        // the clone would resolve fresh random weights — diverging from the
+        // original (Clone_ShouldProduceIdenticalOutput).
+        int lstmInputDim = _convFilters;
+        foreach (var lstm in _lstmLayers)
+        {
+            if (lstm is LayerBase<T> lb && !lb.IsShapeResolved)
+            {
+                lb.ResolveFromShape(new[] { 1, 1, lstmInputDim });
+            }
+            lstmInputDim = _lstmHiddenDim;
+        }
+
+        // The output dense layer is also lazy (input size = lstmHiddenDim, the
+        // last-timestep feature width). Resolve it now for the same reason as
+        // the LSTMs.
+        if (_outputLayer is LayerBase<T> outLb && !outLb.IsShapeResolved)
+        {
+            outLb.ResolveFromShape(new[] { 1, _lstmHiddenDim });
+        }
+    }
+
+    #endregion
+
+    #region IVoiceActivityDetector Implementation
+
+    /// <inheritdoc/>
+    public bool DetectSpeech(Tensor<T> audioFrame)
+    {
+        var prob = GetSpeechProbability(audioFrame);
+        return NumOps.ToDouble(prob) >= _threshold;
+    }
+
+    /// <inheritdoc/>
+    public T GetSpeechProbability(Tensor<T> audioFrame)
+    {
+        var preprocessed = PreprocessAudio(audioFrame);
+        Tensor<T> output;
+
+        if (IsOnnxMode)
+        {
+            output = RunOnnxInference(preprocessed);
+        }
+        else
+        {
+            output = Forward(preprocessed);
+        }
+
+        // Get the probability value
+        var probabilities = output.ToVector().ToArray();
+        return probabilities.Length > 0 ? probabilities[0] : NumOps.FromDouble(0);
+    }
+
+    /// <inheritdoc/>
+    public IReadOnlyList<(int StartSample, int EndSample)> DetectSpeechSegments(Tensor<T> audio)
+    {
+        var samples = audio.ToVector().ToArray();
+        var segments = new List<(int, int)>();
+
+        int minSpeechFrames = (_minSpeechDurationMs * SampleRate) / (1000 * _frameSize);
+        int minSilenceFrames = (_minSilenceDurationMs * SampleRate) / (1000 * _frameSize);
+
+        int? segmentStart = null;
+        int speechCount = 0;
+        int silenceCount = 0;
+        bool inSpeech = false;
+
+        // Reset state for fresh analysis
+        ResetVadState();
+
+        for (int i = 0; i + _frameSize <= samples.Length; i += _frameSize)
+        {
+            var frame = new T[_frameSize];
+            Array.Copy(samples, i, frame, 0, _frameSize);
+
+            // Write directly into the tensor's backing storage, and dispose it per frame.
+            // ToVector() returns a COPY, so assigning into that copy left frameTensor ALL ZEROS
+            // and every frame reached the model as silence -- the same defect PreprocessAudio
+            // below already documents, surviving here. Speech detection was therefore independent
+            // of the audio. Disposal is safe because PreprocessAudio allocates its own result, so
+            // nothing downstream holds a reference to this tensor once the call returns.
+            using var frameTensor = new Tensor<T>([_frameSize]);
+            var frameSpan = frameTensor.Data.Span;
+            for (int j = 0; j < _frameSize; j++)
+            {
+                frameSpan[j] = frame[j];
+            }
+
+            var prob = GetSpeechProbability(frameTensor);
+            bool isSpeech = NumOps.ToDouble(prob) >= _threshold;
+
+            if (isSpeech)
+            {
+                speechCount++;
+                silenceCount = 0;
+
+                if (!inSpeech && speechCount >= minSpeechFrames)
+                {
+                    inSpeech = true;
+                    segmentStart = i - (speechCount - 1) * _frameSize;
+                }
+            }
+            else
+            {
+                silenceCount++;
+                speechCount = 0;
+
+                if (inSpeech && silenceCount >= minSilenceFrames)
+                {
+                    inSpeech = false;
+                    if (segmentStart.HasValue)
+                    {
+                        segments.Add((segmentStart.Value, i - (silenceCount - 1) * _frameSize));
+                        segmentStart = null;
+                    }
+                }
+            }
+        }
+
+        // Handle segment at end
+        if (inSpeech && segmentStart.HasValue)
+        {
+            segments.Add((segmentStart.Value, samples.Length));
+        }
+
+        return segments;
+    }
+
+    /// <inheritdoc/>
+    public T[] GetFrameProbabilities(Tensor<T> audio)
+    {
+        var samples = audio.ToVector().ToArray();
+        int numFrames = samples.Length / _frameSize;
+        var probabilities = new T[numFrames];
+
+        // Reset state for fresh analysis
+        ResetVadState();
+
+        for (int i = 0; i < numFrames; i++)
+        {
+            var frame = new T[_frameSize];
+            Array.Copy(samples, i * _frameSize, frame, 0, _frameSize);
+
+            // Same direct write and per-frame disposal as DetectSpeechSegments above: assigning
+            // into the ToVector() copy left this tensor all zeros, so every probability was
+            // computed from silence rather than from the frame.
+            using var frameTensor = new Tensor<T>([_frameSize]);
+            var frameSpan = frameTensor.Data.Span;
+            for (int j = 0; j < _frameSize; j++)
+            {
+                frameSpan[j] = frame[j];
+            }
+
+            probabilities[i] = GetSpeechProbability(frameTensor);
+        }
+
+        return probabilities;
+    }
+
+    /// <inheritdoc/>
+    public (bool IsSpeech, T Probability) ProcessChunk(Tensor<T> audioChunk)
+    {
+        var prob = GetSpeechProbability(audioChunk);
+        var isSpeech = NumOps.ToDouble(prob) >= _threshold;
+
+        // Apply hangover logic
+        if (isSpeech)
+        {
+            _speechFrameCount++;
+            _silenceFrameCount = 0;
+        }
+        else
+        {
+            _silenceFrameCount++;
+            _speechFrameCount = 0;
+        }
+
+        int minSpeechFrames = (_minSpeechDurationMs * SampleRate) / (1000 * _frameSize);
+        int minSilenceFrames = (_minSilenceDurationMs * SampleRate) / (1000 * _frameSize);
+
+        if (!_inSpeech && _speechFrameCount >= minSpeechFrames)
+        {
+            _inSpeech = true;
+        }
+        else if (_inSpeech && _silenceFrameCount >= minSilenceFrames)
+        {
+            _inSpeech = false;
+        }
+
+        return (_inSpeech, prob);
+    }
+
+    /// <summary>
+    /// Resets the VAD streaming state (implements IVoiceActivityDetector).
+    /// </summary>
+    void IVoiceActivityDetector<T>.ResetState()
+    {
+        ResetVadState();
+    }
+
+    #endregion
+
+    #region AudioNeuralNetworkBase Implementation
+
+    /// <inheritdoc/>
+    protected override Tensor<T> PreprocessAudio(Tensor<T> rawAudio)
+    {
+        // Silero VAD (Silero Team, 2021) consumes float PCM already scaled to
+        // [-1, 1]; it does NOT re-normalize each chunk by its own peak amplitude.
+        // A per-chunk max-abs normalization would make the model amplitude-blind
+        // (a loud and a quiet copy of the same clip would map to identical
+        // features) and collapse a constant signal to all-ones, which is neither
+        // paper-faithful nor desirable. Reshape the waveform to the
+        // [batch, channels, samples] layout the 1-D conv frontend expects and
+        // leave the sample values intact.
+        var samples = rawAudio.ToVector().ToArray();
+        var result = new Tensor<T>([1, 1, samples.Length]);
+        // Write directly into the tensor's backing storage. Tensor.ToVector()
+        // returns a COPY, so assigning into that copy would leave `result` all
+        // zeros (the bug that made the conv frontend see a zero signal and emit
+        // a constant 0.5 for every input).
+        var resultSpan = result.Data.Span;
+        for (int i = 0; i < samples.Length; i++)
+        {
+            resultSpan[i] = samples[i];
+        }
+
+        return result;
+    }
+
+    /// <inheritdoc/>
+    protected override Tensor<T> PostprocessOutput(Tensor<T> modelOutput)
+    {
+        // Output is already a probability [0, 1] from sigmoid
+        return modelOutput;
+    }
+
+    /// <inheritdoc/>
+    protected override Tensor<T> PredictCore(Tensor<T> input)
+    {
+        var preprocessed = PreprocessAudio(input);
+        Tensor<T> output;
+
+        if (IsOnnxMode)
+        {
+            output = RunOnnxInference(preprocessed);
+        }
+        else
+        {
+            output = Forward(preprocessed);
+        }
+
+        return PostprocessOutput(output);
+    }
+
+    /// <inheritdoc/>
+    protected override Tensor<T> Forward(Tensor<T> input)
+    {
+        if (!_useNativeMode)
+            throw new InvalidOperationException("Forward pass only available in native mode.");
+
+        var output = input;
+
+        // Pass through 1-D conv layers: [batch, 1, samples] -> [batch, convFilters, T].
+        foreach (var layer in _convLayers)
+        {
+            output = layer.Forward(output);
+        }
+
+        // The conv stack emits [batch, channels, time]; the LSTM consumes a
+        // sequence [batch, time, features]. Transpose the channel and time axes
+        // so each timestep's convFilters-dim feature vector becomes the LSTM
+        // input (Silero Team, 2021 — conv frontend feeding a recurrent core).
+        // Use the engine's tape-aware permute so the gradient flows back into
+        // the conv frontend during training (a plain Tensor.Transpose would
+        // detach the tape and leave the convs/LSTM untrained).
+        if (output.Rank == 3)
+        {
+            output = Engine.TensorPermute(output, [0, 2, 1]).Contiguous();
+        }
+
+        // Pass through LSTM layers
+        foreach (var layer in _lstmLayers)
+        {
+            output = layer.Forward(output);
+        }
+
+        // Take the last timestep and pass through the dense layer. Use the
+        // tape-aware axis slice ([batch, seq, hidden] -> [batch, hidden]) so the
+        // gradient propagates back through the LSTM and conv frontend.
+        if (_outputLayer is not null)
+        {
+            var lastTimestep = output.Rank == 3
+                ? Engine.TensorSliceAxis(output, axis: 1, index: output.Shape[1] - 1)
+                : output;
+            output = _outputLayer.Forward(lastTimestep);
+        }
+
+        return output;
+    }
+
+    /// <inheritdoc/>
+    /// <remarks>
+    /// SileroVad's forward is the conv frontend → axis transpose → LSTM →
+    /// last-timestep → dense pipeline in <see cref="Forward"/>, not a sequential
+    /// pass over the flat <c>Layers</c> list (which would feed the conv output
+    /// straight into the LSTM with the wrong axis order and skip the
+    /// last-timestep reduction). Route the training forward through the real
+    /// pipeline so the gradient tape records the actual operations.
+    /// </remarks>
+    public override Tensor<T> ForwardForTraining(Tensor<T> input)
+    {
+        // Mirror Predict: normalize + reshape the raw waveform to [1, 1, samples]
+        // before running the conv frontend. Without this the training forward
+        // would feed the un-preprocessed input straight into the first 1-D conv
+        // (channel-count mismatch).
+        return Forward(PreprocessAudio(input));
+    }
+
+
+    /// <inheritdoc/>
+    /// <remarks>
+    /// The base implementation runs the flat <c>Layers</c> list sequentially on
+    /// the raw input, which neither preprocesses the waveform nor applies the
+    /// conv→LSTM axis transpose, so it fails on SileroVad's custom pipeline.
+    /// Capture activations along the model's actual forward path instead.
+    /// </remarks>
+    public override Dictionary<string, Tensor<T>> GetNamedLayerActivations(Tensor<T> input)
+    {
+        var activations = new Dictionary<string, Tensor<T>>();
+        if (!_useNativeMode)
+        {
+            return activations;
+        }
+
+        var current = PreprocessAudio(input);
+        int idx = 0;
+
+        foreach (var layer in _convLayers)
+        {
+            current = layer.Forward(current);
+            activations[$"Layer_{idx}_{layer.GetType().Name}"] = current.Clone();
+            idx++;
+        }
+
+        if (current.Rank == 3)
+        {
+            current = Engine.TensorPermute(current, [0, 2, 1]).Contiguous();
+        }
+
+        foreach (var layer in _lstmLayers)
+        {
+            current = layer.Forward(current);
+            activations[$"Layer_{idx}_{layer.GetType().Name}"] = current.Clone();
+            idx++;
+        }
+
+        if (_outputLayer is not null)
+        {
+            var lastTimestep = current.Rank == 3
+                ? Engine.TensorSliceAxis(current, axis: 1, index: current.Shape[1] - 1)
+                : current;
+            current = _outputLayer.Forward(lastTimestep);
+            activations[$"Layer_{idx}_{_outputLayer.GetType().Name}"] = current.Clone();
+        }
+
+        return activations;
+    }
+
+    /// <inheritdoc/>
+    public override void Train(Tensor<T> input, Tensor<T> expectedOutput)
+    {
+        if (!SupportsTraining)
+            throw new InvalidOperationException("Training not supported in ONNX mode.");
+
+        SetTrainingMode(true);
+        try
+        {
+            TrainWithTape(input, expectedOutput);
+        }
+        finally
+        {
+            SetTrainingMode(false);
+        }
+    }
+
+    // The layer streams this model holds outside Layers are discovered by ModelParameterGenerator and surfaced automatically; the hand-written hook that used to sit here was an override wearing a different name.
+
+    // UpdateParameters restated a fold the base now derives from generated component registration.
+    // Removed under AIDN082.
+    /// <inheritdoc/>
+    public override ModelMetadata<T> GetModelMetadata()
+    {
+        var metadata = new ModelMetadata<T>
+        {
+            Name = "SileroVad",
+            Version = "1.0",
+            Description = "Silero Voice Activity Detection neural network",
+            AdditionalInfo = BaseAudioMetadataInfo()
+        };
+
+        metadata.SetProperty("SampleRate", SampleRate);
+        metadata.SetProperty("FrameSize", _frameSize);
+        metadata.SetProperty("Threshold", _threshold);
+        metadata.SetProperty("ConvFilters", _convFilters);
+        metadata.SetProperty("LstmHiddenDim", _lstmHiddenDim);
+        metadata.SetProperty("NumLstmLayers", _numLstmLayers);
+        metadata.SetProperty("UseNativeMode", _useNativeMode);
+
+        return metadata;
+    }
+
+    /// <inheritdoc/>
+
+
+    /// <inheritdoc/>
+
+
+    #endregion
+
+    #region State Management
+
+    /// <summary>
+    /// Resets the VAD streaming state.
+    /// </summary>
+    private void ResetVadState()
+    {
+        _speechFrameCount = 0;
+        _silenceFrameCount = 0;
+        _inSpeech = false;
+
+        // Reset LSTM layer states
+        foreach (var layer in _lstmLayers)
+        {
+            if (layer is LSTMLayer<T> lstmLayer)
+            {
+                lstmLayer.ResetState();
+            }
+        }
+    }
+
+    #endregion
+
+    #region Dispose
+
+    /// <inheritdoc/>
+    protected override void Dispose(bool disposing)
+    {
+        if (!_disposed)
+        {
+            if (disposing)
+            {
+                OnnxModel?.Dispose();
+
+                foreach (var layer in _convLayers)
+                {
+                    if (layer is IDisposable disposable)
+                        disposable.Dispose();
+                }
+
+                foreach (var layer in _lstmLayers)
+                {
+                    if (layer is IDisposable disposable)
+                        disposable.Dispose();
+                }
+
+                if (_outputLayer is IDisposable disposableOutput)
+                    disposableOutput.Dispose();
+            }
+            _disposed = true;
+        }
+        base.Dispose(disposing);
+    }
+
+    #endregion
+}
diff --git a/src/Audio/VoiceActivity/WebRTCVad.cs b/src/Audio/VoiceActivity/WebRTCVad.cs
index 25cc69d09c..f229c724e0 100644
--- a/src/Audio/VoiceActivity/WebRTCVad.cs
+++ b/src/Audio/VoiceActivity/WebRTCVad.cs
@@ -39,7 +39,7 @@ namespace AiDotNet.Audio.VoiceActivity;
 [ModelComplexity(ModelComplexity.Low)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("WebRTC Voice Activity Detector", "https://webrtc.googlesource.com/src/+/refs/heads/main/common_audio/vad/")]
-public class WebRTCVad<T> : AudioNeuralNetworkBase<T>, IVoiceActivityDetector<T>
+public partial class WebRTCVad<T> : AudioNeuralNetworkBase<T>, IVoiceActivityDetector<T>
 {
     /// <inheritdoc />
     /// <remarks>
@@ -285,26 +285,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty);
-        w.Write(_options.SampleRate); w.Write(_options.FrameDurationMs);
-        w.Write(_options.HiddenDim); w.Write(_options.NumLayers);
-        w.Write(_options.AggressivenessMode); w.Write(Threshold);
-        w.Write(MinSpeechDurationMs); w.Write(MinSilenceDurationMs); w.Write(_options.DropoutRate);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.SampleRate = r.ReadInt32(); _options.FrameDurationMs = r.ReadInt32();
-        _options.HiddenDim = r.ReadInt32(); _options.NumLayers = r.ReadInt32();
-        _options.AggressivenessMode = r.ReadInt32(); Threshold = r.ReadDouble();
-        MinSpeechDurationMs = r.ReadInt32(); MinSilenceDurationMs = r.ReadInt32(); _options.DropoutRate = r.ReadDouble();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() => new WebRTCVad<T>(Architecture, _options);
+
 
     #endregion
 
diff --git a/src/Audio/Whisper/WhisperModel.cs b/src/Audio/Whisper/WhisperModel.cs
index 8f5d148775..6c68e8a7b3 100644
--- a/src/Audio/Whisper/WhisperModel.cs
+++ b/src/Audio/Whisper/WhisperModel.cs
@@ -70,7 +70,7 @@ namespace AiDotNet.Audio.Whisper;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Robust Speech Recognition via Large-Scale Weak Supervision", "https://arxiv.org/abs/2212.04356", Year = 2022, Authors = "Alec Radford, Jong Wook Kim, Tao Xu, Greg Brockman, Christine McLeavey, Ilya Sutskever")]
-public class WhisperModel<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
+public partial class WhisperModel<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
 {
     private readonly WhisperOptions _options;
 
@@ -975,77 +975,12 @@ public override ModelMetadata<T> GetModelMetadata()
     /// <summary>
     /// Serializes network-specific data.
     /// </summary>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(SampleRate);
-        writer.Write(_numMels);
-        writer.Write(_maxAudioLengthSeconds);
-        writer.Write((int)_modelSize);
-        writer.Write(_language ?? string.Empty);
-        writer.Write(_translate);
-        writer.Write(_maxTokens);
-        writer.Write(_beamSize);
-        writer.Write(_temperature);
-    }
+
 
     /// <summary>
     /// Deserializes network-specific data.
     /// </summary>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        // Note: Most fields are readonly, so deserialization would require a different approach
-        // For now, we read and validate the values
-        var useNative = reader.ReadBoolean();
-        var sampleRate = reader.ReadInt32();
-        var numMels = reader.ReadInt32();
-        var maxAudioLen = reader.ReadInt32();
-        var modelSize = (WhisperModelSize)reader.ReadInt32();
-        var lang = reader.ReadString();
-        var translate = reader.ReadBoolean();
-        var maxTokens = reader.ReadInt32();
-        var beamSize = reader.ReadInt32();
-        var temperature = reader.ReadDouble();
-
-        // Validation would happen here
-    }
 
-    /// <summary>
-    /// Creates a new instance of this model for cloning.
-    /// </summary>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (_useNativeMode)
-        {
-            return new WhisperModel<T>(
-                Architecture,
-                modelSize: _modelSize,
-                language: _language,
-                translate: _translate,
-                sampleRate: SampleRate,
-                numMels: _numMels,
-                maxAudioLengthSeconds: _maxAudioLengthSeconds,
-                maxTokens: _maxTokens,
-                beamSize: _beamSize,
-                temperature: _temperature);
-        }
-        else
-        {
-            return new WhisperModel<T>(
-                Architecture,
-                encoderPath: _encoderPath!,
-                decoderPath: _decoderPath!,
-                modelSize: _modelSize,
-                language: _language,
-                translate: _translate,
-                sampleRate: SampleRate,
-                numMels: _numMels,
-                maxAudioLengthSeconds: _maxAudioLengthSeconds,
-                maxTokens: _maxTokens,
-                beamSize: _beamSize,
-                temperature: _temperature);
-        }
-    }
 
     #endregion
 
diff --git a/src/AutoML/AutoMLEnsembleModel.cs b/src/AutoML/AutoMLEnsembleModel.cs
index 78c198715c..cbd3038ef9 100644
--- a/src/AutoML/AutoMLEnsembleModel.cs
+++ b/src/AutoML/AutoMLEnsembleModel.cs
@@ -1,570 +1,519 @@
-using System.Text;
-using AiDotNet.Helpers;
-using AiDotNet.Attributes;
-using AiDotNet.Autodiff;
-using AiDotNet.Enums;
-using AiDotNet.Interfaces;
-using AiDotNet.LossFunctions;
-using AiDotNet.Models;
-using AiDotNet.Serialization;

-using System.Linq;
+using System.Text;
+using AiDotNet.Helpers;
+using AiDotNet.Attributes;
+using AiDotNet.Autodiff;
+using AiDotNet.Enums;
+using AiDotNet.Interfaces;
+using AiDotNet.LossFunctions;
+using AiDotNet.Models;
+using AiDotNet.Serialization;
+
+using System.Linq;
 using AiDotNet.Models.Parameters;
-
-namespace AiDotNet.AutoML;
-
-/// <summary>
-/// A simple tabular ensemble model used as a facade-safe AutoML final model.
-/// </summary>
-/// <typeparam name="T">The numeric type used for calculations.</typeparam>
-/// <remarks>
-/// <para>
-/// This ensemble combines multiple <see cref="IFullModel{T,TInput,TOutput}"/> members by averaging (regression/binary)
-/// or voting (multi-class) over their predictions.
-/// </para>
-/// <para>
-/// <b>For Beginners:</b> Instead of trusting one model, an ensemble uses multiple models and combines their answers.
-/// This often improves stability and accuracy.
-/// </para>
-/// </remarks>
-/// <para><b>Recommended:</b> Use <c>AiModelBuilder</c> for the simplest entry point.</para>
-/// <example>
-/// <code>
-/// // Create an ensemble from multiple trained models
-/// var models = new List&lt;IFullModel&lt;double, Matrix&lt;double&gt;, Vector&lt;double&gt;&gt;&gt;
-/// {
-///     trainedModel1,
-///     trainedModel2,
-///     trainedModel3
-/// };
-/// var ensemble = new AutoMLEnsembleModel&lt;double&gt;(
-///     models, PredictionType.Regression);
-/// Vector&lt;double&gt; predictions = ensemble.Predict(testData);
-/// </code>
-/// </example>
-[ModelDomain(ModelDomain.MachineLearning)]
-[ModelCategory(ModelCategory.Ensemble)]
-[ModelTask(ModelTask.Regression)]
-[ModelTask(ModelTask.Classification)]
-[ModelComplexity(ModelComplexity.Medium)]
-[ModelInput(typeof(Matrix<>), typeof(Vector<>))]
-[ResearchPaper("Ensemble Methods in Machine Learning", "https://doi.org/10.1007/3-540-45014-9_1")]
-public sealed partial class AutoMLEnsembleModel<T> : ModelBase<T, Matrix<T>, Vector<T>>
-{
-
-    [JsonProperty("Members")]
-    private List<IFullModel<T, Matrix<T>, Vector<T>>> _members = new();
-
-    [JsonIgnore]
-    private IReadOnlyList<IFullModel<T, Matrix<T>, Vector<T>>> _membersView = Array.Empty<IFullModel<T, Matrix<T>, Vector<T>>>();
-
-    /// <summary>
-    /// Initializes a new instance of the <see cref="AutoMLEnsembleModel{T}"/> class.
-    /// </summary>
-    /// <remarks>
-    /// This constructor exists for serialization only. Prefer the overload that accepts members.
-    /// </remarks>
-    public AutoMLEnsembleModel()
-    {
-        SetMembers(new List<IFullModel<T, Matrix<T>, Vector<T>>>());
-        Weights = Array.Empty<double>();
-    }
-
-    public AutoMLEnsembleModel(
-        IEnumerable<IFullModel<T, Matrix<T>, Vector<T>>> members,
-        PredictionType predictionType,
-        IReadOnlyList<double>? weights = null)
-    {
-        if (members is null)
-        {
-            throw new ArgumentNullException(nameof(members));
-        }
-
-        var list = members.ToList();
-        if (list.Count == 0)
-        {
-            throw new ArgumentException("Ensemble must include at least one member.", nameof(members));
-        }
-
-        SetMembers(list);
-        PredictionType = predictionType;
-        Weights = weights is null ? CreateUniformWeights(list.Count) : NormalizeWeights(weights, list.Count);
-    }
-
-    /// <summary>
-    /// Gets the member models in the ensemble.
-    /// </summary>
-    [JsonIgnore]
-    public IReadOnlyList<IFullModel<T, Matrix<T>, Vector<T>>> Members => _membersView;
-
-    /// <summary>
-    /// Gets or sets the prediction type used to combine outputs (regression vs classification).
-    /// </summary>
-    public PredictionType PredictionType { get; set; } = PredictionType.Regression;
-
-    /// <summary>
-    /// Gets or sets the per-member weights used when combining predictions.
-    /// </summary>
-    /// <remarks>
-    /// Weights are normalized to sum to 1.0.
-    /// </remarks>
-    public double[] Weights { get; set; }
-
-    public override ILossFunction<T> DefaultLossFunction => Members.Count == 0
-        ? throw new InvalidOperationException("Ensemble has no members.")
-        : Members[0].DefaultLossFunction;
-
-    public override void Train(Matrix<T> input, Vector<T> expectedOutput)
-    {
-        if (Members.Count == 0)
-        {
-            throw new InvalidOperationException("Ensemble has no members.");
-        }
-
-        foreach (var member in Members)
-        {
-            member.Train(input, expectedOutput);
-        }
-    }
-
-    public override Vector<T> Predict(Matrix<T> input)
-    {
-        if (Members.Count == 0)
-        {
-            throw new InvalidOperationException("Ensemble has no members.");
-        }
-
-        var predictions = Members.Select(m => m.Predict(input)).ToList();
-        if (predictions.Count == 1)
-        {
-            return predictions[0];
-        }
-
-        return PredictionType == PredictionType.MultiClass
-            ? Vote(predictions)
-            : WeightedAverage(predictions);
-    }
-
-    public override ModelMetadata<T> GetModelMetadata()
-    {
-        var metadata = Members.Count == 0
-            ? new ModelMetadata<T>()
-            : Members[0].GetModelMetadata();
-
-        metadata.Name = string.IsNullOrWhiteSpace(metadata.Name) ? "AutoML Ensemble" : $"{metadata.Name} (Ensemble)";
-        metadata.Description = $"AutoML ensemble with {Members.Count} members.";
-        metadata.SetProperty("EnsembleSize", Members.Count);
-        metadata.SetProperty("PredictionType", PredictionType.ToString());
-
-        return metadata;
-    }
-
-    public override byte[] Serialize()
-    {
-        ModelPersistenceGuard.EnforceBeforeSerialize();
-        var settings = new JsonSerializerSettings
-        {
-            TypeNameHandling = TypeNameHandling.Auto,
-            SerializationBinder = new SafeSerializationBinder(),
-            Formatting = Formatting.None
-        };
-
-        var json = JsonConvert.SerializeObject(this, settings);
-        return Encoding.UTF8.GetBytes(json);
-    }
-
-    public override void Deserialize(byte[] data)
-    {
-        ModelPersistenceGuard.EnforceBeforeDeserialize();
-        if (data is null)
-        {
-            throw new ArgumentNullException(nameof(data));
-        }
-
-        var json = Encoding.UTF8.GetString(data);
-        var settings = new JsonSerializerSettings
-        {
-            TypeNameHandling = TypeNameHandling.Auto,
-            SerializationBinder = new SafeSerializationBinder()
-        };
-
-        var deserialized = JsonConvert.DeserializeObject<AutoMLEnsembleModel<T>>(json, settings);
-        if (deserialized is null)
-        {
-            throw new InvalidOperationException("Failed to deserialize ensemble model.");
-        }
-
-        SetMembers(deserialized._members);
-        PredictionType = deserialized.PredictionType;
-        Weights = deserialized.Weights ?? Array.Empty<double>();
-    }
-
-    private void SetMembers(List<IFullModel<T, Matrix<T>, Vector<T>>>? members)
-    {
-        _members = members ?? new List<IFullModel<T, Matrix<T>, Vector<T>>>();
-        _membersView = _members.AsReadOnly();
-    }
-
-    public override void SaveModel(string filePath)
-    {
-        Helpers.ModelPersistenceGuard.EnforceBeforeSave();
-        using (Helpers.ModelPersistenceGuard.InternalOperation())
-        {
-            File.WriteAllBytes(filePath, Serialize());
-        }
-    }
-
-    public override void LoadModel(string filePath)
-    {
-        Helpers.ModelPersistenceGuard.EnforceBeforeLoad();
-        using (Helpers.ModelPersistenceGuard.InternalOperation())
-        {
-            Deserialize(File.ReadAllBytes(filePath));
-        }
-    }
-
-    public override void SaveState(Stream stream)
-    {
-        if (stream is null)
-        {
-            throw new ArgumentNullException(nameof(stream));
-        }
-
-        if (!stream.CanWrite)
-        {
-            throw new ArgumentException("Stream must be writable.", nameof(stream));
-        }
-
-        var data = Serialize();
-        stream.Write(data, 0, data.Length);
-        stream.Flush();
-    }
-
-    public override void LoadState(Stream stream)
-    {
-        if (stream is null)
-        {
-            throw new ArgumentNullException(nameof(stream));
-        }
-
-        if (!stream.CanRead)
-        {
-            throw new ArgumentException("Stream must be readable.", nameof(stream));
-        }
-
-        using var ms = new MemoryStream();
-        stream.CopyTo(ms);
-        Deserialize(ms.ToArray());
-    }
-
-    /// <summary>
-    /// The ensemble's parameters are its members', concatenated in member order.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// Declared by hand rather than discovered, and the reason is worth recording: IFullModel does
-    /// NOT derive from IParameterizable or IParameterSource, so a collection of models is not
-    /// statically a collection of parameter sources and automatic discovery correctly skips it. The
-    /// three surfaces this replaces each got round that by CASTING members to IParameterizable --
-    /// they depended on a relationship the type system does not express, three separate times.
-    /// </para>
-    /// <para>
-    /// One source makes the count and the vector agree, and the cast now happens in one place
-    /// instead of three. If IFullModel ever declares the relationship it already relies on, this
-    /// becomes discoverable and the declaration can go.
-    /// </para>
-    /// <para>
-    /// Members are re-read on every access, not captured: an ensemble gains members after
-    /// construction, and registration runs once and lazily.
-    /// </para>
-    /// </remarks>
-    protected override void RegisterComponents()
-    {
-        base.RegisterComponents();
-        RegisterParameterComponent(new ComponentCollectionParameterSource<T>(
-            () => Members.OfType<IParameterizable<T, Matrix<T>, Vector<T>>>()));
-    }
-
-    // Replaced by the declared parameter source below. Removed under AIDN082.
-
-    // Replaced by the declared parameter source below. Removed under AIDN082.
-
-    // Replaced by the declared parameter source below. Removed under AIDN082.
-
-    public override IFullModel<T, Matrix<T>, Vector<T>> WithParameters(Vector<T> parameters)
-    {
-        var copy = DeepCopy();
-        ((IParameterizable<T, Matrix<T>, Vector<T>>)copy).SetParameters(parameters);
-        return copy;
-    }
-
-    public override IEnumerable<int> GetActiveFeatureIndices()
-    {
-        if (Members.Count == 0)
-        {
-            return Array.Empty<int>();
-        }
-
-        var indices = new HashSet<int>();
-        foreach (var member in Members)
-        {
-            foreach (var idx in InterfaceGuard.FeatureAware(member).GetActiveFeatureIndices())
-            {
-                indices.Add(idx);
-            }
-        }
-
-        return indices.OrderBy(i => i).ToArray();
-    }
-
-    public override void SetActiveFeatureIndices(IEnumerable<int> featureIndices)
-    {
-        foreach (var member in Members)
-        {
-            InterfaceGuard.FeatureAware(member).SetActiveFeatureIndices(featureIndices);
-        }
-    }
-
-    public override bool IsFeatureUsed(int featureIndex)
-    {
-        return Members.Any(m => InterfaceGuard.FeatureAware(m).IsFeatureUsed(featureIndex));
-    }
-
-    public override Dictionary<string, T> GetFeatureImportance()
-    {
-        if (Members.Count == 0)
-        {
-            return new Dictionary<string, T>(StringComparer.Ordinal);
-        }
-
-        var aggregate = new Dictionary<string, (double Sum, int Count)>(StringComparer.Ordinal);
-
-        foreach (var member in Members)
-        {
-            Dictionary<string, T> importance;
-            try
-            {
-                importance = member.GetFeatureImportance();
-            }
-            catch (InvalidOperationException)
-            {
-                continue;
-            }
-            catch (NotSupportedException)
-            {
-                continue;
-            }
-
-            foreach (var (key, value) in importance)
-            {
-                double numeric = NumOps.ToDouble(value);
-                if (!aggregate.TryGetValue(key, out var entry))
-                {
-                    aggregate[key] = (numeric, 1);
-                }
-                else
-                {
-                    aggregate[key] = (entry.Sum + numeric, entry.Count + 1);
-                }
-            }
-        }
-
-        var result = new Dictionary<string, T>(StringComparer.Ordinal);
-        foreach (var (key, entry) in aggregate)
-        {
-            result[key] = NumOps.FromDouble(entry.Sum / Math.Max(1, entry.Count));
-        }
-
-        return result;
-    }
-
-    public override IFullModel<T, Matrix<T>, Vector<T>> DeepCopy()
-    {
-        var copiedMembers = Members.Select(m => m.DeepCopy()).ToList();
-        return new AutoMLEnsembleModel<T>(copiedMembers, PredictionType, GetSafeNormalizedWeights(copiedMembers.Count));
-    }
-
-    public override IFullModel<T, Matrix<T>, Vector<T>> Clone()
-    {
-        var clonedMembers = Members.Select(m => m.Clone()).ToList();
-        return new AutoMLEnsembleModel<T>(clonedMembers, PredictionType, GetSafeNormalizedWeights(clonedMembers.Count));
-    }
-
-    public override Vector<T> ComputeGradients(Matrix<T> input, Vector<T> target, ILossFunction<T>? lossFunction = null)
-    {
-        if (Members.Count == 0)
-        {
-            throw new InvalidOperationException("Ensemble has no members.");
-        }
-
-        var gradients = Members
-            .Select(m => ((IGradientComputable<T, Matrix<T>, Vector<T>>)m).ComputeGradients(input, target, lossFunction))
-            .ToArray();
-
-        return Vector<T>.Concatenate(gradients);
-    }
-
-    public override void ApplyGradients(Vector<T> gradients, T learningRate)
-    {
-        if (Members.Count == 0)
-        {
-            throw new InvalidOperationException("Ensemble has no members.");
-        }
-
-        int expected = ParameterCountHelper.ToFlatVectorSize(ParameterCount);
-        if (gradients.Length != expected)
-        {
-            throw new ArgumentException($"Gradient vector length {gradients.Length} does not match expected {expected}.", nameof(gradients));
-        }
-
-        int offset = 0;
-        foreach (var member in Members)
-        {
-            var paramMember = (IParameterizable<T, Matrix<T>, Vector<T>>)member;
-            int count = checked((int)paramMember.ParameterCount);
-            var segment = new Vector<T>(count);
-            for (int i = 0; i < count; i++)
-            {
-                segment[i] = gradients[offset + i];
-            }
-
-            ((IGradientComputable<T, Matrix<T>, Vector<T>>)member).ApplyGradients(segment, learningRate);
-            offset += count;
-        }
-    }
-
-    private Vector<T> WeightedAverage(IReadOnlyList<Vector<T>> predictions)
-    {
-        int length = predictions[0].Length;
-        var output = new Vector<T>(length);
-
-        var weightVector = GetSafeNormalizedWeights(predictions.Count);
-        var weightsT = weightVector.Select(NumOps.FromDouble).ToArray();
-
-        for (int i = 0; i < length; i++)
-        {
-            T sum = NumOps.Zero;
-            for (int m = 0; m < predictions.Count; m++)
-            {
-                sum = NumOps.Add(sum, NumOps.Multiply(predictions[m][i], weightsT[m]));
-            }
-
-            output[i] = sum;
-        }
-
-        return output;
-    }
-
-    private Vector<T> Vote(IReadOnlyList<Vector<T>> predictions)
-    {
-        int length = predictions[0].Length;
-        var output = new Vector<T>(length);
-        var weightVector = GetSafeNormalizedWeights(predictions.Count);
-
-        for (int i = 0; i < length; i++)
-        {
-            var counts = new Dictionary<int, double>();
-
-            for (int m = 0; m < predictions.Count; m++)
-            {
-                int label = NumOps.ToInt32(predictions[m][i]);
-                double weight = weightVector[m];
-
-                counts[label] = counts.TryGetValue(label, out var existing)
-                    ? existing + weight
-                    : weight;
-            }
-
-            int bestLabel = counts.OrderByDescending(kvp => kvp.Value).ThenBy(kvp => kvp.Key).First().Key;
-            output[i] = NumOps.FromDouble(bestLabel);
-        }
-
-        return output;
-    }
-
-    private double[] GetSafeNormalizedWeights(int expectedCount)
-    {
-        if (expectedCount <= 0)
-        {
-            return Array.Empty<double>();
-        }
-
-        if (Weights is null || Weights.Length != expectedCount)
-        {
-            return CreateUniformWeights(expectedCount);
-        }
-
-        double sum = 0.0;
-        for (int i = 0; i < Weights.Length; i++)
-        {
-            double value = Weights[i];
-            if (double.IsNaN(value) || double.IsInfinity(value))
-            {
-                return CreateUniformWeights(expectedCount);
-            }
-
-            sum += value;
-        }
-
-        if (sum <= 0 || double.IsNaN(sum) || double.IsInfinity(sum))
-        {
-            return CreateUniformWeights(expectedCount);
-        }
-
-        if (Math.Abs(sum - 1.0) <= 1e-12)
-        {
-            return Weights;
-        }
-
-        var normalized = new double[expectedCount];
-        for (int i = 0; i < expectedCount; i++)
-        {
-            normalized[i] = Weights[i] / sum;
-        }
-
-        return normalized;
-    }
-
-    private static double[] CreateUniformWeights(int count)
-    {
-        if (count <= 0)
-        {
-            return Array.Empty<double>();
-        }
-
-        double w = 1.0 / count;
-        var weights = new double[count];
-        for (int i = 0; i < count; i++)
-        {
-            weights[i] = w;
-        }
-
-        return weights;
-    }
-
-    private static double[] NormalizeWeights(IReadOnlyList<double> weights, int count)
-    {
-        if (count <= 0)
-        {
-            return Array.Empty<double>();
-        }
-
-        if (weights.Count != count)
-        {
-            throw new ArgumentException($"Expected {count} weights but received {weights.Count}.", nameof(weights));
-        }
-
-        double sum = weights.Sum();
-        if (sum <= 0 || double.IsNaN(sum) || double.IsInfinity(sum))
-        {
-            return CreateUniformWeights(count);
-        }
-
-        var normalized = new double[count];
-        for (int i = 0; i < count; i++)
-        {
-            normalized[i] = weights[i] / sum;
-        }
-
-        return normalized;
-    }
-}
+
+namespace AiDotNet.AutoML;
+
+/// <summary>
+/// A simple tabular ensemble model used as a facade-safe AutoML final model.
+/// </summary>
+/// <typeparam name="T">The numeric type used for calculations.</typeparam>
+/// <remarks>
+/// <para>
+/// This ensemble combines multiple <see cref="IFullModel{T,TInput,TOutput}"/> members by averaging (regression/binary)
+/// or voting (multi-class) over their predictions.
+/// </para>
+/// <para>
+/// <b>For Beginners:</b> Instead of trusting one model, an ensemble uses multiple models and combines their answers.
+/// This often improves stability and accuracy.
+/// </para>
+/// </remarks>
+/// <para><b>Recommended:</b> Use <c>AiModelBuilder</c> for the simplest entry point.</para>
+/// <example>
+/// <code>
+/// // Create an ensemble from multiple trained models
+/// var models = new List&lt;IFullModel&lt;double, Matrix&lt;double&gt;, Vector&lt;double&gt;&gt;&gt;
+/// {
+///     trainedModel1,
+///     trainedModel2,
+///     trainedModel3
+/// };
+/// var ensemble = new AutoMLEnsembleModel&lt;double&gt;(
+///     models, PredictionType.Regression);
+/// Vector&lt;double&gt; predictions = ensemble.Predict(testData);
+/// </code>
+/// </example>
+[ModelDomain(ModelDomain.MachineLearning)]
+[ModelCategory(ModelCategory.Ensemble)]
+[ModelTask(ModelTask.Regression)]
+[ModelTask(ModelTask.Classification)]
+[ModelComplexity(ModelComplexity.Medium)]
+[ModelInput(typeof(Matrix<>), typeof(Vector<>))]
+[ResearchPaper("Ensemble Methods in Machine Learning", "https://doi.org/10.1007/3-540-45014-9_1")]
+public sealed partial class AutoMLEnsembleModel<T> : ModelBase<T, Matrix<T>, Vector<T>>
+{
+
+    [JsonProperty("Members")]
+    private List<IFullModel<T, Matrix<T>, Vector<T>>> _members = new();
+
+    [JsonIgnore]
+    private IReadOnlyList<IFullModel<T, Matrix<T>, Vector<T>>> _membersView = Array.Empty<IFullModel<T, Matrix<T>, Vector<T>>>();
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="AutoMLEnsembleModel{T}"/> class.
+    /// </summary>
+    /// <remarks>
+    /// This constructor exists for serialization only. Prefer the overload that accepts members.
+    /// </remarks>
+    public AutoMLEnsembleModel()
+    {
+        SetMembers(new List<IFullModel<T, Matrix<T>, Vector<T>>>());
+        Weights = Array.Empty<double>();
+    }
+
+    public AutoMLEnsembleModel(
+        IEnumerable<IFullModel<T, Matrix<T>, Vector<T>>> members,
+        PredictionType predictionType,
+        IReadOnlyList<double>? weights = null)
+    {
+        if (members is null)
+        {
+            throw new ArgumentNullException(nameof(members));
+        }
+
+        var list = members.ToList();
+        if (list.Count == 0)
+        {
+            throw new ArgumentException("Ensemble must include at least one member.", nameof(members));
+        }
+
+        SetMembers(list);
+        PredictionType = predictionType;
+        Weights = weights is null ? CreateUniformWeights(list.Count) : NormalizeWeights(weights, list.Count);
+    }
+
+    /// <summary>
+    /// Gets the member models in the ensemble.
+    /// </summary>
+    [JsonIgnore]
+    public IReadOnlyList<IFullModel<T, Matrix<T>, Vector<T>>> Members => _membersView;
+
+    /// <summary>
+    /// Gets or sets the prediction type used to combine outputs (regression vs classification).
+    /// </summary>
+    public PredictionType PredictionType { get; set; } = PredictionType.Regression;
+
+    /// <summary>
+    /// Gets or sets the per-member weights used when combining predictions.
+    /// </summary>
+    /// <remarks>
+    /// Weights are normalized to sum to 1.0.
+    /// </remarks>
+    public double[] Weights { get; set; }
+
+    public override ILossFunction<T> DefaultLossFunction => Members.Count == 0
+        ? throw new InvalidOperationException("Ensemble has no members.")
+        : Members[0].DefaultLossFunction;
+
+    public override void Train(Matrix<T> input, Vector<T> expectedOutput)
+    {
+        if (Members.Count == 0)
+        {
+            throw new InvalidOperationException("Ensemble has no members.");
+        }
+
+        foreach (var member in Members)
+        {
+            member.Train(input, expectedOutput);
+        }
+    }
+
+    public override Vector<T> Predict(Matrix<T> input)
+    {
+        if (Members.Count == 0)
+        {
+            throw new InvalidOperationException("Ensemble has no members.");
+        }
+
+        var predictions = Members.Select(m => m.Predict(input)).ToList();
+        if (predictions.Count == 1)
+        {
+            return predictions[0];
+        }
+
+        return PredictionType == PredictionType.MultiClass
+            ? Vote(predictions)
+            : WeightedAverage(predictions);
+    }
+
+    public override ModelMetadata<T> GetModelMetadata()
+    {
+        var metadata = Members.Count == 0
+            ? new ModelMetadata<T>()
+            : Members[0].GetModelMetadata();
+
+        metadata.Name = string.IsNullOrWhiteSpace(metadata.Name) ? "AutoML Ensemble" : $"{metadata.Name} (Ensemble)";
+        metadata.Description = $"AutoML ensemble with {Members.Count} members.";
+        metadata.SetProperty("EnsembleSize", Members.Count);
+        metadata.SetProperty("PredictionType", PredictionType.ToString());
+
+        return metadata;
+    }
+
+    private void SetMembers(List<IFullModel<T, Matrix<T>, Vector<T>>>? members)
+    {
+        _members = members ?? new List<IFullModel<T, Matrix<T>, Vector<T>>>();
+        _membersView = _members.AsReadOnly();
+    }
+
+    public override void SaveModel(string filePath)
+    {
+        Helpers.ModelPersistenceGuard.EnforceBeforeSave();
+        using (Helpers.ModelPersistenceGuard.InternalOperation())
+        {
+            File.WriteAllBytes(filePath, Serialize());
+        }
+    }
+
+    public override void LoadModel(string filePath)
+    {
+        Helpers.ModelPersistenceGuard.EnforceBeforeLoad();
+        using (Helpers.ModelPersistenceGuard.InternalOperation())
+        {
+            Deserialize(File.ReadAllBytes(filePath));
+        }
+    }
+
+    public override void SaveState(Stream stream)
+    {
+        if (stream is null)
+        {
+            throw new ArgumentNullException(nameof(stream));
+        }
+
+        if (!stream.CanWrite)
+        {
+            throw new ArgumentException("Stream must be writable.", nameof(stream));
+        }
+
+        var data = Serialize();
+        stream.Write(data, 0, data.Length);
+        stream.Flush();
+    }
+
+    public override void LoadState(Stream stream)
+    {
+        if (stream is null)
+        {
+            throw new ArgumentNullException(nameof(stream));
+        }
+
+        if (!stream.CanRead)
+        {
+            throw new ArgumentException("Stream must be readable.", nameof(stream));
+        }
+
+        using var ms = new MemoryStream();
+        stream.CopyTo(ms);
+        Deserialize(ms.ToArray());
+    }
+
+    /// <summary>
+    /// The ensemble's parameters are its members', concatenated in member order.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// Declared by hand rather than discovered, and the reason is worth recording: IFullModel does
+    /// NOT derive from IParameterizable or IParameterSource, so a collection of models is not
+    /// statically a collection of parameter sources and automatic discovery correctly skips it. The
+    /// three surfaces this replaces each got round that by CASTING members to IParameterizable --
+    /// they depended on a relationship the type system does not express, three separate times.
+    /// </para>
+    /// <para>
+    /// One source makes the count and the vector agree, and the cast now happens in one place
+    /// instead of three. If IFullModel ever declares the relationship it already relies on, this
+    /// becomes discoverable and the declaration can go.
+    /// </para>
+    /// <para>
+    /// Members are re-read on every access, not captured: an ensemble gains members after
+    /// construction, and registration runs once and lazily.
+    /// </para>
+    /// </remarks>
+    protected override void RegisterComponents()
+    {
+        base.RegisterComponents();
+        RegisterParameterComponent(new ComponentCollectionParameterSource<T>(
+            () => Members.OfType<IParameterizable<T, Matrix<T>, Vector<T>>>()));
+    }
+
+    // Replaced by the declared parameter source below. Removed under AIDN082.
+
+    // Replaced by the declared parameter source below. Removed under AIDN082.
+
+    // Replaced by the declared parameter source below. Removed under AIDN082.
+
+    public override IFullModel<T, Matrix<T>, Vector<T>> WithParameters(Vector<T> parameters)
+    {
+        var copy = DeepCopy();
+        ((IParameterizable<T, Matrix<T>, Vector<T>>)copy).SetParameters(parameters);
+        return copy;
+    }
+
+    public override IEnumerable<int> GetActiveFeatureIndices()
+    {
+        if (Members.Count == 0)
+        {
+            return Array.Empty<int>();
+        }
+
+        var indices = new HashSet<int>();
+        foreach (var member in Members)
+        {
+            foreach (var idx in InterfaceGuard.FeatureAware(member).GetActiveFeatureIndices())
+            {
+                indices.Add(idx);
+            }
+        }
+
+        return indices.OrderBy(i => i).ToArray();
+    }
+
+    public override void SetActiveFeatureIndices(IEnumerable<int> featureIndices)
+    {
+        foreach (var member in Members)
+        {
+            InterfaceGuard.FeatureAware(member).SetActiveFeatureIndices(featureIndices);
+        }
+    }
+
+    public override bool IsFeatureUsed(int featureIndex)
+    {
+        return Members.Any(m => InterfaceGuard.FeatureAware(m).IsFeatureUsed(featureIndex));
+    }
+
+    public override Dictionary<string, T> GetFeatureImportance()
+    {
+        if (Members.Count == 0)
+        {
+            return new Dictionary<string, T>(StringComparer.Ordinal);
+        }
+
+        var aggregate = new Dictionary<string, (double Sum, int Count)>(StringComparer.Ordinal);
+
+        foreach (var member in Members)
+        {
+            Dictionary<string, T> importance;
+            try
+            {
+                importance = member.GetFeatureImportance();
+            }
+            catch (InvalidOperationException)
+            {
+                continue;
+            }
+            catch (NotSupportedException)
+            {
+                continue;
+            }
+
+            foreach (var (key, value) in importance)
+            {
+                double numeric = NumOps.ToDouble(value);
+                if (!aggregate.TryGetValue(key, out var entry))
+                {
+                    aggregate[key] = (numeric, 1);
+                }
+                else
+                {
+                    aggregate[key] = (entry.Sum + numeric, entry.Count + 1);
+                }
+            }
+        }
+
+        var result = new Dictionary<string, T>(StringComparer.Ordinal);
+        foreach (var (key, entry) in aggregate)
+        {
+            result[key] = NumOps.FromDouble(entry.Sum / Math.Max(1, entry.Count));
+        }
+
+        return result;
+    }
+
+    public override Vector<T> ComputeGradients(Matrix<T> input, Vector<T> target, ILossFunction<T>? lossFunction = null)
+    {
+        if (Members.Count == 0)
+        {
+            throw new InvalidOperationException("Ensemble has no members.");
+        }
+
+        var gradients = Members
+            .Select(m => ((IGradientComputable<T, Matrix<T>, Vector<T>>)m).ComputeGradients(input, target, lossFunction))
+            .ToArray();
+
+        return Vector<T>.Concatenate(gradients);
+    }
+
+    public override void ApplyGradients(Vector<T> gradients, T learningRate)
+    {
+        if (Members.Count == 0)
+        {
+            throw new InvalidOperationException("Ensemble has no members.");
+        }
+
+        int expected = ParameterCountHelper.ToFlatVectorSize(ParameterCount);
+        if (gradients.Length != expected)
+        {
+            throw new ArgumentException($"Gradient vector length {gradients.Length} does not match expected {expected}.", nameof(gradients));
+        }
+
+        int offset = 0;
+        foreach (var member in Members)
+        {
+            var paramMember = (IParameterizable<T, Matrix<T>, Vector<T>>)member;
+            int count = checked((int)paramMember.ParameterCount);
+            var segment = new Vector<T>(count);
+            for (int i = 0; i < count; i++)
+            {
+                segment[i] = gradients[offset + i];
+            }
+
+            ((IGradientComputable<T, Matrix<T>, Vector<T>>)member).ApplyGradients(segment, learningRate);
+            offset += count;
+        }
+    }
+
+    private Vector<T> WeightedAverage(IReadOnlyList<Vector<T>> predictions)
+    {
+        int length = predictions[0].Length;
+        var output = new Vector<T>(length);
+
+        var weightVector = GetSafeNormalizedWeights(predictions.Count);
+        var weightsT = weightVector.Select(NumOps.FromDouble).ToArray();
+
+        for (int i = 0; i < length; i++)
+        {
+            T sum = NumOps.Zero;
+            for (int m = 0; m < predictions.Count; m++)
+            {
+                sum = NumOps.Add(sum, NumOps.Multiply(predictions[m][i], weightsT[m]));
+            }
+
+            output[i] = sum;
+        }
+
+        return output;
+    }
+
+    private Vector<T> Vote(IReadOnlyList<Vector<T>> predictions)
+    {
+        int length = predictions[0].Length;
+        var output = new Vector<T>(length);
+        var weightVector = GetSafeNormalizedWeights(predictions.Count);
+
+        for (int i = 0; i < length; i++)
+        {
+            var counts = new Dictionary<int, double>();
+
+            for (int m = 0; m < predictions.Count; m++)
+            {
+                int label = NumOps.ToInt32(predictions[m][i]);
+                double weight = weightVector[m];
+
+                counts[label] = counts.TryGetValue(label, out var existing)
+                    ? existing + weight
+                    : weight;
+            }
+
+            int bestLabel = counts.OrderByDescending(kvp => kvp.Value).ThenBy(kvp => kvp.Key).First().Key;
+            output[i] = NumOps.FromDouble(bestLabel);
+        }
+
+        return output;
+    }
+
+    private double[] GetSafeNormalizedWeights(int expectedCount)
+    {
+        if (expectedCount <= 0)
+        {
+            return Array.Empty<double>();
+        }
+
+        if (Weights is null || Weights.Length != expectedCount)
+        {
+            return CreateUniformWeights(expectedCount);
+        }
+
+        double sum = 0.0;
+        for (int i = 0; i < Weights.Length; i++)
+        {
+            double value = Weights[i];
+            if (double.IsNaN(value) || double.IsInfinity(value))
+            {
+                return CreateUniformWeights(expectedCount);
+            }
+
+            sum += value;
+        }
+
+        if (sum <= 0 || double.IsNaN(sum) || double.IsInfinity(sum))
+        {
+            return CreateUniformWeights(expectedCount);
+        }
+
+        if (Math.Abs(sum - 1.0) <= 1e-12)
+        {
+            return Weights;
+        }
+
+        var normalized = new double[expectedCount];
+        for (int i = 0; i < expectedCount; i++)
+        {
+            normalized[i] = Weights[i] / sum;
+        }
+
+        return normalized;
+    }
+
+    private static double[] CreateUniformWeights(int count)
+    {
+        if (count <= 0)
+        {
+            return Array.Empty<double>();
+        }
+
+        double w = 1.0 / count;
+        var weights = new double[count];
+        for (int i = 0; i < count; i++)
+        {
+            weights[i] = w;
+        }
+
+        return weights;
+    }
+
+    private static double[] NormalizeWeights(IReadOnlyList<double> weights, int count)
+    {
+        if (count <= 0)
+        {
+            return Array.Empty<double>();
+        }
+
+        if (weights.Count != count)
+        {
+            throw new ArgumentException($"Expected {count} weights but received {weights.Count}.", nameof(weights));
+        }
+
+        double sum = weights.Sum();
+        if (sum <= 0 || double.IsNaN(sum) || double.IsInfinity(sum))
+        {
+            return CreateUniformWeights(count);
+        }
+
+        var normalized = new double[count];
+        for (int i = 0; i < count; i++)
+        {
+            normalized[i] = weights[i] / sum;
+        }
+
+        return normalized;
+    }
+}
diff --git a/src/AutoML/AutoMLModelBase.cs b/src/AutoML/AutoMLModelBase.cs
index 9dec78890c..41ed3ea015 100644
--- a/src/AutoML/AutoMLModelBase.cs
+++ b/src/AutoML/AutoMLModelBase.cs
@@ -20,8 +20,51 @@ namespace AiDotNet.AutoML
     /// <typeparam name="T">The numeric type used for calculations</typeparam>
     /// <typeparam name="TInput">The input data type</typeparam>
     /// <typeparam name="TOutput">The output data type</typeparam>
-    public abstract class AutoMLModelBase<T, TInput, TOutput> : IAutoMLModel<T, TInput, TOutput>, IModelShape
+    public abstract partial class AutoMLModelBase<T, TInput, TOutput> : IAutoMLModel<T, TInput, TOutput>, IModelShape
     {
+    // --- declared state (ModelStateRegistry) ---
+    // Identical in every model base because these bases are siblings over the same interfaces rather
+    // than one hierarchy; the logic itself lives once in ModelStateRegistry/ModelStateEnvelope.
+
+    /// <summary>State that is not a parameter vector, declared once and persisted by this base.</summary>
+    private readonly AiDotNet.Models.ModelStateRegistry<T> _declaredState = new();
+    private bool _declaredStateRegistered;
+
+    /// <summary>
+    /// Declare state here that the parameter vector does not carry -- a retained training set,
+    /// fitted knots, kernel centres, an ensemble's children. Both halves of the payload are driven
+    /// by the declaration, so they cannot drift.
+    /// </summary>
+    /// <param name="state">The registry to declare into.</param>
+    protected virtual void RegisterState(AiDotNet.Models.ModelStateRegistry<T> state)
+    {
+    }
+    /// <summary>Generated state declarations for fields declared across this model's hierarchy.</summary>
+    /// <param name="state">The registry to declare into.</param>
+    /// <remarks>
+    /// Emitted by ModelStateGenerator into the partial model, so a model author declares nothing. The
+    /// hand-written <c>RegisterState</c> beside it exists only for state the classifier genuinely
+    /// cannot place; anything it CAN place belongs here, where it cannot be forgotten.
+    /// </remarks>
+    protected virtual void RegisterGeneratedState(AiDotNet.Models.ModelStateRegistry<T> state)
+    {
+        RegisterGeneratedStateCore(state);
+    }
+
+    /// <summary>The declared state, registered once and lazily so it runs after the constructor.</summary>
+    protected AiDotNet.Models.ModelStateRegistry<T> DeclaredState
+    {
+        get
+        {
+            if (!_declaredStateRegistered)
+            {
+                _declaredStateRegistered = true;
+                RegisterGeneratedState(_declaredState);
+                RegisterState(_declaredState);
+            }
+            return _declaredState;
+        }
+    }
         /// <summary>
         /// Standard key used in trial parameter dictionaries to store the model <see cref="Type"/>.
         /// Using this constant avoids typo-related runtime failures across all AutoML strategies.
@@ -752,6 +795,9 @@ public virtual byte[] Serialize()
     /// </summary>
     public virtual void Deserialize(byte[] data)
     {
+        // Strips and applies any declared-state trailer, so the body below reads the payload
+        // exactly as it did before this existed.
+        data = AiDotNet.Models.ModelStateEnvelope.Extract(DeclaredState, data);
         ModelPersistenceGuard.EnforceBeforeDeserialize();
         if (BestModel == null)
         {
@@ -942,17 +988,29 @@ public virtual IFullModel<T, TInput, TOutput> DeepCopy()
     }
 
     /// <summary>
-    /// Factory method for creating a new instance for deep copy.
-    /// Derived classes must implement this to return a new instance of themselves.
-    /// This ensures each copy has its own collections and lock object.
+    /// Creates a new instance of this model's runtime type for a deep copy to populate.
     /// </summary>
-    /// <returns>A fresh instance of the derived class with default parameters</returns>
+    /// <returns>A fresh instance of the derived class.</returns>
     /// <remarks>
-    /// When implementing this method, derived classes should create a fresh instance with default parameters,
-    /// and should not attempt to preserve runtime or initialization state from the original instance.
-    /// The deep copy logic will transfer relevant state (trial history, search space, etc.) after construction.
+    /// <para>
+    /// NO LONGER ABSTRACT, for the reason <c>CreateNewInstance</c> stopped being abstract across the
+    /// other model families: an abstract factory hook obliges every subclass to write out "build one
+    /// of me", and the recorded constructor already knows how. Fourteen models implemented it here,
+    /// each re-listing the arguments its own type happens to take, and each one a place a new
+    /// argument can be forgotten.
+    /// </para>
+    /// <para>
+    /// The clone plan replays the constructor the instance was actually built through, so this is the
+    /// same code for every model. Deep copy still transfers trial history, search space and the rest
+    /// afterwards exactly as before -- this only supplies the empty instance it fills.
+    /// </para>
+    /// <para>
+    /// Still virtual: a model whose construction the plan cannot reproduce can override, and ADN0059
+    /// names it when that is the case rather than leaving it to fail at runtime.
+    /// </para>
     /// </remarks>
-    protected abstract AutoMLModelBase<T, TInput, TOutput> CreateInstanceForCopy();
+    protected virtual AutoMLModelBase<T, TInput, TOutput> CreateInstanceForCopy()
+        => (AutoMLModelBase<T, TInput, TOutput>)AiDotNet.Models.CloneEngine.CopyConfiguration(this);
 
 
         #endregion
diff --git a/src/AutoML/BayesianOptimizationAutoML.cs b/src/AutoML/BayesianOptimizationAutoML.cs
index 0b9d405803..04184a6d34 100644
--- a/src/AutoML/BayesianOptimizationAutoML.cs
+++ b/src/AutoML/BayesianOptimizationAutoML.cs
@@ -149,11 +149,6 @@ public override Task<Dictionary<string, object>> SuggestNextTrialAsync()
         return Task.FromResult(sampled);
     }
 
-    protected override AutoMLModelBase<T, TInput, TOutput> CreateInstanceForCopy()
-    {
-        return new BayesianOptimizationAutoML<T, TInput, TOutput>(Random);
-    }
-
     private Type? PickModelTypeByUcb()
     {
         lock (_lock)
diff --git a/src/AutoML/DiffusionAutoML.cs b/src/AutoML/DiffusionAutoML.cs
index 291954e7da..55b9cd0a18 100644
--- a/src/AutoML/DiffusionAutoML.cs
+++ b/src/AutoML/DiffusionAutoML.cs
@@ -441,14 +441,6 @@ protected override Dictionary<string, ParameterRange> GetDefaultSearchSpace(Type
             return GetDefaultDiffusionSearchSpace();
         }
 
-        /// <summary>
-        /// Creates an instance for deep copy.
-        /// </summary>
-        protected override AutoMLModelBase<T, Tensor<T>, Tensor<T>> CreateInstanceForCopy()
-        {
-            return new DiffusionAutoML<T>(_seed);
-        }
-
         private Dictionary<string, ParameterRange> GetDefaultDiffusionSearchSpace()
         {
             return new Dictionary<string, ParameterRange>
@@ -938,28 +930,6 @@ public override IFullModel<T, Tensor<T>, Tensor<T>> WithParameters(Vector<T> par
             return copy;
         }
 
-        public override IFullModel<T, Tensor<T>, Tensor<T>> Clone()
-        {
-            return new DiffusionAutoMLModel<T>(
-                _noisePredictor,
-                _vae,
-                _scheduler,
-                _conditioner,
-                _config,
-                _seed);
-        }
-
-        public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy()
-        {
-            return new DiffusionAutoMLModel<T>(
-                (UNetNoisePredictor<T>)_noisePredictor.DeepCopy(),
-                (StandardVAE<T>)_vae.DeepCopy(),
-                _scheduler,
-                _conditioner,
-                _config,
-                _seed);
-        }
-
         /// <summary>
         /// Returns empty because diffusion models operate on latent space noise, not
         /// named tabular features, so per-feature importance is not meaningful.
@@ -1030,62 +1000,6 @@ public override void LoadModel(string filePath)
             }
         }
 
-        public override byte[] Serialize()
-        {
-            Helpers.ModelPersistenceGuard.EnforceBeforeSerialize();
-            // Serialize parameters as doubles for portability across numeric types.
-            // This allows models trained with float to be loaded as double and vice versa.
-            // The format is: [version byte] [parameter count (4 bytes)] [parameters as doubles]
-            var parameters = GetParameters();
-            int headerSize = 1 + sizeof(int); // version + count
-            var data = new byte[headerSize + parameters.Length * sizeof(double)];
-
-            // Version byte (for future format changes)
-            data[0] = 1;
-
-            // Parameter count
-            Buffer.BlockCopy(BitConverter.GetBytes(parameters.Length), 0, data, 1, sizeof(int));
-
-            // Parameters as doubles
-            for (int i = 0; i < parameters.Length; i++)
-            {
-                double value = NumOps.ToDouble(parameters[i]);
-                var bytes = BitConverter.GetBytes(value);
-                Buffer.BlockCopy(bytes, 0, data, headerSize + i * sizeof(double), sizeof(double));
-            }
-
-            return data;
-        }
-
-        public override void Deserialize(byte[] data)
-        {
-            Helpers.ModelPersistenceGuard.EnforceBeforeDeserialize();
-
-            // Check minimum header size
-            int headerSize = 1 + sizeof(int);
-            if (data.Length < headerSize)
-                throw new InvalidDataException("Invalid serialized data: too short for header.");
-
-            // Read version (currently only version 1 supported)
-            byte version = data[0];
-            if (version != 1)
-                throw new InvalidDataException($"Unsupported serialization version: {version}");
-
-            // Read parameter count
-            int paramCount = BitConverter.ToInt32(data, 1);
-            if (data.Length < headerSize + paramCount * sizeof(double))
-                throw new InvalidDataException("Invalid serialized data: truncated parameter data.");
-
-            var parameters = new T[paramCount];
-            for (int i = 0; i < paramCount; i++)
-            {
-                double value = BitConverter.ToDouble(data, headerSize + i * sizeof(double));
-                parameters[i] = NumOps.FromDouble(value);
-            }
-
-            SetParameters(new Vector<T>(parameters));
-        }
-
         public override void SaveState(Stream stream)
         {
             if (stream is null)
diff --git a/src/AutoML/EvolutionaryAutoML.cs b/src/AutoML/EvolutionaryAutoML.cs
index 938848c2e2..e95d128354 100644
--- a/src/AutoML/EvolutionaryAutoML.cs
+++ b/src/AutoML/EvolutionaryAutoML.cs
@@ -154,11 +154,6 @@ public override Task<Dictionary<string, object>> SuggestNextTrialAsync()
         return Task.FromResult(sampled);
     }
 
-    protected override AutoMLModelBase<T, TInput, TOutput> CreateInstanceForCopy()
-    {
-        return new EvolutionaryAutoML<T, TInput, TOutput>(Random);
-    }
-
     private double ToReward(double score) => _maximize ? score : -score;
 
     private Dictionary<string, object> ProposeByEvolution(
diff --git a/src/AutoML/MultiFidelityAutoML.cs b/src/AutoML/MultiFidelityAutoML.cs
index ac9261c3f4..c070c52896 100644
--- a/src/AutoML/MultiFidelityAutoML.cs
+++ b/src/AutoML/MultiFidelityAutoML.cs
@@ -401,11 +401,6 @@ public override Task<Dictionary<string, object>> SuggestNextTrialAsync()
         return Task.FromResult(sampled);
     }
 
-    protected override AutoMLModelBase<T, TInput, TOutput> CreateInstanceForCopy()
-    {
-        return new MultiFidelityAutoML<T, TInput, TOutput>(Random, _options);
-    }
-
     private static double[] ResolveFidelityFractions(AutoMLMultiFidelityOptions options)
     {
         if (options is null)
diff --git a/src/AutoML/NAS/AttentiveNAS.cs b/src/AutoML/NAS/AttentiveNAS.cs
index a9575d6777..29ceb75866 100644
--- a/src/AutoML/NAS/AttentiveNAS.cs
+++ b/src/AutoML/NAS/AttentiveNAS.cs
@@ -39,7 +39,7 @@ namespace AiDotNet.AutoML.NAS
     [ModelComplexity(ModelComplexity.VeryHigh)]
     [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
     [ResearchPaper("AttentiveNAS: Improving Neural Architecture Search via Attentive Sampling", "https://arxiv.org/abs/2011.09011")]
-    public class AttentiveNAS<T> : NasAutoMLModelBase<T>
+    public partial class AttentiveNAS<T> : NasAutoMLModelBase<T>
     {
         private readonly INumericOperations<T> _ops;
         private readonly SearchSpaceBase<T> _nasSearchSpace;
@@ -51,7 +51,9 @@ public class AttentiveNAS<T> : NasAutoMLModelBase<T>
         private readonly List<int> _elasticKernelSizes;
 
         // Attention module parameters
+        [AiDotNet.Attributes.TrainableParameter]
         private readonly Tensor<T> _attentionWeights;
+        [AiDotNet.Attributes.TrainableParameter]
         private readonly Matrix<T> _attentionGradients;
         private readonly int _attentionHiddenSize;
 
@@ -414,16 +416,6 @@ protected override Architecture<T> SearchArchitecture(
             var config = AttentiveSample(context);
             return ConfigToArchitecture(config);
         }
-
-        protected override AutoMLModelBase<T, Tensor<T>, Tensor<T>> CreateInstanceForCopy()
-        {
-            return new AttentiveNAS<T>(
-                _nasSearchSpace,
-                elasticDepths: new List<int>(_elasticDepths),
-                elasticWidthMultipliers: new List<double>(_elasticWidthMultipliers),
-                elasticKernelSizes: new List<int>(_elasticKernelSizes),
-                attentionHiddenSize: _attentionHiddenSize);
-        }
     }
 
 }
diff --git a/src/AutoML/NAS/BigNAS.cs b/src/AutoML/NAS/BigNAS.cs
index c4fc8849f6..531609e61b 100644
--- a/src/AutoML/NAS/BigNAS.cs
+++ b/src/AutoML/NAS/BigNAS.cs
@@ -376,19 +376,6 @@ protected override Architecture<T> SearchArchitecture(
                 cancellationToken: cancellationToken);
             return ConfigToArchitecture(config);
         }
-
-        protected override AutoMLModelBase<T, Tensor<T>, Tensor<T>> CreateInstanceForCopy()
-        {
-            return new BigNAS<T>(
-                _nasSearchSpace,
-                elasticDepths: new List<int>(_elasticDepths),
-                elasticWidthMultipliers: new List<double>(_elasticWidthMultipliers),
-                elasticKernelSizes: new List<int>(_elasticKernelSizes),
-                elasticExpansionRatios: new List<int>(_elasticExpansionRatios),
-                elasticResolutions: new List<int>(_elasticResolutions),
-                useSandwichSampling: _useSandwichSampling,
-                distillationWeight: _ops.ToDouble(_distillationWeight));
-        }
     }
 
 }
diff --git a/src/AutoML/NAS/ENAS.cs b/src/AutoML/NAS/ENAS.cs
index 224cab507e..1814714e9b 100644
--- a/src/AutoML/NAS/ENAS.cs
+++ b/src/AutoML/NAS/ENAS.cs
@@ -44,7 +44,7 @@ namespace AiDotNet.AutoML.NAS
     [ModelComplexity(ModelComplexity.High)]
     [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
     [ResearchPaper("Efficient Neural Architecture Search via Parameter Sharing", "https://arxiv.org/abs/1802.03268")]
-    public class ENAS<T> : NasAutoMLModelBase<T>
+    public partial class ENAS<T> : NasAutoMLModelBase<T>
     {
         private readonly INumericOperations<T> _ops;
         private readonly SearchSpaceBase<T> _nasSearchSpace;
@@ -348,15 +348,5 @@ protected override Architecture<T> SearchArchitecture(
         {
             return SampleArchitecture().architecture;
         }
-
-        protected override AutoMLModelBase<T, Tensor<T>, Tensor<T>> CreateInstanceForCopy()
-        {
-            return new ENAS<T>(
-                _nasSearchSpace,
-                _numNodes,
-                _controllerHiddenSize,
-                baselineDecay: _ops.ToDouble(_baselineDecay),
-                entropyWeight: _ops.ToDouble(_entropyWeight));
-        }
     }
 }
diff --git a/src/AutoML/NAS/FBNet.cs b/src/AutoML/NAS/FBNet.cs
index 71aa4f3f32..35af8f3ff1 100644
--- a/src/AutoML/NAS/FBNet.cs
+++ b/src/AutoML/NAS/FBNet.cs
@@ -41,7 +41,7 @@ namespace AiDotNet.AutoML.NAS
     [ModelComplexity(ModelComplexity.High)]
     [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
     [ResearchPaper("FBNet: Hardware-Aware Efficient ConvNet Design via Differentiable NAS", "https://arxiv.org/abs/1812.03443")]
-    public class FBNet<T> : NasAutoMLModelBase<T>
+    public partial class FBNet<T> : NasAutoMLModelBase<T>
     {
         private readonly INumericOperations<T> _ops;
         private readonly SearchSpaceBase<T> _nasSearchSpace;
@@ -265,17 +265,5 @@ protected override Architecture<T> SearchArchitecture(
         {
             return DeriveArchitecture();
         }
-
-        protected override AutoMLModelBase<T, Tensor<T>, Tensor<T>> CreateInstanceForCopy()
-        {
-            return new FBNet<T>(
-                _nasSearchSpace,
-                _numLayers,
-                targetPlatform: _targetPlatform,
-                latencyWeight: _ops.ToDouble(_latencyWeight),
-                initialTemperature: _initialTemperature,
-                inputChannels: _inputChannels,
-                spatialSize: _spatialSize);
-        }
     }
 }
diff --git a/src/AutoML/NAS/GDAS.cs b/src/AutoML/NAS/GDAS.cs
index feec446b0e..751422c8a8 100644
--- a/src/AutoML/NAS/GDAS.cs
+++ b/src/AutoML/NAS/GDAS.cs
@@ -41,7 +41,7 @@ namespace AiDotNet.AutoML.NAS
     [ModelComplexity(ModelComplexity.High)]
     [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
     [ResearchPaper("Searching for A Robust Neural Architecture in Four GPU Hours", "https://arxiv.org/abs/1910.04465")]
-    public class GDAS<T> : NasAutoMLModelBase<T>
+    public partial class GDAS<T> : NasAutoMLModelBase<T>
     {
         private readonly INumericOperations<T> _ops;
         private readonly SearchSpaceBase<T> _nasSearchSpace;
@@ -177,14 +177,5 @@ protected override Architecture<T> SearchArchitecture(
         {
             return DeriveArchitecture();
         }
-
-        protected override AutoMLModelBase<T, Tensor<T>, Tensor<T>> CreateInstanceForCopy()
-        {
-            return new GDAS<T>(
-                _nasSearchSpace,
-                _numNodes,
-                initialTemperature: _ops.ToDouble(_initialTemperature),
-                finalTemperature: _ops.ToDouble(_finalTemperature));
-        }
     }
 }
diff --git a/src/AutoML/NAS/OnceForAll.cs b/src/AutoML/NAS/OnceForAll.cs
index 793b9b23a6..4339b0ae53 100644
--- a/src/AutoML/NAS/OnceForAll.cs
+++ b/src/AutoML/NAS/OnceForAll.cs
@@ -40,7 +40,7 @@ namespace AiDotNet.AutoML.NAS
     [ModelComplexity(ModelComplexity.VeryHigh)]
     [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
     [ResearchPaper("Once-for-All: Train One Network and Specialize it for Efficient Deployment", "https://arxiv.org/abs/1908.09791")]
-    public class OnceForAll<T> : NasAutoMLModelBase<T>
+    public partial class OnceForAll<T> : NasAutoMLModelBase<T>
     {
         private readonly INumericOperations<T> _ops;
         private readonly SearchSpaceBase<T> _nasSearchSpace;
@@ -431,16 +431,6 @@ private T EvaluateSubNetworkOnValidation(SubNetworkConfig config,
 
             return _ops.FromDouble(Math.Max(0, Math.Min(1.0, normalizedCapacity)));
         }
-
-        protected override AutoMLModelBase<T, Tensor<T>, Tensor<T>> CreateInstanceForCopy()
-        {
-            return new OnceForAll<T>(
-                _nasSearchSpace,
-                elasticDepths: new List<int>(_elasticDepths),
-                elasticWidths: new List<double>(_elasticWidths),
-                elasticKernelSizes: new List<int>(_elasticKernelSizes),
-                elasticExpansionRatios: new List<int>(_elasticExpansionRatios));
-        }
     }
 
 }
diff --git a/src/AutoML/NAS/PCDARTS.cs b/src/AutoML/NAS/PCDARTS.cs
index 8d02859c2b..f1d1bd4f90 100644
--- a/src/AutoML/NAS/PCDARTS.cs
+++ b/src/AutoML/NAS/PCDARTS.cs
@@ -234,14 +234,5 @@ protected override Architecture<T> SearchArchitecture(
         {
             return DeriveArchitecture();
         }
-
-        protected override AutoMLModelBase<T, Tensor<T>, Tensor<T>> CreateInstanceForCopy()
-        {
-            return new PCDARTS<T>(
-                _nasSearchSpace,
-                _numNodes,
-                channelSamplingRatio: _channelSamplingRatio,
-                useEdgeNormalization: _useEdgeNormalization);
-        }
     }
 }
diff --git a/src/AutoML/NAS/ProxylessNAS.cs b/src/AutoML/NAS/ProxylessNAS.cs
index 0094d2d439..ebae5b7f1b 100644
--- a/src/AutoML/NAS/ProxylessNAS.cs
+++ b/src/AutoML/NAS/ProxylessNAS.cs
@@ -42,7 +42,7 @@ namespace AiDotNet.AutoML.NAS
     [ModelComplexity(ModelComplexity.High)]
     [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
     [ResearchPaper("ProxylessNAS: Direct Neural Architecture Search on Target Task and Hardware", "https://arxiv.org/abs/1812.00332")]
-    public class ProxylessNAS<T> : NasAutoMLModelBase<T>
+    public partial class ProxylessNAS<T> : NasAutoMLModelBase<T>
     {
         private readonly INumericOperations<T> _ops;
         private readonly SearchSpaceBase<T> _nasSearchSpace;
@@ -284,15 +284,5 @@ protected override Architecture<T> SearchArchitecture(
         {
             return DeriveArchitecture();
         }
-
-        protected override AutoMLModelBase<T, Tensor<T>, Tensor<T>> CreateInstanceForCopy()
-        {
-            return new ProxylessNAS<T>(
-                _nasSearchSpace,
-                _numNodes,
-                targetPlatform: _targetPlatform,
-                latencyWeight: _ops.ToDouble(_latencyWeight),
-                useBinarization: _useBinarization);
-        }
     }
 }
diff --git a/src/AutoML/RandomSearchAutoML.cs b/src/AutoML/RandomSearchAutoML.cs
index f5f5160d1e..fe1cd1814e 100644
--- a/src/AutoML/RandomSearchAutoML.cs
+++ b/src/AutoML/RandomSearchAutoML.cs
@@ -144,9 +144,4 @@ public override Task<Dictionary<string, object>> SuggestNextTrialAsync()
         sampled[ModelTypeKey] = modelType;
         return Task.FromResult(sampled);
     }
-
-    protected override AutoMLModelBase<T, TInput, TOutput> CreateInstanceForCopy()
-    {
-        return new RandomSearchAutoML<T, TInput, TOutput>(Random);
-    }
 }
diff --git a/src/AutoML/SupervisedAutoMLModelBase.cs b/src/AutoML/SupervisedAutoMLModelBase.cs
index 9dfd64b851..00aebc2b33 100644
--- a/src/AutoML/SupervisedAutoMLModelBase.cs
+++ b/src/AutoML/SupervisedAutoMLModelBase.cs
@@ -34,7 +34,7 @@ namespace AiDotNet.AutoML;
 /// Concrete strategies (random search, Bayesian optimization, etc.) decide how to pick the next trial.
 /// </para>
 /// </remarks>
-public abstract class SupervisedAutoMLModelBase<T, TInput, TOutput> : AutoMLModelBase<T, TInput, TOutput>
+public abstract partial class SupervisedAutoMLModelBase<T, TInput, TOutput> : AutoMLModelBase<T, TInput, TOutput>
 {
     private readonly Random _random;
 
diff --git a/src/Autodiff/AutogradFunction.cs b/src/Autodiff/AutogradFunction.cs
index 2766d23e5a..2a09b9914c 100644
--- a/src/Autodiff/AutogradFunction.cs
+++ b/src/Autodiff/AutogradFunction.cs
@@ -77,13 +77,26 @@ public Tensor<T> Apply(params Tensor<T>[] inputs)
                     var inputGrads = Backward(ctx, gradOutput);
                     for (int i = 0; i < inputTensors.Length && i < inputGrads.Length; i++)
                     {
-                        if (inputGrads[i] is not null)
+                        if (inputGrads[i] is null) continue;
+
+                        // An IDENTITY function returns one of its own inputs, and the gradient map is
+                        // keyed by tensor identity, so output and input are the SAME key. Accumulating
+                        // there adds the gradient to itself: the tensor-parallel copy region made the
+                        // analytical input VJP exactly 2x the finite-difference one. The input's
+                        // gradient IS what Backward returned -- already carrying whatever that
+                        // function does to it, such as an all-reduce -- so it replaces rather than
+                        // adds. Returning a fresh tensor instead would break the alias the caller
+                        // relies on and disconnect the input from the graph entirely.
+                        if (ReferenceEquals(inputTensors[i], output))
                         {
-                            if (grads.TryGetValue(inputTensors[i], out var existing))
-                                eng.TensorAddInPlace(existing, inputGrads[i]);
-                            else
-                                grads[inputTensors[i]] = inputGrads[i];
+                            grads[inputTensors[i]] = inputGrads[i];
+                            continue;
                         }
+
+                        if (grads.TryGetValue(inputTensors[i], out var existing))
+                            eng.TensorAddInPlace(existing, inputGrads[i]);
+                        else
+                            grads[inputTensors[i]] = inputGrads[i];
                     }
                 },
                 InputCount = 0xFF,
diff --git a/src/CausalDiscovery/DeepLearning/DeepCausalBase.cs b/src/CausalDiscovery/DeepLearning/DeepCausalBase.cs
index 064cd1b2a4..c2823883a6 100644
--- a/src/CausalDiscovery/DeepLearning/DeepCausalBase.cs
+++ b/src/CausalDiscovery/DeepLearning/DeepCausalBase.cs
@@ -162,6 +162,72 @@ protected void ApplyDeepOptions(Models.Options.CausalDiscoveryOptions? options)
         return result;
     }
 
+    /// <summary>
+    /// Projects an already weighted directed graph onto a DAG by retaining the strongest edges
+    /// whose insertion does not close a directed cycle.
+    /// </summary>
+    /// <remarks>
+    /// Pairwise direction learners can orient every pair consistently in isolation while the
+    /// combined orientations still form a longer cycle. Sorting by absolute learned strength and
+    /// rejecting only cycle-closing edges preserves the strongest evidence and supplies the DAG
+    /// guarantee advertised by the common causal-graph contract.
+    /// </remarks>
+    protected Matrix<T> ProjectWeightedGraphToDag(Matrix<T> weights)
+    {
+        int d = weights.Rows;
+        var candidates = new List<(int From, int To, T Weight, double Strength)>();
+        for (int from = 0; from < d; from++)
+        {
+            for (int to = 0; to < d; to++)
+            {
+                if (from == to) continue;
+                T weight = weights[from, to];
+                double strength = Math.Abs(NumOps.ToDouble(weight));
+                if (strength > 0.0 && !double.IsNaN(strength) && !double.IsInfinity(strength))
+                    candidates.Add((from, to, weight, strength));
+            }
+        }
+
+        candidates.Sort((left, right) =>
+        {
+            int byStrength = right.Strength.CompareTo(left.Strength);
+            if (byStrength != 0) return byStrength;
+            int byFrom = left.From.CompareTo(right.From);
+            return byFrom != 0 ? byFrom : left.To.CompareTo(right.To);
+        });
+
+        var result = new Matrix<T>(d, d);
+        var adjacency = new List<int>[d];
+        for (int i = 0; i < d; i++) adjacency[i] = new List<int>();
+
+        bool CanReach(int start, int target)
+        {
+            var seen = new bool[d];
+            var pending = new Stack<int>();
+            pending.Push(start);
+            while (pending.Count > 0)
+            {
+                int node = pending.Pop();
+                if (node == target) return true;
+                if (seen[node]) continue;
+                seen[node] = true;
+                for (int i = 0; i < adjacency[node].Count; i++)
+                    pending.Push(adjacency[node][i]);
+            }
+            return false;
+        }
+
+        foreach (var candidate in candidates)
+        {
+            // Adding from->to closes a cycle exactly when to already reaches from.
+            if (CanReach(candidate.To, candidate.From)) continue;
+            result[candidate.From, candidate.To] = candidate.Weight;
+            adjacency[candidate.From].Add(candidate.To);
+        }
+
+        return result;
+    }
+
     /// <summary>
     /// Builds the final weighted adjacency matrix from learned edge probabilities and covariance.
     /// Uses learned P for directionality when training converged, falls back to asymmetric
diff --git a/src/CausalInference/CausalForest.cs b/src/CausalInference/CausalForest.cs
index 246bad8e80..4927e2dd98 100644
--- a/src/CausalInference/CausalForest.cs
+++ b/src/CausalInference/CausalForest.cs
@@ -60,7 +60,7 @@ namespace AiDotNet.CausalInference;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
 [ResearchPaper("Estimation and Inference of Heterogeneous Treatment Effects using Random Forests", "https://doi.org/10.1080/01621459.2017.1319839", Year = 2018, Authors = "Stefan Wager, Susan Athey")]
-public class CausalForest<T> : CausalModelBase<T>
+public partial class CausalForest<T> : CausalModelBase<T>
 {
 
     /// <inheritdoc />
@@ -118,21 +118,25 @@ protected override void RegisterComponents()
     /// <summary>
     /// Propensity score coefficients for overlap adjustment.
     /// </summary>
+    [AiDotNet.Attributes.FittedParameter]
     private Vector<T>? _propensityCoefficients;
 
     /// <summary>
     /// Cached treatment vector from fitting.
     /// </summary>
+    [Scratch]
     private Vector<int>? _cachedTreatment;
 
     /// <summary>
     /// Cached outcome vector from fitting.
     /// </summary>
+    [Scratch]
     private Vector<T>? _cachedOutcome;
 
     /// <summary>
     /// Cached feature matrix from fitting.
     /// </summary>
+    [Scratch]
     private Matrix<T>? _cachedFeatures;
 
     /// <summary>
@@ -902,39 +906,6 @@ public override IFullModel<T, Matrix<T>, Vector<T>> WithParameters(Vector<T> par
         return newModel;
     }
 
-    /// <summary>
-    /// Creates a new instance of the same type.
-    /// </summary>
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        return new CausalForest<T>(_numTrees, _maxDepth, _minSamplesLeaf, _maxFeatures, _honest, _honestFraction);
-    }
-
-    /// <inheritdoc/>
-    /// <remarks>
-    /// A fitted causal forest's predictive state is its tree ensemble, not
-    /// merely the propensity-coefficient vector returned by
-    /// <see cref="GetParameters"/>. Copy that state explicitly so a clone
-    /// cannot be marked fitted while containing no trees.
-    /// </remarks>
-    public override IFullModel<T, Matrix<T>, Vector<T>> DeepCopy()
-    {
-        var copy = new CausalForest<T>(
-            _numTrees, _maxDepth, _minSamplesLeaf, _maxFeatures, _honest, _honestFraction)
-        {
-            NumFeatures = NumFeatures,
-            IsFitted = IsFitted,
-            FeatureNames = FeatureNames is null ? null : (string[])FeatureNames.Clone(),
-            _propensityCoefficients = CopyVector(_propensityCoefficients),
-            _cachedTreatment = CopyVector(_cachedTreatment),
-            _cachedOutcome = CopyVector(_cachedOutcome),
-            _cachedFeatures = CopyMatrix(_cachedFeatures),
-            _trees = _trees?.Select(CloneTree).ToList()
-        };
-
-        return copy;
-    }
-
     private static CausalTree CloneTree(CausalTree source) =>
         new()
         {
diff --git a/src/CausalInference/CausalModelBase.cs b/src/CausalInference/CausalModelBase.cs
index d40e916156..eb7d72876d 100644
--- a/src/CausalInference/CausalModelBase.cs
+++ b/src/CausalInference/CausalModelBase.cs
@@ -31,8 +31,51 @@ namespace AiDotNet.CausalInference;
 /// - Managing fitted model state
 /// </para>
 /// </remarks>
-public abstract class CausalModelBase<T> : ICausalModel<T>, IModelShape, IParameterManifestProvider
+public abstract partial class CausalModelBase<T> : ICausalModel<T>, IModelShape, IParameterManifestProvider
 {
+    // --- declared state (ModelStateRegistry) ---
+    // Identical in every model base because these bases are siblings over the same interfaces rather
+    // than one hierarchy; the logic itself lives once in ModelStateRegistry/ModelStateEnvelope.
+
+    /// <summary>State that is not a parameter vector, declared once and persisted by this base.</summary>
+    private readonly AiDotNet.Models.ModelStateRegistry<T> _declaredState = new();
+    private bool _declaredStateRegistered;
+
+    /// <summary>
+    /// Declare state here that the parameter vector does not carry -- a retained training set,
+    /// fitted knots, kernel centres, an ensemble's children. Both halves of the payload are driven
+    /// by the declaration, so they cannot drift.
+    /// </summary>
+    /// <param name="state">The registry to declare into.</param>
+    protected virtual void RegisterState(AiDotNet.Models.ModelStateRegistry<T> state)
+    {
+    }
+    /// <summary>Generated state declarations for fields declared across this model's hierarchy.</summary>
+    /// <param name="state">The registry to declare into.</param>
+    /// <remarks>
+    /// Emitted by ModelStateGenerator into the partial model, so a model author declares nothing. The
+    /// hand-written <c>RegisterState</c> beside it exists only for state the classifier genuinely
+    /// cannot place; anything it CAN place belongs here, where it cannot be forgotten.
+    /// </remarks>
+    protected virtual void RegisterGeneratedState(AiDotNet.Models.ModelStateRegistry<T> state)
+    {
+        RegisterGeneratedStateCore(state);
+    }
+
+    /// <summary>The declared state, registered once and lazily so it runs after the constructor.</summary>
+    protected AiDotNet.Models.ModelStateRegistry<T> DeclaredState
+    {
+        get
+        {
+            if (!_declaredStateRegistered)
+            {
+                _declaredStateRegistered = true;
+                RegisterGeneratedState(_declaredState);
+                RegisterState(_declaredState);
+            }
+            return _declaredState;
+        }
+    }
     /// <summary>
     /// Gets the hardware-accelerated computation engine for vectorized operations.
     /// </summary>
@@ -436,7 +479,7 @@ public virtual byte[] Serialize()
     {
         ThrowIfDisposed();
         ModelPersistenceGuard.EnforceBeforeSerialize();
-        return SerializeInternalUnchecked();
+        return AiDotNet.Models.ModelStateEnvelope.Append(DeclaredState, SerializeInternalUnchecked());
     }
 
     /// <summary>
@@ -470,6 +513,9 @@ private byte[] SerializeInternalUnchecked()
     /// </summary>
     public virtual void Deserialize(byte[] modelData)
     {
+        // Strips and applies any declared-state trailer, so the body below reads the payload
+        // exactly as it did before this existed.
+        modelData = AiDotNet.Models.ModelStateEnvelope.Extract(DeclaredState, modelData);
         ThrowIfDisposed();
         ModelPersistenceGuard.EnforceBeforeDeserialize();
         DeserializeInternalUnchecked(modelData);
@@ -607,7 +653,18 @@ protected Matrix<T> ExtractCovariates(Matrix<T> input)
     /// <summary>
     /// Creates a new instance of the same type.
     /// </summary>
-    protected abstract IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance();
+    /// <remarks>
+    /// <para>
+    /// No longer abstract. Every concrete model used to be forced to write this, and 1147 of them
+    /// did -- each one a hand-copied list of constructor arguments that a new option could fall out
+    /// of without anything failing. The clone plan records that constructor at compile time instead,
+    /// so the base can rebuild the type and a model only overrides this when the generator says it
+    /// cannot: a constructor parameter with nothing holding its value, which the build reports by
+    /// name rather than leaving to be discovered by a clone that comes back subtly different.
+    /// </para>
+    /// </remarks>
+    protected virtual IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
+        => (IFullModel<T, Matrix<T>, Vector<T>>)AiDotNet.Models.CloneEngine.CopyConfiguration(this);
 
     /// <summary>
     /// Gets the indices of features that are actively used in the model.
@@ -669,11 +726,18 @@ public virtual IFullModel<T, Matrix<T>, Vector<T>> DeepCopy()
         // clone path (closes the subclass-override bypass surface).
         using (ModelPersistenceGuard.InternalOperation())
         {
-            byte[] serialized = SerializeInternalUnchecked();
+            byte[] serialized = AiDotNet.Models.ModelStateEnvelope.Append(
+                DeclaredState, SerializeInternalUnchecked());
             var copy = CreateNewInstance();
             if (copy is CausalModelBase<T> copyBase)
             {
-                copyBase.DeserializeInternalUnchecked(serialized);
+                byte[] inner = AiDotNet.Models.ModelStateEnvelope.Extract(
+                    copyBase.DeclaredState, serialized);
+                copyBase.DeserializeInternalUnchecked(inner);
+                if (IsFitted)
+                {
+                    copyBase.SetParameters(GetParameters());
+                }
             }
             else
             {
diff --git a/src/CausalInference/DoublyRobustEstimator.cs b/src/CausalInference/DoublyRobustEstimator.cs
index 8a4dd407b3..db4d8c722e 100644
--- a/src/CausalInference/DoublyRobustEstimator.cs
+++ b/src/CausalInference/DoublyRobustEstimator.cs
@@ -68,11 +68,12 @@ namespace AiDotNet.CausalInference;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
     [ResearchPaper("Doubly Robust Estimation in Missing Data and Causal Inference Models", "https://doi.org/10.1111/j.0006-341X.2005.031007.x")]
-public class DoublyRobustEstimator<T> : CausalModelBase<T>
+public partial class DoublyRobustEstimator<T> : CausalModelBase<T>
 {
     /// <summary>
     /// Stores the logistic regression coefficients for propensity score estimation.
     /// </summary>
+    [AiDotNet.Attributes.FittedParameter]
     private Vector<T>? _propensityCoefficients;
 
     /// <summary>
@@ -826,31 +827,5 @@ public override IFullModel<T, Matrix<T>, Vector<T>> WithParameters(Vector<T> par
         return newModel;
     }
 
-    /// <summary>
-    /// Creates a fitted copy, including the learned propensity and outcome coefficients.
-    /// CausalModelBase's metadata round-trip does not carry these estimator state vectors.
-    /// </summary>
-    public override IFullModel<T, Matrix<T>, Vector<T>> DeepCopy()
-    {
-        var copy = new DoublyRobustEstimator<T>(_trimMin, _trimMax, _useCrossFitting, _numFolds);
-        // Keep estimator state as independent vectors without forcing a generic
-        // parameter flatten/round-trip. (Unlike a neural model these vectors are
-        // small, but direct cloning is both clearer and preserves fitted state.)
-        copy._propensityCoefficients = _propensityCoefficients?.Clone();
-        copy._outcomeCoefficients1 = _outcomeCoefficients1?.Clone();
-        copy._outcomeCoefficients0 = _outcomeCoefficients0?.Clone();
-        copy.NumFeatures = NumFeatures;
-        copy.IsFitted = IsFitted;
-        return copy;
-    }
-
-    /// <summary>
-    /// Creates a new instance of this type.
-    /// </summary>
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        return new DoublyRobustEstimator<T>(_trimMin, _trimMax, _useCrossFitting, _numFolds);
-    }
-
     #endregion
 }
diff --git a/src/CausalInference/InverseProbabilityWeighting.cs b/src/CausalInference/InverseProbabilityWeighting.cs
index a49b8322ea..0a90c15351 100644
--- a/src/CausalInference/InverseProbabilityWeighting.cs
+++ b/src/CausalInference/InverseProbabilityWeighting.cs
@@ -4,8 +4,6 @@
 using AiDotNet.LinearAlgebra;
 using AiDotNet.Tensors.Helpers;
 
-using AiDotNet.Models.Parameters;
-
 namespace AiDotNet.CausalInference;
 
 /// <summary>
@@ -68,24 +66,13 @@ namespace AiDotNet.CausalInference;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
     [ResearchPaper("Marginal Structural Models and Causal Inference in Epidemiology", "https://doi.org/10.1097/00001648-200009000-00011")]
-public class InverseProbabilityWeighting<T> : CausalModelBase<T>
+public partial class InverseProbabilityWeighting<T> : CausalModelBase<T>
 {
 
-    /// <inheritdoc />
-    /// <remarks>The propensity-score coefficients, and the same off-by-one fix as CausalForest: the inherited count was NumFeatures, one less than the vector it was paired with.</remarks>
-    protected override void RegisterComponents()
-    {
-        RegisterParameterComponent(new VectorFieldParameterSource<T>(
-            () => _propensityCoefficients,
-            value =>
-            {
-                _propensityCoefficients = value;
-                NumFeatures = value.Length - 1;
-            }));
-    }
     /// <summary>
     /// Stores the logistic regression coefficients for propensity score estimation.
     /// </summary>
+    [AiDotNet.Attributes.FittedParameter]
     private Vector<T>? _propensityCoefficients;
 
     /// <summary>
@@ -106,16 +93,19 @@ protected override void RegisterComponents()
     /// <summary>
     /// Cached treatment vector from fitting.
     /// </summary>
+    [Scratch]
     private Vector<int>? _cachedTreatment;
 
     /// <summary>
     /// Cached outcome vector from fitting.
     /// </summary>
+    [Scratch]
     private Vector<T>? _cachedOutcome;
 
     /// <summary>
     /// Cached feature matrix from fitting.
     /// </summary>
+    [Scratch]
     private Matrix<T>? _cachedFeatures;
 
     /// <summary>
@@ -708,14 +698,6 @@ public override IFullModel<T, Matrix<T>, Vector<T>> WithParameters(Vector<T> par
         return newModel;
     }
 
-    /// <summary>
-    /// Creates a new instance of this type.
-    /// </summary>
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        return new InverseProbabilityWeighting<T>(_trimMin, _trimMax, _stabilizedWeights);
-    }
-
     /// <summary>
     /// Gets additional model data for serialization.
     /// </summary>
diff --git a/src/CausalInference/PropensityScoreMatching.cs b/src/CausalInference/PropensityScoreMatching.cs
index 3808706e2b..a2202d39bd 100644
--- a/src/CausalInference/PropensityScoreMatching.cs
+++ b/src/CausalInference/PropensityScoreMatching.cs
@@ -66,7 +66,7 @@ namespace AiDotNet.CausalInference;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
     [ResearchPaper("The Central Role of the Propensity Score in Observational Studies for Causal Effects", "https://doi.org/10.1093/biomet/70.1.41")]
-public class PropensityScoreMatching<T> : CausalModelBase<T>
+public partial class PropensityScoreMatching<T> : CausalModelBase<T>
 {
 
     /// <inheritdoc />
@@ -84,6 +84,7 @@ protected override void RegisterComponents()
     /// <summary>
     /// Stores the logistic regression coefficients for propensity score estimation.
     /// </summary>
+    [AiDotNet.Attributes.FittedParameter]
     private Vector<T>? _propensityCoefficients;
 
     /// <summary>
@@ -109,16 +110,19 @@ protected override void RegisterComponents()
     /// <summary>
     /// Cached treatment vector from fitting.
     /// </summary>
+    [Scratch]
     private Vector<int>? _cachedTreatment;
 
     /// <summary>
     /// Cached outcome vector from fitting.
     /// </summary>
+    [Scratch]
     private Vector<T>? _cachedOutcome;
 
     /// <summary>
     /// Cached feature matrix from fitting.
     /// </summary>
+    [Scratch]
     private Matrix<T>? _cachedFeatures;
 
     /// <summary>
@@ -717,14 +721,6 @@ public override IFullModel<T, Matrix<T>, Vector<T>> WithParameters(Vector<T> par
         return newModel;
     }
 
-    /// <summary>
-    /// Creates a new instance of this type.
-    /// </summary>
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        return new PropensityScoreMatching<T>(_caliper, _withReplacement, _matchRatio);
-    }
-
     /// <summary>
     /// Gets additional model data for serialization.
     /// </summary>
diff --git a/src/CausalInference/SLearner.cs b/src/CausalInference/SLearner.cs
index b36516d348..362cd21b3e 100644
--- a/src/CausalInference/SLearner.cs
+++ b/src/CausalInference/SLearner.cs
@@ -363,12 +363,6 @@ public override IFullModel<T, Matrix<T>, Vector<T>> WithParameters(Vector<T> par
         return copy;
     }
 
-    /// <inheritdoc />
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        return new SLearner<T>(MaxIterations, LearningRate, Lambda);
-    }
-
     /// <inheritdoc />
     /// <remarks>
     /// SLearner's trainable state is the bias scalar and the weight vector
diff --git a/src/CausalInference/TLearner.cs b/src/CausalInference/TLearner.cs
index b676a3d724..53f4e36680 100644
--- a/src/CausalInference/TLearner.cs
+++ b/src/CausalInference/TLearner.cs
@@ -57,7 +57,7 @@ namespace AiDotNet.CausalInference;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
     [ResearchPaper("Metalearners for Estimating Heterogeneous Treatment Effects Using Machine Learning", "https://doi.org/10.1073/pnas.1804597116")]
-public class TLearner<T> : CausalModelBase<T>
+public partial class TLearner<T> : CausalModelBase<T>
 {
     /// <summary>
     /// Weights for the treatment model.
@@ -399,12 +399,6 @@ public override IFullModel<T, Matrix<T>, Vector<T>> WithParameters(Vector<T> par
         return copy;
     }
 
-    /// <inheritdoc />
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        return new TLearner<T>(MaxIterations, LearningRate, Lambda);
-    }
-
     /// <summary>
     /// Persists the two fitted linear sub-models (treated + control weights and biases) so
     /// <see cref="CausalModelBase{T}.DeepCopy"/> / <c>Clone</c> and Serialize/Deserialize reconstruct
diff --git a/src/CausalInference/XLearner.cs b/src/CausalInference/XLearner.cs
index 3e2e7cc281..e722848d78 100644
--- a/src/CausalInference/XLearner.cs
+++ b/src/CausalInference/XLearner.cs
@@ -522,12 +522,6 @@ public override IFullModel<T, Matrix<T>, Vector<T>> WithParameters(Vector<T> par
         return copy;
     }
 
-    /// <inheritdoc />
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        return new XLearner<T>(MaxIterations, LearningRate, Lambda);
-    }
-
     /// <inheritdoc />
     protected override Dictionary<string, object> GetAdditionalModelData()
     {
diff --git a/src/Classification/Boosting/DARTClassifier.cs b/src/Classification/Boosting/DARTClassifier.cs
index adeef60159..5756bcc6ef 100644
--- a/src/Classification/Boosting/DARTClassifier.cs
+++ b/src/Classification/Boosting/DARTClassifier.cs
@@ -485,68 +485,4 @@ public override ModelMetadata<T> GetModelMetadata()
             }
         };
     }
-
-    /// <inheritdoc/>
-    public override byte[] Serialize()
-    {
-        using var ms = new MemoryStream();
-        using var writer = new BinaryWriter(ms);
-
-        byte[] baseData = base.Serialize();
-        writer.Write(baseData.Length);
-        writer.Write(baseData);
-
-        writer.Write(NumOps.ToDouble(_initPrediction));
-        writer.Write(_options.NumberOfIterations);
-        writer.Write(_options.LearningRate);
-        writer.Write(_options.DropoutRate);
-        writer.Write((int)_options.DropoutType);
-
-        writer.Write(_trees.Count);
-        for (int t = 0; t < _trees.Count; t++)
-        {
-            writer.Write(NumOps.ToDouble(_treeWeights[t]));
-            byte[] treeData = _trees[t].Serialize();
-            writer.Write(treeData.Length);
-            writer.Write(treeData);
-        }
-
-        return ms.ToArray();
-    }
-
-    /// <inheritdoc/>
-    public override void Deserialize(byte[] modelData)
-    {
-        using var ms = new MemoryStream(modelData);
-        using var reader = new BinaryReader(ms);
-
-        int baseLen = reader.ReadInt32();
-        byte[] baseData = reader.ReadBytes(baseLen);
-        base.Deserialize(baseData);
-
-        _initPrediction = NumOps.FromDouble(reader.ReadDouble());
-        _options.NumberOfIterations = reader.ReadInt32();
-        _options.LearningRate = reader.ReadDouble();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.DropoutType = (DARTDropoutType)reader.ReadInt32();
-
-        int numTrees = reader.ReadInt32();
-        _trees.Clear();
-        _treeWeights.Clear();
-        for (int t = 0; t < numTrees; t++)
-        {
-            _treeWeights.Add(NumOps.FromDouble(reader.ReadDouble()));
-            int treeLen = reader.ReadInt32();
-            byte[] treeData = reader.ReadBytes(treeLen);
-            var tree = new DecisionTreeRegression<T>(new DecisionTreeOptions());
-            tree.Deserialize(treeData);
-            _trees.Add(tree);
-        }
-    }
-
-    /// <inheritdoc/>
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        return new DARTClassifier<T>(_options, Regularization);
-    }
 }
diff --git a/src/Classification/Boosting/ExplainableBoostingClassifier.cs b/src/Classification/Boosting/ExplainableBoostingClassifier.cs
index 297b8f5c1a..7579a24414 100644
--- a/src/Classification/Boosting/ExplainableBoostingClassifier.cs
+++ b/src/Classification/Boosting/ExplainableBoostingClassifier.cs
@@ -828,163 +828,4 @@ public override ModelMetadata<T> GetModelMetadata()
             }
         };
     }
-
-    /// <inheritdoc/>
-    public override byte[] Serialize()
-    {
-        using var ms = new MemoryStream();
-        using var writer = new BinaryWriter(ms);
-
-        byte[] baseData = base.Serialize();
-        writer.Write(baseData.Length);
-        writer.Write(baseData);
-
-        writer.Write(_numFeatures);
-        writer.Write(NumOps.ToDouble(_intercept));
-
-        // Shape functions
-        for (int f = 0; f < _numFeatures; f++)
-        {
-            writer.Write(_shapeFunctions[f].Length);
-            foreach (var val in _shapeFunctions[f])
-            {
-                writer.Write(NumOps.ToDouble(val));
-            }
-        }
-
-        // Bin edges
-        for (int f = 0; f < _numFeatures; f++)
-        {
-            writer.Write(_binEdges[f].Length);
-            foreach (var edge in _binEdges[f])
-            {
-                writer.Write(NumOps.ToDouble(edge));
-            }
-        }
-
-        // Interaction terms
-        writer.Write(_interactionTerms.Count);
-        foreach (var kvp in _interactionTerms)
-        {
-            writer.Write(kvp.Key.Item1);
-            writer.Write(kvp.Key.Item2);
-            writer.Write(kvp.Value.Rows);
-            writer.Write(kvp.Value.Columns);
-            for (int i = 0; i < kvp.Value.Rows; i++)
-            {
-                for (int j = 0; j < kvp.Value.Columns; j++)
-                {
-                    writer.Write(NumOps.ToDouble(kvp.Value[i, j]));
-                }
-            }
-        }
-
-        return ms.ToArray();
-    }
-
-    /// <inheritdoc/>
-    public override void Deserialize(byte[] modelData)
-    {
-        using var ms = new MemoryStream(modelData);
-        using var reader = new BinaryReader(ms);
-
-        int baseLen = reader.ReadInt32();
-        long remaining = ms.Length - ms.Position;
-        if (baseLen < 0 || baseLen > remaining)
-            throw new InvalidOperationException(
-                $"Deserialized base payload length ({baseLen}) exceeds remaining data ({remaining} bytes). Data may be corrupted.");
-        byte[] baseData = reader.ReadBytes(baseLen);
-        base.Deserialize(baseData);
-
-        const int MaxFeatures = 100_000;
-        const int MaxArrayLength = 10_000_000;
-        const int MaxInteractions = 1_000_000;
-
-        _numFeatures = reader.ReadInt32();
-        if (_numFeatures < 0 || _numFeatures > MaxFeatures)
-        {
-            throw new InvalidOperationException(
-                $"Deserialized _numFeatures ({_numFeatures}) is out of valid range [0, {MaxFeatures}]. Data may be corrupted.");
-        }
-
-        _intercept = NumOps.FromDouble(reader.ReadDouble());
-
-        // Shape functions
-        _shapeFunctions = new List<Vector<T>>(_numFeatures);
-        for (int f = 0; f < _numFeatures; f++)
-        {
-            int len = reader.ReadInt32();
-            if (len < 0 || len > MaxArrayLength)
-            {
-                throw new InvalidOperationException(
-                    $"Deserialized shape function length ({len}) for feature {f} is out of valid range. Data may be corrupted.");
-            }
-            var sf = new Vector<T>(len);
-            for (int b = 0; b < len; b++)
-            {
-                sf[b] = NumOps.FromDouble(reader.ReadDouble());
-            }
-            _shapeFunctions.Add(sf);
-        }
-
-        // Bin edges
-        _binEdges = new List<Vector<T>>(_numFeatures);
-        for (int f = 0; f < _numFeatures; f++)
-        {
-            int len = reader.ReadInt32();
-            if (len < 0 || len > MaxArrayLength)
-            {
-                throw new InvalidOperationException(
-                    $"Deserialized bin edges length ({len}) for feature {f} is out of valid range. Data may be corrupted.");
-            }
-            var edges = new Vector<T>(len);
-            for (int e = 0; e < len; e++)
-            {
-                edges[e] = NumOps.FromDouble(reader.ReadDouble());
-            }
-            _binEdges.Add(edges);
-        }
-
-        // Interaction terms
-        int numInteractions = reader.ReadInt32();
-        if (numInteractions < 0 || numInteractions > MaxInteractions)
-        {
-            throw new InvalidOperationException(
-                $"Deserialized numInteractions ({numInteractions}) is out of valid range. Data may be corrupted.");
-        }
-        _interactionTerms = new Dictionary<(int, int), Matrix<T>>();
-        for (int k = 0; k < numInteractions; k++)
-        {
-            int f1 = reader.ReadInt32();
-            int f2 = reader.ReadInt32();
-            if (f1 < 0 || f1 >= _numFeatures || f2 < 0 || f2 >= _numFeatures)
-            {
-                throw new InvalidOperationException(
-                    $"Deserialized interaction feature indices ({f1}, {f2}) are out of valid range [0, {_numFeatures}). Data may be corrupted.");
-            }
-            int dim1 = reader.ReadInt32();
-            int dim2 = reader.ReadInt32();
-            long totalElements = (long)dim1 * (long)dim2;
-            if (dim1 < 0 || dim2 < 0 || totalElements > MaxArrayLength)
-            {
-                throw new InvalidOperationException(
-                    $"Deserialized interaction dimensions ({dim1}x{dim2} = {totalElements} elements) exceed maximum allowed ({MaxArrayLength}). Data may be corrupted.");
-            }
-            var term = new Matrix<T>(dim1, dim2);
-            for (int i = 0; i < dim1; i++)
-            {
-                for (int j = 0; j < dim2; j++)
-                {
-                    term[i, j] = NumOps.FromDouble(reader.ReadDouble());
-                }
-            }
-            _interactionTerms[(f1, f2)] = term;
-        }
-    }
-
-    /// <inheritdoc/>
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        return new ExplainableBoostingClassifier<T>(_options, Regularization);
-    }
 }
diff --git a/src/Classification/Boosting/HistGradientBoostingClassifier.cs b/src/Classification/Boosting/HistGradientBoostingClassifier.cs
index f69a001efe..e8566e4c07 100644
--- a/src/Classification/Boosting/HistGradientBoostingClassifier.cs
+++ b/src/Classification/Boosting/HistGradientBoostingClassifier.cs
@@ -84,7 +84,7 @@ namespace AiDotNet.Classification.Boosting;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
     [ResearchPaper("LightGBM: A Highly Efficient Gradient Boosting Decision Tree", "https://papers.nips.cc/paper/6907-lightgbm-a-highly-efficient-gradient-boosting-decision-tree")]
-public class HistGradientBoostingClassifier<T> : ClassifierBase<T>
+public partial class HistGradientBoostingClassifier<T> : ClassifierBase<T>
 {
 
     // Its own comment: "For tree-based models, parameters do not fit the typical vector format".
@@ -756,19 +756,6 @@ public override IFullModel<T, Matrix<T>, Vector<T>> WithParameters(Vector<T> par
         return model;
     }
 
-    /// <summary>
-    /// Creates a new instance of this model type.
-    /// </summary>
-    /// <returns>New instance with same hyperparameters.</returns>
-    /// <remarks>
-    /// <para><b>For Beginners:</b> Creates an untrained copy with the same settings.</para>
-    /// </remarks>
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        return new HistGradientBoostingClassifier<T>(_maxBins, _maxDepth, _nEstimators,
-            _learningRate, _minSamplesLeaf, _l2Regularization);
-    }
-
     /// <summary>
     /// Gets feature importance based on total gain reduction.
     /// </summary>
@@ -824,48 +811,6 @@ private void CountFeatureUsage(HistTree node, double[] importance)
         CountFeatureUsage(node.RightChild, importance);
     }
 
-    /// <inheritdoc/>
-    public override IFullModel<T, Matrix<T>, Vector<T>> Clone()
-    {
-        var clone = new HistGradientBoostingClassifier<T>(_maxBins, _maxDepth, _nEstimators,
-            _learningRate, _minSamplesLeaf, _l2Regularization);
-
-        clone.NumFeatures = NumFeatures;
-        clone.NumClasses = NumClasses;
-        clone.TaskType = TaskType;
-        clone.FeatureNames = FeatureNames is not null ? (string[])FeatureNames.Clone() : null;
-
-        if (ClassLabels is not null)
-        {
-            clone.ClassLabels = new Vector<T>(ClassLabels.Length);
-            for (int i = 0; i < ClassLabels.Length; i++)
-                clone.ClassLabels[i] = ClassLabels[i];
-        }
-
-        if (_binBoundaries is not null)
-        {
-            clone._binBoundaries = new double[_binBoundaries.Length][];
-            for (int i = 0; i < _binBoundaries.Length; i++)
-            {
-                clone._binBoundaries[i] = new double[_binBoundaries[i].Length];
-                Array.Copy(_binBoundaries[i], clone._binBoundaries[i], _binBoundaries[i].Length);
-            }
-        }
-
-        if (_initialPrediction is not null)
-        {
-            clone._initialPrediction = new double[_initialPrediction.Length];
-            Array.Copy(_initialPrediction, clone._initialPrediction, _initialPrediction.Length);
-        }
-
-        foreach (var tree in _trees)
-        {
-            clone._trees.Add(CloneHistTree(tree));
-        }
-
-        return clone;
-    }
-
     private static HistTree CloneHistTree(HistTree node)
     {
         var cloned = new HistTree
@@ -881,99 +826,6 @@ private static HistTree CloneHistTree(HistTree node)
         return cloned;
     }
 
-    /// <inheritdoc/>
-    public override byte[] Serialize()
-    {
-        var modelData = new Dictionary<string, object>
-        {
-            { "NumClasses", NumClasses },
-            { "NumFeatures", NumFeatures },
-            { "TaskType", (int)TaskType },
-            { "ClassLabels", ClassLabels?.ToArray() ?? Array.Empty<T>() },
-            { "MaxBins", _maxBins },
-            { "MaxDepth", _maxDepth },
-            { "NEstimators", _nEstimators },
-            { "LearningRate", _learningRate },
-            { "MinSamplesLeaf", _minSamplesLeaf },
-            { "L2Regularization", _l2Regularization }
-        };
-
-        if (_initialPrediction is not null)
-            modelData["InitialPrediction"] = _initialPrediction;
-
-        if (_binBoundaries is not null)
-        {
-            modelData["BinBoundariesCount"] = _binBoundaries.Length;
-            for (int i = 0; i < _binBoundaries.Length; i++)
-                modelData[$"BinBoundaries_{i}"] = _binBoundaries[i];
-        }
-
-        modelData["TreeCount"] = _trees.Count;
-        for (int i = 0; i < _trees.Count; i++)
-            modelData[$"Tree_{i}"] = SerializeHistTree(_trees[i]);
-
-        var modelMetadata = GetModelMetadata();
-        modelMetadata.ModelData = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(modelData));
-        return Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(modelMetadata));
-    }
-
-    /// <inheritdoc/>
-    public override void Deserialize(byte[] modelData)
-    {
-        var jsonString = Encoding.UTF8.GetString(modelData);
-        var modelMetadata = JsonConvert.DeserializeObject<ModelMetadata<T>>(jsonString);
-
-        if (modelMetadata == null || modelMetadata.ModelData == null)
-            throw new InvalidOperationException("Deserialization failed: The model data is invalid or corrupted.");
-
-        var modelDataString = Encoding.UTF8.GetString(modelMetadata.ModelData);
-        var modelDataObj = JsonConvert.DeserializeObject<JObject>(modelDataString);
-
-        if (modelDataObj == null)
-            throw new InvalidOperationException("Deserialization failed: The model data is invalid or corrupted.");
-
-        // Clear optional members before rehydrating to avoid stale state
-        ClassLabels = null;
-        _initialPrediction = null;
-        _binBoundaries = null;
-        _trees.Clear();
-
-        NumClasses = modelDataObj["NumClasses"]?.ToObject<int>() ?? 0;
-        NumFeatures = modelDataObj["NumFeatures"]?.ToObject<int>() ?? 0;
-        TaskType = (ClassificationTaskType)(modelDataObj["TaskType"]?.ToObject<int>() ?? 0);
-
-        var classLabelsToken = modelDataObj["ClassLabels"];
-        if (classLabelsToken is not null)
-        {
-            var classLabelsAsDoubles = classLabelsToken.ToObject<double[]>() ?? Array.Empty<double>();
-            if (classLabelsAsDoubles.Length > 0)
-            {
-                ClassLabels = new Vector<T>(classLabelsAsDoubles.Length);
-                for (int i = 0; i < classLabelsAsDoubles.Length; i++)
-                    ClassLabels[i] = NumOps.FromDouble(classLabelsAsDoubles[i]);
-            }
-        }
-
-        _initialPrediction = modelDataObj["InitialPrediction"]?.ToObject<double[]>();
-
-        int bbCount = modelDataObj["BinBoundariesCount"]?.ToObject<int>() ?? 0;
-        if (bbCount > 0)
-        {
-            _binBoundaries = new double[bbCount][];
-            for (int i = 0; i < bbCount; i++)
-                _binBoundaries[i] = modelDataObj[$"BinBoundaries_{i}"]?.ToObject<double[]>() ?? Array.Empty<double>();
-        }
-
-        _trees.Clear();
-        int treeCount = modelDataObj["TreeCount"]?.ToObject<int>() ?? 0;
-        for (int i = 0; i < treeCount; i++)
-        {
-            var treeToken = modelDataObj[$"Tree_{i}"] as JObject;
-            if (treeToken is not null)
-                _trees.Add(DeserializeHistTree(treeToken));
-        }
-    }
-
     private Dictionary<string, object> SerializeHistTree(HistTree node)
     {
         var data = new Dictionary<string, object>
diff --git a/src/Classification/Boosting/NGBoostClassifier.cs b/src/Classification/Boosting/NGBoostClassifier.cs
index 4c78217434..3db61e9c52 100644
--- a/src/Classification/Boosting/NGBoostClassifier.cs
+++ b/src/Classification/Boosting/NGBoostClassifier.cs
@@ -80,6 +80,7 @@ public partial class NGBoostClassifier<T> : EnsembleClassifierBase<T>
     /// <summary>
     /// Initial log-odds values for each class.
     /// </summary>
+    [AiDotNet.Attributes.FittedParameter]
     private Vector<T> _initialLogOdds;
 
     /// <summary>
@@ -538,115 +539,4 @@ public override ModelMetadata<T> GetModelMetadata()
             }
         };
     }
-
-    /// <inheritdoc/>
-    public override byte[] Serialize()
-    {
-        using var ms = new MemoryStream();
-        using var writer = new BinaryWriter(ms);
-
-        byte[] baseData = base.Serialize();
-        writer.Write(baseData.Length);
-        writer.Write(baseData);
-
-        // Options
-        writer.Write(_options.NumberOfIterations);
-        writer.Write(_options.LearningRate);
-        writer.Write(_options.SubsampleRatio);
-        writer.Write(_options.UseNaturalGradient);
-        writer.Write(_options.MaxDepth);
-        writer.Write(_options.MinSamplesSplit);
-        writer.Write(_options.MaxFeatures);
-        writer.Write((int)_options.SplitCriterion);
-        writer.Write(_options.EarlyStoppingRounds.HasValue);
-        if (_options.EarlyStoppingRounds.HasValue)
-            writer.Write(_options.EarlyStoppingRounds.Value);
-        writer.Write(_options.Verbose);
-        writer.Write(_options.VerboseEval);
-        writer.Write(_options.Seed.HasValue);
-        if (_options.Seed.HasValue)
-            writer.Write(_options.Seed.Value);
-
-        // Class info
-        writer.Write(_numClasses);
-        for (int c = 0; c < _numClasses; c++)
-        {
-            writer.Write(NumOps.ToDouble(_initialLogOdds[c]));
-        }
-
-        // Trees
-        writer.Write(_trees.Count);
-        foreach (var iterTrees in _trees)
-        {
-            for (int c = 0; c < _numClasses; c++)
-            {
-                byte[] treeData = iterTrees[c].Serialize();
-                writer.Write(treeData.Length);
-                writer.Write(treeData);
-            }
-        }
-
-        return ms.ToArray();
-    }
-
-    /// <inheritdoc/>
-    public override void Deserialize(byte[] modelData)
-    {
-        using var ms = new MemoryStream(modelData);
-        using var reader = new BinaryReader(ms);
-
-        int baseLen = reader.ReadInt32();
-        byte[] baseData = reader.ReadBytes(baseLen);
-        base.Deserialize(baseData);
-
-        // Options
-        _options.NumberOfIterations = reader.ReadInt32();
-        _options.LearningRate = reader.ReadDouble();
-        _options.SubsampleRatio = reader.ReadDouble();
-        _options.UseNaturalGradient = reader.ReadBoolean();
-        _options.MaxDepth = reader.ReadInt32();
-        _options.MinSamplesSplit = reader.ReadInt32();
-        _options.MaxFeatures = reader.ReadDouble();
-        _options.SplitCriterion = (Enums.SplitCriterion)reader.ReadInt32();
-        if (reader.ReadBoolean())
-            _options.EarlyStoppingRounds = reader.ReadInt32();
-        else
-            _options.EarlyStoppingRounds = null;
-        _options.Verbose = reader.ReadBoolean();
-        _options.VerboseEval = reader.ReadInt32();
-        if (reader.ReadBoolean())
-            _options.Seed = reader.ReadInt32();
-        else
-            _options.Seed = null;
-
-        // Class info
-        _numClasses = reader.ReadInt32();
-        _initialLogOdds = new Vector<T>(_numClasses);
-        for (int c = 0; c < _numClasses; c++)
-        {
-            _initialLogOdds[c] = NumOps.FromDouble(reader.ReadDouble());
-        }
-
-        // Trees
-        int numIter = reader.ReadInt32();
-        _trees.Clear();
-        for (int iter = 0; iter < numIter; iter++)
-        {
-            var iterTrees = new DecisionTreeRegression<T>[_numClasses];
-            for (int c = 0; c < _numClasses; c++)
-            {
-                int treeLen = reader.ReadInt32();
-                byte[] treeData = reader.ReadBytes(treeLen);
-                iterTrees[c] = new DecisionTreeRegression<T>(new DecisionTreeOptions());
-                iterTrees[c].Deserialize(treeData);
-            }
-            _trees.Add(iterTrees);
-        }
-    }
-
-    /// <inheritdoc/>
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        return new NGBoostClassifier<T>(_options, Regularization);
-    }
 }
diff --git a/src/Classification/Calibration/CalibratedClassifier.cs b/src/Classification/Calibration/CalibratedClassifier.cs
index 32f8b178ae..89ffb76bf5 100644
--- a/src/Classification/Calibration/CalibratedClassifier.cs
+++ b/src/Classification/Calibration/CalibratedClassifier.cs
@@ -779,68 +779,6 @@ private T InterpolateIsotonic(T p)
             NumOps.Multiply(_isotonicMapping[high].calibrated, t));
     }
 
-    /// <summary>
-    /// Gets the model type.
-    /// </summary>
-
-    /// <inheritdoc/>
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        IProbabilisticClassifier<T> clonedBase;
-        if (_baseClassifier is IFullModel<T, Matrix<T>, Vector<T>> fullModel)
-        {
-            clonedBase = (IProbabilisticClassifier<T>)fullModel.Clone();
-        }
-        else
-        {
-            clonedBase = _baseClassifier;
-        }
-
-        return new CalibratedClassifier<T>(clonedBase, new CalibratedClassifierOptions<T>
-        {
-            CalibrationMethod = _options.CalibrationMethod,
-            CrossValidationFolds = _options.CrossValidationFolds,
-            CalibrationSetFraction = _options.CalibrationSetFraction,
-            Seed = _options.Seed
-        });
-    }
-
-    /// <inheritdoc/>
-    public override IFullModel<T, Matrix<T>, Vector<T>> Clone()
-    {
-        var clone = (CalibratedClassifier<T>)CreateNewInstance();
-
-        clone.NumFeatures = NumFeatures;
-        clone.NumClasses = NumClasses;
-        clone.TaskType = TaskType;
-        clone._isTrained = _isTrained;
-
-        // Copy calibration parameters
-        clone._plattA = _plattA;
-        clone._plattB = _plattB;
-        clone._betaA = _betaA;
-        clone._betaB = _betaB;
-        clone._betaC = _betaC;
-        clone._temperature = _temperature;
-
-        if (_isotonicMapping != null)
-        {
-            clone._isotonicMapping = new (T, T)[_isotonicMapping.Length];
-            Array.Copy(_isotonicMapping, clone._isotonicMapping, _isotonicMapping.Length);
-        }
-
-        if (ClassLabels != null)
-        {
-            clone.ClassLabels = new Vector<T>(ClassLabels.Length);
-            for (int i = 0; i < ClassLabels.Length; i++)
-            {
-                clone.ClassLabels[i] = ClassLabels[i];
-            }
-        }
-
-        return clone;
-    }
-
     /// <inheritdoc/>
     private Vector<T> PackParameters()
     {
@@ -884,97 +822,6 @@ public override IFullModel<T, Matrix<T>, Vector<T>> WithParameters(Vector<T> par
         return newModel;
     }
 
-    /// <inheritdoc/>
-    public override byte[] Serialize()
-    {
-        var (baseTypeName, baseData) = ClassifierRegistry<T>.SerializeClassifier((IClassifier<T>)_baseClassifier);
-
-        var modelDict = new Dictionary<string, object?>
-        {
-            { "ClassLabels", ClassLabels?.ToArray().Select(NumOps.ToDouble).ToArray() },
-            { "NumClasses", NumClasses },
-            { "NumFeatures", NumFeatures },
-            { "TaskType", (int)TaskType },
-            { "CalibrationMethod", (int)_options.CalibrationMethod },
-            { "PlattA", _plattA },
-            { "PlattB", _plattB },
-            { "BetaA", _betaA },
-            { "BetaB", _betaB },
-            { "BetaC", _betaC },
-            { "Temperature", _temperature },
-            { "IsotonicMapping", _isotonicMapping?.Select(m => new[] { m.prob, m.calibrated }).ToArray() },
-            { "IsTrained", _isTrained },
-            { "BaseClassifierType", baseTypeName },
-            { "BaseClassifierData", baseData }
-        };
-
-        var metadata = GetModelMetadata();
-        metadata.ModelData = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(modelDict));
-        return Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(metadata));
-    }
-
-    /// <inheritdoc/>
-    public override void Deserialize(byte[] modelData)
-    {
-        var jsonString = Encoding.UTF8.GetString(modelData);
-        var metadata = JsonConvert.DeserializeObject<ModelMetadata<T>>(jsonString);
-        if (metadata?.ModelData is null)
-            throw new InvalidOperationException("Invalid serialized data: missing model metadata.");
-
-        var dataString = Encoding.UTF8.GetString(metadata.ModelData);
-        var jObj = JsonConvert.DeserializeObject<JObject>(dataString);
-        if (jObj is null)
-            throw new InvalidOperationException("Invalid serialized data: model data is not a valid JSON object.");
-
-        var classLabelsArr = jObj["ClassLabels"]?.ToObject<double[]>();
-        if (classLabelsArr is not null)
-        {
-            ClassLabels = new Vector<T>(classLabelsArr.Length);
-            for (int i = 0; i < classLabelsArr.Length; i++)
-                ClassLabels[i] = NumOps.FromDouble(classLabelsArr[i]);
-        }
-        NumClasses = jObj["NumClasses"]?.ToObject<int>() ?? 0;
-        NumFeatures = jObj["NumFeatures"]?.ToObject<int>() ?? 0;
-        TaskType = (ClassificationTaskType)(jObj["TaskType"]?.ToObject<int>() ?? 0);
-        _options.CalibrationMethod = (ProbabilityCalibrationMethod)(jObj["CalibrationMethod"]?.ToObject<int>()
-            ?? (int)ProbabilityCalibrationMethod.PlattScaling);
-        _plattA = DeserializeValue(jObj["PlattA"], NumOps.One);
-        _plattB = DeserializeValue(jObj["PlattB"], NumOps.Zero);
-        _betaA = DeserializeValue(jObj["BetaA"], NumOps.One);
-        _betaB = DeserializeValue(jObj["BetaB"], NumOps.One);
-        _betaC = DeserializeValue(jObj["BetaC"], NumOps.Zero);
-        _temperature = DeserializeValue(jObj["Temperature"], NumOps.One);
-        _isTrained = jObj["IsTrained"]?.ToObject<bool>() ?? false;
-
-        var isoArr = jObj["IsotonicMapping"] is JToken isoToken ? isoToken.ToObject<T[][]>() : null;
-        if (isoArr is not null)
-        {
-            _isotonicMapping = isoArr
-                .Where(m => m is not null && m.Length >= 2)
-                .Select(m => (m[0], m[1]))
-                .ToArray();
-        }
-        else
-        {
-            // Clear stale isotonic calibration state when not present in the payload
-            _isotonicMapping = null;
-        }
-
-        // Restore wrapped base classifier
-        var baseType = jObj["BaseClassifierType"]?.ToObject<string>();
-        var baseData = jObj["BaseClassifierData"]?.ToObject<string>();
-        if (baseType is null || baseData is null)
-            throw new InvalidOperationException(
-                "Invalid serialized data: missing BaseClassifierType or BaseClassifierData for CalibratedClassifier.");
-
-        var restoredBase = ClassifierRegistry<T>.DeserializeClassifier(baseType, baseData);
-        if (restoredBase is not IProbabilisticClassifier<T> probClassifier)
-            throw new InvalidOperationException(
-                $"Deserialized base classifier of type '{baseType}' does not implement IProbabilisticClassifier<T>.");
-
-        _baseClassifier = probClassifier;
-    }
-
     private static T DeserializeValue(JToken? token, T defaultValue)
     {
         if (token is null || token.Type == JTokenType.Null)
diff --git a/src/Classification/ClassifierBase.cs b/src/Classification/ClassifierBase.cs
index 5c2bcad27c..96fac0cdd9 100644
--- a/src/Classification/ClassifierBase.cs
+++ b/src/Classification/ClassifierBase.cs
@@ -31,8 +31,51 @@ namespace AiDotNet.Classification;
 /// functionality.
 /// </para>
 /// </remarks>
-public abstract class ClassifierBase<T> : IClassifier<T>, IConfigurableModel<T>, IModelShape, IParameterManifestProvider
+public abstract partial class ClassifierBase<T> : IClassifier<T>, IConfigurableModel<T>, IModelShape, IParameterManifestProvider
 {
+    // --- declared state (ModelStateRegistry) ---
+    // Identical in every model base because these bases are siblings over the same interfaces rather
+    // than one hierarchy; the logic itself lives once in ModelStateRegistry/ModelStateEnvelope.
+
+    /// <summary>State that is not a parameter vector, declared once and persisted by this base.</summary>
+    private readonly AiDotNet.Models.ModelStateRegistry<T> _declaredState = new();
+    private bool _declaredStateRegistered;
+
+    /// <summary>
+    /// Declare state here that the parameter vector does not carry -- a retained training set,
+    /// fitted knots, kernel centres, an ensemble's children. Both halves of the payload are driven
+    /// by the declaration, so they cannot drift.
+    /// </summary>
+    /// <param name="state">The registry to declare into.</param>
+    protected virtual void RegisterState(AiDotNet.Models.ModelStateRegistry<T> state)
+    {
+    }
+    /// <summary>Generated state declarations for fields declared across this model's hierarchy.</summary>
+    /// <param name="state">The registry to declare into.</param>
+    /// <remarks>
+    /// Emitted by ModelStateGenerator into the partial model, so a model author declares nothing. The
+    /// hand-written <c>RegisterState</c> beside it exists only for state the classifier genuinely
+    /// cannot place; anything it CAN place belongs here, where it cannot be forgotten.
+    /// </remarks>
+    protected virtual void RegisterGeneratedState(AiDotNet.Models.ModelStateRegistry<T> state)
+    {
+        RegisterGeneratedStateCore(state);
+    }
+
+    /// <summary>The declared state, registered once and lazily so it runs after the constructor.</summary>
+    protected AiDotNet.Models.ModelStateRegistry<T> DeclaredState
+    {
+        get
+        {
+            if (!_declaredStateRegistered)
+            {
+                _declaredStateRegistered = true;
+                RegisterGeneratedState(_declaredState);
+                RegisterState(_declaredState);
+            }
+            return _declaredState;
+        }
+    }
     /// <summary>
     /// Gets the numeric operations for the specified type T.
     /// </summary>
@@ -398,7 +441,7 @@ public virtual ModelMetadata<T> GetModelMetadata()
     public virtual byte[] Serialize()
     {
         ModelPersistenceGuard.EnforceBeforeSerialize();
-        return SerializeInternalUnchecked();
+        return AiDotNet.Models.ModelStateEnvelope.Append(DeclaredState, SerializeInternalUnchecked());
     }
 
     /// <summary>
@@ -442,6 +485,9 @@ private byte[] SerializeInternalUnchecked()
     /// </remarks>
     public virtual void Deserialize(byte[] modelData)
     {
+        // Strips and applies any declared-state trailer, so the body below reads the payload
+        // exactly as it did before this existed.
+        modelData = AiDotNet.Models.ModelStateEnvelope.Extract(DeclaredState, modelData);
         ModelPersistenceGuard.EnforceBeforeDeserialize();
         DeserializeInternalUnchecked(modelData);
     }
@@ -620,7 +666,18 @@ public virtual IFullModel<T, Matrix<T>, Vector<T>> DeepCopy()
     /// Creates a new instance of the same type as this classifier.
     /// </summary>
     /// <returns>A new instance of the same classifier type.</returns>
-    protected abstract IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance();
+    /// <remarks>
+    /// <para>
+    /// No longer abstract. Every concrete model used to be forced to write this, and 1147 of them
+    /// did -- each one a hand-copied list of constructor arguments that a new option could fall out
+    /// of without anything failing. The clone plan records that constructor at compile time instead,
+    /// so the base can rebuild the type and a model only overrides this when the generator says it
+    /// cannot: a constructor parameter with nothing holding its value, which the build reports by
+    /// name rather than leaving to be discovered by a clone that comes back subtly different.
+    /// </para>
+    /// </remarks>
+    protected virtual IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
+        => (IFullModel<T, Matrix<T>, Vector<T>>)AiDotNet.Models.CloneEngine.CopyConfiguration(this);
 
     /// <summary>
     /// Creates a clone of the classifier model.
diff --git a/src/Classification/DiscriminantAnalysis/LinearDiscriminantAnalysis.cs b/src/Classification/DiscriminantAnalysis/LinearDiscriminantAnalysis.cs
index d15469c05f..3354aae202 100644
--- a/src/Classification/DiscriminantAnalysis/LinearDiscriminantAnalysis.cs
+++ b/src/Classification/DiscriminantAnalysis/LinearDiscriminantAnalysis.cs
@@ -76,7 +76,7 @@ namespace AiDotNet.Classification.DiscriminantAnalysis;
 [ModelComplexity(ModelComplexity.Low)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
 [ResearchPaper("The Use of Multiple Measurements in Taxonomic Problems", "https://doi.org/10.1111/j.1469-1809.1936.tb02137.x")]
-public class LinearDiscriminantAnalysis<T> : ProbabilisticClassifierBase<T>,
+public partial class LinearDiscriminantAnalysis<T> : ProbabilisticClassifierBase<T>,
     IParameterizable<T, Matrix<T>, Vector<T>>
 {
 
@@ -107,21 +107,25 @@ protected override void RegisterComponents()
     /// <summary>
     /// Class means for each class.
     /// </summary>
+    [AiDotNet.Attributes.FittedParameter]
     private Matrix<T> _classMeans = new Matrix<T>(0, 0);
 
     /// <summary>
     /// Pooled within-class covariance matrix (shared by all classes).
     /// </summary>
+    [AiDotNet.Attributes.FittedParameter]
     private Matrix<T> _pooledCovariance = new Matrix<T>(0, 0);
 
     /// <summary>
     /// Inverse of the pooled covariance matrix.
     /// </summary>
+    [AiDotNet.Attributes.FittedParameter]
     private Matrix<T> _covarianceInverse = new Matrix<T>(0, 0);
 
     /// <summary>
     /// Class priors (prior probabilities).
     /// </summary>
+    [AiDotNet.Attributes.FittedParameter]
     private Vector<T> _classPriors = new Vector<T>(0);
 
     /// <summary>
@@ -537,81 +541,6 @@ public override Matrix<T> PredictLogProbabilities(Matrix<T> input)
         return logProbs;
     }
 
-    /// <inheritdoc/>
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        return new LinearDiscriminantAnalysis<T>(new DiscriminantAnalysisOptions<T>
-        {
-            RegularizationParam = Options.RegularizationParam
-        });
-    }
-
-    /// <inheritdoc/>
-    public override IFullModel<T, Matrix<T>, Vector<T>> Clone()
-    {
-        var clone = (LinearDiscriminantAnalysis<T>)CreateNewInstance();
-
-        clone.NumFeatures = NumFeatures;
-        clone.NumClasses = NumClasses;
-        clone.TaskType = TaskType;
-
-        if (ClassLabels is not null)
-        {
-            clone.ClassLabels = new Vector<T>(ClassLabels.Length);
-            for (int i = 0; i < ClassLabels.Length; i++)
-            {
-                clone.ClassLabels[i] = ClassLabels[i];
-            }
-        }
-
-        if (_classMeans is not null)
-        {
-            clone._classMeans = new Matrix<T>(_classMeans.Rows, _classMeans.Columns);
-            for (int i = 0; i < _classMeans.Rows; i++)
-            {
-                for (int j = 0; j < _classMeans.Columns; j++)
-                {
-                    clone._classMeans[i, j] = _classMeans[i, j];
-                }
-            }
-        }
-
-        if (_pooledCovariance is not null)
-        {
-            clone._pooledCovariance = new Matrix<T>(_pooledCovariance.Rows, _pooledCovariance.Columns);
-            for (int i = 0; i < _pooledCovariance.Rows; i++)
-            {
-                for (int j = 0; j < _pooledCovariance.Columns; j++)
-                {
-                    clone._pooledCovariance[i, j] = _pooledCovariance[i, j];
-                }
-            }
-        }
-
-        if (_covarianceInverse is not null)
-        {
-            clone._covarianceInverse = new Matrix<T>(_covarianceInverse.Rows, _covarianceInverse.Columns);
-            for (int i = 0; i < _covarianceInverse.Rows; i++)
-            {
-                for (int j = 0; j < _covarianceInverse.Columns; j++)
-                {
-                    clone._covarianceInverse[i, j] = _covarianceInverse[i, j];
-                }
-            }
-        }
-
-        if (_classPriors is not null)
-        {
-            clone._classPriors = new Vector<T>(_classPriors.Length);
-            for (int i = 0; i < _classPriors.Length; i++)
-            {
-                clone._classPriors[i] = _classPriors[i];
-            }
-        }
-
-        return clone;
-    }
-
     /// <inheritdoc/>
     public override ModelMetadata<T> GetModelMetadata()
     {
@@ -657,70 +586,6 @@ public override IFullModel<T, Matrix<T>, Vector<T>> WithParameters(Vector<T> par
         return CreateNewInstance();
     }
 
-    /// <inheritdoc/>
-    public override byte[] Serialize()
-    {
-        var modelData = new Dictionary<string, object>
-        {
-            { "NumClasses", NumClasses },
-            { "NumFeatures", NumFeatures },
-            { "TaskType", (int)TaskType },
-            { "ClassLabels", ClassLabels?.ToArray() ?? Array.Empty<T>() },
-            { "RegularizationOptions", Regularization.GetOptions() },
-            { "RegularizationParam", Options.RegularizationParam }
-        };
-
-        SerializeMatrix(modelData, "ClassMeans", _classMeans);
-        SerializeMatrix(modelData, "PooledCovariance", _pooledCovariance);
-        SerializeMatrix(modelData, "CovarianceInverse", _covarianceInverse);
-        SerializeVector(modelData, "ClassPriors", _classPriors);
-
-        var modelMetadata = GetModelMetadata();
-        modelMetadata.ModelData = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(modelData));
-        return Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(modelMetadata));
-    }
-
-    /// <inheritdoc/>
-    public override void Deserialize(byte[] modelData)
-    {
-        var jsonString = Encoding.UTF8.GetString(modelData);
-        var modelMetadata = JsonConvert.DeserializeObject<ModelMetadata<T>>(jsonString);
-
-        if (modelMetadata == null || modelMetadata.ModelData == null)
-            throw new InvalidOperationException("Deserialization failed: The model data is invalid or corrupted.");
-
-        var modelDataString = Encoding.UTF8.GetString(modelMetadata.ModelData);
-        var modelDataObj = JsonConvert.DeserializeObject<JObject>(modelDataString);
-
-        if (modelDataObj == null)
-            throw new InvalidOperationException("Deserialization failed: The model data is invalid or corrupted.");
-
-        NumClasses = modelDataObj["NumClasses"]?.ToObject<int>() ?? 0;
-        NumFeatures = modelDataObj["NumFeatures"]?.ToObject<int>() ?? 0;
-        TaskType = (ClassificationTaskType)(modelDataObj["TaskType"]?.ToObject<int>() ?? 0);
-
-        var classLabelsToken = modelDataObj["ClassLabels"];
-        if (classLabelsToken is not null)
-        {
-            var classLabelsAsDoubles = classLabelsToken.ToObject<double[]>() ?? Array.Empty<double>();
-            if (classLabelsAsDoubles.Length > 0)
-            {
-                ClassLabels = new Vector<T>(classLabelsAsDoubles.Length);
-                for (int i = 0; i < classLabelsAsDoubles.Length; i++)
-                    ClassLabels[i] = NumOps.FromDouble(classLabelsAsDoubles[i]);
-            }
-        }
-
-        _classMeans = DeserializeMatrix(modelDataObj, "ClassMeans")
-            ?? throw new InvalidOperationException("Missing required 'ClassMeans' in serialized model data.");
-        _pooledCovariance = DeserializeMatrix(modelDataObj, "PooledCovariance")
-            ?? throw new InvalidOperationException("Missing required 'PooledCovariance' in serialized model data.");
-        _covarianceInverse = DeserializeMatrix(modelDataObj, "CovarianceInverse")
-            ?? throw new InvalidOperationException("Missing required 'CovarianceInverse' in serialized model data.");
-        _classPriors = DeserializeVector(modelDataObj, "ClassPriors")
-            ?? throw new InvalidOperationException("Missing required 'ClassPriors' in serialized model data.");
-    }
-
     private void SerializeMatrix(Dictionary<string, object> data, string name, Matrix<T>? matrix)
     {
         if (matrix is null) return;
diff --git a/src/Classification/DiscriminantAnalysis/QuadraticDiscriminantAnalysis.cs b/src/Classification/DiscriminantAnalysis/QuadraticDiscriminantAnalysis.cs
index 574b8b9d21..55581bd791 100644
--- a/src/Classification/DiscriminantAnalysis/QuadraticDiscriminantAnalysis.cs
+++ b/src/Classification/DiscriminantAnalysis/QuadraticDiscriminantAnalysis.cs
@@ -65,7 +65,7 @@ namespace AiDotNet.Classification.DiscriminantAnalysis;
 [ModelComplexity(ModelComplexity.Low)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
 [ResearchPaper("The Use of Multiple Measurements in Taxonomic Problems", "https://doi.org/10.1111/j.1469-1809.1936.tb02137.x")]
-public class QuadraticDiscriminantAnalysis<T> : ProbabilisticClassifierBase<T>,
+public partial class QuadraticDiscriminantAnalysis<T> : ProbabilisticClassifierBase<T>,
     IParameterizable<T, Matrix<T>, Vector<T>>
 {
 
@@ -96,6 +96,7 @@ protected override void RegisterComponents()
     /// <summary>
     /// Class means for each class.
     /// </summary>
+    [AiDotNet.Attributes.FittedParameter]
     private Matrix<T> _classMeans = new Matrix<T>(0, 0);
 
     /// <summary>
@@ -111,11 +112,13 @@ protected override void RegisterComponents()
     /// <summary>
     /// Log determinant of covariance matrix for each class.
     /// </summary>
+    [AiDotNet.Attributes.FittedParameter]
     private Vector<T> _classLogDets = new Vector<T>(0);
 
     /// <summary>
     /// Class priors (prior probabilities).
     /// </summary>
+    [AiDotNet.Attributes.FittedParameter]
     private Vector<T> _classPriors = new Vector<T>(0);
 
     /// <summary>
@@ -591,98 +594,6 @@ public override Matrix<T> PredictLogProbabilities(Matrix<T> input)
         return logProbs;
     }
 
-    /// <inheritdoc/>
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        return new QuadraticDiscriminantAnalysis<T>(new DiscriminantAnalysisOptions<T>
-        {
-            RegularizationParam = Options.RegularizationParam
-        });
-    }
-
-    /// <inheritdoc/>
-    public override IFullModel<T, Matrix<T>, Vector<T>> Clone()
-    {
-        var clone = (QuadraticDiscriminantAnalysis<T>)CreateNewInstance();
-
-        clone.NumFeatures = NumFeatures;
-        clone.NumClasses = NumClasses;
-        clone.TaskType = TaskType;
-
-        if (ClassLabels is not null)
-        {
-            clone.ClassLabels = new Vector<T>(ClassLabels.Length);
-            for (int i = 0; i < ClassLabels.Length; i++)
-            {
-                clone.ClassLabels[i] = ClassLabels[i];
-            }
-        }
-
-        if (_classMeans is not null)
-        {
-            clone._classMeans = new Matrix<T>(_classMeans.Rows, _classMeans.Columns);
-            for (int i = 0; i < _classMeans.Rows; i++)
-            {
-                for (int j = 0; j < _classMeans.Columns; j++)
-                {
-                    clone._classMeans[i, j] = _classMeans[i, j];
-                }
-            }
-        }
-
-        if (_classPriors is not null)
-        {
-            clone._classPriors = new Vector<T>(_classPriors.Length);
-            for (int i = 0; i < _classPriors.Length; i++)
-            {
-                clone._classPriors[i] = _classPriors[i];
-            }
-        }
-
-        if (_classLogDets is not null)
-        {
-            clone._classLogDets = new Vector<T>(_classLogDets.Length);
-            for (int i = 0; i < _classLogDets.Length; i++)
-            {
-                clone._classLogDets[i] = _classLogDets[i];
-            }
-        }
-
-        if (_classCovariances is not null)
-        {
-            clone._classCovariances = new Matrix<T>[NumClasses];
-            for (int c = 0; c < NumClasses; c++)
-            {
-                clone._classCovariances[c] = new Matrix<T>(NumFeatures, NumFeatures);
-                for (int i = 0; i < NumFeatures; i++)
-                {
-                    for (int j = 0; j < NumFeatures; j++)
-                    {
-                        clone._classCovariances[c][i, j] = _classCovariances[c][i, j];
-                    }
-                }
-            }
-        }
-
-        if (_classCovarianceInverses is not null)
-        {
-            clone._classCovarianceInverses = new Matrix<T>[NumClasses];
-            for (int c = 0; c < NumClasses; c++)
-            {
-                clone._classCovarianceInverses[c] = new Matrix<T>(NumFeatures, NumFeatures);
-                for (int i = 0; i < NumFeatures; i++)
-                {
-                    for (int j = 0; j < NumFeatures; j++)
-                    {
-                        clone._classCovarianceInverses[c][i, j] = _classCovarianceInverses[c][i, j];
-                    }
-                }
-            }
-        }
-
-        return clone;
-    }
-
     /// <inheritdoc/>
     public override ModelMetadata<T> GetModelMetadata()
     {
@@ -727,104 +638,6 @@ public override IFullModel<T, Matrix<T>, Vector<T>> WithParameters(Vector<T> par
         return CreateNewInstance();
     }
 
-    /// <inheritdoc/>
-    public override byte[] Serialize()
-    {
-        var modelData = new Dictionary<string, object>
-        {
-            { "NumClasses", NumClasses },
-            { "NumFeatures", NumFeatures },
-            { "TaskType", (int)TaskType },
-            { "ClassLabels", ClassLabels?.ToArray() ?? Array.Empty<T>() },
-            { "RegularizationOptions", Regularization.GetOptions() },
-            { "RegularizationParam", Options.RegularizationParam }
-        };
-
-        SerializeMatrix(modelData, "ClassMeans", _classMeans);
-        SerializeVector(modelData, "ClassPriors", _classPriors);
-        SerializeVector(modelData, "ClassLogDets", _classLogDets);
-
-        // Serialize per-class covariance matrices and their inverses
-        if (_classCovariances is not null)
-        {
-            modelData["NumCovarianceMatrices"] = _classCovariances.Length;
-            for (int c = 0; c < _classCovariances.Length; c++)
-            {
-                SerializeMatrix(modelData, $"ClassCovariance_{c}", _classCovariances[c]);
-            }
-        }
-
-        if (_classCovarianceInverses is not null)
-        {
-            for (int c = 0; c < _classCovarianceInverses.Length; c++)
-            {
-                SerializeMatrix(modelData, $"ClassCovarianceInverse_{c}", _classCovarianceInverses[c]);
-            }
-        }
-
-        var modelMetadata = GetModelMetadata();
-        modelMetadata.ModelData = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(modelData));
-        return Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(modelMetadata));
-    }
-
-    /// <inheritdoc/>
-    public override void Deserialize(byte[] modelData)
-    {
-        var jsonString = Encoding.UTF8.GetString(modelData);
-        var modelMetadata = JsonConvert.DeserializeObject<ModelMetadata<T>>(jsonString);
-
-        if (modelMetadata == null || modelMetadata.ModelData == null)
-            throw new InvalidOperationException("Deserialization failed: The model data is invalid or corrupted.");
-
-        var modelDataString = Encoding.UTF8.GetString(modelMetadata.ModelData);
-        var modelDataObj = JsonConvert.DeserializeObject<JObject>(modelDataString);
-
-        if (modelDataObj == null)
-            throw new InvalidOperationException("Deserialization failed: The model data is invalid or corrupted.");
-
-        NumClasses = modelDataObj["NumClasses"]?.ToObject<int>() ?? 0;
-        NumFeatures = modelDataObj["NumFeatures"]?.ToObject<int>() ?? 0;
-        TaskType = (ClassificationTaskType)(modelDataObj["TaskType"]?.ToObject<int>() ?? 0);
-
-        var classLabelsToken = modelDataObj["ClassLabels"];
-        if (classLabelsToken is not null)
-        {
-            var classLabelsAsDoubles = classLabelsToken.ToObject<double[]>() ?? Array.Empty<double>();
-            if (classLabelsAsDoubles.Length > 0)
-            {
-                ClassLabels = new Vector<T>(classLabelsAsDoubles.Length);
-                for (int i = 0; i < classLabelsAsDoubles.Length; i++)
-                    ClassLabels[i] = NumOps.FromDouble(classLabelsAsDoubles[i]);
-            }
-        }
-
-        _classMeans = DeserializeMatrix(modelDataObj, "ClassMeans")
-            ?? throw new InvalidOperationException("Missing required 'ClassMeans' in serialized model data.");
-        _classPriors = DeserializeVector(modelDataObj, "ClassPriors")
-            ?? throw new InvalidOperationException("Missing required 'ClassPriors' in serialized model data.");
-        _classLogDets = DeserializeVector(modelDataObj, "ClassLogDets")
-            ?? throw new InvalidOperationException("Missing required 'ClassLogDets' in serialized model data.");
-
-        int numCovMatrices = modelDataObj["NumCovarianceMatrices"]?.ToObject<int>() ?? 0;
-        if (numCovMatrices > 0)
-        {
-            _classCovariances = new Matrix<T>[numCovMatrices];
-            _classCovarianceInverses = new Matrix<T>[numCovMatrices];
-            for (int c = 0; c < numCovMatrices; c++)
-            {
-                var cov = DeserializeMatrix(modelDataObj, $"ClassCovariance_{c}");
-                var covInv = DeserializeMatrix(modelDataObj, $"ClassCovarianceInverse_{c}");
-                if (cov is null || covInv is null)
-                {
-                    throw new InvalidOperationException(
-                        $"Deserialization failed: ClassCovariance or ClassCovarianceInverse for class {c} is missing.");
-                }
-                _classCovariances[c] = cov;
-                _classCovarianceInverses[c] = covInv;
-            }
-        }
-    }
-
     private void SerializeMatrix(Dictionary<string, object> data, string name, Matrix<T>? matrix)
     {
         if (matrix is null) return;
diff --git a/src/Classification/Ensemble/AdaBoostClassifier.cs b/src/Classification/Ensemble/AdaBoostClassifier.cs
index 2abc557c3d..ba2f0d0e4d 100644
--- a/src/Classification/Ensemble/AdaBoostClassifier.cs
+++ b/src/Classification/Ensemble/AdaBoostClassifier.cs
@@ -73,6 +73,7 @@ public partial class AdaBoostClassifier<T> : EnsembleClassifierBase<T>
     /// <summary>
     /// Weights for each estimator (based on their accuracy).
     /// </summary>
+    [AiDotNet.Attributes.FittedParameter]
     private Vector<T>? _estimatorWeights;
 
     /// <summary>
@@ -385,72 +386,6 @@ public override Matrix<T> PredictProbabilities(Matrix<T> input)
         return probabilities;
     }
 
-    /// <inheritdoc/>
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        return new AdaBoostClassifier<T>(new AdaBoostClassifierOptions<T>
-        {
-            NEstimators = Options.NEstimators,
-            LearningRate = Options.LearningRate,
-            Algorithm = Options.Algorithm,
-            Seed = Options.Seed
-        });
-    }
-
-    /// <inheritdoc/>
-    public override IFullModel<T, Matrix<T>, Vector<T>> Clone()
-    {
-        var clone = new AdaBoostClassifier<T>(new AdaBoostClassifierOptions<T>
-        {
-            NEstimators = Options.NEstimators,
-            LearningRate = Options.LearningRate,
-            Algorithm = Options.Algorithm,
-            Seed = Options.Seed
-        });
-
-        clone.NumFeatures = NumFeatures;
-        clone.NumClasses = NumClasses;
-        clone.TaskType = TaskType;
-
-        if (ClassLabels is not null)
-        {
-            clone.ClassLabels = new Vector<T>(ClassLabels.Length);
-            for (int i = 0; i < ClassLabels.Length; i++)
-            {
-                clone.ClassLabels[i] = ClassLabels[i];
-            }
-        }
-
-        if (_estimatorWeights is not null)
-        {
-            clone._estimatorWeights = new Vector<T>(_estimatorWeights.Length);
-            for (int i = 0; i < _estimatorWeights.Length; i++)
-            {
-                clone._estimatorWeights[i] = _estimatorWeights[i];
-            }
-        }
-
-        if (FeatureImportances is not null)
-        {
-            clone.FeatureImportances = new Vector<T>(FeatureImportances.Length);
-            for (int i = 0; i < FeatureImportances.Length; i++)
-            {
-                clone.FeatureImportances[i] = FeatureImportances[i];
-            }
-        }
-
-        // Clone all estimators
-        foreach (var estimator in Estimators)
-        {
-            if (estimator is IFullModel<T, Matrix<T>, Vector<T>> fullModel)
-            {
-                clone.Estimators.Add((IClassifier<T>)fullModel.Clone());
-            }
-        }
-
-        return clone;
-    }
-
     /// <inheritdoc/>
     public override ModelMetadata<T> GetModelMetadata()
     {
@@ -461,124 +396,4 @@ public override ModelMetadata<T> GetModelMetadata()
         metadata.AdditionalInfo["ActualEstimators"] = Estimators.Count;
         return metadata;
     }
-
-    /// <inheritdoc/>
-    public override byte[] Serialize()
-    {
-        var modelData = new Dictionary<string, object>
-        {
-            { "NumClasses", NumClasses },
-            { "NumFeatures", NumFeatures },
-            { "TaskType", (int)TaskType },
-            { "ClassLabels", ClassLabels?.ToArray() ?? Array.Empty<T>() },
-            { "RegularizationOptions", Regularization.GetOptions() }
-        };
-
-        // Serialize estimator weights
-        if (_estimatorWeights is not null)
-        {
-            var weightsArray = new double[_estimatorWeights.Length];
-            for (int i = 0; i < _estimatorWeights.Length; i++)
-                weightsArray[i] = NumOps.ToDouble(_estimatorWeights[i]);
-            modelData["EstimatorWeights"] = weightsArray;
-        }
-
-        // Serialize FeatureImportances
-        if (FeatureImportances is not null)
-        {
-            var fiArray = new double[FeatureImportances.Length];
-            for (int i = 0; i < FeatureImportances.Length; i++)
-                fiArray[i] = NumOps.ToDouble(FeatureImportances[i]);
-            modelData["FeatureImportances"] = fiArray;
-        }
-
-        // Serialize each estimator as base64
-        modelData["EstimatorCount"] = Estimators.Count;
-        for (int i = 0; i < Estimators.Count; i++)
-        {
-            if (Estimators[i] is IFullModel<T, Matrix<T>, Vector<T>> fullModel)
-            {
-                modelData[$"Estimator_{i}"] = Convert.ToBase64String(fullModel.Serialize());
-            }
-        }
-
-        var modelMetadata = GetModelMetadata();
-        modelMetadata.ModelData = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(modelData));
-        return Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(modelMetadata));
-    }
-
-    /// <inheritdoc/>
-    public override void Deserialize(byte[] modelData)
-    {
-        var jsonString = Encoding.UTF8.GetString(modelData);
-        var modelMetadata = JsonConvert.DeserializeObject<ModelMetadata<T>>(jsonString);
-
-        if (modelMetadata == null || modelMetadata.ModelData == null)
-            throw new InvalidOperationException("Deserialization failed: The model data is invalid or corrupted.");
-
-        var modelDataString = Encoding.UTF8.GetString(modelMetadata.ModelData);
-        var modelDataObj = JsonConvert.DeserializeObject<JObject>(modelDataString);
-
-        if (modelDataObj == null)
-            throw new InvalidOperationException("Deserialization failed: The model data is invalid or corrupted.");
-
-        NumClasses = modelDataObj["NumClasses"]?.ToObject<int>() ?? 0;
-        NumFeatures = modelDataObj["NumFeatures"]?.ToObject<int>() ?? 0;
-        TaskType = (ClassificationTaskType)(modelDataObj["TaskType"]?.ToObject<int>() ?? 0);
-
-        var classLabelsToken = modelDataObj["ClassLabels"];
-        if (classLabelsToken is not null)
-        {
-            var classLabelsAsDoubles = classLabelsToken.ToObject<double[]>() ?? Array.Empty<double>();
-            if (classLabelsAsDoubles.Length > 0)
-            {
-                ClassLabels = new Vector<T>(classLabelsAsDoubles.Length);
-                for (int i = 0; i < classLabelsAsDoubles.Length; i++)
-                    ClassLabels[i] = NumOps.FromDouble(classLabelsAsDoubles[i]);
-            }
-        }
-
-        // Deserialize estimator weights
-        var weightsToken = modelDataObj["EstimatorWeights"];
-        if (weightsToken is not null)
-        {
-            var weightsArray = weightsToken.ToObject<double[]>() ?? Array.Empty<double>();
-            if (weightsArray.Length > 0)
-            {
-                _estimatorWeights = new Vector<T>(weightsArray.Length);
-                for (int i = 0; i < weightsArray.Length; i++)
-                    _estimatorWeights[i] = NumOps.FromDouble(weightsArray[i]);
-            }
-        }
-
-        // Deserialize FeatureImportances
-        var fiToken = modelDataObj["FeatureImportances"];
-        if (fiToken is not null)
-        {
-            var fiArray = fiToken.ToObject<double[]>() ?? Array.Empty<double>();
-            if (fiArray.Length > 0)
-            {
-                FeatureImportances = new Vector<T>(fiArray.Length);
-                for (int i = 0; i < fiArray.Length; i++)
-                    FeatureImportances[i] = NumOps.FromDouble(fiArray[i]);
-            }
-        }
-
-        // Deserialize estimators
-        int estimatorCount = modelDataObj["EstimatorCount"]?.ToObject<int>() ?? 0;
-        Estimators.Clear();
-        for (int i = 0; i < estimatorCount; i++)
-        {
-            var estToken = modelDataObj[$"Estimator_{i}"]?.ToObject<string>();
-            if (estToken is null)
-            {
-                throw new InvalidOperationException(
-                    $"Deserialization failed: Estimator_{i} is missing (expected {estimatorCount} estimators).");
-            }
-            var estBytes = Convert.FromBase64String(estToken);
-            var tree = new DecisionTreeClassifier<T>();
-            tree.Deserialize(estBytes);
-            Estimators.Add(tree);
-        }
-    }
 }
diff --git a/src/Classification/Ensemble/EnsembleClassifierBase.cs b/src/Classification/Ensemble/EnsembleClassifierBase.cs
index 112e1554df..56aaf797e2 100644
--- a/src/Classification/Ensemble/EnsembleClassifierBase.cs
+++ b/src/Classification/Ensemble/EnsembleClassifierBase.cs
@@ -31,7 +31,7 @@ namespace AiDotNet.Classification.Ensemble;
 /// - Voting: Let classifiers vote on the answer
 /// </para>
 /// </remarks>
-public abstract class EnsembleClassifierBase<T> : ProbabilisticClassifierBase<T>
+public abstract partial class EnsembleClassifierBase<T> : ProbabilisticClassifierBase<T>
 {
     /// <summary>
     /// The base estimators in the ensemble.
diff --git a/src/Classification/Ensemble/ExtraTreesClassifier.cs b/src/Classification/Ensemble/ExtraTreesClassifier.cs
index d8b614c81b..2afc08fa32 100644
--- a/src/Classification/Ensemble/ExtraTreesClassifier.cs
+++ b/src/Classification/Ensemble/ExtraTreesClassifier.cs
@@ -276,79 +276,6 @@ private int CalculateTotalNodeCount()
         return total;
     }
 
-    /// <inheritdoc/>
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        return new ExtraTreesClassifier<T>(new ExtraTreesClassifierOptions<T>
-        {
-            NEstimators = Options.NEstimators,
-            MaxDepth = Options.MaxDepth,
-            MinSamplesSplit = Options.MinSamplesSplit,
-            MinSamplesLeaf = Options.MinSamplesLeaf,
-            MaxFeatures = Options.MaxFeatures,
-            // MaxFeatureCount takes PRECEDENCE over MaxFeatures when set, so omitting it here
-            // silently retrained the clone by the rule instead of the caller's explicit count.
-            MaxFeatureCount = Options.MaxFeatureCount,
-            Criterion = Options.Criterion,
-            Bootstrap = Options.Bootstrap,
-            Seed = Options.Seed,
-            MinImpurityDecrease = Options.MinImpurityDecrease
-        });
-    }
-
-    /// <inheritdoc/>
-    public override IFullModel<T, Matrix<T>, Vector<T>> Clone()
-    {
-        var clone = new ExtraTreesClassifier<T>(new ExtraTreesClassifierOptions<T>
-        {
-            NEstimators = Options.NEstimators,
-            MaxDepth = Options.MaxDepth,
-            MinSamplesSplit = Options.MinSamplesSplit,
-            MinSamplesLeaf = Options.MinSamplesLeaf,
-            MaxFeatures = Options.MaxFeatures,
-            // MaxFeatureCount takes PRECEDENCE over MaxFeatures when set, so omitting it here
-            // silently retrained the clone by the rule instead of the caller's explicit count.
-            MaxFeatureCount = Options.MaxFeatureCount,
-            Criterion = Options.Criterion,
-            Bootstrap = Options.Bootstrap,
-            Seed = Options.Seed,
-            MinImpurityDecrease = Options.MinImpurityDecrease
-        });
-
-        clone.NumFeatures = NumFeatures;
-        clone.NumClasses = NumClasses;
-        clone.TaskType = TaskType;
-
-        if (ClassLabels is not null)
-        {
-            clone.ClassLabels = new Vector<T>(ClassLabels.Length);
-            for (int i = 0; i < ClassLabels.Length; i++)
-            {
-                clone.ClassLabels[i] = ClassLabels[i];
-            }
-        }
-
-        if (FeatureImportances is not null)
-        {
-            clone.FeatureImportances = new Vector<T>(FeatureImportances.Length);
-            for (int i = 0; i < FeatureImportances.Length; i++)
-            {
-                clone.FeatureImportances[i] = FeatureImportances[i];
-            }
-        }
-
-        // Clone all estimators
-        foreach (var estimator in Estimators)
-        {
-            if (estimator is IFullModel<T, Matrix<T>, Vector<T>> fullModel)
-            {
-                clone.Estimators.Add((IClassifier<T>)fullModel.Clone());
-            }
-        }
-
-        return clone;
-    }
-
     /// <inheritdoc/>
     public override ModelMetadata<T> GetModelMetadata()
     {
@@ -362,104 +289,4 @@ public override ModelMetadata<T> GetModelMetadata()
         metadata.AdditionalInfo["TotalLeaves"] = LeafCount;
         return metadata;
     }
-
-    /// <inheritdoc/>
-    public override byte[] Serialize()
-    {
-        var modelData = new Dictionary<string, object>
-        {
-            { "NumClasses", NumClasses },
-            { "NumFeatures", NumFeatures },
-            { "TaskType", (int)TaskType },
-            { "ClassLabels", ClassLabels?.ToArray() ?? Array.Empty<T>() },
-            { "RegularizationOptions", Regularization.GetOptions() }
-        };
-
-        // Serialize FeatureImportances
-        if (FeatureImportances is not null)
-        {
-            var fiArray = new double[FeatureImportances.Length];
-            for (int i = 0; i < FeatureImportances.Length; i++)
-                fiArray[i] = NumOps.ToDouble(FeatureImportances[i]);
-            modelData["FeatureImportances"] = fiArray;
-        }
-
-        // Serialize each estimator as base64
-        int serializedCount = 0;
-        for (int i = 0; i < Estimators.Count; i++)
-        {
-            if (Estimators[i] is IFullModel<T, Matrix<T>, Vector<T>> fullModel)
-            {
-                modelData[$"Estimator_{serializedCount}"] = Convert.ToBase64String(fullModel.Serialize());
-                serializedCount++;
-            }
-        }
-        modelData["EstimatorCount"] = serializedCount;
-
-        var modelMetadata = GetModelMetadata();
-        modelMetadata.ModelData = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(modelData));
-        return Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(modelMetadata));
-    }
-
-    /// <inheritdoc/>
-    public override void Deserialize(byte[] modelData)
-    {
-        var jsonString = Encoding.UTF8.GetString(modelData);
-        var modelMetadata = JsonConvert.DeserializeObject<ModelMetadata<T>>(jsonString);
-
-        if (modelMetadata == null || modelMetadata.ModelData == null)
-            throw new InvalidOperationException("Deserialization failed: The model data is invalid or corrupted.");
-
-        var modelDataString = Encoding.UTF8.GetString(modelMetadata.ModelData);
-        var modelDataObj = JsonConvert.DeserializeObject<JObject>(modelDataString);
-
-        if (modelDataObj == null)
-            throw new InvalidOperationException("Deserialization failed: The model data is invalid or corrupted.");
-
-        NumClasses = modelDataObj["NumClasses"]?.ToObject<int>() ?? 0;
-        NumFeatures = modelDataObj["NumFeatures"]?.ToObject<int>() ?? 0;
-        TaskType = (ClassificationTaskType)(modelDataObj["TaskType"]?.ToObject<int>() ?? 0);
-
-        var classLabelsToken = modelDataObj["ClassLabels"];
-        if (classLabelsToken is not null)
-        {
-            var classLabelsAsDoubles = classLabelsToken.ToObject<double[]>() ?? Array.Empty<double>();
-            if (classLabelsAsDoubles.Length > 0)
-            {
-                ClassLabels = new Vector<T>(classLabelsAsDoubles.Length);
-                for (int i = 0; i < classLabelsAsDoubles.Length; i++)
-                    ClassLabels[i] = NumOps.FromDouble(classLabelsAsDoubles[i]);
-            }
-        }
-
-        // Deserialize FeatureImportances
-        var fiToken = modelDataObj["FeatureImportances"];
-        if (fiToken is not null)
-        {
-            var fiArray = fiToken.ToObject<double[]>() ?? Array.Empty<double>();
-            if (fiArray.Length > 0)
-            {
-                FeatureImportances = new Vector<T>(fiArray.Length);
-                for (int i = 0; i < fiArray.Length; i++)
-                    FeatureImportances[i] = NumOps.FromDouble(fiArray[i]);
-            }
-        }
-
-        // Deserialize estimators
-        int estimatorCount = modelDataObj["EstimatorCount"]?.ToObject<int>() ?? 0;
-        Estimators.Clear();
-        for (int i = 0; i < estimatorCount; i++)
-        {
-            var estToken = modelDataObj[$"Estimator_{i}"]?.ToObject<string>();
-            if (estToken is null)
-            {
-                throw new InvalidOperationException(
-                    $"Deserialization failed: Estimator_{i} is missing (expected {estimatorCount} estimators).");
-            }
-            var estBytes = Convert.FromBase64String(estToken);
-            var tree = new DecisionTreeClassifier<T>();
-            tree.Deserialize(estBytes);
-            Estimators.Add(tree);
-        }
-    }
 }
diff --git a/src/Classification/Ensemble/GradientBoostingClassifier.cs b/src/Classification/Ensemble/GradientBoostingClassifier.cs
index 91772a0ddd..e67d0a6c2d 100644
--- a/src/Classification/Ensemble/GradientBoostingClassifier.cs
+++ b/src/Classification/Ensemble/GradientBoostingClassifier.cs
@@ -74,7 +74,7 @@ namespace AiDotNet.Classification.Ensemble;
     "https://doi.org/10.1214/aos/1013203451",
     Year = 2001,
     Authors = "Jerome H. Friedman")]
-public class GradientBoostingClassifier<T> : EnsembleClassifierBase<T>, ITreeBasedClassifier<T>
+public partial class GradientBoostingClassifier<T> : EnsembleClassifierBase<T>, ITreeBasedClassifier<T>
 {
     /// <summary>
     /// Gets the Gradient Boosting specific options.
@@ -458,84 +458,6 @@ private int CalculateTotalNodeCount()
         return total;
     }
 
-    /// <inheritdoc/>
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        return new GradientBoostingClassifier<T>(new GradientBoostingClassifierOptions<T>
-        {
-            NEstimators = Options.NEstimators,
-            LearningRate = Options.LearningRate,
-            MaxDepth = Options.MaxDepth,
-            MinSamplesSplit = Options.MinSamplesSplit,
-            MinSamplesLeaf = Options.MinSamplesLeaf,
-            Subsample = Options.Subsample,
-            MaxFeatures = Options.MaxFeatures,
-            Loss = Options.Loss,
-            Seed = Options.Seed,
-            MinImpurityDecrease = Options.MinImpurityDecrease
-        });
-    }
-
-    /// <inheritdoc/>
-    public override IFullModel<T, Matrix<T>, Vector<T>> Clone()
-    {
-        var clone = new GradientBoostingClassifier<T>(new GradientBoostingClassifierOptions<T>
-        {
-            NEstimators = Options.NEstimators,
-            LearningRate = Options.LearningRate,
-            MaxDepth = Options.MaxDepth,
-            MinSamplesSplit = Options.MinSamplesSplit,
-            MinSamplesLeaf = Options.MinSamplesLeaf,
-            Subsample = Options.Subsample,
-            MaxFeatures = Options.MaxFeatures,
-            Loss = Options.Loss,
-            Seed = Options.Seed,
-            MinImpurityDecrease = Options.MinImpurityDecrease
-        });
-
-        clone.NumFeatures = NumFeatures;
-        clone.NumClasses = NumClasses;
-        clone.TaskType = TaskType;
-        clone._initPrediction = _initPrediction;
-
-        if (ClassLabels is not null)
-        {
-            clone.ClassLabels = new Vector<T>(ClassLabels.Length);
-            for (int i = 0; i < ClassLabels.Length; i++)
-            {
-                clone.ClassLabels[i] = ClassLabels[i];
-            }
-        }
-
-        if (FeatureImportances is not null)
-        {
-            clone.FeatureImportances = new Vector<T>(FeatureImportances.Length);
-            for (int i = 0; i < FeatureImportances.Length; i++)
-            {
-                clone.FeatureImportances[i] = FeatureImportances[i];
-            }
-        }
-
-        // Clone leaf residual means
-        foreach (var means in _leafResidualMeans)
-        {
-            var clonedMeans = new T[means.Length];
-            Array.Copy(means, clonedMeans, means.Length);
-            clone._leafResidualMeans.Add(clonedMeans);
-        }
-
-        // Clone all estimators
-        foreach (var estimator in Estimators)
-        {
-            if (estimator is IFullModel<T, Matrix<T>, Vector<T>> fullModel)
-            {
-                clone.Estimators.Add((IClassifier<T>)fullModel.Clone());
-            }
-        }
-
-        return clone;
-    }
-
     /// <inheritdoc/>
     public override ModelMetadata<T> GetModelMetadata()
     {
@@ -549,167 +471,4 @@ public override ModelMetadata<T> GetModelMetadata()
         metadata.AdditionalInfo["TotalLeaves"] = LeafCount;
         return metadata;
     }
-
-    /// <inheritdoc/>
-    public override byte[] Serialize()
-    {
-        var modelData = new Dictionary<string, object>
-        {
-            { "NumClasses", NumClasses },
-            { "NumFeatures", NumFeatures },
-            { "TaskType", (int)TaskType },
-            { "ClassLabels", ClassLabels?.ToArray() ?? Array.Empty<T>() },
-            { "InitPrediction", NumOps.ToDouble(_initPrediction) }
-        };
-
-        // Serialize regularization configuration
-        if (Regularization is not null)
-        {
-            var regOptions = Regularization.GetOptions();
-            modelData["RegularizationType"] = (int)regOptions.Type;
-            modelData["RegularizationStrength"] = regOptions.Strength;
-            modelData["RegularizationL1Ratio"] = regOptions.L1Ratio;
-        }
-
-        // Serialize FeatureImportances
-        if (FeatureImportances is not null)
-        {
-            var fiArray = new double[FeatureImportances.Length];
-            for (int i = 0; i < FeatureImportances.Length; i++)
-                fiArray[i] = NumOps.ToDouble(FeatureImportances[i]);
-            modelData["FeatureImportances"] = fiArray;
-        }
-
-        // Serialize leaf residual means
-        modelData["LeafResidualMeansCount"] = _leafResidualMeans.Count;
-        for (int i = 0; i < _leafResidualMeans.Count; i++)
-        {
-            var means = _leafResidualMeans[i];
-            var meansDouble = new double[means.Length];
-            for (int j = 0; j < means.Length; j++)
-                meansDouble[j] = NumOps.ToDouble(means[j]);
-            modelData[$"LeafResidualMeans_{i}"] = meansDouble;
-        }
-
-        // Serialize each estimator as base64
-        modelData["EstimatorCount"] = Estimators.Count;
-        for (int i = 0; i < Estimators.Count; i++)
-        {
-            if (Estimators[i] is IFullModel<T, Matrix<T>, Vector<T>> fullModel)
-            {
-                modelData[$"Estimator_{i}"] = Convert.ToBase64String(fullModel.Serialize());
-            }
-        }
-
-        var modelMetadata = GetModelMetadata();
-        modelMetadata.ModelData = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(modelData));
-        return Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(modelMetadata));
-    }
-
-    /// <inheritdoc/>
-    public override void Deserialize(byte[] modelData)
-    {
-        var jsonString = Encoding.UTF8.GetString(modelData);
-        var modelMetadata = JsonConvert.DeserializeObject<ModelMetadata<T>>(jsonString);
-
-        if (modelMetadata == null || modelMetadata.ModelData == null)
-            throw new InvalidOperationException("Deserialization failed: The model data is invalid or corrupted.");
-
-        var modelDataString = Encoding.UTF8.GetString(modelMetadata.ModelData);
-        var modelDataObj = JsonConvert.DeserializeObject<JObject>(modelDataString);
-
-        if (modelDataObj == null)
-            throw new InvalidOperationException("Deserialization failed: The model data is invalid or corrupted.");
-
-        NumClasses = modelDataObj["NumClasses"]?.ToObject<int>() ?? 0;
-        NumFeatures = modelDataObj["NumFeatures"]?.ToObject<int>() ?? 0;
-        TaskType = (ClassificationTaskType)(modelDataObj["TaskType"]?.ToObject<int>() ?? 0);
-
-        var classLabelsToken = modelDataObj["ClassLabels"];
-        if (classLabelsToken is not null)
-        {
-            var classLabelsAsDoubles = classLabelsToken.ToObject<double[]>() ?? Array.Empty<double>();
-            if (classLabelsAsDoubles.Length > 0)
-            {
-                ClassLabels = new Vector<T>(classLabelsAsDoubles.Length);
-                for (int i = 0; i < classLabelsAsDoubles.Length; i++)
-                    ClassLabels[i] = NumOps.FromDouble(classLabelsAsDoubles[i]);
-            }
-        }
-
-        _initPrediction = NumOps.FromDouble(modelDataObj["InitPrediction"]?.ToObject<double>() ?? 0.0);
-
-        // Deserialize FeatureImportances
-        var fiToken = modelDataObj["FeatureImportances"];
-        if (fiToken is not null)
-        {
-            var fiArray = fiToken.ToObject<double[]>() ?? Array.Empty<double>();
-            if (fiArray.Length > 0)
-            {
-                FeatureImportances = new Vector<T>(fiArray.Length);
-                for (int i = 0; i < fiArray.Length; i++)
-                    FeatureImportances[i] = NumOps.FromDouble(fiArray[i]);
-            }
-        }
-
-        // Deserialize leaf residual means
-        _leafResidualMeans.Clear();
-        int lrmCount = modelDataObj["LeafResidualMeansCount"]?.ToObject<int>() ?? 0;
-        for (int i = 0; i < lrmCount; i++)
-        {
-            var lrmToken = modelDataObj[$"LeafResidualMeans_{i}"];
-            if (lrmToken is null)
-            {
-                throw new InvalidOperationException(
-                    $"Deserialization failed: LeafResidualMeans_{i} is missing (expected {lrmCount} entries).");
-            }
-            var meansDouble = lrmToken.ToObject<double[]>() ?? Array.Empty<double>();
-            var means = new T[meansDouble.Length];
-            for (int j = 0; j < meansDouble.Length; j++)
-                means[j] = NumOps.FromDouble(meansDouble[j]);
-            _leafResidualMeans.Add(means);
-        }
-
-        // Deserialize estimators
-        int estimatorCount = modelDataObj["EstimatorCount"]?.ToObject<int>() ?? 0;
-        Estimators.Clear();
-        for (int i = 0; i < estimatorCount; i++)
-        {
-            var estToken = modelDataObj[$"Estimator_{i}"]?.ToObject<string>();
-            if (estToken is null)
-            {
-                throw new InvalidOperationException(
-                    $"Deserialization failed: Estimator_{i} is missing (expected {estimatorCount} estimators).");
-            }
-            var estBytes = Convert.FromBase64String(estToken);
-            var tree = new DecisionTreeClassifier<T>();
-            tree.Deserialize(estBytes);
-            Estimators.Add(tree);
-        }
-
-        // Restore regularization configuration
-        var regType = modelDataObj["RegularizationType"]?.ToObject<int>();
-        if (regType.HasValue)
-        {
-            var regOptions = new RegularizationOptions
-            {
-                Type = (RegularizationType)regType.Value,
-                Strength = modelDataObj["RegularizationStrength"]?.ToObject<double>() ?? 0.0,
-                L1Ratio = modelDataObj["RegularizationL1Ratio"]?.ToObject<double>() ?? 0.5
-            };
-
-
-#pragma warning disable CS8601 // Regularization can be null for RegularizationType.None
-            Regularization = (RegularizationType)regType.Value switch
-            {
-
-                RegularizationType.L1 => new L1Regularization<T, Matrix<T>, Vector<T>>(regOptions),
-                RegularizationType.L2 => new L2Regularization<T, Matrix<T>, Vector<T>>(regOptions),
-                RegularizationType.ElasticNet => new ElasticNetRegularization<T, Matrix<T>, Vector<T>>(regOptions),
-                RegularizationType.None => null,
-                _ => null
-            };
-#pragma warning restore CS8601
-        }
-    }
 }
diff --git a/src/Classification/Ensemble/RandomForestClassifier.cs b/src/Classification/Ensemble/RandomForestClassifier.cs
index f1268f5586..11874f8e55 100644
--- a/src/Classification/Ensemble/RandomForestClassifier.cs
+++ b/src/Classification/Ensemble/RandomForestClassifier.cs
@@ -71,7 +71,7 @@ namespace AiDotNet.Classification.Ensemble;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
 [ResearchPaper("Random Forests", "https://doi.org/10.1023/A:1010933404324", Year = 2001, Authors = "Leo Breiman")]
-public class RandomForestClassifier<T> : EnsembleClassifierBase<T>, ITreeBasedClassifier<T>
+public partial class RandomForestClassifier<T> : EnsembleClassifierBase<T>, ITreeBasedClassifier<T>
 {
     /// <summary>
     /// Gets the Random Forest specific options.
@@ -385,85 +385,6 @@ private int CalculateTotalNodeCount()
         return total;
     }
 
-    /// <inheritdoc/>
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        return new RandomForestClassifier<T>(new RandomForestClassifierOptions<T>
-        {
-            NEstimators = Options.NEstimators,
-            MaxDepth = Options.MaxDepth,
-            MinSamplesSplit = Options.MinSamplesSplit,
-            MinSamplesLeaf = Options.MinSamplesLeaf,
-            MaxFeatures = Options.MaxFeatures,
-            // MaxFeatureCount takes PRECEDENCE over MaxFeatures when set, so omitting it here
-            // silently retrained the clone by the rule instead of the caller's explicit count.
-            MaxFeatureCount = Options.MaxFeatureCount,
-            Criterion = Options.Criterion,
-            Bootstrap = Options.Bootstrap,
-            OobScore = Options.OobScore,
-            NJobs = Options.NJobs,
-            Seed = Options.Seed,
-            MinImpurityDecrease = Options.MinImpurityDecrease
-        });
-    }
-
-    /// <inheritdoc/>
-    public override IFullModel<T, Matrix<T>, Vector<T>> Clone()
-    {
-        var clone = new RandomForestClassifier<T>(new RandomForestClassifierOptions<T>
-        {
-            NEstimators = Options.NEstimators,
-            MaxDepth = Options.MaxDepth,
-            MinSamplesSplit = Options.MinSamplesSplit,
-            MinSamplesLeaf = Options.MinSamplesLeaf,
-            MaxFeatures = Options.MaxFeatures,
-            // MaxFeatureCount takes PRECEDENCE over MaxFeatures when set, so omitting it here
-            // silently retrained the clone by the rule instead of the caller's explicit count.
-            MaxFeatureCount = Options.MaxFeatureCount,
-            Criterion = Options.Criterion,
-            Bootstrap = Options.Bootstrap,
-            OobScore = Options.OobScore,
-            NJobs = Options.NJobs,
-            Seed = Options.Seed,
-            MinImpurityDecrease = Options.MinImpurityDecrease
-        });
-
-        clone.NumFeatures = NumFeatures;
-        clone.NumClasses = NumClasses;
-        clone.TaskType = TaskType;
-        clone.OobScore_ = OobScore_;
-
-        if (ClassLabels != null)
-        {
-            clone.ClassLabels = new Vector<T>(ClassLabels.Length);
-            for (int i = 0; i < ClassLabels.Length; i++)
-            {
-                clone.ClassLabels[i] = ClassLabels[i];
-            }
-        }
-
-        if (FeatureImportances != null)
-        {
-            clone.FeatureImportances = new Vector<T>(FeatureImportances.Length);
-            for (int i = 0; i < FeatureImportances.Length; i++)
-            {
-                clone.FeatureImportances[i] = FeatureImportances[i];
-            }
-        }
-
-        // Clone all estimators
-        foreach (var estimator in Estimators)
-        {
-            // No type test: IClassifier<T> derives from IFullModel<T, Matrix<T>, Vector<T>>, so the
-            // check was always true and its else-branch unreachable. Testing it suggested some
-            // estimator might not be cloneable and be skipped -- which would drop trees from the
-            // forest silently. Every estimator is cloned.
-            clone.Estimators.Add((IClassifier<T>)estimator.Clone());
-        }
-
-        return clone;
-    }
-
     /// <inheritdoc/>
     public override ModelMetadata<T> GetModelMetadata()
     {
@@ -481,105 +402,4 @@ public override ModelMetadata<T> GetModelMetadata()
         metadata.AdditionalInfo["TotalLeaves"] = LeafCount;
         return metadata;
     }
-
-    /// <inheritdoc/>
-    public override byte[] Serialize()
-    {
-        var modelData = new Dictionary<string, object>
-        {
-            { "NumClasses", NumClasses },
-            { "NumFeatures", NumFeatures },
-            { "TaskType", (int)TaskType },
-            { "ClassLabels", ClassLabels?.ToArray() ?? Array.Empty<T>() },
-            { "RegularizationOptions", Regularization.GetOptions() },
-            { "OobScore_", OobScore_ }
-        };
-
-        // Serialize FeatureImportances
-        if (FeatureImportances is not null)
-        {
-            var fiArray = new double[FeatureImportances.Length];
-            for (int i = 0; i < FeatureImportances.Length; i++)
-                fiArray[i] = NumOps.ToDouble(FeatureImportances[i]);
-            modelData["FeatureImportances"] = fiArray;
-        }
-
-        // Serialize each estimator (DecisionTreeClassifier) as base64
-        modelData["EstimatorCount"] = Estimators.Count;
-        for (int i = 0; i < Estimators.Count; i++)
-        {
-            if (Estimators[i] is IFullModel<T, Matrix<T>, Vector<T>> fullModel)
-            {
-                modelData[$"Estimator_{i}"] = Convert.ToBase64String(fullModel.Serialize());
-            }
-        }
-
-        var modelMetadata = GetModelMetadata();
-        modelMetadata.ModelData = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(modelData));
-        return Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(modelMetadata));
-    }
-
-    /// <inheritdoc/>
-    public override void Deserialize(byte[] modelData)
-    {
-        var jsonString = Encoding.UTF8.GetString(modelData);
-        var modelMetadata = JsonConvert.DeserializeObject<ModelMetadata<T>>(jsonString);
-
-        if (modelMetadata == null || modelMetadata.ModelData == null)
-            throw new InvalidOperationException("Deserialization failed: The model data is invalid or corrupted.");
-
-        var modelDataString = Encoding.UTF8.GetString(modelMetadata.ModelData);
-        var modelDataObj = JsonConvert.DeserializeObject<JObject>(modelDataString);
-
-        if (modelDataObj == null)
-            throw new InvalidOperationException("Deserialization failed: The model data is invalid or corrupted.");
-
-        NumClasses = modelDataObj["NumClasses"]?.ToObject<int>() ?? 0;
-        NumFeatures = modelDataObj["NumFeatures"]?.ToObject<int>() ?? 0;
-        TaskType = (ClassificationTaskType)(modelDataObj["TaskType"]?.ToObject<int>() ?? 0);
-
-        var classLabelsToken = modelDataObj["ClassLabels"];
-        if (classLabelsToken is not null)
-        {
-            var classLabelsAsDoubles = classLabelsToken.ToObject<double[]>() ?? Array.Empty<double>();
-            if (classLabelsAsDoubles.Length > 0)
-            {
-                ClassLabels = new Vector<T>(classLabelsAsDoubles.Length);
-                for (int i = 0; i < classLabelsAsDoubles.Length; i++)
-                    ClassLabels[i] = NumOps.FromDouble(classLabelsAsDoubles[i]);
-            }
-        }
-
-        OobScore_ = modelDataObj["OobScore_"]?.ToObject<double>() ?? 0.0;
-
-        // Deserialize FeatureImportances
-        var fiToken = modelDataObj["FeatureImportances"];
-        if (fiToken is not null)
-        {
-            var fiArray = fiToken.ToObject<double[]>() ?? Array.Empty<double>();
-            if (fiArray.Length > 0)
-            {
-                FeatureImportances = new Vector<T>(fiArray.Length);
-                for (int i = 0; i < fiArray.Length; i++)
-                    FeatureImportances[i] = NumOps.FromDouble(fiArray[i]);
-            }
-        }
-
-        // Deserialize estimators
-        int estimatorCount = modelDataObj["EstimatorCount"]?.ToObject<int>() ?? 0;
-        Estimators.Clear();
-        for (int i = 0; i < estimatorCount; i++)
-        {
-            var estToken = modelDataObj[$"Estimator_{i}"]?.ToObject<string>();
-            if (estToken is null)
-            {
-                throw new InvalidOperationException(
-                    $"Deserialization failed: Estimator_{i} is missing (expected {estimatorCount} estimators).");
-            }
-            var estBytes = Convert.FromBase64String(estToken);
-            var tree = new DecisionTreeClassifier<T>();
-            tree.Deserialize(estBytes);
-            Estimators.Add(tree);
-        }
-    }
 }
diff --git a/src/Classification/ImbalancedEnsemble/BalancedBaggingClassifier.cs b/src/Classification/ImbalancedEnsemble/BalancedBaggingClassifier.cs
index 4a68fd2d10..5e8b8d1b2d 100644
--- a/src/Classification/ImbalancedEnsemble/BalancedBaggingClassifier.cs
+++ b/src/Classification/ImbalancedEnsemble/BalancedBaggingClassifier.cs
@@ -76,7 +76,7 @@ namespace AiDotNet.Classification.ImbalancedEnsemble;
     "https://doi.org/10.1007/s10115-008-0180-z",
     Year = 2009,
     Authors = "Shohei Hido, Hisashi Kashima")]
-public class BalancedBaggingClassifier<T> : ClassifierBase<T>
+public partial class BalancedBaggingClassifier<T> : ClassifierBase<T>
 {
 
     // Returned _baseClassifiers.Count -- the NUMBER of estimators, not a parameter. No restore
@@ -565,19 +565,6 @@ public override IFullModel<T, Matrix<T>, Vector<T>> WithParameters(Vector<T> par
             _minSamplesLeaf, _samplingRatio, _bootstrapMinority);
     }
 
-    /// <summary>
-    /// Creates a new instance of this model type.
-    /// </summary>
-    /// <returns>New instance with same hyperparameters.</returns>
-    /// <remarks>
-    /// <para><b>For Beginners:</b> Creates an untrained copy with the same settings.</para>
-    /// </remarks>
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        return new BalancedBaggingClassifier<T>(_nEstimators, _maxDepth, _minSamplesSplit,
-            _minSamplesLeaf, _samplingRatio, _bootstrapMinority);
-    }
-
     /// <summary>
     /// Gets feature importance based on split usage.
     /// </summary>
@@ -626,72 +613,6 @@ private void CountFeatureUsage(DecisionTreeNode node, double[] importance)
         CountFeatureUsage(node.RightChild, importance);
     }
 
-    /// <summary>
-    /// Serializes the trained model state including all base classifier trees.
-    /// </summary>
-    public override byte[] Serialize()
-    {
-        var modelData = new Dictionary<string, object>
-        {
-            { "NumClasses", NumClasses },
-            { "NumFeatures", NumFeatures },
-            { "TaskType", (int)TaskType },
-            { "ClassLabels", ClassLabels?.ToArray() ?? Array.Empty<T>() },
-            { "ClassifierCount", _baseClassifiers.Count }
-        };
-
-        for (int i = 0; i < _baseClassifiers.Count; i++)
-        {
-            modelData[$"Classifier_{i}"] = SerializeTreeNode(_baseClassifiers[i]);
-        }
-
-        var modelMetadata = GetModelMetadata();
-        modelMetadata.ModelData = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(modelData));
-        return Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(modelMetadata));
-    }
-
-    /// <summary>
-    /// Deserializes the trained model state including all base classifier trees.
-    /// </summary>
-    public override void Deserialize(byte[] modelData)
-    {
-        var jsonString = Encoding.UTF8.GetString(modelData);
-        var modelMetadata = JsonConvert.DeserializeObject<ModelMetadata<T>>(jsonString);
-        if (modelMetadata?.ModelData is null)
-            throw new InvalidOperationException("Deserialization failed: invalid model data.");
-
-        var dataString = Encoding.UTF8.GetString(modelMetadata.ModelData);
-        var dataObj = JsonConvert.DeserializeObject<JObject>(dataString);
-        if (dataObj is null)
-            throw new InvalidOperationException("Deserialization failed: invalid model data.");
-
-        NumClasses = dataObj["NumClasses"]?.ToObject<int>() ?? 0;
-        NumFeatures = dataObj["NumFeatures"]?.ToObject<int>() ?? 0;
-        TaskType = (ClassificationTaskType)(dataObj["TaskType"]?.ToObject<int>() ?? 0);
-
-        var classLabelsToken = dataObj["ClassLabels"];
-        if (classLabelsToken is not null)
-        {
-            var arr = classLabelsToken.ToObject<double[]>() ?? Array.Empty<double>();
-            if (arr.Length > 0)
-            {
-                ClassLabels = new Vector<T>(arr.Length);
-                for (int i = 0; i < arr.Length; i++)
-                    ClassLabels[i] = NumOps.FromDouble(arr[i]);
-            }
-        }
-
-        _baseClassifiers.Clear();
-        int count = dataObj["ClassifierCount"]?.ToObject<int>() ?? 0;
-        for (int i = 0; i < count; i++)
-        {
-            if (dataObj[$"Classifier_{i}"] is JObject jObj)
-            {
-                _baseClassifiers.Add(DeserializeTreeNode(jObj));
-            }
-        }
-    }
-
     private static Dictionary<string, object?> SerializeTreeNode(DecisionTreeNode node)
     {
         var dict = new Dictionary<string, object?>
diff --git a/src/Classification/ImbalancedEnsemble/BalancedRandomForestClassifier.cs b/src/Classification/ImbalancedEnsemble/BalancedRandomForestClassifier.cs
index b5cae856f0..bfd49c4815 100644
--- a/src/Classification/ImbalancedEnsemble/BalancedRandomForestClassifier.cs
+++ b/src/Classification/ImbalancedEnsemble/BalancedRandomForestClassifier.cs
@@ -88,7 +88,7 @@ namespace AiDotNet.Classification.ImbalancedEnsemble;
     "https://statistics.berkeley.edu/sites/default/files/tech-reports/666.pdf",
     Year = 2004,
     Authors = "Chao Chen, Andy Liaw, Leo Breiman")]
-public class BalancedRandomForestClassifier<T> : ClassifierBase<T>
+public partial class BalancedRandomForestClassifier<T> : ClassifierBase<T>
 {
 
     // Returned _trees.Count. Same as BalancedBaggingClassifier: a count is not a weight.
@@ -609,19 +609,6 @@ public override IFullModel<T, Matrix<T>, Vector<T>> WithParameters(Vector<T> par
             _minSamplesSplit, _minSamplesLeaf, _samplingStrategy, _bootstrap);
     }
 
-    /// <summary>
-    /// Creates a new instance of this model type.
-    /// </summary>
-    /// <returns>New instance with same hyperparameters.</returns>
-    /// <remarks>
-    /// <para><b>For Beginners:</b> Creates an untrained copy with the same settings.</para>
-    /// </remarks>
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        return new BalancedRandomForestClassifier<T>(_nEstimators, _maxDepth, _maxFeatures,
-            _minSamplesSplit, _minSamplesLeaf, _samplingStrategy, _bootstrap);
-    }
-
     /// <summary>
     /// Gets feature importance based on split usage.
     /// </summary>
@@ -674,72 +661,6 @@ private void CountFeatureUsage(DecisionTreeNode node, double[] importance)
         CountFeatureUsage(node.RightChild, importance);
     }
 
-    /// <summary>
-    /// Serializes the trained model state including all decision trees.
-    /// </summary>
-    public override byte[] Serialize()
-    {
-        var modelData = new Dictionary<string, object>
-        {
-            { "NumClasses", NumClasses },
-            { "NumFeatures", NumFeatures },
-            { "TaskType", (int)TaskType },
-            { "ClassLabels", ClassLabels?.ToArray() ?? Array.Empty<T>() },
-            { "TreeCount", _trees.Count }
-        };
-
-        for (int i = 0; i < _trees.Count; i++)
-        {
-            modelData[$"Tree_{i}"] = SerializeTreeNode(_trees[i]);
-        }
-
-        var modelMetadata = GetModelMetadata();
-        modelMetadata.ModelData = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(modelData));
-        return Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(modelMetadata));
-    }
-
-    /// <summary>
-    /// Deserializes the trained model state including all decision trees.
-    /// </summary>
-    public override void Deserialize(byte[] modelData)
-    {
-        var jsonString = Encoding.UTF8.GetString(modelData);
-        var modelMetadata = JsonConvert.DeserializeObject<ModelMetadata<T>>(jsonString);
-        if (modelMetadata?.ModelData is null)
-            throw new InvalidOperationException("Deserialization failed: invalid model data.");
-
-        var dataString = Encoding.UTF8.GetString(modelMetadata.ModelData);
-        var dataObj = JsonConvert.DeserializeObject<JObject>(dataString);
-        if (dataObj is null)
-            throw new InvalidOperationException("Deserialization failed: invalid model data.");
-
-        NumClasses = dataObj["NumClasses"]?.ToObject<int>() ?? 0;
-        NumFeatures = dataObj["NumFeatures"]?.ToObject<int>() ?? 0;
-        TaskType = (ClassificationTaskType)(dataObj["TaskType"]?.ToObject<int>() ?? 0);
-
-        var classLabelsToken = dataObj["ClassLabels"];
-        if (classLabelsToken is not null)
-        {
-            var arr = classLabelsToken.ToObject<double[]>() ?? Array.Empty<double>();
-            if (arr.Length > 0)
-            {
-                ClassLabels = new Vector<T>(arr.Length);
-                for (int i = 0; i < arr.Length; i++)
-                    ClassLabels[i] = NumOps.FromDouble(arr[i]);
-            }
-        }
-
-        _trees.Clear();
-        int treeCount = dataObj["TreeCount"]?.ToObject<int>() ?? 0;
-        for (int i = 0; i < treeCount; i++)
-        {
-            if (dataObj[$"Tree_{i}"] is JObject jObj)
-            {
-                _trees.Add(DeserializeTreeNode(jObj));
-            }
-        }
-    }
-
     private static Dictionary<string, object?> SerializeTreeNode(DecisionTreeNode node)
     {
         var dict = new Dictionary<string, object?>
diff --git a/src/Classification/ImbalancedEnsemble/EasyEnsembleClassifier.cs b/src/Classification/ImbalancedEnsemble/EasyEnsembleClassifier.cs
index e1cdb3da9b..9f02fc48f9 100644
--- a/src/Classification/ImbalancedEnsemble/EasyEnsembleClassifier.cs
+++ b/src/Classification/ImbalancedEnsemble/EasyEnsembleClassifier.cs
@@ -67,7 +67,7 @@ namespace AiDotNet.Classification.ImbalancedEnsemble;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
 [ResearchPaper("Exploratory Undersampling for Class-Imbalance Learning", "https://doi.org/10.1109/TSMCB.2008.2007853", Year = 2009, Authors = "Xu-Ying Liu, Jianxin Wu, Zhi-Hua Zhou")]
-public class EasyEnsembleClassifier<T> : ClassifierBase<T>
+public partial class EasyEnsembleClassifier<T> : ClassifierBase<T>
 {
 
     // Returned _subClassifiers.Count. Same as its two siblings.
@@ -669,19 +669,6 @@ public override IFullModel<T, Matrix<T>, Vector<T>> WithParameters(Vector<T> par
             _learningRate, _samplingStrategy, _softVoting);
     }
 
-    /// <summary>
-    /// Creates a new instance of this model type.
-    /// </summary>
-    /// <returns>New instance with same hyperparameters.</returns>
-    /// <remarks>
-    /// <para><b>For Beginners:</b> Creates an untrained copy with the same settings.</para>
-    /// </remarks>
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        return new EasyEnsembleClassifier<T>(_nSubsets, _nEstimatorsPerSubset, _maxDepth,
-            _learningRate, _samplingStrategy, _softVoting);
-    }
-
     /// <summary>
     /// Gets feature importance based on weak learner usage.
     /// </summary>
@@ -718,114 +705,6 @@ public override Dictionary<string, T> GetFeatureImportance()
         return result;
     }
 
-    /// <summary>
-    /// Serializes the trained model state including all AdaBoost sub-classifiers.
-    /// </summary>
-    public override byte[] Serialize()
-    {
-        var modelData = new Dictionary<string, object>
-        {
-            { "NumClasses", NumClasses },
-            { "NumFeatures", NumFeatures },
-            { "TaskType", (int)TaskType },
-            { "ClassLabels", ClassLabels?.ToArray() ?? Array.Empty<T>() },
-            { "SubClassifierCount", _subClassifiers.Count },
-            { "SoftVoting", _softVoting }
-        };
-
-        for (int i = 0; i < _subClassifiers.Count; i++)
-        {
-            var sub = _subClassifiers[i];
-            var subDict = new Dictionary<string, object>
-            {
-                { "Alphas", sub.Alphas.ToArray() },
-                { "LearnerCount", sub.WeakLearners.Count }
-            };
-
-            for (int j = 0; j < sub.WeakLearners.Count; j++)
-            {
-                var wl = sub.WeakLearners[j];
-                subDict[$"Learner_{j}"] = new Dictionary<string, object>
-                {
-                    { "FeatureIndex", wl.FeatureIndex },
-                    { "Threshold", wl.Threshold },
-                    { "Polarity", wl.Polarity }
-                };
-            }
-
-            modelData[$"Sub_{i}"] = subDict;
-        }
-
-        var modelMetadata = GetModelMetadata();
-        modelMetadata.ModelData = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(modelData));
-        return Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(modelMetadata));
-    }
-
-    /// <summary>
-    /// Deserializes the trained model state including all AdaBoost sub-classifiers.
-    /// </summary>
-    public override void Deserialize(byte[] modelData)
-    {
-        var jsonString = Encoding.UTF8.GetString(modelData);
-        var modelMetadata = JsonConvert.DeserializeObject<ModelMetadata<T>>(jsonString);
-        if (modelMetadata?.ModelData is null)
-            throw new InvalidOperationException("Deserialization failed: invalid model data.");
-
-        var dataString = Encoding.UTF8.GetString(modelMetadata.ModelData);
-        var dataObj = JsonConvert.DeserializeObject<JObject>(dataString);
-        if (dataObj is null)
-            throw new InvalidOperationException("Deserialization failed: invalid model data.");
-
-        NumClasses = dataObj["NumClasses"]?.ToObject<int>() ?? 0;
-        NumFeatures = dataObj["NumFeatures"]?.ToObject<int>() ?? 0;
-        TaskType = (ClassificationTaskType)(dataObj["TaskType"]?.ToObject<int>() ?? 0);
-        _softVoting = dataObj["SoftVoting"]?.ToObject<bool>() ?? _softVoting;
-
-        var classLabelsToken = dataObj["ClassLabels"];
-        if (classLabelsToken is not null)
-        {
-            var arr = classLabelsToken.ToObject<double[]>() ?? Array.Empty<double>();
-            if (arr.Length > 0)
-            {
-                ClassLabels = new Vector<T>(arr.Length);
-                for (int i = 0; i < arr.Length; i++)
-                    ClassLabels[i] = NumOps.FromDouble(arr[i]);
-            }
-        }
-
-        _subClassifiers.Clear();
-        int subCount = dataObj["SubClassifierCount"]?.ToObject<int>() ?? 0;
-        for (int i = 0; i < subCount; i++)
-        {
-            if (dataObj[$"Sub_{i}"] is JObject subJObj)
-            {
-                var sub = new AdaBoostSubClassifier();
-
-                var alphasToken = subJObj["Alphas"];
-                if (alphasToken is not null)
-                {
-                    sub.Alphas = alphasToken.ToObject<List<double>>() ?? [];
-                }
-
-                int learnerCount = subJObj["LearnerCount"]?.ToObject<int>() ?? 0;
-                for (int j = 0; j < learnerCount; j++)
-                {
-                    if (subJObj[$"Learner_{j}"] is JObject wlObj)
-                    {
-                        sub.WeakLearners.Add(new WeakLearner
-                        {
-                            FeatureIndex = wlObj["FeatureIndex"]?.ToObject<int>() ?? 0,
-                            Threshold = wlObj["Threshold"]?.ToObject<double>() ?? 0,
-                            Polarity = wlObj["Polarity"]?.ToObject<int>() ?? 1
-                        });
-                    }
-                }
-
-                _subClassifiers.Add(sub);
-            }
-        }
-    }
-
     /// <summary>
     /// Represents an AdaBoost sub-classifier.
     /// </summary>
diff --git a/src/Classification/Linear/LinearClassifierBase.cs b/src/Classification/Linear/LinearClassifierBase.cs
index b7355aa5db..5b482e687f 100644
--- a/src/Classification/Linear/LinearClassifierBase.cs
+++ b/src/Classification/Linear/LinearClassifierBase.cs
@@ -39,7 +39,7 @@ namespace AiDotNet.Classification.Linear;
 /// - Often surprisingly effective
 /// </para>
 /// </remarks>
-public abstract class LinearClassifierBase<T> : ProbabilisticClassifierBase<T>,
+public abstract partial class LinearClassifierBase<T> : ProbabilisticClassifierBase<T>,
     IParameterizable<T, Matrix<T>, Vector<T>>, IGradientComputable<T, Matrix<T>, Vector<T>>
 {
 
@@ -396,125 +396,4 @@ public override ModelMetadata<T> GetModelMetadata()
         metadata.AdditionalInfo["Alpha"] = Options.Alpha;
         return metadata;
     }
-
-    /// <inheritdoc/>
-    public override byte[] Serialize()
-    {
-        var modelData = new Dictionary<string, object>
-        {
-            { "NumClasses", NumClasses },
-            { "NumFeatures", NumFeatures },
-            { "TaskType", (int)TaskType },
-            { "ClassLabels", ClassLabels?.ToArray() ?? Array.Empty<T>() },
-            { "RegularizationOptions", Regularization.GetOptions() },
-            { "FitIntercept", Options.FitIntercept },
-            { "LearningRate", Options.LearningRate },
-            { "MaxIterations", Options.MaxIterations },
-            { "Penalty", (int)Options.Penalty },
-            { "Loss", (int)Options.Loss },
-            { "Alpha", Options.Alpha }
-        };
-
-        // Serialize Weights
-        if (Weights is not null)
-        {
-            var weightsArray = new double[Weights.Length];
-            for (int i = 0; i < Weights.Length; i++)
-            {
-                weightsArray[i] = NumOps.ToDouble(Weights[i]);
-            }
-            modelData["Weights"] = weightsArray;
-        }
-
-        // Serialize Intercept
-        modelData["Intercept"] = NumOps.ToDouble(Intercept);
-
-        var modelMetadata = GetModelMetadata();
-        modelMetadata.ModelData = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(modelData));
-
-        return Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(modelMetadata));
-    }
-
-    /// <inheritdoc/>
-    public override void Deserialize(byte[] modelData)
-    {
-        var jsonString = Encoding.UTF8.GetString(modelData);
-        var modelMetadata = JsonConvert.DeserializeObject<ModelMetadata<T>>(jsonString);
-
-        if (modelMetadata == null || modelMetadata.ModelData == null)
-        {
-            throw new InvalidOperationException("Deserialization failed: The model data is invalid or corrupted.");
-        }
-
-        var modelDataString = Encoding.UTF8.GetString(modelMetadata.ModelData);
-        var modelDataObj = JsonConvert.DeserializeObject<JObject>(modelDataString);
-
-        if (modelDataObj == null)
-        {
-            throw new InvalidOperationException("Deserialization failed: The model data is invalid or corrupted.");
-        }
-
-        // Deserialize base properties with validation
-        var numClassesToken = modelDataObj["NumClasses"];
-        var numFeaturesToken = modelDataObj["NumFeatures"];
-        if (numClassesToken is null || numFeaturesToken is null)
-        {
-            throw new InvalidOperationException(
-                "Deserialization failed: NumClasses or NumFeatures is missing from serialized data.");
-        }
-        NumClasses = numClassesToken.ToObject<int>();
-        NumFeatures = numFeaturesToken.ToObject<int>();
-        TaskType = (ClassificationTaskType)(modelDataObj["TaskType"]?.ToObject<int>() ?? 0);
-
-        // Restore options
-        var fitInterceptToken = modelDataObj["FitIntercept"];
-        if (fitInterceptToken is not null)
-            Options.FitIntercept = fitInterceptToken.ToObject<bool>();
-        if (modelDataObj["LearningRate"] is not null)
-            Options.LearningRate = modelDataObj["LearningRate"]?.ToObject<double>() ?? Options.LearningRate;
-        if (modelDataObj["MaxIterations"] is not null)
-            Options.MaxIterations = modelDataObj["MaxIterations"]?.ToObject<int>() ?? Options.MaxIterations;
-        if (modelDataObj["Penalty"] is not null)
-            Options.Penalty = (LinearPenalty)(modelDataObj["Penalty"]?.ToObject<int>() ?? (int)Options.Penalty);
-        if (modelDataObj["Loss"] is not null)
-            Options.Loss = (LinearLoss)(modelDataObj["Loss"]?.ToObject<int>() ?? (int)Options.Loss);
-        if (modelDataObj["Alpha"] is not null)
-            Options.Alpha = modelDataObj["Alpha"]?.ToObject<double>() ?? Options.Alpha;
-
-        var classLabelsToken = modelDataObj["ClassLabels"];
-        if (classLabelsToken is not null)
-        {
-            var classLabelsAsDoubles = classLabelsToken.ToObject<double[]>() ?? Array.Empty<double>();
-            if (classLabelsAsDoubles.Length > 0)
-            {
-                ClassLabels = new Vector<T>(classLabelsAsDoubles.Length);
-                for (int i = 0; i < classLabelsAsDoubles.Length; i++)
-                {
-                    ClassLabels[i] = NumOps.FromDouble(classLabelsAsDoubles[i]);
-                }
-            }
-        }
-
-        // Deserialize Weights
-        var weightsToken = modelDataObj["Weights"];
-        if (weightsToken is not null)
-        {
-            var weightsAsDoubles = weightsToken.ToObject<double[]>() ?? Array.Empty<double>();
-            if (weightsAsDoubles.Length > 0)
-            {
-                Weights = new Vector<T>(weightsAsDoubles.Length);
-                for (int i = 0; i < weightsAsDoubles.Length; i++)
-                {
-                    Weights[i] = NumOps.FromDouble(weightsAsDoubles[i]);
-                }
-            }
-        }
-
-        // Deserialize Intercept
-        var interceptToken = modelDataObj["Intercept"];
-        if (interceptToken is not null)
-        {
-            Intercept = NumOps.FromDouble(interceptToken.ToObject<double>());
-        }
-    }
 }
diff --git a/src/Classification/Linear/PassiveAggressiveClassifier.cs b/src/Classification/Linear/PassiveAggressiveClassifier.cs
index 25afd7016f..ef30216652 100644
--- a/src/Classification/Linear/PassiveAggressiveClassifier.cs
+++ b/src/Classification/Linear/PassiveAggressiveClassifier.cs
@@ -217,51 +217,6 @@ private T ComputeTau(T loss, T squaredNorm, T c)
         return tau;
     }
 
-    /// <inheritdoc/>
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        return new PassiveAggressiveClassifier<T>(new PassiveAggressiveOptions<T>
-        {
-            C = Options.C,
-            PAType = Options.PAType,
-            MaxIterations = Options.MaxIterations,
-            FitIntercept = Options.FitIntercept,
-            Shuffle = Options.Shuffle,
-            Seed = Options.Seed
-        });
-    }
-
-    /// <inheritdoc/>
-    public override IFullModel<T, Matrix<T>, Vector<T>> Clone()
-    {
-        var clone = (PassiveAggressiveClassifier<T>)CreateNewInstance();
-
-        clone.NumFeatures = NumFeatures;
-        clone.NumClasses = NumClasses;
-        clone.TaskType = TaskType;
-        clone.Intercept = Intercept;
-
-        if (ClassLabels is not null)
-        {
-            clone.ClassLabels = new Vector<T>(ClassLabels.Length);
-            for (int i = 0; i < ClassLabels.Length; i++)
-            {
-                clone.ClassLabels[i] = ClassLabels[i];
-            }
-        }
-
-        if (Weights is not null)
-        {
-            clone.Weights = new Vector<T>(Weights.Length);
-            for (int i = 0; i < Weights.Length; i++)
-            {
-                clone.Weights[i] = Weights[i];
-            }
-        }
-
-        return clone;
-    }
-
     /// <inheritdoc/>
     public override ModelMetadata<T> GetModelMetadata()
     {
diff --git a/src/Classification/Linear/PerceptronClassifier.cs b/src/Classification/Linear/PerceptronClassifier.cs
index 575c4db6d8..981e574295 100644
--- a/src/Classification/Linear/PerceptronClassifier.cs
+++ b/src/Classification/Linear/PerceptronClassifier.cs
@@ -187,50 +187,4 @@ public override void Train(Matrix<T> x, Vector<T> y)
             }
         }
     }
-
-    /// <inheritdoc/>
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        return new PerceptronClassifier<T>(new LinearClassifierOptions<T>
-        {
-            LearningRate = Options.LearningRate,
-            MaxIterations = Options.MaxIterations,
-            FitIntercept = Options.FitIntercept,
-            Alpha = Options.Alpha,
-            Shuffle = Options.Shuffle,
-            Penalty = Options.Penalty,
-            Seed = Options.Seed
-        });
-    }
-
-    /// <inheritdoc/>
-    public override IFullModel<T, Matrix<T>, Vector<T>> Clone()
-    {
-        var clone = (PerceptronClassifier<T>)CreateNewInstance();
-
-        clone.NumFeatures = NumFeatures;
-        clone.NumClasses = NumClasses;
-        clone.TaskType = TaskType;
-        clone.Intercept = Intercept;
-
-        if (ClassLabels is not null)
-        {
-            clone.ClassLabels = new Vector<T>(ClassLabels.Length);
-            for (int i = 0; i < ClassLabels.Length; i++)
-            {
-                clone.ClassLabels[i] = ClassLabels[i];
-            }
-        }
-
-        if (Weights is not null)
-        {
-            clone.Weights = new Vector<T>(Weights.Length);
-            for (int i = 0; i < Weights.Length; i++)
-            {
-                clone.Weights[i] = Weights[i];
-            }
-        }
-
-        return clone;
-    }
 }
diff --git a/src/Classification/Linear/RidgeClassifier.cs b/src/Classification/Linear/RidgeClassifier.cs
index 1b035c3fe1..9fa350dc75 100644
--- a/src/Classification/Linear/RidgeClassifier.cs
+++ b/src/Classification/Linear/RidgeClassifier.cs
@@ -311,45 +311,4 @@ private Vector<T> SolveLinearSystem(Matrix<T> a, Vector<T> b)
 
         return x;
     }
-
-    /// <inheritdoc/>
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        return new RidgeClassifier<T>(new LinearClassifierOptions<T>
-        {
-            Alpha = Options.Alpha,
-            FitIntercept = Options.FitIntercept
-        });
-    }
-
-    /// <inheritdoc/>
-    public override IFullModel<T, Matrix<T>, Vector<T>> Clone()
-    {
-        var clone = (RidgeClassifier<T>)CreateNewInstance();
-
-        clone.NumFeatures = NumFeatures;
-        clone.NumClasses = NumClasses;
-        clone.TaskType = TaskType;
-        clone.Intercept = Intercept;
-
-        if (ClassLabels is not null)
-        {
-            clone.ClassLabels = new Vector<T>(ClassLabels.Length);
-            for (int i = 0; i < ClassLabels.Length; i++)
-            {
-                clone.ClassLabels[i] = ClassLabels[i];
-            }
-        }
-
-        if (Weights is not null)
-        {
-            clone.Weights = new Vector<T>(Weights.Length);
-            for (int i = 0; i < Weights.Length; i++)
-            {
-                clone.Weights[i] = Weights[i];
-            }
-        }
-
-        return clone;
-    }
 }
diff --git a/src/Classification/Linear/SGDClassifier.cs b/src/Classification/Linear/SGDClassifier.cs
index 3fc2fe9ec9..21a88e2f83 100644
--- a/src/Classification/Linear/SGDClassifier.cs
+++ b/src/Classification/Linear/SGDClassifier.cs
@@ -269,52 +269,4 @@ private void ComputeLossAndGradient(T prediction, T target, out T loss, out T gr
                 break;
         }
     }
-
-    /// <inheritdoc/>
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        return new SGDClassifier<T>(new LinearClassifierOptions<T>
-        {
-            LearningRate = Options.LearningRate,
-            MaxIterations = Options.MaxIterations,
-            Tolerance = Options.Tolerance,
-            FitIntercept = Options.FitIntercept,
-            Alpha = Options.Alpha,
-            Shuffle = Options.Shuffle,
-            Penalty = Options.Penalty,
-            Loss = Options.Loss,
-            Seed = Options.Seed
-        });
-    }
-
-    /// <inheritdoc/>
-    public override IFullModel<T, Matrix<T>, Vector<T>> Clone()
-    {
-        var clone = (SGDClassifier<T>)CreateNewInstance();
-
-        clone.NumFeatures = NumFeatures;
-        clone.NumClasses = NumClasses;
-        clone.TaskType = TaskType;
-        clone.Intercept = Intercept;
-
-        if (ClassLabels is not null)
-        {
-            clone.ClassLabels = new Vector<T>(ClassLabels.Length);
-            for (int i = 0; i < ClassLabels.Length; i++)
-            {
-                clone.ClassLabels[i] = ClassLabels[i];
-            }
-        }
-
-        if (Weights is not null)
-        {
-            clone.Weights = new Vector<T>(Weights.Length);
-            for (int i = 0; i < Weights.Length; i++)
-            {
-                clone.Weights[i] = Weights[i];
-            }
-        }
-
-        return clone;
-    }
 }
diff --git a/src/Classification/Meta/BaggingClassifier.cs b/src/Classification/Meta/BaggingClassifier.cs
index 38600c75ab..be87814ed2 100644
--- a/src/Classification/Meta/BaggingClassifier.cs
+++ b/src/Classification/Meta/BaggingClassifier.cs
@@ -420,137 +420,6 @@ public override Matrix<T> PredictLogProbabilities(Matrix<T> input)
         return logProbs;
     }
 
-    /// <inheritdoc/>
-    public override byte[] Serialize()
-    {
-        var estimatorTypes = new List<string>();
-        var estimatorData = new List<string>();
-        if (_estimators is not null)
-        {
-            foreach (var est in _estimators)
-            {
-                var (typeName, data) = ClassifierRegistry<T>.SerializeClassifier(est);
-                estimatorTypes.Add(typeName);
-                estimatorData.Add(data);
-            }
-        }
-
-        var modelDict = new Dictionary<string, object?>
-        {
-            { "ClassLabels", ClassLabels?.ToArray().Select(NumOps.ToDouble).ToArray() },
-            { "NumClasses", NumClasses },
-            { "NumFeatures", NumFeatures },
-            { "TaskType", (int)TaskType },
-            { "FeatureIndicesPerEstimator", _featureIndicesPerEstimator },
-            { "EstimatorTypes", estimatorTypes },
-            { "EstimatorData", estimatorData }
-        };
-
-        var metadata = GetModelMetadata();
-        metadata.ModelData = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(modelDict));
-        return Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(metadata));
-    }
-
-    /// <inheritdoc/>
-    public override void Deserialize(byte[] modelData)
-    {
-        var jsonString = Encoding.UTF8.GetString(modelData);
-        var metadata = JsonConvert.DeserializeObject<ModelMetadata<T>>(jsonString)
-            ?? throw new InvalidOperationException("Failed to deserialize BaggingClassifier: invalid metadata.");
-        if (metadata.ModelData is null)
-            throw new InvalidOperationException("Failed to deserialize BaggingClassifier: missing model data.");
-
-        var dataString = Encoding.UTF8.GetString(metadata.ModelData);
-        var jObj = JsonConvert.DeserializeObject<JObject>(dataString)
-            ?? throw new InvalidOperationException("Failed to deserialize BaggingClassifier: invalid model payload.");
-
-        var classLabelsArr = jObj["ClassLabels"]?.ToObject<double[]>();
-        if (classLabelsArr is not null)
-        {
-            ClassLabels = new Vector<T>(classLabelsArr.Length);
-            for (int i = 0; i < classLabelsArr.Length; i++)
-                ClassLabels[i] = NumOps.FromDouble(classLabelsArr[i]);
-        }
-        NumClasses = jObj["NumClasses"]?.ToObject<int>() ?? 0;
-        NumFeatures = jObj["NumFeatures"]?.ToObject<int>() ?? 0;
-        TaskType = (ClassificationTaskType)(jObj["TaskType"]?.ToObject<int>() ?? 0);
-        _featureIndicesPerEstimator = jObj["FeatureIndicesPerEstimator"]?.ToObject<int[][]>();
-
-        var types = jObj["EstimatorTypes"]?.ToObject<string[]>();
-        var data = jObj["EstimatorData"]?.ToObject<string[]>();
-        if (types is null || data is null || types.Length != data.Length)
-            throw new InvalidOperationException(
-                "Failed to deserialize BaggingClassifier: estimator types/data arrays are missing or mismatched.");
-
-        _estimators = new IClassifier<T>[types.Length];
-        for (int i = 0; i < types.Length; i++)
-            _estimators[i] = ClassifierRegistry<T>.DeserializeClassifier(types[i], data[i]);
-    }
-
-    /// <inheritdoc/>
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        if (EstimatorFactory is null)
-        {
-            throw new InvalidOperationException("Estimator factory is not set.");
-        }
-
-        return new BaggingClassifier<T>(EstimatorFactory, new BaggingClassifierOptions<T>
-        {
-            NumEstimators = Options.NumEstimators,
-            MaxSamples = Options.MaxSamples,
-            MaxFeatures = Options.MaxFeatures,
-            Bootstrap = Options.Bootstrap,
-            Seed = Options.Seed
-        });
-    }
-
-    /// <inheritdoc/>
-    public override IFullModel<T, Matrix<T>, Vector<T>> Clone()
-    {
-        var clone = (BaggingClassifier<T>)CreateNewInstance();
-
-        clone.NumFeatures = NumFeatures;
-        clone.NumClasses = NumClasses;
-        clone.TaskType = TaskType;
-
-        if (ClassLabels is not null)
-        {
-            clone.ClassLabels = new Vector<T>(ClassLabels.Length);
-            for (int i = 0; i < ClassLabels.Length; i++)
-            {
-                clone.ClassLabels[i] = ClassLabels[i];
-            }
-        }
-
-        if (_estimators is not null)
-        {
-            clone._estimators = new IClassifier<T>[_estimators.Length];
-            for (int e = 0; e < _estimators.Length; e++)
-            {
-                if (_estimators[e] is IFullModel<T, Matrix<T>, Vector<T>> fullModel)
-                {
-                    clone._estimators[e] = (IClassifier<T>)fullModel.Clone();
-                }
-                else
-                {
-                    clone._estimators[e] = _estimators[e];
-                }
-            }
-        }
-
-        if (_featureIndicesPerEstimator is not null)
-        {
-            clone._featureIndicesPerEstimator = new int[_featureIndicesPerEstimator.Length][];
-            for (int e = 0; e < _featureIndicesPerEstimator.Length; e++)
-            {
-                clone._featureIndicesPerEstimator[e] = (int[])_featureIndicesPerEstimator[e].Clone();
-            }
-        }
-
-        return clone;
-    }
-
     /// <inheritdoc/>
     public override ModelMetadata<T> GetModelMetadata()
     {
diff --git a/src/Classification/Meta/ClassifierChain.cs b/src/Classification/Meta/ClassifierChain.cs
index d4519b79ae..d8bc597016 100644
--- a/src/Classification/Meta/ClassifierChain.cs
+++ b/src/Classification/Meta/ClassifierChain.cs
@@ -449,139 +449,6 @@ public override Matrix<T> PredictLogProbabilities(Matrix<T> input)
 
         return logProbs;
     }
-
-    /// <inheritdoc/>
-    public override byte[] Serialize()
-    {
-        var estimatorTypes = new List<string>();
-        var estimatorData = new List<string>();
-        if (_classifiers is not null)
-        {
-            foreach (var clf in _classifiers)
-            {
-                var (typeName, data) = ClassifierRegistry<T>.SerializeClassifier(clf);
-                estimatorTypes.Add(typeName);
-                estimatorData.Add(data);
-            }
-        }
-
-        var modelDict = new Dictionary<string, object?>
-        {
-            { "ClassLabels", ClassLabels?.ToArray().Select(NumOps.ToDouble).ToArray() },
-            { "NumClasses", NumClasses },
-            { "NumFeatures", NumFeatures },
-            { "TaskType", (int)TaskType },
-            { "LabelNames", LabelNames },
-            { "Order", _order },
-            { "EstimatorTypes", estimatorTypes },
-            { "EstimatorData", estimatorData }
-        };
-
-        var metadata = GetModelMetadata();
-        metadata.ModelData = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(modelDict));
-        return Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(metadata));
-    }
-
-    /// <inheritdoc/>
-    public override void Deserialize(byte[] modelData)
-    {
-        var jsonString = Encoding.UTF8.GetString(modelData);
-        var metadata = JsonConvert.DeserializeObject<ModelMetadata<T>>(jsonString)
-            ?? throw new InvalidOperationException("Failed to deserialize ClassifierChain: invalid metadata.");
-        if (metadata.ModelData is null)
-            throw new InvalidOperationException("Failed to deserialize ClassifierChain: missing model data.");
-
-        var dataString = Encoding.UTF8.GetString(metadata.ModelData);
-        var jObj = JsonConvert.DeserializeObject<JObject>(dataString);
-        if (jObj is null)
-            throw new InvalidOperationException("Failed to deserialize ClassifierChain: invalid model payload.");
-
-        var classLabelsArr = jObj["ClassLabels"]?.ToObject<double[]>();
-        if (classLabelsArr is not null)
-        {
-            ClassLabels = new Vector<T>(classLabelsArr.Length);
-            for (int i = 0; i < classLabelsArr.Length; i++)
-                ClassLabels[i] = NumOps.FromDouble(classLabelsArr[i]);
-        }
-        NumClasses = jObj["NumClasses"]?.ToObject<int>() ?? 0;
-        NumFeatures = jObj["NumFeatures"]?.ToObject<int>() ?? 0;
-        TaskType = (ClassificationTaskType)(jObj["TaskType"]?.ToObject<int>() ?? 0);
-        LabelNames = jObj["LabelNames"]?.ToObject<string[]>();
-        _order = jObj["Order"]?.ToObject<int[]>();
-
-        var types = jObj["EstimatorTypes"]?.ToObject<string[]>();
-        var data = jObj["EstimatorData"]?.ToObject<string[]>();
-        if (types is null || data is null || types.Length != data.Length)
-            throw new InvalidOperationException(
-                "Failed to deserialize ClassifierChain: estimator types/data arrays are missing or mismatched.");
-
-        if (_order is not null && _order.Length != types.Length)
-            throw new InvalidOperationException(
-                $"Failed to deserialize ClassifierChain: Order length ({_order.Length}) does not match classifier count ({types.Length}).");
-
-        _classifiers = new IClassifier<T>[types.Length];
-        for (int i = 0; i < types.Length; i++)
-            _classifiers[i] = ClassifierRegistry<T>.DeserializeClassifier(types[i], data[i]);
-    }
-
-    /// <inheritdoc/>
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        if (EstimatorFactory is null)
-        {
-            throw new InvalidOperationException("Estimator factory is not set.");
-        }
-
-        return new ClassifierChain<T>(EstimatorFactory, new ClassifierChainOptions<T>
-        {
-            Order = Options.Order,
-            RandomOrder = Options.RandomOrder,
-            Seed = Options.Seed
-        });
-    }
-
-    /// <inheritdoc/>
-    public override IFullModel<T, Matrix<T>, Vector<T>> Clone()
-    {
-        var clone = (ClassifierChain<T>)CreateNewInstance();
-
-        clone.NumFeatures = NumFeatures;
-        clone.NumClasses = NumClasses;
-        clone.TaskType = TaskType;
-
-        if (ClassLabels is not null)
-        {
-            clone.ClassLabels = new Vector<T>(ClassLabels.Length);
-            for (int i = 0; i < ClassLabels.Length; i++)
-            {
-                clone.ClassLabels[i] = ClassLabels[i];
-            }
-        }
-
-        if (_order is not null)
-        {
-            clone._order = new int[_order.Length];
-            Array.Copy(_order, clone._order, _order.Length);
-        }
-
-        if (_classifiers is not null)
-        {
-            clone._classifiers = new IClassifier<T>[_classifiers.Length];
-            for (int c = 0; c < _classifiers.Length; c++)
-            {
-                if (_classifiers[c] is IFullModel<T, Matrix<T>, Vector<T>> fullModel)
-                {
-                    clone._classifiers[c] = (IClassifier<T>)fullModel.Clone();
-                }
-                else
-                {
-                    clone._classifiers[c] = _classifiers[c];
-                }
-            }
-        }
-
-        return clone;
-    }
 }
 
 /// <summary>
diff --git a/src/Classification/Meta/MultiOutputClassifier.cs b/src/Classification/Meta/MultiOutputClassifier.cs
index dade306ca5..539e158523 100644
--- a/src/Classification/Meta/MultiOutputClassifier.cs
+++ b/src/Classification/Meta/MultiOutputClassifier.cs
@@ -324,122 +324,4 @@ public override Matrix<T> PredictLogProbabilities(Matrix<T> input)
 
         return logProbs;
     }
-
-    /// <inheritdoc/>
-    public override byte[] Serialize()
-    {
-        var estimatorTypes = new List<string>();
-        var estimatorData = new List<string>();
-        if (_classifiers is not null)
-        {
-            foreach (var clf in _classifiers)
-            {
-                var (typeName, data) = ClassifierRegistry<T>.SerializeClassifier(clf);
-                estimatorTypes.Add(typeName);
-                estimatorData.Add(data);
-            }
-        }
-
-        var modelDict = new Dictionary<string, object?>
-        {
-            { "ClassLabels", ClassLabels?.ToArray().Select(NumOps.ToDouble).ToArray() },
-            { "NumClasses", NumClasses },
-            { "NumFeatures", NumFeatures },
-            { "TaskType", (int)TaskType },
-            { "LabelNames", LabelNames },
-            { "EstimatorTypes", estimatorTypes },
-            { "EstimatorData", estimatorData }
-        };
-
-        var metadata = GetModelMetadata();
-        metadata.ModelData = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(modelDict));
-        return Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(metadata));
-    }
-
-    /// <inheritdoc/>
-    public override void Deserialize(byte[] modelData)
-    {
-        var jsonString = Encoding.UTF8.GetString(modelData);
-        var metadata = JsonConvert.DeserializeObject<ModelMetadata<T>>(jsonString)
-            ?? throw new InvalidOperationException("Failed to deserialize MultiOutputClassifier: invalid metadata.");
-        if (metadata.ModelData is null)
-            throw new InvalidOperationException("Failed to deserialize MultiOutputClassifier: missing model data.");
-
-        var dataString = Encoding.UTF8.GetString(metadata.ModelData);
-        var jObj = JsonConvert.DeserializeObject<JObject>(dataString)
-            ?? throw new InvalidOperationException("Failed to deserialize MultiOutputClassifier: invalid model payload.");
-
-        var classLabelsArr = jObj["ClassLabels"]?.ToObject<double[]>();
-        if (classLabelsArr is not null)
-        {
-            ClassLabels = new Vector<T>(classLabelsArr.Length);
-            for (int i = 0; i < classLabelsArr.Length; i++)
-                ClassLabels[i] = NumOps.FromDouble(classLabelsArr[i]);
-        }
-        NumClasses = jObj["NumClasses"]?.ToObject<int>() ?? 0;
-        NumFeatures = jObj["NumFeatures"]?.ToObject<int>() ?? 0;
-        TaskType = (ClassificationTaskType)(jObj["TaskType"]?.ToObject<int>() ?? 0);
-        LabelNames = jObj["LabelNames"]?.ToObject<string[]>();
-
-        var types = jObj["EstimatorTypes"]?.ToObject<string[]>();
-        var data = jObj["EstimatorData"]?.ToObject<string[]>();
-        if (types is null || data is null || types.Length != data.Length)
-            throw new InvalidOperationException(
-                "Failed to deserialize MultiOutputClassifier: estimator types/data arrays are missing or mismatched.");
-
-        _classifiers = new IClassifier<T>[types.Length];
-        for (int i = 0; i < types.Length; i++)
-            _classifiers[i] = ClassifierRegistry<T>.DeserializeClassifier(types[i], data[i]);
-    }
-
-    /// <inheritdoc/>
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        if (EstimatorFactory is null)
-        {
-            throw new InvalidOperationException("Estimator factory is not set.");
-        }
-
-        return new MultiOutputClassifier<T>(EstimatorFactory, new MetaClassifierOptions<T>
-        {
-            NumJobs = Options.NumJobs
-        });
-    }
-
-    /// <inheritdoc/>
-    public override IFullModel<T, Matrix<T>, Vector<T>> Clone()
-    {
-        var clone = (MultiOutputClassifier<T>)CreateNewInstance();
-
-        clone.NumFeatures = NumFeatures;
-        clone.NumClasses = NumClasses;
-        clone.TaskType = TaskType;
-
-        if (ClassLabels is not null)
-        {
-            clone.ClassLabels = new Vector<T>(ClassLabels.Length);
-            for (int i = 0; i < ClassLabels.Length; i++)
-            {
-                clone.ClassLabels[i] = ClassLabels[i];
-            }
-        }
-
-        if (_classifiers is not null)
-        {
-            clone._classifiers = new IClassifier<T>[_classifiers.Length];
-            for (int c = 0; c < _classifiers.Length; c++)
-            {
-                if (_classifiers[c] is IFullModel<T, Matrix<T>, Vector<T>> fullModel)
-                {
-                    clone._classifiers[c] = (IClassifier<T>)fullModel.Clone();
-                }
-                else
-                {
-                    clone._classifiers[c] = _classifiers[c];
-                }
-            }
-        }
-
-        return clone;
-    }
 }
diff --git a/src/Classification/Meta/OneVsOneClassifier.cs b/src/Classification/Meta/OneVsOneClassifier.cs
index 9bbf7a04b5..afd244c1a4 100644
--- a/src/Classification/Meta/OneVsOneClassifier.cs
+++ b/src/Classification/Meta/OneVsOneClassifier.cs
@@ -372,141 +372,4 @@ public override Matrix<T> PredictLogProbabilities(Matrix<T> input)
 
         return logProbs;
     }
-
-    /// <inheritdoc/>
-    public override byte[] Serialize()
-    {
-        var estimatorTypes = new List<string>();
-        var estimatorData = new List<string>();
-        if (_estimators is not null)
-        {
-            foreach (var est in _estimators)
-            {
-                var (typeName, data) = ClassifierRegistry<T>.SerializeClassifier(est);
-                estimatorTypes.Add(typeName);
-                estimatorData.Add(data);
-            }
-        }
-
-        var classPairsFirst = _classPairs?.Select(p => p.Item1).ToArray();
-        var classPairsSecond = _classPairs?.Select(p => p.Item2).ToArray();
-
-        var modelDict = new Dictionary<string, object?>
-        {
-            { "ClassLabels", ClassLabels?.ToArray().Select(NumOps.ToDouble).ToArray() },
-            { "NumClasses", NumClasses },
-            { "NumFeatures", NumFeatures },
-            { "TaskType", (int)TaskType },
-            { "ClassPairsFirst", classPairsFirst },
-            { "ClassPairsSecond", classPairsSecond },
-            { "EstimatorTypes", estimatorTypes },
-            { "EstimatorData", estimatorData }
-        };
-
-        var metadata = GetModelMetadata();
-        metadata.ModelData = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(modelDict));
-        return Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(metadata));
-    }
-
-    /// <inheritdoc/>
-    public override void Deserialize(byte[] modelData)
-    {
-        var jsonString = Encoding.UTF8.GetString(modelData);
-        var metadata = JsonConvert.DeserializeObject<ModelMetadata<T>>(jsonString)
-            ?? throw new InvalidOperationException("Failed to deserialize OneVsOneClassifier: invalid metadata.");
-        if (metadata.ModelData is null)
-            throw new InvalidOperationException("Failed to deserialize OneVsOneClassifier: missing model data.");
-
-        var dataString = Encoding.UTF8.GetString(metadata.ModelData);
-        var jObj = JsonConvert.DeserializeObject<JObject>(dataString)
-            ?? throw new InvalidOperationException("Failed to deserialize OneVsOneClassifier: invalid model payload.");
-
-        var classLabelsArr = jObj["ClassLabels"]?.ToObject<double[]>();
-        if (classLabelsArr is not null)
-        {
-            ClassLabels = new Vector<T>(classLabelsArr.Length);
-            for (int i = 0; i < classLabelsArr.Length; i++)
-                ClassLabels[i] = NumOps.FromDouble(classLabelsArr[i]);
-        }
-        NumClasses = jObj["NumClasses"]?.ToObject<int>() ?? 0;
-        NumFeatures = jObj["NumFeatures"]?.ToObject<int>() ?? 0;
-        TaskType = (ClassificationTaskType)(jObj["TaskType"]?.ToObject<int>() ?? 0);
-
-        var pairsFirst = jObj["ClassPairsFirst"]?.ToObject<int[]>();
-        var pairsSecond = jObj["ClassPairsSecond"]?.ToObject<int[]>();
-        if (pairsFirst is null || pairsSecond is null || pairsFirst.Length != pairsSecond.Length)
-            throw new InvalidOperationException(
-                "Failed to deserialize OneVsOneClassifier: class pairs data is missing or mismatched.");
-
-        _classPairs = new (int, int)[pairsFirst.Length];
-        for (int i = 0; i < pairsFirst.Length; i++)
-            _classPairs[i] = (pairsFirst[i], pairsSecond[i]);
-
-        var types = jObj["EstimatorTypes"]?.ToObject<string[]>();
-        var data = jObj["EstimatorData"]?.ToObject<string[]>();
-        if (types is null || data is null || types.Length != data.Length)
-            throw new InvalidOperationException(
-                "Failed to deserialize OneVsOneClassifier: estimator types/data arrays are missing or mismatched.");
-
-        _estimators = new IClassifier<T>[types.Length];
-        for (int i = 0; i < types.Length; i++)
-            _estimators[i] = ClassifierRegistry<T>.DeserializeClassifier(types[i], data[i]);
-    }
-
-    /// <inheritdoc/>
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        if (EstimatorFactory is null)
-        {
-            throw new InvalidOperationException("Estimator factory is not set.");
-        }
-
-        return new OneVsOneClassifier<T>(EstimatorFactory, new MetaClassifierOptions<T>
-        {
-            NumJobs = Options.NumJobs
-        });
-    }
-
-    /// <inheritdoc/>
-    public override IFullModel<T, Matrix<T>, Vector<T>> Clone()
-    {
-        var clone = (OneVsOneClassifier<T>)CreateNewInstance();
-
-        clone.NumFeatures = NumFeatures;
-        clone.NumClasses = NumClasses;
-        clone.TaskType = TaskType;
-
-        if (ClassLabels is not null)
-        {
-            clone.ClassLabels = new Vector<T>(ClassLabels.Length);
-            for (int i = 0; i < ClassLabels.Length; i++)
-            {
-                clone.ClassLabels[i] = ClassLabels[i];
-            }
-        }
-
-        if (_classPairs is not null)
-        {
-            clone._classPairs = new (int, int)[_classPairs.Length];
-            Array.Copy(_classPairs, clone._classPairs, _classPairs.Length);
-        }
-
-        if (_estimators is not null)
-        {
-            clone._estimators = new IClassifier<T>[_estimators.Length];
-            for (int p = 0; p < _estimators.Length; p++)
-            {
-                if (_estimators[p] is IFullModel<T, Matrix<T>, Vector<T>> fullModel)
-                {
-                    clone._estimators[p] = (IClassifier<T>)fullModel.Clone();
-                }
-                else
-                {
-                    clone._estimators[p] = _estimators[p];
-                }
-            }
-        }
-
-        return clone;
-    }
 }
diff --git a/src/Classification/Meta/OneVsRestClassifier.cs b/src/Classification/Meta/OneVsRestClassifier.cs
index 05854d50f4..3863cdb611 100644
--- a/src/Classification/Meta/OneVsRestClassifier.cs
+++ b/src/Classification/Meta/OneVsRestClassifier.cs
@@ -372,125 +372,4 @@ private Vector<T> GetEstimatorScores(IClassifier<T> estimator, Matrix<T> input)
         }
         return result;
     }
-
-    /// <inheritdoc/>
-    public override byte[] Serialize()
-    {
-        var estimatorTypes = new List<string>();
-        var estimatorData = new List<string>();
-        if (_estimators is not null)
-        {
-            foreach (var est in _estimators)
-            {
-                var (typeName, data) = ClassifierRegistry<T>.SerializeClassifier(est);
-                estimatorTypes.Add(typeName);
-                estimatorData.Add(data);
-            }
-        }
-
-        var modelDict = new Dictionary<string, object?>
-        {
-            { "ClassLabels", ClassLabels?.ToArray().Select(NumOps.ToDouble).ToArray() },
-            { "NumClasses", NumClasses },
-            { "NumFeatures", NumFeatures },
-            { "TaskType", (int)TaskType },
-            { "LabelNames", LabelNames },
-            { "EstimatorTypes", estimatorTypes },
-            { "EstimatorData", estimatorData }
-        };
-
-        var metadata = GetModelMetadata();
-        metadata.ModelData = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(modelDict));
-        return Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(metadata));
-    }
-
-    /// <inheritdoc/>
-    public override void Deserialize(byte[] modelData)
-    {
-        var jsonString = Encoding.UTF8.GetString(modelData);
-        var metadata = JsonConvert.DeserializeObject<ModelMetadata<T>>(jsonString)
-            ?? throw new InvalidOperationException("Failed to deserialize OneVsRestClassifier: invalid metadata.");
-        if (metadata.ModelData is null)
-            throw new InvalidOperationException("Failed to deserialize OneVsRestClassifier: missing model data.");
-
-        var dataString = Encoding.UTF8.GetString(metadata.ModelData);
-        var jObj = JsonConvert.DeserializeObject<JObject>(dataString)
-            ?? throw new InvalidOperationException("Failed to deserialize OneVsRestClassifier: invalid model payload.");
-
-        var classLabelsArr = jObj["ClassLabels"]?.ToObject<double[]>();
-        if (classLabelsArr is not null)
-        {
-            ClassLabels = new Vector<T>(classLabelsArr.Length);
-            for (int i = 0; i < classLabelsArr.Length; i++)
-                ClassLabels[i] = NumOps.FromDouble(classLabelsArr[i]);
-        }
-        NumClasses = jObj["NumClasses"]?.ToObject<int>() ?? 0;
-        NumFeatures = jObj["NumFeatures"]?.ToObject<int>() ?? 0;
-        TaskType = (ClassificationTaskType)(jObj["TaskType"]?.ToObject<int>() ?? 0);
-        LabelNames = jObj["LabelNames"]?.ToObject<string[]>();
-
-        var types = jObj["EstimatorTypes"]?.ToObject<string[]>();
-        var data = jObj["EstimatorData"]?.ToObject<string[]>();
-        if (types is null || data is null || types.Length != data.Length)
-            throw new InvalidOperationException(
-                "Failed to deserialize OneVsRestClassifier: estimator types/data arrays are missing or mismatched.");
-        if (NumClasses > 0 && types.Length != NumClasses)
-            throw new InvalidOperationException(
-                $"Failed to deserialize OneVsRestClassifier: expected {NumClasses} estimators but found {types.Length}.");
-
-        _estimators = new IClassifier<T>[types.Length];
-        for (int i = 0; i < types.Length; i++)
-            _estimators[i] = ClassifierRegistry<T>.DeserializeClassifier(types[i], data[i]);
-    }
-
-    /// <inheritdoc/>
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        if (EstimatorFactory is null)
-        {
-            throw new InvalidOperationException("Estimator factory is not set.");
-        }
-
-        return new OneVsRestClassifier<T>(EstimatorFactory, new MetaClassifierOptions<T>
-        {
-            NumJobs = Options.NumJobs
-        });
-    }
-
-    /// <inheritdoc/>
-    public override IFullModel<T, Matrix<T>, Vector<T>> Clone()
-    {
-        var clone = (OneVsRestClassifier<T>)CreateNewInstance();
-
-        clone.NumFeatures = NumFeatures;
-        clone.NumClasses = NumClasses;
-        clone.TaskType = TaskType;
-
-        if (ClassLabels is not null)
-        {
-            clone.ClassLabels = new Vector<T>(ClassLabels.Length);
-            for (int i = 0; i < ClassLabels.Length; i++)
-            {
-                clone.ClassLabels[i] = ClassLabels[i];
-            }
-        }
-
-        if (_estimators is not null)
-        {
-            clone._estimators = new IClassifier<T>[NumClasses];
-            for (int c = 0; c < NumClasses; c++)
-            {
-                if (_estimators[c] is IFullModel<T, Matrix<T>, Vector<T>> fullModel)
-                {
-                    clone._estimators[c] = (IClassifier<T>)fullModel.Clone();
-                }
-                else
-                {
-                    clone._estimators[c] = _estimators[c];
-                }
-            }
-        }
-
-        return clone;
-    }
 }
diff --git a/src/Classification/Meta/StackingClassifier.cs b/src/Classification/Meta/StackingClassifier.cs
index ce5c31fdd1..b412151c2f 100644
--- a/src/Classification/Meta/StackingClassifier.cs
+++ b/src/Classification/Meta/StackingClassifier.cs
@@ -495,173 +495,6 @@ public override Matrix<T> PredictLogProbabilities(Matrix<T> input)
         return logProbs;
     }
 
-    /// <inheritdoc/>
-    public override byte[] Serialize()
-    {
-        var estimatorTypes = new List<string>();
-        var estimatorData = new List<string>();
-        if (_estimators is not null)
-        {
-            foreach (var est in _estimators)
-            {
-                var (typeName, data) = ClassifierRegistry<T>.SerializeClassifier(est);
-                estimatorTypes.Add(typeName);
-                estimatorData.Add(data);
-            }
-        }
-
-        string? finalType = null;
-        string? finalData = null;
-        if (_finalEstimator is not null)
-        {
-            var (ft, fd) = ClassifierRegistry<T>.SerializeClassifier(_finalEstimator);
-            finalType = ft;
-            finalData = fd;
-        }
-
-        var modelDict = new Dictionary<string, object?>
-        {
-            { "ClassLabels", ClassLabels?.ToArray().Select(NumOps.ToDouble).ToArray() },
-            { "NumClasses", NumClasses },
-            { "NumFeatures", NumFeatures },
-            { "TaskType", (int)TaskType },
-            { "CrossValidationFolds", Options.CrossValidationFolds },
-            { "UseProbabilities", Options.UseProbabilities },
-            { "Passthrough", Options.Passthrough },
-            { "EstimatorTypes", estimatorTypes },
-            { "EstimatorData", estimatorData },
-            { "FinalEstimatorType", finalType },
-            { "FinalEstimatorData", finalData }
-        };
-
-        var metadata = GetModelMetadata();
-        metadata.ModelData = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(modelDict));
-        return Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(metadata));
-    }
-
-    /// <inheritdoc/>
-    public override void Deserialize(byte[] modelData)
-    {
-        var jsonString = Encoding.UTF8.GetString(modelData);
-        var metadata = JsonConvert.DeserializeObject<ModelMetadata<T>>(jsonString)
-            ?? throw new InvalidOperationException("Failed to deserialize StackingClassifier: invalid metadata.");
-        if (metadata.ModelData is null)
-            throw new InvalidOperationException("Failed to deserialize StackingClassifier: missing model data.");
-
-        var dataString = Encoding.UTF8.GetString(metadata.ModelData);
-        var jObj = JsonConvert.DeserializeObject<JObject>(dataString)
-            ?? throw new InvalidOperationException("Failed to deserialize StackingClassifier: invalid model payload.");
-
-        var classLabelsArr = jObj["ClassLabels"]?.ToObject<double[]>();
-        if (classLabelsArr is not null)
-        {
-            ClassLabels = new Vector<T>(classLabelsArr.Length);
-            for (int i = 0; i < classLabelsArr.Length; i++)
-                ClassLabels[i] = NumOps.FromDouble(classLabelsArr[i]);
-        }
-        NumClasses = jObj["NumClasses"]?.ToObject<int>() ?? 0;
-        NumFeatures = jObj["NumFeatures"]?.ToObject<int>() ?? 0;
-        TaskType = (ClassificationTaskType)(jObj["TaskType"]?.ToObject<int>() ?? 0);
-        Options.CrossValidationFolds = jObj["CrossValidationFolds"]?.ToObject<int>() ?? Options.CrossValidationFolds;
-        Options.UseProbabilities = jObj["UseProbabilities"]?.ToObject<bool>() ?? Options.UseProbabilities;
-        Options.Passthrough = jObj["Passthrough"]?.ToObject<bool>() ?? Options.Passthrough;
-
-        var types = jObj["EstimatorTypes"]?.ToObject<string[]>();
-        var data = jObj["EstimatorData"]?.ToObject<string[]>();
-        if (types is null || data is null || types.Length != data.Length)
-            throw new InvalidOperationException(
-                "Failed to deserialize StackingClassifier: estimator types/data arrays are missing or mismatched.");
-
-        _estimators = new List<IClassifier<T>>();
-        for (int i = 0; i < types.Length; i++)
-            _estimators.Add(ClassifierRegistry<T>.DeserializeClassifier(types[i], data[i]));
-
-        var finalType = jObj["FinalEstimatorType"]?.ToObject<string>();
-        var finalData = jObj["FinalEstimatorData"]?.ToObject<string>();
-        if (finalType is not null && finalData is not null)
-        {
-            _finalEstimator = ClassifierRegistry<T>.DeserializeClassifier(finalType, finalData);
-        }
-    }
-
-    /// <inheritdoc/>
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        if (_finalEstimatorFactory is null)
-        {
-            throw new InvalidOperationException("Final estimator factory is not set.");
-        }
-
-        var newEstimators = new List<IClassifier<T>>();
-
-        if (_estimators is not null)
-        {
-            foreach (var est in _estimators)
-            {
-                if (est is IFullModel<T, Matrix<T>, Vector<T>> fullModel)
-                {
-                    newEstimators.Add((IClassifier<T>)fullModel.Clone());
-                }
-                else
-                {
-                    newEstimators.Add(est);
-                }
-            }
-        }
-
-        return new StackingClassifier<T>(newEstimators, _finalEstimatorFactory, new StackingClassifierOptions<T>
-        {
-            CrossValidationFolds = Options.CrossValidationFolds,
-            UseProbabilities = Options.UseProbabilities,
-            Passthrough = Options.Passthrough,
-            Seed = Options.Seed
-        });
-    }
-
-    /// <inheritdoc/>
-    public override IFullModel<T, Matrix<T>, Vector<T>> Clone()
-    {
-        var clone = (StackingClassifier<T>)CreateNewInstance();
-
-        clone.NumFeatures = NumFeatures;
-        clone.NumClasses = NumClasses;
-        clone.TaskType = TaskType;
-
-        if (ClassLabels is not null)
-        {
-            clone.ClassLabels = new Vector<T>(ClassLabels.Length);
-            for (int i = 0; i < ClassLabels.Length; i++)
-            {
-                clone.ClassLabels[i] = ClassLabels[i];
-            }
-        }
-
-        if (_finalEstimator is IFullModel<T, Matrix<T>, Vector<T>> finalFullModel)
-        {
-            clone._finalEstimator = (IClassifier<T>)finalFullModel.Clone();
-        }
-
-        // Clone trained base estimators
-        if (_estimators is not null)
-        {
-            clone._estimators = new List<IClassifier<T>>(_estimators.Count);
-            for (int e = 0; e < _estimators.Count; e++)
-            {
-                if (_estimators[e] is IFullModel<T, Matrix<T>, Vector<T>> fullModel)
-                {
-                    clone._estimators.Add((IClassifier<T>)fullModel.Clone());
-                }
-                else
-                {
-                    // Cannot clone, just reference the same instance
-                    clone._estimators.Add(_estimators[e]);
-                }
-            }
-        }
-
-        return clone;
-    }
-
     /// <inheritdoc/>
     public override ModelMetadata<T> GetModelMetadata()
     {
diff --git a/src/Classification/Meta/VotingClassifier.cs b/src/Classification/Meta/VotingClassifier.cs
index f958ca08c1..6d3748ce2d 100644
--- a/src/Classification/Meta/VotingClassifier.cs
+++ b/src/Classification/Meta/VotingClassifier.cs
@@ -334,133 +334,6 @@ public override Matrix<T> PredictLogProbabilities(Matrix<T> input)
         return logProbs;
     }
 
-    /// <inheritdoc/>
-    public override byte[] Serialize()
-    {
-        var estimatorTypes = new List<string>();
-        var estimatorData = new List<string>();
-        if (_estimators is not null)
-        {
-            foreach (var est in _estimators)
-            {
-                var (typeName, data) = ClassifierRegistry<T>.SerializeClassifier(est);
-                estimatorTypes.Add(typeName);
-                estimatorData.Add(data);
-            }
-        }
-
-        var modelDict = new Dictionary<string, object?>
-        {
-            { "ClassLabels", ClassLabels?.ToArray().Select(NumOps.ToDouble).ToArray() },
-            { "NumClasses", NumClasses },
-            { "NumFeatures", NumFeatures },
-            { "TaskType", (int)TaskType },
-            { "Weights", _weights },
-            { "VotingType", (int)Options.Voting },
-            { "EstimatorTypes", estimatorTypes },
-            { "EstimatorData", estimatorData }
-        };
-
-        var metadata = GetModelMetadata();
-        metadata.ModelData = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(modelDict));
-        return Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(metadata));
-    }
-
-    /// <inheritdoc/>
-    public override void Deserialize(byte[] modelData)
-    {
-        var jsonString = Encoding.UTF8.GetString(modelData);
-        var metadata = JsonConvert.DeserializeObject<ModelMetadata<T>>(jsonString)
-            ?? throw new InvalidOperationException("Failed to deserialize VotingClassifier: invalid metadata.");
-        if (metadata.ModelData is null)
-            throw new InvalidOperationException("Failed to deserialize VotingClassifier: missing model data.");
-
-        var dataString = Encoding.UTF8.GetString(metadata.ModelData);
-        var jObj = JsonConvert.DeserializeObject<JObject>(dataString)
-            ?? throw new InvalidOperationException("Failed to deserialize VotingClassifier: invalid model payload.");
-
-        var classLabelsArr = jObj["ClassLabels"]?.ToObject<double[]>();
-        if (classLabelsArr is not null)
-        {
-            ClassLabels = new Vector<T>(classLabelsArr.Length);
-            for (int i = 0; i < classLabelsArr.Length; i++)
-                ClassLabels[i] = NumOps.FromDouble(classLabelsArr[i]);
-        }
-        NumClasses = jObj["NumClasses"]?.ToObject<int>() ?? 0;
-        NumFeatures = jObj["NumFeatures"]?.ToObject<int>() ?? 0;
-        TaskType = (ClassificationTaskType)(jObj["TaskType"]?.ToObject<int>() ?? 0);
-        _weights = jObj["Weights"]?.ToObject<double[]>() ?? Array.Empty<double>();
-        Options.Voting = (VotingType)(jObj["VotingType"]?.ToObject<int>() ?? (int)VotingType.Hard);
-
-        var types = jObj["EstimatorTypes"]?.ToObject<string[]>();
-        var data = jObj["EstimatorData"]?.ToObject<string[]>();
-        if (types is null || data is null || types.Length != data.Length)
-            throw new InvalidOperationException(
-                "Failed to deserialize VotingClassifier: estimator types/data arrays are missing or mismatched.");
-
-        _estimators = new List<IClassifier<T>>();
-        for (int i = 0; i < types.Length; i++)
-            _estimators.Add(ClassifierRegistry<T>.DeserializeClassifier(types[i], data[i]));
-
-        if (_weights is not null && _estimators.Count > 0 && _weights.Length != _estimators.Count)
-            throw new InvalidOperationException(
-                $"Failed to deserialize VotingClassifier: weight vector length ({_weights.Length}) does not match estimator count ({_estimators.Count}).");
-    }
-
-    /// <inheritdoc/>
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        var newEstimators = new List<IClassifier<T>>();
-
-        if (_estimators is not null)
-        {
-            foreach (var est in _estimators)
-            {
-                if (est is IFullModel<T, Matrix<T>, Vector<T>> fullModel)
-                {
-                    newEstimators.Add((IClassifier<T>)fullModel.Clone());
-                }
-                else
-                {
-                    newEstimators.Add(est);
-                }
-            }
-        }
-
-        return new VotingClassifier<T>(newEstimators, new VotingClassifierOptions<T>
-        {
-            Voting = Options.Voting,
-            Weights = Options.Weights
-        });
-    }
-
-    /// <inheritdoc/>
-    public override IFullModel<T, Matrix<T>, Vector<T>> Clone()
-    {
-        var clone = (VotingClassifier<T>)CreateNewInstance();
-
-        clone.NumFeatures = NumFeatures;
-        clone.NumClasses = NumClasses;
-        clone.TaskType = TaskType;
-
-        if (ClassLabels is not null)
-        {
-            clone.ClassLabels = new Vector<T>(ClassLabels.Length);
-            for (int i = 0; i < ClassLabels.Length; i++)
-            {
-                clone.ClassLabels[i] = ClassLabels[i];
-            }
-        }
-
-        if (_weights is not null)
-        {
-            clone._weights = new double[_weights.Length];
-            Array.Copy(_weights, clone._weights, _weights.Length);
-        }
-
-        return clone;
-    }
-
     /// <inheritdoc/>
     public override ModelMetadata<T> GetModelMetadata()
     {
diff --git a/src/Classification/MultiLabel/BinaryRelevance.cs b/src/Classification/MultiLabel/BinaryRelevance.cs
index 9b0019cfbf..951d873ed7 100644
--- a/src/Classification/MultiLabel/BinaryRelevance.cs
+++ b/src/Classification/MultiLabel/BinaryRelevance.cs
@@ -248,69 +248,6 @@ public override Matrix<T> PredictMultiLabelProbabilities(Matrix<T> input)
 
     #region Serialization
 
-    /// <inheritdoc/>
-    public override byte[] Serialize()
-    {
-        var classifierTypes = new List<string>();
-        var classifierData = new List<string>();
-        if (_labelClassifiers is not null)
-        {
-            foreach (var clf in _labelClassifiers)
-            {
-                var (typeName, data) = ClassifierRegistry<T>.SerializeClassifier(clf);
-                classifierTypes.Add(typeName);
-                classifierData.Add(data);
-            }
-        }
-
-        var modelDict = new Dictionary<string, object?>
-        {
-            { "NumLabels", NumLabels },
-            { "NumFeatures", NumFeatures },
-            { "NumClasses", NumClasses },
-            { "TaskType", (int)TaskType },
-            { "LabelNames", LabelNames },
-            { "ClassifierTypes", classifierTypes },
-            { "ClassifierData", classifierData }
-        };
-
-        var metadata = GetModelMetadata();
-        metadata.ModelData = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(modelDict));
-        return Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(metadata));
-    }
-
-    /// <inheritdoc/>
-    public override void Deserialize(byte[] modelData)
-    {
-        var jsonString = Encoding.UTF8.GetString(modelData);
-        var metadata = JsonConvert.DeserializeObject<ModelMetadata<T>>(jsonString)
-            ?? throw new InvalidOperationException("Failed to deserialize BinaryRelevance: invalid metadata.");
-        if (metadata.ModelData is null)
-            throw new InvalidOperationException("Failed to deserialize BinaryRelevance: missing model data.");
-
-        var dataString = Encoding.UTF8.GetString(metadata.ModelData);
-        var jObj = JsonConvert.DeserializeObject<JObject>(dataString)
-            ?? throw new InvalidOperationException("Failed to deserialize BinaryRelevance: invalid model payload.");
-
-        NumLabels = jObj["NumLabels"]?.ToObject<int>() ?? 0;
-        NumFeatures = jObj["NumFeatures"]?.ToObject<int>() ?? 0;
-        NumClasses = jObj["NumClasses"]?.ToObject<int>() ?? 2;
-        TaskType = (ClassificationTaskType)(jObj["TaskType"]?.ToObject<int>() ?? 0);
-        LabelNames = jObj["LabelNames"]?.ToObject<string[]>();
-
-        var types = jObj["ClassifierTypes"]?.ToObject<string[]>();
-        var data = jObj["ClassifierData"]?.ToObject<string[]>();
-        if (types is null || data is null || types.Length != data.Length)
-            throw new InvalidOperationException(
-                "Failed to deserialize BinaryRelevance: classifier types/data arrays are missing or mismatched.");
-
-        _labelClassifiers = new IClassifier<T>[types.Length];
-        for (int i = 0; i < types.Length; i++)
-        {
-            _labelClassifiers[i] = ClassifierRegistry<T>.DeserializeClassifier(types[i], data[i]);
-        }
-    }
-
     #endregion
 
     #region Abstract Method Implementations
@@ -409,49 +346,5 @@ public override void ApplyGradients(Vector<T> gradients, T learningRate)
         }
     }
 
-    /// <summary>
-    /// Creates a new instance of this classifier with default configuration.
-    /// </summary>
-    /// <returns>A new BinaryRelevance instance.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> This is used internally for operations like cloning or serialization.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Matrix<T>, Matrix<T>> CreateNewInstance()
-    {
-        return new BinaryRelevance<T>(_classifierFactory, Options, Regularization);
-    }
-
-    /// <summary>
-    /// Creates a deep copy of this classifier.
-    /// </summary>
-    /// <returns>A new instance with the same parameters and state.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Cloning creates an independent copy of the classifier,
-    /// including all its internal label classifiers.
-    /// </para>
-    /// </remarks>
-    public override IFullModel<T, Matrix<T>, Matrix<T>> Clone()
-    {
-        var clone = new BinaryRelevance<T>(_classifierFactory, Options, Regularization);
-        clone.NumLabels = NumLabels;
-        clone.NumFeatures = NumFeatures;
-        clone.NumClasses = NumClasses;
-        clone.TaskType = TaskType;
-
-        if (_labelClassifiers is not null)
-        {
-            clone._labelClassifiers = new IClassifier<T>[_labelClassifiers.Length];
-            for (int i = 0; i < _labelClassifiers.Length; i++)
-            {
-                clone._labelClassifiers[i] = (IClassifier<T>)_labelClassifiers[i].Clone();
-            }
-        }
-
-        return clone;
-    }
-
     #endregion
 }
diff --git a/src/Classification/MultiLabel/ClassifierChainClassifier.cs b/src/Classification/MultiLabel/ClassifierChainClassifier.cs
index d1c8b318f7..4900418d3c 100644
--- a/src/Classification/MultiLabel/ClassifierChainClassifier.cs
+++ b/src/Classification/MultiLabel/ClassifierChainClassifier.cs
@@ -73,7 +73,7 @@ namespace AiDotNet.Classification.MultiLabel;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Matrix<>), typeof(Matrix<>))]
 [ResearchPaper("Classifier Chains for Multi-Label Classification", "https://doi.org/10.1007/s10994-011-5256-5", Year = 2011, Authors = "Jesse Read, Bernhard Pfahringer, Geoff Holmes, Eibe Frank")]
-public class ClassifierChainClassifier<T> : MultiLabelClassifierBase<T>
+public partial class ClassifierChainClassifier<T> : MultiLabelClassifierBase<T>
 {
 
     /// <inheritdoc />
@@ -473,75 +473,6 @@ public override Matrix<T> PredictMultiLabelProbabilities(Matrix<T> input)
 
     #region Serialization
 
-    /// <inheritdoc/>
-    public override byte[] Serialize()
-    {
-        var classifierTypes = new List<string>();
-        var classifierData = new List<string>();
-        if (_chainClassifiers is not null)
-        {
-            foreach (var clf in _chainClassifiers)
-            {
-                var (typeName, data) = ClassifierRegistry<T>.SerializeClassifier(clf);
-                classifierTypes.Add(typeName);
-                classifierData.Add(data);
-            }
-        }
-
-        var modelDict = new Dictionary<string, object?>
-        {
-            { "NumLabels", NumLabels },
-            { "NumFeatures", NumFeatures },
-            { "NumClasses", NumClasses },
-            { "TaskType", (int)TaskType },
-            { "LabelNames", LabelNames },
-            { "ChainOrder", _chainOrder },
-            { "ClassifierTypes", classifierTypes },
-            { "ClassifierData", classifierData }
-        };
-
-        var metadata = GetModelMetadata();
-        metadata.ModelData = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(modelDict));
-        return Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(metadata));
-    }
-
-    /// <inheritdoc/>
-    public override void Deserialize(byte[] modelData)
-    {
-        var jsonString = Encoding.UTF8.GetString(modelData);
-        var metadata = JsonConvert.DeserializeObject<ModelMetadata<T>>(jsonString)
-            ?? throw new InvalidOperationException("Failed to deserialize ClassifierChainClassifier: invalid metadata.");
-        if (metadata.ModelData is null)
-            throw new InvalidOperationException("Failed to deserialize ClassifierChainClassifier: missing model data.");
-
-        var dataString = Encoding.UTF8.GetString(metadata.ModelData);
-        var jObj = JsonConvert.DeserializeObject<JObject>(dataString)
-            ?? throw new InvalidOperationException("Failed to deserialize ClassifierChainClassifier: invalid model payload.");
-
-        NumLabels = jObj["NumLabels"]?.ToObject<int>() ?? 0;
-        NumFeatures = jObj["NumFeatures"]?.ToObject<int>() ?? 0;
-        NumClasses = jObj["NumClasses"]?.ToObject<int>() ?? 2;
-        TaskType = (ClassificationTaskType)(jObj["TaskType"]?.ToObject<int>() ?? 0);
-        LabelNames = jObj["LabelNames"]?.ToObject<string[]>();
-        _chainOrder = jObj["ChainOrder"]?.ToObject<int[]>();
-
-        var types = jObj["ClassifierTypes"]?.ToObject<string[]>();
-        var data = jObj["ClassifierData"]?.ToObject<string[]>();
-        if (types is null || data is null || types.Length != data.Length)
-            throw new InvalidOperationException(
-                "Failed to deserialize ClassifierChainClassifier: classifier types/data arrays are missing or mismatched.");
-
-        if (_chainOrder is not null && _chainOrder.Length != types.Length)
-            throw new InvalidOperationException(
-                $"Failed to deserialize ClassifierChainClassifier: ChainOrder length ({_chainOrder.Length}) does not match classifier count ({types.Length}).");
-
-        _chainClassifiers = new IClassifier<T>[types.Length];
-        for (int i = 0; i < types.Length; i++)
-        {
-            _chainClassifiers[i] = ClassifierRegistry<T>.DeserializeClassifier(types[i], data[i]);
-        }
-    }
-
     #endregion
 
     #region Abstract Method Implementations
@@ -641,52 +572,6 @@ public override void ApplyGradients(Vector<T> gradients, T learningRate)
         }
     }
 
-    /// <summary>
-    /// Creates a new instance of this classifier with default configuration.
-    /// </summary>
-    /// <returns>A new ClassifierChainClassifier instance.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> This is used internally for operations like cloning or serialization.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Matrix<T>, Matrix<T>> CreateNewInstance()
-    {
-        return new ClassifierChainClassifier<T>(_classifierFactory, _specifiedOrder, _useRandomOrder, null, Options, Regularization);
-    }
-
-    /// <summary>
-    /// Creates a deep copy of this classifier.
-    /// </summary>
-    /// <returns>A new instance with the same parameters and state.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Cloning creates an independent copy of the classifier,
-    /// including all its chain classifiers and the chain order.
-    /// </para>
-    /// </remarks>
-    public override IFullModel<T, Matrix<T>, Matrix<T>> Clone()
-    {
-        var clone = new ClassifierChainClassifier<T>(
-            _classifierFactory, _specifiedOrder, _useRandomOrder, _random.Next(), Options, Regularization);
-        clone.NumLabels = NumLabels;
-        clone.NumFeatures = NumFeatures;
-        clone.NumClasses = NumClasses;
-        clone.TaskType = TaskType;
-        clone._chainOrder = _chainOrder?.ToArray();
-
-        if (_chainClassifiers is not null)
-        {
-            clone._chainClassifiers = new IClassifier<T>[_chainClassifiers.Length];
-            for (int i = 0; i < _chainClassifiers.Length; i++)
-            {
-                clone._chainClassifiers[i] = (IClassifier<T>)_chainClassifiers[i].Clone();
-            }
-        }
-
-        return clone;
-    }
-
     #endregion
 
     #region Properties
diff --git a/src/Classification/MultiLabel/LabelPowerset.cs b/src/Classification/MultiLabel/LabelPowerset.cs
index 89c49fd2b6..539a141625 100644
--- a/src/Classification/MultiLabel/LabelPowerset.cs
+++ b/src/Classification/MultiLabel/LabelPowerset.cs
@@ -85,7 +85,7 @@ namespace AiDotNet.Classification.MultiLabel;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Matrix<>), typeof(Matrix<>))]
 [ResearchPaper("Learning multi-label scene classification", "https://doi.org/10.1016/j.patcog.2004.01.013", Year = 2004, Authors = "Matthew R. Boutell, Jiebo Luo, Xipeng Shen, Christopher M. Brown")]
-public class LabelPowerset<T> : MultiLabelClassifierBase<T>
+public partial class LabelPowerset<T> : MultiLabelClassifierBase<T>
 {
 
     /// <inheritdoc />
@@ -398,90 +398,6 @@ public override Matrix<T> PredictMultiLabelProbabilities(Matrix<T> input)
 
     #region Serialization
 
-    /// <inheritdoc/>
-    public override byte[] Serialize()
-    {
-        string? classifierTypeName = null;
-        string? classifierDataStr = null;
-        if (_classifier is not null)
-        {
-            var (typeName, data) = ClassifierRegistry<T>.SerializeClassifier(_classifier);
-            classifierTypeName = typeName;
-            classifierDataStr = data;
-        }
-
-        // Serialize _classToLabels as Dictionary<string, bool[]> (JSON can't use int keys directly)
-        Dictionary<string, bool[]>? classToLabelsStr = null;
-        if (_classToLabels is not null)
-        {
-            classToLabelsStr = new Dictionary<string, bool[]>();
-            foreach (var kvp in _classToLabels)
-            {
-                classToLabelsStr[kvp.Key.ToString()] = kvp.Value;
-            }
-        }
-
-        var modelDict = new Dictionary<string, object?>
-        {
-            { "NumLabels", NumLabels },
-            { "NumFeatures", NumFeatures },
-            { "NumClasses", NumClasses },
-            { "TaskType", (int)TaskType },
-            { "LabelNames", LabelNames },
-            { "NumCombinations", _numCombinations },
-            { "ClassToLabels", classToLabelsStr },
-            { "LabelsToClass", _labelsToClass },
-            { "ClassifierType", classifierTypeName },
-            { "ClassifierData", classifierDataStr }
-        };
-
-        var metadata = GetModelMetadata();
-        metadata.ModelData = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(modelDict));
-        return Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(metadata));
-    }
-
-    /// <inheritdoc/>
-    public override void Deserialize(byte[] modelData)
-    {
-        var jsonString = Encoding.UTF8.GetString(modelData);
-        var metadata = JsonConvert.DeserializeObject<ModelMetadata<T>>(jsonString)
-            ?? throw new InvalidOperationException("Failed to deserialize LabelPowerset: invalid metadata.");
-        if (metadata.ModelData is null)
-            throw new InvalidOperationException("Failed to deserialize LabelPowerset: missing model data.");
-
-        var dataString = Encoding.UTF8.GetString(metadata.ModelData);
-        var jObj = JsonConvert.DeserializeObject<JObject>(dataString)
-            ?? throw new InvalidOperationException("Failed to deserialize LabelPowerset: invalid model payload.");
-
-        NumLabels = jObj["NumLabels"]?.ToObject<int>() ?? 0;
-        NumFeatures = jObj["NumFeatures"]?.ToObject<int>() ?? 0;
-        NumClasses = jObj["NumClasses"]?.ToObject<int>() ?? 2;
-        TaskType = (ClassificationTaskType)(jObj["TaskType"]?.ToObject<int>() ?? 0);
-        LabelNames = jObj["LabelNames"]?.ToObject<string[]>();
-        _numCombinations = jObj["NumCombinations"]?.ToObject<int>() ?? 0;
-
-        // Deserialize _classToLabels from string-keyed dictionary
-        var classToLabelsStr = jObj["ClassToLabels"]?.ToObject<Dictionary<string, bool[]>>();
-        if (classToLabelsStr is not null)
-        {
-            _classToLabels = new Dictionary<int, bool[]>();
-            foreach (var kvp in classToLabelsStr)
-            {
-                _classToLabels[int.Parse(kvp.Key)] = kvp.Value;
-            }
-        }
-
-        _labelsToClass = jObj["LabelsToClass"]?.ToObject<Dictionary<string, int>>();
-
-        var classifierType = jObj["ClassifierType"]?.ToObject<string>();
-        var classifierDataVal = jObj["ClassifierData"]?.ToObject<string>();
-        if (classifierType is null || classifierDataVal is null)
-            throw new InvalidOperationException(
-                "Failed to deserialize LabelPowerset: classifier type/data is missing.");
-
-        _classifier = ClassifierRegistry<T>.DeserializeClassifier(classifierType, classifierDataVal);
-    }
-
     #endregion
 
     #region Abstract Method Implementations
@@ -560,61 +476,6 @@ public override void ApplyGradients(Vector<T> gradients, T learningRate)
         (_classifier as IGradientComputable<T, Matrix<T>, Vector<T>>)?.ApplyGradients(gradients, learningRate);
     }
 
-    /// <summary>
-    /// Creates a new instance of this classifier with default configuration.
-    /// </summary>
-    /// <returns>A new LabelPowerset instance.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> This is used internally for operations like cloning or serialization.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Matrix<T>, Matrix<T>> CreateNewInstance()
-    {
-        return new LabelPowerset<T>(_classifierFactory, Options, Regularization);
-    }
-
-    /// <summary>
-    /// Creates a deep copy of this classifier.
-    /// </summary>
-    /// <returns>A new instance with the same parameters and state.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Cloning creates an independent copy of the classifier,
-    /// including its label mappings and underlying classifier.
-    /// </para>
-    /// </remarks>
-    public override IFullModel<T, Matrix<T>, Matrix<T>> Clone()
-    {
-        var clone = new LabelPowerset<T>(_classifierFactory, Options, Regularization);
-        clone.NumLabels = NumLabels;
-        clone.NumFeatures = NumFeatures;
-        clone.NumClasses = NumClasses;
-        clone.TaskType = TaskType;
-        clone._numCombinations = _numCombinations;
-
-        if (_classToLabels is not null)
-        {
-            clone._classToLabels = new Dictionary<int, bool[]>();
-            foreach (var kvp in _classToLabels)
-            {
-                clone._classToLabels[kvp.Key] = kvp.Value.ToArray();
-            }
-        }
-
-        if (_labelsToClass is not null)
-        {
-            clone._labelsToClass = new Dictionary<string, int>(_labelsToClass);
-        }
-
-        if (_classifier is not null)
-        {
-            clone._classifier = (IClassifier<T>)_classifier.Clone();
-        }
-
-        return clone;
-    }
-
     #endregion
 
     #region Properties
diff --git a/src/Classification/MultiLabel/MLkNNClassifier.cs b/src/Classification/MultiLabel/MLkNNClassifier.cs
index 87e75c2c4b..1518d08ba3 100644
--- a/src/Classification/MultiLabel/MLkNNClassifier.cs
+++ b/src/Classification/MultiLabel/MLkNNClassifier.cs
@@ -68,14 +68,16 @@ namespace AiDotNet.Classification.MultiLabel;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Matrix<>), typeof(Matrix<>))]
 [ResearchPaper("ML-KNN: A Lazy Learning Approach to Multi-Label Learning", "https://doi.org/10.1016/j.patcog.2006.12.019", Year = 2007, Authors = "Min-Ling Zhang, Zhi-Hua Zhou")]
-public class MLkNNClassifier<T> : MultiLabelClassifierBase<T>
+public partial class MLkNNClassifier<T> : MultiLabelClassifierBase<T>
 {
     private readonly MLkNNOptions<T> _options;
 
     /// <inheritdoc/>
     public override ModelOptions GetOptions() => _options;
     private readonly Random _random;
+    [AiDotNet.Attributes.FittedParameter]
     private Matrix<T> _trainFeatures = new Matrix<T>(0, 0);
+    [AiDotNet.Attributes.FittedParameter]
     private Matrix<T> _trainLabels = new Matrix<T>(0, 0);
     private double[]? _priorProbs; // P(H_l = 1)
     private double[,] _condProbsPos = new double[0, 0]; // P(E_l = j | H_l = 1) for j = 0..k
@@ -351,164 +353,5 @@ private void RestoreProbabilityParameters(Vector<T> parameters)
                 _condProbsNeg[l, j] = NumOps.ToDouble(parameters[idx++]);
     }
 
-    /// <inheritdoc/>
-    public override byte[] Serialize()
-    {
-        int k = _options.KNeighbors;
-
-        // Serialize training features as double[][]
-        double[][]? trainFeaturesArr = null;
-        if (_trainFeatures is not null)
-        {
-            trainFeaturesArr = new double[_trainFeatures.Rows][];
-            for (int i = 0; i < _trainFeatures.Rows; i++)
-            {
-                trainFeaturesArr[i] = new double[_trainFeatures.Columns];
-                for (int j = 0; j < _trainFeatures.Columns; j++)
-                {
-                    trainFeaturesArr[i][j] = NumOps.ToDouble(_trainFeatures[i, j]);
-                }
-            }
-        }
-
-        // Serialize training labels as double[][]
-        double[][]? trainLabelsArr = null;
-        if (_trainLabels is not null)
-        {
-            trainLabelsArr = new double[_trainLabels.Rows][];
-            for (int i = 0; i < _trainLabels.Rows; i++)
-            {
-                trainLabelsArr[i] = new double[_trainLabels.Columns];
-                for (int j = 0; j < _trainLabels.Columns; j++)
-                {
-                    trainLabelsArr[i][j] = NumOps.ToDouble(_trainLabels[i, j]);
-                }
-            }
-        }
-
-        // Serialize 2D conditional probability arrays as double[][]
-        double[][]? condProbsPosArr = null;
-        double[][]? condProbsNegArr = null;
-        if (_condProbsPos is not null && _condProbsNeg is not null)
-        {
-            condProbsPosArr = new double[NumLabels][];
-            condProbsNegArr = new double[NumLabels][];
-            for (int l = 0; l < NumLabels; l++)
-            {
-                condProbsPosArr[l] = new double[k + 1];
-                condProbsNegArr[l] = new double[k + 1];
-                for (int j = 0; j <= k; j++)
-                {
-                    condProbsPosArr[l][j] = _condProbsPos[l, j];
-                    condProbsNegArr[l][j] = _condProbsNeg[l, j];
-                }
-            }
-        }
-
-        var modelDict = new Dictionary<string, object?>
-        {
-            { "NumLabels", NumLabels },
-            { "NumFeatures", NumFeatures },
-            { "NumClasses", NumClasses },
-            { "TaskType", (int)TaskType },
-            { "LabelNames", LabelNames },
-            { "KNeighbors", k },
-            { "Smoothing", _options.Smoothing },
-            { "PriorProbs", _priorProbs },
-            { "CondProbsPos", condProbsPosArr },
-            { "CondProbsNeg", condProbsNegArr },
-            { "TrainFeatures", trainFeaturesArr },
-            { "TrainLabels", trainLabelsArr }
-        };
-
-        var metadata = GetModelMetadata();
-        metadata.ModelData = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(modelDict));
-        return Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(metadata));
-    }
-
-    /// <inheritdoc/>
-    public override void Deserialize(byte[] modelData)
-    {
-        var jsonString = Encoding.UTF8.GetString(modelData);
-        var metadata = JsonConvert.DeserializeObject<ModelMetadata<T>>(jsonString)
-            ?? throw new InvalidOperationException("Failed to deserialize MLkNNClassifier: invalid metadata.");
-        if (metadata.ModelData is null)
-            throw new InvalidOperationException("Failed to deserialize MLkNNClassifier: missing model data.");
-
-        var dataString = Encoding.UTF8.GetString(metadata.ModelData);
-        var jObj = JsonConvert.DeserializeObject<JObject>(dataString)
-            ?? throw new InvalidOperationException("Failed to deserialize MLkNNClassifier: invalid model payload.");
-
-        NumLabels = jObj["NumLabels"]?.ToObject<int>() ?? 0;
-        NumFeatures = jObj["NumFeatures"]?.ToObject<int>() ?? 0;
-        NumClasses = jObj["NumClasses"]?.ToObject<int>() ?? 2;
-        TaskType = (ClassificationTaskType)(jObj["TaskType"]?.ToObject<int>() ?? 0);
-        LabelNames = jObj["LabelNames"]?.ToObject<string[]>();
-        _options.Smoothing = jObj["Smoothing"]?.ToObject<double>() ?? _options.Smoothing;
-
-        _priorProbs = jObj["PriorProbs"]?.ToObject<double[]>();
-
-        int k = jObj["KNeighbors"]?.ToObject<int>() ?? _options.KNeighbors;
-
-        var condProbsPosArr = jObj["CondProbsPos"]?.ToObject<double[][]>();
-        var condProbsNegArr = jObj["CondProbsNeg"]?.ToObject<double[][]>();
-        if (condProbsPosArr is not null && condProbsNegArr is not null)
-        {
-            if (condProbsPosArr.Length < NumLabels)
-                throw new InvalidOperationException(
-                    $"Failed to deserialize MLkNNClassifier: CondProbsPos has {condProbsPosArr.Length} rows but expected at least {NumLabels}.");
-            if (condProbsNegArr.Length < NumLabels)
-                throw new InvalidOperationException(
-                    $"Failed to deserialize MLkNNClassifier: CondProbsNeg has {condProbsNegArr.Length} rows but expected at least {NumLabels}.");
-
-            _condProbsPos = new double[NumLabels, k + 1];
-            _condProbsNeg = new double[NumLabels, k + 1];
-            for (int l = 0; l < NumLabels && l < condProbsPosArr.Length; l++)
-            {
-                for (int j = 0; j <= k && j < condProbsPosArr[l].Length; j++)
-                {
-                    _condProbsPos[l, j] = condProbsPosArr[l][j];
-                    _condProbsNeg[l, j] = condProbsNegArr[l][j];
-                }
-            }
-        }
-
-        var trainFeaturesArr = jObj["TrainFeatures"]?.ToObject<double[][]>();
-        if (trainFeaturesArr is not null && trainFeaturesArr.Length > 0)
-        {
-            int rows = trainFeaturesArr.Length;
-            int cols = trainFeaturesArr[0].Length;
-            _trainFeatures = new Matrix<T>(rows, cols);
-            for (int i = 0; i < rows; i++)
-            {
-                for (int j = 0; j < cols; j++)
-                {
-                    _trainFeatures[i, j] = NumOps.FromDouble(trainFeaturesArr[i][j]);
-                }
-            }
-        }
-
-        var trainLabelsArr = jObj["TrainLabels"]?.ToObject<double[][]>();
-        if (trainLabelsArr is not null && trainLabelsArr.Length > 0)
-        {
-            int rows = trainLabelsArr.Length;
-            int cols = trainLabelsArr[0].Length;
-            _trainLabels = new Matrix<T>(rows, cols);
-            for (int i = 0; i < rows; i++)
-            {
-                for (int j = 0; j < cols; j++)
-                {
-                    _trainLabels[i, j] = NumOps.FromDouble(trainLabelsArr[i][j]);
-                }
-            }
-        }
-    }
-
     /// <inheritdoc />
-
-    /// <inheritdoc />
-    protected override IFullModel<T, Matrix<T>, Matrix<T>> CreateNewInstance()
-    {
-        return new MLkNNClassifier<T>(_options);
-    }
 }
diff --git a/src/Classification/MultiLabel/MultiLabelClassifierBase.cs b/src/Classification/MultiLabel/MultiLabelClassifierBase.cs
index 744fe186c4..6afc404fca 100644
--- a/src/Classification/MultiLabel/MultiLabelClassifierBase.cs
+++ b/src/Classification/MultiLabel/MultiLabelClassifierBase.cs
@@ -19,9 +19,52 @@ namespace AiDotNet.Classification.MultiLabel;
 /// traditional classification which assigns exactly one label.</para>
 /// </remarks>
 /// <typeparam name="T">The numeric type for calculations.</typeparam>
-public abstract class MultiLabelClassifierBase<T> : IMultiLabelClassifier<T>, IConfigurableModel<T>, IModelShape,
+public abstract partial class MultiLabelClassifierBase<T> : IMultiLabelClassifier<T>, IConfigurableModel<T>, IModelShape,
     IParameterManifestProvider
 {
+    // --- declared state (ModelStateRegistry) ---
+    // Identical in every model base because these bases are siblings over the same interfaces rather
+    // than one hierarchy; the logic itself lives once in ModelStateRegistry/ModelStateEnvelope.
+
+    /// <summary>State that is not a parameter vector, declared once and persisted by this base.</summary>
+    private readonly AiDotNet.Models.ModelStateRegistry<T> _declaredState = new();
+    private bool _declaredStateRegistered;
+
+    /// <summary>
+    /// Declare state here that the parameter vector does not carry -- a retained training set,
+    /// fitted knots, kernel centres, an ensemble's children. Both halves of the payload are driven
+    /// by the declaration, so they cannot drift.
+    /// </summary>
+    /// <param name="state">The registry to declare into.</param>
+    protected virtual void RegisterState(AiDotNet.Models.ModelStateRegistry<T> state)
+    {
+    }
+    /// <summary>Generated state declarations for fields declared across this model's hierarchy.</summary>
+    /// <param name="state">The registry to declare into.</param>
+    /// <remarks>
+    /// Emitted by ModelStateGenerator into the partial model, so a model author declares nothing. The
+    /// hand-written <c>RegisterState</c> beside it exists only for state the classifier genuinely
+    /// cannot place; anything it CAN place belongs here, where it cannot be forgotten.
+    /// </remarks>
+    protected virtual void RegisterGeneratedState(AiDotNet.Models.ModelStateRegistry<T> state)
+    {
+        RegisterGeneratedStateCore(state);
+    }
+
+    /// <summary>The declared state, registered once and lazily so it runs after the constructor.</summary>
+    protected AiDotNet.Models.ModelStateRegistry<T> DeclaredState
+    {
+        get
+        {
+            if (!_declaredStateRegistered)
+            {
+                _declaredStateRegistered = true;
+                RegisterGeneratedState(_declaredState);
+                RegisterState(_declaredState);
+            }
+            return _declaredState;
+        }
+    }
     /// <summary>
     /// Gets the hardware-accelerated computation engine for vectorized operations.
     /// </summary>
@@ -254,7 +297,18 @@ public virtual long ParameterCount
     /// <summary>
     /// Creates a new instance of this model type.
     /// </summary>
-    protected abstract IFullModel<T, Matrix<T>, Matrix<T>> CreateNewInstance();
+    /// <remarks>
+    /// <para>
+    /// No longer abstract. Every concrete model used to be forced to write this, and 1147 of them
+    /// did -- each one a hand-copied list of constructor arguments that a new option could fall out
+    /// of without anything failing. The clone plan records that constructor at compile time instead,
+    /// so the base can rebuild the type and a model only overrides this when the generator says it
+    /// cannot: a constructor parameter with nothing holding its value, which the build reports by
+    /// name rather than leaving to be discovered by a clone that comes back subtly different.
+    /// </para>
+    /// </remarks>
+    protected virtual IFullModel<T, Matrix<T>, Matrix<T>> CreateNewInstance()
+        => (IFullModel<T, Matrix<T>, Matrix<T>>)AiDotNet.Models.CloneEngine.CopyConfiguration(this);
 
     /// <inheritdoc />
     public virtual IFullModel<T, Matrix<T>, Matrix<T>> WithParameters(Vector<T> parameters)
@@ -304,7 +358,7 @@ public virtual byte[] Serialize()
     {
         ThrowIfDisposed();
         ModelPersistenceGuard.EnforceBeforeSerialize();
-        return SerializeInternalUnchecked();
+        return AiDotNet.Models.ModelStateEnvelope.Append(DeclaredState, SerializeInternalUnchecked());
     }
 
     /// <summary>
@@ -335,6 +389,9 @@ private byte[] SerializeInternalUnchecked()
     /// <inheritdoc />
     public virtual void Deserialize(byte[] modelData)
     {
+        // Strips and applies any declared-state trailer, so the body below reads the payload
+        // exactly as it did before this existed.
+        modelData = AiDotNet.Models.ModelStateEnvelope.Extract(DeclaredState, modelData);
         ThrowIfDisposed();
         ModelPersistenceGuard.EnforceBeforeDeserialize();
         DeserializeInternalUnchecked(modelData);
diff --git a/src/Classification/MultiLabel/RAkELClassifier.cs b/src/Classification/MultiLabel/RAkELClassifier.cs
index b9762506ee..d885f8aef1 100644
--- a/src/Classification/MultiLabel/RAkELClassifier.cs
+++ b/src/Classification/MultiLabel/RAkELClassifier.cs
@@ -51,7 +51,7 @@ namespace AiDotNet.Classification.MultiLabel;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Matrix<>), typeof(Matrix<>))]
 [ResearchPaper("Random k-Labelsets for Multilabel Classification", "https://doi.org/10.1109/TKDE.2010.164", Year = 2011, Authors = "Grigorios Tsoumakas, Ioannis Katakis, Ioannis Vlahavas")]
-public class RAkELClassifier<T> : MultiLabelClassifierBase<T>
+public partial class RAkELClassifier<T> : MultiLabelClassifierBase<T>
 {
     /// <summary>
     /// Gets the size of each labelset (k parameter).
@@ -333,133 +333,5 @@ protected override void RegisterComponents()
                 () => _labelsetWeights));
     }
 
-    /// <inheritdoc/>
-    public override byte[] Serialize()
-    {
-        // Serialize weight matrices as double[][][]
-        var weightsArr = new List<double[][]>();
-        foreach (var weights in _labelsetWeights)
-        {
-            var matrix = new double[weights.Rows][];
-            for (int i = 0; i < weights.Rows; i++)
-            {
-                matrix[i] = new double[weights.Columns];
-                for (int j = 0; j < weights.Columns; j++)
-                {
-                    matrix[i][j] = NumOps.ToDouble(weights[i, j]);
-                }
-            }
-            weightsArr.Add(matrix);
-        }
-
-        // Serialize inverse label maps as Dictionary<string, int[]>[] (JSON needs string keys)
-        var inverseMapsArr = new List<Dictionary<string, int[]>>();
-        foreach (var map in _inverseLabelMaps)
-        {
-            var strMap = new Dictionary<string, int[]>();
-            foreach (var kvp in map)
-            {
-                strMap[kvp.Key.ToString()] = kvp.Value;
-            }
-            inverseMapsArr.Add(strMap);
-        }
-
-        var modelDict = new Dictionary<string, object?>
-        {
-            { "NumLabels", NumLabels },
-            { "NumFeatures", NumFeatures },
-            { "NumClasses", NumClasses },
-            { "TaskType", (int)TaskType },
-            { "LabelNames", LabelNames },
-            { "LabelsetSize", LabelsetSize },
-            { "NumLabelsets", NumLabelsets },
-            { "Labelsets", _labelsets },
-            { "LabelsetWeights", weightsArr },
-            { "LabelCombinationMaps", _labelCombinationMaps },
-            { "InverseLabelMaps", inverseMapsArr }
-        };
-
-        var metadata = GetModelMetadata();
-        metadata.ModelData = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(modelDict));
-        return Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(metadata));
-    }
-
-    /// <inheritdoc/>
-    public override void Deserialize(byte[] modelData)
-    {
-        var jsonString = Encoding.UTF8.GetString(modelData);
-        var metadata = JsonConvert.DeserializeObject<ModelMetadata<T>>(jsonString)
-            ?? throw new InvalidOperationException("Failed to deserialize RAkELClassifier: invalid metadata.");
-        if (metadata.ModelData is null)
-            throw new InvalidOperationException("Failed to deserialize RAkELClassifier: missing model data.");
-
-        var dataString = Encoding.UTF8.GetString(metadata.ModelData);
-        var jObj = JsonConvert.DeserializeObject<JObject>(dataString)
-            ?? throw new InvalidOperationException("Failed to deserialize RAkELClassifier: invalid model payload.");
-
-        NumLabels = jObj["NumLabels"]?.ToObject<int>() ?? 0;
-        NumFeatures = jObj["NumFeatures"]?.ToObject<int>() ?? 0;
-        NumClasses = jObj["NumClasses"]?.ToObject<int>() ?? 2;
-        TaskType = (ClassificationTaskType)(jObj["TaskType"]?.ToObject<int>() ?? 0);
-        LabelNames = jObj["LabelNames"]?.ToObject<string[]>();
-        var deserializedLabelsetSize = jObj["LabelsetSize"]?.ToObject<int>() ?? LabelsetSize;
-        if (deserializedLabelsetSize < 2)
-            throw new InvalidOperationException(
-                $"Failed to deserialize RAkELClassifier: LabelsetSize ({deserializedLabelsetSize}) must be >= 2.");
-        LabelsetSize = deserializedLabelsetSize;
-        NumLabelsets = jObj["NumLabelsets"]?.ToObject<int>() ?? NumLabelsets;
-
-        // Deserialize labelsets
-        var labelsetsArr = jObj["Labelsets"]?.ToObject<List<int[]>>();
-        _labelsets = labelsetsArr ?? new List<int[]>();
-
-        // Deserialize weight matrices
-        _labelsetWeights = new List<Matrix<T>>();
-        var weightsArr = jObj["LabelsetWeights"]?.ToObject<List<double[][]>>();
-        if (weightsArr is not null)
-        {
-            foreach (var matrixArr in weightsArr)
-            {
-                int rows = matrixArr.Length;
-                int cols = rows > 0 ? matrixArr[0].Length : 0;
-                var matrix = new Matrix<T>(rows, cols);
-                for (int i = 0; i < rows; i++)
-                {
-                    for (int j = 0; j < cols; j++)
-                    {
-                        matrix[i, j] = NumOps.FromDouble(matrixArr[i][j]);
-                    }
-                }
-                _labelsetWeights.Add(matrix);
-            }
-        }
-
-        // Deserialize label combination maps
-        _labelCombinationMaps = jObj["LabelCombinationMaps"]?.ToObject<List<Dictionary<string, int>>>()
-            ?? new List<Dictionary<string, int>>();
-
-        // Deserialize inverse label maps (string keys back to int)
-        _inverseLabelMaps = new List<Dictionary<int, int[]>>();
-        var inverseMapsArr = jObj["InverseLabelMaps"]?.ToObject<List<Dictionary<string, int[]>>>();
-        if (inverseMapsArr is not null)
-        {
-            foreach (var strMap in inverseMapsArr)
-            {
-                var intMap = new Dictionary<int, int[]>();
-                foreach (var kvp in strMap)
-                {
-                    intMap[int.Parse(kvp.Key)] = kvp.Value;
-                }
-                _inverseLabelMaps.Add(intMap);
-            }
-        }
-    }
-
-    /// <inheritdoc />
-
     /// <inheritdoc />
-    protected override IFullModel<T, Matrix<T>, Matrix<T>> CreateNewInstance()
-    {
-        return new RAkELClassifier<T>(LabelsetSize, NumLabelsets, null, Options, Regularization);
-    }
 }
diff --git a/src/Classification/NaiveBayes/BernoulliNaiveBayes.cs b/src/Classification/NaiveBayes/BernoulliNaiveBayes.cs
index 426eee6813..bf5ef16cb7 100644
--- a/src/Classification/NaiveBayes/BernoulliNaiveBayes.cs
+++ b/src/Classification/NaiveBayes/BernoulliNaiveBayes.cs
@@ -76,12 +76,14 @@ public partial class BernoulliNaiveBayes<T> : NaiveBayesBase<T>
     /// Log of feature probabilities for presence (P(f=1|c)) for each class.
     /// Shape: [NumClasses, NumFeatures]
     /// </summary>
+    [AiDotNet.Attributes.FittedParameter]
     private Matrix<T>? _logFeatureProbsPresent;
 
     /// <summary>
     /// Log of feature probabilities for absence (P(f=0|c) = 1 - P(f=1|c)) for each class.
     /// Shape: [NumClasses, NumFeatures]
     /// </summary>
+    [AiDotNet.Attributes.FittedParameter]
     private Matrix<T>? _logFeatureProbsAbsent;
 
     /// <summary>
@@ -211,90 +213,6 @@ protected override T ComputeLogLikelihood(Vector<T> sample, int classIndex)
         return logLikelihood;
     }
 
-    /// <summary>
-    /// Creates a new instance of this model type.
-    /// </summary>
-    /// <returns>A new BernoulliNaiveBayes instance.</returns>
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        return new BernoulliNaiveBayes<T>(new NaiveBayesOptions<T>
-        {
-            Alpha = Options.Alpha,
-            FitPriors = Options.FitPriors,
-            ClassPriors = Options.ClassPriors,
-            MinVariance = Options.MinVariance
-        }, binarizeThreshold: NumOps.ToDouble(_binarizeThreshold));
-    }
-
-    /// <summary>
-    /// Creates a deep clone of this model.
-    /// </summary>
-    /// <returns>A cloned BernoulliNaiveBayes instance.</returns>
-    public override IFullModel<T, Matrix<T>, Vector<T>> Clone()
-    {
-        var clone = new BernoulliNaiveBayes<T>(new NaiveBayesOptions<T>
-        {
-            Alpha = Options.Alpha,
-            FitPriors = Options.FitPriors,
-            ClassPriors = Options.ClassPriors?.ToArray(),
-            MinVariance = Options.MinVariance
-        }, binarizeThreshold: NumOps.ToDouble(_binarizeThreshold));
-
-        // Copy trained state
-        clone.NumFeatures = NumFeatures;
-        clone.NumClasses = NumClasses;
-        clone.TaskType = TaskType;
-
-        if (ClassLabels != null)
-        {
-            clone.ClassLabels = new Vector<T>(ClassLabels.Length);
-            for (int i = 0; i < ClassLabels.Length; i++)
-            {
-                clone.ClassLabels[i] = ClassLabels[i];
-            }
-        }
-
-        if (LogPriors != null)
-        {
-            clone.LogPriors = new Vector<T>(LogPriors.Length);
-            for (int i = 0; i < LogPriors.Length; i++)
-            {
-                clone.LogPriors[i] = LogPriors[i];
-            }
-        }
-
-        if (ClassCounts != null)
-        {
-            clone.ClassCounts = ClassCounts.ToArray();
-        }
-
-        if (_logFeatureProbsPresent != null)
-        {
-            clone._logFeatureProbsPresent = new Matrix<T>(_logFeatureProbsPresent.Rows, _logFeatureProbsPresent.Columns);
-            for (int i = 0; i < _logFeatureProbsPresent.Rows; i++)
-            {
-                for (int j = 0; j < _logFeatureProbsPresent.Columns; j++)
-                {
-                    clone._logFeatureProbsPresent[i, j] = _logFeatureProbsPresent[i, j];
-                }
-            }
-        }
-
-        if (_logFeatureProbsAbsent != null)
-        {
-            clone._logFeatureProbsAbsent = new Matrix<T>(_logFeatureProbsAbsent.Rows, _logFeatureProbsAbsent.Columns);
-            for (int i = 0; i < _logFeatureProbsAbsent.Rows; i++)
-            {
-                for (int j = 0; j < _logFeatureProbsAbsent.Columns; j++)
-                {
-                    clone._logFeatureProbsAbsent[i, j] = _logFeatureProbsAbsent[i, j];
-                }
-            }
-        }
-
-        return clone;
-    }
-
     /// <inheritdoc/>
     public override ModelMetadata<T> GetModelMetadata()
     {
@@ -304,92 +222,6 @@ public override ModelMetadata<T> GetModelMetadata()
         return metadata;
     }
 
-    /// <inheritdoc/>
-    public override byte[] Serialize()
-    {
-        var modelData = new Dictionary<string, object>
-        {
-            { "NumClasses", NumClasses },
-            { "NumFeatures", NumFeatures },
-            { "TaskType", (int)TaskType },
-            { "ClassLabels", ClassLabels?.ToArray() ?? Array.Empty<T>() },
-            { "RegularizationOptions", Regularization.GetOptions() },
-            { "ClassCounts", ClassCounts ?? Array.Empty<int>() },
-            { "BinarizeThreshold", NumOps.ToDouble(_binarizeThreshold) }
-        };
-
-        if (LogPriors is not null)
-        {
-            var logPriorsArray = new double[LogPriors.Length];
-            for (int i = 0; i < LogPriors.Length; i++)
-                logPriorsArray[i] = NumOps.ToDouble(LogPriors[i]);
-            modelData["LogPriors"] = logPriorsArray;
-        }
-
-        SerializeMatrix(modelData, "LogFeatureProbsPresent", _logFeatureProbsPresent);
-        SerializeMatrix(modelData, "LogFeatureProbsAbsent", _logFeatureProbsAbsent);
-
-        var modelMetadata = GetModelMetadata();
-        modelMetadata.ModelData = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(modelData));
-        return Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(modelMetadata));
-    }
-
-    /// <inheritdoc/>
-    public override void Deserialize(byte[] modelData)
-    {
-        var jsonString = Encoding.UTF8.GetString(modelData);
-        var modelMetadata = JsonConvert.DeserializeObject<ModelMetadata<T>>(jsonString);
-
-        if (modelMetadata == null || modelMetadata.ModelData == null)
-            throw new InvalidOperationException("Deserialization failed: The model data is invalid or corrupted.");
-
-        var modelDataString = Encoding.UTF8.GetString(modelMetadata.ModelData);
-        var modelDataObj = JsonConvert.DeserializeObject<JObject>(modelDataString);
-
-        if (modelDataObj == null)
-            throw new InvalidOperationException("Deserialization failed: The model data is invalid or corrupted.");
-
-        NumClasses = modelDataObj["NumClasses"]?.ToObject<int>() ?? 0;
-        NumFeatures = modelDataObj["NumFeatures"]?.ToObject<int>() ?? 0;
-        TaskType = (ClassificationTaskType)(modelDataObj["TaskType"]?.ToObject<int>() ?? 0);
-
-        // Restore BinarizeThreshold
-        var binarizeToken = modelDataObj["BinarizeThreshold"];
-        if (binarizeToken is not null)
-            _binarizeThreshold = NumOps.FromDouble(binarizeToken.ToObject<double>());
-
-        var classLabelsToken = modelDataObj["ClassLabels"];
-        if (classLabelsToken is not null)
-        {
-            var classLabelsAsDoubles = classLabelsToken.ToObject<double[]>() ?? Array.Empty<double>();
-            if (classLabelsAsDoubles.Length > 0)
-            {
-                ClassLabels = new Vector<T>(classLabelsAsDoubles.Length);
-                for (int i = 0; i < classLabelsAsDoubles.Length; i++)
-                    ClassLabels[i] = NumOps.FromDouble(classLabelsAsDoubles[i]);
-            }
-        }
-
-        var classCountsToken = modelDataObj["ClassCounts"];
-        if (classCountsToken is not null)
-            ClassCounts = classCountsToken.ToObject<int[]>();
-
-        var logPriorsToken = modelDataObj["LogPriors"];
-        if (logPriorsToken is not null)
-        {
-            var logPriorsArray = logPriorsToken.ToObject<double[]>() ?? Array.Empty<double>();
-            if (logPriorsArray.Length > 0)
-            {
-                LogPriors = new Vector<T>(logPriorsArray.Length);
-                for (int i = 0; i < logPriorsArray.Length; i++)
-                    LogPriors[i] = NumOps.FromDouble(logPriorsArray[i]);
-            }
-        }
-
-        _logFeatureProbsPresent = DeserializeMatrix(modelDataObj, "LogFeatureProbsPresent");
-        _logFeatureProbsAbsent = DeserializeMatrix(modelDataObj, "LogFeatureProbsAbsent");
-    }
-
     private void SerializeMatrix(Dictionary<string, object> data, string name, Matrix<T>? matrix)
     {
         if (matrix is null) return;
diff --git a/src/Classification/NaiveBayes/CategoricalNaiveBayes.cs b/src/Classification/NaiveBayes/CategoricalNaiveBayes.cs
index 1e992441bd..599dc205ae 100644
--- a/src/Classification/NaiveBayes/CategoricalNaiveBayes.cs
+++ b/src/Classification/NaiveBayes/CategoricalNaiveBayes.cs
@@ -201,73 +201,6 @@ protected override T ComputeLogLikelihood(Vector<T> sample, int classIndex)
         return logLikelihood;
     }
 
-    /// <inheritdoc/>
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        return new CategoricalNaiveBayes<T>(new NaiveBayesOptions<T>
-        {
-            Alpha = Options.Alpha,
-            FitPriors = Options.FitPriors
-        });
-    }
-
-    /// <inheritdoc/>
-    public override IFullModel<T, Matrix<T>, Vector<T>> Clone()
-    {
-        var clone = new CategoricalNaiveBayes<T>(new NaiveBayesOptions<T>
-        {
-            Alpha = Options.Alpha,
-            FitPriors = Options.FitPriors
-        });
-
-        clone.NumFeatures = NumFeatures;
-        clone.NumClasses = NumClasses;
-        clone.TaskType = TaskType;
-
-        if (ClassLabels is not null)
-        {
-            clone.ClassLabels = new Vector<T>(ClassLabels.Length);
-            for (int i = 0; i < ClassLabels.Length; i++)
-            {
-                clone.ClassLabels[i] = ClassLabels[i];
-            }
-        }
-
-        if (LogPriors is not null)
-        {
-            clone.LogPriors = new Vector<T>(LogPriors.Length);
-            for (int i = 0; i < LogPriors.Length; i++)
-            {
-                clone.LogPriors[i] = LogPriors[i];
-            }
-        }
-
-        if (_numCategories is not null)
-        {
-            clone._numCategories = new int[_numCategories.Length];
-            Array.Copy(_numCategories, clone._numCategories, _numCategories.Length);
-        }
-
-        if (_categoryLogProbs is not null)
-        {
-            clone._categoryLogProbs = new Matrix<T>[_categoryLogProbs.Length];
-            for (int c = 0; c < _categoryLogProbs.Length; c++)
-            {
-                var src = _categoryLogProbs[c];
-                clone._categoryLogProbs[c] = new Matrix<T>(src.Rows, src.Columns);
-                for (int i = 0; i < src.Rows; i++)
-                {
-                    for (int j = 0; j < src.Columns; j++)
-                    {
-                        clone._categoryLogProbs[c][i, j] = src[i, j];
-                    }
-                }
-            }
-        }
-
-        return clone;
-    }
-
     /// <inheritdoc/>
     public override ModelMetadata<T> GetModelMetadata()
     {
@@ -280,121 +213,6 @@ public override ModelMetadata<T> GetModelMetadata()
         return metadata;
     }
 
-    /// <inheritdoc/>
-    public override byte[] Serialize()
-    {
-        var modelData = new Dictionary<string, object>
-        {
-            { "NumClasses", NumClasses },
-            { "NumFeatures", NumFeatures },
-            { "TaskType", (int)TaskType },
-            { "ClassLabels", ClassLabels?.ToArray() ?? Array.Empty<T>() },
-            { "RegularizationOptions", Regularization.GetOptions() }
-        };
-
-        if (ClassCounts is not null)
-            modelData["ClassCounts"] = ClassCounts;
-
-        if (LogPriors is not null)
-        {
-            var logPriorsArray = new double[LogPriors.Length];
-            for (int i = 0; i < LogPriors.Length; i++)
-                logPriorsArray[i] = NumOps.ToDouble(LogPriors[i]);
-            modelData["LogPriors"] = logPriorsArray;
-        }
-
-        if (_numCategories is not null)
-            modelData["NumCategories"] = _numCategories;
-
-        if (_categoryLogProbs is not null)
-        {
-            modelData["NumCategoryMatrices"] = _categoryLogProbs.Length;
-            for (int c = 0; c < _categoryLogProbs.Length; c++)
-            {
-                SerializeMatrix(modelData, $"CategoryLogProbs_{c}", _categoryLogProbs[c]);
-            }
-        }
-
-        var modelMetadata = GetModelMetadata();
-        modelMetadata.ModelData = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(modelData));
-        return Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(modelMetadata));
-    }
-
-    /// <inheritdoc/>
-    public override void Deserialize(byte[] modelData)
-    {
-        var jsonString = Encoding.UTF8.GetString(modelData);
-        var modelMetadata = JsonConvert.DeserializeObject<ModelMetadata<T>>(jsonString);
-
-        if (modelMetadata == null || modelMetadata.ModelData == null)
-            throw new InvalidOperationException("Deserialization failed: The model data is invalid or corrupted.");
-
-        var modelDataString = Encoding.UTF8.GetString(modelMetadata.ModelData);
-        var modelDataObj = JsonConvert.DeserializeObject<JObject>(modelDataString);
-
-        if (modelDataObj == null)
-            throw new InvalidOperationException("Deserialization failed: The model data is invalid or corrupted.");
-
-        // Clear previous state before deserializing
-        _categoryLogProbs = null;
-        _numCategories = null;
-        ClassLabels = new Vector<T>(0);
-        ClassCounts = null;
-        LogPriors = new Vector<T>(0);
-
-        NumClasses = modelDataObj["NumClasses"]?.ToObject<int>() ?? 0;
-        NumFeatures = modelDataObj["NumFeatures"]?.ToObject<int>() ?? 0;
-        TaskType = (ClassificationTaskType)(modelDataObj["TaskType"]?.ToObject<int>() ?? 0);
-
-        var classLabelsToken = modelDataObj["ClassLabels"];
-        if (classLabelsToken is not null)
-        {
-            var classLabelsAsDoubles = classLabelsToken.ToObject<double[]>() ?? Array.Empty<double>();
-            if (classLabelsAsDoubles.Length > 0)
-            {
-                ClassLabels = new Vector<T>(classLabelsAsDoubles.Length);
-                for (int i = 0; i < classLabelsAsDoubles.Length; i++)
-                    ClassLabels[i] = NumOps.FromDouble(classLabelsAsDoubles[i]);
-            }
-        }
-
-        var classCountsToken = modelDataObj["ClassCounts"];
-        if (classCountsToken is not null)
-            ClassCounts = classCountsToken.ToObject<int[]>();
-
-        var logPriorsToken = modelDataObj["LogPriors"];
-        if (logPriorsToken is not null)
-        {
-            var logPriorsArray = logPriorsToken.ToObject<double[]>() ?? Array.Empty<double>();
-            if (logPriorsArray.Length > 0)
-            {
-                LogPriors = new Vector<T>(logPriorsArray.Length);
-                for (int i = 0; i < logPriorsArray.Length; i++)
-                    LogPriors[i] = NumOps.FromDouble(logPriorsArray[i]);
-            }
-        }
-
-        var numCategoriesToken = modelDataObj["NumCategories"];
-        if (numCategoriesToken is not null)
-            _numCategories = numCategoriesToken.ToObject<int[]>();
-
-        int numMatrices = modelDataObj["NumCategoryMatrices"]?.ToObject<int>() ?? 0;
-        if (numMatrices > 0)
-        {
-            _categoryLogProbs = new Matrix<T>[numMatrices];
-            for (int c = 0; c < numMatrices; c++)
-            {
-                var matrix = DeserializeMatrix(modelDataObj, $"CategoryLogProbs_{c}");
-                if (matrix is null)
-                {
-                    throw new InvalidOperationException(
-                        $"Deserialization failed: CategoryLogProbs_{c} is missing or malformed.");
-                }
-                _categoryLogProbs[c] = matrix;
-            }
-        }
-    }
-
     private void SerializeMatrix(Dictionary<string, object> data, string name, Matrix<T>? matrix)
     {
         if (matrix is null) return;
diff --git a/src/Classification/NaiveBayes/ComplementNaiveBayes.cs b/src/Classification/NaiveBayes/ComplementNaiveBayes.cs
index c5e4094758..e58a35e26c 100644
--- a/src/Classification/NaiveBayes/ComplementNaiveBayes.cs
+++ b/src/Classification/NaiveBayes/ComplementNaiveBayes.cs
@@ -73,6 +73,7 @@ public partial class ComplementNaiveBayes<T> : NaiveBayesBase<T>
     /// <summary>
     /// Complement feature log-probabilities: log P(feature|NOT class).
     /// </summary>
+    [AiDotNet.Attributes.FittedParameter]
     private Matrix<T>? _complementLogProbs;
     private T[]? _featureMinShift;
 
@@ -227,67 +228,6 @@ protected override T ComputeLogLikelihood(Vector<T> sample, int classIndex)
         return logLikelihood;
     }
 
-    /// <inheritdoc/>
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        return new ComplementNaiveBayes<T>(new NaiveBayesOptions<T>
-        {
-            Alpha = Options.Alpha,
-            FitPriors = Options.FitPriors
-        }, null, _normalize);
-    }
-
-    /// <inheritdoc/>
-    public override IFullModel<T, Matrix<T>, Vector<T>> Clone()
-    {
-        var clone = new ComplementNaiveBayes<T>(new NaiveBayesOptions<T>
-        {
-            Alpha = Options.Alpha,
-            FitPriors = Options.FitPriors
-        }, null, _normalize);
-
-        clone.NumFeatures = NumFeatures;
-        clone.NumClasses = NumClasses;
-        clone.TaskType = TaskType;
-
-        if (ClassLabels is not null)
-        {
-            clone.ClassLabels = new Vector<T>(ClassLabels.Length);
-            for (int i = 0; i < ClassLabels.Length; i++)
-            {
-                clone.ClassLabels[i] = ClassLabels[i];
-            }
-        }
-
-        if (LogPriors is not null)
-        {
-            clone.LogPriors = new Vector<T>(LogPriors.Length);
-            for (int i = 0; i < LogPriors.Length; i++)
-            {
-                clone.LogPriors[i] = LogPriors[i];
-            }
-        }
-
-        if (_complementLogProbs is not null)
-        {
-            clone._complementLogProbs = new Matrix<T>(_complementLogProbs.Rows, _complementLogProbs.Columns);
-            for (int i = 0; i < _complementLogProbs.Rows; i++)
-            {
-                for (int j = 0; j < _complementLogProbs.Columns; j++)
-                {
-                    clone._complementLogProbs[i, j] = _complementLogProbs[i, j];
-                }
-            }
-        }
-
-        if (_featureMinShift is not null)
-        {
-            clone._featureMinShift = _featureMinShift.ToArray();
-        }
-
-        return clone;
-    }
-
     /// <inheritdoc/>
     public override ModelMetadata<T> GetModelMetadata()
     {
@@ -296,112 +236,6 @@ public override ModelMetadata<T> GetModelMetadata()
         return metadata;
     }
 
-    /// <inheritdoc/>
-    public override byte[] Serialize()
-    {
-        var modelData = new Dictionary<string, object>
-        {
-            { "NumClasses", NumClasses },
-            { "NumFeatures", NumFeatures },
-            { "TaskType", (int)TaskType },
-            { "ClassLabels", ClassLabels?.ToArray() ?? Array.Empty<T>() },
-            { "RegularizationOptions", Regularization.GetOptions() },
-            { "Normalize", _normalize }
-        };
-
-        if (ClassCounts is not null)
-            modelData["ClassCounts"] = ClassCounts;
-
-        if (LogPriors is not null)
-        {
-            var logPriorsArray = new double[LogPriors.Length];
-            for (int i = 0; i < LogPriors.Length; i++)
-                logPriorsArray[i] = NumOps.ToDouble(LogPriors[i]);
-            modelData["LogPriors"] = logPriorsArray;
-        }
-
-        SerializeMatrix(modelData, "ComplementLogProbs", _complementLogProbs);
-
-        if (_featureMinShift is not null)
-        {
-            var shiftArray = new double[_featureMinShift.Length];
-            for (int i = 0; i < _featureMinShift.Length; i++)
-                shiftArray[i] = NumOps.ToDouble(_featureMinShift[i]);
-            modelData["FeatureMinShift"] = shiftArray;
-        }
-
-        var modelMetadata = GetModelMetadata();
-        modelMetadata.ModelData = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(modelData));
-        return Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(modelMetadata));
-    }
-
-    /// <inheritdoc/>
-    public override void Deserialize(byte[] modelData)
-    {
-        var jsonString = Encoding.UTF8.GetString(modelData);
-        var modelMetadata = JsonConvert.DeserializeObject<ModelMetadata<T>>(jsonString);
-
-        if (modelMetadata == null || modelMetadata.ModelData == null)
-            throw new InvalidOperationException("Deserialization failed: The model data is invalid or corrupted.");
-
-        var modelDataString = Encoding.UTF8.GetString(modelMetadata.ModelData);
-        var modelDataObj = JsonConvert.DeserializeObject<JObject>(modelDataString);
-
-        if (modelDataObj == null)
-            throw new InvalidOperationException("Deserialization failed: The model data is invalid or corrupted.");
-
-        NumClasses = modelDataObj["NumClasses"]?.ToObject<int>() ?? 0;
-        NumFeatures = modelDataObj["NumFeatures"]?.ToObject<int>() ?? 0;
-        TaskType = (ClassificationTaskType)(modelDataObj["TaskType"]?.ToObject<int>() ?? 0);
-
-        var classLabelsToken = modelDataObj["ClassLabels"];
-        if (classLabelsToken is not null)
-        {
-            var classLabelsAsDoubles = classLabelsToken.ToObject<double[]>() ?? Array.Empty<double>();
-            if (classLabelsAsDoubles.Length > 0)
-            {
-                ClassLabels = new Vector<T>(classLabelsAsDoubles.Length);
-                for (int i = 0; i < classLabelsAsDoubles.Length; i++)
-                    ClassLabels[i] = NumOps.FromDouble(classLabelsAsDoubles[i]);
-            }
-        }
-
-        // Restore _normalize
-        var normalizeToken = modelDataObj["Normalize"];
-        if (normalizeToken is not null)
-            _normalize = normalizeToken.ToObject<bool>();
-
-        var classCountsToken = modelDataObj["ClassCounts"];
-        if (classCountsToken is not null)
-            ClassCounts = classCountsToken.ToObject<int[]>();
-
-        var logPriorsToken = modelDataObj["LogPriors"];
-        if (logPriorsToken is not null)
-        {
-            var logPriorsArray = logPriorsToken.ToObject<double[]>() ?? Array.Empty<double>();
-            if (logPriorsArray.Length > 0)
-            {
-                LogPriors = new Vector<T>(logPriorsArray.Length);
-                for (int i = 0; i < logPriorsArray.Length; i++)
-                    LogPriors[i] = NumOps.FromDouble(logPriorsArray[i]);
-            }
-        }
-
-        _complementLogProbs = DeserializeMatrix(modelDataObj, "ComplementLogProbs");
-
-        var shiftToken = modelDataObj["FeatureMinShift"];
-        if (shiftToken is not null)
-        {
-            var shiftArray = shiftToken.ToObject<double[]>() ?? Array.Empty<double>();
-            if (shiftArray.Length > 0)
-            {
-                _featureMinShift = new T[shiftArray.Length];
-                for (int i = 0; i < shiftArray.Length; i++)
-                    _featureMinShift[i] = NumOps.FromDouble(shiftArray[i]);
-            }
-        }
-    }
-
     private void SerializeMatrix(Dictionary<string, object> data, string name, Matrix<T>? matrix)
     {
         if (matrix is null) return;
diff --git a/src/Classification/NaiveBayes/GaussianNaiveBayes.cs b/src/Classification/NaiveBayes/GaussianNaiveBayes.cs
index a39c69e5b8..d7e51bf2dd 100644
--- a/src/Classification/NaiveBayes/GaussianNaiveBayes.cs
+++ b/src/Classification/NaiveBayes/GaussianNaiveBayes.cs
@@ -66,7 +66,7 @@ namespace AiDotNet.Classification.NaiveBayes;
 [ModelComplexity(ModelComplexity.Low)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
     [ResearchPaper("A Comparison of Event Models for Naive Bayes Text Classification", "https://www.cs.cmu.edu/~knigam/papers/multinomial-aaaiws98.pdf")]
-public class GaussianNaiveBayes<T> : NaiveBayesBase<T>
+public partial class GaussianNaiveBayes<T> : NaiveBayesBase<T>
 {
     /// <summary>
     /// Mean values for each feature in each class.
@@ -230,90 +230,6 @@ protected override T ComputeLogLikelihood(Vector<T> sample, int classIndex)
         return logLikelihood;
     }
 
-    /// <summary>
-    /// Creates a new instance of this model type.
-    /// </summary>
-    /// <returns>A new GaussianNaiveBayes instance.</returns>
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        return new GaussianNaiveBayes<T>(new NaiveBayesOptions<T>
-        {
-            Alpha = Options.Alpha,
-            FitPriors = Options.FitPriors,
-            ClassPriors = Options.ClassPriors,
-            MinVariance = Options.MinVariance
-        });
-    }
-
-    /// <summary>
-    /// Creates a deep clone of this model.
-    /// </summary>
-    /// <returns>A cloned GaussianNaiveBayes instance.</returns>
-    public override IFullModel<T, Matrix<T>, Vector<T>> Clone()
-    {
-        var clone = new GaussianNaiveBayes<T>(new NaiveBayesOptions<T>
-        {
-            Alpha = Options.Alpha,
-            FitPriors = Options.FitPriors,
-            ClassPriors = Options.ClassPriors?.ToArray(),
-            MinVariance = Options.MinVariance
-        });
-
-        // Copy trained state
-        clone.NumFeatures = NumFeatures;
-        clone.NumClasses = NumClasses;
-        clone.TaskType = TaskType;
-
-        if (ClassLabels != null)
-        {
-            clone.ClassLabels = new Vector<T>(ClassLabels.Length);
-            for (int i = 0; i < ClassLabels.Length; i++)
-            {
-                clone.ClassLabels[i] = ClassLabels[i];
-            }
-        }
-
-        if (LogPriors != null)
-        {
-            clone.LogPriors = new Vector<T>(LogPriors.Length);
-            for (int i = 0; i < LogPriors.Length; i++)
-            {
-                clone.LogPriors[i] = LogPriors[i];
-            }
-        }
-
-        if (ClassCounts != null)
-        {
-            clone.ClassCounts = ClassCounts.ToArray();
-        }
-
-        if (_means != null)
-        {
-            clone._means = new Matrix<T>(_means.Rows, _means.Columns);
-            for (int i = 0; i < _means.Rows; i++)
-            {
-                for (int j = 0; j < _means.Columns; j++)
-                {
-                    clone._means[i, j] = _means[i, j];
-                }
-            }
-        }
-
-        if (_variances != null)
-        {
-            clone._variances = new Matrix<T>(_variances.Rows, _variances.Columns);
-            for (int i = 0; i < _variances.Rows; i++)
-            {
-                for (int j = 0; j < _variances.Columns; j++)
-                {
-                    clone._variances[i, j] = _variances[i, j];
-                }
-            }
-        }
-
-        return clone;
-    }
-
     /// <inheritdoc/>
     public override ModelMetadata<T> GetModelMetadata()
     {
@@ -321,172 +237,4 @@ public override ModelMetadata<T> GetModelMetadata()
         metadata.AdditionalInfo["MinVariance"] = Options.MinVariance;
         return metadata;
     }
-
-    /// <inheritdoc/>
-    public override byte[] Serialize()
-    {
-        var modelData = new Dictionary<string, object>
-        {
-            { "NumClasses", NumClasses },
-            { "NumFeatures", NumFeatures },
-            { "TaskType", (int)TaskType },
-            { "ClassLabels", ClassLabels?.ToArray() ?? Array.Empty<T>() },
-            { "RegularizationOptions", Regularization.GetOptions() },
-            { "ClassCounts", ClassCounts ?? Array.Empty<int>() }
-        };
-
-        // Serialize LogPriors
-        if (LogPriors is not null)
-        {
-            var logPriorsArray = new double[LogPriors.Length];
-            for (int i = 0; i < LogPriors.Length; i++)
-            {
-                logPriorsArray[i] = NumOps.ToDouble(LogPriors[i]);
-            }
-            modelData["LogPriors"] = logPriorsArray;
-        }
-
-        // Serialize _means matrix
-        if (_means is not null)
-        {
-            var meansArray = new double[_means.Rows * _means.Columns];
-            int idx = 0;
-            for (int i = 0; i < _means.Rows; i++)
-            {
-                for (int j = 0; j < _means.Columns; j++)
-                {
-                    meansArray[idx++] = NumOps.ToDouble(_means[i, j]);
-                }
-            }
-            modelData["Means"] = meansArray;
-            modelData["MeansRows"] = _means.Rows;
-            modelData["MeansCols"] = _means.Columns;
-        }
-
-        // Serialize _variances matrix
-        if (_variances is not null)
-        {
-            var variancesArray = new double[_variances.Rows * _variances.Columns];
-            int idx = 0;
-            for (int i = 0; i < _variances.Rows; i++)
-            {
-                for (int j = 0; j < _variances.Columns; j++)
-                {
-                    variancesArray[idx++] = NumOps.ToDouble(_variances[i, j]);
-                }
-            }
-            modelData["Variances"] = variancesArray;
-            modelData["VariancesRows"] = _variances.Rows;
-            modelData["VariancesCols"] = _variances.Columns;
-        }
-
-        var modelMetadata = GetModelMetadata();
-        modelMetadata.ModelData = System.Text.Encoding.UTF8.GetBytes(
-            Newtonsoft.Json.JsonConvert.SerializeObject(modelData));
-
-        return System.Text.Encoding.UTF8.GetBytes(
-            Newtonsoft.Json.JsonConvert.SerializeObject(modelMetadata));
-    }
-
-    /// <inheritdoc/>
-    public override void Deserialize(byte[] modelData)
-    {
-        var jsonString = System.Text.Encoding.UTF8.GetString(modelData);
-        var modelMetadata = Newtonsoft.Json.JsonConvert.DeserializeObject<ModelMetadata<T>>(jsonString);
-
-        if (modelMetadata == null || modelMetadata.ModelData == null)
-        {
-            throw new InvalidOperationException("Deserialization failed: The model data is invalid or corrupted.");
-        }
-
-        var modelDataString = System.Text.Encoding.UTF8.GetString(modelMetadata.ModelData);
-        var modelDataObj = Newtonsoft.Json.JsonConvert.DeserializeObject<Newtonsoft.Json.Linq.JObject>(modelDataString);
-
-        if (modelDataObj == null)
-        {
-            throw new InvalidOperationException("Deserialization failed: The model data is invalid or corrupted.");
-        }
-
-        // Deserialize base properties
-        NumClasses = modelDataObj["NumClasses"]?.ToObject<int>() ?? 0;
-        NumFeatures = modelDataObj["NumFeatures"]?.ToObject<int>() ?? 0;
-        TaskType = (ClassificationTaskType)(modelDataObj["TaskType"]?.ToObject<int>() ?? 0);
-
-        var classLabelsToken = modelDataObj["ClassLabels"];
-        if (classLabelsToken is not null)
-        {
-            var classLabelsAsDoubles = classLabelsToken.ToObject<double[]>() ?? Array.Empty<double>();
-            if (classLabelsAsDoubles.Length > 0)
-            {
-                ClassLabels = new Vector<T>(classLabelsAsDoubles.Length);
-                for (int i = 0; i < classLabelsAsDoubles.Length; i++)
-                {
-                    ClassLabels[i] = NumOps.FromDouble(classLabelsAsDoubles[i]);
-                }
-            }
-        }
-
-        // Deserialize ClassCounts
-        var classCountsToken = modelDataObj["ClassCounts"];
-        if (classCountsToken is not null)
-        {
-            ClassCounts = classCountsToken.ToObject<int[]>();
-        }
-
-        // Deserialize LogPriors
-        var logPriorsToken = modelDataObj["LogPriors"];
-        if (logPriorsToken is not null)
-        {
-            var logPriorsArray = logPriorsToken.ToObject<double[]>() ?? Array.Empty<double>();
-            LogPriors = new Vector<T>(logPriorsArray.Length);
-            for (int i = 0; i < logPriorsArray.Length; i++)
-            {
-                LogPriors[i] = NumOps.FromDouble(logPriorsArray[i]);
-            }
-        }
-
-        // Deserialize _means matrix
-        var meansToken = modelDataObj["Means"];
-        if (meansToken is not null)
-        {
-            var meansArray = meansToken.ToObject<double[]>() ?? Array.Empty<double>();
-            int rows = modelDataObj["MeansRows"]?.ToObject<int>() ?? 0;
-            int cols = modelDataObj["MeansCols"]?.ToObject<int>() ?? 0;
-
-            if (rows > 0 && cols > 0)
-            {
-                _means = new Matrix<T>(rows, cols);
-                int idx = 0;
-                for (int i = 0; i < rows; i++)
-                {
-                    for (int j = 0; j < cols; j++)
-                    {
-                        _means[i, j] = NumOps.FromDouble(meansArray[idx++]);
-                    }
-                }
-            }
-        }
-
-        // Deserialize _variances matrix
-        var variancesToken = modelDataObj["Variances"];
-        if (variancesToken is not null)
-        {
-            var variancesArray = variancesToken.ToObject<double[]>() ?? Array.Empty<double>();
-            int rows = modelDataObj["VariancesRows"]?.ToObject<int>() ?? 0;
-            int cols = modelDataObj["VariancesCols"]?.ToObject<int>() ?? 0;
-
-            if (rows > 0 && cols > 0)
-            {
-                _variances = new Matrix<T>(rows, cols);
-                int idx = 0;
-                for (int i = 0; i < rows; i++)
-                {
-                    for (int j = 0; j < cols; j++)
-                    {
-                        _variances[i, j] = NumOps.FromDouble(variancesArray[idx++]);
-                    }
-                }
-            }
-        }
-    }
 }
diff --git a/src/Classification/NaiveBayes/MultinomialNaiveBayes.cs b/src/Classification/NaiveBayes/MultinomialNaiveBayes.cs
index ec50bba3c8..89b2218c63 100644
--- a/src/Classification/NaiveBayes/MultinomialNaiveBayes.cs
+++ b/src/Classification/NaiveBayes/MultinomialNaiveBayes.cs
@@ -67,7 +67,7 @@ namespace AiDotNet.Classification.NaiveBayes;
 [ModelComplexity(ModelComplexity.Low)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
     [ResearchPaper("A Comparison of Event Models for Naive Bayes Text Classification", "https://www.cs.cmu.edu/~knigam/papers/multinomial-aaaiws98.pdf")]
-public class MultinomialNaiveBayes<T> : NaiveBayesBase<T>
+public partial class MultinomialNaiveBayes<T> : NaiveBayesBase<T>
 {
     /// <summary>
     /// Log of feature probabilities for each class.
@@ -220,83 +220,6 @@ protected override T ComputeLogLikelihood(Vector<T> sample, int classIndex)
         return logLikelihood;
     }
 
-    /// <summary>
-    /// Creates a new instance of this model type.
-    /// </summary>
-    /// <returns>A new MultinomialNaiveBayes instance.</returns>
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        return new MultinomialNaiveBayes<T>(new NaiveBayesOptions<T>
-        {
-            Alpha = Options.Alpha,
-            FitPriors = Options.FitPriors,
-            ClassPriors = Options.ClassPriors,
-            MinVariance = Options.MinVariance
-        });
-    }
-
-    /// <summary>
-    /// Creates a deep clone of this model.
-    /// </summary>
-    /// <returns>A cloned MultinomialNaiveBayes instance.</returns>
-    public override IFullModel<T, Matrix<T>, Vector<T>> Clone()
-    {
-        var clone = new MultinomialNaiveBayes<T>(new NaiveBayesOptions<T>
-        {
-            Alpha = Options.Alpha,
-            FitPriors = Options.FitPriors,
-            ClassPriors = Options.ClassPriors?.ToArray(),
-            MinVariance = Options.MinVariance
-        });
-
-        // Copy trained state
-        clone.NumFeatures = NumFeatures;
-        clone.NumClasses = NumClasses;
-        clone.TaskType = TaskType;
-
-        if (ClassLabels != null)
-        {
-            clone.ClassLabels = new Vector<T>(ClassLabels.Length);
-            for (int i = 0; i < ClassLabels.Length; i++)
-            {
-                clone.ClassLabels[i] = ClassLabels[i];
-            }
-        }
-
-        if (LogPriors != null)
-        {
-            clone.LogPriors = new Vector<T>(LogPriors.Length);
-            for (int i = 0; i < LogPriors.Length; i++)
-            {
-                clone.LogPriors[i] = LogPriors[i];
-            }
-        }
-
-        if (ClassCounts != null)
-        {
-            clone.ClassCounts = ClassCounts.ToArray();
-        }
-
-        if (_logFeatureProbs != null)
-        {
-            clone._logFeatureProbs = new Matrix<T>(_logFeatureProbs.Rows, _logFeatureProbs.Columns);
-            for (int i = 0; i < _logFeatureProbs.Rows; i++)
-            {
-                for (int j = 0; j < _logFeatureProbs.Columns; j++)
-                {
-                    clone._logFeatureProbs[i, j] = _logFeatureProbs[i, j];
-                }
-            }
-        }
-
-        if (_featureMinShift is not null)
-        {
-            clone._featureMinShift = _featureMinShift.ToArray();
-        }
-
-        return clone;
-    }
-
     /// <inheritdoc/>
     public override ModelMetadata<T> GetModelMetadata()
     {
@@ -304,131 +227,4 @@ public override ModelMetadata<T> GetModelMetadata()
         metadata.AdditionalInfo["DistributionType"] = "Multinomial";
         return metadata;
     }
-
-    /// <inheritdoc/>
-    public override byte[] Serialize()
-    {
-        var modelData = new Dictionary<string, object>
-        {
-            { "NumClasses", NumClasses },
-            { "NumFeatures", NumFeatures },
-            { "TaskType", (int)TaskType },
-            { "ClassLabels", ClassLabels?.ToArray() ?? Array.Empty<T>() },
-            { "RegularizationOptions", Regularization.GetOptions() },
-            { "ClassCounts", ClassCounts ?? Array.Empty<int>() }
-        };
-
-        if (LogPriors is not null)
-        {
-            var logPriorsArray = new double[LogPriors.Length];
-            for (int i = 0; i < LogPriors.Length; i++)
-                logPriorsArray[i] = NumOps.ToDouble(LogPriors[i]);
-            modelData["LogPriors"] = logPriorsArray;
-        }
-
-        if (_logFeatureProbs is not null)
-        {
-            var featureProbsArray = new double[_logFeatureProbs.Rows * _logFeatureProbs.Columns];
-            int idx = 0;
-            for (int i = 0; i < _logFeatureProbs.Rows; i++)
-                for (int j = 0; j < _logFeatureProbs.Columns; j++)
-                    featureProbsArray[idx++] = NumOps.ToDouble(_logFeatureProbs[i, j]);
-            modelData["LogFeatureProbs"] = featureProbsArray;
-            modelData["LogFeatureProbsRows"] = _logFeatureProbs.Rows;
-            modelData["LogFeatureProbsCols"] = _logFeatureProbs.Columns;
-        }
-
-        if (_featureMinShift is not null)
-        {
-            var shiftArray = new double[_featureMinShift.Length];
-            for (int i = 0; i < _featureMinShift.Length; i++)
-                shiftArray[i] = NumOps.ToDouble(_featureMinShift[i]);
-            modelData["FeatureMinShift"] = shiftArray;
-        }
-
-        var modelMetadata = GetModelMetadata();
-        modelMetadata.ModelData = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(modelData));
-        return Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(modelMetadata));
-    }
-
-    /// <inheritdoc/>
-    public override void Deserialize(byte[] modelData)
-    {
-        var jsonString = Encoding.UTF8.GetString(modelData);
-        var modelMetadata = JsonConvert.DeserializeObject<ModelMetadata<T>>(jsonString);
-
-        if (modelMetadata == null || modelMetadata.ModelData == null)
-            throw new InvalidOperationException("Deserialization failed: The model data is invalid or corrupted.");
-
-        var modelDataString = Encoding.UTF8.GetString(modelMetadata.ModelData);
-        var modelDataObj = JsonConvert.DeserializeObject<JObject>(modelDataString);
-
-        if (modelDataObj == null)
-            throw new InvalidOperationException("Deserialization failed: The model data is invalid or corrupted.");
-
-        NumClasses = modelDataObj["NumClasses"]?.ToObject<int>() ?? 0;
-        NumFeatures = modelDataObj["NumFeatures"]?.ToObject<int>() ?? 0;
-        TaskType = (ClassificationTaskType)(modelDataObj["TaskType"]?.ToObject<int>() ?? 0);
-
-        var classLabelsToken = modelDataObj["ClassLabels"];
-        if (classLabelsToken is not null)
-        {
-            var classLabelsAsDoubles = classLabelsToken.ToObject<double[]>() ?? Array.Empty<double>();
-            if (classLabelsAsDoubles.Length > 0)
-            {
-                ClassLabels = new Vector<T>(classLabelsAsDoubles.Length);
-                for (int i = 0; i < classLabelsAsDoubles.Length; i++)
-                    ClassLabels[i] = NumOps.FromDouble(classLabelsAsDoubles[i]);
-            }
-        }
-
-        var classCountsToken = modelDataObj["ClassCounts"];
-        if (classCountsToken is not null)
-            ClassCounts = classCountsToken.ToObject<int[]>();
-
-        var logPriorsToken = modelDataObj["LogPriors"];
-        if (logPriorsToken is not null)
-        {
-            var logPriorsArray = logPriorsToken.ToObject<double[]>() ?? Array.Empty<double>();
-            if (logPriorsArray.Length > 0)
-            {
-                LogPriors = new Vector<T>(logPriorsArray.Length);
-                for (int i = 0; i < logPriorsArray.Length; i++)
-                    LogPriors[i] = NumOps.FromDouble(logPriorsArray[i]);
-            }
-        }
-
-        var featureProbsToken = modelDataObj["LogFeatureProbs"];
-        if (featureProbsToken is not null)
-        {
-            var featureProbsArray = featureProbsToken.ToObject<double[]>() ?? Array.Empty<double>();
-            int rows = modelDataObj["LogFeatureProbsRows"]?.ToObject<int>() ?? 0;
-            int cols = modelDataObj["LogFeatureProbsCols"]?.ToObject<int>() ?? 0;
-            if (rows > 0 && cols > 0)
-            {
-                if (featureProbsArray.Length < rows * cols)
-                {
-                    throw new InvalidOperationException(
-                        $"Deserialization failed: LogFeatureProbs array length {featureProbsArray.Length} is less than expected {rows}x{cols}={rows * cols}.");
-                }
-                _logFeatureProbs = new Matrix<T>(rows, cols);
-                int idx = 0;
-                for (int i = 0; i < rows; i++)
-                    for (int j = 0; j < cols; j++)
-                        _logFeatureProbs[i, j] = NumOps.FromDouble(featureProbsArray[idx++]);
-            }
-        }
-
-        var shiftToken = modelDataObj["FeatureMinShift"];
-        if (shiftToken is not null)
-        {
-            var shiftArray = shiftToken.ToObject<double[]>() ?? Array.Empty<double>();
-            if (shiftArray.Length > 0)
-            {
-                _featureMinShift = new T[shiftArray.Length];
-                for (int i = 0; i < shiftArray.Length; i++)
-                    _featureMinShift[i] = NumOps.FromDouble(shiftArray[i]);
-            }
-        }
-    }
 }
diff --git a/src/Classification/NaiveBayes/NaiveBayesBase.cs b/src/Classification/NaiveBayes/NaiveBayesBase.cs
index e1a41a4186..a561a80111 100644
--- a/src/Classification/NaiveBayes/NaiveBayesBase.cs
+++ b/src/Classification/NaiveBayes/NaiveBayesBase.cs
@@ -1,3 +1,4 @@
+using AiDotNet.Attributes;
 using AiDotNet.Models.Options;
 
 using AiDotNet.Interfaces;
@@ -24,7 +25,7 @@ namespace AiDotNet.Classification.NaiveBayes;
 /// and picks the class with the highest probability.
 /// </para>
 /// </remarks>
-public abstract class NaiveBayesBase<T> : ProbabilisticClassifierBase<T>,
+public abstract partial class NaiveBayesBase<T> : ProbabilisticClassifierBase<T>,
     IParameterizable<T, Matrix<T>, Vector<T>>
 {
 
@@ -56,11 +57,13 @@ protected override void RegisterComponents()
     /// <summary>
     /// Stores the log prior probabilities for each class.
     /// </summary>
+    [Buffer]
     protected Vector<T>? LogPriors { get; set; }
 
     /// <summary>
     /// Stores the count of samples per class during training.
     /// </summary>
+    [Buffer]
     protected int[]? ClassCounts { get; set; }
 
     /// <summary>
diff --git a/src/Classification/Neighbors/KNeighborsClassifier.cs b/src/Classification/Neighbors/KNeighborsClassifier.cs
index f3dc44485e..4a65b81375 100644
--- a/src/Classification/Neighbors/KNeighborsClassifier.cs
+++ b/src/Classification/Neighbors/KNeighborsClassifier.cs
@@ -51,7 +51,7 @@ namespace AiDotNet.Classification.Neighbors;
 [ModelComplexity(ModelComplexity.Low)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
     [ResearchPaper("Nearest Neighbor Pattern Classification", "https://doi.org/10.1109/TIT.1967.1053964")]
-public class KNeighborsClassifier<T> : ProbabilisticClassifierBase<T>
+public partial class KNeighborsClassifier<T> : ProbabilisticClassifierBase<T>
 {
 
     // A lazy learner: it stores training data, not parameters, as its own comment says.
@@ -352,70 +352,6 @@ private int GetClassIndex(T label)
         throw new ArgumentException($"Label {label} not found in class labels.");
     }
 
-    /// <inheritdoc/>
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        return new KNeighborsClassifier<T>(new KNeighborsOptions<T>
-        {
-            NNeighbors = Options.NNeighbors,
-            Metric = Options.Metric,
-            Weights = Options.Weights,
-            P = Options.P,
-            Algorithm = Options.Algorithm,
-            LeafSize = Options.LeafSize
-        });
-    }
-
-    /// <inheritdoc/>
-    public override IFullModel<T, Matrix<T>, Vector<T>> Clone()
-    {
-        var clone = new KNeighborsClassifier<T>(new KNeighborsOptions<T>
-        {
-            NNeighbors = Options.NNeighbors,
-            Metric = Options.Metric,
-            Weights = Options.Weights,
-            P = Options.P,
-            Algorithm = Options.Algorithm,
-            LeafSize = Options.LeafSize
-        });
-
-        clone.NumFeatures = NumFeatures;
-        clone.NumClasses = NumClasses;
-        clone.TaskType = TaskType;
-
-        if (ClassLabels != null)
-        {
-            clone.ClassLabels = new Vector<T>(ClassLabels.Length);
-            for (int i = 0; i < ClassLabels.Length; i++)
-            {
-                clone.ClassLabels[i] = ClassLabels[i];
-            }
-        }
-
-        if (_xTrain != null)
-        {
-            clone._xTrain = new Matrix<T>(_xTrain.Rows, _xTrain.Columns);
-            for (int i = 0; i < _xTrain.Rows; i++)
-            {
-                for (int j = 0; j < _xTrain.Columns; j++)
-                {
-                    clone._xTrain[i, j] = _xTrain[i, j];
-                }
-            }
-        }
-
-        if (_yTrain != null)
-        {
-            clone._yTrain = new Vector<T>(_yTrain.Length);
-            for (int i = 0; i < _yTrain.Length; i++)
-            {
-                clone._yTrain[i] = _yTrain[i];
-            }
-        }
-
-        return clone;
-    }
-
     /// <inheritdoc/>
     public override IFullModel<T, Matrix<T>, Vector<T>> WithParameters(Vector<T> parameters)
     {
@@ -449,143 +385,4 @@ public override ModelMetadata<T> GetModelMetadata()
         metadata.AdditionalInfo["TrainingSamples"] = _xTrain?.Rows ?? 0;
         return metadata;
     }
-
-    /// <inheritdoc/>
-    public override byte[] Serialize()
-    {
-        var modelData = new Dictionary<string, object>
-        {
-            { "NumClasses", NumClasses },
-            { "NumFeatures", NumFeatures },
-            { "TaskType", (int)TaskType },
-            { "ClassLabels", ClassLabels?.ToArray() ?? Array.Empty<T>() },
-            { "RegularizationOptions", Regularization.GetOptions() },
-            // KNN-specific options
-            { "NNeighbors", Options.NNeighbors },
-            { "Metric", (int)Options.Metric },
-            { "Weights", (int)Options.Weights },
-            { "P", Options.P },
-            { "Algorithm", (int)Options.Algorithm },
-            { "LeafSize", Options.LeafSize }
-        };
-
-        // Serialize _xTrain matrix
-        if (_xTrain is not null)
-        {
-            var xTrainArray = new double[_xTrain.Rows * _xTrain.Columns];
-            int idx = 0;
-            for (int i = 0; i < _xTrain.Rows; i++)
-            {
-                for (int j = 0; j < _xTrain.Columns; j++)
-                {
-                    xTrainArray[idx++] = NumOps.ToDouble(_xTrain[i, j]);
-                }
-            }
-            modelData["XTrain"] = xTrainArray;
-            modelData["XTrainRows"] = _xTrain.Rows;
-            modelData["XTrainCols"] = _xTrain.Columns;
-        }
-
-        // Serialize _yTrain vector
-        if (_yTrain is not null)
-        {
-            var yTrainArray = new double[_yTrain.Length];
-            for (int i = 0; i < _yTrain.Length; i++)
-            {
-                yTrainArray[i] = NumOps.ToDouble(_yTrain[i]);
-            }
-            modelData["YTrain"] = yTrainArray;
-        }
-
-        var modelMetadata = GetModelMetadata();
-        modelMetadata.ModelData = System.Text.Encoding.UTF8.GetBytes(
-            Newtonsoft.Json.JsonConvert.SerializeObject(modelData));
-
-        return System.Text.Encoding.UTF8.GetBytes(
-            Newtonsoft.Json.JsonConvert.SerializeObject(modelMetadata));
-    }
-
-    /// <inheritdoc/>
-    public override void Deserialize(byte[] modelData)
-    {
-        var jsonString = System.Text.Encoding.UTF8.GetString(modelData);
-        var modelMetadata = Newtonsoft.Json.JsonConvert.DeserializeObject<ModelMetadata<T>>(jsonString);
-
-        if (modelMetadata == null || modelMetadata.ModelData == null)
-        {
-            throw new InvalidOperationException("Deserialization failed: The model data is invalid or corrupted.");
-        }
-
-        var modelDataString = System.Text.Encoding.UTF8.GetString(modelMetadata.ModelData);
-        var modelDataObj = Newtonsoft.Json.JsonConvert.DeserializeObject<Newtonsoft.Json.Linq.JObject>(modelDataString);
-
-        if (modelDataObj == null)
-        {
-            throw new InvalidOperationException("Deserialization failed: The model data is invalid or corrupted.");
-        }
-
-        // Deserialize base properties
-        NumClasses = modelDataObj["NumClasses"]?.ToObject<int>() ?? 0;
-        NumFeatures = modelDataObj["NumFeatures"]?.ToObject<int>() ?? 0;
-        TaskType = (ClassificationTaskType)(modelDataObj["TaskType"]?.ToObject<int>() ?? 0);
-
-        // Deserialize KNN-specific options
-        Options.NNeighbors = modelDataObj["NNeighbors"]?.ToObject<int>() ?? 5;
-        Options.Metric = (DistanceMetric)(modelDataObj["Metric"]?.ToObject<int>() ?? 0);
-        Options.Weights = (WeightingScheme)(modelDataObj["Weights"]?.ToObject<int>() ?? 0);
-        Options.P = modelDataObj["P"]?.ToObject<double>() ?? 2.0;
-        Options.Algorithm = (KNNAlgorithm)(modelDataObj["Algorithm"]?.ToObject<int>() ?? 0);
-        Options.LeafSize = modelDataObj["LeafSize"]?.ToObject<int>() ?? 30;
-
-        var classLabelsToken = modelDataObj["ClassLabels"];
-        if (classLabelsToken is not null)
-        {
-            var classLabelsAsDoubles = classLabelsToken.ToObject<double[]>() ?? Array.Empty<double>();
-            if (classLabelsAsDoubles.Length > 0)
-            {
-                ClassLabels = new Vector<T>(classLabelsAsDoubles.Length);
-                for (int i = 0; i < classLabelsAsDoubles.Length; i++)
-                {
-                    ClassLabels[i] = NumOps.FromDouble(classLabelsAsDoubles[i]);
-                }
-            }
-        }
-
-        // Deserialize _xTrain matrix
-        var xTrainToken = modelDataObj["XTrain"];
-        if (xTrainToken is not null)
-        {
-            var xTrainArray = xTrainToken.ToObject<double[]>() ?? Array.Empty<double>();
-            int rows = modelDataObj["XTrainRows"]?.ToObject<int>() ?? 0;
-            int cols = modelDataObj["XTrainCols"]?.ToObject<int>() ?? 0;
-
-            if (rows > 0 && cols > 0)
-            {
-                _xTrain = new Matrix<T>(rows, cols);
-                int idx = 0;
-                for (int i = 0; i < rows; i++)
-                {
-                    for (int j = 0; j < cols; j++)
-                    {
-                        _xTrain[i, j] = NumOps.FromDouble(xTrainArray[idx++]);
-                    }
-                }
-            }
-        }
-
-        // Deserialize _yTrain vector
-        var yTrainToken = modelDataObj["YTrain"];
-        if (yTrainToken is not null)
-        {
-            var yTrainArray = yTrainToken.ToObject<double[]>() ?? Array.Empty<double>();
-            if (yTrainArray.Length > 0)
-            {
-                _yTrain = new Vector<T>(yTrainArray.Length);
-                for (int i = 0; i < yTrainArray.Length; i++)
-                {
-                    _yTrain[i] = NumOps.FromDouble(yTrainArray[i]);
-                }
-            }
-        }
-    }
 }
diff --git a/src/Classification/Online/AdaptiveRandomForestClassifier.cs b/src/Classification/Online/AdaptiveRandomForestClassifier.cs
index a2aa6c1469..7721fccba7 100644
--- a/src/Classification/Online/AdaptiveRandomForestClassifier.cs
+++ b/src/Classification/Online/AdaptiveRandomForestClassifier.cs
@@ -77,7 +77,7 @@ namespace AiDotNet.Classification.Online;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
 [ResearchPaper("Adaptive Random Forests for Evolving Data Stream Classification", "https://doi.org/10.1007/s10994-017-5642-8", Year = 2017, Authors = "Heitor Murilo Gomes, Albert Bifet, Jesse Read, Jean Paul Barddal, Fabricio Enembreck, Bernhard Pfharinger, Geoff Holmes, Talel Abdessalem")]
-public class AdaptiveRandomForestClassifier<T> : ClassifierBase<T>, IOnlineClassifier<T>
+public partial class AdaptiveRandomForestClassifier<T> : ClassifierBase<T>, IOnlineClassifier<T>
 {
 
     // Returned a single value described in its own comment as "minimal parameters" for a
@@ -537,137 +537,4 @@ public override IFullModel<T, Matrix<T>, Vector<T>> WithParameters(Vector<T> par
         // Structural parameters only - ensemble cannot be set from flat parameters.
         return new AdaptiveRandomForestClassifier<T>(_options);
     }
-
-    /// <inheritdoc />
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        return new AdaptiveRandomForestClassifier<T>(_options);
-    }
-
-    /// <summary>
-    /// Serializes the trained ARF ensemble including all Hoeffding trees and metadata.
-    /// </summary>
-    public override byte[] Serialize()
-    {
-        var modelData = new Dictionary<string, object>
-        {
-            { "NumClasses", NumClasses },
-            { "NumFeatures", NumFeatures },
-            { "TaskType", (int)TaskType },
-            { "ClassLabels", ClassLabels?.ToArray() ?? Array.Empty<T>() },
-            { "SamplesSeen", SamplesSeen },
-            { "EnsembleCount", _ensemble.Count }
-        };
-
-        var knownClassValues = new double[_knownClasses.Count];
-        for (int i = 0; i < _knownClasses.Count; i++)
-            knownClassValues[i] = NumOps.ToDouble(_knownClasses[i]);
-        modelData["KnownClasses"] = knownClassValues;
-
-        for (int i = 0; i < _ensemble.Count; i++)
-        {
-            var member = _ensemble[i];
-            var memberDict = new Dictionary<string, object?>
-            {
-                { "SelectedFeatures", member.SelectedFeatures },
-                { "AccuracyEstimate", member.AccuracyEstimate },
-                { "CorrectCount", member.CorrectCount },
-                { "TotalCount", member.TotalCount },
-                { "InWarning", member.InWarning }
-            };
-
-            if (member.Tree is not null)
-            {
-                memberDict["TreeData"] = Convert.ToBase64String(member.Tree.Serialize());
-            }
-
-            if (member.BackgroundTree is not null)
-            {
-                memberDict["BackgroundTreeData"] = Convert.ToBase64String(member.BackgroundTree.Serialize());
-            }
-
-            modelData[$"Member_{i}"] = memberDict;
-        }
-
-        var modelMetadata = GetModelMetadata();
-        modelMetadata.ModelData = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(modelData));
-        return Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(modelMetadata));
-    }
-
-    /// <summary>
-    /// Deserializes the trained ARF ensemble including all Hoeffding trees and metadata.
-    /// </summary>
-    public override void Deserialize(byte[] modelData)
-    {
-        var jsonString = Encoding.UTF8.GetString(modelData);
-        var modelMetadata = JsonConvert.DeserializeObject<ModelMetadata<T>>(jsonString);
-        if (modelMetadata?.ModelData is null)
-            throw new InvalidOperationException("Deserialization failed: invalid model data.");
-
-        var dataString = Encoding.UTF8.GetString(modelMetadata.ModelData);
-        var dataObj = JsonConvert.DeserializeObject<JObject>(dataString);
-        if (dataObj is null)
-            throw new InvalidOperationException("Deserialization failed: invalid model data.");
-
-        NumClasses = dataObj["NumClasses"]?.ToObject<int>() ?? 0;
-        NumFeatures = dataObj["NumFeatures"]?.ToObject<int>() ?? 0;
-        TaskType = (ClassificationTaskType)(dataObj["TaskType"]?.ToObject<int>() ?? 0);
-        SamplesSeen = dataObj["SamplesSeen"]?.ToObject<long>() ?? 0;
-
-        var classLabelsToken = dataObj["ClassLabels"];
-        if (classLabelsToken is not null)
-        {
-            var arr = classLabelsToken.ToObject<double[]>() ?? Array.Empty<double>();
-            if (arr.Length > 0)
-            {
-                ClassLabels = new Vector<T>(arr.Length);
-                for (int i = 0; i < arr.Length; i++)
-                    ClassLabels[i] = NumOps.FromDouble(arr[i]);
-            }
-        }
-
-        _knownClasses.Clear();
-        var knownArr = dataObj["KnownClasses"]?.ToObject<double[]>();
-        if (knownArr is not null)
-        {
-            foreach (var val in knownArr)
-                _knownClasses.Add(NumOps.FromDouble(val));
-        }
-
-        _ensemble.Clear();
-        int ensembleCount = dataObj["EnsembleCount"]?.ToObject<int>() ?? 0;
-        for (int i = 0; i < ensembleCount; i++)
-        {
-            if (dataObj[$"Member_{i}"] is JObject memberObj)
-            {
-                var member = new TreeMember
-                {
-                    SelectedFeatures = memberObj["SelectedFeatures"]?.ToObject<int[]>(),
-                    AccuracyEstimate = memberObj["AccuracyEstimate"]?.ToObject<double>() ?? 1.0,
-                    CorrectCount = memberObj["CorrectCount"]?.ToObject<long>() ?? 0,
-                    TotalCount = memberObj["TotalCount"]?.ToObject<long>() ?? 0,
-                    InWarning = memberObj["InWarning"]?.ToObject<bool>() ?? false,
-                    DriftDetector = new DDMDriftDetector<T>(_options.WarningThreshold, _options.DriftThreshold),
-                    WarningDetector = new DDMDriftDetector<T>(
-                        _options.WarningThreshold * 0.7, _options.DriftThreshold * 0.7)
-                };
-
-                var treeDataStr = memberObj["TreeData"]?.ToObject<string>();
-                if (treeDataStr is not null)
-                {
-                    member.Tree = CreateTree();
-                    member.Tree.Deserialize(Convert.FromBase64String(treeDataStr));
-                }
-
-                var bgTreeDataStr = memberObj["BackgroundTreeData"]?.ToObject<string>();
-                if (bgTreeDataStr is not null)
-                {
-                    member.BackgroundTree = CreateTree();
-                    member.BackgroundTree.Deserialize(Convert.FromBase64String(bgTreeDataStr));
-                }
-
-                _ensemble.Add(member);
-            }
-        }
-    }
 }
diff --git a/src/Classification/Online/HoeffdingTreeClassifier.cs b/src/Classification/Online/HoeffdingTreeClassifier.cs
index 53b26eda30..636d3fc166 100644
--- a/src/Classification/Online/HoeffdingTreeClassifier.cs
+++ b/src/Classification/Online/HoeffdingTreeClassifier.cs
@@ -70,7 +70,7 @@ namespace AiDotNet.Classification.Online;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
 [ResearchPaper("Mining High-Speed Data Streams", "https://doi.org/10.1145/347090.347107", Year = 2000, Authors = "Pedro Domingos, Geoff Hulten")]
-public class HoeffdingTreeClassifier<T> : ClassifierBase<T>, IOnlineClassifier<T>
+public partial class HoeffdingTreeClassifier<T> : ClassifierBase<T>, IOnlineClassifier<T>
 {
 
     // Its own comment: "Tree-based model - structure cannot be set from flat parameters".
@@ -729,87 +729,6 @@ private void PerformSplit(HoeffdingNode leaf, int feature, double threshold)
     public override IFullModel<T, Matrix<T>, Vector<T>> WithParameters(Vector<T> parameters)
         => new HoeffdingTreeClassifier<T>(_options);
 
-    /// <inheritdoc />
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        return new HoeffdingTreeClassifier<T>(_options);
-    }
-
-    /// <summary>
-    /// Serializes the trained Hoeffding tree including all nodes and statistics.
-    /// </summary>
-    public override byte[] Serialize()
-    {
-        var modelData = new Dictionary<string, object>
-        {
-            { "NumClasses", NumClasses },
-            { "NumFeatures", NumFeatures },
-            { "TaskType", (int)TaskType },
-            { "ClassLabels", ClassLabels?.ToArray() ?? Array.Empty<T>() },
-            { "SamplesSeen", SamplesSeen }
-        };
-
-        var knownClassValues = new double[_knownClasses.Count];
-        for (int i = 0; i < _knownClasses.Count; i++)
-            knownClassValues[i] = NumOps.ToDouble(_knownClasses[i]);
-        modelData["KnownClasses"] = knownClassValues;
-
-        if (_root is not null)
-        {
-            modelData["Root"] = SerializeNode(_root);
-        }
-
-        var modelMetadata = GetModelMetadata();
-        modelMetadata.ModelData = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(modelData));
-        return Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(modelMetadata));
-    }
-
-    /// <summary>
-    /// Deserializes the trained Hoeffding tree including all nodes and statistics.
-    /// </summary>
-    public override void Deserialize(byte[] modelData)
-    {
-        var jsonString = Encoding.UTF8.GetString(modelData);
-        var modelMetadata = JsonConvert.DeserializeObject<ModelMetadata<T>>(jsonString);
-        if (modelMetadata?.ModelData is null)
-            throw new InvalidOperationException("Deserialization failed: invalid model data.");
-
-        var dataString = Encoding.UTF8.GetString(modelMetadata.ModelData);
-        var dataObj = JsonConvert.DeserializeObject<JObject>(dataString);
-        if (dataObj is null)
-            throw new InvalidOperationException("Deserialization failed: invalid model data.");
-
-        NumClasses = dataObj["NumClasses"]?.ToObject<int>() ?? 0;
-        NumFeatures = dataObj["NumFeatures"]?.ToObject<int>() ?? 0;
-        TaskType = (ClassificationTaskType)(dataObj["TaskType"]?.ToObject<int>() ?? 0);
-        SamplesSeen = dataObj["SamplesSeen"]?.ToObject<long>() ?? 0;
-
-        var classLabelsToken = dataObj["ClassLabels"];
-        if (classLabelsToken is not null)
-        {
-            var arr = classLabelsToken.ToObject<double[]>() ?? Array.Empty<double>();
-            if (arr.Length > 0)
-            {
-                ClassLabels = new Vector<T>(arr.Length);
-                for (int i = 0; i < arr.Length; i++)
-                    ClassLabels[i] = NumOps.FromDouble(arr[i]);
-            }
-        }
-
-        _knownClasses.Clear();
-        var knownArr = dataObj["KnownClasses"]?.ToObject<double[]>();
-        if (knownArr is not null)
-        {
-            foreach (var val in knownArr)
-                _knownClasses.Add(NumOps.FromDouble(val));
-        }
-
-        if (dataObj["Root"] is JObject rootObj)
-        {
-            _root = DeserializeNode(rootObj);
-        }
-    }
-
     private static Dictionary<string, object?> SerializeNode(HoeffdingNode node)
     {
         var dict = new Dictionary<string, object?>
diff --git a/src/Classification/Online/OnlineNaiveBayesClassifier.cs b/src/Classification/Online/OnlineNaiveBayesClassifier.cs
index 84f8c409ff..4fde068ff5 100644
--- a/src/Classification/Online/OnlineNaiveBayesClassifier.cs
+++ b/src/Classification/Online/OnlineNaiveBayesClassifier.cs
@@ -74,7 +74,7 @@ namespace AiDotNet.Classification.Online;
 [ModelComplexity(ModelComplexity.Low)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
 [ResearchPaper("A Comparison of Event Models for Naive Bayes Text Classification", "https://www.cs.cmu.edu/~knigam/papers/multinomial-aaaiws98.pdf")]
-public class OnlineNaiveBayesClassifier<T> : ClassifierBase<T>, IOnlineClassifier<T>,
+public partial class OnlineNaiveBayesClassifier<T> : ClassifierBase<T>, IOnlineClassifier<T>,
     IParameterizable<T, Matrix<T>, Vector<T>>
 {
 
@@ -447,112 +447,4 @@ public override IFullModel<T, Matrix<T>, Vector<T>> WithParameters(Vector<T> par
         clone.SetParameters(parameters);
         return clone;
     }
-
-    /// <inheritdoc />
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        return new OnlineNaiveBayesClassifier<T>(_options);
-    }
-
-    /// <summary>
-    /// Serializes the trained model state including per-class statistics.
-    /// </summary>
-    public override byte[] Serialize()
-    {
-        var modelData = new Dictionary<string, object>
-        {
-            { "NumClasses", NumClasses },
-            { "NumFeatures", NumFeatures },
-            { "TaskType", (int)TaskType },
-            { "ClassLabels", ClassLabels?.ToArray() ?? Array.Empty<T>() },
-            { "SamplesSeen", SamplesSeen },
-            { "KnownClassCount", _knownClasses.Count }
-        };
-
-        // Save known classes
-        var knownClassValues = new double[_knownClasses.Count];
-        for (int i = 0; i < _knownClasses.Count; i++)
-            knownClassValues[i] = NumOps.ToDouble(_knownClasses[i]);
-        modelData["KnownClasses"] = knownClassValues;
-
-        // Save per-class statistics
-        modelData["ClassStatsCount"] = _classStats.Count;
-        int idx = 0;
-        foreach (var kvp in _classStats)
-        {
-            var statsDict = new Dictionary<string, object>
-            {
-                { "ClassIdx", kvp.Key },
-                { "Count", kvp.Value.Count },
-                { "Means", kvp.Value.Means ?? Array.Empty<double>() },
-                { "M2", kvp.Value.M2 ?? Array.Empty<double>() }
-            };
-            modelData[$"ClassStats_{idx}"] = statsDict;
-            idx++;
-        }
-
-        var modelMetadata = GetModelMetadata();
-        modelMetadata.ModelData = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(modelData));
-        return Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(modelMetadata));
-    }
-
-    /// <summary>
-    /// Deserializes the trained model state including per-class statistics.
-    /// </summary>
-    public override void Deserialize(byte[] modelData)
-    {
-        var jsonString = Encoding.UTF8.GetString(modelData);
-        var modelMetadata = JsonConvert.DeserializeObject<ModelMetadata<T>>(jsonString);
-        if (modelMetadata?.ModelData is null)
-            throw new InvalidOperationException("Deserialization failed: invalid model data.");
-
-        var dataString = Encoding.UTF8.GetString(modelMetadata.ModelData);
-        var dataObj = JsonConvert.DeserializeObject<JObject>(dataString);
-        if (dataObj is null)
-            throw new InvalidOperationException("Deserialization failed: invalid model data.");
-
-        NumClasses = dataObj["NumClasses"]?.ToObject<int>() ?? 0;
-        NumFeatures = dataObj["NumFeatures"]?.ToObject<int>() ?? 0;
-        TaskType = (ClassificationTaskType)(dataObj["TaskType"]?.ToObject<int>() ?? 0);
-        SamplesSeen = dataObj["SamplesSeen"]?.ToObject<long>() ?? 0;
-
-        var classLabelsToken = dataObj["ClassLabels"];
-        if (classLabelsToken is not null)
-        {
-            var arr = classLabelsToken.ToObject<double[]>() ?? Array.Empty<double>();
-            if (arr.Length > 0)
-            {
-                ClassLabels = new Vector<T>(arr.Length);
-                for (int i = 0; i < arr.Length; i++)
-                    ClassLabels[i] = NumOps.FromDouble(arr[i]);
-            }
-        }
-
-        // Restore known classes
-        _knownClasses.Clear();
-        var knownClassesArr = dataObj["KnownClasses"]?.ToObject<double[]>();
-        if (knownClassesArr is not null)
-        {
-            foreach (var val in knownClassesArr)
-                _knownClasses.Add(NumOps.FromDouble(val));
-        }
-
-        // Restore per-class statistics
-        _classStats.Clear();
-        int statsCount = dataObj["ClassStatsCount"]?.ToObject<int>() ?? 0;
-        for (int i = 0; i < statsCount; i++)
-        {
-            if (dataObj[$"ClassStats_{i}"] is JObject statsObj)
-            {
-                int classIdx = statsObj["ClassIdx"]?.ToObject<int>() ?? 0;
-                var stats = new ClassStatistics
-                {
-                    Count = statsObj["Count"]?.ToObject<long>() ?? 0,
-                    Means = statsObj["Means"]?.ToObject<double[]>(),
-                    M2 = statsObj["M2"]?.ToObject<double[]>()
-                };
-                _classStats[classIdx] = stats;
-            }
-        }
-    }
 }
diff --git a/src/Classification/Ordinal/OrdinalClassifierBase.cs b/src/Classification/Ordinal/OrdinalClassifierBase.cs
index 5cd9a57539..c035028098 100644
--- a/src/Classification/Ordinal/OrdinalClassifierBase.cs
+++ b/src/Classification/Ordinal/OrdinalClassifierBase.cs
@@ -23,7 +23,7 @@ namespace AiDotNet.Classification.Ordinal;
 /// Predicting 4 stars when the truth is 5 stars is a smaller error than predicting 1 star.</para>
 /// </remarks>
 /// <typeparam name="T">The numeric type for calculations.</typeparam>
-public abstract class OrdinalClassifierBase<T> : ClassifierBase<T>, IOrdinalClassifier<T>
+public abstract partial class OrdinalClassifierBase<T> : ClassifierBase<T>, IOrdinalClassifier<T>
 {
     /// <summary>
     /// The learned thresholds that separate ordinal classes.
diff --git a/src/Classification/Ordinal/OrdinalLogisticRegression.cs b/src/Classification/Ordinal/OrdinalLogisticRegression.cs
index 20bc3d57e9..55d8de36ad 100644
--- a/src/Classification/Ordinal/OrdinalLogisticRegression.cs
+++ b/src/Classification/Ordinal/OrdinalLogisticRegression.cs
@@ -64,7 +64,7 @@ namespace AiDotNet.Classification.Ordinal;
 [ModelComplexity(ModelComplexity.Low)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
 [ResearchPaper("Regression Models for Ordinal Data", "https://doi.org/10.1111/j.2517-6161.1980.tb01109.x", Year = 1980, Authors = "Peter McCullagh")]
-public class OrdinalLogisticRegression<T> : OrdinalClassifierBase<T>,
+public partial class OrdinalLogisticRegression<T> : OrdinalClassifierBase<T>,
     IParameterizable<T, Matrix<T>, Vector<T>>, IGradientComputable<T, Matrix<T>, Vector<T>>
 {
 
@@ -89,6 +89,7 @@ protected override void RegisterComponents()
     /// ordinal outcome. A positive coefficient means higher values of that feature push
     /// predictions toward higher classes (e.g., more stars).</para>
     /// </remarks>
+    [AiDotNet.Attributes.FittedParameter]
     private Vector<T>? _coefficients;
 
     /// <summary>
@@ -660,19 +661,6 @@ public override Vector<T> SanitizeParameters(Vector<T> parameters)
         return sanitized;
     }
 
-    /// <summary>
-    /// Creates a new instance of this model type.
-    /// </summary>
-    /// <returns>New instance with same hyperparameters.</returns>
-    /// <remarks>
-    /// <para><b>For Beginners:</b> Creates a fresh, untrained copy of the model with
-    /// the same configuration settings (learning rate, iterations, etc.).</para>
-    /// </remarks>
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        return new OrdinalLogisticRegression<T>(_learningRate, _maxIterations, _tolerance, _regularizationStrength);
-    }
-
     /// <summary>
     /// Computes gradients for the model parameters.
     /// </summary>
@@ -828,94 +816,6 @@ public void ApplyGradients(Vector<T> gradients, T learningRate)
         }
     }
 
-    /// <inheritdoc/>
-    public override byte[] Serialize()
-    {
-        var modelData = new Dictionary<string, object>
-        {
-            { "NumClasses", NumClasses },
-            { "NumFeatures", NumFeatures },
-            { "TaskType", (int)TaskType },
-            { "ClassLabels", ClassLabels?.ToArray() ?? Array.Empty<T>() }
-        };
-
-        if (_coefficients is not null)
-        {
-            var coefArray = new double[_coefficients.Length];
-            for (int i = 0; i < _coefficients.Length; i++)
-                coefArray[i] = NumOps.ToDouble(_coefficients[i]);
-            modelData["Coefficients"] = coefArray;
-        }
-
-        if (_thresholds is not null)
-        {
-            var threshArray = new double[_thresholds.Length];
-            for (int i = 0; i < _thresholds.Length; i++)
-                threshArray[i] = NumOps.ToDouble(_thresholds[i]);
-            modelData["Thresholds"] = threshArray;
-        }
-
-        var modelMetadata = GetModelMetadata();
-        modelMetadata.ModelData = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(modelData));
-        return Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(modelMetadata));
-    }
-
-    /// <inheritdoc/>
-    public override void Deserialize(byte[] modelData)
-    {
-        var jsonString = Encoding.UTF8.GetString(modelData);
-        var modelMetadata = JsonConvert.DeserializeObject<ModelMetadata<T>>(jsonString);
-
-        if (modelMetadata == null || modelMetadata.ModelData == null)
-            throw new InvalidOperationException("Deserialization failed: The model data is invalid or corrupted.");
-
-        var modelDataString = Encoding.UTF8.GetString(modelMetadata.ModelData);
-        var modelDataObj = JsonConvert.DeserializeObject<JObject>(modelDataString);
-
-        if (modelDataObj == null)
-            throw new InvalidOperationException("Deserialization failed: The model data is invalid or corrupted.");
-
-        NumClasses = modelDataObj["NumClasses"]?.ToObject<int>() ?? 0;
-        NumFeatures = modelDataObj["NumFeatures"]?.ToObject<int>() ?? 0;
-        TaskType = (ClassificationTaskType)(modelDataObj["TaskType"]?.ToObject<int>() ?? 0);
-
-        var classLabelsToken = modelDataObj["ClassLabels"];
-        if (classLabelsToken is not null)
-        {
-            var classLabelsAsDoubles = classLabelsToken.ToObject<double[]>() ?? Array.Empty<double>();
-            if (classLabelsAsDoubles.Length > 0)
-            {
-                ClassLabels = new Vector<T>(classLabelsAsDoubles.Length);
-                for (int i = 0; i < classLabelsAsDoubles.Length; i++)
-                    ClassLabels[i] = NumOps.FromDouble(classLabelsAsDoubles[i]);
-            }
-        }
-
-        var coefToken = modelDataObj["Coefficients"];
-        if (coefToken is not null)
-        {
-            var coefArray = coefToken.ToObject<double[]>() ?? Array.Empty<double>();
-            if (coefArray.Length > 0)
-            {
-                _coefficients = new Vector<T>(coefArray.Length);
-                for (int i = 0; i < coefArray.Length; i++)
-                    _coefficients[i] = NumOps.FromDouble(coefArray[i]);
-            }
-        }
-
-        var threshToken = modelDataObj["Thresholds"];
-        if (threshToken is not null)
-        {
-            var threshArray = threshToken.ToObject<double[]>() ?? Array.Empty<double>();
-            if (threshArray.Length > 0)
-            {
-                _thresholds = new Vector<T>(threshArray.Length);
-                for (int i = 0; i < threshArray.Length; i++)
-                    _thresholds[i] = NumOps.FromDouble(threshArray[i]);
-            }
-        }
-    }
-
     /// <summary>
     /// Gets feature importance based on coefficient magnitude.
     /// </summary>
diff --git a/src/Classification/Ordinal/OrdinalRidgeRegression.cs b/src/Classification/Ordinal/OrdinalRidgeRegression.cs
index 5eb2b5a4e8..2dbd0ab0d6 100644
--- a/src/Classification/Ordinal/OrdinalRidgeRegression.cs
+++ b/src/Classification/Ordinal/OrdinalRidgeRegression.cs
@@ -87,7 +87,7 @@ namespace AiDotNet.Classification.Ordinal;
 [ModelComplexity(ModelComplexity.Low)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
 [ResearchPaper("Ridge Regression: Biased Estimation for Nonorthogonal Problems", "https://doi.org/10.1080/00401706.1970.10488634")]
-public class OrdinalRidgeRegression<T> : OrdinalClassifierBase<T>,
+public partial class OrdinalRidgeRegression<T> : OrdinalClassifierBase<T>,
     IParameterizable<T, Matrix<T>, Vector<T>>, IGradientComputable<T, Matrix<T>, Vector<T>>
 {
 
@@ -111,6 +111,7 @@ protected override void RegisterComponents()
     /// <para><b>For Beginners:</b> These coefficients determine how each feature affects the
     /// predicted value. Positive coefficients push predictions toward higher classes.</para>
     /// </remarks>
+    [AiDotNet.Attributes.FittedParameter]
     private Vector<T>? _coefficients;
 
     /// <summary>
@@ -584,18 +585,6 @@ public override IFullModel<T, Matrix<T>, Vector<T>> WithParameters(Vector<T> par
         return model;
     }
 
-    /// <summary>
-    /// Creates a new instance of this model type.
-    /// </summary>
-    /// <returns>New instance with same hyperparameters.</returns>
-    /// <remarks>
-    /// <para><b>For Beginners:</b> Creates an untrained copy with the same settings.</para>
-    /// </remarks>
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        return new OrdinalRidgeRegression<T>(_alpha, _fitIntercept);
-    }
-
     /// <summary>
     /// Computes gradients for the model parameters.
     /// </summary>
@@ -702,101 +691,6 @@ public void ApplyGradients(Vector<T> gradients, T learningRate)
         // Note: Thresholds are not updated via gradient descent
     }
 
-    /// <inheritdoc/>
-    public override byte[] Serialize()
-    {
-        var modelData = new Dictionary<string, object>
-        {
-            { "NumClasses", NumClasses },
-            { "NumFeatures", NumFeatures },
-            { "TaskType", (int)TaskType },
-            { "ClassLabels", ClassLabels?.ToArray() ?? Array.Empty<T>() },
-            { "Bias", NumOps.ToDouble(_bias) },
-            { "Alpha", _alpha },
-            { "FitIntercept", _fitIntercept }
-        };
-
-        if (_coefficients is not null)
-        {
-            var coefArray = new double[_coefficients.Length];
-            for (int i = 0; i < _coefficients.Length; i++)
-                coefArray[i] = NumOps.ToDouble(_coefficients[i]);
-            modelData["Coefficients"] = coefArray;
-        }
-
-        if (_thresholds is not null)
-        {
-            var threshArray = new double[_thresholds.Length];
-            for (int i = 0; i < _thresholds.Length; i++)
-                threshArray[i] = NumOps.ToDouble(_thresholds[i]);
-            modelData["Thresholds"] = threshArray;
-        }
-
-        var modelMetadata = GetModelMetadata();
-        modelMetadata.ModelData = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(modelData));
-        return Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(modelMetadata));
-    }
-
-    /// <inheritdoc/>
-    public override void Deserialize(byte[] modelData)
-    {
-        var jsonString = Encoding.UTF8.GetString(modelData);
-        var modelMetadata = JsonConvert.DeserializeObject<ModelMetadata<T>>(jsonString);
-
-        if (modelMetadata == null || modelMetadata.ModelData == null)
-            throw new InvalidOperationException("Deserialization failed: The model data is invalid or corrupted.");
-
-        var modelDataString = Encoding.UTF8.GetString(modelMetadata.ModelData);
-        var modelDataObj = JsonConvert.DeserializeObject<JObject>(modelDataString);
-
-        if (modelDataObj == null)
-            throw new InvalidOperationException("Deserialization failed: The model data is invalid or corrupted.");
-
-        NumClasses = modelDataObj["NumClasses"]?.ToObject<int>() ?? 0;
-        NumFeatures = modelDataObj["NumFeatures"]?.ToObject<int>() ?? 0;
-        TaskType = (ClassificationTaskType)(modelDataObj["TaskType"]?.ToObject<int>() ?? 0);
-
-        var classLabelsToken = modelDataObj["ClassLabels"];
-        if (classLabelsToken is not null)
-        {
-            var classLabelsAsDoubles = classLabelsToken.ToObject<double[]>() ?? Array.Empty<double>();
-            if (classLabelsAsDoubles.Length > 0)
-            {
-                ClassLabels = new Vector<T>(classLabelsAsDoubles.Length);
-                for (int i = 0; i < classLabelsAsDoubles.Length; i++)
-                    ClassLabels[i] = NumOps.FromDouble(classLabelsAsDoubles[i]);
-            }
-        }
-
-        _bias = NumOps.FromDouble(modelDataObj["Bias"]?.ToObject<double>() ?? 0.0);
-        _alpha = modelDataObj["Alpha"]?.ToObject<double>() ?? _alpha;
-        _fitIntercept = modelDataObj["FitIntercept"]?.ToObject<bool>() ?? _fitIntercept;
-
-        var coefToken = modelDataObj["Coefficients"];
-        if (coefToken is not null)
-        {
-            var coefArray = coefToken.ToObject<double[]>() ?? Array.Empty<double>();
-            if (coefArray.Length > 0)
-            {
-                _coefficients = new Vector<T>(coefArray.Length);
-                for (int i = 0; i < coefArray.Length; i++)
-                    _coefficients[i] = NumOps.FromDouble(coefArray[i]);
-            }
-        }
-
-        var threshToken = modelDataObj["Thresholds"];
-        if (threshToken is not null)
-        {
-            var threshArray = threshToken.ToObject<double[]>() ?? Array.Empty<double>();
-            if (threshArray.Length > 0)
-            {
-                _thresholds = new Vector<T>(threshArray.Length);
-                for (int i = 0; i < threshArray.Length; i++)
-                    _thresholds[i] = NumOps.FromDouble(threshArray[i]);
-            }
-        }
-    }
-
     /// <summary>
     /// Gets feature importance based on coefficient magnitude.
     /// </summary>
diff --git a/src/Classification/OrdinalRegression.cs b/src/Classification/OrdinalRegression.cs
index 4302994da4..8bf1f4593d 100644
--- a/src/Classification/OrdinalRegression.cs
+++ b/src/Classification/OrdinalRegression.cs
@@ -78,7 +78,7 @@ namespace AiDotNet.Classification;
 [ModelComplexity(ModelComplexity.Low)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
 [ResearchPaper("Regression Models for Ordinal Data", "https://doi.org/10.1111/j.2517-6161.1980.tb01109.x", Year = 1980, Authors = "Peter McCullagh")]
-public class OrdinalRegression<T> : ClassifierBase<T>,
+public partial class OrdinalRegression<T> : ClassifierBase<T>,
     IParameterizable<T, Matrix<T>, Vector<T>>, IGradientComputable<T, Matrix<T>, Vector<T>>
 {
 
@@ -106,12 +106,14 @@ protected override void RegisterComponents()
     /// <summary>
     /// Feature coefficients (β). Shared across all thresholds (proportional odds assumption).
     /// </summary>
+    [AiDotNet.Attributes.FittedParameter]
     private Vector<T> _coefficients = new Vector<T>(0);
 
     /// <summary>
     /// Threshold parameters (α_1, α_2, ..., α_{K-1}) where K is the number of classes.
     /// These are in increasing order: α_1 < α_2 < ... < α_{K-1}.
     /// </summary>
+    [AiDotNet.Attributes.FittedParameter]
     private Vector<T> _thresholds = new Vector<T>(0);
 
     /// <summary>
@@ -775,39 +777,6 @@ public override IFullModel<T, Matrix<T>, Vector<T>> WithParameters(Vector<T> par
         return newModel;
     }
 
-    /// <summary>
-    /// Creates a new instance of the same type as this classifier.
-    /// </summary>
-    /// <returns>A new instance of the same classifier type.</returns>
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        return new OrdinalRegression<T>(_options, Regularization);
-    }
-
-    /// <inheritdoc/>
-    public override IFullModel<T, Matrix<T>, Vector<T>> Clone()
-    {
-        var clone = (OrdinalRegression<T>)CreateNewInstance();
-        clone.NumFeatures = NumFeatures;
-        clone.NumClasses = NumClasses;
-        clone.ClassLabels = ClassLabels?.Clone();
-        clone.TaskType = TaskType;
-
-        if (_coefficients is not null)
-        {
-            clone._coefficients = new Vector<T>(_coefficients);
-        }
-        if (_thresholds is not null)
-        {
-            clone._thresholds = new Vector<T>(_thresholds);
-        }
-
-        return clone;
-    }
-
-    /// <inheritdoc/>
-    public override IFullModel<T, Matrix<T>, Vector<T>> DeepCopy() => Clone();
-
     /// <summary>
     /// Computes gradients for the model parameters.
     /// </summary>
diff --git a/src/Classification/SVM/LinearSupportVectorClassifier.cs b/src/Classification/SVM/LinearSupportVectorClassifier.cs
index 5c4c57b7f9..d1478373e7 100644
--- a/src/Classification/SVM/LinearSupportVectorClassifier.cs
+++ b/src/Classification/SVM/LinearSupportVectorClassifier.cs
@@ -347,67 +347,6 @@ public override Matrix<T> PredictProbabilities(Matrix<T> input)
         return probabilities;
     }
 
-    /// <inheritdoc/>
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        return new LinearSupportVectorClassifier<T>(new SVMOptions<T>
-        {
-            C = Options.C,
-            Kernel = KernelType.Linear,
-            Tolerance = Options.Tolerance,
-            MaxIterations = Options.MaxIterations,
-            Seed = Options.Seed
-        });
-    }
-
-    /// <inheritdoc/>
-    public override IFullModel<T, Matrix<T>, Vector<T>> Clone()
-    {
-        var clone = new LinearSupportVectorClassifier<T>(new SVMOptions<T>
-        {
-            C = Options.C,
-            Kernel = KernelType.Linear,
-            Tolerance = Options.Tolerance,
-            MaxIterations = Options.MaxIterations,
-            Seed = Options.Seed
-        });
-
-        clone.NumFeatures = NumFeatures;
-        clone.NumClasses = NumClasses;
-        clone.TaskType = TaskType;
-
-        if (ClassLabels is not null)
-        {
-            clone.ClassLabels = new Vector<T>(ClassLabels.Length);
-            for (int i = 0; i < ClassLabels.Length; i++)
-            {
-                clone.ClassLabels[i] = ClassLabels[i];
-            }
-        }
-
-        if (_weights is not null)
-        {
-            clone._weights = new Vector<T>(_weights.Length);
-            for (int i = 0; i < _weights.Length; i++)
-            {
-                clone._weights[i] = _weights[i];
-            }
-        }
-
-        clone._bias = _bias;
-
-        if (_intercept is not null)
-        {
-            clone._intercept = new Vector<T>(_intercept.Length);
-            for (int i = 0; i < _intercept.Length; i++)
-            {
-                clone._intercept[i] = _intercept[i];
-            }
-        }
-
-        return clone;
-    }
-
     /// <inheritdoc/>
     public override ModelMetadata<T> GetModelMetadata()
     {
@@ -416,98 +355,4 @@ public override ModelMetadata<T> GetModelMetadata()
         metadata.AdditionalInfo["WeightCount"] = _weights?.Length ?? 0;
         return metadata;
     }
-
-    /// <inheritdoc/>
-    public override byte[] Serialize()
-    {
-        var modelData = new Dictionary<string, object>
-        {
-            { "NumClasses", NumClasses },
-            { "NumFeatures", NumFeatures },
-            { "TaskType", (int)TaskType },
-            { "ClassLabels", ClassLabels?.ToArray() ?? Array.Empty<T>() },
-            { "RegularizationOptions", Regularization.GetOptions() },
-            { "Bias", NumOps.ToDouble(_bias) }
-        };
-
-        if (_weights is not null)
-        {
-            var weightsArray = new double[_weights.Length];
-            for (int i = 0; i < _weights.Length; i++)
-                weightsArray[i] = NumOps.ToDouble(_weights[i]);
-            modelData["Weights"] = weightsArray;
-        }
-
-        if (_intercept is not null)
-        {
-            var interceptArray = new double[_intercept.Length];
-            for (int i = 0; i < _intercept.Length; i++)
-                interceptArray[i] = NumOps.ToDouble(_intercept[i]);
-            modelData["Intercept"] = interceptArray;
-        }
-
-        var modelMetadata = GetModelMetadata();
-        modelMetadata.ModelData = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(modelData));
-        return Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(modelMetadata));
-    }
-
-    /// <inheritdoc/>
-    public override void Deserialize(byte[] modelData)
-    {
-        var jsonString = Encoding.UTF8.GetString(modelData);
-        var modelMetadata = JsonConvert.DeserializeObject<ModelMetadata<T>>(jsonString);
-
-        if (modelMetadata == null || modelMetadata.ModelData == null)
-            throw new InvalidOperationException("Deserialization failed: The model data is invalid or corrupted.");
-
-        var modelDataString = Encoding.UTF8.GetString(modelMetadata.ModelData);
-        var modelDataObj = JsonConvert.DeserializeObject<JObject>(modelDataString);
-
-        if (modelDataObj == null)
-            throw new InvalidOperationException("Deserialization failed: The model data is invalid or corrupted.");
-
-        NumClasses = modelDataObj["NumClasses"]?.ToObject<int>() ?? 0;
-        NumFeatures = modelDataObj["NumFeatures"]?.ToObject<int>() ?? 0;
-        TaskType = (ClassificationTaskType)(modelDataObj["TaskType"]?.ToObject<int>() ?? 0);
-
-        var classLabelsToken = modelDataObj["ClassLabels"];
-        if (classLabelsToken is not null)
-        {
-            var classLabelsAsDoubles = classLabelsToken.ToObject<double[]>() ?? Array.Empty<double>();
-            if (classLabelsAsDoubles.Length > 0)
-            {
-                ClassLabels = new Vector<T>(classLabelsAsDoubles.Length);
-                for (int i = 0; i < classLabelsAsDoubles.Length; i++)
-                    ClassLabels[i] = NumOps.FromDouble(classLabelsAsDoubles[i]);
-            }
-        }
-
-        var weightsToken = modelDataObj["Weights"];
-        if (weightsToken is not null)
-        {
-            var weightsAsDoubles = weightsToken.ToObject<double[]>() ?? Array.Empty<double>();
-            if (weightsAsDoubles.Length > 0)
-            {
-                _weights = new Vector<T>(weightsAsDoubles.Length);
-                for (int i = 0; i < weightsAsDoubles.Length; i++)
-                    _weights[i] = NumOps.FromDouble(weightsAsDoubles[i]);
-            }
-        }
-
-        var biasToken = modelDataObj["Bias"];
-        if (biasToken is not null)
-            _bias = NumOps.FromDouble(biasToken.ToObject<double>());
-
-        var interceptToken = modelDataObj["Intercept"];
-        if (interceptToken is not null)
-        {
-            var interceptAsDoubles = interceptToken.ToObject<double[]>() ?? Array.Empty<double>();
-            if (interceptAsDoubles.Length > 0)
-            {
-                _intercept = new Vector<T>(interceptAsDoubles.Length);
-                for (int i = 0; i < interceptAsDoubles.Length; i++)
-                    _intercept[i] = NumOps.FromDouble(interceptAsDoubles[i]);
-            }
-        }
-    }
 }
diff --git a/src/Classification/SVM/NuSupportVectorClassifier.cs b/src/Classification/SVM/NuSupportVectorClassifier.cs
index 8c30e854ff..4a6ebe6277 100644
--- a/src/Classification/SVM/NuSupportVectorClassifier.cs
+++ b/src/Classification/SVM/NuSupportVectorClassifier.cs
@@ -450,115 +450,6 @@ public override Matrix<T> PredictProbabilities(Matrix<T> input)
         return probabilities;
     }
 
-    /// <inheritdoc/>
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        return new NuSupportVectorClassifier<T>(new SVMOptions<T>
-        {
-            Kernel = Options.Kernel,
-            Gamma = Options.Gamma,
-            Degree = Options.Degree,
-            Coef0 = Options.Coef0,
-            Tolerance = Options.Tolerance,
-            MaxIterations = Options.MaxIterations,
-            Seed = Options.Seed
-        }, null, _nu);
-    }
-
-    /// <inheritdoc/>
-    public override IFullModel<T, Matrix<T>, Vector<T>> Clone()
-    {
-        var clone = new NuSupportVectorClassifier<T>(new SVMOptions<T>
-        {
-            Kernel = Options.Kernel,
-            Gamma = Options.Gamma,
-            Degree = Options.Degree,
-            Coef0 = Options.Coef0,
-            Tolerance = Options.Tolerance,
-            MaxIterations = Options.MaxIterations,
-            Seed = Options.Seed
-        }, null, _nu);
-
-        clone.NumFeatures = NumFeatures;
-        clone.NumClasses = NumClasses;
-        clone.TaskType = TaskType;
-        clone._rho = _rho;
-
-        if (ClassLabels is not null)
-        {
-            clone.ClassLabels = new Vector<T>(ClassLabels.Length);
-            for (int i = 0; i < ClassLabels.Length; i++)
-            {
-                clone.ClassLabels[i] = ClassLabels[i];
-            }
-        }
-
-        if (_xTrain is not null)
-        {
-            clone._xTrain = new Matrix<T>(_xTrain.Rows, _xTrain.Columns);
-            for (int i = 0; i < _xTrain.Rows; i++)
-            {
-                for (int j = 0; j < _xTrain.Columns; j++)
-                {
-                    clone._xTrain[i, j] = _xTrain[i, j];
-                }
-            }
-        }
-
-        if (_yTrain is not null)
-        {
-            clone._yTrain = new Vector<T>(_yTrain.Length);
-            for (int i = 0; i < _yTrain.Length; i++)
-            {
-                clone._yTrain[i] = _yTrain[i];
-            }
-        }
-
-        if (_alphas is not null)
-        {
-            clone._alphas = new Vector<T>(_alphas.Length);
-            for (int i = 0; i < _alphas.Length; i++)
-            {
-                clone._alphas[i] = _alphas[i];
-            }
-        }
-
-        if (_intercept is not null)
-        {
-            clone._intercept = new Vector<T>(_intercept.Length);
-            for (int i = 0; i < _intercept.Length; i++)
-            {
-                clone._intercept[i] = _intercept[i];
-            }
-        }
-
-        if (_supportVectors is not null)
-        {
-            clone._supportVectors = new Matrix<T>(_supportVectors.Rows, _supportVectors.Columns);
-            for (int i = 0; i < _supportVectors.Rows; i++)
-            {
-                for (int j = 0; j < _supportVectors.Columns; j++)
-                {
-                    clone._supportVectors[i, j] = _supportVectors[i, j];
-                }
-            }
-        }
-
-        if (_dualCoef is not null)
-        {
-            clone._dualCoef = new Matrix<T>(_dualCoef.Rows, _dualCoef.Columns);
-            for (int i = 0; i < _dualCoef.Rows; i++)
-            {
-                for (int j = 0; j < _dualCoef.Columns; j++)
-                {
-                    clone._dualCoef[i, j] = _dualCoef[i, j];
-                }
-            }
-        }
-
-        return clone;
-    }
-
     /// <inheritdoc/>
     public override ModelMetadata<T> GetModelMetadata()
     {
@@ -568,113 +459,6 @@ public override ModelMetadata<T> GetModelMetadata()
         return metadata;
     }
 
-    /// <inheritdoc/>
-    public override byte[] Serialize()
-    {
-        var modelData = new Dictionary<string, object>
-        {
-            { "NumClasses", NumClasses },
-            { "NumFeatures", NumFeatures },
-            { "TaskType", (int)TaskType },
-            { "ClassLabels", ClassLabels?.ToArray() ?? Array.Empty<T>() },
-            { "RegularizationOptions", Regularization.GetOptions() },
-            { "Nu", _nu },
-            { "Rho", NumOps.ToDouble(_rho) },
-            { "SVMOptions_C", Options.C },
-            { "SVMOptions_Kernel", (int)Options.Kernel },
-            { "SVMOptions_HasGamma", Options.Gamma.HasValue },
-            { "SVMOptions_Degree", Options.Degree },
-            { "SVMOptions_Coef0", Options.Coef0 },
-            { "SVMOptions_Tolerance", Options.Tolerance },
-            { "SVMOptions_MaxIterations", Options.MaxIterations },
-            { "SVMOptions_Shrinking", Options.Shrinking },
-            { "SVMOptions_Probability", Options.Probability },
-            { "SVMOptions_OneVsRest", Options.OneVsRest }
-        };
-
-        if (Options.Gamma.HasValue)
-            modelData["SVMOptions_GammaValue"] = Options.Gamma.Value;
-
-        SerializeMatrix(modelData, "XTrain", _xTrain);
-        SerializeVector(modelData, "YTrain", _yTrain);
-        SerializeVector(modelData, "Alphas", _alphas);
-        SerializeVector(modelData, "Intercept", _intercept);
-        SerializeMatrix(modelData, "SupportVectors", _supportVectors);
-        SerializeMatrix(modelData, "DualCoef", _dualCoef);
-
-        var modelMetadata = GetModelMetadata();
-        modelMetadata.ModelData = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(modelData));
-        return Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(modelMetadata));
-    }
-
-    /// <inheritdoc/>
-    public override void Deserialize(byte[] modelData)
-    {
-        var jsonString = Encoding.UTF8.GetString(modelData);
-        var modelMetadata = JsonConvert.DeserializeObject<ModelMetadata<T>>(jsonString);
-
-        if (modelMetadata == null || modelMetadata.ModelData == null)
-            throw new InvalidOperationException("Deserialization failed: The model data is invalid or corrupted.");
-
-        var modelDataString = Encoding.UTF8.GetString(modelMetadata.ModelData);
-        var modelDataObj = JsonConvert.DeserializeObject<JObject>(modelDataString);
-
-        if (modelDataObj == null)
-            throw new InvalidOperationException("Deserialization failed: The model data is invalid or corrupted.");
-
-        NumClasses = modelDataObj["NumClasses"]?.ToObject<int>() ?? 0;
-        NumFeatures = modelDataObj["NumFeatures"]?.ToObject<int>() ?? 0;
-        TaskType = (ClassificationTaskType)(modelDataObj["TaskType"]?.ToObject<int>() ?? 0);
-        _rho = NumOps.FromDouble(modelDataObj["Rho"]?.ToObject<double>() ?? 0.0);
-
-        // Restore Nu
-        if (modelDataObj["Nu"] is not null)
-            _nu = modelDataObj["Nu"]?.ToObject<double>() ?? 0.5;
-
-        // Restore SVMOptions (kernel, C, gamma, etc.) - critical for correct predictions
-        if (modelDataObj["SVMOptions_C"] is not null)
-            Options.C = modelDataObj["SVMOptions_C"]?.ToObject<double>() ?? 1.0;
-        if (modelDataObj["SVMOptions_Kernel"] is not null)
-            Options.Kernel = (Enums.KernelType)(modelDataObj["SVMOptions_Kernel"]?.ToObject<int>() ?? 0);
-        if (modelDataObj["SVMOptions_HasGamma"]?.ToObject<bool>() == true)
-            Options.Gamma = modelDataObj["SVMOptions_GammaValue"]?.ToObject<double>();
-        else
-            Options.Gamma = null;
-        if (modelDataObj["SVMOptions_Degree"] is not null)
-            Options.Degree = modelDataObj["SVMOptions_Degree"]?.ToObject<int>() ?? 3;
-        if (modelDataObj["SVMOptions_Coef0"] is not null)
-            Options.Coef0 = modelDataObj["SVMOptions_Coef0"]?.ToObject<double>() ?? 0.0;
-        if (modelDataObj["SVMOptions_Tolerance"] is not null)
-            Options.Tolerance = modelDataObj["SVMOptions_Tolerance"]?.ToObject<double>() ?? 0.001;
-        if (modelDataObj["SVMOptions_MaxIterations"] is not null)
-            Options.MaxIterations = modelDataObj["SVMOptions_MaxIterations"]?.ToObject<int>() ?? 1000;
-        if (modelDataObj["SVMOptions_Shrinking"] is not null)
-            Options.Shrinking = modelDataObj["SVMOptions_Shrinking"]?.ToObject<bool>() ?? true;
-        if (modelDataObj["SVMOptions_Probability"] is not null)
-            Options.Probability = modelDataObj["SVMOptions_Probability"]?.ToObject<bool>() ?? false;
-        if (modelDataObj["SVMOptions_OneVsRest"] is not null)
-            Options.OneVsRest = modelDataObj["SVMOptions_OneVsRest"]?.ToObject<bool>() ?? false;
-
-        var classLabelsToken = modelDataObj["ClassLabels"];
-        if (classLabelsToken is not null)
-        {
-            var classLabelsAsDoubles = classLabelsToken.ToObject<double[]>() ?? Array.Empty<double>();
-            if (classLabelsAsDoubles.Length > 0)
-            {
-                ClassLabels = new Vector<T>(classLabelsAsDoubles.Length);
-                for (int i = 0; i < classLabelsAsDoubles.Length; i++)
-                    ClassLabels[i] = NumOps.FromDouble(classLabelsAsDoubles[i]);
-            }
-        }
-
-        _xTrain = DeserializeMatrix(modelDataObj, "XTrain");
-        _yTrain = DeserializeVector(modelDataObj, "YTrain");
-        _alphas = DeserializeVector(modelDataObj, "Alphas");
-        _intercept = DeserializeVector(modelDataObj, "Intercept");
-        _supportVectors = DeserializeMatrix(modelDataObj, "SupportVectors");
-        _dualCoef = DeserializeMatrix(modelDataObj, "DualCoef");
-    }
-
     private void SerializeMatrix(Dictionary<string, object> data, string name, Matrix<T>? matrix)
     {
         if (matrix is null) return;
diff --git a/src/Classification/SVM/SupportVectorClassifier.cs b/src/Classification/SVM/SupportVectorClassifier.cs
index f5ef1e254c..38c7eff36b 100644
--- a/src/Classification/SVM/SupportVectorClassifier.cs
+++ b/src/Classification/SVM/SupportVectorClassifier.cs
@@ -513,210 +513,6 @@ private T Sigmoid(T x)
         return NumOps.Divide(NumOps.One, NumOps.Add(NumOps.One, expNegX));
     }
 
-    /// <inheritdoc/>
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        return new SupportVectorClassifier<T>(new SVMOptions<T>
-        {
-            C = Options.C,
-            Kernel = Options.Kernel,
-            Gamma = Options.Gamma,
-            Degree = Options.Degree,
-            Coef0 = Options.Coef0,
-            Tolerance = Options.Tolerance,
-            MaxIterations = Options.MaxIterations,
-            Shrinking = Options.Shrinking,
-            Probability = Options.Probability,
-            Seed = Options.Seed,
-            OneVsRest = Options.OneVsRest,
-            CacheSize = Options.CacheSize
-        });
-    }
-
-    /// <inheritdoc/>
-    public override IFullModel<T, Matrix<T>, Vector<T>> Clone()
-    {
-        var clone = (SupportVectorClassifier<T>)CreateNewInstance();
-
-        clone.NumFeatures = NumFeatures;
-        clone.NumClasses = NumClasses;
-        clone.TaskType = TaskType;
-
-        if (ClassLabels != null)
-        {
-            clone.ClassLabels = new Vector<T>(ClassLabels.Length);
-            for (int i = 0; i < ClassLabels.Length; i++)
-            {
-                clone.ClassLabels[i] = ClassLabels[i];
-            }
-        }
-
-        if (_xTrain != null)
-        {
-            clone._xTrain = new Matrix<T>(_xTrain.Rows, _xTrain.Columns);
-            for (int i = 0; i < _xTrain.Rows; i++)
-            {
-                for (int j = 0; j < _xTrain.Columns; j++)
-                {
-                    clone._xTrain[i, j] = _xTrain[i, j];
-                }
-            }
-        }
-
-        if (_yTrain != null)
-        {
-            clone._yTrain = new Vector<T>(_yTrain.Length);
-            for (int i = 0; i < _yTrain.Length; i++)
-            {
-                clone._yTrain[i] = _yTrain[i];
-            }
-        }
-
-        if (_alphas != null)
-        {
-            clone._alphas = new Vector<T>(_alphas.Length);
-            for (int i = 0; i < _alphas.Length; i++)
-            {
-                clone._alphas[i] = _alphas[i];
-            }
-        }
-
-        if (_intercept != null)
-        {
-            clone._intercept = new Vector<T>(_intercept.Length);
-            for (int i = 0; i < _intercept.Length; i++)
-            {
-                clone._intercept[i] = _intercept[i];
-            }
-        }
-
-        if (_supportVectors != null)
-        {
-            clone._supportVectors = new Matrix<T>(_supportVectors.Rows, _supportVectors.Columns);
-            for (int i = 0; i < _supportVectors.Rows; i++)
-            {
-                for (int j = 0; j < _supportVectors.Columns; j++)
-                {
-                    clone._supportVectors[i, j] = _supportVectors[i, j];
-                }
-            }
-        }
-
-        if (_dualCoef != null)
-        {
-            clone._dualCoef = new Matrix<T>(_dualCoef.Rows, _dualCoef.Columns);
-            for (int i = 0; i < _dualCoef.Rows; i++)
-            {
-                for (int j = 0; j < _dualCoef.Columns; j++)
-                {
-                    clone._dualCoef[i, j] = _dualCoef[i, j];
-                }
-            }
-        }
-
-        return clone;
-    }
-
-    /// <inheritdoc/>
-    public override byte[] Serialize()
-    {
-        var modelData = new Dictionary<string, object>
-        {
-            { "NumClasses", NumClasses },
-            { "NumFeatures", NumFeatures },
-            { "TaskType", (int)TaskType },
-            { "ClassLabels", ClassLabels?.ToArray() ?? Array.Empty<T>() },
-            { "RegularizationOptions", Regularization.GetOptions() },
-            { "SVMOptions_C", Options.C },
-            { "SVMOptions_Kernel", (int)Options.Kernel },
-            { "SVMOptions_HasGamma", Options.Gamma.HasValue },
-            { "SVMOptions_Degree", Options.Degree },
-            { "SVMOptions_Coef0", Options.Coef0 },
-            { "SVMOptions_Tolerance", Options.Tolerance },
-            { "SVMOptions_MaxIterations", Options.MaxIterations },
-            { "SVMOptions_Shrinking", Options.Shrinking },
-            { "SVMOptions_Probability", Options.Probability },
-            { "SVMOptions_OneVsRest", Options.OneVsRest }
-        };
-
-        if (Options.Gamma.HasValue)
-            modelData["SVMOptions_GammaValue"] = Options.Gamma.Value;
-
-        SerializeMatrix(modelData, "XTrain", _xTrain);
-        SerializeVector(modelData, "YTrain", _yTrain);
-        SerializeVector(modelData, "Alphas", _alphas);
-        SerializeVector(modelData, "Intercept", _intercept);
-        SerializeMatrix(modelData, "SupportVectors", _supportVectors);
-        SerializeMatrix(modelData, "DualCoef", _dualCoef);
-
-        var modelMetadata = GetModelMetadata();
-        modelMetadata.ModelData = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(modelData));
-        return Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(modelMetadata));
-    }
-
-    /// <inheritdoc/>
-    public override void Deserialize(byte[] modelData)
-    {
-        var jsonString = Encoding.UTF8.GetString(modelData);
-        var modelMetadata = JsonConvert.DeserializeObject<ModelMetadata<T>>(jsonString);
-
-        if (modelMetadata == null || modelMetadata.ModelData == null)
-            throw new InvalidOperationException("Deserialization failed: The model data is invalid or corrupted.");
-
-        var modelDataString = Encoding.UTF8.GetString(modelMetadata.ModelData);
-        var modelDataObj = JsonConvert.DeserializeObject<JObject>(modelDataString);
-
-        if (modelDataObj == null)
-            throw new InvalidOperationException("Deserialization failed: The model data is invalid or corrupted.");
-
-        NumClasses = modelDataObj["NumClasses"]?.ToObject<int>() ?? 0;
-        NumFeatures = modelDataObj["NumFeatures"]?.ToObject<int>() ?? 0;
-        TaskType = (ClassificationTaskType)(modelDataObj["TaskType"]?.ToObject<int>() ?? 0);
-
-        var classLabelsToken = modelDataObj["ClassLabels"];
-        if (classLabelsToken is not null)
-        {
-            var classLabelsAsDoubles = classLabelsToken.ToObject<double[]>() ?? Array.Empty<double>();
-            if (classLabelsAsDoubles.Length > 0)
-            {
-                ClassLabels = new Vector<T>(classLabelsAsDoubles.Length);
-                for (int i = 0; i < classLabelsAsDoubles.Length; i++)
-                    ClassLabels[i] = NumOps.FromDouble(classLabelsAsDoubles[i]);
-            }
-        }
-
-        // Restore SVMOptions (kernel, C, gamma, etc.) - critical for correct predictions
-        if (modelDataObj["SVMOptions_C"] is not null)
-            Options.C = modelDataObj["SVMOptions_C"]?.ToObject<double>() ?? 1.0;
-        if (modelDataObj["SVMOptions_Kernel"] is not null)
-            Options.Kernel = (Enums.KernelType)(modelDataObj["SVMOptions_Kernel"]?.ToObject<int>() ?? 0);
-        if (modelDataObj["SVMOptions_HasGamma"]?.ToObject<bool>() == true)
-            Options.Gamma = modelDataObj["SVMOptions_GammaValue"]?.ToObject<double>();
-        else
-            Options.Gamma = null;
-        if (modelDataObj["SVMOptions_Degree"] is not null)
-            Options.Degree = modelDataObj["SVMOptions_Degree"]?.ToObject<int>() ?? 3;
-        if (modelDataObj["SVMOptions_Coef0"] is not null)
-            Options.Coef0 = modelDataObj["SVMOptions_Coef0"]?.ToObject<double>() ?? 0.0;
-        if (modelDataObj["SVMOptions_Tolerance"] is not null)
-            Options.Tolerance = modelDataObj["SVMOptions_Tolerance"]?.ToObject<double>() ?? 0.001;
-        if (modelDataObj["SVMOptions_MaxIterations"] is not null)
-            Options.MaxIterations = modelDataObj["SVMOptions_MaxIterations"]?.ToObject<int>() ?? 1000;
-        if (modelDataObj["SVMOptions_Shrinking"] is not null)
-            Options.Shrinking = modelDataObj["SVMOptions_Shrinking"]?.ToObject<bool>() ?? true;
-        if (modelDataObj["SVMOptions_Probability"] is not null)
-            Options.Probability = modelDataObj["SVMOptions_Probability"]?.ToObject<bool>() ?? false;
-        if (modelDataObj["SVMOptions_OneVsRest"] is not null)
-            Options.OneVsRest = modelDataObj["SVMOptions_OneVsRest"]?.ToObject<bool>() ?? false;
-
-        _xTrain = DeserializeMatrix(modelDataObj, "XTrain");
-        _yTrain = DeserializeVector(modelDataObj, "YTrain");
-        _alphas = DeserializeVector(modelDataObj, "Alphas");
-        _intercept = DeserializeVector(modelDataObj, "Intercept");
-        _supportVectors = DeserializeMatrix(modelDataObj, "SupportVectors");
-        _dualCoef = DeserializeMatrix(modelDataObj, "DualCoef");
-    }
-
     private void SerializeMatrix(Dictionary<string, object> data, string name, Matrix<T>? matrix)
     {
         if (matrix is null) return;
diff --git a/src/Classification/SemiSupervised/LabelPropagation.cs b/src/Classification/SemiSupervised/LabelPropagation.cs
index 06430eed67..b04bead35e 100644
--- a/src/Classification/SemiSupervised/LabelPropagation.cs
+++ b/src/Classification/SemiSupervised/LabelPropagation.cs
@@ -66,7 +66,7 @@ namespace AiDotNet.Classification.SemiSupervised;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
 [ResearchPaper("Learning from Labeled and Unlabeled Data with Label Propagation", "https://citeseerx.ist.psu.edu/document?repid=rep1&type=pdf&doi=8a6a114d699824b678325766be195b0e7b564f87", Year = 2002, Authors = "Xiaojin Zhu, Zoubin Ghahramani")]
-public class LabelPropagation<T> : SemiSupervisedClassifierBase<T>
+public partial class LabelPropagation<T> : SemiSupervisedClassifierBase<T>
 {
 
     /// <inheritdoc />
@@ -109,16 +109,19 @@ protected override void RegisterComponents()
     /// <summary>
     /// The affinity matrix representing pairwise similarities between all samples.
     /// </summary>
+    [AiDotNet.Attributes.FittedParameter]
     private Matrix<T> _affinityMatrix = new Matrix<T>(0, 0);
 
     /// <summary>
     /// The combined feature matrix (labeled + unlabeled) after training.
     /// </summary>
+    [AiDotNet.Attributes.FittedParameter]
     private Matrix<T> _allFeatures = new Matrix<T>(0, 0);
 
     /// <summary>
     /// The label distribution matrix where each row is a sample and each column is a class.
     /// </summary>
+    [AiDotNet.Attributes.FittedParameter]
     private Matrix<T> _labelDistributions = new Matrix<T>(0, 0);
 
     /// <summary>
@@ -131,6 +134,14 @@ protected override void RegisterComponents()
     /// </summary>
     private readonly Random _random;
 
+    /// <summary>The seed this model was built with, kept so a clone can be built the same way.</summary>
+    /// <remarks>
+    /// The Random built from it cannot be read back, so without this the seed is gone the
+    /// moment the constructor returns and the model cannot be rebuilt from its own state.
+    /// </remarks>
+    private readonly int? _seed;
+
+
     #endregion
 
     #region Constructors
@@ -181,6 +192,7 @@ public LabelPropagation(
         // Accept provided tolerance as-is - zero is valid (means run until maxIterations)
         _tolerance = tolerance;
 
+        _seed = seed;
         _random = seed.HasValue
             ? RandomHelper.CreateSeededRandom(seed.Value)
             : RandomHelper.CreateSecureRandom();
@@ -837,220 +849,10 @@ private static Dictionary<string, double> ExtractKernelParams(IKernelFunction<T>
 
     #region Serialization
 
-    /// <inheritdoc />
-    public override byte[] Serialize()
-    {
-        var modelMetadata = GetModelMetadata();
-        var modelData = new Dictionary<string, object?>
-        {
-            ["NumClasses"] = NumClasses,
-            ["NumFeatures"] = NumFeatures,
-            ["TaskType"] = (int)TaskType,
-            ["NumLabeled"] = _numLabeled,
-            ["KernelType"] = _kernel.GetType().Name,
-            ["KernelParams"] = ExtractKernelParams(_kernel),
-            ["MaxIterations"] = _maxIterations,
-            ["Tolerance"] = NumOps.ToDouble(_tolerance)
-        };
-
-        if (ClassLabels is not null)
-        {
-            var labels = new double[ClassLabels.Length];
-            for (int i = 0; i < ClassLabels.Length; i++)
-                labels[i] = NumOps.ToDouble(ClassLabels[i]);
-            modelData["ClassLabels"] = labels;
-        }
-
-        if (_allFeatures is not null)
-        {
-            modelData["AllFeatures_Rows"] = _allFeatures.Rows;
-            modelData["AllFeatures_Cols"] = _allFeatures.Columns;
-            var data = new double[_allFeatures.Rows * _allFeatures.Columns];
-            for (int i = 0; i < _allFeatures.Rows; i++)
-                for (int j = 0; j < _allFeatures.Columns; j++)
-                    data[i * _allFeatures.Columns + j] = NumOps.ToDouble(_allFeatures[i, j]);
-            modelData["AllFeatures"] = data;
-        }
-
-        if (_labelDistributions is not null)
-        {
-            modelData["LabelDist_Rows"] = _labelDistributions.Rows;
-            modelData["LabelDist_Cols"] = _labelDistributions.Columns;
-            var data = new double[_labelDistributions.Rows * _labelDistributions.Columns];
-            for (int i = 0; i < _labelDistributions.Rows; i++)
-                for (int j = 0; j < _labelDistributions.Columns; j++)
-                    data[i * _labelDistributions.Columns + j] = NumOps.ToDouble(_labelDistributions[i, j]);
-            modelData["LabelDistributions"] = data;
-        }
-
-        modelMetadata.ModelData = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(modelData));
-        return Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(modelMetadata));
-    }
-
-    /// <inheritdoc />
-    public override void Deserialize(byte[] modelData)
-    {
-        var jsonString = Encoding.UTF8.GetString(modelData);
-        var modelMetadata = JsonConvert.DeserializeObject<ModelMetadata<T>>(jsonString)
-            ?? throw new InvalidOperationException("Failed to deserialize LabelPropagation: invalid metadata.");
-        if (modelMetadata.ModelData is null)
-            throw new InvalidOperationException("Failed to deserialize LabelPropagation: missing model data.");
-
-        var dataString = Encoding.UTF8.GetString(modelMetadata.ModelData);
-        var jObj = JsonConvert.DeserializeObject<JObject>(dataString)
-            ?? throw new InvalidOperationException("Failed to deserialize LabelPropagation: invalid model payload.");
-
-        NumClasses = jObj["NumClasses"]?.ToObject<int>()
-            ?? throw new InvalidOperationException("Failed to deserialize LabelPropagation: missing NumClasses.");
-        NumFeatures = jObj["NumFeatures"]?.ToObject<int>()
-            ?? throw new InvalidOperationException("Failed to deserialize LabelPropagation: missing NumFeatures.");
-        TaskType = (ClassificationTaskType)(jObj["TaskType"]?.ToObject<int>()
-            ?? throw new InvalidOperationException("Failed to deserialize LabelPropagation: missing TaskType."));
-        _numLabeled = jObj["NumLabeled"]?.ToObject<int>()
-            ?? throw new InvalidOperationException("Failed to deserialize LabelPropagation: missing NumLabeled.");
-        _maxIterations = jObj["MaxIterations"]?.ToObject<int>()
-            ?? throw new InvalidOperationException("Failed to deserialize LabelPropagation: missing MaxIterations.");
-
-        var kernelType = jObj["KernelType"]?.ToObject<string>();
-        var kernelParams = jObj["KernelParams"]?.ToObject<Dictionary<string, double>>();
-        if (kernelType is not null)
-        {
-            _kernel = CreateKernelByName(kernelType, kernelParams) ?? CreateDefaultKernel();
-        }
-
-        _tolerance = NumOps.FromDouble(jObj["Tolerance"]?.ToObject<double>()
-            ?? throw new InvalidOperationException("Failed to deserialize LabelPropagation: missing Tolerance."));
-
-        var labelsToken = jObj["ClassLabels"];
-        if (labelsToken is JArray labelsArr)
-        {
-            if (labelsArr.Count != NumClasses)
-                throw new InvalidOperationException(
-                    $"Failed to deserialize LabelPropagation: ClassLabels length ({labelsArr.Count}) does not match NumClasses ({NumClasses}).");
-
-            ClassLabels = new Vector<T>(labelsArr.Count);
-            for (int i = 0; i < labelsArr.Count; i++)
-                ClassLabels[i] = NumOps.FromDouble(labelsArr[i].Value<double>());
-        }
-
-        int afRows = jObj["AllFeatures_Rows"]?.ToObject<int>() ?? 0;
-        int afCols = jObj["AllFeatures_Cols"]?.ToObject<int>() ?? 0;
-        var afToken = jObj["AllFeatures"];
-        if (afToken is JArray afArr && afRows > 0 && afCols > 0)
-        {
-            if (afArr.Count != afRows * afCols)
-                throw new InvalidOperationException(
-                    $"Failed to deserialize LabelPropagation: AllFeatures array length ({afArr.Count}) does not match {afRows}x{afCols}.");
-
-            _allFeatures = new Matrix<T>(afRows, afCols);
-            for (int i = 0; i < afRows; i++)
-                for (int j = 0; j < afCols; j++)
-                    _allFeatures[i, j] = NumOps.FromDouble(afArr[i * afCols + j].Value<double>());
-
-            // Rebuild affinity matrix from restored features
-            _affinityMatrix = BuildAffinityMatrix(_allFeatures);
-        }
-
-        int ldRows = jObj["LabelDist_Rows"]?.ToObject<int>() ?? 0;
-        int ldCols = jObj["LabelDist_Cols"]?.ToObject<int>() ?? 0;
-        var ldToken = jObj["LabelDistributions"];
-        if (ldToken is JArray ldArr && ldRows > 0 && ldCols > 0)
-        {
-            if (ldArr.Count != ldRows * ldCols)
-                throw new InvalidOperationException(
-                    $"Failed to deserialize LabelPropagation: LabelDistributions array length ({ldArr.Count}) does not match {ldRows}x{ldCols}.");
-
-            _labelDistributions = new Matrix<T>(ldRows, ldCols);
-            for (int i = 0; i < ldRows; i++)
-                for (int j = 0; j < ldCols; j++)
-                    _labelDistributions[i, j] = NumOps.FromDouble(ldArr[i * ldCols + j].Value<double>());
-        }
-
-        // Cross-field consistency checks
-        if (_allFeatures is not null && afCols != NumFeatures)
-            throw new InvalidOperationException(
-                $"Failed to deserialize LabelPropagation: AllFeatures columns ({afCols}) does not match NumFeatures ({NumFeatures}).");
-        if (_labelDistributions is not null && ldCols != NumClasses)
-            throw new InvalidOperationException(
-                $"Failed to deserialize LabelPropagation: LabelDistributions columns ({ldCols}) does not match NumClasses ({NumClasses}).");
-        if (_allFeatures is not null && _labelDistributions is not null && _allFeatures.Rows != _labelDistributions.Rows)
-            throw new InvalidOperationException(
-                $"Failed to deserialize LabelPropagation: AllFeatures rows ({_allFeatures.Rows}) does not match LabelDistributions rows ({_labelDistributions.Rows}).");
-        if (_allFeatures is not null && _numLabeled > _allFeatures.Rows)
-            throw new InvalidOperationException(
-                $"Failed to deserialize LabelPropagation: NumLabeled ({_numLabeled}) exceeds AllFeatures rows ({_allFeatures.Rows}).");
-    }
-
     #endregion
 
     #region ICloneable Implementation
 
-    /// <summary>
-    /// Creates a deep copy of this classifier.
-    /// </summary>
-    /// <returns>A new instance with the same parameters and state.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Cloning creates an independent copy of the classifier.
-    /// Changes to the clone won't affect the original, and vice versa. This is useful
-    /// for ensemble methods or when you need to experiment without affecting your trained model.
-    /// </para>
-    /// </remarks>
-    public override IFullModel<T, Matrix<T>, Vector<T>> Clone()
-    {
-        var clone = new LabelPropagation<T>(
-            _kernel,
-            _maxIterations,
-            _tolerance,
-            _random.Next());
-
-        // Copy state if trained
-        if (_allFeatures is not null)
-        {
-            clone._allFeatures = new Matrix<T>(_allFeatures.Rows, _allFeatures.Columns);
-            for (int i = 0; i < _allFeatures.Rows; i++)
-            {
-                for (int j = 0; j < _allFeatures.Columns; j++)
-                {
-                    clone._allFeatures[i, j] = _allFeatures[i, j];
-                }
-            }
-        }
-
-        if (_labelDistributions is not null)
-        {
-            clone._labelDistributions = new Matrix<T>(_labelDistributions.Rows, _labelDistributions.Columns);
-            for (int i = 0; i < _labelDistributions.Rows; i++)
-            {
-                for (int j = 0; j < _labelDistributions.Columns; j++)
-                {
-                    clone._labelDistributions[i, j] = _labelDistributions[i, j];
-                }
-            }
-        }
-
-        // Copy affinity matrix for consistent state
-        if (_affinityMatrix is not null)
-        {
-            clone._affinityMatrix = new Matrix<T>(_affinityMatrix.Rows, _affinityMatrix.Columns);
-            for (int i = 0; i < _affinityMatrix.Rows; i++)
-            {
-                for (int j = 0; j < _affinityMatrix.Columns; j++)
-                {
-                    clone._affinityMatrix[i, j] = _affinityMatrix[i, j];
-                }
-            }
-        }
-
-        clone._numLabeled = _numLabeled;
-        clone.NumFeatures = NumFeatures;
-        clone.NumClasses = NumClasses;
-        clone.ClassLabels = ClassLabels?.Clone();
-        clone.TaskType = TaskType;
-
-        return clone;
-    }
-
     #endregion
 
     #region Abstract Method Implementations
@@ -1103,20 +905,5 @@ private void UnpackParameters(Vector<T> parameters)
         // Non-parametric model - no parameters to set
     }
 
-    /// <summary>
-    /// Creates a new instance of this classifier with default configuration.
-    /// </summary>
-    /// <returns>A new LabelPropagation instance.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> This is used internally for operations like cloning or serialization
-    /// that need to create a fresh instance of the same type.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        return new LabelPropagation<T>(_kernel, _maxIterations, _tolerance, _random.Next());
-    }
-
     #endregion
 }
diff --git a/src/Classification/SemiSupervised/LabelSpreading.cs b/src/Classification/SemiSupervised/LabelSpreading.cs
index 10e20637ce..505de526b1 100644
--- a/src/Classification/SemiSupervised/LabelSpreading.cs
+++ b/src/Classification/SemiSupervised/LabelSpreading.cs
@@ -69,7 +69,7 @@ namespace AiDotNet.Classification.SemiSupervised;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
 [ResearchPaper("Learning with Local and Global Consistency", "https://proceedings.neurips.cc/paper/2003/hash/87682805257e619d49b8e0dfdc14affa-Abstract.html", Year = 2003, Authors = "Dengyong Zhou, Olivier Bousquet, Thomas N. Lal, Jason Weston, Bernhard Scholkopf")]
-public class LabelSpreading<T> : SemiSupervisedClassifierBase<T>
+public partial class LabelSpreading<T> : SemiSupervisedClassifierBase<T>
 {
 
     /// <inheritdoc />
@@ -128,21 +128,25 @@ protected override void RegisterComponents()
     /// <summary>
     /// The symmetrically normalized affinity matrix (Laplacian-style normalization).
     /// </summary>
+    [AiDotNet.Attributes.FittedParameter]
     private Matrix<T> _normalizedAffinity = new Matrix<T>(0, 0);
 
     /// <summary>
     /// The combined feature matrix (labeled + unlabeled) after training.
     /// </summary>
+    [AiDotNet.Attributes.FittedParameter]
     private Matrix<T> _allFeatures = new Matrix<T>(0, 0);
 
     /// <summary>
     /// The label distribution matrix where each row is a sample and each column is a class.
     /// </summary>
+    [AiDotNet.Attributes.FittedParameter]
     private Matrix<T> _labelDistributions = new Matrix<T>(0, 0);
 
     /// <summary>
     /// The initial label distributions (before propagation).
     /// </summary>
+    [AiDotNet.Attributes.FittedParameter]
     private Matrix<T> _initialDistributions = new Matrix<T>(0, 0);
 
     /// <summary>
@@ -155,6 +159,14 @@ protected override void RegisterComponents()
     /// </summary>
     private readonly Random _random;
 
+    /// <summary>The seed this model was built with, kept so a clone can be built the same way.</summary>
+    /// <remarks>
+    /// The Random built from it cannot be read back, so without this the seed is gone the
+    /// moment the constructor returns and the model cannot be rebuilt from its own state.
+    /// </remarks>
+    private readonly int? _seed;
+
+
     #endregion
 
     #region Constructors
@@ -213,6 +225,7 @@ public LabelSpreading(
         // Accept provided alpha as-is - zero is valid (means keep original labels, no spreading)
         _alpha = alpha;
 
+        _seed = seed;
         _random = seed.HasValue
             ? RandomHelper.CreateSeededRandom(seed.Value)
             : RandomHelper.CreateSecureRandom();
@@ -904,206 +917,10 @@ private static Dictionary<string, double> ExtractKernelParams(IKernelFunction<T>
 
     #region Serialization
 
-    /// <inheritdoc />
-    public override byte[] Serialize()
-    {
-        var modelMetadata = GetModelMetadata();
-        var modelData = new Dictionary<string, object?>
-        {
-            ["NumClasses"] = NumClasses,
-            ["NumFeatures"] = NumFeatures,
-            ["TaskType"] = (int)TaskType,
-            ["NumLabeled"] = _numLabeled,
-            ["KernelType"] = _kernel.GetType().Name,
-            ["KernelParams"] = ExtractKernelParams(_kernel),
-            ["MaxIterations"] = _maxIterations,
-            ["Tolerance"] = NumOps.ToDouble(_tolerance),
-            ["Alpha"] = NumOps.ToDouble(_alpha)
-        };
-
-        if (ClassLabels is not null)
-        {
-            var labels = new double[ClassLabels.Length];
-            for (int i = 0; i < ClassLabels.Length; i++)
-                labels[i] = NumOps.ToDouble(ClassLabels[i]);
-            modelData["ClassLabels"] = labels;
-        }
-
-        if (_allFeatures is not null)
-        {
-            modelData["AllFeatures_Rows"] = _allFeatures.Rows;
-            modelData["AllFeatures_Cols"] = _allFeatures.Columns;
-            var data = new double[_allFeatures.Rows * _allFeatures.Columns];
-            for (int i = 0; i < _allFeatures.Rows; i++)
-                for (int j = 0; j < _allFeatures.Columns; j++)
-                    data[i * _allFeatures.Columns + j] = NumOps.ToDouble(_allFeatures[i, j]);
-            modelData["AllFeatures"] = data;
-        }
-
-        if (_labelDistributions is not null)
-        {
-            modelData["LabelDist_Rows"] = _labelDistributions.Rows;
-            modelData["LabelDist_Cols"] = _labelDistributions.Columns;
-            var data = new double[_labelDistributions.Rows * _labelDistributions.Columns];
-            for (int i = 0; i < _labelDistributions.Rows; i++)
-                for (int j = 0; j < _labelDistributions.Columns; j++)
-                    data[i * _labelDistributions.Columns + j] = NumOps.ToDouble(_labelDistributions[i, j]);
-            modelData["LabelDistributions"] = data;
-        }
-
-        modelMetadata.ModelData = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(modelData));
-        return Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(modelMetadata));
-    }
-
-    /// <inheritdoc />
-    public override void Deserialize(byte[] modelData)
-    {
-        var jsonString = Encoding.UTF8.GetString(modelData);
-        var modelMetadata = JsonConvert.DeserializeObject<ModelMetadata<T>>(jsonString)
-            ?? throw new InvalidOperationException("Failed to deserialize LabelSpreading: invalid metadata.");
-        if (modelMetadata.ModelData is null)
-            throw new InvalidOperationException("Failed to deserialize LabelSpreading: missing model data.");
-
-        var dataString = Encoding.UTF8.GetString(modelMetadata.ModelData);
-        var jObj = JsonConvert.DeserializeObject<JObject>(dataString)
-            ?? throw new InvalidOperationException("Failed to deserialize LabelSpreading: invalid model payload.");
-
-        NumClasses = jObj["NumClasses"]?.ToObject<int>()
-            ?? throw new InvalidOperationException("Failed to deserialize LabelSpreading: missing NumClasses.");
-        NumFeatures = jObj["NumFeatures"]?.ToObject<int>()
-            ?? throw new InvalidOperationException("Failed to deserialize LabelSpreading: missing NumFeatures.");
-        TaskType = (ClassificationTaskType)(jObj["TaskType"]?.ToObject<int>()
-            ?? throw new InvalidOperationException("Failed to deserialize LabelSpreading: missing TaskType."));
-        _numLabeled = jObj["NumLabeled"]?.ToObject<int>()
-            ?? throw new InvalidOperationException("Failed to deserialize LabelSpreading: missing NumLabeled.");
-        _maxIterations = jObj["MaxIterations"]?.ToObject<int>()
-            ?? throw new InvalidOperationException("Failed to deserialize LabelSpreading: missing MaxIterations.");
-
-        var kernelType = jObj["KernelType"]?.ToObject<string>();
-        var kernelParams = jObj["KernelParams"]?.ToObject<Dictionary<string, double>>();
-        if (kernelType is not null)
-        {
-            _kernel = CreateKernelByName(kernelType, kernelParams) ?? CreateDefaultKernel();
-        }
-
-        _tolerance = NumOps.FromDouble(jObj["Tolerance"]?.ToObject<double>()
-            ?? throw new InvalidOperationException("Failed to deserialize LabelSpreading: missing Tolerance."));
-        _alpha = NumOps.FromDouble(jObj["Alpha"]?.ToObject<double>()
-            ?? throw new InvalidOperationException("Failed to deserialize LabelSpreading: missing Alpha."));
-
-        var labelsToken = jObj["ClassLabels"];
-        if (labelsToken is JArray labelsArr)
-        {
-            if (labelsArr.Count != NumClasses)
-                throw new InvalidOperationException(
-                    $"Failed to deserialize LabelSpreading: ClassLabels length ({labelsArr.Count}) does not match NumClasses ({NumClasses}).");
-
-            ClassLabels = new Vector<T>(labelsArr.Count);
-            for (int i = 0; i < labelsArr.Count; i++)
-                ClassLabels[i] = NumOps.FromDouble(labelsArr[i].Value<double>());
-        }
-
-        int afRows = jObj["AllFeatures_Rows"]?.ToObject<int>() ?? 0;
-        int afCols = jObj["AllFeatures_Cols"]?.ToObject<int>() ?? 0;
-        var afToken = jObj["AllFeatures"];
-        if (afToken is JArray afArr && afRows > 0 && afCols > 0)
-        {
-            if (afArr.Count != afRows * afCols)
-                throw new InvalidOperationException(
-                    $"Failed to deserialize LabelSpreading: AllFeatures array length ({afArr.Count}) does not match {afRows}x{afCols}.");
-
-            _allFeatures = new Matrix<T>(afRows, afCols);
-            for (int i = 0; i < afRows; i++)
-                for (int j = 0; j < afCols; j++)
-                    _allFeatures[i, j] = NumOps.FromDouble(afArr[i * afCols + j].Value<double>());
-
-            // Rebuild normalized affinity from restored features
-            var affinity = BuildAffinityMatrix(_allFeatures);
-            _normalizedAffinity = SymmetricNormalize(affinity);
-        }
-
-        int ldRows = jObj["LabelDist_Rows"]?.ToObject<int>() ?? 0;
-        int ldCols = jObj["LabelDist_Cols"]?.ToObject<int>() ?? 0;
-        var ldToken = jObj["LabelDistributions"];
-        if (ldToken is JArray ldArr && ldRows > 0 && ldCols > 0)
-        {
-            if (ldArr.Count != ldRows * ldCols)
-                throw new InvalidOperationException(
-                    $"Failed to deserialize LabelSpreading: LabelDistributions array length ({ldArr.Count}) does not match {ldRows}x{ldCols}.");
-
-            _labelDistributions = new Matrix<T>(ldRows, ldCols);
-            for (int i = 0; i < ldRows; i++)
-                for (int j = 0; j < ldCols; j++)
-                    _labelDistributions[i, j] = NumOps.FromDouble(ldArr[i * ldCols + j].Value<double>());
-        }
-
-        // Cross-field consistency checks
-        if (_allFeatures is not null && afCols != NumFeatures)
-            throw new InvalidOperationException(
-                $"Failed to deserialize LabelSpreading: AllFeatures columns ({afCols}) does not match NumFeatures ({NumFeatures}).");
-        if (_labelDistributions is not null && ldCols != NumClasses)
-            throw new InvalidOperationException(
-                $"Failed to deserialize LabelSpreading: LabelDistributions columns ({ldCols}) does not match NumClasses ({NumClasses}).");
-        if (_allFeatures is not null && _labelDistributions is not null && _allFeatures.Rows != _labelDistributions.Rows)
-            throw new InvalidOperationException(
-                $"Failed to deserialize LabelSpreading: AllFeatures rows ({_allFeatures.Rows}) does not match LabelDistributions rows ({_labelDistributions.Rows}).");
-        if (_allFeatures is not null && _numLabeled > _allFeatures.Rows)
-            throw new InvalidOperationException(
-                $"Failed to deserialize LabelSpreading: NumLabeled ({_numLabeled}) exceeds AllFeatures rows ({_allFeatures.Rows}).");
-    }
-
     #endregion
 
     #region ICloneable Implementation
 
-    /// <summary>
-    /// Creates a deep copy of this classifier.
-    /// </summary>
-    /// <returns>A new instance with the same parameters and state.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Cloning creates an independent copy that can be modified
-    /// without affecting the original.
-    /// </para>
-    /// </remarks>
-    public override IFullModel<T, Matrix<T>, Vector<T>> Clone()
-    {
-        var clone = new LabelSpreading<T>(
-            _kernel,
-            _maxIterations,
-            _tolerance,
-            _alpha,
-            _random.Next());
-
-        if (_allFeatures is not null)
-        {
-            clone._allFeatures = CloneMatrix(_allFeatures);
-        }
-
-        if (_labelDistributions is not null)
-        {
-            clone._labelDistributions = CloneMatrix(_labelDistributions);
-        }
-
-        if (_initialDistributions is not null)
-        {
-            clone._initialDistributions = CloneMatrix(_initialDistributions);
-        }
-
-        if (_normalizedAffinity is not null)
-        {
-            clone._normalizedAffinity = CloneMatrix(_normalizedAffinity);
-        }
-
-        clone._numLabeled = _numLabeled;
-        clone.NumFeatures = NumFeatures;
-        clone.NumClasses = NumClasses;
-        clone.ClassLabels = ClassLabels?.Clone();
-        clone.TaskType = TaskType;
-
-        return clone;
-    }
-
     #endregion
 
     #region Abstract Method Implementations
@@ -1156,20 +973,5 @@ private void UnpackParameters(Vector<T> parameters)
         // Non-parametric model - no parameters to set
     }
 
-    /// <summary>
-    /// Creates a new instance of this classifier with default configuration.
-    /// </summary>
-    /// <returns>A new LabelSpreading instance.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> This is used internally for operations like cloning or serialization
-    /// that need to create a fresh instance of the same type.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        return new LabelSpreading<T>(_kernel, _maxIterations, _tolerance, _alpha, _random.Next());
-    }
-
     #endregion
 }
diff --git a/src/Classification/SemiSupervised/SelfTrainingClassifier.cs b/src/Classification/SemiSupervised/SelfTrainingClassifier.cs
index 300fae3618..ed54549f9b 100644
--- a/src/Classification/SemiSupervised/SelfTrainingClassifier.cs
+++ b/src/Classification/SemiSupervised/SelfTrainingClassifier.cs
@@ -530,92 +530,4 @@ public void ApplyGradients(Vector<T> gradients, T learningRate)
     {
         ((IGradientComputable<T, Matrix<T>, Vector<T>>)_baseClassifier).ApplyGradients(gradients, learningRate);
     }
-
-    /// <summary>
-    /// Serializes the self-training classifier including its wrapped base classifier.
-    /// </summary>
-    public override byte[] Serialize()
-    {
-        var (baseTypeName, baseData) = ClassifierRegistry<T>.SerializeClassifier(_baseClassifier);
-
-        var modelDict = new Dictionary<string, object?>
-        {
-            { "ClassLabels", ClassLabels?.ToArray().Select(NumOps.ToDouble).ToArray() },
-            { "NumClasses", NumClasses },
-            { "NumFeatures", NumFeatures },
-            { "TaskType", (int)TaskType },
-            { "ConfidenceThreshold", _confidenceThreshold },
-            { "MaxIterations", _maxIterations },
-            { "MaxSamplesPerIteration", _maxSamplesPerIteration },
-            { "SelectionCriterion", (int)_selectionCriterion },
-            { "IterationsPerformed", IterationsPerformed },
-            { "SamplesAdded", SamplesAdded },
-            { "BaseClassifierType", baseTypeName },
-            { "BaseClassifierData", baseData }
-        };
-
-        var metadata = GetModelMetadata();
-        metadata.ModelData = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(modelDict));
-        return Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(metadata));
-    }
-
-    /// <summary>
-    /// Deserializes the self-training classifier including its wrapped base classifier.
-    /// </summary>
-    public override void Deserialize(byte[] modelData)
-    {
-        var jsonString = Encoding.UTF8.GetString(modelData);
-        var metadata = JsonConvert.DeserializeObject<ModelMetadata<T>>(jsonString)
-            ?? throw new InvalidOperationException("Failed to deserialize SelfTrainingClassifier: invalid metadata.");
-        if (metadata.ModelData is null)
-            throw new InvalidOperationException("Failed to deserialize SelfTrainingClassifier: missing model data.");
-
-        var dataString = Encoding.UTF8.GetString(metadata.ModelData);
-        var jObj = JsonConvert.DeserializeObject<JObject>(dataString)
-            ?? throw new InvalidOperationException("Failed to deserialize SelfTrainingClassifier: invalid model payload.");
-
-        // Restore base class state
-        var classLabelsArr = jObj["ClassLabels"]?.ToObject<double[]>();
-        if (classLabelsArr is not null)
-        {
-            ClassLabels = new Vector<T>(classLabelsArr.Length);
-            for (int i = 0; i < classLabelsArr.Length; i++)
-            {
-                ClassLabels[i] = NumOps.FromDouble(classLabelsArr[i]);
-            }
-        }
-        NumClasses = jObj["NumClasses"]?.ToObject<int>() ?? 0;
-        NumFeatures = jObj["NumFeatures"]?.ToObject<int>() ?? 0;
-        TaskType = (ClassificationTaskType)(jObj["TaskType"]?.ToObject<int>() ?? 0);
-        _confidenceThreshold = jObj["ConfidenceThreshold"]?.ToObject<double>() ?? _confidenceThreshold;
-        _maxIterations = jObj["MaxIterations"]?.ToObject<int>() ?? _maxIterations;
-        _maxSamplesPerIteration = jObj["MaxSamplesPerIteration"]?.ToObject<int>() ?? _maxSamplesPerIteration;
-        _selectionCriterion = (SelectionCriterion)(jObj["SelectionCriterion"]?.ToObject<int>() ?? (int)_selectionCriterion);
-        IterationsPerformed = jObj["IterationsPerformed"]?.ToObject<int>() ?? 0;
-        SamplesAdded = jObj["SamplesAdded"]?.ToObject<int>() ?? 0;
-
-        // Restore wrapped base classifier via registry
-        var baseTypeName = jObj["BaseClassifierType"]?.ToObject<string>();
-        var baseData = jObj["BaseClassifierData"]?.ToObject<string>();
-        if (baseTypeName is null || baseData is null)
-            throw new InvalidOperationException(
-                "Failed to deserialize SelfTrainingClassifier: base classifier type/data is missing.");
-
-        _baseClassifier = ClassifierRegistry<T>.DeserializeClassifier(baseTypeName, baseData);
-    }
-
-    /// <summary>
-    /// Creates a new instance of this classifier.
-    /// </summary>
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        return new SelfTrainingClassifier<T>(
-            (IClassifier<T>)_baseClassifier.Clone(),
-            _confidenceThreshold,
-            _maxIterations,
-            _maxSamplesPerIteration,
-            _selectionCriterion,
-            Options,
-            Regularization);
-    }
 }
diff --git a/src/Classification/SemiSupervised/SemiSupervisedClassifierBase.cs b/src/Classification/SemiSupervised/SemiSupervisedClassifierBase.cs
index 371df0ec98..3de4f14d8e 100644
--- a/src/Classification/SemiSupervised/SemiSupervisedClassifierBase.cs
+++ b/src/Classification/SemiSupervised/SemiSupervisedClassifierBase.cs
@@ -25,7 +25,7 @@ namespace AiDotNet.Classification.SemiSupervised;
 /// just the answer key alone.
 /// </para>
 /// </remarks>
-public abstract class SemiSupervisedClassifierBase<T> : ClassifierBase<T>, ISemiSupervisedClassifier<T>
+public abstract partial class SemiSupervisedClassifierBase<T> : ClassifierBase<T>, ISemiSupervisedClassifier<T>
 {
     /// <summary>
     /// Gets or sets the number of labeled samples used in training.
diff --git a/src/Classification/TimeSeries/MiniRocketClassifier.cs b/src/Classification/TimeSeries/MiniRocketClassifier.cs
index b86d604d03..3a4d94c383 100644
--- a/src/Classification/TimeSeries/MiniRocketClassifier.cs
+++ b/src/Classification/TimeSeries/MiniRocketClassifier.cs
@@ -282,149 +282,6 @@ public override IFullModel<T, Matrix<T>, Vector<T>> WithParameters(Vector<T> par
         return clone;
     }
 
-    /// <inheritdoc />
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        return new MiniRocketClassifier<T>(_options);
-    }
-
-    /// <inheritdoc />
-    public override byte[] Serialize()
-    {
-        var metadata = GetModelMetadata();
-        var modelDict = new Dictionary<string, object?>
-        {
-            ["SequenceLength"] = SequenceLength,
-            ["NumChannels"] = NumChannels,
-            ["IsFitted"] = _isFitted,
-            ["NumClasses"] = NumClasses,
-            ["NumFeatures"] = NumFeatures,
-            ["TaskType"] = (int)TaskType
-        };
-
-        if (ClassLabels is not null)
-        {
-            var labels = new double[ClassLabels.Length];
-            for (int i = 0; i < ClassLabels.Length; i++)
-            {
-                labels[i] = NumOps.ToDouble(ClassLabels[i]);
-            }
-            modelDict["ClassLabels"] = labels;
-        }
-
-        if (_weights is not null)
-        {
-            var weights = new double[_weights.Length];
-            for (int i = 0; i < _weights.Length; i++)
-            {
-                weights[i] = NumOps.ToDouble(_weights[i]);
-            }
-            modelDict["Weights"] = weights;
-        }
-
-        if (_kernels is not null)
-        {
-            modelDict["KernelCount"] = _kernels.Length;
-            for (int i = 0; i < _kernels.Length; i++)
-            {
-                modelDict[$"Kernel_{i}"] = _kernels[i];
-            }
-        }
-
-        if (_dilations is not null)
-        {
-            modelDict["Dilations"] = _dilations;
-        }
-
-        if (_biases is not null)
-        {
-            modelDict["BiasCount"] = _biases.Length;
-            for (int i = 0; i < _biases.Length; i++)
-            {
-                modelDict[$"Bias_{i}"] = _biases[i];
-            }
-        }
-
-        metadata.ModelData = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(modelDict));
-        return Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(metadata));
-    }
-
-    /// <inheritdoc />
-    public override void Deserialize(byte[] modelData)
-    {
-        var jsonString = Encoding.UTF8.GetString(modelData);
-        var metadata = JsonConvert.DeserializeObject<ModelMetadata<T>>(jsonString)
-            ?? throw new InvalidOperationException("Failed to deserialize MiniRocketClassifier: invalid metadata.");
-        if (metadata.ModelData is null)
-            throw new InvalidOperationException("Failed to deserialize MiniRocketClassifier: missing model data.");
-
-        var dataString = Encoding.UTF8.GetString(metadata.ModelData);
-        var jObj = JsonConvert.DeserializeObject<JObject>(dataString)
-            ?? throw new InvalidOperationException("Failed to deserialize MiniRocketClassifier: invalid model payload.");
-
-        // Clear prior state before rehydrating
-        ClassLabels = null;
-        _weights = null;
-        _kernels = null;
-        _dilations = null;
-        _biases = null;
-
-        SequenceLength = jObj["SequenceLength"]?.ToObject<int>() ?? 0;
-        NumChannels = jObj["NumChannels"]?.ToObject<int>() ?? 1;
-        _isFitted = jObj["IsFitted"]?.ToObject<bool>() ?? false;
-        NumClasses = jObj["NumClasses"]?.ToObject<int>() ?? 0;
-        NumFeatures = jObj["NumFeatures"]?.ToObject<int>() ?? 0;
-        TaskType = (ClassificationTaskType)(jObj["TaskType"]?.ToObject<int>() ?? 0);
-
-        var labelsToken = jObj["ClassLabels"];
-        if (labelsToken is JArray labelsArr)
-        {
-            ClassLabels = new Vector<T>(labelsArr.Count);
-            for (int i = 0; i < labelsArr.Count; i++)
-            {
-                ClassLabels[i] = NumOps.FromDouble(labelsArr[i].Value<double>());
-            }
-        }
-
-        var weightsToken = jObj["Weights"];
-        if (weightsToken is JArray weightsArr)
-        {
-            _weights = new Vector<T>(weightsArr.Count);
-            for (int i = 0; i < weightsArr.Count; i++)
-            {
-                _weights[i] = NumOps.FromDouble(weightsArr[i].Value<double>());
-            }
-        }
-
-        int kernelCount = jObj["KernelCount"]?.ToObject<int>() ?? 0;
-        if (kernelCount > 0)
-        {
-            _kernels = new double[kernelCount][];
-            for (int i = 0; i < kernelCount; i++)
-            {
-                var kArr = jObj[$"Kernel_{i}"] as JArray;
-                _kernels[i] = kArr?.Select(v => v.Value<double>()).ToArray() ?? [];
-            }
-        }
-
-        var dilationsToken = jObj["Dilations"];
-        if (dilationsToken is JArray dilArr)
-        {
-            _dilations = dilArr.Select(d => d.Value<int>()).ToArray();
-        }
-
-        int biasCount = jObj["BiasCount"]?.ToObject<int>() ?? 0;
-        if (biasCount > 0)
-        {
-            _biases = new double[biasCount][];
-            for (int i = 0; i < biasCount; i++)
-            {
-                var bArr = jObj[$"Bias_{i}"] as JArray;
-                _biases[i] = bArr?.Select(v => v.Value<double>()).ToArray() ?? [];
-            }
-        }
-    }
-
     private static int[][] GenerateKernelPatterns()
     {
         // Generate all 84 combinations of placing 3 values of 2 in a length-9 kernel
diff --git a/src/Classification/TimeSeries/RocketClassifier.cs b/src/Classification/TimeSeries/RocketClassifier.cs
index 9f6a42d51b..3a444831e4 100644
--- a/src/Classification/TimeSeries/RocketClassifier.cs
+++ b/src/Classification/TimeSeries/RocketClassifier.cs
@@ -501,116 +501,8 @@ public override IFullModel<T, Matrix<T>, Vector<T>> WithParameters(Vector<T> par
         return copy;
     }
 
-    /// <inheritdoc />
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        return new RocketClassifier<T>(_rocketOptions);
-    }
 
 
-
-    /// <inheritdoc />
-    public override byte[] Serialize()
-    {
-        var metadata = GetModelMetadata();
-        var modelDict = new Dictionary<string, object?>
-        {
-            ["SequenceLength"] = SequenceLength,
-            ["NumChannels"] = NumChannels,
-            ["NumClasses"] = NumClasses,
-            ["NumFeatures"] = NumFeatures,
-            ["TaskType"] = (int)TaskType
-        };
-
-        if (ClassLabels is not null)
-        {
-            var labels = new double[ClassLabels.Length];
-            for (int i = 0; i < ClassLabels.Length; i++)
-            {
-                labels[i] = NumOps.ToDouble(ClassLabels[i]);
-            }
-            modelDict["ClassLabels"] = labels;
-        }
-
-        if (_internalWeights is not null)
-        {
-            var weights = new double[_internalWeights.Length];
-            for (int i = 0; i < _internalWeights.Length; i++)
-            {
-                weights[i] = NumOps.ToDouble(_internalWeights[i]);
-            }
-            modelDict["InternalWeights"] = weights;
-        }
-
-        if (_kernels.Count > 0)
-        {
-            modelDict["KernelCount"] = _kernels.Count;
-            for (int i = 0; i < _kernels.Count; i++)
-            {
-                var kernel = _kernels[i];
-                modelDict[$"Kernel_{i}_Weights"] = kernel.Weights;
-                modelDict[$"Kernel_{i}_Dilation"] = kernel.Dilation;
-                modelDict[$"Kernel_{i}_Bias"] = kernel.Bias;
-                modelDict[$"Kernel_{i}_Padding"] = kernel.Padding;
-            }
-        }
-
-        metadata.ModelData = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(modelDict));
-        return Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(metadata));
-    }
-
-    /// <inheritdoc />
-    public override void Deserialize(byte[] modelData)
-    {
-        var jsonString = Encoding.UTF8.GetString(modelData);
-        var metadata = JsonConvert.DeserializeObject<ModelMetadata<T>>(jsonString)
-            ?? throw new InvalidOperationException("Failed to deserialize RocketClassifier: invalid metadata.");
-        if (metadata.ModelData is null)
-            throw new InvalidOperationException("Failed to deserialize RocketClassifier: missing model data.");
-
-        var dataString = Encoding.UTF8.GetString(metadata.ModelData);
-        var jObj = JsonConvert.DeserializeObject<JObject>(dataString)
-            ?? throw new InvalidOperationException("Failed to deserialize RocketClassifier: invalid model payload.");
-
-        SequenceLength = jObj["SequenceLength"]?.ToObject<int>() ?? 0;
-        NumChannels = jObj["NumChannels"]?.ToObject<int>() ?? 1;
-        NumClasses = jObj["NumClasses"]?.ToObject<int>() ?? 0;
-        NumFeatures = jObj["NumFeatures"]?.ToObject<int>() ?? 0;
-        TaskType = (ClassificationTaskType)(jObj["TaskType"]?.ToObject<int>() ?? 0);
-
-        var labelsToken = jObj["ClassLabels"];
-        if (labelsToken is JArray labelsArr)
-        {
-            ClassLabels = new Vector<T>(labelsArr.Count);
-            for (int i = 0; i < labelsArr.Count; i++)
-            {
-                ClassLabels[i] = NumOps.FromDouble(labelsArr[i].Value<double>());
-            }
-        }
-
-        var weightsToken = jObj["InternalWeights"];
-        if (weightsToken is JArray weightsArr)
-        {
-            _internalWeights = new Vector<T>(weightsArr.Count);
-            for (int i = 0; i < weightsArr.Count; i++)
-            {
-                _internalWeights[i] = NumOps.FromDouble(weightsArr[i].Value<double>());
-            }
-        }
-
-        int kernelCount = jObj["KernelCount"]?.ToObject<int>() ?? 0;
-        _kernels.Clear();
-        for (int i = 0; i < kernelCount; i++)
-        {
-            var weightsArr2 = jObj[$"Kernel_{i}_Weights"] as JArray;
-            double[] kWeights = weightsArr2?.Select(w => w.Value<double>()).ToArray() ?? [];
-            int dilation = jObj[$"Kernel_{i}_Dilation"]?.ToObject<int>() ?? 1;
-            double bias = jObj[$"Kernel_{i}_Bias"]?.ToObject<double>() ?? 0;
-            int padding = jObj[$"Kernel_{i}_Padding"]?.ToObject<int>() ?? 0;
-            _kernels.Add(new RocketKernel(kWeights, dilation, bias, padding));
-        }
-    }
-
     /// <summary>
     /// Validates the input sequences.
     /// </summary>
diff --git a/src/Classification/TimeSeries/TimeSeriesClassifierBase.cs b/src/Classification/TimeSeries/TimeSeriesClassifierBase.cs
index 2cd6465406..f2762622a9 100644
--- a/src/Classification/TimeSeries/TimeSeriesClassifierBase.cs
+++ b/src/Classification/TimeSeries/TimeSeriesClassifierBase.cs
@@ -26,7 +26,7 @@ namespace AiDotNet.Classification.TimeSeries;
 /// </para>
 /// </remarks>
 /// <typeparam name="T">The numeric type for calculations.</typeparam>
-public abstract class TimeSeriesClassifierBase<T> : ClassifierBase<T>, ITimeSeriesClassifier<T>
+public abstract partial class TimeSeriesClassifierBase<T> : ClassifierBase<T>, ITimeSeriesClassifier<T>
 {
     /// <summary>
     /// Gets or sets the expected sequence length.
diff --git a/src/Classification/TimeSeries/TimeSeriesForestClassifier.cs b/src/Classification/TimeSeries/TimeSeriesForestClassifier.cs
index 2fae93f520..654e631a75 100644
--- a/src/Classification/TimeSeries/TimeSeriesForestClassifier.cs
+++ b/src/Classification/TimeSeries/TimeSeriesForestClassifier.cs
@@ -72,7 +72,7 @@ namespace AiDotNet.Classification.TimeSeries;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Vector<>))]
 [ResearchPaper("A Time Series Forest for Classification and Feature Extraction", "https://doi.org/10.1016/j.ins.2013.01.006", Year = 2013, Authors = "Houtao Deng, George Runger, Eugene Tuv, Martyanov Vladimir")]
-public class TimeSeriesForestClassifier<T> : ClassifierBase<T>, ITimeSeriesClassifier<T>
+public partial class TimeSeriesForestClassifier<T> : ClassifierBase<T>, ITimeSeriesClassifier<T>
 {
 
     // Returned the tree count, its own comment calling it "simplified". An honest zero replaces a
@@ -326,110 +326,6 @@ public override IFullModel<T, Matrix<T>, Vector<T>> WithParameters(Vector<T> par
         return clone;
     }
 
-    /// <inheritdoc />
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        return new TimeSeriesForestClassifier<T>(_options);
-    }
-
-    /// <inheritdoc />
-    public override byte[] Serialize()
-    {
-        var metadata = GetModelMetadata();
-        var modelDict = new Dictionary<string, object?>
-        {
-            ["SequenceLength"] = SequenceLength,
-            ["NumChannels"] = NumChannels,
-            ["IsFitted"] = _isFitted,
-            ["NumClasses"] = NumClasses,
-            ["NumFeatures"] = NumFeatures,
-            ["TaskType"] = (int)TaskType
-        };
-
-        if (ClassLabels is not null)
-        {
-            var labels = new double[ClassLabels.Length];
-            for (int i = 0; i < ClassLabels.Length; i++)
-            {
-                labels[i] = NumOps.ToDouble(ClassLabels[i]);
-            }
-            modelDict["ClassLabels"] = labels;
-        }
-
-        if (_trees is not null)
-        {
-            modelDict["TreeCount"] = _trees.Count;
-            for (int i = 0; i < _trees.Count; i++)
-            {
-                var tree = _trees[i];
-                modelDict[$"Tree_{i}_IntervalStart"] = tree.IntervalStart;
-                modelDict[$"Tree_{i}_IntervalEnd"] = tree.IntervalEnd;
-                modelDict[$"Tree_{i}_ChannelIdx"] = tree.ChannelIdx;
-                if (tree.Root is not null)
-                {
-                    modelDict[$"Tree_{i}_Root"] = SerializeTreeNode(tree.Root);
-                }
-            }
-        }
-
-        metadata.ModelData = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(modelDict));
-        return Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(metadata));
-    }
-
-    /// <inheritdoc />
-    public override void Deserialize(byte[] modelData)
-    {
-        var jsonString = Encoding.UTF8.GetString(modelData);
-        var metadata = JsonConvert.DeserializeObject<ModelMetadata<T>>(jsonString)
-            ?? throw new InvalidOperationException("Failed to deserialize TimeSeriesForestClassifier: invalid metadata.");
-        if (metadata.ModelData is null)
-            throw new InvalidOperationException("Failed to deserialize TimeSeriesForestClassifier: missing model data.");
-
-        var dataString = Encoding.UTF8.GetString(metadata.ModelData);
-        var jObj = JsonConvert.DeserializeObject<JObject>(dataString)
-            ?? throw new InvalidOperationException("Failed to deserialize TimeSeriesForestClassifier: invalid model payload.");
-
-        SequenceLength = jObj["SequenceLength"]?.ToObject<int>() ?? 0;
-        NumChannels = jObj["NumChannels"]?.ToObject<int>() ?? 1;
-        _isFitted = jObj["IsFitted"]?.ToObject<bool>() ?? false;
-        NumClasses = jObj["NumClasses"]?.ToObject<int>() ?? 0;
-        NumFeatures = jObj["NumFeatures"]?.ToObject<int>() ?? 0;
-        TaskType = (ClassificationTaskType)(jObj["TaskType"]?.ToObject<int>() ?? 0);
-
-        var labelsToken = jObj["ClassLabels"];
-        if (labelsToken is JArray labelsArr)
-        {
-            ClassLabels = new Vector<T>(labelsArr.Count);
-            for (int i = 0; i < labelsArr.Count; i++)
-            {
-                ClassLabels[i] = NumOps.FromDouble(labelsArr[i].Value<double>());
-            }
-        }
-
-        int treeCount = jObj["TreeCount"]?.ToObject<int>() ?? 0;
-        if (treeCount > 0)
-        {
-            _trees = new List<IntervalTree>(treeCount);
-            for (int i = 0; i < treeCount; i++)
-            {
-                var tree = new IntervalTree
-                {
-                    IntervalStart = jObj[$"Tree_{i}_IntervalStart"]?.ToObject<int>() ?? 0,
-                    IntervalEnd = jObj[$"Tree_{i}_IntervalEnd"]?.ToObject<int>() ?? 0,
-                    ChannelIdx = jObj[$"Tree_{i}_ChannelIdx"]?.ToObject<int>() ?? 0
-                };
-
-                var rootToken = jObj[$"Tree_{i}_Root"];
-                if (rootToken is not JObject rootObj)
-                    throw new InvalidOperationException(
-                        $"Failed to deserialize TimeSeriesForestClassifier: Tree_{i} has no root node.");
-
-                tree.Root = DeserializeTreeNode(rootObj);
-                _trees.Add(tree);
-            }
-        }
-    }
-
     private Dictionary<string, object?> SerializeTreeNode(DecisionTreeNode node)
     {
         var dict = new Dictionary<string, object?>
diff --git a/src/Classification/Trees/DecisionTreeClassifier.cs b/src/Classification/Trees/DecisionTreeClassifier.cs
index e45e6e959c..3cc030bfe2 100644
--- a/src/Classification/Trees/DecisionTreeClassifier.cs
+++ b/src/Classification/Trees/DecisionTreeClassifier.cs
@@ -47,7 +47,7 @@ namespace AiDotNet.Classification.Trees;
 [ModelComplexity(ModelComplexity.Low)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
     [ResearchPaper("Classification and Regression Trees", "https://doi.org/10.1201/9781315139470")]
-public class DecisionTreeClassifier<T> : ProbabilisticClassifierBase<T>, ITreeBasedClassifier<T>
+public partial class DecisionTreeClassifier<T> : ProbabilisticClassifierBase<T>, ITreeBasedClassifier<T>
 {
 
     // Its own comment: "Decision trees do not have traditional numeric parameters". The base fold
@@ -544,65 +544,6 @@ private int CountNodes(DecisionNode<T>? node)
         return 1 + CountNodes(node.Left) + CountNodes(node.Right);
     }
 
-    /// <inheritdoc/>
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        return new DecisionTreeClassifier<T>(new DecisionTreeClassifierOptions<T>
-        {
-            MaxDepth = Options.MaxDepth,
-            MinSamplesSplit = Options.MinSamplesSplit,
-            MinSamplesLeaf = Options.MinSamplesLeaf,
-            MaxFeatures = Options.MaxFeatures,
-            Criterion = Options.Criterion,
-            Seed = Options.Seed,
-            MinImpurityDecrease = Options.MinImpurityDecrease
-        });
-    }
-
-    /// <inheritdoc/>
-    public override IFullModel<T, Matrix<T>, Vector<T>> Clone()
-    {
-        var clone = new DecisionTreeClassifier<T>(new DecisionTreeClassifierOptions<T>
-        {
-            MaxDepth = Options.MaxDepth,
-            MinSamplesSplit = Options.MinSamplesSplit,
-            MinSamplesLeaf = Options.MinSamplesLeaf,
-            MaxFeatures = Options.MaxFeatures,
-            Criterion = Options.Criterion,
-            Seed = Options.Seed,
-            MinImpurityDecrease = Options.MinImpurityDecrease
-        });
-
-        clone.NumFeatures = NumFeatures;
-        clone.NumClasses = NumClasses;
-        clone.TaskType = TaskType;
-
-        if (ClassLabels != null)
-        {
-            clone.ClassLabels = new Vector<T>(ClassLabels.Length);
-            for (int i = 0; i < ClassLabels.Length; i++)
-            {
-                clone.ClassLabels[i] = ClassLabels[i];
-            }
-        }
-
-        if (FeatureImportances != null)
-        {
-            clone.FeatureImportances = new Vector<T>(FeatureImportances.Length);
-            for (int i = 0; i < FeatureImportances.Length; i++)
-            {
-                clone.FeatureImportances[i] = FeatureImportances[i];
-            }
-        }
-
-        if (_root != null)
-        {
-            clone._root = CloneNode(_root);
-        }
-
-        return clone;
-    }
-
     /// <summary>
     /// Deep clones a decision tree node.
     /// </summary>
@@ -673,43 +614,6 @@ public override ModelMetadata<T> GetModelMetadata()
         return metadata;
     }
 
-    /// <inheritdoc/>
-    public override byte[] Serialize()
-    {
-        var modelData = new Dictionary<string, object>
-        {
-            { "NumClasses", NumClasses },
-            { "NumFeatures", NumFeatures },
-            { "TaskType", (int)TaskType },
-            { "ClassLabels", ClassLabels?.ToArray() ?? Array.Empty<T>() },
-            { "RegularizationOptions", Regularization.GetOptions() }
-        };
-
-        // Serialize FeatureImportances
-        if (FeatureImportances is not null)
-        {
-            var featureImportancesArray = new double[FeatureImportances.Length];
-            for (int i = 0; i < FeatureImportances.Length; i++)
-            {
-                featureImportancesArray[i] = NumOps.ToDouble(FeatureImportances[i]);
-            }
-            modelData["FeatureImportances"] = featureImportancesArray;
-        }
-
-        // Serialize tree structure
-        if (_root is not null)
-        {
-            modelData["Tree"] = SerializeNode(_root);
-        }
-
-        var modelMetadata = GetModelMetadata();
-        modelMetadata.ModelData = System.Text.Encoding.UTF8.GetBytes(
-            Newtonsoft.Json.JsonConvert.SerializeObject(modelData));
-
-        return System.Text.Encoding.UTF8.GetBytes(
-            Newtonsoft.Json.JsonConvert.SerializeObject(modelMetadata));
-    }
-
     /// <summary>
     /// Serializes a decision node to a dictionary for JSON serialization.
     /// </summary>
@@ -747,67 +651,6 @@ private Dictionary<string, object> SerializeNode(DecisionNode<T> node)
         return nodeData;
     }
 
-    /// <inheritdoc/>
-    public override void Deserialize(byte[] modelData)
-    {
-        var jsonString = System.Text.Encoding.UTF8.GetString(modelData);
-        var modelMetadata = Newtonsoft.Json.JsonConvert.DeserializeObject<ModelMetadata<T>>(jsonString);
-
-        if (modelMetadata == null || modelMetadata.ModelData == null)
-        {
-            throw new InvalidOperationException("Deserialization failed: The model data is invalid or corrupted.");
-        }
-
-        var modelDataString = System.Text.Encoding.UTF8.GetString(modelMetadata.ModelData);
-        var modelDataObj = Newtonsoft.Json.JsonConvert.DeserializeObject<Newtonsoft.Json.Linq.JObject>(modelDataString);
-
-        if (modelDataObj == null)
-        {
-            throw new InvalidOperationException("Deserialization failed: The model data is invalid or corrupted.");
-        }
-
-        // Deserialize base properties
-        NumClasses = modelDataObj["NumClasses"]?.ToObject<int>() ?? 0;
-        NumFeatures = modelDataObj["NumFeatures"]?.ToObject<int>() ?? 0;
-        TaskType = (ClassificationTaskType)(modelDataObj["TaskType"]?.ToObject<int>() ?? 0);
-
-        var classLabelsToken = modelDataObj["ClassLabels"];
-        if (classLabelsToken is not null)
-        {
-            var classLabelsAsDoubles = classLabelsToken.ToObject<double[]>() ?? Array.Empty<double>();
-            if (classLabelsAsDoubles.Length > 0)
-            {
-                ClassLabels = new Vector<T>(classLabelsAsDoubles.Length);
-                for (int i = 0; i < classLabelsAsDoubles.Length; i++)
-                {
-                    ClassLabels[i] = NumOps.FromDouble(classLabelsAsDoubles[i]);
-                }
-            }
-        }
-
-        // Deserialize FeatureImportances
-        var featureImportancesToken = modelDataObj["FeatureImportances"];
-        if (featureImportancesToken is not null)
-        {
-            var featureImportancesArray = featureImportancesToken.ToObject<double[]>() ?? Array.Empty<double>();
-            if (featureImportancesArray.Length > 0)
-            {
-                FeatureImportances = new Vector<T>(featureImportancesArray.Length);
-                for (int i = 0; i < featureImportancesArray.Length; i++)
-                {
-                    FeatureImportances[i] = NumOps.FromDouble(featureImportancesArray[i]);
-                }
-            }
-        }
-
-        // Deserialize tree structure
-        var treeToken = modelDataObj["Tree"];
-        if (treeToken is not null)
-        {
-            _root = DeserializeNode(treeToken as Newtonsoft.Json.Linq.JObject);
-        }
-    }
-
     /// <summary>
     /// Deserializes a decision node from a JSON object.
     /// </summary>
diff --git a/src/Clustering/AutoK/GMeans.cs b/src/Clustering/AutoK/GMeans.cs
index 34a07fbba9..51ff0ee421 100644
--- a/src/Clustering/AutoK/GMeans.cs
+++ b/src/Clustering/AutoK/GMeans.cs
@@ -56,7 +56,7 @@ namespace AiDotNet.Clustering.AutoK;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
 [ResearchPaper("Learning the k in k-means", "https://proceedings.neurips.cc/paper/2003/hash/234833147b97bb6aed53a8f4f1c7a7d8-Abstract.html", Year = 2004, Authors = "Greg Hamerly, Charles Elkan")]
-public class GMeans<T> : ClusteringBase<T>
+public partial class GMeans<T> : ClusteringBase<T>
 {
     private readonly GMeansOptions<T> _options;
 
@@ -75,19 +75,6 @@ public GMeans(GMeansOptions<T>? options = null)
 
     /// <inheritdoc />
 
-    /// <inheritdoc />
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        return new GMeans<T>(new GMeansOptions<T>
-        {
-            MinClusters = _options.MinClusters,
-            MaxClusters = _options.MaxClusters,
-            SignificanceLevel = _options.SignificanceLevel,
-            MaxIterations = _options.MaxIterations,
-            DistanceMetric = _options.DistanceMetric
-        });
-    }
-
     /// <inheritdoc />
     public override IFullModel<T, Matrix<T>, Vector<T>> WithParameters(Vector<T> parameters)
     {
diff --git a/src/Clustering/AutoK/XMeans.cs b/src/Clustering/AutoK/XMeans.cs
index baa2134c9f..f40812353b 100644
--- a/src/Clustering/AutoK/XMeans.cs
+++ b/src/Clustering/AutoK/XMeans.cs
@@ -55,7 +55,7 @@ namespace AiDotNet.Clustering.AutoK;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
 [ResearchPaper("X-means: Extending K-means with Efficient Estimation of the Number of Clusters", "https://www.cs.cmu.edu/~dpelleg/download/xmeans.pdf", Year = 2000, Authors = "Dan Pelleg, Andrew Moore")]
-public class XMeans<T> : ClusteringBase<T>
+public partial class XMeans<T> : ClusteringBase<T>
 {
     private readonly XMeansOptions<T> _options;
 
@@ -83,19 +83,6 @@ public XMeans(XMeansOptions<T>? options = null)
 
     /// <inheritdoc />
 
-    /// <inheritdoc />
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        return new XMeans<T>(new XMeansOptions<T>
-        {
-            MinClusters = _options.MinClusters,
-            MaxClusters = _options.MaxClusters,
-            Criterion = _options.Criterion,
-            MaxIterations = _options.MaxIterations,
-            DistanceMetric = _options.DistanceMetric
-        });
-    }
-
     /// <inheritdoc />
     public override IFullModel<T, Matrix<T>, Vector<T>> WithParameters(Vector<T> parameters)
     {
diff --git a/src/Clustering/Base/ClusteringBase.cs b/src/Clustering/Base/ClusteringBase.cs
index 1e5c89ec0a..b6abe05ba8 100644
--- a/src/Clustering/Base/ClusteringBase.cs
+++ b/src/Clustering/Base/ClusteringBase.cs
@@ -20,10 +20,53 @@ namespace AiDotNet.Clustering.Base;
 /// Provides a base implementation for clustering algorithms that group similar data points together.
 /// </summary>
 /// <typeparam name="T">The numeric data type used for calculations (e.g., float, double).</typeparam>
-public abstract class ClusteringBase<T> : IClustering<T>, IConfigurableModel<T>, IModelShape,
+public abstract partial class ClusteringBase<T> : IClustering<T>, IConfigurableModel<T>, IModelShape,
     IParameterizable<T, Matrix<T>, Vector<T>>, IFeatureAware, IGradientComputable<T, Matrix<T>, Vector<T>>,
     IParameterManifestProvider
 {
+    // --- declared state (ModelStateRegistry) ---
+    // Identical in every model base because these bases are siblings over the same interfaces rather
+    // than one hierarchy; the logic itself lives once in ModelStateRegistry/ModelStateEnvelope.
+
+    /// <summary>State that is not a parameter vector, declared once and persisted by this base.</summary>
+    private readonly AiDotNet.Models.ModelStateRegistry<T> _declaredState = new();
+    private bool _declaredStateRegistered;
+
+    /// <summary>
+    /// Declare state here that the parameter vector does not carry -- a retained training set,
+    /// fitted knots, kernel centres, an ensemble's children. Both halves of the payload are driven
+    /// by the declaration, so they cannot drift.
+    /// </summary>
+    /// <param name="state">The registry to declare into.</param>
+    protected virtual void RegisterState(AiDotNet.Models.ModelStateRegistry<T> state)
+    {
+    }
+    /// <summary>Generated state declarations for fields declared across this model's hierarchy.</summary>
+    /// <param name="state">The registry to declare into.</param>
+    /// <remarks>
+    /// Emitted by ModelStateGenerator into the partial model, so a model author declares nothing. The
+    /// hand-written <c>RegisterState</c> beside it exists only for state the classifier genuinely
+    /// cannot place; anything it CAN place belongs here, where it cannot be forgotten.
+    /// </remarks>
+    protected virtual void RegisterGeneratedState(AiDotNet.Models.ModelStateRegistry<T> state)
+    {
+        RegisterGeneratedStateCore(state);
+    }
+
+    /// <summary>The declared state, registered once and lazily so it runs after the constructor.</summary>
+    protected AiDotNet.Models.ModelStateRegistry<T> DeclaredState
+    {
+        get
+        {
+            if (!_declaredStateRegistered)
+            {
+                _declaredStateRegistered = true;
+                RegisterGeneratedState(_declaredState);
+                RegisterState(_declaredState);
+            }
+            return _declaredState;
+        }
+    }
     /// <summary>
     /// Gets the numeric operations for the specified type T.
     /// </summary>
@@ -296,12 +339,15 @@ public virtual byte[] Serialize()
         var modelMetadata = GetModelMetadata();
         modelMetadata.ModelData = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(modelData));
 
-        return Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(modelMetadata));
+        return AiDotNet.Models.ModelStateEnvelope.Append(DeclaredState, Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(modelMetadata)));
     }
 
     /// <inheritdoc/>
     public virtual void Deserialize(byte[] modelData)
     {
+        // Strips and applies any declared-state trailer, so the body below reads the payload
+        // exactly as it did before this existed.
+        modelData = AiDotNet.Models.ModelStateEnvelope.Extract(DeclaredState, modelData);
         ModelPersistenceGuard.EnforceBeforeDeserialize();
         var jsonString = Encoding.UTF8.GetString(modelData);
         var modelMetadata = JsonConvert.DeserializeObject<ModelMetadata<T>>(jsonString);
@@ -742,7 +788,18 @@ public virtual Dictionary<string, T> GetFeatureImportance()
     /// <summary>
     /// Creates a new instance of this clustering algorithm.
     /// </summary>
-    protected abstract IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance();
+    /// <remarks>
+    /// <para>
+    /// No longer abstract. Every concrete model used to be forced to write this, and 1147 of them
+    /// did -- each one a hand-copied list of constructor arguments that a new option could fall out
+    /// of without anything failing. The clone plan records that constructor at compile time instead,
+    /// so the base can rebuild the type and a model only overrides this when the generator says it
+    /// cannot: a constructor parameter with nothing holding its value, which the build reports by
+    /// name rather than leaving to be discovered by a clone that comes back subtly different.
+    /// </para>
+    /// </remarks>
+    protected virtual IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
+        => (IFullModel<T, Matrix<T>, Vector<T>>)AiDotNet.Models.CloneEngine.CopyConfiguration(this);
 
     /// <inheritdoc/>
     public virtual IFullModel<T, Matrix<T>, Vector<T>> DeepCopy()
diff --git a/src/Clustering/Density/DBSCAN.cs b/src/Clustering/Density/DBSCAN.cs
index c4e27f673c..056ebfdbe3 100644
--- a/src/Clustering/Density/DBSCAN.cs
+++ b/src/Clustering/Density/DBSCAN.cs
@@ -60,7 +60,7 @@ namespace AiDotNet.Clustering.Density;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
 [ResearchPaper("A Density-Based Algorithm for Discovering Clusters in Large Spatial Databases with Noise", "https://www.aaai.org/Papers/KDD/1996/KDD96-037.pdf", Year = 1996, Authors = "Martin Ester, Hans-Peter Kriegel, Jorg Sander, Xiaowei Xu")]
-public class DBSCAN<T> : ClusteringBase<T>
+public partial class DBSCAN<T> : ClusteringBase<T>
 {
     private readonly DBSCANOptions<T> _options;
 
@@ -72,10 +72,13 @@ public class DBSCAN<T> : ClusteringBase<T>
     private bool[]? _corePointMask;
 
     // Feature normalization state for scale-invariant distance computation
+    [AiDotNet.Attributes.FittedParameter]
     private Vector<T>? _featureMeans;
+    [AiDotNet.Attributes.FittedParameter]
     private Vector<T>? _featureStds;
 
     // Cluster centers in normalized space for Predict comparison
+    [AiDotNet.Attributes.FittedParameter]
     private Matrix<T>? _normalizedClusterCenters;
 
     /// <summary>
@@ -119,65 +122,6 @@ public DBSCAN(DBSCANOptions<T>? options = null)
     /// </summary>
     public bool[]? CorePointMask => _corePointMask;
 
-    /// <inheritdoc />
-
-    /// <inheritdoc />
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        return new DBSCAN<T>(new DBSCANOptions<T>
-        {
-            Epsilon = _options.Epsilon,
-            MinPoints = _options.MinPoints,
-            Algorithm = _options.Algorithm,
-            LeafSize = _options.LeafSize,
-            P = _options.P,
-            DistanceMetric = _options.DistanceMetric,
-            NumJobs = _options.NumJobs
-        });
-    }
-
-    /// <inheritdoc />
-    public override IFullModel<T, Matrix<T>, Vector<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IFullModel<T, Matrix<T>, Vector<T>> Clone()
-    {
-        var clone = (DBSCAN<T>)CreateNewInstance();
-        clone._corePointMask = _corePointMask?.ToArray();
-        clone._featureMeans = _featureMeans is not null ? new Vector<T>(_featureMeans) : null;
-        clone._featureStds = _featureStds is not null ? new Vector<T>(_featureStds) : null;
-
-        if (Labels is not null)
-        {
-            clone.Labels = new Vector<T>(Labels.Length);
-            for (int i = 0; i < Labels.Length; i++)
-                clone.Labels[i] = Labels[i];
-        }
-
-        if (ClusterCenters is not null)
-        {
-            clone.ClusterCenters = new Matrix<T>(ClusterCenters.Rows, ClusterCenters.Columns);
-            for (int i = 0; i < ClusterCenters.Rows; i++)
-                for (int j = 0; j < ClusterCenters.Columns; j++)
-                    clone.ClusterCenters[i, j] = ClusterCenters[i, j];
-        }
-
-        if (_normalizedClusterCenters is not null)
-        {
-            clone._normalizedClusterCenters = new Matrix<T>(_normalizedClusterCenters.Rows, _normalizedClusterCenters.Columns);
-            for (int i = 0; i < _normalizedClusterCenters.Rows; i++)
-                for (int j = 0; j < _normalizedClusterCenters.Columns; j++)
-                    clone._normalizedClusterCenters[i, j] = _normalizedClusterCenters[i, j];
-        }
-
-        clone.NumClusters = NumClusters;
-        clone.NumFeatures = NumFeatures;
-        clone.IsTrained = IsTrained;
-        clone._fittedEpsilon = _fittedEpsilon;
-
-        return clone;
-    }
-
     /// <inheritdoc />
     public override IFullModel<T, Matrix<T>, Vector<T>> WithParameters(Vector<T> parameters)
     {
diff --git a/src/Clustering/Density/Denclue.cs b/src/Clustering/Density/Denclue.cs
index 0b8685cd87..003950a1cc 100644
--- a/src/Clustering/Density/Denclue.cs
+++ b/src/Clustering/Density/Denclue.cs
@@ -58,7 +58,7 @@ namespace AiDotNet.Clustering.Density;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
 [ResearchPaper("DENCLUE: A New Approach for Discovering Density-Based Clusters in Large Spatial Databases", "https://link.springer.com/chapter/10.1007/978-1-4615-5669-5_7", Year = 1998, Authors = "Alexander Hinneburg, Daniel A. Keim")]
-public class Denclue<T> : ClusteringBase<T>
+public partial class Denclue<T> : ClusteringBase<T>
 {
     private readonly DenclueOptions<T> _options;
 
@@ -66,7 +66,9 @@ public class Denclue<T> : ClusteringBase<T>
     public override ModelOptions GetOptions() => _options;
     private T[][]? _attractors;
     private T[]? _attractorDensities;
+    [AiDotNet.Attributes.FittedParameter]
     private Vector<T>? _featureMeans;
+    [AiDotNet.Attributes.FittedParameter]
     private Vector<T>? _featureStds;
 
     /// <summary>
@@ -92,20 +94,6 @@ public Denclue(DenclueOptions<T>? options = null)
 
     /// <inheritdoc />
 
-    /// <inheritdoc />
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        return new Denclue<T>(new DenclueOptions<T>
-        {
-            Bandwidth = _options.Bandwidth,
-            MinDensity = _options.MinDensity,
-            ConvergenceThreshold = _options.ConvergenceThreshold,
-            AttractorMergeThreshold = _options.AttractorMergeThreshold,
-            MaxIterations = _options.MaxIterations,
-            DistanceMetric = _options.DistanceMetric
-        });
-    }
-
     /// <inheritdoc />
     public override IFullModel<T, Matrix<T>, Vector<T>> WithParameters(Vector<T> parameters)
     {
@@ -453,39 +441,6 @@ public override Vector<T> Predict(Matrix<T> x)
         return labels;
     }
 
-    /// <inheritdoc />
-    public override IFullModel<T, Matrix<T>, Vector<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IFullModel<T, Matrix<T>, Vector<T>> Clone()
-    {
-        var clone = (Denclue<T>)CreateNewInstance();
-        clone._attractors = _attractors?.Select(a => (T[])a.Clone()).ToArray();
-        clone._attractorDensities = _attractorDensities?.ToArray();
-        clone._featureMeans = _featureMeans is not null ? new Vector<T>(_featureMeans) : null;
-        clone._featureStds = _featureStds is not null ? new Vector<T>(_featureStds) : null;
-        clone.NumClusters = NumClusters;
-        clone.NumFeatures = NumFeatures;
-        clone.IsTrained = IsTrained;
-
-        if (Labels is not null)
-        {
-            clone.Labels = new Vector<T>(Labels.Length);
-            for (int i = 0; i < Labels.Length; i++)
-                clone.Labels[i] = Labels[i];
-        }
-
-        if (ClusterCenters is not null)
-        {
-            clone.ClusterCenters = new Matrix<T>(ClusterCenters.Rows, ClusterCenters.Columns);
-            for (int i = 0; i < ClusterCenters.Rows; i++)
-                for (int j = 0; j < ClusterCenters.Columns; j++)
-                    clone.ClusterCenters[i, j] = ClusterCenters[i, j];
-        }
-
-        return clone;
-    }
-
     /// <inheritdoc />
     public override Vector<T> FitPredict(Matrix<T> x)
     {
diff --git a/src/Clustering/Density/HDBSCAN.cs b/src/Clustering/Density/HDBSCAN.cs
index 7b90f058bd..23be6f1a33 100644
--- a/src/Clustering/Density/HDBSCAN.cs
+++ b/src/Clustering/Density/HDBSCAN.cs
@@ -61,7 +61,7 @@ namespace AiDotNet.Clustering.Density;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
 [ResearchPaper("Hierarchical Density Estimates for Data Clustering, Visualization, and Outlier Detection", "https://doi.org/10.1145/2733381", Year = 2015, Authors = "Ricardo J. G. B. Campello, Davoud Moulavi, Arthur Zimek, Jorg Sander")]
-public class HDBSCAN<T> : ClusteringBase<T>
+public partial class HDBSCAN<T> : ClusteringBase<T>
 {
     private readonly HDBSCANOptions<T> _options;
 
@@ -93,56 +93,9 @@ public HDBSCAN(HDBSCANOptions<T>? options = null)
 
     /// <inheritdoc />
 
-    /// <inheritdoc />
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        return new HDBSCAN<T>(new HDBSCANOptions<T>
-        {
-            MinClusterSize = _options.MinClusterSize,
-            MinSamples = _options.MinSamples,
-            ClusterSelection = _options.ClusterSelection,
-            AllowSingleCluster = _options.AllowSingleCluster,
-            ClusterSelectionEpsilon = _options.ClusterSelectionEpsilon,
-            Alpha = _options.Alpha,
-            DistanceMetric = _options.DistanceMetric
-        });
-    }
-
     /// <inheritdoc />
     public override bool SupportsParameterInitialization => false;
 
-    /// <inheritdoc />
-    public override IFullModel<T, Matrix<T>, Vector<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IFullModel<T, Matrix<T>, Vector<T>> Clone()
-    {
-        var clone = (HDBSCAN<T>)CreateNewInstance();
-        clone._outlierScores = _outlierScores?.ToArray();
-        clone._probabilities = _probabilities?.ToArray();
-        clone._condensedTree = _condensedTree?.ToList();
-        clone.NumClusters = NumClusters;
-        clone.NumFeatures = NumFeatures;
-        clone.IsTrained = IsTrained;
-
-        if (Labels is not null)
-        {
-            clone.Labels = new Vector<T>(Labels.Length);
-            for (int i = 0; i < Labels.Length; i++)
-                clone.Labels[i] = Labels[i];
-        }
-
-        if (ClusterCenters is not null)
-        {
-            clone.ClusterCenters = new Matrix<T>(ClusterCenters.Rows, ClusterCenters.Columns);
-            for (int i = 0; i < ClusterCenters.Rows; i++)
-                for (int j = 0; j < ClusterCenters.Columns; j++)
-                    clone.ClusterCenters[i, j] = ClusterCenters[i, j];
-        }
-
-        return clone;
-    }
-
     /// <inheritdoc />
     public override IFullModel<T, Matrix<T>, Vector<T>> WithParameters(Vector<T> parameters)
     {
diff --git a/src/Clustering/Density/MeanShift.cs b/src/Clustering/Density/MeanShift.cs
index 1f9b09b3e3..be04dfb83e 100644
--- a/src/Clustering/Density/MeanShift.cs
+++ b/src/Clustering/Density/MeanShift.cs
@@ -59,7 +59,7 @@ namespace AiDotNet.Clustering.Density;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
 [ResearchPaper("Mean Shift: A Robust Approach toward Feature Space Analysis", "https://doi.org/10.1109/34.1000236", Year = 2002, Authors = "Dorin Comaniciu, Peter Meer")]
-public class MeanShift<T> : ClusteringBase<T>
+public partial class MeanShift<T> : ClusteringBase<T>
 {
     private readonly MeanShiftOptions<T> _options;
 
@@ -84,23 +84,6 @@ public MeanShift(MeanShiftOptions<T>? options = null)
 
     /// <inheritdoc />
 
-    /// <inheritdoc />
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        return new MeanShift<T>(new MeanShiftOptions<T>
-        {
-            Bandwidth = _options.Bandwidth,
-            BandwidthQuantile = _options.BandwidthQuantile,
-            ClusterMergeThreshold = _options.ClusterMergeThreshold,
-            BinSeeding = _options.BinSeeding,
-            ClusterAll = _options.ClusterAll,
-            MinBinFrequency = _options.MinBinFrequency,
-            Algorithm = _options.Algorithm,
-            LeafSize = _options.LeafSize,
-            DistanceMetric = _options.DistanceMetric
-        });
-    }
-
     /// <inheritdoc />
     public override IFullModel<T, Matrix<T>, Vector<T>> WithParameters(Vector<T> parameters)
     {
diff --git a/src/Clustering/Density/OPTICS.cs b/src/Clustering/Density/OPTICS.cs
index 8b6b65cb8b..5ed6a20f62 100644
--- a/src/Clustering/Density/OPTICS.cs
+++ b/src/Clustering/Density/OPTICS.cs
@@ -53,16 +53,21 @@ namespace AiDotNet.Clustering.Density;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
 [ResearchPaper("OPTICS: Ordering Points To Identify the Clustering Structure", "https://doi.org/10.1145/304181.304187", Year = 1999, Authors = "Mihael Ankerst, Markus M. Breunig, Hans-Peter Kriegel, Jorg Sander")]
-public class OPTICS<T> : ClusteringBase<T>
+public partial class OPTICS<T> : ClusteringBase<T>
 {
     private readonly OPTICSOptions<T> _options;
+    [AiDotNet.Attributes.FittedParameter]
     private Vector<T>? _featureMeans;
+    [AiDotNet.Attributes.FittedParameter]
     private Vector<T>? _featureStds;
+    [AiDotNet.Attributes.FittedParameter]
     private Matrix<T>? _normalizedClusterCenters;
 
     /// <inheritdoc/>
     public override ModelOptions GetOptions() => _options;
+    [AiDotNet.Attributes.FittedParameter]
     private Vector<T> _reachabilityDistances = new Vector<T>(0);
+    [AiDotNet.Attributes.FittedParameter]
     private Vector<T> _coreDistances = new Vector<T>(0);
     private int[] _ordering = Array.Empty<int>();
     private int[] _predecessor = Array.Empty<int>();
@@ -99,22 +104,6 @@ public OPTICS(OPTICSOptions<T>? options = null)
 
     /// <inheritdoc />
 
-    /// <inheritdoc />
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        return new OPTICS<T>(new OPTICSOptions<T>
-        {
-            MinSamples = _options.MinSamples,
-            MaxEpsilon = _options.MaxEpsilon,
-            ExtractionMethod = _options.ExtractionMethod,
-            Xi = _options.Xi,
-            ClusterEpsilon = _options.ClusterEpsilon,
-            Algorithm = _options.Algorithm,
-            LeafSize = _options.LeafSize,
-            DistanceMetric = _options.DistanceMetric
-        });
-    }
-
     /// <inheritdoc />
     public override IFullModel<T, Matrix<T>, Vector<T>> WithParameters(Vector<T> parameters)
     {
@@ -123,49 +112,6 @@ public override IFullModel<T, Matrix<T>, Vector<T>> WithParameters(Vector<T> par
         return newInstance;
     }
 
-    /// <inheritdoc />
-    /// <inheritdoc />
-    public override IFullModel<T, Matrix<T>, Vector<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IFullModel<T, Matrix<T>, Vector<T>> Clone()
-    {
-        var clone = (OPTICS<T>)CreateNewInstance();
-        clone._reachabilityDistances = _reachabilityDistances.Length > 0 ? Vector<T>.Wrap(_reachabilityDistances.ToArray()) : new Vector<T>(0);
-        clone._coreDistances = _coreDistances.Length > 0 ? Vector<T>.Wrap(_coreDistances.ToArray()) : new Vector<T>(0);
-        clone._ordering = _ordering?.ToArray() ?? Array.Empty<int>();
-        clone._predecessor = _predecessor?.ToArray() ?? Array.Empty<int>();
-        clone._featureMeans = _featureMeans is not null ? new Vector<T>(_featureMeans) : null;
-        clone._featureStds = _featureStds is not null ? new Vector<T>(_featureStds) : null;
-        if (_normalizedClusterCenters is not null)
-        {
-            clone._normalizedClusterCenters = new Matrix<T>(_normalizedClusterCenters.Rows, _normalizedClusterCenters.Columns);
-            for (int i = 0; i < _normalizedClusterCenters.Rows; i++)
-                for (int j = 0; j < _normalizedClusterCenters.Columns; j++)
-                    clone._normalizedClusterCenters[i, j] = _normalizedClusterCenters[i, j];
-        }
-        clone.NumClusters = NumClusters;
-        clone.NumFeatures = NumFeatures;
-        clone.IsTrained = IsTrained;
-
-        if (Labels is not null)
-        {
-            clone.Labels = new Vector<T>(Labels.Length);
-            for (int i = 0; i < Labels.Length; i++)
-                clone.Labels[i] = Labels[i];
-        }
-
-        if (ClusterCenters is not null)
-        {
-            clone.ClusterCenters = new Matrix<T>(ClusterCenters.Rows, ClusterCenters.Columns);
-            for (int i = 0; i < ClusterCenters.Rows; i++)
-                for (int j = 0; j < ClusterCenters.Columns; j++)
-                    clone.ClusterCenters[i, j] = ClusterCenters[i, j];
-        }
-
-        return clone;
-    }
-
     public override void Train(Matrix<T> x, Vector<T> y)
     {
         int n = x.Rows;
diff --git a/src/Clustering/DistanceMetrics/MahalanobisDistance.cs b/src/Clustering/DistanceMetrics/MahalanobisDistance.cs
index 0c41962643..c2cfc8f719 100644
--- a/src/Clustering/DistanceMetrics/MahalanobisDistance.cs
+++ b/src/Clustering/DistanceMetrics/MahalanobisDistance.cs
@@ -38,6 +38,7 @@ namespace AiDotNet.Clustering.DistanceMetrics;
 [PipelineStage(PipelineStage.Evaluation)]
 public class MahalanobisDistance<T> : DistanceMetricBase<T>
 {
+    [AiDotNet.Attributes.FittedParameter]
     private Matrix<T>? _inverseCovarianceMatrix;
 
     /// <summary>
diff --git a/src/Clustering/Ensemble/ConsensusClustering.cs b/src/Clustering/Ensemble/ConsensusClustering.cs
index 74d1d1a08c..7184a401ed 100644
--- a/src/Clustering/Ensemble/ConsensusClustering.cs
+++ b/src/Clustering/Ensemble/ConsensusClustering.cs
@@ -58,12 +58,13 @@ namespace AiDotNet.Clustering.Ensemble;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
 [ResearchPaper("Cluster Ensembles - A Knowledge Reuse Framework for Combining Multiple Partitions", "https://doi.org/10.1162/153244303321897735", Year = 2003, Authors = "Alexander Strehl, Joydeep Ghosh")]
-public class ConsensusClustering<T> : ClusteringBase<T>
+public partial class ConsensusClustering<T> : ClusteringBase<T>
 {
     private readonly ConsensusClusteringOptions<T> _options;
 
     /// <inheritdoc/>
     public override ModelOptions GetOptions() => _options;
+    [AiDotNet.Attributes.FittedParameter]
     private Matrix<T>? _coAssociationMatrix;
     private readonly INumericOperations<T> _numOps;
 
@@ -85,19 +86,6 @@ public ConsensusClustering(ConsensusClusteringOptions<T>? options = null)
 
     /// <inheritdoc />
 
-    /// <inheritdoc />
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        return new ConsensusClustering<T>(new ConsensusClusteringOptions<T>
-        {
-            NumBaseClusterings = _options.NumBaseClusterings,
-            Method = _options.Method,
-            FinalAlgorithm = _options.FinalAlgorithm,
-            NumClusters = _options.NumClusters,
-            Seed = _options.Seed
-        });
-    }
-
     /// <inheritdoc />
     public override IFullModel<T, Matrix<T>, Vector<T>> WithParameters(Vector<T> parameters)
     {
diff --git a/src/Clustering/Hierarchical/AgglomerativeClustering.cs b/src/Clustering/Hierarchical/AgglomerativeClustering.cs
index f542410082..eede5e181f 100644
--- a/src/Clustering/Hierarchical/AgglomerativeClustering.cs
+++ b/src/Clustering/Hierarchical/AgglomerativeClustering.cs
@@ -54,7 +54,7 @@ namespace AiDotNet.Clustering.Hierarchical;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
     [ResearchPaper("Hierarchical Grouping to Optimize an Objective Function", "https://doi.org/10.1080/01621459.1963.10500845")]
-public class AgglomerativeClustering<T> : ClusteringBase<T>
+public partial class AgglomerativeClustering<T> : ClusteringBase<T>
 {
     private readonly HierarchicalOptions<T> _options;
 
@@ -91,19 +91,6 @@ public AgglomerativeClustering(HierarchicalOptions<T>? options = null)
 
     /// <inheritdoc />
 
-    /// <inheritdoc />
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        return new AgglomerativeClustering<T>(new HierarchicalOptions<T>
-        {
-            NumClusters = _options.NumClusters,
-            Linkage = _options.Linkage,
-            DistanceThreshold = _options.DistanceThreshold,
-            ComputeFullTree = _options.ComputeFullTree,
-            DistanceMetric = _options.DistanceMetric
-        });
-    }
-
     /// <inheritdoc />
     public override IFullModel<T, Matrix<T>, Vector<T>> WithParameters(Vector<T> parameters)
     {
diff --git a/src/Clustering/Hierarchical/BIRCH.cs b/src/Clustering/Hierarchical/BIRCH.cs
index fc95fe47c2..fc5178232f 100644
--- a/src/Clustering/Hierarchical/BIRCH.cs
+++ b/src/Clustering/Hierarchical/BIRCH.cs
@@ -56,7 +56,7 @@ namespace AiDotNet.Clustering.Hierarchical;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
 [ResearchPaper("BIRCH: An Efficient Data Clustering Method for Very Large Databases", "https://doi.org/10.1145/233269.233324", Year = 1996, Authors = "Tian Zhang, Raghu Ramakrishnan, Miron Livny")]
-public class BIRCH<T> : ClusteringBase<T>
+public partial class BIRCH<T> : ClusteringBase<T>
 {
     private readonly BIRCHOptions<T> _options;
 
@@ -82,19 +82,6 @@ public BIRCH(BIRCHOptions<T>? options = null)
 
     /// <inheritdoc />
 
-    /// <inheritdoc />
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        return new BIRCH<T>(new BIRCHOptions<T>
-        {
-            Threshold = _options.Threshold,
-            BranchingFactor = _options.BranchingFactor,
-            NumClusters = _options.NumClusters,
-            ComputeLabels = _options.ComputeLabels,
-            DistanceMetric = _options.DistanceMetric
-        });
-    }
-
     /// <inheritdoc />
     public override IFullModel<T, Matrix<T>, Vector<T>> WithParameters(Vector<T> parameters)
     {
diff --git a/src/Clustering/Hierarchical/BisectingKMeans.cs b/src/Clustering/Hierarchical/BisectingKMeans.cs
index e80936503f..c01911a068 100644
--- a/src/Clustering/Hierarchical/BisectingKMeans.cs
+++ b/src/Clustering/Hierarchical/BisectingKMeans.cs
@@ -54,7 +54,7 @@ namespace AiDotNet.Clustering.Hierarchical;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
     [ResearchPaper("A Comparison of Document Clustering Techniques", "https://www.cs.cmu.edu/~dunja/KDDpapers/Steinbach_IR.pdf")]
-public class BisectingKMeans<T> : ClusteringBase<T>
+public partial class BisectingKMeans<T> : ClusteringBase<T>
 {
     private readonly BisectingKMeansOptions<T> _options;
 
@@ -86,23 +86,6 @@ public BisectingKMeans(BisectingKMeansOptions<T>? options = null)
 
     /// <inheritdoc />
 
-    /// <inheritdoc />
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        return new BisectingKMeans<T>(new BisectingKMeansOptions<T>
-        {
-            NumClusters = _options.NumClusters,
-            MaxIterations = _options.MaxIterations,
-            Tolerance = _options.Tolerance,
-            Seed = _options.Seed,
-            NumBisectionTrials = _options.NumBisectionTrials,
-            ClusterSelection = _options.ClusterSelection,
-            MinClusterSizeForBisection = _options.MinClusterSizeForBisection,
-            BuildHierarchy = _options.BuildHierarchy,
-            DistanceMetric = _options.DistanceMetric
-        });
-    }
-
     /// <inheritdoc />
     public override IFullModel<T, Matrix<T>, Vector<T>> WithParameters(Vector<T> parameters)
     {
diff --git a/src/Clustering/Hierarchical/CURE.cs b/src/Clustering/Hierarchical/CURE.cs
index ed0bed34bb..d0bc4a8b1e 100644
--- a/src/Clustering/Hierarchical/CURE.cs
+++ b/src/Clustering/Hierarchical/CURE.cs
@@ -58,7 +58,7 @@ namespace AiDotNet.Clustering.Hierarchical;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
 [ResearchPaper("CURE: An Efficient Clustering Algorithm for Large Databases", "https://doi.org/10.1145/276304.276312", Year = 1998, Authors = "Sudipto Guha, Rajeev Rastogi, Kyuseok Shim")]
-public class CURE<T> : ClusteringBase<T>
+public partial class CURE<T> : ClusteringBase<T>
 {
     private readonly CUREOptions<T> _options;
 
@@ -89,62 +89,6 @@ public CURE(CUREOptions<T>? options = null)
     /// <inheritdoc />
     public override bool SupportsParameterInitialization => false;
 
-    /// <inheritdoc />
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        return new CURE<T>(new CUREOptions<T>
-        {
-            NumClusters = _options.NumClusters,
-            MaxIterations = _options.MaxIterations,
-            Tolerance = _options.Tolerance,
-            Seed = _options.Seed,
-            NumRepresentatives = _options.NumRepresentatives,
-            ShrinkFactor = _options.ShrinkFactor,
-            SampleFraction = _options.SampleFraction,
-            UsePartitioning = _options.UsePartitioning,
-            NumPartitions = _options.NumPartitions,
-            DistanceMetric = _options.DistanceMetric
-        });
-    }
-
-    /// <inheritdoc />
-    public override IFullModel<T, Matrix<T>, Vector<T>> Clone()
-    {
-        var clone = (CURE<T>)CreateNewInstance();
-        clone.NumFeatures = NumFeatures;
-        clone.NumClusters = NumClusters;
-        clone.IsTrained = IsTrained;
-        clone.Labels = Labels is not null ? new Vector<T>(Labels) : null;
-        clone.Inertia = Inertia;
-
-        if (ClusterCenters is not null)
-        {
-            clone.ClusterCenters = new Matrix<T>(ClusterCenters.Rows, ClusterCenters.Columns);
-            for (int i = 0; i < ClusterCenters.Rows; i++)
-                for (int j = 0; j < ClusterCenters.Columns; j++)
-                    clone.ClusterCenters[i, j] = ClusterCenters[i, j];
-        }
-
-        if (_clusters is not null)
-        {
-            clone._clusters = new List<CureCluster>();
-            foreach (var cluster in _clusters)
-            {
-                clone._clusters.Add(new CureCluster
-                {
-                    Points = new List<int>(cluster.Points),
-                    Center = (T[])cluster.Center.Clone(),
-                    Representatives = cluster.Representatives.Select(r => (T[])r.Clone()).ToList()
-                });
-            }
-        }
-
-        return clone;
-    }
-
-    /// <inheritdoc />
-    public override IFullModel<T, Matrix<T>, Vector<T>> DeepCopy() => Clone();
-
     /// <inheritdoc />
     public override IFullModel<T, Matrix<T>, Vector<T>> WithParameters(Vector<T> parameters)
     {
diff --git a/src/Clustering/Neural/SelfOrganizingMap.cs b/src/Clustering/Neural/SelfOrganizingMap.cs
index 3ca3786de3..0790ab8491 100644
--- a/src/Clustering/Neural/SelfOrganizingMap.cs
+++ b/src/Clustering/Neural/SelfOrganizingMap.cs
@@ -61,7 +61,7 @@ namespace AiDotNet.Clustering.Neural;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
 [ResearchPaper("Self-Organized Formation of Topologically Correct Feature Maps", "https://doi.org/10.1007/BF00337288", Year = 1982, Authors = "Teuvo Kohonen")]
-public class SelfOrganizingMap<T> : ClusteringBase<T>
+public partial class SelfOrganizingMap<T> : ClusteringBase<T>
 {
     private readonly SOMOptions<T> _options;
 
@@ -91,63 +91,6 @@ public SelfOrganizingMap(SOMOptions<T>? options = null)
     /// </summary>
     public int[]? NeuronLabels => _neuronLabels;
 
-    /// <inheritdoc />
-
-    /// <inheritdoc />
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        return new SelfOrganizingMap<T>(new SOMOptions<T>
-        {
-            GridWidth = _options.GridWidth,
-            GridHeight = _options.GridHeight,
-            InitialLearningRate = _options.InitialLearningRate,
-            InitialNeighborhoodRadius = _options.InitialNeighborhoodRadius,
-            NeighborhoodType = _options.NeighborhoodType,
-            Topology = _options.Topology,
-            MaxIterations = _options.MaxIterations,
-            DistanceMetric = _options.DistanceMetric
-        });
-    }
-
-    /// <inheritdoc />
-    public override IFullModel<T, Matrix<T>, Vector<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IFullModel<T, Matrix<T>, Vector<T>> Clone()
-    {
-        var clone = (SelfOrganizingMap<T>)CreateNewInstance();
-        if (_weights is not null)
-        {
-            int h = _weights.GetLength(0);
-            int w = _weights.GetLength(1);
-            clone._weights = new T[h, w][];
-            for (int r = 0; r < h; r++)
-                for (int c = 0; c < w; c++)
-                    clone._weights[r, c] = (T[])_weights[r, c].Clone();
-        }
-        clone._neuronLabels = _neuronLabels?.ToArray();
-        clone.NumClusters = NumClusters;
-        clone.NumFeatures = NumFeatures;
-        clone.IsTrained = IsTrained;
-
-        if (Labels is not null)
-        {
-            clone.Labels = new Vector<T>(Labels.Length);
-            for (int i = 0; i < Labels.Length; i++)
-                clone.Labels[i] = Labels[i];
-        }
-
-        if (ClusterCenters is not null)
-        {
-            clone.ClusterCenters = new Matrix<T>(ClusterCenters.Rows, ClusterCenters.Columns);
-            for (int i = 0; i < ClusterCenters.Rows; i++)
-                for (int j = 0; j < ClusterCenters.Columns; j++)
-                    clone.ClusterCenters[i, j] = ClusterCenters[i, j];
-        }
-
-        return clone;
-    }
-
     /// <inheritdoc />
     public override IFullModel<T, Matrix<T>, Vector<T>> WithParameters(Vector<T> parameters)
     {
diff --git a/src/Clustering/Partitioning/AffinityPropagation.cs b/src/Clustering/Partitioning/AffinityPropagation.cs
index b605c51e0b..1c6c077ccf 100644
--- a/src/Clustering/Partitioning/AffinityPropagation.cs
+++ b/src/Clustering/Partitioning/AffinityPropagation.cs
@@ -53,7 +53,7 @@ namespace AiDotNet.Clustering.Partitioning;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
 [ResearchPaper("Clustering by Passing Messages Between Data Points", "https://doi.org/10.1126/science.1136800", Year = 2007, Authors = "Brendan J. Frey, Delbert Dueck")]
-public class AffinityPropagation<T> : ClusteringBase<T>
+public partial class AffinityPropagation<T> : ClusteringBase<T>
 {
     private readonly AffinityPropagationOptions<T> _options;
 
@@ -84,20 +84,6 @@ public AffinityPropagation(AffinityPropagationOptions<T>? options = null)
 
     /// <inheritdoc />
 
-    /// <inheritdoc />
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        return new AffinityPropagation<T>(new AffinityPropagationOptions<T>
-        {
-            Damping = _options.Damping,
-            Preference = _options.Preference,
-            MaxIterations = _options.MaxIterations,
-            ConvergenceIterations = _options.ConvergenceIterations,
-            AffinityType = _options.AffinityType,
-            DistanceMetric = _options.DistanceMetric
-        });
-    }
-
     /// <inheritdoc />
     public override IFullModel<T, Matrix<T>, Vector<T>> WithParameters(Vector<T> parameters)
     {
diff --git a/src/Clustering/Partitioning/CLARANS.cs b/src/Clustering/Partitioning/CLARANS.cs
index 350ee13a6c..93e0b067e2 100644
--- a/src/Clustering/Partitioning/CLARANS.cs
+++ b/src/Clustering/Partitioning/CLARANS.cs
@@ -57,7 +57,7 @@ namespace AiDotNet.Clustering.Partitioning;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
 [ResearchPaper("CLARANS: A Method for Clustering Objects for Spatial Data Mining", "https://doi.org/10.1109/69.971187", Year = 2002, Authors = "Raymond T. Ng, Jiawei Han")]
-public class CLARANS<T> : ClusteringBase<T>
+public partial class CLARANS<T> : ClusteringBase<T>
 {
     private readonly CLARANSOptions<T> _options;
 
@@ -89,18 +89,6 @@ public CLARANS(CLARANSOptions<T>? options = null)
 
     /// <inheritdoc />
 
-    /// <inheritdoc />
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        return new CLARANS<T>(new CLARANSOptions<T>
-        {
-            NumClusters = _options.NumClusters,
-            MaxNeighbor = _options.MaxNeighbor,
-            NumLocal = _options.NumLocal,
-            DistanceMetric = _options.DistanceMetric
-        });
-    }
-
     /// <inheritdoc />
     public override IFullModel<T, Matrix<T>, Vector<T>> WithParameters(Vector<T> parameters)
     {
diff --git a/src/Clustering/Partitioning/FuzzyCMeans.cs b/src/Clustering/Partitioning/FuzzyCMeans.cs
index 9757e2759b..9761111df4 100644
--- a/src/Clustering/Partitioning/FuzzyCMeans.cs
+++ b/src/Clustering/Partitioning/FuzzyCMeans.cs
@@ -55,12 +55,13 @@ namespace AiDotNet.Clustering.Partitioning;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
 [ResearchPaper("FCM: The Fuzzy c-Means Clustering Algorithm", "https://doi.org/10.1016/0098-3004(84)90020-7", Year = 1984, Authors = "James C. Bezdek, Robert Ehrlich, William Full")]
-public class FuzzyCMeans<T> : ClusteringBase<T>
+public partial class FuzzyCMeans<T> : ClusteringBase<T>
 {
     private readonly FuzzyCMeansOptions<T> _options;
 
     /// <inheritdoc/>
     public override ModelOptions GetOptions() => _options;
+    [AiDotNet.Attributes.FittedParameter]
     private Matrix<T> _membershipMatrix = new Matrix<T>(0, 0);
 
     /// <summary>
@@ -84,19 +85,6 @@ public FuzzyCMeans(FuzzyCMeansOptions<T>? options = null)
 
     /// <inheritdoc />
 
-    /// <inheritdoc />
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        return new FuzzyCMeans<T>(new FuzzyCMeansOptions<T>
-        {
-            NumClusters = _options.NumClusters,
-            Fuzziness = _options.Fuzziness,
-            MaxIterations = _options.MaxIterations,
-            Tolerance = _options.Tolerance,
-            DistanceMetric = _options.DistanceMetric
-        });
-    }
-
     /// <inheritdoc />
     public override IFullModel<T, Matrix<T>, Vector<T>> WithParameters(Vector<T> parameters)
     {
diff --git a/src/Clustering/Partitioning/KMeans.cs b/src/Clustering/Partitioning/KMeans.cs
index 571a5dc635..d8c89154fc 100644
--- a/src/Clustering/Partitioning/KMeans.cs
+++ b/src/Clustering/Partitioning/KMeans.cs
@@ -52,7 +52,7 @@ namespace AiDotNet.Clustering.Partitioning;
 [ModelComplexity(ModelComplexity.Low)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
 [ResearchPaper("Some methods for classification and analysis of multivariate observations", "https://projecteuclid.org/proceedings/berkeley-symposium-on-mathematical-statistics-and-probability/Proceedings-of-the-Fifth-Berkeley-Symposium-on-Mathematical-Statistics-and/Chapter/0/bsmsp/1200512992", Year = 1967, Authors = "James MacQueen")]
-public class KMeans<T> : ClusteringBase<T>
+public partial class KMeans<T> : ClusteringBase<T>
 {
     private readonly KMeansOptions<T> _options;
 
@@ -90,21 +90,6 @@ public KMeans(KMeansOptions<T>? options = null)
 
     /// <inheritdoc />
 
-    /// <inheritdoc />
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        return new KMeans<T>(new KMeansOptions<T>
-        {
-            NumClusters = _options.NumClusters,
-            MaxIterations = _options.MaxIterations,
-            Tolerance = _options.Tolerance,
-            Seed = _options.Seed,
-            NumInitializations = _options.NumInitializations,
-            InitMethod = _options.InitMethod,
-            DistanceMetric = _options.DistanceMetric
-        });
-    }
-
     /// <inheritdoc />
     public override IFullModel<T, Matrix<T>, Vector<T>> WithParameters(Vector<T> parameters)
     {
diff --git a/src/Clustering/Partitioning/KMedoids.cs b/src/Clustering/Partitioning/KMedoids.cs
index d8eea3540c..462e09ce70 100644
--- a/src/Clustering/Partitioning/KMedoids.cs
+++ b/src/Clustering/Partitioning/KMedoids.cs
@@ -54,7 +54,7 @@ namespace AiDotNet.Clustering.Partitioning;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
 [ResearchPaper("Finding Groups in Data: An Introduction to Cluster Analysis", "https://doi.org/10.1002/9780470316801", Year = 1990, Authors = "Leonard Kaufman, Peter J. Rousseeuw")]
-public class KMedoids<T> : ClusteringBase<T>
+public partial class KMedoids<T> : ClusteringBase<T>
 {
     private readonly KMedoidsOptions<T> _options;
 
@@ -79,19 +79,6 @@ public KMedoids(KMedoidsOptions<T>? options = null)
 
     /// <inheritdoc />
 
-    /// <inheritdoc />
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        return new KMedoids<T>(new KMedoidsOptions<T>
-        {
-            NumClusters = _options.NumClusters,
-            MaxIterations = _options.MaxIterations,
-            Init = _options.Init,
-            Algorithm = _options.Algorithm,
-            DistanceMetric = _options.DistanceMetric
-        });
-    }
-
     /// <inheritdoc />
     public override IFullModel<T, Matrix<T>, Vector<T>> WithParameters(Vector<T> parameters)
     {
diff --git a/src/Clustering/Partitioning/MiniBatchKMeans.cs b/src/Clustering/Partitioning/MiniBatchKMeans.cs
index 9fed84d3cc..560fe327e4 100644
--- a/src/Clustering/Partitioning/MiniBatchKMeans.cs
+++ b/src/Clustering/Partitioning/MiniBatchKMeans.cs
@@ -58,7 +58,7 @@ namespace AiDotNet.Clustering.Partitioning;
 [ModelComplexity(ModelComplexity.Low)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
 [ResearchPaper("Web-Scale K-Means Clustering", "https://doi.org/10.1145/1772690.1772862", Year = 2010, Authors = "David Sculley")]
-public class MiniBatchKMeans<T> : ClusteringBase<T>
+public partial class MiniBatchKMeans<T> : ClusteringBase<T>
 {
     private readonly MiniBatchKMeansOptions<T> _options;
 
@@ -97,23 +97,6 @@ public MiniBatchKMeans(MiniBatchKMeansOptions<T>? options = null)
 
     /// <inheritdoc />
 
-    /// <inheritdoc />
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        return new MiniBatchKMeans<T>(new MiniBatchKMeansOptions<T>
-        {
-            NumClusters = _options.NumClusters,
-            MaxIterations = _options.MaxIterations,
-            Tolerance = _options.Tolerance,
-            Seed = _options.Seed,
-            NumInitializations = _options.NumInitializations,
-            BatchSize = _options.BatchSize,
-            InitMethod = _options.InitMethod,
-            MaxNoImprovement = _options.MaxNoImprovement,
-            DistanceMetric = _options.DistanceMetric
-        });
-    }
-
     /// <inheritdoc />
     public override IFullModel<T, Matrix<T>, Vector<T>> WithParameters(Vector<T> parameters)
     {
diff --git a/src/Clustering/Probabilistic/GaussianMixtureModel.cs b/src/Clustering/Probabilistic/GaussianMixtureModel.cs
index 5d058192fc..ab9f4fae0b 100644
--- a/src/Clustering/Probabilistic/GaussianMixtureModel.cs
+++ b/src/Clustering/Probabilistic/GaussianMixtureModel.cs
@@ -55,15 +55,19 @@ namespace AiDotNet.Clustering.Probabilistic;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
     [ResearchPaper("Maximum Likelihood from Incomplete Data via the EM Algorithm", "https://doi.org/10.1111/j.2517-6161.1977.tb01600.x")]
-public class GaussianMixtureModel<T> : ClusteringBase<T>
+public partial class GaussianMixtureModel<T> : ClusteringBase<T>
 {
     private readonly GMMOptions<T> _options;
 
     /// <inheritdoc/>
     public override ModelOptions GetOptions() => _options;
+    [AiDotNet.Attributes.FittedParameter]
     private Vector<T>? _weights;
+    [AiDotNet.Attributes.FittedParameter]
     private Matrix<T>? _means;
+    [AiDotNet.Attributes.FittedParameter]
     private Tensor<T>? _covariances;
+    [AiDotNet.Attributes.FittedParameter]
     private Matrix<T>? _responsibilities;
     private T _lowerBound = MathHelper.GetNumericOperations<T>().Zero;
 
@@ -103,54 +107,6 @@ public GaussianMixtureModel(GMMOptions<T>? options = null)
     /// </summary>
     public T LowerBound => _lowerBound;
 
-    /// <inheritdoc />
-
-    /// <inheritdoc />
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        return new GaussianMixtureModel<T>(new GMMOptions<T>
-        {
-            NumComponents = _options.NumComponents,
-            CovarianceType = _options.CovarianceType,
-            Tolerance = _options.Tolerance,
-            MaxIterations = _options.MaxIterations,
-            NumInitializations = _options.NumInitializations,
-            InitMethod = _options.InitMethod,
-            RegularizationCovariance = _options.RegularizationCovariance
-        });
-    }
-
-    /// <inheritdoc />
-    public override IFullModel<T, Matrix<T>, Vector<T>> Clone()
-    {
-        var clone = (GaussianMixtureModel<T>)CreateNewInstance();
-        clone.NumFeatures = NumFeatures;
-        clone.NumClusters = NumClusters;
-        clone.IsTrained = IsTrained;
-        clone.Labels = Labels is not null ? new Vector<T>(Labels) : null;
-        clone.Inertia = Inertia;
-
-        if (ClusterCenters is not null)
-        {
-            clone.ClusterCenters = new Matrix<T>(ClusterCenters.Rows, ClusterCenters.Columns);
-            for (int i = 0; i < ClusterCenters.Rows; i++)
-                for (int j = 0; j < ClusterCenters.Columns; j++)
-                    clone.ClusterCenters[i, j] = ClusterCenters[i, j];
-        }
-
-        if (_weights is not null)
-            clone._weights = _weights.Clone();
-        if (_means is not null)
-            clone._means = _means.Clone();
-        if (_covariances is not null)
-            clone._covariances = _covariances.Clone();
-
-        return clone;
-    }
-
-    /// <inheritdoc />
-    public override IFullModel<T, Matrix<T>, Vector<T>> DeepCopy() => Clone();
-
     /// <inheritdoc />
     public override IFullModel<T, Matrix<T>, Vector<T>> WithParameters(Vector<T> parameters)
     {
diff --git a/src/Clustering/SemiSupervised/COPKMeans.cs b/src/Clustering/SemiSupervised/COPKMeans.cs
index df3f6c73a7..eb6e19079a 100644
--- a/src/Clustering/SemiSupervised/COPKMeans.cs
+++ b/src/Clustering/SemiSupervised/COPKMeans.cs
@@ -55,7 +55,7 @@ namespace AiDotNet.Clustering.SemiSupervised;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
 [ResearchPaper("Constrained K-means Clustering with Background Knowledge", "https://doi.org/10.1145/944919.944935", Year = 2001, Authors = "Kiri Wagstaff, Claire Cardie, Seth Rogers, Stefan Schroedl")]
-public class COPKMeans<T> : ClusteringBase<T>
+public partial class COPKMeans<T> : ClusteringBase<T>
 {
     private readonly COPKMeansOptions<T> _options;
 
@@ -86,20 +86,6 @@ public COPKMeans(COPKMeansOptions<T>? options = null)
 
     /// <inheritdoc />
 
-    /// <inheritdoc />
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        return new COPKMeans<T>(new COPKMeansOptions<T>
-        {
-            NumClusters = _options.NumClusters,
-            MustLink = _options.MustLink,
-            CannotLink = _options.CannotLink,
-            UseTransitiveClosure = _options.UseTransitiveClosure,
-            MaxIterations = _options.MaxIterations,
-            DistanceMetric = _options.DistanceMetric
-        });
-    }
-
     /// <inheritdoc />
     public override IFullModel<T, Matrix<T>, Vector<T>> WithParameters(Vector<T> parameters)
     {
diff --git a/src/Clustering/SemiSupervised/SeededKMeans.cs b/src/Clustering/SemiSupervised/SeededKMeans.cs
index f1f3797add..1a0bbd841b 100644
--- a/src/Clustering/SemiSupervised/SeededKMeans.cs
+++ b/src/Clustering/SemiSupervised/SeededKMeans.cs
@@ -60,7 +60,7 @@ namespace AiDotNet.Clustering.SemiSupervised;
 [ModelComplexity(ModelComplexity.Low)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
 [ResearchPaper("Seeded Region Growing", "https://doi.org/10.1109/34.295913", Year = 2000, Authors = "Sugato Basu, Arindam Banerjee, Raymond Mooney")]
-public class SeededKMeans<T> : ClusteringBase<T>
+public partial class SeededKMeans<T> : ClusteringBase<T>
 {
     private readonly SeededKMeansOptions<T> _options;
 
@@ -79,19 +79,6 @@ public SeededKMeans(SeededKMeansOptions<T>? options = null)
 
     /// <inheritdoc />
 
-    /// <inheritdoc />
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        return new SeededKMeans<T>(new SeededKMeansOptions<T>
-        {
-            NumClusters = _options.NumClusters,
-            Seeds = _options.Seeds,
-            ConstrainSeeds = _options.ConstrainSeeds,
-            MaxIterations = _options.MaxIterations,
-            DistanceMetric = _options.DistanceMetric
-        });
-    }
-
     /// <inheritdoc />
     public override IFullModel<T, Matrix<T>, Vector<T>> WithParameters(Vector<T> parameters)
     {
diff --git a/src/Clustering/Spectral/SpectralClustering.cs b/src/Clustering/Spectral/SpectralClustering.cs
index 8d70f58117..13f6aea79e 100644
--- a/src/Clustering/Spectral/SpectralClustering.cs
+++ b/src/Clustering/Spectral/SpectralClustering.cs
@@ -49,7 +49,7 @@ namespace AiDotNet.Clustering.Spectral;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
 [ResearchPaper("On Spectral Clustering: Analysis and an algorithm", "https://proceedings.neurips.cc/paper/2001/hash/801272ee79cfde7fa5960571fee36b9b-Abstract.html", Year = 2002, Authors = "Andrew Ng, Michael Jordan, Yair Weiss")]
-public class SpectralClustering<T> : ClusteringBase<T>
+public partial class SpectralClustering<T> : ClusteringBase<T>
 {
     private readonly SpectralOptions<T> _options;
 
@@ -81,22 +81,6 @@ public SpectralClustering(SpectralOptions<T>? options = null)
 
     /// <inheritdoc />
 
-    /// <inheritdoc />
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        return new SpectralClustering<T>(new SpectralOptions<T>
-        {
-            NumClusters = _options.NumClusters,
-            Affinity = _options.Affinity,
-            Gamma = _options.Gamma,
-            NumNeighbors = _options.NumNeighbors,
-            EigenSolver = _options.EigenSolver,
-            Normalization = _options.Normalization,
-            AssignLabels = _options.AssignLabels,
-            DistanceMetric = _options.DistanceMetric
-        });
-    }
-
     /// <inheritdoc />
     public override IFullModel<T, Matrix<T>, Vector<T>> WithParameters(Vector<T> parameters)
     {
diff --git a/src/Clustering/Streaming/MiniBatchKMeans.cs b/src/Clustering/Streaming/MiniBatchKMeans.cs
index 619c67e1a9..a4763067cd 100644
--- a/src/Clustering/Streaming/MiniBatchKMeans.cs
+++ b/src/Clustering/Streaming/MiniBatchKMeans.cs
@@ -59,7 +59,7 @@ namespace AiDotNet.Clustering.Streaming;
 [ModelComplexity(ModelComplexity.Low)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
 [ResearchPaper("Web-Scale K-Means Clustering", "https://doi.org/10.1145/1772690.1772862", Year = 2010, Authors = "David Sculley")]
-public class MiniBatchKMeans<T> : ClusteringBase<T>
+public partial class MiniBatchKMeans<T> : ClusteringBase<T>
 {
     private readonly MiniBatchKMeansOptions<T> _options;
 
@@ -89,19 +89,6 @@ public MiniBatchKMeans(MiniBatchKMeansOptions<T>? options = null)
 
     /// <inheritdoc />
 
-    /// <inheritdoc />
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        return new MiniBatchKMeans<T>(new MiniBatchKMeansOptions<T>
-        {
-            NumClusters = _options.NumClusters,
-            BatchSize = _options.BatchSize,
-            MaxNoImprovement = _options.MaxNoImprovement,
-            ReassignEmptyClusters = _options.ReassignEmptyClusters,
-            MaxIterations = _options.MaxIterations
-        });
-    }
-
     /// <inheritdoc />
     public override IFullModel<T, Matrix<T>, Vector<T>> WithParameters(Vector<T> parameters)
     {
diff --git a/src/Clustering/Streaming/OnlineKMeans.cs b/src/Clustering/Streaming/OnlineKMeans.cs
index 9cc19d793a..dbcf458727 100644
--- a/src/Clustering/Streaming/OnlineKMeans.cs
+++ b/src/Clustering/Streaming/OnlineKMeans.cs
@@ -60,7 +60,7 @@ namespace AiDotNet.Clustering.Streaming;
 [ModelComplexity(ModelComplexity.Low)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
     [ResearchPaper("Mini-Batch K-Means Clustering", "https://www.eecs.tufts.edu/~dsculley/papers/fastkmeans.pdf")]
-public class OnlineKMeans<T> : ClusteringBase<T>
+public partial class OnlineKMeans<T> : ClusteringBase<T>
 {
     private readonly OnlineKMeansOptions<T> _options;
 
@@ -90,63 +90,6 @@ public OnlineKMeans(OnlineKMeansOptions<T>? options = null)
     /// </summary>
     public double CurrentLearningRate { get; private set; }
 
-    /// <inheritdoc />
-
-    /// <inheritdoc />
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        return new OnlineKMeans<T>(new OnlineKMeansOptions<T>
-        {
-            NumClusters = _options.NumClusters,
-            LearningRate = _options.LearningRate,
-            DecayLearningRate = _options.DecayLearningRate,
-            MinLearningRate = _options.MinLearningRate,
-            MaxIterations = _options.MaxIterations,
-            DistanceMetric = _options.DistanceMetric
-        });
-    }
-
-    /// <inheritdoc />
-    public override IFullModel<T, Matrix<T>, Vector<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IFullModel<T, Matrix<T>, Vector<T>> Clone()
-    {
-        var clone = (OnlineKMeans<T>)CreateNewInstance();
-        if (_centers is not null)
-        {
-            int k = _centers.Rows;
-            int d = _centers.Columns;
-            clone._centers = new Matrix<T>(k, d);
-            for (int i = 0; i < k; i++)
-                for (int j = 0; j < d; j++)
-                    clone._centers[i, j] = _centers[i, j];
-        }
-        clone._clusterCounts = _clusterCounts?.ToArray() ?? Array.Empty<int>();
-        clone._totalPointsSeen = _totalPointsSeen;
-        clone.CurrentLearningRate = CurrentLearningRate;
-        clone.NumClusters = NumClusters;
-        clone.NumFeatures = NumFeatures;
-        clone.IsTrained = IsTrained;
-
-        if (Labels is not null)
-        {
-            clone.Labels = new Vector<T>(Labels.Length);
-            for (int i = 0; i < Labels.Length; i++)
-                clone.Labels[i] = Labels[i];
-        }
-
-        if (ClusterCenters is not null)
-        {
-            clone.ClusterCenters = new Matrix<T>(ClusterCenters.Rows, ClusterCenters.Columns);
-            for (int i = 0; i < ClusterCenters.Rows; i++)
-                for (int j = 0; j < ClusterCenters.Columns; j++)
-                    clone.ClusterCenters[i, j] = ClusterCenters[i, j];
-        }
-
-        return clone;
-    }
-
     /// <inheritdoc />
     public override IFullModel<T, Matrix<T>, Vector<T>> WithParameters(Vector<T> parameters)
     {
diff --git a/src/Clustering/Subspace/CLIQUE.cs b/src/Clustering/Subspace/CLIQUE.cs
index 1d2022f770..ec2f3e9c74 100644
--- a/src/Clustering/Subspace/CLIQUE.cs
+++ b/src/Clustering/Subspace/CLIQUE.cs
@@ -51,7 +51,7 @@ namespace AiDotNet.Clustering.Subspace;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
 [ResearchPaper("Automatic Subspace Clustering of High Dimensional Data for Data Mining Applications", "https://doi.org/10.1145/276304.276314", Year = 1998, Authors = "Rakesh Agrawal, Johannes Gehrke, Dimitrios Gunopulos, Prabhakar Raghavan")]
-public class CLIQUE<T> : ClusteringBase<T>
+public partial class CLIQUE<T> : ClusteringBase<T>
 {
     private readonly CLIQUEOptions<T> _options;
 
@@ -95,74 +95,6 @@ public CLIQUE(CLIQUEOptions<T>? options = null)
             NumUnits = c.DenseUnits.Count
         }).ToList().AsReadOnly();
 
-    /// <inheritdoc />
-
-    /// <inheritdoc />
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        return new CLIQUE<T>(new CLIQUEOptions<T>
-        {
-            MaxIterations = _options.MaxIterations,
-            Tolerance = _options.Tolerance,
-            Seed = _options.Seed,
-            NumIntervals = _options.NumIntervals,
-            DensityThreshold = _options.DensityThreshold,
-            MinPoints = _options.MinPoints,
-            MaxSubspaceDimensions = _options.MaxSubspaceDimensions,
-            UseAprioriPruning = _options.UseAprioriPruning
-        });
-    }
-
-    /// <inheritdoc />
-    public override IFullModel<T, Matrix<T>, Vector<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IFullModel<T, Matrix<T>, Vector<T>> Clone()
-    {
-        var clone = (CLIQUE<T>)CreateNewInstance();
-        clone._minBounds = _minBounds.ToArray();
-        clone._maxBounds = _maxBounds.ToArray();
-        clone._intervalWidths = _intervalWidths.ToArray();
-
-        if (_subspaceClustersInternal is not null)
-        {
-            clone._subspaceClustersInternal = _subspaceClustersInternal.Select(c => new SubspaceClusterInternal
-            {
-                ClusterId = c.ClusterId,
-                Dimensions = c.Dimensions.ToArray(),
-                DenseUnits = c.DenseUnits.Select(u => new DenseUnit
-                {
-                    Dimensions = u.Dimensions.ToArray(),
-                    Cells = u.Cells.ToArray(),
-                    Count = u.Count,
-                    Points = new List<int>(u.Points)
-                }).ToList(),
-                Points = new HashSet<int>(c.Points)
-            }).ToList();
-        }
-
-        clone.NumClusters = NumClusters;
-        clone.NumFeatures = NumFeatures;
-        clone.IsTrained = IsTrained;
-
-        if (Labels is not null)
-        {
-            clone.Labels = new Vector<T>(Labels.Length);
-            for (int i = 0; i < Labels.Length; i++)
-                clone.Labels[i] = Labels[i];
-        }
-
-        if (ClusterCenters is not null)
-        {
-            clone.ClusterCenters = new Matrix<T>(ClusterCenters.Rows, ClusterCenters.Columns);
-            for (int i = 0; i < ClusterCenters.Rows; i++)
-                for (int j = 0; j < ClusterCenters.Columns; j++)
-                    clone.ClusterCenters[i, j] = ClusterCenters[i, j];
-        }
-
-        return clone;
-    }
-
     /// <inheritdoc />
     public override IFullModel<T, Matrix<T>, Vector<T>> WithParameters(Vector<T> parameters)
     {
diff --git a/src/Clustering/Subspace/SUBCLU.cs b/src/Clustering/Subspace/SUBCLU.cs
index cdc6ba829e..1c4076a473 100644
--- a/src/Clustering/Subspace/SUBCLU.cs
+++ b/src/Clustering/Subspace/SUBCLU.cs
@@ -55,7 +55,7 @@ namespace AiDotNet.Clustering.Subspace;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
 [ResearchPaper("Density-Connected Subspace Clustering for High-Dimensional Data", "https://doi.org/10.1137/1.9781611972740.23", Year = 2004, Authors = "Karin Kailing, Hans-Peter Kriegel, Peer Kroger")]
-public class SUBCLU<T> : ClusteringBase<T>
+public partial class SUBCLU<T> : ClusteringBase<T>
 {
     private readonly SUBCLUOptions<T> _options;
     private double[]? _normMeans;
@@ -64,6 +64,7 @@ public class SUBCLU<T> : ClusteringBase<T>
     /// <inheritdoc/>
     public override ModelOptions GetOptions() => _options;
     private List<SubspaceClusterInfo>? _subspaceClusterInfos;
+    [AiDotNet.Attributes.FittedParameter]
     private Matrix<T>? _trainingData;
 
     /// <summary>
@@ -88,78 +89,6 @@ public SUBCLU(SUBCLUOptions<T>? options = null)
             NumUnits = 1
         }).ToList().AsReadOnly();
 
-    /// <inheritdoc />
-
-    /// <inheritdoc />
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        return new SUBCLU<T>(new SUBCLUOptions<T>
-        {
-            MaxIterations = _options.MaxIterations,
-            Tolerance = _options.Tolerance,
-            Seed = _options.Seed,
-            Epsilon = _options.Epsilon,
-            MinPoints = _options.MinPoints,
-            MaxSubspaceDimensions = _options.MaxSubspaceDimensions,
-            MinClusterSize = _options.MinClusterSize
-        });
-    }
-
-    /// <inheritdoc />
-    public override IFullModel<T, Matrix<T>, Vector<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IFullModel<T, Matrix<T>, Vector<T>> Clone()
-    {
-        var clone = (SUBCLU<T>)CreateNewInstance();
-
-        if (_trainingData is not null)
-        {
-            clone._trainingData = new Matrix<T>(_trainingData.Rows, _trainingData.Columns);
-            for (int i = 0; i < _trainingData.Rows; i++)
-                for (int j = 0; j < _trainingData.Columns; j++)
-                    clone._trainingData[i, j] = _trainingData[i, j];
-        }
-
-        if (_subspaceClusterInfos is not null)
-        {
-            clone._subspaceClusterInfos = _subspaceClusterInfos.Select(c => new SubspaceClusterInfo
-            {
-                ClusterId = c.ClusterId,
-                Dimensions = c.Dimensions.ToArray(),
-                Points = new HashSet<int>(c.Points),
-                CorePoints = new HashSet<int>(c.CorePoints)
-            }).ToList();
-        }
-
-        clone.NumClusters = NumClusters;
-        clone.NumFeatures = NumFeatures;
-        clone.IsTrained = IsTrained;
-
-        if (Labels is not null)
-        {
-            clone.Labels = new Vector<T>(Labels.Length);
-            for (int i = 0; i < Labels.Length; i++)
-                clone.Labels[i] = Labels[i];
-        }
-
-        if (ClusterCenters is not null)
-        {
-            clone.ClusterCenters = new Matrix<T>(ClusterCenters.Rows, ClusterCenters.Columns);
-            for (int i = 0; i < ClusterCenters.Rows; i++)
-                for (int j = 0; j < ClusterCenters.Columns; j++)
-                    clone.ClusterCenters[i, j] = ClusterCenters[i, j];
-        }
-
-        // Copy normalization state so Predict works correctly on the clone
-        if (_normMeans is not null)
-            clone._normMeans = (double[])_normMeans.Clone();
-        if (_normStds is not null)
-            clone._normStds = (double[])_normStds.Clone();
-
-        return clone;
-    }
-
     /// <inheritdoc />
     public override IFullModel<T, Matrix<T>, Vector<T>> WithParameters(Vector<T> parameters)
     {
diff --git a/src/ComputerVision/Detection/Backbones/CSPDarknet.cs b/src/ComputerVision/Detection/Backbones/CSPDarknet.cs
index e7c508eefa..4d9d7e8205 100644
--- a/src/ComputerVision/Detection/Backbones/CSPDarknet.cs
+++ b/src/ComputerVision/Detection/Backbones/CSPDarknet.cs
@@ -243,17 +243,6 @@ protected override void InitializeLayers()
         Layers.AddRange(_stages);
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer) => WriteParameters(writer);
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader) => ReadParameters(reader);
-
-    /// <inheritdoc />
-    /// <remarks>
-    /// Constructs a fresh CSPDarknet with the same depth, width multiplier, and
-    /// input-channel configuration. All internal layers are freshly allocated.
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-        => new CSPDarknet<T>(_depthOriginal, _widthMultiplier, _inChannels, _activation);
-
     public override ModelMetadata<T> GetModelMetadata() => new ModelMetadata<T>
     {
         Name = Name,
@@ -276,28 +265,6 @@ public override IFullModel<T, Tensor<T>, Tensor<T>> WithParameters(Vector<T> par
         throw new NotSupportedException(
             $"{GetType().Name}: WithParameters(Vector<T>) is unsupported on backbones.");
 
-    /// <inheritdoc />
-    /// <remarks>
-    /// Round-trips the parameter binary stream through a fresh
-    /// <see cref="CreateNewInstance"/> so internal Conv / BN layers and their
-    /// tensor buffers are independent copies — see ResNet.DeepCopy.
-    /// </remarks>
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy()
-    {
-        var copy = (CSPDarknet<T>)CreateNewInstance();
-        using var ms = new MemoryStream();
-        using (var writer = new BinaryWriter(ms, System.Text.Encoding.UTF8, leaveOpen: true))
-        {
-            WriteParameters(writer);
-        }
-        ms.Position = 0;
-        using (var reader = new BinaryReader(ms, System.Text.Encoding.UTF8, leaveOpen: true))
-        {
-            copy.ReadParameters(reader);
-        }
-        return copy;
-    }
-
     // SiLU activation moved to BackboneOps<T>.ApplySiLU — was duplicated 3 times in this file.
 }
 
@@ -350,10 +317,26 @@ internal IEnumerable<LayerBase<T>> EnumerateLayers()
     private readonly List<CSPBottleneckBlock<T>> _bottlenecks;
     private readonly IActivationFunction<T> _activation;
 
+    /// <summary>Construction state: the 'inChannels' the layer was built with.</summary>
+    private readonly int _inChannels;
+
+    /// <summary>Construction state: the 'outChannels' the layer was built with.</summary>
+    private readonly int _outChannels;
+
+    /// <summary>Construction state: the 'numBlocks' the layer was built with.</summary>
+    private readonly int _numBlocks;
+
+    /// <summary>Construction state: the 'stride' the layer was built with.</summary>
+    private readonly int _stride;
+
     public CSPBlock(int inChannels, int outChannels, int numBlocks, int stride, IActivationFunction<T> activation)
         : base(new[] { inChannels, -1, -1 }, new[] { outChannels, -1, -1 },
                (IActivationFunction<T>)new IdentityActivation<T>())
     {
+        _stride = stride;
+        _numBlocks = numBlocks;
+        _outChannels = outChannels;
+        _inChannels = inChannels;
         _activation = activation;
         int hiddenChannels = outChannels / 2;
 
@@ -531,10 +514,14 @@ internal IEnumerable<LayerBase<T>> EnumerateLayers()
     private readonly bool _add;
     private readonly IActivationFunction<T> _activation;
 
+    /// <summary>Construction state: the 'channels' the layer was built with.</summary>
+    private readonly int _channels;
+
     public CSPBottleneckBlock(int channels, IActivationFunction<T> activation, bool add = true)
         : base(new[] { channels, -1, -1 }, new[] { channels, -1, -1 },
                (IActivationFunction<T>)new IdentityActivation<T>())
     {
+        _channels = channels;
         _add = add;
         _activation = activation;
         _cv1 = new ConvolutionalLayer<T>(channels, kernelSize: 3, stride: 1, padding: 1);
diff --git a/src/ComputerVision/Detection/Backbones/EfficientNet.cs b/src/ComputerVision/Detection/Backbones/EfficientNet.cs
index 614b496d77..fac29a1646 100644
--- a/src/ComputerVision/Detection/Backbones/EfficientNet.cs
+++ b/src/ComputerVision/Detection/Backbones/EfficientNet.cs
@@ -38,28 +38,6 @@ namespace AiDotNet.ComputerVision.Detection.Backbones;
 public partial class EfficientNet<T> : NeuralNetworkBase<T>, IDetectionBackbone<T>
 {
 
-
-    /// <inheritdoc />
-    /// <remarks>
-    /// The stem convolution and every layer inside every MBConv block.
-    /// <para>
-    /// These live outside <c>Layers</c>, held in plain block objects, which is why this backbone
-    /// used to THROW from GetParameters rather than expose a flat vector -- the base walk would
-    /// have found nothing. Refusing was never right: PyTorch has no module that declines to
-    /// enumerate its parameters, and the refusal cost this model checkpointing, flat-vector
-    /// optimizers and every count-based diagnostic. Declaring the layers here gets all of it back,
-    /// and count, vector, restore and chunks fold this one declaration.
-    /// </para>
-    /// </remarks>
-    protected override IEnumerable<LayerBase<T>?> GetExtraTrainableLayers()
-    {
-        yield return _stem;
-        foreach (var block in _blocks)
-        {
-            foreach (var layer in block.EnumerateLayers()) yield return layer;
-        }
-    }
-
     private readonly ConvolutionalLayer<T> _stem;
     private readonly List<MBConvBlock<T>> _blocks;
     private readonly EfficientNetVariant _variant;
@@ -242,16 +220,6 @@ protected override Tensor<T> PredictCore(Tensor<T> input)
 
     protected override void InitializeLayers() { }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer) => WriteParameters(writer);
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader) => ReadParameters(reader);
-
-    /// <inheritdoc />
-    /// <remarks>
-    /// Constructs a fresh EfficientNet with the same variant and input-channel configuration.
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-        => new EfficientNet<T>(_variant, _inChannels, _activation);
-
     public override ModelMetadata<T> GetModelMetadata() => new ModelMetadata<T>
     {
         Name = Name,
@@ -274,28 +242,6 @@ public override IFullModel<T, Tensor<T>, Tensor<T>> WithParameters(Vector<T> par
         throw new NotSupportedException(
             $"{GetType().Name}: WithParameters(Vector<T>) is unsupported on backbones.");
 
-    /// <inheritdoc />
-    /// <remarks>
-    /// Round-trips the parameter binary stream through a fresh
-    /// <see cref="CreateNewInstance"/> so internal Conv / BN / SE blocks and
-    /// their tensor buffers are independent copies — see ResNet.DeepCopy.
-    /// </remarks>
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy()
-    {
-        var copy = (EfficientNet<T>)CreateNewInstance();
-        using var ms = new MemoryStream();
-        using (var writer = new BinaryWriter(ms, System.Text.Encoding.UTF8, leaveOpen: true))
-        {
-            WriteParameters(writer);
-        }
-        ms.Position = 0;
-        using (var reader = new BinaryReader(ms, System.Text.Encoding.UTF8, leaveOpen: true))
-        {
-            copy.ReadParameters(reader);
-        }
-        return copy;
-    }
-
     // ApplySwish moved to BackboneOps<T>.ApplySwish — was duplicated 3 times in this file.
 }
 
diff --git a/src/ComputerVision/Detection/Backbones/ResNet.cs b/src/ComputerVision/Detection/Backbones/ResNet.cs
index 86f696edfc..42b5a2446a 100644
--- a/src/ComputerVision/Detection/Backbones/ResNet.cs
+++ b/src/ComputerVision/Detection/Backbones/ResNet.cs
@@ -46,28 +46,6 @@ namespace AiDotNet.ComputerVision.Detection.Backbones;
     Direction = TensorLayoutDirection.Output, BatchOptional = true)]
 public partial class ResNet<T> : NeuralNetworkBase<T>, IDetectionBackbone<T>
 {
-
-    /// <inheritdoc />
-    /// <remarks>
-    /// The stem convolution and every layer inside every stage. These live outside <c>Layers</c>,
-    /// held in plain block objects, which is why this backbone used to THROW from GetParameters
-    /// rather than expose a flat vector -- the base walk would have found nothing.
-    /// <para>
-    /// Refusing was never right. PyTorch has no module that declines to enumerate its parameters;
-    /// parameters_to_vector over a ResNet works. The refusal was unfinished plumbing wearing the
-    /// shape of a design decision, and it cost the model checkpointing, flat-vector optimizers and
-    /// every count-based diagnostic. Declaring the layers here gets all of that back, and the count,
-    /// the vector, the restore and the chunk walk all fold this one declaration.
-    /// </para>
-    /// </remarks>
-    protected override IEnumerable<LayerBase<T>?> GetExtraTrainableLayers()
-    {
-        yield return _conv1;
-        foreach (var stage in _stages)
-        {
-            foreach (var layer in stage.EnumerateLayers()) yield return layer;
-        }
-    }
     // UpdateParameters delegated straight to SetParameters. The base does that now.
     private readonly ConvolutionalLayer<T> _conv1;
     private readonly List<ResNetStage<T>> _stages;
@@ -254,18 +232,6 @@ protected override void InitializeLayers()
         // Backbones own their per-stage layers directly; the inherited Layers list stays empty.
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer) => WriteParameters(writer);
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader) => ReadParameters(reader);
-
-    /// <inheritdoc />
-    /// <remarks>
-    /// Constructs a fresh ResNet with the same variant and input-channel configuration.
-    /// MemberwiseClone would alias internal layers and tensors, so deserialization into the
-    /// returned instance would mutate the original.
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-        => new ResNet<T>(_variant, _inChannels, _activation);
-
     public override ModelMetadata<T> GetModelMetadata() => new ModelMetadata<T>
     {
         Name = Name,
@@ -290,30 +256,6 @@ public override IFullModel<T, Tensor<T>, Tensor<T>> WithParameters(Vector<T> par
         throw new NotSupportedException(
             $"{GetType().Name}: WithParameters(Vector<T>) is unsupported on backbones. " +
             "Use ReadParameters(BinaryReader) on a fresh instance.");
-
-    /// <inheritdoc />
-    /// <remarks>
-    /// Round-trips the parameter binary stream through a fresh
-    /// <see cref="CreateNewInstance"/> so internal Conv / BN layers and their
-    /// tensor buffers are independent copies — <c>MemberwiseClone()</c> would
-    /// alias every reference type and a subsequent train step on the copy
-    /// would mutate the original's weights.
-    /// </remarks>
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy()
-    {
-        var copy = (ResNet<T>)CreateNewInstance();
-        using var ms = new MemoryStream();
-        using (var writer = new BinaryWriter(ms, System.Text.Encoding.UTF8, leaveOpen: true))
-        {
-            WriteParameters(writer);
-        }
-        ms.Position = 0;
-        using (var reader = new BinaryReader(ms, System.Text.Encoding.UTF8, leaveOpen: true))
-        {
-            copy.ReadParameters(reader);
-        }
-        return copy;
-    }
 }
 
 /// <summary>
diff --git a/src/ComputerVision/Detection/Backbones/SwinTransformer.cs b/src/ComputerVision/Detection/Backbones/SwinTransformer.cs
index 7b31ee8e60..a2c02a6a26 100644
--- a/src/ComputerVision/Detection/Backbones/SwinTransformer.cs
+++ b/src/ComputerVision/Detection/Backbones/SwinTransformer.cs
@@ -36,31 +36,9 @@ namespace AiDotNet.ComputerVision.Detection.Backbones;
     Direction = TensorLayoutDirection.Input, BatchOptional = true)]
 [TensorLayout(TensorAxis.Batch, TensorAxis.Channels, TensorAxis.Height, TensorAxis.Width,
     Direction = TensorLayoutDirection.Output, BatchOptional = true)]
-public class SwinTransformer<T> : NeuralNetworkBase<T>, IDetectionBackbone<T>
+public partial class SwinTransformer<T> : NeuralNetworkBase<T>, IDetectionBackbone<T>
 {
 
-
-    /// <inheritdoc />
-    /// <remarks>
-    /// The patch embedding and every layer inside every Swin stage. The layer norms are excluded because SwinLayerNorm is not a LayerBase and holds no trainable tensors of its own -- widening it is a separate change, not one to make silently here.
-    /// <para>
-    /// These live outside <c>Layers</c>, held in plain block objects, which is why this backbone
-    /// used to THROW from GetParameters rather than expose a flat vector -- the base walk would
-    /// have found nothing. Refusing was never right: PyTorch has no module that declines to
-    /// enumerate its parameters, and the refusal cost this model checkpointing, flat-vector
-    /// optimizers and every count-based diagnostic. Declaring the layers here gets all of it back,
-    /// and count, vector, restore and chunks fold this one declaration.
-    /// </para>
-    /// </remarks>
-    protected override IEnumerable<LayerBase<T>?> GetExtraTrainableLayers()
-    {
-        foreach (var layer in _patchEmbed.EnumerateLayers()) yield return layer;
-        foreach (var stage in _stages)
-        {
-            foreach (var layer in stage.EnumerateLayers()) yield return layer;
-        }
-    }
-
     private readonly PatchEmbeddingBlock<T> _patchEmbed;
     private readonly List<SwinStage<T>> _stages;
     private readonly SwinVariant _variant;
@@ -297,17 +275,6 @@ public override Dictionary<string, Tensor<T>> GetNamedLayerActivations(Tensor<T>
 
     protected override void InitializeLayers() { }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer) => WriteParameters(writer);
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader) => ReadParameters(reader);
-
-    /// <inheritdoc />
-    /// <remarks>
-    /// Constructs a fresh Swin Transformer with the same variant, window size, and
-    /// input-channel configuration.
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-        => new SwinTransformer<T>(_variant, _windowSize, _inChannels);
-
     public override ModelMetadata<T> GetModelMetadata() => new ModelMetadata<T>
     {
         Name = Name,
@@ -329,29 +296,6 @@ public override void Train(Tensor<T> input, Tensor<T> expectedOutput) =>
     public override IFullModel<T, Tensor<T>, Tensor<T>> WithParameters(Vector<T> parameters) =>
         throw new NotSupportedException(
             $"{GetType().Name}: WithParameters(Vector<T>) is unsupported on backbones.");
-
-    /// <inheritdoc />
-    /// <remarks>
-    /// Round-trips the parameter binary stream through a fresh
-    /// <see cref="CreateNewInstance"/> so internal patch-embedding /
-    /// transformer / patch-merging blocks and their tensor buffers are
-    /// independent copies — see ResNet.DeepCopy.
-    /// </remarks>
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy()
-    {
-        var copy = (SwinTransformer<T>)CreateNewInstance();
-        using var ms = new MemoryStream();
-        using (var writer = new BinaryWriter(ms, System.Text.Encoding.UTF8, leaveOpen: true))
-        {
-            WriteParameters(writer);
-        }
-        ms.Position = 0;
-        using (var reader = new BinaryReader(ms, System.Text.Encoding.UTF8, leaveOpen: true))
-        {
-            copy.ReadParameters(reader);
-        }
-        return copy;
-    }
 }
 
 /// <summary>
diff --git a/src/ComputerVision/Detection/Necks/BiFPN.cs b/src/ComputerVision/Detection/Necks/BiFPN.cs
index b672223978..f8a2691710 100644
--- a/src/ComputerVision/Detection/Necks/BiFPN.cs
+++ b/src/ComputerVision/Detection/Necks/BiFPN.cs
@@ -548,51 +548,6 @@ private Tensor<T> ApplySwish(Tensor<T> x)
         return result;
     }
 
-    /// <inheritdoc />
-    /// <remarks>
-    /// Produces a bit-exact deep copy by reconstructing a fresh instance with the same
-    /// input channels, output channels, and repeat count, then copying every weight
-    /// tensor element-by-element in the native <typeparamref name="T"/> domain. Avoids
-    /// the binary <c>WriteParameters</c> path because that round-trips through
-    /// <c>double</c> and is lossy for non-<c>double</c> numeric backends.
-    /// </remarks>
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy()
-    {
-        var clone = new BiFPN<T>((int[])_inputChannels.Clone(), _outputChannels, _numRepeats);
-
-        for (int i = 0; i < _lateralWeights.Count; i++)
-        {
-            CopyTensorInto(_lateralWeights[i], clone._lateralWeights[i]);
-            CopyTensorInto(_lateralBiases[i], clone._lateralBiases[i]);
-        }
-
-        // _topDownFusionWeights and _bottomUpFusionWeights are List<List<Tensor<T>>>
-        // (per-repeat × per-level slots).
-        for (int r = 0; r < _topDownFusionWeights.Count; r++)
-        {
-            for (int i = 0; i < _topDownFusionWeights[r].Count; i++)
-                CopyTensorInto(_topDownFusionWeights[r][i], clone._topDownFusionWeights[r][i]);
-        }
-        for (int r = 0; r < _bottomUpFusionWeights.Count; r++)
-        {
-            for (int i = 0; i < _bottomUpFusionWeights[r].Count; i++)
-                CopyTensorInto(_bottomUpFusionWeights[r][i], clone._bottomUpFusionWeights[r][i]);
-        }
-
-        for (int i = 0; i < _topDownConvWeights.Count; i++)
-        {
-            CopyTensorInto(_topDownConvWeights[i], clone._topDownConvWeights[i]);
-            CopyTensorInto(_topDownConvBiases[i], clone._topDownConvBiases[i]);
-        }
-        for (int i = 0; i < _bottomUpConvWeights.Count; i++)
-        {
-            CopyTensorInto(_bottomUpConvWeights[i], clone._bottomUpConvWeights[i]);
-            CopyTensorInto(_bottomUpConvBiases[i], clone._bottomUpConvBiases[i]);
-        }
-
-        return clone;
-    }
-
     /// <summary>
     /// Copies every element from <paramref name="src"/> into <paramref name="dst"/> in
     /// native <typeparamref name="T"/> arithmetic. Both tensors must share the same shape.
diff --git a/src/ComputerVision/Detection/Necks/FPN.cs b/src/ComputerVision/Detection/Necks/FPN.cs
index ff5b002c41..c9f8ede689 100644
--- a/src/ComputerVision/Detection/Necks/FPN.cs
+++ b/src/ComputerVision/Detection/Necks/FPN.cs
@@ -319,28 +319,6 @@ private Tensor<T> ApplyReLU(Tensor<T> x)
         return result;
     }
 
-    /// <inheritdoc />
-    /// <remarks>
-    /// Produces a bit-exact deep copy by reconstructing a fresh instance with the same
-    /// input/output channel configuration and copying every weight tensor element-by-element
-    /// in the native <typeparamref name="T"/> domain. Avoids the binary <c>WriteParameters</c>
-    /// path because that round-trips through <c>double</c> via
-    /// <c>NumOps.ToDouble</c>/<c>NumOps.FromDouble</c>, which is lossy for backends like
-    /// <c>decimal</c>, <c>Half</c>, or other non-<c>double</c> numeric types.
-    /// </remarks>
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy()
-    {
-        var clone = new FPN<T>((int[])_inputChannels.Clone(), _outputChannels);
-        for (int i = 0; i < _numLevels; i++)
-        {
-            CopyTensorInto(_lateralWeights[i], clone._lateralWeights[i]);
-            CopyTensorInto(_lateralBiases[i], clone._lateralBiases[i]);
-            CopyTensorInto(_outputWeights[i], clone._outputWeights[i]);
-            CopyTensorInto(_outputBiases[i], clone._outputBiases[i]);
-        }
-        return clone;
-    }
-
     /// <summary>
     /// Copies every element from <paramref name="src"/> into <paramref name="dst"/> in
     /// native <typeparamref name="T"/> arithmetic. Both tensors must share the same shape.
diff --git a/src/ComputerVision/Detection/Necks/NeckBase.cs b/src/ComputerVision/Detection/Necks/NeckBase.cs
index d99212eefc..765cc2aca3 100644
--- a/src/ComputerVision/Detection/Necks/NeckBase.cs
+++ b/src/ComputerVision/Detection/Necks/NeckBase.cs
@@ -1,4 +1,4 @@
-using System.IO;
+using System.IO;
 using AiDotNet.LossFunctions;
 using AiDotNet.Models;
 using AiDotNet.Tensors;
@@ -21,7 +21,7 @@ namespace AiDotNet.ComputerVision.Detection.Necks;
 /// - BiFPN (Bidirectional FPN): Weighted bidirectional fusion
 /// </para>
 /// </remarks>
-public abstract class NeckBase<T> : ModelBase<T, Tensor<T>, Tensor<T>>
+public abstract partial class NeckBase<T> : ModelBase<T, Tensor<T>, Tensor<T>>
 {
     // NumOps and Engine inherited from ModelBase
 
@@ -321,7 +321,7 @@ protected Tensor<T> Add(Tensor<T> a, Tensor<T> b)
     /// concrete necks (FPN, PANet, BiFPN) operate on the full backbone feature pyramid
     /// (a <see cref="List{Tensor}"/> with one tensor per level) and would fail their own
     /// feature-count validation if handed a single tensor. Use
-    /// <see cref="Forward(List{Tensor{T}})"/> directly instead — that is the public API
+    /// <see cref="Forward(List{Tensor{T}})"/> directly instead — that is the public API
     /// for running a neck.
     /// </summary>
     /// <exception cref="NotSupportedException">Always.</exception>
@@ -359,12 +359,10 @@ public override IFullModel<T, Tensor<T>, Tensor<T>> WithParameters(Vector<T> par
             "Use ReadParameters(BinaryReader) on a fresh instance.");
     }
 
-    /// <summary>
-    /// Concrete necks are responsible for producing a true deep copy of their internal
-    /// Conv2D wrappers and config. Returning <see cref="object.MemberwiseClone"/> here
-    /// would silently share tensor references, so we require an explicit override.
-    /// </summary>
-    public override abstract IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy();
+    // The re-declaration that used to sit here forced every neck to hand-write DeepCopy, on the
+    // reasoning that a memberwise copy would share tensor references. ModelBase does not do a
+    // memberwise copy: it rebuilds the neck from its recorded constructor and then reloads state
+    // through Serialize/Deserialize, so the tensors are new storage and the reason no longer holds.
 
     #endregion
 }
diff --git a/src/ComputerVision/Detection/Necks/PANet.cs b/src/ComputerVision/Detection/Necks/PANet.cs
index 83f5e78ecc..ba968c0d9e 100644
--- a/src/ComputerVision/Detection/Necks/PANet.cs
+++ b/src/ComputerVision/Detection/Necks/PANet.cs
@@ -413,36 +413,6 @@ private Tensor<T> ApplyReLU(Tensor<T> x)
         return result;
     }
 
-    /// <inheritdoc />
-    /// <remarks>
-    /// Produces a bit-exact deep copy by reconstructing a fresh instance with the same
-    /// configuration and copying every weight tensor element-by-element in the native
-    /// <typeparamref name="T"/> domain. Avoids the binary <c>WriteParameters</c> path
-    /// because that round-trips through <c>double</c> and is lossy for non-<c>double</c>
-    /// numeric backends.
-    /// </remarks>
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy()
-    {
-        var clone = new PANet<T>((int[])_inputChannels.Clone(), _outputChannels);
-        for (int i = 0; i < _numLevels; i++)
-        {
-            CopyTensorInto(_lateralWeights[i], clone._lateralWeights[i]);
-            CopyTensorInto(_lateralBiases[i], clone._lateralBiases[i]);
-            CopyTensorInto(_topDownWeights[i], clone._topDownWeights[i]);
-            CopyTensorInto(_topDownBiases[i], clone._topDownBiases[i]);
-            CopyTensorInto(_bottomUpWeights[i], clone._bottomUpWeights[i]);
-            CopyTensorInto(_bottomUpBiases[i], clone._bottomUpBiases[i]);
-        }
-        // _downsampleWeights/_downsampleBiases run only at non-bottom levels; size matches
-        // the constructor's allocation regardless of _numLevels alignment.
-        for (int i = 0; i < _downsampleWeights.Count; i++)
-        {
-            CopyTensorInto(_downsampleWeights[i], clone._downsampleWeights[i]);
-            CopyTensorInto(_downsampleBiases[i], clone._downsampleBiases[i]);
-        }
-        return clone;
-    }
-
     /// <summary>
     /// Copies every element from <paramref name="src"/> into <paramref name="dst"/> in
     /// native <typeparamref name="T"/> arithmetic. Both tensors must share the same shape.
diff --git a/src/ComputerVision/Detection/ObjectDetection/DETR/DETRDecoder.cs b/src/ComputerVision/Detection/ObjectDetection/DETR/DETRDecoder.cs
index 0a345649eb..8da82ceab5 100644
--- a/src/ComputerVision/Detection/ObjectDetection/DETR/DETRDecoder.cs
+++ b/src/ComputerVision/Detection/ObjectDetection/DETR/DETRDecoder.cs
@@ -21,7 +21,7 @@ namespace AiDotNet.ComputerVision.Detection.ObjectDetection.DETR;
 /// - FFN (feed-forward network) for each query
 /// </para>
 /// </remarks>
-internal class DETRDecoder<T>
+internal partial class DETRDecoder<T>
 {
     private readonly INumericOperations<T> _numOps;
     private readonly int _numLayers;
@@ -29,6 +29,7 @@ internal class DETRDecoder<T>
     private readonly int _numHeads;
     private readonly int _numQueries;
     private readonly List<DecoderLayer<T>> _layers;
+    [AiDotNet.Attributes.TrainableParameter]
     private readonly Tensor<T> _queryEmbed;  // Learnable query embeddings
     private readonly Dense<T> _classHead;
     private readonly Dense<T> _boxHead;
diff --git a/src/ComputerVision/Detection/ObjectDetection/ObjectDetectorBase.cs b/src/ComputerVision/Detection/ObjectDetection/ObjectDetectorBase.cs
index 61e3b73c07..417b14d2ea 100644
--- a/src/ComputerVision/Detection/ObjectDetection/ObjectDetectorBase.cs
+++ b/src/ComputerVision/Detection/ObjectDetection/ObjectDetectorBase.cs
@@ -26,7 +26,7 @@ namespace AiDotNet.ComputerVision.Detection.ObjectDetection;
 /// </para>
 /// </remarks>
 [AiDotNet.Configuration.YamlConfigurable("ObjectDetector")]
-public abstract class ObjectDetectorBase<T> : ModelBase<T, Tensor<T>, Tensor<T>>
+public abstract partial class ObjectDetectorBase<T> : ModelBase<T, Tensor<T>, Tensor<T>>
 {
     // Engine and NumOps inherited from ModelBase
 
diff --git a/src/ComputerVision/Detection/TextDetection/TextDetectorBase.cs b/src/ComputerVision/Detection/TextDetection/TextDetectorBase.cs
index aab98a22d7..63cbe4a102 100644
--- a/src/ComputerVision/Detection/TextDetection/TextDetectorBase.cs
+++ b/src/ComputerVision/Detection/TextDetection/TextDetectorBase.cs
@@ -209,7 +209,7 @@ public enum TextDetectionArchitecture
 /// Base class for text detection models.
 /// </summary>
 /// <typeparam name="T">The numeric type used for calculations.</typeparam>
-public abstract class TextDetectorBase<T> : ModelBase<T, Tensor<T>, Tensor<T>>
+public abstract partial class TextDetectorBase<T> : ModelBase<T, Tensor<T>, Tensor<T>>
 {
     // NumOps inherited from ModelBase
     protected readonly TextDetectionOptions<T> Options;
diff --git a/src/ComputerVision/OCR/EndToEnd/ABCNet.cs b/src/ComputerVision/OCR/EndToEnd/ABCNet.cs
index 078dbbd043..bc6354c497 100644
--- a/src/ComputerVision/OCR/EndToEnd/ABCNet.cs
+++ b/src/ComputerVision/OCR/EndToEnd/ABCNet.cs
@@ -74,7 +74,7 @@ namespace AiDotNet.ComputerVision.OCR.EndToEnd;
     Direction = TensorLayoutDirection.Input, BatchOptional = true)]
 [TensorLayout(TensorAxis.Batch, TensorAxis.Time, TensorAxis.Classes,
     Direction = TensorLayoutDirection.Output, BatchOptional = true)]
-public class ABCNet<T> : NeuralNetworkBase<T>, ICompositeLoss<T>
+public partial class ABCNet<T> : NeuralNetworkBase<T>, ICompositeLoss<T>
 {
     /// <summary>Coordinates the Bezier head regresses: 8 control points, (x, y) each.</summary>
     public const int BezierCoordinateCount = 16;
@@ -815,27 +815,8 @@ public static IReadOnlyList<int> CtcGreedyDecode(Tensor<T> logits)
     };
 
     /// <inheritdoc />
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        Guard.NotNull(writer);
-        writer.Write(_options.InputHeight);
-        writer.Write(_options.InputWidth);
-        writer.Write(_options.InputChannels);
-        writer.Write(_options.FeatureChannels);
-        writer.Write(_options.FeatureStride);
-        writer.Write(_options.BezierSampleHeight);
-        writer.Write(_options.BezierSampleWidth);
-        writer.Write(_options.NumCharacterClasses);
-    }
 
-    /// <inheritdoc />
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        Guard.NotNull(reader);
-        for (int i = 0; i < 8; i++) _ = reader.ReadInt32();
-    }
 
     /// <inheritdoc />
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() =>
-        new ABCNet<T>(_options, Architecture, _optimizer, _lossFunction);
+
 }
diff --git a/src/ComputerVision/OCR/EndToEnd/DocumentReader.cs b/src/ComputerVision/OCR/EndToEnd/DocumentReader.cs
index 71e6ca2548..ee4998fe53 100644
--- a/src/ComputerVision/OCR/EndToEnd/DocumentReader.cs
+++ b/src/ComputerVision/OCR/EndToEnd/DocumentReader.cs
@@ -408,10 +408,6 @@ public override IFullModel<T, Tensor<T>, Tensor<T>> WithParameters(Vector<T> par
         return copy;
     }
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy()
-        => (DocumentReader<T>)MemberwiseClone();
-
     #endregion
 }
 
diff --git a/src/ComputerVision/OCR/EndToEnd/SceneTextReader.cs b/src/ComputerVision/OCR/EndToEnd/SceneTextReader.cs
index 16f3863505..866662a38b 100644
--- a/src/ComputerVision/OCR/EndToEnd/SceneTextReader.cs
+++ b/src/ComputerVision/OCR/EndToEnd/SceneTextReader.cs
@@ -683,9 +683,5 @@ public override IFullModel<T, Tensor<T>, Tensor<T>> WithParameters(Vector<T> par
         return copy;
     }
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy()
-        => (SceneTextReader<T>)MemberwiseClone();
-
     #endregion
 }
diff --git a/src/ComputerVision/Segmentation/Common/InstanceSegmentationBase.cs b/src/ComputerVision/Segmentation/Common/InstanceSegmentationBase.cs
index eb46271db8..d0cbeec29c 100644
--- a/src/ComputerVision/Segmentation/Common/InstanceSegmentationBase.cs
+++ b/src/ComputerVision/Segmentation/Common/InstanceSegmentationBase.cs
@@ -19,7 +19,7 @@ namespace AiDotNet.ComputerVision.Segmentation.Common;
 /// Models extending this base class: YOLOv9-Seg, YOLO11-Seg, YOLOv12-Seg, YOLO26-Seg, Mask2Former, MaskDINO.
 /// </para>
 /// </remarks>
-public abstract class InstanceSegmentationBase<T> : SegmentationModelBase<T>, IInstanceSegmentation<T>
+public abstract partial class InstanceSegmentationBase<T> : SegmentationModelBase<T>, IInstanceSegmentation<T>
 {
     // protected and mutable so a derived model can read them and restore them on deserialization -
     // see the note on PanopticSegmentationBase._numStuffClasses for why private/readonly here is what
diff --git a/src/ComputerVision/Segmentation/Common/OpenVocabSegmentationBase.cs b/src/ComputerVision/Segmentation/Common/OpenVocabSegmentationBase.cs
index 45a2db18f8..8cad59d6b3 100644
--- a/src/ComputerVision/Segmentation/Common/OpenVocabSegmentationBase.cs
+++ b/src/ComputerVision/Segmentation/Common/OpenVocabSegmentationBase.cs
@@ -19,7 +19,7 @@ namespace AiDotNet.ComputerVision.Segmentation.Common;
 /// Models extending this base class: SAN, CAT-Seg, SED, Open-Vocabulary SAM, Grounded SAM 2, Mask-Adapter.
 /// </para>
 /// </remarks>
-public abstract class OpenVocabSegmentationBase<T> : SegmentationModelBase<T>, IOpenVocabSegmentation<T>
+public abstract partial class OpenVocabSegmentationBase<T> : SegmentationModelBase<T>, IOpenVocabSegmentation<T>
 {
     // protected and mutable so a derived model can read them and restore them on deserialization -
     // see PanopticSegmentationBase._numStuffClasses for why private/readonly makes a base unadoptable.
diff --git a/src/ComputerVision/Segmentation/Common/PanopticSegmentationBase.cs b/src/ComputerVision/Segmentation/Common/PanopticSegmentationBase.cs
index be9f3160c8..0b52416679 100644
--- a/src/ComputerVision/Segmentation/Common/PanopticSegmentationBase.cs
+++ b/src/ComputerVision/Segmentation/Common/PanopticSegmentationBase.cs
@@ -17,7 +17,7 @@ namespace AiDotNet.ComputerVision.Segmentation.Common;
 /// Models extending this base class: Mask2Former, kMaX-DeepLab, OneFormer, ODISE.
 /// </para>
 /// </remarks>
-public abstract class PanopticSegmentationBase<T> : SegmentationModelBase<T>, IPanopticSegmentation<T>
+public abstract partial class PanopticSegmentationBase<T> : SegmentationModelBase<T>, IPanopticSegmentation<T>
 {
     // protected, and NOT readonly, for the same reason _optimizer on SegmentationModelBase is not: a
     // base field a derived model can neither read nor restore makes the base unadoptable. XDecoder
diff --git a/src/ComputerVision/Segmentation/Common/PromptableSegmentationBase.cs b/src/ComputerVision/Segmentation/Common/PromptableSegmentationBase.cs
index 6ad9874c19..f268889530 100644
--- a/src/ComputerVision/Segmentation/Common/PromptableSegmentationBase.cs
+++ b/src/ComputerVision/Segmentation/Common/PromptableSegmentationBase.cs
@@ -18,7 +18,7 @@ namespace AiDotNet.ComputerVision.Segmentation.Common;
 /// Models extending this base class: SAM, SAM 2, SAM-HQ, SegGPT, SEEM.
 /// </para>
 /// </remarks>
-public abstract class PromptableSegmentationBase<T> : SegmentationModelBase<T>, IPromptableSegmentation<T>
+public abstract partial class PromptableSegmentationBase<T> : SegmentationModelBase<T>, IPromptableSegmentation<T>
 {
     /// <summary>
     /// Cached image embedding from the most recent SetImage call.
diff --git a/src/ComputerVision/Segmentation/Common/ReferringSegmentationBase.cs b/src/ComputerVision/Segmentation/Common/ReferringSegmentationBase.cs
index c92c1c4927..aaff7f4ebc 100644
--- a/src/ComputerVision/Segmentation/Common/ReferringSegmentationBase.cs
+++ b/src/ComputerVision/Segmentation/Common/ReferringSegmentationBase.cs
@@ -19,7 +19,7 @@ namespace AiDotNet.ComputerVision.Segmentation.Common;
 /// Models extending this base class: LISA, VideoLISA, GLaMM, OMG-LLaVA, PixelLM.
 /// </para>
 /// </remarks>
-public abstract class ReferringSegmentationBase<T> : SegmentationModelBase<T>, IReferringSegmentation<T>
+public abstract partial class ReferringSegmentationBase<T> : SegmentationModelBase<T>, IReferringSegmentation<T>
 {
     // protected and mutable so a derived model can read it and restore it on deserialization - see
     // PanopticSegmentationBase._numStuffClasses for why private/readonly makes a base unadoptable.
diff --git a/src/ComputerVision/Segmentation/Common/SegmentationModelBase.cs b/src/ComputerVision/Segmentation/Common/SegmentationModelBase.cs
index 277b5f0e7c..2cc5662d14 100644
--- a/src/ComputerVision/Segmentation/Common/SegmentationModelBase.cs
+++ b/src/ComputerVision/Segmentation/Common/SegmentationModelBase.cs
@@ -54,7 +54,7 @@ namespace AiDotNet.ComputerVision.Segmentation.Common;
 [TensorLayout(TensorAxis.Batch, TensorAxis.Classes, TensorAxis.Height, TensorAxis.Width,
     Direction = TensorLayoutDirection.Output,
     Note = "Per-class logits over a /32 feature grid; the class axis IS the channel axis of the output.")]
-public abstract class SegmentationModelBase<T> : NeuralNetworkBase<T>, ISegmentationModel<T>, IShapeContract
+public abstract partial class SegmentationModelBase<T> : NeuralNetworkBase<T>, ISegmentationModel<T>, IShapeContract
 {
     /// <summary>
     /// The output axes for a segmentation model, shared by every model in the family.
diff --git a/src/ComputerVision/Segmentation/Common/VideoSegmentationBase.cs b/src/ComputerVision/Segmentation/Common/VideoSegmentationBase.cs
index 5d0e415e59..368f859fc0 100644
--- a/src/ComputerVision/Segmentation/Common/VideoSegmentationBase.cs
+++ b/src/ComputerVision/Segmentation/Common/VideoSegmentationBase.cs
@@ -17,7 +17,7 @@ namespace AiDotNet.ComputerVision.Segmentation.Common;
 /// Models extending this base class: SAM 2, Cutie, XMem, DEVA, EfficientTAM, UniVS.
 /// </para>
 /// </remarks>
-public abstract class VideoSegmentationBase<T> : SegmentationModelBase<T>, IVideoSegmentation<T>
+public abstract partial class VideoSegmentationBase<T> : SegmentationModelBase<T>, IVideoSegmentation<T>
 {
     // protected and mutable so a derived model can read it and restore it on deserialization - see
     // PanopticSegmentationBase._numStuffClasses for why private/readonly makes a base unadoptable.
diff --git a/src/ComputerVision/Segmentation/Diffusion/DiffCutSegmentation.cs b/src/ComputerVision/Segmentation/Diffusion/DiffCutSegmentation.cs
index 71c3764aea..c978bae7a3 100644
--- a/src/ComputerVision/Segmentation/Diffusion/DiffCutSegmentation.cs
+++ b/src/ComputerVision/Segmentation/Diffusion/DiffCutSegmentation.cs
@@ -56,7 +56,7 @@ namespace AiDotNet.ComputerVision.Segmentation.Diffusion;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("DiffCut: Catalyzing Zero-Shot Semantic Segmentation with Diffusion Features and Recursive Normalized Cut", "https://arxiv.org/abs/2406.02842", Year = 2024, Authors = "Couairon et al.")]
-public class DiffCutSegmentation<T> : Common.SemanticSegmentationBase<T>
+public partial class DiffCutSegmentation<T> : Common.SemanticSegmentationBase<T>
 {
     private readonly DiffCutSegmentationOptions _options;
     public override ModelOptions GetOptions() => _options;
@@ -289,50 +289,6 @@ protected override void InitializeLayers()
         ModelData = SerializeForMetadata()
     };
 
-    /// <summary>
-    /// Writes configuration to a binary stream.
-    /// </summary>
-    /// <param name="writer">The binary writer.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Saves model configuration for later reconstruction.
-    /// </para>
-    /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    { writer.Write(_height); writer.Write(_width); writer.Write(_channels); writer.Write(_numClasses); writer.Write(_decoderDim); writer.Write(_dropRate); writer.Write(_useNativeMode); writer.Write(_onnxModelPath ?? string.Empty); writer.Write(_encoderLayerEnd); writer.Write(_channelDims.Length); foreach (int d in _channelDims) writer.Write(d); writer.Write(_depths.Length); foreach (int d in _depths) writer.Write(d); }
-
-    /// <summary>
-    /// Reads configuration from a binary stream.
-    /// </summary>
-    /// <param name="reader">The binary reader.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Loads model configuration when restoring a saved model.
-    /// </para>
-    /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    { _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadDouble(); _ = reader.ReadBoolean(); _ = reader.ReadString(); _ = reader.ReadInt32(); int dc = reader.ReadInt32(); for (int i = 0; i < dc; i++) _ = reader.ReadInt32(); int dd = reader.ReadInt32(); for (int i = 0; i < dd; i++) _ = reader.ReadInt32(); }
-
-    /// <summary>
-    /// Creates a new instance with the same configuration but fresh weights.
-    /// </summary>
-    /// <returns>A new model instance.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Creates a copy for cross-validation or ensemble training.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var clonedOptions = new DiffCutSegmentationOptions(_options);
-        return _useNativeMode
-            ? new DiffCutSegmentation<T>(Architecture, optimizer: null, lossFunction: LossFunction,
-                numClasses: _numClasses, dropRate: _dropRate, options: clonedOptions)
-            : new DiffCutSegmentation<T>(Architecture,
-                _onnxModelPath ?? throw new InvalidOperationException("ONNX model path not initialized."),
-                _numClasses, clonedOptions);
-    }
-
     // Dispose of the ONNX session and the _disposed latch are handled by SegmentationModelBase.
     // NumClasses / InputHeight / InputWidth / IsOnnxMode / Segment / GetClassMap / GetProbabilityMap
     // all arrive from SemanticSegmentationBase with identical bodies.
diff --git a/src/ComputerVision/Segmentation/Diffusion/MedSegDiffV2Segmentation.cs b/src/ComputerVision/Segmentation/Diffusion/MedSegDiffV2Segmentation.cs
index 3258e7c76c..5599ce58d1 100644
--- a/src/ComputerVision/Segmentation/Diffusion/MedSegDiffV2Segmentation.cs
+++ b/src/ComputerVision/Segmentation/Diffusion/MedSegDiffV2Segmentation.cs
@@ -58,7 +58,7 @@ namespace AiDotNet.ComputerVision.Segmentation.Diffusion;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("MedSegDiff-V2: Diffusion-based Medical Image Segmentation with Transformer", "https://arxiv.org/abs/2301.11798", Year = 2023, Authors = "Junde Wu, Wei Ji, Huazhu Fu, Min Xu, Yueming Jin, Yanwu Xu")]
-public class MedSegDiffV2Segmentation<T> : Common.MedicalSegmentationBase<T>
+public partial class MedSegDiffV2Segmentation<T> : Common.MedicalSegmentationBase<T>
 {
     private readonly MedSegDiffV2SegmentationOptions _options;
     public override ModelOptions GetOptions() => _options;
@@ -261,43 +261,6 @@ protected override void InitializeLayers()
         ModelData = SerializeForMetadata()
     };
 
-    /// <summary>
-    /// Writes configuration to a binary stream.
-    /// </summary>
-    /// <param name="writer">The binary writer.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Saves model configuration for later reconstruction.
-    /// </para>
-    /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    { writer.Write(_height); writer.Write(_width); writer.Write(_channels); writer.Write(_numClasses); writer.Write(_decoderDim); writer.Write(_dropRate); writer.Write(_useNativeMode); writer.Write(_onnxModelPath ?? string.Empty); writer.Write(_encoderLayerEnd); writer.Write(_channelDims.Length); foreach (int d in _channelDims) writer.Write(d); writer.Write(_depths.Length); foreach (int d in _depths) writer.Write(d); }
-
-    /// <summary>
-    /// Reads configuration from a binary stream.
-    /// </summary>
-    /// <param name="reader">The binary reader.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Loads model configuration when restoring a saved model.
-    /// </para>
-    /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    { _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadDouble(); _ = reader.ReadBoolean(); _ = reader.ReadString(); _ = reader.ReadInt32(); int dc = reader.ReadInt32(); for (int i = 0; i < dc; i++) _ = reader.ReadInt32(); int dd = reader.ReadInt32(); for (int i = 0; i < dd; i++) _ = reader.ReadInt32(); }
-
-    /// <summary>
-    /// Creates a new instance with the same configuration but fresh weights.
-    /// </summary>
-    /// <returns>A new model instance.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Creates a copy for cross-validation or ensemble training.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() => _useNativeMode
-        ? new MedSegDiffV2Segmentation<T>(Architecture, _optimizer, LossFunction, _numClasses, _dropRate, _options)
-        : new MedSegDiffV2Segmentation<T>(Architecture, _onnxModelPath ?? throw new InvalidOperationException("ONNX model path not initialized."), _numClasses, _options);
-
     // Dispose of the ONNX session and the _disposed latch are handled by SegmentationModelBase.
     #endregion
 
diff --git a/src/ComputerVision/Segmentation/Diffusion/ODISESegmentation.cs b/src/ComputerVision/Segmentation/Diffusion/ODISESegmentation.cs
index d8bd186861..cecaacc721 100644
--- a/src/ComputerVision/Segmentation/Diffusion/ODISESegmentation.cs
+++ b/src/ComputerVision/Segmentation/Diffusion/ODISESegmentation.cs
@@ -56,7 +56,7 @@ namespace AiDotNet.ComputerVision.Segmentation.Diffusion;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Open-Vocabulary Panoptic Segmentation with Text-to-Image Diffusion Models", "https://arxiv.org/abs/2303.04803", Year = 2023, Authors = "Xu et al.")]
-public class ODISESegmentation<T> : Common.PanopticSegmentationBase<T>
+public partial class ODISESegmentation<T> : Common.PanopticSegmentationBase<T>
 {
     private readonly ODISESegmentationOptions _options;
     public override ModelOptions GetOptions() => _options;
@@ -271,50 +271,6 @@ protected override void InitializeLayers()
         ModelData = SerializeForMetadata()
     };
 
-    /// <summary>
-    /// Writes configuration to a binary stream.
-    /// </summary>
-    /// <param name="writer">The binary writer.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Saves model configuration for later reconstruction.
-    /// </para>
-    /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    { writer.Write(_height); writer.Write(_width); writer.Write(_channels); writer.Write(_numClasses); writer.Write(_decoderDim); writer.Write(_dropRate); writer.Write(_useNativeMode); writer.Write(_onnxModelPath ?? string.Empty); writer.Write(_encoderLayerEnd); writer.Write(_channelDims.Length); foreach (int d in _channelDims) writer.Write(d); writer.Write(_depths.Length); foreach (int d in _depths) writer.Write(d); }
-
-    /// <summary>
-    /// Reads configuration from a binary stream.
-    /// </summary>
-    /// <param name="reader">The binary reader.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Loads model configuration when restoring a saved model.
-    /// </para>
-    /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    { _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadDouble(); _ = reader.ReadBoolean(); _ = reader.ReadString(); _ = reader.ReadInt32(); int dc = reader.ReadInt32(); for (int i = 0; i < dc; i++) _ = reader.ReadInt32(); int dd = reader.ReadInt32(); for (int i = 0; i < dd; i++) _ = reader.ReadInt32(); }
-
-    /// <summary>
-    /// Creates a new instance with the same configuration but fresh weights.
-    /// </summary>
-    /// <returns>A new model instance.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Creates a copy for cross-validation or ensemble training.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var options = new ODISESegmentationOptions(_options);
-        return _useNativeMode
-            ? new ODISESegmentation<T>(Architecture, optimizer: null, lossFunction: LossFunction,
-                numClasses: _numClasses, dropRate: _dropRate, options: options)
-            : new ODISESegmentation<T>(Architecture,
-                _onnxModelPath ?? throw new InvalidOperationException("ONNX model path not initialized."),
-                _numClasses, options);
-    }
-
     // Dispose of the ONNX session and the _disposed latch are handled by SegmentationModelBase.
     #endregion
 
diff --git a/src/ComputerVision/Segmentation/Efficient/EdgeSAM.cs b/src/ComputerVision/Segmentation/Efficient/EdgeSAM.cs
index 704c5de1ce..92810da8eb 100644
--- a/src/ComputerVision/Segmentation/Efficient/EdgeSAM.cs
+++ b/src/ComputerVision/Segmentation/Efficient/EdgeSAM.cs
@@ -55,7 +55,7 @@ namespace AiDotNet.ComputerVision.Segmentation.Efficient;
 [ModelComplexity(ModelComplexity.Low)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("EdgeSAM: Prompt-In-the-Loop Distillation for On-Device Deployment of SAM", "https://arxiv.org/abs/2312.06660", Year = 2024, Authors = "Chong Zhou, Xiangtai Li, Chen Change Loy, Bo Dai")]
-public class EdgeSAM<T> : Common.PromptableSegmentationBase<T>
+public partial class EdgeSAM<T> : Common.PromptableSegmentationBase<T>
 {
     private readonly EdgeSAMOptions _options;
     public override ModelOptions GetOptions() => _options;
@@ -253,43 +253,6 @@ protected override void InitializeLayers()
         ModelData = SerializeForMetadata()
     };
 
-    /// <summary>
-    /// Writes configuration to a binary stream.
-    /// </summary>
-    /// <param name="writer">The binary writer.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Saves model configuration for later reconstruction.
-    /// </para>
-    /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    { writer.Write(_height); writer.Write(_width); writer.Write(_channels); writer.Write(_numClasses); writer.Write(_decoderDim); writer.Write(_dropRate); writer.Write(_useNativeMode); writer.Write(_onnxModelPath ?? string.Empty); writer.Write(_encoderLayerEnd); writer.Write(_channelDims.Length); foreach (int d in _channelDims) writer.Write(d); writer.Write(_depths.Length); foreach (int d in _depths) writer.Write(d); }
-
-    /// <summary>
-    /// Reads configuration from a binary stream.
-    /// </summary>
-    /// <param name="reader">The binary reader.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Loads model configuration when restoring a saved model.
-    /// </para>
-    /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    { _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadDouble(); _ = reader.ReadBoolean(); _ = reader.ReadString(); _ = reader.ReadInt32(); int dc = reader.ReadInt32(); for (int i = 0; i < dc; i++) _ = reader.ReadInt32(); int dd = reader.ReadInt32(); for (int i = 0; i < dd; i++) _ = reader.ReadInt32(); }
-
-    /// <summary>
-    /// Creates a new instance with the same configuration but fresh weights.
-    /// </summary>
-    /// <returns>A new model instance.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Creates a copy for cross-validation or ensemble training.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() => _useNativeMode
-        ? new EdgeSAM<T>(Architecture, _optimizer, LossFunction, _numClasses, _dropRate, _options)
-        : new EdgeSAM<T>(Architecture, _onnxModelPath ?? throw new InvalidOperationException("ONNX model path not initialized."), _numClasses, _options);
-
     // Dispose of the ONNX session and the _disposed latch are handled by SegmentationModelBase.
     #endregion
 
diff --git a/src/ComputerVision/Segmentation/Efficient/EfficientSAM.cs b/src/ComputerVision/Segmentation/Efficient/EfficientSAM.cs
index 5c15021ca1..6f52196099 100644
--- a/src/ComputerVision/Segmentation/Efficient/EfficientSAM.cs
+++ b/src/ComputerVision/Segmentation/Efficient/EfficientSAM.cs
@@ -52,7 +52,7 @@ namespace AiDotNet.ComputerVision.Segmentation.Efficient;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("EfficientSAM: Leveraged Masked Image Pretraining for Efficient Segment Anything", "https://arxiv.org/abs/2312.00863", Year = 2024, Authors = "Yunyang Xiong, Bala Varadarajan, Lemeng Wu, Xiaoyu Xiang, Fanyi Xiao, Chenchen Zhu, Xiaoliang Dai, Dilin Wang, Fei Sun, Forrest Iandola, Raghuraman Krishnamoorthi, Vikas Chandra")]
-public class EfficientSAM<T> : Common.PromptableSegmentationBase<T>
+public partial class EfficientSAM<T> : Common.PromptableSegmentationBase<T>
 {
     private readonly EfficientSAMOptions _options;
     public override ModelOptions GetOptions() => _options;
@@ -265,43 +265,6 @@ protected override void InitializeLayers()
         ModelData = SerializeForMetadata()
     };
 
-    /// <summary>
-    /// Writes configuration to a binary stream.
-    /// </summary>
-    /// <param name="writer">The binary writer.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Saves model configuration for later reconstruction.
-    /// </para>
-    /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    { writer.Write(_height); writer.Write(_width); writer.Write(_channels); writer.Write(_numClasses); writer.Write(_decoderDim); writer.Write(_dropRate); writer.Write(_useNativeMode); writer.Write(_onnxModelPath ?? string.Empty); writer.Write(_encoderLayerEnd); writer.Write(_channelDims.Length); foreach (int d in _channelDims) writer.Write(d); writer.Write(_depths.Length); foreach (int d in _depths) writer.Write(d); }
-
-    /// <summary>
-    /// Reads configuration from a binary stream.
-    /// </summary>
-    /// <param name="reader">The binary reader.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Loads model configuration when restoring a saved model.
-    /// </para>
-    /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    { _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadDouble(); _ = reader.ReadBoolean(); _ = reader.ReadString(); _ = reader.ReadInt32(); int dc = reader.ReadInt32(); for (int i = 0; i < dc; i++) _ = reader.ReadInt32(); int dd = reader.ReadInt32(); for (int i = 0; i < dd; i++) _ = reader.ReadInt32(); }
-
-    /// <summary>
-    /// Creates a new instance with the same configuration but fresh weights.
-    /// </summary>
-    /// <returns>A new model instance.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Creates a copy for cross-validation or ensemble training.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() => _useNativeMode
-        ? new EfficientSAM<T>(Architecture, _optimizer, LossFunction, _numClasses, _dropRate, _options)
-        : new EfficientSAM<T>(Architecture, _onnxModelPath ?? throw new InvalidOperationException("ONNX model path not initialized."), _numClasses, _options);
-
     /// <summary>
     /// Releases managed resources including the ONNX inference session.
     /// </summary>
diff --git a/src/ComputerVision/Segmentation/Efficient/FastSAM.cs b/src/ComputerVision/Segmentation/Efficient/FastSAM.cs
index 8004ad5dc2..d2a9ac7ce1 100644
--- a/src/ComputerVision/Segmentation/Efficient/FastSAM.cs
+++ b/src/ComputerVision/Segmentation/Efficient/FastSAM.cs
@@ -52,7 +52,7 @@ namespace AiDotNet.ComputerVision.Segmentation.Efficient;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Fast Segment Anything", "https://arxiv.org/abs/2306.12156", Year = 2023, Authors = "Xu Zhao, Wenchao Ding, Yongqi An, Yinglong Du, Tao Yu, Min Li, Ming Tang, Jinqiao Wang")]
-public class FastSAM<T> : Common.PromptableSegmentationBase<T>
+public partial class FastSAM<T> : Common.PromptableSegmentationBase<T>
 {
     private readonly FastSAMOptions _options;
     public override ModelOptions GetOptions() => _options;
@@ -262,43 +262,6 @@ protected override void InitializeLayers()
         ModelData = SerializeForMetadata()
     };
 
-    /// <summary>
-    /// Writes configuration to a binary stream.
-    /// </summary>
-    /// <param name="writer">The binary writer.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Saves model configuration for later reconstruction.
-    /// </para>
-    /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    { writer.Write(_height); writer.Write(_width); writer.Write(_channels); writer.Write(_numClasses); writer.Write(_decoderDim); writer.Write(_dropRate); writer.Write(_useNativeMode); writer.Write(_onnxModelPath ?? string.Empty); writer.Write(_encoderLayerEnd); writer.Write(_channelDims.Length); foreach (int d in _channelDims) writer.Write(d); writer.Write(_depths.Length); foreach (int d in _depths) writer.Write(d); }
-
-    /// <summary>
-    /// Reads configuration from a binary stream.
-    /// </summary>
-    /// <param name="reader">The binary reader.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Loads model configuration when restoring a saved model.
-    /// </para>
-    /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    { _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadDouble(); _ = reader.ReadBoolean(); _ = reader.ReadString(); _ = reader.ReadInt32(); int dc = reader.ReadInt32(); for (int i = 0; i < dc; i++) _ = reader.ReadInt32(); int dd = reader.ReadInt32(); for (int i = 0; i < dd; i++) _ = reader.ReadInt32(); }
-
-    /// <summary>
-    /// Creates a new instance with the same configuration but fresh weights.
-    /// </summary>
-    /// <returns>A new model instance.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Creates a copy for cross-validation or ensemble training.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() => _useNativeMode
-        ? new FastSAM<T>(Architecture, _optimizer, LossFunction, _numClasses, _dropRate, _options)
-        : new FastSAM<T>(Architecture, _onnxModelPath ?? throw new InvalidOperationException("ONNX model path not initialized."), _numClasses, _options);
-
     /// <summary>
     /// Releases managed resources including the ONNX inference session.
     /// </summary>
diff --git a/src/ComputerVision/Segmentation/Efficient/MobileSAM.cs b/src/ComputerVision/Segmentation/Efficient/MobileSAM.cs
index f9205534f3..b3b8a7b0b9 100644
--- a/src/ComputerVision/Segmentation/Efficient/MobileSAM.cs
+++ b/src/ComputerVision/Segmentation/Efficient/MobileSAM.cs
@@ -52,7 +52,7 @@ namespace AiDotNet.ComputerVision.Segmentation.Efficient;
 [ModelComplexity(ModelComplexity.Low)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Faster Segment Anything: Towards Lightweight SAM for Mobile Applications", "https://arxiv.org/abs/2306.14289", Year = 2023, Authors = "Chaoning Zhang, Dongshen Han, Yu Qiao, Jung Uk Kim, Sung-Ho Bae, Seungkyu Lee, Choong Seon Hong")]
-public class MobileSAM<T> : Common.PromptableSegmentationBase<T>
+public partial class MobileSAM<T> : Common.PromptableSegmentationBase<T>
 {
     private readonly MobileSAMOptions _options;
     public override ModelOptions GetOptions() => _options;
@@ -251,59 +251,6 @@ protected override void InitializeLayers()
         ModelData = SerializeForMetadata()
     };
 
-    /// <summary>
-    /// Writes configuration to a binary stream.
-    /// </summary>
-    /// <param name="writer">The binary writer.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Saves model configuration for later reconstruction.
-    /// </para>
-    /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    { writer.Write(_height); writer.Write(_width); writer.Write(_channels); writer.Write(_numClasses); writer.Write(_decoderDim); writer.Write(_dropRate); writer.Write(_useNativeMode); writer.Write(_onnxModelPath ?? string.Empty); writer.Write(_encoderLayerEnd); writer.Write(_channelDims.Length); foreach (int d in _channelDims) writer.Write(d); writer.Write(_depths.Length); foreach (int d in _depths) writer.Write(d); }
-
-    /// <summary>
-    /// Reads configuration from a binary stream.
-    /// </summary>
-    /// <param name="reader">The binary reader.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Loads model configuration when restoring a saved model.
-    /// </para>
-    /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _height = reader.ReadInt32();
-        _width = reader.ReadInt32();
-        _channels = reader.ReadInt32();
-        _numClasses = reader.ReadInt32();
-        _decoderDim = reader.ReadInt32();
-        _dropRate = reader.ReadDouble();
-        _useNativeMode = reader.ReadBoolean();
-        _onnxModelPath = reader.ReadString();
-        _encoderLayerEnd = reader.ReadInt32();
-        int dc = reader.ReadInt32();
-        _channelDims = new int[dc];
-        for (int i = 0; i < dc; i++) _channelDims[i] = reader.ReadInt32();
-        int dd = reader.ReadInt32();
-        _depths = new int[dd];
-        for (int i = 0; i < dd; i++) _depths[i] = reader.ReadInt32();
-    }
-
-    /// <summary>
-    /// Creates a new instance with the same configuration but fresh weights.
-    /// </summary>
-    /// <returns>A new model instance.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Creates a copy for cross-validation or ensemble training.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() => _useNativeMode
-        ? new MobileSAM<T>(Architecture, _optimizer, LossFunction, _numClasses, _dropRate, _options)
-        : new MobileSAM<T>(Architecture, _onnxModelPath ?? throw new InvalidOperationException("ONNX model path not initialized."), _numClasses, _options);
-
     /// <summary>
     /// Releases managed resources including the ONNX inference session.
     /// </summary>
diff --git a/src/ComputerVision/Segmentation/Efficient/PIDNet.cs b/src/ComputerVision/Segmentation/Efficient/PIDNet.cs
index 38b7e9ed9b..8cea6c645d 100644
--- a/src/ComputerVision/Segmentation/Efficient/PIDNet.cs
+++ b/src/ComputerVision/Segmentation/Efficient/PIDNet.cs
@@ -57,7 +57,7 @@ namespace AiDotNet.ComputerVision.Segmentation.Efficient;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("PIDNet: A Real-time Semantic Segmentation Network Inspired by PID Controllers", "https://arxiv.org/abs/2206.02066", Year = 2023, Authors = "Jiacong Xu, Zixiang Xiong, Shankar P. Bhatt, Ravi Tandon")]
-public class PIDNet<T> : Common.SemanticSegmentationBase<T>
+public partial class PIDNet<T> : Common.SemanticSegmentationBase<T>
 {
     private readonly PIDNetOptions _options;
     public override ModelOptions GetOptions() => _options;
@@ -263,43 +263,6 @@ protected override void InitializeLayers()
         ModelData = SerializeForMetadata()
     };
 
-    /// <summary>
-    /// Writes configuration to a binary stream.
-    /// </summary>
-    /// <param name="writer">The binary writer.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Saves model configuration for later reconstruction.
-    /// </para>
-    /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    { writer.Write(_height); writer.Write(_width); writer.Write(_channels); writer.Write(_numClasses); writer.Write((int)_modelSize); writer.Write(_decoderDim); writer.Write(_dropRate); writer.Write(_useNativeMode); writer.Write(_onnxModelPath ?? string.Empty); writer.Write(_encoderLayerEnd); writer.Write(_channelDims.Length); foreach (int d in _channelDims) writer.Write(d); writer.Write(_depths.Length); foreach (int d in _depths) writer.Write(d); }
-
-    /// <summary>
-    /// Reads configuration from a binary stream.
-    /// </summary>
-    /// <param name="reader">The binary reader.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Loads model configuration when restoring a saved model.
-    /// </para>
-    /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    { _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadDouble(); _ = reader.ReadBoolean(); _ = reader.ReadString(); _ = reader.ReadInt32(); int dc = reader.ReadInt32(); for (int i = 0; i < dc; i++) _ = reader.ReadInt32(); int dd = reader.ReadInt32(); for (int i = 0; i < dd; i++) _ = reader.ReadInt32(); }
-
-    /// <summary>
-    /// Creates a new instance with the same configuration but fresh weights.
-    /// </summary>
-    /// <returns>A new model instance.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Creates a copy for cross-validation or ensemble training.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() => _useNativeMode
-        ? new PIDNet<T>(Architecture, _optimizer, LossFunction, _numClasses, _modelSize, _dropRate, _options)
-        : new PIDNet<T>(Architecture, _onnxModelPath ?? throw new InvalidOperationException("ONNX model path not initialized."), _numClasses, _modelSize, _options);
-
     // Dispose of the ONNX session and the _disposed latch are handled by SegmentationModelBase.
     // NumClasses / InputHeight / InputWidth / IsOnnxMode / Segment / GetClassMap / GetProbabilityMap
     // all arrive from SemanticSegmentationBase with identical bodies.
diff --git a/src/ComputerVision/Segmentation/Efficient/RepViTSAM.cs b/src/ComputerVision/Segmentation/Efficient/RepViTSAM.cs
index d2a3fc493e..3cdc7c9878 100644
--- a/src/ComputerVision/Segmentation/Efficient/RepViTSAM.cs
+++ b/src/ComputerVision/Segmentation/Efficient/RepViTSAM.cs
@@ -52,7 +52,7 @@ namespace AiDotNet.ComputerVision.Segmentation.Efficient;
 [ModelComplexity(ModelComplexity.Low)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("RepViT-SAM: Towards Real-Time Segmenting Anything", "https://arxiv.org/abs/2312.05760", Year = 2024, Authors = "Ao Wang, Hui Chen, Zijia Lin, Jungong Han, Guiguang Ding")]
-public class RepViTSAM<T> : Common.PromptableSegmentationBase<T>
+public partial class RepViTSAM<T> : Common.PromptableSegmentationBase<T>
 {
     private readonly RepViTSAMOptions _options;
     public override ModelOptions GetOptions() => _options;
@@ -250,43 +250,6 @@ protected override void InitializeLayers()
         ModelData = SerializeForMetadata()
     };
 
-    /// <summary>
-    /// Writes configuration to a binary stream.
-    /// </summary>
-    /// <param name="writer">The binary writer.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Saves model configuration for later reconstruction.
-    /// </para>
-    /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    { writer.Write(_height); writer.Write(_width); writer.Write(_channels); writer.Write(_numClasses); writer.Write(_decoderDim); writer.Write(_dropRate); writer.Write(_useNativeMode); writer.Write(_onnxModelPath ?? string.Empty); writer.Write(_encoderLayerEnd); writer.Write(_channelDims.Length); foreach (int d in _channelDims) writer.Write(d); writer.Write(_depths.Length); foreach (int d in _depths) writer.Write(d); }
-
-    /// <summary>
-    /// Reads configuration from a binary stream.
-    /// </summary>
-    /// <param name="reader">The binary reader.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Loads model configuration when restoring a saved model.
-    /// </para>
-    /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    { _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadDouble(); _ = reader.ReadBoolean(); _ = reader.ReadString(); _ = reader.ReadInt32(); int dc = reader.ReadInt32(); for (int i = 0; i < dc; i++) _ = reader.ReadInt32(); int dd = reader.ReadInt32(); for (int i = 0; i < dd; i++) _ = reader.ReadInt32(); }
-
-    /// <summary>
-    /// Creates a new instance with the same configuration but fresh weights.
-    /// </summary>
-    /// <returns>A new model instance.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Creates a copy for cross-validation or ensemble training.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() => _useNativeMode
-        ? new RepViTSAM<T>(Architecture, _optimizer, LossFunction, _numClasses, _dropRate, _options)
-        : new RepViTSAM<T>(Architecture, _onnxModelPath ?? throw new InvalidOperationException("ONNX model path not initialized."), _numClasses, _options);
-
     /// <summary>
     /// Releases managed resources including the ONNX inference session.
     /// </summary>
diff --git a/src/ComputerVision/Segmentation/Efficient/SlimSAM.cs b/src/ComputerVision/Segmentation/Efficient/SlimSAM.cs
index 10d5092375..5ebaf8ce27 100644
--- a/src/ComputerVision/Segmentation/Efficient/SlimSAM.cs
+++ b/src/ComputerVision/Segmentation/Efficient/SlimSAM.cs
@@ -56,7 +56,7 @@ namespace AiDotNet.ComputerVision.Segmentation.Efficient;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("SlimSAM: 0.1% Data Frees Slim Segment Anything Model", "https://arxiv.org/abs/2312.05284", Year = 2023, Authors = "Zigeng Chen, Gongfan Fang, Xinyin Ma, Xinchao Wang")]
-public class SlimSAM<T> : Common.PromptableSegmentationBase<T>
+public partial class SlimSAM<T> : Common.PromptableSegmentationBase<T>
 {
     private readonly SlimSAMOptions _options;
     public override ModelOptions GetOptions() => _options;
@@ -284,64 +284,6 @@ protected override void InitializeLayers()
         ModelData = SerializeForMetadata()
     };
 
-    /// <summary>
-    /// Writes configuration to a binary stream.
-    /// </summary>
-    /// <param name="writer">The binary writer.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Saves model configuration for later reconstruction.
-    /// </para>
-    /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    { writer.Write(_height); writer.Write(_width); writer.Write(_channels); writer.Write(_numClasses); writer.Write(_decoderDim); writer.Write(_dropRate); writer.Write(_useNativeMode); writer.Write(_onnxModelPath ?? string.Empty); writer.Write(_encoderLayerEnd); writer.Write(_channelDims.Length); foreach (int d in _channelDims) writer.Write(d); writer.Write(_depths.Length); foreach (int d in _depths) writer.Write(d); }
-
-    /// <summary>
-    /// Reads configuration from a binary stream.
-    /// </summary>
-    /// <param name="reader">The binary reader.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Loads model configuration when restoring a saved model.
-    /// </para>
-    /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _height = reader.ReadInt32();
-        _width = reader.ReadInt32();
-        _channels = reader.ReadInt32();
-        _numClasses = reader.ReadInt32();
-        _decoderDim = reader.ReadInt32();
-        _dropRate = reader.ReadDouble();
-        _useNativeMode = reader.ReadBoolean();
-        _onnxModelPath = reader.ReadString();
-        _encoderLayerEnd = reader.ReadInt32();
-        int dc = reader.ReadInt32();
-        _channelDims = new int[dc];
-        for (int i = 0; i < dc; i++) _channelDims[i] = reader.ReadInt32();
-        int dd = reader.ReadInt32();
-        _depths = new int[dd];
-        for (int i = 0; i < dd; i++) _depths[i] = reader.ReadInt32();
-    }
-
-    /// <summary>
-    /// Creates a new instance with the same configuration but fresh weights.
-    /// </summary>
-    /// <returns>A new model instance.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Creates a copy for cross-validation or ensemble training.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var options = new SlimSAMOptions(_options);
-        return _useNativeMode
-            ? new SlimSAM<T>(architecture: Architecture, optimizer: null, lossFunction: LossFunction,
-                numClasses: _numClasses, dropRate: _dropRate, options: options)
-            : new SlimSAM<T>(Architecture, _onnxModelPath ?? throw new InvalidOperationException("ONNX model path not initialized."), _numClasses, options);
-    }
-
     /// <summary>
     /// Releases managed resources including the ONNX inference session.
     /// </summary>
diff --git a/src/ComputerVision/Segmentation/Foundation/EoMT.cs b/src/ComputerVision/Segmentation/Foundation/EoMT.cs
index 16af85f3ac..d0327bb9bf 100644
--- a/src/ComputerVision/Segmentation/Foundation/EoMT.cs
+++ b/src/ComputerVision/Segmentation/Foundation/EoMT.cs
@@ -59,7 +59,7 @@ namespace AiDotNet.ComputerVision.Segmentation.Foundation;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Your ViT is Secretly an Image Segmentation Model", "https://arxiv.org/abs/2503.19108", Year = 2025, Authors = "Tommie Kerssies, Niccolò Cavagnero, Alexander Hermans, Narges Norouzi, Giuseppe Averta, Bastian Leibe, Gijs Dubbelman, Daan de Geus")]
-public class EoMT<T> : Common.PanopticSegmentationBase<T>
+public partial class EoMT<T> : Common.PanopticSegmentationBase<T>
 {
     /// <inheritdoc />
     /// <remarks>
@@ -356,62 +356,6 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    /// <summary>
-    /// Writes EoMT configuration to a binary stream.
-    /// </summary>
-    /// <param name="writer">The binary writer.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Saves model configuration for later reconstruction.
-    /// </para>
-    /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_height); writer.Write(_width); writer.Write(_channels);
-        writer.Write(_numClasses); writer.Write(_numQueries); writer.Write((int)_modelSize);
-        writer.Write(_embedDim); writer.Write(_decoderDim); writer.Write(_dropRate);
-        writer.Write(_useNativeMode); writer.Write(_onnxModelPath ?? string.Empty);
-        writer.Write(_encoderLayerEnd);
-        writer.Write(_depths.Length);
-        foreach (int depth in _depths) writer.Write(depth);
-    }
-
-    /// <summary>
-    /// Reads EoMT configuration from a binary stream.
-    /// </summary>
-    /// <param name="reader">The binary reader.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Loads model configuration when restoring a saved model.
-    /// </para>
-    /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32();
-        _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32();
-        _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadDouble();
-        _ = reader.ReadBoolean(); _ = reader.ReadString();
-        _ = reader.ReadInt32();
-        int depthCount = reader.ReadInt32();
-        for (int i = 0; i < depthCount; i++) _ = reader.ReadInt32();
-    }
-
-    /// <summary>
-    /// Creates a new EoMT instance with the same configuration but fresh weights.
-    /// </summary>
-    /// <returns>A new <see cref="EoMT{T}"/> model.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Creates a copy for cross-validation or ensemble training.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return _useNativeMode
-            ? new EoMT<T>(Architecture, _optimizer, LossFunction, _numClasses, _numQueries, _modelSize, _dropRate, _options)
-            : new EoMT<T>(Architecture, _onnxModelPath ?? throw new InvalidOperationException("ONNX model path not initialized."), _numClasses, _numQueries, _modelSize, _options);
-    }
-
     /// <summary>
     // Dispose of the ONNX session and the _disposed latch are handled by SegmentationModelBase.
 
diff --git a/src/ComputerVision/Segmentation/Foundation/Mask2Former.cs b/src/ComputerVision/Segmentation/Foundation/Mask2Former.cs
index a6dce0ef8a..2c95823bd6 100644
--- a/src/ComputerVision/Segmentation/Foundation/Mask2Former.cs
+++ b/src/ComputerVision/Segmentation/Foundation/Mask2Former.cs
@@ -62,7 +62,7 @@ namespace AiDotNet.ComputerVision.Segmentation.Foundation;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Masked-attention Mask Transformer for Universal Image Segmentation", "https://arxiv.org/abs/2112.01527", Year = 2022, Authors = "Bowen Cheng, Ishan Misra, Alexander G. Schwing, Alexander Kirillov, Rohit Girdhar")]
-public class Mask2Former<T> : Common.PanopticSegmentationBase<T>
+public partial class Mask2Former<T> : Common.PanopticSegmentationBase<T>
 {
     private readonly Mask2FormerOptions _options;
 
@@ -436,63 +436,6 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    /// <summary>
-    /// Serializes Mask2Former configuration for persistence.
-    /// </summary>
-    /// <param name="writer">Binary writer.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Saves configuration so the model can be restored later.
-    /// </para>
-    /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_height); writer.Write(_width); writer.Write(_channels);
-        writer.Write(_numClasses); writer.Write(_numQueries); writer.Write((int)_modelSize);
-        writer.Write(_decoderDim); writer.Write(_dropRate);
-        writer.Write(_useNativeMode); writer.Write(_onnxModelPath ?? string.Empty);
-        writer.Write(_encoderLayerEnd);
-        writer.Write(_channelDims.Length);
-        foreach (int c in _channelDims) writer.Write(c);
-        writer.Write(_depths.Length);
-        foreach (int d in _depths) writer.Write(d);
-    }
-
-    /// <summary>
-    /// Deserializes Mask2Former configuration.
-    /// </summary>
-    /// <param name="reader">Binary reader.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Reads saved configuration matching the write order.
-    /// </para>
-    /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32();
-        _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32();
-        _ = reader.ReadInt32(); _ = reader.ReadDouble();
-        _ = reader.ReadBoolean(); _ = reader.ReadString(); _ = reader.ReadInt32();
-        int cc = reader.ReadInt32(); for (int i = 0; i < cc; i++) _ = reader.ReadInt32();
-        int dc = reader.ReadInt32(); for (int i = 0; i < dc; i++) _ = reader.ReadInt32();
-    }
-
-    /// <summary>
-    /// Creates a new Mask2Former with same config but fresh weights.
-    /// </summary>
-    /// <returns>New model instance.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Used for cross-validation or ensemble training.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return _useNativeMode
-            ? new Mask2Former<T>(Architecture, _optimizer, LossFunction, _numClasses, _numQueries, _modelSize, _dropRate, _options)
-            : new Mask2Former<T>(Architecture, _onnxModelPath ?? throw new InvalidOperationException("ONNX model path not initialized."), _numClasses, _numQueries, _modelSize, _options);
-    }
-
     // Dispose of the ONNX session and the _disposed latch are handled by SegmentationModelBase.
 
     #endregion
diff --git a/src/ComputerVision/Segmentation/Foundation/MaskDINO.cs b/src/ComputerVision/Segmentation/Foundation/MaskDINO.cs
index 5dfa566ef8..81c2dcbe26 100644
--- a/src/ComputerVision/Segmentation/Foundation/MaskDINO.cs
+++ b/src/ComputerVision/Segmentation/Foundation/MaskDINO.cs
@@ -60,7 +60,7 @@ namespace AiDotNet.ComputerVision.Segmentation.Foundation;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Mask DINO: Towards A Unified Transformer-based Framework for Object Detection and Segmentation", "https://arxiv.org/abs/2206.02777", Year = 2023, Authors = "Feng Li, Hao Zhang, Huaizhe Xu, Shilong Liu, Lei Zhang, Lionel M. Ni, Heung-Yeung Shum")]
-public class MaskDINO<T> : Common.PanopticSegmentationBase<T>
+public partial class MaskDINO<T> : Common.PanopticSegmentationBase<T>
 {
     private readonly MaskDINOOptions _options;
 
@@ -360,66 +360,6 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    /// <summary>
-    /// Writes Mask DINO configuration to a binary stream.
-    /// </summary>
-    /// <param name="writer">The binary writer.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Saves model configuration for later reconstruction.
-    /// </para>
-    /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_height); writer.Write(_width); writer.Write(_channels);
-        writer.Write(_numClasses); writer.Write(_numQueries); writer.Write((int)_modelSize);
-        writer.Write(_decoderDim); writer.Write(_dropRate);
-        writer.Write(_useNativeMode); writer.Write(_onnxModelPath ?? string.Empty);
-        writer.Write(_encoderLayerEnd);
-        writer.Write(_channelDims.Length);
-        foreach (int dim in _channelDims) writer.Write(dim);
-        writer.Write(_depths.Length);
-        foreach (int depth in _depths) writer.Write(depth);
-    }
-
-    /// <summary>
-    /// Reads Mask DINO configuration from a binary stream.
-    /// </summary>
-    /// <param name="reader">The binary reader.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Loads model configuration when restoring a saved model.
-    /// </para>
-    /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32();
-        _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32();
-        _ = reader.ReadInt32(); _ = reader.ReadDouble();
-        _ = reader.ReadBoolean(); _ = reader.ReadString();
-        _ = reader.ReadInt32();
-        int dimCount = reader.ReadInt32();
-        for (int i = 0; i < dimCount; i++) _ = reader.ReadInt32();
-        int depthCount = reader.ReadInt32();
-        for (int i = 0; i < depthCount; i++) _ = reader.ReadInt32();
-    }
-
-    /// <summary>
-    /// Creates a new Mask DINO instance with the same configuration but fresh weights.
-    /// </summary>
-    /// <returns>A new <see cref="MaskDINO{T}"/> model.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Creates a copy for cross-validation or ensemble training.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return _useNativeMode
-            ? new MaskDINO<T>(Architecture, Optimizer, LossFunction, _numClasses, _numQueries, _modelSize, _dropRate, _options)
-            : new MaskDINO<T>(Architecture, _onnxModelPath ?? throw new InvalidOperationException("ONNX model path not initialized."), _numClasses, _numQueries, _modelSize, _options);
-    }
-
     // Dispose is inherited: SegmentationModelBase already disposes _onnxSession and sets _disposed,
     // and Mask DINO owns no further unmanaged resources.
 
diff --git a/src/ComputerVision/Segmentation/Foundation/MixedQueryTransformer.cs b/src/ComputerVision/Segmentation/Foundation/MixedQueryTransformer.cs
index eff5d8b9a6..9b3a9bf135 100644
--- a/src/ComputerVision/Segmentation/Foundation/MixedQueryTransformer.cs
+++ b/src/ComputerVision/Segmentation/Foundation/MixedQueryTransformer.cs
@@ -61,7 +61,7 @@ namespace AiDotNet.ComputerVision.Segmentation.Foundation;
     Year = 2024,
     Authors = "Pei Wang, Zhaowei Cai, Hao Yang, Ashwin Swaminathan, R. Manmatha, Stefano Soatto")]
     [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
-public class MixedQueryTransformer<T> : Common.PanopticSegmentationBase<T>
+public partial class MixedQueryTransformer<T> : Common.PanopticSegmentationBase<T>
 {
     private readonly MixedQueryTransformerOptions _options;
 
@@ -358,65 +358,6 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    /// <summary>
-    /// Writes MixedQueryTransformer configuration to a binary stream.
-    /// </summary>
-    /// <param name="writer">The binary writer.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Saves model configuration for later reconstruction.
-    /// </para>
-    /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_height); writer.Write(_width); writer.Write(_channels);
-        writer.Write(_numClasses); writer.Write(_numQueries); writer.Write((int)_modelSize);
-        writer.Write(_decoderDim); writer.Write(_dropRate);
-        writer.Write(_useNativeMode); writer.Write(_onnxModelPath ?? string.Empty);
-        writer.Write(_encoderLayerEnd);
-        writer.Write(_channelDims.Length);
-        foreach (int dim in _channelDims) writer.Write(dim);
-        writer.Write(_depths.Length);
-        foreach (int depth in _depths) writer.Write(depth);
-    }
-
-    /// <summary>
-    /// Reads MixedQueryTransformer configuration from a binary stream.
-    /// </summary>
-    /// <param name="reader">The binary reader.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Loads model configuration when restoring a saved model.
-    /// </para>
-    /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32();
-        _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32();
-        _ = reader.ReadInt32(); _ = reader.ReadDouble();
-        _ = reader.ReadBoolean(); _ = reader.ReadString(); _ = reader.ReadInt32();
-        int dimCount = reader.ReadInt32();
-        for (int i = 0; i < dimCount; i++) _ = reader.ReadInt32();
-        int depthCount = reader.ReadInt32();
-        for (int i = 0; i < depthCount; i++) _ = reader.ReadInt32();
-    }
-
-    /// <summary>
-    /// Creates a new MixedQueryTransformer instance with the same configuration but fresh weights.
-    /// </summary>
-    /// <returns>A new <see cref="MixedQueryTransformer{T}"/> model.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Creates a copy for cross-validation or ensemble training.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return _useNativeMode
-            ? new MixedQueryTransformer<T>(Architecture, Optimizer, LossFunction, _numClasses, _numQueries, _modelSize, _dropRate, _options)
-            : new MixedQueryTransformer<T>(Architecture, _onnxModelPath ?? throw new InvalidOperationException("ONNX model path not initialized."), _numClasses, _numQueries, _modelSize, _options);
-    }
-
     // Dispose is inherited: SegmentationModelBase already disposes _onnxSession and sets _disposed,
     // and MixedQueryTransformer owns no further unmanaged resources.
 
diff --git a/src/ComputerVision/Segmentation/Foundation/OMGSeg.cs b/src/ComputerVision/Segmentation/Foundation/OMGSeg.cs
index 342ee2d104..f519df44f7 100644
--- a/src/ComputerVision/Segmentation/Foundation/OMGSeg.cs
+++ b/src/ComputerVision/Segmentation/Foundation/OMGSeg.cs
@@ -59,7 +59,7 @@ namespace AiDotNet.ComputerVision.Segmentation.Foundation;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("OMG-Seg: Is One Model Good Enough For All Segmentation?", "https://arxiv.org/abs/2401.10229", Year = 2024, Authors = "Li et al.")]
-public class OMGSeg<T> : Common.PanopticSegmentationBase<T>
+public partial class OMGSeg<T> : Common.PanopticSegmentationBase<T>
 {
     private readonly OMGSegOptions _options;
 
@@ -353,66 +353,6 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    /// <summary>
-    /// Writes OMG-Seg configuration to a binary stream.
-    /// </summary>
-    /// <param name="writer">The binary writer.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Saves model configuration for later reconstruction.
-    /// </para>
-    /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_height); writer.Write(_width); writer.Write(_channels);
-        writer.Write(_numClasses); writer.Write(_numQueries); writer.Write((int)_modelSize);
-        writer.Write(_decoderDim); writer.Write(_dropRate);
-        writer.Write(_useNativeMode); writer.Write(_onnxModelPath ?? string.Empty);
-        writer.Write(_encoderLayerEnd);
-        writer.Write(_channelDims.Length);
-        foreach (int dim in _channelDims) writer.Write(dim);
-        writer.Write(_depths.Length);
-        foreach (int depth in _depths) writer.Write(depth);
-    }
-
-    /// <summary>
-    /// Reads OMG-Seg configuration from a binary stream.
-    /// </summary>
-    /// <param name="reader">The binary reader.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Loads model configuration when restoring a saved model.
-    /// </para>
-    /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32();
-        _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32();
-        _ = reader.ReadInt32(); _ = reader.ReadDouble();
-        _ = reader.ReadBoolean(); _ = reader.ReadString();
-        _ = reader.ReadInt32();
-        int dimCount = reader.ReadInt32();
-        for (int i = 0; i < dimCount; i++) _ = reader.ReadInt32();
-        int depthCount = reader.ReadInt32();
-        for (int i = 0; i < depthCount; i++) _ = reader.ReadInt32();
-    }
-
-    /// <summary>
-    /// Creates a new OMG-Seg instance with the same configuration but fresh weights.
-    /// </summary>
-    /// <returns>A new <see cref="OMGSeg{T}"/> model.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Creates a copy for cross-validation or ensemble training.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return _useNativeMode
-            ? new OMGSeg<T>(Architecture, Optimizer, LossFunction, _numClasses, _numQueries, _modelSize, _dropRate, _options)
-            : new OMGSeg<T>(Architecture, _onnxModelPath ?? throw new InvalidOperationException("ONNX model path not initialized."), _numClasses, _numQueries, _modelSize, _options);
-    }
-
     // Dispose is inherited: SegmentationModelBase already disposes _onnxSession and sets _disposed,
     // and OMG-Seg owns no further unmanaged resources.
 
diff --git a/src/ComputerVision/Segmentation/Foundation/OneFormer.cs b/src/ComputerVision/Segmentation/Foundation/OneFormer.cs
index 14e2b0b1ac..306740901a 100644
--- a/src/ComputerVision/Segmentation/Foundation/OneFormer.cs
+++ b/src/ComputerVision/Segmentation/Foundation/OneFormer.cs
@@ -65,7 +65,7 @@ namespace AiDotNet.ComputerVision.Segmentation.Foundation;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("OneFormer: One Transformer to Rule Universal Image Segmentation", "https://arxiv.org/abs/2211.06220", Year = 2023, Authors = "Jitesh Jain, Jiachen Li, MangTik Chiu, Ali Hassani, Nikita Orlov, Humphrey Shi")]
-public class OneFormer<T> : Common.PanopticSegmentationBase<T>
+public partial class OneFormer<T> : Common.PanopticSegmentationBase<T>
 {
     private readonly OneFormerOptions _options;
 
@@ -477,63 +477,6 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    /// <summary>
-    /// Serializes OneFormer configuration.
-    /// </summary>
-    /// <param name="writer">Binary writer.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Saves configuration for later restoration.
-    /// </para>
-    /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_height); writer.Write(_width); writer.Write(_channels);
-        writer.Write(_numClasses); writer.Write(_numQueries); writer.Write((int)_modelSize);
-        writer.Write(_decoderDim); writer.Write(_dropRate);
-        writer.Write(_useNativeMode); writer.Write(_onnxModelPath ?? string.Empty);
-        writer.Write(_encoderLayerEnd);
-        writer.Write(_channelDims.Length); foreach (int c in _channelDims) writer.Write(c);
-        writer.Write(_depths.Length); foreach (int d in _depths) writer.Write(d);
-    }
-
-    /// <summary>
-    /// Deserializes OneFormer configuration.
-    /// </summary>
-    /// <param name="reader">Binary reader.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Reads saved configuration in write order.
-    /// </para>
-    /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32();
-        _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32();
-        _ = reader.ReadInt32(); _ = reader.ReadDouble();
-        _ = reader.ReadBoolean(); _ = reader.ReadString(); _ = reader.ReadInt32();
-        int cc = reader.ReadInt32(); for (int i = 0; i < cc; i++) _ = reader.ReadInt32();
-        int dc = reader.ReadInt32(); for (int i = 0; i < dc; i++) _ = reader.ReadInt32();
-    }
-
-    /// <summary>
-    /// Creates a new OneFormer with same config but fresh weights.
-    /// </summary>
-    /// <returns>New model instance.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Used for cross-validation or ensemble training.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return _useNativeMode
-            ? new OneFormer<T>(Architecture, optimizer: null, lossFunction: LossFunction,
-                numClasses: _numClasses, numQueries: _numQueries, modelSize: _modelSize,
-                dropRate: _dropRate, options: new OneFormerOptions(_options))
-            : new OneFormer<T>(Architecture, _onnxModelPath ?? throw new InvalidOperationException("ONNX model path not initialized."), _numClasses, _numQueries, _modelSize, new OneFormerOptions(_options));
-    }
-
     // Dispose is inherited: SegmentationModelBase already disposes _onnxSession and sets _disposed,
     // and OneFormer owns no further unmanaged resources.
 
diff --git a/src/ComputerVision/Segmentation/Foundation/SAM.cs b/src/ComputerVision/Segmentation/Foundation/SAM.cs
index 82e08f8cb8..c3651fef13 100644
--- a/src/ComputerVision/Segmentation/Foundation/SAM.cs
+++ b/src/ComputerVision/Segmentation/Foundation/SAM.cs
@@ -61,7 +61,7 @@ namespace AiDotNet.ComputerVision.Segmentation.Foundation;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Segment Anything", "https://arxiv.org/abs/2304.02643", Year = 2023, Authors = "Alexander Kirillov, Eric Mintun, Nikhila Ravi, Hanzi Mao, Chloe Rolland, Laura Gustafson, Tete Xiao, Spencer Whitehead, Alexander C. Berg, Wan-Yen Lo, Piotr Dollár, Ross Girshick")]
-public class SAM<T> : Common.PromptableSegmentationBase<T>
+public partial class SAM<T> : Common.PromptableSegmentationBase<T>
 {
     /// <inheritdoc />
     /// <remarks>
@@ -418,62 +418,6 @@ protected override void InitializeLayers()
         ModelData = SerializeForMetadata()
     };
 
-    /// <summary>
-    /// Writes configuration to a binary stream.
-    /// </summary>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_height);
-        writer.Write(_width);
-        writer.Write(_channels);
-        writer.Write(_numClasses);
-        writer.Write((int)_modelSize);
-        writer.Write(_decoderDim);
-        writer.Write(_dropRate);
-        writer.Write(_useNativeMode);
-        writer.Write(_onnxModelPath ?? string.Empty);
-        writer.Write(_encoderLayerEnd);
-        writer.Write(_channelDims.Length);
-        foreach (int d in _channelDims) writer.Write(d);
-        writer.Write(_depths.Length);
-        foreach (int d in _depths) writer.Write(d);
-    }
-
-    /// <summary>
-    /// Reads configuration from a binary stream.
-    /// </summary>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _height = reader.ReadInt32();
-        _width = reader.ReadInt32();
-        _channels = reader.ReadInt32();
-        _numClasses = reader.ReadInt32();
-        _ = reader.ReadInt32(); // modelSize (readonly)
-        _ = reader.ReadInt32(); // decoderDim (readonly)
-        _ = reader.ReadDouble(); // dropRate (readonly)
-        _useNativeMode = reader.ReadBoolean();
-        _onnxModelPath = reader.ReadString();
-        _ = reader.ReadInt32(); // encoderLayerEnd
-        int dc = reader.ReadInt32();
-        for (int i = 0; i < dc; i++) _ = reader.ReadInt32();
-        int dd = reader.ReadInt32();
-        for (int i = 0; i < dd; i++) _ = reader.ReadInt32();
-    }
-
-    /// <summary>
-    /// Creates a new instance with the same configuration but fresh weights.
-    /// </summary>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() => _useNativeMode
-        ? new SAM<T>(
-            Architecture,
-            optimizer: null,
-            lossFunction: LossFunction,
-            numClasses: _numClasses,
-            modelSize: _modelSize,
-            dropRate: _dropRate,
-            options: new SAMOptions(_options))
-        : new SAM<T>(Architecture, _onnxModelPath ?? throw new InvalidOperationException("ONNX model path not initialized."), _numClasses, _modelSize, new SAMOptions(_options));
-
     // Dispose is inherited: SegmentationModelBase already disposes _onnxSession and sets _disposed,
     // and SAM owns no further unmanaged resources.
 
diff --git a/src/ComputerVision/Segmentation/Foundation/SAM21.cs b/src/ComputerVision/Segmentation/Foundation/SAM21.cs
index 3f7140a4b6..e3cd636572 100644
--- a/src/ComputerVision/Segmentation/Foundation/SAM21.cs
+++ b/src/ComputerVision/Segmentation/Foundation/SAM21.cs
@@ -60,7 +60,7 @@ namespace AiDotNet.ComputerVision.Segmentation.Foundation;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("SAM 2: Segment Anything in Images and Videos", "https://arxiv.org/abs/2408.00714", Year = 2024, Authors = "Nikhila Ravi, Valentin Gabeur, Yuan-Ting Hu, Ronghang Hu, Chaitanya Ryali, Tengyu Ma, Haitham Khedr, Roman Rädle, Chloe Rolland, Laura Gustafson, Eric Mintun, Junting Pan, Kalyan Vasudev Alwala, Nicolas Carion, Chao-Yuan Wu, Ross Girshick, Piotr Dollár, Christoph Feichtenhofer")]
-public class SAM21<T> : Common.PromptableSegmentationBase<T>
+public partial class SAM21<T> : Common.PromptableSegmentationBase<T>
 {
     private readonly SAM21Options _options;
 
@@ -341,57 +341,6 @@ protected override void InitializeLayers()
         ModelData = SerializeForMetadata()
     };
 
-    /// <summary>
-    /// Writes configuration to a binary stream.
-    /// </summary>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_height);
-        writer.Write(_width);
-        writer.Write(_channels);
-        writer.Write(_numClasses);
-        writer.Write((int)_modelSize);
-        writer.Write(_decoderDim);
-        writer.Write(_dropRate);
-        writer.Write(_useNativeMode);
-        writer.Write(_onnxModelPath ?? string.Empty);
-        writer.Write(_encoderLayerEnd);
-        writer.Write(_memoryBankSize);
-        writer.Write(_channelDims.Length);
-        foreach (int d in _channelDims) writer.Write(d);
-        writer.Write(_depths.Length);
-        foreach (int d in _depths) writer.Write(d);
-    }
-
-    /// <summary>
-    /// Reads configuration from a binary stream.
-    /// </summary>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _height = reader.ReadInt32();
-        _width = reader.ReadInt32();
-        _channels = reader.ReadInt32();
-        _numClasses = reader.ReadInt32();
-        _ = reader.ReadInt32(); // modelSize (readonly)
-        _ = reader.ReadInt32(); // decoderDim (readonly)
-        _ = reader.ReadDouble(); // dropRate (readonly)
-        _useNativeMode = reader.ReadBoolean();
-        _onnxModelPath = reader.ReadString();
-        _ = reader.ReadInt32(); // encoderLayerEnd
-        _ = reader.ReadInt32(); // memoryBankSize (readonly)
-        int dc = reader.ReadInt32();
-        for (int i = 0; i < dc; i++) _ = reader.ReadInt32();
-        int dd = reader.ReadInt32();
-        for (int i = 0; i < dd; i++) _ = reader.ReadInt32();
-    }
-
-    /// <summary>
-    /// Creates a new instance with the same configuration.
-    /// </summary>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() => _useNativeMode
-        ? new SAM21<T>(Architecture, Optimizer, LossFunction, _numClasses, _modelSize, _dropRate, _options)
-        : new SAM21<T>(Architecture, _onnxModelPath ?? throw new InvalidOperationException("ONNX model path not initialized."), _numClasses, _modelSize, _options);
-
     /// <summary>
     /// Releases managed resources.
     /// </summary>
diff --git a/src/ComputerVision/Segmentation/Foundation/SAMHQ.cs b/src/ComputerVision/Segmentation/Foundation/SAMHQ.cs
index eae6c6479b..ad98a27afd 100644
--- a/src/ComputerVision/Segmentation/Foundation/SAMHQ.cs
+++ b/src/ComputerVision/Segmentation/Foundation/SAMHQ.cs
@@ -60,7 +60,7 @@ namespace AiDotNet.ComputerVision.Segmentation.Foundation;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Segment Anything in High Quality", "https://arxiv.org/abs/2306.01567", Year = 2023, Authors = "Lei Ke, Mingqiao Ye, Martin Danelljan, Yifan Liu, Yu-Wing Tai, Chi-Keung Tang, Fisher Yu")]
-public class SAMHQ<T> : Common.PromptableSegmentationBase<T>
+public partial class SAMHQ<T> : Common.PromptableSegmentationBase<T>
 {
     /// <inheritdoc />
     /// <remarks>Downsamples by 16, not the family's 32 - measured: [1,3,64,64] returns [1,C,4,4].</remarks>
@@ -366,67 +366,6 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    /// <summary>
-    /// Writes SAM-HQ configuration to a binary stream.
-    /// </summary>
-    /// <param name="writer">The binary writer.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Saves model configuration for later reconstruction.
-    /// </para>
-    /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_height); writer.Write(_width); writer.Write(_channels);
-        writer.Write(_numClasses); writer.Write((int)_modelSize);
-        writer.Write(_decoderDim); writer.Write(_dropRate);
-        writer.Write(_useNativeMode); writer.Write(_onnxModelPath ?? string.Empty);
-        writer.Write(_encoderLayerEnd);
-        writer.Write(_channelDims.Length);
-        foreach (int dim in _channelDims) writer.Write(dim);
-        writer.Write(_depths.Length);
-        foreach (int depth in _depths) writer.Write(depth);
-    }
-
-    /// <summary>
-    /// Reads SAM-HQ configuration from a binary stream.
-    /// </summary>
-    /// <param name="reader">The binary reader.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Loads model configuration when restoring a saved model.
-    /// </para>
-    /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32();
-        _ = reader.ReadInt32(); _ = reader.ReadInt32();
-        _ = reader.ReadInt32(); _ = reader.ReadDouble();
-        _ = reader.ReadBoolean(); _ = reader.ReadString();
-        _ = reader.ReadInt32();
-        int dimCount = reader.ReadInt32();
-        for (int i = 0; i < dimCount; i++) _ = reader.ReadInt32();
-        int depthCount = reader.ReadInt32();
-        for (int i = 0; i < depthCount; i++) _ = reader.ReadInt32();
-    }
-
-    /// <summary>
-    /// Creates a new SAM-HQ instance with the same configuration but fresh weights.
-    /// </summary>
-    /// <returns>A new <see cref="SAMHQ{T}"/> model with reinitialized weights.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Creates a copy of the model's configuration with fresh random weights.
-    /// Used for cross-validation and ensemble training.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return _useNativeMode
-            ? new SAMHQ<T>(Architecture, Optimizer, LossFunction, _numClasses, _modelSize, _dropRate, _options)
-            : new SAMHQ<T>(Architecture, _onnxModelPath ?? throw new InvalidOperationException("ONNX model path not initialized."), _numClasses, _modelSize, _options);
-    }
-
     // Dispose is inherited: SegmentationModelBase already disposes _onnxSession and sets _disposed,
     // and SAM-HQ owns no further unmanaged resources.
 
diff --git a/src/ComputerVision/Segmentation/Foundation/U2Seg.cs b/src/ComputerVision/Segmentation/Foundation/U2Seg.cs
index 2e02fcff28..5d67ae5f25 100644
--- a/src/ComputerVision/Segmentation/Foundation/U2Seg.cs
+++ b/src/ComputerVision/Segmentation/Foundation/U2Seg.cs
@@ -58,7 +58,7 @@ namespace AiDotNet.ComputerVision.Segmentation.Foundation;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Unsupervised Universal Image Segmentation", "https://arxiv.org/abs/2312.17243", Year = 2024, Authors = "Dantong Niu, Xudong Wang, Xinyang Han, Long Lian, Roei Herzig, Trevor Darrell")]
-public class U2Seg<T> : Common.PanopticSegmentationBase<T>
+public partial class U2Seg<T> : Common.PanopticSegmentationBase<T>
 {
     private readonly U2SegOptions _options;
 
@@ -317,63 +317,6 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    /// <summary>
-    /// Writes U2Seg configuration to a binary stream.
-    /// </summary>
-    /// <param name="writer">The binary writer.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Saves model configuration for later reconstruction.
-    /// </para>
-    /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_height); writer.Write(_width); writer.Write(_channels);
-        writer.Write(_numClasses); writer.Write(_decoderDim); writer.Write(_dropRate);
-        writer.Write(_useNativeMode); writer.Write(_onnxModelPath ?? string.Empty);
-        writer.Write(_encoderLayerEnd);
-        writer.Write(_channelDims.Length);
-        foreach (int dim in _channelDims) writer.Write(dim);
-        writer.Write(_depths.Length);
-        foreach (int depth in _depths) writer.Write(depth);
-    }
-
-    /// <summary>
-    /// Reads U2Seg configuration from a binary stream.
-    /// </summary>
-    /// <param name="reader">The binary reader.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Loads model configuration when restoring a saved model.
-    /// </para>
-    /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32();
-        _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadDouble();
-        _ = reader.ReadBoolean(); _ = reader.ReadString(); _ = reader.ReadInt32();
-        int dimCount = reader.ReadInt32();
-        for (int i = 0; i < dimCount; i++) _ = reader.ReadInt32();
-        int depthCount = reader.ReadInt32();
-        for (int i = 0; i < depthCount; i++) _ = reader.ReadInt32();
-    }
-
-    /// <summary>
-    /// Creates a new U2Seg instance with the same configuration but fresh weights.
-    /// </summary>
-    /// <returns>A new <see cref="U2Seg{T}"/> model.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Creates a copy for cross-validation or ensemble training.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return _useNativeMode
-            ? new U2Seg<T>(Architecture, Optimizer, LossFunction, _numClasses, _dropRate, _options)
-            : new U2Seg<T>(Architecture, _onnxModelPath ?? throw new InvalidOperationException("ONNX model path not initialized."), _numClasses, _options);
-    }
-
     // Dispose is inherited: SegmentationModelBase already disposes _onnxSession and sets _disposed,
     // and U2Seg owns no further unmanaged resources.
 
diff --git a/src/ComputerVision/Segmentation/Foundation/UNINEXT.cs b/src/ComputerVision/Segmentation/Foundation/UNINEXT.cs
index 2199e49aed..147ec8de30 100644
--- a/src/ComputerVision/Segmentation/Foundation/UNINEXT.cs
+++ b/src/ComputerVision/Segmentation/Foundation/UNINEXT.cs
@@ -62,7 +62,7 @@ namespace AiDotNet.ComputerVision.Segmentation.Foundation;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Universal Instance Perception as Object Discovery and Retrieval", "https://arxiv.org/abs/2303.06674", Year = 2023, Authors = "Yan et al.")]
-public class UNINEXT<T> : Common.PanopticSegmentationBase<T>
+public partial class UNINEXT<T> : Common.PanopticSegmentationBase<T>
 {
     private readonly UNINEXTOptions _options;
 
@@ -350,65 +350,6 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    /// <summary>
-    /// Writes UNINEXT configuration to a binary stream.
-    /// </summary>
-    /// <param name="writer">The binary writer.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Saves model configuration for later reconstruction.
-    /// </para>
-    /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_height); writer.Write(_width); writer.Write(_channels);
-        writer.Write(_numClasses); writer.Write(_numQueries); writer.Write((int)_modelSize);
-        writer.Write(_decoderDim); writer.Write(_dropRate);
-        writer.Write(_useNativeMode); writer.Write(_onnxModelPath ?? string.Empty);
-        writer.Write(_encoderLayerEnd);
-        writer.Write(_channelDims.Length);
-        foreach (int dim in _channelDims) writer.Write(dim);
-        writer.Write(_depths.Length);
-        foreach (int depth in _depths) writer.Write(depth);
-    }
-
-    /// <summary>
-    /// Reads UNINEXT configuration from a binary stream.
-    /// </summary>
-    /// <param name="reader">The binary reader.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Loads model configuration when restoring a saved model.
-    /// </para>
-    /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32();
-        _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32();
-        _ = reader.ReadInt32(); _ = reader.ReadDouble();
-        _ = reader.ReadBoolean(); _ = reader.ReadString(); _ = reader.ReadInt32();
-        int dimCount = reader.ReadInt32();
-        for (int i = 0; i < dimCount; i++) _ = reader.ReadInt32();
-        int depthCount = reader.ReadInt32();
-        for (int i = 0; i < depthCount; i++) _ = reader.ReadInt32();
-    }
-
-    /// <summary>
-    /// Creates a new UNINEXT instance with the same configuration but fresh weights.
-    /// </summary>
-    /// <returns>A new <see cref="UNINEXT{T}"/> model.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Creates a copy for cross-validation or ensemble training.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return _useNativeMode
-            ? new UNINEXT<T>(Architecture, Optimizer, LossFunction, _numClasses, _numQueries, _modelSize, _dropRate, _options)
-            : new UNINEXT<T>(Architecture, _onnxModelPath ?? throw new InvalidOperationException("ONNX model path not initialized."), _numClasses, _numQueries, _modelSize, _options);
-    }
-
     // Dispose is inherited: SegmentationModelBase already disposes _onnxSession and sets _disposed,
     // and UNINEXT owns no further unmanaged resources.
 
diff --git a/src/ComputerVision/Segmentation/Foundation/XDecoder.cs b/src/ComputerVision/Segmentation/Foundation/XDecoder.cs
index d236e96df6..33c0874b1d 100644
--- a/src/ComputerVision/Segmentation/Foundation/XDecoder.cs
+++ b/src/ComputerVision/Segmentation/Foundation/XDecoder.cs
@@ -62,7 +62,7 @@ namespace AiDotNet.ComputerVision.Segmentation.Foundation;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Generalized Decoding for Pixel, Image, and Language", "https://arxiv.org/abs/2212.11270", Year = 2023, Authors = "Zou et al.")]
-public class XDecoder<T> : Common.PanopticSegmentationBase<T>
+public partial class XDecoder<T> : Common.PanopticSegmentationBase<T>
 {
     private readonly XDecoderOptions _options;
 
@@ -388,75 +388,6 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    /// <summary>
-    /// Writes X-Decoder configuration to a binary stream.
-    /// </summary>
-    /// <param name="writer">The binary writer.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Saves model configuration for later reconstruction.
-    /// </para>
-    /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_height); writer.Write(_width); writer.Write(_channels);
-        writer.Write(_numClasses); writer.Write(_numQueries); writer.Write((int)_modelSize);
-        writer.Write(_decoderDim); writer.Write(_dropRate);
-        writer.Write(_useNativeMode); writer.Write(_onnxModelPath ?? string.Empty);
-        writer.Write(_encoderLayerEnd); writer.Write(_numStuffClasses);
-        writer.Write(_channelDims.Length);
-        foreach (int dim in _channelDims) writer.Write(dim);
-        writer.Write(_depths.Length);
-        foreach (int depth in _depths) writer.Write(depth);
-    }
-
-    /// <summary>
-    /// Reads X-Decoder configuration from a binary stream.
-    /// </summary>
-    /// <param name="reader">The binary reader.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Loads model configuration when restoring a saved model.
-    /// </para>
-    /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _height = reader.ReadInt32();
-        _width = reader.ReadInt32();
-        _channels = reader.ReadInt32();
-        _numClasses = reader.ReadInt32();
-        _numQueries = reader.ReadInt32();
-        _modelSize = (XDecoderModelSize)reader.ReadInt32();
-        _decoderDim = reader.ReadInt32();
-        _dropRate = reader.ReadDouble();
-        _useNativeMode = reader.ReadBoolean();
-        _onnxModelPath = reader.ReadString();
-        _encoderLayerEnd = reader.ReadInt32();
-        _numStuffClasses = reader.ReadInt32();
-        int dimCount = reader.ReadInt32();
-        _channelDims = new int[dimCount];
-        for (int i = 0; i < dimCount; i++) _channelDims[i] = reader.ReadInt32();
-        int depthCount = reader.ReadInt32();
-        _depths = new int[depthCount];
-        for (int i = 0; i < depthCount; i++) _depths[i] = reader.ReadInt32();
-    }
-
-    /// <summary>
-    /// Creates a new X-Decoder instance with the same configuration but fresh weights.
-    /// </summary>
-    /// <returns>A new <see cref="XDecoder{T}"/> model.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Creates a copy for cross-validation or ensemble training.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return _useNativeMode
-            ? new XDecoder<T>(Architecture, _optimizer, LossFunction, _numClasses, _numQueries, _modelSize, _dropRate, _options)
-            : new XDecoder<T>(Architecture, _onnxModelPath ?? throw new InvalidOperationException("ONNX model path not initialized."), _numClasses, _numQueries, _modelSize, _options);
-    }
-
     /// <summary>
     /// Releases managed resources including the ONNX inference session.
     /// </summary>
diff --git a/src/ComputerVision/Segmentation/InstanceSegmentation/YOLO11Seg.cs b/src/ComputerVision/Segmentation/InstanceSegmentation/YOLO11Seg.cs
index 2885ab25bf..4c6cd560ef 100644
--- a/src/ComputerVision/Segmentation/InstanceSegmentation/YOLO11Seg.cs
+++ b/src/ComputerVision/Segmentation/InstanceSegmentation/YOLO11Seg.cs
@@ -57,7 +57,7 @@ namespace AiDotNet.ComputerVision.Segmentation.InstanceSegmentation;
 [ModelComplexity(ModelComplexity.Medium)]
 [ResearchPaper("Ultralytics YOLO11", "https://docs.ultralytics.com/models/yolo11/")]
     [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
-public class YOLO11Seg<T> : Common.InstanceSegmentationBase<T>
+public partial class YOLO11Seg<T> : Common.InstanceSegmentationBase<T>
 {
     private readonly YOLO11SegOptions _options;
     public override ModelOptions GetOptions() => _options;
@@ -271,43 +271,6 @@ protected override void InitializeLayers()
         ModelData = SerializeForMetadata()
     };
 
-    /// <summary>
-    /// Writes configuration to a binary stream.
-    /// </summary>
-    /// <param name="writer">The binary writer.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Saves model configuration for later reconstruction.
-    /// </para>
-    /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    { writer.Write(_height); writer.Write(_width); writer.Write(_channels); writer.Write(_numClasses); writer.Write((int)_modelSize); writer.Write(_decoderDim); writer.Write(_dropRate); writer.Write(_useNativeMode); writer.Write(_onnxModelPath ?? string.Empty); writer.Write(_encoderLayerEnd); writer.Write(_channelDims.Length); foreach (int d in _channelDims) writer.Write(d); writer.Write(_depths.Length); foreach (int d in _depths) writer.Write(d); }
-
-    /// <summary>
-    /// Reads configuration from a binary stream.
-    /// </summary>
-    /// <param name="reader">The binary reader.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Loads model configuration when restoring a saved model.
-    /// </para>
-    /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    { _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadDouble(); _ = reader.ReadBoolean(); _ = reader.ReadString(); _ = reader.ReadInt32(); int dc = reader.ReadInt32(); for (int i = 0; i < dc; i++) _ = reader.ReadInt32(); int dd = reader.ReadInt32(); for (int i = 0; i < dd; i++) _ = reader.ReadInt32(); }
-
-    /// <summary>
-    /// Creates a new instance with the same configuration but fresh weights.
-    /// </summary>
-    /// <returns>A new model instance.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Creates a copy for cross-validation or ensemble training.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() => _useNativeMode
-        ? new YOLO11Seg<T>(Architecture, Optimizer, LossFunction, _numClasses, _modelSize, _dropRate, _options)
-        : new YOLO11Seg<T>(Architecture, _onnxModelPath ?? throw new InvalidOperationException("ONNX model path not initialized."), _numClasses, _modelSize, _options);
-
     // Dispose is inherited: SegmentationModelBase already disposes _onnxSession and sets _disposed,
     // and YOLO11Seg owns no further unmanaged resources.
     #endregion
diff --git a/src/ComputerVision/Segmentation/InstanceSegmentation/YOLO26Seg.cs b/src/ComputerVision/Segmentation/InstanceSegmentation/YOLO26Seg.cs
index cad920cb08..6e80979214 100644
--- a/src/ComputerVision/Segmentation/InstanceSegmentation/YOLO26Seg.cs
+++ b/src/ComputerVision/Segmentation/InstanceSegmentation/YOLO26Seg.cs
@@ -57,7 +57,7 @@ namespace AiDotNet.ComputerVision.Segmentation.InstanceSegmentation;
 [ModelComplexity(ModelComplexity.Medium)]
 [ResearchPaper("Ultralytics YOLO", "https://github.com/ultralytics/ultralytics")]
     [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
-public class YOLO26Seg<T> : Common.InstanceSegmentationBase<T>
+public partial class YOLO26Seg<T> : Common.InstanceSegmentationBase<T>
 {
     private readonly YOLO26SegOptions _options;
     public override ModelOptions GetOptions() => _options;
@@ -271,43 +271,6 @@ protected override void InitializeLayers()
         ModelData = SerializeForMetadata()
     };
 
-    /// <summary>
-    /// Writes configuration to a binary stream.
-    /// </summary>
-    /// <param name="writer">The binary writer.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Saves model configuration for later reconstruction.
-    /// </para>
-    /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    { writer.Write(_height); writer.Write(_width); writer.Write(_channels); writer.Write(_numClasses); writer.Write((int)_modelSize); writer.Write(_decoderDim); writer.Write(_dropRate); writer.Write(_useNativeMode); writer.Write(_onnxModelPath ?? string.Empty); writer.Write(_encoderLayerEnd); writer.Write(_channelDims.Length); foreach (int d in _channelDims) writer.Write(d); writer.Write(_depths.Length); foreach (int d in _depths) writer.Write(d); }
-
-    /// <summary>
-    /// Reads configuration from a binary stream.
-    /// </summary>
-    /// <param name="reader">The binary reader.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Loads model configuration when restoring a saved model.
-    /// </para>
-    /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    { _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadDouble(); _ = reader.ReadBoolean(); _ = reader.ReadString(); _ = reader.ReadInt32(); int dc = reader.ReadInt32(); for (int i = 0; i < dc; i++) _ = reader.ReadInt32(); int dd = reader.ReadInt32(); for (int i = 0; i < dd; i++) _ = reader.ReadInt32(); }
-
-    /// <summary>
-    /// Creates a new instance with the same configuration but fresh weights.
-    /// </summary>
-    /// <returns>A new model instance.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Creates a copy for cross-validation or ensemble training.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() => _useNativeMode
-        ? new YOLO26Seg<T>(Architecture, Optimizer, LossFunction, _numClasses, _modelSize, _dropRate, _options)
-        : new YOLO26Seg<T>(Architecture, _onnxModelPath ?? throw new InvalidOperationException("ONNX model path not initialized."), _numClasses, _modelSize, _options);
-
     /// <summary>
     /// Releases managed resources including the ONNX inference session.
     /// </summary>
diff --git a/src/ComputerVision/Segmentation/InstanceSegmentation/YOLOv12Seg.cs b/src/ComputerVision/Segmentation/InstanceSegmentation/YOLOv12Seg.cs
index 58bf14f982..21bec0860d 100644
--- a/src/ComputerVision/Segmentation/InstanceSegmentation/YOLOv12Seg.cs
+++ b/src/ComputerVision/Segmentation/InstanceSegmentation/YOLOv12Seg.cs
@@ -57,7 +57,7 @@ namespace AiDotNet.ComputerVision.Segmentation.InstanceSegmentation;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("YOLOv12: Attention-Centric Real-Time Object Detectors", "https://arxiv.org/abs/2502.12524", Year = 2025, Authors = "Yunjie Tian, Qixiang Ye, David Doermann")]
-public class YOLOv12Seg<T> : Common.InstanceSegmentationBase<T>
+public partial class YOLOv12Seg<T> : Common.InstanceSegmentationBase<T>
 {
     private readonly YOLOv12SegOptions _options;
     public override ModelOptions GetOptions() => _options;
@@ -314,60 +314,6 @@ protected override void InitializeLayers()
         ModelData = SerializeForMetadata()
     };
 
-    /// <summary>
-    /// Writes configuration to a binary stream.
-    /// </summary>
-    /// <param name="writer">The binary writer.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Saves model configuration for later reconstruction.
-    /// </para>
-    /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    { writer.Write(_height); writer.Write(_width); writer.Write(_channels); writer.Write(_numClasses); writer.Write((int)_modelSize); writer.Write(_decoderDim); writer.Write(_dropRate); writer.Write(_useNativeMode); writer.Write(_onnxModelPath ?? string.Empty); writer.Write(_encoderLayerEnd); writer.Write(_channelDims.Length); foreach (int d in _channelDims) writer.Write(d); writer.Write(_depths.Length); foreach (int d in _depths) writer.Write(d); }
-
-    /// <summary>
-    /// Reads configuration from a binary stream.
-    /// </summary>
-    /// <param name="reader">The binary reader.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Loads model configuration when restoring a saved model.
-    /// </para>
-    /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _height = reader.ReadInt32();
-        _width = reader.ReadInt32();
-        _channels = reader.ReadInt32();
-        _numClasses = reader.ReadInt32();
-        _modelSize = (YOLOv12SegModelSize)reader.ReadInt32();
-        _decoderDim = reader.ReadInt32();
-        _dropRate = reader.ReadDouble();
-        _useNativeMode = reader.ReadBoolean();
-        _onnxModelPath = reader.ReadString();
-        _encoderLayerEnd = reader.ReadInt32();
-        int dc = reader.ReadInt32();
-        _channelDims = new int[dc];
-        for (int i = 0; i < dc; i++) _channelDims[i] = reader.ReadInt32();
-        int dd = reader.ReadInt32();
-        _depths = new int[dd];
-        for (int i = 0; i < dd; i++) _depths[i] = reader.ReadInt32();
-    }
-
-    /// <summary>
-    /// Creates a new instance with the same configuration but fresh weights.
-    /// </summary>
-    /// <returns>A new model instance.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Creates a copy for cross-validation or ensemble training.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() => _useNativeMode
-        ? new YOLOv12Seg<T>(Architecture, Optimizer, LossFunction, _numClasses, _modelSize, _dropRate, _options)
-        : new YOLOv12Seg<T>(Architecture, _onnxModelPath ?? throw new InvalidOperationException("ONNX model path not initialized."), _numClasses, _modelSize, _options);
-
     // Dispose is inherited from SegmentationModelBase, which already disposes the ONNX session.
     // YOLOv12Seg owns no further unmanaged resources.
     #endregion
diff --git a/src/ComputerVision/Segmentation/InstanceSegmentation/YOLOv8Seg.cs b/src/ComputerVision/Segmentation/InstanceSegmentation/YOLOv8Seg.cs
index a4070f58da..43cfb1ba4b 100644
--- a/src/ComputerVision/Segmentation/InstanceSegmentation/YOLOv8Seg.cs
+++ b/src/ComputerVision/Segmentation/InstanceSegmentation/YOLOv8Seg.cs
@@ -60,7 +60,7 @@ namespace AiDotNet.ComputerVision.Segmentation.InstanceSegmentation;
 [ModelComplexity(ModelComplexity.Medium)]
 [ResearchPaper("Ultralytics YOLOv8", "https://docs.ultralytics.com/models/yolov8/")]
     [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
-public class YOLOv8Seg<T> : Common.InstanceSegmentationBase<T>
+public partial class YOLOv8Seg<T> : Common.InstanceSegmentationBase<T>
 {
     private readonly YOLOv8SegOptions _options;
     public override ModelOptions GetOptions() => _options;
@@ -306,57 +306,6 @@ protected override void InitializeLayers()
         ModelData = SerializeForMetadata()
     };
 
-    /// <summary>
-    /// Writes configuration to a binary stream.
-    /// </summary>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_height);
-        writer.Write(_width);
-        writer.Write(_channels);
-        writer.Write(_numClasses);
-        writer.Write((int)_modelSize);
-        writer.Write(_decoderDim);
-        writer.Write(_dropRate);
-        writer.Write(_useNativeMode);
-        writer.Write(_onnxModelPath ?? string.Empty);
-        writer.Write(_encoderLayerEnd);
-        writer.Write(_channelDims.Length);
-        foreach (int d in _channelDims) writer.Write(d);
-        writer.Write(_depths.Length);
-        foreach (int d in _depths) writer.Write(d);
-    }
-
-    /// <summary>
-    /// Reads configuration from a binary stream.
-    /// </summary>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _height = reader.ReadInt32();
-        _width = reader.ReadInt32();
-        _channels = reader.ReadInt32();
-        _numClasses = reader.ReadInt32();
-        _modelSize = (YOLOv8SegModelSize)reader.ReadInt32();
-        _decoderDim = reader.ReadInt32();
-        _dropRate = reader.ReadDouble();
-        _useNativeMode = reader.ReadBoolean();
-        _onnxModelPath = reader.ReadString();
-        _encoderLayerEnd = reader.ReadInt32();
-        int dc = reader.ReadInt32();
-        _channelDims = new int[dc];
-        for (int i = 0; i < dc; i++) _channelDims[i] = reader.ReadInt32();
-        int dd = reader.ReadInt32();
-        _depths = new int[dd];
-        for (int i = 0; i < dd; i++) _depths[i] = reader.ReadInt32();
-    }
-
-    /// <summary>
-    /// Creates a new instance with the same configuration.
-    /// </summary>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() => _useNativeMode
-        ? new YOLOv8Seg<T>(Architecture, Optimizer, LossFunction, _numClasses, _modelSize, _dropRate, _options)
-        : new YOLOv8Seg<T>(Architecture, _onnxModelPath ?? throw new InvalidOperationException("ONNX model path not initialized."), _numClasses, _modelSize, _options);
-
     // Dispose is inherited from SegmentationModelBase, which already disposes the ONNX session.
     // YOLOv8Seg owns no further unmanaged resources.
 
diff --git a/src/ComputerVision/Segmentation/InstanceSegmentation/YOLOv9Seg.cs b/src/ComputerVision/Segmentation/InstanceSegmentation/YOLOv9Seg.cs
index f2d230bc94..f780af96b3 100644
--- a/src/ComputerVision/Segmentation/InstanceSegmentation/YOLOv9Seg.cs
+++ b/src/ComputerVision/Segmentation/InstanceSegmentation/YOLOv9Seg.cs
@@ -61,7 +61,7 @@ namespace AiDotNet.ComputerVision.Segmentation.InstanceSegmentation;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("YOLOv9: Learning What You Want to Learn Using Programmable Gradient Information", "https://arxiv.org/abs/2402.13616", Year = 2024, Authors = "Wang et al.")]
-public class YOLOv9Seg<T> : Common.InstanceSegmentationBase<T>
+public partial class YOLOv9Seg<T> : Common.InstanceSegmentationBase<T>
 {
     private readonly YOLOv9SegOptions _options;
     public override ModelOptions GetOptions() => _options;
@@ -278,43 +278,6 @@ protected override void InitializeLayers()
         ModelData = SerializeForMetadata()
     };
 
-    /// <summary>
-    /// Writes configuration to a binary stream.
-    /// </summary>
-    /// <param name="writer">The binary writer.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Saves model configuration for later reconstruction.
-    /// </para>
-    /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    { writer.Write(_height); writer.Write(_width); writer.Write(_channels); writer.Write(_numClasses); writer.Write((int)_modelSize); writer.Write(_decoderDim); writer.Write(_dropRate); writer.Write(_useNativeMode); writer.Write(_onnxModelPath ?? string.Empty); writer.Write(_encoderLayerEnd); writer.Write(_channelDims.Length); foreach (int d in _channelDims) writer.Write(d); writer.Write(_depths.Length); foreach (int d in _depths) writer.Write(d); }
-
-    /// <summary>
-    /// Reads configuration from a binary stream.
-    /// </summary>
-    /// <param name="reader">The binary reader.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Loads model configuration when restoring a saved model.
-    /// </para>
-    /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    { _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadDouble(); _ = reader.ReadBoolean(); _ = reader.ReadString(); _ = reader.ReadInt32(); int dc = reader.ReadInt32(); for (int i = 0; i < dc; i++) _ = reader.ReadInt32(); int dd = reader.ReadInt32(); for (int i = 0; i < dd; i++) _ = reader.ReadInt32(); }
-
-    /// <summary>
-    /// Creates a new instance with the same configuration but fresh weights.
-    /// </summary>
-    /// <returns>A new model instance.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Creates a copy for cross-validation or ensemble training.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() => _useNativeMode
-        ? new YOLOv9Seg<T>(Architecture, Optimizer, LossFunction, _numClasses, _modelSize, _dropRate, _options)
-        : new YOLOv9Seg<T>(Architecture, _onnxModelPath ?? throw new InvalidOperationException("ONNX model path not initialized."), _numClasses, _modelSize, _options);
-
     // Dispose is inherited from SegmentationModelBase, which already disposes the ONNX session.
     // YOLOv9Seg owns no further unmanaged resources.
     #endregion
diff --git a/src/ComputerVision/Segmentation/Interactive/SEEM.cs b/src/ComputerVision/Segmentation/Interactive/SEEM.cs
index bf3601d154..7066a7b93d 100644
--- a/src/ComputerVision/Segmentation/Interactive/SEEM.cs
+++ b/src/ComputerVision/Segmentation/Interactive/SEEM.cs
@@ -57,7 +57,7 @@ namespace AiDotNet.ComputerVision.Segmentation.Interactive;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Segment Everything Everywhere All at Once", "https://arxiv.org/abs/2304.06718", Year = 2023, Authors = "Zou et al.")]
-public class SEEM<T> : Common.PromptableSegmentationBase<T>
+public partial class SEEM<T> : Common.PromptableSegmentationBase<T>
 {
     private readonly SEEMOptions _options;
     public override ModelOptions GetOptions() => _options;
@@ -296,65 +296,6 @@ protected override void InitializeLayers()
         ModelData = SerializeForMetadata()
     };
 
-    /// <summary>
-    /// Writes configuration to a binary stream.
-    /// </summary>
-    /// <param name="writer">The binary writer.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Saves model configuration for later reconstruction.
-    /// </para>
-    /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    { writer.Write(_height); writer.Write(_width); writer.Write(_channels); writer.Write(_numClasses); writer.Write((int)_modelSize); writer.Write(_decoderDim); writer.Write(_dropRate); writer.Write(_useNativeMode); writer.Write(_onnxModelPath ?? string.Empty); writer.Write(_encoderLayerEnd); writer.Write(_channelDims.Length); foreach (int d in _channelDims) writer.Write(d); writer.Write(_depths.Length); foreach (int d in _depths) writer.Write(d); }
-
-    /// <summary>
-    /// Reads configuration from a binary stream.
-    /// </summary>
-    /// <param name="reader">The binary reader.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Loads model configuration when restoring a saved model.
-    /// </para>
-    /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _height = reader.ReadInt32();
-        _width = reader.ReadInt32();
-        _channels = reader.ReadInt32();
-        _numClasses = reader.ReadInt32();
-        _modelSize = (SEEMModelSize)reader.ReadInt32();
-        _decoderDim = reader.ReadInt32();
-        _dropRate = reader.ReadDouble();
-        _useNativeMode = reader.ReadBoolean();
-        _onnxModelPath = reader.ReadString();
-        _encoderLayerEnd = reader.ReadInt32();
-        int dc = reader.ReadInt32();
-        _channelDims = new int[dc];
-        for (int i = 0; i < dc; i++) _channelDims[i] = reader.ReadInt32();
-        int dd = reader.ReadInt32();
-        _depths = new int[dd];
-        for (int i = 0; i < dd; i++) _depths[i] = reader.ReadInt32();
-    }
-
-    /// <summary>
-    /// Creates a new instance with the same configuration but fresh weights.
-    /// </summary>
-    /// <returns>A new model instance.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Creates a copy for cross-validation or ensemble training.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var options = new SEEMOptions(_options);
-        return _useNativeMode
-            ? new SEEM<T>(Architecture, optimizer: null, lossFunction: LossFunction,
-                numClasses: _numClasses, modelSize: _modelSize, dropRate: _dropRate, options: options)
-            : new SEEM<T>(Architecture, _onnxModelPath ?? throw new InvalidOperationException("ONNX model path not initialized."), _numClasses, _modelSize, options);
-    }
-
     // Dispose is inherited from SegmentationModelBase, which already disposes the ONNX session.
     // SEEM owns no further unmanaged resources.
     #endregion
diff --git a/src/ComputerVision/Segmentation/Interactive/SegGPT.cs b/src/ComputerVision/Segmentation/Interactive/SegGPT.cs
index 53be710209..4c60b2b412 100644
--- a/src/ComputerVision/Segmentation/Interactive/SegGPT.cs
+++ b/src/ComputerVision/Segmentation/Interactive/SegGPT.cs
@@ -56,7 +56,7 @@ namespace AiDotNet.ComputerVision.Segmentation.Interactive;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("SegGPT: Segmenting Everything In Context", "https://arxiv.org/abs/2304.03284", Year = 2023, Authors = "Wang et al.")]
-public class SegGPT<T> : Common.PromptableSegmentationBase<T>
+public partial class SegGPT<T> : Common.PromptableSegmentationBase<T>
 {
     private readonly SegGPTOptions _options;
     public override ModelOptions GetOptions() => _options;
@@ -281,45 +281,6 @@ protected override void InitializeLayers()
         ModelData = SerializeForMetadata()
     };
 
-    /// <summary>
-    /// Writes configuration to a binary stream.
-    /// </summary>
-    /// <param name="writer">The binary writer.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Saves model configuration for later reconstruction.
-    /// </para>
-    /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    { writer.Write(_height); writer.Write(_width); writer.Write(_channels); writer.Write(_numClasses); writer.Write((int)_modelSize); writer.Write(_decoderDim); writer.Write(_dropRate); writer.Write(_useNativeMode); writer.Write(_onnxModelPath ?? string.Empty); writer.Write(_encoderLayerEnd); writer.Write(_channelDims.Length); foreach (int d in _channelDims) writer.Write(d); writer.Write(_depths.Length); foreach (int d in _depths) writer.Write(d); }
-
-    /// <summary>
-    /// Reads configuration from a binary stream.
-    /// </summary>
-    /// <param name="reader">The binary reader.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Loads model configuration when restoring a saved model.
-    /// </para>
-    /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    { _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadDouble(); _ = reader.ReadBoolean(); _ = reader.ReadString(); _ = reader.ReadInt32(); int dc = reader.ReadInt32(); for (int i = 0; i < dc; i++) _ = reader.ReadInt32(); int dd = reader.ReadInt32(); for (int i = 0; i < dd; i++) _ = reader.ReadInt32(); }
-
-    /// <summary>
-    /// Creates a new instance with the same configuration but fresh weights.
-    /// </summary>
-    /// <returns>A new model instance.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Creates a copy for cross-validation or ensemble training.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() => _useNativeMode
-        ? new SegGPT<T>(Architecture, optimizer: null, lossFunction: LossFunction,
-            numClasses: _numClasses, modelSize: _modelSize, dropRate: _dropRate,
-            options: new SegGPTOptions(_options))
-        : new SegGPT<T>(Architecture, _onnxModelPath ?? throw new InvalidOperationException("ONNX model path not initialized."), _numClasses, _modelSize, new SegGPTOptions(_options));
-
     // Dispose is inherited from SegmentationModelBase, which already disposes the ONNX session.
     // SegGPT owns no further unmanaged resources.
     #endregion
diff --git a/src/ComputerVision/Segmentation/Mamba/VMamba.cs b/src/ComputerVision/Segmentation/Mamba/VMamba.cs
index f1c8937da9..6cc2a0eb78 100644
--- a/src/ComputerVision/Segmentation/Mamba/VMamba.cs
+++ b/src/ComputerVision/Segmentation/Mamba/VMamba.cs
@@ -55,7 +55,7 @@ namespace AiDotNet.ComputerVision.Segmentation.Mamba;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("VMamba: Visual State Space Model", "https://arxiv.org/abs/2401.10166", Year = 2024, Authors = "Liu et al.")]
-public class VMamba<T> : Common.SemanticSegmentationBase<T>
+public partial class VMamba<T> : Common.SemanticSegmentationBase<T>
 {
     private readonly VMambaOptions _options;
     public override ModelOptions GetOptions() => _options;
@@ -275,43 +275,6 @@ protected override void InitializeLayers()
         ModelData = SerializeForMetadata()
     };
 
-    /// <summary>
-    /// Writes configuration to a binary stream.
-    /// </summary>
-    /// <param name="writer">The binary writer.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Saves model configuration for later reconstruction.
-    /// </para>
-    /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    { writer.Write(_height); writer.Write(_width); writer.Write(_channels); writer.Write(_numClasses); writer.Write((int)_modelSize); writer.Write(_decoderDim); writer.Write(_dropRate); writer.Write(_useNativeMode); writer.Write(_onnxModelPath ?? string.Empty); writer.Write(_encoderLayerEnd); writer.Write(_channelDims.Length); foreach (int d in _channelDims) writer.Write(d); writer.Write(_depths.Length); foreach (int d in _depths) writer.Write(d); }
-
-    /// <summary>
-    /// Reads configuration from a binary stream.
-    /// </summary>
-    /// <param name="reader">The binary reader.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Loads model configuration when restoring a saved model.
-    /// </para>
-    /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    { _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadDouble(); _ = reader.ReadBoolean(); _ = reader.ReadString(); _ = reader.ReadInt32(); int dc = reader.ReadInt32(); for (int i = 0; i < dc; i++) _ = reader.ReadInt32(); int dd = reader.ReadInt32(); for (int i = 0; i < dd; i++) _ = reader.ReadInt32(); }
-
-    /// <summary>
-    /// Creates a new instance with the same configuration but fresh weights.
-    /// </summary>
-    /// <returns>A new model instance.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Creates a copy for cross-validation or ensemble training.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() => _useNativeMode
-        ? new VMamba<T>(Architecture, Optimizer, LossFunction, _numClasses, _modelSize, _dropRate, _options)
-        : new VMamba<T>(Architecture, _onnxModelPath ?? throw new InvalidOperationException("ONNX model path not initialized."), _numClasses, _modelSize, _options);
-
     // Dispose is inherited from SegmentationModelBase, which already disposes the ONNX session.
     // VMamba owns no further unmanaged resources.
     #endregion
diff --git a/src/ComputerVision/Segmentation/Mamba/ViMUNet.cs b/src/ComputerVision/Segmentation/Mamba/ViMUNet.cs
index fcbdf86262..51d5af8451 100644
--- a/src/ComputerVision/Segmentation/Mamba/ViMUNet.cs
+++ b/src/ComputerVision/Segmentation/Mamba/ViMUNet.cs
@@ -56,7 +56,7 @@ namespace AiDotNet.ComputerVision.Segmentation.Mamba;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("ViM-UNet: Vision Mamba for Biomedical Segmentation", "https://arxiv.org/abs/2404.07705", Year = 2024, Authors = "Archit and Pape")]
-public class ViMUNet<T> : Common.SemanticSegmentationBase<T>
+public partial class ViMUNet<T> : Common.SemanticSegmentationBase<T>
 {
     private readonly ViMUNetOptions _options;
     public override ModelOptions GetOptions() => _options;
@@ -270,43 +270,6 @@ protected override void InitializeLayers()
         ModelData = SerializeForMetadata()
     };
 
-    /// <summary>
-    /// Writes configuration to a binary stream.
-    /// </summary>
-    /// <param name="writer">The binary writer.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Saves model configuration for later reconstruction.
-    /// </para>
-    /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    { writer.Write(_height); writer.Write(_width); writer.Write(_channels); writer.Write(_numClasses); writer.Write(_decoderDim); writer.Write(_dropRate); writer.Write(_useNativeMode); writer.Write(_onnxModelPath ?? string.Empty); writer.Write(_encoderLayerEnd); writer.Write(_channelDims.Length); foreach (int d in _channelDims) writer.Write(d); writer.Write(_depths.Length); foreach (int d in _depths) writer.Write(d); }
-
-    /// <summary>
-    /// Reads configuration from a binary stream.
-    /// </summary>
-    /// <param name="reader">The binary reader.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Loads model configuration when restoring a saved model.
-    /// </para>
-    /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    { _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadDouble(); _ = reader.ReadBoolean(); _ = reader.ReadString(); _ = reader.ReadInt32(); int dc = reader.ReadInt32(); for (int i = 0; i < dc; i++) _ = reader.ReadInt32(); int dd = reader.ReadInt32(); for (int i = 0; i < dd; i++) _ = reader.ReadInt32(); }
-
-    /// <summary>
-    /// Creates a new instance with the same configuration but fresh weights.
-    /// </summary>
-    /// <returns>A new model instance.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Creates a copy for cross-validation or ensemble training.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() => _useNativeMode
-        ? new ViMUNet<T>(Architecture, Optimizer, LossFunction, _numClasses, _dropRate, _options)
-        : new ViMUNet<T>(Architecture, _onnxModelPath ?? throw new InvalidOperationException("ONNX model path not initialized."), _numClasses, _options);
-
     // Dispose is inherited from SegmentationModelBase, which already disposes the ONNX session.
     // ViMUNet owns no further unmanaged resources.
     #endregion
diff --git a/src/ComputerVision/Segmentation/Mamba/VisionMamba.cs b/src/ComputerVision/Segmentation/Mamba/VisionMamba.cs
index 9439efb791..a75c83783f 100644
--- a/src/ComputerVision/Segmentation/Mamba/VisionMamba.cs
+++ b/src/ComputerVision/Segmentation/Mamba/VisionMamba.cs
@@ -55,7 +55,7 @@ namespace AiDotNet.ComputerVision.Segmentation.Mamba;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Vision Mamba: Efficient Visual Representation Learning with Bidirectional State Space Model", "https://arxiv.org/abs/2401.09417", Year = 2024, Authors = "Zhu et al.")]
-public class VisionMamba<T> : Common.SemanticSegmentationBase<T>
+public partial class VisionMamba<T> : Common.SemanticSegmentationBase<T>
 {
     private readonly VisionMambaOptions _options;
     public override ModelOptions GetOptions() => _options;
@@ -276,43 +276,6 @@ protected override void InitializeLayers()
         ModelData = SerializeForMetadata()
     };
 
-    /// <summary>
-    /// Writes configuration to a binary stream.
-    /// </summary>
-    /// <param name="writer">The binary writer.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Saves model configuration for later reconstruction.
-    /// </para>
-    /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    { writer.Write(_height); writer.Write(_width); writer.Write(_channels); writer.Write(_numClasses); writer.Write((int)_modelSize); writer.Write(_decoderDim); writer.Write(_dropRate); writer.Write(_useNativeMode); writer.Write(_onnxModelPath ?? string.Empty); writer.Write(_encoderLayerEnd); writer.Write(_channelDims.Length); foreach (int d in _channelDims) writer.Write(d); writer.Write(_depths.Length); foreach (int d in _depths) writer.Write(d); }
-
-    /// <summary>
-    /// Reads configuration from a binary stream.
-    /// </summary>
-    /// <param name="reader">The binary reader.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Loads model configuration when restoring a saved model.
-    /// </para>
-    /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    { _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadDouble(); _ = reader.ReadBoolean(); _ = reader.ReadString(); _ = reader.ReadInt32(); int dc = reader.ReadInt32(); for (int i = 0; i < dc; i++) _ = reader.ReadInt32(); int dd = reader.ReadInt32(); for (int i = 0; i < dd; i++) _ = reader.ReadInt32(); }
-
-    /// <summary>
-    /// Creates a new instance with the same configuration but fresh weights.
-    /// </summary>
-    /// <returns>A new model instance.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Creates a copy for cross-validation or ensemble training.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() => _useNativeMode
-        ? new VisionMamba<T>(Architecture, Optimizer, LossFunction, _numClasses, _modelSize, _dropRate, _options)
-        : new VisionMamba<T>(Architecture, _onnxModelPath ?? throw new InvalidOperationException("ONNX model path not initialized."), _numClasses, _modelSize, _options);
-
     // Dispose is inherited from SegmentationModelBase, which already disposes the ONNX session.
     // VisionMamba owns no further unmanaged resources.
     #endregion
diff --git a/src/ComputerVision/Segmentation/Medical/BiomedParse.cs b/src/ComputerVision/Segmentation/Medical/BiomedParse.cs
index e72a8574c6..197b539fdd 100644
--- a/src/ComputerVision/Segmentation/Medical/BiomedParse.cs
+++ b/src/ComputerVision/Segmentation/Medical/BiomedParse.cs
@@ -56,7 +56,7 @@ namespace AiDotNet.ComputerVision.Segmentation.Medical;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("BiomedParse: a Biomedical Foundation Model for Image Parsing of Everything Everywhere All at Once", "https://arxiv.org/abs/2405.12971", Year = 2024, Authors = "Zhao et al.")]
-public class BiomedParse<T> : Common.MedicalSegmentationBase<T>
+public partial class BiomedParse<T> : Common.MedicalSegmentationBase<T>
 {
     private readonly BiomedParseOptions _options;
     public override ModelOptions GetOptions() => _options;
@@ -307,59 +307,6 @@ protected override void InitializeLayers()
         ModelData = SerializeForMetadata()
     };
 
-    /// <summary>
-    /// Writes configuration to a binary stream.
-    /// </summary>
-    /// <param name="writer">The binary writer.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Saves model configuration for later reconstruction.
-    /// </para>
-    /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    { writer.Write(_height); writer.Write(_width); writer.Write(_channels); writer.Write(_numClasses); writer.Write(_decoderDim); writer.Write(_dropRate); writer.Write(_useNativeMode); writer.Write(_onnxModelPath ?? string.Empty); writer.Write(_encoderLayerEnd); writer.Write(_channelDims.Length); foreach (int d in _channelDims) writer.Write(d); writer.Write(_depths.Length); foreach (int d in _depths) writer.Write(d); }
-
-    /// <summary>
-    /// Reads configuration from a binary stream.
-    /// </summary>
-    /// <param name="reader">The binary reader.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Loads model configuration when restoring a saved model.
-    /// </para>
-    /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _height = reader.ReadInt32();
-        _width = reader.ReadInt32();
-        _channels = reader.ReadInt32();
-        _numClasses = reader.ReadInt32();
-        _decoderDim = reader.ReadInt32();
-        _dropRate = reader.ReadDouble();
-        _useNativeMode = reader.ReadBoolean();
-        _onnxModelPath = reader.ReadString();
-        _encoderLayerEnd = reader.ReadInt32();
-        int dc = reader.ReadInt32();
-        _channelDims = new int[dc];
-        for (int i = 0; i < dc; i++) _channelDims[i] = reader.ReadInt32();
-        int dd = reader.ReadInt32();
-        _depths = new int[dd];
-        for (int i = 0; i < dd; i++) _depths[i] = reader.ReadInt32();
-    }
-
-    /// <summary>
-    /// Creates a new instance with the same configuration but fresh weights.
-    /// </summary>
-    /// <returns>A new model instance.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Creates a copy for cross-validation or ensemble training.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() => _useNativeMode
-        ? new BiomedParse<T>(Architecture, Optimizer, LossFunction, _numClasses, _dropRate, _options)
-        : new BiomedParse<T>(Architecture, _onnxModelPath ?? throw new InvalidOperationException("ONNX model path not initialized."), _numClasses, _options);
-
     // Dispose is inherited from SegmentationModelBase, which already disposes the ONNX session.
     // BiomedParse owns no further unmanaged resources.
     #endregion
diff --git a/src/ComputerVision/Segmentation/Medical/MedNeXt.cs b/src/ComputerVision/Segmentation/Medical/MedNeXt.cs
index 9b6724c245..364e1ba0a9 100644
--- a/src/ComputerVision/Segmentation/Medical/MedNeXt.cs
+++ b/src/ComputerVision/Segmentation/Medical/MedNeXt.cs
@@ -56,7 +56,7 @@ namespace AiDotNet.ComputerVision.Segmentation.Medical;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("MedNeXt: Transformer-driven Scaling of ConvNets for Medical Image Segmentation", "https://arxiv.org/abs/2303.09975", Year = 2023, Authors = "Roy et al.")]
-public class MedNeXt<T> : Common.MedicalSegmentationBase<T>
+public partial class MedNeXt<T> : Common.MedicalSegmentationBase<T>
 {
     private readonly MedNeXtOptions _options;
     public override ModelOptions GetOptions() => _options;
@@ -281,43 +281,6 @@ protected override void InitializeLayers()
         ModelData = SerializeForMetadata()
     };
 
-    /// <summary>
-    /// Writes configuration to a binary stream.
-    /// </summary>
-    /// <param name="writer">The binary writer.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Saves model configuration for later reconstruction.
-    /// </para>
-    /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    { writer.Write(_height); writer.Write(_width); writer.Write(_channels); writer.Write(_numClasses); writer.Write((int)_modelSize); writer.Write(_decoderDim); writer.Write(_dropRate); writer.Write(_useNativeMode); writer.Write(_onnxModelPath ?? string.Empty); writer.Write(_encoderLayerEnd); writer.Write(_channelDims.Length); foreach (int d in _channelDims) writer.Write(d); writer.Write(_depths.Length); foreach (int d in _depths) writer.Write(d); }
-
-    /// <summary>
-    /// Reads configuration from a binary stream.
-    /// </summary>
-    /// <param name="reader">The binary reader.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Loads model configuration when restoring a saved model.
-    /// </para>
-    /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    { _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadDouble(); _ = reader.ReadBoolean(); _ = reader.ReadString(); _ = reader.ReadInt32(); int dc = reader.ReadInt32(); for (int i = 0; i < dc; i++) _ = reader.ReadInt32(); int dd = reader.ReadInt32(); for (int i = 0; i < dd; i++) _ = reader.ReadInt32(); }
-
-    /// <summary>
-    /// Creates a new instance with the same configuration but fresh weights.
-    /// </summary>
-    /// <returns>A new model instance.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Creates a copy for cross-validation or ensemble training.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() => _useNativeMode
-        ? new MedNeXt<T>(Architecture, Optimizer, LossFunction, _numClasses, _modelSize, _dropRate, _options)
-        : new MedNeXt<T>(Architecture, _onnxModelPath ?? throw new InvalidOperationException("ONNX model path not initialized."), _numClasses, _modelSize, _options);
-
     // Dispose is inherited from SegmentationModelBase, which already disposes the ONNX session.
     // MedNeXt owns no further unmanaged resources.
     #endregion
diff --git a/src/ComputerVision/Segmentation/Medical/MedSAM.cs b/src/ComputerVision/Segmentation/Medical/MedSAM.cs
index 38780016cb..d27c4e6aa4 100644
--- a/src/ComputerVision/Segmentation/Medical/MedSAM.cs
+++ b/src/ComputerVision/Segmentation/Medical/MedSAM.cs
@@ -57,7 +57,7 @@ namespace AiDotNet.ComputerVision.Segmentation.Medical;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Segment Anything in Medical Images", "https://doi.org/10.1038/s41467-024-44824-z", Year = 2024, Authors = "Jun Ma, Yuting He, Feifei Li, Lin Han, Chenyu You, Bo Wang")]
-public class MedSAM<T> : Common.MedicalSegmentationBase<T>
+public partial class MedSAM<T> : Common.MedicalSegmentationBase<T>
 {
     private readonly MedSAMOptions _options;
     public override ModelOptions GetOptions() => _options;
@@ -376,43 +376,6 @@ protected override void InitializeLayers()
         ModelData = SerializeForMetadata()
     };
 
-    /// <summary>
-    /// Writes configuration to a binary stream.
-    /// </summary>
-    /// <param name="writer">The binary writer.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Saves model configuration for later reconstruction.
-    /// </para>
-    /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    { writer.Write(_height); writer.Write(_width); writer.Write(_channels); writer.Write(_numClasses); writer.Write((int)_modelSize); writer.Write(_decoderDim); writer.Write(_dropRate); writer.Write(_useNativeMode); writer.Write(_onnxModelPath ?? string.Empty); writer.Write(_encoderLayerEnd); writer.Write(_channelDims.Length); foreach (int d in _channelDims) writer.Write(d); writer.Write(_depths.Length); foreach (int d in _depths) writer.Write(d); }
-
-    /// <summary>
-    /// Reads configuration from a binary stream.
-    /// </summary>
-    /// <param name="reader">The binary reader.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Loads model configuration when restoring a saved model.
-    /// </para>
-    /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    { _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadDouble(); _ = reader.ReadBoolean(); _ = reader.ReadString(); _ = reader.ReadInt32(); int dc = reader.ReadInt32(); for (int i = 0; i < dc; i++) _ = reader.ReadInt32(); int dd = reader.ReadInt32(); for (int i = 0; i < dd; i++) _ = reader.ReadInt32(); }
-
-    /// <summary>
-    /// Creates a new instance with the same configuration but fresh weights.
-    /// </summary>
-    /// <returns>A new model instance.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Creates a copy for cross-validation or ensemble training.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() => _useNativeMode
-        ? new MedSAM<T>(Architecture, _optimizer, LossFunction, _numClasses, _modelSize, _dropRate, _options)
-        : new MedSAM<T>(Architecture, _onnxModelPath ?? throw new InvalidOperationException("ONNX model path not initialized."), _numClasses, _modelSize, _options);
-
     // Dispose is inherited from SegmentationModelBase, which already disposes the ONNX session.
     // MedSAM owns no further unmanaged resources.
     #endregion
diff --git a/src/ComputerVision/Segmentation/Medical/MedSAM2.cs b/src/ComputerVision/Segmentation/Medical/MedSAM2.cs
index e3a10a35ac..81a6612f6e 100644
--- a/src/ComputerVision/Segmentation/Medical/MedSAM2.cs
+++ b/src/ComputerVision/Segmentation/Medical/MedSAM2.cs
@@ -56,7 +56,7 @@ namespace AiDotNet.ComputerVision.Segmentation.Medical;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Medical SAM 2: Segment Medical Images As Video Via Segment Anything Model 2", "https://arxiv.org/abs/2408.00874", Year = 2024, Authors = "Zhu et al.")]
-public class MedSAM2<T> : Common.MedicalSegmentationBase<T>
+public partial class MedSAM2<T> : Common.MedicalSegmentationBase<T>
 {
     private readonly MedSAM2Options _options;
     public override ModelOptions GetOptions() => _options;
@@ -354,43 +354,6 @@ protected override void InitializeLayers()
         ModelData = SerializeForMetadata()
     };
 
-    /// <summary>
-    /// Writes configuration to a binary stream.
-    /// </summary>
-    /// <param name="writer">The binary writer.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Saves model configuration for later reconstruction.
-    /// </para>
-    /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    { writer.Write(_height); writer.Write(_width); writer.Write(_channels); writer.Write(_numClasses); writer.Write((int)_modelSize); writer.Write(_decoderDim); writer.Write(_dropRate); writer.Write(_useNativeMode); writer.Write(_onnxModelPath ?? string.Empty); writer.Write(_encoderLayerEnd); writer.Write(_channelDims.Length); foreach (int d in _channelDims) writer.Write(d); writer.Write(_depths.Length); foreach (int d in _depths) writer.Write(d); }
-
-    /// <summary>
-    /// Reads configuration from a binary stream.
-    /// </summary>
-    /// <param name="reader">The binary reader.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Loads model configuration when restoring a saved model.
-    /// </para>
-    /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    { _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadDouble(); _ = reader.ReadBoolean(); _ = reader.ReadString(); _ = reader.ReadInt32(); int dc = reader.ReadInt32(); for (int i = 0; i < dc; i++) _ = reader.ReadInt32(); int dd = reader.ReadInt32(); for (int i = 0; i < dd; i++) _ = reader.ReadInt32(); }
-
-    /// <summary>
-    /// Creates a new instance with the same configuration but fresh weights.
-    /// </summary>
-    /// <returns>A new model instance.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Creates a copy for cross-validation or ensemble training.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() => _useNativeMode
-        ? new MedSAM2<T>(Architecture, _optimizer, LossFunction, _numClasses, _modelSize, _dropRate, _options)
-        : new MedSAM2<T>(Architecture, _onnxModelPath ?? throw new InvalidOperationException("ONNX model path not initialized."), _numClasses, _modelSize, _options);
-
     // Dispose is inherited from SegmentationModelBase, which already disposes the ONNX session.
     // MedSAM2 owns no further unmanaged resources.
     #endregion
diff --git a/src/ComputerVision/Segmentation/Medical/MedSegDiffV2.cs b/src/ComputerVision/Segmentation/Medical/MedSegDiffV2.cs
index f1b128a26a..30ea42af83 100644
--- a/src/ComputerVision/Segmentation/Medical/MedSegDiffV2.cs
+++ b/src/ComputerVision/Segmentation/Medical/MedSegDiffV2.cs
@@ -56,7 +56,7 @@ namespace AiDotNet.ComputerVision.Segmentation.Medical;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("MedSegDiff-V2: Diffusion-based Medical Image Segmentation with Transformer", "https://arxiv.org/abs/2301.11798", Year = 2024, Authors = "Wu et al.")]
-public class MedSegDiffV2<T> : Common.MedicalSegmentationBase<T>
+public partial class MedSegDiffV2<T> : Common.MedicalSegmentationBase<T>
 {
     private readonly MedSegDiffV2Options _options;
     public override ModelOptions GetOptions() => _options;
@@ -263,43 +263,6 @@ protected override void InitializeLayers()
         ModelData = SerializeForMetadata()
     };
 
-    /// <summary>
-    /// Writes configuration to a binary stream.
-    /// </summary>
-    /// <param name="writer">The binary writer.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Saves model configuration for later reconstruction.
-    /// </para>
-    /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    { writer.Write(_height); writer.Write(_width); writer.Write(_channels); writer.Write(_numClasses); writer.Write(_decoderDim); writer.Write(_dropRate); writer.Write(_useNativeMode); writer.Write(_onnxModelPath ?? string.Empty); writer.Write(_encoderLayerEnd); writer.Write(_channelDims.Length); foreach (int d in _channelDims) writer.Write(d); writer.Write(_depths.Length); foreach (int d in _depths) writer.Write(d); }
-
-    /// <summary>
-    /// Reads configuration from a binary stream.
-    /// </summary>
-    /// <param name="reader">The binary reader.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Loads model configuration when restoring a saved model.
-    /// </para>
-    /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    { _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadDouble(); _ = reader.ReadBoolean(); _ = reader.ReadString(); _ = reader.ReadInt32(); int dc = reader.ReadInt32(); for (int i = 0; i < dc; i++) _ = reader.ReadInt32(); int dd = reader.ReadInt32(); for (int i = 0; i < dd; i++) _ = reader.ReadInt32(); }
-
-    /// <summary>
-    /// Creates a new instance with the same configuration but fresh weights.
-    /// </summary>
-    /// <returns>A new model instance.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Creates a copy for cross-validation or ensemble training.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() => _useNativeMode
-        ? new MedSegDiffV2<T>(Architecture, _optimizer, LossFunction, _numClasses, _dropRate, _options)
-        : new MedSegDiffV2<T>(Architecture, _onnxModelPath ?? throw new InvalidOperationException("ONNX model path not initialized."), _numClasses, _options);
-
     // Dispose is inherited: SegmentationModelBase already disposes _onnxSession and flips _disposed,
     // and MedSegDiffV2 owns no other unmanaged resource.
     #endregion
diff --git a/src/ComputerVision/Segmentation/Medical/NnUNet.cs b/src/ComputerVision/Segmentation/Medical/NnUNet.cs
index ca1b562c85..04ba8edde0 100644
--- a/src/ComputerVision/Segmentation/Medical/NnUNet.cs
+++ b/src/ComputerVision/Segmentation/Medical/NnUNet.cs
@@ -56,7 +56,7 @@ namespace AiDotNet.ComputerVision.Segmentation.Medical;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("nnU-Net: a self-configuring method for deep learning-based biomedical image segmentation", "https://doi.org/10.1038/s41592-020-01008-z", Year = 2021, Authors = "Fabian Isensee, Paul F. Jaeger, Simon A. A. Kohl, Jens Petersen, Klaus H. Maier-Hein")]
-public class NnUNet<T> : Common.MedicalSegmentationBase<T>
+public partial class NnUNet<T> : Common.MedicalSegmentationBase<T>
 {
     private readonly NnUNetOptions _options;
     public override ModelOptions GetOptions() => _options;
@@ -273,43 +273,6 @@ protected override void InitializeLayers()
         ModelData = SerializeForMetadata()
     };
 
-    /// <summary>
-    /// Writes configuration to a binary stream.
-    /// </summary>
-    /// <param name="writer">The binary writer.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Saves model configuration for later reconstruction.
-    /// </para>
-    /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    { writer.Write(_height); writer.Write(_width); writer.Write(_channels); writer.Write(_numClasses); writer.Write((int)_modelSize); writer.Write(_decoderDim); writer.Write(_dropRate); writer.Write(_useNativeMode); writer.Write(_onnxModelPath ?? string.Empty); writer.Write(_encoderLayerEnd); writer.Write(_channelDims.Length); foreach (int d in _channelDims) writer.Write(d); writer.Write(_depths.Length); foreach (int d in _depths) writer.Write(d); }
-
-    /// <summary>
-    /// Reads configuration from a binary stream.
-    /// </summary>
-    /// <param name="reader">The binary reader.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Loads model configuration when restoring a saved model.
-    /// </para>
-    /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    { _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadDouble(); _ = reader.ReadBoolean(); _ = reader.ReadString(); _ = reader.ReadInt32(); int dc = reader.ReadInt32(); for (int i = 0; i < dc; i++) _ = reader.ReadInt32(); int dd = reader.ReadInt32(); for (int i = 0; i < dd; i++) _ = reader.ReadInt32(); }
-
-    /// <summary>
-    /// Creates a new instance with the same configuration but fresh weights.
-    /// </summary>
-    /// <returns>A new model instance.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Creates a copy for cross-validation or ensemble training.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() => _useNativeMode
-        ? new NnUNet<T>(Architecture, _optimizer, LossFunction, _numClasses, _modelSize, _dropRate, _options)
-        : new NnUNet<T>(Architecture, _onnxModelPath ?? throw new InvalidOperationException("ONNX model path not initialized."), _numClasses, _modelSize, _options);
-
     // Dispose is inherited: SegmentationModelBase already disposes _onnxSession and flips _disposed,
     // and NnUNet owns no other unmanaged resource.
     #endregion
diff --git a/src/ComputerVision/Segmentation/Medical/SegMamba.cs b/src/ComputerVision/Segmentation/Medical/SegMamba.cs
index 27d1c67667..06b77701f0 100644
--- a/src/ComputerVision/Segmentation/Medical/SegMamba.cs
+++ b/src/ComputerVision/Segmentation/Medical/SegMamba.cs
@@ -683,31 +683,6 @@ private void ExtractLayerReferences()
         ModelData = SerializeForMetadata()
     };
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_inChannels); writer.Write(_numClasses); writer.Write(_stateDim);
-        writer.Write(_dropRate); writer.Write(_useNativeMode); writer.Write(_onnxModelPath ?? string.Empty);
-        writer.Write(_channelDims.Length); foreach (int d in _channelDims) writer.Write(d);
-        writer.Write(_depths.Length); foreach (int d in _depths) writer.Write(d);
-    }
-
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32();
-        _ = reader.ReadDouble(); _ = reader.ReadBoolean(); _ = reader.ReadString();
-        int dc = reader.ReadInt32(); for (int i = 0; i < dc; i++) _ = reader.ReadInt32();
-        int dd = reader.ReadInt32(); for (int i = 0; i < dd; i++) _ = reader.ReadInt32();
-
-        // Layers has already been rebuilt with the loaded weights; re-point the typed
-        // references at them so Forward uses the loaded layers, not the ctor's fresh ones.
-        if (_useNativeMode && Layers.Count > 0)
-            ExtractLayerReferences();
-    }
-
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() => _useNativeMode
-        ? new SegMamba<T>(Architecture, _optimizer, LossFunction, _numClasses, _dropRate, _options)
-        : new SegMamba<T>(Architecture, _onnxModelPath ?? throw new InvalidOperationException("ONNX model path not initialized."), _numClasses, _options);
-
     // Dispose is inherited: SegmentationModelBase already disposes _onnxSession and flips _disposed,
     // and SegMamba owns no other unmanaged resource.
     #endregion
diff --git a/src/ComputerVision/Segmentation/Medical/SwinUNETR.cs b/src/ComputerVision/Segmentation/Medical/SwinUNETR.cs
index fc8346d104..3fb6f86b3e 100644
--- a/src/ComputerVision/Segmentation/Medical/SwinUNETR.cs
+++ b/src/ComputerVision/Segmentation/Medical/SwinUNETR.cs
@@ -58,7 +58,7 @@ namespace AiDotNet.ComputerVision.Segmentation.Medical;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Swin UNETR: Swin Transformers for Semantic Segmentation of Brain Tumors in MRI Images", "https://arxiv.org/abs/2201.01266", Year = 2022, Authors = "Ali Hatamizadeh, Vishwesh Nath, Yucheng Tang, Dong Yang, Holger R. Roth, Daguang Xu")]
-public class SwinUNETR<T> : Common.MedicalSegmentationBase<T>
+public partial class SwinUNETR<T> : Common.MedicalSegmentationBase<T>
 {
     /// <inheritdoc />
     /// <remarks>
@@ -342,43 +342,6 @@ protected override IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>> GetOrCreateB
         ModelData = SerializeForMetadata()
     };
 
-    /// <summary>
-    /// Writes configuration to a binary stream.
-    /// </summary>
-    /// <param name="writer">The binary writer.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Saves model configuration for later reconstruction.
-    /// </para>
-    /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    { writer.Write(_height); writer.Write(_width); writer.Write(_channels); writer.Write(_numClasses); writer.Write((int)_modelSize); writer.Write(_decoderDim); writer.Write(_dropRate); writer.Write(_useNativeMode); writer.Write(_onnxModelPath ?? string.Empty); writer.Write(_encoderLayerEnd); writer.Write(_channelDims.Length); foreach (int d in _channelDims) writer.Write(d); writer.Write(_depths.Length); foreach (int d in _depths) writer.Write(d); }
-
-    /// <summary>
-    /// Reads configuration from a binary stream.
-    /// </summary>
-    /// <param name="reader">The binary reader.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Loads model configuration when restoring a saved model.
-    /// </para>
-    /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    { _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadDouble(); _ = reader.ReadBoolean(); _ = reader.ReadString(); _ = reader.ReadInt32(); int dc = reader.ReadInt32(); for (int i = 0; i < dc; i++) _ = reader.ReadInt32(); int dd = reader.ReadInt32(); for (int i = 0; i < dd; i++) _ = reader.ReadInt32(); }
-
-    /// <summary>
-    /// Creates a new instance with the same configuration but fresh weights.
-    /// </summary>
-    /// <returns>A new model instance.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Creates a copy for cross-validation or ensemble training.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() => _useNativeMode
-        ? new SwinUNETR<T>(Architecture, optimizer: null, LossFunction, _numClasses, _modelSize, _dropRate, _options)
-        : new SwinUNETR<T>(Architecture, _onnxModelPath ?? throw new InvalidOperationException("ONNX model path not initialized."), _numClasses, _modelSize, _options);
-
     // Dispose is inherited: SegmentationModelBase already disposes _onnxSession and flips _disposed,
     // and SwinUNETR owns no other unmanaged resource.
     #endregion
diff --git a/src/ComputerVision/Segmentation/Medical/TransUNet.cs b/src/ComputerVision/Segmentation/Medical/TransUNet.cs
index 0b54097e4e..f750622ef5 100644
--- a/src/ComputerVision/Segmentation/Medical/TransUNet.cs
+++ b/src/ComputerVision/Segmentation/Medical/TransUNet.cs
@@ -57,7 +57,7 @@ namespace AiDotNet.ComputerVision.Segmentation.Medical;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("TransUNet: Transformers Make Strong Encoders for Medical Image Segmentation", "https://arxiv.org/abs/2102.04306", Year = 2021, Authors = "Jieneng Chen, Yongyi Lu, Qihang Yu, Xiangde Luo, Ehsan Adeli, Yan Wang, Le Lu, Alan L. Yuille, Yuyin Zhou")]
-public class TransUNet<T> : Common.MedicalSegmentationBase<T>
+public partial class TransUNet<T> : Common.MedicalSegmentationBase<T>
 {
     private readonly TransUNetOptions _options;
     public override ModelOptions GetOptions() => _options;
@@ -274,43 +274,6 @@ protected override void InitializeLayers()
         ModelData = SerializeForMetadata()
     };
 
-    /// <summary>
-    /// Writes configuration to a binary stream.
-    /// </summary>
-    /// <param name="writer">The binary writer.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Saves model configuration for later reconstruction.
-    /// </para>
-    /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    { writer.Write(_height); writer.Write(_width); writer.Write(_channels); writer.Write(_numClasses); writer.Write((int)_modelSize); writer.Write(_decoderDim); writer.Write(_dropRate); writer.Write(_useNativeMode); writer.Write(_onnxModelPath ?? string.Empty); writer.Write(_encoderLayerEnd); writer.Write(_channelDims.Length); foreach (int d in _channelDims) writer.Write(d); writer.Write(_depths.Length); foreach (int d in _depths) writer.Write(d); }
-
-    /// <summary>
-    /// Reads configuration from a binary stream.
-    /// </summary>
-    /// <param name="reader">The binary reader.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Loads model configuration when restoring a saved model.
-    /// </para>
-    /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    { _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadDouble(); _ = reader.ReadBoolean(); _ = reader.ReadString(); _ = reader.ReadInt32(); int dc = reader.ReadInt32(); for (int i = 0; i < dc; i++) _ = reader.ReadInt32(); int dd = reader.ReadInt32(); for (int i = 0; i < dd; i++) _ = reader.ReadInt32(); }
-
-    /// <summary>
-    /// Creates a new instance with the same configuration but fresh weights.
-    /// </summary>
-    /// <returns>A new model instance.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Creates a copy for cross-validation or ensemble training.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() => _useNativeMode
-        ? new TransUNet<T>(Architecture, _optimizer, LossFunction, _numClasses, _modelSize, _dropRate, _options)
-        : new TransUNet<T>(Architecture, _onnxModelPath ?? throw new InvalidOperationException("ONNX model path not initialized."), _numClasses, _modelSize, _options);
-
     // Dispose is inherited: SegmentationModelBase already disposes _onnxSession and flips _disposed,
     // and TransUNet owns no other unmanaged resource.
     #endregion
diff --git a/src/ComputerVision/Segmentation/Medical/UMamba.cs b/src/ComputerVision/Segmentation/Medical/UMamba.cs
index 42b5f6c602..de79564a12 100644
--- a/src/ComputerVision/Segmentation/Medical/UMamba.cs
+++ b/src/ComputerVision/Segmentation/Medical/UMamba.cs
@@ -56,7 +56,7 @@ namespace AiDotNet.ComputerVision.Segmentation.Medical;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("U-Mamba: Enhancing Long-range Dependency for Biomedical Image Segmentation", "https://arxiv.org/abs/2401.04722", Year = 2024, Authors = "Ma et al.")]
-public class UMamba<T> : Common.MedicalSegmentationBase<T>
+public partial class UMamba<T> : Common.MedicalSegmentationBase<T>
 {
     private readonly UMambaOptions _options;
     public override ModelOptions GetOptions() => _options;
@@ -262,43 +262,6 @@ protected override void InitializeLayers()
         ModelData = SerializeForMetadata()
     };
 
-    /// <summary>
-    /// Writes configuration to a binary stream.
-    /// </summary>
-    /// <param name="writer">The binary writer.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Saves model configuration for later reconstruction.
-    /// </para>
-    /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    { writer.Write(_height); writer.Write(_width); writer.Write(_channels); writer.Write(_numClasses); writer.Write(_decoderDim); writer.Write(_dropRate); writer.Write(_useNativeMode); writer.Write(_onnxModelPath ?? string.Empty); writer.Write(_encoderLayerEnd); writer.Write(_channelDims.Length); foreach (int d in _channelDims) writer.Write(d); writer.Write(_depths.Length); foreach (int d in _depths) writer.Write(d); }
-
-    /// <summary>
-    /// Reads configuration from a binary stream.
-    /// </summary>
-    /// <param name="reader">The binary reader.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Loads model configuration when restoring a saved model.
-    /// </para>
-    /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    { _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadDouble(); _ = reader.ReadBoolean(); _ = reader.ReadString(); _ = reader.ReadInt32(); int dc = reader.ReadInt32(); for (int i = 0; i < dc; i++) _ = reader.ReadInt32(); int dd = reader.ReadInt32(); for (int i = 0; i < dd; i++) _ = reader.ReadInt32(); }
-
-    /// <summary>
-    /// Creates a new instance with the same configuration but fresh weights.
-    /// </summary>
-    /// <returns>A new model instance.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Creates a copy for cross-validation or ensemble training.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() => _useNativeMode
-        ? new UMamba<T>(Architecture, _optimizer, LossFunction, _numClasses, _dropRate, _options)
-        : new UMamba<T>(Architecture, _onnxModelPath ?? throw new InvalidOperationException("ONNX model path not initialized."), _numClasses, _options);
-
     // Dispose is inherited: SegmentationModelBase already disposes _onnxSession and flips _disposed,
     // and UMamba owns no other unmanaged resource.
     #endregion
diff --git a/src/ComputerVision/Segmentation/Medical/UniverSeg.cs b/src/ComputerVision/Segmentation/Medical/UniverSeg.cs
index 9aaa719c36..fdf8314556 100644
--- a/src/ComputerVision/Segmentation/Medical/UniverSeg.cs
+++ b/src/ComputerVision/Segmentation/Medical/UniverSeg.cs
@@ -56,7 +56,7 @@ namespace AiDotNet.ComputerVision.Segmentation.Medical;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("UniverSeg: Universal Medical Image Segmentation", "https://arxiv.org/abs/2304.06131", Year = 2023, Authors = "Butoi et al.")]
-public class UniverSeg<T> : Common.MedicalSegmentationBase<T>
+public partial class UniverSeg<T> : Common.MedicalSegmentationBase<T>
 {
     private readonly UniverSegOptions _options;
     public override ModelOptions GetOptions() => _options;
@@ -265,43 +265,6 @@ protected override void InitializeLayers()
         ModelData = SerializeForMetadata()
     };
 
-    /// <summary>
-    /// Writes configuration to a binary stream.
-    /// </summary>
-    /// <param name="writer">The binary writer.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Saves model configuration for later reconstruction.
-    /// </para>
-    /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    { writer.Write(_height); writer.Write(_width); writer.Write(_channels); writer.Write(_numClasses); writer.Write(_decoderDim); writer.Write(_dropRate); writer.Write(_useNativeMode); writer.Write(_onnxModelPath ?? string.Empty); writer.Write(_encoderLayerEnd); writer.Write(_channelDims.Length); foreach (int d in _channelDims) writer.Write(d); writer.Write(_depths.Length); foreach (int d in _depths) writer.Write(d); }
-
-    /// <summary>
-    /// Reads configuration from a binary stream.
-    /// </summary>
-    /// <param name="reader">The binary reader.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Loads model configuration when restoring a saved model.
-    /// </para>
-    /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    { _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadDouble(); _ = reader.ReadBoolean(); _ = reader.ReadString(); _ = reader.ReadInt32(); int dc = reader.ReadInt32(); for (int i = 0; i < dc; i++) _ = reader.ReadInt32(); int dd = reader.ReadInt32(); for (int i = 0; i < dd; i++) _ = reader.ReadInt32(); }
-
-    /// <summary>
-    /// Creates a new instance with the same configuration but fresh weights.
-    /// </summary>
-    /// <returns>A new model instance.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Creates a copy for cross-validation or ensemble training.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() => _useNativeMode
-        ? new UniverSeg<T>(Architecture, _optimizer, LossFunction, _numClasses, _dropRate, _options)
-        : new UniverSeg<T>(Architecture, _onnxModelPath ?? throw new InvalidOperationException("ONNX model path not initialized."), _numClasses, _options);
-
     // Dispose is inherited: SegmentationModelBase already disposes _onnxSession and flips _disposed,
     // and UniverSeg owns no other unmanaged resource.
     #endregion
diff --git a/src/ComputerVision/Segmentation/OpenVocabulary/CATSeg.cs b/src/ComputerVision/Segmentation/OpenVocabulary/CATSeg.cs
index 805e7f5204..7bbceef714 100644
--- a/src/ComputerVision/Segmentation/OpenVocabulary/CATSeg.cs
+++ b/src/ComputerVision/Segmentation/OpenVocabulary/CATSeg.cs
@@ -58,7 +58,7 @@ namespace AiDotNet.ComputerVision.Segmentation.OpenVocabulary;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("CAT-Seg: Cost Aggregation for Open-Vocabulary Semantic Segmentation", "https://arxiv.org/abs/2303.11797", Year = 2024, Authors = "Cho et al.")]
-public class CATSeg<T> : Common.OpenVocabSegmentationBase<T>
+public partial class CATSeg<T> : Common.OpenVocabSegmentationBase<T>
 {
     private readonly CATSegOptions _options;
     public override ModelOptions GetOptions() => _options;
@@ -277,43 +277,6 @@ protected override void InitializeLayers()
         ModelData = SerializeForMetadata()
     };
 
-    /// <summary>
-    /// Writes configuration to a binary stream.
-    /// </summary>
-    /// <param name="writer">The binary writer.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Saves model configuration for later reconstruction.
-    /// </para>
-    /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    { writer.Write(_height); writer.Write(_width); writer.Write(_channels); writer.Write(_numClasses); writer.Write(_decoderDim); writer.Write(_dropRate); writer.Write(_useNativeMode); writer.Write(_onnxModelPath ?? string.Empty); writer.Write(_encoderLayerEnd); writer.Write(_channelDims.Length); foreach (int d in _channelDims) writer.Write(d); writer.Write(_depths.Length); foreach (int d in _depths) writer.Write(d); }
-
-    /// <summary>
-    /// Reads configuration from a binary stream.
-    /// </summary>
-    /// <param name="reader">The binary reader.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Loads model configuration when restoring a saved model.
-    /// </para>
-    /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    { _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadDouble(); _ = reader.ReadBoolean(); _ = reader.ReadString(); _ = reader.ReadInt32(); int dc = reader.ReadInt32(); for (int i = 0; i < dc; i++) _ = reader.ReadInt32(); int dd = reader.ReadInt32(); for (int i = 0; i < dd; i++) _ = reader.ReadInt32(); }
-
-    /// <summary>
-    /// Creates a new instance with the same configuration but fresh weights.
-    /// </summary>
-    /// <returns>A new model instance.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Creates a copy for cross-validation or ensemble training.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() => _useNativeMode
-        ? new CATSeg<T>(Architecture, _optimizer, LossFunction, _numClasses, _dropRate, _options)
-        : new CATSeg<T>(Architecture, _onnxModelPath ?? throw new InvalidOperationException("ONNX model path not initialized."), _numClasses, _options);
-
     // Dispose is inherited: SegmentationModelBase already disposes _onnxSession and flips _disposed,
     // and CATSeg owns no other unmanaged resource.
     #endregion
diff --git a/src/ComputerVision/Segmentation/OpenVocabulary/GroundedSAM2.cs b/src/ComputerVision/Segmentation/OpenVocabulary/GroundedSAM2.cs
index 9cd1e1f8e4..5384e02e9b 100644
--- a/src/ComputerVision/Segmentation/OpenVocabulary/GroundedSAM2.cs
+++ b/src/ComputerVision/Segmentation/OpenVocabulary/GroundedSAM2.cs
@@ -59,7 +59,7 @@ namespace AiDotNet.ComputerVision.Segmentation.OpenVocabulary;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Grounded SAM: Assembling Open-World Models for Diverse Visual Tasks", "https://arxiv.org/abs/2401.14159", Year = 2024, Authors = "Ren et al.")]
-public class GroundedSAM2<T> : Common.OpenVocabSegmentationBase<T>
+public partial class GroundedSAM2<T> : Common.OpenVocabSegmentationBase<T>
 {
     /// <inheritdoc />
     /// <remarks>
@@ -459,49 +459,6 @@ public override Dictionary<string, Tensor<T>> GetNamedLayerActivations(Tensor<T>
         ModelData = SerializeForMetadata()
     };
 
-    /// <summary>
-    /// Writes configuration to a binary stream.
-    /// </summary>
-    /// <param name="writer">The binary writer.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Saves model configuration for later reconstruction.
-    /// </para>
-    /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    { writer.Write(_height); writer.Write(_width); writer.Write(_channels); writer.Write(_numClasses); writer.Write(_decoderDim); writer.Write(_dropRate); writer.Write(_useNativeMode); writer.Write(_onnxModelPath ?? string.Empty); writer.Write(_encoderLayerEnd); }
-
-    /// <summary>
-    /// Reads configuration from a binary stream.
-    /// </summary>
-    /// <param name="reader">The binary reader.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Loads model configuration when restoring a saved model.
-    /// </para>
-    /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    { _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadDouble(); _ = reader.ReadBoolean(); _ = reader.ReadString(); _ = reader.ReadInt32(); }
-
-    /// <summary>
-    /// Creates a new instance with the same configuration but fresh weights.
-    /// </summary>
-    /// <returns>A new model instance.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Creates a copy for cross-validation or ensemble training.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() => _useNativeMode
-        ? new GroundedSAM2<T>(
-            architecture: Architecture,
-            optimizer: null,
-            lossFunction: LossFunction,
-            numClasses: _numClasses,
-            dropRate: _dropRate,
-            options: new GroundedSAM2Options(_options))
-        : new GroundedSAM2<T>(Architecture, _onnxModelPath ?? throw new InvalidOperationException("ONNX model path not initialized."), _numClasses, new GroundedSAM2Options(_options));
-
     // Dispose is inherited: SegmentationModelBase already disposes _onnxSession and flips _disposed,
     // and GroundedSAM2 owns no other unmanaged resource.
     #endregion
diff --git a/src/ComputerVision/Segmentation/OpenVocabulary/MaskAdapter.cs b/src/ComputerVision/Segmentation/OpenVocabulary/MaskAdapter.cs
index b7918ce315..29a5a7c1fe 100644
--- a/src/ComputerVision/Segmentation/OpenVocabulary/MaskAdapter.cs
+++ b/src/ComputerVision/Segmentation/OpenVocabulary/MaskAdapter.cs
@@ -56,7 +56,7 @@ namespace AiDotNet.ComputerVision.Segmentation.OpenVocabulary;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Mask-Adapter: The Devil is in the Masks for Open-Vocabulary Segmentation", "https://arxiv.org/abs/2412.04533", Year = 2025, Authors = "Yongkang Li, Tianheng Cheng, Wenyu Liu, Xinggang Wang")]
-public class MaskAdapter<T> : Common.OpenVocabSegmentationBase<T>
+public partial class MaskAdapter<T> : Common.OpenVocabSegmentationBase<T>
 {
     private readonly MaskAdapterOptions _options;
     public override ModelOptions GetOptions() => _options;
@@ -274,43 +274,6 @@ protected override void InitializeLayers()
         ModelData = SerializeForMetadata()
     };
 
-    /// <summary>
-    /// Writes configuration to a binary stream.
-    /// </summary>
-    /// <param name="writer">The binary writer.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Saves model configuration for later reconstruction.
-    /// </para>
-    /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    { writer.Write(_height); writer.Write(_width); writer.Write(_channels); writer.Write(_numClasses); writer.Write(_decoderDim); writer.Write(_dropRate); writer.Write(_useNativeMode); writer.Write(_onnxModelPath ?? string.Empty); writer.Write(_encoderLayerEnd); writer.Write(_channelDims.Length); foreach (int d in _channelDims) writer.Write(d); writer.Write(_depths.Length); foreach (int d in _depths) writer.Write(d); }
-
-    /// <summary>
-    /// Reads configuration from a binary stream.
-    /// </summary>
-    /// <param name="reader">The binary reader.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Loads model configuration when restoring a saved model.
-    /// </para>
-    /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    { _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadDouble(); _ = reader.ReadBoolean(); _ = reader.ReadString(); _ = reader.ReadInt32(); int dc = reader.ReadInt32(); for (int i = 0; i < dc; i++) _ = reader.ReadInt32(); int dd = reader.ReadInt32(); for (int i = 0; i < dd; i++) _ = reader.ReadInt32(); }
-
-    /// <summary>
-    /// Creates a new instance with the same configuration but fresh weights.
-    /// </summary>
-    /// <returns>A new model instance.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Creates a copy for cross-validation or ensemble training.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() => _useNativeMode
-        ? new MaskAdapter<T>(Architecture, _optimizer, LossFunction, _numClasses, _dropRate, _options)
-        : new MaskAdapter<T>(Architecture, _onnxModelPath ?? throw new InvalidOperationException("ONNX model path not initialized."), _numClasses, _options);
-
     // Dispose is inherited: SegmentationModelBase already disposes _onnxSession and flips _disposed,
     // and MaskAdapter owns no other unmanaged resource.
     #endregion
diff --git a/src/ComputerVision/Segmentation/OpenVocabulary/OpenVocabSAM.cs b/src/ComputerVision/Segmentation/OpenVocabulary/OpenVocabSAM.cs
index a92a4a7d9f..14f0c9ec60 100644
--- a/src/ComputerVision/Segmentation/OpenVocabulary/OpenVocabSAM.cs
+++ b/src/ComputerVision/Segmentation/OpenVocabulary/OpenVocabSAM.cs
@@ -58,7 +58,7 @@ namespace AiDotNet.ComputerVision.Segmentation.OpenVocabulary;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Open-Vocabulary SAM: Segment and Recognize Twenty-thousand Classes Interactively", "https://arxiv.org/abs/2401.02955", Year = 2024, Authors = "Yuan et al.")]
-public class OpenVocabSAM<T> : Common.OpenVocabSegmentationBase<T>
+public partial class OpenVocabSAM<T> : Common.OpenVocabSegmentationBase<T>
 {
     private readonly OpenVocabSAMOptions _options;
     public override ModelOptions GetOptions() => _options;
@@ -279,65 +279,6 @@ protected override void InitializeLayers()
         ModelData = SerializeForMetadata()
     };
 
-    /// <summary>
-    /// Writes configuration to a binary stream.
-    /// </summary>
-    /// <param name="writer">The binary writer.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Saves model configuration for later reconstruction.
-    /// </para>
-    /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_height); writer.Write(_width); writer.Write(_channels); writer.Write(_numClasses);
-        writer.Write(_decoderDim); writer.Write(_dropRate); writer.Write(_useNativeMode);
-        writer.Write(_onnxModelPath ?? string.Empty); writer.Write(_encoderLayerEnd);
-        writer.Write(_channelDims.Length); foreach (int d in _channelDims) writer.Write(d);
-        writer.Write(_depths.Length); foreach (int d in _depths) writer.Write(d);
-        writer.Write(_neckEmbeddingDim);
-        writer.Write(_options.LearningRate);
-        writer.Write(_options.WeightDecay);
-    }
-
-    /// <summary>
-    /// Reads configuration from a binary stream.
-    /// </summary>
-    /// <param name="reader">The binary reader.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Loads model configuration when restoring a saved model.
-    /// </para>
-    /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32();
-        _ = reader.ReadInt32(); _ = reader.ReadDouble(); _ = reader.ReadBoolean(); _ = reader.ReadString();
-        _ = reader.ReadInt32();
-        int dc = reader.ReadInt32(); for (int i = 0; i < dc; i++) _ = reader.ReadInt32();
-        int dd = reader.ReadInt32(); for (int i = 0; i < dd; i++) _ = reader.ReadInt32();
-        if (reader.BaseStream.Position < reader.BaseStream.Length)
-        {
-            _options.NeckEmbeddingDimension = reader.ReadInt32();
-            _options.LearningRate = reader.ReadDouble();
-            _options.WeightDecay = reader.ReadDouble();
-        }
-    }
-
-    /// <summary>
-    /// Creates a new instance with the same configuration but fresh weights.
-    /// </summary>
-    /// <returns>A new model instance.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Creates a copy for cross-validation or ensemble training.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() => _useNativeMode
-        ? new OpenVocabSAM<T>(Architecture, lossFunction: LossFunction, numClasses: _numClasses,
-            dropRate: _dropRate, options: _options)
-        : new OpenVocabSAM<T>(Architecture, _onnxModelPath ?? throw new InvalidOperationException("ONNX model path not initialized."), _numClasses, _options);
-
     /// <summary>
     /// Open-Vocabulary SAM's default optimizer is AdamW configured from the model options.
     /// </summary>
diff --git a/src/ComputerVision/Segmentation/OpenVocabulary/SAN.cs b/src/ComputerVision/Segmentation/OpenVocabulary/SAN.cs
index 015ff39734..3898925846 100644
--- a/src/ComputerVision/Segmentation/OpenVocabulary/SAN.cs
+++ b/src/ComputerVision/Segmentation/OpenVocabulary/SAN.cs
@@ -56,7 +56,7 @@ namespace AiDotNet.ComputerVision.Segmentation.OpenVocabulary;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Side Adapter Network for Open-Vocabulary Semantic Segmentation", "https://arxiv.org/abs/2302.12242", Year = 2023, Authors = "Xu et al.")]
-public class SAN<T> : Common.OpenVocabSegmentationBase<T>
+public partial class SAN<T> : Common.OpenVocabSegmentationBase<T>
 {
     private readonly SANOptions _options;
     public override ModelOptions GetOptions() => _options;
@@ -257,43 +257,6 @@ protected override void InitializeLayers()
         ModelData = SerializeForMetadata()
     };
 
-    /// <summary>
-    /// Writes configuration to a binary stream.
-    /// </summary>
-    /// <param name="writer">The binary writer.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Saves model configuration for later reconstruction.
-    /// </para>
-    /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    { writer.Write(_height); writer.Write(_width); writer.Write(_channels); writer.Write(_numClasses); writer.Write(_decoderDim); writer.Write(_dropRate); writer.Write(_useNativeMode); writer.Write(_onnxModelPath ?? string.Empty); writer.Write(_encoderLayerEnd); writer.Write(_channelDims.Length); foreach (int d in _channelDims) writer.Write(d); writer.Write(_depths.Length); foreach (int d in _depths) writer.Write(d); }
-
-    /// <summary>
-    /// Reads configuration from a binary stream.
-    /// </summary>
-    /// <param name="reader">The binary reader.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Loads model configuration when restoring a saved model.
-    /// </para>
-    /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    { _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadDouble(); _ = reader.ReadBoolean(); _ = reader.ReadString(); _ = reader.ReadInt32(); int dc = reader.ReadInt32(); for (int i = 0; i < dc; i++) _ = reader.ReadInt32(); int dd = reader.ReadInt32(); for (int i = 0; i < dd; i++) _ = reader.ReadInt32(); }
-
-    /// <summary>
-    /// Creates a new instance with the same configuration but fresh weights.
-    /// </summary>
-    /// <returns>A new model instance.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Creates a copy for cross-validation or ensemble training.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() => _useNativeMode
-        ? new SAN<T>(Architecture, _optimizer, LossFunction, _numClasses, _dropRate, _options)
-        : new SAN<T>(Architecture, _onnxModelPath ?? throw new InvalidOperationException("ONNX model path not initialized."), _numClasses, _options);
-
     // Dispose is inherited: SegmentationModelBase already disposes _onnxSession and flips _disposed,
     // and SAN owns no other unmanaged resource.
     #endregion
diff --git a/src/ComputerVision/Segmentation/OpenVocabulary/SED.cs b/src/ComputerVision/Segmentation/OpenVocabulary/SED.cs
index 29c757ee20..b193911337 100644
--- a/src/ComputerVision/Segmentation/OpenVocabulary/SED.cs
+++ b/src/ComputerVision/Segmentation/OpenVocabulary/SED.cs
@@ -56,7 +56,7 @@ namespace AiDotNet.ComputerVision.Segmentation.OpenVocabulary;
 [ModelComplexity(ModelComplexity.Low)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("SED: A Simple Encoder-Decoder for Open-Vocabulary Semantic Segmentation", "https://arxiv.org/abs/2311.15537", Year = 2024, Authors = "Xie et al.")]
-public class SED<T> : Common.OpenVocabSegmentationBase<T>
+public partial class SED<T> : Common.OpenVocabSegmentationBase<T>
 {
     private readonly SEDOptions _options;
     public override ModelOptions GetOptions() => _options;
@@ -254,43 +254,6 @@ protected override void InitializeLayers()
         AdditionalInfo = new Dictionary<string, object> { { "ModelName", "SED" }, { "InputHeight", _height }, { "InputWidth", _width }, { "NumClasses", _numClasses }, { "UseNativeMode", _useNativeMode }, { "NumLayers", Layers.Count } },
         ModelData = SerializeForMetadata()
     };
-
-    /// <summary>
-    /// Writes configuration to a binary stream.
-    /// </summary>
-    /// <param name="writer">The binary writer.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Saves model configuration for later reconstruction.
-    /// </para>
-    /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    { writer.Write(_height); writer.Write(_width); writer.Write(_channels); writer.Write(_numClasses); writer.Write(_decoderDim); writer.Write(_dropRate); writer.Write(_useNativeMode); writer.Write(_onnxModelPath ?? string.Empty); writer.Write(_encoderLayerEnd); writer.Write(_channelDims.Length); foreach (int d in _channelDims) writer.Write(d); writer.Write(_depths.Length); foreach (int d in _depths) writer.Write(d); }
-
-    /// <summary>
-    /// Reads configuration from a binary stream.
-    /// </summary>
-    /// <param name="reader">The binary reader.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Loads model configuration when restoring a saved model.
-    /// </para>
-    /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    { _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadDouble(); _ = reader.ReadBoolean(); _ = reader.ReadString(); _ = reader.ReadInt32(); int dc = reader.ReadInt32(); for (int i = 0; i < dc; i++) _ = reader.ReadInt32(); int dd = reader.ReadInt32(); for (int i = 0; i < dd; i++) _ = reader.ReadInt32(); }
-
-    /// <summary>
-    /// Creates a new instance with the same configuration but fresh weights.
-    /// </summary>
-    /// <returns>A new model instance.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Creates a copy for cross-validation or ensemble training.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() => _useNativeMode
-        ? new SED<T>(Architecture, _optimizer, LossFunction, _numClasses, _dropRate, _options)
-        : new SED<T>(Architecture, _onnxModelPath ?? throw new InvalidOperationException("ONNX model path not initialized."), _numClasses, _options);
     #endregion
 
     #region IOpenVocabSegmentation Implementation
diff --git a/src/ComputerVision/Segmentation/Panoptic/CUPS.cs b/src/ComputerVision/Segmentation/Panoptic/CUPS.cs
index e55770aa03..9b1de4816c 100644
--- a/src/ComputerVision/Segmentation/Panoptic/CUPS.cs
+++ b/src/ComputerVision/Segmentation/Panoptic/CUPS.cs
@@ -67,7 +67,7 @@ namespace AiDotNet.ComputerVision.Segmentation.Panoptic;
     "https://arxiv.org/abs/2504.01955",
     Year = 2025,
     Authors = "Oliver Hahn, Christoph Reich, Nikita Araslanov, Daniel Cremers, Christian Rupprecht, Stefan Roth")]
-public class CUPS<T> : Common.PanopticSegmentationBase<T>
+public partial class CUPS<T> : Common.PanopticSegmentationBase<T>
 {
     private readonly CUPSOptions _options;
     public override ModelOptions GetOptions() => _options;
@@ -272,48 +272,6 @@ protected override void InitializeLayers()
         AdditionalInfo = new Dictionary<string, object> { { "ModelName", "CUPS" }, { "InputHeight", _height }, { "InputWidth", _width }, { "NumClasses", _numClasses }, { "UseNativeMode", _useNativeMode }, { "NumLayers", Layers.Count } },
         ModelData = SerializeForMetadata()
     };
-
-    /// <summary>
-    /// Writes configuration to a binary stream.
-    /// </summary>
-    /// <param name="writer">The binary writer.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Saves model configuration for later reconstruction.
-    /// </para>
-    /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    { writer.Write(_height); writer.Write(_width); writer.Write(_channels); writer.Write(_numClasses); writer.Write(_decoderDim); writer.Write(_dropRate); writer.Write(_useNativeMode); writer.Write(_onnxModelPath ?? string.Empty); writer.Write(_encoderLayerEnd); writer.Write(_channelDims.Length); foreach (int d in _channelDims) writer.Write(d); writer.Write(_depths.Length); foreach (int d in _depths) writer.Write(d); }
-
-    /// <summary>
-    /// Reads configuration from a binary stream.
-    /// </summary>
-    /// <param name="reader">The binary reader.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Loads model configuration when restoring a saved model.
-    /// </para>
-    /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    { _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadDouble(); _ = reader.ReadBoolean(); _ = reader.ReadString(); _ = reader.ReadInt32(); int dc = reader.ReadInt32(); for (int i = 0; i < dc; i++) _ = reader.ReadInt32(); int dd = reader.ReadInt32(); for (int i = 0; i < dd; i++) _ = reader.ReadInt32(); }
-
-    /// <summary>
-    /// Creates a new instance with the same configuration but fresh weights.
-    /// </summary>
-    /// <returns>A new model instance.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Creates a copy for cross-validation or ensemble training.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var cloneOptions = new CUPSOptions(_options);
-        return _useNativeMode
-            ? new CUPS<T>(Architecture, optimizer: null, lossFunction: LossFunction,
-                numClasses: _numClasses, dropRate: _dropRate, options: cloneOptions)
-            : new CUPS<T>(Architecture, _onnxModelPath ?? throw new InvalidOperationException("ONNX model path not initialized."), _numClasses, cloneOptions);
-    }
     #endregion
 
     #region IPanopticSegmentation Implementation
diff --git a/src/ComputerVision/Segmentation/Panoptic/KMaXDeepLab.cs b/src/ComputerVision/Segmentation/Panoptic/KMaXDeepLab.cs
index b4601c210c..54e522a9f7 100644
--- a/src/ComputerVision/Segmentation/Panoptic/KMaXDeepLab.cs
+++ b/src/ComputerVision/Segmentation/Panoptic/KMaXDeepLab.cs
@@ -55,7 +55,7 @@ namespace AiDotNet.ComputerVision.Segmentation.Panoptic;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("k-means Mask Transformer", "https://arxiv.org/abs/2207.04044", Year = 2022, Authors = "Yu et al.")]
-public class KMaXDeepLab<T> : Common.PanopticSegmentationBase<T>
+public partial class KMaXDeepLab<T> : Common.PanopticSegmentationBase<T>
 {
     private readonly KMaXDeepLabOptions _options;
     public override ModelOptions GetOptions() => _options;
@@ -267,43 +267,6 @@ protected override void InitializeLayers()
         AdditionalInfo = new Dictionary<string, object> { { "ModelName", "KMaXDeepLab" }, { "InputHeight", _height }, { "InputWidth", _width }, { "NumClasses", _numClasses }, { "ModelSize", _modelSize.ToString() }, { "UseNativeMode", _useNativeMode }, { "NumLayers", Layers.Count } },
         ModelData = SerializeForMetadata()
     };
-
-    /// <summary>
-    /// Writes configuration to a binary stream.
-    /// </summary>
-    /// <param name="writer">The binary writer.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Saves model configuration for later reconstruction.
-    /// </para>
-    /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    { writer.Write(_height); writer.Write(_width); writer.Write(_channels); writer.Write(_numClasses); writer.Write((int)_modelSize); writer.Write(_decoderDim); writer.Write(_dropRate); writer.Write(_useNativeMode); writer.Write(_onnxModelPath ?? string.Empty); writer.Write(_encoderLayerEnd); writer.Write(_channelDims.Length); foreach (int d in _channelDims) writer.Write(d); writer.Write(_depths.Length); foreach (int d in _depths) writer.Write(d); }
-
-    /// <summary>
-    /// Reads configuration from a binary stream.
-    /// </summary>
-    /// <param name="reader">The binary reader.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Loads model configuration when restoring a saved model.
-    /// </para>
-    /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    { _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadDouble(); _ = reader.ReadBoolean(); _ = reader.ReadString(); _ = reader.ReadInt32(); int dc = reader.ReadInt32(); for (int i = 0; i < dc; i++) _ = reader.ReadInt32(); int dd = reader.ReadInt32(); for (int i = 0; i < dd; i++) _ = reader.ReadInt32(); }
-
-    /// <summary>
-    /// Creates a new instance with the same configuration but fresh weights.
-    /// </summary>
-    /// <returns>A new model instance.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Creates a copy for cross-validation or ensemble training.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() => _useNativeMode
-        ? new KMaXDeepLab<T>(Architecture, _optimizer, LossFunction, _numClasses, _modelSize, _dropRate, _options)
-        : new KMaXDeepLab<T>(Architecture, _onnxModelPath ?? throw new InvalidOperationException("ONNX model path not initialized."), _numClasses, _modelSize, _options);
     #endregion
 
     #region IPanopticSegmentation Implementation
diff --git a/src/ComputerVision/Segmentation/Panoptic/ODISE.cs b/src/ComputerVision/Segmentation/Panoptic/ODISE.cs
index e755818d03..2265f071d1 100644
--- a/src/ComputerVision/Segmentation/Panoptic/ODISE.cs
+++ b/src/ComputerVision/Segmentation/Panoptic/ODISE.cs
@@ -56,7 +56,7 @@ namespace AiDotNet.ComputerVision.Segmentation.Panoptic;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Open-Vocabulary Panoptic Segmentation with Text-to-Image Diffusion Models", "https://arxiv.org/abs/2303.04803", Year = 2023, Authors = "Xu et al.")]
-public class ODISE<T> : Common.PanopticSegmentationBase<T>
+public partial class ODISE<T> : Common.PanopticSegmentationBase<T>
 {
     /// <inheritdoc />
     /// <remarks>
@@ -443,43 +443,6 @@ protected override void ResolveLazyLayerShapes()
         AdditionalInfo = new Dictionary<string, object> { { "ModelName", "ODISE" }, { "InputHeight", _height }, { "InputWidth", _width }, { "NumClasses", _numClasses }, { "ModelSize", _modelSize.ToString() }, { "UseNativeMode", _useNativeMode }, { "NumLayers", Layers.Count } },
         ModelData = SerializeForMetadata()
     };
-
-    /// <summary>
-    /// Writes configuration to a binary stream.
-    /// </summary>
-    /// <param name="writer">The binary writer.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Saves model configuration for later reconstruction.
-    /// </para>
-    /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    { writer.Write(_height); writer.Write(_width); writer.Write(_channels); writer.Write(_numClasses); writer.Write((int)_modelSize); writer.Write(_decoderDim); writer.Write(_dropRate); writer.Write(_useNativeMode); writer.Write(_onnxModelPath ?? string.Empty); writer.Write(_encoderLayerEnd); writer.Write(_channelDims.Length); foreach (int d in _channelDims) writer.Write(d); writer.Write(_depths.Length); foreach (int d in _depths) writer.Write(d); }
-
-    /// <summary>
-    /// Reads configuration from a binary stream.
-    /// </summary>
-    /// <param name="reader">The binary reader.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Loads model configuration when restoring a saved model.
-    /// </para>
-    /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    { _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadDouble(); _ = reader.ReadBoolean(); _ = reader.ReadString(); _ = reader.ReadInt32(); int dc = reader.ReadInt32(); for (int i = 0; i < dc; i++) _ = reader.ReadInt32(); int dd = reader.ReadInt32(); for (int i = 0; i < dd; i++) _ = reader.ReadInt32(); }
-
-    /// <summary>
-    /// Creates a new instance with the same configuration but fresh weights.
-    /// </summary>
-    /// <returns>A new model instance.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Creates a copy for cross-validation or ensemble training.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() => _useNativeMode
-        ? new ODISE<T>(Architecture, _optimizer, LossFunction, _numClasses, _modelSize, _dropRate, _options)
-        : new ODISE<T>(Architecture, _onnxModelPath ?? throw new InvalidOperationException("ONNX model path not initialized."), _numClasses, _modelSize, _options);
     #endregion
 
     #region IPanopticSegmentation Implementation
diff --git a/src/ComputerVision/Segmentation/PointCloud/Concerto.cs b/src/ComputerVision/Segmentation/PointCloud/Concerto.cs
index eee6a95918..f1d2d88cb2 100644
--- a/src/ComputerVision/Segmentation/PointCloud/Concerto.cs
+++ b/src/ComputerVision/Segmentation/PointCloud/Concerto.cs
@@ -85,7 +85,7 @@ namespace AiDotNet.ComputerVision.Segmentation.PointCloud;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Concerto: Joint 2D-3D Self-Supervised Learning Emerges Spatial Representations", "https://arxiv.org/abs/2510.23607", Year = 2025)]
-public class Concerto<T> : Common.SemanticSegmentationBase<T>
+public partial class Concerto<T> : Common.SemanticSegmentationBase<T>
 {
     private readonly ConcertoOptions _options;
     public override ModelOptions GetOptions() => _options;
@@ -294,43 +294,6 @@ protected override void InitializeLayers()
         AdditionalInfo = new Dictionary<string, object> { { "ModelName", "Concerto" }, { "InputHeight", _height }, { "InputWidth", _width }, { "NumClasses", _numClasses }, { "ModelSize", _modelSize.ToString() }, { "UseNativeMode", _useNativeMode }, { "NumLayers", Layers.Count } },
         ModelData = SerializeForMetadata()
     };
-
-    /// <summary>
-    /// Writes configuration to a binary stream.
-    /// </summary>
-    /// <param name="writer">The binary writer.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Saves model configuration for later reconstruction.
-    /// </para>
-    /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    { writer.Write(_height); writer.Write(_width); writer.Write(_channels); writer.Write(_numClasses); writer.Write((int)_modelSize); writer.Write(_decoderDim); writer.Write(_dropRate); writer.Write(_useNativeMode); writer.Write(_onnxModelPath ?? string.Empty); writer.Write(_encoderLayerEnd); writer.Write(_channelDims.Length); foreach (int d in _channelDims) writer.Write(d); writer.Write(_depths.Length); foreach (int d in _depths) writer.Write(d); }
-
-    /// <summary>
-    /// Reads configuration from a binary stream.
-    /// </summary>
-    /// <param name="reader">The binary reader.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Loads model configuration when restoring a saved model.
-    /// </para>
-    /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    { _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadDouble(); _ = reader.ReadBoolean(); _ = reader.ReadString(); _ = reader.ReadInt32(); int dc = reader.ReadInt32(); for (int i = 0; i < dc; i++) _ = reader.ReadInt32(); int dd = reader.ReadInt32(); for (int i = 0; i < dd; i++) _ = reader.ReadInt32(); }
-
-    /// <summary>
-    /// Creates a new instance with the same configuration but fresh weights.
-    /// </summary>
-    /// <returns>A new model instance.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Creates a copy for cross-validation or ensemble training.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() => _useNativeMode
-        ? new Concerto<T>(Architecture, _optimizer, LossFunction, _numClasses, _modelSize, _dropRate, _options)
-        : new Concerto<T>(Architecture, _onnxModelPath ?? throw new InvalidOperationException("ONNX model path not initialized."), _numClasses, _modelSize, _options);
     #endregion
 
     // NumClasses, InputHeight, InputWidth, IsOnnxMode and Segment come from SegmentationModelBase;
diff --git a/src/ComputerVision/Segmentation/PointCloud/PointTransformerV3.cs b/src/ComputerVision/Segmentation/PointCloud/PointTransformerV3.cs
index a10653877e..62a3e310af 100644
--- a/src/ComputerVision/Segmentation/PointCloud/PointTransformerV3.cs
+++ b/src/ComputerVision/Segmentation/PointCloud/PointTransformerV3.cs
@@ -53,7 +53,7 @@ namespace AiDotNet.ComputerVision.Segmentation.PointCloud;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Point Transformer V3: Simpler, Faster, Stronger", "https://arxiv.org/abs/2312.10035", Year = 2024, Authors = "Wu et al.")]
-public class PointTransformerV3<T> : Common.SemanticSegmentationBase<T>
+public partial class PointTransformerV3<T> : Common.SemanticSegmentationBase<T>
 {
     private readonly PointTransformerV3Options _options;
     public override ModelOptions GetOptions() => _options;
@@ -262,43 +262,6 @@ protected override void InitializeLayers()
         AdditionalInfo = new Dictionary<string, object> { { "ModelName", "PointTransformerV3" }, { "InputHeight", _height }, { "InputWidth", _width }, { "NumClasses", _numClasses }, { "ModelSize", _modelSize.ToString() }, { "UseNativeMode", _useNativeMode }, { "NumLayers", Layers.Count } },
         ModelData = SerializeForMetadata()
     };
-
-    /// <summary>
-    /// Writes configuration to a binary stream.
-    /// </summary>
-    /// <param name="writer">The binary writer.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Saves model configuration for later reconstruction.
-    /// </para>
-    /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    { writer.Write(_height); writer.Write(_width); writer.Write(_channels); writer.Write(_numClasses); writer.Write((int)_modelSize); writer.Write(_decoderDim); writer.Write(_dropRate); writer.Write(_useNativeMode); writer.Write(_onnxModelPath ?? string.Empty); writer.Write(_encoderLayerEnd); writer.Write(_channelDims.Length); foreach (int d in _channelDims) writer.Write(d); writer.Write(_depths.Length); foreach (int d in _depths) writer.Write(d); }
-
-    /// <summary>
-    /// Reads configuration from a binary stream.
-    /// </summary>
-    /// <param name="reader">The binary reader.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Loads model configuration when restoring a saved model.
-    /// </para>
-    /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    { _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadDouble(); _ = reader.ReadBoolean(); _ = reader.ReadString(); _ = reader.ReadInt32(); int dc = reader.ReadInt32(); for (int i = 0; i < dc; i++) _ = reader.ReadInt32(); int dd = reader.ReadInt32(); for (int i = 0; i < dd; i++) _ = reader.ReadInt32(); }
-
-    /// <summary>
-    /// Creates a new instance with the same configuration but fresh weights.
-    /// </summary>
-    /// <returns>A new model instance.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Creates a copy for cross-validation or ensemble training.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() => _useNativeMode
-        ? new PointTransformerV3<T>(Architecture, _optimizer, LossFunction, _numClasses, _modelSize, _dropRate, _options)
-        : new PointTransformerV3<T>(Architecture, _onnxModelPath ?? throw new InvalidOperationException("ONNX model path not initialized."), _numClasses, _modelSize, _options);
     #endregion
 
     // NumClasses, InputHeight, InputWidth, IsOnnxMode and Segment come from SegmentationModelBase;
diff --git a/src/ComputerVision/Segmentation/PointCloud/Sonata.cs b/src/ComputerVision/Segmentation/PointCloud/Sonata.cs
index ecdb79467f..c9f1aa9114 100644
--- a/src/ComputerVision/Segmentation/PointCloud/Sonata.cs
+++ b/src/ComputerVision/Segmentation/PointCloud/Sonata.cs
@@ -53,7 +53,7 @@ namespace AiDotNet.ComputerVision.Segmentation.PointCloud;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Mamba3D: Enhancing Local Features for 3D Point Cloud Analysis via State Space Model", "https://arxiv.org/abs/2404.14966", Year = 2024, Authors = "Xu Han, Yuan Tang, Zhaoxuan Wang, Xianzhi Li")]
-public class Sonata<T> : Common.SemanticSegmentationBase<T>
+public partial class Sonata<T> : Common.SemanticSegmentationBase<T>
 {
     private readonly SonataOptions _options;
     public override ModelOptions GetOptions() => _options;
@@ -262,43 +262,6 @@ protected override void InitializeLayers()
         AdditionalInfo = new Dictionary<string, object> { { "ModelName", "Sonata" }, { "InputHeight", _height }, { "InputWidth", _width }, { "NumClasses", _numClasses }, { "ModelSize", _modelSize.ToString() }, { "UseNativeMode", _useNativeMode }, { "NumLayers", Layers.Count } },
         ModelData = SerializeForMetadata()
     };
-
-    /// <summary>
-    /// Writes configuration to a binary stream.
-    /// </summary>
-    /// <param name="writer">The binary writer.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Saves model configuration for later reconstruction.
-    /// </para>
-    /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    { writer.Write(_height); writer.Write(_width); writer.Write(_channels); writer.Write(_numClasses); writer.Write((int)_modelSize); writer.Write(_decoderDim); writer.Write(_dropRate); writer.Write(_useNativeMode); writer.Write(_onnxModelPath ?? string.Empty); writer.Write(_encoderLayerEnd); writer.Write(_channelDims.Length); foreach (int d in _channelDims) writer.Write(d); writer.Write(_depths.Length); foreach (int d in _depths) writer.Write(d); }
-
-    /// <summary>
-    /// Reads configuration from a binary stream.
-    /// </summary>
-    /// <param name="reader">The binary reader.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Loads model configuration when restoring a saved model.
-    /// </para>
-    /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    { _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadDouble(); _ = reader.ReadBoolean(); _ = reader.ReadString(); _ = reader.ReadInt32(); int dc = reader.ReadInt32(); for (int i = 0; i < dc; i++) _ = reader.ReadInt32(); int dd = reader.ReadInt32(); for (int i = 0; i < dd; i++) _ = reader.ReadInt32(); }
-
-    /// <summary>
-    /// Creates a new instance with the same configuration but fresh weights.
-    /// </summary>
-    /// <returns>A new model instance.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Creates a copy for cross-validation or ensemble training.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() => _useNativeMode
-        ? new Sonata<T>(Architecture, _optimizer, LossFunction, _numClasses, _modelSize, _dropRate, _options)
-        : new Sonata<T>(Architecture, _onnxModelPath ?? throw new InvalidOperationException("ONNX model path not initialized."), _numClasses, _modelSize, _options);
     #endregion
 
     // NumClasses, InputHeight, InputWidth, IsOnnxMode and Segment come from SegmentationModelBase;
diff --git a/src/ComputerVision/Segmentation/Referring/GLaMM.cs b/src/ComputerVision/Segmentation/Referring/GLaMM.cs
index 62e776b20d..56487eeda4 100644
--- a/src/ComputerVision/Segmentation/Referring/GLaMM.cs
+++ b/src/ComputerVision/Segmentation/Referring/GLaMM.cs
@@ -59,7 +59,7 @@ namespace AiDotNet.ComputerVision.Segmentation.Referring;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("GLaMM: Pixel Grounding Large Multimodal Model", "https://arxiv.org/abs/2311.03356", Year = 2024, Authors = "Rasheed et al.")]
-public class GLaMM<T> : Common.ReferringSegmentationBase<T>
+public partial class GLaMM<T> : Common.ReferringSegmentationBase<T>
 {
     private readonly GLaMMOptions _options;
     public override ModelOptions GetOptions() => _options;
@@ -267,43 +267,6 @@ protected override void InitializeLayers()
         AdditionalInfo = new Dictionary<string, object> { { "ModelName", "GLaMM" }, { "InputHeight", _height }, { "InputWidth", _width }, { "NumClasses", _numClasses }, { "UseNativeMode", _useNativeMode }, { "NumLayers", Layers.Count } },
         ModelData = SerializeForMetadata()
     };
-
-    /// <summary>
-    /// Writes configuration to a binary stream.
-    /// </summary>
-    /// <param name="writer">The binary writer.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Saves model configuration for later reconstruction.
-    /// </para>
-    /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    { writer.Write(_height); writer.Write(_width); writer.Write(_channels); writer.Write(_numClasses); writer.Write(_decoderDim); writer.Write(_dropRate); writer.Write(_useNativeMode); writer.Write(_onnxModelPath ?? string.Empty); writer.Write(_encoderLayerEnd); writer.Write(_channelDims.Length); foreach (int d in _channelDims) writer.Write(d); writer.Write(_depths.Length); foreach (int d in _depths) writer.Write(d); }
-
-    /// <summary>
-    /// Reads configuration from a binary stream.
-    /// </summary>
-    /// <param name="reader">The binary reader.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Loads model configuration when restoring a saved model.
-    /// </para>
-    /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    { _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadDouble(); _ = reader.ReadBoolean(); _ = reader.ReadString(); _ = reader.ReadInt32(); int dc = reader.ReadInt32(); for (int i = 0; i < dc; i++) _ = reader.ReadInt32(); int dd = reader.ReadInt32(); for (int i = 0; i < dd; i++) _ = reader.ReadInt32(); }
-
-    /// <summary>
-    /// Creates a new instance with the same configuration but fresh weights.
-    /// </summary>
-    /// <returns>A new model instance.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Creates a copy for cross-validation or ensemble training.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() => _useNativeMode
-        ? new GLaMM<T>(Architecture, _optimizer, LossFunction, _numClasses, _dropRate, _options)
-        : new GLaMM<T>(Architecture, _onnxModelPath ?? throw new InvalidOperationException("ONNX model path not initialized."), _numClasses, _options);
     // Dispose is inherited: SegmentationModelBase already disposes _onnxSession and latches
     // _disposed, and GLaMM owns no other unmanaged resource.
     #endregion
diff --git a/src/ComputerVision/Segmentation/Referring/LISA.cs b/src/ComputerVision/Segmentation/Referring/LISA.cs
index 1cb98951e8..ddd9202a12 100644
--- a/src/ComputerVision/Segmentation/Referring/LISA.cs
+++ b/src/ComputerVision/Segmentation/Referring/LISA.cs
@@ -57,7 +57,7 @@ namespace AiDotNet.ComputerVision.Segmentation.Referring;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("LISA: Reasoning Segmentation via Large Language Model", "https://arxiv.org/abs/2308.00692", Year = 2024, Authors = "Lai et al.")]
-public class LISA<T> : Common.ReferringSegmentationBase<T>
+public partial class LISA<T> : Common.ReferringSegmentationBase<T>
 {
     private readonly LISAOptions _options;
     public override ModelOptions GetOptions() => _options;
@@ -255,43 +255,6 @@ protected override void InitializeLayers()
         AdditionalInfo = new Dictionary<string, object> { { "ModelName", "LISA" }, { "InputHeight", _height }, { "InputWidth", _width }, { "NumClasses", _numClasses }, { "UseNativeMode", _useNativeMode }, { "NumLayers", Layers.Count } },
         ModelData = SerializeForMetadata()
     };
-
-    /// <summary>
-    /// Writes configuration to a binary stream.
-    /// </summary>
-    /// <param name="writer">The binary writer.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Saves model configuration for later reconstruction.
-    /// </para>
-    /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    { writer.Write(_height); writer.Write(_width); writer.Write(_channels); writer.Write(_numClasses); writer.Write(_decoderDim); writer.Write(_dropRate); writer.Write(_useNativeMode); writer.Write(_onnxModelPath ?? string.Empty); writer.Write(_encoderLayerEnd); writer.Write(_channelDims.Length); foreach (int d in _channelDims) writer.Write(d); writer.Write(_depths.Length); foreach (int d in _depths) writer.Write(d); }
-
-    /// <summary>
-    /// Reads configuration from a binary stream.
-    /// </summary>
-    /// <param name="reader">The binary reader.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Loads model configuration when restoring a saved model.
-    /// </para>
-    /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    { _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadDouble(); _ = reader.ReadBoolean(); _ = reader.ReadString(); _ = reader.ReadInt32(); int dc = reader.ReadInt32(); for (int i = 0; i < dc; i++) _ = reader.ReadInt32(); int dd = reader.ReadInt32(); for (int i = 0; i < dd; i++) _ = reader.ReadInt32(); }
-
-    /// <summary>
-    /// Creates a new instance with the same configuration but fresh weights.
-    /// </summary>
-    /// <returns>A new model instance.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Creates a copy for cross-validation or ensemble training.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() => _useNativeMode
-        ? new LISA<T>(Architecture, _optimizer, LossFunction, _numClasses, _dropRate, _options)
-        : new LISA<T>(Architecture, _onnxModelPath ?? throw new InvalidOperationException("ONNX model path not initialized."), _numClasses, _options);
     // Dispose is inherited: SegmentationModelBase already disposes _onnxSession and latches
     // _disposed, and LISA owns no other unmanaged resource.
     #endregion
diff --git a/src/ComputerVision/Segmentation/Referring/OMGLLaVA.cs b/src/ComputerVision/Segmentation/Referring/OMGLLaVA.cs
index 331deca2b9..266bd23d72 100644
--- a/src/ComputerVision/Segmentation/Referring/OMGLLaVA.cs
+++ b/src/ComputerVision/Segmentation/Referring/OMGLLaVA.cs
@@ -59,7 +59,7 @@ namespace AiDotNet.ComputerVision.Segmentation.Referring;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("OMG-LLaVA: Bridging Image-Level, Object-Level, Pixel-Level Reasoning and Understanding", "https://arxiv.org/abs/2406.19389", Year = 2024, Authors = "Zhang et al.")]
-public class OMGLLaVA<T> : Common.ReferringSegmentationBase<T>
+public partial class OMGLLaVA<T> : Common.ReferringSegmentationBase<T>
 {
     private readonly OMGLLaVAOptions _options;
     public override ModelOptions GetOptions() => _options;
@@ -257,46 +257,6 @@ protected override void InitializeLayers()
         AdditionalInfo = new Dictionary<string, object> { { "ModelName", "OMGLLaVA" }, { "InputHeight", _height }, { "InputWidth", _width }, { "NumClasses", _numClasses }, { "UseNativeMode", _useNativeMode }, { "NumLayers", Layers.Count } },
         ModelData = SerializeForMetadata()
     };
-
-    /// <summary>
-    /// Writes configuration to a binary stream.
-    /// </summary>
-    /// <param name="writer">The binary writer.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Saves model configuration for later reconstruction.
-    /// </para>
-    /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    { writer.Write(_height); writer.Write(_width); writer.Write(_channels); writer.Write(_numClasses); writer.Write(_decoderDim); writer.Write(_dropRate); writer.Write(_useNativeMode); writer.Write(_onnxModelPath ?? string.Empty); writer.Write(_encoderLayerEnd); writer.Write(_channelDims.Length); foreach (int d in _channelDims) writer.Write(d); writer.Write(_depths.Length); foreach (int d in _depths) writer.Write(d); }
-
-    /// <summary>
-    /// Reads configuration from a binary stream.
-    /// </summary>
-    /// <param name="reader">The binary reader.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Loads model configuration when restoring a saved model.
-    /// </para>
-    /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    { _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadDouble(); _ = reader.ReadBoolean(); _ = reader.ReadString(); _ = reader.ReadInt32(); int dc = reader.ReadInt32(); for (int i = 0; i < dc; i++) _ = reader.ReadInt32(); int dd = reader.ReadInt32(); for (int i = 0; i < dd; i++) _ = reader.ReadInt32(); }
-
-    /// <summary>
-    /// Creates a new instance with the same configuration but fresh weights.
-    /// </summary>
-    /// <returns>A new model instance.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Creates a copy for cross-validation or ensemble training.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() => _useNativeMode
-        ? new OMGLLaVA<T>(Architecture, optimizer: null, lossFunction: LossFunction,
-            numClasses: _numClasses, dropRate: _dropRate, options: new OMGLLaVAOptions(_options))
-        : new OMGLLaVA<T>(Architecture,
-            _onnxModelPath ?? throw new InvalidOperationException("ONNX model path not initialized."),
-            _numClasses, new OMGLLaVAOptions(_options));
     // Dispose is inherited: SegmentationModelBase already disposes _onnxSession and latches
     // _disposed, and OMGLLaVA owns no other unmanaged resource.
     #endregion
diff --git a/src/ComputerVision/Segmentation/Referring/PixelLM.cs b/src/ComputerVision/Segmentation/Referring/PixelLM.cs
index 3200cc7e00..b1b1d26cdd 100644
--- a/src/ComputerVision/Segmentation/Referring/PixelLM.cs
+++ b/src/ComputerVision/Segmentation/Referring/PixelLM.cs
@@ -56,7 +56,7 @@ namespace AiDotNet.ComputerVision.Segmentation.Referring;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("PixelLM: Pixel Reasoning with Large Multimodal Model", "https://arxiv.org/abs/2312.02228", Year = 2024, Authors = "Ren et al.")]
-public class PixelLM<T> : Common.ReferringSegmentationBase<T>
+public partial class PixelLM<T> : Common.ReferringSegmentationBase<T>
 {
     private readonly PixelLMOptions _options;
     public override ModelOptions GetOptions() => _options;
@@ -302,46 +302,6 @@ protected override void InitializeLayers()
         AdditionalInfo = new Dictionary<string, object> { { "ModelName", "PixelLM" }, { "InputHeight", _height }, { "InputWidth", _width }, { "NumClasses", _numClasses }, { "UseNativeMode", _useNativeMode }, { "NumLayers", Layers.Count } },
         ModelData = SerializeForMetadata()
     };
-
-    /// <summary>
-    /// Writes configuration to a binary stream.
-    /// </summary>
-    /// <param name="writer">The binary writer.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Saves model configuration for later reconstruction.
-    /// </para>
-    /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    { writer.Write(_height); writer.Write(_width); writer.Write(_channels); writer.Write(_numClasses); writer.Write(_decoderDim); writer.Write(_dropRate); writer.Write(_useNativeMode); writer.Write(_onnxModelPath ?? string.Empty); writer.Write(_encoderLayerEnd); writer.Write(_channelDims.Length); foreach (int d in _channelDims) writer.Write(d); writer.Write(_depths.Length); foreach (int d in _depths) writer.Write(d); }
-
-    /// <summary>
-    /// Reads configuration from a binary stream.
-    /// </summary>
-    /// <param name="reader">The binary reader.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Loads model configuration when restoring a saved model.
-    /// </para>
-    /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    { _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadDouble(); _ = reader.ReadBoolean(); _ = reader.ReadString(); _ = reader.ReadInt32(); int dc = reader.ReadInt32(); for (int i = 0; i < dc; i++) _ = reader.ReadInt32(); int dd = reader.ReadInt32(); for (int i = 0; i < dd; i++) _ = reader.ReadInt32(); }
-
-    /// <summary>
-    /// Creates a new instance with the same configuration but fresh weights.
-    /// </summary>
-    /// <returns>A new model instance.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Creates a copy for cross-validation or ensemble training.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() => _useNativeMode
-        ? new PixelLM<T>(Architecture, optimizer: null, lossFunction: LossFunction,
-            numClasses: _numClasses, dropRate: _dropRate, options: new PixelLMOptions(_options))
-        : new PixelLM<T>(Architecture,
-            _onnxModelPath ?? throw new InvalidOperationException("ONNX model path not initialized."),
-            _numClasses, new PixelLMOptions(_options));
     // Dispose is inherited: SegmentationModelBase already disposes _onnxSession and latches
     // _disposed, and PixelLM owns no other unmanaged resource.
     #endregion
diff --git a/src/ComputerVision/Segmentation/Referring/VideoLISA.cs b/src/ComputerVision/Segmentation/Referring/VideoLISA.cs
index e84a067736..d863e2d678 100644
--- a/src/ComputerVision/Segmentation/Referring/VideoLISA.cs
+++ b/src/ComputerVision/Segmentation/Referring/VideoLISA.cs
@@ -59,7 +59,7 @@ namespace AiDotNet.ComputerVision.Segmentation.Referring;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("One Token to Seg Them All: Language Instructed Reasoning Segmentation in Videos", "https://arxiv.org/abs/2409.19603", Year = 2024, Authors = "Zechen Bai, Tong He, Haiyang Mei, Pichao Wang, Ziteng Gao, Joya Chen, Lei Liu, Zheng Zhang, Mike Zheng Shou")]
-public class VideoLISA<T> : Common.ReferringSegmentationBase<T>
+public partial class VideoLISA<T> : Common.ReferringSegmentationBase<T>
 {
     /// <inheritdoc />
     /// <remarks>Does NOT downsample: measured [1,3,64,64] -> [1,C,64,64].</remarks>
@@ -335,43 +335,6 @@ protected override void InitializeLayers()
         ModelData = SerializeForMetadata()
     };
 
-    /// <summary>
-    /// Writes configuration to a binary stream.
-    /// </summary>
-    /// <param name="writer">The binary writer.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Saves model configuration for later reconstruction.
-    /// </para>
-    /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    { writer.Write(_height); writer.Write(_width); writer.Write(_channels); writer.Write(_numClasses); writer.Write(_decoderDim); writer.Write(_dropRate); writer.Write(_useNativeMode); writer.Write(_onnxModelPath ?? string.Empty); writer.Write(_encoderLayerEnd); writer.Write(_channelDims.Length); foreach (int d in _channelDims) writer.Write(d); writer.Write(_depths.Length); foreach (int d in _depths) writer.Write(d); }
-
-    /// <summary>
-    /// Reads configuration from a binary stream.
-    /// </summary>
-    /// <param name="reader">The binary reader.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Loads model configuration when restoring a saved model.
-    /// </para>
-    /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    { _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadDouble(); _ = reader.ReadBoolean(); _ = reader.ReadString(); _ = reader.ReadInt32(); int dc = reader.ReadInt32(); for (int i = 0; i < dc; i++) _ = reader.ReadInt32(); int dd = reader.ReadInt32(); for (int i = 0; i < dd; i++) _ = reader.ReadInt32(); }
-
-    /// <summary>
-    /// Creates a new instance with the same configuration but fresh weights.
-    /// </summary>
-    /// <returns>A new model instance.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Creates a copy for cross-validation or ensemble training.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() => _useNativeMode
-        ? new VideoLISA<T>(Architecture, null, LossFunction, _numClasses, _dropRate, new VideoLISAOptions(_options))
-        : new VideoLISA<T>(Architecture, _onnxModelPath ?? throw new InvalidOperationException("ONNX model path not initialized."), _numClasses, new VideoLISAOptions(_options));
-
     #endregion
 
     #region IReferringSegmentation Implementation
diff --git a/src/ComputerVision/Segmentation/Semantic/DiffCut.cs b/src/ComputerVision/Segmentation/Semantic/DiffCut.cs
index 62473605a7..bfad36177a 100644
--- a/src/ComputerVision/Segmentation/Semantic/DiffCut.cs
+++ b/src/ComputerVision/Segmentation/Semantic/DiffCut.cs
@@ -61,7 +61,7 @@ namespace AiDotNet.ComputerVision.Segmentation.Semantic;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("DiffCut: Catalyzing Zero-Shot Semantic Segmentation with Diffusion Features and Recursive Normalized Cut", "https://arxiv.org/abs/2406.02842", Year = 2024, Authors = "Couairon et al.")]
-public class DiffCut<T> : Common.SemanticSegmentationBase<T>
+public partial class DiffCut<T> : Common.SemanticSegmentationBase<T>
 {
     private readonly DiffCutOptions _options;
     public override ModelOptions GetOptions() => _options;
@@ -307,33 +307,5 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_height); writer.Write(_width); writer.Write(_channels);
-        writer.Write(_numClasses); writer.Write(_decoderDim); writer.Write(_dropRate);
-        writer.Write(_useNativeMode); writer.Write(_onnxModelPath ?? string.Empty);
-        writer.Write(_encoderLayerEnd);
-        writer.Write(_channelDims.Length);
-        foreach (int c in _channelDims) writer.Write(c);
-        writer.Write(_depths.Length);
-        foreach (int d in _depths) writer.Write(d);
-    }
-
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32();
-        _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadDouble();
-        _ = reader.ReadBoolean(); _ = reader.ReadString(); _ = reader.ReadInt32();
-        int cc = reader.ReadInt32(); for (int i = 0; i < cc; i++) _ = reader.ReadInt32();
-        int dc = reader.ReadInt32(); for (int i = 0; i < dc; i++) _ = reader.ReadInt32();
-    }
-
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return _useNativeMode
-            ? new DiffCut<T>(Architecture, _optimizer, LossFunction, _numClasses, _dropRate, _options)
-            : new DiffCut<T>(Architecture, _onnxModelPath ?? throw new InvalidOperationException("ONNX model path not initialized."), _numClasses, _options);
-    }
-
     #endregion
 }
diff --git a/src/ComputerVision/Segmentation/Semantic/DiffSeg.cs b/src/ComputerVision/Segmentation/Semantic/DiffSeg.cs
index 39199d23e7..b3604a3ccc 100644
--- a/src/ComputerVision/Segmentation/Semantic/DiffSeg.cs
+++ b/src/ComputerVision/Segmentation/Semantic/DiffSeg.cs
@@ -60,7 +60,7 @@ namespace AiDotNet.ComputerVision.Segmentation.Semantic;
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 // Citation URL corrected: the arXiv id for this title is 2308.12469, not 2305.02015.
 [ResearchPaper("Diffuse, Attend, and Segment: Unsupervised Zero-Shot Segmentation using Stable Diffusion", "https://arxiv.org/abs/2308.12469", Year = 2023, Authors = "Junjiao Tian, Lavisha Aggarwal, Andrea Colber, Zunzhi You, Eldhose Iype, Haiyang Sheng")]
-public class DiffSeg<T> : Common.SemanticSegmentationBase<T>
+public partial class DiffSeg<T> : Common.SemanticSegmentationBase<T>
 {
     private readonly DiffSegOptions _options;
     public override ModelOptions GetOptions() => _options;
@@ -304,33 +304,5 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_height); writer.Write(_width); writer.Write(_channels);
-        writer.Write(_numClasses); writer.Write(_decoderDim); writer.Write(_dropRate);
-        writer.Write(_useNativeMode); writer.Write(_onnxModelPath ?? string.Empty);
-        writer.Write(_encoderLayerEnd);
-        writer.Write(_channelDims.Length);
-        foreach (int c in _channelDims) writer.Write(c);
-        writer.Write(_depths.Length);
-        foreach (int d in _depths) writer.Write(d);
-    }
-
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32();
-        _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadDouble();
-        _ = reader.ReadBoolean(); _ = reader.ReadString(); _ = reader.ReadInt32();
-        int cc = reader.ReadInt32(); for (int i = 0; i < cc; i++) _ = reader.ReadInt32();
-        int dc = reader.ReadInt32(); for (int i = 0; i < dc; i++) _ = reader.ReadInt32();
-    }
-
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return _useNativeMode
-            ? new DiffSeg<T>(Architecture, _optimizer, LossFunction, _numClasses, _dropRate, _options)
-            : new DiffSeg<T>(Architecture, _onnxModelPath ?? throw new InvalidOperationException("ONNX model path not initialized."), _numClasses, _options);
-    }
-
     #endregion
 }
diff --git a/src/ComputerVision/Segmentation/Semantic/InternImage.cs b/src/ComputerVision/Segmentation/Semantic/InternImage.cs
index 7583bdd690..01a934da2a 100644
--- a/src/ComputerVision/Segmentation/Semantic/InternImage.cs
+++ b/src/ComputerVision/Segmentation/Semantic/InternImage.cs
@@ -60,7 +60,7 @@ namespace AiDotNet.ComputerVision.Segmentation.Semantic;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("InternImage: Exploring Large-Scale Vision Foundation Models with Deformable Convolutions", "https://arxiv.org/abs/2211.05778", Year = 2023, Authors = "Wang et al.")]
-public class InternImage<T> : Common.SemanticSegmentationBase<T>
+public partial class InternImage<T> : Common.SemanticSegmentationBase<T>
 {
     private readonly InternImageOptions _options;
 
@@ -388,67 +388,5 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    /// <summary>
-    /// Serializes InternImage-specific configuration to a binary stream.
-    /// </summary>
-    /// <param name="writer">Binary writer for persistence.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Saves the model's configuration so it can be restored later.
-    /// The order must match <see cref="DeserializeNetworkSpecificData"/>.
-    /// </para>
-    /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_height); writer.Write(_width); writer.Write(_channels);
-        writer.Write(_numClasses); writer.Write((int)_modelSize);
-        writer.Write(_decoderDim); writer.Write(_dropRate);
-        writer.Write(_useNativeMode); writer.Write(_onnxModelPath ?? string.Empty);
-        writer.Write(_encoderLayerEnd);
-        writer.Write(_channelDims.Length);
-        foreach (int dim in _channelDims) writer.Write(dim);
-        writer.Write(_depths.Length);
-        foreach (int depth in _depths) writer.Write(depth);
-    }
-
-    /// <summary>
-    /// Deserializes InternImage-specific configuration from a binary stream.
-    /// </summary>
-    /// <param name="reader">Binary reader for loading.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Reads back the saved configuration in the same order it was written.
-    /// </para>
-    /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32();
-        _ = reader.ReadInt32(); _ = reader.ReadInt32();
-        _ = reader.ReadInt32(); _ = reader.ReadDouble();
-        _ = reader.ReadBoolean(); _ = reader.ReadString();
-        _ = reader.ReadInt32();
-        int channelCount = reader.ReadInt32();
-        for (int i = 0; i < channelCount; i++) _ = reader.ReadInt32();
-        int depthCount = reader.ReadInt32();
-        for (int i = 0; i < depthCount; i++) _ = reader.ReadInt32();
-    }
-
-    /// <summary>
-    /// Creates a new InternImage with the same config but fresh weights.
-    /// </summary>
-    /// <returns>A new model instance with reinitialized weights.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Used for cross-validation or ensemble training where multiple
-    /// independent copies of the same architecture are needed.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return _useNativeMode
-            ? new InternImage<T>(Architecture, null, LossFunction, _numClasses, _modelSize, _dropRate, _options)
-            : new InternImage<T>(Architecture, _onnxModelPath ?? throw new InvalidOperationException("ONNX model path not initialized."), _numClasses, _modelSize, _options);
-    }
-
     #endregion
 }
diff --git a/src/ComputerVision/Segmentation/Semantic/SegFormer.cs b/src/ComputerVision/Segmentation/Semantic/SegFormer.cs
index 6a92743db1..6e34b7d18d 100644
--- a/src/ComputerVision/Segmentation/Semantic/SegFormer.cs
+++ b/src/ComputerVision/Segmentation/Semantic/SegFormer.cs
@@ -61,7 +61,7 @@ namespace AiDotNet.ComputerVision.Segmentation.Semantic;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("SegFormer: Simple and Efficient Design for Semantic Segmentation with Transformers", "https://arxiv.org/abs/2105.15203", Year = 2021, Authors = "Enze Xie, Wenhai Wang, Zhiding Yu, Anima Anandkumar, Jose M. Alvarez, Ping Luo")]
-public class SegFormer<T> : Common.SemanticSegmentationBase<T>
+public partial class SegFormer<T> : Common.SemanticSegmentationBase<T>
 {
     private readonly SegFormerOptions _options;
 
@@ -596,40 +596,7 @@ public override ModelMetadata<T> GetModelMetadata()
     /// match the reading order in <see cref="DeserializeNetworkSpecificData"/>.
     /// </para>
     /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_height);
-        writer.Write(_width);
-        writer.Write(_channels);
-        writer.Write(_numClasses);
-        writer.Write((int)_modelSize);
-        writer.Write(_decoderDim);
-        writer.Write(_dropRate);
-        writer.Write(_useNativeMode);
-        writer.Write(_onnxModelPath ?? string.Empty);
-        writer.Write(_encoderLayerEnd);
-
-        // Write embed dims
-        writer.Write(_embedDims.Length);
-        foreach (int dim in _embedDims)
-        {
-            writer.Write(dim);
-        }
-
-        // Write depths
-        writer.Write(_depths.Length);
-        foreach (int depth in _depths)
-        {
-            writer.Write(depth);
-        }
 
-        // Write num heads
-        writer.Write(_numHeads.Length);
-        foreach (int head in _numHeads)
-        {
-            writer.Write(head);
-        }
-    }
 
     /// <summary>
     /// Reads SegFormer-specific configuration values from a binary stream during model loading.
@@ -644,67 +611,7 @@ protected override void SerializeNetworkSpecificData(BinaryWriter writer)
     /// are consumed to advance the reader position.
     /// </para>
     /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _ = reader.ReadInt32(); // height
-        _ = reader.ReadInt32(); // width
-        _ = reader.ReadInt32(); // channels
-        _ = reader.ReadInt32(); // numClasses
-        _ = reader.ReadInt32(); // modelSize
-        _ = reader.ReadInt32(); // decoderDim
-        _ = reader.ReadDouble(); // dropRate
-        _ = reader.ReadBoolean(); // useNativeMode
-        _ = reader.ReadString(); // onnxModelPath
-        _ = reader.ReadInt32(); // encoderLayerEnd
-
-        // Read embed dims
-        int embedCount = reader.ReadInt32();
-        for (int i = 0; i < embedCount; i++)
-        {
-            _ = reader.ReadInt32();
-        }
-
-        // Read depths
-        int depthCount = reader.ReadInt32();
-        for (int i = 0; i < depthCount; i++)
-        {
-            _ = reader.ReadInt32();
-        }
-
-        // Read num heads
-        int headCount = reader.ReadInt32();
-        for (int i = 0; i < headCount; i++)
-        {
-            _ = reader.ReadInt32();
-        }
-    }
 
-    /// <summary>
-    /// Creates a new SegFormer instance with the same configuration as this one but freshly
-    /// initialized weights.
-    /// </summary>
-    /// <returns>A new <see cref="SegFormer{T}"/> model with the same architecture, model size,
-    /// number of classes, and other settings, but with reinitialized layer weights.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> This creates a "copy" of the model's configuration (same size,
-    /// same number of classes, same input dimensions) but with fresh random weights. It's used
-    /// internally by the framework for operations like cross-validation, where multiple independent
-    /// copies of the same model architecture need to be trained separately. In native mode it
-    /// creates a new trainable model; in ONNX mode it reloads from the same ONNX file.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (_useNativeMode)
-        {
-            return new SegFormer<T>(Architecture, _optimizer, LossFunction, _numClasses, _modelSize, _dropRate, _options);
-        }
-        else
-        {
-            return new SegFormer<T>(Architecture, _onnxModelPath ?? throw new InvalidOperationException("ONNX model path not initialized."), _numClasses, _modelSize, _options);
-        }
-    }
 
     /// <summary>
     /// Releases managed resources held by this SegFormer instance, including the ONNX inference session.
diff --git a/src/ComputerVision/Segmentation/Semantic/SegNeXt.cs b/src/ComputerVision/Segmentation/Semantic/SegNeXt.cs
index 51d4829d83..4a763fda73 100644
--- a/src/ComputerVision/Segmentation/Semantic/SegNeXt.cs
+++ b/src/ComputerVision/Segmentation/Semantic/SegNeXt.cs
@@ -60,7 +60,7 @@ namespace AiDotNet.ComputerVision.Segmentation.Semantic;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("SegNeXt: Rethinking Convolutional Attention Design for Semantic Segmentation", "https://arxiv.org/abs/2209.08575", Year = 2022, Authors = "Guo et al.")]
-public class SegNeXt<T> : Common.SemanticSegmentationBase<T>
+public partial class SegNeXt<T> : Common.SemanticSegmentationBase<T>
 {
     private readonly SegNeXtOptions _options;
 
@@ -517,31 +517,7 @@ public override ModelMetadata<T> GetModelMetadata()
     /// The data is written in a specific order matching <see cref="DeserializeNetworkSpecificData"/>.
     /// </para>
     /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_height);
-        writer.Write(_width);
-        writer.Write(_channels);
-        writer.Write(_numClasses);
-        writer.Write((int)_modelSize);
-        writer.Write(_decoderDim);
-        writer.Write(_dropRate);
-        writer.Write(_useNativeMode);
-        writer.Write(_onnxModelPath ?? string.Empty);
-        writer.Write(_encoderLayerEnd);
-
-        writer.Write(_channelDims.Length);
-        foreach (int dim in _channelDims)
-        {
-            writer.Write(dim);
-        }
 
-        writer.Write(_depths.Length);
-        foreach (int depth in _depths)
-        {
-            writer.Write(depth);
-        }
-    }
 
     /// <summary>
     /// Reads SegNeXt-specific configuration values from a binary stream during model loading.
@@ -554,54 +530,7 @@ protected override void SerializeNetworkSpecificData(BinaryWriter writer)
     /// they were written.
     /// </para>
     /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _ = reader.ReadInt32(); // height
-        _ = reader.ReadInt32(); // width
-        _ = reader.ReadInt32(); // channels
-        _ = reader.ReadInt32(); // numClasses
-        _ = reader.ReadInt32(); // modelSize
-        _ = reader.ReadInt32(); // decoderDim
-        _ = reader.ReadDouble(); // dropRate
-        _ = reader.ReadBoolean(); // useNativeMode
-        _ = reader.ReadString(); // onnxModelPath
-        _ = reader.ReadInt32(); // encoderLayerEnd
-
-        int channelCount = reader.ReadInt32();
-        for (int i = 0; i < channelCount; i++)
-        {
-            _ = reader.ReadInt32();
-        }
-
-        int depthCount = reader.ReadInt32();
-        for (int i = 0; i < depthCount; i++)
-        {
-            _ = reader.ReadInt32();
-        }
-    }
 
-    /// <summary>
-    /// Creates a new SegNeXt instance with the same configuration but freshly initialized weights.
-    /// </summary>
-    /// <returns>A new <see cref="SegNeXt{T}"/> with the same settings but reinitialized weights.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Creates a "copy" of the model configuration with fresh random weights.
-    /// Used internally for cross-validation or ensemble training where multiple independent copies
-    /// of the same architecture are needed.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (_useNativeMode)
-        {
-            return new SegNeXt<T>(Architecture, _optimizer, LossFunction, _numClasses, _modelSize, _dropRate, _options);
-        }
-        else
-        {
-            return new SegNeXt<T>(Architecture, _onnxModelPath ?? throw new InvalidOperationException("ONNX model path not initialized."), _numClasses, _modelSize, _options);
-        }
-    }
 
     #endregion
 }
diff --git a/src/ComputerVision/Segmentation/Semantic/ViTAdapter.cs b/src/ComputerVision/Segmentation/Semantic/ViTAdapter.cs
index ac5b37a4d4..fd4855ac70 100644
--- a/src/ComputerVision/Segmentation/Semantic/ViTAdapter.cs
+++ b/src/ComputerVision/Segmentation/Semantic/ViTAdapter.cs
@@ -59,7 +59,7 @@ namespace AiDotNet.ComputerVision.Segmentation.Semantic;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Vision Transformer Adapter for Dense Predictions", "https://arxiv.org/abs/2205.08534", Year = 2023, Authors = "Chen et al.")]
-public class ViTAdapter<T> : Common.SemanticSegmentationBase<T>
+public partial class ViTAdapter<T> : Common.SemanticSegmentationBase<T>
 {
     private readonly ViTAdapterOptions _options;
 
@@ -337,63 +337,5 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    /// <summary>
-    /// Serializes ViT-Adapter configuration for persistence.
-    /// </summary>
-    /// <param name="writer">Binary writer.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Saves configuration so the model can be restored later.
-    /// </para>
-    /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_height); writer.Write(_width); writer.Write(_channels);
-        writer.Write(_numClasses); writer.Write((int)_modelSize);
-        writer.Write(_embedDim); writer.Write(_decoderDim); writer.Write(_dropRate);
-        writer.Write(_useNativeMode); writer.Write(_onnxModelPath ?? string.Empty);
-        writer.Write(_encoderLayerEnd);
-        writer.Write(_depths.Length);
-        foreach (int d in _depths) writer.Write(d);
-        writer.Write(_numHeads.Length);
-        foreach (int h in _numHeads) writer.Write(h);
-    }
-
-    /// <summary>
-    /// Deserializes ViT-Adapter configuration.
-    /// </summary>
-    /// <param name="reader">Binary reader.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Reads saved configuration matching the write order.
-    /// </para>
-    /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32();
-        _ = reader.ReadInt32(); _ = reader.ReadInt32();
-        _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadDouble();
-        _ = reader.ReadBoolean(); _ = reader.ReadString();
-        _ = reader.ReadInt32();
-        int dc = reader.ReadInt32(); for (int i = 0; i < dc; i++) _ = reader.ReadInt32();
-        int hc = reader.ReadInt32(); for (int i = 0; i < hc; i++) _ = reader.ReadInt32();
-    }
-
-    /// <summary>
-    /// Creates a new ViT-Adapter with same config but fresh weights.
-    /// </summary>
-    /// <returns>New model instance.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Used for cross-validation or ensemble training.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return _useNativeMode
-            ? new ViTAdapter<T>(Architecture, _optimizer, LossFunction, _numClasses, _modelSize, _dropRate, _options)
-            : new ViTAdapter<T>(Architecture, _onnxModelPath ?? throw new InvalidOperationException("ONNX model path not initialized."), _numClasses, _modelSize, _options);
-    }
-
     #endregion
 }
diff --git a/src/ComputerVision/Segmentation/Semantic/ViTCoMer.cs b/src/ComputerVision/Segmentation/Semantic/ViTCoMer.cs
index 202154f6a5..97cdc26a0a 100644
--- a/src/ComputerVision/Segmentation/Semantic/ViTCoMer.cs
+++ b/src/ComputerVision/Segmentation/Semantic/ViTCoMer.cs
@@ -60,7 +60,7 @@ namespace AiDotNet.ComputerVision.Segmentation.Semantic;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("ViT-CoMer: Vision Transformer with Convolutional Multi-scale Feature Interaction for Dense Predictions", "https://arxiv.org/abs/2403.07392", Year = 2024, Authors = "Xia et al.")]
-public class ViTCoMer<T> : Common.SemanticSegmentationBase<T>
+public partial class ViTCoMer<T> : Common.SemanticSegmentationBase<T>
 {
     /// <inheritdoc />
     /// <remarks>
@@ -375,65 +375,5 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    /// <summary>
-    /// Serializes configuration for persistence.
-    /// </summary>
-    /// <param name="writer">Binary writer.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Saves config so the model can be restored later.
-    /// </para>
-    /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_height); writer.Write(_width); writer.Write(_channels);
-        writer.Write(_numClasses); writer.Write((int)_modelSize);
-        writer.Write(_embedDim); writer.Write(_decoderDim); writer.Write(_dropRate);
-        writer.Write(_useNativeMode); writer.Write(_onnxModelPath ?? string.Empty);
-        writer.Write(_encoderLayerEnd);
-        writer.Write(_options.LearningRate);
-        writer.Write(_cnnChannels.Length);
-        foreach (int c in _cnnChannels) writer.Write(c);
-        writer.Write(_depths.Length);
-        foreach (int d in _depths) writer.Write(d);
-    }
-
-    /// <summary>
-    /// Deserializes configuration.
-    /// </summary>
-    /// <param name="reader">Binary reader.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Reads saved configuration matching the write order.
-    /// </para>
-    /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32();
-        _ = reader.ReadInt32(); _ = reader.ReadInt32();
-        _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadDouble();
-        _ = reader.ReadBoolean(); _ = reader.ReadString();
-        _ = reader.ReadInt32();
-        _ = reader.ReadDouble();
-        int cc = reader.ReadInt32(); for (int i = 0; i < cc; i++) _ = reader.ReadInt32();
-        int dc = reader.ReadInt32(); for (int i = 0; i < dc; i++) _ = reader.ReadInt32();
-    }
-
-    /// <summary>
-    /// Creates a new ViT-CoMer with same config but fresh weights.
-    /// </summary>
-    /// <returns>New model instance.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Used for cross-validation or ensemble training.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return _useNativeMode
-            ? new ViTCoMer<T>(Architecture, optimizer: null, LossFunction, _numClasses, _modelSize, _dropRate, new ViTCoMerOptions(_options))
-            : new ViTCoMer<T>(Architecture, _onnxModelPath ?? throw new InvalidOperationException("ONNX model path not initialized."), _numClasses, _modelSize, new ViTCoMerOptions(_options));
-    }
-
     #endregion
 }
diff --git a/src/ComputerVision/Segmentation/Video/DEVA.cs b/src/ComputerVision/Segmentation/Video/DEVA.cs
index b19ef9c75a..5867155dd9 100644
--- a/src/ComputerVision/Segmentation/Video/DEVA.cs
+++ b/src/ComputerVision/Segmentation/Video/DEVA.cs
@@ -58,7 +58,7 @@ namespace AiDotNet.ComputerVision.Segmentation.Video;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Tracking Anything with Decoupled Video Segmentation", "https://arxiv.org/abs/2309.03903", Year = 2023, Authors = "Cheng et al.")]
-public class DEVA<T> : Common.VideoSegmentationBase<T>
+public partial class DEVA<T> : Common.VideoSegmentationBase<T>
 {
     private readonly DEVAOptions _options;
     public override ModelOptions GetOptions() => _options;
@@ -295,43 +295,6 @@ protected override void InitializeLayers()
         ModelData = SerializeForMetadata()
     };
 
-    /// <summary>
-    /// Writes configuration to a binary stream.
-    /// </summary>
-    /// <param name="writer">The binary writer.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Saves model configuration for later reconstruction.
-    /// </para>
-    /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    { writer.Write(_height); writer.Write(_width); writer.Write(_channels); writer.Write(_numClasses); writer.Write((int)_modelSize); writer.Write(_decoderDim); writer.Write(_dropRate); writer.Write(_useNativeMode); writer.Write(_onnxModelPath ?? string.Empty); writer.Write(_encoderLayerEnd); writer.Write(_channelDims.Length); foreach (int d in _channelDims) writer.Write(d); writer.Write(_depths.Length); foreach (int d in _depths) writer.Write(d); }
-
-    /// <summary>
-    /// Reads configuration from a binary stream.
-    /// </summary>
-    /// <param name="reader">The binary reader.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Loads model configuration when restoring a saved model.
-    /// </para>
-    /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    { _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadDouble(); _ = reader.ReadBoolean(); _ = reader.ReadString(); _ = reader.ReadInt32(); int dc = reader.ReadInt32(); for (int i = 0; i < dc; i++) _ = reader.ReadInt32(); int dd = reader.ReadInt32(); for (int i = 0; i < dd; i++) _ = reader.ReadInt32(); }
-
-    /// <summary>
-    /// Creates a new instance with the same configuration but fresh weights.
-    /// </summary>
-    /// <returns>A new model instance.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Creates a copy for cross-validation or ensemble training.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() => _useNativeMode
-        ? new DEVA<T>(Architecture, CreateOptimizerForClone(), LossFunction, _numClasses, _modelSize, _dropRate, new DEVAOptions(_options))
-        : new DEVA<T>(Architecture, _onnxModelPath ?? throw new InvalidOperationException("ONNX model path not initialized."), _numClasses, _modelSize, new DEVAOptions(_options));
-
     private IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? CreateOptimizerForClone()
     {
         // Reads through the base's Optimizer property rather than the raw field, so the lazily
diff --git a/src/ComputerVision/Segmentation/Video/EfficientTAM.cs b/src/ComputerVision/Segmentation/Video/EfficientTAM.cs
index 78d37bb853..a04a54575d 100644
--- a/src/ComputerVision/Segmentation/Video/EfficientTAM.cs
+++ b/src/ComputerVision/Segmentation/Video/EfficientTAM.cs
@@ -60,7 +60,7 @@ namespace AiDotNet.ComputerVision.Segmentation.Video;
 [ModelComplexity(ModelComplexity.Low)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Efficient Track Anything", "https://arxiv.org/abs/2411.18933", Year = 2024, Authors = "Yunyang Xiong, Chong Zhou, Xiaoyu Xiang, Lemeng Wu, Chenchen Zhu, Zechun Liu, Saksham Suri, Balakrishnan Varadarajan, Ramya Akula, Forrest Iandola, Raghuraman Krishnamoorthi, Bilge Soran, Vikas Chandra")]
-public class EfficientTAM<T> : Common.VideoSegmentationBase<T>
+public partial class EfficientTAM<T> : Common.VideoSegmentationBase<T>
 {
     /// <inheritdoc />
     /// <remarks>
@@ -353,43 +353,6 @@ protected override void InitializeLayers()
         ModelData = SerializeForMetadata()
     };
 
-    /// <summary>
-    /// Writes configuration to a binary stream.
-    /// </summary>
-    /// <param name="writer">The binary writer.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Saves model configuration for later reconstruction.
-    /// </para>
-    /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    { writer.Write(_height); writer.Write(_width); writer.Write(_channels); writer.Write(_numClasses); writer.Write((int)_modelSize); writer.Write(_decoderDim); writer.Write(_dropRate); writer.Write(_useNativeMode); writer.Write(_onnxModelPath ?? string.Empty); writer.Write(_encoderLayerEnd); writer.Write(_embedDim); writer.Write(_numEncoderLayers); writer.Write(_numHeads); writer.Write(_patchSize); }
-
-    /// <summary>
-    /// Reads configuration from a binary stream.
-    /// </summary>
-    /// <param name="reader">The binary reader.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Loads model configuration when restoring a saved model.
-    /// </para>
-    /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    { _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadDouble(); _ = reader.ReadBoolean(); _ = reader.ReadString(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); }
-
-    /// <summary>
-    /// Creates a new instance with the same configuration but fresh weights.
-    /// </summary>
-    /// <returns>A new model instance.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Creates a copy for cross-validation or ensemble training.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() => _useNativeMode
-        ? new EfficientTAM<T>(Architecture, Optimizer, LossFunction, _numClasses, _modelSize, _dropRate, _options)
-        : new EfficientTAM<T>(Architecture, _onnxModelPath ?? throw new InvalidOperationException("ONNX model path not initialized."), _numClasses, _modelSize, _options);
-
     #endregion
 
     #region IVideoSegmentation Implementation
diff --git a/src/ComputerVision/Segmentation/Video/UniVS.cs b/src/ComputerVision/Segmentation/Video/UniVS.cs
index 70a298e506..abb80f6870 100644
--- a/src/ComputerVision/Segmentation/Video/UniVS.cs
+++ b/src/ComputerVision/Segmentation/Video/UniVS.cs
@@ -57,7 +57,7 @@ namespace AiDotNet.ComputerVision.Segmentation.Video;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("UniVS: Unified and Universal Video Segmentation with Prompts as Queries", "https://arxiv.org/abs/2402.18115", Year = 2024, Authors = "Li et al.")]
-public class UniVS<T> : Common.VideoSegmentationBase<T>
+public partial class UniVS<T> : Common.VideoSegmentationBase<T>
 {
     private readonly UniVSOptions _options;
     public override ModelOptions GetOptions() => _options;
@@ -345,43 +345,6 @@ protected override void InitializeLayers()
         ModelData = SerializeForMetadata()
     };
 
-    /// <summary>
-    /// Writes configuration to a binary stream.
-    /// </summary>
-    /// <param name="writer">The binary writer.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Saves model configuration for later reconstruction.
-    /// </para>
-    /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    { writer.Write(_height); writer.Write(_width); writer.Write(_channels); writer.Write(_numClasses); writer.Write((int)_modelSize); writer.Write(_decoderDim); writer.Write(_dropRate); writer.Write(_useNativeMode); writer.Write(_onnxModelPath ?? string.Empty); writer.Write(_encoderLayerEnd); writer.Write(_channelDims.Length); foreach (int d in _channelDims) writer.Write(d); writer.Write(_depths.Length); foreach (int d in _depths) writer.Write(d); }
-
-    /// <summary>
-    /// Reads configuration from a binary stream.
-    /// </summary>
-    /// <param name="reader">The binary reader.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Loads model configuration when restoring a saved model.
-    /// </para>
-    /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    { _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadInt32(); _ = reader.ReadDouble(); _ = reader.ReadBoolean(); _ = reader.ReadString(); _ = reader.ReadInt32(); int dc = reader.ReadInt32(); for (int i = 0; i < dc; i++) _ = reader.ReadInt32(); int dd = reader.ReadInt32(); for (int i = 0; i < dd; i++) _ = reader.ReadInt32(); }
-
-    /// <summary>
-    /// Creates a new instance with the same configuration but fresh weights.
-    /// </summary>
-    /// <returns>A new model instance.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Creates a copy for cross-validation or ensemble training.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() => _useNativeMode
-        ? new UniVS<T>(Architecture, _optimizer, LossFunction, _numClasses, _modelSize, _dropRate, _options)
-        : new UniVS<T>(Architecture, _onnxModelPath ?? throw new InvalidOperationException("ONNX model path not initialized."), _numClasses, _modelSize, _options);
-
 
     #endregion
 
diff --git a/src/ContinualLearning/LearningWithoutForgetting.cs b/src/ContinualLearning/LearningWithoutForgetting.cs
index 0003fc8e33..e7af5c0754 100644
--- a/src/ContinualLearning/LearningWithoutForgetting.cs
+++ b/src/ContinualLearning/LearningWithoutForgetting.cs
@@ -42,6 +42,7 @@ public class LearningWithoutForgetting<T> : IContinualLearningStrategy<T>
 {
     private readonly INumericOperations<T> _numOps;
     private readonly Dictionary<int, Tensor<T>> _oldPredictions;
+    [AiDotNet.Attributes.FittedParameter]
     private Tensor<T>? _currentTaskInputs;
     private double _lambda;
     private double _temperature;
diff --git a/src/ContinualLearning/Memory/ExperienceReplayBuffer.cs b/src/ContinualLearning/Memory/ExperienceReplayBuffer.cs
index 02ebaa8f92..8bcc4a5029 100644
--- a/src/ContinualLearning/Memory/ExperienceReplayBuffer.cs
+++ b/src/ContinualLearning/Memory/ExperienceReplayBuffer.cs
@@ -82,7 +82,7 @@ public enum ReplaySamplingStrategy
 [ResearchPaper("Experience Replay for Continual Learning", "https://arxiv.org/abs/1811.11682", Year = 2019, Authors = "David Rolnick, Arun Ahuja, Jonathan Schwarz, Timothy Lillicrap, Gregory Wayne")]
 [ComponentType(ComponentType.ContinualLearner)]
 [PipelineStage(PipelineStage.Training)]
-public class ExperienceReplayBuffer<T, TInput, TOutput> : ModelBase<T, TInput, TOutput>
+public partial class ExperienceReplayBuffer<T, TInput, TOutput> : ModelBase<T, TInput, TOutput>
 {
     private readonly int _maxSize;
     private readonly List<DataPoint<T, TInput, TOutput>> _buffer;
@@ -921,10 +921,6 @@ public override IFullModel<T, TInput, TOutput> WithParameters(Vector<T> paramete
         return copy;
     }
 
-    /// <inheritdoc />
-    public override IFullModel<T, TInput, TOutput> DeepCopy()
-        => (ExperienceReplayBuffer<T, TInput, TOutput>)MemberwiseClone();
-
     #endregion
 }
 
diff --git a/src/ContinualLearning/Strategies/ElasticWeightConsolidation.cs b/src/ContinualLearning/Strategies/ElasticWeightConsolidation.cs
index 4082b6e36c..8eaf92a4fa 100644
--- a/src/ContinualLearning/Strategies/ElasticWeightConsolidation.cs
+++ b/src/ContinualLearning/Strategies/ElasticWeightConsolidation.cs
@@ -127,10 +127,13 @@ public class ElasticWeightConsolidation<T, TInput, TOutput> : ContinualLearningS
     private readonly List<Vector<T>> _taskFisherInfo;
 
     // For online EWC: single accumulated importance matrix
+    [AiDotNet.Attributes.Buffer]
     private Vector<T>? _accumulatedFisher;
+    [AiDotNet.Attributes.Buffer]
     private Vector<T>? _consolidatedParameters;
 
     // Cached gradients for Fisher computation
+    [Scratch]
     private readonly List<Vector<T>> _gradientCache;
 
     /// <summary>
diff --git a/src/ContinualLearning/Strategies/ExpectedGradientLength.cs b/src/ContinualLearning/Strategies/ExpectedGradientLength.cs
index a4b663ed62..a61bdc0164 100644
--- a/src/ContinualLearning/Strategies/ExpectedGradientLength.cs
+++ b/src/ContinualLearning/Strategies/ExpectedGradientLength.cs
@@ -108,6 +108,7 @@ public class ExpectedGradientLength<T, TInput, TOutput> : ContinualLearningStrat
     private Vector<T>? _previousParameters;
 
     // Running gradient length accumulator
+    [Scratch]
     private Vector<T>? _gradientLengthSum;
     private int _gradientCount;
 
diff --git a/src/ContinualLearning/Strategies/MemoryAwareSynapses.cs b/src/ContinualLearning/Strategies/MemoryAwareSynapses.cs
index cc11a8061b..e15418d079 100644
--- a/src/ContinualLearning/Strategies/MemoryAwareSynapses.cs
+++ b/src/ContinualLearning/Strategies/MemoryAwareSynapses.cs
@@ -169,6 +169,7 @@ public class MemoryAwareSynapses<T, TInput, TOutput> : ContinualLearningStrategy
     private readonly bool _useL1Norm;
 
     // Accumulated importance across tasks (Ω)
+    [AiDotNet.Attributes.Buffer]
     private Vector<T>? _omega;
 
     // Optimal parameters from the last completed task (θ*)
diff --git a/src/ContinualLearning/Strategies/PackNet.cs b/src/ContinualLearning/Strategies/PackNet.cs
index b47aa0af5f..f7ee046b44 100644
--- a/src/ContinualLearning/Strategies/PackNet.cs
+++ b/src/ContinualLearning/Strategies/PackNet.cs
@@ -109,6 +109,7 @@ public class PackNet<T, TInput, TOutput> : ContinualLearningStrategyBase<T, TInp
     private int[]? _parameterOwnership;
 
     // Accumulated gradient importance for gradient-based pruning
+    [Scratch]
     private Vector<T>? _gradientImportance;
     private int _gradientCount;
 
diff --git a/src/ContinualLearning/Strategies/SynapticIntelligence.cs b/src/ContinualLearning/Strategies/SynapticIntelligence.cs
index 3509af4d13..29f8233291 100644
--- a/src/ContinualLearning/Strategies/SynapticIntelligence.cs
+++ b/src/ContinualLearning/Strategies/SynapticIntelligence.cs
@@ -160,6 +160,7 @@ public class SynapticIntelligence<T, TInput, TOutput> : ContinualLearningStrateg
     private readonly bool _trackLayerStatistics;
 
     // Consolidated importance across tasks (Ω in the paper)
+    [AiDotNet.Attributes.Buffer]
     private Vector<T>? _omega;
 
     // Parameters at the start of current task (θ*)
@@ -169,9 +170,11 @@ public class SynapticIntelligence<T, TInput, TOutput> : ContinualLearningStrateg
     private Vector<T>? _pathIntegral;
 
     // Previous gradients for computing parameter changes
+    [Scratch]
     private Vector<T>? _lastGradients;
 
     // Previous parameters for delta computation
+    [Scratch]
     private Vector<T>? _lastParameters;
 
     // Whether we're currently tracking a task
diff --git a/src/ContinualLearning/SynapticIntelligence.cs b/src/ContinualLearning/SynapticIntelligence.cs
index 7ff8273596..669a41c5f7 100644
--- a/src/ContinualLearning/SynapticIntelligence.cs
+++ b/src/ContinualLearning/SynapticIntelligence.cs
@@ -55,6 +55,7 @@ public class SynapticIntelligence<T> : IContinualLearningStrategy<T>
     private double _lambda;
     private readonly double _damping;            // Small constant to prevent division by zero
     private bool _isTrackingTask;
+    [Scratch]
     private Vector<T>? _lastGradients;
 
     /// <summary>
diff --git a/src/CurriculumLearning/CurriculumLearner.cs b/src/CurriculumLearning/CurriculumLearner.cs
index 65ee29d26e..d2ca96181f 100644
--- a/src/CurriculumLearning/CurriculumLearner.cs
+++ b/src/CurriculumLearning/CurriculumLearner.cs
@@ -64,6 +64,7 @@ public class CurriculumLearner<T, TInput, TOutput> : ICurriculumLearner<T, TInpu
     private bool _isTraining;
     private T _bestValidationLoss;
     private int _epochsWithoutImprovement;
+    [AiDotNet.Attributes.FittedParameter]
     private Vector<T>? _currentDifficulties;
     private int[]? _sortedIndices;
 
diff --git a/src/CurriculumLearning/DifficultyEstimators/ExpertDefinedDifficultyEstimator.cs b/src/CurriculumLearning/DifficultyEstimators/ExpertDefinedDifficultyEstimator.cs
index 3091cad83a..fe215ffc6a 100644
--- a/src/CurriculumLearning/DifficultyEstimators/ExpertDefinedDifficultyEstimator.cs
+++ b/src/CurriculumLearning/DifficultyEstimators/ExpertDefinedDifficultyEstimator.cs
@@ -31,9 +31,10 @@ namespace AiDotNet.CurriculumLearning.DifficultyEstimators;
 /// <item><description><b>Dataset metadata:</b> Difficulty stored with sample data</description></item>
 /// </list>
 /// </remarks>
-public class ExpertDefinedDifficultyEstimator<T, TInput, TOutput> : DifficultyEstimatorBase<T, TInput, TOutput>
+public partial class ExpertDefinedDifficultyEstimator<T, TInput, TOutput> : DifficultyEstimatorBase<T, TInput, TOutput>
 {
     private readonly Func<TInput, TOutput, T>? _difficultyFunction;
+    [AiDotNet.Attributes.TrainableParameter]
     private readonly Vector<T>? _precomputedDifficulties;
     private readonly bool _normalize;
 
diff --git a/src/CurriculumLearning/DifficultyEstimators/LossBasedDifficultyEstimator.cs b/src/CurriculumLearning/DifficultyEstimators/LossBasedDifficultyEstimator.cs
index 782b5d6a91..e7b42adb18 100644
--- a/src/CurriculumLearning/DifficultyEstimators/LossBasedDifficultyEstimator.cs
+++ b/src/CurriculumLearning/DifficultyEstimators/LossBasedDifficultyEstimator.cs
@@ -148,6 +148,7 @@ public override Vector<T> EstimateDifficulties(
 public class SmoothedLossDifficultyEstimator<T, TInput, TOutput> : LossBasedDifficultyEstimator<T, TInput, TOutput>
 {
     private readonly T _smoothingFactor;
+    [AiDotNet.Attributes.FittedParameter]
     private Vector<T>? _smoothedLosses;
 
     /// <summary>
diff --git a/src/CurriculumLearning/Schedulers/SelfPacedScheduler.cs b/src/CurriculumLearning/Schedulers/SelfPacedScheduler.cs
index dacafc05ac..210d5406c3 100644
--- a/src/CurriculumLearning/Schedulers/SelfPacedScheduler.cs
+++ b/src/CurriculumLearning/Schedulers/SelfPacedScheduler.cs
@@ -40,6 +40,7 @@ public class SelfPacedScheduler<T> : CurriculumSchedulerBase<T>, ISelfPacedSched
     private readonly T _maxLambda;
     private T _currentLambda;
     private T _lambdaGrowthRate;
+    [AiDotNet.Attributes.Scratch]
     private Vector<T>? _sampleWeights;
 
     /// <summary>
diff --git a/src/DecompositionMethods/TimeSeriesDecomposition/BeveridgeNelsonDecomposition.cs b/src/DecompositionMethods/TimeSeriesDecomposition/BeveridgeNelsonDecomposition.cs
index abde7987e7..e57c945406 100644
--- a/src/DecompositionMethods/TimeSeriesDecomposition/BeveridgeNelsonDecomposition.cs
+++ b/src/DecompositionMethods/TimeSeriesDecomposition/BeveridgeNelsonDecomposition.cs
@@ -23,11 +23,12 @@ namespace AiDotNet.DecompositionMethods.TimeSeriesDecomposition;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Vector<>), typeof(Vector<>))]
 [ResearchPaper("A New Approach to Decomposition of Economic Time Series into Permanent and Transitory Components", "https://doi.org/10.1016/0304-3932(81)90040-4", Year = 1981, Authors = "Stephen Beveridge, Charles R. Nelson")]
-public class BeveridgeNelsonDecomposition<T> : TimeSeriesDecompositionBase<T>
+public partial class BeveridgeNelsonDecomposition<T> : TimeSeriesDecompositionBase<T>
 {
     private readonly BeveridgeNelsonAlgorithmType _algorithm;
     private readonly ARIMAOptions<T> _arimaOptions;
     private readonly int _forecastHorizon;
+    [AiDotNet.Attributes.TrainableParameter]
     private readonly Matrix<T> _multivariateSeries;
 
     /// <summary>
diff --git a/src/Diffusion/Acceleration/PABCache.cs b/src/Diffusion/Acceleration/PABCache.cs
index ec2b9a8652..ce88bba8b9 100644
--- a/src/Diffusion/Acceleration/PABCache.cs
+++ b/src/Diffusion/Acceleration/PABCache.cs
@@ -30,8 +30,11 @@ public class PABCache<T>
     private readonly int _spatialBroadcastInterval;
     private readonly int _temporalBroadcastInterval;
     private readonly int _crossBroadcastInterval;
+    [Scratch]
     private readonly Dictionary<string, Tensor<T>> _spatialCache;
+    [Scratch]
     private readonly Dictionary<string, Tensor<T>> _temporalCache;
+    [Scratch]
     private readonly Dictionary<string, Tensor<T>> _crossCache;
     private int _currentStep;
 
diff --git a/src/Diffusion/Acceleration/TeaCache.cs b/src/Diffusion/Acceleration/TeaCache.cs
index 4c028e07f8..48c41487b1 100644
--- a/src/Diffusion/Acceleration/TeaCache.cs
+++ b/src/Diffusion/Acceleration/TeaCache.cs
@@ -31,6 +31,7 @@ public class TeaCache<T>
 {
     private readonly double _reuseThreshold;
     private readonly int _maxCacheSize;
+    [Scratch]
     private readonly Dictionary<string, Tensor<T>> _kvCache;
     private readonly Dictionary<string, double> _lastTimestepEmbedding;
     private readonly List<string> _insertionOrder;
diff --git a/src/Diffusion/Attention/DiffusionAttention.cs b/src/Diffusion/Attention/DiffusionAttention.cs
index 2907853649..1e7a8d1e9a 100644
--- a/src/Diffusion/Attention/DiffusionAttention.cs
+++ b/src/Diffusion/Attention/DiffusionAttention.cs
@@ -91,6 +91,7 @@ public partial class DiffusionAttention<T> : LayerBase<T>, IShapeContract
     /// <summary>
     /// Cached input for backward pass.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastInput;
 
     /// <summary>
@@ -118,6 +119,9 @@ public partial class DiffusionAttention<T> : LayerBase<T>, IShapeContract
     /// </summary>
     public bool FlashAttentionEnabled => _flashConfig != null;
 
+    /// <summary>Construction state: the 'useCausalMask' the layer was built with.</summary>
+    private readonly bool _useCausalMask;
+
     /// <summary>
     /// Initializes a new diffusion attention layer.
     /// </summary>
@@ -146,6 +150,7 @@ public DiffusionAttention(
             CalculateInputShape(channels, spatialSize),
             CalculateOutputShape(channels, spatialSize))
     {
+        _useCausalMask = useCausalMask;
         if (channels <= 0)
             throw new ArgumentOutOfRangeException(nameof(channels), "Channels must be positive.");
         if (numHeads <= 0)
@@ -392,11 +397,13 @@ public partial class DiffusionCrossAttention<T> : LayerBase<T>, IShapeContract
     /// <summary>
     /// Cached input for backward pass.
     /// </summary>
+    [AiDotNet.Attributes.Scratch]
     private Tensor<T>? _lastInput;
 
     /// <summary>
     /// Cached context for backward pass.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastContext;
 
     /// <inheritdoc />
diff --git a/src/Diffusion/Attention/FactorizedSpatioTemporalAttention.cs b/src/Diffusion/Attention/FactorizedSpatioTemporalAttention.cs
index 4c07f79bc6..b14c7c75a1 100644
--- a/src/Diffusion/Attention/FactorizedSpatioTemporalAttention.cs
+++ b/src/Diffusion/Attention/FactorizedSpatioTemporalAttention.cs
@@ -43,6 +43,7 @@ public partial class FactorizedSpatioTemporalAttention<T> : LayerBase<T>, IShape
     private readonly TemporalSelfAttention<T> _temporalAttention;
     private readonly LayerNormalizationLayer<T> _spatialNorm;
     private readonly LayerNormalizationLayer<T> _temporalNorm;
+    [Scratch]
     private Tensor<T>? _lastInput;
 
     /// <inheritdoc />
diff --git a/src/Diffusion/Attention/Full3DAttention.cs b/src/Diffusion/Attention/Full3DAttention.cs
index 09435bd50b..1bd0ddf296 100644
--- a/src/Diffusion/Attention/Full3DAttention.cs
+++ b/src/Diffusion/Attention/Full3DAttention.cs
@@ -42,6 +42,7 @@ public partial class Full3DAttention<T> : LayerBase<T>, IShapeContract
     private readonly int _numFrames;
     private readonly int _spatialSize;
     private readonly FlashAttentionLayer<T> _fullAttention;
+    [Scratch]
     private Tensor<T>? _lastInput;
 
     /// <inheritdoc />
diff --git a/src/Diffusion/Attention/MotionModule.cs b/src/Diffusion/Attention/MotionModule.cs
index 9792af61d6..18ec53fd18 100644
--- a/src/Diffusion/Attention/MotionModule.cs
+++ b/src/Diffusion/Attention/MotionModule.cs
@@ -45,6 +45,7 @@ public partial class MotionModule<T> : LayerBase<T>, IShapeContract
     private readonly DenseLayer<T> _ffnOut;
     private readonly LayerNormalizationLayer<T> _norm1;
     private readonly LayerNormalizationLayer<T> _norm2;
+    [Scratch]
     private Tensor<T>? _lastInput;
 
     /// <inheritdoc />
@@ -60,6 +61,9 @@ public partial class MotionModule<T> : LayerBase<T>, IShapeContract
     /// </summary>
     public int NumFrames => _numFrames;
 
+    /// <summary>Construction state: the 'ffnMultiplier' the layer was built with.</summary>
+    private readonly int _ffnMultiplier;
+
     /// <summary>
     /// Initializes a new AnimateDiff motion module.
     /// </summary>
@@ -78,6 +82,7 @@ public MotionModule(
             new[] { spatialSize * spatialSize, numFrames, channels },
             new[] { spatialSize * spatialSize, numFrames, channels })
     {
+        _ffnMultiplier = ffnMultiplier;
         if (channels <= 0)
             throw new ArgumentOutOfRangeException(nameof(channels), "Channels must be positive.");
         if (numHeads <= 0)
diff --git a/src/Diffusion/Attention/STDiTBlock.cs b/src/Diffusion/Attention/STDiTBlock.cs
index 7b6b0aa0a0..a3d44b7674 100644
--- a/src/Diffusion/Attention/STDiTBlock.cs
+++ b/src/Diffusion/Attention/STDiTBlock.cs
@@ -49,6 +49,7 @@ public partial class STDiTBlock<T> : LayerBase<T>, IShapeContract
     private readonly LayerNormalizationLayer<T> _crossNorm;
     private readonly LayerNormalizationLayer<T> _ffnNorm;
 
+    [Scratch]
     private Tensor<T>? _lastInput;
     private Tensor<T>? _afterSpatial;
     private Tensor<T>? _afterTemporal;
@@ -72,6 +73,9 @@ private Tensor<T> AddTensors(Tensor<T> a, Tensor<T> b)
     /// </summary>
     public int ContextDim => _contextDim;
 
+    /// <summary>Construction state: the 'ffnMultiplier' the layer was built with.</summary>
+    private readonly int _ffnMultiplier;
+
     /// <summary>
     /// Initializes a new STDiT block.
     /// </summary>
@@ -92,6 +96,7 @@ public STDiTBlock(
             new[] { 1, numFrames * spatialSize * spatialSize, channels },
             new[] { 1, numFrames * spatialSize * spatialSize, channels })
     {
+        _ffnMultiplier = ffnMultiplier;
         if (channels <= 0)
             throw new ArgumentOutOfRangeException(nameof(channels), "Channels must be positive.");
         if (numHeads <= 0)
diff --git a/src/Diffusion/Attention/TemporalConvolution.cs b/src/Diffusion/Attention/TemporalConvolution.cs
index 9ae3da39e5..283ef67708 100644
--- a/src/Diffusion/Attention/TemporalConvolution.cs
+++ b/src/Diffusion/Attention/TemporalConvolution.cs
@@ -37,6 +37,7 @@ public partial class TemporalConvolution<T> : LayerBase<T>, IShapeContract
     private readonly bool _causal;
     private readonly DenseLayer<T> _conv;
     private readonly LayerNormalizationLayer<T> _norm;
+    [Scratch]
     private Tensor<T>? _lastInput;
 
     private Tensor<T> AddTensors(Tensor<T> a, Tensor<T> b)
diff --git a/src/Diffusion/Attention/TemporalSelfAttention.cs b/src/Diffusion/Attention/TemporalSelfAttention.cs
index 6fe21d6d77..ad9d29ca69 100644
--- a/src/Diffusion/Attention/TemporalSelfAttention.cs
+++ b/src/Diffusion/Attention/TemporalSelfAttention.cs
@@ -41,6 +41,7 @@ public partial class TemporalSelfAttention<T> : LayerBase<T>, IShapeContract
     private readonly int _numFrames;
     private readonly int _spatialSize;
     private readonly MultiHeadAttentionLayer<T> _temporalAttention;
+    [Scratch]
     private Tensor<T>? _lastInput;
 
     /// <inheritdoc />
diff --git a/src/Diffusion/Audio/AudioLDM2Model.cs b/src/Diffusion/Audio/AudioLDM2Model.cs
index b018f82bc4..d3f575a5b8 100644
--- a/src/Diffusion/Audio/AudioLDM2Model.cs
+++ b/src/Diffusion/Audio/AudioLDM2Model.cs
@@ -855,46 +855,6 @@ public virtual List<Tensor<T>> InterpolateAudio(
 
     #region ICloneable Implementation
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy()
-    {
-        return Clone();
-    }
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        // The previous Clone() passed unet/audioVAE as null and let the
-        // constructor build fresh randomly-initialized sub-modules, dropping
-        // every learned weight on the original. That broke
-        // Clone_ShouldProduceIdenticalOutput (cloned Predict diverged from
-        // original Predict — same seed, totally different noise predictor
-        // weights). Per Liu et al. 2024 §3 the AudioLDM2 latent pipeline is
-        // <c>VAE + UNet + projection</c>, so the clone must carry the same
-        // weights across all three. Conditioners are treated as shared,
-        // upstream-frozen modules (CLAP / T5-GPT2 in the paper) and don't
-        // get deep-copied.
-        var unetClone = (UNetNoisePredictor<T>)_unet.Clone();
-        var vaeClone = (AudioVAE<T>)_audioVAE.Clone();
-
-        var clone = new AudioLDM2Model<T>(
-            options: null,
-            scheduler: null,
-            unet: unetClone,
-            audioVAE: vaeClone,
-            clapConditioner: _clapConditioner,
-            languageConditioner: _languageConditioner,
-            variant: _variant,
-            sampleRate: SampleRate,
-            defaultDurationSeconds: DefaultDurationSeconds);
-
-        // The projection layer is created fresh by InitializeLayers because
-        // its dimensions are derived from <c>_variant</c> and the conditioner
-        // dim, not passed in. Copy its weights/bias across explicitly.
-        clone._projectionLayer.SetParameters(_projectionLayer.GetParameters());
-        return clone;
-    }
-
     #endregion
 }
 
diff --git a/src/Diffusion/Audio/AudioLDMModel.cs b/src/Diffusion/Audio/AudioLDMModel.cs
index 94e4800fa7..f192eb2d56 100644
--- a/src/Diffusion/Audio/AudioLDMModel.cs
+++ b/src/Diffusion/Audio/AudioLDMModel.cs
@@ -532,28 +532,5 @@ public virtual List<Tensor<T>> GenerateVariations(
 
     #region ICloneable Implementation
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy()
-    {
-        return Clone();
-    }
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        // Lazy-preserving Clone: delegate to the U-Net's and AudioVAE's own Clone() (trained weights
-        // preserved); configuration is carried by the injected submodules + the passed-through fields.
-        return new AudioLDMModel<T>(
-            options: null,
-            scheduler: null,
-            unet: (UNetNoisePredictor<T>)_unet.Clone(),
-            audioVAE: (AudioVAE<T>)_audioVAE.Clone(),
-            conditioner: _conditioner,
-            sampleRate: SampleRate,
-            defaultDurationSeconds: DefaultDurationSeconds,
-            melChannels: MelChannels,
-            isVersion2: _isVersion2);
-    }
-
     #endregion
 }
diff --git a/src/Diffusion/Audio/BarkModel.cs b/src/Diffusion/Audio/BarkModel.cs
new file mode 100644
index 0000000000..56849ca39c
--- /dev/null
+++ b/src/Diffusion/Audio/BarkModel.cs
@@ -0,0 +1,234 @@
+using System.Diagnostics.CodeAnalysis;
+using AiDotNet.Attributes;
+using AiDotNet.Diffusion.NoisePredictors;
+using AiDotNet.Diffusion.VAE;
+using AiDotNet.Enums;
+using AiDotNet.Helpers;
+using AiDotNet.Interfaces;
+using AiDotNet.LinearAlgebra;
+using AiDotNet.Models;
+using AiDotNet.Models.Options;
+using AiDotNet.NeuralNetworks;
+using AiDotNet.Diffusion.Schedulers;
+
+namespace AiDotNet.Diffusion.Audio;
+
+/// <summary>
+/// Bark model for transformer-based text-to-audio generation with multi-lingual speech, music, and sound effects.
+/// </summary>
+/// <typeparam name="T">The numeric type used for calculations.</typeparam>
+/// <remarks>
+/// <para>
+/// Bark uses a GPT-like auto-regressive architecture with three transformer stages to generate
+/// diverse audio content from text prompts, including speech in 10+ languages, music, laughter,
+/// sighing, and other non-verbal sounds. Audio tokens are produced via an EnCodec codec.
+/// </para>
+/// <para>
+/// Architecture components:
+/// <list type="bullet">
+/// <item><description>Semantic transformer (GPT-like, 1024 hidden, 24 layers, 16 heads) for text-to-semantic tokens</description></item>
+/// <item><description>Coarse acoustic transformer for semantic-to-coarse audio tokens</description></item>
+/// <item><description>Fine acoustic transformer for coarse-to-fine audio token refinement</description></item>
+/// <item><description>CLIP text encoder for 768-dim conditioning</description></item>
+/// <item><description>EnCodec-based audio codec for token-to-waveform synthesis</description></item>
+/// <item><description>Speaker voice presets for zero-shot cloning</description></item>
+/// </list>
+/// </para>
+/// <para>
+/// <b>For Beginners:</b> Bark generates realistic speech and sounds from text prompts.
+///
+/// How Bark works:
+/// 1. Text is tokenized and encoded via CLIP into 768-dim conditioning features
+/// 2. Semantic transformer converts text tokens to high-level semantic audio tokens
+/// 3. Coarse acoustic transformer maps semantic tokens to coarse EnCodec tokens
+/// 4. Fine acoustic transformer refines coarse tokens to full-resolution EnCodec tokens
+/// 5. EnCodec decoder converts audio tokens to a 24 kHz waveform
+/// 6. Speaker presets enable voice cloning from short reference audio
+///
+/// Key characteristics:
+/// - Three-stage GPT-like auto-regressive generation
+/// - Multi-lingual speech in 10+ languages
+/// - Non-speech audio: laughter, music, sound effects, sighing
+/// - Speaker cloning with voice presets
+/// - EnCodec-based audio codec at 24 kHz
+/// - Open-source (Suno AI, MIT license)
+///
+/// When to use Bark:
+/// - Multi-lingual text-to-speech generation
+/// - Expressive speech with emotions and non-verbal sounds
+/// - Quick audio prototyping from text descriptions
+/// - When diverse audio output types are needed
+///
+/// Limitations:
+/// - Auto-regressive generation is slower than parallel methods
+/// - Maximum duration limited by context window
+/// - Speaker cloning quality depends on reference audio
+/// - Less control over fine-grained prosody
+/// </para>
+/// <para>
+/// Technical specifications:
+/// - Architecture: Three-stage GPT-like transformer
+/// - Hidden dimension: 1024
+/// - Transformer layers: 24
+/// - Attention heads: 16
+/// - Text encoder: CLIP (768-dim)
+/// - Audio codec: EnCodec
+/// - Sample rate: 24,000 Hz
+/// - Default duration: 15 seconds
+/// - Mel channels: 100
+/// - Open-source: Yes (MIT license)
+///
+/// Reference: Suno AI, "Bark: Text-Prompted Generative Audio Model", 2023
+/// </para>
+/// </remarks>
+/// <example>
+/// <code>
+/// var bark = new BarkModel&lt;float&gt;();
+/// var speech = bark.GenerateFromText(
+///     prompt: "Hello, how are you today? [laughs]",
+///     durationSeconds: 10.0,
+///     numInferenceSteps: 100,
+///     guidanceScale: 3.0);
+/// </code>
+/// </example>
+[ModelDomain(ModelDomain.Audio)]
+[ModelDomain(ModelDomain.Language)]
+[ModelCategory(ModelCategory.Transformer)]
+[ModelTask(ModelTask.Generation)]
+[ModelTask(ModelTask.TextToSpeech)]
+[ModelComplexity(ModelComplexity.High)]
+[ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
+    [ResearchPaper("Bark: Text-Prompted Generative Audio Model", "https://github.com/suno-ai/bark")]
+public partial class BarkModel<T> : AudioDiffusionModelBase<T>
+{
+    /// <inheritdoc />
+    /// <remarks>Registration order is serialization order, and matches the
+    /// concatenation the previous hand-written GetParameters performed.</remarks>
+    protected override void RegisterComponents()
+    {
+        RegisterParameterComponent(_transformer);
+        RegisterParameterComponent(_audioVAE);
+    }
+
+    #region Constants
+
+    private const int LATENT_CHANNELS = 8;
+    private const int HIDDEN_DIM = 1024;
+    private const int NUM_LAYERS = 24;
+    private const int NUM_HEADS = 16;
+    private const int CONTEXT_DIM = 768;
+    private const int SAMPLE_RATE = 24000;
+    private const int MEL_CHANNELS = 100;
+    private const double DEFAULT_DURATION = 15.0;
+
+    #endregion
+
+    #region Fields
+
+    private DiTNoisePredictor<T> _transformer;
+    private AudioVAE<T> _audioVAE;
+    private readonly IConditioningModule<T>? _conditioner;
+
+    #endregion
+
+    #region Properties
+
+    /// <inheritdoc />
+    public override INoisePredictor<T> NoisePredictor => _transformer;
+    /// <inheritdoc />
+    public override IVAEModel<T> VAE => _audioVAE;
+    /// <inheritdoc />
+    public override IConditioningModule<T>? Conditioner => _conditioner;
+    /// <inheritdoc />
+    public override int LatentChannels => LATENT_CHANNELS;
+    /// <inheritdoc />
+    public override bool SupportsTextToAudio => true;
+    /// <inheritdoc />
+    public override bool SupportsTextToMusic => true;
+    /// <inheritdoc />
+    public override bool SupportsTextToSpeech => true;
+    /// <inheritdoc />
+    public override bool SupportsAudioToAudio => false;
+    /// <inheritdoc />
+
+    #endregion
+
+    #region Constructor
+
+    public BarkModel(
+        NeuralNetworkArchitecture<T>? architecture = null,
+        DiffusionModelOptions<T>? options = null,
+        INoiseScheduler<T>? scheduler = null,
+        DiTNoisePredictor<T>? transformer = null,
+        AudioVAE<T>? audioVAE = null,
+        IConditioningModule<T>? conditioner = null,
+        int? seed = null)
+        : base(
+            options ?? new DiffusionModelOptions<T>
+            {
+                TrainTimesteps = 1000, BetaStart = 0.0001,
+                BetaEnd = 0.02, BetaSchedule = BetaSchedule.Linear
+            },
+            scheduler ?? new DDPMScheduler<T>(SchedulerConfig<T>.CreateDefault()),
+            sampleRate: SAMPLE_RATE, defaultDurationSeconds: DEFAULT_DURATION,
+            melChannels: MEL_CHANNELS, architecture: architecture)
+    {
+        _conditioner = conditioner;
+        InitializeLayers(transformer, audioVAE, seed);
+    }
+
+    #endregion
+
+    #region Layer Initialization
+
+    [MemberNotNull(nameof(_transformer), nameof(_audioVAE))]
+    private void InitializeLayers(DiTNoisePredictor<T>? transformer, AudioVAE<T>? audioVAE, int? seed)
+    {
+        _transformer = transformer ?? new DiTNoisePredictor<T>(
+            inputChannels: LATENT_CHANNELS, hiddenSize: HIDDEN_DIM,
+            numLayers: NUM_LAYERS, numHeads: NUM_HEADS,
+            patchSize: 1, contextDim: CONTEXT_DIM);
+
+        _audioVAE = audioVAE ?? new AudioVAE<T>(
+            melChannels: MEL_CHANNELS, latentChannels: LATENT_CHANNELS,
+            baseChannels: 64, numResBlocks: 2);
+    }
+
+    #endregion
+
+    #region IParameterizable Implementation
+
+
+
+    #endregion
+
+    #region ICloneable Implementation
+
+    #endregion
+
+    #region Metadata
+
+    /// <inheritdoc />
+    public override ModelMetadata<T> GetModelMetadata()
+    {
+        var metadata = new ModelMetadata<T>
+        {
+            Name = "Bark", Version = "1.0",
+            Description = "Bark GPT-based text-to-audio generation with multi-lingual speech and sound effects",
+            FeatureCount = (int)System.Math.Min((long)int.MaxValue, ParameterCount), Complexity = ParameterCount
+        };
+        metadata.SetProperty("architecture", "gpt-encodec-three-stage");
+        metadata.SetProperty("hidden_dim", HIDDEN_DIM);
+        metadata.SetProperty("num_layers", NUM_LAYERS);
+        metadata.SetProperty("num_heads", NUM_HEADS);
+        metadata.SetProperty("audio_codec", "EnCodec");
+        metadata.SetProperty("multilingual", true);
+        metadata.SetProperty("non_speech_audio", true);
+        metadata.SetProperty("speaker_cloning", true);
+        metadata.SetProperty("sample_rate", SAMPLE_RATE);
+        metadata.SetProperty("open_source", true);
+        return metadata;
+    }
+
+    #endregion
+}
diff --git a/src/Diffusion/Audio/DiffWaveModel.cs b/src/Diffusion/Audio/DiffWaveModel.cs
index d1a9fafd82..20ff799d1a 100644
--- a/src/Diffusion/Audio/DiffWaveModel.cs
+++ b/src/Diffusion/Audio/DiffWaveModel.cs
@@ -126,14 +126,6 @@ protected override void RegisterComponents()
     /// </summary>
     private DiffWaveNetwork<T> _network;
 
-    /// <summary>
-    /// Last audio input shape seen by <see cref="PredictNoise"/>. Used by
-    /// <see cref="Clone"/> to replay lazy DenseLayer shape resolution on
-    /// the cloned network so its layers have the same parameter layout
-    /// as the original before parameters are copied across.
-    /// </summary>
-    private int[]? _lastInputShape;
-
     #endregion
 
     #region Properties
@@ -348,14 +340,6 @@ private Tensor<T> SampleNoise(int[] shape, Random rng)
     /// <inheritdoc />
     public override Tensor<T> PredictNoise(Tensor<T> noisySample, int timestep)
     {
-        // Remember the input shape so Clone() can replay lazy shape
-        // resolution on the cloned network — the downstream DenseLayers
-        // project the LAST tensor dim, so their parameter count depends
-        // on the audio's time axis. Without this, the clone's layers
-        // would lazily initialize to a different shape on first Predict
-        // and SetParameters would reject the original's parameter
-        // vector with an "Expected X parameters, got Y" mismatch.
-        _lastInputShape = (int[])noisySample._shape.Clone();
         return _network.Forward(noisySample, timestep, null);
     }
 
@@ -369,32 +353,6 @@ public override Tensor<T> PredictNoise(Tensor<T> noisySample, int timestep)
 
     #region ICloneable Implementation
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy()
-    {
-        return Clone();
-    }
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        var clone = new DiffWaveModel<T>(
-            residualChannels: _residualChannels,
-            residualLayers: _residualLayers,
-            dilationCycle: _dilationCycle,
-            melChannels: _melChannels,
-            sampleRate: SampleRate,
-            seed: null);
-
-        if (_lastInputShape is not null)
-        {
-            clone._network.ResolveLayerShapesFor(_lastInputShape);
-            clone._lastInputShape = (int[])_lastInputShape.Clone();
-        }
-        if (!clone.TryShareParametersFrom(this)) clone.SetParameterChunks(GetParameterChunks());
-        return clone;
-    }
-
     #endregion
 
     #region Metadata
@@ -517,6 +475,10 @@ public DiffWaveNetwork(
         // a 2-layer FC MLP. The MLP is per-sample (no time axis), so a
         // plain DenseLayer is paper-correct here — NOT a Conv1D.
         _diffusionEmbedding = new DenseLayer<T>(residualChannels, (IActivationFunction<T>?)null);
+        // The sinusoidal embedding width is an architectural constant, not a data-dependent
+        // shape. Declare it at construction so manifests, checkpoints, and generated clones all
+        // expose the same parameter surface before the first forward pass.
+        _diffusionEmbedding.ResolveShapesOnly([128]);
 
         // Residual blocks with varying dilation
         _residualBlocks = new List<DiffWaveResidualBlock<T>>();
@@ -553,25 +515,6 @@ public DiffWaveNetwork(
         // anti-pattern.
     }
 
-    /// <summary>
-    /// Replays the lazy shape-resolution pass that would happen on the
-    /// first <see cref="Forward"/> with the given audio shape, without
-    /// keeping the dummy output. Used by <see cref="DiffWaveModel{T}.Clone"/>
-    /// to make the cloned network's layers match the original's parameter
-    /// layout before <c>SetParameters</c> validates the count.
-    /// </summary>
-    internal void ResolveLayerShapesFor(int[] audioShape)
-    {
-        if (audioShape is null) throw new ArgumentNullException(nameof(audioShape));
-        if (audioShape.Length < 1)
-        {
-            throw new ArgumentException(
-                "Audio shape must have at least one dimension.", nameof(audioShape));
-        }
-        var dummyAudio = new Tensor<T>(audioShape);
-        _ = Forward(dummyAudio, timestep: 0, melCondition: null);
-    }
-
     /// <summary>
     /// Forward pass through the network — Kong et al. 2020 "DiffWave"
     /// §3 / Figure 1. Channel layout is paper-faithful channels-FIRST
@@ -854,6 +797,9 @@ public DiffWaveResidualBlock(
         // residualChannels-dim per-sample embedding to residualChannels
         // (then broadcast-added across the time axis inside Forward).
         _diffusionProj = new DenseLayer<T>(channels, (IActivationFunction<T>?)null);
+        // The parent MLP emits exactly residualChannels values. Resolve this construction-known
+        // dimension once instead of making clone/checkpoint layout depend on a warm-up forward.
+        _diffusionProj.ResolveShapesOnly([channels]);
 
         // Mel conditioning — Kong 2020 §3.3: optional global conditioner
         // (mel-spectrogram, upsampled to audio rate) projected via 1×1
diff --git a/src/Diffusion/Audio/GriffinLim.cs b/src/Diffusion/Audio/GriffinLim.cs
index 1831dc55d2..4985a50d69 100644
--- a/src/Diffusion/Audio/GriffinLim.cs
+++ b/src/Diffusion/Audio/GriffinLim.cs
@@ -47,7 +47,7 @@ namespace AiDotNet.Diffusion.Audio;
 /// </remarks>
 [ComponentType(ComponentType.Encoder)]
 [PipelineStage(PipelineStage.Preprocessing)]
-public class GriffinLim<T>
+public partial class GriffinLim<T>
 {
     /// <summary>
     /// Provides numeric operations for the specific type T.
@@ -67,6 +67,7 @@ public class GriffinLim<T>
     /// <summary>
     /// Window tensor for GPU operations.
     /// </summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private readonly Tensor<T>? _windowTensor;
 
     /// <summary>
diff --git a/src/Diffusion/Audio/JEN1Model.cs b/src/Diffusion/Audio/JEN1Model.cs
index 05b26c6a4d..d68ca72b3c 100644
--- a/src/Diffusion/Audio/JEN1Model.cs
+++ b/src/Diffusion/Audio/JEN1Model.cs
@@ -221,25 +221,6 @@ private void InitializeLayers(
 
     #region ICloneable Implementation
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy()
-    {
-        return Clone();
-    }
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        var clonedUnet = (UNetNoisePredictor<T>)_unet.Clone();
-        var clonedVae = (AudioVAE<T>)_audioVae.Clone();
-
-        return new JEN1Model<T>(
-            architecture: Architecture,
-            unet: clonedUnet,
-            audioVae: clonedVae,
-            conditioner: _conditioner);
-    }
-
     #endregion
 
     #region Metadata
diff --git a/src/Diffusion/Audio/MelSpectrogram.cs b/src/Diffusion/Audio/MelSpectrogram.cs
index 5f3a1f92bb..60e4cbb26f 100644
--- a/src/Diffusion/Audio/MelSpectrogram.cs
+++ b/src/Diffusion/Audio/MelSpectrogram.cs
@@ -46,7 +46,7 @@ namespace AiDotNet.Diffusion.Audio;
 /// </remarks>
 [ComponentType(ComponentType.Encoder)]
 [PipelineStage(PipelineStage.Preprocessing)]
-public class MelSpectrogram<T>
+public partial class MelSpectrogram<T>
 {
     /// <summary>
     /// Provides numeric operations for the specific type T.
@@ -101,11 +101,13 @@ public class MelSpectrogram<T>
     /// <summary>
     /// Mel filterbank matrix [nMels, nFreqs].
     /// </summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private readonly Tensor<T> _melFilterbank;
 
     /// <summary>
     /// Window tensor for IEngine operations.
     /// </summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private readonly Tensor<T> _windowTensor;
 
     /// <summary>
diff --git a/src/Diffusion/Audio/MusicGenModel.cs b/src/Diffusion/Audio/MusicGenModel.cs
index cd755a4e7b..c6a6a0f152 100644
--- a/src/Diffusion/Audio/MusicGenModel.cs
+++ b/src/Diffusion/Audio/MusicGenModel.cs
@@ -954,30 +954,6 @@ private Tensor<T> BlendAudio(Tensor<T> first, Tensor<T> second, int overlapSampl
 
     #region ICloneable Implementation
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy()
-    {
-        return Clone();
-    }
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        var clone = new MusicGenModel<T>(
-            architecture: Architecture,
-            unet: (UNetNoisePredictor<T>)_unet.Clone(),
-            musicVAE: (AudioVAE<T>)_musicVAE.Clone(),
-            textConditioner: _textConditioner,
-            modelSize: _modelSize,
-            sampleRate: SampleRate,
-            defaultDurationSeconds: DefaultDurationSeconds);
-
-        clone._melodyEncoder.SetParameters(_melodyEncoder.GetParameters());
-        clone._rhythmEncoder.SetParameters(_rhythmEncoder.GetParameters());
-
-        return clone;
-    }
-
     #endregion
 }
 
diff --git a/src/Diffusion/Audio/RiffusionModel.cs b/src/Diffusion/Audio/RiffusionModel.cs
index b25901c9a6..d94302ce9e 100644
--- a/src/Diffusion/Audio/RiffusionModel.cs
+++ b/src/Diffusion/Audio/RiffusionModel.cs
@@ -576,30 +576,6 @@ private Tensor<T> InterpolateTensors(Tensor<T> a, Tensor<T> b, double alpha)
 
     #region ICloneable Implementation
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy()
-    {
-        return Clone();
-    }
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        EnsureParameterShapesResolved();
-
-        // Preserve the actual injected architecture instead of rebuilding the
-        // default full-size SD 1.5 spectrogram stack.
-        var clonedUnet = (UNetNoisePredictor<T>)_unet.Clone();
-        var clonedVae = (StandardVAE<T>)_vae.Clone();
-
-        return new RiffusionModel<T>(
-            unet: clonedUnet,
-            vae: clonedVae,
-            conditioner: _conditioner,
-            spectrogramConfig: _spectrogramConfig,
-            seed: _seed);
-    }
-
     /// <summary>
     /// Materializes lazy submodule weights before state-dict style operations.
     /// </summary>
diff --git a/src/Diffusion/Audio/ShortTimeFourierTransform.cs b/src/Diffusion/Audio/ShortTimeFourierTransform.cs
index 6a05204068..d2dd52225a 100644
--- a/src/Diffusion/Audio/ShortTimeFourierTransform.cs
+++ b/src/Diffusion/Audio/ShortTimeFourierTransform.cs
@@ -41,7 +41,7 @@ namespace AiDotNet.Diffusion.Audio;
 /// </remarks>
 [ComponentType(ComponentType.Encoder)]
 [PipelineStage(PipelineStage.Preprocessing)]
-public class ShortTimeFourierTransform<T>
+public partial class ShortTimeFourierTransform<T>
 {
     /// <summary>
     /// Provides numeric operations for the specific type T.
@@ -91,6 +91,7 @@ public class ShortTimeFourierTransform<T>
     /// <summary>
     /// Window function as a tensor (for IEngine operations).
     /// </summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T>? _windowTensor;
 
     /// <summary>
diff --git a/src/Diffusion/Audio/SoundStormModel.cs b/src/Diffusion/Audio/SoundStormModel.cs
index e45f2cc260..304035d2c7 100644
--- a/src/Diffusion/Audio/SoundStormModel.cs
+++ b/src/Diffusion/Audio/SoundStormModel.cs
@@ -202,17 +202,6 @@ private void InitializeLayers(DiTNoisePredictor<T>? conformer, AudioVAE<T>? audi
 
     #region ICloneable Implementation
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-                return new SoundStormModel<T>(conformer: (DiTNoisePredictor<T>)_conformer.Clone(),
-            audioVAE: (AudioVAE<T>)_audioVAE.Clone(),
-            conditioner: _conditioner);
-    }
-
     #endregion
 
     #region Metadata
diff --git a/src/Diffusion/Audio/StableAudioModel.cs b/src/Diffusion/Audio/StableAudioModel.cs
index 59bc61d687..b96d269993 100644
--- a/src/Diffusion/Audio/StableAudioModel.cs
+++ b/src/Diffusion/Audio/StableAudioModel.cs
@@ -218,21 +218,6 @@ private void InitializeLayers(
 
     #region ICloneable
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy()
-    {
-        return Clone();
-    }
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-                return new StableAudioModel<T>(
-            dit: (DiTNoisePredictor<T>)_dit.Clone(),
-            audioVAE: (AudioVAE<T>)_audioVAE.Clone(),
-            conditioner: _conditioner);
-    }
-
     #endregion
 
     #region Metadata
diff --git a/src/Diffusion/Audio/UdioModel.cs b/src/Diffusion/Audio/UdioModel.cs
index 3e5efd5e5f..6edb985bf3 100644
--- a/src/Diffusion/Audio/UdioModel.cs
+++ b/src/Diffusion/Audio/UdioModel.cs
@@ -214,18 +214,6 @@ private void InitializeLayers(DiTNoisePredictor<T>? dit, AudioVAE<T>? audioVAE,
 
     #region ICloneable Implementation
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        EnsureInitialized();
-        return new UdioModel<T>(dit: (DiTNoisePredictor<T>)_dit.Clone(),
-            audioVAE: (AudioVAE<T>)_audioVAE.Clone(),
-            conditioner: _conditioner);
-    }
-
     #endregion
 
     #region Metadata
diff --git a/src/Diffusion/Audio/VoiceCraftModel.cs b/src/Diffusion/Audio/VoiceCraftModel.cs
index a4c38fe436..1b1ce6ac96 100644
--- a/src/Diffusion/Audio/VoiceCraftModel.cs
+++ b/src/Diffusion/Audio/VoiceCraftModel.cs
@@ -205,17 +205,6 @@ private void InitializeLayers(DiTNoisePredictor<T>? transformer, AudioVAE<T>? au
 
     #region ICloneable Implementation
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-                return new VoiceCraftModel<T>(transformer: (DiTNoisePredictor<T>)_transformer.Clone(),
-            audioVAE: (AudioVAE<T>)_audioVAE.Clone(),
-            conditioner: _conditioner);
-    }
-
     #endregion
 
     #region Metadata
diff --git a/src/Diffusion/AudioDiffusionModelBase.cs b/src/Diffusion/AudioDiffusionModelBase.cs
index 1db0811def..13a20b2e3d 100644
--- a/src/Diffusion/AudioDiffusionModelBase.cs
+++ b/src/Diffusion/AudioDiffusionModelBase.cs
@@ -30,7 +30,7 @@ namespace AiDotNet.Diffusion;
 /// 5. A vocoder converts the spectrogram back to audio
 /// </para>
 /// </remarks>
-public abstract class AudioDiffusionModelBase<T> : LatentDiffusionModelBase<T>, IAudioDiffusionModel<T>
+public abstract partial class AudioDiffusionModelBase<T> : LatentDiffusionModelBase<T>, IAudioDiffusionModel<T>
 {
     /// <summary>
     /// Sample rate in Hz.
diff --git a/src/Diffusion/Conditioning/CLIPTextConditioner.cs b/src/Diffusion/Conditioning/CLIPTextConditioner.cs
index 55e44835f1..256df88ea0 100644
--- a/src/Diffusion/Conditioning/CLIPTextConditioner.cs
+++ b/src/Diffusion/Conditioning/CLIPTextConditioner.cs
@@ -99,9 +99,6 @@ protected override IEnumerable<ILayer<T>> CreateDefaultLayers() =>
             numLayers: GetNumLayers(_variant),
             numHeads: GetNumHeads(_variant));
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() =>
-        new CLIPTextConditioner<T>(Tokenizer, _variant, Architecture);
-
     /// <summary>
     /// CLIP pools by extracting the embedding at the EOS token position
     /// (Radford 2021 §3.1) and then applying <see cref="_textProjection"/>
diff --git a/src/Diffusion/Conditioning/ChatGLM3TextConditioner.cs b/src/Diffusion/Conditioning/ChatGLM3TextConditioner.cs
index e1c34d18c8..abecaf7433 100644
--- a/src/Diffusion/Conditioning/ChatGLM3TextConditioner.cs
+++ b/src/Diffusion/Conditioning/ChatGLM3TextConditioner.cs
@@ -70,9 +70,6 @@ protected override IEnumerable<ILayer<T>> CreateDefaultLayers() =>
             numHeads: GetNumHeads(_variant),
             numKvHeads: GetNumKvHeads(_variant));
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() =>
-        new ChatGLM3TextConditioner<T>(Tokenizer, _variant, Architecture);
-
     public override Tensor<T> GetPooledEmbedding(Tensor<T> sequenceEmbeddings)
     {
         int rank = sequenceEmbeddings.Shape.Length;
diff --git a/src/Diffusion/Conditioning/DistilledT5TextConditioner.cs b/src/Diffusion/Conditioning/DistilledT5TextConditioner.cs
index 62c48871d8..4be0a55e8d 100644
--- a/src/Diffusion/Conditioning/DistilledT5TextConditioner.cs
+++ b/src/Diffusion/Conditioning/DistilledT5TextConditioner.cs
@@ -68,9 +68,6 @@ protected override IEnumerable<ILayer<T>> CreateDefaultLayers() =>
             numLayers: GetNumLayers(_variant),
             numHeads: GetNumHeads(_variant));
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() =>
-        new DistilledT5TextConditioner<T>(Tokenizer, _variant, Architecture);
-
     private static NeuralNetworkArchitecture<T> BuildDefaultArchitecture(DistilledT5Variant variant) =>
         new NeuralNetworkArchitecture<T>(
             inputType: InputType.TwoDimensional,
diff --git a/src/Diffusion/Conditioning/GemmaTextConditioner.cs b/src/Diffusion/Conditioning/GemmaTextConditioner.cs
index ce443577bd..4af98ff6b9 100644
--- a/src/Diffusion/Conditioning/GemmaTextConditioner.cs
+++ b/src/Diffusion/Conditioning/GemmaTextConditioner.cs
@@ -73,9 +73,6 @@ protected override IEnumerable<ILayer<T>> CreateDefaultLayers() =>
             numLayers: GetNumLayers(_variant),
             numHeads: GetNumHeads(_variant));
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() =>
-        new GemmaTextConditioner<T>(Tokenizer, _variant, Architecture);
-
     /// <summary>
     /// Decoder-style models pool by extracting the embedding at the last
     /// non-pad token position. With fixed-length padded sequences (the
diff --git a/src/Diffusion/Conditioning/Qwen2TextConditioner.cs b/src/Diffusion/Conditioning/Qwen2TextConditioner.cs
index a95d23fdfd..2b39d5e93e 100644
--- a/src/Diffusion/Conditioning/Qwen2TextConditioner.cs
+++ b/src/Diffusion/Conditioning/Qwen2TextConditioner.cs
@@ -75,9 +75,6 @@ protected override IEnumerable<ILayer<T>> CreateDefaultLayers() =>
             numHeads: GetNumHeads(_variant),
             numKvHeads: GetNumKvHeads(_variant));
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() =>
-        new Qwen2TextConditioner<T>(Tokenizer, _variant, Architecture);
-
     public override Tensor<T> GetPooledEmbedding(Tensor<T> sequenceEmbeddings)
     {
         int rank = sequenceEmbeddings.Shape.Length;
diff --git a/src/Diffusion/Conditioning/SigLIP2TextConditioner.cs b/src/Diffusion/Conditioning/SigLIP2TextConditioner.cs
index 9aa5b518a4..60611f2f11 100644
--- a/src/Diffusion/Conditioning/SigLIP2TextConditioner.cs
+++ b/src/Diffusion/Conditioning/SigLIP2TextConditioner.cs
@@ -68,9 +68,6 @@ protected override IEnumerable<ILayer<T>> CreateDefaultLayers() =>
             numLayers: GetNumLayers(_variant),
             numHeads: GetNumHeads(_variant));
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() =>
-        new SigLIP2TextConditioner<T>(Tokenizer, _variant, Architecture);
-
     private static NeuralNetworkArchitecture<T> BuildDefaultArchitecture(SigLIP2Variant variant) =>
         new NeuralNetworkArchitecture<T>(
             inputType: InputType.TwoDimensional,
diff --git a/src/Diffusion/Conditioning/SigLIPTextConditioner.cs b/src/Diffusion/Conditioning/SigLIPTextConditioner.cs
index 2de310e449..c3b71a2361 100644
--- a/src/Diffusion/Conditioning/SigLIPTextConditioner.cs
+++ b/src/Diffusion/Conditioning/SigLIPTextConditioner.cs
@@ -70,9 +70,6 @@ protected override IEnumerable<ILayer<T>> CreateDefaultLayers() =>
             numLayers: GetNumLayers(_variant),
             numHeads: GetNumHeads(_variant));
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() =>
-        new SigLIPTextConditioner<T>(Tokenizer, _variant, Architecture);
-
     private static NeuralNetworkArchitecture<T> BuildDefaultArchitecture(SigLIPVariant variant) =>
         new NeuralNetworkArchitecture<T>(
             inputType: InputType.TwoDimensional,
diff --git a/src/Diffusion/Conditioning/T5TextConditioner.cs b/src/Diffusion/Conditioning/T5TextConditioner.cs
index 16c7b4027d..ce3a84c1c9 100644
--- a/src/Diffusion/Conditioning/T5TextConditioner.cs
+++ b/src/Diffusion/Conditioning/T5TextConditioner.cs
@@ -79,9 +79,6 @@ protected override IEnumerable<ILayer<T>> CreateDefaultLayers() =>
             numLayers: GetNumLayers(_variant),
             numHeads: GetNumHeads(_variant));
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() =>
-        new T5TextConditioner<T>(Tokenizer, _variant, Architecture);
-
     /// <summary>
     /// T5 pools by mean over non-pad tokens. With fixed-length padding (the
     /// SD3/FLUX/Imagen convention) the base class's <see cref="TextConditioningBase{T}.MeanPool"/>
diff --git a/src/Diffusion/Conditioning/TextConditioningBase.cs b/src/Diffusion/Conditioning/TextConditioningBase.cs
index 22d61d3506..efee5c9e7f 100644
--- a/src/Diffusion/Conditioning/TextConditioningBase.cs
+++ b/src/Diffusion/Conditioning/TextConditioningBase.cs
@@ -39,7 +39,7 @@ namespace AiDotNet.Diffusion.Conditioning;
 [TensorLayout(TensorAxis.Time, TensorAxis.Features, Direction = TensorLayoutDirection.Output)]
 [TensorLayout(TensorAxis.Batch, TensorAxis.Time, TensorAxis.Features,
     Direction = TensorLayoutDirection.Output)]
-public abstract class TextConditioningBase<T> : NeuralNetworkBase<T>, IConditioningModule<T>, IShapeContract
+public abstract partial class TextConditioningBase<T> : NeuralNetworkBase<T>, IConditioningModule<T>, IShapeContract
 {
     /// <inheritdoc />
     public IReadOnlyList<OutputAxisContract>? OutputAxesFor(int inputRank)
@@ -284,26 +284,10 @@ protected Tensor<T> MeanPool(Tensor<T> sequenceEmbeddings)
     };
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(VocabSize);
-        writer.Write(EmbeddingDimension);
-        writer.Write(MaxSequenceLength);
-        writer.Write(Tokenizer.GetType().AssemblyQualifiedName ?? Tokenizer.GetType().FullName ?? "");
-    }
+
 
     /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        VerifyEqual(reader.ReadInt32(), VocabSize, nameof(VocabSize));
-        VerifyEqual(reader.ReadInt32(), EmbeddingDimension, nameof(EmbeddingDimension));
-        VerifyEqual(reader.ReadInt32(), MaxSequenceLength, nameof(MaxSequenceLength));
-        string persistedTokenizerType = reader.ReadString();
-        string currentTokenizerType = Tokenizer.GetType().AssemblyQualifiedName ?? Tokenizer.GetType().FullName ?? "";
-        if (!string.Equals(persistedTokenizerType, currentTokenizerType, StringComparison.Ordinal))
-            throw new InvalidOperationException(
-                $"Persisted tokenizer type '{persistedTokenizerType}' does not match current '{currentTokenizerType}'.");
-    }
+
 
     private static void VerifyEqual<TValue>(TValue persisted, TValue current, string name)
         where TValue : IEquatable<TValue>
diff --git a/src/Diffusion/Control/ControlARModel.cs b/src/Diffusion/Control/ControlARModel.cs
index 3f43f0221a..22f6bad113 100644
--- a/src/Diffusion/Control/ControlARModel.cs
+++ b/src/Diffusion/Control/ControlARModel.cs
@@ -123,32 +123,6 @@ private void InitializeLayers(UNetNoisePredictor<T>? baseUNet, StandardVAE<T>? v
 
 
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        // Clone the ACTUAL baseUNet/VAE (see InstaFlowModel/MultiDiffusionModel): passing only
-        // controlType/conditioner/seed rebuilt InitializeLayers' DEFAULT-sized, lazily-unresolved
-        // sub-models, so once the source resolved its lazy layers via a forward pass the trainable-layer
-        // shapes no longer lined up 1:1 and Clone diverged. Cloning the resolved baseUNet/VAE (+ same
-        // architecture/options/scheduler) makes the clone structurally identical.
-        var clone = new ControlARModel<T>(
-            architecture: Architecture,
-            options: Options as DiffusionModelOptions<T>,
-            scheduler: Scheduler,
-            baseUNet: (UNetNoisePredictor<T>)_baseUNet.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            controlType: _controlType,
-            conditioner: _conditioner,
-            seed: null);
-        // Copy-on-write: share weight tensors with the clone (O(1)-until-write) via the global helper;
-        // fall back to the eager flat copy only if the trainable-layer structure doesn't line up 1:1.
-        if (!clone.TryShareParametersFrom(this)) clone.SetParameters(GetParameters()); // flat path: inherited GetParameterChunks() omits this model's extra module(s) and is empty on net471
-        return clone;
-    }
-
     /// <inheritdoc />
     public override ModelMetadata<T> GetModelMetadata()
     {
diff --git a/src/Diffusion/Control/ControlNeXtModel.cs b/src/Diffusion/Control/ControlNeXtModel.cs
index 86dfcd7f54..b6ee3b7959 100644
--- a/src/Diffusion/Control/ControlNeXtModel.cs
+++ b/src/Diffusion/Control/ControlNeXtModel.cs
@@ -122,30 +122,6 @@ private void InitializeLayers(UNetNoisePredictor<T>? baseUNet, StandardVAE<T>? v
 
 
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        // Clone the ACTUAL baseUNet/VAE (see InstaFlowModel/MultiDiffusionModel): passing only
-        // controlType/conditioner/seed rebuilt InitializeLayers' DEFAULT-sized, lazily-unresolved
-        // sub-models, so once the source resolved its lazy layers via a forward pass the trainable-layer
-        // shapes no longer lined up 1:1 and Clone diverged. Cloning the resolved baseUNet/VAE (+ same
-        // architecture/options/scheduler) makes the clone structurally identical.
-        var clone = new ControlNeXtModel<T>(
-            architecture: Architecture,
-            options: Options as DiffusionModelOptions<T>,
-            scheduler: Scheduler,
-            baseUNet: (UNetNoisePredictor<T>)_baseUNet.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            controlType: _controlType,
-            conditioner: _conditioner,
-            seed: null);
-        if (!clone.TryShareParametersFrom(this)) clone.SetParameters(GetParameters()); // flat path: inherited GetParameterChunks() omits this model's extra module(s) and is empty on net471
-        return clone;
-    }
-
     /// <inheritdoc />
     public override ModelMetadata<T> GetModelMetadata()
     {
diff --git a/src/Diffusion/Control/ControlNetFluxModel.cs b/src/Diffusion/Control/ControlNetFluxModel.cs
index bef7e0b319..e24bc60843 100644
--- a/src/Diffusion/Control/ControlNetFluxModel.cs
+++ b/src/Diffusion/Control/ControlNetFluxModel.cs
@@ -135,31 +135,6 @@ private void InitializeLayers(FluxDoubleStreamPredictor<T>? predictor, StandardV
 
 
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        // Clone the ACTUAL predictor and VAE (see InstaFlowModel/MultiDiffusionModel): passing only
-        // controlType/conditioner/seed rebuilt InitializeLayers' DEFAULT-sized, lazily-unresolved Flux
-        // predictor/VAE, so the field-by-field SetParameters below copied a resolved source predictor
-        // into the clone's still-lazy one and threw / mis-shaped. Cloning the resolved predictor/VAE
-        // makes those two structurally identical up front; the control encoder isn't a ctor param, so its
-        // (config-driven, matching-shape) weights are copied field-by-field afterward.
-        var clone = new ControlNetFluxModel<T>(
-            architecture: Architecture,
-            options: Options as DiffusionModelOptions<T>,
-            scheduler: Scheduler,
-            predictor: (FluxDoubleStreamPredictor<T>)_predictor.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            controlType: _controlType,
-            conditioner: _conditioner,
-            seed: null);
-        clone._controlEncoder.SetParameters(_controlEncoder.GetParameters());
-        return clone;
-    }
-
     /// <inheritdoc />
     public override ModelMetadata<T> GetModelMetadata()
     {
diff --git a/src/Diffusion/Control/ControlNetInpaintingModel.cs b/src/Diffusion/Control/ControlNetInpaintingModel.cs
index 58bdf0cd64..06fc56aa88 100644
--- a/src/Diffusion/Control/ControlNetInpaintingModel.cs
+++ b/src/Diffusion/Control/ControlNetInpaintingModel.cs
@@ -150,31 +150,6 @@ public override void SetParameterChunks(IEnumerable<Tensor<T>> chunks)
         SetParameters(DiffusionParameterChunkHelper.BufferToFlatVector(chunks));
     }
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        // Clone the ACTUAL baseUNet and VAE (mirrors InstaFlowModel/MultiDiffusionModel): passing only
-        // controlType/conditioner/seed rebuilt InitializeLayers' DEFAULT-sized, lazily-unresolved
-        // UNet/VAE, so once the source resolved its lazy layers via a forward pass the trainable-layer
-        // shapes no longer lined up 1:1 — TryShareParametersFrom bailed and the chunk fallback ran.
-        // Cloning the resolved baseUNet/VAE makes the clone structurally identical so the copy-on-write
-        // share succeeds (which also transfers the control encoder, walked by reflection).
-        var clone = new ControlNetInpaintingModel<T>(
-            architecture: Architecture,
-            options: Options as DiffusionModelOptions<T>,
-            scheduler: Scheduler,
-            baseUNet: (UNetNoisePredictor<T>)_baseUNet.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner,
-            controlType: _controlType,
-            seed: null);
-        if (!clone.TryShareParametersFrom(this)) clone.SetParameterChunks(GetParameterChunks());
-        return clone;
-    }
-
     /// <inheritdoc />
     public override ModelMetadata<T> GetModelMetadata()
     {
diff --git a/src/Diffusion/Control/ControlNetLiteModel.cs b/src/Diffusion/Control/ControlNetLiteModel.cs
index 31a6b763a0..ebc67afed9 100644
--- a/src/Diffusion/Control/ControlNetLiteModel.cs
+++ b/src/Diffusion/Control/ControlNetLiteModel.cs
@@ -124,30 +124,6 @@ private void InitializeLayers(UNetNoisePredictor<T>? baseUNet, StandardVAE<T>? v
 
 
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        // Clone the ACTUAL baseUNet/VAE (see InstaFlowModel/MultiDiffusionModel): passing only
-        // controlType/conditioner/seed rebuilt InitializeLayers' DEFAULT-sized, lazily-unresolved
-        // sub-models, so once the source resolved its lazy layers via a forward pass the trainable-layer
-        // shapes no longer lined up 1:1 and Clone diverged. Cloning the resolved baseUNet/VAE (+ same
-        // architecture/options/scheduler) makes the clone structurally identical.
-        var clone = new ControlNetLiteModel<T>(
-            architecture: Architecture,
-            options: Options as DiffusionModelOptions<T>,
-            scheduler: Scheduler,
-            baseUNet: (UNetNoisePredictor<T>)_baseUNet.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            controlType: _controlType,
-            conditioner: _conditioner,
-            seed: null);
-        if (!clone.TryShareParametersFrom(this)) clone.SetParameters(GetParameters()); // flat path: inherited GetParameterChunks() omits this model's extra module(s) and is empty on net471
-        return clone;
-    }
-
     /// <inheritdoc />
     public override ModelMetadata<T> GetModelMetadata()
     {
diff --git a/src/Diffusion/Control/ControlNetModel.cs b/src/Diffusion/Control/ControlNetModel.cs
index c8fd63e5d5..baf42dfc7b 100644
--- a/src/Diffusion/Control/ControlNetModel.cs
+++ b/src/Diffusion/Control/ControlNetModel.cs
@@ -619,45 +619,6 @@ private Tensor<T> AddTensors(Tensor<T> a, Tensor<T> b)
         return Engine.TensorAdd(a, b);
     }
 
-
-
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy()
-    {
-        return Clone();
-    }
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        // Clone the ACTUAL baseUNet/VAE (see InstaFlowModel/MultiDiffusionModel): passing only
-        // controlType/conditioner/seed rebuilt InitializeLayers' DEFAULT-sized, lazily-unresolved
-        // sub-models, so once the source resolved its lazy layers via a forward pass the trainable-layer
-        // shapes no longer lined up 1:1 and Clone diverged. Cloning the resolved baseUNet/VAE (+ same
-        // architecture/options/scheduler) makes the clone structurally identical.
-        var clone = new ControlNetModel<T>(
-            architecture: Architecture,
-            options: Options as DiffusionModelOptions<T>,
-            scheduler: Scheduler,
-            baseUNet: (UNetNoisePredictor<T>)_baseUNet.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            controlType: _controlType,
-            conditioner: _conditioner,
-            seed: null);
-
-        // Create matching encoder cache in clone before setting parameters
-        foreach (var controlType in _encoderCache.Keys.Where(ct => ct != _controlType))
-        {
-            // GetOrCreateEncoder adds to the cache
-            clone.GetOrCreateEncoder(controlType);
-        }
-
-        if (!clone.TryShareParametersFrom(this)) clone.SetParameters(GetParameters()); // flat path: inherited GetParameterChunks() omits this model's extra module(s) and is empty on net471
-        clone.ConditioningStrength = _conditioningStrength;
-
-        return clone;
-    }
-
     /// <inheritdoc />
     public override ModelMetadata<T> GetModelMetadata()
     {
@@ -885,6 +846,13 @@ public List<Tensor<T>> Encode(Tensor<T> controlImage)
     /// </summary>
     public Vector<T> GetParameters()
     {
+        // ParameterCount describes every shape-resolved convolution, including kernels whose storage
+        // is intentionally lazy. A concrete read must cross the lifecycle boundary before capturing
+        // the vector; otherwise Count and Get disagree and any containing model slices the following
+        // component at the wrong offset (ControlNet++ clone emitted 55,871,135 fewer values).
+        foreach (var block in _downBlocks) block.MaterializeParameters();
+        foreach (var zc in _zeroConvs) zc.MaterializeParameters();
+
         // Single-allocation concat — avoids the List<T> + per-element Add + ToArray
         // triple-copy. Vector<T>.Concatenate pre-sizes one result and vectorized-
         // copies each conv's params in once.
@@ -899,6 +867,14 @@ public Vector<T> GetParameters()
     /// </summary>
     public void SetParameters(Vector<T> parameters)
     {
+        if (parameters is null) throw new ArgumentNullException(nameof(parameters));
+        if (parameters.Length != ParameterCount)
+        {
+            throw new ArgumentException(
+                $"Expected {ParameterCount} ControlNet encoder parameters, got {parameters.Length}.",
+                nameof(parameters));
+        }
+
         int offset = 0;
 
         foreach (var block in _downBlocks)
diff --git a/src/Diffusion/Control/ControlNetPlusPlusFluxModel.cs b/src/Diffusion/Control/ControlNetPlusPlusFluxModel.cs
index e0519fe752..fd71e27484 100644
--- a/src/Diffusion/Control/ControlNetPlusPlusFluxModel.cs
+++ b/src/Diffusion/Control/ControlNetPlusPlusFluxModel.cs
@@ -122,38 +122,6 @@ private void InitializeLayers(FluxDoubleStreamPredictor<T>? predictor, StandardV
 
 
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        // Clone the ACTUAL predictor and VAE (see InstaFlowModel/MultiDiffusionModel): passing only
-        // controlType/conditioner/rewardWeight/seed rebuilt InitializeLayers' DEFAULT-sized, lazily-
-        // unresolved Flux predictor/VAE, so after the source resolved its lazy layers the copy-on-write
-        // share no longer lined up 1:1 and the clone diverged. Cloning the resolved predictor/VAE makes
-        // the clone structurally identical (the control encoder is then transferred by the share below).
-        var clone = new ControlNetPlusPlusFluxModel<T>(
-            architecture: Architecture,
-            options: Options as DiffusionModelOptions<T>,
-            scheduler: Scheduler,
-            predictor: (FluxDoubleStreamPredictor<T>)_predictor.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            controlType: _controlType, conditioner: _conditioner, rewardWeight: _rewardWeight, seed: null);
-        // #1624: O(1)-until-write copy-on-write parameter share (avoids the full-model flatten copy that
-        // OOMs the 16 GB runner). Foundation-scale (12B FLUX) fallback when the share doesn't line up 1:1:
-        // restore the base predictor/VAE through the STREAMING chunked API (never materializes a flat 12B
-        // Vector<T> — that flatten is the #1624 clone OOM). The inherited GetParameterChunks() covers only
-        // predictor/VAE/conditioner, so restore the small conv control encoder via its own flat API after.
-        // (On net471 the chunked base restore no-ops — but net471 does not run a 12B FLUX predictor.)
-        if (!clone.TryShareParametersFrom(this))
-        {
-            clone.SetParameterChunks(GetParameterChunks());
-            clone._controlEncoder.SetParameters(_controlEncoder.GetParameters());
-        }
-        return clone;
-    }
-
     /// <inheritdoc />
     public override ModelMetadata<T> GetModelMetadata()
     {
diff --git a/src/Diffusion/Control/ControlNetPlusPlusModel.cs b/src/Diffusion/Control/ControlNetPlusPlusModel.cs
index 715626b46a..4c00f38cf9 100644
--- a/src/Diffusion/Control/ControlNetPlusPlusModel.cs
+++ b/src/Diffusion/Control/ControlNetPlusPlusModel.cs
@@ -175,32 +175,6 @@ public override void SetParameterChunks(IEnumerable<Tensor<T>> chunks)
         SetParameters(DiffusionParameterChunkHelper.BufferToFlatVector(chunks));
     }
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        // Clone the ACTUAL baseUNet and VAE (mirrors InstaFlowModel/MultiDiffusionModel): passing only
-        // controlType/conditioner/rewardWeight/seed rebuilt InitializeLayers' DEFAULT-sized, lazily-
-        // unresolved sub-models, so once the source resolved its lazy layers via a forward pass the
-        // trainable-layer shapes no longer lined up 1:1 — TryShareParametersFrom bailed and the chunk
-        // fallback ran. Cloning the resolved baseUNet/VAE makes the clone structurally identical so the
-        // copy-on-write share succeeds (which also transfers the control encoder, walked by reflection).
-        var clone = new ControlNetPlusPlusModel<T>(
-            architecture: Architecture,
-            options: Options as DiffusionModelOptions<T>,
-            scheduler: Scheduler,
-            baseUNet: (UNetNoisePredictor<T>)_baseUNet.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner,
-            controlType: _controlType,
-            rewardWeight: _rewardWeight,
-            seed: null);
-        if (!clone.TryShareParametersFrom(this)) clone.SetParameterChunks(GetParameterChunks());
-        return clone;
-    }
-
     /// <inheritdoc />
     public override ModelMetadata<T> GetModelMetadata()
     {
diff --git a/src/Diffusion/Control/ControlNetQRModel.cs b/src/Diffusion/Control/ControlNetQRModel.cs
index c80e7e394e..b3659e1f90 100644
--- a/src/Diffusion/Control/ControlNetQRModel.cs
+++ b/src/Diffusion/Control/ControlNetQRModel.cs
@@ -127,33 +127,6 @@ private void InitializeLayers(UNetNoisePredictor<T>? baseUNet, StandardVAE<T>? v
 
 
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        // Lazy-preserving Clone (recipe from #1596): delegate to the base UNet's and VAE's own Clone()
-        // (preserves materialized weights, reconstructs from actual config) instead of rebuilding a
-        // default-scale model and SetParameters(GetParameters()), which mismatches an injected non-default
-        // variant and re-randomizes the clone's unmaterialized lazy weights.
-        var clone = new ControlNetQRModel<T>(
-            baseUNet: (UNetNoisePredictor<T>)_baseUNet.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner);
-
-        // The control-branch encoder is a separate trainable component (counted
-        // in ParameterCount/GetParameters); the constructor builds a fresh one,
-        // so transfer this model's trained weights into the clone explicitly —
-        // otherwise the clone silently loses the control-branch state.
-        if (_controlEncoder.ParameterCount > 0)
-        {
-            clone._controlEncoder.SetParameters(_controlEncoder.GetParameters());
-        }
-
-        return clone;
-    }
-
     /// <inheritdoc />
     public override ModelMetadata<T> GetModelMetadata()
     {
diff --git a/src/Diffusion/Control/ControlNetSD3Model.cs b/src/Diffusion/Control/ControlNetSD3Model.cs
index c062f44a0d..4baf04e90e 100644
--- a/src/Diffusion/Control/ControlNetSD3Model.cs
+++ b/src/Diffusion/Control/ControlNetSD3Model.cs
@@ -162,31 +162,6 @@ public override void SetParameterChunks(IEnumerable<Tensor<T>> chunks)
         SetParameters(DiffusionParameterChunkHelper.BufferToFlatVector(chunks));
     }
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        // Clone the ACTUAL predictor and VAE (mirrors InstaFlowModel/MultiDiffusionModel): passing only
-        // controlType/conditioner/seed rebuilt InitializeLayers' DEFAULT-sized, lazily-unresolved MMDiT-X
-        // predictor and VAE, so once the source resolved its lazy layers via a forward pass the
-        // trainable-layer shapes no longer lined up 1:1 — TryShareParametersFrom bailed and the chunk
-        // fallback ran. Cloning the resolved predictor/VAE makes the clone structurally identical so the
-        // copy-on-write share succeeds (which also transfers the control encoder, walked by reflection).
-        var clone = new ControlNetSD3Model<T>(
-            architecture: Architecture,
-            options: Options as DiffusionModelOptions<T>,
-            scheduler: Scheduler,
-            predictor: (MMDiTXNoisePredictor<T>)_predictor.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner,
-            controlType: _controlType,
-            seed: null);
-        if (!clone.TryShareParametersFrom(this)) clone.SetParameterChunks(GetParameterChunks());
-        return clone;
-    }
-
     /// <inheritdoc />
     public override ModelMetadata<T> GetModelMetadata()
     {
diff --git a/src/Diffusion/Control/ControlNetTileModel.cs b/src/Diffusion/Control/ControlNetTileModel.cs
index 7c99339cd8..536d7cbc37 100644
--- a/src/Diffusion/Control/ControlNetTileModel.cs
+++ b/src/Diffusion/Control/ControlNetTileModel.cs
@@ -116,29 +116,6 @@ private void InitializeLayers(UNetNoisePredictor<T>? baseUNet, StandardVAE<T>? v
 
 
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        // Clone the ACTUAL baseUNet/VAE (see InstaFlowModel/MultiDiffusionModel): passing only
-        // conditioner/seed rebuilt InitializeLayers' DEFAULT-sized, lazily-unresolved sub-models, so once
-        // the source resolved its lazy layers via a forward pass the trainable-layer shapes no longer
-        // lined up 1:1 and Clone diverged. Cloning the resolved baseUNet/VAE (+ same architecture/
-        // options/scheduler) makes the clone structurally identical.
-        var clone = new ControlNetTileModel<T>(
-            architecture: Architecture,
-            options: Options as DiffusionModelOptions<T>,
-            scheduler: Scheduler,
-            baseUNet: (UNetNoisePredictor<T>)_baseUNet.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner,
-            seed: null);
-        if (!clone.TryShareParametersFrom(this)) clone.SetParameters(GetParameters()); // flat path: inherited GetParameterChunks() omits this model's extra module(s) and is empty on net471
-        return clone;
-    }
-
     /// <inheritdoc />
     public override ModelMetadata<T> GetModelMetadata()
     {
diff --git a/src/Diffusion/Control/ControlNetUnionModel.cs b/src/Diffusion/Control/ControlNetUnionModel.cs
index c4a085e4ef..cc9aa3e536 100644
--- a/src/Diffusion/Control/ControlNetUnionModel.cs
+++ b/src/Diffusion/Control/ControlNetUnionModel.cs
@@ -210,16 +210,6 @@ public override Tensor<T> GenerateFromText(string prompt, string? negativePrompt
 
     #region ICloneable Implementation
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-                                return new ControlNetUnionModel<T>(unet: (UNetNoisePredictor<T>)_unet.Clone(), controlNet: (UNetNoisePredictor<T>)_controlNet.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(), conditioner: _conditioner);
-    }
-
     #endregion
 
     #region Metadata
diff --git a/src/Diffusion/Control/ControlNetUnionProModel.cs b/src/Diffusion/Control/ControlNetUnionProModel.cs
index 093b508c90..f04c7a9667 100644
--- a/src/Diffusion/Control/ControlNetUnionProModel.cs
+++ b/src/Diffusion/Control/ControlNetUnionProModel.cs
@@ -181,31 +181,6 @@ public override void SetParameterChunks(IEnumerable<Tensor<T>> chunks)
         SetParameters(DiffusionParameterChunkHelper.BufferToFlatVector(chunks));
     }
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        // Clone the ACTUAL baseUNet and VAE (mirrors InstaFlowModel/MultiDiffusionModel): passing only
-        // conditioner/supportedTypes/seed rebuilt InitializeLayers' DEFAULT-sized, lazily-unresolved
-        // sub-models, so once the source resolved its lazy layers via a forward pass the trainable-layer
-        // shapes no longer lined up 1:1 — TryShareParametersFrom bailed and the chunk fallback ran.
-        // Cloning the resolved baseUNet/VAE makes the clone structurally identical so the copy-on-write
-        // share succeeds (which also transfers the per-modality encoder cache, walked by reflection).
-        var clone = new ControlNetUnionProModel<T>(
-            architecture: Architecture,
-            options: Options as DiffusionModelOptions<T>,
-            scheduler: Scheduler,
-            baseUNet: (UNetNoisePredictor<T>)_baseUNet.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner,
-            supportedTypes: _supportedTypes,
-            seed: null);
-        if (!clone.TryShareParametersFrom(this)) clone.SetParameterChunks(GetParameterChunks());
-        return clone;
-    }
-
     /// <inheritdoc />
     public override ModelMetadata<T> GetModelMetadata()
     {
diff --git a/src/Diffusion/Control/ControlNetXSModel.cs b/src/Diffusion/Control/ControlNetXSModel.cs
index b5deeb82a9..93b2644dd7 100644
--- a/src/Diffusion/Control/ControlNetXSModel.cs
+++ b/src/Diffusion/Control/ControlNetXSModel.cs
@@ -196,27 +196,6 @@ public override Tensor<T> GenerateFromText(
 
     #region ICloneable
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        // Delegate to sub-Clones — same lazy-init fix pattern as
-        // SDXLTurbo / RealESRGAN / EDiffI / DiffEdit / DDPM / SUPIR.
-        // Preserve outer configuration (architecture / options / scheduler) so
-        // a model created with custom diffusion settings doesn't clone back
-        // to constructor defaults (CodeRabbit PR #1562).
-        var cu = (UNetNoisePredictor<T>)_unet.Clone();
-        var cc = (UNetNoisePredictor<T>)_controlEncoder.Clone();
-        var cv = (StandardVAE<T>)_vae.Clone();
-        return new ControlNetXSModel<T>(
-            architecture: Architecture,
-            options: (DiffusionModelOptions<T>)GetOptions(),
-            scheduler: Scheduler,
-            unet: cu, controlEncoder: cc, vae: cv, conditioner: _conditioner);
-    }
-
     #endregion
 
     #region Metadata
diff --git a/src/Diffusion/Control/IPAdapterFaceIDModel.cs b/src/Diffusion/Control/IPAdapterFaceIDModel.cs
index 279bc57bcf..aaa077b523 100644
--- a/src/Diffusion/Control/IPAdapterFaceIDModel.cs
+++ b/src/Diffusion/Control/IPAdapterFaceIDModel.cs
@@ -199,21 +199,6 @@ public override Tensor<T> GenerateFromText(string prompt, string? negativePrompt
 
     #region ICloneable Implementation
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        return new IPAdapterFaceIDModel<T>(
-            architecture: Architecture,
-            options: Options as DiffusionModelOptions<T>,
-            scheduler: Scheduler,
-            unet: (UNetNoisePredictor<T>)_unet.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner);
-    }
-
     #endregion
 
     #region Metadata
diff --git a/src/Diffusion/Control/IPAdapterFaceIDPlusModel.cs b/src/Diffusion/Control/IPAdapterFaceIDPlusModel.cs
index d28dceb6df..70d4168f68 100644
--- a/src/Diffusion/Control/IPAdapterFaceIDPlusModel.cs
+++ b/src/Diffusion/Control/IPAdapterFaceIDPlusModel.cs
@@ -175,31 +175,6 @@ public override void SetParameterChunks(IEnumerable<Tensor<T>> chunks)
         SetParameters(DiffusionParameterChunkHelper.BufferToFlatVector(chunks));
     }
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        // Clone the ACTUAL baseUNet and VAE (mirrors InstaFlowModel/MultiDiffusionModel): passing only
-        // conditioner/faceIdScale/seed rebuilt InitializeLayers' DEFAULT-sized, lazily-unresolved
-        // sub-models, so once the source resolved its lazy layers via a forward pass the trainable-layer
-        // shapes no longer lined up 1:1 — TryShareParametersFrom bailed and the chunk fallback ran.
-        // Cloning the resolved baseUNet/VAE makes the clone structurally identical so the copy-on-write
-        // share succeeds (which also transfers the projection heads, walked by reflection).
-        var clone = new IPAdapterFaceIDPlusModel<T>(
-            architecture: Architecture,
-            options: Options as DiffusionModelOptions<T>,
-            scheduler: Scheduler,
-            baseUNet: (UNetNoisePredictor<T>)_baseUNet.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner,
-            faceIdScale: _faceIdScale,
-            seed: null);
-        if (!clone.TryShareParametersFrom(this)) clone.SetParameterChunks(GetParameterChunks());
-        return clone;
-    }
-
     /// <inheritdoc />
     public override ModelMetadata<T> GetModelMetadata()
     {
diff --git a/src/Diffusion/Control/IPAdapterModel.cs b/src/Diffusion/Control/IPAdapterModel.cs
index a5c42c82ad..57fbc30c0c 100644
--- a/src/Diffusion/Control/IPAdapterModel.cs
+++ b/src/Diffusion/Control/IPAdapterModel.cs
@@ -499,38 +499,6 @@ private Tensor<T> AddTensors(Tensor<T> a, Tensor<T> b)
         return Engine.TensorAdd(a, b);
     }
 
-
-
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy()
-    {
-        return Clone();
-    }
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        // Clone the ACTUAL baseUNet/VAE (see InstaFlowModel/MultiDiffusionModel): passing only
-        // conditioner/seed rebuilt InitializeLayers' DEFAULT-sized, lazily-unresolved sub-models, so once
-        // the source resolved its lazy layers via a forward pass the trainable-layer shapes no longer
-        // lined up 1:1 and Clone diverged. Cloning the resolved baseUNet/VAE (+ same architecture/
-        // options/scheduler) makes the clone structurally identical.
-        var clone = new IPAdapterModel<T>(
-            architecture: Architecture,
-            options: Options as DiffusionModelOptions<T>,
-            scheduler: Scheduler,
-            baseUNet: (UNetNoisePredictor<T>)_baseUNet.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner,
-            embedDim: _embedDim,
-            seed: null);
-
-        if (!clone.TryShareParametersFrom(this)) clone.SetParameters(GetParameters()); // flat path: inherited GetParameterChunks() omits this model's extra module(s) and is empty on net471
-        clone.ImagePromptWeight = _imagePromptWeight;
-
-        return clone;
-    }
-
     /// <inheritdoc />
     public override ModelMetadata<T> GetModelMetadata()
     {
diff --git a/src/Diffusion/Control/IPAdapterPlusModel.cs b/src/Diffusion/Control/IPAdapterPlusModel.cs
index ba49a36184..47ed02903f 100644
--- a/src/Diffusion/Control/IPAdapterPlusModel.cs
+++ b/src/Diffusion/Control/IPAdapterPlusModel.cs
@@ -147,30 +147,6 @@ private void InitializeLayers(UNetNoisePredictor<T>? baseUNet, StandardVAE<T>? v
 
 
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        // Clone the ACTUAL baseUNet/VAE (see InstaFlowModel/MultiDiffusionModel): passing only
-        // conditioner/ipAdapterScale/seed rebuilt InitializeLayers' DEFAULT-sized, lazily-unresolved
-        // sub-models, so once the source resolved its lazy layers via a forward pass the trainable-layer
-        // shapes no longer lined up 1:1 and Clone diverged. Cloning the resolved baseUNet/VAE (+ same
-        // architecture/options/scheduler) makes the clone structurally identical.
-        var clone = new IPAdapterPlusModel<T>(
-            architecture: Architecture,
-            options: Options as DiffusionModelOptions<T>,
-            scheduler: Scheduler,
-            baseUNet: (UNetNoisePredictor<T>)_baseUNet.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner,
-            ipAdapterScale: _ipAdapterScale,
-            seed: null);
-        if (!clone.TryShareParametersFrom(this)) clone.SetParameterChunks(GetParameterChunks());
-        return clone;
-    }
-
     /// <inheritdoc />
     public override ModelMetadata<T> GetModelMetadata()
     {
diff --git a/src/Diffusion/Control/InstantIDModel.cs b/src/Diffusion/Control/InstantIDModel.cs
index b3f9c9898b..eb5f45d785 100644
--- a/src/Diffusion/Control/InstantIDModel.cs
+++ b/src/Diffusion/Control/InstantIDModel.cs
@@ -189,15 +189,6 @@ public override Tensor<T> GenerateFromText(
 
     #region ICloneable
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-                        return new InstantIDModel<T>(unet: (UNetNoisePredictor<T>)_unet.Clone(), vae: (StandardVAE<T>)_vae.Clone(), conditioner: _conditioner);
-    }
-
     #endregion
 
     #region Metadata
diff --git a/src/Diffusion/Control/PhotoMakerModel.cs b/src/Diffusion/Control/PhotoMakerModel.cs
index 2d569c5a7e..85df8bb275 100644
--- a/src/Diffusion/Control/PhotoMakerModel.cs
+++ b/src/Diffusion/Control/PhotoMakerModel.cs
@@ -219,21 +219,6 @@ public override Tensor<T> GenerateFromText(
 
     #region ICloneable
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        return new PhotoMakerModel<T>(
-            architecture: Architecture,
-            options: Options as DiffusionModelOptions<T>,
-            scheduler: Scheduler,
-            unet: (UNetNoisePredictor<T>)_unet.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner);
-    }
-
     #endregion
 
     #region Metadata
diff --git a/src/Diffusion/Control/ReferenceOnlyModel.cs b/src/Diffusion/Control/ReferenceOnlyModel.cs
index d7464cefd0..b1d99cbda8 100644
--- a/src/Diffusion/Control/ReferenceOnlyModel.cs
+++ b/src/Diffusion/Control/ReferenceOnlyModel.cs
@@ -121,30 +121,6 @@ private void InitializeLayers(UNetNoisePredictor<T>? baseUNet, StandardVAE<T>? v
 
 
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        // Clone the ACTUAL baseUNet/VAE (see InstaFlowModel/MultiDiffusionModel): passing only
-        // conditioner/referenceWeight/seed rebuilt InitializeLayers' DEFAULT-sized, lazily-unresolved
-        // sub-models, so once the source resolved its lazy layers via a forward pass the trainable-layer
-        // shapes no longer lined up 1:1 and Clone diverged. Cloning the resolved baseUNet/VAE (+ same
-        // architecture/options/scheduler) makes the clone structurally identical.
-        var clone = new ReferenceOnlyModel<T>(
-            architecture: Architecture,
-            options: Options as DiffusionModelOptions<T>,
-            scheduler: Scheduler,
-            baseUNet: (UNetNoisePredictor<T>)_baseUNet.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            referenceWeight: _referenceWeight,
-            conditioner: _conditioner,
-            seed: null);
-        if (!clone.TryShareParametersFrom(this)) clone.SetParameterChunks(GetParameterChunks());
-        return clone;
-    }
-
     /// <inheritdoc />
     public override ModelMetadata<T> GetModelMetadata()
     {
diff --git a/src/Diffusion/Control/StyleAlignedModel.cs b/src/Diffusion/Control/StyleAlignedModel.cs
index b5b13ee63b..14316bb015 100644
--- a/src/Diffusion/Control/StyleAlignedModel.cs
+++ b/src/Diffusion/Control/StyleAlignedModel.cs
@@ -122,26 +122,6 @@ private void InitializeLayers(UNetNoisePredictor<T>? baseUNet, StandardVAE<T>? v
 
 
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        // Lazy-preserving Clone (recipe from #1596): delegate to the base UNet's and VAE's own Clone()
-        // (preserves materialized weights, reconstructs from actual config) instead of rebuilding a
-        // default-scale model and SetParameters(GetParameters()), which mismatches an injected non-default
-        // variant and re-randomizes the clone's unmaterialized lazy weights.
-        return new StyleAlignedModel<T>(
-            architecture: Architecture,
-            options: Options as DiffusionModelOptions<T>,
-            scheduler: Scheduler,
-            baseUNet: (UNetNoisePredictor<T>)_baseUNet.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner,
-            styleAlignmentStrength: _styleAlignmentStrength);
-    }
-
     /// <inheritdoc />
     public override ModelMetadata<T> GetModelMetadata()
     {
diff --git a/src/Diffusion/Control/T2IAdapterModel.cs b/src/Diffusion/Control/T2IAdapterModel.cs
index 9a71876f26..610f62e415 100644
--- a/src/Diffusion/Control/T2IAdapterModel.cs
+++ b/src/Diffusion/Control/T2IAdapterModel.cs
@@ -339,23 +339,6 @@ public override Tensor<T> ImageToImage(
 
     #region ICloneable Implementation
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy()
-    {
-        return Clone();
-    }
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-                                return new T2IAdapterModel<T>(
-            unet: (UNetNoisePredictor<T>)_unet.Clone(),
-            adapterNetwork: (UNetNoisePredictor<T>)_adapterNetwork.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner,
-            adapterScale: _adapterScale);
-    }
-
     #endregion
 
     #region Metadata
diff --git a/src/Diffusion/Control/UniControlNetModel.cs b/src/Diffusion/Control/UniControlNetModel.cs
index 98f901cc1a..01ae77321c 100644
--- a/src/Diffusion/Control/UniControlNetModel.cs
+++ b/src/Diffusion/Control/UniControlNetModel.cs
@@ -196,15 +196,6 @@ public override Tensor<T> GenerateFromText(string prompt, string? negativePrompt
 
     #region ICloneable Implementation
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-                        return new UniControlNetModel<T>(unet: (UNetNoisePredictor<T>)_unet.Clone(), vae: (StandardVAE<T>)_vae.Clone(), conditioner: _conditioner);
-    }
-
     #endregion
 
     #region Metadata
diff --git a/src/Diffusion/DDPMModel.cs b/src/Diffusion/DDPMModel.cs
index 814859e6e6..00dbd8ca46 100644
--- a/src/Diffusion/DDPMModel.cs
+++ b/src/Diffusion/DDPMModel.cs
@@ -294,21 +294,5 @@ public static DDPMModel<T> Create(
 
     #region ICloneable Implementation
 
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        var clonedUnet = (UNetNoisePredictor<T>)_unet.Clone();
-        return new DDPMModel<T>(
-            scheduler: Scheduler,
-            unet: clonedUnet,
-            customPredictor: _customPredictor);
-    }
-
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy()
-    {
-        return Clone();
-    }
-
     #endregion
 }
diff --git a/src/Diffusion/DiffusionModelBase.cs b/src/Diffusion/DiffusionModelBase.cs
index 3db61ba970..dfefd71db7 100644
--- a/src/Diffusion/DiffusionModelBase.cs
+++ b/src/Diffusion/DiffusionModelBase.cs
@@ -1,4 +1,4 @@
-using System.Linq;
+using System.Linq;
 using AiDotNet.Autodiff;
 using AiDotNet.Deployment.Optimization.Quantization;
 using AiDotNet.Deployment.Optimization.Quantization.Training;
@@ -39,10 +39,53 @@ namespace AiDotNet.Diffusion;
 /// Specific diffusion models (like DDPM, Latent Diffusion) extend this base to implement
 /// their unique noise prediction architectures.</para>
 /// </remarks>
-public abstract class DiffusionModelBase<T> : IDiffusionModel<T>, IConfigurableModel<T>, IModelShape, IDisposable,
+public abstract partial class DiffusionModelBase<T> : IDiffusionModel<T>, IConfigurableModel<T>, IModelShape, IDisposable,
     AiDotNet.Interfaces.ISelfSupervisedModel, AiDotNet.Models.Parameters.IParameterManifestProvider,
     AiDotNet.Models.Parameters.IParameterSurfaceLifecycle
 {
+    // --- declared state (ModelStateRegistry) ---
+    // Identical in every model base because these bases are siblings over the same interfaces rather
+    // than one hierarchy; the logic itself lives once in ModelStateRegistry/ModelStateEnvelope.
+
+    /// <summary>State that is not a parameter vector, declared once and persisted by this base.</summary>
+    private readonly AiDotNet.Models.ModelStateRegistry<T> _declaredState = new();
+    private bool _declaredStateRegistered;
+
+    /// <summary>
+    /// Declare state here that the parameter vector does not carry -- a retained training set,
+    /// fitted knots, kernel centres, an ensemble's children. Both halves of the payload are driven
+    /// by the declaration, so they cannot drift.
+    /// </summary>
+    /// <param name="state">The registry to declare into.</param>
+    protected virtual void RegisterState(AiDotNet.Models.ModelStateRegistry<T> state)
+    {
+    }
+    /// <summary>Generated state declarations for fields declared across this model's hierarchy.</summary>
+    /// <param name="state">The registry to declare into.</param>
+    /// <remarks>
+    /// Emitted by ModelStateGenerator into the partial model, so a model author declares nothing. The
+    /// hand-written <c>RegisterState</c> beside it exists only for state the classifier genuinely
+    /// cannot place; anything it CAN place belongs here, where it cannot be forgotten.
+    /// </remarks>
+    protected virtual void RegisterGeneratedState(AiDotNet.Models.ModelStateRegistry<T> state)
+    {
+        RegisterGeneratedStateCore(state);
+    }
+
+    /// <summary>The declared state, registered once and lazily so it runs after the constructor.</summary>
+    protected AiDotNet.Models.ModelStateRegistry<T> DeclaredState
+    {
+        get
+        {
+            if (!_declaredStateRegistered)
+            {
+                _declaredStateRegistered = true;
+                RegisterGeneratedState(_declaredState);
+                RegisterState(_declaredState);
+            }
+            return _declaredState;
+        }
+    }
     /// <summary>
     /// Concrete diffusion models can override this method to yield the components
     /// they own that hold disposable resources — typically the noise predictor
@@ -1185,6 +1228,13 @@ public void DisableQuantizationAwareTraining()
         _qatHook = null;
     }
 
+    /// <summary>Marks a payload whose weights are streamed per tensor rather than flattened.</summary>
+    /// <remarks>
+    /// Negative on purpose: a payload written before streaming existed opens with a vector LENGTH,
+    /// so the reader can tell the two apart without a version field.
+    /// </remarks>
+    private const int ChunkedParameterMarker = -424242;
+
     /// <summary>
     /// Whether quantization-aware training is engaged for <see cref="Train"/> (G5, #1624). Opt-in and OFF
     /// by default at every model size; turn it on/off explicitly via
@@ -1646,12 +1696,15 @@ public virtual byte[] Serialize()
         ModelPersistenceGuard.EnforceBeforeSerialize();
         using var stream = new MemoryStream();
         SaveState(stream);
-        return stream.ToArray();
+        return AiDotNet.Models.ModelStateEnvelope.Append(DeclaredState, stream.ToArray());
     }
 
     /// <inheritdoc />
     public virtual void Deserialize(byte[] data)
     {
+        // Strips and applies any declared-state trailer, so the body below reads the payload
+        // exactly as it did before this existed.
+        data = AiDotNet.Models.ModelStateEnvelope.Extract(DeclaredState, data);
         ModelPersistenceGuard.EnforceBeforeDeserialize();
         using var stream = new MemoryStream(data);
         LoadState(stream);
@@ -1721,8 +1774,25 @@ public virtual void SaveState(Stream stream)
         writer.Write((int)_scheduler.Config.PredictionType);
         writer.Write(_scheduler.Config.ClipSample);
 
-        // Save model parameters using SerializationHelper
-        SerializationHelper<T>.SerializeVector(writer, GetParameters());
+        // STREAM THE WEIGHTS, DO NOT FLATTEN THEM. GetParameters() materialises every weight into
+        // one Vector<T>, and a foundation-scale model crosses the CLR's ~2 GB single-array ceiling on
+        // the way in -- six diffusion clone contracts failed here with "Array dimensions exceeded
+        // supported range". DeepCopy was already fixed to stream chunks; this path never was.
+        //
+        // A sentinel keeps old files readable: it is negative, and a legacy payload starts with a
+        // vector LENGTH, which never is.
+        writer.Write(ChunkedParameterMarker);
+        var parameterChunks = new List<Tensor<T>>(GetParameterChunks());
+        writer.Write(parameterChunks.Count);
+        foreach (var chunk in parameterChunks)
+        {
+            writer.Write(chunk.Length);
+            var span = chunk.AsSpan();
+            for (int i = 0; i < span.Length; i++)
+            {
+                writer.Write(NumOps.ToDouble(span[i]));
+            }
+        }
 
         stream.Flush();
     }
@@ -1803,8 +1873,32 @@ public virtual void LoadState(Stream stream)
                 $"current={_scheduler.Config.ClipSample}. Create a model with matching scheduler config.");
         }
 
-        // Load model parameters using SerializationHelper
-        SetParameters(SerializationHelper<T>.DeserializeVector(reader));
+        // Matches the writer above, and still reads a file written before it: a legacy payload opens
+        // with the vector length, so anything that is not the sentinel is handed to the flat reader
+        // with that length already consumed.
+        int parameterMarker = reader.ReadInt32();
+        if (parameterMarker == ChunkedParameterMarker)
+        {
+            int chunkCount = reader.ReadInt32();
+            var restored = new List<Tensor<T>>(chunkCount);
+            for (int c = 0; c < chunkCount; c++)
+            {
+                int length = reader.ReadInt32();
+                var values = new T[length];
+                for (int i = 0; i < length; i++)
+                {
+                    values[i] = NumOps.FromDouble(reader.ReadDouble());
+                }
+
+                restored.Add(new Tensor<T>(new[] { length }, new Vector<T>(values)));
+            }
+
+            SetParameterChunks(restored);
+        }
+        else
+        {
+            SetParameters(SerializationHelper<T>.DeserializeVector(reader, parameterMarker));
+        }
     }
 
     #endregion
@@ -1868,7 +1962,142 @@ public virtual Dictionary<string, T> GetFeatureImportance()
     #region ICloneable<IFullModel<T, Tensor<T>, Tensor<T>>> Implementation
 
     /// <inheritdoc />
-    public abstract IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy();
+    /// <remarks>
+    /// <para>
+    /// No longer abstract. Declaring it abstract here is what produced 267 hand-written DeepCopy and
+    /// Clone pairs across this family -- one per model, each re-listing the constructor arguments
+    /// its type happens to take. The clone plan records that constructor at compile time, so the
+    /// rebuild is the same code for every model and a new argument cannot be forgotten in 266 places.
+    /// </para>
+    /// <para>
+    /// Configuration is rebuilt, learned state is carried through the model's own Serialize and
+    /// Deserialize -- the public, overridable pair, so a model that persists something extra keeps
+    /// it. The guard is told this is an internal operation because a clone is not a save.
+    /// </para>
+    /// </remarks>
+    public virtual IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy()
+    {
+        using (ModelPersistenceGuard.InternalOperation())
+        {
+            var copy = (DiffusionModelBase<T>)AiDotNet.Models.CloneEngine.CopyConfiguration(this);
+
+            // Copy the weights CHUNK BY CHUNK rather than through Serialize/Deserialize. The
+            // roundtrip funnels every parameter into one MemoryStream, and a ControlNet-scale model
+            // crosses the CLR's ~2 GB single-array ceiling on the way in -- the clone died with
+            // "Array dimensions exceeded supported range" inside BinaryWriter.Write, having
+            // allocated gigabytes first. GetParameterChunks exists precisely so a whole-model
+            // transfer never materialises a flat aggregate.
+            //
+            // Nothing is lost by not serializing. SaveState writes exactly three things: a version
+            // marker, the scheduler config, and the parameters. The scheduler config is already
+            // reproduced by CopyConfiguration above, and LoadState only VALIDATES that it matches
+            // rather than restoring it -- so the parameters were the sole payload this roundtrip
+            // was carrying.
+            // Prefer the shared O(1)-until-write transfer for every diffusion model. Keeping this
+            // decision in the base removes the last reason for concrete diffusion types to carry
+            // bespoke clone overrides, and avoids both materializing a second foundation-scale
+            // parameter set and depending on post-forward reflection order. The helper validates
+            // the complete source/destination layer graph before rebinding anything; an unsupported
+            // graph remains untouched and takes the exact streaming fallback below.
+            if (!copy.TryShareParametersFrom(this))
+            {
+                EnsureCloneParameterLayoutMatches(this, copy);
+#if NETFRAMEWORK
+                // IParameterizable's chunked API is unavailable on .NET Framework, so latent
+                // diffusion models deliberately expose no chunks there. Falling through to the
+                // streaming restore would therefore hand a non-empty clone a zero-length vector.
+                // The net471 target is retained for compatibility and cannot host foundation-scale
+                // models; use the contract-preserving flat path on that target only.
+                copy.SetParameters(GetParameters());
+#else
+                copy.SetParameterChunks(GetParameterChunks());
+#endif
+            }
+            return copy;
+        }
+    }
+
+    private static void EnsureCloneParameterLayoutMatches(
+        DiffusionModelBase<T> source,
+        DiffusionModelBase<T> destination)
+    {
+        var sourceLayout = source.ParameterLayout;
+        var destinationLayout = destination.ParameterLayout;
+        // Clone restoration may materialize a shape-resolved lazy child. Allocation timing is
+        // not part of the durable model schema, so validate the declared layout here while the
+        // exact fingerprint remains available to checkpoint/readiness boundaries.
+        if (string.Equals(sourceLayout.DeclaredLayoutFingerprint,
+                destinationLayout.DeclaredLayoutFingerprint,
+                StringComparison.Ordinal))
+            return;
+
+        var destinationById = destinationLayout.Slots.ToDictionary(
+            slot => slot.StableId,
+            StringComparer.Ordinal);
+        var differences = new List<string>();
+        for (int i = 0; i < sourceLayout.Slots.Count && differences.Count < 8; i++)
+        {
+            var sourceSlot = sourceLayout.Slots[i];
+            if (!destinationById.TryGetValue(sourceSlot.StableId, out var destinationSlot))
+            {
+                differences.Add($"missing '{sourceSlot.StableId}' ({sourceSlot.ParameterCount?.ToString() ?? "?"})");
+                continue;
+            }
+
+            if (sourceSlot.ParameterCount != destinationSlot.ParameterCount
+                || sourceSlot.Role != destinationSlot.Role
+                || sourceSlot.UpdatePolicy != destinationSlot.UpdatePolicy
+                || sourceSlot.Persistence != destinationSlot.Persistence
+                || sourceSlot.Ownership != destinationSlot.Ownership
+                || sourceSlot.Availability != destinationSlot.Availability
+                || !string.Equals(sourceSlot.ElementType, destinationSlot.ElementType,
+                    StringComparison.Ordinal)
+                || !ShapesEqual(sourceSlot.Shape, destinationSlot.Shape))
+            {
+                differences.Add(
+                    $"'{sourceSlot.StableId}' source={DescribeSlot(sourceSlot)}, "
+                    + $"clone={DescribeSlot(destinationSlot)}");
+            }
+        }
+
+        if (differences.Count < 8)
+        {
+            var sourceIds = new HashSet<string>(
+                sourceLayout.Slots.Select(slot => slot.StableId),
+                StringComparer.Ordinal);
+            for (int i = 0; i < destinationLayout.Slots.Count && differences.Count < 8; i++)
+            {
+                var slot = destinationLayout.Slots[i];
+                if (!sourceIds.Contains(slot.StableId))
+                    differences.Add($"extra '{slot.StableId}' ({slot.ParameterCount?.ToString() ?? "?"})");
+            }
+        }
+
+        throw new InvalidOperationException(
+            $"Clone configuration changed the parameter manifest for {source.GetType().Name}: "
+            + $"source declared/materialized={sourceLayout.ParameterCount?.ToString() ?? "?"}/"
+            + $"{sourceLayout.MaterializedParameterCount}, clone={destinationLayout.ParameterCount?.ToString() ?? "?"}/"
+            + $"{destinationLayout.MaterializedParameterCount}. "
+            + (differences.Count == 0
+                ? "Stable slot metadata or ordering differs."
+                : string.Join("; ", differences)));
+    }
+
+    private static string DescribeSlot(AiDotNet.Models.Parameters.ParameterSlotDescriptor slot)
+        => $"{slot.Readiness}, declared={slot.ParameterCount?.ToString() ?? "?"}, "
+           + $"materialized={slot.MaterializedParameterCount}, shape={DescribeShape(slot.Shape)}";
+
+    private static string DescribeShape(IReadOnlyList<int>? shape)
+        => shape is null ? "?" : $"[{string.Join(",", shape)}]";
+
+    private static bool ShapesEqual(IReadOnlyList<int>? left, IReadOnlyList<int>? right)
+    {
+        if (left is null || right is null) return left is null && right is null;
+        if (left.Count != right.Count) return false;
+        for (int i = 0; i < left.Count; i++)
+            if (left[i] != right[i]) return false;
+        return true;
+    }
 
     /// <inheritdoc />
     IFullModel<T, Tensor<T>, Tensor<T>> ICloneable<IFullModel<T, Tensor<T>, Tensor<T>>>.Clone()
@@ -1880,7 +2109,7 @@ IFullModel<T, Tensor<T>, Tensor<T>> ICloneable<IFullModel<T, Tensor<T>, Tensor<T
     /// Creates a deep copy of the model.
     /// </summary>
     /// <returns>A new instance with the same parameters.</returns>
-    public abstract IDiffusionModel<T> Clone();
+    public virtual IDiffusionModel<T> Clone() => (IDiffusionModel<T>)DeepCopy();
 
     #endregion
 
diff --git a/src/Diffusion/Distillation/StudentTeacherFramework.cs b/src/Diffusion/Distillation/StudentTeacherFramework.cs
index 0cc99f66df..536ac9376e 100644
--- a/src/Diffusion/Distillation/StudentTeacherFramework.cs
+++ b/src/Diffusion/Distillation/StudentTeacherFramework.cs
@@ -39,6 +39,7 @@ public class StudentTeacherFramework<T>
     private readonly IDiffusionModel<T> _student;
     private readonly double _emaDecay;
     private readonly double _temperatureScale;
+    [AiDotNet.Attributes.Buffer]
     private Vector<T>? _emaParameters;
 
     /// <summary>
diff --git a/src/Diffusion/FastGeneration/ARDiffusionModel.cs b/src/Diffusion/FastGeneration/ARDiffusionModel.cs
index 1bb4e75581..1f4f846299 100644
--- a/src/Diffusion/FastGeneration/ARDiffusionModel.cs
+++ b/src/Diffusion/FastGeneration/ARDiffusionModel.cs
@@ -115,24 +115,6 @@ private void InitializeLayers(SiTPredictor<T>? predictor, StandardVAE<T>? vae, i
 
 
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        // Lazy-preserving Clone (recipe from #1596): delegate to the predictor's and VAE's own Clone(),
-        // which reconstruct from their actual config fields and preserve materialized weights. Rebuilding
-        // a default-scale model here and SetParameters(GetParameters()) double-counts/mismatches the
-        // parameter vector once the source has been forwarded (lazy layers materialize on the forward path,
-        // a different entry than SetParameters' EnsureInitialized), and rebuilding at hardcoded scale can't
-        // accept an injected non-default predictor.
-        return new ARDiffusionModel<T>(
-            predictor: (SiTPredictor<T>)_predictor.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner);
-    }
-
     /// <inheritdoc />
     public override ModelMetadata<T> GetModelMetadata()
     {
diff --git a/src/Diffusion/FastGeneration/AuraFlowModel.cs b/src/Diffusion/FastGeneration/AuraFlowModel.cs
index ec57736631..552f6e3ef7 100644
--- a/src/Diffusion/FastGeneration/AuraFlowModel.cs
+++ b/src/Diffusion/FastGeneration/AuraFlowModel.cs
@@ -174,23 +174,6 @@ public override Tensor<T> GenerateFromText(
 
     #region ICloneable
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        // Delegate to the predictor's and VAE's own Clone(), which reconstruct from their
-        // actual config fields (NOT hardcoded foundation-scale constants) and preserve
-        // materialized weights — so a caller-injected variant of any scale round-trips
-        // correctly. Rebuilding at fixed 1536/24 here would size a clone that cannot accept
-        // an injected tiny (or otherwise non-default) predictor's parameter vector.
-        return new AuraFlowModel<T>(
-            dit: (DiTNoisePredictor<T>)_dit.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner);
-    }
-
     #endregion
 
     #region Metadata
diff --git a/src/Diffusion/FastGeneration/AutoRegressiveMaskedDiffusion.cs b/src/Diffusion/FastGeneration/AutoRegressiveMaskedDiffusion.cs
index 201eeeb585..09a4dc5148 100644
--- a/src/Diffusion/FastGeneration/AutoRegressiveMaskedDiffusion.cs
+++ b/src/Diffusion/FastGeneration/AutoRegressiveMaskedDiffusion.cs
@@ -115,29 +115,6 @@ private void InitializeLayers(SiTPredictor<T>? predictor, StandardVAE<T>? vae, i
 
 
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        // Fast path: O(1) copy-on-write share when the default clone is structurally identical
-        // (the common foundation-scale case the COW lever targets — no re-materialization/OOM).
-        var clone = new AutoRegressiveMaskedDiffusion<T>(conditioner: _conditioner, seed: null);
-        if (clone.TryShareParametersFrom(this)) return clone;
-        // Structure mismatch ⇒ custom architecture/predictor/VAE the default clone can't reproduce;
-        // rebuild faithfully from this instance's configuration so the clone is observationally
-        // identical instead of throwing on a parameter-count mismatch.
-        return new AutoRegressiveMaskedDiffusion<T>(
-            architecture: Architecture,
-            options: (DiffusionModelOptions<T>)Options,
-            scheduler: Scheduler,
-            predictor: (SiTPredictor<T>)_predictor.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner,
-            seed: null);
-    }
-
     /// <inheritdoc />
     public override ModelMetadata<T> GetModelMetadata()
     {
diff --git a/src/Diffusion/FastGeneration/ConsistencyModel.cs b/src/Diffusion/FastGeneration/ConsistencyModel.cs
index 8ccb7597fa..d505b32e60 100644
--- a/src/Diffusion/FastGeneration/ConsistencyModel.cs
+++ b/src/Diffusion/FastGeneration/ConsistencyModel.cs
@@ -628,30 +628,6 @@ private Tensor<T> ScaleTensor(Tensor<T> tensor, double scale)
 
     #region ICloneable Implementation
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy()
-    {
-        return Clone();
-    }
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        // Lazy-preserving Clone (recipe from #1596): delegate to the predictor's and VAE's own Clone()
-        // (preserves materialized weights, reconstructs from actual config) instead of rebuilding a
-        // default-scale model and SetParameters(GetParameters()), which mismatches an injected non-default
-        // variant and re-randomizes the clone's unmaterialized lazy weights.
-        return new ConsistencyModel<T>(
-            noisePredictor: (UNetNoisePredictor<T>)_noisePredictor.Clone(),
-            vae: (StandardVAE<T>)_vae.Value.Clone(),
-            numTrainSteps: _numTrainSteps,
-            sigmaMin: _sigmaMin,
-            sigmaMax: _sigmaMax,
-            rho: _rho,
-            isDistilled: _isDistilled,
-            conditioner: _conditioner);
-    }
-
     #endregion
 
     #region Metadata
diff --git a/src/Diffusion/FastGeneration/DMD2Model.cs b/src/Diffusion/FastGeneration/DMD2Model.cs
index 27c8517410..4b6b091342 100644
--- a/src/Diffusion/FastGeneration/DMD2Model.cs
+++ b/src/Diffusion/FastGeneration/DMD2Model.cs
@@ -121,29 +121,6 @@ private void InitializeLayers(UNetNoisePredictor<T>? predictor, StandardVAE<T>?
 
 
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        // Clone the ACTUAL predictor and VAE (mirrors InstaFlowModel/MultiDiffusionModel): passing only
-        // conditioner/seed rebuilt InitializeLayers' DEFAULT-sized, lazily-unresolved UNet/VAE, so once
-        // the source resolved its lazy layers via a forward pass GetParameters() returned a larger count
-        // than the clone could accept — SetParameters threw / Clone diverged. Cloning the resolved
-        // predictor/VAE (+ same architecture/options/scheduler) makes the clone structurally identical.
-        var clone = new DMD2Model<T>(
-            architecture: Architecture,
-            options: Options as DiffusionModelOptions<T>,
-            scheduler: Scheduler,
-            predictor: (UNetNoisePredictor<T>)_predictor.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner,
-            seed: null);
-        if (!clone.TryShareParametersFrom(this)) clone.SetParameterChunks(GetParameterChunks());
-        return clone;
-    }
-
     /// <inheritdoc />
     public override ModelMetadata<T> GetModelMetadata()
     {
diff --git a/src/Diffusion/FastGeneration/EasyConsistencyModel.cs b/src/Diffusion/FastGeneration/EasyConsistencyModel.cs
index 43f28e8fac..e4d8524e76 100644
--- a/src/Diffusion/FastGeneration/EasyConsistencyModel.cs
+++ b/src/Diffusion/FastGeneration/EasyConsistencyModel.cs
@@ -151,22 +151,6 @@ private void InitializeLayers(UNetNoisePredictor<T>? predictor, StandardVAE<T>?
 
 
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        // Lazy-preserving Clone (recipe from #1596): delegate to the predictor's and VAE's own Clone()
-        // (preserves materialized weights, reconstructs from actual config) instead of rebuilding a
-        // default-scale model and SetParameters(GetParameters()), which mismatches an injected non-default
-        // variant and re-randomizes the clone's unmaterialized lazy weights.
-        return new EasyConsistencyModel<T>(
-            predictor: (UNetNoisePredictor<T>)_predictor.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner);
-    }
-
     /// <inheritdoc />
     public override ModelMetadata<T> GetModelMetadata()
     {
diff --git a/src/Diffusion/FastGeneration/FlashDiffusionModel.cs b/src/Diffusion/FastGeneration/FlashDiffusionModel.cs
index 87ad80ae36..d88f5967ee 100644
--- a/src/Diffusion/FastGeneration/FlashDiffusionModel.cs
+++ b/src/Diffusion/FastGeneration/FlashDiffusionModel.cs
@@ -119,22 +119,6 @@ private void InitializeLayers(UNetNoisePredictor<T>? predictor, StandardVAE<T>?
 
 
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        // Lazy-preserving Clone (recipe from #1596): delegate to the predictor's and VAE's own Clone()
-        // (preserves materialized weights, reconstructs from actual config) instead of rebuilding a
-        // default-scale model and SetParameters(GetParameters()), which mismatches an injected non-default
-        // variant and re-randomizes the clone's unmaterialized lazy weights.
-        return new FlashDiffusionModel<T>(
-            predictor: (UNetNoisePredictor<T>)_predictor.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner);
-    }
-
     /// <inheritdoc />
     public override ModelMetadata<T> GetModelMetadata()
     {
diff --git a/src/Diffusion/FastGeneration/FlowMapModel.cs b/src/Diffusion/FastGeneration/FlowMapModel.cs
index 434108c2a9..1b0e83778d 100644
--- a/src/Diffusion/FastGeneration/FlowMapModel.cs
+++ b/src/Diffusion/FastGeneration/FlowMapModel.cs
@@ -118,29 +118,6 @@ private void InitializeLayers(UNetNoisePredictor<T>? predictor, StandardVAE<T>?
 
 
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        // Clone the ACTUAL predictor and VAE (mirrors InstaFlowModel/MultiDiffusionModel): passing only
-        // conditioner/seed rebuilt InitializeLayers' DEFAULT-sized, lazily-unresolved UNet/VAE, so once
-        // the source resolved its lazy layers via a forward pass GetParameters() returned a larger count
-        // than the clone could accept — SetParameters threw / Clone diverged. Cloning the resolved
-        // predictor/VAE (+ same architecture/options/scheduler) makes the clone structurally identical.
-        var clone = new FlowMapModel<T>(
-            architecture: Architecture,
-            options: Options as DiffusionModelOptions<T>,
-            scheduler: Scheduler,
-            predictor: (UNetNoisePredictor<T>)_predictor.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner,
-            seed: null);
-        if (!clone.TryShareParametersFrom(this)) clone.SetParameterChunks(GetParameterChunks());
-        return clone;
-    }
-
     /// <inheritdoc />
     public override ModelMetadata<T> GetModelMetadata()
     {
diff --git a/src/Diffusion/FastGeneration/Flux2SchnellModel.cs b/src/Diffusion/FastGeneration/Flux2SchnellModel.cs
index 0f950cc952..2b2409be03 100644
--- a/src/Diffusion/FastGeneration/Flux2SchnellModel.cs
+++ b/src/Diffusion/FastGeneration/Flux2SchnellModel.cs
@@ -126,22 +126,6 @@ private void InitializeLayers(FluxDoubleStreamPredictor<T>? predictor, StandardV
 
 
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        // #1711: delegate to predictor/VAE Clone (probe-forward + copy); DiT LazyDense weights resolve
-        // via the FORWARD path so a model-level SetParameters(GetParameters()) clone re-RNG-initialized.
-        var clone = new Flux2SchnellModel<T>(
-            conditioner: _conditioner,
-            predictor: (FluxDoubleStreamPredictor<T>)_predictor.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            seed: null);
-        return clone;
-    }
-
     /// <inheritdoc />
     public override ModelMetadata<T> GetModelMetadata()
     {
diff --git a/src/Diffusion/FastGeneration/FluxSchnellModel.cs b/src/Diffusion/FastGeneration/FluxSchnellModel.cs
index 9cd977746d..9053ea7c18 100644
--- a/src/Diffusion/FastGeneration/FluxSchnellModel.cs
+++ b/src/Diffusion/FastGeneration/FluxSchnellModel.cs
@@ -123,28 +123,6 @@ private void InitializeLayers(FluxDoubleStreamPredictor<T>? predictor, StandardV
 
 
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        // Reuse THIS model's resolved construction seed (not a fresh one): a never-forwarded predictor is
-        // still lazy, so the clone must materialize from the SAME seed to stay equivalent — a fresh seed
-        // would later materialize different weights and break Clone() equivalence.
-        var clone = new FluxSchnellModel<T>(conditioner: _conditioner, seed: _layerSeed);
-        // Scale-safe + lazy-preserving: only copy the foundation-scale (~12B-param FLUX) predictor's
-        // weights if they were actually materialized. A never-forwarded model's weights are still lazy, so
-        // the clone reconstructs them from the shared seed above (nothing to copy) — copying would
-        // pointlessly materialize the predictor twice (source + clone) and OOM. When a copy IS needed it
-        // streams per-tensor chunks (#1624), never the int-bounded flat Vector<T> that
-        // SetParameters(GetParameters()) builds (which threw "Array dimensions exceeded supported range").
-        if (_predictor.WeightsMaterialized)
-            clone._predictor.SetParameterChunks(_predictor.GetParameterChunks());
-        clone._vae.SetParameters(_vae.GetParameters());
-        return clone;
-    }
-
     /// <inheritdoc />
     public override ModelMetadata<T> GetModelMetadata()
     {
diff --git a/src/Diffusion/FastGeneration/HyperSDModel.cs b/src/Diffusion/FastGeneration/HyperSDModel.cs
index 60233855fa..60bae3cdbb 100644
--- a/src/Diffusion/FastGeneration/HyperSDModel.cs
+++ b/src/Diffusion/FastGeneration/HyperSDModel.cs
@@ -132,28 +132,6 @@ private void InitializeLayers(UNetNoisePredictor<T>? predictor, StandardVAE<T>?
 
 
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        // Clone the ACTUAL predictor/VAE (see InstaFlowModel/MultiDiffusionModel): passing only
-        // conditioner/isXLVariant/seed rebuilt InitializeLayers' DEFAULT-sized, lazily-unresolved
-        // sub-models, so once the source resolved its lazy layers via a forward pass the trainable-layer
-        // shapes no longer lined up 1:1 and Clone diverged. Cloning the resolved predictor/VAE (+ same
-        // architecture/options/scheduler) makes the clone structurally identical.
-        var clone = new HyperSDModel<T>(
-            architecture: Architecture,
-            options: Options as DiffusionModelOptions<T>,
-            scheduler: Scheduler,
-            predictor: (UNetNoisePredictor<T>)_predictor.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner, isXLVariant: _isXLVariant, seed: null);
-        if (!clone.TryShareParametersFrom(this)) clone.SetParameterChunks(GetParameterChunks());
-        return clone;
-    }
-
     /// <inheritdoc />
     public override ModelMetadata<T> GetModelMetadata()
     {
diff --git a/src/Diffusion/FastGeneration/ImprovedConsistencyModel.cs b/src/Diffusion/FastGeneration/ImprovedConsistencyModel.cs
index 5bb1f19591..47c6750afc 100644
--- a/src/Diffusion/FastGeneration/ImprovedConsistencyModel.cs
+++ b/src/Diffusion/FastGeneration/ImprovedConsistencyModel.cs
@@ -150,30 +150,6 @@ private void InitializeLayers(UNetNoisePredictor<T>? predictor, StandardVAE<T>?
 
 
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        // Delegate to the predictor/VAE's own Clone implementations,
-        // which handle their internal lazy shape inference on BOTH
-        // source and clone before copying weights. Constructing a
-        // fresh predictor/VAE here and then calling SetParameters with
-        // GetParameters from this would re-hit the same lazy-init bug:
-        // GetParameters() on a freshly built (unresolved) source
-        // under-counts the time-embedding DenseLayer params, while the
-        // new constructor's ParameterCount is live (arch-derived),
-        // throwing ArgumentException from SetParameters' length check.
-        var predictorClone = (UNetNoisePredictor<T>)_predictor.Clone();
-        var vaeClone = (StandardVAE<T>)_vae.Clone();
-        return new ImprovedConsistencyModel<T>(
-            predictor: predictorClone,
-            vae: vaeClone,
-            conditioner: _conditioner,
-            seed: null);
-    }
-
     /// <inheritdoc />
     public override ModelMetadata<T> GetModelMetadata()
     {
diff --git a/src/Diffusion/FastGeneration/InstaFlowModel.cs b/src/Diffusion/FastGeneration/InstaFlowModel.cs
index 22190e8fab..da93f1f073 100644
--- a/src/Diffusion/FastGeneration/InstaFlowModel.cs
+++ b/src/Diffusion/FastGeneration/InstaFlowModel.cs
@@ -121,30 +121,6 @@ private void InitializeLayers(UNetNoisePredictor<T>? predictor, StandardVAE<T>?
 
 
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        // Clone the ACTUAL predictor and VAE (mirrors MultiDiffusionModel/SpotDiffusionModel):
-        // the previous code passed only conditioner/seed, so the clone rebuilt InitializeLayers'
-        // DEFAULT-sized UNet/VAE while this model may hold a custom-sized predictor/vae. GetParameters()
-        // then returned the source's larger count and clone.SetParameters threw "Expected X, got Y".
-        // Passing the cloned predictor/VAE (+ same architecture/options/scheduler) makes the clone
-        // structurally identical to the source.
-        var clone = new InstaFlowModel<T>(
-            architecture: Architecture,
-            options: Options as DiffusionModelOptions<T>,
-            scheduler: Scheduler,
-            predictor: (UNetNoisePredictor<T>)_predictor.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner,
-            seed: null);
-        if (!clone.TryShareParametersFrom(this)) clone.SetParameterChunks(GetParameterChunks());
-        return clone;
-    }
-
     /// <inheritdoc />
     public override ModelMetadata<T> GetModelMetadata()
     {
diff --git a/src/Diffusion/FastGeneration/LatentConsistencyModel.cs b/src/Diffusion/FastGeneration/LatentConsistencyModel.cs
index 9d36811457..f04d19858a 100644
--- a/src/Diffusion/FastGeneration/LatentConsistencyModel.cs
+++ b/src/Diffusion/FastGeneration/LatentConsistencyModel.cs
@@ -319,32 +319,6 @@ public override Tensor<T> ImageToImage(
 
     #region ICloneable Implementation
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy()
-    {
-        return Clone();
-    }
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        var contextDim = _baseModel switch
-        {
-            "SDXL" => 2048,
-            "SD2.1" => 1024,
-            _ => LCM_CROSS_ATTENTION_DIM
-        };
-
-        return new LatentConsistencyModel<T>(
-            architecture: Architecture,
-            options: Options as DiffusionModelOptions<T>,
-            scheduler: Scheduler,
-            unet: (UNetNoisePredictor<T>)_unet.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner,
-            baseModel: _baseModel);
-    }
-
     #endregion
 
     #region Metadata
diff --git a/src/Diffusion/FastGeneration/MARModel.cs b/src/Diffusion/FastGeneration/MARModel.cs
index c213304e01..e1caa4992a 100644
--- a/src/Diffusion/FastGeneration/MARModel.cs
+++ b/src/Diffusion/FastGeneration/MARModel.cs
@@ -117,22 +117,6 @@ private void InitializeLayers(SiTPredictor<T>? predictor, StandardVAE<T>? vae, i
 
 
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        // #1711: delegate to predictor/VAE Clone (probe-forward + copy); DiT LazyDense weights resolve
-        // via the FORWARD path so a model-level SetParameters(GetParameters()) clone re-RNG-initialized.
-        var clone = new MARModel<T>(
-            conditioner: _conditioner,
-            predictor: (SiTPredictor<T>)_predictor.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            seed: null);
-        return clone;
-    }
-
     /// <inheritdoc />
     public override ModelMetadata<T> GetModelMetadata()
     {
diff --git a/src/Diffusion/FastGeneration/MultiStepConsistencyModel.cs b/src/Diffusion/FastGeneration/MultiStepConsistencyModel.cs
index 3c9ad99076..05b1f5e0c1 100644
--- a/src/Diffusion/FastGeneration/MultiStepConsistencyModel.cs
+++ b/src/Diffusion/FastGeneration/MultiStepConsistencyModel.cs
@@ -151,21 +151,6 @@ private void InitializeLayers(UNetNoisePredictor<T>? predictor, StandardVAE<T>?
 
 
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        // Lazy-preserving Clone (recipe from #1596): delegate to the predictor's and VAE's own Clone()
-        // instead of rebuild-at-default-scale + SetParameters(GetParameters()), which re-randomizes
-        // the clone's unmaterialized lazy weights.
-        return new MultiStepConsistencyModel<T>(
-            predictor: (UNetNoisePredictor<T>)_predictor.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner);
-    }
-
     /// <inheritdoc />
     public override ModelMetadata<T> GetModelMetadata()
     {
diff --git a/src/Diffusion/FastGeneration/MultistepLCModel.cs b/src/Diffusion/FastGeneration/MultistepLCModel.cs
index 08095799ef..e2f731945d 100644
--- a/src/Diffusion/FastGeneration/MultistepLCModel.cs
+++ b/src/Diffusion/FastGeneration/MultistepLCModel.cs
@@ -151,29 +151,6 @@ private void InitializeLayers(UNetNoisePredictor<T>? predictor, StandardVAE<T>?
 
 
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        // Clone the ACTUAL predictor and VAE (mirrors InstaFlowModel/MultiDiffusionModel): passing only
-        // conditioner/seed rebuilt InitializeLayers' DEFAULT-sized, lazily-unresolved UNet/VAE, so once
-        // the source resolved its lazy layers via a forward pass GetParameters() returned a larger count
-        // than the clone could accept — SetParameters threw / Clone diverged. Cloning the resolved
-        // predictor/VAE (+ same architecture/options/scheduler) makes the clone structurally identical.
-        var clone = new MultistepLCModel<T>(
-            architecture: Architecture,
-            options: Options as DiffusionModelOptions<T>,
-            scheduler: Scheduler,
-            predictor: (UNetNoisePredictor<T>)_predictor.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner,
-            seed: null);
-        if (!clone.TryShareParametersFrom(this)) clone.SetParameterChunks(GetParameterChunks());
-        return clone;
-    }
-
     /// <inheritdoc />
     public override ModelMetadata<T> GetModelMetadata()
     {
diff --git a/src/Diffusion/FastGeneration/OSDSModel.cs b/src/Diffusion/FastGeneration/OSDSModel.cs
index e99167e802..4171be2dcf 100644
--- a/src/Diffusion/FastGeneration/OSDSModel.cs
+++ b/src/Diffusion/FastGeneration/OSDSModel.cs
@@ -111,29 +111,6 @@ private void InitializeLayers(UNetNoisePredictor<T>? predictor, StandardVAE<T>?
 
 
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        // Clone the ACTUAL predictor and VAE (mirrors InstaFlowModel/MultiDiffusionModel): passing only
-        // conditioner/seed rebuilt InitializeLayers' DEFAULT-sized, lazily-unresolved UNet/VAE, so once
-        // the source resolved its lazy layers via a forward pass GetParameters() returned a larger count
-        // than the clone could accept — SetParameters threw / Clone diverged. Cloning the resolved
-        // predictor/VAE (+ same architecture/options/scheduler) makes the clone structurally identical.
-        var clone = new OSDSModel<T>(
-            architecture: Architecture,
-            options: Options as DiffusionModelOptions<T>,
-            scheduler: Scheduler,
-            predictor: (UNetNoisePredictor<T>)_predictor.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner,
-            seed: null);
-        if (!clone.TryShareParametersFrom(this)) clone.SetParameterChunks(GetParameterChunks());
-        return clone;
-    }
-
     /// <inheritdoc />
     public override ModelMetadata<T> GetModelMetadata()
     {
diff --git a/src/Diffusion/FastGeneration/PCMModel.cs b/src/Diffusion/FastGeneration/PCMModel.cs
index f83c130e1e..f36228e4c9 100644
--- a/src/Diffusion/FastGeneration/PCMModel.cs
+++ b/src/Diffusion/FastGeneration/PCMModel.cs
@@ -127,28 +127,6 @@ private void InitializeLayers(UNetNoisePredictor<T>? predictor, StandardVAE<T>?
 
 
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        // Clone the ACTUAL predictor/VAE (see InstaFlowModel/MultiDiffusionModel): passing only
-        // conditioner/isXLVariant/seed rebuilt InitializeLayers' DEFAULT-sized, lazily-unresolved
-        // sub-models, so once the source resolved its lazy layers via a forward pass the trainable-layer
-        // shapes no longer lined up 1:1 and Clone diverged. Cloning the resolved predictor/VAE (+ same
-        // architecture/options/scheduler) makes the clone structurally identical.
-        var clone = new PCMModel<T>(
-            architecture: Architecture,
-            options: Options as DiffusionModelOptions<T>,
-            scheduler: Scheduler,
-            predictor: (UNetNoisePredictor<T>)_predictor.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner, isXLVariant: _isXLVariant, seed: null);
-        if (!clone.TryShareParametersFrom(this)) clone.SetParameterChunks(GetParameterChunks());
-        return clone;
-    }
-
     /// <inheritdoc />
     public override ModelMetadata<T> GetModelMetadata()
     {
diff --git a/src/Diffusion/FastGeneration/PeRFlowModel.cs b/src/Diffusion/FastGeneration/PeRFlowModel.cs
index ebbaeda770..9247abc153 100644
--- a/src/Diffusion/FastGeneration/PeRFlowModel.cs
+++ b/src/Diffusion/FastGeneration/PeRFlowModel.cs
@@ -128,28 +128,6 @@ private void InitializeLayers(UNetNoisePredictor<T>? predictor, StandardVAE<T>?
 
 
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        // Clone the ACTUAL predictor/VAE (see InstaFlowModel/MultiDiffusionModel): passing only
-        // conditioner/numSegments/seed rebuilt InitializeLayers' DEFAULT-sized, lazily-unresolved
-        // sub-models, so once the source resolved its lazy layers via a forward pass the trainable-layer
-        // shapes no longer lined up 1:1 and Clone diverged. Cloning the resolved predictor/VAE (+ same
-        // architecture/options/scheduler) makes the clone structurally identical.
-        var clone = new PeRFlowModel<T>(
-            architecture: Architecture,
-            options: Options as DiffusionModelOptions<T>,
-            scheduler: Scheduler,
-            predictor: (UNetNoisePredictor<T>)_predictor.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner, numSegments: _numSegments, seed: null);
-        if (!clone.TryShareParametersFrom(this)) clone.SetParameterChunks(GetParameterChunks());
-        return clone;
-    }
-
     /// <inheritdoc />
     public override ModelMetadata<T> GetModelMetadata()
     {
diff --git a/src/Diffusion/FastGeneration/PixArtDeltaLCMModel.cs b/src/Diffusion/FastGeneration/PixArtDeltaLCMModel.cs
index 28e10013ef..617a4ca0d6 100644
--- a/src/Diffusion/FastGeneration/PixArtDeltaLCMModel.cs
+++ b/src/Diffusion/FastGeneration/PixArtDeltaLCMModel.cs
@@ -117,22 +117,6 @@ private void InitializeLayers(SiTPredictor<T>? predictor, StandardVAE<T>? vae, i
 
 
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        // #1711: delegate to predictor/VAE Clone (probe-forward + copy); DiT LazyDense weights resolve
-        // via the FORWARD path so a model-level SetParameters(GetParameters()) clone re-RNG-initialized.
-        var clone = new PixArtDeltaLCMModel<T>(
-            conditioner: _conditioner,
-            predictor: (SiTPredictor<T>)_predictor.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            seed: null);
-        return clone;
-    }
-
     /// <inheritdoc />
     public override ModelMetadata<T> GetModelMetadata()
     {
diff --git a/src/Diffusion/FastGeneration/SANASprintModel.cs b/src/Diffusion/FastGeneration/SANASprintModel.cs
index 6fc12cedab..d7d3c705bf 100644
--- a/src/Diffusion/FastGeneration/SANASprintModel.cs
+++ b/src/Diffusion/FastGeneration/SANASprintModel.cs
@@ -121,29 +121,6 @@ private void InitializeLayers(SiTPredictor<T>? predictor, StandardVAE<T>? vae, i
 
 
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        // Fast path: O(1) copy-on-write share when the default clone is structurally identical
-        // (the common foundation-scale case the COW lever targets — no re-materialization/OOM).
-        var clone = new SANASprintModel<T>(conditioner: _conditioner, seed: null);
-        if (clone.TryShareParametersFrom(this)) return clone;
-        // Structure mismatch ⇒ custom architecture/predictor/VAE the default clone can't reproduce;
-        // rebuild faithfully from this instance's configuration so the clone is observationally
-        // identical instead of throwing on a parameter-count mismatch.
-        return new SANASprintModel<T>(
-            architecture: Architecture,
-            options: (DiffusionModelOptions<T>)Options,
-            scheduler: Scheduler,
-            predictor: (SiTPredictor<T>)_predictor.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner,
-            seed: null);
-    }
-
     /// <inheritdoc />
     public override ModelMetadata<T> GetModelMetadata()
     {
diff --git a/src/Diffusion/FastGeneration/SCottModel.cs b/src/Diffusion/FastGeneration/SCottModel.cs
index 5c313b49ce..860c2cfa36 100644
--- a/src/Diffusion/FastGeneration/SCottModel.cs
+++ b/src/Diffusion/FastGeneration/SCottModel.cs
@@ -118,29 +118,6 @@ private void InitializeLayers(UNetNoisePredictor<T>? predictor, StandardVAE<T>?
 
 
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        // Fast path: O(1) copy-on-write share when the default clone is structurally identical
-        // (the common foundation-scale case the COW lever targets — no re-materialization/OOM).
-        var clone = new SCottModel<T>(conditioner: _conditioner, seed: null);
-        if (clone.TryShareParametersFrom(this)) return clone;
-        // Structure mismatch ⇒ custom architecture/predictor/VAE the default clone can't reproduce;
-        // rebuild faithfully from this instance's configuration so the clone is observationally
-        // identical instead of throwing on a parameter-count mismatch.
-        return new SCottModel<T>(
-            architecture: Architecture,
-            options: (DiffusionModelOptions<T>)Options,
-            scheduler: Scheduler,
-            predictor: (UNetNoisePredictor<T>)_predictor.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner,
-            seed: null);
-    }
-
     /// <inheritdoc />
     public override ModelMetadata<T> GetModelMetadata()
     {
diff --git a/src/Diffusion/FastGeneration/SD3FlashModel.cs b/src/Diffusion/FastGeneration/SD3FlashModel.cs
index 7548962816..559a1215f9 100644
--- a/src/Diffusion/FastGeneration/SD3FlashModel.cs
+++ b/src/Diffusion/FastGeneration/SD3FlashModel.cs
@@ -114,22 +114,6 @@ private void InitializeLayers(MMDiTXNoisePredictor<T>? predictor, StandardVAE<T>
 
 
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        // #1711: delegate to predictor/VAE Clone (probe-forward + copy); MMDiT LazyDense weights resolve
-        // via the FORWARD path so a model-level SetParameters(GetParameters()) clone re-RNG-initialized.
-        var clone = new SD3FlashModel<T>(
-            conditioner: _conditioner,
-            predictor: (MMDiTXNoisePredictor<T>)_predictor.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            seed: null);
-        return clone;
-    }
-
     /// <inheritdoc />
     public override ModelMetadata<T> GetModelMetadata()
     {
diff --git a/src/Diffusion/FastGeneration/SD3TurboModel.cs b/src/Diffusion/FastGeneration/SD3TurboModel.cs
index ad7b4c2a02..07e1fa1412 100644
--- a/src/Diffusion/FastGeneration/SD3TurboModel.cs
+++ b/src/Diffusion/FastGeneration/SD3TurboModel.cs
@@ -114,22 +114,6 @@ private void InitializeLayers(MMDiTXNoisePredictor<T>? predictor, StandardVAE<T>
 
 
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        // #1711: delegate to predictor/VAE Clone (probe-forward + copy); MMDiT LazyDense weights resolve
-        // via the FORWARD path so a model-level SetParameters(GetParameters()) clone re-RNG-initialized.
-        var clone = new SD3TurboModel<T>(
-            conditioner: _conditioner,
-            predictor: (MMDiTXNoisePredictor<T>)_predictor.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            seed: null);
-        return clone;
-    }
-
     /// <inheritdoc />
     public override ModelMetadata<T> GetModelMetadata()
     {
diff --git a/src/Diffusion/FastGeneration/SDTurboModel.cs b/src/Diffusion/FastGeneration/SDTurboModel.cs
index b0705dcb3f..a772821a06 100644
--- a/src/Diffusion/FastGeneration/SDTurboModel.cs
+++ b/src/Diffusion/FastGeneration/SDTurboModel.cs
@@ -325,36 +325,6 @@ public override Tensor<T> ImageToImage(
 
     #region ICloneable Implementation
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy()
-    {
-        return Clone();
-    }
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        // Clone the U-Net through its OWN Clone(), which reconstructs from the
-        // source predictor's actual architecture fields (input/output channels,
-        // base channels, channel multipliers, res-block count, attention
-        // resolutions, context dim, heads, input height) and copies weights via a
-        // paired per-layer walk. The previous code rebuilt clonedUnet from
-        // HARDCODED SD-/SDXL-Turbo defaults (baseChannels 320, [1,2,4,4],
-        // numResBlocks 2, contextDim 1024) and then SetParameters'd the source's
-        // weights into it — correct only when the model used the production default
-        // U-Net. With a CUSTOM U-Net (e.g. a smaller test configuration) the
-        // architectures differed, so SetParameters mis-distributed the source's
-        // shorter parameter vector and the clone's later layers kept their random
-        // init — diverging from the original despite "identical" parameters.
-        var clonedUnet = (UNetNoisePredictor<T>)_unet.Clone();
-
-        return new SDTurboModel<T>(
-            unet: clonedUnet,
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner,
-            isXLVariant: _isXLVariant);
-    }
-
     #endregion
 
     #region Metadata
diff --git a/src/Diffusion/FastGeneration/SDXLLightningModel.cs b/src/Diffusion/FastGeneration/SDXLLightningModel.cs
index a3e05d00eb..d708048a39 100644
--- a/src/Diffusion/FastGeneration/SDXLLightningModel.cs
+++ b/src/Diffusion/FastGeneration/SDXLLightningModel.cs
@@ -121,30 +121,6 @@ private void InitializeLayers(UNetNoisePredictor<T>? predictor, StandardVAE<T>?
 
 
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        // Clone the ACTUAL predictor and VAE (mirrors InstaFlowModel/MultiDiffusionModel):
-        // passing only conditioner/seed rebuilt InitializeLayers' DEFAULT-sized (and lazily
-        // unresolved) UNet/VAE, so once the source resolved its lazy layers via a forward pass
-        // its GetParameters() returned a larger count than the clone could accept — SetParameters
-        // threw / Clone produced divergent output. Cloning the resolved predictor/VAE (+ same
-        // architecture/options/scheduler) makes the clone structurally identical to the source.
-        var clone = new SDXLLightningModel<T>(
-            architecture: Architecture,
-            options: Options as DiffusionModelOptions<T>,
-            scheduler: Scheduler,
-            predictor: (UNetNoisePredictor<T>)_predictor.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner,
-            seed: null);
-        if (!clone.TryShareParametersFrom(this)) clone.SetParameterChunks(GetParameterChunks());
-        return clone;
-    }
-
     /// <inheritdoc />
     public override ModelMetadata<T> GetModelMetadata()
     {
diff --git a/src/Diffusion/FastGeneration/SDXLTurboModel.cs b/src/Diffusion/FastGeneration/SDXLTurboModel.cs
index c16d9c1c51..94f42b033b 100644
--- a/src/Diffusion/FastGeneration/SDXLTurboModel.cs
+++ b/src/Diffusion/FastGeneration/SDXLTurboModel.cs
@@ -119,32 +119,6 @@ private void InitializeLayers(UNetNoisePredictor<T>? predictor, StandardVAE<T>?
 
 
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        // Delegate to the predictor/VAE's own Clone implementations, which
-        // resolve their internal lazy shape inference on BOTH source and clone
-        // before copying weights. Constructing a fresh SDXLTurboModel here and
-        // calling SetParameters(GetParameters()) re-hits the lazy-init bug:
-        // GetParameters() on the unresolved source under-counts the UNet's
-        // top-level time-embedding DenseLayer params, while the fresh clone's
-        // SetParameters checks parameters.Length against the resolved
-        // (arch-derived) ParameterCount and throws — surfaced as
-        // SDXLTurboModel_GetSetParameters_RoundTrips / Clone_CreatesIndependentCopy
-        // failures in the Unit-03 Diffusion/Encoding shard. Same fix pattern
-        // as ImprovedConsistencyModel.Clone (commit 7ab314796, PR #1555).
-        var predictorClone = (UNetNoisePredictor<T>)_predictor.Clone();
-        var vaeClone = (StandardVAE<T>)_vae.Clone();
-        return new SDXLTurboModel<T>(
-            predictor: predictorClone,
-            vae: vaeClone,
-            conditioner: _conditioner,
-            seed: null);
-    }
-
     /// <inheritdoc />
     public override ModelMetadata<T> GetModelMetadata()
     {
diff --git a/src/Diffusion/FastGeneration/SenseFlowModel.cs b/src/Diffusion/FastGeneration/SenseFlowModel.cs
index b64504b69d..22548db3e8 100644
--- a/src/Diffusion/FastGeneration/SenseFlowModel.cs
+++ b/src/Diffusion/FastGeneration/SenseFlowModel.cs
@@ -119,22 +119,6 @@ private void InitializeLayers(FluxDoubleStreamPredictor<T>? predictor, StandardV
 
 
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        // #1711: delegate to predictor/VAE Clone (probe-forward + copy); DiT LazyDense weights resolve
-        // via the FORWARD path so a model-level SetParameters(GetParameters()) clone re-RNG-initialized.
-        var clone = new SenseFlowModel<T>(
-            conditioner: _conditioner,
-            predictor: (FluxDoubleStreamPredictor<T>)_predictor.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            seed: null);
-        return clone;
-    }
-
     /// <inheritdoc />
     public override ModelMetadata<T> GetModelMetadata()
     {
diff --git a/src/Diffusion/FastGeneration/SiDDiTModel.cs b/src/Diffusion/FastGeneration/SiDDiTModel.cs
index d177dfa78c..e160194676 100644
--- a/src/Diffusion/FastGeneration/SiDDiTModel.cs
+++ b/src/Diffusion/FastGeneration/SiDDiTModel.cs
@@ -119,23 +119,6 @@ private void InitializeLayers(SiTPredictor<T>? predictor, StandardVAE<T>? vae, i
 
 
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        // #1711: delegate to the predictor's/VAE's own Clone (probe-forward + copy). The DiT/SiT
-        // LazyDense weights resolve via the FORWARD path, so the model-level
-        // SetParameters(GetParameters()) clone re-RNG-initialized them on first forward and diverged.
-        var clone = new SiDDiTModel<T>(
-            conditioner: _conditioner,
-            predictor: (SiTPredictor<T>)_predictor.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            seed: null);
-        return clone;
-    }
-
     /// <inheritdoc />
     public override ModelMetadata<T> GetModelMetadata()
     {
diff --git a/src/Diffusion/FastGeneration/SiDModel.cs b/src/Diffusion/FastGeneration/SiDModel.cs
index 5557c4492c..3645e0202a 100644
--- a/src/Diffusion/FastGeneration/SiDModel.cs
+++ b/src/Diffusion/FastGeneration/SiDModel.cs
@@ -118,30 +118,6 @@ private void InitializeLayers(UNetNoisePredictor<T>? predictor, StandardVAE<T>?
 
 
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        // Clone the ACTUAL predictor and VAE (mirrors InstaFlowModel/MultiDiffusionModel):
-        // passing only conditioner/seed rebuilt InitializeLayers' DEFAULT-sized (and lazily
-        // unresolved) UNet/VAE, so once the source resolved its lazy layers via a forward pass
-        // its GetParameters() returned a larger count than the clone could accept — SetParameters
-        // threw / Clone produced divergent output. Cloning the resolved predictor/VAE (+ same
-        // architecture/options/scheduler) makes the clone structurally identical to the source.
-        var clone = new SiDModel<T>(
-            architecture: Architecture,
-            options: Options as DiffusionModelOptions<T>,
-            scheduler: Scheduler,
-            predictor: (UNetNoisePredictor<T>)_predictor.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner,
-            seed: null);
-        if (!clone.TryShareParametersFrom(this)) clone.SetParameterChunks(GetParameterChunks());
-        return clone;
-    }
-
     /// <inheritdoc />
     public override ModelMetadata<T> GetModelMetadata()
     {
diff --git a/src/Diffusion/FastGeneration/SwiftBrushModel.cs b/src/Diffusion/FastGeneration/SwiftBrushModel.cs
index 176ae241a7..771c8a12a6 100644
--- a/src/Diffusion/FastGeneration/SwiftBrushModel.cs
+++ b/src/Diffusion/FastGeneration/SwiftBrushModel.cs
@@ -118,30 +118,6 @@ private void InitializeLayers(UNetNoisePredictor<T>? predictor, StandardVAE<T>?
 
 
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        // Clone the ACTUAL predictor and VAE (mirrors InstaFlowModel/MultiDiffusionModel):
-        // passing only conditioner/seed rebuilt InitializeLayers' DEFAULT-sized (and lazily
-        // unresolved) UNet/VAE, so once the source resolved its lazy layers via a forward pass
-        // its GetParameters() returned a larger count than the clone could accept — SetParameters
-        // threw / Clone produced divergent output. Cloning the resolved predictor/VAE (+ same
-        // architecture/options/scheduler) makes the clone structurally identical to the source.
-        var clone = new SwiftBrushModel<T>(
-            architecture: Architecture,
-            options: Options as DiffusionModelOptions<T>,
-            scheduler: Scheduler,
-            predictor: (UNetNoisePredictor<T>)_predictor.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner,
-            seed: null);
-        if (!clone.TryShareParametersFrom(this)) clone.SetParameterChunks(GetParameterChunks());
-        return clone;
-    }
-
     /// <inheritdoc />
     public override ModelMetadata<T> GetModelMetadata()
     {
diff --git a/src/Diffusion/FastGeneration/TCDModel.cs b/src/Diffusion/FastGeneration/TCDModel.cs
index b751f49e62..62fbb850b2 100644
--- a/src/Diffusion/FastGeneration/TCDModel.cs
+++ b/src/Diffusion/FastGeneration/TCDModel.cs
@@ -131,26 +131,6 @@ private void InitializeLayers(UNetNoisePredictor<T>? predictor, StandardVAE<T>?
 
 
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        // #1706: delegate to the sub-models' own Clone() (UNetNoisePredictor.Clone materializes the
-        // clone's lazy layers then copies weights). The previous fresh-construct + model-level
-        // TryShareParametersFrom path left the clone's U-Net lazy — the share saw zero-shape tensors,
-        // fell back to SetParameters, and the clone re-RNG-initialized on its first forward, diverging
-        // from the source (Clone_ShouldProduceIdenticalOutput; the seed was random too).
-        return new TCDModel<T>(
-            architecture: Architecture,
-            options: Options as DiffusionModelOptions<T>,
-            scheduler: Scheduler,
-            predictor: (UNetNoisePredictor<T>)_predictor.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner);
-    }
-
     /// <inheritdoc />
     public override ModelMetadata<T> GetModelMetadata()
     {
diff --git a/src/Diffusion/FastGeneration/TrainingEfficientLCM.cs b/src/Diffusion/FastGeneration/TrainingEfficientLCM.cs
index 6a0b5eff5b..20252da96f 100644
--- a/src/Diffusion/FastGeneration/TrainingEfficientLCM.cs
+++ b/src/Diffusion/FastGeneration/TrainingEfficientLCM.cs
@@ -161,28 +161,6 @@ private void InitializeLayers(UNetNoisePredictor<T>? predictor, StandardVAE<T>?
 
 
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        // Clone the ACTUAL predictor/VAE (see InstaFlowModel/MultiDiffusionModel): passing only
-        // conditioner/loraRank/seed rebuilt InitializeLayers' DEFAULT-sized, lazily-unresolved
-        // sub-models, so once the source resolved its lazy layers via a forward pass the trainable-layer
-        // shapes no longer lined up 1:1 and Clone diverged. Cloning the resolved predictor/VAE (+ same
-        // architecture/options/scheduler) makes the clone structurally identical.
-        var clone = new TrainingEfficientLCM<T>(
-            architecture: Architecture,
-            options: Options as DiffusionModelOptions<T>,
-            scheduler: Scheduler,
-            predictor: (UNetNoisePredictor<T>)_predictor.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner, loraRank: _loraRank, seed: null);
-        if (!clone.TryShareParametersFrom(this)) clone.SetParameterChunks(GetParameterChunks());
-        return clone;
-    }
-
     /// <inheritdoc />
     public override ModelMetadata<T> GetModelMetadata()
     {
diff --git a/src/Diffusion/FastGeneration/TransfusionModel.cs b/src/Diffusion/FastGeneration/TransfusionModel.cs
index 496b53fab0..2bb511af8e 100644
--- a/src/Diffusion/FastGeneration/TransfusionModel.cs
+++ b/src/Diffusion/FastGeneration/TransfusionModel.cs
@@ -118,29 +118,6 @@ private void InitializeLayers(SiTPredictor<T>? predictor, StandardVAE<T>? vae, i
 
 
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        // Fast path: O(1) copy-on-write share when the default clone is structurally identical
-        // (the common foundation-scale case the COW lever targets — no re-materialization/OOM).
-        var clone = new TransfusionModel<T>(conditioner: _conditioner, seed: null);
-        if (clone.TryShareParametersFrom(this)) return clone;
-        // Structure mismatch ⇒ custom architecture/predictor/VAE the default clone can't reproduce;
-        // rebuild faithfully from this instance's configuration so the clone is observationally
-        // identical instead of throwing on a parameter-count mismatch.
-        return new TransfusionModel<T>(
-            architecture: Architecture,
-            options: (DiffusionModelOptions<T>)Options,
-            scheduler: Scheduler,
-            predictor: (SiTPredictor<T>)_predictor.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner,
-            seed: null);
-    }
-
     /// <inheritdoc />
     public override ModelMetadata<T> GetModelMetadata()
     {
diff --git a/src/Diffusion/ImageEditing/AnyEditModel.cs b/src/Diffusion/ImageEditing/AnyEditModel.cs
index 9e16b19944..a1e726f3ac 100644
--- a/src/Diffusion/ImageEditing/AnyEditModel.cs
+++ b/src/Diffusion/ImageEditing/AnyEditModel.cs
@@ -108,30 +108,6 @@ private void InitializeLayers(UNetNoisePredictor<T>? predictor, StandardVAE<T>?
 
 
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        // Clone the ACTUAL predictor and VAE (mirrors InstaFlowModel/MultiDiffusionModel):
-        // passing only conditioner/seed rebuilt InitializeLayers' DEFAULT-sized (and lazily
-        // unresolved) UNet/VAE, so once the source resolved its lazy layers via a forward pass
-        // its GetParameters() returned a larger count than the clone could accept — SetParameters
-        // threw / Clone produced divergent output. Cloning the resolved predictor/VAE (+ same
-        // architecture/options/scheduler) makes the clone structurally identical to the source.
-        var clone = new AnyEditModel<T>(
-            architecture: Architecture,
-            options: Options as DiffusionModelOptions<T>,
-            scheduler: Scheduler,
-            predictor: (UNetNoisePredictor<T>)_predictor.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner,
-            seed: null);
-        if (!clone.TryShareParametersFrom(this)) clone.SetParameterChunks(GetParameterChunks());
-        return clone;
-    }
-
     /// <inheritdoc />
     public override ModelMetadata<T> GetModelMetadata()
     {
diff --git a/src/Diffusion/ImageEditing/BlendedDiffusionModel.cs b/src/Diffusion/ImageEditing/BlendedDiffusionModel.cs
index 6bb8e0f672..fb6c6a0f4e 100644
--- a/src/Diffusion/ImageEditing/BlendedDiffusionModel.cs
+++ b/src/Diffusion/ImageEditing/BlendedDiffusionModel.cs
@@ -267,24 +267,6 @@ public override Tensor<T> ImageToImage(
 
     #region ICloneable Implementation
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy()
-    {
-        return Clone();
-    }
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        var clonedUnet = (UNetNoisePredictor<T>)_unet.Clone();
-        var clonedVae = (StandardVAE<T>)_vae.Clone();
-
-        return new BlendedDiffusionModel<T>(
-            unet: clonedUnet,
-            vae: clonedVae,
-            conditioner: _conditioner);
-    }
-
     #endregion
 
     #region Metadata
diff --git a/src/Diffusion/ImageEditing/BrushEditModel.cs b/src/Diffusion/ImageEditing/BrushEditModel.cs
index 1e63140d68..46535a1250 100644
--- a/src/Diffusion/ImageEditing/BrushEditModel.cs
+++ b/src/Diffusion/ImageEditing/BrushEditModel.cs
@@ -108,30 +108,6 @@ private void InitializeLayers(UNetNoisePredictor<T>? predictor, StandardVAE<T>?
 
 
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        // Clone the ACTUAL predictor and VAE (mirrors InstaFlowModel/MultiDiffusionModel):
-        // passing only conditioner/seed rebuilt InitializeLayers' DEFAULT-sized (and lazily
-        // unresolved) UNet/VAE, so once the source resolved its lazy layers via a forward pass
-        // its GetParameters() returned a larger count than the clone could accept — SetParameters
-        // threw / Clone produced divergent output. Cloning the resolved predictor/VAE (+ same
-        // architecture/options/scheduler) makes the clone structurally identical to the source.
-        var clone = new BrushEditModel<T>(
-            architecture: Architecture,
-            options: Options as DiffusionModelOptions<T>,
-            scheduler: Scheduler,
-            predictor: (UNetNoisePredictor<T>)_predictor.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner,
-            seed: null);
-        if (!clone.TryShareParametersFrom(this)) clone.SetParameterChunks(GetParameterChunks());
-        return clone;
-    }
-
     /// <inheritdoc />
     public override ModelMetadata<T> GetModelMetadata()
     {
diff --git a/src/Diffusion/ImageEditing/BrushNetModel.cs b/src/Diffusion/ImageEditing/BrushNetModel.cs
index 2bab276f15..8835b4507d 100644
--- a/src/Diffusion/ImageEditing/BrushNetModel.cs
+++ b/src/Diffusion/ImageEditing/BrushNetModel.cs
@@ -110,29 +110,6 @@ private void InitializeLayers(UNetNoisePredictor<T>? predictor, StandardVAE<T>?
 
 
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        // Clone the ACTUAL predictor/VAE (see InstaFlowModel/MultiDiffusionModel): passing only
-        // conditioner/seed rebuilt InitializeLayers' DEFAULT-sized, lazily-unresolved sub-models, so once
-        // the source resolved its lazy layers via a forward pass the trainable-layer shapes no longer
-        // lined up 1:1 and Clone diverged. Cloning the resolved predictor/VAE (+ same architecture/
-        // options/scheduler) makes the clone structurally identical.
-        var clone = new BrushNetModel<T>(
-            architecture: Architecture,
-            options: Options as DiffusionModelOptions<T>,
-            scheduler: Scheduler,
-            predictor: (UNetNoisePredictor<T>)_predictor.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner,
-            seed: null);
-        if (!clone.TryShareParametersFrom(this)) clone.SetParameterChunks(GetParameterChunks());
-        return clone;
-    }
-
     /// <inheritdoc />
     public override ModelMetadata<T> GetModelMetadata()
     {
diff --git a/src/Diffusion/ImageEditing/BrushNetXModel.cs b/src/Diffusion/ImageEditing/BrushNetXModel.cs
index ee9bbcc983..142aa43bd9 100644
--- a/src/Diffusion/ImageEditing/BrushNetXModel.cs
+++ b/src/Diffusion/ImageEditing/BrushNetXModel.cs
@@ -105,29 +105,6 @@ private void InitializeLayers(UNetNoisePredictor<T>? predictor, StandardVAE<T>?
 
 
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        // Clone the ACTUAL predictor/VAE (see InstaFlowModel/MultiDiffusionModel): passing only
-        // conditioner/seed rebuilt InitializeLayers' DEFAULT-sized, lazily-unresolved sub-models, so once
-        // the source resolved its lazy layers via a forward pass the trainable-layer shapes no longer
-        // lined up 1:1 and Clone diverged. Cloning the resolved predictor/VAE (+ same architecture/
-        // options/scheduler) makes the clone structurally identical.
-        var clone = new BrushNetXModel<T>(
-            architecture: Architecture,
-            options: Options as DiffusionModelOptions<T>,
-            scheduler: Scheduler,
-            predictor: (UNetNoisePredictor<T>)_predictor.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner,
-            seed: null);
-        if (!clone.TryShareParametersFrom(this)) clone.SetParameterChunks(GetParameterChunks());
-        return clone;
-    }
-
     /// <inheritdoc />
     public override ModelMetadata<T> GetModelMetadata()
     {
diff --git a/src/Diffusion/ImageEditing/CycleGANTurboModel.cs b/src/Diffusion/ImageEditing/CycleGANTurboModel.cs
index b5fae82652..d40a87bf8b 100644
--- a/src/Diffusion/ImageEditing/CycleGANTurboModel.cs
+++ b/src/Diffusion/ImageEditing/CycleGANTurboModel.cs
@@ -111,29 +111,6 @@ private void InitializeLayers(UNetNoisePredictor<T>? predictor, StandardVAE<T>?
 
 
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        // Clone the ACTUAL predictor/VAE (see InstaFlowModel/MultiDiffusionModel): passing only
-        // conditioner/seed rebuilt InitializeLayers' DEFAULT-sized, lazily-unresolved sub-models, so once
-        // the source resolved its lazy layers via a forward pass the trainable-layer shapes no longer
-        // lined up 1:1 and Clone diverged. Cloning the resolved predictor/VAE (+ same architecture/
-        // options/scheduler) makes the clone structurally identical.
-        var clone = new CycleGANTurboModel<T>(
-            architecture: Architecture,
-            options: Options as DiffusionModelOptions<T>,
-            scheduler: Scheduler,
-            predictor: (UNetNoisePredictor<T>)_predictor.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner,
-            seed: null);
-        if (!clone.TryShareParametersFrom(this)) clone.SetParameterChunks(GetParameterChunks());
-        return clone;
-    }
-
     /// <inheritdoc />
     public override ModelMetadata<T> GetModelMetadata()
     {
diff --git a/src/Diffusion/ImageEditing/DiffEditModel.cs b/src/Diffusion/ImageEditing/DiffEditModel.cs
index 7de3c62fa7..a58479311a 100644
--- a/src/Diffusion/ImageEditing/DiffEditModel.cs
+++ b/src/Diffusion/ImageEditing/DiffEditModel.cs
@@ -267,30 +267,6 @@ public override Tensor<T> ImageToImage(
 
     #region ICloneable Implementation
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy()
-    {
-        return Clone();
-    }
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        // Delegate to sub-Clones — same lazy-init fix pattern as
-        // SDXLTurboModel / RealESRGANModel / EDiffIModel / DDPMModel.
-        // Preserve outer configuration (architecture / options / scheduler) so
-        // custom diffusion settings round-trip through Clone (CodeRabbit PR #1562).
-        var clonedUnet = (UNetNoisePredictor<T>)_unet.Clone();
-        var clonedVae = (StandardVAE<T>)_vae.Clone();
-        return new DiffEditModel<T>(
-            architecture: Architecture,
-            options: (DiffusionModelOptions<T>)GetOptions(),
-            scheduler: Scheduler,
-            unet: clonedUnet,
-            vae: clonedVae,
-            conditioner: _conditioner);
-    }
-
     #endregion
 
     #region Metadata
diff --git a/src/Diffusion/ImageEditing/FlowEditModel.cs b/src/Diffusion/ImageEditing/FlowEditModel.cs
index 6a77d87997..57411f9c21 100644
--- a/src/Diffusion/ImageEditing/FlowEditModel.cs
+++ b/src/Diffusion/ImageEditing/FlowEditModel.cs
@@ -111,29 +111,6 @@ private void InitializeLayers(FluxDoubleStreamPredictor<T>? predictor, StandardV
 
 
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        // Fast path: O(1) copy-on-write share when the default clone is structurally identical
-        // (the common foundation-scale case the COW lever targets — no re-materialization/OOM).
-        var clone = new FlowEditModel<T>(conditioner: _conditioner, seed: null);
-        if (clone.TryShareParametersFrom(this)) return clone;
-        // Structure mismatch ⇒ custom architecture/predictor/VAE the default clone can't reproduce;
-        // rebuild faithfully from this instance's configuration so the clone is observationally
-        // identical instead of throwing on a parameter-count mismatch.
-        return new FlowEditModel<T>(
-            architecture: Architecture,
-            options: (DiffusionModelOptions<T>)Options,
-            scheduler: Scheduler,
-            predictor: (FluxDoubleStreamPredictor<T>)_predictor.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner,
-            seed: null);
-    }
-
     /// <inheritdoc />
     public override ModelMetadata<T> GetModelMetadata()
     {
diff --git a/src/Diffusion/ImageEditing/FluxInpaintingModel.cs b/src/Diffusion/ImageEditing/FluxInpaintingModel.cs
index 8c9f449a7a..3cc5790799 100644
--- a/src/Diffusion/ImageEditing/FluxInpaintingModel.cs
+++ b/src/Diffusion/ImageEditing/FluxInpaintingModel.cs
@@ -114,27 +114,6 @@ private void InitializeLayers(FluxDoubleStreamPredictor<T>? predictor, StandardV
 
 
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        // Clone the resolved predictor/VAE via their own Clone() (+ same architecture/options/scheduler).
-        // The sub-model Clone()s already deep-copy the ~12B FLUX-scale weights, so no field-by-field
-        // SetParameters(GetParameters()) is needed — which also avoids the int-bounded flat Vector<T>
-        // round-trip ("Array dimensions exceeded" / OOM) at that scale.
-        var clone = new FluxInpaintingModel<T>(
-            architecture: Architecture,
-            options: Options as DiffusionModelOptions<T>,
-            scheduler: Scheduler,
-            predictor: (FluxDoubleStreamPredictor<T>)_predictor.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner,
-            seed: null); // predictor+vae are cloned & passed, so InitializeLayers ignores seed — do not advance the source RNG
-        return clone;
-    }
-
     /// <inheritdoc />
     public override ModelMetadata<T> GetModelMetadata()
     {
diff --git a/src/Diffusion/ImageEditing/FreeInpaintModel.cs b/src/Diffusion/ImageEditing/FreeInpaintModel.cs
index 9b9c913f58..4ced42ce5c 100644
--- a/src/Diffusion/ImageEditing/FreeInpaintModel.cs
+++ b/src/Diffusion/ImageEditing/FreeInpaintModel.cs
@@ -105,29 +105,6 @@ private void InitializeLayers(UNetNoisePredictor<T>? predictor, StandardVAE<T>?
 
 
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        // Fast path: O(1) copy-on-write share when the default clone is structurally identical
-        // (the common foundation-scale case the COW lever targets — no re-materialization/OOM).
-        var clone = new FreeInpaintModel<T>(conditioner: _conditioner, seed: null);
-        if (clone.TryShareParametersFrom(this)) return clone;
-        // Structure mismatch ⇒ custom architecture/predictor/VAE the default clone can't reproduce;
-        // rebuild faithfully from this instance's configuration so the clone is observationally
-        // identical instead of throwing on a parameter-count mismatch.
-        return new FreeInpaintModel<T>(
-            architecture: Architecture,
-            options: (DiffusionModelOptions<T>)Options,
-            scheduler: Scheduler,
-            predictor: (UNetNoisePredictor<T>)_predictor.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner,
-            seed: null);
-    }
-
     /// <inheritdoc />
     public override ModelMetadata<T> GetModelMetadata()
     {
diff --git a/src/Diffusion/ImageEditing/HDPainterModel.cs b/src/Diffusion/ImageEditing/HDPainterModel.cs
index bd50103682..dad5027083 100644
--- a/src/Diffusion/ImageEditing/HDPainterModel.cs
+++ b/src/Diffusion/ImageEditing/HDPainterModel.cs
@@ -110,29 +110,6 @@ private void InitializeLayers(UNetNoisePredictor<T>? predictor, StandardVAE<T>?
 
 
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        // Fast path: O(1) copy-on-write share when the default clone is structurally identical
-        // (the common foundation-scale case the COW lever targets — no re-materialization/OOM).
-        var clone = new HDPainterModel<T>(conditioner: _conditioner, seed: null);
-        if (clone.TryShareParametersFrom(this)) return clone;
-        // Structure mismatch ⇒ custom architecture/predictor/VAE the default clone can't reproduce;
-        // rebuild faithfully from this instance's configuration so the clone is observationally
-        // identical instead of throwing on a parameter-count mismatch.
-        return new HDPainterModel<T>(
-            architecture: Architecture,
-            options: (DiffusionModelOptions<T>)Options,
-            scheduler: Scheduler,
-            predictor: (UNetNoisePredictor<T>)_predictor.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner,
-            seed: null);
-    }
-
     /// <inheritdoc />
     public override ModelMetadata<T> GetModelMetadata()
     {
diff --git a/src/Diffusion/ImageEditing/ICEditModel.cs b/src/Diffusion/ImageEditing/ICEditModel.cs
index 839b2e79ad..d534442e55 100644
--- a/src/Diffusion/ImageEditing/ICEditModel.cs
+++ b/src/Diffusion/ImageEditing/ICEditModel.cs
@@ -108,28 +108,6 @@ private void InitializeLayers(SiTPredictor<T>? predictor, StandardVAE<T>? vae, i
 
 
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        // Clone the resolved predictor/VAE via their own Clone(), which correctly handle the DiT/SiT
-        // LazyDense weights (thread the seed + probe-forward materialize + copy). A naive new-predictor +
-        // SetParameters(GetParameters()) misses lazy weights that only resolve on the forward path, so the
-        // clone would re-RNG-initialize and diverge (the #1711 trap Clone_ShouldProduceIdenticalOutput
-        // caught). Passing architecture/options/scheduler keeps the clone structurally identical; the
-        // sub-model Clone()s make a field-by-field copy unnecessary (and dodge the int-bounded flat Vector).
-        return new ICEditModel<T>(
-            architecture: Architecture,
-            options: Options as DiffusionModelOptions<T>,
-            scheduler: Scheduler,
-            predictor: (SiTPredictor<T>)_predictor.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner,
-            seed: null); // predictor+vae are cloned & passed, so InitializeLayers ignores seed — do not advance the source RNG
-    }
-
     /// <inheritdoc />
     public override ModelMetadata<T> GetModelMetadata()
     {
diff --git a/src/Diffusion/ImageEditing/ImagicModel.cs b/src/Diffusion/ImageEditing/ImagicModel.cs
index 3f7ed437eb..2d1932961c 100644
--- a/src/Diffusion/ImageEditing/ImagicModel.cs
+++ b/src/Diffusion/ImageEditing/ImagicModel.cs
@@ -266,28 +266,6 @@ public override Tensor<T> ImageToImage(
 
     #region ICloneable Implementation
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy()
-    {
-        return Clone();
-    }
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        var clonedOptions = GetOptions() is DiffusionModelOptions<T> options
-            ? new DiffusionModelOptions<T>(options)
-            : null;
-
-        return new ImagicModel<T>(
-            architecture: Architecture,
-            options: clonedOptions,
-            scheduler: new DDIMScheduler<T>(Scheduler.Config),
-            unet: (UNetNoisePredictor<T>)_unet.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner);
-    }
-
     #endregion
 
     #region Metadata
diff --git a/src/Diffusion/ImageEditing/InstructPix2PixModel.cs b/src/Diffusion/ImageEditing/InstructPix2PixModel.cs
index 83612ff344..7f207b8556 100644
--- a/src/Diffusion/ImageEditing/InstructPix2PixModel.cs
+++ b/src/Diffusion/ImageEditing/InstructPix2PixModel.cs
@@ -206,15 +206,6 @@ public override Tensor<T> GenerateFromText(string prompt, string? negativePrompt
 
     #region ICloneable Implementation
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-                        return new InstructPix2PixModel<T>(unet: (UNetNoisePredictor<T>)_unet.Clone(), vae: (StandardVAE<T>)_vae.Clone(), conditioner: _conditioner);
-    }
-
     #endregion
 
     #region Metadata
diff --git a/src/Diffusion/ImageEditing/LEDITSPPModel.cs b/src/Diffusion/ImageEditing/LEDITSPPModel.cs
index 81f8f86a39..be215cd8b8 100644
--- a/src/Diffusion/ImageEditing/LEDITSPPModel.cs
+++ b/src/Diffusion/ImageEditing/LEDITSPPModel.cs
@@ -267,27 +267,6 @@ public override Tensor<T> ImageToImage(
 
     #region ICloneable Implementation
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy()
-    {
-        return Clone();
-    }
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        // Lazy-preserving Clone: delegate weights to the submodules' own Clone(), and carry through the
-        // caller-provided runtime configuration (architecture / options / scheduler) so the clone is a
-        // faithful copy rather than a defaults-rebuild.
-        return new LEDITSPPModel<T>(
-            architecture: Architecture,
-            options: Options as DiffusionModelOptions<T>,
-            scheduler: Scheduler,
-            unet: (UNetNoisePredictor<T>)_unet.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner);
-    }
-
     #endregion
 
     #region Metadata
diff --git a/src/Diffusion/ImageEditing/MagicBrushModel.cs b/src/Diffusion/ImageEditing/MagicBrushModel.cs
index 9549fc9f64..45e028d564 100644
--- a/src/Diffusion/ImageEditing/MagicBrushModel.cs
+++ b/src/Diffusion/ImageEditing/MagicBrushModel.cs
@@ -266,24 +266,6 @@ public override Tensor<T> ImageToImage(
 
     #region ICloneable Implementation
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy()
-    {
-        return Clone();
-    }
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        return new MagicBrushModel<T>(
-            architecture: Architecture,
-            options: Options as DiffusionModelOptions<T>,
-            scheduler: Scheduler,
-            unet: (UNetNoisePredictor<T>)_unet.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner);
-    }
-
     #endregion
 
     #region Metadata
diff --git a/src/Diffusion/ImageEditing/NullTextInversionModel.cs b/src/Diffusion/ImageEditing/NullTextInversionModel.cs
index 55b3373a32..29214d2d0b 100644
--- a/src/Diffusion/ImageEditing/NullTextInversionModel.cs
+++ b/src/Diffusion/ImageEditing/NullTextInversionModel.cs
@@ -275,22 +275,6 @@ public override Tensor<T> ImageToImage(
 
     #region ICloneable Implementation
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy()
-    {
-        return Clone();
-    }
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        EnsureInitialized();
-                        return new NullTextInversionModel<T>(
-            unet: (UNetNoisePredictor<T>)_unet.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner);
-    }
-
     #endregion
 
     #region Metadata
diff --git a/src/Diffusion/ImageEditing/OmniGen2Model.cs b/src/Diffusion/ImageEditing/OmniGen2Model.cs
index 09c45a043a..f840a8a7df 100644
--- a/src/Diffusion/ImageEditing/OmniGen2Model.cs
+++ b/src/Diffusion/ImageEditing/OmniGen2Model.cs
@@ -113,23 +113,6 @@ private void InitializeLayers(SiTPredictor<T>? predictor, StandardVAE<T>? vae, i
 
 
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        // Delegate to the predictor's and VAE's own Clone(), which reconstruct from their
-        // actual config fields and preserve materialized weights. The previous form rebuilt a
-        // DEFAULT-scale model (SiTPredictor 1152/28) and SetParameters(GetParameters()) onto it,
-        // which both ignored a caller-injected variant and threw on the resulting parameter-count
-        // mismatch for any non-default predictor.
-        return new OmniGen2Model<T>(
-            predictor: (SiTPredictor<T>)_predictor.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner);
-    }
-
     /// <inheritdoc />
     public override ModelMetadata<T> GetModelMetadata()
     {
diff --git a/src/Diffusion/ImageEditing/PaintByExampleModel.cs b/src/Diffusion/ImageEditing/PaintByExampleModel.cs
index 11987c21b9..ac2bd038e3 100644
--- a/src/Diffusion/ImageEditing/PaintByExampleModel.cs
+++ b/src/Diffusion/ImageEditing/PaintByExampleModel.cs
@@ -279,21 +279,6 @@ public override Tensor<T> ImageToImage(
 
     #region ICloneable Implementation
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy()
-    {
-        return Clone();
-    }
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-                        return new PaintByExampleModel<T>(
-            unet: (UNetNoisePredictor<T>)_unet.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner);
-    }
-
     #endregion
 
     #region Metadata
diff --git a/src/Diffusion/ImageEditing/Pix2PixZeroModel.cs b/src/Diffusion/ImageEditing/Pix2PixZeroModel.cs
index 4be4f59791..d0122ad569 100644
--- a/src/Diffusion/ImageEditing/Pix2PixZeroModel.cs
+++ b/src/Diffusion/ImageEditing/Pix2PixZeroModel.cs
@@ -109,22 +109,6 @@ private void InitializeLayers(UNetNoisePredictor<T>? predictor, StandardVAE<T>?
 
 
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        // Lazy-preserving Clone (recipe from #1596): delegate to the predictor's and VAE's own Clone()
-        // (preserves materialized weights) instead of rebuilding a default-scale model and
-        // SetParameters(GetParameters()), which mismatches an injected non-default variant and
-        // re-randomizes the clone's unmaterialized lazy weights on its first forward.
-        return new Pix2PixZeroModel<T>(
-            predictor: (UNetNoisePredictor<T>)_predictor.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner);
-    }
-
     /// <inheritdoc />
     public override ModelMetadata<T> GetModelMetadata()
     {
diff --git a/src/Diffusion/ImageEditing/PowerPaintModel.cs b/src/Diffusion/ImageEditing/PowerPaintModel.cs
index 90a6da2b2b..c2d324bcb7 100644
--- a/src/Diffusion/ImageEditing/PowerPaintModel.cs
+++ b/src/Diffusion/ImageEditing/PowerPaintModel.cs
@@ -112,29 +112,6 @@ private void InitializeLayers(UNetNoisePredictor<T>? predictor, StandardVAE<T>?
 
 
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        // Clone the ACTUAL predictor/VAE (see InstaFlowModel/MultiDiffusionModel): passing only
-        // conditioner/seed rebuilt InitializeLayers' DEFAULT-sized, lazily-unresolved sub-models, so once
-        // the source resolved its lazy layers via a forward pass the trainable-layer shapes no longer
-        // lined up 1:1 and Clone diverged. Cloning the resolved predictor/VAE (+ same architecture/
-        // options/scheduler) makes the clone structurally identical.
-        var clone = new PowerPaintModel<T>(
-            architecture: Architecture,
-            options: Options as DiffusionModelOptions<T>,
-            scheduler: Scheduler,
-            predictor: (UNetNoisePredictor<T>)_predictor.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner,
-            seed: null);
-        if (!clone.TryShareParametersFrom(this)) clone.SetParameterChunks(GetParameterChunks());
-        return clone;
-    }
-
     /// <inheritdoc />
     public override ModelMetadata<T> GetModelMetadata()
     {
diff --git a/src/Diffusion/ImageEditing/PromptToPromptModel.cs b/src/Diffusion/ImageEditing/PromptToPromptModel.cs
index 37bab6ad95..bf9bdb4d41 100644
--- a/src/Diffusion/ImageEditing/PromptToPromptModel.cs
+++ b/src/Diffusion/ImageEditing/PromptToPromptModel.cs
@@ -195,21 +195,6 @@ public override Tensor<T> GenerateFromText(string prompt, string? negativePrompt
 
     #region ICloneable Implementation
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        return new PromptToPromptModel<T>(
-            architecture: Architecture,
-            options: Options as DiffusionModelOptions<T>,
-            scheduler: Scheduler,
-            unet: (UNetNoisePredictor<T>)_unet.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner);
-    }
-
     #endregion
 
     #region Metadata
diff --git a/src/Diffusion/ImageEditing/RADModel.cs b/src/Diffusion/ImageEditing/RADModel.cs
index 21bb5e3fd7..b03fbd53bd 100644
--- a/src/Diffusion/ImageEditing/RADModel.cs
+++ b/src/Diffusion/ImageEditing/RADModel.cs
@@ -106,29 +106,6 @@ private void InitializeLayers(UNetNoisePredictor<T>? predictor, StandardVAE<T>?
 
 
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        // Clone the ACTUAL predictor/VAE (see InstaFlowModel/MultiDiffusionModel): passing only
-        // conditioner/seed rebuilt InitializeLayers' DEFAULT-sized, lazily-unresolved sub-models, so once
-        // the source resolved its lazy layers via a forward pass the trainable-layer shapes no longer
-        // lined up 1:1 and Clone diverged. Cloning the resolved predictor/VAE (+ same architecture/
-        // options/scheduler) makes the clone structurally identical.
-        var clone = new RADModel<T>(
-            architecture: Architecture,
-            options: Options as DiffusionModelOptions<T>,
-            scheduler: Scheduler,
-            predictor: (UNetNoisePredictor<T>)_predictor.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner,
-            seed: null);
-        if (!clone.TryShareParametersFrom(this)) clone.SetParameterChunks(GetParameterChunks());
-        return clone;
-    }
-
     /// <inheritdoc />
     public override ModelMetadata<T> GetModelMetadata()
     {
diff --git a/src/Diffusion/ImageEditing/ReplaceAnythingModel.cs b/src/Diffusion/ImageEditing/ReplaceAnythingModel.cs
index 4a9ca8a720..5eba7dfcdd 100644
--- a/src/Diffusion/ImageEditing/ReplaceAnythingModel.cs
+++ b/src/Diffusion/ImageEditing/ReplaceAnythingModel.cs
@@ -107,29 +107,6 @@ private void InitializeLayers(UNetNoisePredictor<T>? predictor, StandardVAE<T>?
 
 
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        // Clone the ACTUAL predictor/VAE (see InstaFlowModel/MultiDiffusionModel): passing only
-        // conditioner/seed rebuilt InitializeLayers' DEFAULT-sized, lazily-unresolved sub-models, so once
-        // the source resolved its lazy layers via a forward pass the trainable-layer shapes no longer
-        // lined up 1:1 and Clone diverged. Cloning the resolved predictor/VAE (+ same architecture/
-        // options/scheduler) makes the clone structurally identical.
-        var clone = new ReplaceAnythingModel<T>(
-            architecture: Architecture,
-            options: Options as DiffusionModelOptions<T>,
-            scheduler: Scheduler,
-            predictor: (UNetNoisePredictor<T>)_predictor.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner,
-            seed: null);
-        if (!clone.TryShareParametersFrom(this)) clone.SetParameterChunks(GetParameterChunks());
-        return clone;
-    }
-
     /// <inheritdoc />
     public override ModelMetadata<T> GetModelMetadata()
     {
diff --git a/src/Diffusion/ImageEditing/SD3InpaintingModel.cs b/src/Diffusion/ImageEditing/SD3InpaintingModel.cs
index 11584e74f3..00a31c37f3 100644
--- a/src/Diffusion/ImageEditing/SD3InpaintingModel.cs
+++ b/src/Diffusion/ImageEditing/SD3InpaintingModel.cs
@@ -111,29 +111,6 @@ private void InitializeLayers(MMDiTXNoisePredictor<T>? predictor, StandardVAE<T>
 
 
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        // Fast path: O(1) copy-on-write share when the default clone is structurally identical
-        // (the common foundation-scale case the COW lever targets — no re-materialization/OOM).
-        var clone = new SD3InpaintingModel<T>(conditioner: _conditioner, seed: null);
-        if (clone.TryShareParametersFrom(this)) return clone;
-        // Structure mismatch ⇒ custom architecture/predictor/VAE the default clone can't reproduce;
-        // rebuild faithfully from this instance's configuration so the clone is observationally
-        // identical instead of throwing on a parameter-count mismatch.
-        return new SD3InpaintingModel<T>(
-            architecture: Architecture,
-            options: (DiffusionModelOptions<T>)Options,
-            scheduler: Scheduler,
-            predictor: (MMDiTXNoisePredictor<T>)_predictor.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner,
-            seed: null);
-    }
-
     /// <inheritdoc />
     public override ModelMetadata<T> GetModelMetadata()
     {
diff --git a/src/Diffusion/ImageEditing/SDEditModel.cs b/src/Diffusion/ImageEditing/SDEditModel.cs
index 3f6311f0f1..754effe070 100644
--- a/src/Diffusion/ImageEditing/SDEditModel.cs
+++ b/src/Diffusion/ImageEditing/SDEditModel.cs
@@ -268,21 +268,6 @@ public override Tensor<T> ImageToImage(
 
     #region ICloneable Implementation
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy()
-    {
-        return Clone();
-    }
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-                        return new SDEditModel<T>(
-            unet: (UNetNoisePredictor<T>)_unet.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner);
-    }
-
     #endregion
 
     #region Metadata
diff --git a/src/Diffusion/ImageEditing/SDXLInpaintingModel.cs b/src/Diffusion/ImageEditing/SDXLInpaintingModel.cs
index e3066b859a..fbd43736fa 100644
--- a/src/Diffusion/ImageEditing/SDXLInpaintingModel.cs
+++ b/src/Diffusion/ImageEditing/SDXLInpaintingModel.cs
@@ -109,39 +109,6 @@ private void InitializeLayers(UNetNoisePredictor<T>? predictor, StandardVAE<T>?
 
 
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        // Clone the predictor and VAE structurally so the clone respects the
-        // SOURCE instance's UNet/VAE config (baseChannels, multipliers,
-        // numResBlocks, etc.) rather than rebuilding them with the
-        // SDXLInpainting constructor's paper-scale defaults. The previous
-        // implementation passed no predictor/vae to the ctor → ctor built
-        // 320-baseChannels defaults → SetParameters(GetParameters()) then
-        // tried to bridge potentially mismatched parameter counts when
-        // callers had constructed the model with a smaller custom UNet
-        // (e.g. test scaffolds that scale down to baseChannels=64 for
-        // tractable CI runtime — same pattern as FlashDiffusion /
-        // SyncDiffusion / SpotDiffusion). Both paths now use the source's
-        // already-built components' Clone(), which preserves shape and
-        // copies parameters atomically.
-        var predictorClone = (UNetNoisePredictor<T>)_predictor.Clone();
-        var vaeClone = (StandardVAE<T>)_vae.Clone();
-        var options = GetOptions() is DiffusionModelOptions<T> diffusionOptions
-            ? new DiffusionModelOptions<T>(diffusionOptions)
-            : null;
-        return new SDXLInpaintingModel<T>(
-            architecture: Architecture,
-            options: options,
-            predictor: predictorClone,
-            vae: vaeClone,
-            conditioner: _conditioner,
-            seed: null);
-    }
-
     /// <inheritdoc />
     public override ModelMetadata<T> GetModelMetadata()
     {
diff --git a/src/Diffusion/ImageEditing/SeedEdit3Model.cs b/src/Diffusion/ImageEditing/SeedEdit3Model.cs
index 80900dcf4e..eca8b24e30 100644
--- a/src/Diffusion/ImageEditing/SeedEdit3Model.cs
+++ b/src/Diffusion/ImageEditing/SeedEdit3Model.cs
@@ -105,25 +105,6 @@ private void InitializeLayers(SiTPredictor<T>? predictor, StandardVAE<T>? vae, i
 
 
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        // Delegate to the predictor/VAE's own Clone implementations, which resolve
-        // their internal lazy shapes on BOTH source and clone before copying weights.
-        // Re-constructing a fresh model with a new seed and calling
-        // SetParameters(GetParameters()) re-hits the lazy-init bug: GetParameters() on a
-        // still-unresolved source under-counts the lazy DenseLayer params and the fresh
-        // model re-resolves (with a different seed) on its first Predict, diverging from
-        // the original. Mirrors ImprovedConsistencyModel / RealESRGAN (PR #1555 / #1562).
-        return new SeedEdit3Model<T>(
-            predictor: (SiTPredictor<T>)_predictor.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner);
-    }
-
     /// <inheritdoc />
     public override ModelMetadata<T> GetModelMetadata()
     {
diff --git a/src/Diffusion/ImageEditing/Step1XEditModel.cs b/src/Diffusion/ImageEditing/Step1XEditModel.cs
index 97346e7299..217015648d 100644
--- a/src/Diffusion/ImageEditing/Step1XEditModel.cs
+++ b/src/Diffusion/ImageEditing/Step1XEditModel.cs
@@ -124,29 +124,6 @@ private void InitializeLayers(SiTPredictor<T>? predictor, StandardVAE<T>? vae, i
 
 
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        // Fast path: O(1) copy-on-write share when the default clone is structurally identical
-        // (the common foundation-scale case the COW lever targets — no re-materialization/OOM).
-        var clone = new Step1XEditModel<T>(conditioner: _conditioner, seed: null);
-        if (clone.TryShareParametersFrom(this)) return clone;
-        // Structure mismatch ⇒ custom architecture/predictor/VAE the default clone can't reproduce;
-        // rebuild faithfully from this instance's configuration so the clone is observationally
-        // identical instead of throwing on a parameter-count mismatch.
-        return new Step1XEditModel<T>(
-            architecture: Architecture,
-            options: (DiffusionModelOptions<T>)Options,
-            scheduler: Scheduler,
-            predictor: (SiTPredictor<T>)_predictor.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner,
-            seed: null);
-    }
-
     /// <inheritdoc />
     public override ModelMetadata<T> GetModelMetadata()
     {
diff --git a/src/Diffusion/ImageEditing/TurboEditModel.cs b/src/Diffusion/ImageEditing/TurboEditModel.cs
index 1f7e202683..3b5ab9d376 100644
--- a/src/Diffusion/ImageEditing/TurboEditModel.cs
+++ b/src/Diffusion/ImageEditing/TurboEditModel.cs
@@ -110,29 +110,6 @@ private void InitializeLayers(UNetNoisePredictor<T>? predictor, StandardVAE<T>?
 
 
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        // Fast path: O(1) copy-on-write share when the default clone is structurally identical
-        // (the common foundation-scale case the COW lever targets — no re-materialization/OOM).
-        var clone = new TurboEditModel<T>(conditioner: _conditioner, seed: null);
-        if (clone.TryShareParametersFrom(this)) return clone;
-        // Structure mismatch ⇒ custom architecture/predictor/VAE the default clone can't reproduce;
-        // rebuild faithfully from this instance's configuration so the clone is observationally
-        // identical instead of throwing on a parameter-count mismatch.
-        return new TurboEditModel<T>(
-            architecture: Architecture,
-            options: (DiffusionModelOptions<T>)Options,
-            scheduler: Scheduler,
-            predictor: (UNetNoisePredictor<T>)_predictor.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner,
-            seed: null);
-    }
-
     /// <inheritdoc />
     public override ModelMetadata<T> GetModelMetadata()
     {
diff --git a/src/Diffusion/ImageEditing/TurboFillModel.cs b/src/Diffusion/ImageEditing/TurboFillModel.cs
index d4da9a452d..28956fdaa5 100644
--- a/src/Diffusion/ImageEditing/TurboFillModel.cs
+++ b/src/Diffusion/ImageEditing/TurboFillModel.cs
@@ -108,27 +108,6 @@ private void InitializeLayers(UNetNoisePredictor<T>? predictor, StandardVAE<T>?
 
 
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        // Clone the resolved predictor/VAE via their own Clone() (+ same architecture/options/scheduler).
-        // The sub-model Clone()s already deep-copy the weights, so no field-by-field
-        // SetParameters(GetParameters()) is needed — which also avoids the int-bounded flat Vector<T>
-        // round-trip that a foundation-scale predictor would overflow / OOM.
-        var clone = new TurboFillModel<T>(
-            architecture: Architecture,
-            options: Options as DiffusionModelOptions<T>,
-            scheduler: Scheduler,
-            predictor: (UNetNoisePredictor<T>)_predictor.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner,
-            seed: null); // predictor+vae are cloned & passed, so InitializeLayers ignores seed — do not advance the source RNG
-        return clone;
-    }
-
     /// <inheritdoc />
     public override ModelMetadata<T> GetModelMetadata()
     {
diff --git a/src/Diffusion/ImageEditing/UltraEditModel.cs b/src/Diffusion/ImageEditing/UltraEditModel.cs
index 63a5902cc9..8c9d9cab7d 100644
--- a/src/Diffusion/ImageEditing/UltraEditModel.cs
+++ b/src/Diffusion/ImageEditing/UltraEditModel.cs
@@ -107,29 +107,6 @@ private void InitializeLayers(UNetNoisePredictor<T>? predictor, StandardVAE<T>?
 
 
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        // Clone the ACTUAL predictor and VAE (mirrors MultiDiffusionModel/SpotDiffusionModel): the
-        // previous code passed only conditioner/seed, so the clone rebuilt the DEFAULT-sized UNet/VAE
-        // while this model may hold a custom-sized predictor/vae, making GetParameters() mismatch and
-        // clone.SetParameters throw "Expected X, got Y". Pass the cloned predictor/VAE (+ same
-        // architecture/options/scheduler) so the clone is structurally identical to the source.
-        var clone = new UltraEditModel<T>(
-            architecture: Architecture,
-            options: Options as DiffusionModelOptions<T>,
-            scheduler: Scheduler,
-            predictor: (UNetNoisePredictor<T>)_predictor.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner,
-            seed: null);
-        if (!clone.TryShareParametersFrom(this)) clone.SetParameterChunks(GetParameterChunks());
-        return clone;
-    }
-
     /// <inheritdoc />
     public override ModelMetadata<T> GetModelMetadata()
     {
diff --git a/src/Diffusion/LatentDiffusionModelBase.cs b/src/Diffusion/LatentDiffusionModelBase.cs
index 85bc41a759..d3c1d0ce7a 100644
--- a/src/Diffusion/LatentDiffusionModelBase.cs
+++ b/src/Diffusion/LatentDiffusionModelBase.cs
@@ -23,7 +23,7 @@ namespace AiDotNet.Diffusion;
 /// (for guided generation from text or images).
 /// </para>
 /// </remarks>
-public abstract class LatentDiffusionModelBase<T> : DiffusionModelBase<T>, ILatentDiffusionModel<T>
+public abstract partial class LatentDiffusionModelBase<T> : DiffusionModelBase<T>, ILatentDiffusionModel<T>
 {
     /// <summary>
     /// The default guidance scale for classifier-free guidance.
diff --git a/src/Diffusion/MotionGeneration/MoMaskModel.cs b/src/Diffusion/MotionGeneration/MoMaskModel.cs
index 0851a9a47b..d1df163330 100644
--- a/src/Diffusion/MotionGeneration/MoMaskModel.cs
+++ b/src/Diffusion/MotionGeneration/MoMaskModel.cs
@@ -101,27 +101,6 @@ private void InitializeLayers(SiTPredictor<T>? predictor, StandardVAE<T>? vae, i
 
 
 
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    public override IDiffusionModel<T> Clone()
-    {
-        // Fast path: O(1) copy-on-write share when the default clone is structurally identical
-        // (the common foundation-scale case the COW lever targets — no re-materialization/OOM).
-        var clone = new MoMaskModel<T>(conditioner: _conditioner, seed: null);
-        if (clone.TryShareParametersFrom(this)) return clone;
-        // Structure mismatch ⇒ custom architecture/predictor/VAE the default clone can't reproduce;
-        // rebuild faithfully from this instance's configuration so the clone is observationally
-        // identical instead of throwing on a parameter-count mismatch.
-        return new MoMaskModel<T>(
-            architecture: Architecture,
-            options: (DiffusionModelOptions<T>)Options,
-            scheduler: Scheduler,
-            predictor: (SiTPredictor<T>)_predictor.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner,
-            seed: null);
-    }
-
     public override ModelMetadata<T> GetModelMetadata()
     {
         var m = new ModelMetadata<T> { Name = "MoMask", Version = "1.0",
diff --git a/src/Diffusion/MotionGeneration/MotionDiffuseModel.cs b/src/Diffusion/MotionGeneration/MotionDiffuseModel.cs
index a232491a2f..4a6e94e65e 100644
--- a/src/Diffusion/MotionGeneration/MotionDiffuseModel.cs
+++ b/src/Diffusion/MotionGeneration/MotionDiffuseModel.cs
@@ -101,23 +101,6 @@ private void InitializeLayers(SiTPredictor<T>? predictor, StandardVAE<T>? vae, i
 
 
 
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    public override IDiffusionModel<T> Clone()
-    {
-        // Lazy-preserving Clone (recipe from #1596): delegate to the predictor's and VAE's own Clone()
-        // (preserves materialized weights, reconstructs from actual config) instead of rebuilding a
-        // default-scale model and SetParameters(GetParameters()), which mismatches an injected non-default
-        // variant and re-randomizes the clone's unmaterialized lazy weights.
-        return new MotionDiffuseModel<T>(
-            architecture: Architecture,
-            options: Options as DiffusionModelOptions<T>,
-            scheduler: Scheduler,
-            predictor: (SiTPredictor<T>)_predictor.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner);
-    }
-
     public override ModelMetadata<T> GetModelMetadata()
     {
         var m = new ModelMetadata<T> { Name = "MotionDiffuse", Version = "1.0",
diff --git a/src/Diffusion/MotionGeneration/MotionDiffusionModel.cs b/src/Diffusion/MotionGeneration/MotionDiffusionModel.cs
index fa7b615581..d4f301318c 100644
--- a/src/Diffusion/MotionGeneration/MotionDiffusionModel.cs
+++ b/src/Diffusion/MotionGeneration/MotionDiffusionModel.cs
@@ -97,20 +97,6 @@ private void InitializeLayers(SiTPredictor<T>? predictor, StandardVAE<T>? vae, i
 
 
 
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    public override IDiffusionModel<T> Clone()
-    {
-        // #1711: delegate to predictor/VAE Clone (probe-forward + copy); DiT LazyDense weights resolve
-        // via the FORWARD path so a model-level SetParameters(GetParameters()) clone re-RNG-initialized.
-        var clone = new MotionDiffusionModel<T>(
-            conditioner: _conditioner,
-            predictor: (SiTPredictor<T>)_predictor.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            seed: null);
-        return clone;
-    }
-
     public override ModelMetadata<T> GetModelMetadata()
     {
         var m = new ModelMetadata<T> { Name = "MDM", Version = "1.0",
diff --git a/src/Diffusion/NoisePredictors/AsymmDiTPredictor.cs b/src/Diffusion/NoisePredictors/AsymmDiTPredictor.cs
index dc5975b914..0b6d0f41bd 100644
--- a/src/Diffusion/NoisePredictors/AsymmDiTPredictor.cs
+++ b/src/Diffusion/NoisePredictors/AsymmDiTPredictor.cs
@@ -86,18 +86,4 @@ public AsymmDiTPredictor(
         _asymSeed = seed;
     }
 
-    /// <inheritdoc />
-    public override INoisePredictor<T> Clone()
-    {
-        var clone = new AsymmDiTPredictor<T>(
-            _asymInputChannels, _asymHiddenSize, _asymNumLayers, _asymNumHeads, _asymContextDim, _asymSeed);
-        // #1711: MMDiT LazyDense weights resolve via the FORWARD path, so a naive
-        // SetParameters(GetParameters()) clone re-RNG-initializes on its first forward and
-        // diverges from the source. ProbeMaterializeAndCopyInto probe-forwards the clone, then copies.
-        ProbeMaterializeAndCopyInto(clone);
-        return clone;
-    }
-
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
 }
diff --git a/src/Diffusion/NoisePredictors/DiTNoisePredictor.cs b/src/Diffusion/NoisePredictors/DiTNoisePredictor.cs
index b0be2a62da..f258cfa82f 100644
--- a/src/Diffusion/NoisePredictors/DiTNoisePredictor.cs
+++ b/src/Diffusion/NoisePredictors/DiTNoisePredictor.cs
@@ -74,17 +74,9 @@ namespace AiDotNet.Diffusion.NoisePredictors;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
     [ResearchPaper("Scalable Diffusion Models with Transformers", "https://arxiv.org/abs/2212.09748")]
-public class DiTNoisePredictor<T> : NoisePredictorBase<T>
+public partial class DiTNoisePredictor<T> : NoisePredictorBase<T>
 {
 
-    /// <inheritdoc />
-    /// <remarks>DiT builds its blocks lazily, so nothing is reflectable until this runs. Without it
-    /// SiTPredictor, which derives from this type, reported 0 parameters against a real 49,328.</remarks>
-    protected override void EnsureParametersReady()
-    {
-        EnsureLayersInitialized();
-    }
-
     /// <inheritdoc />
     protected override void EnsureParameterStructureReady()
     {
@@ -245,6 +237,7 @@ public static class ModelSizes
     /// <summary>
     /// Cached input for backward pass.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastInput;
 
     // ──────────────────────────────────────────────────────────────────────────
@@ -258,8 +251,11 @@ public static class ModelSizes
     // Reallocated whenever the [B, seq, hidden] shape changes. Used only on the no-tape
     // inference forward (ForwardScratchGate.Enabled). Bit-identical to the allocating path.
     // ──────────────────────────────────────────────────────────────────────────
+    [Scratch]
     private Tensor<T>? _adaLnScaledScratch;   // TensorMultiply(x, 1+scale)
+    [Scratch]
     private Tensor<T>? _adaLnOutScratch;       // TensorAdd(scaled, shift)
+    [Scratch]
     private Tensor<T>? _gateScratch;           // TensorMultiply(residual, gate)
 
     /// <summary>Element-wise shape-array equality for the #1672 scratch-reuse decision.</summary>
@@ -1326,30 +1322,6 @@ private static bool HasMaterializedParameters(ILayer<T>? layer)
         return false;
     }
 
-    /// <inheritdoc />
-    public override INoisePredictor<T> Clone()
-    {
-        var clone = new DiTNoisePredictor<T>(
-            inputChannels: _inputChannels,
-            hiddenSize: _hiddenSize,
-            numLayers: _numLayers,
-            numHeads: _numHeads,
-            patchSize: _patchSize,
-            contextDim: _contextDim,
-            mlpRatio: _mlpRatio,
-            latentSpatialSize: _latentSpatialSize,
-            seed: _seed);
-
-        // Carry the test-only resident-threshold override so an eager fallback takes the same
-        // (fp16-resident vs fp32) path as the source — otherwise a small test clone would materialize fp32
-        // while the source is resident, masking the resident clone round-trip under test (#1764). Null in
-        // production, so this is a no-op there.
-        clone.ResidentThresholdOverrideForTests = ResidentThresholdOverrideForTests;
-
-        ProbeMaterializeAndCopyInto(clone);
-        return clone;
-    }
-
     /// <summary>
     /// Shares this predictor's trained weights with <paramref name="clone"/> through the central
     /// copy-on-write path, falling back to a materialize-and-copy forward only when the generated
@@ -1472,9 +1444,6 @@ private static IEnumerable<Tensor<T>> EnumerateMaterializedParameters(ILayer<T>?
     /// <inheritdoc />
     public override int ContextDimension => _contextDim;
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
     protected override Vector<T> GetParameterGradients()
     {
         EnsureLayersInitialized();
diff --git a/src/Diffusion/NoisePredictors/DiffusionAttentionLayer.cs b/src/Diffusion/NoisePredictors/DiffusionAttentionLayer.cs
index be9794f403..948d2d8f33 100644
--- a/src/Diffusion/NoisePredictors/DiffusionAttentionLayer.cs
+++ b/src/Diffusion/NoisePredictors/DiffusionAttentionLayer.cs
@@ -150,14 +150,7 @@ public override void ResetState()
     {
     }
 
-    /// <inheritdoc />
-    public override LayerBase<T> Clone()
-    {
-        var clone = new DiffusionAttentionLayer<T>(
-            _queryDimension, _contextDimension, _headCount, _zeroOutputProjection);
-        if (_queryWeights.Length > 0) clone.SetParameters(GetParameters());
-        return clone;
-    }
+
 
     /// <inheritdoc />
     internal override Dictionary<string, string> GetMetadata()
diff --git a/src/Diffusion/NoisePredictors/DiffusionResBlock.cs b/src/Diffusion/NoisePredictors/DiffusionResBlock.cs
index bf57967c52..6a300353cd 100644
--- a/src/Diffusion/NoisePredictors/DiffusionResBlock.cs
+++ b/src/Diffusion/NoisePredictors/DiffusionResBlock.cs
@@ -84,6 +84,7 @@ public partial class DiffusionResBlock<T> : LayerBase<T>, IShapeContract
     private readonly SiLUActivation<T> _silu = new();
 
     // Cache for backward
+    [Scratch]
     private Tensor<T>? _lastInput;
     private Tensor<T>? _preSiLU1;   // norm1 output (before SiLU)
     private Tensor<T>? _preSiLU2;   // norm2 output (before SiLU)
@@ -95,7 +96,9 @@ public partial class DiffusionResBlock<T> : LayerBase<T>, IShapeContract
     // tensors per ResBlock at SD 320×64×64 shapes; pooling these eliminates
     // ~40 MB of per-ResBlock allocation churn (≈22 ResBlocks per UNet
     // forward → ~880 MB removed from each Predict's GC pressure).
+    [AiDotNet.Attributes.Scratch]
     private Tensor<T>? _preAllocatedNorm1Out;
+    [AiDotNet.Attributes.Scratch]
     private Tensor<T>? _preAllocatedNorm2Out;
 
     private static bool ShapeEquals(int[] a, int[] b)
@@ -502,6 +505,7 @@ void RbTick(string s)
     }
 
     // Stores time embed gradient for collection by UNet backward
+    [Scratch]
     private Tensor<T>? _timeEmbedGradient;
 
     /// <summary>
diff --git a/src/Diffusion/NoisePredictors/EMMDiTPredictor.cs b/src/Diffusion/NoisePredictors/EMMDiTPredictor.cs
index 1e0da32157..09da5e5405 100644
--- a/src/Diffusion/NoisePredictors/EMMDiTPredictor.cs
+++ b/src/Diffusion/NoisePredictors/EMMDiTPredictor.cs
@@ -78,16 +78,4 @@ public EMMDiTPredictor(
         _emmSeed = seed;
     }
 
-    /// <inheritdoc />
-    public override INoisePredictor<T> Clone()
-    {
-        var clone = new EMMDiTPredictor<T>(_emmInputChannels, _emmContextDim, _emmSeed);
-        // #1711: MMDiT LazyDense weights resolve via the FORWARD path; ProbeMaterializeAndCopyInto
-        // probe-forwards the clone then copies, instead of a naive re-RNG-initializing copy.
-        ProbeMaterializeAndCopyInto(clone);
-        return clone;
-    }
-
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
 }
diff --git a/src/Diffusion/NoisePredictors/FlagDiTPredictor.cs b/src/Diffusion/NoisePredictors/FlagDiTPredictor.cs
index bb95698da5..e5c94cb6e9 100644
--- a/src/Diffusion/NoisePredictors/FlagDiTPredictor.cs
+++ b/src/Diffusion/NoisePredictors/FlagDiTPredictor.cs
@@ -42,7 +42,7 @@ namespace AiDotNet.Diffusion.NoisePredictors;
 [ModelComplexity(ModelComplexity.VeryHigh)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Lumina-T2X: Transforming Text into Any Modality with Flow Matching", "https://arxiv.org/abs/2405.05945")]
-public class FlagDiTPredictor<T> : NoisePredictorBase<T>
+public partial class FlagDiTPredictor<T> : NoisePredictorBase<T>
 {
     /// <summary>Patch size (p): a p×p block of the latent becomes one token (paper uses 2).</summary>
     private const int PatchSize = 2;
@@ -375,43 +375,4 @@ private static int Load(ILayer<T> layer, Vector<T> parameters, int offset)
         return offset + count;
     }
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override INoisePredictor<T> Clone()
-    {
-        var clone = new FlagDiTPredictor<T>(_inputChannels, _hiddenSize, _numLayers, _numHeads,
-            _numKVHeads, _contextDim, _latentSize);
-
-        // #1711: the LazyDense projections and the deferAllocation GQA attention resolve+allocate
-        // their weights on the FIRST FORWARD (EnsureInitializedFromInput), a different entry than the
-        // SetParameters path. A naive SetParameters(GetParameters()) clone leaves the fresh clone's
-        // first real forward to re-resolve and RNG-initialize those weights, discarding the copied
-        // values and diverging from the source. Probe-forward the clone to materialize every weight
-        // through the same path the source used, THEN copy the source's weights layer-by-layer (never
-        // materializing one contiguous multi-billion-parameter vector — the GetParameters flat path
-        // OOMs at Flag-DiT / Lumina scale). Gated on the source having been forwarded.
-        if (_patchEmbed.IsInitialized)
-        {
-            var probe = new Tensor<T>(new[] { 1, _inputChannels, _latentSize, _latentSize });
-            // Probe WITH conditioning when the source materialized its context path, so the clone's
-            // context projection + cross-attention K/V layers allocate too (else they stay lazy and
-            // re-init with fresh RNG on the first conditioned forward, diverging from the source).
-            Tensor<T>? probeConditioning = _contextProj.IsInitialized
-                ? new Tensor<T>(new[] { 1, 1, _contextDim })
-                : null;
-            clone.PredictNoise(probe, timestep: 0, conditioning: probeConditioning);
-
-            using var src = FlagDiTLayerSequence().GetEnumerator();
-            using var dst = clone.FlagDiTLayerSequence().GetEnumerator();
-            while (src.MoveNext() && dst.MoveNext())
-                dst.Current.SetParameters(src.Current.GetParameters());
-
-            // The probe forward traced a compiled plan over the clone's random init; drop it so the
-            // next real forward re-traces against the copied weights.
-            clone.InvalidateCompiledPlans();
-        }
-        return clone;
-    }
 }
diff --git a/src/Diffusion/NoisePredictors/FluxDoubleStreamPredictor.cs b/src/Diffusion/NoisePredictors/FluxDoubleStreamPredictor.cs
index 65512c713b..73d69c21f0 100644
--- a/src/Diffusion/NoisePredictors/FluxDoubleStreamPredictor.cs
+++ b/src/Diffusion/NoisePredictors/FluxDoubleStreamPredictor.cs
@@ -59,6 +59,11 @@ public class FluxDoubleStreamPredictor<T> : MMDiTNoisePredictor<T>
     // Retained for a type-correct Clone().
     private readonly FluxPredictorVariant _variant;
     private readonly int _fluxInputChannels;
+    private readonly int _fluxHiddenSize;
+    private readonly int _fluxNumJointLayers;
+    private readonly int _fluxNumSingleLayers;
+    private readonly int _fluxNumHeads;
+    private readonly int _fluxPatchSize;
     private readonly int _fluxContextDim;
     private readonly int? _fluxSeed;
 
@@ -75,31 +80,55 @@ public FluxDoubleStreamPredictor(
         int inputChannels = 16,
         int contextDim = 4096,
         int? seed = null)
+        : this(
+            inputChannels, FLUX_HIDDEN_SIZE, FLUX_NUM_JOINT_LAYERS,
+            FLUX_NUM_SINGLE_LAYERS, FLUX_NUM_HEADS,
+            patchSize: 2, contextDim: contextDim, variant: variant, seed: seed)
+    {
+    }
+
+    /// <summary>
+    /// Initializes a configurable FLUX double-stream predictor while retaining paper-scale defaults
+    /// on the established constructor.
+    /// </summary>
+    /// <param name="inputChannels">Latent channel count.</param>
+    /// <param name="hiddenSize">Transformer width.</param>
+    /// <param name="numJointLayers">Number of double-stream blocks.</param>
+    /// <param name="numSingleLayers">Number of single-stream blocks.</param>
+    /// <param name="numHeads">Attention head count.</param>
+    /// <param name="patchSize">Latent patch size (default: 2).</param>
+    /// <param name="contextDim">Text-conditioning dimension (default: 4096, T5-XXL).</param>
+    /// <param name="variant">FLUX variant (Dev / Schnell). Default: Dev.</param>
+    /// <param name="seed">Optional random seed.</param>
+    public FluxDoubleStreamPredictor(
+        int inputChannels,
+        int hiddenSize,
+        int numJointLayers,
+        int numSingleLayers,
+        int numHeads,
+        int patchSize = 2,
+        int contextDim = 4096,
+        FluxPredictorVariant variant = FluxPredictorVariant.Dev,
+        int? seed = null)
         : base(
             inputChannels: inputChannels,
-            hiddenSize: FLUX_HIDDEN_SIZE,
-            numJointLayers: FLUX_NUM_JOINT_LAYERS,
-            numSingleLayers: FLUX_NUM_SINGLE_LAYERS,
-            numHeads: FLUX_NUM_HEADS,
+            hiddenSize: hiddenSize,
+            numJointLayers: numJointLayers,
+            numSingleLayers: numSingleLayers,
+            numHeads: numHeads,
+            patchSize: patchSize,
             contextDim: contextDim,
             seed: seed)
     {
         _variant = variant;
         _fluxInputChannels = inputChannels;
+        _fluxHiddenSize = hiddenSize;
+        _fluxNumJointLayers = numJointLayers;
+        _fluxNumSingleLayers = numSingleLayers;
+        _fluxNumHeads = numHeads;
+        _fluxPatchSize = patchSize;
         _fluxContextDim = contextDim;
         _fluxSeed = seed;
     }
 
-    /// <inheritdoc />
-    public override INoisePredictor<T> Clone()
-    {
-        var clone = new FluxDoubleStreamPredictor<T>(_variant, _fluxInputChannels, _fluxContextDim, _fluxSeed);
-        // #1711: MMDiT LazyDense weights resolve via the FORWARD path; ProbeMaterializeAndCopyInto
-        // probe-forwards the clone then copies, instead of a naive re-RNG-initializing copy.
-        ProbeMaterializeAndCopyInto(clone);
-        return clone;
-    }
-
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
 }
diff --git a/src/Diffusion/NoisePredictors/MMDiTNoisePredictor.cs b/src/Diffusion/NoisePredictors/MMDiTNoisePredictor.cs
index 3d492c7cc6..2adc9aae4c 100644
--- a/src/Diffusion/NoisePredictors/MMDiTNoisePredictor.cs
+++ b/src/Diffusion/NoisePredictors/MMDiTNoisePredictor.cs
@@ -86,7 +86,7 @@ namespace AiDotNet.Diffusion.NoisePredictors;
 [ModelComplexity(ModelComplexity.VeryHigh)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
     [ResearchPaper("Scaling Rectified Flow Transformers for High-Resolution Image Synthesis", "https://arxiv.org/abs/2403.03206")]
-public class MMDiTNoisePredictor<T> : NoisePredictorBase<T>
+public partial class MMDiTNoisePredictor<T> : NoisePredictorBase<T>
 {
     #region Fields
 
@@ -270,8 +270,12 @@ private void InitializeLayers(
         // runner just from `new MMDiTNoisePredictor()`.
         _patchEmbed = LazyDense(patchDim, _hiddenSize);
 
-        // Time embedding MLP
-        _timeEmbed1 = LazyDense(_hiddenSize, timeEmbedDim, new SiLUActivation<T>());
+        // The shared sinusoidal embedding contract emits TimeEmbeddingDim features (4*hidden).
+        // Declare that exact input width before the first forward. A hiddenSize-wide declaration was
+        // silently resized on first use, so the generated pre-forward parameter layout described a
+        // 4,096-value matrix while the live model held 16,384 values; clone/serialization then paired
+        // different chunk shapes. DiT uses the same contract and declaration.
+        _timeEmbed1 = LazyDense(TimeEmbeddingDim, timeEmbedDim, new SiLUActivation<T>());
         _timeEmbed2 = LazyDense(timeEmbedDim, timeEmbedDim, new SiLUActivation<T>());
 
         // Context projection: project text embeddings to hidden dim
@@ -1095,23 +1099,6 @@ private int SetLayerParams(ILayer<T> layer, Vector<T> parameters, int offset)
 
     #region ICloneable Implementation
 
-    /// <inheritdoc />
-    public override INoisePredictor<T> Clone()
-    {
-        var clone = new MMDiTNoisePredictor<T>(
-            inputChannels: _inputChannels,
-            hiddenSize: _hiddenSize,
-            numJointLayers: _numJointLayers,
-            numSingleLayers: _numSingleLayers,
-            numHeads: _numHeads,
-            patchSize: _patchSize,
-            contextDim: _contextDim,
-            mlpRatio: _mlpRatio);
-
-        ProbeMaterializeAndCopyInto(clone);
-        return clone;
-    }
-
     /// <summary>
     /// Materializes <paramref name="clone"/> through one throwaway probe forward (the same path the
     /// source's weights resolved on) and then copies this predictor's weights into it.
@@ -1188,9 +1175,6 @@ private void CopyParametersFrom(MMDiTNoisePredictor<T> source)
         }
     }
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
     #endregion
 
     #region Block Structures
diff --git a/src/Diffusion/NoisePredictors/MMDiTXNoisePredictor.cs b/src/Diffusion/NoisePredictors/MMDiTXNoisePredictor.cs
index cb9b31686e..c8110b8172 100644
--- a/src/Diffusion/NoisePredictors/MMDiTXNoisePredictor.cs
+++ b/src/Diffusion/NoisePredictors/MMDiTXNoisePredictor.cs
@@ -47,9 +47,14 @@ public class MMDiTXNoisePredictor<T> : MMDiTNoisePredictor<T>
     private readonly int _mmxPatchSize;
     private readonly int _mmxContextDim;
     private readonly int? _mmxSeed;
-    private readonly int _mmxHiddenOverride;
-    private readonly int _mmxLayersOverride;
-    private readonly int _mmxHeadsOverride;
+    // Keep constructor inputs under the generator's parameter-name convention. These values are
+    // semantically different from the resolved base dimensions: zero means "use the variant
+    // default", while a positive value is an explicit override that must survive configuration
+    // reconstruction. Hiding them behind an unrelated `mmx` prefix made the clone plan emit the
+    // declared defaults and silently rebuild a tiny injected predictor at foundation scale.
+    private readonly int _hiddenSizeOverride;
+    private readonly int _numLayersOverride;
+    private readonly int _numHeadsOverride;
 
     /// <summary>
     /// Initializes a new MMDiT-X (SD3.5) predictor on the faithful MMDiT
@@ -87,29 +92,11 @@ public MMDiTXNoisePredictor(
         _mmxPatchSize = patchSize;
         _mmxContextDim = contextDim;
         _mmxSeed = seed;
-        _mmxHiddenOverride = hiddenSizeOverride;
-        _mmxLayersOverride = numLayersOverride;
-        _mmxHeadsOverride = numHeadsOverride;
+        _hiddenSizeOverride = hiddenSizeOverride;
+        _numLayersOverride = numLayersOverride;
+        _numHeadsOverride = numHeadsOverride;
     }
 
-    /// <inheritdoc />
-    public override INoisePredictor<T> Clone()
-    {
-        var clone = new MMDiTXNoisePredictor<T>(
-            _variant, _mmxInputChannels, _mmxPatchSize, _mmxContextDim, _mmxSeed,
-            _mmxHiddenOverride, _mmxLayersOverride, _mmxHeadsOverride);
-        // #1706: probe-materialize the clone through the forward path, THEN copy weights — the same
-        // pattern the base MMDiTNoisePredictor.Clone uses. The previous TryShareParametersFrom /
-        // SetParameters path copied onto unmaterialized lazy layers, which then re-RNG-initialized
-        // on the clone's first real forward and diverged from the source (HiDream
-        // Clone_ShouldProduceIdenticalOutput, maxDiff ~7e2).
-        ProbeMaterializeAndCopyInto(clone);
-        return clone;
-    }
-
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
     // SD3.5 variant dimensions. hidden % heads == 0 for each (2048%16=128, 2560%20=128).
     private static int GetHiddenSize(MMDiTXVariant variant) => variant switch
     {
diff --git a/src/Diffusion/NoisePredictors/NoisePredictorBase.cs b/src/Diffusion/NoisePredictors/NoisePredictorBase.cs
index 0b2f5460a4..517f710b53 100644
--- a/src/Diffusion/NoisePredictors/NoisePredictorBase.cs
+++ b/src/Diffusion/NoisePredictors/NoisePredictorBase.cs
@@ -1,4 +1,5 @@
-using System.Linq;
+using System.Linq;
+using AiDotNet.Attributes;
 using AiDotNet.Autodiff;
 using AiDotNet.Engines;
 using AiDotNet.Extensions;
@@ -29,11 +30,54 @@ namespace AiDotNet.Diffusion.NoisePredictors;
 /// extend this base class.
 /// </para>
 /// </remarks>
-public abstract class NoisePredictorBase<T> : INoisePredictor<T>, IModelShape,
+public abstract partial class NoisePredictorBase<T> : INoisePredictor<T>, IModelShape,
     AiDotNet.Models.Parameters.IParameterLayoutSource,
     AiDotNet.Models.Parameters.IParameterManifestProvider,
     AiDotNet.Models.Parameters.IParameterSurfaceLifecycle, IDisposable
 {
+    // --- declared state (ModelStateRegistry) ---
+    // Identical in every model base because these bases are siblings over the same interfaces rather
+    // than one hierarchy; the logic itself lives once in ModelStateRegistry/ModelStateEnvelope.
+
+    /// <summary>State that is not a parameter vector, declared once and persisted by this base.</summary>
+    private readonly AiDotNet.Models.ModelStateRegistry<T> _declaredState = new();
+    private bool _declaredStateRegistered;
+
+    /// <summary>
+    /// Declare state here that the parameter vector does not carry -- a retained training set,
+    /// fitted knots, kernel centres, an ensemble's children. Both halves of the payload are driven
+    /// by the declaration, so they cannot drift.
+    /// </summary>
+    /// <param name="state">The registry to declare into.</param>
+    protected virtual void RegisterState(AiDotNet.Models.ModelStateRegistry<T> state)
+    {
+    }
+    /// <summary>Generated state declarations for fields declared across this model's hierarchy.</summary>
+    /// <param name="state">The registry to declare into.</param>
+    /// <remarks>
+    /// Emitted by ModelStateGenerator into the partial model, so a model author declares nothing. The
+    /// hand-written <c>RegisterState</c> beside it exists only for state the classifier genuinely
+    /// cannot place; anything it CAN place belongs here, where it cannot be forgotten.
+    /// </remarks>
+    protected virtual void RegisterGeneratedState(AiDotNet.Models.ModelStateRegistry<T> state)
+    {
+        RegisterGeneratedStateCore(state);
+    }
+
+    /// <summary>The declared state, registered once and lazily so it runs after the constructor.</summary>
+    protected AiDotNet.Models.ModelStateRegistry<T> DeclaredState
+    {
+        get
+        {
+            if (!_declaredStateRegistered)
+            {
+                _declaredStateRegistered = true;
+                RegisterGeneratedState(_declaredState);
+                RegisterState(_declaredState);
+            }
+            return _declaredState;
+        }
+    }
     /// <summary>
     /// Provides access to the hardware-accelerated tensor engine.
     /// </summary>
@@ -530,7 +574,7 @@ public virtual long ParameterCount
             if (TryGetDeclaredParameterCount(out long declaredCount, out _))
                 return declaredCount;
 
-            EnsureParametersReadyGuarded();
+            PrepareParameterSurface(AiDotNet.Models.Parameters.ParameterSurfaceIntent.Read);
             long total = 0;
             foreach (var slot in EnumerateParameterValueSlots())
             {
@@ -579,8 +623,8 @@ public virtual long ParameterCount
 
     /// <summary>
     /// Builds any layer objects whose dimensions are fixed by construction, without allocating
-    /// their weight tensors. Deferred-construction predictors override this independently from
-    /// <see cref="EnsureParametersReady"/>, whose explicit read/write path may materialize values.
+    /// their weight tensors. Deferred-construction predictors override this shape-only hook;
+    /// concrete reads and writes are materialized uniformly by the layer lifecycle below.
     /// </summary>
     protected virtual void EnsureParameterStructureReady()
     {
@@ -659,8 +703,12 @@ protected IEnumerable<Tensor<T>> EnumerateParameterTensors()
                     streamingEngaged = true;
                 }
 
-                ((AiDotNet.Models.Parameters.IParameterSurfaceLifecycle)lb)
-                    .PrepareParameterSurface(AiDotNet.Models.Parameters.ParameterSurfaceIntent.Read);
+                // LayerBase<T> declares IParameterSurfaceLifecycle in its base list, so the type
+                // test this replaces was always true (CodeQL: useless type test). The cast is still
+                // needed because LayerBase implements the member EXPLICITLY, which keeps it off the
+                // public surface.
+                ((AiDotNet.Models.Parameters.IParameterSurfaceLifecycle)lb).PrepareParameterSurface(
+                    AiDotNet.Models.Parameters.ParameterSurfaceIntent.Read);
             }
 
             // STATE slots, not trainable-only: this enumeration backs the flat vector and the chunk
@@ -682,98 +730,40 @@ protected IEnumerable<Tensor<T>> EnumerateParameterTensors()
     }
 
     /// <summary>
-    /// Brings lazily-built layers into existence before their parameters are read or written.
-    /// Does nothing by default, which is correct for the predictors that build eagerly.
+    /// The chunk surface's slots: the same walk as <see cref="EnumerateParameterValueSlots"/> but
+    /// covering every component <c>GetOwnParameterStateChunks</c> emits, so the chunk pair is
+    /// symmetric where the flat pair is the narrower trainable-only optimizer view.
     /// </summary>
-    /// <remarks>
-    /// A predictor with lazy weights overrides this, and must use the SAME resolution on every
-    /// path. UNetNoisePredictor is the cautionary case: it resolved shape-only when read and for
-    /// real when written, so the count described one model and the restore built another, and
-    /// restoring grew it from 3,146,496 to 5,006,595.
-    /// </remarks>
-    protected virtual void EnsureParametersReady()
+    private IEnumerable<LayerBase<T>.ParameterStateWriteTarget> EnumerateParameterStateValueSlots()
     {
-    }
-
-    /// <summary>
-    /// The instance whose <see cref="EnsureParametersReady"/> is currently running on this thread,
-    /// or null. Per-thread so concurrent predictors never suppress each other's resolution, and
-    /// saved/restored around each call so a nested resolution on a DIFFERENT predictor still runs.
-    /// </summary>
-    [ThreadStatic]
-    private static object? _resolvingParametersFor;
-
-    /// <summary>
-    /// The predictor whose streaming-engagement decision is currently being made on this thread,
-    /// or null. Same shape and reason as <see cref="_resolvingParametersFor"/>, for the second
-    /// cycle through this heuristic:
-    /// <para>
-    /// ParameterCount -&gt; EnumerateParameterValueSlots -&gt; MaybeEngageWeightStreaming -&gt;
-    /// ParameterCount.
-    /// </para>
-    /// <para>
-    /// EnumerateParameterValueSlots guards its own call with a LOCAL flag, which a nested
-    /// enumeration re-creates as false, so the local guard cannot see the outer call. The
-    /// _streamingEngaged flag cannot break it either: the re-entry happens while the engagement
-    /// decision is still being made, which is precisely when nothing has engaged yet. Like the
-    /// resolution guard, this overflowed the stack instead of failing a test, so it aborted the
-    /// whole run with no failing test named.
-    /// </para>
-    /// </summary>
-    [ThreadStatic]
-    private static object? _decidingStreamingEngagementFor;
-
-    /// <summary>
-    /// Calls <see cref="EnsureParametersReady"/>, but returns immediately if this same predictor is
-    /// already resolving on this thread.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// Lazy predictors resolve their shapes by running a real forward pass, and the forward path
-    /// consults the weight-streaming heuristic, which reads <see cref="ParameterCount"/> -- which
-    /// resolves. That closes a cycle with no base case:
-    /// </para>
-    /// <para>
-    /// ParameterCount -&gt; EnsureParametersReady -&gt; TriggerLazyShapeResolution -&gt; PredictNoise
-    /// -&gt; BeginWeightStreamingForward -&gt; MaybeEngageWeightStreaming -&gt; ParameterCount.
-    /// </para>
-    /// <para>
-    /// It overflowed the stack rather than failing a test, so it killed the whole test host: the
-    /// parameter sweeps reported "Test Run Aborted" with empty logs and no artifacts instead of
-    /// naming a failing model. The <c>_streamingEngaged</c> flag cannot break the cycle because the
-    /// re-entry happens at the ParameterCount READ, before anything has engaged.
-    /// </para>
-    /// <para>
-    /// Returning early is correct, not just a stack guard: the outer call is already resolving, so
-    /// the inner read sees whatever is materialized so far. The streaming heuristic that triggers
-    /// the re-entry only needs a count to compare against a threshold, and a predictor mid-resolve
-    /// is by definition not yet finished building.
-    /// </para>
-    /// </remarks>
-    private protected void EnsureParametersReadyGuarded()
-    {
-        if (ReferenceEquals(_resolvingParametersFor, this)) return;
-
-        object? previous = _resolvingParametersFor;
-        _resolvingParametersFor = this;
-        try
-        {
-            EnsureParametersReady();
-        }
-        finally
+        foreach (var layer in ReflectInstanceLayers(this))
         {
-            _resolvingParametersFor = previous;
+            if (layer is not LayerBase<T> lb) continue;
+            foreach (var target in lb.GetOwnParameterStateWriteTargets())
+            {
+                if (target.ScalarCount == 0) continue;
+                yield return target;
+            }
         }
     }
 
     /// <inheritdoc />
     void AiDotNet.Models.Parameters.IParameterSurfaceLifecycle.PrepareParameterSurface(
         AiDotNet.Models.Parameters.ParameterSurfaceIntent intent)
+        => PrepareParameterSurface(intent);
+
+    /// <summary>
+    /// Advances the reflected layer graph through the one shared parameter lifecycle. Shape-only
+    /// queries never allocate; every concrete operation asks each generated layer manifest to
+    /// materialize exactly its construction-declared slots. Predictor authors therefore do not
+    /// need value-readiness overrides or dummy forwards.
+    /// </summary>
+    private void PrepareParameterSurface(
+        AiDotNet.Models.Parameters.ParameterSurfaceIntent intent)
     {
         EnsureParameterStructureReady();
         if (intent == AiDotNet.Models.Parameters.ParameterSurfaceIntent.Describe) return;
 
-        EnsureParametersReadyGuarded();
         foreach (var layer in ReflectInstanceLayers(this))
         {
             if (layer is AiDotNet.Models.Parameters.IParameterSurfaceLifecycle lifecycle)
@@ -862,20 +852,37 @@ public virtual IEnumerable<Tensor<T>> GetParameterChunks()
     }
 
     /// <summary>
-    /// Collects this predictor's reflectable trainable weight tensors (skipping null / empty),
-    /// summing their lengths, and reports whether that sum equals <see cref="ParameterCount"/> — i.e.
-    /// whether reflection sees the FULL parameter set. Only then is the flat-free per-tensor chunk
-    /// path (used by both <see cref="GetParameterChunks"/> and <see cref="SetParameterChunks"/>) safe;
-    /// otherwise those fall back to the legacy flat path so a predictor with non-LayerBase weight
-    /// storage (or unresolved lazy weights) round-trips correctly rather than dropping weights. Both
-    /// callers use this same walk on the same instance, so Get and Set agree on order by construction.
+    /// Collects the slots backing this predictor's CHUNK surface (skipping null / empty), summing
+    /// their lengths, and reports whether that sum equals <see cref="ParameterCount"/> — i.e. whether
+    /// reflection sees the FULL parameter set. Only then is the flat-free per-tensor chunk path (used
+    /// by both <see cref="GetParameterChunks"/> and <see cref="SetParameterChunks"/>) safe; otherwise
+    /// those fall back to the legacy flat path so a predictor with non-LayerBase weight storage (or
+    /// unresolved lazy weights) round-trips correctly rather than dropping weights. Both callers use
+    /// this same walk on the same instance, so Get and Set agree on order by construction.
     /// </summary>
+    /// <remarks>
+    /// The walk must be the STATE surface, not the trainable-only one. ParameterCount and the
+    /// declared manifest both count buffers, so collecting trainable slots made the gate compare
+    /// 88,860 against 95,116: it could never pass, every predictor silently collapsed to a single
+    /// flat blob (the failure mode the ParameterCount remarks warn about), and the resulting stream
+    /// was then too wide for the trainable-only SetParameters that consumed it.
+    /// </remarks>
     private bool TryCollectReflectedParameterSlots(
-        out List<LayerBase<T>.TrainableParameterValueSlot> slots)
+        out List<LayerBase<T>.ParameterStateWriteTarget> slots)
     {
-        slots = new List<LayerBase<T>.TrainableParameterValueSlot>();
+        slots = new List<LayerBase<T>.ParameterStateWriteTarget>();
+
+        // Ready the parameter structure BEFORE walking it. The completeness gate below compares the
+        // reflected total against ParameterCount, whose getter readies the structure as a side effect
+        // -- so without this call the walk runs against a still-lazy graph while the comparand is
+        // materialized, the totals cannot agree, and the caller silently drops to the flat path. On a
+        // freshly cloned predictor that path then threw "Expected 88860 parameters, got 95116": the
+        // copy's own weights had never been brought up. Readying first leaves the fallback for what it
+        // was meant for -- genuinely non-LayerBase weight storage.
+        PrepareParameterSurface(AiDotNet.Models.Parameters.ParameterSurfaceIntent.Read);
+
         long total = 0;
-        foreach (var slot in EnumerateParameterValueSlots())
+        foreach (var slot in EnumerateParameterStateValueSlots())
         {
             slots.Add(slot);
             total += slot.ScalarCount;
@@ -914,19 +921,23 @@ public virtual void SetParameterChunks(IEnumerable<Tensor<T>> chunks)
             // only tensor REFERENCES (no flat aggregate / no per-tensor data copy), so this stays
             // flat-free — matching the buffer-then-single-SetParameters atomicity of the legacy branch
             // and VAEModelBase/DiffusionModelBase without reintroducing the flat-vector OOM.
-            var pairs = new List<(Tensor<T> Src, LayerBase<T>.TrainableParameterValueSlot Dst)>(slots.Count);
-            foreach (var dst in slots)
+            var pairs = new List<(Tensor<T> Src, LayerBase<T>.ParameterStateWriteTarget Dst)>(slots.Count);
+            for (int chunkIndex = 0; chunkIndex < slots.Count; chunkIndex++)
             {
+                var dst = slots[chunkIndex];
                 if (!e.MoveNext())
                     throw new ArgumentException(
-                        "SetParameterChunks received fewer chunks than the predictor has parameter tensors.",
+                        $"SetParameterChunks received fewer chunks than the predictor has parameter tensors " +
+                        $"(missing chunk {chunkIndex} of {slots.Count}).",
                         nameof(chunks));
                 var src = e.Current;
                 if (src is null)
-                    throw new ArgumentException("Chunk sequence contains a null tensor.", nameof(chunks));
+                    throw new ArgumentException(
+                        $"Chunk sequence contains a null tensor at index {chunkIndex}.", nameof(chunks));
                 if (src.Length != dst.ScalarCount)
                     throw new ArgumentException(
-                        $"SetParameterChunks chunk length {src.Length} does not match parameter length {dst.ScalarCount}.",
+                        $"SetParameterChunks chunk {chunkIndex} length {src.Length} does not match " +
+                        $"parameter length {dst.ScalarCount}.",
                         nameof(chunks));
                 pairs.Add((src, dst));
             }
@@ -1098,25 +1109,6 @@ protected void MaybeEngageWeightStreaming()
     {
         if (System.Threading.Volatile.Read(ref _streamingEngaged) != 0) return;
 
-        // Re-entry guard. Reading ParameterCount below walks EnumerateParameterValueSlots, which
-        // calls back into this method; returning early is correct rather than merely safe, because
-        // the outer call is already deciding and the inner one has nothing to add.
-        if (ReferenceEquals(_decidingStreamingEngagementFor, this)) return;
-
-        object? previousDeciding = _decidingStreamingEngagementFor;
-        _decidingStreamingEngagementFor = this;
-        try
-        {
-            MaybeEngageWeightStreamingCore();
-        }
-        finally
-        {
-            _decidingStreamingEngagementFor = previousDeciding;
-        }
-    }
-
-    private void MaybeEngageWeightStreamingCore()
-    {
         long threshold = StreamingThresholdOverride ?? DefaultStreamingThresholdParams;
         if (ParameterCount <= threshold) return;
 
@@ -1661,6 +1653,7 @@ public virtual Tensor<T> PredictNoiseWithEmbedding(Tensor<T> noisySample, Tensor
     /// Cache for timestep embeddings to avoid recomputing sinusoidal embeddings
     /// for the same timestep during the denoising loop.
     /// </summary>
+    [Scratch]
     private readonly Dictionary<int, Tensor<T>> _timestepEmbeddingCache = new();
 
     /// <inheritdoc />
@@ -1747,7 +1740,7 @@ public virtual ModelMetadata<T> GetModelMetadata()
     /// this explicit value read materializes lazy tensors and emits those concrete values.</remarks>
     public virtual Vector<T> GetParameters()
     {
-        EnsureParametersReadyGuarded();
+        PrepareParameterSurface(AiDotNet.Models.Parameters.ParameterSurfaceIntent.Read);
 
         long total = 0;
         var slots = EnumerateParameterValueSlots().ToList();
@@ -1775,7 +1768,7 @@ public virtual Vector<T> GetParameters()
     public virtual void SetParameters(Vector<T> parameters)
     {
         if (parameters is null) throw new ArgumentNullException(nameof(parameters));
-        EnsureParametersReadyGuarded();
+        PrepareParameterSurface(AiDotNet.Models.Parameters.ParameterSurfaceIntent.Restore);
 
         long expected = 0;
         var slots = EnumerateParameterValueSlots().ToList();
@@ -1815,6 +1808,13 @@ public virtual void SetParameters(Vector<T> parameters)
         }
     }
 
+    /// <summary>Marks a payload whose weights are streamed per tensor rather than flattened.</summary>
+    /// <remarks>
+    /// Negative on purpose: a payload written before streaming existed opens with a vector LENGTH,
+    /// so the reader can tell the two apart without a version field.
+    /// </remarks>
+    private const int ChunkedParameterMarker = -424242;
+
     /// <summary>
     /// COW clone lever (#1624): shares each trainable weight tensor's STORAGE with <paramref name="source"/>
     /// via the global <see cref="AiDotNet.Helpers.CopyOnWriteCloneHelper"/> (O(1)-until-write), instead of
@@ -1826,6 +1826,10 @@ public virtual void SetParameters(Vector<T> parameters)
     protected bool TryShareParametersFrom(NoisePredictorBase<T> source)
         => AiDotNet.Helpers.CopyOnWriteCloneHelper.TryShareTrainableParameters<T>(source, this);
 
+    private bool TryShareParametersFrom(NoisePredictorBase<T> source, out string mismatch)
+        => AiDotNet.Helpers.CopyOnWriteCloneHelper.TryShareTrainableParameters<T>(
+            source, this, out mismatch);
+
     /// <inheritdoc />
     public virtual IFullModel<T, Tensor<T>, Tensor<T>> WithParameters(Vector<T> parameters)
     {
@@ -1845,12 +1849,15 @@ public virtual byte[] Serialize()
         ModelPersistenceGuard.EnforceBeforeSerialize();
         using var stream = new MemoryStream();
         SaveState(stream);
-        return stream.ToArray();
+        return AiDotNet.Models.ModelStateEnvelope.Append(DeclaredState, stream.ToArray());
     }
 
     /// <inheritdoc />
     public virtual void Deserialize(byte[] data)
     {
+        // Strips and applies any declared-state trailer, so the body below reads the payload
+        // exactly as it did before this existed.
+        data = AiDotNet.Models.ModelStateEnvelope.Extract(DeclaredState, data);
         ThrowIfDisposed();
         ModelPersistenceGuard.EnforceBeforeDeserialize();
         using var stream = new MemoryStream(data);
@@ -1964,8 +1971,49 @@ public virtual void LoadState(Stream stream)
                 $"vs current ({InputChannels}, {OutputChannels}, {BaseChannels}, {TimeEmbeddingDim}).");
         }
 
-        // Load model parameters
-        SetParameters(SerializationHelper<T>.DeserializeVector(reader));
+        // Matches the writer above, and still reads a file written before it: a legacy payload opens
+        // with the vector length, so anything that is not the sentinel is handed to the flat reader
+        // with that length already consumed.
+        int parameterMarker = reader.ReadInt32();
+        if (parameterMarker == ChunkedParameterMarker)
+        {
+            int chunkCount = reader.ReadInt32();
+            var restored = new List<Tensor<T>>(chunkCount);
+            for (int c = 0; c < chunkCount; c++)
+            {
+                int length = reader.ReadInt32();
+                var values = new T[length];
+                for (int i = 0; i < length; i++)
+                {
+                    values[i] = NumOps.FromDouble(reader.ReadDouble());
+                }
+
+                restored.Add(new Tensor<T>(new[] { length }, new Vector<T>(values)));
+            }
+
+            SetParameterChunks(restored);
+        }
+        else
+        {
+            if (parameterMarker < 0)
+            {
+                throw new InvalidOperationException(
+                    $"Unsupported parameter payload marker: {parameterMarker}.");
+            }
+
+            // The legacy payload's vector length was already consumed above while distinguishing it
+            // from the chunked sentinel. DeserializeVector(reader, expectedLength) expects to read
+            // that prefix itself, so calling it here interpreted the first parameter bytes as a
+            // second length and failed for nested predictor state. Read the known-length body
+            // directly; ReadValue remains the exact inverse of SerializeVector's WriteValue for T.
+            var parameters = new Vector<T>(parameterMarker);
+            for (int i = 0; i < parameterMarker; i++)
+            {
+                parameters[i] = SerializationHelper<T>.ReadValue(reader);
+            }
+
+            SetParameters(parameters);
+        }
     }
 
     #endregion
@@ -2029,7 +2077,63 @@ public virtual Dictionary<string, T> GetFeatureImportance()
     #region ICloneable<IFullModel<T, Tensor<T>, Tensor<T>>> Implementation
 
     /// <inheritdoc />
-    public abstract IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy();
+    /// <remarks>
+    /// <para>
+    /// No longer abstract. Declaring it abstract here is what produced 267 hand-written DeepCopy and
+    /// Clone pairs across this family -- one per model, each re-listing the constructor arguments
+    /// its type happens to take. The clone plan records that constructor at compile time, so the
+    /// rebuild is the same code for every model and a new argument cannot be forgotten in 266 places.
+    /// </para>
+    /// <para>
+    /// Configuration is rebuilt, learned state is carried through the model's own Serialize and
+    /// Deserialize -- the public, overridable pair, so a model that persists something extra keeps
+    /// it. The guard is told this is an internal operation because a clone is not a save.
+    /// </para>
+    /// </remarks>
+    public virtual IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy()
+    {
+        using (ModelPersistenceGuard.InternalOperation())
+        {
+            var copy = (NoisePredictorBase<T>)AiDotNet.Models.CloneEngine.CopyConfiguration(this);
+
+            // Copy the weights CHUNK BY CHUNK rather than through Serialize/Deserialize. The
+            // roundtrip funnels every parameter into one MemoryStream, and a foundation-scale
+            // predictor crosses the CLR's ~2 GB single-array ceiling on the way in. That cost is
+            // why eleven predictors grew their own hand-written Clone() overrides, and those
+            // overrides are where cloning defects accumulated -- one of them decided whether to
+            // copy weights at all from a flag that records "a forward has run", so a freshly
+            // constructed model was cloned with its weights discarded. Making the base both
+            // correct and cheap is what lets those overrides be deleted rather than each fixed.
+            // Make copy-on-write the common predictor clone path instead of requiring each large
+            // predictor to repeat it in an override. The helper performs a complete structural and
+            // per-tensor shape preflight before it mutates the destination, so the streaming copy
+            // remains the correctness fallback for custom or otherwise non-isomorphic graphs.
+            bool shared = copy.TryShareParametersFrom(this, out string shareMismatch);
+            if (!shared)
+                copy.SetParameterChunks(GetParameterChunks());
+
+            var sourceLayout = ParameterLayout;
+            var copyLayout = copy.ParameterLayout;
+            // Restoring a clone may allocate storage for a shape-resolved lazy slot. That changes
+            // readiness but not the durable parameter schema. Reject identity, role, shape, type,
+            // ownership, availability, order, or declared-count changes; allow only that lifecycle
+            // transition, using the common manifest contract rather than a predictor override.
+            if (!string.Equals(sourceLayout.DeclaredLayoutFingerprint,
+                    copyLayout.DeclaredLayoutFingerprint,
+                    StringComparison.Ordinal))
+            {
+                throw new InvalidOperationException(
+                    $"Clone state transfer changed the parameter manifest for {GetType().Name}: "
+                    + $"source declared/materialized={sourceLayout.ParameterCount?.ToString() ?? "?"}/"
+                    + $"{sourceLayout.MaterializedParameterCount}, clone="
+                    + $"{copyLayout.ParameterCount?.ToString() ?? "?"}/{copyLayout.MaterializedParameterCount}. "
+                    + (shared ? "The copy-on-write transfer reported success."
+                        : $"Copy-on-write preflight rejected the clone because {shareMismatch}; "
+                          + "the streaming fallback did not restore an identical manifest."));
+            }
+            return copy;
+        }
+    }
 
     /// <inheritdoc />
     IFullModel<T, Tensor<T>, Tensor<T>> ICloneable<IFullModel<T, Tensor<T>, Tensor<T>>>.Clone()
@@ -2041,7 +2145,7 @@ IFullModel<T, Tensor<T>, Tensor<T>> ICloneable<IFullModel<T, Tensor<T>, Tensor<T
     /// Creates a deep copy of the noise predictor.
     /// </summary>
     /// <returns>A new instance with the same parameters.</returns>
-    public abstract INoisePredictor<T> Clone();
+    public virtual INoisePredictor<T> Clone() => (INoisePredictor<T>)DeepCopy();
 
     #endregion
 
diff --git a/src/Diffusion/NoisePredictors/SiTPredictor.cs b/src/Diffusion/NoisePredictors/SiTPredictor.cs
index 13a270a522..cc30a92278 100644
--- a/src/Diffusion/NoisePredictors/SiTPredictor.cs
+++ b/src/Diffusion/NoisePredictors/SiTPredictor.cs
@@ -90,18 +90,4 @@ public SiTPredictor(
         _sitSeed = seed;
     }
 
-    /// <inheritdoc />
-    public override INoisePredictor<T> Clone()
-    {
-        var clone = new SiTPredictor<T>(_sitInputChannels, _sitHiddenSize, _sitNumLayers, _sitNumHeads, _sitSeed);
-        // #1711: DiT LazyDense weights resolve via the FORWARD path, so a naive
-        // SetParameters(GetParameters()) / COW clone re-RNG-initializes on its first forward and
-        // diverges from the source. Use the base DiT clone semantics (probe-forward + copy), which
-        // also no-ops cleanly when the source has no materialized weights.
-        ProbeMaterializeAndCopyInto(clone);
-        return clone;
-    }
-
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
 }
diff --git a/src/Diffusion/NoisePredictors/TemporalModule3DLayer.cs b/src/Diffusion/NoisePredictors/TemporalModule3DLayer.cs
index 57269e91d5..75f4e8fda9 100644
--- a/src/Diffusion/NoisePredictors/TemporalModule3DLayer.cs
+++ b/src/Diffusion/NoisePredictors/TemporalModule3DLayer.cs
@@ -15,7 +15,7 @@ namespace AiDotNet.Diffusion.NoisePredictors;
 /// remains independent of the number of frames supplied at runtime.
 /// </remarks>
 [ElementWiseShape(Note = "Residual temporal module preserves NCFHW shape at every frame count.")]
-public sealed class TemporalModule3DLayer<T> : LayerBase<T>
+public sealed partial class TemporalModule3DLayer<T> : LayerBase<T>
 {
     private readonly int _channels;
     private readonly int _timeEmbeddingDim;
@@ -158,14 +158,7 @@ public override void ResetState()
         foreach (var layer in ParameterLayers()) layer.ResetState();
     }
 
-    /// <inheritdoc />
-    public override LayerBase<T> Clone()
-    {
-        var clone = new TemporalModule3DLayer<T>(_channels, _timeEmbeddingDim, _spatialSize);
-        var parameters = GetParameters();
-        if (parameters.Length > 0) clone.SetParameters(parameters);
-        return clone;
-    }
+
 
     /// <inheritdoc />
     internal override Dictionary<string, string> GetMetadata()
diff --git a/src/Diffusion/NoisePredictors/UNetNoisePredictor.cs b/src/Diffusion/NoisePredictors/UNetNoisePredictor.cs
index 3f523cd1aa..deb9ba3ecb 100644
--- a/src/Diffusion/NoisePredictors/UNetNoisePredictor.cs
+++ b/src/Diffusion/NoisePredictors/UNetNoisePredictor.cs
@@ -55,25 +55,9 @@ namespace AiDotNet.Diffusion.NoisePredictors;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
     [ResearchPaper("Denoising Diffusion Probabilistic Models", "https://arxiv.org/abs/2006.11239")]
-public class UNetNoisePredictor<T> : NoisePredictorBase<T>
+public partial class UNetNoisePredictor<T> : NoisePredictorBase<T>
 {
 
-    /// <inheritdoc />
-    /// <remarks>The SAME resolution the write path uses. Reading through the shape-only
-    /// ResolveShapesViaForward instead left seven lazy layers reporting zero, so restoring the
-    /// model grew it from 3,146,496 to 5,006,595.</remarks>
-    protected override void EnsureParametersReady()
-    {
-        TriggerLazyShapeResolution();
-    }
-
-    /// <inheritdoc />
-    protected override void EnsureParameterStructureReady()
-    {
-        // Run the real topology in shape-inference mode. This resolves decoder-concat and
-        // attention dimensions without allocating the paper-scale U-Net's weight tensors.
-        ResolveShapesViaForward();
-    }
     /// <summary>
     /// Channel multipliers for each resolution level.
     /// </summary>
@@ -123,11 +107,13 @@ protected override void EnsureParameterStructureReady()
     /// <summary>
     /// Cached input for backward pass.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastInput;
 
     /// <summary>
     /// Cached output for backward pass.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastOutput;
 
     /// <summary>
@@ -301,12 +287,14 @@ public UNetNoisePredictor(
             encoderBlocks is { Count: > 0 } &&
             middleBlocks is { Count: > 0 } &&
             decoderBlocks is { Count: > 0 };
-        bool hasCustomArchitecture = architecture?.Layers is { Count: > 0 };
-
-        if (hasCustomBlocks || hasCustomArchitecture)
-        {
-            InitializeLayers(architecture, encoderBlocks, middleBlocks, decoderBlocks);
-        }
+        // Building the module graph is allocation-free: every paper-scale weight uses a lazy
+        // factory below. Construct it once here so parameter/layout/clone code can discover the
+        // same graph mechanically without a model-specific readiness override.
+        InitializeLayers(
+            architecture,
+            hasCustomBlocks ? encoderBlocks : null,
+            hasCustomBlocks ? middleBlocks : null,
+            hasCustomBlocks ? decoderBlocks : null);
     }
 
     [MemberNotNull(nameof(_inputConv), nameof(_outputConv), nameof(_timeEmbedMlp1), nameof(_timeEmbedMlp2))]
@@ -350,23 +338,21 @@ private void InitializeLayers(
             return;
         }
 
-        // Create input/output convolutions and time embedding MLP via LayerHelper
-        var baseLayers = LayerHelper<T>.CreateUNetNoisePredictorEncoderLayers(
-            _inputChannels, _baseChannels, _channelMultipliers, _numResBlocks,
-            _contextDim, _numHeads).ToList();
-
-        // First layer is input conv, next two are time embedding MLP
-        _inputConv = (ConvolutionalLayer<T>)baseLayers[0];
-        _timeEmbedMlp1 = (DenseLayer<T>)baseLayers[1];
-        _timeEmbedMlp2 = (DenseLayer<T>)baseLayers[2];
-
-        // input/output convs are left fully lazy; the predictor's shape-only forward
-        // (ResolveShapesViaForward) resolves their true InputDepth from the topology.
-
-        // Output conv from decoder layers
-        var decoderBaseLayers = LayerHelper<T>.CreateUNetNoisePredictorDecoderLayers(
-            _outputChannels, _baseChannels, _channelMultipliers, _numResBlocks).ToList();
-        _outputConv = (ConvolutionalLayer<T>)decoderBaseLayers[^1];
+        // All four fan-ins are fixed by the U-Net architecture. These factories record their
+        // exact shapes without allocating values, so metadata stays cheap while the shared layer
+        // lifecycle can materialize reads/restores without a dummy forward.
+        _inputConv = LazyConv2D(
+            _inputChannels, _inputHeight, _inputHeight, _baseChannels,
+            kernelSize: 3, stride: 1, padding: 1,
+            activation: new IdentityActivation<T>());
+        _timeEmbedMlp1 = LazyDense(
+            _timeEmbeddingDim, _timeEmbeddingDim, new ReLUActivation<T>());
+        _timeEmbedMlp2 = LazyDense(
+            _timeEmbeddingDim, _timeEmbeddingDim, new ReLUActivation<T>());
+        _outputConv = LazyConv2D(
+            _baseChannels * _channelMultipliers[0], _inputHeight, _inputHeight, _outputChannels,
+            kernelSize: 3, stride: 1, padding: 1,
+            activation: new IdentityActivation<T>());
 
         // Priority 1: Use custom blocks passed directly
         if (customEncoderBlocks != null && customEncoderBlocks.Count > 0 &&
@@ -1204,7 +1190,8 @@ private ILayer<T> CreateUpsample(int channels, int spatialSize)
     {
         // spatialSize here is the current (smaller) spatial size before upsampling.
         // Fully lazy: shape resolved by the predictor's shape-only forward.
-        return new DeconvolutionalLayer<T>(
+        return DeconvolutionalLayer<T>.WithInputDepth(
+            inputDepth: channels,
             outputDepth: channels,
             kernelSize: 4,
             stride: 2,
@@ -1348,52 +1335,6 @@ private void SetBlockParameters(UNetBlock block, Vector<T> parameters, ref int i
 
     #region ICloneable Implementation
 
-    /// <inheritdoc />
-    public override INoisePredictor<T> Clone()
-    {
-        var clone = new UNetNoisePredictor<T>(
-            architecture: _architecture,
-            inputChannels: _inputChannels,
-            outputChannels: _outputChannels,
-            baseChannels: _baseChannels,
-            channelMultipliers: _channelMultipliers,
-            numResBlocks: _numResBlocks,
-            attentionResolutions: _attentionResolutions,
-            contextDim: _contextDim,
-            numHeads: _numHeads,
-            inputHeight: _inputHeight,
-            lossFunction: LossFunction);
-
-        // Keep default paper-scale lazy constructors lazy. Already-materialized
-        // eager tensors are still copied, but lazy tensors are resolved only
-        // after a forward pass or explicit SetParameters has established
-        // runtime weight state.
-        if (_preserveMaterializedParameters)
-        {
-            clone.TriggerLazyShapeResolution();
-            // Preserve the complete trainable tensor graph. A per-layer
-            // GetParameters/SetParameters round-trip is not equivalent here:
-            // composite U-Net layers expose nested tensors through
-            // ITrainableLayer, and flattening only the parent layer can leave
-            // inference-visible child state at the clone's initialization.
-            // COW also avoids allocating a second foundation-scale parameter
-            // vector; the chunk fallback remains the safe eager path when the
-            // materialized source/clone graphs do not line up exactly.
-            if (!clone.TryShareParametersFrom(this))
-                clone.SetParameterChunks(GetParameterChunks());
-        }
-        else
-        {
-            if (_layersInitialized)
-            {
-                clone.EnsureLayersInitialized();
-            }
-
-            CopyMaterializedParametersTo(clone);
-        }
-        return clone;
-    }
-
     private void CopyMaterializedParametersTo(UNetNoisePredictor<T> clone)
         => CopyMaterializedParametersTo(clone, this);
 
@@ -1474,12 +1415,11 @@ internal void TriggerLazyShapeResolution()
         // stage (2^stages, doubled so the bottleneck stays >= 2) allocates the
         // identical weight tensors with trivial compute. Cap at _inputHeight so
         // models whose native size is already small aren't enlarged.
-        int numDownsamples = System.Math.Max(0, _channelMultipliers.Length - 1);
-        int safeSpatial = System.Math.Max(2, (1 << numDownsamples) * 2);
-        int resolveSpatial = System.Math.Min(_inputHeight, safeSpatial);
-        if (resolveSpatial < 1) resolveSpatial = _inputHeight;
-
-        var dummy = new Tensor<T>(new[] { 1, _inputChannels, resolveSpatial, resolveSpatial });
+        // Shape inference is allocation-free, so it must use the configured extent. Several
+        // composite blocks legitimately declare that spatial shape at construction; probing a
+        // smaller tensor made the symbolic path add a configured [H,W] residual to a probe-sized
+        // [h,w] branch when a fresh clone prepared its destination manifest.
+        var dummy = new Tensor<T>(new[] { 1, _inputChannels, _inputHeight, _inputHeight });
         Tensor<T>? dummyCtx = _contextDim > 0
             ? new Tensor<T>(new[] { 1, 1, _contextDim })
             : null;
@@ -1518,18 +1458,14 @@ internal void ResolveShapesViaForward()
         LayerBase<T>.RunShapeInference(() => { _ = PredictNoise(dummy, timestep: 0, conditioning: dummyCtx); });
     }
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy()
-    {
-        return Clone();
-    }
-
     #endregion
 
     #region Layer-Level Backpropagation
 
     // Skip connections saved during forward for proper gradient splitting
+    [Scratch]
     private List<Tensor<T>>? _lastSkips;
+    [Scratch]
     private Tensor<T>? _lastTimeEmbed;
 
     /// <summary>
diff --git a/src/Diffusion/NoisePredictors/UViTNoisePredictor.cs b/src/Diffusion/NoisePredictors/UViTNoisePredictor.cs
index ffbc2d107b..ad88664a76 100644
--- a/src/Diffusion/NoisePredictors/UViTNoisePredictor.cs
+++ b/src/Diffusion/NoisePredictors/UViTNoisePredictor.cs
@@ -55,7 +55,7 @@ namespace AiDotNet.Diffusion.NoisePredictors;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
     [ResearchPaper("All are Worth Words: A ViT Backbone for Diffusion Models", "https://arxiv.org/abs/2209.12152")]
-public class UViTNoisePredictor<T> : NoisePredictorBase<T>
+public partial class UViTNoisePredictor<T> : NoisePredictorBase<T>
 {
     private readonly int _inputChannels;
     private readonly int _hiddenSize;
@@ -63,6 +63,7 @@ public class UViTNoisePredictor<T> : NoisePredictorBase<T>
     private readonly int _numHeads;
     private readonly int _patchSize;
     private readonly int _contextDim;
+    private readonly int _latentSpatialSize;
 
     /// <summary>
     /// Maximum number of patches (computed from latent size and patch size).
@@ -89,7 +90,9 @@ public class UViTNoisePredictor<T> : NoisePredictorBase<T>
     private DenseLayer<T> _outputProj;
 
     // Position embeddings
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T>? _posEmbed;
+    [Scratch]
     private Tensor<T>? _lastInput;
 
     /// <inheritdoc />
@@ -153,7 +156,12 @@ public UViTNoisePredictor(
         _numHeads = numHeads;
         _patchSize = patchSize;
         _contextDim = contextDim;
-        _maxPatches = (latentSpatialSize / patchSize) * (latentSpatialSize / patchSize);
+        // Preserve the constructor-level configuration, not only its derived patch count. The
+        // generated clone plan can carry an argument only from state the instance still owns;
+        // retaining the source value lets it reconstruct the same position/attention shapes
+        // without any UViT-specific clone method.
+        _latentSpatialSize = latentSpatialSize;
+        _maxPatches = (_latentSpatialSize / patchSize) * (_latentSpatialSize / patchSize);
 
         _encoderBlocks = [];
         _decoderBlocks = [];
@@ -174,7 +182,10 @@ private void InitializeLayers()
         _patchEmbed = LazyDense(patchDim, _hiddenSize);
 
         // Time embedding MLP
-        _timeEmbed1 = LazyDense(_hiddenSize, timeEmbedDim, new SiLUActivation<T>());
+        // NoisePredictorBase emits [1, TimeEmbeddingDim], so the first projection's fan-in is
+        // architecture-known. Declaring hiddenSize here made a fresh clone materialize 32x128 while
+        // the first real forward correctly rebuilt the source as 128x128.
+        _timeEmbed1 = LazyDense(timeEmbedDim, timeEmbedDim, new SiLUActivation<T>());
         _timeEmbed2 = LazyDense(timeEmbedDim, _hiddenSize);
 
         // Encoder blocks
@@ -195,7 +206,7 @@ private void InitializeLayers()
         }
 
         // Final norm and output
-        _finalNorm = new LayerNormalizationLayer<T>();
+        _finalNorm = LazyLayerNorm(_hiddenSize);
         int outPatchDim = _inputChannels * _patchSize * _patchSize;
         _outputProj = LazyDense(_hiddenSize, outPatchDim);
 
@@ -215,9 +226,9 @@ private UViTBlock CreateBlock()
     {
         return new UViTBlock
         {
-            Norm1 = new LayerNormalizationLayer<T>(),
+            Norm1 = LazyLayerNorm(_hiddenSize),
             Attention = LazySelfAttention(_maxPatches, _hiddenSize, _numHeads),
-            Norm2 = new LayerNormalizationLayer<T>(),
+            Norm2 = LazyLayerNorm(_hiddenSize),
             MLP1 = LazyDense(_hiddenSize, _hiddenSize * 4, new GELUActivation<T>()),
             MLP2 = LazyDense(_hiddenSize * 4, _hiddenSize)
         };
@@ -551,39 +562,6 @@ private static int SetLayerParams(ILayer<T> layer, Vector<T> parameters, int off
 
     #endregion
 
-    /// <inheritdoc />
-    public override INoisePredictor<T> Clone()
-    {
-        var clone = new UViTNoisePredictor<T>(
-            inputChannels: _inputChannels,
-            hiddenSize: _hiddenSize,
-            numLayers: _numLayers,
-            numHeads: _numHeads,
-            patchSize: _patchSize,
-            contextDim: _contextDim);
-        // The block attention layers only allocate weights on the first Forward; a fresh clone has
-        // resolved shapes but unallocated weights, so SetParameters/SetParameterChunks would land into
-        // nothing and the clone would re-RNG-init on its first real forward, diverging from the source.
-        // When the source has been materialized, probe-forward the clone through the same path first so
-        // the weights exist, THEN copy. Mirrors MMDiTXNoisePredictor.Clone.
-        if (_patchEmbed.IsInitialized)
-        {
-            int probeSpatial = (int)System.Math.Sqrt(_maxPatches) * _patchSize;
-            var probe = new Tensor<T>(new[] { 1, _inputChannels, probeSpatial, probeSpatial });
-            clone.PredictNoise(probe, timestep: 0, conditioning: null);
-        }
-        // _posEmbed is a random-init Tensor<T> field that is NOT part of Get/SetParameters and is not a
-        // trainable layer, so neither the COW share nor the SetParameters fallback below copies it —
-        // without this the clone keeps its own RNG-drawn positional embedding and diverges from the
-        // source. Copy-on-write share it (O(1) until either side writes).
-        if (_posEmbed is not null) clone._posEmbed = (Tensor<T>)_posEmbed.CloneShared();
-        if (!clone.TryShareParametersFrom(this)) clone.SetParameterChunks(GetParameterChunks());
-        return clone;
-    }
-
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
     protected override Vector<T> GetParameterGradients()
     {
         var allGrads = new List<T>();
diff --git a/src/Diffusion/NoisePredictors/VideoTransformer3DLayer.cs b/src/Diffusion/NoisePredictors/VideoTransformer3DLayer.cs
index b53581cea6..12e0a30f8e 100644
--- a/src/Diffusion/NoisePredictors/VideoTransformer3DLayer.cs
+++ b/src/Diffusion/NoisePredictors/VideoTransformer3DLayer.cs
@@ -14,7 +14,7 @@ namespace AiDotNet.Diffusion.NoisePredictors;
 /// outer residual. The implementation accepts arbitrary frame counts.
 /// </remarks>
 [ElementWiseShape(Note = "Released Transformer3D residual block preserves NCFHW shape.")]
-public sealed class VideoTransformer3DLayer<T> : LayerBase<T>
+public sealed partial class VideoTransformer3DLayer<T> : LayerBase<T>
 {
     private readonly int _channels;
     private readonly int _contextDimension;
@@ -230,15 +230,7 @@ public override void ResetState()
         foreach (var layer in ParameterLayers()) layer.ResetState();
     }
 
-    /// <inheritdoc />
-    public override LayerBase<T> Clone()
-    {
-        var clone = new VideoTransformer3DLayer<T>(
-            _channels, _contextDimension, _headCount, _spatialSize, _onlyCrossAttention);
-        var parameters = GetParameters();
-        if (parameters.Length > 0) clone.SetParameters(parameters);
-        return clone;
-    }
+
 
     /// <inheritdoc />
     internal override Dictionary<string, string> GetMetadata()
diff --git a/src/Diffusion/NoisePredictors/VideoUNetPredictor.cs b/src/Diffusion/NoisePredictors/VideoUNetPredictor.cs
index 8af3e38796..0dbb932edc 100644
--- a/src/Diffusion/NoisePredictors/VideoUNetPredictor.cs
+++ b/src/Diffusion/NoisePredictors/VideoUNetPredictor.cs
@@ -68,20 +68,8 @@ namespace AiDotNet.Diffusion.NoisePredictors;
 [ModelComplexity(ModelComplexity.VeryHigh)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
     [ResearchPaper("Video Diffusion Models", "https://arxiv.org/abs/2204.03458")]
-public class VideoUNetPredictor<T> : NoisePredictorBase<T>
+public partial class VideoUNetPredictor<T> : NoisePredictorBase<T>
 {
-
-    /// <inheritdoc />
-    /// <remarks>Lazy weights, same reasoning as UNetNoisePredictor.</remarks>
-    protected override void EnsureParametersReady()
-    {
-        // A concatenated image condition changes the entry convolution from C to C+conditionC.
-        // Resolve through that real public path; an unconditioned dummy would resize the lazy
-        // convolution back to C and make ParameterCount disagree with GetParameters by exactly the
-        // missing condition-channel kernel slice.
-        TriggerLazyShapeResolution(
-            includeImageConditioning: _supportsImageConditioning && _concatenateImageCondition);
-    }
     /// <summary>
     /// Channel multipliers for each resolution level.
     /// </summary>
@@ -156,6 +144,7 @@ protected override void EnsureParametersReady()
     /// <summary>
     /// Cached input for backward pass.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastInput;
 
     /// <summary>
@@ -1903,73 +1892,13 @@ public override void SetParameters(Vector<T> parameters)
 
     #endregion
 
-    #region ICloneable Implementation
-
-    /// <inheritdoc />
-    public override INoisePredictor<T> Clone()
-    {
-        var clone = new VideoUNetPredictor<T>(
-            _inputChannels,
-            _outputChannels,
-            _baseChannels,
-            _channelMultipliers,
-            _numResBlocks,
-            _attentionResolutions,
-            _numTemporalLayers,
-            _contextDim,
-            _numHeads,
-            _supportsImageConditioning,
-            _inputHeight,
-            _inputWidth,
-            _numFrames,
-            _clipTokenLength,
-            LossFunction,
-            seed: null,
-            imageConditionChannels: _imageConditionChannels,
-            concatenateImageCondition: _concatenateImageCondition,
-            numClassEmbeddings: _numClassEmbeddings,
-            architectureProfile: _architectureProfile);
-
-        // Resolve the SOURCE's lazy layers so each source layer reports its real
-        // parameter shape below. The source's resolving forward packs its OWN
-        // (correct) weights, so the source stays self-consistent.
-        TriggerLazyShapeResolution(
-            includeImageConditioning: _supportsImageConditioning && _concatenateImageCondition);
-
-        bool sourceUsedVideo = _lazyShapeResolvedWithVideo;
-        bool sourceUsedTextConditioning = _lazyShapeResolvedWithTextConditioning;
-        bool sourceUsedImageConditioning = _lazyShapeResolvedWithImageConditioning;
-
-        // Materialize the clone with the same execution path, then copy values into its existing
-        // tensors. This preserves layer-owned caches and avoids relying on SetParameters to infer
-        // a lazy tensor's shape from a flat length (which is ambiguous for grouped/deconvolutional
-        // kernels and caused output-divergent clones).
-        clone.TriggerLazyShapeResolution(
-            sourceUsedVideo,
-            sourceUsedTextConditioning,
-            sourceUsedImageConditioning);
-        using (var srcEnum = EnumerateLayersInParameterOrder().GetEnumerator())
-        using (var cloneEnum = clone.EnumerateLayersInParameterOrder().GetEnumerator())
-        {
-            while (srcEnum.MoveNext() && cloneEnum.MoveNext())
-            {
-                var srcLayer = srcEnum.Current;
-                var cloneLayer = cloneEnum.Current;
-                if (srcLayer is null || cloneLayer is null)
-                    continue;
-                cloneLayer.SetParameters(srcLayer.GetParameters());
-            }
-        }
-        return clone;
-    }
+    #region Lazy Shape Resolution
 
     /// <summary>
     /// Runs a single dummy forward through the network at the configured
     /// spatial / frame size so every lazy layer (time-embedding MLPs,
     /// temporal + cross attention, and the image-condition projection)
-    /// resolves its weight shapes. Used by <see cref="Clone"/> to make the
-    /// clone's layer parameter counts match the original's before
-    /// <see cref="SetParameters"/> copies weights across. Mirrors
+    /// resolves its weight shapes for the shared parameter lifecycle. Mirrors
     /// UNetNoisePredictor.TriggerLazyShapeResolution.
     /// </summary>
     internal void TriggerLazyShapeResolution(
@@ -2058,12 +1987,6 @@ internal void TriggerLazyShapeResolution(
         _ = PredictNoise(dummy, timestep: 0, conditioning: textConditioning);
     }
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy()
-    {
-        return Clone();
-    }
-
     #endregion
 
     #region Layer-Level Backpropagation
diff --git a/src/Diffusion/Panorama/CubeDiffModel.cs b/src/Diffusion/Panorama/CubeDiffModel.cs
index 5f0297202b..85a6946c8e 100644
--- a/src/Diffusion/Panorama/CubeDiffModel.cs
+++ b/src/Diffusion/Panorama/CubeDiffModel.cs
@@ -91,27 +91,6 @@ private void InitializeLayers(UNetNoisePredictor<T>? predictor, StandardVAE<T>?
 
 
 
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    public override IDiffusionModel<T> Clone()
-    {
-        // Clone the ACTUAL predictor and VAE (mirrors MultiDiffusionModel/SpotDiffusionModel): the
-        // previous code passed only conditioner/seed, so the clone rebuilt the DEFAULT-sized UNet/VAE
-        // while this model may hold a custom-sized predictor/vae, making GetParameters() mismatch and
-        // clone.SetParameters throw "Expected X, got Y". Pass the cloned predictor/VAE (+ same
-        // architecture/options/scheduler) so the clone is structurally identical to the source.
-        var clone = new CubeDiffModel<T>(
-            architecture: Architecture,
-            options: Options as DiffusionModelOptions<T>,
-            scheduler: Scheduler,
-            predictor: (UNetNoisePredictor<T>)_predictor.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner,
-            seed: null);
-        if (!clone.TryShareParametersFrom(this)) clone.SetParameterChunks(GetParameterChunks());
-        return clone;
-    }
-
     public override ModelMetadata<T> GetModelMetadata()
     {
         var m = new ModelMetadata<T> { Name = "CubeDiff", Version = "1.0",
diff --git a/src/Diffusion/Panorama/DiffPanoModel.cs b/src/Diffusion/Panorama/DiffPanoModel.cs
index 0f56e1d20e..ebcfce7d38 100644
--- a/src/Diffusion/Panorama/DiffPanoModel.cs
+++ b/src/Diffusion/Panorama/DiffPanoModel.cs
@@ -113,29 +113,6 @@ private void InitializeLayers(UNetNoisePredictor<T>? predictor, StandardVAE<T>?
 
 
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        // Fast path: O(1) copy-on-write share when the default clone is structurally identical
-        // (the common foundation-scale case the COW lever targets — no re-materialization/OOM).
-        var clone = new DiffPanoModel<T>(conditioner: _conditioner, seed: null);
-        if (clone.TryShareParametersFrom(this)) return clone;
-        // Structure mismatch ⇒ custom architecture/predictor/VAE the default clone can't reproduce;
-        // rebuild faithfully from this instance's configuration so the clone is observationally
-        // identical instead of throwing on a parameter-count mismatch.
-        return new DiffPanoModel<T>(
-            architecture: Architecture,
-            options: (DiffusionModelOptions<T>)Options,
-            scheduler: Scheduler,
-            predictor: (UNetNoisePredictor<T>)_predictor.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner,
-            seed: null);
-    }
-
     /// <inheritdoc />
     public override ModelMetadata<T> GetModelMetadata()
     {
diff --git a/src/Diffusion/Panorama/MultiDiffusionModel.cs b/src/Diffusion/Panorama/MultiDiffusionModel.cs
index ada1ec9456..5dcdf37efe 100644
--- a/src/Diffusion/Panorama/MultiDiffusionModel.cs
+++ b/src/Diffusion/Panorama/MultiDiffusionModel.cs
@@ -97,28 +97,6 @@ private void InitializeLayers(UNetNoisePredictor<T>? predictor, StandardVAE<T>?
 
 
 
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    public override IDiffusionModel<T> Clone()
-    {
-        // Clone the ACTUAL predictor and VAE — the previous code passed neither, so the new instance
-        // rebuilt InitializeLayers' DEFAULT foundation-scale UNet (320 base channels, ~643 M params)
-        // while this model may hold a small/custom predictor (e.g. a test-scale UNet, ~10 M params).
-        // GetParameters() then returned the source's param count and clone.SetParameters threw
-        // "Expected 643774499 parameters, got 10342915". Passing the cloned predictor/VAE (and the
-        // same architecture/options/scheduler) makes the clone structurally identical to the source.
-        var clone = new MultiDiffusionModel<T>(
-            architecture: Architecture,
-            options: Options as DiffusionModelOptions<T>,
-            scheduler: Scheduler,
-            predictor: (UNetNoisePredictor<T>)_predictor.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner,
-            seed: null);
-        if (!clone.TryShareParametersFrom(this)) clone.SetParameterChunks(GetParameterChunks());
-        return clone;
-    }
-
     public override ModelMetadata<T> GetModelMetadata()
     {
         var m = new ModelMetadata<T> { Name = "MultiDiffusion", Version = "1.0",
diff --git a/src/Diffusion/Panorama/SpotDiffusionModel.cs b/src/Diffusion/Panorama/SpotDiffusionModel.cs
index 6ba2dedec3..9d64cfc0d2 100644
--- a/src/Diffusion/Panorama/SpotDiffusionModel.cs
+++ b/src/Diffusion/Panorama/SpotDiffusionModel.cs
@@ -97,25 +97,6 @@ private void InitializeLayers(UNetNoisePredictor<T>? predictor, StandardVAE<T>?
 
 
 
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    public override IDiffusionModel<T> Clone()
-    {
-        // Clone the ACTUAL predictor/VAE: passing neither rebuilt the default foundation-scale UNet
-        // (~643 M params) while the source may hold a small/custom predictor (~10 M), so
-        // SetParameters threw "Expected 643774499 parameters, got 10342915". See MultiDiffusionModel.
-        var clone = new SpotDiffusionModel<T>(
-            architecture: Architecture,
-            options: Options as DiffusionModelOptions<T>,
-            scheduler: Scheduler,
-            predictor: (UNetNoisePredictor<T>)_predictor.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner,
-            seed: null);
-        if (!clone.TryShareParametersFrom(this)) clone.SetParameterChunks(GetParameterChunks());
-        return clone;
-    }
-
     public override ModelMetadata<T> GetModelMetadata()
     {
         var m = new ModelMetadata<T> { Name = "SpotDiffusion", Version = "1.0",
diff --git a/src/Diffusion/Panorama/StitchDiffusionModel.cs b/src/Diffusion/Panorama/StitchDiffusionModel.cs
index 2215f1f98a..063446fbde 100644
--- a/src/Diffusion/Panorama/StitchDiffusionModel.cs
+++ b/src/Diffusion/Panorama/StitchDiffusionModel.cs
@@ -94,25 +94,6 @@ private void InitializeLayers(UNetNoisePredictor<T>? predictor, StandardVAE<T>?
 
 
 
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    public override IDiffusionModel<T> Clone()
-    {
-        // Clone the ACTUAL predictor/VAE: passing neither rebuilt the default foundation-scale UNet
-        // (~643 M params) while the source may hold a small/custom predictor (~10 M), so
-        // SetParameters threw "Expected 643774499 parameters, got 10342915". See MultiDiffusionModel.
-        var clone = new StitchDiffusionModel<T>(
-            architecture: Architecture,
-            options: Options as DiffusionModelOptions<T>,
-            scheduler: Scheduler,
-            predictor: (UNetNoisePredictor<T>)_predictor.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner,
-            seed: null);
-        if (!clone.TryShareParametersFrom(this)) clone.SetParameterChunks(GetParameterChunks());
-        return clone;
-    }
-
     public override ModelMetadata<T> GetModelMetadata()
     {
         var m = new ModelMetadata<T> { Name = "StitchDiffusion", Version = "1.0",
diff --git a/src/Diffusion/Panorama/SyncDiffusionModel.cs b/src/Diffusion/Panorama/SyncDiffusionModel.cs
index 2ec45e6d14..07b642071e 100644
--- a/src/Diffusion/Panorama/SyncDiffusionModel.cs
+++ b/src/Diffusion/Panorama/SyncDiffusionModel.cs
@@ -94,19 +94,6 @@ private void InitializeLayers(UNetNoisePredictor<T>? predictor, StandardVAE<T>?
 
 
 
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    public override IDiffusionModel<T> Clone()
-    {
-        // Lazy-preserving Clone (recipe from #1596): delegate to the predictor's and VAE's own Clone()
-        // instead of rebuild-at-default-scale + SetParameters(GetParameters()), which re-randomizes
-        // the clone's unmaterialized lazy weights (and ignores an injected non-default variant).
-        return new SyncDiffusionModel<T>(
-            predictor: (UNetNoisePredictor<T>)_predictor.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner);
-    }
-
     public override ModelMetadata<T> GetModelMetadata()
     {
         var m = new ModelMetadata<T> { Name = "SyncDiffusion", Version = "1.0",
diff --git a/src/Diffusion/Schedulers/ConsistencyModelScheduler.cs b/src/Diffusion/Schedulers/ConsistencyModelScheduler.cs
index fbc52de611..10fd1a1b86 100644
--- a/src/Diffusion/Schedulers/ConsistencyModelScheduler.cs
+++ b/src/Diffusion/Schedulers/ConsistencyModelScheduler.cs
@@ -43,6 +43,7 @@ namespace AiDotNet.Diffusion.Schedulers;
 [PipelineStage(PipelineStage.Training)]
 public sealed class ConsistencyModelScheduler<T> : NoiseSchedulerBase<T>
 {
+    [AiDotNet.Attributes.Scratch]
     private Vector<T>? _sigmas;
     private readonly Random _random;
     private readonly double _sigmaMin;
diff --git a/src/Diffusion/Schedulers/DEISMultistepScheduler.cs b/src/Diffusion/Schedulers/DEISMultistepScheduler.cs
index 25c72544ce..b0549f7543 100644
--- a/src/Diffusion/Schedulers/DEISMultistepScheduler.cs
+++ b/src/Diffusion/Schedulers/DEISMultistepScheduler.cs
@@ -39,6 +39,7 @@ namespace AiDotNet.Diffusion.Schedulers;
 [PipelineStage(PipelineStage.Training)]
 public sealed class DEISMultistepScheduler<T> : NoiseSchedulerBase<T>
 {
+    [AiDotNet.Attributes.Scratch]
     private Vector<T>? _sigmas;
     private readonly List<Vector<T>> _modelOutputHistory = [];
     private readonly int _order;
diff --git a/src/Diffusion/Schedulers/DPMSolverMultistepScheduler.cs b/src/Diffusion/Schedulers/DPMSolverMultistepScheduler.cs
index a1c956c89b..48627b71d2 100644
--- a/src/Diffusion/Schedulers/DPMSolverMultistepScheduler.cs
+++ b/src/Diffusion/Schedulers/DPMSolverMultistepScheduler.cs
@@ -46,16 +46,19 @@ public sealed class DPMSolverMultistepScheduler<T> : NoiseSchedulerBase<T>
     /// <summary>
     /// Lambda values (log-SNR) for each inference timestep.
     /// </summary>
+    [AiDotNet.Attributes.Scratch]
     private Vector<T>? _lambdas;
 
     /// <summary>
     /// Alpha_t values for inference timesteps.
     /// </summary>
+    [AiDotNet.Attributes.Scratch]
     private Vector<T>? _alphaTs;
 
     /// <summary>
     /// Sigma_t values for inference timesteps.
     /// </summary>
+    [AiDotNet.Attributes.Scratch]
     private Vector<T>? _sigmaTs;
 
     /// <summary>
diff --git a/src/Diffusion/Schedulers/DPMSolverSDEScheduler.cs b/src/Diffusion/Schedulers/DPMSolverSDEScheduler.cs
index 80a6a7879a..d3e4585a16 100644
--- a/src/Diffusion/Schedulers/DPMSolverSDEScheduler.cs
+++ b/src/Diffusion/Schedulers/DPMSolverSDEScheduler.cs
@@ -37,7 +37,9 @@ namespace AiDotNet.Diffusion.Schedulers;
 [PipelineStage(PipelineStage.Training)]
 public sealed class DPMSolverSDEScheduler<T> : NoiseSchedulerBase<T>
 {
+    [AiDotNet.Attributes.Scratch]
     private Vector<T>? _sigmas;
+    [AiDotNet.Attributes.Scratch]
     private Vector<T>? _previousDerivative;
     private readonly Random _random;
 
diff --git a/src/Diffusion/Schedulers/DPMSolverSinglestepScheduler.cs b/src/Diffusion/Schedulers/DPMSolverSinglestepScheduler.cs
index 14b765fd65..157e473ce7 100644
--- a/src/Diffusion/Schedulers/DPMSolverSinglestepScheduler.cs
+++ b/src/Diffusion/Schedulers/DPMSolverSinglestepScheduler.cs
@@ -38,6 +38,7 @@ namespace AiDotNet.Diffusion.Schedulers;
 [PipelineStage(PipelineStage.Training)]
 public sealed class DPMSolverSinglestepScheduler<T> : NoiseSchedulerBase<T>
 {
+    [AiDotNet.Attributes.Scratch]
     private Vector<T>? _sigmas;
     private readonly Random _random;
 
diff --git a/src/Diffusion/Schedulers/EulerAncestralDiscreteScheduler.cs b/src/Diffusion/Schedulers/EulerAncestralDiscreteScheduler.cs
index 467474f034..ce9e7b5cd4 100644
--- a/src/Diffusion/Schedulers/EulerAncestralDiscreteScheduler.cs
+++ b/src/Diffusion/Schedulers/EulerAncestralDiscreteScheduler.cs
@@ -41,6 +41,7 @@ public sealed class EulerAncestralDiscreteScheduler<T> : NoiseSchedulerBase<T>
     /// <summary>
     /// Sigma values (noise levels) for each inference timestep.
     /// </summary>
+    [AiDotNet.Attributes.Scratch]
     private Vector<T>? _sigmas;
 
     /// <summary>
diff --git a/src/Diffusion/Schedulers/EulerDiscreteScheduler.cs b/src/Diffusion/Schedulers/EulerDiscreteScheduler.cs
index 45b86a071b..9d6d896157 100644
--- a/src/Diffusion/Schedulers/EulerDiscreteScheduler.cs
+++ b/src/Diffusion/Schedulers/EulerDiscreteScheduler.cs
@@ -40,6 +40,7 @@ public sealed class EulerDiscreteScheduler<T> : NoiseSchedulerBase<T>
     /// <summary>
     /// Sigma values (noise levels) for each inference timestep.
     /// </summary>
+    [AiDotNet.Attributes.Scratch]
     private Vector<T>? _sigmas;
 
     /// <summary>
diff --git a/src/Diffusion/Schedulers/FlowMatchingScheduler.cs b/src/Diffusion/Schedulers/FlowMatchingScheduler.cs
index d5452a61ea..1ebdf15e07 100644
--- a/src/Diffusion/Schedulers/FlowMatchingScheduler.cs
+++ b/src/Diffusion/Schedulers/FlowMatchingScheduler.cs
@@ -46,7 +46,7 @@ namespace AiDotNet.Diffusion.Schedulers;
 /// </remarks>
 [ComponentType(ComponentType.Scheduler)]
 [PipelineStage(PipelineStage.Training)]
-public sealed class FlowMatchingScheduler<T> : NoiseSchedulerBase<T>
+public sealed partial class FlowMatchingScheduler<T> : NoiseSchedulerBase<T>
 {
     /// <summary>
     /// Sigma values for each timestep (optional noise scaling for stochastic sampling).
@@ -59,6 +59,7 @@ public sealed class FlowMatchingScheduler<T> : NoiseSchedulerBase<T>
     /// <remarks>
     /// Maps integer timesteps to continuous t in [0, 1] where t=0 is clean and t=1 is noise.
     /// </remarks>
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T> _timeValues;
 
     /// <summary>
diff --git a/src/Diffusion/Schedulers/HeunDiscreteScheduler.cs b/src/Diffusion/Schedulers/HeunDiscreteScheduler.cs
index 85cc14cf40..84b95c05ee 100644
--- a/src/Diffusion/Schedulers/HeunDiscreteScheduler.cs
+++ b/src/Diffusion/Schedulers/HeunDiscreteScheduler.cs
@@ -42,6 +42,7 @@ public sealed class HeunDiscreteScheduler<T> : NoiseSchedulerBase<T>
     /// <summary>
     /// Sigma values (noise levels) for each inference timestep.
     /// </summary>
+    [AiDotNet.Attributes.Scratch]
     private Vector<T>? _sigmas;
 
     // Two-pass Heun state: stored between predictor (first call) and corrector (second call)
diff --git a/src/Diffusion/Schedulers/LMSDiscreteScheduler.cs b/src/Diffusion/Schedulers/LMSDiscreteScheduler.cs
index 9c3555ed14..13f79bd530 100644
--- a/src/Diffusion/Schedulers/LMSDiscreteScheduler.cs
+++ b/src/Diffusion/Schedulers/LMSDiscreteScheduler.cs
@@ -37,6 +37,7 @@ namespace AiDotNet.Diffusion.Schedulers;
 [PipelineStage(PipelineStage.Training)]
 public sealed class LMSDiscreteScheduler<T> : NoiseSchedulerBase<T>
 {
+    [AiDotNet.Attributes.Scratch]
     private Vector<T>? _sigmas;
     private readonly List<Vector<T>> _derivativeHistory = [];
     private readonly int _order;
diff --git a/src/Diffusion/Schedulers/PNDMScheduler.cs b/src/Diffusion/Schedulers/PNDMScheduler.cs
index f75536b80f..b2e2b1050d 100644
--- a/src/Diffusion/Schedulers/PNDMScheduler.cs
+++ b/src/Diffusion/Schedulers/PNDMScheduler.cs
@@ -55,6 +55,7 @@ public sealed class PNDMScheduler<T> : NoiseSchedulerBase<T>
     /// <summary>
     /// Current sample being processed (for Runge-Kutta steps).
     /// </summary>
+    [AiDotNet.Attributes.Scratch]
     private Vector<T>? _currentSample;
 
     /// <summary>
diff --git a/src/Diffusion/Schedulers/UniPCScheduler.cs b/src/Diffusion/Schedulers/UniPCScheduler.cs
index 561d53493a..f080d69b26 100644
--- a/src/Diffusion/Schedulers/UniPCScheduler.cs
+++ b/src/Diffusion/Schedulers/UniPCScheduler.cs
@@ -53,16 +53,19 @@ public sealed class UniPCScheduler<T> : NoiseSchedulerBase<T>
     /// <summary>
     /// Lambda values (log-SNR) for each inference timestep.
     /// </summary>
+    [AiDotNet.Attributes.Scratch]
     private Vector<T> _lambdas = new Vector<T>(0);
 
     /// <summary>
     /// Alpha_t values for inference timesteps.
     /// </summary>
+    [AiDotNet.Attributes.Scratch]
     private Vector<T> _alphaTs = new Vector<T>(0);
 
     /// <summary>
     /// Sigma_t values for inference timesteps.
     /// </summary>
+    [AiDotNet.Attributes.Scratch]
     private Vector<T> _sigmaTs = new Vector<T>(0);
 
     /// <summary>
diff --git a/src/Diffusion/StyleTransfer/ConsisLoRAModel.cs b/src/Diffusion/StyleTransfer/ConsisLoRAModel.cs
index 9c5098093a..efa31ac102 100644
--- a/src/Diffusion/StyleTransfer/ConsisLoRAModel.cs
+++ b/src/Diffusion/StyleTransfer/ConsisLoRAModel.cs
@@ -90,29 +90,6 @@ private void InitializeLayers(UNetNoisePredictor<T>? predictor, StandardVAE<T>?
 
 
 
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    public override IDiffusionModel<T> Clone()
-    {
-        // Fast path: O(1) copy-on-write share when the default-constructed clone is structurally
-        // identical to this instance (the common, foundation-scale case the COW lever targets — no
-        // flat re-materialization, no OOM).
-        var clone = new ConsisLoRAModel<T>(conditioner: _conditioner, seed: null);
-        if (clone.TryShareParametersFrom(this)) return clone;
-        // Structure mismatch ⇒ this instance was built with a custom architecture/predictor/VAE the
-        // default clone doesn't reproduce. Rebuild a structurally-faithful clone from THIS instance's
-        // configuration (predictor/VAE Clone() preserve their own structure + weights) so the result
-        // is observationally identical instead of throwing on a parameter-count mismatch.
-        return new ConsisLoRAModel<T>(
-            architecture: Architecture,
-            options: (DiffusionModelOptions<T>)Options,
-            scheduler: Scheduler,
-            predictor: (UNetNoisePredictor<T>)_predictor.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner,
-            seed: null);
-    }
-
     public override ModelMetadata<T> GetModelMetadata()
     {
         var m = new ModelMetadata<T> { Name = "ConsisLoRA", Version = "1.0",
diff --git a/src/Diffusion/StyleTransfer/InstantStyleModel.cs b/src/Diffusion/StyleTransfer/InstantStyleModel.cs
index 0936eb3dbb..eee2922289 100644
--- a/src/Diffusion/StyleTransfer/InstantStyleModel.cs
+++ b/src/Diffusion/StyleTransfer/InstantStyleModel.cs
@@ -214,27 +214,6 @@ private void InitializeLayers(UNetNoisePredictor<T>? predictor, StandardVAE<T>?
 
 
 
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    public override IDiffusionModel<T> Clone()
-    {
-        // Fast path: O(1) copy-on-write share when the default clone is structurally identical
-        // (the common foundation-scale case the COW lever targets — no re-materialization/OOM).
-        var clone = new InstantStyleModel<T>(conditioner: _conditioner, seed: null);
-        if (clone.TryShareParametersFrom(this)) return clone;
-        // Structure mismatch ⇒ custom architecture/predictor/VAE the default clone can't reproduce;
-        // rebuild faithfully from this instance's configuration so the clone is observationally
-        // identical instead of throwing on a parameter-count mismatch.
-        return new InstantStyleModel<T>(
-            architecture: Architecture,
-            options: (DiffusionModelOptions<T>)Options,
-            scheduler: Scheduler,
-            predictor: (UNetNoisePredictor<T>)_predictor.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner,
-            seed: null);
-    }
-
     public override ModelMetadata<T> GetModelMetadata()
     {
         var m = new ModelMetadata<T> { Name = "InstantStyle", Version = "1.0",
diff --git a/src/Diffusion/StyleTransfer/KLoRAStyleModel.cs b/src/Diffusion/StyleTransfer/KLoRAStyleModel.cs
index 9b9bad7d3f..130f0eca11 100644
--- a/src/Diffusion/StyleTransfer/KLoRAStyleModel.cs
+++ b/src/Diffusion/StyleTransfer/KLoRAStyleModel.cs
@@ -90,27 +90,6 @@ private void InitializeLayers(UNetNoisePredictor<T>? predictor, StandardVAE<T>?
 
 
 
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    public override IDiffusionModel<T> Clone()
-    {
-        // Fast path: O(1) copy-on-write share when the default clone is structurally identical
-        // (the common foundation-scale case the COW lever targets — no re-materialization/OOM).
-        var clone = new KLoRAStyleModel<T>(conditioner: _conditioner, seed: null);
-        if (clone.TryShareParametersFrom(this)) return clone;
-        // Structure mismatch ⇒ custom architecture/predictor/VAE the default clone can't reproduce;
-        // rebuild faithfully from this instance's configuration so the clone is observationally
-        // identical instead of throwing on a parameter-count mismatch.
-        return new KLoRAStyleModel<T>(
-            architecture: Architecture,
-            options: (DiffusionModelOptions<T>)Options,
-            scheduler: Scheduler,
-            predictor: (UNetNoisePredictor<T>)_predictor.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner,
-            seed: null);
-    }
-
     public override ModelMetadata<T> GetModelMetadata()
     {
         var m = new ModelMetadata<T> { Name = "K-LoRA Style", Version = "1.0",
diff --git a/src/Diffusion/StyleTransfer/RBModulationModel.cs b/src/Diffusion/StyleTransfer/RBModulationModel.cs
index b89fe6135c..0bb9f1fa36 100644
--- a/src/Diffusion/StyleTransfer/RBModulationModel.cs
+++ b/src/Diffusion/StyleTransfer/RBModulationModel.cs
@@ -94,27 +94,6 @@ private void InitializeLayers(UNetNoisePredictor<T>? predictor, StandardVAE<T>?
 
 
 
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    public override IDiffusionModel<T> Clone()
-    {
-        // Clone the ACTUAL predictor/VAE (see InstaFlowModel/MultiDiffusionModel): passing only
-        // conditioner/seed rebuilt InitializeLayers' DEFAULT-sized, lazily-unresolved sub-models, so once
-        // the source resolved its lazy layers via a forward pass the trainable-layer shapes no longer
-        // lined up 1:1 and Clone diverged. Cloning the resolved predictor/VAE (+ same architecture/
-        // options/scheduler) makes the clone structurally identical.
-        var clone = new RBModulationModel<T>(
-            architecture: Architecture,
-            options: Options as DiffusionModelOptions<T>,
-            scheduler: Scheduler,
-            predictor: (UNetNoisePredictor<T>)_predictor.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner,
-            seed: null);
-        if (!clone.TryShareParametersFrom(this)) clone.SetParameterChunks(GetParameterChunks());
-        return clone;
-    }
-
     public override ModelMetadata<T> GetModelMetadata()
     {
         var m = new ModelMetadata<T> { Name = "RB-Modulation", Version = "1.0",
diff --git a/src/Diffusion/StyleTransfer/SASTDModel.cs b/src/Diffusion/StyleTransfer/SASTDModel.cs
index 6d4adbab8f..8e1a493f28 100644
--- a/src/Diffusion/StyleTransfer/SASTDModel.cs
+++ b/src/Diffusion/StyleTransfer/SASTDModel.cs
@@ -97,27 +97,6 @@ private void InitializeLayers(UNetNoisePredictor<T>? predictor, StandardVAE<T>?
 
 
 
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    public override IDiffusionModel<T> Clone()
-    {
-        // Fast path: O(1) copy-on-write share when the default clone is structurally identical
-        // (the common foundation-scale case the COW lever targets — no re-materialization/OOM).
-        var clone = new SASTDModel<T>(conditioner: _conditioner, seed: null);
-        if (clone.TryShareParametersFrom(this)) return clone;
-        // Structure mismatch ⇒ custom architecture/predictor/VAE the default clone can't reproduce;
-        // rebuild faithfully from this instance's configuration so the clone is observationally
-        // identical instead of throwing on a parameter-count mismatch.
-        return new SASTDModel<T>(
-            architecture: Architecture,
-            options: (DiffusionModelOptions<T>)Options,
-            scheduler: Scheduler,
-            predictor: (UNetNoisePredictor<T>)_predictor.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner,
-            seed: null);
-    }
-
     public override ModelMetadata<T> GetModelMetadata()
     {
         var m = new ModelMetadata<T> { Name = "SASTD", Version = "1.0",
diff --git a/src/Diffusion/StyleTransfer/StyDiffModel.cs b/src/Diffusion/StyleTransfer/StyDiffModel.cs
index 45f8352204..d8a2979e06 100644
--- a/src/Diffusion/StyleTransfer/StyDiffModel.cs
+++ b/src/Diffusion/StyleTransfer/StyDiffModel.cs
@@ -89,46 +89,6 @@ private void InitializeLayers(UNetNoisePredictor<T>? predictor, StandardVAE<T>?
             baseChannels: 128, channelMultipliers: new[] { 1, 2, 4, 4 }, numResBlocksPerLevel: 2, seed: seed);
     }
 
-
-
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    public override IDiffusionModel<T> Clone()
-    {
-        var optionsCopy = new DiffusionModelOptions<T>((DiffusionModelOptions<T>)Options);
-
-        // Fast path: O(1) copy-on-write share when the default clone is structurally identical
-        // (the common foundation-scale case the COW lever targets — no re-materialization/OOM).
-        var clone = new StyDiffModel<T>(
-            architecture: Architecture,
-            options: optionsCopy,
-            scheduler: Scheduler,
-            conditioner: _conditioner,
-            seed: null);
-        if (clone.TryShareParametersFrom(this)) return clone;
-        // Structure mismatch ⇒ custom architecture/predictor/VAE the default clone can't reproduce;
-        // rebuild faithfully from this instance's configuration so the clone is observationally
-        // identical instead of throwing on a parameter-count mismatch.
-        var rebuilt = new StyDiffModel<T>(
-            architecture: Architecture,
-            options: new DiffusionModelOptions<T>((DiffusionModelOptions<T>)Options),
-            scheduler: Scheduler,
-            predictor: (UNetNoisePredictor<T>)_predictor.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner,
-            seed: null);
-        // The cloned sub-models have the same materialized structure as the source. Bind the rebuilt
-        // model to the exact same Tensor objects through DiffusionModelBase's reference-counted COW
-        // path, rather than creating new CloneShared tensor wrappers. The wrappers preserve values but
-        // have independent tensor identity/version state, so the CPU packed-weight cache can take a
-        // different cold path in the clone; DDIM compounds that small first-step reduction difference
-        // across its denoising loop (the Linux CI failure was 3.43e-5). ShareWeightsFrom preserves both
-        // values and inference-cache identity while EnsureOwnWeights still detaches either model before
-        // training or SetParameters, keeping clone independence.
-        rebuilt.ShareWeightsFrom(this);
-        return rebuilt;
-    }
-
     public override ModelMetadata<T> GetModelMetadata()
     {
         var m = new ModelMetadata<T> { Name = "StyDiff", Version = "1.0",
diff --git a/src/Diffusion/StyleTransfer/StyleAlignedEditModel.cs b/src/Diffusion/StyleTransfer/StyleAlignedEditModel.cs
index 5c2b404b7c..0be042e2ac 100644
--- a/src/Diffusion/StyleTransfer/StyleAlignedEditModel.cs
+++ b/src/Diffusion/StyleTransfer/StyleAlignedEditModel.cs
@@ -93,27 +93,6 @@ private void InitializeLayers(UNetNoisePredictor<T>? predictor, StandardVAE<T>?
 
 
 
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    public override IDiffusionModel<T> Clone()
-    {
-        // Fast path: O(1) copy-on-write share when the default clone is structurally identical
-        // (the common foundation-scale case the COW lever targets — no re-materialization/OOM).
-        var clone = new StyleAlignedEditModel<T>(conditioner: _conditioner, seed: null);
-        if (clone.TryShareParametersFrom(this)) return clone;
-        // Structure mismatch ⇒ custom architecture/predictor/VAE the default clone can't reproduce;
-        // rebuild faithfully from this instance's configuration so the clone is observationally
-        // identical instead of throwing on a parameter-count mismatch.
-        return new StyleAlignedEditModel<T>(
-            architecture: Architecture,
-            options: (DiffusionModelOptions<T>)Options,
-            scheduler: Scheduler,
-            predictor: (UNetNoisePredictor<T>)_predictor.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner,
-            seed: null);
-    }
-
     public override ModelMetadata<T> GetModelMetadata()
     {
         var m = new ModelMetadata<T> { Name = "StyleAligned-Edit", Version = "1.0",
diff --git a/src/Diffusion/StyleTransfer/StyleStudioModel.cs b/src/Diffusion/StyleTransfer/StyleStudioModel.cs
index 6177f52cc0..07b9683c25 100644
--- a/src/Diffusion/StyleTransfer/StyleStudioModel.cs
+++ b/src/Diffusion/StyleTransfer/StyleStudioModel.cs
@@ -90,27 +90,6 @@ private void InitializeLayers(UNetNoisePredictor<T>? predictor, StandardVAE<T>?
 
 
 
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    public override IDiffusionModel<T> Clone()
-    {
-        // Clone the ACTUAL predictor/VAE (see InstaFlowModel/MultiDiffusionModel): passing only
-        // conditioner/seed rebuilt InitializeLayers' DEFAULT-sized, lazily-unresolved sub-models, so once
-        // the source resolved its lazy layers via a forward pass the trainable-layer shapes no longer
-        // lined up 1:1 and Clone diverged. Cloning the resolved predictor/VAE (+ same architecture/
-        // options/scheduler) makes the clone structurally identical.
-        var clone = new StyleStudioModel<T>(
-            architecture: Architecture,
-            options: Options as DiffusionModelOptions<T>,
-            scheduler: Scheduler,
-            predictor: (UNetNoisePredictor<T>)_predictor.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner,
-            seed: null);
-        if (!clone.TryShareParametersFrom(this)) clone.SetParameterChunks(GetParameterChunks());
-        return clone;
-    }
-
     public override ModelMetadata<T> GetModelMetadata()
     {
         var m = new ModelMetadata<T> { Name = "StyleStudio", Version = "1.0",
diff --git a/src/Diffusion/StyleTransfer/TLoRAAttentionAdapter.cs b/src/Diffusion/StyleTransfer/TLoRAAttentionAdapter.cs
index 969cb2171e..cf4e8901b0 100644
--- a/src/Diffusion/StyleTransfer/TLoRAAttentionAdapter.cs
+++ b/src/Diffusion/StyleTransfer/TLoRAAttentionAdapter.cs
@@ -111,6 +111,12 @@ public sealed partial class TLoRAAttentionAdapter<T> : LayerBase<T>, IAttentionB
     /// <inheritdoc/>
     public override bool SupportsTraining => true;
 
+    /// <summary>Construction state: the 'rank' the layer was built with.</summary>
+    private readonly int _rank;
+
+    /// <summary>Construction state: the 'totalTimesteps' the layer was built with.</summary>
+    private readonly int _totalTimesteps;
+
     /// <summary>
     /// Wraps <paramref name="inner"/> with a T-LoRA adapter over <paramref name="channels"/> width.
     /// </summary>
@@ -122,12 +128,21 @@ public sealed partial class TLoRAAttentionAdapter<T> : LayerBase<T>, IAttentionB
     /// r = 64 is larger than the narrow channel counts used by reduced test fixtures.
     /// </param>
     /// <param name="totalTimesteps">The diffusion horizon T, the schedule's denominator.</param>
-    /// <param name="random">RNG for the orthogonal initialization.</param>
+    /// <param name="random">
+    /// RNG for the orthogonal initialization, or <c>null</c> for a fresh one.
+    /// </param>
+    /// <remarks>
+    /// The RNG is construction-time only: it seeds an initialization that a rebuild immediately
+    /// overwrites with the saved weights, so it is not construction state and nothing is gained by
+    /// recording it. Optional so a rebuild can supply its own.
+    /// </remarks>
     public TLoRAAttentionAdapter(
-        ILayer<T> inner, int channels, int rank, int totalTimesteps, Random random)
+        ILayer<T> inner, int channels, int rank, int totalTimesteps, Random? random = null)
         : base(inner?.GetInputShape() ?? throw new ArgumentNullException(nameof(inner)),
                inner.GetOutputShape())
     {
+        _totalTimesteps = totalTimesteps;
+        _rank = rank;
         if (channels <= 0)
             throw new ArgumentOutOfRangeException(nameof(channels), channels, "Channel width must be positive.");
 
@@ -136,7 +151,7 @@ public TLoRAAttentionAdapter(
         _adapter = new TimestepDependentLora<T>(
             rank: Math.Max(1, Math.Min(rank, channels)),
             inputDim: channels, outputDim: channels,
-            totalTimesteps: totalTimesteps, random: random);
+            totalTimesteps: totalTimesteps, random: random ?? new Random());
     }
 
     /// <summary>
diff --git a/src/Diffusion/StyleTransfer/TLoRAModel.cs b/src/Diffusion/StyleTransfer/TLoRAModel.cs
index 637371cf4d..6c0fafbddb 100644
--- a/src/Diffusion/StyleTransfer/TLoRAModel.cs
+++ b/src/Diffusion/StyleTransfer/TLoRAModel.cs
@@ -274,54 +274,6 @@ private int TotalAdapterParameterCount
         }
     }
 
-
-
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    public override IDiffusionModel<T> Clone()
-    {
-        // Clone the ACTUAL predictor/VAE (see InstaFlowModel/MultiDiffusionModel): passing only
-        // conditioner/seed rebuilt InitializeLayers' DEFAULT-sized, lazily-unresolved sub-models, so once
-        // the source resolved its lazy layers via a forward pass the trainable-layer shapes no longer
-        // lined up 1:1 and Clone diverged. Cloning the resolved predictor/VAE (+ same architecture/
-        // options/scheduler) makes the clone structurally identical.
-        var clone = new TLoRAModel<T>(
-            architecture: Architecture,
-            options: Options as DiffusionModelOptions<T>,
-            scheduler: Scheduler,
-            predictor: (UNetNoisePredictor<T>)_predictor.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner,
-            seed: null,
-            // Carry the rank across, or the clone would silently fall back to the default and end up
-            // with a different adapter shape than the source — which SetParameters would then reject.
-            adapterRank: _adapterRank);
-        if (!clone.TryShareParametersFrom(this)) clone.SetParameterChunks(GetParameterChunks());
-
-        // Adapter state is deliberately NOT part of any layer's parameter vector (see
-        // TLoRAAttentionAdapter.GetAdapterState), so it is copied here explicitly. Without this the
-        // clone would keep its own freshly-initialized adapters: identical in shape, different in
-        // value, and — because Clone passes seed: null — drawn from a different RNG, so the clone would
-        // produce different output despite holding identical base weights.
-        if (clone._adapters.Count != _adapters.Count)
-        {
-            throw new InvalidOperationException(
-                $"The clone has {clone._adapters.Count} T-LoRA adapters but the source has " +
-                $"{_adapters.Count}. Injection is meant to be deterministic given the same predictor " +
-                "shape, so a difference here means decoration ran against a different block set.");
-        }
-
-        for (int i = 0; i < _adapters.Count; i++)
-        {
-            // FULL state, including the frozen initialization triplet. Copying only A/B/S leaves the
-            // clone subtracting its own independently-drawn A_init/B_init/S_init, so its adapter applies
-            // the difference between two unrelated initializations rather than the identity.
-            clone._adapters[i].Adapter.CopyStateFrom(_adapters[i].Adapter);
-        }
-
-        return clone;
-    }
-
     public override ModelMetadata<T> GetModelMetadata()
     {
         var m = new ModelMetadata<T> { Name = "T-LoRA", Version = "1.0",
diff --git a/src/Diffusion/StyleTransfer/TimestepDependentLora.cs b/src/Diffusion/StyleTransfer/TimestepDependentLora.cs
index 41618c787d..bea4242a73 100644
--- a/src/Diffusion/StyleTransfer/TimestepDependentLora.cs
+++ b/src/Diffusion/StyleTransfer/TimestepDependentLora.cs
@@ -1,4 +1,5 @@
 using AiDotNet.DecompositionMethods.MatrixDecomposition;
+using AiDotNet.Attributes;
 using AiDotNet.Helpers;
 using AiDotNet.LinearAlgebra;
 
@@ -65,7 +66,7 @@ namespace AiDotNet.Diffusion.StyleTransfer;
 /// </para>
 /// </remarks>
 /// <typeparam name="T">The numeric type.</typeparam>
-public sealed class TimestepDependentLora<T>
+public sealed partial class TimestepDependentLora<T>
 {
     private static readonly INumericOperations<T> Ops = MathHelper.GetNumericOperations<T>();
 
@@ -79,11 +80,15 @@ public sealed class TimestepDependentLora<T>
 
     // The frozen initialization triplet. Subtracting its masked product is what makes the adapter
     // the identity at init WITHOUT forcing B or S to start at zero (see the class remarks).
+    [AiDotNet.Attributes.TrainableParameter]
     private readonly Matrix<T> _downInit;
+    [AiDotNet.Attributes.TrainableParameter]
     private readonly Matrix<T> _upInit;
+    [AiDotNet.Attributes.TrainableParameter]
     private readonly Vector<T> _singularInit;
 
     // Cached [inputDim, outputDim] delta for _cachedTimestep. Invalidated by InvalidateCache().
+    [Scratch]
     private Tensor<T>? _cachedDelta;
     private int _cachedTimestep = -1;
 
diff --git a/src/Diffusion/StyleTransfer/UniVSTModel.cs b/src/Diffusion/StyleTransfer/UniVSTModel.cs
index f7762675db..8874e967f9 100644
--- a/src/Diffusion/StyleTransfer/UniVSTModel.cs
+++ b/src/Diffusion/StyleTransfer/UniVSTModel.cs
@@ -267,30 +267,6 @@ public void PrepareAttentionStep(
     // reference and a region mask, which Predict has no way to supply. See ApplyLatentStylization,
     // QkvTransform and Smoothing.
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        // Fast path: an O(1) copy-on-write share when the default clone is structurally identical.
-        var clone = new UniVSTModel<T>(univstOptions: _univstOptions, conditioner: _conditioner, seed: null);
-        if (clone.TryShareParametersFrom(this)) return clone;
-
-        // Structure mismatch means a custom architecture/predictor/VAE the default clone cannot
-        // reproduce; rebuild from this instance's configuration so the clone is observationally
-        // identical instead of throwing on a parameter-count mismatch.
-        return new UniVSTModel<T>(
-            architecture: Architecture,
-            options: (DiffusionModelOptions<T>)Options,
-            univstOptions: _univstOptions,
-            scheduler: Scheduler,
-            predictor: (UNetNoisePredictor<T>)_predictor.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner,
-            seed: null);
-    }
-
     /// <inheritdoc />
     public override ModelMetadata<T> GetModelMetadata()
     {
diff --git a/src/Diffusion/SuperResolution/CCSRModel.cs b/src/Diffusion/SuperResolution/CCSRModel.cs
index afc2ce85ce..4f1c35a5aa 100644
--- a/src/Diffusion/SuperResolution/CCSRModel.cs
+++ b/src/Diffusion/SuperResolution/CCSRModel.cs
@@ -125,29 +125,6 @@ private void InitializeLayers(UNetNoisePredictor<T>? predictor, StandardVAE<T>?
 
 
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        // Clone the ACTUAL predictor and VAE (mirrors InstaFlowModel/MultiDiffusionModel): passing only
-        // conditioner/seed rebuilt InitializeLayers' DEFAULT-sized, lazily-unresolved sub-models, so once
-        // the source resolved its lazy layers via a forward pass the trainable-layer shapes no longer
-        // lined up 1:1 and Clone diverged. Cloning the resolved predictor/VAE (+ same architecture/
-        // options/scheduler) makes the clone structurally identical so the copy-on-write share succeeds.
-        var clone = new CCSRModel<T>(
-            architecture: Architecture,
-            options: Options as DiffusionModelOptions<T>,
-            scheduler: Scheduler,
-            predictor: (UNetNoisePredictor<T>)_predictor.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner,
-            seed: null);
-        if (!clone.TryShareParametersFrom(this)) clone.SetParameterChunks(GetParameterChunks());
-        return clone;
-    }
-
     /// <inheritdoc />
     public override ModelMetadata<T> GetModelMetadata()
     {
diff --git a/src/Diffusion/SuperResolution/DiffBIRModel.cs b/src/Diffusion/SuperResolution/DiffBIRModel.cs
index 7fe35b0655..7cf74dfe25 100644
--- a/src/Diffusion/SuperResolution/DiffBIRModel.cs
+++ b/src/Diffusion/SuperResolution/DiffBIRModel.cs
@@ -443,27 +443,6 @@ public override Tensor<T> ImageToImage(
 
     #region ICloneable Implementation
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy()
-    {
-        return Clone();
-    }
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        // Lazy-preserving Clone: delegate weights to the submodules' own Clone(), and carry through the
-        // caller-provided runtime configuration (architecture / options / scheduler) so the clone is a
-        // faithful copy rather than a defaults-rebuild.
-        return new DiffBIRModel<T>(
-            architecture: Architecture,
-            options: Options as DiffusionModelOptions<T>,
-            scheduler: Scheduler,
-            unet: (UNetNoisePredictor<T>)_unet.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner);
-    }
-
     #endregion
 
     #region Metadata
diff --git a/src/Diffusion/SuperResolution/PASDModel.cs b/src/Diffusion/SuperResolution/PASDModel.cs
index 07f7ad1930..705beaf324 100644
--- a/src/Diffusion/SuperResolution/PASDModel.cs
+++ b/src/Diffusion/SuperResolution/PASDModel.cs
@@ -124,29 +124,6 @@ private void InitializeLayers(UNetNoisePredictor<T>? predictor, StandardVAE<T>?
 
 
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        // Clone the ACTUAL predictor/VAE (see InstaFlowModel/MultiDiffusionModel): passing only
-        // conditioner/seed rebuilt InitializeLayers' DEFAULT-sized, lazily-unresolved sub-models, so once
-        // the source resolved its lazy layers via a forward pass the trainable-layer shapes no longer
-        // lined up 1:1 and Clone diverged. Cloning the resolved predictor/VAE (+ same architecture/
-        // options/scheduler) makes the clone structurally identical.
-        var clone = new PASDModel<T>(
-            architecture: Architecture,
-            options: Options as DiffusionModelOptions<T>,
-            scheduler: Scheduler,
-            predictor: (UNetNoisePredictor<T>)_predictor.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner,
-            seed: null);
-        if (!clone.TryShareParametersFrom(this)) clone.SetParameterChunks(GetParameterChunks());
-        return clone;
-    }
-
     /// <inheritdoc />
     public override ModelMetadata<T> GetModelMetadata()
     {
diff --git a/src/Diffusion/SuperResolution/RealESRGANModel.cs b/src/Diffusion/SuperResolution/RealESRGANModel.cs
index 13f91c0fdc..c1916555b0 100644
--- a/src/Diffusion/SuperResolution/RealESRGANModel.cs
+++ b/src/Diffusion/SuperResolution/RealESRGANModel.cs
@@ -407,32 +407,6 @@ public override Tensor<T> ImageToImage(
 
     #region ICloneable Implementation
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy()
-    {
-        return Clone();
-    }
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        // Delegate to the predictor/VAE's own Clone implementations, which resolve
-        // their internal lazy shapes on BOTH source and clone before copying weights.
-        // Constructing a fresh predictor/VAE here and calling SetParameters with
-        // GetParameters from this re-hits the lazy-init bug: GetParameters() on a
-        // still-unresolved source under-counts the lazy DenseLayer params while the new
-        // constructor's ParameterCount is live (arch-derived), so the clone re-resolves
-        // on its first Predict and diverges from the original. Mirrors
-        // ImprovedConsistencyModel / SDXLTurbo / DDPM (PR #1555 / #1562).
-        var clonedUnet = (UNetNoisePredictor<T>)_unet.Clone();
-        var clonedVae = (StandardVAE<T>)_vae.Clone();
-
-        return new RealESRGANModel<T>(
-            unet: clonedUnet,
-            vae: clonedVae,
-            conditioner: _conditioner);
-    }
-
     #endregion
 
     #region Metadata
diff --git a/src/Diffusion/SuperResolution/SDUpscalerModel.cs b/src/Diffusion/SuperResolution/SDUpscalerModel.cs
index eefd3d1747..63ae9c5131 100644
--- a/src/Diffusion/SuperResolution/SDUpscalerModel.cs
+++ b/src/Diffusion/SuperResolution/SDUpscalerModel.cs
@@ -381,31 +381,6 @@ public override Tensor<T> ImageToImage(
 
     #region ICloneable Implementation
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy()
-    {
-        return Clone();
-    }
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        // Defer to the sub-models' own Clone implementations — they preserve the
-        // ACTUAL architecture passed at ctor (test fixtures override channel counts
-        // / multipliers / resolutions) rather than hardcoding the SD-Upscaler default
-        // shape. The previous Clone constructed a fresh UNet/VAE with the production
-        // SD-Upscaler dimensions and then SetParameters(_unet.GetParameters()) on top,
-        // which mismatched test-fixture weight buffers and produced silently-different
-        // Predict output (the Clone_ShouldProduceIdenticalOutput regression).
-        var clonedUnet = (UNetNoisePredictor<T>)_unet.Clone();
-        var clonedVae = (StandardVAE<T>)_vae.Clone();
-
-        return new SDUpscalerModel<T>(
-            unet: clonedUnet,
-            vae: clonedVae,
-            conditioner: _conditioner);
-    }
-
     #endregion
 
     #region Metadata
diff --git a/src/Diffusion/SuperResolution/SUPIRModel.cs b/src/Diffusion/SuperResolution/SUPIRModel.cs
index 474f027988..e82a3e2b07 100644
--- a/src/Diffusion/SuperResolution/SUPIRModel.cs
+++ b/src/Diffusion/SuperResolution/SUPIRModel.cs
@@ -385,30 +385,6 @@ public override Tensor<T> ImageToImage(
 
     #region ICloneable Implementation
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy()
-    {
-        return Clone();
-    }
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        // Delegate to sub-Clones — same lazy-init fix pattern as
-        // SDXLTurbo / RealESRGAN / EDiffI / DiffEdit / DDPM.
-        // Preserve outer configuration (architecture / options / scheduler) so
-        // custom diffusion settings round-trip through Clone (CodeRabbit PR #1562).
-        var clonedUnet = (UNetNoisePredictor<T>)_unet.Clone();
-        var clonedVae = (StandardVAE<T>)_vae.Clone();
-        return new SUPIRModel<T>(
-            architecture: Architecture,
-            options: (DiffusionModelOptions<T>)GetOptions(),
-            scheduler: Scheduler,
-            unet: clonedUnet,
-            vae: clonedVae,
-            conditioner: _conditioner);
-    }
-
     #endregion
 
     #region Metadata
diff --git a/src/Diffusion/SuperResolution/SeeSRModel.cs b/src/Diffusion/SuperResolution/SeeSRModel.cs
index 6f3881650e..1f3748edd6 100644
--- a/src/Diffusion/SuperResolution/SeeSRModel.cs
+++ b/src/Diffusion/SuperResolution/SeeSRModel.cs
@@ -125,29 +125,6 @@ private void InitializeLayers(UNetNoisePredictor<T>? predictor, StandardVAE<T>?
 
 
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        // Clone the ACTUAL predictor/VAE (see InstaFlowModel/MultiDiffusionModel): passing only
-        // conditioner/seed rebuilt InitializeLayers' DEFAULT-sized, lazily-unresolved sub-models, so once
-        // the source resolved its lazy layers via a forward pass the trainable-layer shapes no longer
-        // lined up 1:1 and Clone diverged. Cloning the resolved predictor/VAE (+ same architecture/
-        // options/scheduler) makes the clone structurally identical.
-        var clone = new SeeSRModel<T>(
-            architecture: Architecture,
-            options: Options as DiffusionModelOptions<T>,
-            scheduler: Scheduler,
-            predictor: (UNetNoisePredictor<T>)_predictor.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner,
-            seed: null);
-        if (!clone.TryShareParametersFrom(this)) clone.SetParameterChunks(GetParameterChunks());
-        return clone;
-    }
-
     /// <inheritdoc />
     public override ModelMetadata<T> GetModelMetadata()
     {
diff --git a/src/Diffusion/SuperResolution/StableSRModel.cs b/src/Diffusion/SuperResolution/StableSRModel.cs
index 54d783c4b5..1f749fe33f 100644
--- a/src/Diffusion/SuperResolution/StableSRModel.cs
+++ b/src/Diffusion/SuperResolution/StableSRModel.cs
@@ -392,22 +392,6 @@ public override Tensor<T> ImageToImage(
 
     #region ICloneable Implementation
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy()
-    {
-        return Clone();
-    }
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        EnsureInitialized();
-                        return new StableSRModel<T>(
-            unet: (UNetNoisePredictor<T>)_unet.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner);
-    }
-
     #endregion
 
     #region Metadata
diff --git a/src/Diffusion/SuperResolution/TSDSRModel.cs b/src/Diffusion/SuperResolution/TSDSRModel.cs
index 7088d79789..61558c6322 100644
--- a/src/Diffusion/SuperResolution/TSDSRModel.cs
+++ b/src/Diffusion/SuperResolution/TSDSRModel.cs
@@ -125,21 +125,6 @@ private void InitializeLayers(UNetNoisePredictor<T>? predictor, StandardVAE<T>?
 
 
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        // Lazy-preserving Clone (recipe from #1596): delegate to the predictor's and VAE's own Clone()
-        // instead of rebuild-at-default-scale + SetParameters(GetParameters()), which re-randomizes
-        // the clone's unmaterialized lazy weights.
-        return new TSDSRModel<T>(
-            predictor: (UNetNoisePredictor<T>)_predictor.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner);
-    }
-
     /// <inheritdoc />
     public override ModelMetadata<T> GetModelMetadata()
     {
diff --git a/src/Diffusion/SuperResolution/UpscaleAVideoModel.cs b/src/Diffusion/SuperResolution/UpscaleAVideoModel.cs
index a6182c3f18..64b63195d8 100644
--- a/src/Diffusion/SuperResolution/UpscaleAVideoModel.cs
+++ b/src/Diffusion/SuperResolution/UpscaleAVideoModel.cs
@@ -230,8 +230,10 @@ protected override void RegisterComponents()
     // Explicit positive/negative slots bound memory even when prompt text changes.
     private readonly object _conditioningCacheLock = new();
     private string? _cachedPrompt;
+    [Scratch]
     private Tensor<T>? _cachedPromptConditioning;
     private string? _cachedNegativePrompt;
+    [Scratch]
     private Tensor<T>? _cachedNegativeConditioning;
     // Seed for the deferred (lazy) init path: the constructor only eager-inits when an explicit
     // predictor/VAE is passed, so without capturing the seed the lazy EnsureInitialized() built the
@@ -242,7 +244,9 @@ protected override void RegisterComponents()
     // trainer owns timestep sampling, target-noise construction, autodiff, and optimization; these
     // fields provide the paper-specific low-resolution RGB and text context to its virtual hooks.
     private readonly object _trainingContextLock = new();
+    [Scratch]
     private Tensor<T>? _trainingVideoCondition;
+    [Scratch]
     private Tensor<T>? _trainingTextConditioning;
     private int _trainingNoiseLevel;
 
@@ -1016,42 +1020,6 @@ protected override Tensor<T> PredictVideoNoise(
 
     #region ICloneable Implementation
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy()
-    {
-        return Clone();
-    }
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        EnsureInitialized();
-        return new UpscaleAVideoModel<T>(
-            architecture: Architecture,
-            options: new DiffusionModelOptions<T>((DiffusionModelOptions<T>)GetOptions()),
-            scheduler: CloneScheduler(Scheduler),
-            videoUNet: (VideoUNetPredictor<T>)_videoUNet.Clone(),
-            temporalVAE: (TemporalVAE<T>)_temporalVAE.Clone(),
-            conditioner: _conditioner,
-            defaultNumFrames: DefaultNumFrames,
-            defaultFPS: DefaultFPS,
-            seed: _seed);
-    }
-
-    private static INoiseScheduler<T> CloneScheduler(INoiseScheduler<T> scheduler)
-    {
-        object? created = Activator.CreateInstance(scheduler.GetType(), scheduler.Config);
-        if (created is not INoiseScheduler<T> clone)
-            throw new InvalidOperationException(
-                $"Scheduler {scheduler.GetType().Name} must expose a constructor accepting SchedulerConfig<{typeof(T).Name}> to support model cloning.");
-
-        var state = scheduler.GetState().ToDictionary(
-            pair => pair.Key,
-            pair => pair.Value is int[] values ? (object)values.ToArray() : pair.Value);
-        clone.LoadState(state);
-        return clone;
-    }
-
     #endregion
 
     #region Metadata
diff --git a/src/Diffusion/TextToImage/CogView4Model.cs b/src/Diffusion/TextToImage/CogView4Model.cs
index d156c521a8..31e4852850 100644
--- a/src/Diffusion/TextToImage/CogView4Model.cs
+++ b/src/Diffusion/TextToImage/CogView4Model.cs
@@ -273,20 +273,6 @@ public override Tensor<T> ImageToImage(
 
     #region ICloneable Implementation
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        // Clone must preserve the latent channel count so SetParameters lines
-        // up with the original predictor's weight layout.
-                        return new CogView4Model<T>(
-            predictor: (SiTPredictor<T>)_predictor.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner);
-    }
-
     #endregion
 
     #region Metadata
diff --git a/src/Diffusion/TextToImage/DallE2Model.cs b/src/Diffusion/TextToImage/DallE2Model.cs
index 8a72e3102e..b616036bd9 100644
--- a/src/Diffusion/TextToImage/DallE2Model.cs
+++ b/src/Diffusion/TextToImage/DallE2Model.cs
@@ -324,31 +324,6 @@ public override Tensor<T> ImageToImage(
 
     #region ICloneable Implementation
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy()
-    {
-        return Clone();
-    }
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        var clonedPrior = (UNetNoisePredictor<T>)_priorUnet.Clone();
-        var clonedDecoder = (UNetNoisePredictor<T>)_decoderUnet.Clone();
-        var clonedVae = (StandardVAE<T>)_vae.Clone();
-        var options = GetOptions() is DiffusionModelOptions<T> diffusionOptions
-            ? new DiffusionModelOptions<T>(diffusionOptions)
-            : null;
-
-        return new DallE2Model<T>(
-            architecture: Architecture,
-            options: options,
-            priorUnet: clonedPrior,
-            decoderUnet: clonedDecoder,
-            vae: clonedVae,
-            conditioner: _conditioner);
-    }
-
     #endregion
 
     #region Metadata
diff --git a/src/Diffusion/TextToImage/DallE3Model.cs b/src/Diffusion/TextToImage/DallE3Model.cs
index 3ac42f111a..4a0f0e354e 100644
--- a/src/Diffusion/TextToImage/DallE3Model.cs
+++ b/src/Diffusion/TextToImage/DallE3Model.cs
@@ -767,26 +767,6 @@ private Tensor<T> CreateOutpaintMask(int origWidth, int origHeight, int newWidth
 
     #region ICloneable Implementation
 
-    /// <inheritdoc/>
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy()
-    {
-        return Clone();
-    }
-
-    /// <inheritdoc/>
-    public override IDiffusionModel<T> Clone()
-    {
-        // Lazy-preserving Clone (recipe from #1596): delegate to the UNet's and VAE's own Clone(), which
-        // reconstruct from their actual config fields and preserve materialized weights. Rebuilding a
-        // DEFAULT (foundation-scale) DallE3 here and copying the source's parameters onto its internal
-        // UNet mismatches when the source is an injected tiny/non-default variant, and re-randomizes the
-        // clone's unmaterialized lazy weights on its first forward.
-        return new DallE3Model<T>(
-            unet: (UNetNoisePredictor<T>)_unet.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner);
-    }
-
     #endregion
 
     #region DiffusionModelBase Overrides
diff --git a/src/Diffusion/TextToImage/DeepFloydIFModel.cs b/src/Diffusion/TextToImage/DeepFloydIFModel.cs
index 141380baa7..283ea0ff0a 100644
--- a/src/Diffusion/TextToImage/DeepFloydIFModel.cs
+++ b/src/Diffusion/TextToImage/DeepFloydIFModel.cs
@@ -336,26 +336,6 @@ public override Tensor<T> ImageToImage(
 
     #region ICloneable Implementation
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy()
-    {
-        return Clone();
-    }
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        return new DeepFloydIFModel<T>(
-            architecture: Architecture,
-            options: Options as DiffusionModelOptions<T>,
-            scheduler: Scheduler,
-            stageIUnet: (UNetNoisePredictor<T>)_stageIUnet.Clone(),
-            stageIIUnet: (UNetNoisePredictor<T>)_stageIIUnet.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner,
-            useDynamicThresholding: _useDynamicThresholding);
-    }
-
     #endregion
 
     #region Metadata
diff --git a/src/Diffusion/TextToImage/EDiffIModel.cs b/src/Diffusion/TextToImage/EDiffIModel.cs
index b248ace075..e38a3a07e3 100644
--- a/src/Diffusion/TextToImage/EDiffIModel.cs
+++ b/src/Diffusion/TextToImage/EDiffIModel.cs
@@ -212,27 +212,6 @@ public override Tensor<T> GenerateFromText(
 
     #region ICloneable
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        // Delegate to _unet.Clone() + _vae.Clone() — same lazy-init fix pattern as
-        // SDXLTurboModel / RealESRGANModel / DDPMModel. The previous "construct
-        // fresh + SetParameters(GetParameters())" dance under-counts the unresolved
-        // source and leaves clone's lazy projections at fresh random init.
-        // Preserve outer configuration (architecture / options / scheduler) so
-        // custom diffusion settings round-trip through Clone (CodeRabbit PR #1562).
-        var clonedUnet = (UNetNoisePredictor<T>)_unet.Clone();
-        var clonedVae = (StandardVAE<T>)_vae.Clone();
-        return new EDiffIModel<T>(
-            architecture: Architecture,
-            options: (DiffusionModelOptions<T>)GetOptions(),
-            scheduler: Scheduler,
-            unet: clonedUnet, vae: clonedVae, conditioner: _conditioner);
-    }
-
     #endregion
 
     #region Metadata
diff --git a/src/Diffusion/TextToImage/Flux1Model.cs b/src/Diffusion/TextToImage/Flux1Model.cs
index 765e267779..91118403af 100644
--- a/src/Diffusion/TextToImage/Flux1Model.cs
+++ b/src/Diffusion/TextToImage/Flux1Model.cs
@@ -312,27 +312,6 @@ public override Tensor<T> ImageToImage(
 
     #region ICloneable Implementation
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy()
-    {
-        return Clone();
-    }
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        // Delegate to the predictor's and VAE's own Clone(), which reconstruct from their
-        // actual config fields (NOT hardcoded foundation-scale constants) and preserve
-        // materialized weights — so a caller-injected variant of any scale round-trips
-        // correctly. Rebuilding at fixed FLUX_HIDDEN_SIZE here would size a clone that cannot
-        // accept an injected tiny (or otherwise non-default) predictor's parameter vector.
-        return new Flux1Model<T>(
-            mmdit: (MMDiTNoisePredictor<T>)_mmdit.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner,
-            variant: _variant);
-    }
-
     #endregion
 
     #region Metadata
diff --git a/src/Diffusion/TextToImage/Flux2Model.cs b/src/Diffusion/TextToImage/Flux2Model.cs
index 02f98c8aee..c8bce5d5d4 100644
--- a/src/Diffusion/TextToImage/Flux2Model.cs
+++ b/src/Diffusion/TextToImage/Flux2Model.cs
@@ -296,19 +296,6 @@ public override Tensor<T> ImageToImage(
 
     #region ICloneable Implementation
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-                        return new Flux2Model<T>(
-            predictor: (FluxDoubleStreamPredictor<T>)_predictor.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner,
-            variant: _variant);
-    }
-
     #endregion
 
     #region Metadata
diff --git a/src/Diffusion/TextToImage/HiDreamModel.cs b/src/Diffusion/TextToImage/HiDreamModel.cs
index e953791c09..7f3581432f 100644
--- a/src/Diffusion/TextToImage/HiDreamModel.cs
+++ b/src/Diffusion/TextToImage/HiDreamModel.cs
@@ -294,24 +294,6 @@ public override Tensor<T> ImageToImage(
 
     #region ICloneable Implementation
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        // Lazy-preserving Clone: delegate to the predictor's and VAE's own Clone() (trained weights
-        // preserved); the variant is carried through directly, so no derived MMDiT-X variant is needed.
-        return new HiDreamModel<T>(
-            architecture: Architecture,
-            options: Options as DiffusionModelOptions<T>,
-            scheduler: Scheduler,
-            predictor: (MMDiTXNoisePredictor<T>)_predictor.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner,
-            variant: _variant);
-    }
-
     #endregion
 
     #region Metadata
diff --git a/src/Diffusion/TextToImage/HunyuanDiTModel.cs b/src/Diffusion/TextToImage/HunyuanDiTModel.cs
index 3e8e22e890..35f90f48d5 100644
--- a/src/Diffusion/TextToImage/HunyuanDiTModel.cs
+++ b/src/Diffusion/TextToImage/HunyuanDiTModel.cs
@@ -221,24 +221,6 @@ public override Tensor<T> GenerateFromText(
 
     #region ICloneable
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        EnsureInitialized();
-        // Delegate to the predictor's and VAE's own Clone(), which reconstruct from their
-        // actual config fields (NOT hardcoded foundation-scale constants) and preserve
-        // materialized weights — so a caller-injected variant of any scale round-trips
-        // correctly. Rebuilding at fixed 1408/40 here would size a clone that cannot accept
-        // an injected tiny (or otherwise non-default) predictor's parameter vector.
-        return new HunyuanDiTModel<T>(
-            dit: (DiTNoisePredictor<T>)_dit.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner);
-    }
-
     #endregion
 
     #region Metadata
diff --git a/src/Diffusion/TextToImage/Ideogram3Model.cs b/src/Diffusion/TextToImage/Ideogram3Model.cs
index b0fa7366d3..e250a30b19 100644
--- a/src/Diffusion/TextToImage/Ideogram3Model.cs
+++ b/src/Diffusion/TextToImage/Ideogram3Model.cs
@@ -277,18 +277,6 @@ public override Tensor<T> ImageToImage(
 
     #region ICloneable Implementation
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-                        return new Ideogram3Model<T>(
-            predictor: (SiTPredictor<T>)_predictor.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner);
-    }
-
     #endregion
 
     #region Metadata
diff --git a/src/Diffusion/TextToImage/Imagen2Model.cs b/src/Diffusion/TextToImage/Imagen2Model.cs
index 2de847787e..1c23d67faf 100644
--- a/src/Diffusion/TextToImage/Imagen2Model.cs
+++ b/src/Diffusion/TextToImage/Imagen2Model.cs
@@ -233,24 +233,6 @@ public override Tensor<T> GenerateFromText(
 
     #region ICloneable
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        int baseChannels = _isImagen3 ? 384 : 320;
-        int contextDim = _isImagen3 ? 4096 : CROSS_ATTENTION_DIM;
-
-        return new Imagen2Model<T>(
-            architecture: Architecture,
-            options: Options as DiffusionModelOptions<T>,
-            scheduler: Scheduler,
-            unet: (UNetNoisePredictor<T>)_unet.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner, isImagen3: _isImagen3);
-    }
-
     #endregion
 
     #region Metadata
diff --git a/src/Diffusion/TextToImage/Imagen3Model.cs b/src/Diffusion/TextToImage/Imagen3Model.cs
index 77b36a9c8e..3d7ba394f6 100644
--- a/src/Diffusion/TextToImage/Imagen3Model.cs
+++ b/src/Diffusion/TextToImage/Imagen3Model.cs
@@ -267,18 +267,6 @@ public override Tensor<T> ImageToImage(
 
     #region ICloneable Implementation
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-                        return new Imagen3Model<T>(
-            predictor: (SiTPredictor<T>)_predictor.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner);
-    }
-
     #endregion
 
     #region Metadata
diff --git a/src/Diffusion/TextToImage/ImagenModel.cs b/src/Diffusion/TextToImage/ImagenModel.cs
index e8402ce1fc..aa39be77c5 100644
--- a/src/Diffusion/TextToImage/ImagenModel.cs
+++ b/src/Diffusion/TextToImage/ImagenModel.cs
@@ -343,23 +343,6 @@ public override Tensor<T> ImageToImage(
 
     #region ICloneable Implementation
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy()
-    {
-        return Clone();
-    }
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-                                return new ImagenModel<T>(
-            baseUnet: (UNetNoisePredictor<T>)_baseUnet.Clone(),
-            superRes1Unet: (UNetNoisePredictor<T>)_superRes1Unet.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner,
-            dynamicThresholdPercentile: _dynamicThresholdPercentile);
-    }
-
     #endregion
 
     #region Metadata
diff --git a/src/Diffusion/TextToImage/KandinskyModel.cs b/src/Diffusion/TextToImage/KandinskyModel.cs
index a7fa185c89..871bfc8792 100644
--- a/src/Diffusion/TextToImage/KandinskyModel.cs
+++ b/src/Diffusion/TextToImage/KandinskyModel.cs
@@ -337,23 +337,6 @@ public override Tensor<T> ImageToImage(
 
     #region ICloneable Implementation
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy()
-    {
-        return Clone();
-    }
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-                                return new KandinskyModel<T>(
-            priorUnet: (UNetNoisePredictor<T>)_priorUnet.Clone(),
-            decoderUnet: (UNetNoisePredictor<T>)_decoderUnet.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner,
-            version: _version);
-    }
-
     #endregion
 
     #region Metadata
diff --git a/src/Diffusion/TextToImage/KolorsModel.cs b/src/Diffusion/TextToImage/KolorsModel.cs
index 2a6c8609f9..61b2de9737 100644
--- a/src/Diffusion/TextToImage/KolorsModel.cs
+++ b/src/Diffusion/TextToImage/KolorsModel.cs
@@ -209,16 +209,6 @@ public override Tensor<T> GenerateFromText(
 
     #region ICloneable
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-                        return new KolorsModel<T>(
-            unet: (UNetNoisePredictor<T>)_unet.Clone(), vae: (StandardVAE<T>)_vae.Clone(), conditioner: _conditioner);
-    }
-
     #endregion
 
     #region Metadata
diff --git a/src/Diffusion/TextToImage/LuminaImage2Model.cs b/src/Diffusion/TextToImage/LuminaImage2Model.cs
index a0966ebffd..61174e6723 100644
--- a/src/Diffusion/TextToImage/LuminaImage2Model.cs
+++ b/src/Diffusion/TextToImage/LuminaImage2Model.cs
@@ -185,15 +185,6 @@ public override Tensor<T> ImageToImage(
 
     #region ICloneable Implementation
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-                        return new LuminaImage2Model<T>(predictor: (FlagDiTPredictor<T>)_predictor.Clone(), vae: (StandardVAE<T>)_vae.Clone(), conditioner: _conditioner);
-    }
-
     #endregion
 
     #region Metadata
diff --git a/src/Diffusion/TextToImage/LuminaT2XModel.cs b/src/Diffusion/TextToImage/LuminaT2XModel.cs
index 0055efcc0e..e55469cb91 100644
--- a/src/Diffusion/TextToImage/LuminaT2XModel.cs
+++ b/src/Diffusion/TextToImage/LuminaT2XModel.cs
@@ -209,15 +209,6 @@ public override Tensor<T> ImageToImage(
 
     #region ICloneable Implementation
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-                        return new LuminaT2XModel<T>(predictor: (FlagDiTPredictor<T>)_predictor.Clone(), vae: (StandardVAE<T>)_vae.Clone(), conditioner: _conditioner);
-    }
-
     #endregion
 
     #region Metadata
diff --git a/src/Diffusion/TextToImage/MeissonicModel.cs b/src/Diffusion/TextToImage/MeissonicModel.cs
index 7c5a132882..204e0b0203 100644
--- a/src/Diffusion/TextToImage/MeissonicModel.cs
+++ b/src/Diffusion/TextToImage/MeissonicModel.cs
@@ -277,18 +277,6 @@ public override Tensor<T> ImageToImage(
 
     #region ICloneable Implementation
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-                        return new MeissonicModel<T>(
-            predictor: (EMMDiTPredictor<T>)_predictor.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner);
-    }
-
     #endregion
 
     #region Metadata
diff --git a/src/Diffusion/TextToImage/MidJourneyV7Model.cs b/src/Diffusion/TextToImage/MidJourneyV7Model.cs
index d0989d7cb2..39040aa608 100644
--- a/src/Diffusion/TextToImage/MidJourneyV7Model.cs
+++ b/src/Diffusion/TextToImage/MidJourneyV7Model.cs
@@ -206,21 +206,6 @@ public override Tensor<T> ImageToImage(
 
     #region ICloneable Implementation
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        return new MidJourneyV7Model<T>(
-            architecture: Architecture,
-            options: Options as DiffusionModelOptions<T>,
-            scheduler: Scheduler,
-            predictor: (MMDiTXNoisePredictor<T>)_predictor.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner);
-    }
-
     #endregion
 
     #region Metadata
diff --git a/src/Diffusion/TextToImage/OmniGenModel.cs b/src/Diffusion/TextToImage/OmniGenModel.cs
index 42648ebe40..82ed47cf23 100644
--- a/src/Diffusion/TextToImage/OmniGenModel.cs
+++ b/src/Diffusion/TextToImage/OmniGenModel.cs
@@ -294,23 +294,6 @@ public override Tensor<T> GenerateFromText(
 
     #region ICloneable
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        // Delegate to the predictor's and VAE's own Clone(), which reconstruct from their
-        // actual config fields (NOT hardcoded foundation-scale constants) and preserve
-        // materialized weights — so a caller-injected variant of any scale round-trips
-        // correctly. Rebuilding at fixed 2048/32 here would size a clone that cannot accept
-        // an injected tiny (or otherwise non-default) predictor's parameter vector.
-        return new OmniGenModel<T>(
-            dit: (DiTNoisePredictor<T>)_dit.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner);
-    }
-
     #endregion
 
     #region Metadata
diff --git a/src/Diffusion/TextToImage/PixArtDeltaModel.cs b/src/Diffusion/TextToImage/PixArtDeltaModel.cs
index 82745a6c94..3c34585a05 100644
--- a/src/Diffusion/TextToImage/PixArtDeltaModel.cs
+++ b/src/Diffusion/TextToImage/PixArtDeltaModel.cs
@@ -207,16 +207,6 @@ public override Tensor<T> GenerateFromText(
 
     #region ICloneable
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-                        return new PixArtDeltaModel<T>(
-            dit: (DiTNoisePredictor<T>)_dit.Clone(), vae: (StandardVAE<T>)_vae.Clone(), conditioner: _conditioner);
-    }
-
     #endregion
 
     #region Metadata
diff --git a/src/Diffusion/TextToImage/PixArtModel.cs b/src/Diffusion/TextToImage/PixArtModel.cs
index 8d7e66a4ca..ef72c236dc 100644
--- a/src/Diffusion/TextToImage/PixArtModel.cs
+++ b/src/Diffusion/TextToImage/PixArtModel.cs
@@ -589,37 +589,6 @@ public override Tensor<T> ImageToImage(
 
     #region ICloneable Implementation
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy()
-    {
-        return Clone();
-    }
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        // Clone the ACTUAL DiT/VAE (see InstaFlowModel/MultiDiffusionModel): passing only modelSize/
-        // conditioner/seed rebuilt InitializeLayers' DEFAULT-sized, lazily-unresolved DiT/VAE, so once the
-        // source resolved its lazy layers via a forward pass ShareWeightsFrom threw on the layer-count/
-        // shape mismatch (or the clone diverged). Passing the resolved DiT/VAE makes the clone
-        // structurally identical so the copy-on-write share below lines up 1:1.
-        var clone = new PixArtModel<T>(
-            architecture: Architecture,
-            modelSize: _modelSize,
-            conditioner: _conditioner,
-            scheduler: Scheduler,
-            dit: (DiTNoisePredictor<T>)_dit.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            seed: null);
-
-        // Copy-on-write: share this model's weight tensors with the clone instead of deep-copying all
-        // parameters (PixArt-α is ~600M params / ~2.4 GB). The clone gets identical weights at O(1);
-        // either model copies its own set lazily on the first weight write (training).
-        clone.ShareWeightsFrom(this);
-
-        return clone;
-    }
-
     #endregion
 
     #region Metadata
diff --git a/src/Diffusion/TextToImage/PixArtSigmaModel.cs b/src/Diffusion/TextToImage/PixArtSigmaModel.cs
index b86eff3aa1..d3d6bb0b05 100644
--- a/src/Diffusion/TextToImage/PixArtSigmaModel.cs
+++ b/src/Diffusion/TextToImage/PixArtSigmaModel.cs
@@ -213,24 +213,6 @@ public override Tensor<T> GenerateFromText(
 
     #region ICloneable
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        // Lazy-preserving clone: delegate to the predictor's and VAE's own Clone(), which
-        // reconstruct from their actual config fields and copy only materialized weights.
-        // The previous flatten -> SetParameters(GetParameters()) round-trip materialised the
-        // entire foundation-scale DiT + VAE (model + clone + flat parameter vector) at once
-        // and OOM'd the runner. Delegating also lets a caller-injected non-default-scale
-        // predictor/VAE round-trip correctly instead of being rebuilt at fixed constants.
-        return new PixArtSigmaModel<T>(
-            dit: (DiTNoisePredictor<T>)_dit.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner);
-    }
-
     #endregion
 
     #region Metadata
diff --git a/src/Diffusion/TextToImage/PlaygroundV25Model.cs b/src/Diffusion/TextToImage/PlaygroundV25Model.cs
index 327de739d2..0052901cca 100644
--- a/src/Diffusion/TextToImage/PlaygroundV25Model.cs
+++ b/src/Diffusion/TextToImage/PlaygroundV25Model.cs
@@ -312,31 +312,6 @@ public override Tensor<T> ImageToImage(
 
     #region ICloneable Implementation
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy()
-    {
-        return Clone();
-    }
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        // Delegate to the UNet/VAE's own Clone, which triggers lazy
-        // shape resolution on BOTH source and clone before copying
-        // weights. Reconstructing fresh predictors here and calling
-        // SetParameters with this.GetParameters under-copies the
-        // unresolved time-embedding DenseLayer params, producing a
-        // clone whose Predict diverges from the original — surfaces
-        // as Clone_ShouldProduceIdenticalOutput numerical failure.
-        var clonedUnet = (UNetNoisePredictor<T>)_unet.Clone();
-        var clonedVae = (StandardVAE<T>)_vae.Clone();
-
-        return new PlaygroundV25Model<T>(
-            unet: clonedUnet,
-            vae: clonedVae,
-            conditioner: _conditioner);
-    }
-
     #endregion
 
     #region Metadata
diff --git a/src/Diffusion/TextToImage/PlaygroundV3Model.cs b/src/Diffusion/TextToImage/PlaygroundV3Model.cs
index 4264e59ca8..4208ab76c3 100644
--- a/src/Diffusion/TextToImage/PlaygroundV3Model.cs
+++ b/src/Diffusion/TextToImage/PlaygroundV3Model.cs
@@ -275,18 +275,6 @@ public override Tensor<T> ImageToImage(
 
     #region ICloneable Implementation
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-                        return new PlaygroundV3Model<T>(
-            predictor: (MMDiTXNoisePredictor<T>)_predictor.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner);
-    }
-
     #endregion
 
     #region Metadata
diff --git a/src/Diffusion/TextToImage/RAPHAELModel.cs b/src/Diffusion/TextToImage/RAPHAELModel.cs
index 8a6fb4de0f..e9e8c63ecd 100644
--- a/src/Diffusion/TextToImage/RAPHAELModel.cs
+++ b/src/Diffusion/TextToImage/RAPHAELModel.cs
@@ -206,16 +206,6 @@ public override Tensor<T> GenerateFromText(
 
     #region ICloneable
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-                        return new RAPHAELModel<T>(
-            unet: (UNetNoisePredictor<T>)_unet.Clone(), vae: (StandardVAE<T>)_vae.Clone(), conditioner: _conditioner);
-    }
-
     #endregion
 
     #region Metadata
diff --git a/src/Diffusion/TextToImage/RecraftV3Model.cs b/src/Diffusion/TextToImage/RecraftV3Model.cs
index 5e8aee7fcf..8692deeee8 100644
--- a/src/Diffusion/TextToImage/RecraftV3Model.cs
+++ b/src/Diffusion/TextToImage/RecraftV3Model.cs
@@ -274,25 +274,6 @@ public override Tensor<T> ImageToImage(
 
     #region ICloneable Implementation
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        var clone = new RecraftV3Model<T>(
-            architecture: Architecture,
-            options: Options as DiffusionModelOptions<T>,
-            scheduler: Scheduler,
-            predictor: (MMDiTXNoisePredictor<T>)_predictor.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner);
-        // The constructor resets guidance to the Recraft default; carry over the
-        // current (possibly caller-tuned) guidance scale so the clone matches.
-        clone.SetGuidanceScale(GuidanceScale);
-        return clone;
-    }
-
     #endregion
 
     #region Metadata
diff --git a/src/Diffusion/TextToImage/SANAModel.cs b/src/Diffusion/TextToImage/SANAModel.cs
index b312fe28e3..100ba03080 100644
--- a/src/Diffusion/TextToImage/SANAModel.cs
+++ b/src/Diffusion/TextToImage/SANAModel.cs
@@ -299,22 +299,6 @@ public override Tensor<T> ImageToImage(
 
     #region ICloneable Implementation
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        return new SANAModel<T>(
-            architecture: Architecture,
-            options: Options as DiffusionModelOptions<T>,
-            scheduler: Scheduler,
-            predictor: (EMMDiTPredictor<T>)_predictor.Clone(),
-            vae: (DeepCompressionVAE<T>)_vae.Clone(),
-            conditioner: _conditioner,
-            variant: _variant);
-    }
-
     #endregion
 
     #region Metadata
diff --git a/src/Diffusion/TextToImage/SDXLModel.cs b/src/Diffusion/TextToImage/SDXLModel.cs
index 813df82e3c..f781974e8f 100644
--- a/src/Diffusion/TextToImage/SDXLModel.cs
+++ b/src/Diffusion/TextToImage/SDXLModel.cs
@@ -1095,29 +1095,6 @@ private Tensor<T> ApplyMicroCondition(Tensor<T> embedding, Tensor<T> microCond)
 
     #region ICloneable Implementation
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy()
-    {
-        return Clone();
-    }
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        // Clone U-Net with trained weights
-                // Clone VAE with trained weights
-                return new SDXLModel<T>(
-            options: null,
-            scheduler: null,
-            unet: (UNetNoisePredictor<T>)_unet.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner1: _conditioner1,
-            conditioner2: _conditioner2,
-            refiner: _refiner,
-            useDualEncoder: _useDualEncoder,
-            crossAttentionDim: _crossAttentionDim);
-    }
-
     #endregion
 
     #region Metadata
diff --git a/src/Diffusion/TextToImage/StableCascadeModel.cs b/src/Diffusion/TextToImage/StableCascadeModel.cs
index 1aadb30c85..e06c2aadeb 100644
--- a/src/Diffusion/TextToImage/StableCascadeModel.cs
+++ b/src/Diffusion/TextToImage/StableCascadeModel.cs
@@ -329,22 +329,6 @@ public override Tensor<T> ImageToImage(
 
     #region ICloneable Implementation
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy()
-    {
-        return Clone();
-    }
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-                                return new StableCascadeModel<T>(
-            priorUnet: (UNetNoisePredictor<T>)_priorUnet.Clone(),
-            decoderUnet: (UNetNoisePredictor<T>)_decoderUnet.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner);
-    }
-
     #endregion
 
     #region Metadata
diff --git a/src/Diffusion/TextToImage/StableDiffusion15Model.cs b/src/Diffusion/TextToImage/StableDiffusion15Model.cs
index 866180ee69..36d02e3c7e 100644
--- a/src/Diffusion/TextToImage/StableDiffusion15Model.cs
+++ b/src/Diffusion/TextToImage/StableDiffusion15Model.cs
@@ -550,27 +550,6 @@ public virtual List<Tensor<T>> GenerateVariations(
 
     #region ICloneable Implementation
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy()
-    {
-        return Clone();
-    }
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        // Delegate to submodule clones so default lazy paper-scale scaffolds stay
-        // lazy. Materialized/trained submodules are responsible for preserving
-        // their own weights.
-        var clonedUnet = (UNetNoisePredictor<T>)_unet.Clone();
-        var clonedVae = (StandardVAE<T>)_vae.Clone();
-
-        return new StableDiffusion15Model<T>(
-            unet: clonedUnet,
-            vae: clonedVae,
-            conditioner: _conditioner);
-    }
-
     /// <summary>
     /// Materializes lazy submodule weights before state-dict style operations.
     /// </summary>
diff --git a/src/Diffusion/TextToImage/StableDiffusion2Model.cs b/src/Diffusion/TextToImage/StableDiffusion2Model.cs
index d2e6de0f85..937f9a4e5d 100644
--- a/src/Diffusion/TextToImage/StableDiffusion2Model.cs
+++ b/src/Diffusion/TextToImage/StableDiffusion2Model.cs
@@ -310,22 +310,6 @@ public override Tensor<T> ImageToImage(
 
     #region ICloneable Implementation
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy()
-    {
-        return Clone();
-    }
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-                        return new StableDiffusion2Model<T>(
-            unet: (UNetNoisePredictor<T>)_unet.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner,
-            useVPrediction: _useVPrediction);
-    }
-
     #endregion
 
     #region Metadata
diff --git a/src/Diffusion/TextToImage/StableDiffusion35Model.cs b/src/Diffusion/TextToImage/StableDiffusion35Model.cs
index 673b5a3abf..f81841356a 100644
--- a/src/Diffusion/TextToImage/StableDiffusion35Model.cs
+++ b/src/Diffusion/TextToImage/StableDiffusion35Model.cs
@@ -297,19 +297,6 @@ public override Tensor<T> ImageToImage(
 
     #region ICloneable Implementation
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-                        return new StableDiffusion35Model<T>(
-            predictor: (MMDiTXNoisePredictor<T>)_predictor.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner,
-            variant: _variant);
-    }
-
     #endregion
 
     #region Metadata
diff --git a/src/Diffusion/TextToImage/StableDiffusion3Model.cs b/src/Diffusion/TextToImage/StableDiffusion3Model.cs
index 09151b79f1..85e1f32463 100644
--- a/src/Diffusion/TextToImage/StableDiffusion3Model.cs
+++ b/src/Diffusion/TextToImage/StableDiffusion3Model.cs
@@ -293,28 +293,6 @@ public override Tensor<T> ImageToImage(
 
     #region ICloneable Implementation
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy()
-    {
-        return Clone();
-    }
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        var (hiddenSize, numLayers, numHeads) = _variant switch
-        {
-            SD3Variant.Large or SD3Variant.LargeTurbo => (2432, 38, 38),
-            _ => (1536, 24, 24)
-        };
-
-                        return new StableDiffusion3Model<T>(
-            mmdit: (MMDiTNoisePredictor<T>)_mmdit.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner,
-            variant: _variant);
-    }
-
     #endregion
 
     #region Metadata
diff --git a/src/Diffusion/ThreeD/DreamFusionModel.cs b/src/Diffusion/ThreeD/DreamFusionModel.cs
index a640b943a1..4591e04d04 100644
--- a/src/Diffusion/ThreeD/DreamFusionModel.cs
+++ b/src/Diffusion/ThreeD/DreamFusionModel.cs
@@ -600,33 +600,6 @@ public override Tensor<T> PredictNoise(Tensor<T> noisySample, int timestep)
 
 
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy()
-    {
-        return Clone();
-    }
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        // #1706: clone the noise predictor through its OWN Clone() (UNetNoisePredictor.Clone
-        // materializes the clone's lazy layers then copies weights). The previous fresh-construct +
-        // model-level TryShareParametersFrom left the clone's U-Net (and the NeRF DenseLayers) lazy:
-        // the share saw zero-shape tensors, fell back to SetParameters, and the clone re-RNG-
-        // initialized on its first forward and diverged from the source
-        // (Clone_ShouldProduceIdenticalOutput, maxDiff ~3e1). Only the U-Net is on the Predict
-        // (denoise) path, so passing a faithful U-Net clone makes Predict output identical; the VAE
-        // and NeRF (used by VAE-decode / 3D rendering, not by Predict) are rebuilt fresh. The prior
-        // is preserved so non-Predict behaviour is unchanged.
-        return new DreamFusionModel<T>(
-            architecture: Architecture,
-            diffusionPrior: ReferenceEquals(_diffusionPrior, this) ? null : _diffusionPrior,
-            config: _config,
-            conditioner: _conditioner,
-            unet: (UNetNoisePredictor<T>)_unet.Clone(),
-            seed: null);
-    }
-
     /// <inheritdoc />
     public override ModelMetadata<T> GetModelMetadata()
     {
diff --git a/src/Diffusion/ThreeD/DreamGaussianModel.cs b/src/Diffusion/ThreeD/DreamGaussianModel.cs
index 8803bf74d7..4f649cf4c4 100644
--- a/src/Diffusion/ThreeD/DreamGaussianModel.cs
+++ b/src/Diffusion/ThreeD/DreamGaussianModel.cs
@@ -320,47 +320,6 @@ public override Mesh3D<T> GenerateMesh(
 
     #region ICloneable Implementation
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy()
-    {
-        return Clone();
-    }
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        EnsureInitialized();
-        // Clone the existing UNet + VAE via their own Clone() methods so
-        // the cloned DreamGaussian preserves whatever config the original
-        // was constructed with — NOT the paper-scale defaults. The
-        // previous Clone() rebuilt both sub-modules with hardcoded
-        // {baseChannels=320, channelMultipliers={1,2,4,4}, 2 res blocks,
-        // 3 attention resolutions} and pushed the small test
-        // scaffold's parameters into them, which (a) reshaped the
-        // parameter vector silently when test sizes ≠ paper sizes and
-        // (b) made the Clone_ShouldProduceIdenticalOutput test
-        // unconditionally Predict at paper scale, blowing the 120 s
-        // xUnit timeout regardless of whether the original used a
-        // smaller test-friendly UNet.
-        var clonedUnet = (UNetNoisePredictor<T>)_unet.Clone();
-        var clonedVae = (StandardVAE<T>)_vae.Clone();
-
-        // Forward the outer-model config (DiffusionModelOptions, Scheduler,
-        // Architecture) too — the previous version only passed the cloned
-        // sub-modules and let the constructor defaults paper-scale-rebuild
-        // everything else, silently changing schedule/options/architecture
-        // on a customized original.
-        return new DreamGaussianModel<T>(
-            architecture: Architecture,
-            options: (DiffusionModelOptions<T>)GetOptions(),
-            scheduler: Scheduler,
-            unet: clonedUnet,
-            vae: clonedVae,
-            conditioner: _conditioner,
-            defaultPointCount: DefaultPointCount,
-            seed: _seed);
-    }
-
     #endregion
 
     #region Metadata
diff --git a/src/Diffusion/ThreeD/Instant3DModel.cs b/src/Diffusion/ThreeD/Instant3DModel.cs
index 76770dbfb3..3abf8b5375 100644
--- a/src/Diffusion/ThreeD/Instant3DModel.cs
+++ b/src/Diffusion/ThreeD/Instant3DModel.cs
@@ -214,25 +214,6 @@ public override Mesh3D<T> GenerateMesh(
 
     #region ICloneable
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-                return new Instant3DModel<T>(
-            unet: (UNetNoisePredictor<T>)_unet.Clone(),
-            vae: new StandardVAE<T>(
-                inputChannels: 3,
-                latentChannels: LATENT_CHANNELS,
-                baseChannels: 128,
-                channelMultipliers: [1, 2, 4, 4],
-                numResBlocksPerLevel: 2,
-                latentScaleFactor: 0.18215),
-            conditioner: _conditioner,
-            defaultPointCount: DefaultPointCount);
-    }
-
     #endregion
 
     #region Metadata
diff --git a/src/Diffusion/ThreeD/LGMModel.cs b/src/Diffusion/ThreeD/LGMModel.cs
index 103683681d..f1f86a2b2d 100644
--- a/src/Diffusion/ThreeD/LGMModel.cs
+++ b/src/Diffusion/ThreeD/LGMModel.cs
@@ -299,23 +299,6 @@ public override Mesh3D<T> GenerateMesh(
 
     #region ICloneable Implementation
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        var clonedUnet = (UNetNoisePredictor<T>)_unet.Clone();
-        var clonedVae = (StandardVAE<T>)_vae.Clone();
-
-        return new LGMModel<T>(
-            architecture: Architecture,
-            unet: clonedUnet,
-            vae: clonedVae,
-            conditioner: _conditioner,
-            defaultPointCount: DefaultPointCount);
-    }
-
     #endregion
 
     #region Metadata
diff --git a/src/Diffusion/ThreeD/MVDreamModel.cs b/src/Diffusion/ThreeD/MVDreamModel.cs
index d045a8ba00..ec3a403b90 100644
--- a/src/Diffusion/ThreeD/MVDreamModel.cs
+++ b/src/Diffusion/ThreeD/MVDreamModel.cs
@@ -1142,36 +1142,6 @@ private Mesh3D<T> ReconstructFromMultiView(
 
     #region ICloneable Implementation
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy()
-    {
-        return Clone();
-    }
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        // Clone the ACTUAL multi-view UNet / image VAE (see InstaFlowModel/MultiDiffusionModel):
-        // passing null rebuilt InitializeLayers' DEFAULT-sized, lazily-unresolved sub-models, so once the
-        // source resolved its lazy layers via a forward pass the clone reconstructed a different-valued
-        // (and, after resolution, mismatched) network and diverged. Cloning the resolved sub-models makes
-        // the clone structurally and observationally identical.
-        var clone = new MVDreamModel<T>(
-            architecture: Architecture,
-            options: Options as DiffusionModelOptions<T>,
-            scheduler: Scheduler,
-            multiViewUNet: _multiViewUNet.Clone(),
-            imageVAE: (StandardVAE<T>)_imageVAE.Clone(),
-            textConditioner: _textConditioner,
-            imageConditioner: _imageConditioner,
-            config: _config);
-        // The camera-embedding block is rebuilt fresh by the ctor (it is not a ctor param), so copy the
-        // full parameter set across. With the multi-view U-Net and VAE already resolved clones, the two
-        // graphs line up 1:1 and the copy-on-write share also transfers the camera embedding's weights.
-        if (!clone.TryShareParametersFrom(this)) clone.SetParameters(GetParameters());
-        return clone;
-    }
-
     #endregion
 }
 
diff --git a/src/Diffusion/ThreeD/Magic3DModel.cs b/src/Diffusion/ThreeD/Magic3DModel.cs
index 3423bea064..2a2f6a618e 100644
--- a/src/Diffusion/ThreeD/Magic3DModel.cs
+++ b/src/Diffusion/ThreeD/Magic3DModel.cs
@@ -247,23 +247,6 @@ private void InitializeLayers(
 
     #region ICloneable Implementation
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy()
-    {
-        return Clone();
-    }
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-                                return new Magic3DModel<T>(
-            coarseUnet: (UNetNoisePredictor<T>)_coarseUnet.Clone(),
-            fineUnet: (UNetNoisePredictor<T>)_fineUnet.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner,
-            defaultPointCount: DefaultPointCount);
-    }
-
     #endregion
 
     #region Metadata
diff --git a/src/Diffusion/ThreeD/MeshyModel.cs b/src/Diffusion/ThreeD/MeshyModel.cs
index d16ed69628..aaf20dc17a 100644
--- a/src/Diffusion/ThreeD/MeshyModel.cs
+++ b/src/Diffusion/ThreeD/MeshyModel.cs
@@ -219,23 +219,6 @@ public override Mesh3D<T> GenerateMesh(string prompt, string? negativePrompt = n
 
     #region ICloneable Implementation
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        var clonedUnet = (UNetNoisePredictor<T>)_unet.Clone();
-        var clonedVae = (StandardVAE<T>)_vae.Clone();
-
-        return new MeshyModel<T>(
-            architecture: Architecture,
-            unet: clonedUnet,
-            vae: clonedVae,
-            conditioner: _conditioner,
-            defaultPointCount: DefaultPointCount);
-    }
-
     #endregion
 
     #region Metadata
diff --git a/src/Diffusion/ThreeD/One2345Model.cs b/src/Diffusion/ThreeD/One2345Model.cs
index 1288b7b9f7..7af2811408 100644
--- a/src/Diffusion/ThreeD/One2345Model.cs
+++ b/src/Diffusion/ThreeD/One2345Model.cs
@@ -222,36 +222,6 @@ public override Mesh3D<T> GenerateMesh(string prompt, string? negativePrompt = n
 
     #region ICloneable Implementation
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        EnsureInitialized();
-        // Clone the existing UNet + VAE via their own Clone() methods —
-        // see DreamGaussianModel.Clone for the full rationale. The
-        // previous "rebuild with paper-scale defaults + push original's
-        // params" pattern made Clone_ShouldProduceIdenticalOutput
-        // exceed the 120 s xUnit timeout on the test scaffold because
-        // the clone always ran a full-paper-scale UNet Predict
-        // regardless of how small the original was.
-        var clonedUnet = (UNetNoisePredictor<T>)_unet.Clone();
-        var clonedVae = (StandardVAE<T>)_vae.Clone();
-        // Forward the outer-model config (DiffusionModelOptions, Scheduler,
-        // Architecture) too — otherwise a customized One2345Model resets to
-        // constructor defaults on clone.
-        return new One2345Model<T>(
-            architecture: Architecture,
-            options: (DiffusionModelOptions<T>)GetOptions(),
-            scheduler: Scheduler,
-            unet: clonedUnet,
-            vae: clonedVae,
-            conditioner: _conditioner,
-            defaultPointCount: DefaultPointCount,
-            seed: _seed);
-    }
-
     #endregion
 
     #region Metadata
diff --git a/src/Diffusion/ThreeD/PointEModel.cs b/src/Diffusion/ThreeD/PointEModel.cs
index d8ea515fbb..a3266a3e1c 100644
--- a/src/Diffusion/ThreeD/PointEModel.cs
+++ b/src/Diffusion/ThreeD/PointEModel.cs
@@ -646,24 +646,6 @@ public virtual (Tensor<T> Vertices, Tensor<T> Faces) ConvertToMesh(
 
     #region ICloneable Implementation
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy()
-    {
-        return Clone();
-    }
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        // Create a clone of the predictor to preserve trained weights
-                return new PointEModel<T>(
-            pointCloudPredictor: (DiTNoisePredictor<T>)_pointCloudPredictor.Clone(),
-            imageGenerator: _imageGenerator,
-            conditioner: _conditioner,
-            defaultPointCount: DefaultPointCount,
-            useTwoStage: _useTwoStage);
-    }
-
     #endregion
 
     #region Metadata
diff --git a/src/Diffusion/ThreeD/ShapEModel.cs b/src/Diffusion/ThreeD/ShapEModel.cs
index 20605ed709..c2e416c75e 100644
--- a/src/Diffusion/ThreeD/ShapEModel.cs
+++ b/src/Diffusion/ThreeD/ShapEModel.cs
@@ -877,25 +877,6 @@ private Tensor<T> FlattenToCondition(Tensor<T> imageLatent)
 
     #region ICloneable Implementation
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy()
-    {
-        return Clone();
-    }
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        // Clone the predictor to preserve trained weights
-                return new ShapEModel<T>(
-            options: null,
-            scheduler: null,
-            latentPredictor: (DiTNoisePredictor<T>)_latentPredictor.Clone(),
-            conditioner: _conditioner,
-            useSDFMode: _useSDFMode,
-            defaultPointCount: DefaultPointCount);
-    }
-
     #endregion
 
     #region Metadata
diff --git a/src/Diffusion/ThreeD/SyncDreamerModel.cs b/src/Diffusion/ThreeD/SyncDreamerModel.cs
index a72098c77d..9db33b684a 100644
--- a/src/Diffusion/ThreeD/SyncDreamerModel.cs
+++ b/src/Diffusion/ThreeD/SyncDreamerModel.cs
@@ -218,19 +218,6 @@ public override Mesh3D<T> GenerateMesh(string prompt, string? negativePrompt = n
 
     #region ICloneable Implementation
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-                return new SyncDreamerModel<T>(unet: (UNetNoisePredictor<T>)_unet.Clone(),
-            vae: new StandardVAE<T>(inputChannels: 3, latentChannels: LATENT_CHANNELS,
-                baseChannels: 128, channelMultipliers: new[] { 1, 2, 4, 4 },
-                numResBlocksPerLevel: 2, latentScaleFactor: 0.18215),
-            conditioner: _conditioner, defaultPointCount: DefaultPointCount);
-    }
-
     #endregion
 
     #region Metadata
diff --git a/src/Diffusion/ThreeD/TripoSRModel.cs b/src/Diffusion/ThreeD/TripoSRModel.cs
index c2640bfcf4..b9cc56ff9e 100644
--- a/src/Diffusion/ThreeD/TripoSRModel.cs
+++ b/src/Diffusion/ThreeD/TripoSRModel.cs
@@ -223,17 +223,6 @@ public override Mesh3D<T> GenerateMesh(string prompt, string? negativePrompt = n
 
     #region ICloneable Implementation
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        return new TripoSRModel<T>(transformer: (DiTNoisePredictor<T>)_transformer.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner, defaultPointCount: DefaultPointCount);
-    }
-
     #endregion
 
     #region Metadata
diff --git a/src/Diffusion/ThreeD/Wonder3DModel.cs b/src/Diffusion/ThreeD/Wonder3DModel.cs
index 6797187c28..d61dacd829 100644
--- a/src/Diffusion/ThreeD/Wonder3DModel.cs
+++ b/src/Diffusion/ThreeD/Wonder3DModel.cs
@@ -222,34 +222,6 @@ public override Mesh3D<T> GenerateMesh(string prompt, string? negativePrompt = n
 
     #region ICloneable Implementation
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        // Delegate to the U-Net's and VAE's own Clone implementations, which
-        // resolve lazy shape inference on BOTH source and clone before copying
-        // weights. The previous "construct fresh + SetParameters(GetParameters())"
-        // dance re-hit the lazy-init bug on the U-Net AND never copied the VAE's
-        // weights at all — the clone decoded through a fresh random VAE and
-        // produced different Predict outputs than the source
-        // (Clone_ShouldProduceIdenticalOutput). Same fix pattern as
-        // SDXLTurboModel / RealESRGANModel / EDiffIModel (PR #1562).
-        // Preserve outer configuration (architecture / options / scheduler) so
-        // custom diffusion settings round-trip through Clone.
-        var clonedUnet = (UNetNoisePredictor<T>)_unet.Clone();
-        var clonedVae = (StandardVAE<T>)_vae.Clone();
-        return new Wonder3DModel<T>(
-            architecture: Architecture,
-            options: (DiffusionModelOptions<T>)GetOptions(),
-            scheduler: Scheduler,
-            unet: clonedUnet,
-            vae: clonedVae,
-            conditioner: _conditioner,
-            defaultPointCount: DefaultPointCount);
-    }
-
     #endregion
 
     #region Metadata
diff --git a/src/Diffusion/ThreeD/Zero123Model.cs b/src/Diffusion/ThreeD/Zero123Model.cs
index 8627026d5b..b956074cf8 100644
--- a/src/Diffusion/ThreeD/Zero123Model.cs
+++ b/src/Diffusion/ThreeD/Zero123Model.cs
@@ -465,30 +465,6 @@ private void AddParams(List<T> allParams, Vector<T> p)
 
     #region ICloneable Implementation
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy()
-    {
-        return Clone();
-    }
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        // Lazy-preserving Clone (recipe from #1596): inject the UNet's and VAE's own lazy-preserving
-        // Clone() so the clone's UNet/VAE are MATERIALIZED targets. The default ctor builds a lazy
-        // foundation-scale UNet whose weights only allocate on first forward, so the old
-        // SetParameters(GetParameters()) had no tensors to write into and the clone re-randomized.
-        // The image/pose encoders are eager (allocated in their ctors), so SetParameters still copies
-        // their trained values correctly.
-        var clone = new Zero123Model<T>(
-            unet: (UNetNoisePredictor<T>)_unet.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            seed: null);
-
-        if (!clone.TryShareParametersFrom(this)) clone.SetParameterChunks(GetParameterChunks());
-        return clone;
-    }
-
     #endregion
 }
 
diff --git a/src/Diffusion/ThreeDDiffusionModelBase.cs b/src/Diffusion/ThreeDDiffusionModelBase.cs
index 69b11011c3..ce2d8682e1 100644
--- a/src/Diffusion/ThreeDDiffusionModelBase.cs
+++ b/src/Diffusion/ThreeDDiffusionModelBase.cs
@@ -34,7 +34,7 @@ namespace AiDotNet.Diffusion;
 /// 3. Score Distillation: Use 2D diffusion knowledge to guide 3D optimization
 /// </para>
 /// </remarks>
-public abstract class ThreeDDiffusionModelBase<T> : LatentDiffusionModelBase<T>, I3DDiffusionModel<T>
+public abstract partial class ThreeDDiffusionModelBase<T> : LatentDiffusionModelBase<T>, I3DDiffusionModel<T>
 {
     /// <summary>
     /// Default number of points in generated point clouds.
diff --git a/src/Diffusion/VAE/AudioVAE.cs b/src/Diffusion/VAE/AudioVAE.cs
index acd26c483e..349a09d2e8 100644
--- a/src/Diffusion/VAE/AudioVAE.cs
+++ b/src/Diffusion/VAE/AudioVAE.cs
@@ -677,27 +677,6 @@ private double MelToFrequency(int melBin, int totalBins, int sampleRate)
 
     #region ICloneable Implementation
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy()
-    {
-        return Clone();
-    }
-
-    /// <inheritdoc />
-    public override IVAEModel<T> Clone()
-    {
-        var clone = new AudioVAE<T>(
-            _melChannels,
-            _latentChannels,
-            _baseChannels,
-            _channelMultipliers,
-            _numResBlocks);
-
-        // Preserve trained weights
-        if (!clone.TryShareParametersFrom(this)) clone.SetParameterChunks(GetParameterChunks());
-        return clone;
-    }
-
     #endregion
 
     protected override Vector<T> GetParameterGradients()
diff --git a/src/Diffusion/VAE/AutoencoderKL.cs b/src/Diffusion/VAE/AutoencoderKL.cs
index 2f11c1f160..e49c4f9aa4 100644
--- a/src/Diffusion/VAE/AutoencoderKL.cs
+++ b/src/Diffusion/VAE/AutoencoderKL.cs
@@ -126,11 +126,13 @@ protected override void RegisterComponents()
     /// <summary>
     /// Cached mean from last encoding.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _cachedMean;
 
     /// <summary>
     /// Cached log variance from last encoding.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _cachedLogVar;
 
     /// <summary>
@@ -502,30 +504,6 @@ public override void LoadState(Stream stream)
 
     #region Cloning
 
-    /// <inheritdoc />
-    public override IVAEModel<T> Clone()
-    {
-        var clone = new AutoencoderKL<T>(
-            _inputChannels,
-            _latentChannels,
-            _baseChannels,
-            _channelMults,
-            numResBlocks: 2,
-            numGroups: 32,
-            _latentScaleFactor,
-            inputSpatialSize: 512,
-            LossFunction);
-
-        if (!clone.TryShareParametersFrom(this)) clone.SetParameterChunks(GetParameterChunks());
-        return clone;
-    }
-
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy()
-    {
-        return Clone();
-    }
-
     #endregion
 
     /// <summary>
diff --git a/src/Diffusion/VAE/Causal3DVAE.cs b/src/Diffusion/VAE/Causal3DVAE.cs
index e5190f08f0..a31abaa71a 100644
--- a/src/Diffusion/VAE/Causal3DVAE.cs
+++ b/src/Diffusion/VAE/Causal3DVAE.cs
@@ -181,20 +181,6 @@ public override Tensor<T> Decode(Tensor<T> latent)
         return x;
     }
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy()
-    {
-        var clone = new Causal3DVAE<T>(
-            inputChannels: _inputChannels,
-            latentChannels: _latentChannels,
-            baseChannels: _baseChannels,
-            channelMultipliers: (int[])_channelMultipliers.Clone(),
-            temporalCompression: _temporalCompression,
-            latentScaleFactor: _latentScaleFactor);
-        if (!clone.TryShareParametersFrom(this)) clone.SetParameterChunks(GetParameterChunks());
-        return clone;
-    }
-
     private static int[] GetReducedShape(int[] shape, int lastDim)
     {
         var result = (int[])shape.Clone();
@@ -202,20 +188,6 @@ private static int[] GetReducedShape(int[] shape, int lastDim)
         return result;
     }
 
-    /// <inheritdoc />
-    public override IVAEModel<T> Clone()
-    {
-        var clone = new Causal3DVAE<T>(
-            inputChannels: _inputChannels,
-            latentChannels: _latentChannels,
-            baseChannels: _baseChannels,
-            channelMultipliers: (int[])_channelMultipliers.Clone(),
-            temporalCompression: _temporalCompression,
-            latentScaleFactor: _latentScaleFactor);
-        if (!clone.TryShareParametersFrom(this)) clone.SetParameterChunks(GetParameterChunks());
-        return clone;
-    }
-
     protected override Vector<T> GetParameterGradients()
     {
         var parts = new[]
diff --git a/src/Diffusion/VAE/DeepCompressionVAE.cs b/src/Diffusion/VAE/DeepCompressionVAE.cs
index fad91c808f..1596ca08b6 100644
--- a/src/Diffusion/VAE/DeepCompressionVAE.cs
+++ b/src/Diffusion/VAE/DeepCompressionVAE.cs
@@ -240,19 +240,6 @@ public override Tensor<T> Decode(Tensor<T> latent)
     }
 
 
-    /// <inheritdoc />
-    public override IVAEModel<T> Clone()
-    {
-        var clone = new DeepCompressionVAE<T>(
-            _inputChannels, _latentChannels, _downsampleFactor, _baseChannels,
-            LossFunction);
-        if (!clone.TryShareParametersFrom(this)) clone.SetParameterChunks(GetParameterChunks());
-        return clone;
-    }
-
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
     protected override Vector<T> GetParameterGradients()
     {
         var gradients = new List<T>();
diff --git a/src/Diffusion/VAE/DownBlock.cs b/src/Diffusion/VAE/DownBlock.cs
index c93ab2c4c0..932eb67274 100644
--- a/src/Diffusion/VAE/DownBlock.cs
+++ b/src/Diffusion/VAE/DownBlock.cs
@@ -139,6 +139,7 @@ AxisRelation Spatial(TensorAxis axis) => _hasDownsample
     /// <summary>
     /// Cached inputs and intermediate values for backward pass.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastInput;
     private readonly Tensor<T>?[] _resBlockOutputs;
     private Tensor<T>? _preDownsampleOutput;
@@ -348,57 +349,6 @@ public override void ResetState()
     }
 
 
-    /// <summary>
-    /// Saves the block's state to a binary writer.
-    /// </summary>
-    public override void Serialize(BinaryWriter writer)
-    {
-        base.Serialize(writer);
-
-        writer.Write(_inChannels);
-        writer.Write(_outChannels);
-        writer.Write(_numLayers);
-        writer.Write(_numGroups);
-        writer.Write(_inputSpatialSize);
-        writer.Write(_hasDownsample);
-
-        foreach (var block in _resBlocks)
-        {
-            block.Serialize(writer);
-        }
-
-        _downsample.Serialize(writer);
-    }
-
-    /// <summary>
-    /// Loads the block's state from a binary reader.
-    /// </summary>
-    public override void Deserialize(BinaryReader reader)
-    {
-        base.Deserialize(reader);
-
-        var inChannels = reader.ReadInt32();
-        var outChannels = reader.ReadInt32();
-        var numLayers = reader.ReadInt32();
-        var numGroups = reader.ReadInt32();
-        var inputSpatialSize = reader.ReadInt32();
-        var hasDownsample = reader.ReadBoolean();
-
-        if (inChannels != _inChannels || outChannels != _outChannels ||
-            numLayers != _numLayers || hasDownsample != _hasDownsample)
-        {
-            throw new InvalidOperationException(
-                $"Architecture mismatch in DownBlock deserialization.");
-        }
-
-        foreach (var block in _resBlocks)
-        {
-            block.Deserialize(reader);
-        }
-
-        _downsample.Deserialize(reader);
-    }
-
     /// <summary>
     /// Gets the residual blocks for external access (e.g., for skip connections in UNet).
     /// </summary>
diff --git a/src/Diffusion/VAE/EQVAEModel.cs b/src/Diffusion/VAE/EQVAEModel.cs
index 739be32c14..65851fc0d7 100644
--- a/src/Diffusion/VAE/EQVAEModel.cs
+++ b/src/Diffusion/VAE/EQVAEModel.cs
@@ -277,19 +277,6 @@ public T ComputeEquivarianceLoss(Tensor<T> original, Tensor<T> transformed)
     }
 
 
-    /// <inheritdoc />
-    public override IVAEModel<T> Clone()
-    {
-        var clone = new EQVAEModel<T>(
-            _inputChannels, _latentChannels, _baseChannels,
-            _equivarianceWeight, LossFunction);
-        if (!clone.TryShareParametersFrom(this)) clone.SetParameterChunks(GetParameterChunks());
-        return clone;
-    }
-
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
     protected override Vector<T> GetParameterGradients()
     {
         var gradients = new List<T>();
diff --git a/src/Diffusion/VAE/ImprovedVideoVAE.cs b/src/Diffusion/VAE/ImprovedVideoVAE.cs
index b7c711d24e..b23f3eb5f2 100644
--- a/src/Diffusion/VAE/ImprovedVideoVAE.cs
+++ b/src/Diffusion/VAE/ImprovedVideoVAE.cs
@@ -283,19 +283,6 @@ public List<Tensor<T>> EncodeVideo(List<Tensor<T>> frames)
     }
 
 
-    /// <inheritdoc />
-    public override IVAEModel<T> Clone()
-    {
-        var clone = new ImprovedVideoVAE<T>(
-            _inputChannels, _latentChannels, _baseChannels,
-            _temporalDownsample, LossFunction);
-        if (!clone.TryShareParametersFrom(this)) clone.SetParameterChunks(GetParameterChunks());
-        return clone;
-    }
-
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
     protected override Vector<T> GetParameterGradients()
     {
         var gradients = new List<T>();
diff --git a/src/Diffusion/VAE/LiteVAEModel.cs b/src/Diffusion/VAE/LiteVAEModel.cs
index b2cbcc7d4f..6aa83e504f 100644
--- a/src/Diffusion/VAE/LiteVAEModel.cs
+++ b/src/Diffusion/VAE/LiteVAEModel.cs
@@ -237,18 +237,6 @@ public override Tensor<T> Decode(Tensor<T> latent)
     }
 
 
-    /// <inheritdoc />
-    public override IVAEModel<T> Clone()
-    {
-        var clone = new LiteVAEModel<T>(
-            _inputChannels, _latentChannels, _baseChannels, LossFunction);
-        if (!clone.TryShareParametersFrom(this)) clone.SetParameterChunks(GetParameterChunks());
-        return clone;
-    }
-
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
     protected override Vector<T> GetParameterGradients()
     {
         var gradients = new List<T>();
diff --git a/src/Diffusion/VAE/SDXLVAEModel.cs b/src/Diffusion/VAE/SDXLVAEModel.cs
index 52e623181e..1f91c86c9b 100644
--- a/src/Diffusion/VAE/SDXLVAEModel.cs
+++ b/src/Diffusion/VAE/SDXLVAEModel.cs
@@ -283,19 +283,6 @@ private static void SetLayerParams(ILayer<T>? layer, Vector<T> parameters, ref i
         layer.SetParameters(np);
     }
 
-    /// <inheritdoc />
-    public override IVAEModel<T> Clone()
-    {
-        var clone = new SDXLVAEModel<T>(
-            _inputChannels, _latentChannels, _baseChannels,
-            _channelMultipliers, LossFunction);
-        if (!clone.TryShareParametersFrom(this)) clone.SetParameterChunks(GetParameterChunks());
-        return clone;
-    }
-
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
     protected override Vector<T> GetParameterGradients()
     {
         var gradients = new List<T>();
diff --git a/src/Diffusion/VAE/StandardVAE.cs b/src/Diffusion/VAE/StandardVAE.cs
index 481c07b47e..f5bb4ed4fc 100644
--- a/src/Diffusion/VAE/StandardVAE.cs
+++ b/src/Diffusion/VAE/StandardVAE.cs
@@ -223,6 +223,7 @@ private void RegisterLayerCollection(string prefix, IReadOnlyList<ILayer<T>> lay
     /// Tracks whether the VAE layer graph has been built. Default paper-scale
     /// constructors defer this work until first use to keep construction cheap.
     /// </summary>
+    [Scratch]
     private bool _layersInitialized;
 
     /// <inheritdoc />
@@ -591,17 +592,6 @@ private static void AddLayerCount(ref long count, ILayer<T>? layer)
         if (layer != null) count += (int)layer.ParameterCount;
     }
 
-    /// <inheritdoc />
-    public override IEnumerable<Tensor<T>> GetParameterChunks()
-    {
-        EnsureLayersInitialized();
-        foreach (var layer in EnumerateAllLayers())
-        {
-            foreach (var parameter in EnumerateMaterializedParameters(layer))
-                yield return parameter;
-        }
-    }
-
     private IEnumerable<ILayer<T>?> EnumerateAllLayers()
     {
         yield return _inputConv;
@@ -656,48 +646,6 @@ private void SetLayerParameters(ILayer<T>? layer, Vector<T> parameters, ref int
 
     #region ICloneable Implementation
 
-    /// <inheritdoc />
-    public override IVAEModel<T> Clone()
-    {
-        var clone = new StandardVAE<T>(
-            architecture: _architecture,
-            inputChannels: _inputChannels,
-            latentChannels: _latentChannels,
-            baseChannels: _baseChannels,
-            channelMultipliers: _channelMultipliers,
-            numResBlocksPerLevel: _numResBlocksPerLevel,
-            latentScaleFactor: _latentScaleFactor,
-            lossFunction: LossFunction);
-
-        // Keep source and destination at the same structural lifecycle before comparing or copying
-        // tensors. ParameterCount/GetParameters can resolve the lazy graph without a real forward;
-        // measuring before that resolution and copying afterward compares different layer sequences.
-        bool structureResolved = _shapesResolvedViaForward;
-        if (structureResolved)
-            clone.ResolveShapesViaForward();
-        else if (_layersInitialized)
-            clone.EnsureLayersInitialized();
-
-        // A flat parameter read materializes the complete generated surface without running
-        // Encode/Decode, so the forward-only flag is not enough to decide whether trained state
-        // exists. Only compare against ParameterCount after structure is already stable, ensuring
-        // the metadata read cannot mutate the sequence being measured.
-        bool hasCompleteMaterializedSurface = structureResolved
-            && GetMaterializedParameterCount() == ParameterCount;
-        if (_preserveMaterializedParameters || hasCompleteMaterializedSurface)
-        {
-            TriggerLazyShapeResolution();
-            clone.TriggerLazyShapeResolution();
-            if (!clone.TryShareParametersFrom(this))
-                CopyMaterializedParametersTo(clone);
-        }
-        else
-        {
-            CopyMaterializedParametersTo(clone);
-        }
-        return clone;
-    }
-
     private long GetMaterializedParameterCount()
     {
         long count = 0;
@@ -768,8 +716,10 @@ private static void CopyTensorData(Tensor<T> source, Tensor<T> target)
     /// invariant), so any size works as long as the conv stack doesn't
     /// underflow.
     /// </remarks>
+    [Scratch]
     private bool _lazyShapesResolved;
 
+    [Scratch]
     private bool _shapesResolvedViaForward;
 
     /// <summary>
@@ -814,12 +764,6 @@ internal void TriggerLazyShapeResolution()
         _ = Decode(dummyLatent);
     }
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy()
-    {
-        return Clone();
-    }
-
     #endregion
 
     #region Layer-Level Backpropagation
diff --git a/src/Diffusion/VAE/TemporalInterpolationVAE.cs b/src/Diffusion/VAE/TemporalInterpolationVAE.cs
index 66fdd03703..803e31f977 100644
--- a/src/Diffusion/VAE/TemporalInterpolationVAE.cs
+++ b/src/Diffusion/VAE/TemporalInterpolationVAE.cs
@@ -198,19 +198,6 @@ public override Tensor<T> Decode(Tensor<T> latent)
         return x;
     }
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy()
-    {
-        var clone = new TemporalInterpolationVAE<T>(
-            inputChannels: _inputChannels,
-            latentChannels: _latentChannels,
-            baseChannels: _baseChannels,
-            interpolationFactor: _interpolationFactor,
-            latentScaleFactor: _latentScaleFactor);
-        if (!clone.TryShareParametersFrom(this)) clone.SetParameterChunks(GetParameterChunks());
-        return clone;
-    }
-
     /// <summary>
     /// Interpolates between two latent frames to generate an intermediate frame.
     /// </summary>
@@ -261,19 +248,6 @@ private static int[] GetReducedShape(int[] shape, int lastDim)
         return result;
     }
 
-    /// <inheritdoc />
-    public override IVAEModel<T> Clone()
-    {
-        var clone = new TemporalInterpolationVAE<T>(
-            inputChannels: _inputChannels,
-            latentChannels: _latentChannels,
-            baseChannels: _baseChannels,
-            interpolationFactor: _interpolationFactor,
-            latentScaleFactor: _latentScaleFactor);
-        if (!clone.TryShareParametersFrom(this)) clone.SetParameterChunks(GetParameterChunks());
-        return clone;
-    }
-
     protected override Vector<T> GetParameterGradients()
     {
         var parts = new[]
diff --git a/src/Diffusion/VAE/TemporalVAE.cs b/src/Diffusion/VAE/TemporalVAE.cs
index 6abc248db1..d79f74d493 100644
--- a/src/Diffusion/VAE/TemporalVAE.cs
+++ b/src/Diffusion/VAE/TemporalVAE.cs
@@ -796,16 +796,6 @@ private void AddLayerParameters(List<T> parameters, ILayer<T>? layer)
         }
     }
 
-    /// <inheritdoc />
-    public override IEnumerable<Tensor<T>> GetParameterChunks()
-    {
-        foreach (var layer in EnumerateAllLayers())
-        {
-            foreach (var parameter in EnumerateMaterializedParameters(layer))
-                yield return parameter;
-        }
-    }
-
     private IEnumerable<ILayer<T>?> EnumerateAllLayers()
     {
         yield return _inputConv;
@@ -865,40 +855,6 @@ private void SetLayerParameters(ILayer<T>? layer, Vector<T> parameters, ref int
 
     #region ICloneable Implementation
 
-    /// <inheritdoc />
-    public override IVAEModel<T> Clone()
-    {
-        var clone = new TemporalVAE<T>(
-            _inputChannels,
-            _latentChannels,
-            _baseChannels,
-            _channelMultipliers,
-            _numTemporalLayers,
-            _temporalKernelSize,
-            _causalMode,
-            _latentScaleFactor,
-            LossFunction);
-
-        if (_preserveMaterializedParameters)
-        {
-            // The encoder/decoder conv stacks are lazy — they only ALLOCATE their weight tensors on
-            // the first Encode/Decode, not at construction. A fresh clone has the layer STRUCTURE but
-            // unallocated weights, so SetParameters(GetParameters()) onto it copies into nothing and the
-            // clone re-initializes with a fresh RNG on its first real forward → divergent Predict and a
-            // parameter-count mismatch. Resolve both sides' lazy shapes (one tiny encode+decode) before
-            // the parameter round-trip so the vectors line up and the trained values land. Mirrors
-            // StandardVAE.Clone.
-            TriggerLazyShapeResolution();
-            clone.TriggerLazyShapeResolution();
-            if (!clone.TryShareParametersFrom(this)) clone.SetParameterChunks(GetParameterChunks());
-        }
-        else
-        {
-            CopyMaterializedParametersTo(clone);
-        }
-        return clone;
-    }
-
     /// <summary>
     /// Materializes every lazy encoder/decoder weight tensor by running one tiny encode+decode probe,
     /// so <see cref="GetParameters"/>/<see cref="SetParameters"/>/parameter-count agree before any real
@@ -966,12 +922,6 @@ private static void CopyTensorData(Tensor<T> source, Tensor<T> target)
         source.Data.Span.CopyTo(target.Data.Span);
     }
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy()
-    {
-        return Clone();
-    }
-
     #endregion
 
     protected override Vector<T> GetParameterGradients()
diff --git a/src/Diffusion/VAE/UpBlock.cs b/src/Diffusion/VAE/UpBlock.cs
index e452889a56..af3a614153 100644
--- a/src/Diffusion/VAE/UpBlock.cs
+++ b/src/Diffusion/VAE/UpBlock.cs
@@ -152,6 +152,7 @@ public partial class UpBlock<T> : LayerBase<T>, IShapeContract
     /// <summary>
     /// Cached inputs and intermediate values for backward pass.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastInput;
     private Tensor<T>? _postUpsampleOutput;
     private readonly Tensor<T>?[] _resBlockOutputs;
@@ -373,63 +374,6 @@ public override void ResetState()
     }
 
 
-    /// <summary>
-    /// Saves the block's state to a binary writer.
-    /// </summary>
-    public override void Serialize(BinaryWriter writer)
-    {
-        base.Serialize(writer);
-
-        writer.Write(_inChannels);
-        writer.Write(_outChannels);
-        writer.Write(_numLayers);
-        writer.Write(_numGroups);
-        writer.Write(_inputSpatialSize);
-        writer.Write(_hasUpsample);
-
-        if (_hasUpsample && _upsample != null)
-        {
-            _upsample.Serialize(writer);
-        }
-
-        foreach (var block in _resBlocks)
-        {
-            block.Serialize(writer);
-        }
-    }
-
-    /// <summary>
-    /// Loads the block's state from a binary reader.
-    /// </summary>
-    public override void Deserialize(BinaryReader reader)
-    {
-        base.Deserialize(reader);
-
-        var inChannels = reader.ReadInt32();
-        var outChannels = reader.ReadInt32();
-        var numLayers = reader.ReadInt32();
-        var numGroups = reader.ReadInt32();
-        var inputSpatialSize = reader.ReadInt32();
-        var hasUpsample = reader.ReadBoolean();
-
-        if (inChannels != _inChannels || outChannels != _outChannels ||
-            numLayers != _numLayers || hasUpsample != _hasUpsample)
-        {
-            throw new InvalidOperationException(
-                $"Architecture mismatch in UpBlock deserialization.");
-        }
-
-        if (_hasUpsample && _upsample != null)
-        {
-            _upsample.Deserialize(reader);
-        }
-
-        foreach (var block in _resBlocks)
-        {
-            block.Deserialize(reader);
-        }
-    }
-
     /// <summary>
     /// Gets the residual blocks for external access.
     /// </summary>
diff --git a/src/Diffusion/VAE/VAEDecoder.cs b/src/Diffusion/VAE/VAEDecoder.cs
index 528db03ea8..a54e697d69 100644
--- a/src/Diffusion/VAE/VAEDecoder.cs
+++ b/src/Diffusion/VAE/VAEDecoder.cs
@@ -185,13 +185,17 @@ public partial class VAEDecoder<T> : LayerBase<T>, IShapeContract
     /// <summary>
     /// Cached intermediate values for backward pass.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastInput;
     private Tensor<T>? _postQuantOutput;
     private Tensor<T>? _inputConvOutput;
     private Tensor<T>? _midBlock1Output;
+    [AiDotNet.Attributes.Scratch]
     private Tensor<T>? _midBlock2Output;
     private readonly Tensor<T>?[] _upBlockOutputs;
+    [AiDotNet.Attributes.Scratch]
     private Tensor<T>? _normOutOutput;
+    [AiDotNet.Attributes.Scratch]
     private Tensor<T>? _siluOutput;
 
     /// <inheritdoc />
@@ -591,96 +595,4 @@ public override void ResetState()
         _normOut.ResetState();
         _outputConv.ResetState();
     }
-
-    /// <summary>
-    /// Saves the decoder's state to a binary writer.
-    /// </summary>
-    public override void Serialize(BinaryWriter writer)
-    {
-        base.Serialize(writer);
-
-        writer.Write(_outputChannels);
-        writer.Write(_latentChannels);
-        writer.Write(_baseChannels);
-        writer.Write(_channelMults.Length);
-        foreach (var mult in _channelMults)
-        {
-            writer.Write(mult);
-        }
-        writer.Write(_numGroups);
-        writer.Write(_bottleneckSize);
-        writer.Write(_outputSpatialSize);
-        writer.Write(_numResBlocks);
-
-        _postQuantConv.Serialize(writer);
-        _inputConv.Serialize(writer);
-
-        foreach (var block in _midBlocks)
-        {
-            block.Serialize(writer);
-        }
-
-        foreach (var block in _upBlocks)
-        {
-            block.Serialize(writer);
-        }
-
-        _normOut.Serialize(writer);
-        _outputConv.Serialize(writer);
-    }
-
-    /// <summary>
-    /// Loads the decoder's state from a binary reader.
-    /// </summary>
-    public override void Deserialize(BinaryReader reader)
-    {
-        base.Deserialize(reader);
-
-        var outputChannels = reader.ReadInt32();
-        var latentChannels = reader.ReadInt32();
-        var baseChannels = reader.ReadInt32();
-        var numMults = reader.ReadInt32();
-        var channelMults = new int[numMults];
-        for (int i = 0; i < numMults; i++)
-        {
-            channelMults[i] = reader.ReadInt32();
-        }
-        var numGroups = reader.ReadInt32();
-        var bottleneckSize = reader.ReadInt32();
-        var outputSpatialSize = reader.ReadInt32();
-        var numResBlocks = reader.ReadInt32();
-
-        if (outputChannels != _outputChannels || latentChannels != _latentChannels ||
-            baseChannels != _baseChannels || !channelMults.SequenceEqual(_channelMults) ||
-            numGroups != _numGroups || bottleneckSize != _bottleneckSize ||
-            outputSpatialSize != _outputSpatialSize || numResBlocks != _numResBlocks)
-        {
-            throw new InvalidOperationException(
-                "Architecture mismatch in VAEDecoder deserialization. " +
-                $"Expected (outputChannels={_outputChannels}, latentChannels={_latentChannels}, " +
-                $"baseChannels={_baseChannels}, channelMults=[{string.Join(",", _channelMults)}], " +
-                $"numGroups={_numGroups}, bottleneckSize={_bottleneckSize}, " +
-                $"outputSpatialSize={_outputSpatialSize}, numResBlocks={_numResBlocks}); " +
-                $"got (outputChannels={outputChannels}, latentChannels={latentChannels}, " +
-                $"baseChannels={baseChannels}, channelMults=[{string.Join(",", channelMults)}], " +
-                $"numGroups={numGroups}, bottleneckSize={bottleneckSize}, " +
-                $"outputSpatialSize={outputSpatialSize}, numResBlocks={numResBlocks}).");
-        }
-
-        _postQuantConv.Deserialize(reader);
-        _inputConv.Deserialize(reader);
-
-        foreach (var block in _midBlocks)
-        {
-            block.Deserialize(reader);
-        }
-
-        foreach (var block in _upBlocks)
-        {
-            block.Deserialize(reader);
-        }
-
-        _normOut.Deserialize(reader);
-        _outputConv.Deserialize(reader);
-    }
 }
diff --git a/src/Diffusion/VAE/VAEEncoder.cs b/src/Diffusion/VAE/VAEEncoder.cs
index a3c4263120..162bb649ce 100644
--- a/src/Diffusion/VAE/VAEEncoder.cs
+++ b/src/Diffusion/VAE/VAEEncoder.cs
@@ -187,12 +187,16 @@ public partial class VAEEncoder<T> : LayerBase<T>, IShapeContract
     /// <summary>
     /// Cached intermediate values for backward pass.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastInput;
     private Tensor<T>? _inputConvOutput;
     private readonly Tensor<T>?[] _downBlockOutputs;
     private Tensor<T>? _midBlock1Output;
+    [AiDotNet.Attributes.Scratch]
     private Tensor<T>? _midBlock2Output;
+    [AiDotNet.Attributes.Scratch]
     private Tensor<T>? _normOutOutput;
+    [AiDotNet.Attributes.Scratch]
     private Tensor<T>? _siluOutput;
 
     /// <inheritdoc />
@@ -213,6 +217,12 @@ public partial class VAEEncoder<T> : LayerBase<T>, IShapeContract
     /// </summary>
     public int DownsampleFactor => (int)Math.Pow(2, _channelMults.Length - 1);
 
+    /// <summary>Construction state: the 'inputSpatialSize' the layer was built with.</summary>
+    private readonly int _inputSpatialSize;
+
+    /// <summary>Construction state: the 'numResBlocks' the layer was built with.</summary>
+    private readonly int _numResBlocks;
+
     /// <summary>
     /// Initializes a new instance of the VAEEncoder class.
     /// </summary>
@@ -235,6 +245,8 @@ public VAEEncoder(
             CalculateInputShape(inputChannels, inputSpatialSize),
             CalculateOutputShape(latentChannels, inputSpatialSize, channelMults?.Length ?? 4))
     {
+        _numResBlocks = numResBlocks;
+        _inputSpatialSize = inputSpatialSize;
         if (inputChannels <= 0)
             throw new ArgumentOutOfRangeException(nameof(inputChannels));
         if (latentChannels <= 0)
@@ -677,85 +689,6 @@ public override void ResetState()
         _quantConv.ResetState();
     }
 
-    /// <summary>
-    /// Saves the encoder's state to a binary writer.
-    /// </summary>
-    public override void Serialize(BinaryWriter writer)
-    {
-        base.Serialize(writer);
-
-        writer.Write(_inputChannels);
-        writer.Write(_latentChannels);
-        writer.Write(_baseChannels);
-        writer.Write(_channelMults.Length);
-        foreach (var mult in _channelMults)
-        {
-            writer.Write(mult);
-        }
-        writer.Write(_numGroups);
-        writer.Write(_bottleneckSize);
-
-        _inputConv.Serialize(writer);
-
-        foreach (var block in _downBlocks)
-        {
-            block.Serialize(writer);
-        }
-
-        foreach (var block in _midBlocks)
-        {
-            block.Serialize(writer);
-        }
-
-        _normOut.Serialize(writer);
-        _meanConv.Serialize(writer);
-        _logVarConv.Serialize(writer);
-        _quantConv.Serialize(writer);
-    }
-
-    /// <summary>
-    /// Loads the encoder's state from a binary reader.
-    /// </summary>
-    public override void Deserialize(BinaryReader reader)
-    {
-        base.Deserialize(reader);
-
-        var inputChannels = reader.ReadInt32();
-        var latentChannels = reader.ReadInt32();
-        var baseChannels = reader.ReadInt32();
-        var numMults = reader.ReadInt32();
-        var channelMults = new int[numMults];
-        for (int i = 0; i < numMults; i++)
-        {
-            channelMults[i] = reader.ReadInt32();
-        }
-        _ = reader.ReadInt32(); // numGroups
-        _ = reader.ReadInt32(); // bottleneckSize
-
-        if (inputChannels != _inputChannels || latentChannels != _latentChannels ||
-            baseChannels != _baseChannels || !channelMults.SequenceEqual(_channelMults))
-        {
-            throw new InvalidOperationException("Architecture mismatch in VAEEncoder deserialization.");
-        }
-
-        _inputConv.Deserialize(reader);
-
-        foreach (var block in _downBlocks)
-        {
-            block.Deserialize(reader);
-        }
-
-        foreach (var block in _midBlocks)
-        {
-            block.Deserialize(reader);
-        }
-
-        _normOut.Deserialize(reader);
-        _meanConv.Deserialize(reader);
-        _logVarConv.Deserialize(reader);
-        _quantConv.Deserialize(reader);
-    }
-
     #region IWeightLoadable Implementation
 
     /// <summary>
diff --git a/src/Diffusion/VAE/VAEModelBase.cs b/src/Diffusion/VAE/VAEModelBase.cs
index 26f206ec32..e0a8f4fe7b 100644
--- a/src/Diffusion/VAE/VAEModelBase.cs
+++ b/src/Diffusion/VAE/VAEModelBase.cs
@@ -1,4 +1,4 @@
-using AiDotNet.Autodiff;
+using AiDotNet.Autodiff;
 using AiDotNet.Engines;
 using AiDotNet.Extensions;
 using AiDotNet.Interfaces;
@@ -23,10 +23,53 @@ namespace AiDotNet.Diffusion.VAE;
 /// They are essential for efficient latent diffusion models like Stable Diffusion.
 /// </para>
 /// </remarks>
-public abstract class VAEModelBase<T> : IVAEModel<T>, IModelShape,
+public abstract partial class VAEModelBase<T> : IVAEModel<T>, IModelShape,
     AiDotNet.Models.Parameters.IParameterManifestProvider,
     AiDotNet.Models.Parameters.IParameterSurfaceLifecycle
 {
+    // --- declared state (ModelStateRegistry) ---
+    // Identical in every model base because these bases are siblings over the same interfaces rather
+    // than one hierarchy; the logic itself lives once in ModelStateRegistry/ModelStateEnvelope.
+
+    /// <summary>State that is not a parameter vector, declared once and persisted by this base.</summary>
+    private readonly AiDotNet.Models.ModelStateRegistry<T> _declaredState = new();
+    private bool _declaredStateRegistered;
+
+    /// <summary>
+    /// Declare state here that the parameter vector does not carry -- a retained training set,
+    /// fitted knots, kernel centres, an ensemble's children. Both halves of the payload are driven
+    /// by the declaration, so they cannot drift.
+    /// </summary>
+    /// <param name="state">The registry to declare into.</param>
+    protected virtual void RegisterState(AiDotNet.Models.ModelStateRegistry<T> state)
+    {
+    }
+    /// <summary>Generated state declarations for fields declared across this model's hierarchy.</summary>
+    /// <param name="state">The registry to declare into.</param>
+    /// <remarks>
+    /// Emitted by ModelStateGenerator into the partial model, so a model author declares nothing. The
+    /// hand-written <c>RegisterState</c> beside it exists only for state the classifier genuinely
+    /// cannot place; anything it CAN place belongs here, where it cannot be forgotten.
+    /// </remarks>
+    protected virtual void RegisterGeneratedState(AiDotNet.Models.ModelStateRegistry<T> state)
+    {
+        RegisterGeneratedStateCore(state);
+    }
+
+    /// <summary>The declared state, registered once and lazily so it runs after the constructor.</summary>
+    protected AiDotNet.Models.ModelStateRegistry<T> DeclaredState
+    {
+        get
+        {
+            if (!_declaredStateRegistered)
+            {
+                _declaredStateRegistered = true;
+                RegisterGeneratedState(_declaredState);
+                RegisterState(_declaredState);
+            }
+            return _declaredState;
+        }
+    }
     /// <summary>
     /// Provides access to the hardware-accelerated tensor engine.
     /// </summary>
@@ -239,19 +282,18 @@ public virtual long ParameterCount
     }
 
     /// <summary>
-    /// Streams the VAE's trainable weight tensors per-tensor without
+    /// Streams the VAE's registered parameter state in canonical stable-ID order without
     /// materialising a flat aggregate, mirroring PyTorch's
-    /// <c>nn.Module.parameters()</c> generator pattern. Default
-    /// implementation yields a single chunk wrapping
-    /// <see cref="GetParameters"/>; subclasses with separable
-    /// encoder/decoder weight stores can override to yield each piece
-    /// independently.
+    /// <c>nn.Module.parameters()</c> generator pattern. The shared registry lifecycle prepares
+    /// and materialises lazy sources before enumeration, so every VAE exposes the same complete
+    /// surface through flat reads, chunk reads, cloning, and checkpointing without model-specific
+    /// plumbing.
     /// </summary>
     public virtual IEnumerable<Tensor<T>> GetParameterChunks()
     {
-        var p = GetParameters();
-        if (p.Length == 0) yield break;
-        yield return new Tensor<T>(new[] { p.Length }, p);
+        EnsureComponentsRegistered();
+        foreach (var chunk in _parameterRegistry.GetParameterStateChunks())
+            yield return chunk.Tensor;
     }
 
     /// <summary>
@@ -480,12 +522,15 @@ public virtual byte[] Serialize()
         ModelPersistenceGuard.EnforceBeforeSerialize();
         using var stream = new MemoryStream();
         SaveState(stream);
-        return stream.ToArray();
+        return AiDotNet.Models.ModelStateEnvelope.Append(DeclaredState, stream.ToArray());
     }
 
     /// <inheritdoc />
     public virtual void Deserialize(byte[] data)
     {
+        // Strips and applies any declared-state trailer, so the body below reads the payload
+        // exactly as it did before this existed.
+        data = AiDotNet.Models.ModelStateEnvelope.Extract(DeclaredState, data);
         ThrowIfDisposed();
         ModelPersistenceGuard.EnforceBeforeDeserialize();
         using var stream = new MemoryStream(data);
@@ -684,7 +729,29 @@ public virtual Dictionary<string, T> GetFeatureImportance()
     #region ICloneable<IFullModel<T, Tensor<T>, Tensor<T>>> Implementation
 
     /// <inheritdoc />
-    public abstract IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy();
+    /// <remarks>
+    /// <para>
+    /// No longer abstract. Declaring it abstract here is what produced 267 hand-written DeepCopy and
+    /// Clone pairs across this family -- one per model, each re-listing the constructor arguments
+    /// its type happens to take. The clone plan records that constructor at compile time, so the
+    /// rebuild is the same code for every model and a new argument cannot be forgotten in 266 places.
+    /// </para>
+    /// <para>
+    /// Configuration is rebuilt, learned state is carried through the model's own Serialize and
+    /// Deserialize -- the public, overridable pair, so a model that persists something extra keeps
+    /// it. The guard is told this is an internal operation because a clone is not a save.
+    /// </para>
+    /// </remarks>
+    public virtual IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy()
+    {
+        using (ModelPersistenceGuard.InternalOperation())
+        {
+            byte[] state = Serialize();
+            var copy = (VAEModelBase<T>)AiDotNet.Models.CloneEngine.CopyConfiguration(this);
+            copy.Deserialize(state);
+            return copy;
+        }
+    }
 
     /// <inheritdoc />
     IFullModel<T, Tensor<T>, Tensor<T>> ICloneable<IFullModel<T, Tensor<T>, Tensor<T>>>.Clone()
@@ -696,7 +763,7 @@ IFullModel<T, Tensor<T>, Tensor<T>> ICloneable<IFullModel<T, Tensor<T>, Tensor<T
     /// Creates a deep copy of the VAE model.
     /// </summary>
     /// <returns>A new instance with the same parameters.</returns>
-    public abstract IVAEModel<T> Clone();
+    public virtual IVAEModel<T> Clone() => (IVAEModel<T>)DeepCopy();
 
     #endregion
 
diff --git a/src/Diffusion/VAE/VAEResBlock.cs b/src/Diffusion/VAE/VAEResBlock.cs
index a4725c095b..70b79ed1b1 100644
--- a/src/Diffusion/VAE/VAEResBlock.cs
+++ b/src/Diffusion/VAE/VAEResBlock.cs
@@ -147,17 +147,25 @@ public partial class VAEResBlock<T> : LayerBase<T>, IShapeContract
     /// <summary>
     /// Cached input from forward pass for backward.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastInput;
 
     /// <summary>
     /// Cached intermediate values for backward pass.
     /// </summary>
+    [AiDotNet.Attributes.Scratch]
     private Tensor<T>? _norm1Output;
+    [AiDotNet.Attributes.Scratch]
     private Tensor<T>? _silu1Output;
+    [AiDotNet.Attributes.Scratch]
     private Tensor<T>? _conv1Output;
+    [AiDotNet.Attributes.Scratch]
     private Tensor<T>? _norm2Output;
+    [AiDotNet.Attributes.Scratch]
     private Tensor<T>? _silu2Output;
+    [AiDotNet.Attributes.Scratch]
     private Tensor<T>? _conv2Output;
+    [AiDotNet.Attributes.Scratch]
     private Tensor<T>? _skipOutput;
 
     /// <inheritdoc />
@@ -178,6 +186,9 @@ public partial class VAEResBlock<T> : LayerBase<T>, IShapeContract
     /// </summary>
     public int NumGroups => _numGroups;
 
+    /// <summary>Construction state: the 'spatialSize' the layer was built with.</summary>
+    private readonly int _spatialSize;
+
     /// <summary>
     /// Initializes a new instance of the VAEResBlock class.
     /// </summary>
@@ -200,6 +211,7 @@ public partial class VAEResBlock<T> : LayerBase<T>, IShapeContract
     public VAEResBlock(int inChannels, int outChannels, int numGroups = 32, int spatialSize = 32)
         : base(CalculateInputShape(inChannels, spatialSize), CalculateOutputShape(outChannels, spatialSize))
     {
+        _spatialSize = spatialSize;
         if (inChannels <= 0)
             throw new ArgumentOutOfRangeException(nameof(inChannels), "Input channels must be positive.");
         if (outChannels <= 0)
@@ -369,52 +381,4 @@ public override void ResetState()
         _conv2.ResetState();
         _skipConv?.ResetState();
     }
-
-    /// <summary>
-    /// Saves the block's state to a binary writer.
-    /// </summary>
-    public override void Serialize(BinaryWriter writer)
-    {
-        base.Serialize(writer);
-        writer.Write(_inChannels);
-        writer.Write(_outChannels);
-        writer.Write(_numGroups);
-
-        _norm1.Serialize(writer);
-        _conv1.Serialize(writer);
-        _norm2.Serialize(writer);
-        _conv2.Serialize(writer);
-
-        writer.Write(_skipConv != null);
-        _skipConv?.Serialize(writer);
-    }
-
-    /// <summary>
-    /// Loads the block's state from a binary reader.
-    /// </summary>
-    public override void Deserialize(BinaryReader reader)
-    {
-        base.Deserialize(reader);
-        var inChannels = reader.ReadInt32();
-        var outChannels = reader.ReadInt32();
-        var numGroups = reader.ReadInt32();
-
-        if (inChannels != _inChannels || outChannels != _outChannels || numGroups != _numGroups)
-        {
-            throw new InvalidOperationException(
-                $"Architecture mismatch: expected ({_inChannels}, {_outChannels}, {_numGroups}) " +
-                $"but got ({inChannels}, {outChannels}, {numGroups}).");
-        }
-
-        _norm1.Deserialize(reader);
-        _conv1.Deserialize(reader);
-        _norm2.Deserialize(reader);
-        _conv2.Deserialize(reader);
-
-        var hasSkipConv = reader.ReadBoolean();
-        if (hasSkipConv && _skipConv != null)
-        {
-            _skipConv.Deserialize(reader);
-        }
-    }
 }
diff --git a/src/Diffusion/Video/AllegroModel.cs b/src/Diffusion/Video/AllegroModel.cs
index e601ca640e..c52346768d 100644
--- a/src/Diffusion/Video/AllegroModel.cs
+++ b/src/Diffusion/Video/AllegroModel.cs
@@ -145,21 +145,6 @@ protected override Tensor<T> PredictVideoNoise(
 
 
 
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    public override IDiffusionModel<T> Clone()
-    {
-                return new AllegroModel<T>(
-            architecture: Architecture,
-            options: Options as DiffusionModelOptions<T>,
-            scheduler: Scheduler,
-            predictor: (DiTNoisePredictor<T>)_predictor.Clone(),
-            temporalVAE: (TemporalVAE<T>)_temporalVAE.Clone(),
-            conditioner: _conditioner,
-            defaultNumFrames: DefaultNumFrames,
-            defaultFPS: DefaultFPS);
-    }
-
     public override ModelMetadata<T> GetModelMetadata()
     {
         var metadata = new ModelMetadata<T>
diff --git a/src/Diffusion/Video/AnimateDiffModel.cs b/src/Diffusion/Video/AnimateDiffModel.cs
index 0e8ee88826..730462e959 100644
--- a/src/Diffusion/Video/AnimateDiffModel.cs
+++ b/src/Diffusion/Video/AnimateDiffModel.cs
@@ -833,36 +833,6 @@ protected override Tensor<T> DecodeVideoLatents(Tensor<T> latents)
 
     #region ICloneable Implementation
 
-    /// <summary>
-    /// Clones this AnimateDiff model.
-    /// </summary>
-    public override IDiffusionModel<T> Clone()
-    {
-        var clone = new AnimateDiffModel<T>(
-            options: null,
-            scheduler: null,
-            unet: (UNetNoisePredictor<T>)_unet.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner,
-            motionConfig: _motionConfig.Clone(),
-            defaultNumFrames: DefaultNumFrames,
-            defaultFPS: DefaultFPS);
-
-        clone.ContextLength = ContextLength;
-        clone.ContextOverlap = ContextOverlap;
-        clone.SetMotionBucketId(MotionBucketId);
-
-        return clone;
-    }
-
-    /// <summary>
-    /// Creates a deep copy.
-    /// </summary>
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy()
-    {
-        return (IFullModel<T, Tensor<T>, Tensor<T>>)Clone();
-    }
-
     #endregion
 }
 
diff --git a/src/Diffusion/Video/AudioVisual/EmuVideo2Model.cs b/src/Diffusion/Video/AudioVisual/EmuVideo2Model.cs
index c077296262..ae1251f8e8 100644
--- a/src/Diffusion/Video/AudioVisual/EmuVideo2Model.cs
+++ b/src/Diffusion/Video/AudioVisual/EmuVideo2Model.cs
@@ -150,18 +150,6 @@ protected override Tensor<T> PredictVideoNoise(
 
 
 
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    public override IDiffusionModel<T> Clone()
-    {
-                return new EmuVideo2Model<T>(
-            predictor: (DiTNoisePredictor<T>)_predictor.Clone(),
-            temporalVAE: (TemporalVAE<T>)_temporalVAE.Clone(),
-            conditioner: _conditioner,
-            defaultNumFrames: DefaultNumFrames,
-            defaultFPS: DefaultFPS);
-    }
-
     public override ModelMetadata<T> GetModelMetadata()
     {
         var metadata = new ModelMetadata<T>
diff --git a/src/Diffusion/Video/AudioVisual/EmuVideoModel.cs b/src/Diffusion/Video/AudioVisual/EmuVideoModel.cs
index 52f6c85b6c..68f6078525 100644
--- a/src/Diffusion/Video/AudioVisual/EmuVideoModel.cs
+++ b/src/Diffusion/Video/AudioVisual/EmuVideoModel.cs
@@ -150,18 +150,6 @@ protected override Tensor<T> PredictVideoNoise(
 
 
 
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    public override IDiffusionModel<T> Clone()
-    {
-                return new EmuVideoModel<T>(
-            predictor: (DiTNoisePredictor<T>)_predictor.Clone(),
-            temporalVAE: (TemporalVAE<T>)_temporalVAE.Clone(),
-            conditioner: _conditioner,
-            defaultNumFrames: DefaultNumFrames,
-            defaultFPS: DefaultFPS);
-    }
-
     public override ModelMetadata<T> GetModelMetadata()
     {
         var metadata = new ModelMetadata<T>
diff --git a/src/Diffusion/Video/CogVideoModel.cs b/src/Diffusion/Video/CogVideoModel.cs
index 9bd8667585..53780f991d 100644
--- a/src/Diffusion/Video/CogVideoModel.cs
+++ b/src/Diffusion/Video/CogVideoModel.cs
@@ -247,31 +247,6 @@ protected override Tensor<T> PredictVideoNoise(
 
     #region ICloneable Implementation
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy()
-    {
-        return Clone();
-    }
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        // #1624: compose the clone from each sub-model's own Clone(). The model cannot share weights at
-        // its own level: a fresh CogVideoModel's VideoUNetPredictor has UNRESOLVED lazy layers, so a
-        // model-level parameter transfer (COW share or flat SetParameters) cannot reshape the clone to the
-        // source's resolved 573M-parameter structure and silently produces a wrong-sized network. Each
-        // sub-model's Clone() resolves its own lazy shapes first and applies the memory-efficient transfer
-        // internally (VideoUNetPredictor: paired per-layer copy that avoids the fused-CPU stale-pack
-        // divergence; TemporalVAE: copy-on-write), so the composed clone is both correct and OOM-safe.
-        return new CogVideoModel<T>(
-            videoUnet: (VideoUNetPredictor<T>)_videoUnet.Clone(),
-            temporalVae: (TemporalVAE<T>)_temporalVae.Clone(),
-            conditioner: _conditioner,
-            variant: _variant,
-            defaultNumFrames: DefaultNumFrames,
-            defaultFPS: DefaultFPS);
-    }
-
     #endregion
 
     #region Metadata
diff --git a/src/Diffusion/Video/CogVideoX15Model.cs b/src/Diffusion/Video/CogVideoX15Model.cs
index 36d2493df1..49749d8bbb 100644
--- a/src/Diffusion/Video/CogVideoX15Model.cs
+++ b/src/Diffusion/Video/CogVideoX15Model.cs
@@ -147,18 +147,6 @@ protected override Tensor<T> PredictVideoNoise(
 
 
 
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    public override IDiffusionModel<T> Clone()
-    {
-                return new CogVideoX15Model<T>(
-            predictor: (DiTNoisePredictor<T>)_predictor.Clone(),
-            temporalVAE: (TemporalVAE<T>)_temporalVAE.Clone(),
-            conditioner: _conditioner,
-            defaultNumFrames: DefaultNumFrames,
-            defaultFPS: DefaultFPS);
-    }
-
     public override ModelMetadata<T> GetModelMetadata()
     {
         var metadata = new ModelMetadata<T>
diff --git a/src/Diffusion/Video/HunyuanVideo15Model.cs b/src/Diffusion/Video/HunyuanVideo15Model.cs
index b6a43cae5b..0ec52b4954 100644
--- a/src/Diffusion/Video/HunyuanVideo15Model.cs
+++ b/src/Diffusion/Video/HunyuanVideo15Model.cs
@@ -145,21 +145,6 @@ protected override Tensor<T> PredictVideoNoise(
 
 
 
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    public override IDiffusionModel<T> Clone()
-    {
-                return new HunyuanVideo15Model<T>(
-            architecture: Architecture,
-            options: Options as DiffusionModelOptions<T>,
-            scheduler: Scheduler,
-            predictor: (DiTNoisePredictor<T>)_predictor.Clone(),
-            temporalVAE: (TemporalVAE<T>)_temporalVAE.Clone(),
-            conditioner: _conditioner,
-            defaultNumFrames: DefaultNumFrames,
-            defaultFPS: DefaultFPS);
-    }
-
     public override ModelMetadata<T> GetModelMetadata()
     {
         var metadata = new ModelMetadata<T>
diff --git a/src/Diffusion/Video/HunyuanVideoModel.cs b/src/Diffusion/Video/HunyuanVideoModel.cs
index 1685f4a8ab..e79657d40e 100644
--- a/src/Diffusion/Video/HunyuanVideoModel.cs
+++ b/src/Diffusion/Video/HunyuanVideoModel.cs
@@ -337,23 +337,6 @@ protected override Tensor<T> PredictVideoNoise(
 
     #region ICloneable Implementation
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy()
-    {
-        return Clone();
-    }
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-                return new HunyuanVideoModel<T>(
-            dit: (DiTNoisePredictor<T>)_dit.Clone(),
-            temporalVAE: (TemporalVAE<T>)_temporalVAE.Clone(),
-            conditioner: _conditioner,
-            defaultNumFrames: DefaultNumFrames,
-            defaultFPS: DefaultFPS);
-    }
-
     #endregion
 
     #region Metadata
diff --git a/src/Diffusion/Video/Kling26Model.cs b/src/Diffusion/Video/Kling26Model.cs
index 58436f3c3d..055cd1582a 100644
--- a/src/Diffusion/Video/Kling26Model.cs
+++ b/src/Diffusion/Video/Kling26Model.cs
@@ -145,21 +145,6 @@ protected override Tensor<T> PredictVideoNoise(
 
 
 
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    public override IDiffusionModel<T> Clone()
-    {
-                return new Kling26Model<T>(
-            architecture: Architecture,
-            options: Options as DiffusionModelOptions<T>,
-            scheduler: Scheduler,
-            predictor: (DiTNoisePredictor<T>)_predictor.Clone(),
-            temporalVAE: (TemporalVAE<T>)_temporalVAE.Clone(),
-            conditioner: _conditioner,
-            defaultNumFrames: DefaultNumFrames,
-            defaultFPS: DefaultFPS);
-    }
-
     public override ModelMetadata<T> GetModelMetadata()
     {
         var metadata = new ModelMetadata<T>
diff --git a/src/Diffusion/Video/KlingModel.cs b/src/Diffusion/Video/KlingModel.cs
index cc1c8f9432..36a40adf5b 100644
--- a/src/Diffusion/Video/KlingModel.cs
+++ b/src/Diffusion/Video/KlingModel.cs
@@ -276,20 +276,6 @@ protected override Tensor<T> PredictVideoNoise(
 
     #region ICloneable
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-                return new KlingModel<T>(
-            dit: (DiTNoisePredictor<T>)_dit.Clone(),
-            temporalVAE: (TemporalVAE<T>)_temporalVAE.Clone(),
-            conditioner: _conditioner,
-            defaultNumFrames: DefaultNumFrames,
-            defaultFPS: DefaultFPS);
-    }
-
     #endregion
 
     #region Metadata
diff --git a/src/Diffusion/Video/LTXVideoModel.cs b/src/Diffusion/Video/LTXVideoModel.cs
index 08d10b8a7e..4542f3581f 100644
--- a/src/Diffusion/Video/LTXVideoModel.cs
+++ b/src/Diffusion/Video/LTXVideoModel.cs
@@ -337,23 +337,6 @@ protected override Tensor<T> PredictVideoNoise(
 
     #region ICloneable Implementation
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy()
-    {
-        return Clone();
-    }
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-                return new LTXVideoModel<T>(
-            dit: (DiTNoisePredictor<T>)_dit.Clone(),
-            temporalVAE: (TemporalVAE<T>)_temporalVAE.Clone(),
-            conditioner: _conditioner,
-            defaultNumFrames: DefaultNumFrames,
-            defaultFPS: DefaultFPS);
-    }
-
     #endregion
 
     #region Metadata
diff --git a/src/Diffusion/Video/LatteModel.cs b/src/Diffusion/Video/LatteModel.cs
index 43d6f44121..055da0df66 100644
--- a/src/Diffusion/Video/LatteModel.cs
+++ b/src/Diffusion/Video/LatteModel.cs
@@ -322,29 +322,6 @@ protected override Tensor<T> PredictVideoNoise(
 
     #region ICloneable Implementation
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy()
-    {
-        return Clone();
-    }
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-                return new LatteModel<T>(
-            dit: (DiTNoisePredictor<T>)_dit.Clone(),
-            vae: new StandardVAE<T>(
-                inputChannels: 3,
-                latentChannels: LATENT_CHANNELS,
-                baseChannels: 128,
-                channelMultipliers: new[] { 1, 2, 4, 4 },
-                numResBlocksPerLevel: 2,
-                latentScaleFactor: 0.18215),
-            conditioner: _conditioner,
-            defaultNumFrames: DefaultNumFrames,
-            defaultFPS: DefaultFPS);
-    }
-
     #endregion
 
     #region Metadata
diff --git a/src/Diffusion/Video/LongVideo/FreeNoiseVideoModel.cs b/src/Diffusion/Video/LongVideo/FreeNoiseVideoModel.cs
index b531bda405..85117c0a8a 100644
--- a/src/Diffusion/Video/LongVideo/FreeNoiseVideoModel.cs
+++ b/src/Diffusion/Video/LongVideo/FreeNoiseVideoModel.cs
@@ -144,21 +144,6 @@ protected override Tensor<T> PredictVideoNoise(
 
 
 
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    public override IDiffusionModel<T> Clone()
-    {
-                return new FreeNoiseVideoModel<T>(
-            architecture: Architecture,
-            options: Options as DiffusionModelOptions<T>,
-            scheduler: Scheduler,
-            predictor: (VideoUNetPredictor<T>)_predictor.Clone(),
-            temporalVAE: (TemporalVAE<T>)_temporalVAE.Clone(),
-            conditioner: _conditioner,
-            defaultNumFrames: DefaultNumFrames,
-            defaultFPS: DefaultFPS);
-    }
-
     public override ModelMetadata<T> GetModelMetadata()
     {
         var metadata = new ModelMetadata<T>
diff --git a/src/Diffusion/Video/LongVideo/LoongModel.cs b/src/Diffusion/Video/LongVideo/LoongModel.cs
index 2ddaa7b67f..c61fac1ac0 100644
--- a/src/Diffusion/Video/LongVideo/LoongModel.cs
+++ b/src/Diffusion/Video/LongVideo/LoongModel.cs
@@ -147,18 +147,6 @@ protected override Tensor<T> PredictVideoNoise(
 
 
 
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    public override IDiffusionModel<T> Clone()
-    {
-                return new LoongModel<T>(
-            predictor: (DiTNoisePredictor<T>)_predictor.Clone(),
-            temporalVAE: (TemporalVAE<T>)_temporalVAE.Clone(),
-            conditioner: _conditioner,
-            defaultNumFrames: DefaultNumFrames,
-            defaultFPS: DefaultFPS);
-    }
-
     public override ModelMetadata<T> GetModelMetadata()
     {
         var metadata = new ModelMetadata<T>
diff --git a/src/Diffusion/Video/LongVideo/Show1Model.cs b/src/Diffusion/Video/LongVideo/Show1Model.cs
index f6cdf4cfb3..e8027827b8 100644
--- a/src/Diffusion/Video/LongVideo/Show1Model.cs
+++ b/src/Diffusion/Video/LongVideo/Show1Model.cs
@@ -146,18 +146,6 @@ protected override Tensor<T> PredictVideoNoise(
 
 
 
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    public override IDiffusionModel<T> Clone()
-    {
-                return new Show1Model<T>(
-            predictor: (VideoUNetPredictor<T>)_predictor.Clone(),
-            temporalVAE: (TemporalVAE<T>)_temporalVAE.Clone(),
-            conditioner: _conditioner,
-            defaultNumFrames: DefaultNumFrames,
-            defaultFPS: DefaultFPS);
-    }
-
     public override ModelMetadata<T> GetModelMetadata()
     {
         var metadata = new ModelMetadata<T>
diff --git a/src/Diffusion/Video/LongVideo/SnapVideoModel.cs b/src/Diffusion/Video/LongVideo/SnapVideoModel.cs
index e34db401d6..778c7f7f91 100644
--- a/src/Diffusion/Video/LongVideo/SnapVideoModel.cs
+++ b/src/Diffusion/Video/LongVideo/SnapVideoModel.cs
@@ -146,18 +146,6 @@ protected override Tensor<T> PredictVideoNoise(
 
 
 
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    public override IDiffusionModel<T> Clone()
-    {
-                return new SnapVideoModel<T>(
-            predictor: (DiTNoisePredictor<T>)_predictor.Clone(),
-            temporalVAE: (TemporalVAE<T>)_temporalVAE.Clone(),
-            conditioner: _conditioner,
-            defaultNumFrames: DefaultNumFrames,
-            defaultFPS: DefaultFPS);
-    }
-
     public override ModelMetadata<T> GetModelMetadata()
     {
         var metadata = new ModelMetadata<T>
diff --git a/src/Diffusion/Video/LongVideo/StreamingT2VModel.cs b/src/Diffusion/Video/LongVideo/StreamingT2VModel.cs
index f3b1f24f70..99b24a2fbc 100644
--- a/src/Diffusion/Video/LongVideo/StreamingT2VModel.cs
+++ b/src/Diffusion/Video/LongVideo/StreamingT2VModel.cs
@@ -146,18 +146,6 @@ protected override Tensor<T> PredictVideoNoise(
 
 
 
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    public override IDiffusionModel<T> Clone()
-    {
-                return new StreamingT2VModel<T>(
-            predictor: (VideoUNetPredictor<T>)_predictor.Clone(),
-            temporalVAE: (TemporalVAE<T>)_temporalVAE.Clone(),
-            conditioner: _conditioner,
-            defaultNumFrames: DefaultNumFrames,
-            defaultFPS: DefaultFPS);
-    }
-
     public override ModelMetadata<T> GetModelMetadata()
     {
         var metadata = new ModelMetadata<T>
diff --git a/src/Diffusion/Video/LumaRay2Model.cs b/src/Diffusion/Video/LumaRay2Model.cs
index e4edec9bfc..c90e8d49a0 100644
--- a/src/Diffusion/Video/LumaRay2Model.cs
+++ b/src/Diffusion/Video/LumaRay2Model.cs
@@ -144,21 +144,6 @@ protected override Tensor<T> PredictVideoNoise(
 
 
 
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    public override IDiffusionModel<T> Clone()
-    {
-                return new LumaRay2Model<T>(
-            architecture: Architecture,
-            options: Options as DiffusionModelOptions<T>,
-            scheduler: Scheduler,
-            predictor: (DiTNoisePredictor<T>)_predictor.Clone(),
-            temporalVAE: (TemporalVAE<T>)_temporalVAE.Clone(),
-            conditioner: _conditioner,
-            defaultNumFrames: DefaultNumFrames,
-            defaultFPS: DefaultFPS);
-    }
-
     public override ModelMetadata<T> GetModelMetadata()
     {
         var metadata = new ModelMetadata<T>
diff --git a/src/Diffusion/Video/LumaRay3Model.cs b/src/Diffusion/Video/LumaRay3Model.cs
index 854c022d05..79ce3b1f09 100644
--- a/src/Diffusion/Video/LumaRay3Model.cs
+++ b/src/Diffusion/Video/LumaRay3Model.cs
@@ -145,21 +145,6 @@ protected override Tensor<T> PredictVideoNoise(
 
 
 
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    public override IDiffusionModel<T> Clone()
-    {
-                return new LumaRay3Model<T>(
-            architecture: Architecture,
-            options: Options as DiffusionModelOptions<T>,
-            scheduler: Scheduler,
-            predictor: (DiTNoisePredictor<T>)_predictor.Clone(),
-            temporalVAE: (TemporalVAE<T>)_temporalVAE.Clone(),
-            conditioner: _conditioner,
-            defaultNumFrames: DefaultNumFrames,
-            defaultFPS: DefaultFPS);
-    }
-
     public override ModelMetadata<T> GetModelMetadata()
     {
         var metadata = new ModelMetadata<T>
diff --git a/src/Diffusion/Video/LumiereModel.cs b/src/Diffusion/Video/LumiereModel.cs
index f527ebe77c..7390b635fb 100644
--- a/src/Diffusion/Video/LumiereModel.cs
+++ b/src/Diffusion/Video/LumiereModel.cs
@@ -143,21 +143,6 @@ protected override Tensor<T> PredictVideoNoise(
 
 
 
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    public override IDiffusionModel<T> Clone()
-    {
-                return new LumiereModel<T>(
-            architecture: Architecture,
-            options: Options as DiffusionModelOptions<T>,
-            scheduler: Scheduler,
-            predictor: (VideoUNetPredictor<T>)_predictor.Clone(),
-            temporalVAE: (TemporalVAE<T>)_temporalVAE.Clone(),
-            conditioner: _conditioner,
-            defaultNumFrames: DefaultNumFrames,
-            defaultFPS: DefaultFPS);
-    }
-
     public override ModelMetadata<T> GetModelMetadata()
     {
         var metadata = new ModelMetadata<T>
diff --git a/src/Diffusion/Video/LuminaT2XModel.cs b/src/Diffusion/Video/LuminaT2XModel.cs
index f62c30b533..5208d2ff9d 100644
--- a/src/Diffusion/Video/LuminaT2XModel.cs
+++ b/src/Diffusion/Video/LuminaT2XModel.cs
@@ -187,16 +187,6 @@ public override Tensor<T> GenerateFromText(
 
     #region ICloneable
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        EnsureInitialized();
-                        return new LuminaT2XModel<T>(dit: (DiTNoisePredictor<T>)_dit.Clone(), vae: (StandardVAE<T>)_vae.Clone(), conditioner: _conditioner);
-    }
-
     #endregion
 
     #region Metadata
diff --git a/src/Diffusion/Video/MAGI1Model.cs b/src/Diffusion/Video/MAGI1Model.cs
index e81046accd..e37b49f481 100644
--- a/src/Diffusion/Video/MAGI1Model.cs
+++ b/src/Diffusion/Video/MAGI1Model.cs
@@ -145,21 +145,6 @@ protected override Tensor<T> PredictVideoNoise(
 
 
 
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    public override IDiffusionModel<T> Clone()
-    {
-                return new MAGI1Model<T>(
-            architecture: Architecture,
-            options: Options as DiffusionModelOptions<T>,
-            scheduler: Scheduler,
-            predictor: (DiTNoisePredictor<T>)_predictor.Clone(),
-            temporalVAE: (TemporalVAE<T>)_temporalVAE.Clone(),
-            conditioner: _conditioner,
-            defaultNumFrames: DefaultNumFrames,
-            defaultFPS: DefaultFPS);
-    }
-
     public override ModelMetadata<T> GetModelMetadata()
     {
         var metadata = new ModelMetadata<T>
diff --git a/src/Diffusion/Video/MakeAVideoModel.cs b/src/Diffusion/Video/MakeAVideoModel.cs
index fe83a8a0b9..e18ea73d26 100644
--- a/src/Diffusion/Video/MakeAVideoModel.cs
+++ b/src/Diffusion/Video/MakeAVideoModel.cs
@@ -267,23 +267,6 @@ protected override Tensor<T> PredictVideoNoise(
 
     #region ICloneable
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        // Lazy-preserving Clone (recipe from #1596): delegate to the video UNet's AND VAE's own Clone()
-        // — the previous code rebuilt a FRESH StandardVAE here, re-randomizing the clone's VAE weights
-        // and diverging from the source on the first decode.
-        return new MakeAVideoModel<T>(
-            videoUNet: (VideoUNetPredictor<T>)_videoUNet.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner,
-            defaultNumFrames: DefaultNumFrames,
-            defaultFPS: DefaultFPS);
-    }
-
     #endregion
 
     #region Metadata
diff --git a/src/Diffusion/Video/MinimaxVideoModel.cs b/src/Diffusion/Video/MinimaxVideoModel.cs
index 839c7ab505..6e7cec7c19 100644
--- a/src/Diffusion/Video/MinimaxVideoModel.cs
+++ b/src/Diffusion/Video/MinimaxVideoModel.cs
@@ -146,18 +146,6 @@ protected override Tensor<T> PredictVideoNoise(
 
 
 
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    public override IDiffusionModel<T> Clone()
-    {
-                return new MinimaxVideoModel<T>(
-            predictor: (DiTNoisePredictor<T>)_predictor.Clone(),
-            temporalVAE: (TemporalVAE<T>)_temporalVAE.Clone(),
-            conditioner: _conditioner,
-            defaultNumFrames: DefaultNumFrames,
-            defaultFPS: DefaultFPS);
-    }
-
     public override ModelMetadata<T> GetModelMetadata()
     {
         var metadata = new ModelMetadata<T>
diff --git a/src/Diffusion/Video/Mochi1Model.cs b/src/Diffusion/Video/Mochi1Model.cs
index 66d7b7a665..d67163644d 100644
--- a/src/Diffusion/Video/Mochi1Model.cs
+++ b/src/Diffusion/Video/Mochi1Model.cs
@@ -349,24 +349,6 @@ protected override Tensor<T> PredictVideoNoise(
 
     #region ICloneable Implementation
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy()
-    {
-        return Clone();
-    }
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        EnsureInitialized();
-                return new Mochi1Model<T>(
-            dit: (DiTNoisePredictor<T>)_dit.Clone(),
-            temporalVAE: (TemporalVAE<T>)_temporalVAE.Clone(),
-            conditioner: _conditioner,
-            defaultNumFrames: DefaultNumFrames,
-            defaultFPS: DefaultFPS);
-    }
-
     #endregion
 
     #region Metadata
diff --git a/src/Diffusion/Video/Mochi1PreviewModel.cs b/src/Diffusion/Video/Mochi1PreviewModel.cs
index cb8b676524..fe735b1d88 100644
--- a/src/Diffusion/Video/Mochi1PreviewModel.cs
+++ b/src/Diffusion/Video/Mochi1PreviewModel.cs
@@ -145,21 +145,6 @@ protected override Tensor<T> PredictVideoNoise(
 
 
 
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    public override IDiffusionModel<T> Clone()
-    {
-                return new Mochi1PreviewModel<T>(
-            architecture: Architecture,
-            options: Options as DiffusionModelOptions<T>,
-            scheduler: Scheduler,
-            predictor: (DiTNoisePredictor<T>)_predictor.Clone(),
-            temporalVAE: (TemporalVAE<T>)_temporalVAE.Clone(),
-            conditioner: _conditioner,
-            defaultNumFrames: DefaultNumFrames,
-            defaultFPS: DefaultFPS);
-    }
-
     public override ModelMetadata<T> GetModelMetadata()
     {
         var metadata = new ModelMetadata<T>
diff --git a/src/Diffusion/Video/ModelScopeT2VModel.cs b/src/Diffusion/Video/ModelScopeT2VModel.cs
index da6f70aba1..498ff6b94b 100644
--- a/src/Diffusion/Video/ModelScopeT2VModel.cs
+++ b/src/Diffusion/Video/ModelScopeT2VModel.cs
@@ -320,29 +320,6 @@ protected override Tensor<T> PredictVideoNoise(
 
     #region ICloneable Implementation
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy()
-    {
-        return Clone();
-    }
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        return new ModelScopeT2VModel<T>(
-            videoUNet: (VideoUNetPredictor<T>)_videoUNet.Clone(),
-            vae: new StandardVAE<T>(
-                inputChannels: 3,
-                latentChannels: LATENT_CHANNELS,
-                baseChannels: 128,
-                channelMultipliers: new[] { 1, 2, 4, 4 },
-                numResBlocksPerLevel: 2,
-                latentScaleFactor: 0.18215),
-            conditioner: _conditioner,
-            defaultNumFrames: DefaultNumFrames,
-            defaultFPS: DefaultFPS);
-    }
-
     #endregion
 
     #region Metadata
diff --git a/src/Diffusion/Video/MovieGenModel.cs b/src/Diffusion/Video/MovieGenModel.cs
index 79853f94bc..e7a9b3b56b 100644
--- a/src/Diffusion/Video/MovieGenModel.cs
+++ b/src/Diffusion/Video/MovieGenModel.cs
@@ -148,18 +148,6 @@ protected override Tensor<T> PredictVideoNoise(
 
 
 
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    public override IDiffusionModel<T> Clone()
-    {
-                return new MovieGenModel<T>(
-            predictor: (DiTNoisePredictor<T>)_predictor.Clone(),
-            temporalVAE: (TemporalVAE<T>)_temporalVAE.Clone(),
-            conditioner: _conditioner,
-            defaultNumFrames: DefaultNumFrames,
-            defaultFPS: DefaultFPS);
-    }
-
     public override ModelMetadata<T> GetModelMetadata()
     {
         var metadata = new ModelMetadata<T>
diff --git a/src/Diffusion/Video/OpenSora13Model.cs b/src/Diffusion/Video/OpenSora13Model.cs
index f6a4f217b3..5ea8f2da1b 100644
--- a/src/Diffusion/Video/OpenSora13Model.cs
+++ b/src/Diffusion/Video/OpenSora13Model.cs
@@ -146,18 +146,6 @@ protected override Tensor<T> PredictVideoNoise(
 
 
 
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    public override IDiffusionModel<T> Clone()
-    {
-                return new OpenSora13Model<T>(
-            predictor: (DiTNoisePredictor<T>)_predictor.Clone(),
-            temporalVAE: (TemporalVAE<T>)_temporalVAE.Clone(),
-            conditioner: _conditioner,
-            defaultNumFrames: DefaultNumFrames,
-            defaultFPS: DefaultFPS);
-    }
-
     public override ModelMetadata<T> GetModelMetadata()
     {
         var metadata = new ModelMetadata<T>
diff --git a/src/Diffusion/Video/OpenSora2Model.cs b/src/Diffusion/Video/OpenSora2Model.cs
index 0a13e355b0..48f3bfb7bd 100644
--- a/src/Diffusion/Video/OpenSora2Model.cs
+++ b/src/Diffusion/Video/OpenSora2Model.cs
@@ -162,21 +162,6 @@ protected override Tensor<T> PredictVideoNoise(
         return _predictor.PredictNoise(latents, timestep, imageEmbedding);
     }
 
-
-
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    public override IDiffusionModel<T> Clone()
-    {
-        EnsureInitialized();
-                return new OpenSora2Model<T>(
-            predictor: (DiTNoisePredictor<T>)_predictor.Clone(),
-            temporalVAE: (TemporalVAE<T>)_temporalVAE.Clone(),
-            conditioner: _conditioner,
-            defaultNumFrames: DefaultNumFrames,
-            defaultFPS: DefaultFPS);
-    }
-
     public override ModelMetadata<T> GetModelMetadata()
     {
         var metadata = new ModelMetadata<T>
diff --git a/src/Diffusion/Video/OpenSoraModel.cs b/src/Diffusion/Video/OpenSoraModel.cs
index 98bd9bc1e2..4e2de35996 100644
--- a/src/Diffusion/Video/OpenSoraModel.cs
+++ b/src/Diffusion/Video/OpenSoraModel.cs
@@ -335,23 +335,6 @@ protected override Tensor<T> PredictVideoNoise(
 
     #region ICloneable Implementation
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy()
-    {
-        return Clone();
-    }
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-                return new OpenSoraModel<T>(
-            dit: (DiTNoisePredictor<T>)_dit.Clone(),
-            temporalVAE: (TemporalVAE<T>)_temporalVAE.Clone(),
-            conditioner: _conditioner,
-            defaultNumFrames: DefaultNumFrames,
-            defaultFPS: DefaultFPS);
-    }
-
     #endregion
 
     #region Metadata
diff --git a/src/Diffusion/Video/Pika21Model.cs b/src/Diffusion/Video/Pika21Model.cs
index 3a8cceb923..6086479884 100644
--- a/src/Diffusion/Video/Pika21Model.cs
+++ b/src/Diffusion/Video/Pika21Model.cs
@@ -146,18 +146,6 @@ protected override Tensor<T> PredictVideoNoise(
 
 
 
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    public override IDiffusionModel<T> Clone()
-    {
-                return new Pika21Model<T>(
-            predictor: (DiTNoisePredictor<T>)_predictor.Clone(),
-            temporalVAE: (TemporalVAE<T>)_temporalVAE.Clone(),
-            conditioner: _conditioner,
-            defaultNumFrames: DefaultNumFrames,
-            defaultFPS: DefaultFPS);
-    }
-
     public override ModelMetadata<T> GetModelMetadata()
     {
         var metadata = new ModelMetadata<T>
diff --git a/src/Diffusion/Video/PyramidFlowModel.cs b/src/Diffusion/Video/PyramidFlowModel.cs
index b2f0b46aee..3f207af487 100644
--- a/src/Diffusion/Video/PyramidFlowModel.cs
+++ b/src/Diffusion/Video/PyramidFlowModel.cs
@@ -145,21 +145,6 @@ protected override Tensor<T> PredictVideoNoise(
 
 
 
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    public override IDiffusionModel<T> Clone()
-    {
-                return new PyramidFlowModel<T>(
-            architecture: Architecture,
-            options: Options as DiffusionModelOptions<T>,
-            scheduler: Scheduler,
-            predictor: (DiTNoisePredictor<T>)_predictor.Clone(),
-            temporalVAE: (TemporalVAE<T>)_temporalVAE.Clone(),
-            conditioner: _conditioner,
-            defaultNumFrames: DefaultNumFrames,
-            defaultFPS: DefaultFPS);
-    }
-
     public override ModelMetadata<T> GetModelMetadata()
     {
         var metadata = new ModelMetadata<T>
diff --git a/src/Diffusion/Video/RunwayGen4Model.cs b/src/Diffusion/Video/RunwayGen4Model.cs
index 9516b65be2..3a2dd94518 100644
--- a/src/Diffusion/Video/RunwayGen4Model.cs
+++ b/src/Diffusion/Video/RunwayGen4Model.cs
@@ -144,21 +144,6 @@ protected override Tensor<T> PredictVideoNoise(
 
 
 
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    public override IDiffusionModel<T> Clone()
-    {
-                return new RunwayGen4Model<T>(
-            architecture: Architecture,
-            options: Options as DiffusionModelOptions<T>,
-            scheduler: Scheduler,
-            predictor: (DiTNoisePredictor<T>)_predictor.Clone(),
-            temporalVAE: (TemporalVAE<T>)_temporalVAE.Clone(),
-            conditioner: _conditioner,
-            defaultNumFrames: DefaultNumFrames,
-            defaultFPS: DefaultFPS);
-    }
-
     public override ModelMetadata<T> GetModelMetadata()
     {
         var metadata = new ModelMetadata<T>
diff --git a/src/Diffusion/Video/RunwayGenModel.cs b/src/Diffusion/Video/RunwayGenModel.cs
index 0c72458959..b43d1c537a 100644
--- a/src/Diffusion/Video/RunwayGenModel.cs
+++ b/src/Diffusion/Video/RunwayGenModel.cs
@@ -366,24 +366,6 @@ protected override Tensor<T> PredictVideoNoise(
 
     #region ICloneable Implementation
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy()
-    {
-        return Clone();
-    }
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        return new RunwayGenModel<T>(
-            videoUNet: (VideoUNetPredictor<T>)_videoUNet.Clone(),
-            temporalVAE: (TemporalVAE<T>)_temporalVAE.Clone(),
-            conditioner: _conditioner,
-            isGen3: _isGen3,
-            defaultNumFrames: DefaultNumFrames,
-            defaultFPS: DefaultFPS);
-    }
-
     #endregion
 
     #region Metadata
diff --git a/src/Diffusion/Video/Seedance1Model.cs b/src/Diffusion/Video/Seedance1Model.cs
index a3abb43b7c..035839f57d 100644
--- a/src/Diffusion/Video/Seedance1Model.cs
+++ b/src/Diffusion/Video/Seedance1Model.cs
@@ -144,21 +144,6 @@ protected override Tensor<T> PredictVideoNoise(
 
 
 
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    public override IDiffusionModel<T> Clone()
-    {
-                return new Seedance1Model<T>(
-            architecture: Architecture,
-            options: Options as DiffusionModelOptions<T>,
-            scheduler: Scheduler,
-            predictor: (DiTNoisePredictor<T>)_predictor.Clone(),
-            temporalVAE: (TemporalVAE<T>)_temporalVAE.Clone(),
-            conditioner: _conditioner,
-            defaultNumFrames: DefaultNumFrames,
-            defaultFPS: DefaultFPS);
-    }
-
     public override ModelMetadata<T> GetModelMetadata()
     {
         var metadata = new ModelMetadata<T>
diff --git a/src/Diffusion/Video/SkyReelsV1Model.cs b/src/Diffusion/Video/SkyReelsV1Model.cs
index 3d4c71f907..67c1ed7559 100644
--- a/src/Diffusion/Video/SkyReelsV1Model.cs
+++ b/src/Diffusion/Video/SkyReelsV1Model.cs
@@ -147,18 +147,6 @@ protected override Tensor<T> PredictVideoNoise(
 
 
 
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    public override IDiffusionModel<T> Clone()
-    {
-                return new SkyReelsV1Model<T>(
-            predictor: (DiTNoisePredictor<T>)_predictor.Clone(),
-            temporalVAE: (TemporalVAE<T>)_temporalVAE.Clone(),
-            conditioner: _conditioner,
-            defaultNumFrames: DefaultNumFrames,
-            defaultFPS: DefaultFPS);
-    }
-
     public override ModelMetadata<T> GetModelMetadata()
     {
         var metadata = new ModelMetadata<T>
diff --git a/src/Diffusion/Video/Sora2Model.cs b/src/Diffusion/Video/Sora2Model.cs
index 00514af93d..79f1955936 100644
--- a/src/Diffusion/Video/Sora2Model.cs
+++ b/src/Diffusion/Video/Sora2Model.cs
@@ -151,22 +151,6 @@ protected override Tensor<T> PredictVideoNoise(
 
 
 
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    public override IDiffusionModel<T> Clone()
-    {
-                return new Sora2Model<T>(
-            architecture: Architecture,
-            options: Options as DiffusionModelOptions<T>,
-            scheduler: Scheduler,
-            predictor: (DiTNoisePredictor<T>)_predictor.Clone(),
-            temporalVAE: (TemporalVAE<T>)_temporalVAE.Clone(),
-            conditioner: _conditioner, // Conditioners are typically stateless; shared reference is safe
-            defaultNumFrames: DefaultNumFrames,
-            defaultFPS: DefaultFPS,
-            seed: _seed);
-    }
-
     public override ModelMetadata<T> GetModelMetadata()
     {
         var metadata = new ModelMetadata<T>
diff --git a/src/Diffusion/Video/SoraModel.cs b/src/Diffusion/Video/SoraModel.cs
index eecd6b417c..b5b8029849 100644
--- a/src/Diffusion/Video/SoraModel.cs
+++ b/src/Diffusion/Video/SoraModel.cs
@@ -338,23 +338,6 @@ protected override Tensor<T> PredictVideoNoise(
 
     #region ICloneable Implementation
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy()
-    {
-        return Clone();
-    }
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        return new SoraModel<T>(
-            dit: (DiTNoisePredictor<T>)_dit.Clone(),
-            temporalVAE: (TemporalVAE<T>)_temporalVAE.Clone(),
-            conditioner: _conditioner,
-            defaultNumFrames: DefaultNumFrames,
-            defaultFPS: DefaultFPS);
-    }
-
     #endregion
 
     #region Metadata
diff --git a/src/Diffusion/Video/StableVideoDiffusion.cs b/src/Diffusion/Video/StableVideoDiffusion.cs
index ed23e30261..11a45f2fae 100644
--- a/src/Diffusion/Video/StableVideoDiffusion.cs
+++ b/src/Diffusion/Video/StableVideoDiffusion.cs
@@ -760,35 +760,5 @@ public static (int width, int height) GetRecommendedResolution(double aspectRati
 
     #region ICloneable Implementation
 
-    /// <summary>
-    /// Creates a clone of this StableVideoDiffusion model.
-    /// </summary>
-    /// <returns>A new instance with the same configuration.</returns>
-    public override IDiffusionModel<T> Clone()
-    {
-        var clone = new StableVideoDiffusion<T>(
-            options: null,
-            scheduler: null,
-            videoUNet: (VideoUNetPredictor<T>)_videoUNet.Clone(),
-            temporalVAE: (TemporalVAE<T>)_temporalVAE.Clone(),
-            conditioner: _conditioner,
-            defaultNumFrames: DefaultNumFrames,
-            defaultFPS: DefaultFPS);
-
-        // Copy motion bucket state
-        clone.SetMotionBucketId(MotionBucketId);
-
-        return clone;
-    }
-
-    /// <summary>
-    /// Creates a deep copy of this model.
-    /// </summary>
-    /// <returns>A new instance with copied parameters.</returns>
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy()
-    {
-        return (IFullModel<T, Tensor<T>, Tensor<T>>)Clone();
-    }
-
     #endregion
 }
diff --git a/src/Diffusion/Video/StepVideoModel.cs b/src/Diffusion/Video/StepVideoModel.cs
index 03b85a4e08..6069e54779 100644
--- a/src/Diffusion/Video/StepVideoModel.cs
+++ b/src/Diffusion/Video/StepVideoModel.cs
@@ -144,21 +144,6 @@ protected override Tensor<T> PredictVideoNoise(
 
 
 
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    public override IDiffusionModel<T> Clone()
-    {
-                return new StepVideoModel<T>(
-            architecture: Architecture,
-            options: Options as DiffusionModelOptions<T>,
-            scheduler: Scheduler,
-            predictor: (DiTNoisePredictor<T>)_predictor.Clone(),
-            temporalVAE: (TemporalVAE<T>)_temporalVAE.Clone(),
-            conditioner: _conditioner,
-            defaultNumFrames: DefaultNumFrames,
-            defaultFPS: DefaultFPS);
-    }
-
     public override ModelMetadata<T> GetModelMetadata()
     {
         var metadata = new ModelMetadata<T>
diff --git a/src/Diffusion/Video/Veo3Model.cs b/src/Diffusion/Video/Veo3Model.cs
index 114fd0f754..add540b747 100644
--- a/src/Diffusion/Video/Veo3Model.cs
+++ b/src/Diffusion/Video/Veo3Model.cs
@@ -144,21 +144,6 @@ protected override Tensor<T> PredictVideoNoise(
 
 
 
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    public override IDiffusionModel<T> Clone()
-    {
-                return new Veo3Model<T>(
-            architecture: Architecture,
-            options: Options as DiffusionModelOptions<T>,
-            scheduler: Scheduler,
-            predictor: (DiTNoisePredictor<T>)_predictor.Clone(),
-            temporalVAE: (TemporalVAE<T>)_temporalVAE.Clone(),
-            conditioner: _conditioner,
-            defaultNumFrames: DefaultNumFrames,
-            defaultFPS: DefaultFPS);
-    }
-
     public override ModelMetadata<T> GetModelMetadata()
     {
         var metadata = new ModelMetadata<T>
diff --git a/src/Diffusion/Video/VeoModel.cs b/src/Diffusion/Video/VeoModel.cs
index 456e0731e4..e914ebaa27 100644
--- a/src/Diffusion/Video/VeoModel.cs
+++ b/src/Diffusion/Video/VeoModel.cs
@@ -369,24 +369,6 @@ protected override Tensor<T> PredictVideoNoise(
 
     #region ICloneable Implementation
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy()
-    {
-        return Clone();
-    }
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-                return new VeoModel<T>(
-            dit: (DiTNoisePredictor<T>)_dit.Clone(),
-            temporalVAE: (TemporalVAE<T>)_temporalVAE.Clone(),
-            conditioner: _conditioner,
-            isVeo2: _isVeo2,
-            defaultNumFrames: DefaultNumFrames,
-            defaultFPS: DefaultFPS);
-    }
-
     #endregion
 
     #region Metadata
diff --git a/src/Diffusion/Video/VideoCrafter2Model.cs b/src/Diffusion/Video/VideoCrafter2Model.cs
index 6b751fedc8..fba3bdeeea 100644
--- a/src/Diffusion/Video/VideoCrafter2Model.cs
+++ b/src/Diffusion/Video/VideoCrafter2Model.cs
@@ -144,25 +144,6 @@ protected override Tensor<T> PredictVideoNoise(
 
 
 
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    public override IDiffusionModel<T> Clone()
-    {
-        var clonedOptions = GetOptions() is DiffusionModelOptions<T> options
-            ? new DiffusionModelOptions<T>(options)
-            : null;
-
-        return new VideoCrafter2Model<T>(
-            architecture: Architecture,
-            options: clonedOptions,
-            scheduler: new DDIMScheduler<T>(Scheduler.Config),
-            predictor: (VideoUNetPredictor<T>)_predictor.Clone(),
-            temporalVAE: (TemporalVAE<T>)_temporalVAE.Clone(),
-            conditioner: _conditioner,
-            defaultNumFrames: DefaultNumFrames,
-            defaultFPS: DefaultFPS);
-    }
-
     public override ModelMetadata<T> GetModelMetadata()
     {
         var metadata = new ModelMetadata<T>
diff --git a/src/Diffusion/Video/VideoCrafterModel.cs b/src/Diffusion/Video/VideoCrafterModel.cs
index 1b3031b9d6..8065d0256d 100644
--- a/src/Diffusion/Video/VideoCrafterModel.cs
+++ b/src/Diffusion/Video/VideoCrafterModel.cs
@@ -674,35 +674,5 @@ protected override Tensor<T> DecodeVideoLatents(Tensor<T> latents)
 
     #region ICloneable Implementation
 
-    /// <summary>
-    /// Clones this model.
-    /// </summary>
-    public override IDiffusionModel<T> Clone()
-    {
-        var clone = new VideoCrafterModel<T>(
-            options: null,
-            scheduler: null,
-            videoUNet: (VideoUNetPredictor<T>)_videoUNet.Clone(),
-            temporalVAE: (TemporalVAE<T>)_temporalVAE.Clone(),
-            textConditioner: _textConditioner,
-            imageConditioner: _imageConditioner,
-            defaultNumFrames: DefaultNumFrames,
-            defaultFPS: DefaultFPS);
-
-        clone.ImageConditioningScale = ImageConditioningScale;
-        clone.UseDualConditioning = UseDualConditioning;
-        clone.SetMotionBucketId(MotionBucketId);
-
-        return clone;
-    }
-
-    /// <summary>
-    /// Creates a deep copy.
-    /// </summary>
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy()
-    {
-        return (IFullModel<T, Tensor<T>, Tensor<T>>)Clone();
-    }
-
     #endregion
 }
diff --git a/src/Diffusion/Video/VideoEditing/FateZeroModel.cs b/src/Diffusion/Video/VideoEditing/FateZeroModel.cs
index 0a66ea5190..59d752c8ab 100644
--- a/src/Diffusion/Video/VideoEditing/FateZeroModel.cs
+++ b/src/Diffusion/Video/VideoEditing/FateZeroModel.cs
@@ -146,21 +146,6 @@ protected override void RegisterComponents()
         RegisterParameterComponent(_temporalVAE);
     }
 
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    public override IDiffusionModel<T> Clone()
-    {
-                return new FateZeroModel<T>(
-            architecture: Architecture,
-            options: Options as DiffusionModelOptions<T>,
-            scheduler: Scheduler,
-            predictor: (VideoUNetPredictor<T>)_predictor.Clone(),
-            temporalVAE: (TemporalVAE<T>)_temporalVAE.Clone(),
-            conditioner: _conditioner,
-            defaultNumFrames: DefaultNumFrames,
-            defaultFPS: DefaultFPS);
-    }
-
     public override ModelMetadata<T> GetModelMetadata()
     {
         var metadata = new ModelMetadata<T>
diff --git a/src/Diffusion/Video/VideoEditing/FlowVidModel.cs b/src/Diffusion/Video/VideoEditing/FlowVidModel.cs
index e9f12a2f5a..2a864f2862 100644
--- a/src/Diffusion/Video/VideoEditing/FlowVidModel.cs
+++ b/src/Diffusion/Video/VideoEditing/FlowVidModel.cs
@@ -166,21 +166,6 @@ protected override Tensor<T> PredictVideoNoise(
         return _predictor.PredictNoise(latents, timestep, imageEmbedding);
     }
 
-
-
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    public override IDiffusionModel<T> Clone()
-    {
-        EnsureInitialized();
-                return new FlowVidModel<T>(
-            predictor: (VideoUNetPredictor<T>)_predictor.Clone(),
-            temporalVAE: (TemporalVAE<T>)_temporalVAE.Clone(),
-            conditioner: _conditioner,
-            defaultNumFrames: DefaultNumFrames,
-            defaultFPS: DefaultFPS);
-    }
-
     public override ModelMetadata<T> GetModelMetadata()
     {
         var metadata = new ModelMetadata<T>
diff --git a/src/Diffusion/Video/VideoEditing/InstructVid2VidModel.cs b/src/Diffusion/Video/VideoEditing/InstructVid2VidModel.cs
index 95addcc0ec..17de18729f 100644
--- a/src/Diffusion/Video/VideoEditing/InstructVid2VidModel.cs
+++ b/src/Diffusion/Video/VideoEditing/InstructVid2VidModel.cs
@@ -146,18 +146,6 @@ protected override Tensor<T> PredictVideoNoise(
 
 
 
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    public override IDiffusionModel<T> Clone()
-    {
-                return new InstructVid2VidModel<T>(
-            predictor: (VideoUNetPredictor<T>)_predictor.Clone(),
-            temporalVAE: (TemporalVAE<T>)_temporalVAE.Clone(),
-            conditioner: _conditioner,
-            defaultNumFrames: DefaultNumFrames,
-            defaultFPS: DefaultFPS);
-    }
-
     public override ModelMetadata<T> GetModelMetadata()
     {
         var metadata = new ModelMetadata<T>
diff --git a/src/Diffusion/Video/VideoEditing/TokenFlowModel.cs b/src/Diffusion/Video/VideoEditing/TokenFlowModel.cs
index dcbb9748fa..3c1e2356d3 100644
--- a/src/Diffusion/Video/VideoEditing/TokenFlowModel.cs
+++ b/src/Diffusion/Video/VideoEditing/TokenFlowModel.cs
@@ -146,21 +146,6 @@ protected override Tensor<T> PredictVideoNoise(
 
 
 
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    public override IDiffusionModel<T> Clone()
-    {
-                return new TokenFlowModel<T>(
-            architecture: Architecture,
-            options: Options as DiffusionModelOptions<T>,
-            scheduler: Scheduler,
-            predictor: (VideoUNetPredictor<T>)_predictor.Clone(),
-            temporalVAE: (TemporalVAE<T>)_temporalVAE.Clone(),
-            conditioner: _conditioner,
-            defaultNumFrames: DefaultNumFrames,
-            defaultFPS: DefaultFPS);
-    }
-
     public override ModelMetadata<T> GetModelMetadata()
     {
         var metadata = new ModelMetadata<T>
diff --git a/src/Diffusion/Video/VideoEditing/VideoP2PModel.cs b/src/Diffusion/Video/VideoEditing/VideoP2PModel.cs
index 483258171e..427e8d7580 100644
--- a/src/Diffusion/Video/VideoEditing/VideoP2PModel.cs
+++ b/src/Diffusion/Video/VideoEditing/VideoP2PModel.cs
@@ -145,18 +145,6 @@ protected override Tensor<T> PredictVideoNoise(
 
 
 
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    public override IDiffusionModel<T> Clone()
-    {
-                return new VideoP2PModel<T>(
-            predictor: (VideoUNetPredictor<T>)_predictor.Clone(),
-            temporalVAE: (TemporalVAE<T>)_temporalVAE.Clone(),
-            conditioner: _conditioner,
-            defaultNumFrames: DefaultNumFrames,
-            defaultFPS: DefaultFPS);
-    }
-
     public override ModelMetadata<T> GetModelMetadata()
     {
         var metadata = new ModelMetadata<T>
diff --git a/src/Diffusion/Video/VideoPoetModel.cs b/src/Diffusion/Video/VideoPoetModel.cs
index 32e67973e5..64a8c43266 100644
--- a/src/Diffusion/Video/VideoPoetModel.cs
+++ b/src/Diffusion/Video/VideoPoetModel.cs
@@ -145,21 +145,6 @@ protected override Tensor<T> PredictVideoNoise(
 
 
 
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    public override IDiffusionModel<T> Clone()
-    {
-                return new VideoPoetModel<T>(
-            architecture: Architecture,
-            options: Options as DiffusionModelOptions<T>,
-            scheduler: Scheduler,
-            predictor: (DiTNoisePredictor<T>)_predictor.Clone(),
-            temporalVAE: (TemporalVAE<T>)_temporalVAE.Clone(),
-            conditioner: _conditioner,
-            defaultNumFrames: DefaultNumFrames,
-            defaultFPS: DefaultFPS);
-    }
-
     public override ModelMetadata<T> GetModelMetadata()
     {
         var metadata = new ModelMetadata<T>
diff --git a/src/Diffusion/Video/Wan21Model.cs b/src/Diffusion/Video/Wan21Model.cs
index 53e92736ae..668cf8f10b 100644
--- a/src/Diffusion/Video/Wan21Model.cs
+++ b/src/Diffusion/Video/Wan21Model.cs
@@ -152,18 +152,6 @@ protected override Tensor<T> PredictVideoNoise(
 
 
 
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    public override IDiffusionModel<T> Clone()
-    {
-                return new Wan21Model<T>(
-            predictor: (DiTNoisePredictor<T>)_predictor.Clone(),
-            temporalVAE: (TemporalVAE<T>)_temporalVAE.Clone(),
-            conditioner: _conditioner,
-            defaultNumFrames: DefaultNumFrames,
-            defaultFPS: DefaultFPS);
-    }
-
     public override ModelMetadata<T> GetModelMetadata()
     {
         var metadata = new ModelMetadata<T>
diff --git a/src/Diffusion/Video/Wan22Model.cs b/src/Diffusion/Video/Wan22Model.cs
index 41c23180ae..73ab389fe7 100644
--- a/src/Diffusion/Video/Wan22Model.cs
+++ b/src/Diffusion/Video/Wan22Model.cs
@@ -162,24 +162,6 @@ protected override Tensor<T> PredictVideoNoise(
         return _predictor.PredictNoise(latents, timestep, imageEmbedding);
     }
 
-
-
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    public override IDiffusionModel<T> Clone()
-    {
-        EnsureInitialized();
-                return new Wan22Model<T>(
-            architecture: Architecture,
-            options: Options as DiffusionModelOptions<T>,
-            scheduler: Scheduler,
-            predictor: (DiTNoisePredictor<T>)_predictor.Clone(),
-            temporalVAE: (TemporalVAE<T>)_temporalVAE.Clone(),
-            conditioner: _conditioner,
-            defaultNumFrames: DefaultNumFrames,
-            defaultFPS: DefaultFPS);
-    }
-
     public override ModelMetadata<T> GetModelMetadata()
     {
         var metadata = new ModelMetadata<T>
diff --git a/src/Diffusion/Video/WanVideoModel.cs b/src/Diffusion/Video/WanVideoModel.cs
index 2e7ff76956..810f34b773 100644
--- a/src/Diffusion/Video/WanVideoModel.cs
+++ b/src/Diffusion/Video/WanVideoModel.cs
@@ -385,32 +385,6 @@ protected override Tensor<T> PredictVideoNoise(
 
 
 
-    #endregion
-
-    #region ICloneable Implementation
-
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy()
-    {
-        return Clone();
-    }
-
-    /// <inheritdoc />
-    public override IDiffusionModel<T> Clone()
-    {
-        // _dit.Clone() reconstructs from the predictor's own config fields and (with the
-        // lazy-layer-materializing DiTNoisePredictor.Clone) preserves its weights — so it is
-        // correct for both a caller-injected predictor and the default variant build, with no
-        // need to re-derive the variant config or round-trip a flat foundation-scale vector.
-        return new WanVideoModel<T>(
-            dit: (DiTNoisePredictor<T>)_dit.Clone(),
-            temporalVAE: (TemporalVAE<T>)_temporalVAE.Clone(),
-            conditioner: _conditioner,
-            variant: _variant,
-            defaultNumFrames: DefaultNumFrames,
-            defaultFPS: DefaultFPS);
-    }
-
     #endregion
 
     #region Metadata
diff --git a/src/Diffusion/Video/WorldModels/CosmosModel.cs b/src/Diffusion/Video/WorldModels/CosmosModel.cs
index 365c026f09..713803d338 100644
--- a/src/Diffusion/Video/WorldModels/CosmosModel.cs
+++ b/src/Diffusion/Video/WorldModels/CosmosModel.cs
@@ -145,21 +145,6 @@ protected override Tensor<T> PredictVideoNoise(
 
 
 
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    public override IDiffusionModel<T> Clone()
-    {
-                return new CosmosModel<T>(
-            architecture: Architecture,
-            options: Options as DiffusionModelOptions<T>,
-            scheduler: Scheduler,
-            predictor: (DiTNoisePredictor<T>)_predictor.Clone(),
-            temporalVAE: (TemporalVAE<T>)_temporalVAE.Clone(),
-            conditioner: _conditioner,
-            defaultNumFrames: DefaultNumFrames,
-            defaultFPS: DefaultFPS);
-    }
-
     public override ModelMetadata<T> GetModelMetadata()
     {
         var metadata = new ModelMetadata<T>
diff --git a/src/Diffusion/Video/WorldModels/DIAMONDModel.cs b/src/Diffusion/Video/WorldModels/DIAMONDModel.cs
index 3ca4bee2a9..2bd5dc6ffd 100644
--- a/src/Diffusion/Video/WorldModels/DIAMONDModel.cs
+++ b/src/Diffusion/Video/WorldModels/DIAMONDModel.cs
@@ -145,21 +145,6 @@ protected override Tensor<T> PredictVideoNoise(
 
 
 
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    public override IDiffusionModel<T> Clone()
-    {
-                return new DIAMONDModel<T>(
-            architecture: Architecture,
-            options: Options as DiffusionModelOptions<T>,
-            scheduler: Scheduler,
-            predictor: (DiTNoisePredictor<T>)_predictor.Clone(),
-            temporalVAE: (TemporalVAE<T>)_temporalVAE.Clone(),
-            conditioner: _conditioner,
-            defaultNumFrames: DefaultNumFrames,
-            defaultFPS: DefaultFPS);
-    }
-
     public override ModelMetadata<T> GetModelMetadata()
     {
         var metadata = new ModelMetadata<T>
diff --git a/src/Diffusion/Video/WorldModels/GameGenXModel.cs b/src/Diffusion/Video/WorldModels/GameGenXModel.cs
index 7e3705d071..73e52c45ee 100644
--- a/src/Diffusion/Video/WorldModels/GameGenXModel.cs
+++ b/src/Diffusion/Video/WorldModels/GameGenXModel.cs
@@ -147,18 +147,6 @@ protected override Tensor<T> PredictVideoNoise(
 
 
 
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    public override IDiffusionModel<T> Clone()
-    {
-                return new GameGenXModel<T>(
-            predictor: (DiTNoisePredictor<T>)_predictor.Clone(),
-            temporalVAE: (TemporalVAE<T>)_temporalVAE.Clone(),
-            conditioner: _conditioner,
-            defaultNumFrames: DefaultNumFrames,
-            defaultFPS: DefaultFPS);
-    }
-
     public override ModelMetadata<T> GetModelMetadata()
     {
         var metadata = new ModelMetadata<T>
diff --git a/src/Diffusion/Video/WorldModels/Genie2Model.cs b/src/Diffusion/Video/WorldModels/Genie2Model.cs
index f6f7464307..ce85dbb8fc 100644
--- a/src/Diffusion/Video/WorldModels/Genie2Model.cs
+++ b/src/Diffusion/Video/WorldModels/Genie2Model.cs
@@ -144,21 +144,6 @@ protected override Tensor<T> PredictVideoNoise(
 
 
 
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    public override IDiffusionModel<T> Clone()
-    {
-                return new Genie2Model<T>(
-            architecture: Architecture,
-            options: Options as DiffusionModelOptions<T>,
-            scheduler: Scheduler,
-            predictor: (DiTNoisePredictor<T>)_predictor.Clone(),
-            temporalVAE: (TemporalVAE<T>)_temporalVAE.Clone(),
-            conditioner: _conditioner,
-            defaultNumFrames: DefaultNumFrames,
-            defaultFPS: DefaultFPS);
-    }
-
     public override ModelMetadata<T> GetModelMetadata()
     {
         var metadata = new ModelMetadata<T>
diff --git a/src/Diffusion/Video/WorldModels/OasisModel.cs b/src/Diffusion/Video/WorldModels/OasisModel.cs
index 2c954c6325..4e2dee271e 100644
--- a/src/Diffusion/Video/WorldModels/OasisModel.cs
+++ b/src/Diffusion/Video/WorldModels/OasisModel.cs
@@ -147,18 +147,6 @@ protected override Tensor<T> PredictVideoNoise(
 
 
 
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    public override IDiffusionModel<T> Clone()
-    {
-                return new OasisModel<T>(
-            predictor: (DiTNoisePredictor<T>)_predictor.Clone(),
-            temporalVAE: (TemporalVAE<T>)_temporalVAE.Clone(),
-            conditioner: _conditioner,
-            defaultNumFrames: DefaultNumFrames,
-            defaultFPS: DefaultFPS);
-    }
-
     public override ModelMetadata<T> GetModelMetadata()
     {
         var metadata = new ModelMetadata<T>
diff --git a/src/Diffusion/Video/WorldModels/UniSimModel.cs b/src/Diffusion/Video/WorldModels/UniSimModel.cs
index 7e2a2525e5..22e546bc6e 100644
--- a/src/Diffusion/Video/WorldModels/UniSimModel.cs
+++ b/src/Diffusion/Video/WorldModels/UniSimModel.cs
@@ -147,18 +147,6 @@ protected override Tensor<T> PredictVideoNoise(
 
 
 
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    public override IDiffusionModel<T> Clone()
-    {
-                return new UniSimModel<T>(
-            predictor: (DiTNoisePredictor<T>)_predictor.Clone(),
-            temporalVAE: (TemporalVAE<T>)_temporalVAE.Clone(),
-            conditioner: _conditioner,
-            defaultNumFrames: DefaultNumFrames,
-            defaultFPS: DefaultFPS);
-    }
-
     public override ModelMetadata<T> GetModelMetadata()
     {
         var metadata = new ModelMetadata<T>
diff --git a/src/Diffusion/VideoDiffusionModelBase.cs b/src/Diffusion/VideoDiffusionModelBase.cs
index 8e95316bc0..c0b7f0bb87 100644
--- a/src/Diffusion/VideoDiffusionModelBase.cs
+++ b/src/Diffusion/VideoDiffusionModelBase.cs
@@ -29,7 +29,7 @@ namespace AiDotNet.Diffusion;
 /// - Frame interpolation: Increase frame rate smoothly
 /// </para>
 /// </remarks>
-public abstract class VideoDiffusionModelBase<T> : LatentDiffusionModelBase<T>, IVideoDiffusionModel<T>
+public abstract partial class VideoDiffusionModelBase<T> : LatentDiffusionModelBase<T>, IVideoDiffusionModel<T>
 {
     /// <summary>
     /// The motion bucket ID for controlling motion intensity.
diff --git a/src/Diffusion/VirtualTryOn/CATDMModel.cs b/src/Diffusion/VirtualTryOn/CATDMModel.cs
index 08436a1c25..824bf80dcd 100644
--- a/src/Diffusion/VirtualTryOn/CATDMModel.cs
+++ b/src/Diffusion/VirtualTryOn/CATDMModel.cs
@@ -92,27 +92,6 @@ private void InitializeLayers(UNetNoisePredictor<T>? predictor, StandardVAE<T>?
 
 
 
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    public override IDiffusionModel<T> Clone()
-    {
-        // Clone the ACTUAL predictor/VAE (see InstaFlowModel/MultiDiffusionModel): passing only
-        // conditioner/seed rebuilt InitializeLayers' DEFAULT-sized, lazily-unresolved sub-models, so once
-        // the source resolved its lazy layers via a forward pass the trainable-layer shapes no longer
-        // lined up 1:1 and Clone diverged. Cloning the resolved predictor/VAE (+ same architecture/
-        // options/scheduler) makes the clone structurally identical.
-        var clone = new CATDMModel<T>(
-            architecture: Architecture,
-            options: Options as DiffusionModelOptions<T>,
-            scheduler: Scheduler,
-            predictor: (UNetNoisePredictor<T>)_predictor.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner,
-            seed: null);
-        if (!clone.TryShareParametersFrom(this)) clone.SetParameterChunks(GetParameterChunks());
-        return clone;
-    }
-
     public override ModelMetadata<T> GetModelMetadata()
     {
         var m = new ModelMetadata<T> { Name = "CATDM", Version = "1.0",
diff --git a/src/Diffusion/VirtualTryOn/CatVTONModel.cs b/src/Diffusion/VirtualTryOn/CatVTONModel.cs
index c91fa7788b..8401ee9cdb 100644
--- a/src/Diffusion/VirtualTryOn/CatVTONModel.cs
+++ b/src/Diffusion/VirtualTryOn/CatVTONModel.cs
@@ -93,25 +93,6 @@ private void InitializeLayers(UNetNoisePredictor<T>? predictor, StandardVAE<T>?
 
 
 
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    public override IDiffusionModel<T> Clone()
-    {
-        // Delegate to the predictor/VAE's own Clone implementations (mirrors
-        // RealESRGAN / SeedEdit3 / ImprovedConsistencyModel, PR #1555/#1565).
-        // The previous body constructed a fresh CatVTONModel — which rebuilds
-        // the DEFAULT SD-1.5-scale predictor/VAE — and then SetParameters with
-        // this model's weights: for a model constructed with custom-sized
-        // components the parameter counts differ and SetParameters throws, and
-        // even at default scale the fresh components re-hit the lazy-init
-        // divergence bug.
-        var clone = new CatVTONModel<T>(
-            predictor: (UNetNoisePredictor<T>)_predictor.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner, seed: null);
-        return clone;
-    }
-
     public override ModelMetadata<T> GetModelMetadata()
     {
         var m = new ModelMetadata<T> { Name = "CatVTON", Version = "1.0",
diff --git a/src/Diffusion/VirtualTryOn/FashionVDMModel.cs b/src/Diffusion/VirtualTryOn/FashionVDMModel.cs
index 0a077f7333..be749e6f46 100644
--- a/src/Diffusion/VirtualTryOn/FashionVDMModel.cs
+++ b/src/Diffusion/VirtualTryOn/FashionVDMModel.cs
@@ -91,28 +91,6 @@ private void InitializeLayers(UNetNoisePredictor<T>? predictor, StandardVAE<T>?
 
 
 
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    public override IDiffusionModel<T> Clone()
-    {
-        // Clone the ACTUAL predictor and VAE (mirrors InstaFlowModel/MultiDiffusionModel):
-        // passing only conditioner/seed rebuilt InitializeLayers' DEFAULT-sized (and lazily
-        // unresolved) UNet/VAE, so once the source resolved its lazy layers via a forward pass
-        // its GetParameters() returned a larger count than the clone could accept — SetParameters
-        // threw / Clone produced divergent output. Cloning the resolved predictor/VAE (+ same
-        // architecture/options/scheduler) makes the clone structurally identical to the source.
-        var clone = new FashionVDMModel<T>(
-            architecture: Architecture,
-            options: Options as DiffusionModelOptions<T>,
-            scheduler: Scheduler,
-            predictor: (UNetNoisePredictor<T>)_predictor.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner,
-            seed: null);
-        if (!clone.TryShareParametersFrom(this)) clone.SetParameterChunks(GetParameterChunks());
-        return clone;
-    }
-
     public override ModelMetadata<T> GetModelMetadata()
     {
         var m = new ModelMetadata<T> { Name = "FashionVDM", Version = "1.0",
diff --git a/src/Diffusion/VirtualTryOn/IDMVTONModel.cs b/src/Diffusion/VirtualTryOn/IDMVTONModel.cs
index fb65ad9a9b..efdf51ebc1 100644
--- a/src/Diffusion/VirtualTryOn/IDMVTONModel.cs
+++ b/src/Diffusion/VirtualTryOn/IDMVTONModel.cs
@@ -94,27 +94,6 @@ private void InitializeLayers(UNetNoisePredictor<T>? predictor, StandardVAE<T>?
 
 
 
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    public override IDiffusionModel<T> Clone()
-    {
-        // Clone the ACTUAL predictor and VAE (mirrors MultiDiffusionModel/SpotDiffusionModel): the
-        // previous code passed only conditioner/seed, so the clone rebuilt the DEFAULT-sized UNet/VAE
-        // while this model may hold a custom-sized predictor/vae, making GetParameters() mismatch and
-        // clone.SetParameters throw "Expected X, got Y". Pass the cloned predictor/VAE (+ same
-        // architecture/options/scheduler) so the clone is structurally identical to the source.
-        var clone = new IDMVTONModel<T>(
-            architecture: Architecture,
-            options: Options as DiffusionModelOptions<T>,
-            scheduler: Scheduler,
-            predictor: (UNetNoisePredictor<T>)_predictor.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner,
-            seed: null);
-        if (!clone.TryShareParametersFrom(this)) clone.SetParameterChunks(GetParameterChunks());
-        return clone;
-    }
-
     public override ModelMetadata<T> GetModelMetadata()
     {
         var m = new ModelMetadata<T> { Name = "IDM-VTON", Version = "1.0",
diff --git a/src/Diffusion/VirtualTryOn/StableVITONModel.cs b/src/Diffusion/VirtualTryOn/StableVITONModel.cs
index ac11a21e10..0f7627e12e 100644
--- a/src/Diffusion/VirtualTryOn/StableVITONModel.cs
+++ b/src/Diffusion/VirtualTryOn/StableVITONModel.cs
@@ -93,27 +93,6 @@ private void InitializeLayers(UNetNoisePredictor<T>? predictor, StandardVAE<T>?
 
 
 
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-    public override IDiffusionModel<T> Clone()
-    {
-        // Clone the ACTUAL predictor/VAE (see InstaFlowModel/MultiDiffusionModel): passing only
-        // conditioner/seed rebuilt InitializeLayers' DEFAULT-sized, lazily-unresolved sub-models, so once
-        // the source resolved its lazy layers via a forward pass the trainable-layer shapes no longer
-        // lined up 1:1 and Clone diverged. Cloning the resolved predictor/VAE (+ same architecture/
-        // options/scheduler) makes the clone structurally identical.
-        var clone = new StableVITONModel<T>(
-            architecture: Architecture,
-            options: Options as DiffusionModelOptions<T>,
-            scheduler: Scheduler,
-            predictor: (UNetNoisePredictor<T>)_predictor.Clone(),
-            vae: (StandardVAE<T>)_vae.Clone(),
-            conditioner: _conditioner,
-            seed: null);
-        if (!clone.TryShareParametersFrom(this)) clone.SetParameterChunks(GetParameterChunks());
-        return clone;
-    }
-
     public override ModelMetadata<T> GetModelMetadata()
     {
         var m = new ModelMetadata<T> { Name = "StableVITON", Version = "1.0",
diff --git a/src/DistributedTraining/DDPModel.cs b/src/DistributedTraining/DDPModel.cs
index 5ed61f55b9..0afa08973c 100644
--- a/src/DistributedTraining/DDPModel.cs
+++ b/src/DistributedTraining/DDPModel.cs
@@ -68,8 +68,9 @@ namespace AiDotNet.DistributedTraining;
 [ModelComplexity(ModelComplexity.High)]
 [ResearchPaper("PyTorch Distributed: Accelerating Data Parallel Training", "https://arxiv.org/abs/2006.15704")]
     [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
-public class DDPModel<T, TInput, TOutput> : ShardedModelBase<T, TInput, TOutput>
+public partial class DDPModel<T, TInput, TOutput> : ShardedModelBase<T, TInput, TOutput>
 {
+    [AiDotNet.Attributes.FittedParameter]
     private Vector<T>? _computedGradients;
 
     /// <summary>
@@ -236,64 +237,6 @@ public override IFullModel<T, TInput, TOutput> WithParameters(Vector<T> paramete
         return new DDPModel<T, TInput, TOutput>(newModel, Config);
     }
 
-    /// <inheritdoc/>
-    public override byte[] Serialize()
-    {
-        using var ms = new MemoryStream();
-        using var writer = new BinaryWriter(ms);
-
-        // Serialize sharding configuration info
-        writer.Write(WorldSize);
-        writer.Write(Rank);
-        writer.Write(Config.AutoSyncGradients);
-        writer.Write(Config.MinimumParameterGroupSize);
-        writer.Write(Config.EnableGradientCompression);
-
-        // Serialize wrapped model
-        var modelData = WrappedModel.Serialize();
-        writer.Write(modelData.Length);
-        writer.Write(modelData);
-
-        return ms.ToArray();
-    }
-
-    /// <inheritdoc/>
-    public override void Deserialize(byte[] data)
-    {
-        using var ms = new MemoryStream(data);
-        using var reader = new BinaryReader(ms);
-
-        // Read sharding configuration (for validation)
-        int savedWorldSize = reader.ReadInt32();
-        int savedRank = reader.ReadInt32();
-        reader.ReadBoolean(); // AutoSyncGradients
-        reader.ReadInt32(); // MinimumParameterGroupSize
-        reader.ReadBoolean(); // EnableGradientCompression
-
-        if (savedWorldSize != WorldSize)
-        {
-            throw new InvalidOperationException(
-                $"World size mismatch. Model was trained with {savedWorldSize} processes, " +
-                $"but current configuration has {WorldSize} processes.");
-        }
-
-        // Validate rank matches
-        if (savedRank != Rank)
-        {
-            throw new InvalidOperationException(
-                $"Rank mismatch. Model was saved on rank {savedRank}, " +
-                $"but is being loaded on rank {Rank}. This could indicate a configuration error.");
-        }
-
-        // Read wrapped model
-        int modelDataLength = reader.ReadInt32();
-        byte[] modelData = reader.ReadBytes(modelDataLength);
-        WrappedModel.Deserialize(modelData);
-
-        // Re-initialize (will set full parameters, not sharded)
-        InitializeSharding();
-    }
-
     /// <inheritdoc/>
     public override void SaveModel(string filePath)
     {
@@ -336,11 +279,4 @@ public override void LoadModel(string filePath)
             Config.CommunicationBackend.Barrier();
         }
     }
-
-    /// <inheritdoc/>
-    public override IFullModel<T, TInput, TOutput> Clone()
-    {
-        var clonedWrappedModel = WrappedModel.Clone();
-        return new DDPModel<T, TInput, TOutput>(clonedWrappedModel, Config);
-    }
 }
diff --git a/src/DistributedTraining/ElasticOptimizer.cs b/src/DistributedTraining/ElasticOptimizer.cs
index d3c66bb272..f2bce16f73 100644
--- a/src/DistributedTraining/ElasticOptimizer.cs
+++ b/src/DistributedTraining/ElasticOptimizer.cs
@@ -79,7 +79,7 @@ namespace AiDotNet.DistributedTraining;
 /// <typeparam name="T">The numeric type</typeparam>
 /// <typeparam name="TInput">The input type for the model</typeparam>
 /// <typeparam name="TOutput">The output type for the model</typeparam>
-public class ElasticOptimizer<T, TInput, TOutput> : ShardedOptimizerBase<T, TInput, TOutput>
+public partial class ElasticOptimizer<T, TInput, TOutput> : ShardedOptimizerBase<T, TInput, TOutput>
 {
     private readonly int _minWorkers;
     private readonly int _maxWorkers;
diff --git a/src/DistributedTraining/FSDPModel.cs b/src/DistributedTraining/FSDPModel.cs
index 0606d95b82..19b10d3070 100644
--- a/src/DistributedTraining/FSDPModel.cs
+++ b/src/DistributedTraining/FSDPModel.cs
@@ -66,8 +66,9 @@ namespace AiDotNet.DistributedTraining;
 [ModelComplexity(ModelComplexity.VeryHigh)]
 [ResearchPaper("PyTorch FSDP: Experiences on Scaling Fully Sharded Data Parallel", "https://arxiv.org/abs/2304.11277")]
     [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
-public class FSDPModel<T, TInput, TOutput> : ShardedModelBase<T, TInput, TOutput>
+public partial class FSDPModel<T, TInput, TOutput> : ShardedModelBase<T, TInput, TOutput>
 {
+    [AiDotNet.Attributes.FittedParameter]
     private Vector<T>? _computedGradients;
 
     /// <summary>
@@ -225,64 +226,6 @@ public override IFullModel<T, TInput, TOutput> WithParameters(Vector<T> paramete
         return new FSDPModel<T, TInput, TOutput>(newModel, Config);
     }
 
-    /// <inheritdoc/>
-    public override byte[] Serialize()
-    {
-        using var ms = new MemoryStream();
-        using var writer = new BinaryWriter(ms);
-
-        // Serialize sharding configuration info
-        writer.Write(WorldSize);
-        writer.Write(Rank);
-        writer.Write(Config.AutoSyncGradients);
-        writer.Write(Config.MinimumParameterGroupSize);
-        writer.Write(Config.EnableGradientCompression);
-
-        // Serialize wrapped model
-        var modelData = WrappedModel.Serialize();
-        writer.Write(modelData.Length);
-        writer.Write(modelData);
-
-        return ms.ToArray();
-    }
-
-    /// <inheritdoc/>
-    public override void Deserialize(byte[] data)
-    {
-        using var ms = new MemoryStream(data);
-        using var reader = new BinaryReader(ms);
-
-        // Read sharding configuration (for validation)
-        int savedWorldSize = reader.ReadInt32();
-        int savedRank = reader.ReadInt32();
-        reader.ReadBoolean(); // AutoSyncGradients
-        reader.ReadInt32(); // MinimumParameterGroupSize
-        reader.ReadBoolean(); // EnableGradientCompression
-
-        if (savedWorldSize != WorldSize)
-        {
-            throw new InvalidOperationException(
-                $"World size mismatch. Model was trained with {savedWorldSize} processes, " +
-                $"but current configuration has {WorldSize} processes.");
-        }
-
-        // Validate rank matches - different rank could indicate configuration mismatch
-        if (savedRank != Rank)
-        {
-            throw new InvalidOperationException(
-                $"Rank mismatch. Model was saved on rank {savedRank}, " +
-                $"but is being loaded on rank {Rank}. This could indicate a configuration error.");
-        }
-
-        // Read wrapped model
-        int modelDataLength = reader.ReadInt32();
-        byte[] modelData = reader.ReadBytes(modelDataLength);
-        WrappedModel.Deserialize(modelData);
-
-        // Re-initialize sharding
-        InitializeSharding();
-    }
-
     /// <inheritdoc/>
     public override void SaveModel(string filePath)
     {
@@ -334,26 +277,12 @@ public override void LoadModel(string filePath)
         }
     }
 
-    /// <inheritdoc/>
-    public override IFullModel<T, TInput, TOutput> Clone()
-    {
-        var clonedWrappedModel = WrappedModel.Clone();
-        return new FSDPModel<T, TInput, TOutput>(clonedWrappedModel, Config);
-    }
-
     /// <inheritdoc/>
     public override Dictionary<string, T> GetFeatureImportance()
     {
         return WrappedModel.GetFeatureImportance();
     }
 
-    /// <inheritdoc/>
-    public override IFullModel<T, TInput, TOutput> DeepCopy()
-    {
-        var deepCopiedWrappedModel = WrappedModel.DeepCopy();
-        return new FSDPModel<T, TInput, TOutput>(deepCopiedWrappedModel, Config);
-    }
-
     /// <inheritdoc/>
     public override IEnumerable<int> GetActiveFeatureIndices()
     {
diff --git a/src/DistributedTraining/HybridShardedModel.cs b/src/DistributedTraining/HybridShardedModel.cs
index 2e0803b082..c275b848fa 100644
--- a/src/DistributedTraining/HybridShardedModel.cs
+++ b/src/DistributedTraining/HybridShardedModel.cs
@@ -85,8 +85,9 @@ namespace AiDotNet.DistributedTraining;
 [ModelComplexity(ModelComplexity.VeryHigh)]
 [ResearchPaper("PyTorch FSDP: Scaling Fully Sharded Data Parallel", "https://arxiv.org/abs/2304.11277")]
     [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
-public class HybridShardedModel<T, TInput, TOutput> : ShardedModelBase<T, TInput, TOutput>
+public partial class HybridShardedModel<T, TInput, TOutput> : ShardedModelBase<T, TInput, TOutput>
 {
+    [AiDotNet.Attributes.FittedParameter]
     private Vector<T>? _computedGradients;
 
     // Static ThreadLocal to pass constructor parameters before base constructor call.
@@ -492,56 +493,6 @@ public override IFullModel<T, TInput, TOutput> WithParameters(Vector<T> paramete
             _pipelineParallelSize, _tensorParallelSize, _dataParallelSize);
     }
 
-    /// <inheritdoc/>
-    public override byte[] Serialize()
-    {
-        using var ms = new MemoryStream();
-        using var writer = new BinaryWriter(ms);
-        writer.Write(WorldSize);
-        writer.Write(Rank);
-        writer.Write(_pipelineParallelSize);
-        writer.Write(_tensorParallelSize);
-        writer.Write(_dataParallelSize);
-        writer.Write(Config.AutoSyncGradients);
-        writer.Write(Config.MinimumParameterGroupSize);
-        writer.Write(Config.EnableGradientCompression);
-        var modelData = WrappedModel.Serialize();
-        writer.Write(modelData.Length);
-        writer.Write(modelData);
-        return ms.ToArray();
-    }
-
-    /// <inheritdoc/>
-    public override void Deserialize(byte[] data)
-    {
-        using var ms = new MemoryStream(data);
-        using var reader = new BinaryReader(ms);
-        int savedWorldSize = reader.ReadInt32();
-        int savedRank = reader.ReadInt32();
-        int savedPP = reader.ReadInt32();
-        int savedTP = reader.ReadInt32();
-        int savedDP = reader.ReadInt32();
-        reader.ReadBoolean();
-        reader.ReadInt32();
-        reader.ReadBoolean();
-
-        if (savedWorldSize != WorldSize)
-            throw new InvalidOperationException($"World size mismatch: {savedWorldSize} vs {WorldSize}");
-        if (savedRank != Rank)
-            throw new InvalidOperationException($"Rank mismatch: {savedRank} vs {Rank}");
-        if (savedPP != _pipelineParallelSize)
-            throw new InvalidOperationException($"Pipeline parallel size mismatch: saved model used {savedPP} pipeline stages, but current instance configured with {_pipelineParallelSize}");
-        if (savedTP != _tensorParallelSize)
-            throw new InvalidOperationException($"Tensor parallel size mismatch: saved model used {savedTP} tensor parallel groups, but current instance configured with {_tensorParallelSize}");
-        if (savedDP != _dataParallelSize)
-            throw new InvalidOperationException($"Data parallel size mismatch: saved model used {savedDP} data parallel replicas, but current instance configured with {_dataParallelSize}");
-
-        int modelDataLength = reader.ReadInt32();
-        byte[] modelData = reader.ReadBytes(modelDataLength);
-        WrappedModel.Deserialize(modelData);
-        InitializeSharding();
-    }
-
     /// <inheritdoc/>
     public override void SaveModel(string filePath)
     {
@@ -570,12 +521,4 @@ public override void LoadModel(string filePath)
             Config.CommunicationBackend.Barrier();
         }
     }
-
-    /// <inheritdoc/>
-    public override IFullModel<T, TInput, TOutput> Clone()
-    {
-        return new HybridShardedModel<T, TInput, TOutput>(
-            WrappedModel.Clone(), Config,
-            _pipelineParallelSize, _tensorParallelSize, _dataParallelSize);
-    }
 }
diff --git a/src/DistributedTraining/Layers/ColumnParallelLinear.cs b/src/DistributedTraining/Layers/ColumnParallelLinear.cs
index a5e3fa9da6..d357f014b3 100644
--- a/src/DistributedTraining/Layers/ColumnParallelLinear.cs
+++ b/src/DistributedTraining/Layers/ColumnParallelLinear.cs
@@ -19,7 +19,7 @@ namespace AiDotNet.DistributedTraining.Layers;
 /// </summary>
 [LayerCategory(LayerCategory.Dense)]
 [LayerTask(LayerTask.Projection)]
-[LayerProperty(IsTrainable = true, ChangesShape = true)]
+[LayerProperty(IsTrainable = true, ChangesShape = true, TestConstructorArgs = "new AiDotNet.DistributedTraining.InMemoryCommunicationBackend<double>(0, 1), 4, 8", TestInputShape = "1, 4")]
 // Rank 2 [Batch, Features] and nothing else, read off ForwardTraced's own arithmetic: the matmul is
 // against a rank-2 weightT ([inputSize, localOut]) and the bias is broadcast from a rank-2
 // [1, _localOutputSize]. Those two shapes only line up with a rank-2 activation, so no other rank is
@@ -46,6 +46,9 @@ public sealed partial class ColumnParallelLinear<T> : LayerBase<T>, IShapeContra
     public override bool SupportsTraining => true;
     public int LocalOutputSize => _localOutputSize;
 
+    /// <summary>Construction state: the 'outputSize' the layer was built with.</summary>
+    private readonly int _outputSize;
+
     public ColumnParallelLinear(
         ICommunicationBackend<T> backend,
         int inputSize,
@@ -56,6 +59,7 @@ public ColumnParallelLinear(
                [gatherOutput ? outputSize : ShardCount(outputSize, backend.WorldSize, backend.Rank)],
                activationFunction ?? new AiDotNet.ActivationFunctions.IdentityActivation<T>())
     {
+        _outputSize = outputSize;
         _backend = backend;
         _f = new CopyToTensorParallelRegion<T>(backend);
         _gather = new GatherFromTensorParallelRegion<T>(backend, outputSize);
diff --git a/src/DistributedTraining/Layers/RowParallelLinear.cs b/src/DistributedTraining/Layers/RowParallelLinear.cs
index be94424d90..afa5d7308a 100644
--- a/src/DistributedTraining/Layers/RowParallelLinear.cs
+++ b/src/DistributedTraining/Layers/RowParallelLinear.cs
@@ -20,7 +20,7 @@ namespace AiDotNet.DistributedTraining.Layers;
 /// </summary>
 [LayerCategory(LayerCategory.Dense)]
 [LayerTask(LayerTask.Projection)]
-[LayerProperty(IsTrainable = true, ChangesShape = true)]
+[LayerProperty(IsTrainable = true, ChangesShape = true, TestConstructorArgs = "new AiDotNet.DistributedTraining.InMemoryCommunicationBackend<double>(0, 1), 4, 8", TestInputShape = "1, 4")]
 // The SHARDING IS INVISIBLE FROM THE OUTSIDE, which is the whole point of the ḡ conjugate operator and
 // the only reason a shape contract is expressible here at all. Each rank consumes its own input slice
 // [batch, localIn] and produces a PARTIAL [batch, outputSize]; the all-reduce sums the partials without
@@ -67,6 +67,9 @@ public sealed partial class RowParallelLinear<T> : LayerBase<T>, IShapeContract
     public override bool SupportsTraining => true;
     public int LocalInputSize => _localInputSize;
 
+    /// <summary>Construction state: the 'inputSize' the layer was built with.</summary>
+    private readonly int _inputSize;
+
     public RowParallelLinear(
         ICommunicationBackend<T> backend,
         int inputSize,
@@ -76,6 +79,7 @@ public RowParallelLinear(
                [outputSize],
                activationFunction ?? new AiDotNet.ActivationFunctions.IdentityActivation<T>())
     {
+        _inputSize = inputSize;
         _backend = backend;
         _g = new ReduceFromTensorParallelRegion<T>(backend);
         _fullInputSize = inputSize;
diff --git a/src/DistributedTraining/Layers/Stage3ShardedLinear.cs b/src/DistributedTraining/Layers/Stage3ShardedLinear.cs
index c2bcd2abf0..8decf2d002 100644
--- a/src/DistributedTraining/Layers/Stage3ShardedLinear.cs
+++ b/src/DistributedTraining/Layers/Stage3ShardedLinear.cs
@@ -18,7 +18,7 @@ namespace AiDotNet.DistributedTraining.Layers;
 /// </summary>
 [LayerCategory(LayerCategory.Dense)]
 [LayerTask(LayerTask.Projection)]
-[LayerProperty(IsTrainable = true, ChangesShape = true)]
+[LayerProperty(IsTrainable = true, ChangesShape = true, TestConstructorArgs = "new AiDotNet.DistributedTraining.InMemoryCommunicationBackend<double>(0, 1), 4, 8", TestInputShape = "1, 4")]
 // SHARDING IS A STORAGE CONCERN, NOT A SHAPE ONE, and that is the whole point of the contract here.
 // _shardLen splits the weight across ranks, but ForwardTraced all-gathers it back to the full
 // [outputSize, inputSize] before the matmul, so every rank returns the SAME full-width [batch,
diff --git a/src/DistributedTraining/Layers/TensorParallelAttention.cs b/src/DistributedTraining/Layers/TensorParallelAttention.cs
index e0602fbd4f..29175ee261 100644
--- a/src/DistributedTraining/Layers/TensorParallelAttention.cs
+++ b/src/DistributedTraining/Layers/TensorParallelAttention.cs
@@ -64,6 +64,9 @@ public sealed partial class TensorParallelAttention<T> : LayerBase<T>, IShapeCon
     private readonly bool _causal;
     private readonly double _scale;
 
+    /// <summary>Construction state: the 'backend' the layer was built with.</summary>
+    private readonly AiDotNet.DistributedTraining.ICommunicationBackend<T> _backend;
+
     /// <summary>
     /// Creates a tensor-parallel attention block sharded across the ranks of <paramref name="backend"/>.
     /// </summary>
@@ -74,6 +77,7 @@ public sealed partial class TensorParallelAttention<T> : LayerBase<T>, IShapeCon
     public TensorParallelAttention(ICommunicationBackend<T> backend, int embedDim, int numHeads, bool causal = false)
         : base([embedDim], [embedDim])
     {
+        _backend = backend;
         if (backend is null) throw new ArgumentNullException(nameof(backend));
         if (embedDim <= 0) throw new ArgumentOutOfRangeException(nameof(embedDim));
         if (numHeads <= 0 || embedDim % numHeads != 0)
diff --git a/src/DistributedTraining/Layers/TensorParallelTransformerBlock.cs b/src/DistributedTraining/Layers/TensorParallelTransformerBlock.cs
index 405e39830e..2da8e460c8 100644
--- a/src/DistributedTraining/Layers/TensorParallelTransformerBlock.cs
+++ b/src/DistributedTraining/Layers/TensorParallelTransformerBlock.cs
@@ -57,6 +57,15 @@ public sealed partial class TensorParallelTransformerBlock<T> : LayerBase<T>, IS
     private readonly int _embedDim;
     private readonly int _ffnDim;
 
+    /// <summary>Construction state: the 'backend' the layer was built with.</summary>
+    private readonly AiDotNet.DistributedTraining.ICommunicationBackend<T> _backend;
+
+    /// <summary>Construction state: the 'numHeads' the layer was built with.</summary>
+    private readonly int _numHeads;
+
+    /// <summary>Construction state: the 'causal' the layer was built with.</summary>
+    private readonly bool _causal;
+
     /// <summary>Creates a tensor-parallel transformer block sharded across the ranks of <paramref name="backend"/>.</summary>
     /// <param name="backend">The tensor-parallel communication backend.</param>
     /// <param name="embedDim">Model embedding dimension (= numHeads * headDim).</param>
@@ -69,6 +78,9 @@ public TensorParallelTransformerBlock(
         IActivationFunction<T>? activation = null, bool causal = false)
         : base([embedDim], [embedDim])
     {
+        _causal = causal;
+        _numHeads = numHeads;
+        _backend = backend;
         if (backend is null) throw new ArgumentNullException(nameof(backend));
         if (ffnDim <= 0) throw new ArgumentOutOfRangeException(nameof(ffnDim));
 
diff --git a/src/DistributedTraining/PipelineParallelModel.cs b/src/DistributedTraining/PipelineParallelModel.cs
index 9372ca5e56..bf653b0ba0 100644
--- a/src/DistributedTraining/PipelineParallelModel.cs
+++ b/src/DistributedTraining/PipelineParallelModel.cs
@@ -73,7 +73,7 @@ namespace AiDotNet.DistributedTraining;
 [ModelComplexity(ModelComplexity.VeryHigh)]
 [ResearchPaper("GPipe: Efficient Training of Giant Neural Networks", "https://arxiv.org/abs/1811.06965")]
     [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
-public class PipelineParallelModel<T, TInput, TOutput> : ShardedModelBase<T, TInput, TOutput>
+public partial class PipelineParallelModel<T, TInput, TOutput> : ShardedModelBase<T, TInput, TOutput>
 {
     private readonly int _microBatchCount;
     private readonly IPipelinePartitionStrategy<T>? _partitionStrategy;
@@ -102,6 +102,7 @@ public class PipelineParallelModel<T, TInput, TOutput> : ShardedModelBase<T, TIn
 
     // Cached weight gradients from BackwardInput for fallback accumulation when model
     // does not support IPipelineDecomposableModel (emulated B/W split).
+    [Scratch]
     private readonly Dictionary<int, Vector<T>> _cachedWeightGradients = new();
 
     // Whether the wrapped model supports true B/W decomposition
@@ -1390,61 +1391,6 @@ public override IFullModel<T, TInput, TOutput> WithParameters(Vector<T> paramete
             _partitionStrategy, _schedule, _checkpointConfig);
     }
 
-    /// <inheritdoc/>
-    public override byte[] Serialize()
-    {
-        EnsureShardingInitialized();
-        using var ms = new MemoryStream();
-        using var writer = new BinaryWriter(ms);
-        writer.Write(WorldSize);
-        writer.Write(Rank);
-        writer.Write(_microBatchCount);
-        writer.Write(Config.AutoSyncGradients);
-        writer.Write(Config.MinimumParameterGroupSize);
-        writer.Write(Config.EnableGradientCompression);
-        writer.Write(_schedule.Name);
-        writer.Write(_checkpointConfig.Enabled);
-        writer.Write(_checkpointConfig.CheckpointEveryNLayers);
-        writer.Write(_virtualStagesPerRank);
-        var modelData = WrappedModel.Serialize();
-        writer.Write(modelData.Length);
-        writer.Write(modelData);
-        return ms.ToArray();
-    }
-
-    /// <inheritdoc/>
-    public override void Deserialize(byte[] data)
-    {
-        using var ms = new MemoryStream(data);
-        using var reader = new BinaryReader(ms);
-        int savedWorldSize = reader.ReadInt32();
-        int savedRank = reader.ReadInt32();
-        int savedMicroBatchCount = reader.ReadInt32();
-        reader.ReadBoolean(); // AutoSyncGradients
-        reader.ReadInt32(); // MinimumParameterGroupSize
-        reader.ReadBoolean(); // EnableGradientCompression
-        reader.ReadString(); // Schedule name (informational)
-        reader.ReadBoolean(); // Checkpointing enabled
-        reader.ReadInt32(); // CheckpointEveryNLayers
-        reader.ReadInt32(); // VirtualStagesPerRank (informational)
-
-        if (savedWorldSize != WorldSize)
-            throw new InvalidOperationException($"World size mismatch: {savedWorldSize} vs {WorldSize}");
-        if (savedRank != Rank)
-            throw new InvalidOperationException($"Rank mismatch: {savedRank} vs {Rank}");
-        if (savedMicroBatchCount != _microBatchCount)
-            throw new InvalidOperationException($"Micro-batch count mismatch: saved model was trained with {savedMicroBatchCount}, but current instance configured with {_microBatchCount}");
-
-        int modelDataLength = reader.ReadInt32();
-        byte[] modelData = reader.ReadBytes(modelDataLength);
-        WrappedModel.Deserialize(modelData);
-
-        // EnsureShardingInitialized calls OnBeforeInitializeSharding (which sets _numStages
-        // and other derived state) before InitializeSharding. Calling InitializeSharding
-        // directly would skip that setup and cause divide-by-zero.
-        EnsureShardingInitialized();
-    }
-
     /// <inheritdoc/>
     public override void SaveModel(string filePath)
     {
@@ -1472,12 +1418,4 @@ public override void LoadModel(string filePath)
             Config.CommunicationBackend.Barrier();
         }
     }
-
-    /// <inheritdoc/>
-    public override IFullModel<T, TInput, TOutput> Clone()
-    {
-        return new PipelineParallelModel<T, TInput, TOutput>(
-            WrappedModel.Clone(), Config, _microBatchCount,
-            _partitionStrategy, _schedule, _checkpointConfig);
-    }
 }
diff --git a/src/DistributedTraining/ShardedModelBase.cs b/src/DistributedTraining/ShardedModelBase.cs
index 790c3f8a14..a0f48e9557 100644
--- a/src/DistributedTraining/ShardedModelBase.cs
+++ b/src/DistributedTraining/ShardedModelBase.cs
@@ -5,6 +5,8 @@
 using AiDotNet.Models;
 using AiDotNet.Tensors.Engines;
 using AiDotNet.Validation;
+using System.Globalization;
+using System.Reflection;
 
 
 namespace AiDotNet.DistributedTraining;
@@ -36,12 +38,55 @@ namespace AiDotNet.DistributedTraining;
 /// <typeparam name="T">The numeric type for operations</typeparam>
 /// <typeparam name="TInput">The input type for the model</typeparam>
 /// <typeparam name="TOutput">The output type for the model</typeparam>
-public abstract class ShardedModelBase<T, TInput, TOutput> :
+public abstract partial class ShardedModelBase<T, TInput, TOutput> :
     IShardedModel<T, TInput, TOutput>,
     IParameterizable<T, TInput, TOutput>,
     IGradientComputable<T, TInput, TOutput>,
     IModelShape
 {
+    // --- declared state (ModelStateRegistry) ---
+    // Identical in every model base because these bases are siblings over the same interfaces rather
+    // than one hierarchy; the logic itself lives once in ModelStateRegistry/ModelStateEnvelope.
+
+    /// <summary>State that is not a parameter vector, declared once and persisted by this base.</summary>
+    private readonly AiDotNet.Models.ModelStateRegistry<T> _declaredState = new();
+    private bool _declaredStateRegistered;
+
+    /// <summary>
+    /// Declare state here that the parameter vector does not carry -- a retained training set,
+    /// fitted knots, kernel centres, an ensemble's children. Both halves of the payload are driven
+    /// by the declaration, so they cannot drift.
+    /// </summary>
+    /// <param name="state">The registry to declare into.</param>
+    protected virtual void RegisterState(AiDotNet.Models.ModelStateRegistry<T> state)
+    {
+    }
+    /// <summary>Generated state declarations for fields declared across this model's hierarchy.</summary>
+    /// <param name="state">The registry to declare into.</param>
+    /// <remarks>
+    /// Emitted by ModelStateGenerator into the partial model, so a model author declares nothing. The
+    /// hand-written <c>RegisterState</c> beside it exists only for state the classifier genuinely
+    /// cannot place; anything it CAN place belongs here, where it cannot be forgotten.
+    /// </remarks>
+    protected virtual void RegisterGeneratedState(AiDotNet.Models.ModelStateRegistry<T> state)
+    {
+        RegisterGeneratedStateCore(state);
+    }
+
+    /// <summary>The declared state, registered once and lazily so it runs after the constructor.</summary>
+    protected AiDotNet.Models.ModelStateRegistry<T> DeclaredState
+    {
+        get
+        {
+            if (!_declaredStateRegistered)
+            {
+                _declaredStateRegistered = true;
+                RegisterGeneratedState(_declaredState);
+                RegisterState(_declaredState);
+            }
+            return _declaredState;
+        }
+    }
     /// <summary>
     /// Provides numeric operations for type T.
     /// </summary>
@@ -427,10 +472,171 @@ public virtual void SetParameters(Vector<T> parameters)
     public abstract IFullModel<T, TInput, TOutput> WithParameters(Vector<T> parameters);
 
     /// <inheritdoc/>
-    public abstract byte[] Serialize();
+    /// <remarks>
+    /// Every sharding strategy persists the same two things: compatibility metadata for the
+    /// process topology and the wrapped model payload. Strategy-specific fitted state is appended
+    /// through the generated state registry, so concrete wrappers never own a serializer.
+    /// </remarks>
+    public virtual byte[] Serialize()
+    {
+        EnsureShardingInitialized();
+        using var stream = new MemoryStream();
+        using (var writer = new BinaryWriter(stream, System.Text.Encoding.UTF8, leaveOpen: true))
+        {
+            writer.Write(WorldSize);
+            writer.Write(Rank);
+            writer.Write(Config.AutoSyncGradients);
+            writer.Write(Config.MinimumParameterGroupSize);
+            writer.Write(Config.EnableGradientCompression);
+
+            var compatibilityValues = GetStrategyCompatibilityValues();
+            writer.Write(compatibilityValues.Count);
+            foreach (var value in compatibilityValues)
+            {
+                writer.Write(value.Name);
+                writer.Write(value.Value);
+            }
+
+            var modelData = WrappedModel.Serialize();
+            writer.Write(modelData.Length);
+            writer.Write(modelData);
+        }
+
+        return AiDotNet.Models.ModelStateEnvelope.Append(DeclaredState, stream.ToArray());
+    }
 
     /// <inheritdoc/>
-    public abstract void Deserialize(byte[] data);
+    public virtual void Deserialize(byte[] data)
+    {
+        Guard.NotNull(data);
+        EnsureShardingInitialized();
+        // Snapshot the destination configuration before generated state is restored. Some
+        // strategies derive their topology fields during base construction, and the state envelope
+        // legitimately carries those fields; comparing afterwards would compare saved state to
+        // itself and silently accept an incompatible destination.
+        var currentCompatibility = GetStrategyCompatibilityValues()
+            .ToDictionary(item => item.Name, item => item.Value, StringComparer.Ordinal);
+        var payload = AiDotNet.Models.ModelStateEnvelope.Extract(DeclaredState, data);
+
+        using var stream = new MemoryStream(payload);
+        using var reader = new BinaryReader(stream);
+        int savedWorldSize = reader.ReadInt32();
+        int savedRank = reader.ReadInt32();
+        bool savedAutoSync = reader.ReadBoolean();
+        int savedMinimumGroupSize = reader.ReadInt32();
+        bool savedCompression = reader.ReadBoolean();
+
+        if (savedWorldSize != WorldSize)
+            throw new InvalidOperationException(
+                $"World size mismatch: saved={savedWorldSize}, current={WorldSize}.");
+        if (savedRank != Rank)
+            throw new InvalidOperationException($"Rank mismatch: saved={savedRank}, current={Rank}.");
+        if (savedAutoSync != Config.AutoSyncGradients)
+            throw new InvalidOperationException(
+                $"AutoSyncGradients mismatch: saved={savedAutoSync}, current={Config.AutoSyncGradients}.");
+        if (savedMinimumGroupSize != Config.MinimumParameterGroupSize)
+            throw new InvalidOperationException(
+                $"MinimumParameterGroupSize mismatch: saved={savedMinimumGroupSize}, current={Config.MinimumParameterGroupSize}.");
+        if (savedCompression != Config.EnableGradientCompression)
+            throw new InvalidOperationException(
+                $"EnableGradientCompression mismatch: saved={savedCompression}, current={Config.EnableGradientCompression}.");
+
+        int savedCompatibilityCount = reader.ReadInt32();
+        if (savedCompatibilityCount < 0 || savedCompatibilityCount > 1024)
+            throw new InvalidDataException(
+                $"Invalid sharding compatibility value count {savedCompatibilityCount}.");
+
+        for (int i = 0; i < savedCompatibilityCount; i++)
+        {
+            string name = reader.ReadString();
+            string savedValue = reader.ReadString();
+            if (!currentCompatibility.TryGetValue(name, out string? currentValue))
+                throw new InvalidOperationException(
+                    $"Sharding strategy setting '{name}' is not present on the current {GetType().Name} instance.");
+            if (!string.Equals(savedValue, currentValue, StringComparison.Ordinal))
+                throw new InvalidOperationException(
+                    $"Sharding strategy setting '{name}' mismatch: saved={savedValue}, current={currentValue}.");
+        }
+
+        if (savedCompatibilityCount != currentCompatibility.Count)
+            throw new InvalidOperationException(
+                $"Sharding strategy setting count mismatch: saved={savedCompatibilityCount}, current={currentCompatibility.Count}.");
+
+        int modelDataLength = reader.ReadInt32();
+        if (modelDataLength < 0 || modelDataLength > stream.Length - stream.Position)
+            throw new InvalidDataException(
+                $"Invalid wrapped-model payload length {modelDataLength} for {stream.Length - stream.Position} remaining bytes.");
+
+        WrappedModel.Deserialize(reader.ReadBytes(modelDataLength));
+
+        // A restored wrapped model invalidates the local shard and every derived partition cache.
+        // Re-enter through the common initialization hook so pipeline and hybrid strategies rebuild
+        // their topology before slicing the restored parameter surface.
+        _isShardingInitialized = false;
+        CachedFullParameters = null;
+        EnsureShardingInitialized();
+    }
+
+    /// <summary>
+    /// Discovers scalar strategy settings backed by constructor parameters. This preserves
+    /// topology compatibility checks for every wrapper without asking concrete strategies to
+    /// maintain matching serialization methods.
+    /// </summary>
+    private IReadOnlyList<(string Name, string Value)> GetStrategyCompatibilityValues()
+    {
+        var concreteType = GetType();
+        var constructorParameters = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+        foreach (var constructor in concreteType.GetConstructors(
+                     BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic))
+        {
+            foreach (var parameter in constructor.GetParameters())
+            {
+                if (!string.IsNullOrEmpty(parameter.Name))
+                    constructorParameters.Add(parameter.Name!);
+            }
+        }
+
+        var values = new List<(string Name, string Value)>();
+        for (Type? type = concreteType;
+             type is not null && type != typeof(ShardedModelBase<T, TInput, TOutput>);
+             type = type.BaseType)
+        {
+            foreach (var field in type.GetFields(
+                         BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic |
+                         BindingFlags.DeclaredOnly))
+            {
+                string logicalName = field.Name.TrimStart('_');
+                if (!constructorParameters.Contains(logicalName) ||
+                    !TryFormatCompatibilityValue(field.FieldType, field.GetValue(this), out string value))
+                {
+                    continue;
+                }
+
+                values.Add(($"{type.FullName}.{field.Name}", value));
+            }
+        }
+
+        values.Sort((left, right) => StringComparer.Ordinal.Compare(left.Name, right.Name));
+        return values;
+    }
+
+    private static bool TryFormatCompatibilityValue(Type type, object? value, out string formatted)
+    {
+        Type valueType = Nullable.GetUnderlyingType(type) ?? type;
+        if (!(valueType.IsEnum || valueType.IsPrimitive || valueType == typeof(decimal) ||
+              valueType == typeof(string)))
+        {
+            formatted = string.Empty;
+            return false;
+        }
+
+        formatted = value is null
+            ? "<null>"
+            : value is IFormattable formattable
+                ? formattable.ToString(null, CultureInfo.InvariantCulture) ?? string.Empty
+                : value.ToString() ?? string.Empty;
+        return true;
+    }
 
     /// <inheritdoc/>
     public virtual int[] GetInputShape()
@@ -513,7 +719,28 @@ public virtual void LoadModel(string filePath)
     }
 
     /// <inheritdoc/>
-    public abstract IFullModel<T, TInput, TOutput> Clone();
+    /// <remarks>
+    /// <para>
+    /// No longer abstract. Configuration is rebuilt from the compile-time clone plan, which records
+    /// the constructor the type was built with; learned state is carried through the model's own
+    /// public Serialize and Deserialize, so a model that persists something extra keeps it. The
+    /// persistence guard is told this is an internal operation because a clone is not a save.
+    /// </para>
+    /// <para>
+    /// A model overrides this only when the generator reports that it cannot rebuild the type --
+    /// a constructor parameter with no member holding its value -- and the build names which one.
+    /// </para>
+    /// </remarks>
+    public virtual IFullModel<T, TInput, TOutput> Clone()
+    {
+        using (ModelPersistenceGuard.InternalOperation())
+        {
+            byte[] state = Serialize();
+            var copy = (ShardedModelBase<T, TInput, TOutput>)AiDotNet.Models.CloneEngine.CopyConfiguration(this);
+            copy.Deserialize(state);
+            return copy;
+        }
+    }
 
     /// <inheritdoc/>
     public virtual IFullModel<T, TInput, TOutput> DeepCopy()
diff --git a/src/DistributedTraining/ShardedOptimizerBase.cs b/src/DistributedTraining/ShardedOptimizerBase.cs
index 4bd789393b..94e8233bdd 100644
--- a/src/DistributedTraining/ShardedOptimizerBase.cs
+++ b/src/DistributedTraining/ShardedOptimizerBase.cs
@@ -34,8 +34,51 @@ namespace AiDotNet.DistributedTraining;
 /// <typeparam name="T">The numeric type for operations</typeparam>
 /// <typeparam name="TInput">The input type for the model</typeparam>
 /// <typeparam name="TOutput">The output type for the model</typeparam>
-public abstract class ShardedOptimizerBase<T, TInput, TOutput> : IShardedOptimizer<T, TInput, TOutput>, IModelShape
+public abstract partial class ShardedOptimizerBase<T, TInput, TOutput> : IShardedOptimizer<T, TInput, TOutput>, IModelShape
 {
+    // --- declared state (ModelStateRegistry) ---
+    // Identical in every model base because these bases are siblings over the same interfaces rather
+    // than one hierarchy; the logic itself lives once in ModelStateRegistry/ModelStateEnvelope.
+
+    /// <summary>State that is not a parameter vector, declared once and persisted by this base.</summary>
+    private readonly AiDotNet.Models.ModelStateRegistry<T> _declaredState = new();
+    private bool _declaredStateRegistered;
+
+    /// <summary>
+    /// Declare state here that the parameter vector does not carry -- a retained training set,
+    /// fitted knots, kernel centres, an ensemble's children. Both halves of the payload are driven
+    /// by the declaration, so they cannot drift.
+    /// </summary>
+    /// <param name="state">The registry to declare into.</param>
+    protected virtual void RegisterState(AiDotNet.Models.ModelStateRegistry<T> state)
+    {
+    }
+    /// <summary>Generated state declarations for fields declared across this model's hierarchy.</summary>
+    /// <param name="state">The registry to declare into.</param>
+    /// <remarks>
+    /// Emitted by ModelStateGenerator into the partial model, so a model author declares nothing. The
+    /// hand-written <c>RegisterState</c> beside it exists only for state the classifier genuinely
+    /// cannot place; anything it CAN place belongs here, where it cannot be forgotten.
+    /// </remarks>
+    protected virtual void RegisterGeneratedState(AiDotNet.Models.ModelStateRegistry<T> state)
+    {
+        RegisterGeneratedStateCore(state);
+    }
+
+    /// <summary>The declared state, registered once and lazily so it runs after the constructor.</summary>
+    protected AiDotNet.Models.ModelStateRegistry<T> DeclaredState
+    {
+        get
+        {
+            if (!_declaredStateRegistered)
+            {
+                _declaredStateRegistered = true;
+                RegisterGeneratedState(_declaredState);
+                RegisterState(_declaredState);
+            }
+            return _declaredState;
+        }
+    }
     /// <summary>
     /// Provides numeric operations for type T.
     /// </summary>
diff --git a/src/DistributedTraining/TensorParallelModel.cs b/src/DistributedTraining/TensorParallelModel.cs
index 7680d7e83c..2febf6d615 100644
--- a/src/DistributedTraining/TensorParallelModel.cs
+++ b/src/DistributedTraining/TensorParallelModel.cs
@@ -98,7 +98,7 @@ namespace AiDotNet.DistributedTraining;
 [ModelComplexity(ModelComplexity.VeryHigh)]
 [ResearchPaper("Megatron-LM: Training Multi-Billion Parameter Language Models", "https://arxiv.org/abs/1909.08053")]
     [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
-public class TensorParallelModel<T, TInput, TOutput> : ShardedModelBase<T, TInput, TOutput>
+public partial class TensorParallelModel<T, TInput, TOutput> : ShardedModelBase<T, TInput, TOutput>
 {
     private int _tensorParallelSize;
     private List<int> _tensorParallelGroup = new();
@@ -505,44 +505,6 @@ public override IFullModel<T, TInput, TOutput> WithParameters(Vector<T> paramete
             InterfaceGuard.Parameterizable(WrappedModel).WithParameters(parameters), Config);
     }
 
-    /// <inheritdoc/>
-    public override byte[] Serialize()
-    {
-        using var ms = new MemoryStream();
-        using var writer = new BinaryWriter(ms);
-        writer.Write(WorldSize);
-        writer.Write(Rank);
-        writer.Write(Config.AutoSyncGradients);
-        writer.Write(Config.MinimumParameterGroupSize);
-        writer.Write(Config.EnableGradientCompression);
-        var modelData = WrappedModel.Serialize();
-        writer.Write(modelData.Length);
-        writer.Write(modelData);
-        return ms.ToArray();
-    }
-
-    /// <inheritdoc/>
-    public override void Deserialize(byte[] data)
-    {
-        using var ms = new MemoryStream(data);
-        using var reader = new BinaryReader(ms);
-        int savedWorldSize = reader.ReadInt32();
-        int savedRank = reader.ReadInt32();
-        reader.ReadBoolean();
-        reader.ReadInt32();
-        reader.ReadBoolean();
-
-        if (savedWorldSize != WorldSize)
-            throw new InvalidOperationException($"World size mismatch: {savedWorldSize} vs {WorldSize}");
-        if (savedRank != Rank)
-            throw new InvalidOperationException($"Rank mismatch: {savedRank} vs {Rank}");
-
-        int modelDataLength = reader.ReadInt32();
-        byte[] modelData = reader.ReadBytes(modelDataLength);
-        WrappedModel.Deserialize(modelData);
-        InitializeSharding();
-    }
-
     /// <inheritdoc/>
     public override void SaveModel(string filePath)
     {
@@ -570,10 +532,4 @@ public override void LoadModel(string filePath)
             Config.CommunicationBackend.Barrier();
         }
     }
-
-    /// <inheritdoc/>
-    public override IFullModel<T, TInput, TOutput> Clone()
-    {
-        return new TensorParallelModel<T, TInput, TOutput>(WrappedModel.Clone(), Config);
-    }
 }
diff --git a/src/DistributedTraining/TensorParallelPagedModel.cs b/src/DistributedTraining/TensorParallelPagedModel.cs
index f24adc2860..9cc370e1ba 100644
--- a/src/DistributedTraining/TensorParallelPagedModel.cs
+++ b/src/DistributedTraining/TensorParallelPagedModel.cs
@@ -90,7 +90,9 @@ internal sealed partial class TensorParallelPagedModel<T> : TokenLanguageModelLa
     private readonly double _scale;
 
     // Full (un-sharded) weights.
+    [AiDotNet.Attributes.TrainableParameter]
     private readonly Tensor<T> _embedding; // [vocab, embedDim]
+    [AiDotNet.Attributes.TrainableParameter]
     private readonly Tensor<T> _lmHead;    // [vocab, embedDim]
     private readonly TensorParallelLayerWeights<T>[] _layers;
 
@@ -102,6 +104,7 @@ internal sealed partial class TensorParallelPagedModel<T> : TokenLanguageModelLa
     // primitive equivalence tests), and the FFN uses the trained activation (else ReLU). This lets the sharded
     // model reproduce a real model's output token-for-token rather than a reference block.
     private readonly bool _useRmsNorm;
+    [AiDotNet.Attributes.TrainableParameter]
     private readonly Tensor<T>? _finalNormGamma;
     private readonly Func<double, double> _ffnActivation;
     private readonly double _rmsNormEpsilon;
@@ -618,13 +621,4 @@ public void ShutdownRanks()
             ["VocabSize"] = _vocabSize
         }
     };
-
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-        => throw new NotSupportedException("TensorParallelPagedModel is a live serving model and is not serialized.");
-
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-        => throw new NotSupportedException("TensorParallelPagedModel is a live serving model and is not deserialized.");
-
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-        => throw new NotSupportedException("TensorParallelPagedModel cannot be cloned.");
 }
diff --git a/src/DistributedTraining/ZeRO1Model.cs b/src/DistributedTraining/ZeRO1Model.cs
index af534b8a93..52c07a5c68 100644
--- a/src/DistributedTraining/ZeRO1Model.cs
+++ b/src/DistributedTraining/ZeRO1Model.cs
@@ -63,8 +63,9 @@ namespace AiDotNet.DistributedTraining;
 [ModelComplexity(ModelComplexity.High)]
 [ResearchPaper("ZeRO: Memory Optimizations Toward Training Trillion Parameter Models", "https://arxiv.org/abs/1910.02054")]
     [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
-public class ZeRO1Model<T, TInput, TOutput> : ShardedModelBase<T, TInput, TOutput>
+public partial class ZeRO1Model<T, TInput, TOutput> : ShardedModelBase<T, TInput, TOutput>
 {
+    [AiDotNet.Attributes.FittedParameter]
     private Vector<T>? _computedGradients;
 
     /// <summary>
@@ -187,44 +188,6 @@ public override IFullModel<T, TInput, TOutput> WithParameters(Vector<T> paramete
         return new ZeRO1Model<T, TInput, TOutput>(newModel, Config);
     }
 
-    /// <inheritdoc/>
-    public override byte[] Serialize()
-    {
-        using var ms = new MemoryStream();
-        using var writer = new BinaryWriter(ms);
-        writer.Write(WorldSize);
-        writer.Write(Rank);
-        writer.Write(Config.AutoSyncGradients);
-        writer.Write(Config.MinimumParameterGroupSize);
-        writer.Write(Config.EnableGradientCompression);
-        var modelData = WrappedModel.Serialize();
-        writer.Write(modelData.Length);
-        writer.Write(modelData);
-        return ms.ToArray();
-    }
-
-    /// <inheritdoc/>
-    public override void Deserialize(byte[] data)
-    {
-        using var ms = new MemoryStream(data);
-        using var reader = new BinaryReader(ms);
-        int savedWorldSize = reader.ReadInt32();
-        int savedRank = reader.ReadInt32();
-        reader.ReadBoolean();
-        reader.ReadInt32();
-        reader.ReadBoolean();
-
-        if (savedWorldSize != WorldSize)
-            throw new InvalidOperationException($"World size mismatch: {savedWorldSize} vs {WorldSize}");
-        if (savedRank != Rank)
-            throw new InvalidOperationException($"Rank mismatch: {savedRank} vs {Rank}");
-
-        int modelDataLength = reader.ReadInt32();
-        byte[] modelData = reader.ReadBytes(modelDataLength);
-        WrappedModel.Deserialize(modelData);
-        InitializeSharding();
-    }
-
     /// <inheritdoc/>
     public override void SaveModel(string filePath)
     {
@@ -252,10 +215,4 @@ public override void LoadModel(string filePath)
             Config.CommunicationBackend.Barrier();
         }
     }
-
-    /// <inheritdoc/>
-    public override IFullModel<T, TInput, TOutput> Clone()
-    {
-        return new ZeRO1Model<T, TInput, TOutput>(WrappedModel.Clone(), Config);
-    }
 }
diff --git a/src/DistributedTraining/ZeRO2Model.cs b/src/DistributedTraining/ZeRO2Model.cs
index 238d375840..276226be94 100644
--- a/src/DistributedTraining/ZeRO2Model.cs
+++ b/src/DistributedTraining/ZeRO2Model.cs
@@ -62,10 +62,13 @@ namespace AiDotNet.DistributedTraining;
 [ModelComplexity(ModelComplexity.High)]
 [ResearchPaper("ZeRO: Memory Optimizations Toward Training Trillion Parameter Models", "https://arxiv.org/abs/1910.02054")]
     [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
-public class ZeRO2Model<T, TInput, TOutput> : ShardedModelBase<T, TInput, TOutput>
+public partial class ZeRO2Model<T, TInput, TOutput> : ShardedModelBase<T, TInput, TOutput>
 {
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T>? _parameterDeltaShard;
+    [AiDotNet.Attributes.FittedParameter]
     private Vector<T>? _computedGradients;
+    [Scratch]
     private Vector<T>? _gradientShard;
 
     /// <summary>
@@ -322,52 +325,6 @@ public override IFullModel<T, TInput, TOutput> WithParameters(Vector<T> paramete
         return new ZeRO2Model<T, TInput, TOutput>(InterfaceGuard.Parameterizable(WrappedModel).WithParameters(parameters), Config);
     }
 
-    /// <inheritdoc/>
-    public override byte[] Serialize()
-    {
-        using var ms = new MemoryStream();
-        using var writer = new BinaryWriter(ms);
-        writer.Write(WorldSize);
-        writer.Write(Rank);
-        writer.Write(Config.AutoSyncGradients);
-        writer.Write(Config.MinimumParameterGroupSize);
-        writer.Write(Config.EnableGradientCompression);
-        var modelData = WrappedModel.Serialize();
-        writer.Write(modelData.Length);
-        writer.Write(modelData);
-        return ms.ToArray();
-    }
-
-    /// <inheritdoc/>
-    public override void Deserialize(byte[] data)
-    {
-        using var ms = new MemoryStream(data);
-        using var reader = new BinaryReader(ms);
-        int savedWorldSize = reader.ReadInt32();
-        int savedRank = reader.ReadInt32();
-        bool savedAutoSyncGradients = reader.ReadBoolean();
-        int savedMinimumParameterGroupSize = reader.ReadInt32();
-        bool savedEnableGradientCompression = reader.ReadBoolean();
-
-        if (savedWorldSize != WorldSize)
-            throw new InvalidOperationException($"World size mismatch: {savedWorldSize} vs {WorldSize}");
-        if (savedRank != Rank)
-            throw new InvalidOperationException($"Rank mismatch: {savedRank} vs {Rank}");
-
-        // Validate configuration compatibility
-        if (savedAutoSyncGradients != Config.AutoSyncGradients)
-            throw new InvalidOperationException($"AutoSyncGradients mismatch: saved={savedAutoSyncGradients}, current={Config.AutoSyncGradients}");
-        if (savedMinimumParameterGroupSize != Config.MinimumParameterGroupSize)
-            throw new InvalidOperationException($"MinimumParameterGroupSize mismatch: saved={savedMinimumParameterGroupSize}, current={Config.MinimumParameterGroupSize}");
-        if (savedEnableGradientCompression != Config.EnableGradientCompression)
-            throw new InvalidOperationException($"EnableGradientCompression mismatch: saved={savedEnableGradientCompression}, current={Config.EnableGradientCompression}");
-
-        int modelDataLength = reader.ReadInt32();
-        byte[] modelData = reader.ReadBytes(modelDataLength);
-        WrappedModel.Deserialize(modelData);
-        InitializeSharding();
-    }
-
     /// <inheritdoc/>
     public override void SaveModel(string filePath)
     {
@@ -407,10 +364,4 @@ public override void LoadModel(string filePath)
             Config.CommunicationBackend.Barrier();
         }
     }
-
-    /// <inheritdoc/>
-    public override IFullModel<T, TInput, TOutput> Clone()
-    {
-        return new ZeRO2Model<T, TInput, TOutput>(WrappedModel.Clone(), Config);
-    }
 }
diff --git a/src/DistributedTraining/ZeRO3Model.cs b/src/DistributedTraining/ZeRO3Model.cs
index e1c6116240..d84a339000 100644
--- a/src/DistributedTraining/ZeRO3Model.cs
+++ b/src/DistributedTraining/ZeRO3Model.cs
@@ -100,11 +100,4 @@ public override IFullModel<T, TInput, TOutput> WithParameters(Vector<T> paramete
         var newModel = InterfaceGuard.Parameterizable(WrappedModel).WithParameters(parameters);
         return new ZeRO3Model<T, TInput, TOutput>(newModel, Config);
     }
-
-    /// <inheritdoc/>
-    public override IFullModel<T, TInput, TOutput> Clone()
-    {
-        var clonedWrappedModel = WrappedModel.Clone();
-        return new ZeRO3Model<T, TInput, TOutput>(clonedWrappedModel, Config);
-    }
 }
diff --git a/src/Distributions/DistributionBase.cs b/src/Distributions/DistributionBase.cs
index 0efa4bcba8..afe176b940 100644
--- a/src/Distributions/DistributionBase.cs
+++ b/src/Distributions/DistributionBase.cs
@@ -79,7 +79,12 @@ public abstract class DistributionBase<T> : ISamplingDistribution<T>
     public abstract Matrix<T> FisherInformation();
 
     /// <inheritdoc/>
-    public abstract IParametricDistribution<T> Clone();
+    /// <remarks>
+    /// A distribution carries no learned tensors -- its parameters ARE its configuration -- so
+    /// rebuilding it from the recorded constructor is the whole copy, with no state to reload.
+    /// </remarks>
+    public virtual IParametricDistribution<T> Clone()
+        => (IParametricDistribution<T>)AiDotNet.Models.CloneEngine.CopyConfiguration(this);
 
     /// <inheritdoc/>
     public abstract T Sample(Random random);
diff --git a/src/Distributions/GammaDistribution.cs b/src/Distributions/GammaDistribution.cs
index 542c24fb98..59b8561793 100644
--- a/src/Distributions/GammaDistribution.cs
+++ b/src/Distributions/GammaDistribution.cs
@@ -199,12 +199,6 @@ public override Matrix<T> FisherInformation()
         });
     }
 
-    /// <inheritdoc/>
-    public override IParametricDistribution<T> Clone()
-    {
-        return new GammaDistribution<T>(_shape, _rate);
-    }
-
     /// <inheritdoc/>
     public override T Sample(Random random)
     {
diff --git a/src/Distributions/NegativeBinomialDistribution.cs b/src/Distributions/NegativeBinomialDistribution.cs
index 78c8d5da2f..63001ab7da 100644
--- a/src/Distributions/NegativeBinomialDistribution.cs
+++ b/src/Distributions/NegativeBinomialDistribution.cs
@@ -247,12 +247,6 @@ public override Matrix<T> FisherInformation()
     }
 
 
-    /// <inheritdoc/>
-    public override IParametricDistribution<T> Clone()
-    {
-        return new NegativeBinomialDistribution<T>(_r, _prob);
-    }
-
     /// <inheritdoc/>
     public override T Sample(Random random)
     {
diff --git a/src/Distributions/PoissonDistribution.cs b/src/Distributions/PoissonDistribution.cs
index a578b75220..0dd720b08d 100644
--- a/src/Distributions/PoissonDistribution.cs
+++ b/src/Distributions/PoissonDistribution.cs
@@ -206,12 +206,6 @@ public override Matrix<T> FisherInformation()
         });
     }
 
-    /// <inheritdoc/>
-    public override IParametricDistribution<T> Clone()
-    {
-        return new PoissonDistribution<T>(_lambda);
-    }
-
     /// <inheritdoc/>
     public override T Sample(Random random)
     {
diff --git a/src/Distributions/StudentTDistribution.cs b/src/Distributions/StudentTDistribution.cs
index 3a13da48bc..1d95184253 100644
--- a/src/Distributions/StudentTDistribution.cs
+++ b/src/Distributions/StudentTDistribution.cs
@@ -258,12 +258,6 @@ public override Matrix<T> FisherInformation()
         });
     }
 
-    /// <inheritdoc/>
-    public override IParametricDistribution<T> Clone()
-    {
-        return new StudentTDistribution<T>(_location, _scale, _degreesOfFreedom);
-    }
-
     /// <inheritdoc/>
     public override T Sample(Random random)
     {
diff --git a/src/Distributions/WeibullDistribution.cs b/src/Distributions/WeibullDistribution.cs
index 45cc0e8a72..fb50221d35 100644
--- a/src/Distributions/WeibullDistribution.cs
+++ b/src/Distributions/WeibullDistribution.cs
@@ -223,12 +223,6 @@ public override Matrix<T> FisherInformation()
         });
     }
 
-    /// <inheritdoc/>
-    public override IParametricDistribution<T> Clone()
-    {
-        return new WeibullDistribution<T>(_shape, _scale);
-    }
-
     /// <inheritdoc/>
     public override T Sample(Random random)
     {
diff --git a/src/Document/Analysis/PageSegmentation/DocBank.cs b/src/Document/Analysis/PageSegmentation/DocBank.cs
index d9c90e68a4..fdbc42c0b1 100644
--- a/src/Document/Analysis/PageSegmentation/DocBank.cs
+++ b/src/Document/Analysis/PageSegmentation/DocBank.cs
@@ -612,40 +612,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_backboneChannels);
-        writer.Write(_numClasses);
-        writer.Write(_hiddenDim);
-        writer.Write(ImageSize);
-        writer.Write(_useTextFeatures);
-        writer.Write(_useNativeMode);
-    }
-
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        int backboneChannels = reader.ReadInt32();
-        int numClasses = reader.ReadInt32();
-        int hiddenDim = reader.ReadInt32();
-        int imageSize = reader.ReadInt32();
-        bool useTextFeatures = reader.ReadBoolean();
-        bool useNativeMode = reader.ReadBoolean();
 
-        ImageSize = imageSize;
-    }
 
     /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new DocBank<T>(
-            Architecture,
-            ImageSize,
-            _backboneChannels,
-            _numClasses,
-            _hiddenDim,
-            _useTextFeatures);
-    }
+
 
     #endregion
 
diff --git a/src/Document/Analysis/TableDetection/TableTransformer.cs b/src/Document/Analysis/TableDetection/TableTransformer.cs
index b6a3059c04..dcac37dcdc 100644
--- a/src/Document/Analysis/TableDetection/TableTransformer.cs
+++ b/src/Document/Analysis/TableDetection/TableTransformer.cs
@@ -1,1258 +1,1134 @@
-using AiDotNet.Attributes;
-using AiDotNet.Document.Interfaces;
-using AiDotNet.Document.Options;
-using AiDotNet.Enums;
-using AiDotNet.Helpers;
-using AiDotNet.Interfaces;
-using AiDotNet.LinearAlgebra;
-using AiDotNet.LossFunctions;
-using AiDotNet.NeuralNetworks;
-using AiDotNet.NeuralNetworks.Layers;
-using AiDotNet.Onnx;
-using AiDotNet.Optimizers;
-using Microsoft.ML.OnnxRuntime;
-
-namespace AiDotNet.Document.Analysis.TableDetection;
-
-/// <summary>
-/// TableTransformer for table detection and structure recognition using DETR-style architecture.
-/// </summary>
-/// <typeparam name="T">The numeric type used for calculations.</typeparam>
-/// <remarks>
-/// <para>
-/// TableTransformer is based on the DETR (DEtection TRansformer) architecture, adapted for
-/// table detection and table structure recognition. It can detect tables in documents and
-/// identify their internal structure (rows, columns, cells, headers).
-/// </para>
-/// <para>
-/// <b>For Beginners:</b> TableTransformer helps computers understand tables in documents.
-/// It can:
-/// 1. Find where tables are located in a page (table detection)
-/// 2. Identify the structure within tables - rows, columns, and cells (structure recognition)
-/// 3. Handle both bordered and borderless tables
-///
-/// Example usage:
-/// <code>
-/// var tableModel = new TableTransformer&lt;float&gt;(architecture);
-/// var tables = tableModel.DetectTables(documentImage);
-/// foreach (var table in tables)
-/// {
-///     var structure = tableModel.RecognizeStructure(table.Image);
-///     Console.WriteLine($"Table has {structure.NumRows} rows and {structure.NumColumns} columns");
-/// }
-/// </code>
-/// </para>
-/// <para>
-/// <b>Reference:</b> "PubTables-1M: Towards Comprehensive Table Extraction from Unstructured Documents" (CVPR 2022)
-/// https://arxiv.org/abs/2110.00061
-/// </para>
-/// </remarks>
-[ModelDomain(ModelDomain.Vision)]
-[ModelCategory(ModelCategory.NeuralNetwork)]
-[ModelCategory(ModelCategory.Transformer)]
-[ModelTask(ModelTask.Detection)]
-[ModelTask(ModelTask.Segmentation)]
-[ModelComplexity(ModelComplexity.High)]
-[ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
-[ResearchPaper("PubTables-1M: Towards Comprehensive Table Extraction from Unstructured Documents", "https://doi.org/10.48550/arXiv.2110.00061", Year = 2022, Authors = "Brandon Smock, Rohith Pesala, Robin Abraham")]
-public partial class TableTransformer<T> : DocumentNeuralNetworkBase<T>, ITableExtractor<T>
-{
-    private readonly TableTransformerOptions _options;
-
-    /// <inheritdoc/>
-    public override ModelOptions GetOptions() => _options;
-
-    #region Fields
-
-    private bool _useNativeMode;
-    private InferenceSession? _onnxDetectionSession;
-    private InferenceSession? _onnxStructureSession;
-    private string? _onnxDetectionModelPath;
-    private string? _onnxStructureModelPath;
-    private readonly IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>> _optimizer;
-    private int _hiddenDim;
-    private int _numEncoderLayers;
-    private int _numDecoderLayers;
-    private int _numHeads;
-    private int _numQueries;
-    private int _numTableClasses;
-    private int _numStructureClasses;
-
-    // Native mode layers
-    private readonly List<ILayer<T>> _backboneLayers = [];
-    private readonly List<ILayer<T>> _encoderLayers = [];
-    private readonly List<ILayer<T>> _decoderLayers = [];
-    private readonly List<ILayer<T>> _detectionHead = [];
-    private readonly List<ILayer<T>> _structureHead = [];
-
-    // Learnable object queries
-    private Tensor<T>? _objectQueries;
-
-    // Task mode - tracks whether we're doing detection or structure recognition
-#pragma warning disable CS0414 // Field is assigned but its value is never used - kept for future use in task-specific processing
-    private TableTransformerTask _currentTask = TableTransformerTask.Detection;
-#pragma warning restore CS0414
-
-    #endregion
-
-    #region Properties
-
-    /// <inheritdoc/>
-    public override DocumentType SupportedDocumentTypes => DocumentType.All;
-
-    /// <inheritdoc/>
-    public override bool RequiresOCR => false;
-
-    /// <inheritdoc/>
-    public int ExpectedImageSize => ImageSize;
-
-    /// <inheritdoc/>
-    public bool SupportsBorderedTables => true;
-
-    /// <inheritdoc/>
-    public bool SupportsBorderlessTables => true;
-
-    /// <inheritdoc/>
-    public bool SupportsMergedCells => true;
-
-    /// <summary>
-    /// Gets the number of object queries used in DETR decoder.
-    /// </summary>
-    public int NumQueries => _numQueries;
-
-    #endregion
-
-    #region Constructors
-
-    /// <summary>
-    /// Creates a TableTransformer model using pre-trained ONNX models for inference.
-    /// </summary>
-    /// <param name="architecture">The neural network architecture.</param>
-    /// <param name="detectionModelPath">Path to the table detection ONNX model.</param>
-    /// <param name="structureModelPath">Path to the structure recognition ONNX model.</param>
-    /// <param name="imageSize">Expected input image size (default: 800).</param>
-    /// <param name="hiddenDim">Transformer hidden dimension (default: 256).</param>
-    /// <param name="numEncoderLayers">Number of encoder layers (default: 6).</param>
-    /// <param name="numDecoderLayers">Number of decoder layers (default: 6).</param>
-    /// <param name="numHeads">Number of attention heads (default: 8).</param>
-    /// <param name="numQueries">Number of object queries (default: 100).</param>
-    /// <param name="optimizer">Optimizer for training (optional).</param>
-    /// <param name="lossFunction">Loss function (optional).</param>
-    /// <exception cref="ArgumentNullException">Thrown if model paths are null.</exception>
-    /// <exception cref="FileNotFoundException">Thrown if ONNX model files don't exist.</exception>
-    public TableTransformer(
-        NeuralNetworkArchitecture<T> architecture,
-        string detectionModelPath,
-        string structureModelPath,
-        int imageSize = 800,
-        int hiddenDim = 256,
-        int numEncoderLayers = 6,
-        int numDecoderLayers = 6,
-        int numHeads = 8,
-        int numQueries = 100,
-        IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? optimizer = null,
-        ILossFunction<T>? lossFunction = null,
-        TableTransformerOptions? options = null)
-        : base(architecture, lossFunction ?? new CrossEntropyWithLogitsLoss<T>(), 1.0)
-    {
-        _options = options ?? new TableTransformerOptions();
-        Options = _options;
-
-        if (string.IsNullOrWhiteSpace(detectionModelPath))
-            throw new ArgumentNullException(nameof(detectionModelPath));
-        if (string.IsNullOrWhiteSpace(structureModelPath))
-            throw new ArgumentNullException(nameof(structureModelPath));
-        if (!File.Exists(detectionModelPath))
-            throw new FileNotFoundException($"Detection model not found: {detectionModelPath}", detectionModelPath);
-        if (!File.Exists(structureModelPath))
-            throw new FileNotFoundException($"Structure model not found: {structureModelPath}", structureModelPath);
-
-        _useNativeMode = false;
-        _hiddenDim = hiddenDim;
-        _numEncoderLayers = numEncoderLayers;
-        _numDecoderLayers = numDecoderLayers;
-        _numHeads = numHeads;
-        _numQueries = numQueries;
-        _numTableClasses = 2;       // background, table
-        _numStructureClasses = 7;   // background, table, column, row, column header, projected row header, spanning cell
-        // TableTransformer is a DETR-based detector (Smock et al. 2022). DETR fine-tunes at 1e-4 with
-        // gradient-norm clipping at 0.1-1.0; built bare, the optimizer ran on framework defaults.
-        _optimizer = optimizer ?? new AdamOptimizer<T, Tensor<T>, Tensor<T>>(this,
-            new AiDotNet.Models.Options.AdamOptimizerOptions<T, Tensor<T>, Tensor<T>>
-            {
-                InitialLearningRate = 0.0001,
-                EnableGradientClipping = true,
-                MaxGradientNorm = 1.0,
-            });
-
-        ImageSize = imageSize;
-
-        _onnxDetectionModelPath = detectionModelPath;
-        _onnxStructureModelPath = structureModelPath;
-        InitializeOnnxSessions();
-
-        InitializeLayers();
-    }
-
-    /// <summary>
-    /// Creates a TableTransformer model using native layers for training and inference.
-    /// </summary>
-    /// <param name="architecture">The neural network architecture.</param>
-    /// <param name="imageSize">Expected input image size (default: 800).</param>
-    /// <param name="hiddenDim">Transformer hidden dimension (default: 256).</param>
-    /// <param name="numEncoderLayers">Number of encoder layers (default: 6).</param>
-    /// <param name="numDecoderLayers">Number of decoder layers (default: 6).</param>
-    /// <param name="numHeads">Number of attention heads (default: 8).</param>
-    /// <param name="numQueries">Number of object queries (default: 100).</param>
-    /// <param name="optimizer">Optimizer for training (optional).</param>
-    /// <param name="lossFunction">Loss function (optional).</param>
-    /// <remarks>
-    /// <para>
-    /// <b>Default Configuration (from CVPR 2022 paper):</b>
-    /// - Backbone: ResNet-18 (for detection) or ResNet-50 (for structure)
-    /// - Transformer: 6 encoder layers, 6 decoder layers, 256 hidden dim
-    /// - Object queries: 100
-    /// - Image size: 800
-    /// </para>
-    /// </remarks>
-    public TableTransformer(
-        NeuralNetworkArchitecture<T> architecture,
-        int imageSize = 800,
-        int hiddenDim = 256,
-        int numEncoderLayers = 6,
-        int numDecoderLayers = 6,
-        int numHeads = 8,
-        int numQueries = 100,
-        IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? optimizer = null,
-        ILossFunction<T>? lossFunction = null,
-        TableTransformerOptions? options = null)
-        : base(architecture, lossFunction ?? new CrossEntropyWithLogitsLoss<T>(), 1.0)
-    {
-        _options = options ?? new TableTransformerOptions();
-        Options = _options;
-
-        _useNativeMode = true;
-        _hiddenDim = hiddenDim;
-        _numEncoderLayers = numEncoderLayers;
-        _numDecoderLayers = numDecoderLayers;
-        _numHeads = numHeads;
-        _numQueries = numQueries;
-        _numTableClasses = 2;
-        _numStructureClasses = 7;
-        // TableTransformer is a DETR-based detector (Smock et al. 2022). DETR fine-tunes at 1e-4 with
-        // gradient-norm clipping at 0.1-1.0; built bare, the optimizer ran on framework defaults.
-        _optimizer = optimizer ?? new AdamOptimizer<T, Tensor<T>, Tensor<T>>(this,
-            new AiDotNet.Models.Options.AdamOptimizerOptions<T, Tensor<T>, Tensor<T>>
-            {
-                InitialLearningRate = 0.0001,
-                EnableGradientClipping = true,
-                MaxGradientNorm = 1.0,
-            });
-
-        ImageSize = imageSize;
-
-        InitializeLayers();
-        InitializeObjectQueries();
-    }
-
-    #endregion
-
-    #region Initialization
-
-    /// <inheritdoc/>
-    protected override void InitializeLayers()
-    {
-        if (!_useNativeMode)
-        {
-            return;
-        }
-
-        // Check if user provided custom layers
-        if (Architecture.Layers is not null && Architecture.Layers.Count > 0)
-        {
-            Layers.AddRange(Architecture.Layers);
-            ValidateCustomLayers(Layers);
-            return;
-        }
-
-        // Use LayerHelper to create default TableTransformer layers
-        Layers.AddRange(LayerHelper<T>.CreateDefaultTableTransformerLayers(
-            imageSize: ImageSize,
-            hiddenDim: _hiddenDim,
-            numEncoderLayers: _numEncoderLayers,
-            numDecoderLayers: _numDecoderLayers,
-            numHeads: _numHeads,
-            numQueries: _numQueries,
-            numStructureClasses: _numStructureClasses));
-    }
-
-    private void InitializeObjectQueries()
-    {
-        var random = RandomHelper.CreateSeededRandom(42);
-        _objectQueries = Tensor<T>.CreateDefault([_numQueries, _hiddenDim], NumOps.Zero);
-
-        // Xavier initialization for object queries
-        double scale = Math.Sqrt(2.0 / (_numQueries + _hiddenDim));
-        for (int i = 0; i < _objectQueries.Data.Length; i++)
-        {
-            double u1 = 1.0 - random.NextDouble();
-            double u2 = 1.0 - random.NextDouble();
-            double randStdNormal = Math.Sqrt(-2.0 * Math.Log(u1)) * Math.Sin(2.0 * Math.PI * u2);
-            _objectQueries.Data.Span[i] = NumOps.FromDouble(randStdNormal * scale);
-        }
-    }
-
-    private void InitializeOnnxSessions()
-    {
-        if (string.IsNullOrWhiteSpace(_onnxDetectionModelPath))
-            throw new InvalidOperationException("Detection ONNX model path is not set.");
-        if (string.IsNullOrWhiteSpace(_onnxStructureModelPath))
-            throw new InvalidOperationException("Structure ONNX model path is not set.");
-        if (!File.Exists(_onnxDetectionModelPath))
-            throw new FileNotFoundException($"Detection model not found: {_onnxDetectionModelPath}", _onnxDetectionModelPath);
-        if (!File.Exists(_onnxStructureModelPath))
-            throw new FileNotFoundException($"Structure model not found: {_onnxStructureModelPath}", _onnxStructureModelPath);
-
-        _onnxDetectionSession?.Dispose();
-        _onnxStructureSession?.Dispose();
-        _onnxDetectionSession = new InferenceSession(_onnxDetectionModelPath);
-        _onnxStructureSession = new InferenceSession(_onnxStructureModelPath);
-    }
-
-    #endregion
-
-    #region ITableExtractor Implementation
-
-    /// <inheritdoc/>
-    public IEnumerable<TableRegion<T>> DetectTables(Tensor<T> documentImage)
-    {
-        return DetectTables(documentImage, 0.5);
-    }
-
-    /// <summary>
-    /// Detects tables with a custom confidence threshold.
-    /// </summary>
-    public IEnumerable<TableRegion<T>> DetectTables(Tensor<T> documentImage, double confidenceThreshold)
-    {
-        ValidateImageShape(documentImage);
-
-        _currentTask = TableTransformerTask.Detection;
-
-        var preprocessed = PreprocessDocument(documentImage);
-        var output = _useNativeMode
-            ? Forward(preprocessed)
-            : RunDetectionOnnx(preprocessed);
-
-        return ParseTableDetections(output, documentImage, confidenceThreshold);
-    }
-
-    /// <inheritdoc/>
-    public TableStructureResult<T> RecognizeStructure(Tensor<T> tableImage)
-    {
-        return RecognizeStructure(tableImage, 0.5);
-    }
-
-    /// <summary>
-    /// Recognizes table structure with a custom confidence threshold.
-    /// </summary>
-    public TableStructureResult<T> RecognizeStructure(Tensor<T> tableImage, double confidenceThreshold)
-    {
-        ValidateImageShape(tableImage);
-
-        _currentTask = TableTransformerTask.Structure;
-
-        var preprocessed = PreprocessDocument(tableImage);
-        var output = _useNativeMode
-            ? Forward(preprocessed)
-            : RunStructureOnnx(preprocessed);
-
-        return ParseStructureOutput(output, tableImage, confidenceThreshold);
-    }
-
-    /// <inheritdoc/>
-    public IEnumerable<List<List<string>>> ExtractTableContent(Tensor<T> documentImage)
-    {
-        var tables = DetectTables(documentImage);
-
-        foreach (var table in tables)
-        {
-            if (table.Image is not null)
-            {
-                var structure = RecognizeStructure(table.Image);
-                yield return structure.ToStringGrid();
-            }
-        }
-    }
-
-    /// <inheritdoc/>
-    public string ExportTables(Tensor<T> documentImage, TableExportFormat format)
-    {
-        var tables = ExtractTableContent(documentImage).ToList();
-
-        return format switch
-        {
-            TableExportFormat.CSV => ExportToCSV(tables),
-            TableExportFormat.JSON => ExportToJSON(tables),
-            TableExportFormat.HTML => ExportToHTML(tables),
-            TableExportFormat.Markdown => ExportToMarkdown(tables),
-            _ => ExportToCSV(tables)
-        };
-    }
-
-    private Tensor<T> RunDetectionOnnx(Tensor<T> input)
-    {
-        if (_onnxDetectionSession is null)
-            throw new InvalidOperationException("Detection ONNX session not initialized.");
-        return RunOnnxInferenceWithSession(_onnxDetectionSession, input);
-    }
-
-    private Tensor<T> RunStructureOnnx(Tensor<T> input)
-    {
-        if (_onnxStructureSession is null)
-            throw new InvalidOperationException("Structure ONNX session not initialized.");
-        return RunOnnxInferenceWithSession(_onnxStructureSession, input);
-    }
-
-    private static Tensor<T> RunOnnxInferenceWithSession(InferenceSession session, Tensor<T> input)
-    {
-        if (session.InputMetadata.Count == 0)
-            throw new InvalidOperationException("ONNX session has no inputs.");
-        if (session.OutputMetadata.Count == 0)
-            throw new InvalidOperationException("ONNX session has no outputs.");
-
-        var inputName = session.InputMetadata.Keys.First();
-        var elementType = session.InputMetadata[inputName].ElementType.ToString();
-        var inputValue = OnnxTensorConverter.ToOnnxValue(inputName, input, elementType);
-        using var results = session.Run([inputValue]);
-        if (results.Count == 0)
-            throw new InvalidOperationException("ONNX session returned no outputs.");
-
-        if (results.Count == 1)
-        {
-            var result = results.FirstOrDefault()
-                ?? throw new InvalidOperationException("ONNX session returned no outputs.");
-            return OnnxTensorConverter.FromOnnxValue<T>(result)
-                ?? throw new InvalidOperationException("Failed to convert ONNX output tensor.");
-        }
-
-        var outputs = results
-            .Select(result => new OutputTensor(result.Name,
-                OnnxTensorConverter.FromOnnxValue<T>(result)
-                ?? throw new InvalidOperationException($"Failed to convert ONNX output tensor '{result.Name}'.")))
-            .ToList();
-
-        var boxesOutput = outputs.FirstOrDefault(o => NameMatches(o.Name, "pred_boxes", "boxes", "bbox"))
-            ?? outputs.FirstOrDefault(o => o.Tensor.Rank >= 2 && o.Tensor.Shape[^1] == 4);
-        var logitsOutput = outputs.FirstOrDefault(o => NameMatches(o.Name, "pred_logits", "logits", "class"))
-            ?? outputs.FirstOrDefault(o => o.Tensor.Rank >= 2 && o.Tensor.Shape[^1] > 4);
-
-        if (boxesOutput is null || logitsOutput is null)
-        {
-            var outputNames = string.Join(", ", outputs.Select(o => o.Name));
-            throw new InvalidOperationException(
-                $"ONNX session returned multiple outputs but pred_boxes/pred_logits were not found. Outputs: {outputNames}");
-        }
-
-        return CombineDetrOutputs(boxesOutput.Tensor, logitsOutput.Tensor);
-    }
-
-    private sealed class OutputTensor
-    {
-        public OutputTensor(string name, Tensor<T> tensor)
-        {
-            Name = name;
-            Tensor = tensor;
-        }
-
-        public string Name { get; }
-        public Tensor<T> Tensor { get; }
-    }
-
-    private static bool NameMatches(string name, params string[] tokens)
-    {
-        foreach (var token in tokens)
-        {
-            if (name.Contains(token, StringComparison.OrdinalIgnoreCase))
-                return true;
-        }
-
-        return false;
-    }
-
-    private static Tensor<T> CombineDetrOutputs(Tensor<T> boxes, Tensor<T> logits)
-    {
-        var boxesTensor = SqueezeBatch(boxes, "pred_boxes");
-        var logitsTensor = SqueezeBatch(logits, "pred_logits");
-
-        if (boxesTensor.Rank != 2 || logitsTensor.Rank != 2)
-            throw new InvalidOperationException("DETR outputs must be 2D tensors after removing batch dimension.");
-        if (boxesTensor.Shape[0] != logitsTensor.Shape[0])
-            throw new InvalidOperationException("pred_boxes and pred_logits must have the same number of queries.");
-
-        int numQueries = boxesTensor.Shape[0];
-        int boxDim = boxesTensor.Shape[1];
-        int classDim = logitsTensor.Shape[1];
-        var merged = new Tensor<T>([numQueries, boxDim + classDim]);
-
-        for (int i = 0; i < numQueries; i++)
-        {
-            for (int b = 0; b < boxDim; b++)
-                merged[i, b] = boxesTensor[i, b];
-            for (int c = 0; c < classDim; c++)
-                merged[i, boxDim + c] = logitsTensor[i, c];
-        }
-
-        return merged;
-    }
-
-    private static Tensor<T> SqueezeBatch(Tensor<T> tensor, string outputName)
-    {
-        if (tensor.Rank == 2)
-            return tensor;
-        if (tensor.Rank == 3 && tensor.Shape[0] == 1)
-            return tensor.Slice(0);
-        if (tensor.Rank == 3)
-            throw new InvalidOperationException($"{outputName} output has batch size {tensor.Shape[0]}; only batch size 1 is supported.");
-
-        throw new InvalidOperationException($"{outputName} output must be rank 2 or 3.");
-    }
-
-    private static (int Height, int Width) GetImageDimensions(Tensor<T> image)
-    {
-        if (image.Rank < 3)
-            throw new ArgumentException("Expected image tensor with rank 3 or 4.", nameof(image));
-
-        return (image.Shape[^2], image.Shape[^1]);
-    }
-
-    private static double Clamp(double value, double min, double max)
-    {
-        if (value < min)
-            return min;
-        if (value > max)
-            return max;
-        return value;
-    }
-
-    private static int Clamp(int value, int min, int max)
-    {
-        if (value < min)
-            return min;
-        if (value > max)
-            return max;
-        return value;
-    }
-
-    private IEnumerable<TableRegion<T>> ParseTableDetections(Tensor<T> output, Tensor<T> originalImage, double threshold)
-    {
-        var regions = new List<TableRegion<T>>();
-        var (imageHeight, imageWidth) = GetImageDimensions(originalImage);
-
-        // DETR output: [num_queries, 4 + num_classes] (bbox + class logits)
-        bool is1D = output.Shape.Length == 1;
-        int outputDim = output.Shape.Length > 1 ? output.Shape[1] : 4 + _numTableClasses; // 4 bbox + classes
-        int numDetections = is1D ? output.Length / outputDim : output.Shape[0];
-
-        for (int i = 0; i < numDetections; i++)
-        {
-            int baseIndex = is1D ? i * outputDim : 0;
-            if (is1D && baseIndex + outputDim > output.Length)
-                break;
-
-            // Get class probabilities
-            double tableProb = 0;
-            if (outputDim >= 6)
-            {
-                // Softmax over class logits
-                if (is1D && baseIndex + 5 >= output.Length)
-                    continue;
-
-                double bg = is1D
-                    ? NumOps.ToDouble(output[baseIndex + 4])
-                    : NumOps.ToDouble(output[i, 4]);
-                double table = is1D
-                    ? NumOps.ToDouble(output[baseIndex + 5])
-                    : NumOps.ToDouble(output[i, 5]);
-                double maxLogit = Math.Max(bg, table);
-                double sumExp = Math.Exp(bg - maxLogit) + Math.Exp(table - maxLogit);
-                tableProb = Math.Exp(table - maxLogit) / sumExp;
-            }
-
-            if (tableProb >= threshold)
-            {
-                if (is1D && baseIndex + 3 >= output.Length)
-                    continue;
-
-                // Get bounding box (DETR uses center_x, center_y, width, height format normalized to [0,1])
-                double cx = is1D
-                    ? NumOps.ToDouble(output[baseIndex + 0])
-                    : NumOps.ToDouble(output[i, 0]);
-                double cy = is1D
-                    ? NumOps.ToDouble(output[baseIndex + 1])
-                    : NumOps.ToDouble(output[i, 1]);
-                double w = is1D
-                    ? NumOps.ToDouble(output[baseIndex + 2])
-                    : NumOps.ToDouble(output[i, 2]);
-                double h = is1D
-                    ? NumOps.ToDouble(output[baseIndex + 3])
-                    : NumOps.ToDouble(output[i, 3]);
-
-                // Convert to [x1, y1, x2, y2] format
-                double x1 = (cx - w / 2) * imageWidth;
-                double y1 = (cy - h / 2) * imageHeight;
-                double x2 = (cx + w / 2) * imageWidth;
-                double y2 = (cy + h / 2) * imageHeight;
-
-                x1 = Clamp(x1, 0, imageWidth);
-                x2 = Clamp(x2, 0, imageWidth);
-                y1 = Clamp(y1, 0, imageHeight);
-                y2 = Clamp(y2, 0, imageHeight);
-
-                if (x2 <= x1 || y2 <= y1)
-                    continue;
-
-                var region = new TableRegion<T>
-                {
-                    BoundingBox = new Vector<T>([
-                        NumOps.FromDouble(x1),
-                        NumOps.FromDouble(y1),
-                        NumOps.FromDouble(x2),
-                        NumOps.FromDouble(y2)
-                    ]),
-                    Confidence = NumOps.FromDouble(tableProb),
-                    TableIndex = regions.Count,
-                    Image = CropTableImage(originalImage, x1, y1, x2, y2)
-                };
-
-                regions.Add(region);
-            }
-        }
-
-        return regions;
-    }
-
-    private TableStructureResult<T> ParseStructureOutput(Tensor<T> output, Tensor<T> tableImage, double threshold)
-    {
-        var cells = new List<TableCell<T>>();
-        var rows = new HashSet<int>();
-        var columns = new HashSet<int>();
-        var (imageHeight, imageWidth) = GetImageDimensions(tableImage);
-
-        bool is1D = output.Shape.Length == 1;
-        int outputDim = output.Shape.Length > 1 ? output.Shape[1] : 4 + _numStructureClasses; // 4 bbox + classes
-        int numDetections = is1D ? output.Length / outputDim : output.Shape[0];
-
-        for (int i = 0; i < numDetections; i++)
-        {
-            int baseIndex = is1D ? i * outputDim : 0;
-            if (is1D && baseIndex + outputDim > output.Length)
-                break;
-
-            // Find the class with highest probability
-            double maxProb = 0;
-            int maxClass = 0;
-            for (int c = 0; c < _numStructureClasses && (4 + c) < outputDim; c++)
-            {
-                if (is1D)
-                {
-                    int flatIndex = baseIndex + 4 + c;
-                    if (flatIndex < 0 || flatIndex >= output.Length)
-                        break;
-                    double prob = NumOps.ToDouble(output[flatIndex]);
-                    if (prob > maxProb)
-                    {
-                        maxProb = prob;
-                        maxClass = c;
-                    }
-                }
-                else
-                {
-                    double prob = NumOps.ToDouble(output[i, 4 + c]);
-                    if (prob > maxProb)
-                    {
-                        maxProb = prob;
-                        maxClass = c;
-                    }
-                }
-            }
-
-            if (maxProb >= threshold && maxClass > 0) // Skip background class
-            {
-                if (is1D && baseIndex + 3 >= output.Length)
-                    continue;
-
-                double cx = is1D
-                    ? NumOps.ToDouble(output[baseIndex + 0])
-                    : NumOps.ToDouble(output[i, 0]);
-                double cy = is1D
-                    ? NumOps.ToDouble(output[baseIndex + 1])
-                    : NumOps.ToDouble(output[i, 1]);
-                double w = is1D
-                    ? NumOps.ToDouble(output[baseIndex + 2])
-                    : NumOps.ToDouble(output[i, 2]);
-                double h = is1D
-                    ? NumOps.ToDouble(output[baseIndex + 3])
-                    : NumOps.ToDouble(output[i, 3]);
-
-                // Convert to pixel coordinates
-                double x1 = (cx - w / 2) * imageWidth;
-                double y1 = (cy - h / 2) * imageHeight;
-                double x2 = (cx + w / 2) * imageWidth;
-                double y2 = (cy + h / 2) * imageHeight;
-
-                x1 = Clamp(x1, 0, imageWidth);
-                x2 = Clamp(x2, 0, imageWidth);
-                y1 = Clamp(y1, 0, imageHeight);
-                y2 = Clamp(y2, 0, imageHeight);
-
-                if (x2 <= x1 || y2 <= y1)
-                    continue;
-
-                // Determine row/column based on position
-                int rowIdx = EstimateRowIndex(y1, y2);
-                int colIdx = EstimateColumnIndex(x1, x2);
-                rows.Add(rowIdx);
-                columns.Add(colIdx);
-
-                bool isHeader = maxClass == 4; // column header class
-                int rowSpan = maxClass == 6 ? 2 : 1; // spanning cell
-                int colSpan = maxClass == 6 ? 2 : 1;
-
-                cells.Add(new TableCell<T>
-                {
-                    Row = rowIdx,
-                    Column = colIdx,
-                    RowSpan = rowSpan,
-                    ColSpan = colSpan,
-                    BoundingBox = new Vector<T>([
-                        NumOps.FromDouble(x1),
-                        NumOps.FromDouble(y1),
-                        NumOps.FromDouble(x2),
-                        NumOps.FromDouble(y2)
-                    ]),
-                    IsHeader = isHeader,
-                    Confidence = NumOps.FromDouble(maxProb),
-                    Text = "" // Would be filled by OCR
-                });
-            }
-        }
-
-        return new TableStructureResult<T>
-        {
-            NumRows = rows.Count > 0 ? rows.Max() + 1 : 0,
-            NumColumns = columns.Count > 0 ? columns.Max() + 1 : 0,
-            Cells = cells,
-            HeaderRows = cells.Any(c => c.IsHeader) ? [0] : [],
-            HasBorders = true,
-            Confidence = cells.Count > 0
-                ? NumOps.FromDouble(cells.Average(c => NumOps.ToDouble(c.Confidence)))
-                : NumOps.Zero
-        };
-    }
-
-    private int EstimateRowIndex(double y1, double y2)
-    {
-        // Simple heuristic: divide image into grid
-        double centerY = (y1 + y2) / 2;
-        return (int)(centerY / 50); // Assume ~50px per row
-    }
-
-    private int EstimateColumnIndex(double x1, double x2)
-    {
-        double centerX = (x1 + x2) / 2;
-        return (int)(centerX / 100); // Assume ~100px per column
-    }
-
-    private Tensor<T>? CropTableImage(Tensor<T> image, double x1, double y1, double x2, double y2)
-    {
-        var (imageHeight, imageWidth) = GetImageDimensions(image);
-        int startX = Clamp((int)Math.Floor(x1), 0, imageWidth);
-        int startY = Clamp((int)Math.Floor(y1), 0, imageHeight);
-        int endX = Clamp((int)Math.Ceiling(x2), 0, imageWidth);
-        int endY = Clamp((int)Math.Ceiling(y2), 0, imageHeight);
-
-        int cropWidth = endX - startX;
-        int cropHeight = endY - startY;
-        if (cropWidth <= 0 || cropHeight <= 0)
-            return null;
-
-        if (image.Rank == 3)
-        {
-            int channels = image.Shape[0];
-            var cropped = new Tensor<T>([channels, cropHeight, cropWidth]);
-            for (int c = 0; c < channels; c++)
-            {
-                for (int y = 0; y < cropHeight; y++)
-                {
-                    int srcY = startY + y;
-                    for (int x = 0; x < cropWidth; x++)
-                    {
-                        int srcX = startX + x;
-                        cropped[c, y, x] = image[c, srcY, srcX];
-                    }
-                }
-            }
-            return cropped;
-        }
-
-        if (image.Rank == 4)
-        {
-            int batch = image.Shape[0];
-            int channels = image.Shape[1];
-            var cropped = new Tensor<T>([batch, channels, cropHeight, cropWidth]);
-            for (int b = 0; b < batch; b++)
-            {
-                for (int c = 0; c < channels; c++)
-                {
-                    for (int y = 0; y < cropHeight; y++)
-                    {
-                        int srcY = startY + y;
-                        for (int x = 0; x < cropWidth; x++)
-                        {
-                            int srcX = startX + x;
-                            cropped[b, c, y, x] = image[b, c, srcY, srcX];
-                        }
-                    }
-                }
-            }
-            return cropped;
-        }
-
-        return null;
-    }
-
-    #region Export Methods
-
-    private static string ExportToCSV(List<List<List<string>>> tables)
-    {
-        var sb = new System.Text.StringBuilder();
-        foreach (var table in tables)
-        {
-            foreach (var row in table)
-            {
-                sb.AppendLine(string.Join(",", row.Select(c => $"\"{c.Replace("\"", "\"\"")}\"")));
-            }
-            sb.AppendLine();
-        }
-        return sb.ToString();
-    }
-
-    private static string ExportToJSON(List<List<List<string>>> tables)
-    {
-        var payload = tables.Select(table => new { rows = table }).ToList();
-        var options = new System.Text.Json.JsonSerializerOptions
-        {
-            WriteIndented = true
-        };
-
-        return System.Text.Json.JsonSerializer.Serialize(payload, options);
-    }
-
-    private static string ExportToHTML(List<List<List<string>>> tables)
-    {
-        var sb = new System.Text.StringBuilder();
-        foreach (var table in tables)
-        {
-            sb.AppendLine("<table border=\"1\">");
-            foreach (var row in table)
-            {
-                sb.AppendLine("  <tr>");
-                foreach (var cell in row)
-                {
-                    sb.AppendLine($"    <td>{System.Net.WebUtility.HtmlEncode(cell)}</td>");
-                }
-                sb.AppendLine("  </tr>");
-            }
-            sb.AppendLine("</table>");
-            sb.AppendLine();
-        }
-        return sb.ToString();
-    }
-
-    private static string ExportToMarkdown(List<List<List<string>>> tables)
-    {
-        var sb = new System.Text.StringBuilder();
-        foreach (var table in tables)
-        {
-            if (table.Count == 0) continue;
-
-            // Header row
-            if (table.Count > 0)
-            {
-                var header = table[0].Select(EscapeMarkdownCell).ToList();
-                sb.AppendLine("| " + string.Join(" | ", header) + " |");
-                sb.AppendLine("| " + string.Join(" | ", header.Select(_ => "---")) + " |");
-            }
-
-            // Data rows
-            for (int r = 1; r < table.Count; r++)
-            {
-                var row = table[r].Select(EscapeMarkdownCell);
-                sb.AppendLine("| " + string.Join(" | ", row) + " |");
-            }
-            sb.AppendLine();
-        }
-        return sb.ToString();
-    }
-
-    private static string EscapeMarkdownCell(string value)
-    {
-        return value?.Replace("|", "\\|") ?? string.Empty;
-    }
-
-    #endregion
-
-    #endregion
-
-    #region IDocumentModel Implementation
-
-    /// <inheritdoc/>
-    public Tensor<T> EncodeDocument(Tensor<T> documentImage)
-    {
-        ValidateImageShape(documentImage);
-        var preprocessed = PreprocessDocument(documentImage);
-        return _useNativeMode ? Forward(preprocessed) : RunDetectionOnnx(preprocessed);
-    }
-
-    /// <inheritdoc/>
-    public void ValidateInputShape(Tensor<T> documentImage)
-    {
-        ValidateImageShape(documentImage);
-    }
-
-    /// <inheritdoc/>
-    public string GetModelSummary()
-    {
-        var sb = new System.Text.StringBuilder();
-        sb.AppendLine("TableTransformer Model Summary");
-        sb.AppendLine("==============================");
-        sb.AppendLine($"Mode: {(_useNativeMode ? "Native (Trainable)" : "ONNX (Inference)")}");
-        sb.AppendLine($"Architecture: DETR-style (Detection Transformer)");
-        sb.AppendLine();
-        sb.AppendLine("Transformer Configuration:");
-        sb.AppendLine($"  Hidden Dimension: {_hiddenDim}");
-        sb.AppendLine($"  Encoder Layers: {_numEncoderLayers}");
-        sb.AppendLine($"  Decoder Layers: {_numDecoderLayers}");
-        sb.AppendLine($"  Attention Heads: {_numHeads}");
-        sb.AppendLine($"  Object Queries: {_numQueries}");
-        sb.AppendLine();
-        sb.AppendLine($"Image Size: {ImageSize}x{ImageSize}");
-        sb.AppendLine($"Table Classes: {_numTableClasses}");
-        sb.AppendLine($"Structure Classes: {_numStructureClasses}");
-        sb.AppendLine($"Supports Bordered Tables: {SupportsBorderedTables}");
-        sb.AppendLine($"Supports Borderless Tables: {SupportsBorderlessTables}");
-        sb.AppendLine($"Supports Merged Cells: {SupportsMergedCells}");
-        sb.AppendLine($"Total Layers: {Layers.Count}");
-        return sb.ToString();
-    }
-
-    #endregion
-
-    #region Preprocessing
-
-    /// <summary>
-    /// Applies TableTransformer's industry-standard preprocessing: COCO/ImageNet normalization.
-    /// </summary>
-    /// <remarks>
-    /// TableTransformer uses COCO-style normalization with ImageNet mean=[0.485, 0.456, 0.406] and std=[0.229, 0.224, 0.225].
-    /// From the PubTables-1M paper (CVPR 2022).
-    /// </remarks>
-    protected override Tensor<T> ApplyDefaultPreprocessing(Tensor<T> rawImage)
-    {
-        var image = EnsureBatchDimension(rawImage);
-
-        int batchSize = image.Shape[0];
-        int channels = image.Shape[1];
-        int height = image.Shape[2];
-        int width = image.Shape[3];
-
-        var normalized = new Tensor<T>(image._shape);
-
-        // COCO/ImageNet normalization (industry standard for TableTransformer)
-        double[] means = [0.485, 0.456, 0.406];
-        double[] stds = [0.229, 0.224, 0.225];
-
-        // Pixel intensities are expected in [0,1]; clamp out-of-range values
-        // (over/under-exposed pixels, or callers passing un-normalized data) rather
-        // than rejecting them, so the model is robust to arbitrary inputs. Clamping
-        // — not min-max rescaling — is intentional: it keeps distinct-brightness
-        // inputs distinct after preprocessing (a 2× image still differs from the 1×),
-        // which the ScaledInput/LargerInput invariants depend on.
-        for (int b = 0; b < batchSize; b++)
-        {
-            for (int c = 0; c < channels; c++)
-            {
-                double mean = c < means.Length ? means[c] : 0.5;
-                double std = c < stds.Length ? stds[c] : 0.5;
-
-                for (int h = 0; h < height; h++)
-                {
-                    for (int w = 0; w < width; w++)
-                    {
-                        int idx = b * channels * height * width + c * height * width + h * width + w;
-                        double value = NumOps.ToDouble(image.Data.Span[idx]);
-                        value = Math.Max(0.0, Math.Min(1.0, value));
-                        normalized.Data.Span[idx] = NumOps.FromDouble((value - mean) / std);
-                    }
-                }
-            }
-        }
-
-        return normalized;
-    }
-
-    /// <summary>
-    /// Applies TableTransformer's industry-standard postprocessing: pass-through (DETR outputs are already in final format).
-    /// </summary>
-    protected override Tensor<T> ApplyDefaultPostprocessing(Tensor<T> modelOutput)
-    {
-        // DETR-style outputs are already in final format (bbox + class logits)
-        return modelOutput;
-    }
-
-    #endregion
-
-    #region Serialization
-
-    /// <inheritdoc/>
-    public override ModelMetadata<T> GetModelMetadata()
-    {
-        return new ModelMetadata<T>
-        {
-            Name = "TableTransformer",
-            Description = "DETR-style table detection and structure recognition (CVPR 2022)",
-            FeatureCount = _hiddenDim,
-            Complexity = _numEncoderLayers + _numDecoderLayers,
-            AdditionalInfo = new Dictionary<string, object>
-            {
-                { "hidden_dim", _hiddenDim },
-                { "num_encoder_layers", _numEncoderLayers },
-                { "num_decoder_layers", _numDecoderLayers },
-                { "num_heads", _numHeads },
-                { "num_queries", _numQueries },
-                { "num_table_classes", _numTableClasses },
-                { "num_structure_classes", _numStructureClasses },
-                { "image_size", ImageSize },
-                { "use_native_mode", _useNativeMode }
-            },
-            ModelData = SafeSerialize()
-        };
-    }
-
-    /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_hiddenDim);
-        writer.Write(_numEncoderLayers);
-        writer.Write(_numDecoderLayers);
-        writer.Write(_numHeads);
-        writer.Write(_numQueries);
-        writer.Write(_numTableClasses);
-        writer.Write(_numStructureClasses);
-        writer.Write(ImageSize);
-        writer.Write(_useNativeMode);
-        writer.Write(_onnxDetectionModelPath ?? string.Empty);
-        writer.Write(_onnxStructureModelPath ?? string.Empty);
-    }
-
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        int hiddenDim = reader.ReadInt32();
-        int numEncoderLayers = reader.ReadInt32();
-        int numDecoderLayers = reader.ReadInt32();
-        int numHeads = reader.ReadInt32();
-        int numQueries = reader.ReadInt32();
-        int numTableClasses = reader.ReadInt32();
-        int numStructureClasses = reader.ReadInt32();
-        int imageSize = reader.ReadInt32();
-        bool useNativeMode = reader.ReadBoolean();
-        string? detectionModelPath = null;
-        string? structureModelPath = null;
-        if (reader.BaseStream.Position < reader.BaseStream.Length)
-        {
-            detectionModelPath = reader.ReadString();
-            if (reader.BaseStream.Position < reader.BaseStream.Length)
-            {
-                structureModelPath = reader.ReadString();
-            }
-        }
-
-        _hiddenDim = hiddenDim;
-        _numEncoderLayers = numEncoderLayers;
-        _numDecoderLayers = numDecoderLayers;
-        _numHeads = numHeads;
-        _numQueries = numQueries;
-        _numTableClasses = numTableClasses;
-        _numStructureClasses = numStructureClasses;
-        _useNativeMode = useNativeMode;
-        ImageSize = imageSize;
-        if (!string.IsNullOrWhiteSpace(detectionModelPath))
-        {
-            _onnxDetectionModelPath = detectionModelPath;
-        }
-        else if (_useNativeMode)
-        {
-            _onnxDetectionModelPath = null;
-        }
-
-        if (!string.IsNullOrWhiteSpace(structureModelPath))
-        {
-            _onnxStructureModelPath = structureModelPath;
-        }
-        else if (_useNativeMode)
-        {
-            _onnxStructureModelPath = null;
-        }
-
-        if (_useNativeMode && _objectQueries is null)
-        {
-            InitializeObjectQueries();
-        }
-
-        if (!_useNativeMode)
-        {
-            if (!string.IsNullOrWhiteSpace(_onnxDetectionModelPath)
-                && !string.IsNullOrWhiteSpace(_onnxStructureModelPath))
-            {
-                InitializeOnnxSessions();
-            }
-            else if (_onnxDetectionSession is null || _onnxStructureSession is null)
-            {
-                throw new InvalidOperationException(
-                    "Missing ONNX model paths required to restore TableTransformer.");
-            }
-        }
-    }
-
-    /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (_useNativeMode)
-        {
-            return new TableTransformer<T>(
-                Architecture,
-                ImageSize,
-                _hiddenDim,
-                _numEncoderLayers,
-                _numDecoderLayers,
-                _numHeads,
-                _numQueries);
-        }
-
-        if (string.IsNullOrWhiteSpace(_onnxDetectionModelPath) || string.IsNullOrWhiteSpace(_onnxStructureModelPath))
-        {
-            throw new InvalidOperationException(
-                "Missing ONNX model paths required to clone TableTransformer.");
-        }
-
-        var detectionModelPath = _onnxDetectionModelPath
-            ?? throw new InvalidOperationException(
-                "Missing ONNX detection model path required to clone TableTransformer.");
-        var structureModelPath = _onnxStructureModelPath
-            ?? throw new InvalidOperationException(
-                "Missing ONNX structure model path required to clone TableTransformer.");
-
-        return new TableTransformer<T>(
-            Architecture,
-            detectionModelPath,
-            structureModelPath,
-            ImageSize,
-            _hiddenDim,
-            _numEncoderLayers,
-            _numDecoderLayers,
-            _numHeads,
-            _numQueries);
-    }
-
-    #endregion
-
-    #region NeuralNetworkBase Implementation
-
-    /// <inheritdoc/>
-    protected override Tensor<T> PredictCore(Tensor<T> input)
-    {
-        var preprocessed = PreprocessDocument(input);
-        return _useNativeMode ? Forward(preprocessed) : RunDetectionOnnx(preprocessed);
-    }
-
-    /// <inheritdoc/>
-    public override void Train(Tensor<T> input, Tensor<T> expectedOutput)
-    {
-        if (!_useNativeMode)
-        {
-            throw new NotSupportedException("Training is not supported in ONNX inference mode.");
-        }
-
-        SetTrainingMode(true);
-        try
-        {
-            // TrainWithTape runs forward + backward + the optimizer update (the same
-            // tape path the base Train uses). The previous code followed it with a
-            // manual CollectParameterGradients()/UpdateParameters() — a SECOND,
-            // redundant update whose flat per-parameter gradient vector length did
-            // not match GetParameters() (a layer's gradient count differs from its
-            // ParameterCount), throwing in Engine.Subtract once the forward stopped
-            // crashing. TrainWithTape owns the whole step.
-            // Pass the configured optimizer through. The two-argument overload left _optimizer
-            // assigned but never read, so training ran on the framework default instead of DETR's
-            // 1e-4 (Smock et al., 2022) and the memorization loss went from 0.0000 to 12.3652.
-            TrainWithTape(input, expectedOutput, _optimizer);
-        }
-        finally
-        {
-            SetTrainingMode(false);
-        }
-    }
-
-    // UpdateParameters applied a GRADIENT STEP, but its one-argument form is the value setter and every caller passes values -- the override corrupted the model. Removed under AIDN082.

-
-    /// <summary>
-    /// Parameters cannot be written while the model is backed by a loaded ONNX graph: the weights
-    /// belong to that graph, not to this instance.
-    /// </summary>
-    /// <remarks>
-    /// Replaces a hand-written throw that used to sit inside UpdateParameters. The base checks this
-    /// on every mutating entry point rather than the one member the throw happened to guard, and
-    /// reading -- ParameterCount and GetParameters -- stays available either way.
-    /// </remarks>
+using AiDotNet.Attributes;
+using AiDotNet.Document.Interfaces;
+using AiDotNet.Document.Options;
+using AiDotNet.Enums;
+using AiDotNet.Helpers;
+using AiDotNet.Interfaces;
+using AiDotNet.LinearAlgebra;
+using AiDotNet.LossFunctions;
+using AiDotNet.NeuralNetworks;
+using AiDotNet.NeuralNetworks.Layers;
+using AiDotNet.Onnx;
+using AiDotNet.Optimizers;
+using Microsoft.ML.OnnxRuntime;
+
+namespace AiDotNet.Document.Analysis.TableDetection;
+
+/// <summary>
+/// TableTransformer for table detection and structure recognition using DETR-style architecture.
+/// </summary>
+/// <typeparam name="T">The numeric type used for calculations.</typeparam>
+/// <remarks>
+/// <para>
+/// TableTransformer is based on the DETR (DEtection TRansformer) architecture, adapted for
+/// table detection and table structure recognition. It can detect tables in documents and
+/// identify their internal structure (rows, columns, cells, headers).
+/// </para>
+/// <para>
+/// <b>For Beginners:</b> TableTransformer helps computers understand tables in documents.
+/// It can:
+/// 1. Find where tables are located in a page (table detection)
+/// 2. Identify the structure within tables - rows, columns, and cells (structure recognition)
+/// 3. Handle both bordered and borderless tables
+///
+/// Example usage:
+/// <code>
+/// var tableModel = new TableTransformer&lt;float&gt;(architecture);
+/// var tables = tableModel.DetectTables(documentImage);
+/// foreach (var table in tables)
+/// {
+///     var structure = tableModel.RecognizeStructure(table.Image);
+///     Console.WriteLine($"Table has {structure.NumRows} rows and {structure.NumColumns} columns");
+/// }
+/// </code>
+/// </para>
+/// <para>
+/// <b>Reference:</b> "PubTables-1M: Towards Comprehensive Table Extraction from Unstructured Documents" (CVPR 2022)
+/// https://arxiv.org/abs/2110.00061
+/// </para>
+/// </remarks>
+[ModelDomain(ModelDomain.Vision)]
+[ModelCategory(ModelCategory.NeuralNetwork)]
+[ModelCategory(ModelCategory.Transformer)]
+[ModelTask(ModelTask.Detection)]
+[ModelTask(ModelTask.Segmentation)]
+[ModelComplexity(ModelComplexity.High)]
+[ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
+[ResearchPaper("PubTables-1M: Towards Comprehensive Table Extraction from Unstructured Documents", "https://doi.org/10.48550/arXiv.2110.00061", Year = 2022, Authors = "Brandon Smock, Rohith Pesala, Robin Abraham")]
+public partial class TableTransformer<T> : DocumentNeuralNetworkBase<T>, ITableExtractor<T>
+{
+    private readonly TableTransformerOptions _options;
+
+    /// <inheritdoc/>
+    public override ModelOptions GetOptions() => _options;
+
+    #region Fields
+
+    private bool _useNativeMode;
+    private InferenceSession? _onnxDetectionSession;
+    private InferenceSession? _onnxStructureSession;
+    private string? _onnxDetectionModelPath;
+    private string? _onnxStructureModelPath;
+    private readonly IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>> _optimizer;
+    private int _hiddenDim;
+    private int _numEncoderLayers;
+    private int _numDecoderLayers;
+    private int _numHeads;
+    private int _numQueries;
+    private int _numTableClasses;
+    private int _numStructureClasses;
+
+    // Native mode layers
+    private readonly List<ILayer<T>> _backboneLayers = [];
+    private readonly List<ILayer<T>> _encoderLayers = [];
+    private readonly List<ILayer<T>> _decoderLayers = [];
+    private readonly List<ILayer<T>> _detectionHead = [];
+    private readonly List<ILayer<T>> _structureHead = [];
+
+    // Learnable object queries
+    [AiDotNet.Attributes.TrainableParameter]
+    private Tensor<T>? _objectQueries;
+
+    // Task mode - tracks whether we're doing detection or structure recognition
+#pragma warning disable CS0414 // Field is assigned but its value is never used - kept for future use in task-specific processing
+    private TableTransformerTask _currentTask = TableTransformerTask.Detection;
+#pragma warning restore CS0414
+
+    #endregion
+
+    #region Properties
+
+    /// <inheritdoc/>
+    public override DocumentType SupportedDocumentTypes => DocumentType.All;
+
+    /// <inheritdoc/>
+    public override bool RequiresOCR => false;
+
+    /// <inheritdoc/>
+    public int ExpectedImageSize => ImageSize;
+
+    /// <inheritdoc/>
+    public bool SupportsBorderedTables => true;
+
+    /// <inheritdoc/>
+    public bool SupportsBorderlessTables => true;
+
+    /// <inheritdoc/>
+    public bool SupportsMergedCells => true;
+
+    /// <summary>
+    /// Gets the number of object queries used in DETR decoder.
+    /// </summary>
+    public int NumQueries => _numQueries;
+
+    #endregion
+
+    #region Constructors
+
+    /// <summary>
+    /// Creates a TableTransformer model using pre-trained ONNX models for inference.
+    /// </summary>
+    /// <param name="architecture">The neural network architecture.</param>
+    /// <param name="detectionModelPath">Path to the table detection ONNX model.</param>
+    /// <param name="structureModelPath">Path to the structure recognition ONNX model.</param>
+    /// <param name="imageSize">Expected input image size (default: 800).</param>
+    /// <param name="hiddenDim">Transformer hidden dimension (default: 256).</param>
+    /// <param name="numEncoderLayers">Number of encoder layers (default: 6).</param>
+    /// <param name="numDecoderLayers">Number of decoder layers (default: 6).</param>
+    /// <param name="numHeads">Number of attention heads (default: 8).</param>
+    /// <param name="numQueries">Number of object queries (default: 100).</param>
+    /// <param name="optimizer">Optimizer for training (optional).</param>
+    /// <param name="lossFunction">Loss function (optional).</param>
+    /// <exception cref="ArgumentNullException">Thrown if model paths are null.</exception>
+    /// <exception cref="FileNotFoundException">Thrown if ONNX model files don't exist.</exception>
+    public TableTransformer(
+        NeuralNetworkArchitecture<T> architecture,
+        string detectionModelPath,
+        string structureModelPath,
+        int imageSize = 800,
+        int hiddenDim = 256,
+        int numEncoderLayers = 6,
+        int numDecoderLayers = 6,
+        int numHeads = 8,
+        int numQueries = 100,
+        IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? optimizer = null,
+        ILossFunction<T>? lossFunction = null,
+        TableTransformerOptions? options = null)
+        : base(architecture, lossFunction ?? new CrossEntropyWithLogitsLoss<T>(), 1.0)
+    {
+        _options = options ?? new TableTransformerOptions();
+        Options = _options;
+
+        if (string.IsNullOrWhiteSpace(detectionModelPath))
+            throw new ArgumentNullException(nameof(detectionModelPath));
+        if (string.IsNullOrWhiteSpace(structureModelPath))
+            throw new ArgumentNullException(nameof(structureModelPath));
+        if (!File.Exists(detectionModelPath))
+            throw new FileNotFoundException($"Detection model not found: {detectionModelPath}", detectionModelPath);
+        if (!File.Exists(structureModelPath))
+            throw new FileNotFoundException($"Structure model not found: {structureModelPath}", structureModelPath);
+
+        _useNativeMode = false;
+        _hiddenDim = hiddenDim;
+        _numEncoderLayers = numEncoderLayers;
+        _numDecoderLayers = numDecoderLayers;
+        _numHeads = numHeads;
+        _numQueries = numQueries;
+        _numTableClasses = 2;       // background, table
+        _numStructureClasses = 7;   // background, table, column, row, column header, projected row header, spanning cell
+        // TableTransformer is a DETR-based detector (Smock et al. 2022). DETR fine-tunes at 1e-4 with
+        // gradient-norm clipping at 0.1-1.0; built bare, the optimizer ran on framework defaults.
+        _optimizer = optimizer ?? new AdamOptimizer<T, Tensor<T>, Tensor<T>>(this,
+            new AiDotNet.Models.Options.AdamOptimizerOptions<T, Tensor<T>, Tensor<T>>
+            {
+                InitialLearningRate = 0.0001,
+                EnableGradientClipping = true,
+                MaxGradientNorm = 1.0,
+            });
+
+        ImageSize = imageSize;
+
+        _onnxDetectionModelPath = detectionModelPath;
+        _onnxStructureModelPath = structureModelPath;
+        InitializeOnnxSessions();
+
+        InitializeLayers();
+    }
+
+    /// <summary>
+    /// Creates a TableTransformer model using native layers for training and inference.
+    /// </summary>
+    /// <param name="architecture">The neural network architecture.</param>
+    /// <param name="imageSize">Expected input image size (default: 800).</param>
+    /// <param name="hiddenDim">Transformer hidden dimension (default: 256).</param>
+    /// <param name="numEncoderLayers">Number of encoder layers (default: 6).</param>
+    /// <param name="numDecoderLayers">Number of decoder layers (default: 6).</param>
+    /// <param name="numHeads">Number of attention heads (default: 8).</param>
+    /// <param name="numQueries">Number of object queries (default: 100).</param>
+    /// <param name="optimizer">Optimizer for training (optional).</param>
+    /// <param name="lossFunction">Loss function (optional).</param>
+    /// <remarks>
+    /// <para>
+    /// <b>Default Configuration (from CVPR 2022 paper):</b>
+    /// - Backbone: ResNet-18 (for detection) or ResNet-50 (for structure)
+    /// - Transformer: 6 encoder layers, 6 decoder layers, 256 hidden dim
+    /// - Object queries: 100
+    /// - Image size: 800
+    /// </para>
+    /// </remarks>
+    public TableTransformer(
+        NeuralNetworkArchitecture<T> architecture,
+        int imageSize = 800,
+        int hiddenDim = 256,
+        int numEncoderLayers = 6,
+        int numDecoderLayers = 6,
+        int numHeads = 8,
+        int numQueries = 100,
+        IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? optimizer = null,
+        ILossFunction<T>? lossFunction = null,
+        TableTransformerOptions? options = null)
+        : base(architecture, lossFunction ?? new CrossEntropyWithLogitsLoss<T>(), 1.0)
+    {
+        _options = options ?? new TableTransformerOptions();
+        Options = _options;
+
+        _useNativeMode = true;
+        _hiddenDim = hiddenDim;
+        _numEncoderLayers = numEncoderLayers;
+        _numDecoderLayers = numDecoderLayers;
+        _numHeads = numHeads;
+        _numQueries = numQueries;
+        _numTableClasses = 2;
+        _numStructureClasses = 7;
+        // TableTransformer is a DETR-based detector (Smock et al. 2022). DETR fine-tunes at 1e-4 with
+        // gradient-norm clipping at 0.1-1.0; built bare, the optimizer ran on framework defaults.
+        _optimizer = optimizer ?? new AdamOptimizer<T, Tensor<T>, Tensor<T>>(this,
+            new AiDotNet.Models.Options.AdamOptimizerOptions<T, Tensor<T>, Tensor<T>>
+            {
+                InitialLearningRate = 0.0001,
+                EnableGradientClipping = true,
+                MaxGradientNorm = 1.0,
+            });
+
+        ImageSize = imageSize;
+
+        InitializeLayers();
+        InitializeObjectQueries();
+    }
+
+    #endregion
+
+    #region Initialization
+
+    /// <inheritdoc/>
+    protected override void InitializeLayers()
+    {
+        if (!_useNativeMode)
+        {
+            return;
+        }
+
+        // Check if user provided custom layers
+        if (Architecture.Layers is not null && Architecture.Layers.Count > 0)
+        {
+            Layers.AddRange(Architecture.Layers);
+            ValidateCustomLayers(Layers);
+            return;
+        }
+
+        // Use LayerHelper to create default TableTransformer layers
+        Layers.AddRange(LayerHelper<T>.CreateDefaultTableTransformerLayers(
+            imageSize: ImageSize,
+            hiddenDim: _hiddenDim,
+            numEncoderLayers: _numEncoderLayers,
+            numDecoderLayers: _numDecoderLayers,
+            numHeads: _numHeads,
+            numQueries: _numQueries,
+            numStructureClasses: _numStructureClasses));
+    }
+
+    private void InitializeObjectQueries()
+    {
+        var random = RandomHelper.CreateSeededRandom(42);
+        _objectQueries = Tensor<T>.CreateDefault([_numQueries, _hiddenDim], NumOps.Zero);
+
+        // Xavier initialization for object queries
+        double scale = Math.Sqrt(2.0 / (_numQueries + _hiddenDim));
+        for (int i = 0; i < _objectQueries.Data.Length; i++)
+        {
+            double u1 = 1.0 - random.NextDouble();
+            double u2 = 1.0 - random.NextDouble();
+            double randStdNormal = Math.Sqrt(-2.0 * Math.Log(u1)) * Math.Sin(2.0 * Math.PI * u2);
+            _objectQueries.Data.Span[i] = NumOps.FromDouble(randStdNormal * scale);
+        }
+    }
+
+    private void InitializeOnnxSessions()
+    {
+        if (string.IsNullOrWhiteSpace(_onnxDetectionModelPath))
+            throw new InvalidOperationException("Detection ONNX model path is not set.");
+        if (string.IsNullOrWhiteSpace(_onnxStructureModelPath))
+            throw new InvalidOperationException("Structure ONNX model path is not set.");
+        if (!File.Exists(_onnxDetectionModelPath))
+            throw new FileNotFoundException($"Detection model not found: {_onnxDetectionModelPath}", _onnxDetectionModelPath);
+        if (!File.Exists(_onnxStructureModelPath))
+            throw new FileNotFoundException($"Structure model not found: {_onnxStructureModelPath}", _onnxStructureModelPath);
+
+        _onnxDetectionSession?.Dispose();
+        _onnxStructureSession?.Dispose();
+        _onnxDetectionSession = new InferenceSession(_onnxDetectionModelPath);
+        _onnxStructureSession = new InferenceSession(_onnxStructureModelPath);
+    }
+
+    #endregion
+
+    #region ITableExtractor Implementation
+
+    /// <inheritdoc/>
+    public IEnumerable<TableRegion<T>> DetectTables(Tensor<T> documentImage)
+    {
+        return DetectTables(documentImage, 0.5);
+    }
+
+    /// <summary>
+    /// Detects tables with a custom confidence threshold.
+    /// </summary>
+    public IEnumerable<TableRegion<T>> DetectTables(Tensor<T> documentImage, double confidenceThreshold)
+    {
+        ValidateImageShape(documentImage);
+
+        _currentTask = TableTransformerTask.Detection;
+
+        var preprocessed = PreprocessDocument(documentImage);
+        var output = _useNativeMode
+            ? Forward(preprocessed)
+            : RunDetectionOnnx(preprocessed);
+
+        return ParseTableDetections(output, documentImage, confidenceThreshold);
+    }
+
+    /// <inheritdoc/>
+    public TableStructureResult<T> RecognizeStructure(Tensor<T> tableImage)
+    {
+        return RecognizeStructure(tableImage, 0.5);
+    }
+
+    /// <summary>
+    /// Recognizes table structure with a custom confidence threshold.
+    /// </summary>
+    public TableStructureResult<T> RecognizeStructure(Tensor<T> tableImage, double confidenceThreshold)
+    {
+        ValidateImageShape(tableImage);
+
+        _currentTask = TableTransformerTask.Structure;
+
+        var preprocessed = PreprocessDocument(tableImage);
+        var output = _useNativeMode
+            ? Forward(preprocessed)
+            : RunStructureOnnx(preprocessed);
+
+        return ParseStructureOutput(output, tableImage, confidenceThreshold);
+    }
+
+    /// <inheritdoc/>
+    public IEnumerable<List<List<string>>> ExtractTableContent(Tensor<T> documentImage)
+    {
+        var tables = DetectTables(documentImage);
+
+        foreach (var table in tables)
+        {
+            if (table.Image is not null)
+            {
+                var structure = RecognizeStructure(table.Image);
+                yield return structure.ToStringGrid();
+            }
+        }
+    }
+
+    /// <inheritdoc/>
+    public string ExportTables(Tensor<T> documentImage, TableExportFormat format)
+    {
+        var tables = ExtractTableContent(documentImage).ToList();
+
+        return format switch
+        {
+            TableExportFormat.CSV => ExportToCSV(tables),
+            TableExportFormat.JSON => ExportToJSON(tables),
+            TableExportFormat.HTML => ExportToHTML(tables),
+            TableExportFormat.Markdown => ExportToMarkdown(tables),
+            _ => ExportToCSV(tables)
+        };
+    }
+
+    private Tensor<T> RunDetectionOnnx(Tensor<T> input)
+    {
+        if (_onnxDetectionSession is null)
+            throw new InvalidOperationException("Detection ONNX session not initialized.");
+        return RunOnnxInferenceWithSession(_onnxDetectionSession, input);
+    }
+
+    private Tensor<T> RunStructureOnnx(Tensor<T> input)
+    {
+        if (_onnxStructureSession is null)
+            throw new InvalidOperationException("Structure ONNX session not initialized.");
+        return RunOnnxInferenceWithSession(_onnxStructureSession, input);
+    }
+
+    private static Tensor<T> RunOnnxInferenceWithSession(InferenceSession session, Tensor<T> input)
+    {
+        if (session.InputMetadata.Count == 0)
+            throw new InvalidOperationException("ONNX session has no inputs.");
+        if (session.OutputMetadata.Count == 0)
+            throw new InvalidOperationException("ONNX session has no outputs.");
+
+        var inputName = session.InputMetadata.Keys.First();
+        var elementType = session.InputMetadata[inputName].ElementType.ToString();
+        var inputValue = OnnxTensorConverter.ToOnnxValue(inputName, input, elementType);
+        using var results = session.Run([inputValue]);
+        if (results.Count == 0)
+            throw new InvalidOperationException("ONNX session returned no outputs.");
+
+        if (results.Count == 1)
+        {
+            var result = results.FirstOrDefault()
+                ?? throw new InvalidOperationException("ONNX session returned no outputs.");
+            return OnnxTensorConverter.FromOnnxValue<T>(result)
+                ?? throw new InvalidOperationException("Failed to convert ONNX output tensor.");
+        }
+
+        var outputs = results
+            .Select(result => new OutputTensor(result.Name,
+                OnnxTensorConverter.FromOnnxValue<T>(result)
+                ?? throw new InvalidOperationException($"Failed to convert ONNX output tensor '{result.Name}'.")))
+            .ToList();
+
+        var boxesOutput = outputs.FirstOrDefault(o => NameMatches(o.Name, "pred_boxes", "boxes", "bbox"))
+            ?? outputs.FirstOrDefault(o => o.Tensor.Rank >= 2 && o.Tensor.Shape[^1] == 4);
+        var logitsOutput = outputs.FirstOrDefault(o => NameMatches(o.Name, "pred_logits", "logits", "class"))
+            ?? outputs.FirstOrDefault(o => o.Tensor.Rank >= 2 && o.Tensor.Shape[^1] > 4);
+
+        if (boxesOutput is null || logitsOutput is null)
+        {
+            var outputNames = string.Join(", ", outputs.Select(o => o.Name));
+            throw new InvalidOperationException(
+                $"ONNX session returned multiple outputs but pred_boxes/pred_logits were not found. Outputs: {outputNames}");
+        }
+
+        return CombineDetrOutputs(boxesOutput.Tensor, logitsOutput.Tensor);
+    }
+
+    private sealed class OutputTensor
+    {
+        public OutputTensor(string name, Tensor<T> tensor)
+        {
+            Name = name;
+            Tensor = tensor;
+        }
+
+        public string Name { get; }
+        public Tensor<T> Tensor { get; }
+    }
+
+    private static bool NameMatches(string name, params string[] tokens)
+    {
+        foreach (var token in tokens)
+        {
+            if (name.Contains(token, StringComparison.OrdinalIgnoreCase))
+                return true;
+        }
+
+        return false;
+    }
+
+    private static Tensor<T> CombineDetrOutputs(Tensor<T> boxes, Tensor<T> logits)
+    {
+        var boxesTensor = SqueezeBatch(boxes, "pred_boxes");
+        var logitsTensor = SqueezeBatch(logits, "pred_logits");
+
+        if (boxesTensor.Rank != 2 || logitsTensor.Rank != 2)
+            throw new InvalidOperationException("DETR outputs must be 2D tensors after removing batch dimension.");
+        if (boxesTensor.Shape[0] != logitsTensor.Shape[0])
+            throw new InvalidOperationException("pred_boxes and pred_logits must have the same number of queries.");
+
+        int numQueries = boxesTensor.Shape[0];
+        int boxDim = boxesTensor.Shape[1];
+        int classDim = logitsTensor.Shape[1];
+        var merged = new Tensor<T>([numQueries, boxDim + classDim]);
+
+        for (int i = 0; i < numQueries; i++)
+        {
+            for (int b = 0; b < boxDim; b++)
+                merged[i, b] = boxesTensor[i, b];
+            for (int c = 0; c < classDim; c++)
+                merged[i, boxDim + c] = logitsTensor[i, c];
+        }
+
+        return merged;
+    }
+
+    private static Tensor<T> SqueezeBatch(Tensor<T> tensor, string outputName)
+    {
+        if (tensor.Rank == 2)
+            return tensor;
+        if (tensor.Rank == 3 && tensor.Shape[0] == 1)
+            return tensor.Slice(0);
+        if (tensor.Rank == 3)
+            throw new InvalidOperationException($"{outputName} output has batch size {tensor.Shape[0]}; only batch size 1 is supported.");
+
+        throw new InvalidOperationException($"{outputName} output must be rank 2 or 3.");
+    }
+
+    private static (int Height, int Width) GetImageDimensions(Tensor<T> image)
+    {
+        if (image.Rank < 3)
+            throw new ArgumentException("Expected image tensor with rank 3 or 4.", nameof(image));
+
+        return (image.Shape[^2], image.Shape[^1]);
+    }
+
+    private static double Clamp(double value, double min, double max)
+    {
+        if (value < min)
+            return min;
+        if (value > max)
+            return max;
+        return value;
+    }
+
+    private static int Clamp(int value, int min, int max)
+    {
+        if (value < min)
+            return min;
+        if (value > max)
+            return max;
+        return value;
+    }
+
+    private IEnumerable<TableRegion<T>> ParseTableDetections(Tensor<T> output, Tensor<T> originalImage, double threshold)
+    {
+        var regions = new List<TableRegion<T>>();
+        var (imageHeight, imageWidth) = GetImageDimensions(originalImage);
+
+        // DETR output: [num_queries, 4 + num_classes] (bbox + class logits)
+        bool is1D = output.Shape.Length == 1;
+        int outputDim = output.Shape.Length > 1 ? output.Shape[1] : 4 + _numTableClasses; // 4 bbox + classes
+        int numDetections = is1D ? output.Length / outputDim : output.Shape[0];
+
+        for (int i = 0; i < numDetections; i++)
+        {
+            int baseIndex = is1D ? i * outputDim : 0;
+            if (is1D && baseIndex + outputDim > output.Length)
+                break;
+
+            // Get class probabilities
+            double tableProb = 0;
+            if (outputDim >= 6)
+            {
+                // Softmax over class logits
+                if (is1D && baseIndex + 5 >= output.Length)
+                    continue;
+
+                double bg = is1D
+                    ? NumOps.ToDouble(output[baseIndex + 4])
+                    : NumOps.ToDouble(output[i, 4]);
+                double table = is1D
+                    ? NumOps.ToDouble(output[baseIndex + 5])
+                    : NumOps.ToDouble(output[i, 5]);
+                double maxLogit = Math.Max(bg, table);
+                double sumExp = Math.Exp(bg - maxLogit) + Math.Exp(table - maxLogit);
+                tableProb = Math.Exp(table - maxLogit) / sumExp;
+            }
+
+            if (tableProb >= threshold)
+            {
+                if (is1D && baseIndex + 3 >= output.Length)
+                    continue;
+
+                // Get bounding box (DETR uses center_x, center_y, width, height format normalized to [0,1])
+                double cx = is1D
+                    ? NumOps.ToDouble(output[baseIndex + 0])
+                    : NumOps.ToDouble(output[i, 0]);
+                double cy = is1D
+                    ? NumOps.ToDouble(output[baseIndex + 1])
+                    : NumOps.ToDouble(output[i, 1]);
+                double w = is1D
+                    ? NumOps.ToDouble(output[baseIndex + 2])
+                    : NumOps.ToDouble(output[i, 2]);
+                double h = is1D
+                    ? NumOps.ToDouble(output[baseIndex + 3])
+                    : NumOps.ToDouble(output[i, 3]);
+
+                // Convert to [x1, y1, x2, y2] format
+                double x1 = (cx - w / 2) * imageWidth;
+                double y1 = (cy - h / 2) * imageHeight;
+                double x2 = (cx + w / 2) * imageWidth;
+                double y2 = (cy + h / 2) * imageHeight;
+
+                x1 = Clamp(x1, 0, imageWidth);
+                x2 = Clamp(x2, 0, imageWidth);
+                y1 = Clamp(y1, 0, imageHeight);
+                y2 = Clamp(y2, 0, imageHeight);
+
+                if (x2 <= x1 || y2 <= y1)
+                    continue;
+
+                var region = new TableRegion<T>
+                {
+                    BoundingBox = new Vector<T>([
+                        NumOps.FromDouble(x1),
+                        NumOps.FromDouble(y1),
+                        NumOps.FromDouble(x2),
+                        NumOps.FromDouble(y2)
+                    ]),
+                    Confidence = NumOps.FromDouble(tableProb),
+                    TableIndex = regions.Count,
+                    Image = CropTableImage(originalImage, x1, y1, x2, y2)
+                };
+
+                regions.Add(region);
+            }
+        }
+
+        return regions;
+    }
+
+    private TableStructureResult<T> ParseStructureOutput(Tensor<T> output, Tensor<T> tableImage, double threshold)
+    {
+        var cells = new List<TableCell<T>>();
+        var rows = new HashSet<int>();
+        var columns = new HashSet<int>();
+        var (imageHeight, imageWidth) = GetImageDimensions(tableImage);
+
+        bool is1D = output.Shape.Length == 1;
+        int outputDim = output.Shape.Length > 1 ? output.Shape[1] : 4 + _numStructureClasses; // 4 bbox + classes
+        int numDetections = is1D ? output.Length / outputDim : output.Shape[0];
+
+        for (int i = 0; i < numDetections; i++)
+        {
+            int baseIndex = is1D ? i * outputDim : 0;
+            if (is1D && baseIndex + outputDim > output.Length)
+                break;
+
+            // Find the class with highest probability
+            double maxProb = 0;
+            int maxClass = 0;
+            for (int c = 0; c < _numStructureClasses && (4 + c) < outputDim; c++)
+            {
+                if (is1D)
+                {
+                    int flatIndex = baseIndex + 4 + c;
+                    if (flatIndex < 0 || flatIndex >= output.Length)
+                        break;
+                    double prob = NumOps.ToDouble(output[flatIndex]);
+                    if (prob > maxProb)
+                    {
+                        maxProb = prob;
+                        maxClass = c;
+                    }
+                }
+                else
+                {
+                    double prob = NumOps.ToDouble(output[i, 4 + c]);
+                    if (prob > maxProb)
+                    {
+                        maxProb = prob;
+                        maxClass = c;
+                    }
+                }
+            }
+
+            if (maxProb >= threshold && maxClass > 0) // Skip background class
+            {
+                if (is1D && baseIndex + 3 >= output.Length)
+                    continue;
+
+                double cx = is1D
+                    ? NumOps.ToDouble(output[baseIndex + 0])
+                    : NumOps.ToDouble(output[i, 0]);
+                double cy = is1D
+                    ? NumOps.ToDouble(output[baseIndex + 1])
+                    : NumOps.ToDouble(output[i, 1]);
+                double w = is1D
+                    ? NumOps.ToDouble(output[baseIndex + 2])
+                    : NumOps.ToDouble(output[i, 2]);
+                double h = is1D
+                    ? NumOps.ToDouble(output[baseIndex + 3])
+                    : NumOps.ToDouble(output[i, 3]);
+
+                // Convert to pixel coordinates
+                double x1 = (cx - w / 2) * imageWidth;
+                double y1 = (cy - h / 2) * imageHeight;
+                double x2 = (cx + w / 2) * imageWidth;
+                double y2 = (cy + h / 2) * imageHeight;
+
+                x1 = Clamp(x1, 0, imageWidth);
+                x2 = Clamp(x2, 0, imageWidth);
+                y1 = Clamp(y1, 0, imageHeight);
+                y2 = Clamp(y2, 0, imageHeight);
+
+                if (x2 <= x1 || y2 <= y1)
+                    continue;
+
+                // Determine row/column based on position
+                int rowIdx = EstimateRowIndex(y1, y2);
+                int colIdx = EstimateColumnIndex(x1, x2);
+                rows.Add(rowIdx);
+                columns.Add(colIdx);
+
+                bool isHeader = maxClass == 4; // column header class
+                int rowSpan = maxClass == 6 ? 2 : 1; // spanning cell
+                int colSpan = maxClass == 6 ? 2 : 1;
+
+                cells.Add(new TableCell<T>
+                {
+                    Row = rowIdx,
+                    Column = colIdx,
+                    RowSpan = rowSpan,
+                    ColSpan = colSpan,
+                    BoundingBox = new Vector<T>([
+                        NumOps.FromDouble(x1),
+                        NumOps.FromDouble(y1),
+                        NumOps.FromDouble(x2),
+                        NumOps.FromDouble(y2)
+                    ]),
+                    IsHeader = isHeader,
+                    Confidence = NumOps.FromDouble(maxProb),
+                    Text = "" // Would be filled by OCR
+                });
+            }
+        }
+
+        return new TableStructureResult<T>
+        {
+            NumRows = rows.Count > 0 ? rows.Max() + 1 : 0,
+            NumColumns = columns.Count > 0 ? columns.Max() + 1 : 0,
+            Cells = cells,
+            HeaderRows = cells.Any(c => c.IsHeader) ? [0] : [],
+            HasBorders = true,
+            Confidence = cells.Count > 0
+                ? NumOps.FromDouble(cells.Average(c => NumOps.ToDouble(c.Confidence)))
+                : NumOps.Zero
+        };
+    }
+
+    private int EstimateRowIndex(double y1, double y2)
+    {
+        // Simple heuristic: divide image into grid
+        double centerY = (y1 + y2) / 2;
+        return (int)(centerY / 50); // Assume ~50px per row
+    }
+
+    private int EstimateColumnIndex(double x1, double x2)
+    {
+        double centerX = (x1 + x2) / 2;
+        return (int)(centerX / 100); // Assume ~100px per column
+    }
+
+    private Tensor<T>? CropTableImage(Tensor<T> image, double x1, double y1, double x2, double y2)
+    {
+        var (imageHeight, imageWidth) = GetImageDimensions(image);
+        int startX = Clamp((int)Math.Floor(x1), 0, imageWidth);
+        int startY = Clamp((int)Math.Floor(y1), 0, imageHeight);
+        int endX = Clamp((int)Math.Ceiling(x2), 0, imageWidth);
+        int endY = Clamp((int)Math.Ceiling(y2), 0, imageHeight);
+
+        int cropWidth = endX - startX;
+        int cropHeight = endY - startY;
+        if (cropWidth <= 0 || cropHeight <= 0)
+            return null;
+
+        if (image.Rank == 3)
+        {
+            int channels = image.Shape[0];
+            var cropped = new Tensor<T>([channels, cropHeight, cropWidth]);
+            for (int c = 0; c < channels; c++)
+            {
+                for (int y = 0; y < cropHeight; y++)
+                {
+                    int srcY = startY + y;
+                    for (int x = 0; x < cropWidth; x++)
+                    {
+                        int srcX = startX + x;
+                        cropped[c, y, x] = image[c, srcY, srcX];
+                    }
+                }
+            }
+            return cropped;
+        }
+
+        if (image.Rank == 4)
+        {
+            int batch = image.Shape[0];
+            int channels = image.Shape[1];
+            var cropped = new Tensor<T>([batch, channels, cropHeight, cropWidth]);
+            for (int b = 0; b < batch; b++)
+            {
+                for (int c = 0; c < channels; c++)
+                {
+                    for (int y = 0; y < cropHeight; y++)
+                    {
+                        int srcY = startY + y;
+                        for (int x = 0; x < cropWidth; x++)
+                        {
+                            int srcX = startX + x;
+                            cropped[b, c, y, x] = image[b, c, srcY, srcX];
+                        }
+                    }
+                }
+            }
+            return cropped;
+        }
+
+        return null;
+    }
+
+    #region Export Methods
+
+    private static string ExportToCSV(List<List<List<string>>> tables)
+    {
+        var sb = new System.Text.StringBuilder();
+        foreach (var table in tables)
+        {
+            foreach (var row in table)
+            {
+                sb.AppendLine(string.Join(",", row.Select(c => $"\"{c.Replace("\"", "\"\"")}\"")));
+            }
+            sb.AppendLine();
+        }
+        return sb.ToString();
+    }
+
+    private static string ExportToJSON(List<List<List<string>>> tables)
+    {
+        var payload = tables.Select(table => new { rows = table }).ToList();
+        var options = new System.Text.Json.JsonSerializerOptions
+        {
+            WriteIndented = true
+        };
+
+        return System.Text.Json.JsonSerializer.Serialize(payload, options);
+    }
+
+    private static string ExportToHTML(List<List<List<string>>> tables)
+    {
+        var sb = new System.Text.StringBuilder();
+        foreach (var table in tables)
+        {
+            sb.AppendLine("<table border=\"1\">");
+            foreach (var row in table)
+            {
+                sb.AppendLine("  <tr>");
+                foreach (var cell in row)
+                {
+                    sb.AppendLine($"    <td>{System.Net.WebUtility.HtmlEncode(cell)}</td>");
+                }
+                sb.AppendLine("  </tr>");
+            }
+            sb.AppendLine("</table>");
+            sb.AppendLine();
+        }
+        return sb.ToString();
+    }
+
+    private static string ExportToMarkdown(List<List<List<string>>> tables)
+    {
+        var sb = new System.Text.StringBuilder();
+        foreach (var table in tables)
+        {
+            if (table.Count == 0) continue;
+
+            // Header row
+            if (table.Count > 0)
+            {
+                var header = table[0].Select(EscapeMarkdownCell).ToList();
+                sb.AppendLine("| " + string.Join(" | ", header) + " |");
+                sb.AppendLine("| " + string.Join(" | ", header.Select(_ => "---")) + " |");
+            }
+
+            // Data rows
+            for (int r = 1; r < table.Count; r++)
+            {
+                var row = table[r].Select(EscapeMarkdownCell);
+                sb.AppendLine("| " + string.Join(" | ", row) + " |");
+            }
+            sb.AppendLine();
+        }
+        return sb.ToString();
+    }
+
+    private static string EscapeMarkdownCell(string value)
+    {
+        return value?.Replace("|", "\\|") ?? string.Empty;
+    }
+
+    #endregion
+
+    #endregion
+
+    #region IDocumentModel Implementation
+
+    /// <inheritdoc/>
+    public Tensor<T> EncodeDocument(Tensor<T> documentImage)
+    {
+        ValidateImageShape(documentImage);
+        var preprocessed = PreprocessDocument(documentImage);
+        return _useNativeMode ? Forward(preprocessed) : RunDetectionOnnx(preprocessed);
+    }
+
+    /// <inheritdoc/>
+    public void ValidateInputShape(Tensor<T> documentImage)
+    {
+        ValidateImageShape(documentImage);
+    }
+
+    /// <inheritdoc/>
+    public string GetModelSummary()
+    {
+        var sb = new System.Text.StringBuilder();
+        sb.AppendLine("TableTransformer Model Summary");
+        sb.AppendLine("==============================");
+        sb.AppendLine($"Mode: {(_useNativeMode ? "Native (Trainable)" : "ONNX (Inference)")}");
+        sb.AppendLine($"Architecture: DETR-style (Detection Transformer)");
+        sb.AppendLine();
+        sb.AppendLine("Transformer Configuration:");
+        sb.AppendLine($"  Hidden Dimension: {_hiddenDim}");
+        sb.AppendLine($"  Encoder Layers: {_numEncoderLayers}");
+        sb.AppendLine($"  Decoder Layers: {_numDecoderLayers}");
+        sb.AppendLine($"  Attention Heads: {_numHeads}");
+        sb.AppendLine($"  Object Queries: {_numQueries}");
+        sb.AppendLine();
+        sb.AppendLine($"Image Size: {ImageSize}x{ImageSize}");
+        sb.AppendLine($"Table Classes: {_numTableClasses}");
+        sb.AppendLine($"Structure Classes: {_numStructureClasses}");
+        sb.AppendLine($"Supports Bordered Tables: {SupportsBorderedTables}");
+        sb.AppendLine($"Supports Borderless Tables: {SupportsBorderlessTables}");
+        sb.AppendLine($"Supports Merged Cells: {SupportsMergedCells}");
+        sb.AppendLine($"Total Layers: {Layers.Count}");
+        return sb.ToString();
+    }
+
+    #endregion
+
+    #region Preprocessing
+
+    /// <summary>
+    /// Applies TableTransformer's industry-standard preprocessing: COCO/ImageNet normalization.
+    /// </summary>
+    /// <remarks>
+    /// TableTransformer uses COCO-style normalization with ImageNet mean=[0.485, 0.456, 0.406] and std=[0.229, 0.224, 0.225].
+    /// From the PubTables-1M paper (CVPR 2022).
+    /// </remarks>
+    protected override Tensor<T> ApplyDefaultPreprocessing(Tensor<T> rawImage)
+    {
+        var image = EnsureBatchDimension(rawImage);
+
+        int batchSize = image.Shape[0];
+        int channels = image.Shape[1];
+        int height = image.Shape[2];
+        int width = image.Shape[3];
+
+        var normalized = new Tensor<T>(image._shape);
+
+        // COCO/ImageNet normalization (industry standard for TableTransformer)
+        double[] means = [0.485, 0.456, 0.406];
+        double[] stds = [0.229, 0.224, 0.225];
+
+        // Pixel intensities are expected in [0,1]; clamp out-of-range values
+        // (over/under-exposed pixels, or callers passing un-normalized data) rather
+        // than rejecting them, so the model is robust to arbitrary inputs. Clamping
+        // — not min-max rescaling — is intentional: it keeps distinct-brightness
+        // inputs distinct after preprocessing (a 2× image still differs from the 1×),
+        // which the ScaledInput/LargerInput invariants depend on.
+        for (int b = 0; b < batchSize; b++)
+        {
+            for (int c = 0; c < channels; c++)
+            {
+                double mean = c < means.Length ? means[c] : 0.5;
+                double std = c < stds.Length ? stds[c] : 0.5;
+
+                for (int h = 0; h < height; h++)
+                {
+                    for (int w = 0; w < width; w++)
+                    {
+                        int idx = b * channels * height * width + c * height * width + h * width + w;
+                        double value = NumOps.ToDouble(image.Data.Span[idx]);
+                        value = Math.Max(0.0, Math.Min(1.0, value));
+                        normalized.Data.Span[idx] = NumOps.FromDouble((value - mean) / std);
+                    }
+                }
+            }
+        }
+
+        return normalized;
+    }
+
+    /// <summary>
+    /// Applies TableTransformer's industry-standard postprocessing: pass-through (DETR outputs are already in final format).
+    /// </summary>
+    protected override Tensor<T> ApplyDefaultPostprocessing(Tensor<T> modelOutput)
+    {
+        // DETR-style outputs are already in final format (bbox + class logits)
+        return modelOutput;
+    }
+
+    #endregion
+
+    #region Serialization
+
+    /// <inheritdoc/>
+    public override ModelMetadata<T> GetModelMetadata()
+    {
+        return new ModelMetadata<T>
+        {
+            Name = "TableTransformer",
+            Description = "DETR-style table detection and structure recognition (CVPR 2022)",
+            FeatureCount = _hiddenDim,
+            Complexity = _numEncoderLayers + _numDecoderLayers,
+            AdditionalInfo = new Dictionary<string, object>
+            {
+                { "hidden_dim", _hiddenDim },
+                { "num_encoder_layers", _numEncoderLayers },
+                { "num_decoder_layers", _numDecoderLayers },
+                { "num_heads", _numHeads },
+                { "num_queries", _numQueries },
+                { "num_table_classes", _numTableClasses },
+                { "num_structure_classes", _numStructureClasses },
+                { "image_size", ImageSize },
+                { "use_native_mode", _useNativeMode }
+            },
+            ModelData = SafeSerialize()
+        };
+    }
+
+    #endregion
+
+    #region NeuralNetworkBase Implementation
+
+    /// <inheritdoc/>
+    protected override Tensor<T> PredictCore(Tensor<T> input)
+    {
+        var preprocessed = PreprocessDocument(input);
+        return _useNativeMode ? Forward(preprocessed) : RunDetectionOnnx(preprocessed);
+    }
+
+    /// <inheritdoc/>
+    public override void Train(Tensor<T> input, Tensor<T> expectedOutput)
+    {
+        if (!_useNativeMode)
+        {
+            throw new NotSupportedException("Training is not supported in ONNX inference mode.");
+        }
+
+        SetTrainingMode(true);
+        try
+        {
+            // TrainWithTape runs forward + backward + the optimizer update (the same
+            // tape path the base Train uses). The previous code followed it with a
+            // manual CollectParameterGradients()/UpdateParameters() — a SECOND,
+            // redundant update whose flat per-parameter gradient vector length did
+            // not match GetParameters() (a layer's gradient count differs from its
+            // ParameterCount), throwing in Engine.Subtract once the forward stopped
+            // crashing. TrainWithTape owns the whole step.
+            // Pass the configured optimizer through. The two-argument overload left _optimizer
+            // assigned but never read, so training ran on the framework default instead of DETR's
+            // 1e-4 (Smock et al., 2022) and the memorization loss went from 0.0000 to 12.3652.
+            TrainWithTape(input, expectedOutput, _optimizer);
+        }
+        finally
+        {
+            SetTrainingMode(false);
+        }
+    }
+
+    // UpdateParameters applied a GRADIENT STEP, but its one-argument form is the value setter and every caller passes values -- the override corrupted the model. Removed under AIDN082.
+
+
+    /// <summary>
+    /// Parameters cannot be written while the model is backed by a loaded ONNX graph: the weights
+    /// belong to that graph, not to this instance.
+    /// </summary>
+    /// <remarks>
+    /// Replaces a hand-written throw that used to sit inside UpdateParameters. The base checks this
+    /// on every mutating entry point rather than the one member the throw happened to guard, and
+    /// reading -- ParameterCount and GetParameters -- stays available either way.
+    /// </remarks>
     protected override bool SupportsParameterMutation => _useNativeMode;
-    private Vector<T> CollectParameterGradients()
-    {
-        var gradients = new List<T>();
-
-        foreach (var layer in Layers)
-        {
-            var layerGradients = layer.GetParameterGradients();
-            gradients.AddRange(layerGradients);
-        }
-
-        return new Vector<T>([.. gradients]);
-    }
-
-    #endregion
-
-    #region Disposal
-
-    /// <inheritdoc/>
-    protected override void Dispose(bool disposing)
-    {
-        if (disposing)
-        {
-            _onnxDetectionSession?.Dispose();
-            _onnxStructureSession?.Dispose();
-        }
-        base.Dispose(disposing);
-    }
-
-    #endregion
-}
-
-/// <summary>
-/// Task modes for TableTransformer.
-/// </summary>
-internal enum TableTransformerTask
-{
-    Detection,
-    Structure
-}
+    private Vector<T> CollectParameterGradients()
+    {
+        var gradients = new List<T>();
+
+        foreach (var layer in Layers)
+        {
+            var layerGradients = layer.GetParameterGradients();
+            gradients.AddRange(layerGradients);
+        }
+
+        return new Vector<T>([.. gradients]);
+    }
+
+    #endregion
+
+    #region Disposal
+
+    /// <inheritdoc/>
+    protected override void Dispose(bool disposing)
+    {
+        if (disposing)
+        {
+            _onnxDetectionSession?.Dispose();
+            _onnxStructureSession?.Dispose();
+        }
+        base.Dispose(disposing);
+    }
+
+    #endregion
+}
+
+/// <summary>
+/// Task modes for TableTransformer.
+/// </summary>
+internal enum TableTransformerTask
+{
+    Detection,
+    Structure
+}
diff --git a/src/Document/GraphBased/DocGCN.cs b/src/Document/GraphBased/DocGCN.cs
index ca1a21a77e..0539a81d84 100644
--- a/src/Document/GraphBased/DocGCN.cs
+++ b/src/Document/GraphBased/DocGCN.cs
@@ -1,713 +1,687 @@
-using AiDotNet.Attributes;
-using AiDotNet.Document.Interfaces;
-using AiDotNet.Document.Options;
-using AiDotNet.Enums;
-using AiDotNet.Helpers;
-using AiDotNet.Interfaces;
-using AiDotNet.LinearAlgebra;
-using AiDotNet.LossFunctions;
-using AiDotNet.Models.Options;
-using AiDotNet.NeuralNetworks;
-using AiDotNet.NeuralNetworks.Layers;
-using AiDotNet.Optimizers;
-using Microsoft.ML.OnnxRuntime;
-
-namespace AiDotNet.Document.GraphBased;
-
-/// <summary>
-/// DocGCN (Document Graph Convolutional Network) for document understanding using graph neural networks.
-/// </summary>
-/// <typeparam name="T">The numeric type used for calculations.</typeparam>
-/// <remarks>
-/// <para>
-/// DocGCN represents documents as graphs where nodes are text blocks and edges represent
-/// spatial and semantic relationships. Graph convolutional layers propagate information
-/// to understand document structure.
-/// </para>
-/// <para>
-/// <b>For Beginners:</b> DocGCN views documents as networks:
-/// 1. Each text block becomes a node in a graph
-/// 2. Nearby blocks are connected by edges
-/// 3. Graph convolutions learn relationships
-/// 4. Can classify, extract, or understand document structure
-///
-/// Key features:
-/// - Graph-based document representation
-/// - Spatial relationship modeling
-/// - Multi-hop reasoning through graph layers
-/// - Entity and relation extraction
-///
-/// Example usage:
-/// <code>
-/// var model = new DocGCN&lt;float&gt;(architecture);
-/// var result = model.DetectLayout(documentImage);
-/// </code>
-/// </para>
-/// <para>
-/// <b>Reference:</b> Based on graph neural network approaches for document understanding.
-/// </para>
-/// </remarks>
-[ModelDomain(ModelDomain.Vision)]
-[ModelDomain(ModelDomain.Language)]
-[ModelCategory(ModelCategory.NeuralNetwork)]
-[ModelCategory(ModelCategory.GraphNetwork)]
-[ModelTask(ModelTask.Classification)]
-[ModelTask(ModelTask.Detection)]
-[ModelComplexity(ModelComplexity.High)]
-[ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
-[ResearchPaper("DocGCN: Heterogeneous Graph Convolutional Networks for Document Layout Analysis", "https://doi.org/10.48550/arXiv.2208.10970", Year = 2022, Authors = "Siwen Luo, Josiah Poon, Soyeon Caren Han")]
-public partial class DocGCN<T> : DocumentNeuralNetworkBase<T>, ILayoutDetector<T>
-{
-    private readonly DocGCNOptions _options;
-
-    /// <inheritdoc/>
-    public override ModelOptions GetOptions() => _options;
-
-    #region Fields
-
-    private readonly bool _useNativeMode;
-    private readonly InferenceSession? _onnxSession;
-    private readonly IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>> _optimizer;
-    private int _nodeDim;
-    private int _edgeDim;
-    private int _gcnLayers;
-    private int _numClasses;
-    private int _maxNodes;
-
-    // Native mode layers
-    private readonly List<ILayer<T>> _nodeEncoderLayers = [];
-    private readonly List<ILayer<T>> _gcnLayersList = [];
-    private readonly List<ILayer<T>> _classifierLayers = [];
-
-    // Node embeddings
-
-    #endregion
-
-    #region Properties
-
-    /// <inheritdoc/>
-    public override DocumentType SupportedDocumentTypes => DocumentType.All;
-
-    /// <inheritdoc/>
-    public override bool RequiresOCR => true;
-
-    /// <inheritdoc/>
-    public int ExpectedImageSize => ImageSize;
-
-    /// <summary>
-    /// Gets the node feature dimension.
-    /// </summary>
-    public int NodeDim => _nodeDim;
-
-    /// <summary>
-    /// Gets the number of GCN layers.
-    /// </summary>
-    public int NumGCNLayers => _gcnLayers;
-
-    /// <summary>
-    /// Gets the maximum number of nodes.
-    /// </summary>
-    public int MaxNodes => _maxNodes;
-
-    /// <inheritdoc/>
-    public IReadOnlyList<LayoutElementType> SupportedElementTypes { get; } =
-    [
-        LayoutElementType.Text,
-        LayoutElementType.Title,
-        LayoutElementType.List,
-        LayoutElementType.Table,
-        LayoutElementType.Figure,
-        LayoutElementType.Caption,
-        LayoutElementType.Header,
-        LayoutElementType.Footer,
-        LayoutElementType.FormField
-    ];
-
-    #endregion
-
-    #region Constructors
-
-    /// <summary>
-    /// Creates a DocGCN model with default configuration for native training.
-    /// </summary>
-    public DocGCN()
-        : this(new NeuralNetworkArchitecture<T>(
-            inputType: InputType.OneDimensional,
-            taskType: NeuralNetworkTaskType.MultiClassClassification,
-            inputSize: 256,
-            outputSize: 9))
-    {
-    }
-
-    /// <summary>
-    /// Creates a DocGCN model using a pre-trained ONNX model for inference.
-    /// </summary>
-    public DocGCN(
-        NeuralNetworkArchitecture<T> architecture,
-        string onnxModelPath,
-        int nodeDim = 256,
-        int edgeDim = 64,
-        int gcnLayers = 3,
-        int numClasses = 9,
-        int maxNodes = 512,
-        IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? optimizer = null,
-        ILossFunction<T>? lossFunction = null,
-        DocGCNOptions? options = null)
-        : base(architecture, lossFunction ?? new CrossEntropyWithLogitsLoss<T>(), 1.0)
-    {
-        _options = options ?? new DocGCNOptions();
-        Options = _options;
-
-        if (string.IsNullOrWhiteSpace(onnxModelPath))
-            throw new ArgumentNullException(nameof(onnxModelPath));
-        if (!File.Exists(onnxModelPath))
-            throw new FileNotFoundException($"ONNX model not found: {onnxModelPath}", onnxModelPath);
-
-        _useNativeMode = false;
-        _nodeDim = nodeDim;
-        _edgeDim = edgeDim;
-        _gcnLayers = gcnLayers;
-        _numClasses = numClasses;
-        _maxNodes = maxNodes;
-        _optimizer = ResolveOptimizer(optimizer);
-
-        _onnxSession = new InferenceSession(onnxModelPath);
-
-        InitializeLayers();
-    }
-
-    /// <summary>
-    /// Creates a DocGCN model using native layers for training and inference.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// <b>Default Configuration:</b>
-    /// - Node feature encoder (text + spatial)
-    /// - Multiple GCN layers with message passing
-    /// - Edge-aware attention mechanism
-    /// - Node classification head
-    /// </para>
-    /// </remarks>
-    public DocGCN(
-        NeuralNetworkArchitecture<T> architecture,
-        int nodeDim = 256,
-        int edgeDim = 64,
-        int gcnLayers = 3,
-        int numClasses = 9,
-        int maxNodes = 512,
-        IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? optimizer = null,
-        ILossFunction<T>? lossFunction = null,
-        DocGCNOptions? options = null)
-        : base(architecture, lossFunction ?? new CrossEntropyWithLogitsLoss<T>(), 1.0)
-    {
-        _options = options ?? new DocGCNOptions();
-        Options = _options;
-
-        _useNativeMode = true;
-        _nodeDim = nodeDim;
-        _edgeDim = edgeDim;
-        _gcnLayers = gcnLayers;
-        _numClasses = numClasses;
-        _maxNodes = maxNodes;
-        _optimizer = ResolveOptimizer(optimizer);
-
-        InitializeLayers();
-        InitializeEmbeddings();
-    }
-
-    #endregion
-
-    #region Initialization
-
-    /// <inheritdoc/>
-    protected override void InitializeLayers()
-    {
-        if (!_useNativeMode)
-        {
-            return;
-        }
-
-        if (Architecture.Layers is not null && Architecture.Layers.Count > 0)
-        {
-            Layers.AddRange(Architecture.Layers);
-            ValidateCustomLayers(Layers);
-            return;
-        }
-
-        Layers.AddRange(LayerHelper<T>.CreateDefaultDocGCNLayers(
-            inputDim: _nodeDim,
-            hiddenDim: _edgeDim,
-            numGCNLayers: _gcnLayers,
-            numClasses: _numClasses));
-    }
-
-    private void InitializeEmbeddings()
-    {
-        var random = RandomHelper.CreateSeededRandom(42);
-    }
-
-    private void InitializeWithSmallRandomValues(Tensor<T> tensor, Random random, double stdDev)
-    {
-        for (int i = 0; i < tensor.Data.Length; i++)
-        {
-            double u1 = 1.0 - random.NextDouble();
-            double u2 = 1.0 - random.NextDouble();
-            double randStdNormal = Math.Sqrt(-2.0 * Math.Log(u1)) * Math.Sin(2.0 * Math.PI * u2);
-            tensor.Data.Span[i] = NumOps.FromDouble(randStdNormal * stdDev);
-        }
-    }
-
-    /// <summary>
-    /// Resolves Doc-GCN's trainable optimizer while preserving the public constructor's
-    /// general <see cref="IOptimizer{T, TInput, TOutput}"/> contract.
-    /// </summary>
-    private IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>> ResolveOptimizer(
-        IOptimizer<T, Tensor<T>, Tensor<T>>? optimizer)
-    {
-        if (optimizer is not null)
-        {
-            return optimizer as IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>
-                ?? throw new ArgumentException(
-                    "DocGCN training requires a gradient-based optimizer.", nameof(optimizer));
-        }
-
-        // Doc-GCN (Luo et al., COLING 2022) §4.3 specifies THREE Adam rates, not one:
-        // 1e-4 for the Semantic/Syntactic GCNs, 0.001 for "others", and 2e-5 for the classifier.
-        // The previous value took the 1e-4 branch rate and applied it to the whole model -- but the
-        // default native stack has no semantic/syntactic GCN in it at all (see CreateDefaultDocGCNLayers:
-        // it emits DenseLayer + Dropout, with the adjacency implicitly identity). This stack IS the
-        // paper's "others" path, so 0.001 is its rate, and picking the smallest of the three left
-        // the model training an order of magnitude below both the paper and the framework default.
-        //
-        // That is measurable rather than theoretical. Adam's per-parameter step is about lr on a
-        // repeated single pair, so across the memorization probe's 15 steps the 316 parameters moved
-        // ~1.0e-3 in total and the loss fell 1.3276 -> 1.3155: a 0.912% decrease against a 1.000%
-        // threshold, missing by 9% of the threshold. It was not that gradients were failing to reach
-        // the parameters -- a detached graph gives a flat loss, and a last-layer-only gradient would
-        // have given roughly a tenth of that movement. The whole model was descending, just slowly.
-        return new AdamOptimizer<T, Tensor<T>, Tensor<T>>(
-            this,
-            new AdamOptimizerOptions<T, Tensor<T>, Tensor<T>>
-            {
-                InitialLearningRate = 1e-3,
-                EnableGradientClipping = true,
-                MaxGradientNorm = 1.0
-            });
-    }
-
-    #endregion
-
-    #region ILayoutDetector Implementation
-
-    /// <inheritdoc/>
-    public DocumentLayoutResult<T> DetectLayout(Tensor<T> documentImage)
-    {
-        return DetectLayout(documentImage, 0.5);
-    }
-
-    /// <inheritdoc/>
-    public DocumentLayoutResult<T> DetectLayout(Tensor<T> documentImage, double confidenceThreshold)
-    {
-        ValidateImageShape(documentImage);
-        var startTime = DateTime.UtcNow;
-
-        var preprocessed = PreprocessDocument(documentImage);
-        var output = _useNativeMode ? Forward(preprocessed) : RunOnnxInference(preprocessed);
-
-        var regions = ParseLayoutOutput(output, confidenceThreshold);
-
-        return new DocumentLayoutResult<T>
-        {
-            Regions = regions,
-            ProcessingTimeMs = (DateTime.UtcNow - startTime).TotalMilliseconds
-        };
-    }
-
-    private List<LayoutRegion<T>> ParseLayoutOutput(Tensor<T> output, double threshold)
-    {
-        var regions = new List<LayoutRegion<T>>();
-        int numNodes = Math.Min(output.Shape[0], _maxNodes);
-        int hiddenDim = output.Shape.Length > 1 ? output.Shape[1] : _numClasses;
-        int numClasses = Math.Min(hiddenDim - 4, _numClasses); // Reserve 4 for bbox
-        bool hasBbox = hiddenDim > _numClasses;
-
-        for (int i = 0; i < numNodes; i++)
-        {
-            double maxConf = 0;
-            int maxClass = 0;
-            for (int c = 0; c < numClasses; c++)
-            {
-                double conf = NumOps.ToDouble(output[i, c]);
-                if (conf > maxConf) { maxConf = conf; maxClass = c; }
-            }
-
-            if (maxConf >= threshold && maxClass > 0)
-            {
-                // Extract bounding box from last 4 values (normalized coordinates)
-                Vector<T> bbox;
-                if (hasBbox && hiddenDim >= 4)
-                {
-                    int bboxStart = hiddenDim - 4;
-                    double x1 = NumOps.ToDouble(output[i, bboxStart]) * ImageSize;
-                    double y1 = NumOps.ToDouble(output[i, bboxStart + 1]) * ImageSize;
-                    double x2 = NumOps.ToDouble(output[i, bboxStart + 2]) * ImageSize;
-                    double y2 = NumOps.ToDouble(output[i, bboxStart + 3]) * ImageSize;
-
-                    bbox = new Vector<T>([
-                        NumOps.FromDouble(Math.Max(0, x1)),
-                        NumOps.FromDouble(Math.Max(0, y1)),
-                        NumOps.FromDouble(Math.Min(ImageSize, x2)),
-                        NumOps.FromDouble(Math.Min(ImageSize, y2))
-                    ]);
-                }
-                else
-                {
-                    // Grid-based fallback for node index
-                    int gridSize = (int)Math.Sqrt(numNodes);
-                    int cellSize = ImageSize / Math.Max(1, gridSize);
-                    int row = i / gridSize;
-                    int col = i % gridSize;
-
-                    bbox = new Vector<T>([
-                        NumOps.FromDouble(col * cellSize),
-                        NumOps.FromDouble(row * cellSize),
-                        NumOps.FromDouble((col + 1) * cellSize),
-                        NumOps.FromDouble((row + 1) * cellSize)
-                    ]);
-                }
-
-                regions.Add(new LayoutRegion<T>
-                {
-                    ElementType = (LayoutElementType)Math.Min(maxClass, (int)LayoutElementType.Other),
-                    Confidence = NumOps.FromDouble(maxConf),
-                    ConfidenceValue = maxConf,
-                    Index = i,
-                    BoundingBox = bbox
-                });
-            }
-        }
-
-        return regions;
-    }
-
-    #endregion
-
-    #region IDocumentModel Implementation
-
-    /// <inheritdoc/>
-    public Tensor<T> EncodeDocument(Tensor<T> documentImage)
-    {
-        ValidateImageShape(documentImage);
-        var preprocessed = PreprocessDocument(documentImage);
-        return _useNativeMode ? Forward(preprocessed) : RunOnnxInference(preprocessed);
-    }
-
-    /// <inheritdoc/>
-    public void ValidateInputShape(Tensor<T> documentImage)
-    {
-        ValidateImageShape(documentImage);
-    }
-
-    /// <inheritdoc/>
-    public string GetModelSummary()
-    {
-        var sb = new System.Text.StringBuilder();
-        sb.AppendLine("DocGCN Model Summary");
-        sb.AppendLine("====================");
-        sb.AppendLine($"Mode: {(_useNativeMode ? "Native (Trainable)" : "ONNX (Inference)")}");
-        sb.AppendLine($"Architecture: Graph Convolutional Network");
-        sb.AppendLine($"Node Dimension: {_nodeDim}");
-        sb.AppendLine($"Edge Dimension: {_edgeDim}");
-        sb.AppendLine($"GCN Layers: {_gcnLayers}");
-        sb.AppendLine($"Max Nodes: {_maxNodes}");
-        sb.AppendLine($"Number of Classes: {_numClasses}");
-        sb.AppendLine($"Graph-Based: Yes");
-        sb.AppendLine($"Total Layers: {Layers.Count}");
-        return sb.ToString();
-    }
-
-    #endregion
-
-    #region Preprocessing
-
-    /// <summary>
-    /// Applies DocGCN's industry-standard preprocessing: simple normalization to [0,1].
-    /// </summary>
-    /// <remarks>
-    /// DocGCN uses basic normalization (divide by 255) since the focus is on graph-based processing.
-    /// </remarks>
-    protected override Tensor<T> ApplyDefaultPreprocessing(Tensor<T> rawImage)
-    {
-        var image = EnsureBatchDimension(rawImage);
-        int batchSize = image.Shape[0];
-        int channels = image.Shape[1];
-        int height = image.Shape[2];
-        int width = image.Shape[3];
-
-        var normalized = new Tensor<T>(image._shape);
-        for (int i = 0; i < image.Data.Length; i++)
-        {
-            normalized.Data.Span[i] = NumOps.FromDouble(NumOps.ToDouble(image.Data.Span[i]) / 255.0);
-        }
-        return normalized;
-    }
-
-    /// <summary>
-    /// Applies DocGCN's industry-standard postprocessing: pass-through (node classifications are already final).
-    /// </summary>
-    protected override Tensor<T> ApplyDefaultPostprocessing(Tensor<T> modelOutput) => modelOutput;
-
-    #endregion
-
-    #region Serialization
-
-    /// <inheritdoc/>
-    public override ModelMetadata<T> GetModelMetadata()
-    {
-        return new ModelMetadata<T>
-        {
-            Name = "DocGCN",
-            Description = "DocGCN for graph-based document understanding",
-            FeatureCount = _nodeDim,
-            Complexity = _gcnLayers,
-            AdditionalInfo = new Dictionary<string, object>
-            {
-                { "node_dim", _nodeDim },
-                { "edge_dim", _edgeDim },
-                { "gcn_layers", _gcnLayers },
-                { "num_classes", _numClasses },
-                { "max_nodes", _maxNodes },
-                { "use_native_mode", _useNativeMode }
-            },
-            ModelData = SafeSerialize()
-        };
-    }
-
-    /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_nodeDim);
-        writer.Write(_edgeDim);
-        writer.Write(_gcnLayers);
-        writer.Write(_numClasses);
-        writer.Write(_maxNodes);
-        writer.Write(_useNativeMode);
-    }
-
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _nodeDim = reader.ReadInt32();
-        _edgeDim = reader.ReadInt32();
-        _gcnLayers = reader.ReadInt32();
-        _numClasses = reader.ReadInt32();
-        _maxNodes = reader.ReadInt32();
-        _ = reader.ReadBoolean(); // useNativeMode - already set by constructor
-    }
-
-    /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new DocGCN<T>(Architecture, _nodeDim, _edgeDim, _gcnLayers, _numClasses, _maxNodes);
-    }
-
-    #endregion
-
-    #region NeuralNetworkBase Implementation
-
-    /// <inheritdoc/>
-    protected override Tensor<T> PredictCore(Tensor<T> input)
-    {
-        var preprocessed = PreprocessDocument(input);
-        return _useNativeMode ? Forward(preprocessed) : RunOnnxInference(preprocessed);
-    }
-
-    /// <summary>
-    /// Modality-robust HETEROGENEOUS-graph inference (Luo et al. 2022 — DocGCN is a heterogeneous
-    /// graph over text/visual/layout nodes). Each argument is one modality's node-feature matrix
-    /// (<c>[N_modality, F]</c>, sharing the feature dim <c>F</c>); present modalities are stacked along
-    /// the NODE axis into one joint heterogeneous node set that the shared GCN stack reasons over.
-    /// Supplying a single modality (or null for the others) gracefully degrades to that modality —
-    /// reference DocGCN impls expect a pre-fused node set, so accepting missing modalities is where
-    /// this exceeds them.
-    /// </summary>
-    /// <param name="modalityNodeFeatures">One rank-2 <c>[N, F]</c> node-feature matrix per modality;
-    /// null entries (absent modalities) are skipped.</param>
-    public Tensor<T> PredictMultimodal(params Tensor<T>?[] modalityNodeFeatures)
-    {
-        if (!_useNativeMode)
-            throw new NotSupportedException("Multimodal fusion is only available in native mode.");
-        if (modalityNodeFeatures is null)
-            throw new ArgumentNullException(nameof(modalityNodeFeatures));
-
-        var present = System.Array.FindAll(modalityNodeFeatures, m => m is not null);
-        if (present.Length == 0)
-            throw new ArgumentException("PredictMultimodal requires at least one non-null modality node-feature matrix.", nameof(modalityNodeFeatures));
-
-        SetTrainingMode(false);
-        var fused = present.Length == 1
-            ? present[0]!
-            : Engine.TensorConcatenate(System.Array.ConvertAll(present, m => m!), axis: 0); // [ΣN_modality, F]
-        return Forward(fused);
-    }
-
-    /// <inheritdoc/>
-    public override void Train(Tensor<T> input, Tensor<T> expectedOutput)
-    {
-        if (!_useNativeMode)
-            throw new NotSupportedException("Training not supported in ONNX mode.");
-
-        // TrainWithTape already runs the forward, backprop, and optimizer update. The manual
-        // UpdateParameters(CollectGradients()) that followed was a redundant SECOND gradient step whose
-        // hand-collected vector length didn't match GetParameters, crashing training. Use the tape only.
-        SetTrainingMode(true);
-        try
-        {
-            TrainWithTape(input, expectedOutput, _optimizer);
-        }
-        finally
-        {
-            SetTrainingMode(false);
-        }
-    }
-
-    // UpdateParameters applied a GRADIENT STEP, but its one-argument form is the value setter and every caller passes values -- the override corrupted the model. Removed under AIDN082.

-
-    /// <summary>
-    /// Parameters cannot be written while the model is backed by a loaded ONNX graph: the weights
-    /// belong to that graph, not to this instance.
-    /// </summary>
-    /// <remarks>
-    /// Replaces a hand-written throw that used to sit inside UpdateParameters. The base checks this
-    /// on every mutating entry point rather than the one member the throw happened to guard, and
-    /// reading -- ParameterCount and GetParameters -- stays available either way.
-    /// </remarks>
+using AiDotNet.Attributes;
+using AiDotNet.Document.Interfaces;
+using AiDotNet.Document.Options;
+using AiDotNet.Enums;
+using AiDotNet.Helpers;
+using AiDotNet.Interfaces;
+using AiDotNet.LinearAlgebra;
+using AiDotNet.LossFunctions;
+using AiDotNet.Models.Options;
+using AiDotNet.NeuralNetworks;
+using AiDotNet.NeuralNetworks.Layers;
+using AiDotNet.Optimizers;
+using Microsoft.ML.OnnxRuntime;
+
+namespace AiDotNet.Document.GraphBased;
+
+/// <summary>
+/// DocGCN (Document Graph Convolutional Network) for document understanding using graph neural networks.
+/// </summary>
+/// <typeparam name="T">The numeric type used for calculations.</typeparam>
+/// <remarks>
+/// <para>
+/// DocGCN represents documents as graphs where nodes are text blocks and edges represent
+/// spatial and semantic relationships. Graph convolutional layers propagate information
+/// to understand document structure.
+/// </para>
+/// <para>
+/// <b>For Beginners:</b> DocGCN views documents as networks:
+/// 1. Each text block becomes a node in a graph
+/// 2. Nearby blocks are connected by edges
+/// 3. Graph convolutions learn relationships
+/// 4. Can classify, extract, or understand document structure
+///
+/// Key features:
+/// - Graph-based document representation
+/// - Spatial relationship modeling
+/// - Multi-hop reasoning through graph layers
+/// - Entity and relation extraction
+///
+/// Example usage:
+/// <code>
+/// var model = new DocGCN&lt;float&gt;(architecture);
+/// var result = model.DetectLayout(documentImage);
+/// </code>
+/// </para>
+/// <para>
+/// <b>Reference:</b> Based on graph neural network approaches for document understanding.
+/// </para>
+/// </remarks>
+[ModelDomain(ModelDomain.Vision)]
+[ModelDomain(ModelDomain.Language)]
+[ModelCategory(ModelCategory.NeuralNetwork)]
+[ModelCategory(ModelCategory.GraphNetwork)]
+[ModelTask(ModelTask.Classification)]
+[ModelTask(ModelTask.Detection)]
+[ModelComplexity(ModelComplexity.High)]
+[ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
+[ResearchPaper("DocGCN: Heterogeneous Graph Convolutional Networks for Document Layout Analysis", "https://doi.org/10.48550/arXiv.2208.10970", Year = 2022, Authors = "Siwen Luo, Josiah Poon, Soyeon Caren Han")]
+public partial class DocGCN<T> : DocumentNeuralNetworkBase<T>, ILayoutDetector<T>
+{
+    private readonly DocGCNOptions _options;
+
+    /// <inheritdoc/>
+    public override ModelOptions GetOptions() => _options;
+
+    #region Fields
+
+    private readonly bool _useNativeMode;
+    private readonly InferenceSession? _onnxSession;
+    private readonly IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>> _optimizer;
+    private int _nodeDim;
+    private int _edgeDim;
+    private int _gcnLayers;
+    private int _numClasses;
+    private int _maxNodes;
+
+    // Native mode layers
+    private readonly List<ILayer<T>> _nodeEncoderLayers = [];
+    private readonly List<ILayer<T>> _gcnLayersList = [];
+    private readonly List<ILayer<T>> _classifierLayers = [];
+
+    // Node embeddings
+
+    #endregion
+
+    #region Properties
+
+    /// <inheritdoc/>
+    public override DocumentType SupportedDocumentTypes => DocumentType.All;
+
+    /// <inheritdoc/>
+    public override bool RequiresOCR => true;
+
+    /// <inheritdoc/>
+    public int ExpectedImageSize => ImageSize;
+
+    /// <summary>
+    /// Gets the node feature dimension.
+    /// </summary>
+    public int NodeDim => _nodeDim;
+
+    /// <summary>
+    /// Gets the number of GCN layers.
+    /// </summary>
+    public int NumGCNLayers => _gcnLayers;
+
+    /// <summary>
+    /// Gets the maximum number of nodes.
+    /// </summary>
+    public int MaxNodes => _maxNodes;
+
+    /// <inheritdoc/>
+    public IReadOnlyList<LayoutElementType> SupportedElementTypes { get; } =
+    [
+        LayoutElementType.Text,
+        LayoutElementType.Title,
+        LayoutElementType.List,
+        LayoutElementType.Table,
+        LayoutElementType.Figure,
+        LayoutElementType.Caption,
+        LayoutElementType.Header,
+        LayoutElementType.Footer,
+        LayoutElementType.FormField
+    ];
+
+    #endregion
+
+    #region Constructors
+
+    /// <summary>
+    /// Creates a DocGCN model with default configuration for native training.
+    /// </summary>
+    public DocGCN()
+        : this(new NeuralNetworkArchitecture<T>(
+            inputType: InputType.OneDimensional,
+            taskType: NeuralNetworkTaskType.MultiClassClassification,
+            inputSize: 256,
+            outputSize: 9))
+    {
+    }
+
+    /// <summary>
+    /// Creates a DocGCN model using a pre-trained ONNX model for inference.
+    /// </summary>
+    public DocGCN(
+        NeuralNetworkArchitecture<T> architecture,
+        string onnxModelPath,
+        int nodeDim = 256,
+        int edgeDim = 64,
+        int gcnLayers = 3,
+        int numClasses = 9,
+        int maxNodes = 512,
+        IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? optimizer = null,
+        ILossFunction<T>? lossFunction = null,
+        DocGCNOptions? options = null)
+        : base(architecture, lossFunction ?? new CrossEntropyWithLogitsLoss<T>(), 1.0)
+    {
+        _options = options ?? new DocGCNOptions();
+        Options = _options;
+
+        if (string.IsNullOrWhiteSpace(onnxModelPath))
+            throw new ArgumentNullException(nameof(onnxModelPath));
+        if (!File.Exists(onnxModelPath))
+            throw new FileNotFoundException($"ONNX model not found: {onnxModelPath}", onnxModelPath);
+
+        _useNativeMode = false;
+        _nodeDim = nodeDim;
+        _edgeDim = edgeDim;
+        _gcnLayers = gcnLayers;
+        _numClasses = numClasses;
+        _maxNodes = maxNodes;
+        _optimizer = ResolveOptimizer(optimizer);
+
+        _onnxSession = new InferenceSession(onnxModelPath);
+
+        InitializeLayers();
+    }
+
+    /// <summary>
+    /// Creates a DocGCN model using native layers for training and inference.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// <b>Default Configuration:</b>
+    /// - Node feature encoder (text + spatial)
+    /// - Multiple GCN layers with message passing
+    /// - Edge-aware attention mechanism
+    /// - Node classification head
+    /// </para>
+    /// </remarks>
+    public DocGCN(
+        NeuralNetworkArchitecture<T> architecture,
+        int nodeDim = 256,
+        int edgeDim = 64,
+        int gcnLayers = 3,
+        int numClasses = 9,
+        int maxNodes = 512,
+        IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? optimizer = null,
+        ILossFunction<T>? lossFunction = null,
+        DocGCNOptions? options = null)
+        : base(architecture, lossFunction ?? new CrossEntropyWithLogitsLoss<T>(), 1.0)
+    {
+        _options = options ?? new DocGCNOptions();
+        Options = _options;
+
+        _useNativeMode = true;
+        _nodeDim = nodeDim;
+        _edgeDim = edgeDim;
+        _gcnLayers = gcnLayers;
+        _numClasses = numClasses;
+        _maxNodes = maxNodes;
+        _optimizer = ResolveOptimizer(optimizer);
+
+        InitializeLayers();
+        InitializeEmbeddings();
+    }
+
+    #endregion
+
+    #region Initialization
+
+    /// <inheritdoc/>
+    protected override void InitializeLayers()
+    {
+        if (!_useNativeMode)
+        {
+            return;
+        }
+
+        if (Architecture.Layers is not null && Architecture.Layers.Count > 0)
+        {
+            Layers.AddRange(Architecture.Layers);
+            ValidateCustomLayers(Layers);
+            return;
+        }
+
+        Layers.AddRange(LayerHelper<T>.CreateDefaultDocGCNLayers(
+            inputDim: _nodeDim,
+            hiddenDim: _edgeDim,
+            numGCNLayers: _gcnLayers,
+            numClasses: _numClasses));
+    }
+
+    private void InitializeEmbeddings()
+    {
+        // The graph stack is part of the native architecture, even before the caller supplies an
+        // adjacency matrix. Construct it here so the generated layer inventory, clone graph and
+        // optimizer all see one stable topology without a model-specific enumeration override.
+        EnsureGraphPathBuilt();
+    }
+
+    private void InitializeWithSmallRandomValues(Tensor<T> tensor, Random random, double stdDev)
+    {
+        for (int i = 0; i < tensor.Data.Length; i++)
+        {
+            double u1 = 1.0 - random.NextDouble();
+            double u2 = 1.0 - random.NextDouble();
+            double randStdNormal = Math.Sqrt(-2.0 * Math.Log(u1)) * Math.Sin(2.0 * Math.PI * u2);
+            tensor.Data.Span[i] = NumOps.FromDouble(randStdNormal * stdDev);
+        }
+    }
+
+    /// <summary>
+    /// Resolves Doc-GCN's trainable optimizer while preserving the public constructor's
+    /// general <see cref="IOptimizer{T, TInput, TOutput}"/> contract.
+    /// </summary>
+    private IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>> ResolveOptimizer(
+        IOptimizer<T, Tensor<T>, Tensor<T>>? optimizer)
+    {
+        if (optimizer is not null)
+        {
+            return optimizer as IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>
+                ?? throw new ArgumentException(
+                    "DocGCN training requires a gradient-based optimizer.", nameof(optimizer));
+        }
+
+        // Doc-GCN (Luo et al., COLING 2022) §4.3 specifies THREE Adam rates, not one:
+        // 1e-4 for the Semantic/Syntactic GCNs, 0.001 for "others", and 2e-5 for the classifier.
+        // The previous value took the 1e-4 branch rate and applied it to the whole model -- but the
+        // default native stack has no semantic/syntactic GCN in it at all (see CreateDefaultDocGCNLayers:
+        // it emits DenseLayer + Dropout, with the adjacency implicitly identity). This stack IS the
+        // paper's "others" path, so 0.001 is its rate, and picking the smallest of the three left
+        // the model training an order of magnitude below both the paper and the framework default.
+        //
+        // That is measurable rather than theoretical. Adam's per-parameter step is about lr on a
+        // repeated single pair, so across the memorization probe's 15 steps the 316 parameters moved
+        // ~1.0e-3 in total and the loss fell 1.3276 -> 1.3155: a 0.912% decrease against a 1.000%
+        // threshold, missing by 9% of the threshold. It was not that gradients were failing to reach
+        // the parameters -- a detached graph gives a flat loss, and a last-layer-only gradient would
+        // have given roughly a tenth of that movement. The whole model was descending, just slowly.
+        return new AdamOptimizer<T, Tensor<T>, Tensor<T>>(
+            this,
+            new AdamOptimizerOptions<T, Tensor<T>, Tensor<T>>
+            {
+                InitialLearningRate = 1e-3,
+                EnableGradientClipping = true,
+                MaxGradientNorm = 1.0
+            });
+    }
+
+    #endregion
+
+    #region ILayoutDetector Implementation
+
+    /// <inheritdoc/>
+    public DocumentLayoutResult<T> DetectLayout(Tensor<T> documentImage)
+    {
+        return DetectLayout(documentImage, 0.5);
+    }
+
+    /// <inheritdoc/>
+    public DocumentLayoutResult<T> DetectLayout(Tensor<T> documentImage, double confidenceThreshold)
+    {
+        ValidateImageShape(documentImage);
+        var startTime = DateTime.UtcNow;
+
+        var preprocessed = PreprocessDocument(documentImage);
+        var output = _useNativeMode ? Forward(preprocessed) : RunOnnxInference(preprocessed);
+
+        var regions = ParseLayoutOutput(output, confidenceThreshold);
+
+        return new DocumentLayoutResult<T>
+        {
+            Regions = regions,
+            ProcessingTimeMs = (DateTime.UtcNow - startTime).TotalMilliseconds
+        };
+    }
+
+    private List<LayoutRegion<T>> ParseLayoutOutput(Tensor<T> output, double threshold)
+    {
+        var regions = new List<LayoutRegion<T>>();
+        int numNodes = Math.Min(output.Shape[0], _maxNodes);
+        int hiddenDim = output.Shape.Length > 1 ? output.Shape[1] : _numClasses;
+        int numClasses = Math.Min(hiddenDim - 4, _numClasses); // Reserve 4 for bbox
+        bool hasBbox = hiddenDim > _numClasses;
+
+        for (int i = 0; i < numNodes; i++)
+        {
+            double maxConf = 0;
+            int maxClass = 0;
+            for (int c = 0; c < numClasses; c++)
+            {
+                double conf = NumOps.ToDouble(output[i, c]);
+                if (conf > maxConf) { maxConf = conf; maxClass = c; }
+            }
+
+            if (maxConf >= threshold && maxClass > 0)
+            {
+                // Extract bounding box from last 4 values (normalized coordinates)
+                Vector<T> bbox;
+                if (hasBbox && hiddenDim >= 4)
+                {
+                    int bboxStart = hiddenDim - 4;
+                    double x1 = NumOps.ToDouble(output[i, bboxStart]) * ImageSize;
+                    double y1 = NumOps.ToDouble(output[i, bboxStart + 1]) * ImageSize;
+                    double x2 = NumOps.ToDouble(output[i, bboxStart + 2]) * ImageSize;
+                    double y2 = NumOps.ToDouble(output[i, bboxStart + 3]) * ImageSize;
+
+                    bbox = new Vector<T>([
+                        NumOps.FromDouble(Math.Max(0, x1)),
+                        NumOps.FromDouble(Math.Max(0, y1)),
+                        NumOps.FromDouble(Math.Min(ImageSize, x2)),
+                        NumOps.FromDouble(Math.Min(ImageSize, y2))
+                    ]);
+                }
+                else
+                {
+                    // Grid-based fallback for node index
+                    int gridSize = (int)Math.Sqrt(numNodes);
+                    int cellSize = ImageSize / Math.Max(1, gridSize);
+                    int row = i / gridSize;
+                    int col = i % gridSize;
+
+                    bbox = new Vector<T>([
+                        NumOps.FromDouble(col * cellSize),
+                        NumOps.FromDouble(row * cellSize),
+                        NumOps.FromDouble((col + 1) * cellSize),
+                        NumOps.FromDouble((row + 1) * cellSize)
+                    ]);
+                }
+
+                regions.Add(new LayoutRegion<T>
+                {
+                    ElementType = (LayoutElementType)Math.Min(maxClass, (int)LayoutElementType.Other),
+                    Confidence = NumOps.FromDouble(maxConf),
+                    ConfidenceValue = maxConf,
+                    Index = i,
+                    BoundingBox = bbox
+                });
+            }
+        }
+
+        return regions;
+    }
+
+    #endregion
+
+    #region IDocumentModel Implementation
+
+    /// <inheritdoc/>
+    public Tensor<T> EncodeDocument(Tensor<T> documentImage)
+    {
+        ValidateImageShape(documentImage);
+        var preprocessed = PreprocessDocument(documentImage);
+        return _useNativeMode ? Forward(preprocessed) : RunOnnxInference(preprocessed);
+    }
+
+    /// <inheritdoc/>
+    public void ValidateInputShape(Tensor<T> documentImage)
+    {
+        ValidateImageShape(documentImage);
+    }
+
+    /// <inheritdoc/>
+    public string GetModelSummary()
+    {
+        var sb = new System.Text.StringBuilder();
+        sb.AppendLine("DocGCN Model Summary");
+        sb.AppendLine("====================");
+        sb.AppendLine($"Mode: {(_useNativeMode ? "Native (Trainable)" : "ONNX (Inference)")}");
+        sb.AppendLine($"Architecture: Graph Convolutional Network");
+        sb.AppendLine($"Node Dimension: {_nodeDim}");
+        sb.AppendLine($"Edge Dimension: {_edgeDim}");
+        sb.AppendLine($"GCN Layers: {_gcnLayers}");
+        sb.AppendLine($"Max Nodes: {_maxNodes}");
+        sb.AppendLine($"Number of Classes: {_numClasses}");
+        sb.AppendLine($"Graph-Based: Yes");
+        sb.AppendLine($"Total Layers: {Layers.Count}");
+        return sb.ToString();
+    }
+
+    #endregion
+
+    #region Preprocessing
+
+    /// <summary>
+    /// Applies DocGCN's industry-standard preprocessing: simple normalization to [0,1].
+    /// </summary>
+    /// <remarks>
+    /// DocGCN uses basic normalization (divide by 255) since the focus is on graph-based processing.
+    /// </remarks>
+    protected override Tensor<T> ApplyDefaultPreprocessing(Tensor<T> rawImage)
+    {
+        var image = EnsureBatchDimension(rawImage);
+        int batchSize = image.Shape[0];
+        int channels = image.Shape[1];
+        int height = image.Shape[2];
+        int width = image.Shape[3];
+
+        var normalized = new Tensor<T>(image._shape);
+        for (int i = 0; i < image.Data.Length; i++)
+        {
+            normalized.Data.Span[i] = NumOps.FromDouble(NumOps.ToDouble(image.Data.Span[i]) / 255.0);
+        }
+        return normalized;
+    }
+
+    /// <summary>
+    /// Applies DocGCN's industry-standard postprocessing: pass-through (node classifications are already final).
+    /// </summary>
+    protected override Tensor<T> ApplyDefaultPostprocessing(Tensor<T> modelOutput) => modelOutput;
+
+    #endregion
+
+    #region Serialization
+
+    /// <inheritdoc/>
+    public override ModelMetadata<T> GetModelMetadata()
+    {
+        return new ModelMetadata<T>
+        {
+            Name = "DocGCN",
+            Description = "DocGCN for graph-based document understanding",
+            FeatureCount = _nodeDim,
+            Complexity = _gcnLayers,
+            AdditionalInfo = new Dictionary<string, object>
+            {
+                { "node_dim", _nodeDim },
+                { "edge_dim", _edgeDim },
+                { "gcn_layers", _gcnLayers },
+                { "num_classes", _numClasses },
+                { "max_nodes", _maxNodes },
+                { "use_native_mode", _useNativeMode }
+            },
+            ModelData = SafeSerialize()
+        };
+    }
+
+    /// <inheritdoc/>
+
+
+    /// <inheritdoc/>
+
+
+    #endregion
+
+    #region NeuralNetworkBase Implementation
+
+    /// <inheritdoc/>
+    protected override Tensor<T> PredictCore(Tensor<T> input)
+    {
+        var preprocessed = PreprocessDocument(input);
+        return _useNativeMode ? Forward(preprocessed) : RunOnnxInference(preprocessed);
+    }
+
+    /// <summary>
+    /// Modality-robust HETEROGENEOUS-graph inference (Luo et al. 2022 — DocGCN is a heterogeneous
+    /// graph over text/visual/layout nodes). Each argument is one modality's node-feature matrix
+    /// (<c>[N_modality, F]</c>, sharing the feature dim <c>F</c>); present modalities are stacked along
+    /// the NODE axis into one joint heterogeneous node set that the shared GCN stack reasons over.
+    /// Supplying a single modality (or null for the others) gracefully degrades to that modality —
+    /// reference DocGCN impls expect a pre-fused node set, so accepting missing modalities is where
+    /// this exceeds them.
+    /// </summary>
+    /// <param name="modalityNodeFeatures">One rank-2 <c>[N, F]</c> node-feature matrix per modality;
+    /// null entries (absent modalities) are skipped.</param>
+    public Tensor<T> PredictMultimodal(params Tensor<T>?[] modalityNodeFeatures)
+    {
+        if (!_useNativeMode)
+            throw new NotSupportedException("Multimodal fusion is only available in native mode.");
+        if (modalityNodeFeatures is null)
+            throw new ArgumentNullException(nameof(modalityNodeFeatures));
+
+        var present = System.Array.FindAll(modalityNodeFeatures, m => m is not null);
+        if (present.Length == 0)
+            throw new ArgumentException("PredictMultimodal requires at least one non-null modality node-feature matrix.", nameof(modalityNodeFeatures));
+
+        SetTrainingMode(false);
+        var fused = present.Length == 1
+            ? present[0]!
+            : Engine.TensorConcatenate(System.Array.ConvertAll(present, m => m!), axis: 0); // [ΣN_modality, F]
+        return Forward(fused);
+    }
+
+    /// <inheritdoc/>
+    public override void Train(Tensor<T> input, Tensor<T> expectedOutput)
+    {
+        if (!_useNativeMode)
+            throw new NotSupportedException("Training not supported in ONNX mode.");
+
+        // TrainWithTape already runs the forward, backprop, and optimizer update. The manual
+        // UpdateParameters(CollectGradients()) that followed was a redundant SECOND gradient step whose
+        // hand-collected vector length didn't match GetParameters, crashing training. Use the tape only.
+        SetTrainingMode(true);
+        try
+        {
+            TrainWithTape(input, expectedOutput, _optimizer);
+        }
+        finally
+        {
+            SetTrainingMode(false);
+        }
+    }
+
+    // UpdateParameters applied a GRADIENT STEP, but its one-argument form is the value setter and every caller passes values -- the override corrupted the model. Removed under AIDN082.
+
+
+    /// <summary>
+    /// Parameters cannot be written while the model is backed by a loaded ONNX graph: the weights
+    /// belong to that graph, not to this instance.
+    /// </summary>
+    /// <remarks>
+    /// Replaces a hand-written throw that used to sit inside UpdateParameters. The base checks this
+    /// on every mutating entry point rather than the one member the throw happened to guard, and
+    /// reading -- ParameterCount and GetParameters -- stays available either way.
+    /// </remarks>
     protected override bool SupportsParameterMutation => _useNativeMode;
-    #endregion
-
-    #region Disposal
-
-    /// <inheritdoc/>
-    protected override void Dispose(bool disposing)
-    {
-        if (disposing)
-            _onnxSession?.Dispose();
-        base.Dispose(disposing);
-    }
-
-    #endregion
-
-    #region Graph convolution
-
-    /// <summary>
-    /// Learned per-node position over reading order, and the graph-convolution stack that consumes
-    /// it. Both are held OUTSIDE <c>Layers</c> and surfaced through
-    /// <see cref="GetExtraTrainableLayers"/>, the base's hook for trainable layers the sequential
-    /// chain does not walk -- putting them in the chain would hand an index lookup a hidden state,
-    /// which is exactly how the equivalent change broke LayoutGraph before it was moved off-chain.
-    /// </summary>
-    private EmbeddingLayer<T>? _nodeOrderEmbedding;
-
-    private readonly List<GraphConvolutionalLayer<T>> _graphConvolutions = [];
-
-    /// <inheritdoc/>
-    protected override IEnumerable<LayerBase<T>?> GetExtraTrainableLayers()
-    {
-        EnsureGraphPathBuilt();
-        yield return _nodeOrderEmbedding;
-        foreach (var conv in _graphConvolutions) yield return conv;
-    }
-
-    /// <summary>Builds the graph path once. Cheap no-op afterwards.</summary>
-    private void EnsureGraphPathBuilt()
-    {
-        if (_nodeOrderEmbedding is not null) return;
-
-        _nodeOrderEmbedding = new EmbeddingLayer<T>(Math.Max(1, _maxNodes), _edgeDim);
-
-        // A * X * W per Kipf and Welling, which is what Doc-GCN's semantic and syntactic branches
-        // are built on. implicitIdentityWhenUnset stays false: a GCN with no adjacency is a Dense
-        // layer wearing a different name, and silently becoming one is the confusion this whole
-        // change exists to remove.
-        int inFeatures = _nodeDim;
-        for (int i = 0; i < Math.Max(1, _gcnLayers); i++)
-        {
-            _graphConvolutions.Add(new GraphConvolutionalLayer<T>(
-                inFeatures, _edgeDim, (IActivationFunction<T>?)null));
-            inFeatures = _edgeDim;
-        }
-    }
-
-    /// <inheritdoc/>
-    protected override Tensor<T> Forward(Tensor<T> input) => RunGraphOrDefault(input, training: false);
-
-    /// <inheritdoc/>
-    public override Tensor<T> ForwardForTraining(Tensor<T> input) => RunGraphOrDefault(input, training: true);
-
-    /// <summary>
-    /// Runs real graph convolution when the caller supplies an adjacency matrix, and the documented
-    /// per-node path when they do not.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// The default path is left BYTE-IDENTICAL on purpose. This model documents its no-GCN stack as
-    /// the paper's "others" branch and its 1e-3 Adam rate was chosen against that, with measurements
-    /// recorded in this file; diverting unconditionally would falsify both. It also matters
-    /// mechanically -- routing the default through a hand-written walk instead of the base one made
-    /// analytic and finite-difference gradients disagree on every sampled parameter in LayoutGraph,
-    /// because the base path owns dropout, seed wiring and checkpointing.
-    /// </para>
-    /// <para>
-    /// The adjacency arrives as <c>[numNodes, numNodes]</c> through the base auxiliary input, so it
-    /// reaches Train as well as Predict.
-    /// </para>
-    /// </remarks>
-    private Tensor<T> RunGraphOrDefault(Tensor<T> input, bool training)
-    {
-        var adjacency = AuxiliaryInput;
-        bool usable = adjacency is not null
-            && adjacency.Rank == 2
-            && adjacency.Shape[0] == adjacency.Shape[1]
-            && input.Rank == 2
-            && input.Shape[0] == adjacency.Shape[0];
-
-        if (!usable)
-        {
-            return training ? base.ForwardForTraining(input) : base.Forward(input);
-        }
-
-        EnsureGraphPathBuilt();
-        if (training) EnsureLayerRandomSeedsWired();
-
-        var hidden = input;
-        foreach (var conv in _graphConvolutions)
-        {
-            conv.SetAdjacencyMatrix(adjacency!);
-            hidden = conv.Forward(hidden);
-        }
-
-        // Node order, added in the graph hidden space once the convolutions have produced it.
-        var positions = new Tensor<T>([hidden.Shape[0]]);
-        for (int i = 0; i < positions.Length; i++)
-        {
-            positions[i] = NumOps.FromDouble(Math.Min(i, Math.Max(1, _maxNodes) - 1));
-        }
-
-        var order = _nodeOrderEmbedding!.Forward(positions);
-        if (order.Rank == hidden.Rank && order.Length == hidden.Length)
-        {
-            hidden = Engine.TensorAdd(hidden, order);
-        }
-
-        // Classifier head: the tail of the declared stack, reused so the graph path and the default
-        // path end in the same trained classifier rather than two that drift apart.
-        for (int i = Layers.Count - 2; i < Layers.Count; i++)
-        {
-            if (i >= 0) hidden = Layers[i].Forward(hidden);
-        }
-
-        return hidden;
-    }
-
-    #endregion
-}
+    #endregion
+
+    #region Disposal
+
+    /// <inheritdoc/>
+    protected override void Dispose(bool disposing)
+    {
+        if (disposing)
+            _onnxSession?.Dispose();
+        base.Dispose(disposing);
+    }
+
+    #endregion
+
+    #region Graph convolution
+
+    /// <summary>
+    /// Learned per-node position over reading order, and the graph-convolution stack that consumes
+    /// it. Both are held OUTSIDE <c>Layers</c> and surfaced through
+    /// <see cref="GetExtraTrainableLayers"/>, the base's hook for trainable layers the sequential
+    /// chain does not walk -- putting them in the chain would hand an index lookup a hidden state,
+    /// which is exactly how the equivalent change broke LayoutGraph before it was moved off-chain.
+    /// </summary>
+    private EmbeddingLayer<T>? _nodeOrderEmbedding;
+
+    private readonly List<GraphConvolutionalLayer<T>> _graphConvolutions = [];
+
+    /// <summary>Builds the graph path once. Cheap no-op afterwards.</summary>
+    private void EnsureGraphPathBuilt()
+    {
+        if (_nodeOrderEmbedding is not null) return;
+
+        _nodeOrderEmbedding = new EmbeddingLayer<T>(Math.Max(1, _maxNodes), _edgeDim);
+
+        // A * X * W per Kipf and Welling, which is what Doc-GCN's semantic and syntactic branches
+        // are built on. implicitIdentityWhenUnset stays false: a GCN with no adjacency is a Dense
+        // layer wearing a different name, and silently becoming one is the confusion this whole
+        // change exists to remove.
+        int inFeatures = _nodeDim;
+        for (int i = 0; i < Math.Max(1, _gcnLayers); i++)
+        {
+            _graphConvolutions.Add(new GraphConvolutionalLayer<T>(
+                inFeatures, _edgeDim, (IActivationFunction<T>?)null));
+            inFeatures = _edgeDim;
+        }
+    }
+
+    /// <inheritdoc/>
+    protected override Tensor<T> Forward(Tensor<T> input) => RunGraphOrDefault(input, training: false);
+
+    /// <inheritdoc/>
+    public override Tensor<T> ForwardForTraining(Tensor<T> input) => RunGraphOrDefault(input, training: true);
+
+    /// <summary>
+    /// Runs real graph convolution when the caller supplies an adjacency matrix, and the documented
+    /// per-node path when they do not.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// The default path is left BYTE-IDENTICAL on purpose. This model documents its no-GCN stack as
+    /// the paper's "others" branch and its 1e-3 Adam rate was chosen against that, with measurements
+    /// recorded in this file; diverting unconditionally would falsify both. It also matters
+    /// mechanically -- routing the default through a hand-written walk instead of the base one made
+    /// analytic and finite-difference gradients disagree on every sampled parameter in LayoutGraph,
+    /// because the base path owns dropout, seed wiring and checkpointing.
+    /// </para>
+    /// <para>
+    /// The adjacency arrives as <c>[numNodes, numNodes]</c> through the base auxiliary input, so it
+    /// reaches Train as well as Predict.
+    /// </para>
+    /// </remarks>
+    private Tensor<T> RunGraphOrDefault(Tensor<T> input, bool training)
+    {
+        var adjacency = AuxiliaryInput;
+        bool usable = adjacency is not null
+            && adjacency.Rank == 2
+            && adjacency.Shape[0] == adjacency.Shape[1]
+            && input.Rank == 2
+            && input.Shape[0] == adjacency.Shape[0];
+
+        if (!usable)
+        {
+            return training ? base.ForwardForTraining(input) : base.Forward(input);
+        }
+
+        EnsureGraphPathBuilt();
+        if (training) EnsureLayerRandomSeedsWired();
+
+        var hidden = input;
+        foreach (var conv in _graphConvolutions)
+        {
+            conv.SetAdjacencyMatrix(adjacency!);
+            hidden = conv.Forward(hidden);
+        }
+
+        // Node order, added in the graph hidden space once the convolutions have produced it.
+        var positions = new Tensor<T>([hidden.Shape[0]]);
+        for (int i = 0; i < positions.Length; i++)
+        {
+            positions[i] = NumOps.FromDouble(Math.Min(i, Math.Max(1, _maxNodes) - 1));
+        }
+
+        var order = _nodeOrderEmbedding!.Forward(positions);
+        if (order.Rank == hidden.Rank && order.Length == hidden.Length)
+        {
+            hidden = Engine.TensorAdd(hidden, order);
+        }
+
+        // Classifier head: the tail of the declared stack, reused so the graph path and the default
+        // path end in the same trained classifier rather than two that drift apart.
+        for (int i = Layers.Count - 2; i < Layers.Count; i++)
+        {
+            if (i >= 0) hidden = Layers[i].Forward(hidden);
+        }
+
+        return hidden;
+    }
+
+    #endregion
+}
diff --git a/src/Document/GraphBased/LayoutGraph.cs b/src/Document/GraphBased/LayoutGraph.cs
index 0cbcab719d..1587b5e6bc 100644
--- a/src/Document/GraphBased/LayoutGraph.cs
+++ b/src/Document/GraphBased/LayoutGraph.cs
@@ -1,728 +1,701 @@
-using AiDotNet.Attributes;
-using AiDotNet.Document.Interfaces;
-using AiDotNet.Document.Options;
-using AiDotNet.Enums;
-using AiDotNet.Helpers;
-using AiDotNet.Interfaces;
-using AiDotNet.LinearAlgebra;
-using AiDotNet.LossFunctions;
-using AiDotNet.NeuralNetworks;
-using AiDotNet.NeuralNetworks.Layers;
-using AiDotNet.Optimizers;
-using Microsoft.ML.OnnxRuntime;
-
-namespace AiDotNet.Document.GraphBased;
-
-/// <summary>
-/// LayoutGraph for graph-based document layout analysis.
-/// </summary>
-/// <typeparam name="T">The numeric type used for calculations.</typeparam>
-/// <remarks>
-/// <para>
-/// LayoutGraph constructs and analyzes graphs from document layouts, where nodes
-/// represent document elements and edges encode spatial relationships. It excels
-/// at understanding hierarchical document structures.
-/// </para>
-/// <para>
-/// <b>For Beginners:</b> LayoutGraph analyzes how document parts relate:
-/// 1. Builds a graph from document structure
-/// 2. Models reading order and containment
-/// 3. Learns hierarchical relationships
-/// 4. Predicts document element types and groupings
-///
-/// Key features:
-/// - Hierarchical graph construction
-/// - Spatial relationship modeling
-/// - Reading order prediction
-/// - Multi-level layout understanding
-///
-/// Example usage:
-/// <code>
-/// var model = new LayoutGraph&lt;float&gt;(architecture);
-/// var result = model.DetectLayout(documentImage);
-/// </code>
-/// </para>
-/// </remarks>
-[ModelDomain(ModelDomain.Vision)]
-[ModelCategory(ModelCategory.NeuralNetwork)]
-[ModelCategory(ModelCategory.GraphNetwork)]
-[ModelTask(ModelTask.Detection)]
-[ModelTask(ModelTask.Classification)]
-[ModelComplexity(ModelComplexity.Medium)]
-[ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
-[ResearchPaper("Rethinking Table Structure Recognition Using Sequence Labeling Methods", "https://doi.org/10.48550/arXiv.2209.14469", Year = 2022, Authors = "Yibo Li, Yilun Huang, Ziyi Zhu, Lemeng Pan, Yongshuai Huang, Lin Du, Zhi Tang")]
-public partial class LayoutGraph<T> : DocumentNeuralNetworkBase<T>, ILayoutDetector<T>, IReadingOrderDetector<T>
-{
-    private readonly LayoutGraphOptions _options;
-
-    /// <inheritdoc/>
-    public override ModelOptions GetOptions() => _options;
-
-    #region Fields
-
-    private readonly bool _useNativeMode;
-    private readonly InferenceSession? _onnxSession;
-    private readonly IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>> _optimizer;
-    private int _nodeDim;
-    private int _edgeDim;
-    private int _graphLayers;
-    private int _numClasses;
-    private int _maxNodes;
-
-    // Native mode layers
-    private readonly List<ILayer<T>> _nodeEncoderLayers = [];
-    private readonly List<ILayer<T>> _edgeEncoderLayers = [];
-    private readonly List<ILayer<T>> _graphLayersList = [];
-    private readonly List<ILayer<T>> _outputLayers = [];
-
-    // Embeddings
-
-    #endregion
-
-    #region Properties
-
-    /// <inheritdoc/>
-    public override DocumentType SupportedDocumentTypes => DocumentType.All;
-
-    /// <inheritdoc/>
-    public override bool RequiresOCR => true;
-
-    /// <inheritdoc/>
-    public int ExpectedImageSize => ImageSize;
-
-    /// <summary>
-    /// Gets the node dimension.
-    /// </summary>
-    public int NodeDim => _nodeDim;
-
-    /// <inheritdoc/>
-    public IReadOnlyList<LayoutElementType> SupportedElementTypes { get; } =
-    [
-        LayoutElementType.Text,
-        LayoutElementType.Title,
-        LayoutElementType.List,
-        LayoutElementType.Table,
-        LayoutElementType.Figure,
-        LayoutElementType.Caption,
-        LayoutElementType.Header,
-        LayoutElementType.Footer,
-        LayoutElementType.FormField
-    ];
-
-    #endregion
-
-    #region Constructors
-
-    /// <summary>
-    /// Creates a LayoutGraph model using a pre-trained ONNX model for inference.
-    /// </summary>
-    public LayoutGraph(
-        NeuralNetworkArchitecture<T> architecture,
-        string onnxModelPath,
-        int nodeDim = 256,
-        int edgeDim = 64,
-        int graphLayers = 4,
-        int numClasses = 9,
-        int maxNodes = 256,
-        IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? optimizer = null,
-        ILossFunction<T>? lossFunction = null,
-        LayoutGraphOptions? options = null)
-        : base(architecture, lossFunction ?? new CrossEntropyWithLogitsLoss<T>(), 1.0)
-    {
-        _options = options ?? new LayoutGraphOptions();
-        Options = _options;
-
-        if (string.IsNullOrWhiteSpace(onnxModelPath))
-            throw new ArgumentNullException(nameof(onnxModelPath));
-        if (!File.Exists(onnxModelPath))
-            throw new FileNotFoundException($"ONNX model not found: {onnxModelPath}", onnxModelPath);
-
-        _useNativeMode = false;
-        _nodeDim = nodeDim;
-        _edgeDim = edgeDim;
-        _graphLayers = graphLayers;
-        _numClasses = numClasses;
-        _maxNodes = maxNodes;
-        _optimizer = optimizer ?? new AdamOptimizer<T, Tensor<T>, Tensor<T>>(this,
-            new AdamOptimizerOptions<T, Tensor<T>, Tensor<T>>
-            {
-                InitialLearningRate = _options.LearningRate
-            });
-
-        _onnxSession = new InferenceSession(onnxModelPath);
-
-        InitializeLayers();
-    }
-
-    /// <summary>
-    /// Creates a LayoutGraph model using native layers for training and inference.
-    /// </summary>
-    public LayoutGraph(
-        NeuralNetworkArchitecture<T> architecture,
-        int nodeDim = 256,
-        int edgeDim = 64,
-        int graphLayers = 4,
-        int numClasses = 9,
-        int maxNodes = 256,
-        IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? optimizer = null,
-        ILossFunction<T>? lossFunction = null,
-        LayoutGraphOptions? options = null)
-        : base(architecture, lossFunction ?? new CrossEntropyWithLogitsLoss<T>(), 1.0)
-    {
-        _options = options ?? new LayoutGraphOptions();
-        Options = _options;
-
-        _useNativeMode = true;
-        _nodeDim = nodeDim;
-        _edgeDim = edgeDim;
-        _graphLayers = graphLayers;
-        _numClasses = numClasses;
-        _maxNodes = maxNodes;
-        // Honor the model's configured LearningRate (the bare AdamOptimizer(this) ignored it and ran at Adam's
-        // 0.001) and enable gradient clipping so graph-conv training does not drift upward over more iterations
-        // (MoreData saw 200-iter loss 2.40 -> 2.82). Fully user-overridable via the optimizer parameter and
-        // LayoutGraphOptions.LearningRate. (#1789)
-        _optimizer = optimizer ?? new AdamOptimizer<T, Tensor<T>, Tensor<T>>(this,
-            new AiDotNet.Models.Options.AdamOptimizerOptions<T, Tensor<T>, Tensor<T>>
-            { InitialLearningRate = _options.LearningRate, EnableGradientClipping = true, MaxGradientNorm = 1.0 });
-
-        // Route base tape training through the configured optimizer. Previously _optimizer was stored but
-        // never used — TrainWithTape resolved the default base optimizer, so a caller-supplied optimizer
-        // was silently ignored. Install it as the base-train optimizer (matches SVTR<T>).
-        SetBaseTrainOptimizer(_optimizer);
-
-        InitializeLayers();
-        InitializeEmbeddings();
-    }
-
-    #endregion
-
-    #region Initialization
-
-    /// <inheritdoc/>
-    protected override void InitializeLayers()
-    {
-        if (!_useNativeMode)
-        {
-            return;
-        }
-
-        if (Architecture.Layers is not null && Architecture.Layers.Count > 0)
-        {
-            Layers.AddRange(Architecture.Layers);
-            ValidateCustomLayers(Layers);
-            return;
-        }
-
-        Layers.AddRange(LayerHelper<T>.CreateDefaultLayoutGraphLayers(
-            inputDim: _nodeDim,
-            hiddenDim: _edgeDim,
-            numGraphLayers: _graphLayers,
-            numClasses: _numClasses,
-            maxNodes: _maxNodes));
-    }
-
-    private void InitializeEmbeddings()
-    {
-        var random = RandomHelper.CreateSeededRandom(42);
-
-    }
-
-    private void InitializeWithSmallRandomValues(Tensor<T> tensor, Random random, double stdDev)
-    {
-        for (int i = 0; i < tensor.Data.Length; i++)
-        {
-            double u1 = 1.0 - random.NextDouble();
-            double u2 = 1.0 - random.NextDouble();
-            double randStdNormal = Math.Sqrt(-2.0 * Math.Log(u1)) * Math.Sin(2.0 * Math.PI * u2);
-            tensor.Data.Span[i] = NumOps.FromDouble(randStdNormal * stdDev);
-        }
-    }
-
-    #endregion
-
-    #region ILayoutDetector Implementation
-
-    /// <inheritdoc/>
-    public DocumentLayoutResult<T> DetectLayout(Tensor<T> documentImage)
-    {
-        return DetectLayout(documentImage, 0.5);
-    }
-
-    /// <inheritdoc/>
-    public DocumentLayoutResult<T> DetectLayout(Tensor<T> documentImage, double confidenceThreshold)
-    {
-        ValidateImageShape(documentImage);
-        var startTime = DateTime.UtcNow;
-
-        var preprocessed = PreprocessDocument(documentImage);
-        var output = _useNativeMode ? Forward(preprocessed) : RunOnnxInference(preprocessed);
-
-        var regions = ParseLayoutOutput(output, confidenceThreshold);
-
-        return new DocumentLayoutResult<T>
-        {
-            Regions = regions,
-            ProcessingTimeMs = (DateTime.UtcNow - startTime).TotalMilliseconds
-        };
-    }
-
-    private List<LayoutRegion<T>> ParseLayoutOutput(Tensor<T> output, double threshold)
-    {
-        var regions = new List<LayoutRegion<T>>();
-        int numNodes = Math.Min(output.Shape[0], _maxNodes);
-        int hiddenDim = output.Shape.Length > 1 ? output.Shape[1] : _numClasses;
-        int numClasses = Math.Min(hiddenDim - 4, _numClasses); // Reserve 4 for bbox
-        bool hasBbox = hiddenDim > _numClasses;
-
-        for (int i = 0; i < numNodes; i++)
-        {
-            double maxConf = 0;
-            int maxClass = 0;
-            for (int c = 0; c < numClasses; c++)
-            {
-                double conf = NumOps.ToDouble(output[i, c]);
-                if (conf > maxConf) { maxConf = conf; maxClass = c; }
-            }
-
-            if (maxConf >= threshold && maxClass > 0)
-            {
-                // Extract bounding box from last 4 values (normalized coordinates)
-                Vector<T> bbox;
-                if (hasBbox && hiddenDim >= 4)
-                {
-                    int bboxStart = hiddenDim - 4;
-                    double x1 = NumOps.ToDouble(output[i, bboxStart]) * ImageSize;
-                    double y1 = NumOps.ToDouble(output[i, bboxStart + 1]) * ImageSize;
-                    double x2 = NumOps.ToDouble(output[i, bboxStart + 2]) * ImageSize;
-                    double y2 = NumOps.ToDouble(output[i, bboxStart + 3]) * ImageSize;
-
-                    bbox = new Vector<T>([
-                        NumOps.FromDouble(Math.Max(0, x1)),
-                        NumOps.FromDouble(Math.Max(0, y1)),
-                        NumOps.FromDouble(Math.Min(ImageSize, x2)),
-                        NumOps.FromDouble(Math.Min(ImageSize, y2))
-                    ]);
-                }
-                else
-                {
-                    // Grid-based fallback for node index
-                    int gridSize = (int)Math.Sqrt(numNodes);
-                    int cellSize = ImageSize / Math.Max(1, gridSize);
-                    int row = i / gridSize;
-                    int col = i % gridSize;
-
-                    bbox = new Vector<T>([
-                        NumOps.FromDouble(col * cellSize),
-                        NumOps.FromDouble(row * cellSize),
-                        NumOps.FromDouble((col + 1) * cellSize),
-                        NumOps.FromDouble((row + 1) * cellSize)
-                    ]);
-                }
-
-                regions.Add(new LayoutRegion<T>
-                {
-                    ElementType = (LayoutElementType)Math.Min(maxClass, (int)LayoutElementType.Other),
-                    Confidence = NumOps.FromDouble(maxConf),
-                    ConfidenceValue = maxConf,
-                    Index = i,
-                    BoundingBox = bbox
-                });
-            }
-        }
-
-        return regions;
-    }
-
-    #endregion
-
-    #region IReadingOrderDetector Implementation
-
-    /// <inheritdoc/>
-    public ReadingOrderResult<T> DetectReadingOrder(Tensor<T> documentImage)
-    {
-        ValidateImageShape(documentImage);
-        var startTime = DateTime.UtcNow;
-
-        var preprocessed = PreprocessDocument(documentImage);
-        var output = _useNativeMode ? Forward(preprocessed) : RunOnnxInference(preprocessed);
-
-        var orderedElements = PredictReadingOrder(output);
-
-        return new ReadingOrderResult<T>
-        {
-            OrderedElements = orderedElements,
-            Confidence = NumOps.FromDouble(0.85),
-            ConfidenceValue = 0.85,
-            ProcessingTimeMs = (DateTime.UtcNow - startTime).TotalMilliseconds
-        };
-    }
-
-    /// <inheritdoc/>
-    public ReadingOrderResult<T> DetectReadingOrder(DocumentLayoutResult<T> layoutResult)
-    {
-        var orderedElements = layoutResult.Regions
-            .OrderBy(r => r.Index)
-            .Select((r, idx) => new OrderedElement<T>
-            {
-                ElementIndex = r.Index,
-                ReadingOrderPosition = idx,
-                Confidence = r.Confidence,
-                ConfidenceValue = r.ConfidenceValue
-            })
-            .ToList();
-
-        return new ReadingOrderResult<T>
-        {
-            OrderedElements = orderedElements,
-            Confidence = NumOps.FromDouble(0.8),
-            ConfidenceValue = 0.8,
-            ProcessingTimeMs = 0
-        };
-    }
-
-    private List<OrderedElement<T>> PredictReadingOrder(Tensor<T> output)
-    {
-        var elements = new List<OrderedElement<T>>();
-        int numNodes = Math.Min(output.Shape[0], _maxNodes);
-
-        for (int i = 0; i < numNodes; i++)
-        {
-            elements.Add(new OrderedElement<T>
-            {
-                ElementIndex = i,
-                ReadingOrderPosition = i,
-                Confidence = NumOps.FromDouble(0.9),
-                ConfidenceValue = 0.9
-            });
-        }
-
-        return elements;
-    }
-
-    #endregion
-
-    #region IDocumentModel Implementation
-
-    /// <inheritdoc/>
-    public Tensor<T> EncodeDocument(Tensor<T> documentImage)
-    {
-        ValidateImageShape(documentImage);
-        var preprocessed = PreprocessDocument(documentImage);
-        return _useNativeMode ? Forward(preprocessed) : RunOnnxInference(preprocessed);
-    }
-
-    /// <inheritdoc/>
-    public void ValidateInputShape(Tensor<T> documentImage)
-    {
-        ValidateImageShape(documentImage);
-    }
-
-    /// <inheritdoc/>
-    public string GetModelSummary()
-    {
-        var sb = new System.Text.StringBuilder();
-        sb.AppendLine("LayoutGraph Model Summary");
-        sb.AppendLine("=========================");
-        sb.AppendLine($"Mode: {(_useNativeMode ? "Native (Trainable)" : "ONNX (Inference)")}");
-        sb.AppendLine($"Architecture: Hierarchical Graph Network");
-        sb.AppendLine($"Node Dimension: {_nodeDim}");
-        sb.AppendLine($"Edge Dimension: {_edgeDim}");
-        sb.AppendLine($"Graph Layers: {_graphLayers}");
-        sb.AppendLine($"Max Nodes: {_maxNodes}");
-        sb.AppendLine($"Number of Classes: {_numClasses}");
-        sb.AppendLine($"Reading Order: Yes");
-        sb.AppendLine($"Total Layers: {Layers.Count}");
-        return sb.ToString();
-    }
-
-    #endregion
-
-    #region Preprocessing
-
-    /// <summary>
-    /// Applies LayoutGraph's industry-standard preprocessing: simple normalization to [0,1].
-    /// </summary>
-    /// <remarks>
-    /// LayoutGraph uses basic normalization (divide by 255) since the focus is on graph-based layout analysis.
-    /// </remarks>
-    protected override Tensor<T> ApplyDefaultPreprocessing(Tensor<T> rawImage)
-    {
-        var image = EnsureBatchDimension(rawImage);
-        var normalized = new Tensor<T>(image._shape);
-        for (int i = 0; i < image.Data.Length; i++)
-        {
-            normalized.Data.Span[i] = NumOps.FromDouble(NumOps.ToDouble(image.Data.Span[i]) / 255.0);
-        }
-        return normalized;
-    }
-
-    /// <summary>
-    /// Applies LayoutGraph's industry-standard postprocessing: pass-through (graph node classifications are already final).
-    /// </summary>
-    protected override Tensor<T> ApplyDefaultPostprocessing(Tensor<T> modelOutput) => modelOutput;
-
-    #endregion
-
-    #region Serialization
-
-    /// <inheritdoc/>
-    public override ModelMetadata<T> GetModelMetadata()
-    {
-        return new ModelMetadata<T>
-        {
-            Name = "LayoutGraph",
-            Description = "LayoutGraph for hierarchical document layout analysis",
-            FeatureCount = _nodeDim,
-            Complexity = _graphLayers,
-            AdditionalInfo = new Dictionary<string, object>
-            {
-                { "node_dim", _nodeDim },
-                { "edge_dim", _edgeDim },
-                { "graph_layers", _graphLayers },
-                { "num_classes", _numClasses },
-                { "max_nodes", _maxNodes },
-                { "use_native_mode", _useNativeMode }
-            },
-            ModelData = SafeSerialize()
-        };
-    }
-
-    /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_nodeDim);
-        writer.Write(_edgeDim);
-        writer.Write(_graphLayers);
-        writer.Write(_numClasses);
-        writer.Write(_maxNodes);
-        writer.Write(_useNativeMode);
-    }
-
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _nodeDim = reader.ReadInt32();
-        _edgeDim = reader.ReadInt32();
-        _graphLayers = reader.ReadInt32();
-        _numClasses = reader.ReadInt32();
-        _maxNodes = reader.ReadInt32();
-        _ = reader.ReadBoolean(); // useNativeMode - already set by constructor
-    }
-
-    /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new LayoutGraph<T>(Architecture, _nodeDim, _edgeDim, _graphLayers, _numClasses, _maxNodes);
-    }
-
-    #endregion
-
-    #region NeuralNetworkBase Implementation
-
-    /// <inheritdoc/>
-    protected override Tensor<T> PredictCore(Tensor<T> input)
-    {
-        var preprocessed = PreprocessDocument(input);
-        return _useNativeMode ? Forward(preprocessed) : RunOnnxInference(preprocessed);
-    }
-
-    /// <summary>
-    /// Inference forward: runs the graph layer stack and returns the per-node class logits
-    /// [numNodes, numClasses] UNCHANGED. DetectLayout, DetectReadingOrder, and ParseLayoutOutput index
-    /// this rank-2 output per node (output[node, class]); pooling it to a rank-1 [numClasses] vector here
-    /// would collapse every node and break their two-dimensional indexing. The document-level pooling
-    /// needed to align with the classification target happens only on the training path
-    /// (<see cref="ForwardForTraining"/>).
-    /// </summary>
-    protected override Tensor<T> Forward(Tensor<T> input)
-    {
-        // Unchanged when no node types are supplied -- the plain walk below IS the previous
-        // behaviour, and keeping it byte-identical matters: routing the default path through a
-        // hand-written walk instead of the base one made the analytic and finite-difference
-        // gradients disagree on every sampled parameter, because the base path owns dropout,
-        // seed wiring and checkpointing that a bare Layers[i].Forward loop does not reproduce.
-        if (AuxiliaryInput is null || AuxiliaryInput.Length == 0)
-        {
-            var plain = input;
-            foreach (var layer in Layers) plain = layer.Forward(plain);
-            return plain;
-        }
-
-        return RunWithNodeTypes(input);
-    }
-
-    /// <summary>
-    /// Training forward: runs the base training forward (which wires layer seeds and applies gradient
-    /// checkpointing / weight streaming over the graph layers), then mean-pools every axis but the class
-    /// axis so the per-node logits [numNodes, numClasses] reduce to the document-level [numClasses] logit
-    /// vector the classification target expects. Without this pooling the rank-2 tensor cannot align to
-    /// the rank-1 [numClasses] target and CrossEntropyWithLogits over-indexes ClassIndicesToOneHot and
-    /// throws. All ops are tape-aware, so training back-propagates through the pool into the graph layers.
-    /// Inference (PredictCore → Forward) deliberately skips this pooling to keep the per-node output.
-    /// </summary>
-    public override Tensor<T> ForwardForTraining(Tensor<T> input)
-    {
-        // Default path stays on base.ForwardForTraining, which owns seed wiring, gradient
-        // checkpointing and weight streaming. Only a call that actually supplies node types diverts,
-        // and that one wires seeds itself per EnsureLayerRandomSeedsWired's contract.
-        Tensor<T> output;
-        if (AuxiliaryInput is null || AuxiliaryInput.Length == 0)
-        {
-            output = base.ForwardForTraining(input);
-        }
-        else
-        {
-            EnsureLayerRandomSeedsWired();
-            output = RunWithNodeTypes(input);
-        }
-
-        if (output.Shape.Length >= 2)
-        {
-            int classAxis = output.Shape.Length - 1;
-            var poolAxes = new int[classAxis];
-            for (int a = 0; a < classAxis; a++) poolAxes[a] = a;
-            output = Engine.ReduceMean(output, poolAxes, keepDims: false); // → [numClasses]
-        }
-        return output;
-    }
-
-    /// <inheritdoc/>
-    public override void Train(Tensor<T> input, Tensor<T> expectedOutput)
-    {
-        if (!_useNativeMode)
-            throw new NotSupportedException("Training not supported in ONNX mode.");
-
-        SetTrainingMode(true);
-        try
-        {
-            // TrainWithTape performs the complete forward + backward + optimizer step over the tape. The
-            // previous code then ALSO ran a manual UpdateParameters(CollectGradients()) gradient-descent step
-            // on top of it — a double update that reads gradients TrainWithTape already consumed and pushes
-            // the weights past the tape's step. One tape step is the correct, complete update.
-            TrainWithTape(input, expectedOutput, _optimizer);
-        }
-        finally
-        {
-            // Restore inference mode even if TrainWithTape throws, so a failed step doesn't leave
-            // BatchNorm/Dropout stuck in training mode for subsequent inference.
-            SetTrainingMode(false);
-        }
-    }
-
-    // UpdateParameters applied a GRADIENT STEP, but its one-argument form is the value setter and every caller passes values -- the override corrupted the model. Removed under AIDN082.

-
-    /// <summary>
-    /// Parameters cannot be written while the model is backed by a loaded ONNX graph: the weights
-    /// belong to that graph, not to this instance.
-    /// </summary>
-    /// <remarks>
-    /// Replaces a hand-written throw that used to sit inside UpdateParameters. The base checks this
-    /// on every mutating entry point rather than the one member the throw happened to guard, and
-    /// reading -- ParameterCount and GetParameters -- stays available either way.
-    /// </remarks>
+using AiDotNet.Attributes;
+using AiDotNet.Document.Interfaces;
+using AiDotNet.Document.Options;
+using AiDotNet.Enums;
+using AiDotNet.Helpers;
+using AiDotNet.Interfaces;
+using AiDotNet.LinearAlgebra;
+using AiDotNet.LossFunctions;
+using AiDotNet.NeuralNetworks;
+using AiDotNet.NeuralNetworks.Layers;
+using AiDotNet.Optimizers;
+using Microsoft.ML.OnnxRuntime;
+
+namespace AiDotNet.Document.GraphBased;
+
+/// <summary>
+/// LayoutGraph for graph-based document layout analysis.
+/// </summary>
+/// <typeparam name="T">The numeric type used for calculations.</typeparam>
+/// <remarks>
+/// <para>
+/// LayoutGraph constructs and analyzes graphs from document layouts, where nodes
+/// represent document elements and edges encode spatial relationships. It excels
+/// at understanding hierarchical document structures.
+/// </para>
+/// <para>
+/// <b>For Beginners:</b> LayoutGraph analyzes how document parts relate:
+/// 1. Builds a graph from document structure
+/// 2. Models reading order and containment
+/// 3. Learns hierarchical relationships
+/// 4. Predicts document element types and groupings
+///
+/// Key features:
+/// - Hierarchical graph construction
+/// - Spatial relationship modeling
+/// - Reading order prediction
+/// - Multi-level layout understanding
+///
+/// Example usage:
+/// <code>
+/// var model = new LayoutGraph&lt;float&gt;(architecture);
+/// var result = model.DetectLayout(documentImage);
+/// </code>
+/// </para>
+/// </remarks>
+[ModelDomain(ModelDomain.Vision)]
+[ModelCategory(ModelCategory.NeuralNetwork)]
+[ModelCategory(ModelCategory.GraphNetwork)]
+[ModelTask(ModelTask.Detection)]
+[ModelTask(ModelTask.Classification)]
+[ModelComplexity(ModelComplexity.Medium)]
+[ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
+[ResearchPaper("Rethinking Table Structure Recognition Using Sequence Labeling Methods", "https://doi.org/10.48550/arXiv.2209.14469", Year = 2022, Authors = "Yibo Li, Yilun Huang, Ziyi Zhu, Lemeng Pan, Yongshuai Huang, Lin Du, Zhi Tang")]
+public partial class LayoutGraph<T> : DocumentNeuralNetworkBase<T>, ILayoutDetector<T>, IReadingOrderDetector<T>
+{
+    private readonly LayoutGraphOptions _options;
+
+    /// <inheritdoc/>
+    public override ModelOptions GetOptions() => _options;
+
+    #region Fields
+
+    private readonly bool _useNativeMode;
+    private readonly InferenceSession? _onnxSession;
+    private readonly IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>> _optimizer;
+    private int _nodeDim;
+    private int _edgeDim;
+    private int _graphLayers;
+    private int _numClasses;
+    private int _maxNodes;
+
+    // Native mode layers
+    private readonly List<ILayer<T>> _nodeEncoderLayers = [];
+    private readonly List<ILayer<T>> _edgeEncoderLayers = [];
+    private readonly List<ILayer<T>> _graphLayersList = [];
+    private readonly List<ILayer<T>> _outputLayers = [];
+
+    // Embeddings
+
+    #endregion
+
+    #region Properties
+
+    /// <inheritdoc/>
+    public override DocumentType SupportedDocumentTypes => DocumentType.All;
+
+    /// <inheritdoc/>
+    public override bool RequiresOCR => true;
+
+    /// <inheritdoc/>
+    public int ExpectedImageSize => ImageSize;
+
+    /// <summary>
+    /// Gets the node dimension.
+    /// </summary>
+    public int NodeDim => _nodeDim;
+
+    /// <inheritdoc/>
+    public IReadOnlyList<LayoutElementType> SupportedElementTypes { get; } =
+    [
+        LayoutElementType.Text,
+        LayoutElementType.Title,
+        LayoutElementType.List,
+        LayoutElementType.Table,
+        LayoutElementType.Figure,
+        LayoutElementType.Caption,
+        LayoutElementType.Header,
+        LayoutElementType.Footer,
+        LayoutElementType.FormField
+    ];
+
+    #endregion
+
+    #region Constructors
+
+    /// <summary>
+    /// Creates a LayoutGraph model using a pre-trained ONNX model for inference.
+    /// </summary>
+    public LayoutGraph(
+        NeuralNetworkArchitecture<T> architecture,
+        string onnxModelPath,
+        int nodeDim = 256,
+        int edgeDim = 64,
+        int graphLayers = 4,
+        int numClasses = 9,
+        int maxNodes = 256,
+        IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? optimizer = null,
+        ILossFunction<T>? lossFunction = null,
+        LayoutGraphOptions? options = null)
+        : base(architecture, lossFunction ?? new CrossEntropyWithLogitsLoss<T>(), 1.0)
+    {
+        _options = options ?? new LayoutGraphOptions();
+        Options = _options;
+
+        if (string.IsNullOrWhiteSpace(onnxModelPath))
+            throw new ArgumentNullException(nameof(onnxModelPath));
+        if (!File.Exists(onnxModelPath))
+            throw new FileNotFoundException($"ONNX model not found: {onnxModelPath}", onnxModelPath);
+
+        _useNativeMode = false;
+        _nodeDim = nodeDim;
+        _edgeDim = edgeDim;
+        _graphLayers = graphLayers;
+        _numClasses = numClasses;
+        _maxNodes = maxNodes;
+        _optimizer = optimizer ?? new AdamOptimizer<T, Tensor<T>, Tensor<T>>(this,
+            new AdamOptimizerOptions<T, Tensor<T>, Tensor<T>>
+            {
+                InitialLearningRate = _options.LearningRate
+            });
+
+        _onnxSession = new InferenceSession(onnxModelPath);
+
+        InitializeLayers();
+    }
+
+    /// <summary>
+    /// Creates a LayoutGraph model using native layers for training and inference.
+    /// </summary>
+    public LayoutGraph(
+        NeuralNetworkArchitecture<T> architecture,
+        int nodeDim = 256,
+        int edgeDim = 64,
+        int graphLayers = 4,
+        int numClasses = 9,
+        int maxNodes = 256,
+        IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? optimizer = null,
+        ILossFunction<T>? lossFunction = null,
+        LayoutGraphOptions? options = null)
+        : base(architecture, lossFunction ?? new CrossEntropyWithLogitsLoss<T>(), 1.0)
+    {
+        _options = options ?? new LayoutGraphOptions();
+        Options = _options;
+
+        _useNativeMode = true;
+        _nodeDim = nodeDim;
+        _edgeDim = edgeDim;
+        _graphLayers = graphLayers;
+        _numClasses = numClasses;
+        _maxNodes = maxNodes;
+        // Honor the model's configured LearningRate (the bare AdamOptimizer(this) ignored it and ran at Adam's
+        // 0.001) and enable gradient clipping so graph-conv training does not drift upward over more iterations
+        // (MoreData saw 200-iter loss 2.40 -> 2.82). Fully user-overridable via the optimizer parameter and
+        // LayoutGraphOptions.LearningRate. (#1789)
+        _optimizer = optimizer ?? new AdamOptimizer<T, Tensor<T>, Tensor<T>>(this,
+            new AiDotNet.Models.Options.AdamOptimizerOptions<T, Tensor<T>, Tensor<T>>
+            { InitialLearningRate = _options.LearningRate, EnableGradientClipping = true, MaxGradientNorm = 1.0 });
+
+        // Route base tape training through the configured optimizer. Previously _optimizer was stored but
+        // never used — TrainWithTape resolved the default base optimizer, so a caller-supplied optimizer
+        // was silently ignored. Install it as the base-train optimizer (matches SVTR<T>).
+        SetBaseTrainOptimizer(_optimizer);
+
+        InitializeLayers();
+        InitializeEmbeddings();
+    }
+
+    #endregion
+
+    #region Initialization
+
+    /// <inheritdoc/>
+    protected override void InitializeLayers()
+    {
+        if (!_useNativeMode)
+        {
+            return;
+        }
+
+        if (Architecture.Layers is not null && Architecture.Layers.Count > 0)
+        {
+            Layers.AddRange(Architecture.Layers);
+            ValidateCustomLayers(Layers);
+            return;
+        }
+
+        Layers.AddRange(LayerHelper<T>.CreateDefaultLayoutGraphLayers(
+            inputDim: _nodeDim,
+            hiddenDim: _edgeDim,
+            numGraphLayers: _graphLayers,
+            numClasses: _numClasses,
+            maxNodes: _maxNodes));
+    }
+
+    private void InitializeEmbeddings()
+    {
+        var random = RandomHelper.CreateSeededRandom(42);
+
+    }
+
+    private void InitializeWithSmallRandomValues(Tensor<T> tensor, Random random, double stdDev)
+    {
+        for (int i = 0; i < tensor.Data.Length; i++)
+        {
+            double u1 = 1.0 - random.NextDouble();
+            double u2 = 1.0 - random.NextDouble();
+            double randStdNormal = Math.Sqrt(-2.0 * Math.Log(u1)) * Math.Sin(2.0 * Math.PI * u2);
+            tensor.Data.Span[i] = NumOps.FromDouble(randStdNormal * stdDev);
+        }
+    }
+
+    #endregion
+
+    #region ILayoutDetector Implementation
+
+    /// <inheritdoc/>
+    public DocumentLayoutResult<T> DetectLayout(Tensor<T> documentImage)
+    {
+        return DetectLayout(documentImage, 0.5);
+    }
+
+    /// <inheritdoc/>
+    public DocumentLayoutResult<T> DetectLayout(Tensor<T> documentImage, double confidenceThreshold)
+    {
+        ValidateImageShape(documentImage);
+        var startTime = DateTime.UtcNow;
+
+        var preprocessed = PreprocessDocument(documentImage);
+        var output = _useNativeMode ? Forward(preprocessed) : RunOnnxInference(preprocessed);
+
+        var regions = ParseLayoutOutput(output, confidenceThreshold);
+
+        return new DocumentLayoutResult<T>
+        {
+            Regions = regions,
+            ProcessingTimeMs = (DateTime.UtcNow - startTime).TotalMilliseconds
+        };
+    }
+
+    private List<LayoutRegion<T>> ParseLayoutOutput(Tensor<T> output, double threshold)
+    {
+        var regions = new List<LayoutRegion<T>>();
+        int numNodes = Math.Min(output.Shape[0], _maxNodes);
+        int hiddenDim = output.Shape.Length > 1 ? output.Shape[1] : _numClasses;
+        int numClasses = Math.Min(hiddenDim - 4, _numClasses); // Reserve 4 for bbox
+        bool hasBbox = hiddenDim > _numClasses;
+
+        for (int i = 0; i < numNodes; i++)
+        {
+            double maxConf = 0;
+            int maxClass = 0;
+            for (int c = 0; c < numClasses; c++)
+            {
+                double conf = NumOps.ToDouble(output[i, c]);
+                if (conf > maxConf) { maxConf = conf; maxClass = c; }
+            }
+
+            if (maxConf >= threshold && maxClass > 0)
+            {
+                // Extract bounding box from last 4 values (normalized coordinates)
+                Vector<T> bbox;
+                if (hasBbox && hiddenDim >= 4)
+                {
+                    int bboxStart = hiddenDim - 4;
+                    double x1 = NumOps.ToDouble(output[i, bboxStart]) * ImageSize;
+                    double y1 = NumOps.ToDouble(output[i, bboxStart + 1]) * ImageSize;
+                    double x2 = NumOps.ToDouble(output[i, bboxStart + 2]) * ImageSize;
+                    double y2 = NumOps.ToDouble(output[i, bboxStart + 3]) * ImageSize;
+
+                    bbox = new Vector<T>([
+                        NumOps.FromDouble(Math.Max(0, x1)),
+                        NumOps.FromDouble(Math.Max(0, y1)),
+                        NumOps.FromDouble(Math.Min(ImageSize, x2)),
+                        NumOps.FromDouble(Math.Min(ImageSize, y2))
+                    ]);
+                }
+                else
+                {
+                    // Grid-based fallback for node index
+                    int gridSize = (int)Math.Sqrt(numNodes);
+                    int cellSize = ImageSize / Math.Max(1, gridSize);
+                    int row = i / gridSize;
+                    int col = i % gridSize;
+
+                    bbox = new Vector<T>([
+                        NumOps.FromDouble(col * cellSize),
+                        NumOps.FromDouble(row * cellSize),
+                        NumOps.FromDouble((col + 1) * cellSize),
+                        NumOps.FromDouble((row + 1) * cellSize)
+                    ]);
+                }
+
+                regions.Add(new LayoutRegion<T>
+                {
+                    ElementType = (LayoutElementType)Math.Min(maxClass, (int)LayoutElementType.Other),
+                    Confidence = NumOps.FromDouble(maxConf),
+                    ConfidenceValue = maxConf,
+                    Index = i,
+                    BoundingBox = bbox
+                });
+            }
+        }
+
+        return regions;
+    }
+
+    #endregion
+
+    #region IReadingOrderDetector Implementation
+
+    /// <inheritdoc/>
+    public ReadingOrderResult<T> DetectReadingOrder(Tensor<T> documentImage)
+    {
+        ValidateImageShape(documentImage);
+        var startTime = DateTime.UtcNow;
+
+        var preprocessed = PreprocessDocument(documentImage);
+        var output = _useNativeMode ? Forward(preprocessed) : RunOnnxInference(preprocessed);
+
+        var orderedElements = PredictReadingOrder(output);
+
+        return new ReadingOrderResult<T>
+        {
+            OrderedElements = orderedElements,
+            Confidence = NumOps.FromDouble(0.85),
+            ConfidenceValue = 0.85,
+            ProcessingTimeMs = (DateTime.UtcNow - startTime).TotalMilliseconds
+        };
+    }
+
+    /// <inheritdoc/>
+    public ReadingOrderResult<T> DetectReadingOrder(DocumentLayoutResult<T> layoutResult)
+    {
+        var orderedElements = layoutResult.Regions
+            .OrderBy(r => r.Index)
+            .Select((r, idx) => new OrderedElement<T>
+            {
+                ElementIndex = r.Index,
+                ReadingOrderPosition = idx,
+                Confidence = r.Confidence,
+                ConfidenceValue = r.ConfidenceValue
+            })
+            .ToList();
+
+        return new ReadingOrderResult<T>
+        {
+            OrderedElements = orderedElements,
+            Confidence = NumOps.FromDouble(0.8),
+            ConfidenceValue = 0.8,
+            ProcessingTimeMs = 0
+        };
+    }
+
+    private List<OrderedElement<T>> PredictReadingOrder(Tensor<T> output)
+    {
+        var elements = new List<OrderedElement<T>>();
+        int numNodes = Math.Min(output.Shape[0], _maxNodes);
+
+        for (int i = 0; i < numNodes; i++)
+        {
+            elements.Add(new OrderedElement<T>
+            {
+                ElementIndex = i,
+                ReadingOrderPosition = i,
+                Confidence = NumOps.FromDouble(0.9),
+                ConfidenceValue = 0.9
+            });
+        }
+
+        return elements;
+    }
+
+    #endregion
+
+    #region IDocumentModel Implementation
+
+    /// <inheritdoc/>
+    public Tensor<T> EncodeDocument(Tensor<T> documentImage)
+    {
+        ValidateImageShape(documentImage);
+        var preprocessed = PreprocessDocument(documentImage);
+        return _useNativeMode ? Forward(preprocessed) : RunOnnxInference(preprocessed);
+    }
+
+    /// <inheritdoc/>
+    public void ValidateInputShape(Tensor<T> documentImage)
+    {
+        ValidateImageShape(documentImage);
+    }
+
+    /// <inheritdoc/>
+    public string GetModelSummary()
+    {
+        var sb = new System.Text.StringBuilder();
+        sb.AppendLine("LayoutGraph Model Summary");
+        sb.AppendLine("=========================");
+        sb.AppendLine($"Mode: {(_useNativeMode ? "Native (Trainable)" : "ONNX (Inference)")}");
+        sb.AppendLine($"Architecture: Hierarchical Graph Network");
+        sb.AppendLine($"Node Dimension: {_nodeDim}");
+        sb.AppendLine($"Edge Dimension: {_edgeDim}");
+        sb.AppendLine($"Graph Layers: {_graphLayers}");
+        sb.AppendLine($"Max Nodes: {_maxNodes}");
+        sb.AppendLine($"Number of Classes: {_numClasses}");
+        sb.AppendLine($"Reading Order: Yes");
+        sb.AppendLine($"Total Layers: {Layers.Count}");
+        return sb.ToString();
+    }
+
+    #endregion
+
+    #region Preprocessing
+
+    /// <summary>
+    /// Applies LayoutGraph's industry-standard preprocessing: simple normalization to [0,1].
+    /// </summary>
+    /// <remarks>
+    /// LayoutGraph uses basic normalization (divide by 255) since the focus is on graph-based layout analysis.
+    /// </remarks>
+    protected override Tensor<T> ApplyDefaultPreprocessing(Tensor<T> rawImage)
+    {
+        var image = EnsureBatchDimension(rawImage);
+        var normalized = new Tensor<T>(image._shape);
+        for (int i = 0; i < image.Data.Length; i++)
+        {
+            normalized.Data.Span[i] = NumOps.FromDouble(NumOps.ToDouble(image.Data.Span[i]) / 255.0);
+        }
+        return normalized;
+    }
+
+    /// <summary>
+    /// Applies LayoutGraph's industry-standard postprocessing: pass-through (graph node classifications are already final).
+    /// </summary>
+    protected override Tensor<T> ApplyDefaultPostprocessing(Tensor<T> modelOutput) => modelOutput;
+
+    #endregion
+
+    #region Serialization
+
+    /// <inheritdoc/>
+    public override ModelMetadata<T> GetModelMetadata()
+    {
+        return new ModelMetadata<T>
+        {
+            Name = "LayoutGraph",
+            Description = "LayoutGraph for hierarchical document layout analysis",
+            FeatureCount = _nodeDim,
+            Complexity = _graphLayers,
+            AdditionalInfo = new Dictionary<string, object>
+            {
+                { "node_dim", _nodeDim },
+                { "edge_dim", _edgeDim },
+                { "graph_layers", _graphLayers },
+                { "num_classes", _numClasses },
+                { "max_nodes", _maxNodes },
+                { "use_native_mode", _useNativeMode }
+            },
+            ModelData = SafeSerialize()
+        };
+    }
+
+    /// <inheritdoc/>
+
+
+    /// <inheritdoc/>
+
+
+    #endregion
+
+    #region NeuralNetworkBase Implementation
+
+    /// <inheritdoc/>
+    protected override Tensor<T> PredictCore(Tensor<T> input)
+    {
+        var preprocessed = PreprocessDocument(input);
+        return _useNativeMode ? Forward(preprocessed) : RunOnnxInference(preprocessed);
+    }
+
+    /// <summary>
+    /// Inference forward: runs the graph layer stack and returns the per-node class logits
+    /// [numNodes, numClasses] UNCHANGED. DetectLayout, DetectReadingOrder, and ParseLayoutOutput index
+    /// this rank-2 output per node (output[node, class]); pooling it to a rank-1 [numClasses] vector here
+    /// would collapse every node and break their two-dimensional indexing. The document-level pooling
+    /// needed to align with the classification target happens only on the training path
+    /// (<see cref="ForwardForTraining"/>).
+    /// </summary>
+    protected override Tensor<T> Forward(Tensor<T> input)
+    {
+        // Unchanged when no node types are supplied -- the plain walk below IS the previous
+        // behaviour, and keeping it byte-identical matters: routing the default path through a
+        // hand-written walk instead of the base one made the analytic and finite-difference
+        // gradients disagree on every sampled parameter, because the base path owns dropout,
+        // seed wiring and checkpointing that a bare Layers[i].Forward loop does not reproduce.
+        if (AuxiliaryInput is null || AuxiliaryInput.Length == 0)
+        {
+            var plain = input;
+            foreach (var layer in Layers) plain = layer.Forward(plain);
+            return plain;
+        }
+
+        return RunWithNodeTypes(input);
+    }
+
+    /// <summary>
+    /// Training forward: runs the base training forward (which wires layer seeds and applies gradient
+    /// checkpointing / weight streaming over the graph layers), then mean-pools every axis but the class
+    /// axis so the per-node logits [numNodes, numClasses] reduce to the document-level [numClasses] logit
+    /// vector the classification target expects. Without this pooling the rank-2 tensor cannot align to
+    /// the rank-1 [numClasses] target and CrossEntropyWithLogits over-indexes ClassIndicesToOneHot and
+    /// throws. All ops are tape-aware, so training back-propagates through the pool into the graph layers.
+    /// Inference (PredictCore → Forward) deliberately skips this pooling to keep the per-node output.
+    /// </summary>
+    public override Tensor<T> ForwardForTraining(Tensor<T> input)
+    {
+        // Default path stays on base.ForwardForTraining, which owns seed wiring, gradient
+        // checkpointing and weight streaming. Only a call that actually supplies node types diverts,
+        // and that one wires seeds itself per EnsureLayerRandomSeedsWired's contract.
+        Tensor<T> output;
+        if (AuxiliaryInput is null || AuxiliaryInput.Length == 0)
+        {
+            output = base.ForwardForTraining(input);
+        }
+        else
+        {
+            EnsureLayerRandomSeedsWired();
+            output = RunWithNodeTypes(input);
+        }
+
+        if (output.Shape.Length >= 2)
+        {
+            int classAxis = output.Shape.Length - 1;
+            var poolAxes = new int[classAxis];
+            for (int a = 0; a < classAxis; a++) poolAxes[a] = a;
+            output = Engine.ReduceMean(output, poolAxes, keepDims: false); // → [numClasses]
+        }
+        return output;
+    }
+
+    /// <inheritdoc/>
+    public override void Train(Tensor<T> input, Tensor<T> expectedOutput)
+    {
+        if (!_useNativeMode)
+            throw new NotSupportedException("Training not supported in ONNX mode.");
+
+        SetTrainingMode(true);
+        try
+        {
+            // TrainWithTape performs the complete forward + backward + optimizer step over the tape. The
+            // previous code then ALSO ran a manual UpdateParameters(CollectGradients()) gradient-descent step
+            // on top of it — a double update that reads gradients TrainWithTape already consumed and pushes
+            // the weights past the tape's step. One tape step is the correct, complete update.
+            TrainWithTape(input, expectedOutput, _optimizer);
+        }
+        finally
+        {
+            // Restore inference mode even if TrainWithTape throws, so a failed step doesn't leave
+            // BatchNorm/Dropout stuck in training mode for subsequent inference.
+            SetTrainingMode(false);
+        }
+    }
+
+    // UpdateParameters applied a GRADIENT STEP, but its one-argument form is the value setter and every caller passes values -- the override corrupted the model. Removed under AIDN082.
+
+
+    /// <summary>
+    /// Parameters cannot be written while the model is backed by a loaded ONNX graph: the weights
+    /// belong to that graph, not to this instance.
+    /// </summary>
+    /// <remarks>
+    /// Replaces a hand-written throw that used to sit inside UpdateParameters. The base checks this
+    /// on every mutating entry point rather than the one member the throw happened to guard, and
+    /// reading -- ParameterCount and GetParameters -- stays available either way.
+    /// </remarks>
     protected override bool SupportsParameterMutation => _useNativeMode;
-    #endregion
-
-    #region Disposal
-
-    /// <inheritdoc/>
-    protected override void Dispose(bool disposing)
-    {
-        if (disposing)
-            _onnxSession?.Dispose();
-        base.Dispose(disposing);
-    }
-
-    #endregion
-
-    #region Node-type fusion
-
-    /// <summary>
-    /// The per-node TYPE embedding. Held OUTSIDE Layers on purpose: it is not a step in the
-    /// sequential chain, and putting it there fed an index lookup a graph hidden state. It reaches
-    /// the parameter surface and the optimizer through GetExtraTrainableLayers instead, which is the
-    /// base's existing hook for exactly this -- a trainable layer that the chain does not walk.
-    /// </summary>
-    private readonly EmbeddingLayer<T> _nodeTypeEmbedding = new(NodeTypeCount, NodeTypeDim);
-
-    private const int NodeTypeCount = 64;
-    private const int NodeTypeDim = 256;
-
-    /// <inheritdoc/>
-    protected override IEnumerable<LayerBase<T>?> GetExtraTrainableLayers()
-    {
-        yield return _nodeTypeEmbedding;
-    }
-
-    /// <summary>
-    /// Runs the graph stack, adding a learned per-node TYPE vector when the caller supplies type ids
-    /// through the auxiliary input.
-    /// </summary>
-    /// <remarks>
-    /// _nodeTypeEmbeddings used to be a model field nothing read. Type is not derivable from the node
-    /// features -- it is a label the layout parser assigns ("title", "caption", "table") -- so unlike
-    /// node order it needs an input, which is what the base's auxiliary slot provides. Both forwards
-    /// route here, so the type embedding is on the gradient tape. With no type ids the model behaves
-    /// exactly as before.
-    /// </remarks>
-    private Tensor<T> RunWithNodeTypes(Tensor<T> input)
-    {
-        // Project to the graph hidden width first, so the type vector is added in that space rather
-        // than to the raw node features.
-        var hidden = Layers[0].Forward(input);
-
-        var types = AuxiliaryInput;
-        if (types is not null && types.Length > 0)
-        {
-            var typeVectors = _nodeTypeEmbedding.Forward(types);
-            if (typeVectors.Rank == hidden.Rank && typeVectors.Length == hidden.Length)
-            {
-                hidden = Engine.TensorAdd(hidden, typeVectors);
-            }
-        }
-
-        for (int i = 1; i < Layers.Count; i++)
-        {
-            hidden = Layers[i].Forward(hidden);
-        }
-
-        return hidden;
-    }
-
-    /// <inheritdoc/>
-    /// <remarks>
-    /// The base walks Layers as a chain and would hand the appended type table a graph hidden state.
-    /// This is the fourth site of that same pattern in this family (LiLT, SVTR, DocOwl were the
-    /// others), so the walk is reused rather than re-derived.
-    /// </remarks>
-    public override Dictionary<string, Tensor<T>> GetNamedLayerActivations(Tensor<T> input)
-    {
-        using var _ = new AiDotNet.Tensors.Engines.Autodiff.NoGradScope<T>();
-
-        var activations = new Dictionary<string, Tensor<T>>();
-        var hidden = Layers[0].Forward(input);
-        activations[$"0_{Layers[0].GetType().Name}"] = hidden;
-
-        var types = AuxiliaryInput;
-        if (types is not null && types.Length > 0)
-        {
-            var typeVectors = _nodeTypeEmbedding.Forward(types);
-            activations["node_type_embedding"] = typeVectors;
-            if (typeVectors.Rank == hidden.Rank && typeVectors.Length == hidden.Length)
-            {
-                hidden = Engine.TensorAdd(hidden, typeVectors);
-            }
-        }
-
-        for (int i = 1; i < Layers.Count; i++)
-        {
-            hidden = Layers[i].Forward(hidden);
-            activations[$"{i}_{Layers[i].GetType().Name}"] = hidden;
-        }
-
-        return activations;
-    }
-
-    #endregion
-}
+    #endregion
+
+    #region Disposal
+
+    /// <inheritdoc/>
+    protected override void Dispose(bool disposing)
+    {
+        if (disposing)
+            _onnxSession?.Dispose();
+        base.Dispose(disposing);
+    }
+
+    #endregion
+
+    #region Node-type fusion
+
+    /// <summary>
+    /// The per-node TYPE embedding. Held OUTSIDE Layers on purpose: it is not a step in the
+    /// sequential chain, and putting it there fed an index lookup a graph hidden state. It reaches
+    /// the parameter surface and the optimizer through GetExtraTrainableLayers instead, which is the
+    /// base's existing hook for exactly this -- a trainable layer that the chain does not walk.
+    /// </summary>
+    private readonly EmbeddingLayer<T> _nodeTypeEmbedding = new(NodeTypeCount, NodeTypeDim);
+
+    private const int NodeTypeCount = 64;
+    private const int NodeTypeDim = 256;
+
+    /// <summary>
+    /// Runs the graph stack, adding a learned per-node TYPE vector when the caller supplies type ids
+    /// through the auxiliary input.
+    /// </summary>
+    /// <remarks>
+    /// _nodeTypeEmbeddings used to be a model field nothing read. Type is not derivable from the node
+    /// features -- it is a label the layout parser assigns ("title", "caption", "table") -- so unlike
+    /// node order it needs an input, which is what the base's auxiliary slot provides. Both forwards
+    /// route here, so the type embedding is on the gradient tape. With no type ids the model behaves
+    /// exactly as before.
+    /// </remarks>
+    private Tensor<T> RunWithNodeTypes(Tensor<T> input)
+    {
+        // Project to the graph hidden width first, so the type vector is added in that space rather
+        // than to the raw node features.
+        var hidden = Layers[0].Forward(input);
+
+        var types = AuxiliaryInput;
+        if (types is not null && types.Length > 0)
+        {
+            var typeVectors = _nodeTypeEmbedding.Forward(types);
+            if (typeVectors.Rank == hidden.Rank && typeVectors.Length == hidden.Length)
+            {
+                hidden = Engine.TensorAdd(hidden, typeVectors);
+            }
+        }
+
+        for (int i = 1; i < Layers.Count; i++)
+        {
+            hidden = Layers[i].Forward(hidden);
+        }
+
+        return hidden;
+    }
+
+    /// <inheritdoc/>
+    /// <remarks>
+    /// The base walks Layers as a chain and would hand the appended type table a graph hidden state.
+    /// This is the fourth site of that same pattern in this family (LiLT, SVTR, DocOwl were the
+    /// others), so the walk is reused rather than re-derived.
+    /// </remarks>
+    public override Dictionary<string, Tensor<T>> GetNamedLayerActivations(Tensor<T> input)
+    {
+        using var _ = new AiDotNet.Tensors.Engines.Autodiff.NoGradScope<T>();
+
+        var activations = new Dictionary<string, Tensor<T>>();
+        var hidden = Layers[0].Forward(input);
+        activations[$"0_{Layers[0].GetType().Name}"] = hidden;
+
+        var types = AuxiliaryInput;
+        if (types is not null && types.Length > 0)
+        {
+            var typeVectors = _nodeTypeEmbedding.Forward(types);
+            activations["node_type_embedding"] = typeVectors;
+            if (typeVectors.Rank == hidden.Rank && typeVectors.Length == hidden.Length)
+            {
+                hidden = Engine.TensorAdd(hidden, typeVectors);
+            }
+        }
+
+        for (int i = 1; i < Layers.Count; i++)
+        {
+            hidden = Layers[i].Forward(hidden);
+            activations[$"{i}_{Layers[i].GetType().Name}"] = hidden;
+        }
+
+        return activations;
+    }
+
+    #endregion
+}
diff --git a/src/Document/GraphBased/PICK.cs b/src/Document/GraphBased/PICK.cs
index 25ede463ff..a67aaf4dc6 100644
--- a/src/Document/GraphBased/PICK.cs
+++ b/src/Document/GraphBased/PICK.cs
@@ -1,676 +1,647 @@
-using AiDotNet.Attributes;
-using AiDotNet.Document.Interfaces;
-using AiDotNet.Document.Options;
-using AiDotNet.Enums;
-using AiDotNet.Helpers;
-using AiDotNet.Interfaces;
-using AiDotNet.LinearAlgebra;
-using AiDotNet.LossFunctions;
-using AiDotNet.NeuralNetworks;
-using AiDotNet.NeuralNetworks.Layers;
-using AiDotNet.Optimizers;
-using AiDotNet.Models.Options;
-using AiDotNet.Tokenization;
-using AiDotNet.Tokenization.Interfaces;
-using Microsoft.ML.OnnxRuntime;
-using AiDotNet.Validation;
-
-namespace AiDotNet.Document.GraphBased;
-
-/// <summary>
-/// PICK (Processing Key Information Extraction) neural network for document key information extraction.
-/// </summary>
-/// <typeparam name="T">The numeric type used for calculations.</typeparam>
-/// <remarks>
-/// <para>
-/// PICK uses a graph neural network approach to extract key information from documents.
-/// It models text segments as nodes and their relationships as edges, enabling
-/// better understanding of document structure.
-/// </para>
-/// <para>
-/// <b>For Beginners:</b> PICK is especially good at:
-/// 1. Extracting key-value pairs from invoices and receipts
-/// 2. Understanding relationships between text segments
-/// 3. Handling complex document layouts
-/// 4. Named Entity Recognition in documents
-///
-/// Example usage:
-/// <code>
-/// var model = new PICK&lt;float&gt;(architecture);
-/// var result = model.ExtractKeyInfo(documentImage);
-/// foreach (var entity in result.Entities)
-///     Console.WriteLine($"{entity.Label}: {entity.Text}");
-/// </code>
-/// </para>
-/// <para>
-/// <b>Reference:</b> "PICK: Processing Key Information Extraction from Documents using Improved Graph Learning-Convolutional Networks" (ICPR 2020)
-/// https://arxiv.org/abs/2004.07464
-/// </para>
-/// </remarks>
-[ModelDomain(ModelDomain.Vision)]
-[ModelDomain(ModelDomain.Language)]
-[ModelCategory(ModelCategory.NeuralNetwork)]
-[ModelCategory(ModelCategory.GraphNetwork)]
-[ModelTask(ModelTask.Classification)]
-[ModelTask(ModelTask.FeatureExtraction)]
-[ModelComplexity(ModelComplexity.High)]
-[ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
-[ResearchPaper("PICK: Processing Key Information Extraction from Documents using Improved Graph Learning-Convolutional Networks", "https://doi.org/10.48550/arXiv.2004.07464", Year = 2020, Authors = "Wenwen Yu, Ning Lu, Xianbiao Qi, Ping Gong, Rong Xiao")]
-public partial class PICK<T> : DocumentNeuralNetworkBase<T>, IFormUnderstanding<T>
-{
-    private readonly PICKOptions _options;
-
-    /// <inheritdoc/>
-    public override ModelOptions GetOptions() => _options;
-
-    #region Fields
-
-    private readonly bool _useNativeMode;
-    private readonly InferenceSession? _onnxSession;
-    private readonly ITokenizer _tokenizer;
-    private readonly IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>> _optimizer;
-    private readonly int _hiddenDim;
-    private readonly int _numGcnLayers;
-    private readonly int _numHeads;
-    private readonly int _vocabSize;
-    private readonly int _numEntityTypes;
-
-    // Native mode layers
-    private readonly List<ILayer<T>> _textEncoderLayers = [];
-    private readonly List<ILayer<T>> _gcnLayers = [];
-    private readonly List<ILayer<T>> _outputLayers = [];
-
-    #endregion
-
-    #region Properties
-
-    /// <inheritdoc/>
-    public override DocumentType SupportedDocumentTypes => DocumentType.Form;
-
-    /// <inheritdoc/>
-    public override bool RequiresOCR => true;
-
-    /// <inheritdoc/>
-    public int ExpectedImageSize => ImageSize;
-
-    /// <summary>
-    /// Gets the supported entity types for extraction.
-    /// </summary>
-    public IReadOnlyList<string> SupportedEntityTypes { get; } =
-    [
-        "SELLER", "ADDRESS", "DATE", "TOTAL", "TAX", "ITEM", "QUANTITY", "PRICE",
-        "INVOICE_NUMBER", "BUYER", "PAYMENT_METHOD", "DUE_DATE", "CURRENCY", "OTHER"
-    ];
-
-    #endregion
-
-    #region Constructors
-
-    /// <summary>
-    /// Creates a PICK model using a pre-trained ONNX model for inference.
-    /// </summary>
-    public PICK(
-        NeuralNetworkArchitecture<T> architecture,
-        string onnxModelPath,
-        ITokenizer tokenizer,
-        int numEntityTypes = 14,
-        int imageSize = 512,
-        int maxSequenceLength = 512,
-        int hiddenDim = 256,
-        int numGcnLayers = 2,
-        int numHeads = 8,
-        int vocabSize = 30522,
-        IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? optimizer = null,
-        ILossFunction<T>? lossFunction = null,
-        PICKOptions? options = null)
-        : base(architecture, lossFunction ?? new CrossEntropyWithLogitsLoss<T>(), 1.0)
-    {
-        _options = options ?? new PICKOptions();
-        Options = _options;
-
-        if (string.IsNullOrWhiteSpace(onnxModelPath))
-            throw new ArgumentNullException(nameof(onnxModelPath));
-        if (!File.Exists(onnxModelPath))
-            throw new FileNotFoundException($"ONNX model not found: {onnxModelPath}", onnxModelPath);
-
-        Guard.NotNull(tokenizer);
-        _tokenizer = tokenizer;
-        _useNativeMode = false;
-        _numEntityTypes = numEntityTypes;
-        _hiddenDim = hiddenDim;
-        _numGcnLayers = numGcnLayers;
-        _numHeads = numHeads;
-        _vocabSize = vocabSize;
-        _optimizer = optimizer ?? new AdamOptimizer<T, Tensor<T>, Tensor<T>>(this,
-            new AdamOptimizerOptions<T, Tensor<T>, Tensor<T>> { InitialLearningRate = 1e-4 });
-
-        ImageSize = imageSize;
-        MaxSequenceLength = maxSequenceLength;
-
-        _onnxSession = new InferenceSession(onnxModelPath);
-
-        InitializeLayers();
-    }
-
-    /// <summary>
-    /// Creates a PICK model using native layers for training and inference.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// <b>Default Configuration (PICK from ICPR 2020):</b>
-    /// - BERT-based text encoder
-    /// - 2-layer Graph Convolutional Network
-    /// - BiLSTM for sequence modeling
-    /// - CRF decoder for NER
-    /// - Hidden dimension: 256
-    /// </para>
-    /// </remarks>
-    public PICK(
-        NeuralNetworkArchitecture<T> architecture,
-        ITokenizer? tokenizer = null,
-        int numEntityTypes = 14,
-        int imageSize = 512,
-        int maxSequenceLength = 512,
-        int hiddenDim = 256,
-        int numGcnLayers = 2,
-        int numHeads = 8,
-        int vocabSize = 30522,
-        IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? optimizer = null,
-        ILossFunction<T>? lossFunction = null,
-        PICKOptions? options = null)
-        : base(architecture, lossFunction ?? new CrossEntropyWithLogitsLoss<T>(), 1.0)
-    {
-        _options = options ?? new PICKOptions();
-        Options = _options;
-
-        _useNativeMode = true;
-        _numEntityTypes = numEntityTypes;
-        _hiddenDim = hiddenDim;
-        _numGcnLayers = numGcnLayers;
-        _numHeads = numHeads;
-        _vocabSize = vocabSize;
-        _optimizer = optimizer ?? new AdamOptimizer<T, Tensor<T>, Tensor<T>>(this,
-            new AdamOptimizerOptions<T, Tensor<T>, Tensor<T>> { InitialLearningRate = 1e-4 });
-
-        ImageSize = imageSize;
-        MaxSequenceLength = maxSequenceLength;
-
-        _tokenizer = tokenizer ?? LanguageModelTokenizerFactory.CreateForBackbone(LanguageModelBackbone.OPT);
-
-        InitializeLayers();
-    }
-
-    #endregion
-
-    #region Initialization
-
-    /// <inheritdoc/>
-    protected override void InitializeLayers()
-    {
-        if (!_useNativeMode)
-        {
-            return;
-        }
-
-        if (Architecture.Layers is not null && Architecture.Layers.Count > 0)
-        {
-            Layers.AddRange(Architecture.Layers);
-            ValidateCustomLayers(Layers);
-            return;
-        }
-
-        Layers.AddRange(LayerHelper<T>.CreateDefaultPICKLayers(
-            hiddenDim: _hiddenDim,
-            numGcnLayers: _numGcnLayers,
-            numHeads: _numHeads,
-            vocabSize: _vocabSize,
-            numEntityTypes: _numEntityTypes,
-            maxSequenceLength: MaxSequenceLength));
-    }
-
-    #endregion
-
-    #region IFormUnderstanding Implementation
-
-    /// <inheritdoc/>
-    public FormFieldResult<T> ExtractFormFields(Tensor<T> documentImage)
-    {
-        return ExtractFormFields(documentImage, 0.5);
-    }
-
-    /// <inheritdoc/>
-    public FormFieldResult<T> ExtractFormFields(Tensor<T> documentImage, double confidenceThreshold)
-    {
-        ValidateImageShape(documentImage);
-        var startTime = DateTime.UtcNow;
-
-        var preprocessed = PreprocessDocument(documentImage);
-        var output = _useNativeMode ? Forward(preprocessed) : RunOnnxInference(preprocessed);
-
-        var fields = ParseFieldOutput(output, confidenceThreshold);
-
-        return new FormFieldResult<T>
-        {
-            Fields = fields,
-            ProcessingTimeMs = (DateTime.UtcNow - startTime).TotalMilliseconds
-        };
-    }
-
-    /// <inheritdoc/>
-    public Dictionary<string, string> ExtractKeyValuePairs(Tensor<T> documentImage)
-    {
-        var result = ExtractFormFields(documentImage);
-        var pairs = new Dictionary<string, string>();
-
-        foreach (var field in result.Fields)
-        {
-            if (!string.IsNullOrEmpty(field.FieldName) && !string.IsNullOrEmpty(field.FieldValue))
-            {
-                pairs[field.FieldName] = field.FieldValue;
-            }
-        }
-
-        return pairs;
-    }
-
-    /// <inheritdoc/>
-    public IEnumerable<CheckboxResult<T>> DetectCheckboxes(Tensor<T> documentImage)
-    {
-        // PICK is designed for text extraction, not checkbox detection
-        yield break;
-    }
-
-    /// <inheritdoc/>
-    public IEnumerable<SignatureResult<T>> DetectSignatures(Tensor<T> documentImage)
-    {
-        // PICK is designed for text extraction, not signature detection
-        yield break;
-    }
-
-    private List<FormField<T>> ParseFieldOutput(Tensor<T> output, double threshold)
-    {
-        var fields = new List<FormField<T>>();
-        int seqLen = output.Shape[0];
-        int numClasses = output.Shape.Length > 1 ? output.Shape[1] : _numEntityTypes;
-
-        for (int i = 0; i < seqLen; i++)
-        {
-            double maxConf = 0;
-            int maxClass = 0;
-            for (int c = 0; c < numClasses; c++)
-            {
-                double conf = NumOps.ToDouble(output[i, c]);
-                if (conf > maxConf) { maxConf = conf; maxClass = c; }
-            }
-
-            if (maxConf >= threshold && maxClass > 0)
-            {
-                string entityType = maxClass < SupportedEntityTypes.Count
-                    ? SupportedEntityTypes[maxClass]
-                    : "UNKNOWN";
-
-                fields.Add(new FormField<T>
-                {
-                    FieldName = entityType,
-                    FieldValue = $"[Token {i}]",
-                    FieldType = entityType,
-                    Confidence = NumOps.FromDouble(maxConf),
-                    ConfidenceValue = maxConf,
-                    BoundingBox = Vector<T>.Empty()
-                });
-            }
-        }
-
-        return fields;
-    }
-
-    /// <summary>
-    /// Extracts key information entities from a document.
-    /// </summary>
-    /// <param name="documentImage">The document image tensor.</param>
-    /// <returns>Key information extraction result.</returns>
-    public KeyInfoExtractionResult<T> ExtractKeyInfo(Tensor<T> documentImage)
-    {
-        var formResult = ExtractFormFields(documentImage);
-
-        var entities = formResult.Fields.Select(f => new ExtractedEntity<T>
-        {
-            Label = f.FieldName,
-            Text = f.FieldValue,
-            EntityType = f.FieldType,
-            Confidence = f.Confidence,
-            ConfidenceValue = f.ConfidenceValue,
-            BoundingBox = f.BoundingBox
-        }).ToList();
-
-        return new KeyInfoExtractionResult<T>
-        {
-            Entities = entities,
-            ProcessingTimeMs = formResult.ProcessingTimeMs
-        };
-    }
-
-    #endregion
-
-    #region IDocumentModel Implementation
-
-    /// <inheritdoc/>
-    public Tensor<T> EncodeDocument(Tensor<T> documentImage)
-    {
-        ValidateImageShape(documentImage);
-        var preprocessed = PreprocessDocument(documentImage);
-        return _useNativeMode ? Forward(preprocessed) : RunOnnxInference(preprocessed);
-    }
-
-    /// <inheritdoc/>
-    public void ValidateInputShape(Tensor<T> documentImage)
-    {
-        ValidateImageShape(documentImage);
-    }
-
-    /// <inheritdoc/>
-    public string GetModelSummary()
-    {
-        var sb = new System.Text.StringBuilder();
-        sb.AppendLine("PICK Model Summary");
-        sb.AppendLine("==================");
-        sb.AppendLine($"Mode: {(_useNativeMode ? "Native (Trainable)" : "ONNX (Inference)")}");
-        sb.AppendLine($"Architecture: BERT + Graph Convolutional Network");
-        sb.AppendLine($"Hidden Dimension: {_hiddenDim}");
-        sb.AppendLine($"GCN Layers: {_numGcnLayers}");
-        sb.AppendLine($"Attention Heads: {_numHeads}");
-        sb.AppendLine($"Max Sequence Length: {MaxSequenceLength}");
-        sb.AppendLine($"Number of Entity Types: {_numEntityTypes}");
-        sb.AppendLine($"Supported Entity Types: {string.Join(", ", SupportedEntityTypes.Take(5))}...");
-        sb.AppendLine($"Total Layers: {Layers.Count}");
-        return sb.ToString();
-    }
-
-    #endregion
-
-    #region Preprocessing
-
-    /// <summary>
-    /// Applies PICK's industry-standard preprocessing: pass-through (PICK works with text + bbox input).
-    /// </summary>
-    /// <remarks>
-    /// PICK (ICPR 2020) primarily processes text and bounding box features rather than raw images.
-    /// </remarks>
-    protected override Tensor<T> ApplyDefaultPreprocessing(Tensor<T> rawImage)
-    {
-        // PICK works with text + bbox input, preprocessing is mainly for compatibility
-        return rawImage;
-    }
-
-    /// <summary>
-    /// Applies PICK's industry-standard postprocessing: pass-through (entity extraction outputs are already final).
-    /// </summary>
-    protected override Tensor<T> ApplyDefaultPostprocessing(Tensor<T> modelOutput) => modelOutput;
-
-    #endregion
-
-    #region Serialization
-
-    /// <inheritdoc/>
-    public override ModelMetadata<T> GetModelMetadata()
-    {
-        return new ModelMetadata<T>
-        {
-            Name = "PICK",
-            Description = "PICK for key information extraction (ICPR 2020)",
-            FeatureCount = _hiddenDim,
-            Complexity = _numGcnLayers,
-            AdditionalInfo = new Dictionary<string, object>
-            {
-                { "hidden_dim", _hiddenDim },
-                { "num_gcn_layers", _numGcnLayers },
-                { "num_heads", _numHeads },
-                { "vocab_size", _vocabSize },
-                { "num_entity_types", _numEntityTypes },
-                { "use_native_mode", _useNativeMode }
-            },
-            ModelData = SafeSerialize()
-        };
-    }
-
-    /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_hiddenDim);
-        writer.Write(_numGcnLayers);
-        writer.Write(_numHeads);
-        writer.Write(_vocabSize);
-        writer.Write(ImageSize);
-        writer.Write(MaxSequenceLength);
-        writer.Write(_numEntityTypes);
-        writer.Write(_useNativeMode);
-    }
-
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        int hiddenDim = reader.ReadInt32();
-        int numGcnLayers = reader.ReadInt32();
-        int numHeads = reader.ReadInt32();
-        int vocabSize = reader.ReadInt32();
-        int imageSize = reader.ReadInt32();
-        int maxSeqLen = reader.ReadInt32();
-        int numEntityTypes = reader.ReadInt32();
-        bool useNativeMode = reader.ReadBoolean();
-
-        ImageSize = imageSize;
-        MaxSequenceLength = maxSeqLen;
-    }
-
-    /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new PICK<T>(Architecture, _tokenizer, _numEntityTypes, ImageSize, MaxSequenceLength,
-            _hiddenDim, _numGcnLayers, _numHeads, _vocabSize);
-    }
-
-    #endregion
-
-    #region NeuralNetworkBase Implementation
-
-    /// <inheritdoc/>
-    protected override Tensor<T> PredictCore(Tensor<T> input)
-    {
-        var preprocessed = PreprocessDocument(input);
-        return _useNativeMode ? Forward(preprocessed) : RunOnnxInference(preprocessed);
-    }
-
-    /// <summary>
-    /// Modality-robust fused inference (Yu et al. 2020 — PICK fuses text-segment features with visual
-    /// features on the GLCN document graph). Text tokens run through the BERT-style text encoder to
-    /// produce per-segment node features; when per-segment VISUAL node features are also supplied they
-    /// are stacked with the text nodes along the NODE axis so the shared GLCN + BiLSTM + head reasons
-    /// over the joint multimodal node set. Passing null for either modality gracefully degrades to the
-    /// other — reference PICK impls require both, so single-modality support is where this exceeds them.
-    /// </summary>
-    /// <param name="textTokens">Token IDs/features fed to the text encoder (or null for visual-only).</param>
-    /// <param name="visualNodeFeatures">Per-segment visual node features (or null); projected to the text
-    /// encoder's hidden dim so the node-axis concat lines up regardless of the caller's raw feature size.</param>
-    public Tensor<T> PredictMultimodal(Tensor<T>? textTokens, Tensor<T>? visualNodeFeatures)
-    {
-        if (!_useNativeMode)
-            throw new NotSupportedException("Multimodal fusion is only available in native mode.");
-        if (textTokens is null && visualNodeFeatures is null)
-            throw new ArgumentException("PredictMultimodal requires at least one of textTokens or visualNodeFeatures.");
-
-        SetTrainingMode(false);
-
-        // Fusion point = end of the BERT-style text encoder (which emits per-segment [Nt, hidden] node
-        // features); everything from there on is the GLCN graph + BiLSTM + NER head that reasons over the
-        // node set. Visual segment features stack onto the text nodes at that boundary.
-        int graphStart = TextEncoderEndIndex();
-
-        Tensor<T>? textNodes = null;
-        if (textTokens is not null)
-        {
-            var feats = textTokens;
-            for (int i = 0; i < graphStart && i < Layers.Count; i++)
-                feats = Layers[i].Forward(feats);
-            textNodes = AlignToNodeMatrix(feats);
-        }
-        var visualNodes = visualNodeFeatures is not null ? AlignToNodeMatrix(visualNodeFeatures) : null;
-
-        Tensor<T> nodes;
-        if (textNodes is not null && visualNodes is not null)
-        {
-            // Concat needs a shared feature dim. The text encoder emits [Nt, hidden]; if the caller's
-            // visual node features carry a different raw feature size, reshape-align them onto the graph's
-            // hidden dim (a zero-cost view when their element count already matches Nv * hidden).
-            visualNodes = MatchFeatureDim(visualNodes, textNodes.Shape[textNodes.Shape.Length - 1]);
-            nodes = Engine.TensorConcatenate(new[] { textNodes, visualNodes }, axis: 0); // [Nt + Nv, hidden]
-        }
-        else
-        {
-            nodes = textNodes ?? visualNodes
-                ?? throw new ArgumentException("PICK requires text tokens or visual node features.");
-        }
-
-        for (int i = graphStart; i < Layers.Count; i++)
-            nodes = Layers[i].Forward(nodes);
-        return nodes;
-    }
-
-    // Index one past the end of the transformer text encoder — the fusion boundary. Each text-encoder
-    // block is [MHA, LN, Dense, Dense, LN], so the encoder ends 4 layers after its LAST
-    // MultiHeadAttentionLayer; the GLCN graph + BiLSTM + head follow. 0 when there is no attention layer.
-    private int TextEncoderEndIndex()
-    {
-        int lastMha = -1;
-        for (int i = 0; i < Layers.Count; i++)
-            if (Layers[i] is AiDotNet.NeuralNetworks.Layers.MultiHeadAttentionLayer<T>)
-                lastMha = i;
-        return lastMha >= 0 ? System.Math.Min(lastMha + 5, Layers.Count) : 0;
-    }
-
-    // Normalizes a stream output to a rank-2 [N, F] node matrix for node-axis fusion.
-    private Tensor<T> AlignToNodeMatrix(Tensor<T> s)
-    {
-        if (s.Rank == 1) return Engine.Reshape(s, new[] { 1, s.Shape[0] });
-        if (s.Rank == 3) return Engine.Reshape(s, new[] { s.Shape[0] * s.Shape[1], s.Shape[2] });
-        return s;
-    }
-
-    // Reshapes a [N, F] node matrix so its feature dim is `hidden`, provided N*F is divisible by hidden.
-    private Tensor<T> MatchFeatureDim(Tensor<T> nodes, int hidden)
-    {
-        int lastDim = nodes.Shape[nodes.Shape.Length - 1];
-        if (lastDim == hidden) return nodes;
-        long total = nodes.Length;
-        if (total % hidden != 0)
-            throw new ArgumentException(
-                $"Visual node features (total {total} elements) are not compatible with PICK's hidden dim {hidden}; " +
-                $"supply features whose element count is a multiple of {hidden}.");
-        return Engine.Reshape(nodes, new[] { (int)(total / hidden), hidden });
-    }
-
-    /// <inheritdoc/>
-    public override void Train(Tensor<T> input, Tensor<T> expectedOutput)
-    {
-        if (!_useNativeMode)
-            throw new NotSupportedException("Training not supported in ONNX mode.");
-
-        // TrainWithTape already runs the forward, backprop, and optimizer update. The manual
-        // UpdateParameters(CollectGradients()) that followed was a redundant SECOND gradient step whose
-        // hand-collected vector length didn't match GetParameters, crashing training. Use the tape only.
-        //
-        // Pass PICK's configured optimizer explicitly: the no-optimizer overload falls back to the base
-        // default Adam at lr 1e-3, which OVERSHOOTS PICK's sharp early descent (BiLSTM + CRF produce
-        // large early gradients) and then diverges to a worse plateau — MoreData_ShouldNotDegrade saw
-        // loss(200) > loss(50). PICK's own optimizer is a lower-lr (1e-4) Adam suited to sequence-model
-        // training, which converges monotonically instead.
-        SetTrainingMode(true);
-        try
-        {
-            TrainWithTape(input, expectedOutput, _optimizer);
-        }
-        finally
-        {
-            SetTrainingMode(false);
-        }
-    }
-
-    // UpdateParameters applied a GRADIENT STEP, but its one-argument form is the value setter and every caller passes values -- the override corrupted the model. Removed under AIDN082.

-
-    /// <summary>
-    /// Parameters cannot be written while the model is backed by a loaded ONNX graph: the weights
-    /// belong to that graph, not to this instance.
-    /// </summary>
-    /// <remarks>
-    /// Replaces a hand-written throw that used to sit inside UpdateParameters. The base checks this
-    /// on every mutating entry point rather than the one member the throw happened to guard, and
-    /// reading -- ParameterCount and GetParameters -- stays available either way.
-    /// </remarks>
+using AiDotNet.Attributes;
+using AiDotNet.Document.Interfaces;
+using AiDotNet.Document.Options;
+using AiDotNet.Enums;
+using AiDotNet.Helpers;
+using AiDotNet.Interfaces;
+using AiDotNet.LinearAlgebra;
+using AiDotNet.LossFunctions;
+using AiDotNet.NeuralNetworks;
+using AiDotNet.NeuralNetworks.Layers;
+using AiDotNet.Optimizers;
+using AiDotNet.Models.Options;
+using AiDotNet.Tokenization;
+using AiDotNet.Tokenization.Interfaces;
+using Microsoft.ML.OnnxRuntime;
+using AiDotNet.Validation;
+
+namespace AiDotNet.Document.GraphBased;
+
+/// <summary>
+/// PICK (Processing Key Information Extraction) neural network for document key information extraction.
+/// </summary>
+/// <typeparam name="T">The numeric type used for calculations.</typeparam>
+/// <remarks>
+/// <para>
+/// PICK uses a graph neural network approach to extract key information from documents.
+/// It models text segments as nodes and their relationships as edges, enabling
+/// better understanding of document structure.
+/// </para>
+/// <para>
+/// <b>For Beginners:</b> PICK is especially good at:
+/// 1. Extracting key-value pairs from invoices and receipts
+/// 2. Understanding relationships between text segments
+/// 3. Handling complex document layouts
+/// 4. Named Entity Recognition in documents
+///
+/// Example usage:
+/// <code>
+/// var model = new PICK&lt;float&gt;(architecture);
+/// var result = model.ExtractKeyInfo(documentImage);
+/// foreach (var entity in result.Entities)
+///     Console.WriteLine($"{entity.Label}: {entity.Text}");
+/// </code>
+/// </para>
+/// <para>
+/// <b>Reference:</b> "PICK: Processing Key Information Extraction from Documents using Improved Graph Learning-Convolutional Networks" (ICPR 2020)
+/// https://arxiv.org/abs/2004.07464
+/// </para>
+/// </remarks>
+[ModelDomain(ModelDomain.Vision)]
+[ModelDomain(ModelDomain.Language)]
+[ModelCategory(ModelCategory.NeuralNetwork)]
+[ModelCategory(ModelCategory.GraphNetwork)]
+[ModelTask(ModelTask.Classification)]
+[ModelTask(ModelTask.FeatureExtraction)]
+[ModelComplexity(ModelComplexity.High)]
+[ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
+[ResearchPaper("PICK: Processing Key Information Extraction from Documents using Improved Graph Learning-Convolutional Networks", "https://doi.org/10.48550/arXiv.2004.07464", Year = 2020, Authors = "Wenwen Yu, Ning Lu, Xianbiao Qi, Ping Gong, Rong Xiao")]
+public partial class PICK<T> : DocumentNeuralNetworkBase<T>, IFormUnderstanding<T>
+{
+    private readonly PICKOptions _options;
+
+    /// <inheritdoc/>
+    public override ModelOptions GetOptions() => _options;
+
+    #region Fields
+
+    private readonly bool _useNativeMode;
+    private readonly InferenceSession? _onnxSession;
+    private readonly ITokenizer _tokenizer;
+    private readonly IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>> _optimizer;
+    private readonly int _hiddenDim;
+    private readonly int _numGcnLayers;
+    private readonly int _numHeads;
+    private readonly int _vocabSize;
+    private readonly int _numEntityTypes;
+
+    // Native mode layers
+    private readonly List<ILayer<T>> _textEncoderLayers = [];
+    private readonly List<ILayer<T>> _gcnLayers = [];
+    private readonly List<ILayer<T>> _outputLayers = [];
+
+    #endregion
+
+    #region Properties
+
+    /// <inheritdoc/>
+    public override DocumentType SupportedDocumentTypes => DocumentType.Form;
+
+    /// <inheritdoc/>
+    public override bool RequiresOCR => true;
+
+    /// <inheritdoc/>
+    public int ExpectedImageSize => ImageSize;
+
+    /// <summary>
+    /// Gets the supported entity types for extraction.
+    /// </summary>
+    public IReadOnlyList<string> SupportedEntityTypes { get; } =
+    [
+        "SELLER", "ADDRESS", "DATE", "TOTAL", "TAX", "ITEM", "QUANTITY", "PRICE",
+        "INVOICE_NUMBER", "BUYER", "PAYMENT_METHOD", "DUE_DATE", "CURRENCY", "OTHER"
+    ];
+
+    #endregion
+
+    #region Constructors
+
+    /// <summary>
+    /// Creates a PICK model using a pre-trained ONNX model for inference.
+    /// </summary>
+    public PICK(
+        NeuralNetworkArchitecture<T> architecture,
+        string onnxModelPath,
+        ITokenizer tokenizer,
+        int numEntityTypes = 14,
+        int imageSize = 512,
+        int maxSequenceLength = 512,
+        int hiddenDim = 256,
+        int numGcnLayers = 2,
+        int numHeads = 8,
+        int vocabSize = 30522,
+        IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? optimizer = null,
+        ILossFunction<T>? lossFunction = null,
+        PICKOptions? options = null)
+        : base(architecture, lossFunction ?? new CrossEntropyWithLogitsLoss<T>(), 1.0)
+    {
+        _options = options ?? new PICKOptions();
+        Options = _options;
+
+        if (string.IsNullOrWhiteSpace(onnxModelPath))
+            throw new ArgumentNullException(nameof(onnxModelPath));
+        if (!File.Exists(onnxModelPath))
+            throw new FileNotFoundException($"ONNX model not found: {onnxModelPath}", onnxModelPath);
+
+        Guard.NotNull(tokenizer);
+        _tokenizer = tokenizer;
+        _useNativeMode = false;
+        _numEntityTypes = numEntityTypes;
+        _hiddenDim = hiddenDim;
+        _numGcnLayers = numGcnLayers;
+        _numHeads = numHeads;
+        _vocabSize = vocabSize;
+        _optimizer = optimizer ?? new AdamOptimizer<T, Tensor<T>, Tensor<T>>(this,
+            new AdamOptimizerOptions<T, Tensor<T>, Tensor<T>> { InitialLearningRate = 1e-4 });
+
+        ImageSize = imageSize;
+        MaxSequenceLength = maxSequenceLength;
+
+        _onnxSession = new InferenceSession(onnxModelPath);
+
+        InitializeLayers();
+    }
+
+    /// <summary>
+    /// Creates a PICK model using native layers for training and inference.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// <b>Default Configuration (PICK from ICPR 2020):</b>
+    /// - BERT-based text encoder
+    /// - 2-layer Graph Convolutional Network
+    /// - BiLSTM for sequence modeling
+    /// - CRF decoder for NER
+    /// - Hidden dimension: 256
+    /// </para>
+    /// </remarks>
+    public PICK(
+        NeuralNetworkArchitecture<T> architecture,
+        ITokenizer? tokenizer = null,
+        int numEntityTypes = 14,
+        int imageSize = 512,
+        int maxSequenceLength = 512,
+        int hiddenDim = 256,
+        int numGcnLayers = 2,
+        int numHeads = 8,
+        int vocabSize = 30522,
+        IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? optimizer = null,
+        ILossFunction<T>? lossFunction = null,
+        PICKOptions? options = null)
+        : base(architecture, lossFunction ?? new CrossEntropyWithLogitsLoss<T>(), 1.0)
+    {
+        _options = options ?? new PICKOptions();
+        Options = _options;
+
+        _useNativeMode = true;
+        _numEntityTypes = numEntityTypes;
+        _hiddenDim = hiddenDim;
+        _numGcnLayers = numGcnLayers;
+        _numHeads = numHeads;
+        _vocabSize = vocabSize;
+        _optimizer = optimizer ?? new AdamOptimizer<T, Tensor<T>, Tensor<T>>(this,
+            new AdamOptimizerOptions<T, Tensor<T>, Tensor<T>> { InitialLearningRate = 1e-4 });
+
+        ImageSize = imageSize;
+        MaxSequenceLength = maxSequenceLength;
+
+        _tokenizer = tokenizer ?? LanguageModelTokenizerFactory.CreateForBackbone(LanguageModelBackbone.OPT);
+
+        InitializeLayers();
+    }
+
+    #endregion
+
+    #region Initialization
+
+    /// <inheritdoc/>
+    protected override void InitializeLayers()
+    {
+        if (!_useNativeMode)
+        {
+            return;
+        }
+
+        if (Architecture.Layers is not null && Architecture.Layers.Count > 0)
+        {
+            Layers.AddRange(Architecture.Layers);
+            ValidateCustomLayers(Layers);
+            return;
+        }
+
+        Layers.AddRange(LayerHelper<T>.CreateDefaultPICKLayers(
+            hiddenDim: _hiddenDim,
+            numGcnLayers: _numGcnLayers,
+            numHeads: _numHeads,
+            vocabSize: _vocabSize,
+            numEntityTypes: _numEntityTypes,
+            maxSequenceLength: MaxSequenceLength));
+    }
+
+    #endregion
+
+    #region IFormUnderstanding Implementation
+
+    /// <inheritdoc/>
+    public FormFieldResult<T> ExtractFormFields(Tensor<T> documentImage)
+    {
+        return ExtractFormFields(documentImage, 0.5);
+    }
+
+    /// <inheritdoc/>
+    public FormFieldResult<T> ExtractFormFields(Tensor<T> documentImage, double confidenceThreshold)
+    {
+        ValidateImageShape(documentImage);
+        var startTime = DateTime.UtcNow;
+
+        var preprocessed = PreprocessDocument(documentImage);
+        var output = _useNativeMode ? Forward(preprocessed) : RunOnnxInference(preprocessed);
+
+        var fields = ParseFieldOutput(output, confidenceThreshold);
+
+        return new FormFieldResult<T>
+        {
+            Fields = fields,
+            ProcessingTimeMs = (DateTime.UtcNow - startTime).TotalMilliseconds
+        };
+    }
+
+    /// <inheritdoc/>
+    public Dictionary<string, string> ExtractKeyValuePairs(Tensor<T> documentImage)
+    {
+        var result = ExtractFormFields(documentImage);
+        var pairs = new Dictionary<string, string>();
+
+        foreach (var field in result.Fields)
+        {
+            if (!string.IsNullOrEmpty(field.FieldName) && !string.IsNullOrEmpty(field.FieldValue))
+            {
+                pairs[field.FieldName] = field.FieldValue;
+            }
+        }
+
+        return pairs;
+    }
+
+    /// <inheritdoc/>
+    public IEnumerable<CheckboxResult<T>> DetectCheckboxes(Tensor<T> documentImage)
+    {
+        // PICK is designed for text extraction, not checkbox detection
+        yield break;
+    }
+
+    /// <inheritdoc/>
+    public IEnumerable<SignatureResult<T>> DetectSignatures(Tensor<T> documentImage)
+    {
+        // PICK is designed for text extraction, not signature detection
+        yield break;
+    }
+
+    private List<FormField<T>> ParseFieldOutput(Tensor<T> output, double threshold)
+    {
+        var fields = new List<FormField<T>>();
+        int seqLen = output.Shape[0];
+        int numClasses = output.Shape.Length > 1 ? output.Shape[1] : _numEntityTypes;
+
+        for (int i = 0; i < seqLen; i++)
+        {
+            double maxConf = 0;
+            int maxClass = 0;
+            for (int c = 0; c < numClasses; c++)
+            {
+                double conf = NumOps.ToDouble(output[i, c]);
+                if (conf > maxConf) { maxConf = conf; maxClass = c; }
+            }
+
+            if (maxConf >= threshold && maxClass > 0)
+            {
+                string entityType = maxClass < SupportedEntityTypes.Count
+                    ? SupportedEntityTypes[maxClass]
+                    : "UNKNOWN";
+
+                fields.Add(new FormField<T>
+                {
+                    FieldName = entityType,
+                    FieldValue = $"[Token {i}]",
+                    FieldType = entityType,
+                    Confidence = NumOps.FromDouble(maxConf),
+                    ConfidenceValue = maxConf,
+                    BoundingBox = Vector<T>.Empty()
+                });
+            }
+        }
+
+        return fields;
+    }
+
+    /// <summary>
+    /// Extracts key information entities from a document.
+    /// </summary>
+    /// <param name="documentImage">The document image tensor.</param>
+    /// <returns>Key information extraction result.</returns>
+    public KeyInfoExtractionResult<T> ExtractKeyInfo(Tensor<T> documentImage)
+    {
+        var formResult = ExtractFormFields(documentImage);
+
+        var entities = formResult.Fields.Select(f => new ExtractedEntity<T>
+        {
+            Label = f.FieldName,
+            Text = f.FieldValue,
+            EntityType = f.FieldType,
+            Confidence = f.Confidence,
+            ConfidenceValue = f.ConfidenceValue,
+            BoundingBox = f.BoundingBox
+        }).ToList();
+
+        return new KeyInfoExtractionResult<T>
+        {
+            Entities = entities,
+            ProcessingTimeMs = formResult.ProcessingTimeMs
+        };
+    }
+
+    #endregion
+
+    #region IDocumentModel Implementation
+
+    /// <inheritdoc/>
+    public Tensor<T> EncodeDocument(Tensor<T> documentImage)
+    {
+        ValidateImageShape(documentImage);
+        var preprocessed = PreprocessDocument(documentImage);
+        return _useNativeMode ? Forward(preprocessed) : RunOnnxInference(preprocessed);
+    }
+
+    /// <inheritdoc/>
+    public void ValidateInputShape(Tensor<T> documentImage)
+    {
+        ValidateImageShape(documentImage);
+    }
+
+    /// <inheritdoc/>
+    public string GetModelSummary()
+    {
+        var sb = new System.Text.StringBuilder();
+        sb.AppendLine("PICK Model Summary");
+        sb.AppendLine("==================");
+        sb.AppendLine($"Mode: {(_useNativeMode ? "Native (Trainable)" : "ONNX (Inference)")}");
+        sb.AppendLine($"Architecture: BERT + Graph Convolutional Network");
+        sb.AppendLine($"Hidden Dimension: {_hiddenDim}");
+        sb.AppendLine($"GCN Layers: {_numGcnLayers}");
+        sb.AppendLine($"Attention Heads: {_numHeads}");
+        sb.AppendLine($"Max Sequence Length: {MaxSequenceLength}");
+        sb.AppendLine($"Number of Entity Types: {_numEntityTypes}");
+        sb.AppendLine($"Supported Entity Types: {string.Join(", ", SupportedEntityTypes.Take(5))}...");
+        sb.AppendLine($"Total Layers: {Layers.Count}");
+        return sb.ToString();
+    }
+
+    #endregion
+
+    #region Preprocessing
+
+    /// <summary>
+    /// Applies PICK's industry-standard preprocessing: pass-through (PICK works with text + bbox input).
+    /// </summary>
+    /// <remarks>
+    /// PICK (ICPR 2020) primarily processes text and bounding box features rather than raw images.
+    /// </remarks>
+    protected override Tensor<T> ApplyDefaultPreprocessing(Tensor<T> rawImage)
+    {
+        // PICK works with text + bbox input, preprocessing is mainly for compatibility
+        return rawImage;
+    }
+
+    /// <summary>
+    /// Applies PICK's industry-standard postprocessing: pass-through (entity extraction outputs are already final).
+    /// </summary>
+    protected override Tensor<T> ApplyDefaultPostprocessing(Tensor<T> modelOutput) => modelOutput;
+
+    #endregion
+
+    #region Serialization
+
+    /// <inheritdoc/>
+    public override ModelMetadata<T> GetModelMetadata()
+    {
+        return new ModelMetadata<T>
+        {
+            Name = "PICK",
+            Description = "PICK for key information extraction (ICPR 2020)",
+            FeatureCount = _hiddenDim,
+            Complexity = _numGcnLayers,
+            AdditionalInfo = new Dictionary<string, object>
+            {
+                { "hidden_dim", _hiddenDim },
+                { "num_gcn_layers", _numGcnLayers },
+                { "num_heads", _numHeads },
+                { "vocab_size", _vocabSize },
+                { "num_entity_types", _numEntityTypes },
+                { "use_native_mode", _useNativeMode }
+            },
+            ModelData = SafeSerialize()
+        };
+    }
+
+    /// <inheritdoc/>
+
+
+    /// <inheritdoc/>
+
+
+    #endregion
+
+    #region NeuralNetworkBase Implementation
+
+    /// <inheritdoc/>
+    protected override Tensor<T> PredictCore(Tensor<T> input)
+    {
+        var preprocessed = PreprocessDocument(input);
+        return _useNativeMode ? Forward(preprocessed) : RunOnnxInference(preprocessed);
+    }
+
+    /// <summary>
+    /// Modality-robust fused inference (Yu et al. 2020 — PICK fuses text-segment features with visual
+    /// features on the GLCN document graph). Text tokens run through the BERT-style text encoder to
+    /// produce per-segment node features; when per-segment VISUAL node features are also supplied they
+    /// are stacked with the text nodes along the NODE axis so the shared GLCN + BiLSTM + head reasons
+    /// over the joint multimodal node set. Passing null for either modality gracefully degrades to the
+    /// other — reference PICK impls require both, so single-modality support is where this exceeds them.
+    /// </summary>
+    /// <param name="textTokens">Token IDs/features fed to the text encoder (or null for visual-only).</param>
+    /// <param name="visualNodeFeatures">Per-segment visual node features (or null); projected to the text
+    /// encoder's hidden dim so the node-axis concat lines up regardless of the caller's raw feature size.</param>
+    public Tensor<T> PredictMultimodal(Tensor<T>? textTokens, Tensor<T>? visualNodeFeatures)
+    {
+        if (!_useNativeMode)
+            throw new NotSupportedException("Multimodal fusion is only available in native mode.");
+        if (textTokens is null && visualNodeFeatures is null)
+            throw new ArgumentException("PredictMultimodal requires at least one of textTokens or visualNodeFeatures.");
+
+        SetTrainingMode(false);
+
+        // Fusion point = end of the BERT-style text encoder (which emits per-segment [Nt, hidden] node
+        // features); everything from there on is the GLCN graph + BiLSTM + NER head that reasons over the
+        // node set. Visual segment features stack onto the text nodes at that boundary.
+        int graphStart = TextEncoderEndIndex();
+
+        Tensor<T>? textNodes = null;
+        if (textTokens is not null)
+        {
+            var feats = textTokens;
+            for (int i = 0; i < graphStart && i < Layers.Count; i++)
+                feats = Layers[i].Forward(feats);
+            textNodes = AlignToNodeMatrix(feats);
+        }
+        var visualNodes = visualNodeFeatures is not null ? AlignToNodeMatrix(visualNodeFeatures) : null;
+
+        Tensor<T> nodes;
+        if (textNodes is not null && visualNodes is not null)
+        {
+            // Concat needs a shared feature dim. The text encoder emits [Nt, hidden]; if the caller's
+            // visual node features carry a different raw feature size, reshape-align them onto the graph's
+            // hidden dim (a zero-cost view when their element count already matches Nv * hidden).
+            visualNodes = MatchFeatureDim(visualNodes, textNodes.Shape[textNodes.Shape.Length - 1]);
+            nodes = Engine.TensorConcatenate(new[] { textNodes, visualNodes }, axis: 0); // [Nt + Nv, hidden]
+        }
+        else
+        {
+            nodes = textNodes ?? visualNodes
+                ?? throw new ArgumentException("PICK requires text tokens or visual node features.");
+        }
+
+        for (int i = graphStart; i < Layers.Count; i++)
+            nodes = Layers[i].Forward(nodes);
+        return nodes;
+    }
+
+    // Index one past the end of the transformer text encoder — the fusion boundary. Each text-encoder
+    // block is [MHA, LN, Dense, Dense, LN], so the encoder ends 4 layers after its LAST
+    // MultiHeadAttentionLayer; the GLCN graph + BiLSTM + head follow. 0 when there is no attention layer.
+    private int TextEncoderEndIndex()
+    {
+        int lastMha = -1;
+        for (int i = 0; i < Layers.Count; i++)
+            if (Layers[i] is AiDotNet.NeuralNetworks.Layers.MultiHeadAttentionLayer<T>)
+                lastMha = i;
+        return lastMha >= 0 ? System.Math.Min(lastMha + 5, Layers.Count) : 0;
+    }
+
+    // Normalizes a stream output to a rank-2 [N, F] node matrix for node-axis fusion.
+    private Tensor<T> AlignToNodeMatrix(Tensor<T> s)
+    {
+        if (s.Rank == 1) return Engine.Reshape(s, new[] { 1, s.Shape[0] });
+        if (s.Rank == 3) return Engine.Reshape(s, new[] { s.Shape[0] * s.Shape[1], s.Shape[2] });
+        return s;
+    }
+
+    // Reshapes a [N, F] node matrix so its feature dim is `hidden`, provided N*F is divisible by hidden.
+    private Tensor<T> MatchFeatureDim(Tensor<T> nodes, int hidden)
+    {
+        int lastDim = nodes.Shape[nodes.Shape.Length - 1];
+        if (lastDim == hidden) return nodes;
+        long total = nodes.Length;
+        if (total % hidden != 0)
+            throw new ArgumentException(
+                $"Visual node features (total {total} elements) are not compatible with PICK's hidden dim {hidden}; " +
+                $"supply features whose element count is a multiple of {hidden}.");
+        return Engine.Reshape(nodes, new[] { (int)(total / hidden), hidden });
+    }
+
+    /// <inheritdoc/>
+    public override void Train(Tensor<T> input, Tensor<T> expectedOutput)
+    {
+        if (!_useNativeMode)
+            throw new NotSupportedException("Training not supported in ONNX mode.");
+
+        // TrainWithTape already runs the forward, backprop, and optimizer update. The manual
+        // UpdateParameters(CollectGradients()) that followed was a redundant SECOND gradient step whose
+        // hand-collected vector length didn't match GetParameters, crashing training. Use the tape only.
+        //
+        // Pass PICK's configured optimizer explicitly: the no-optimizer overload falls back to the base
+        // default Adam at lr 1e-3, which OVERSHOOTS PICK's sharp early descent (BiLSTM + CRF produce
+        // large early gradients) and then diverges to a worse plateau — MoreData_ShouldNotDegrade saw
+        // loss(200) > loss(50). PICK's own optimizer is a lower-lr (1e-4) Adam suited to sequence-model
+        // training, which converges monotonically instead.
+        SetTrainingMode(true);
+        try
+        {
+            TrainWithTape(input, expectedOutput, _optimizer);
+        }
+        finally
+        {
+            SetTrainingMode(false);
+        }
+    }
+
+    // UpdateParameters applied a GRADIENT STEP, but its one-argument form is the value setter and every caller passes values -- the override corrupted the model. Removed under AIDN082.
+
+
+    /// <summary>
+    /// Parameters cannot be written while the model is backed by a loaded ONNX graph: the weights
+    /// belong to that graph, not to this instance.
+    /// </summary>
+    /// <remarks>
+    /// Replaces a hand-written throw that used to sit inside UpdateParameters. The base checks this
+    /// on every mutating entry point rather than the one member the throw happened to guard, and
+    /// reading -- ParameterCount and GetParameters -- stays available either way.
+    /// </remarks>
     protected override bool SupportsParameterMutation => _useNativeMode;
-    #endregion
-
-    #region Disposal
-
-    /// <inheritdoc/>
-    protected override void Dispose(bool disposing)
-    {
-        if (disposing)
-            _onnxSession?.Dispose();
-        base.Dispose(disposing);
-    }
-
-    #endregion
-}
-
-/// <summary>
-/// Result of key information extraction.
-/// </summary>
-/// <typeparam name="T">The numeric type used for calculations.</typeparam>
-public class KeyInfoExtractionResult<T>
-{
-    /// <summary>
-    /// Gets or sets the extracted entities.
-    /// </summary>
-    public IList<ExtractedEntity<T>> Entities { get; set; } = [];
-
-    /// <summary>
-    /// Gets or sets the processing time in milliseconds.
-    /// </summary>
-    public double ProcessingTimeMs { get; set; }
-}
-
-/// <summary>
-/// An extracted entity from a document.
-/// </summary>
-/// <typeparam name="T">The numeric type used for calculations.</typeparam>
-public class ExtractedEntity<T>
-{
-    /// <summary>
-    /// Gets or sets the entity label.
-    /// </summary>
-    public string Label { get; set; } = string.Empty;
-
-    /// <summary>
-    /// Gets or sets the extracted text.
-    /// </summary>
-    public string Text { get; set; } = string.Empty;
-
-    /// <summary>
-    /// Gets or sets the entity type.
-    /// </summary>
-    public string EntityType { get; set; } = string.Empty;
-
-    /// <summary>
-    /// Gets or sets the confidence score.
-    /// </summary>
-    public required T Confidence { get; set; }
-
-    /// <summary>
-    /// Gets or sets the confidence as a double.
-    /// </summary>
-    public double ConfidenceValue { get; set; }
-
-    /// <summary>
-    /// Gets or sets the bounding box.
-    /// </summary>
-    public Vector<T> BoundingBox { get; set; } = Vector<T>.Empty();
-}
+    #endregion
+
+    #region Disposal
+
+    /// <inheritdoc/>
+    protected override void Dispose(bool disposing)
+    {
+        if (disposing)
+            _onnxSession?.Dispose();
+        base.Dispose(disposing);
+    }
+
+    #endregion
+}
+
+/// <summary>
+/// Result of key information extraction.
+/// </summary>
+/// <typeparam name="T">The numeric type used for calculations.</typeparam>
+public class KeyInfoExtractionResult<T>
+{
+    /// <summary>
+    /// Gets or sets the extracted entities.
+    /// </summary>
+    public IList<ExtractedEntity<T>> Entities { get; set; } = [];
+
+    /// <summary>
+    /// Gets or sets the processing time in milliseconds.
+    /// </summary>
+    public double ProcessingTimeMs { get; set; }
+}
+
+/// <summary>
+/// An extracted entity from a document.
+/// </summary>
+/// <typeparam name="T">The numeric type used for calculations.</typeparam>
+public class ExtractedEntity<T>
+{
+    /// <summary>
+    /// Gets or sets the entity label.
+    /// </summary>
+    public string Label { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Gets or sets the extracted text.
+    /// </summary>
+    public string Text { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Gets or sets the entity type.
+    /// </summary>
+    public string EntityType { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Gets or sets the confidence score.
+    /// </summary>
+    public required T Confidence { get; set; }
+
+    /// <summary>
+    /// Gets or sets the confidence as a double.
+    /// </summary>
+    public double ConfidenceValue { get; set; }
+
+    /// <summary>
+    /// Gets or sets the bounding box.
+    /// </summary>
+    public Vector<T> BoundingBox { get; set; } = Vector<T>.Empty();
+}
diff --git a/src/Document/GraphBased/TRIE.cs b/src/Document/GraphBased/TRIE.cs
index 3e11793911..4a3c4ca906 100644
--- a/src/Document/GraphBased/TRIE.cs
+++ b/src/Document/GraphBased/TRIE.cs
@@ -1,878 +1,853 @@
-using AiDotNet.Attributes;
-using AiDotNet.Document.Interfaces;
-using AiDotNet.Document.Options;
-using AiDotNet.Enums;
-using AiDotNet.Helpers;
-using AiDotNet.Interfaces;
-using AiDotNet.LinearAlgebra;
-using AiDotNet.LossFunctions;
-using AiDotNet.NeuralNetworks;
-using AiDotNet.NeuralNetworks.Layers;
-using AiDotNet.Optimizers;
-using Microsoft.ML.OnnxRuntime;
-
-namespace AiDotNet.Document.GraphBased;
-
-/// <summary>
-/// TRIE (Text Reading and Information Extraction) for end-to-end document understanding.
-/// </summary>
-/// <typeparam name="T">The numeric type used for calculations.</typeparam>
-/// <remarks>
-/// <para>
-/// TRIE combines text reading (OCR) with information extraction in an end-to-end framework,
-/// using graph neural networks to model relationships between text entities and extract
-/// structured information.
-/// </para>
-/// <para>
-/// <b>For Beginners:</b> TRIE does reading and extraction together:
-/// 1. Reads text from document images
-/// 2. Builds a graph of text entities
-/// 3. Extracts key-value pairs and entities
-/// 4. Outputs structured information
-///
-/// Key features:
-/// - End-to-end text reading + extraction
-/// - Graph-based entity relationship modeling
-/// - Joint optimization of OCR and IE
-/// - Strong performance on receipts and forms
-///
-/// Example usage:
-/// <code>
-/// var model = new TRIE&lt;float&gt;(architecture);
-/// var result = model.ExtractFormFields(documentImage);
-/// </code>
-/// </para>
-/// <para>
-/// <b>Reference:</b> "TRIE: End-to-End Text Reading and Information Extraction" (ACM MM 2020)
-/// https://arxiv.org/abs/2005.13118
-/// </para>
-/// </remarks>
-[ModelDomain(ModelDomain.Vision)]
-[ModelDomain(ModelDomain.Language)]
-[ModelCategory(ModelCategory.NeuralNetwork)]
-[ModelCategory(ModelCategory.GraphNetwork)]
-[ModelTask(ModelTask.Detection)]
-[ModelTask(ModelTask.FeatureExtraction)]
-[ModelComplexity(ModelComplexity.High)]
-[ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
-[ResearchPaper("TRIE: End-to-End Text Reading and Information Extraction for Document Understanding", "https://doi.org/10.48550/arXiv.2005.13118", Year = 2020, Authors = "Peng Zhang, Yunlu Xu, Zhanzhan Cheng, Shiliang Pu, Jing Lu, Liang Qiao, Yi Niu, Fei Wu")]
-public partial class TRIE<T> : DocumentNeuralNetworkBase<T>, IFormUnderstanding<T>, ITextDetector<T>
-{
-    private readonly TRIEOptions _options;
-
-    /// <inheritdoc/>
-    public override ModelOptions GetOptions() => _options;
-
-    #region Fields
-
-    private readonly bool _useNativeMode;
-    private readonly InferenceSession? _onnxSession;
-    private readonly IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>> _optimizer;
-    private readonly int _visualDim;
-    private readonly int _textDim;
-    private readonly int _graphDim;
-    private readonly int _numEntityTypes;
-    private readonly int _maxEntities;
-
-    // Native mode layers
-    private readonly List<ILayer<T>> _visualEncoderLayers = [];
-    private readonly List<ILayer<T>> _textEncoderLayers = [];
-    private readonly List<ILayer<T>> _graphLayers = [];
-    private readonly List<ILayer<T>> _extractionLayers = [];
-
-    #endregion
-
-    #region Properties
-
-    /// <inheritdoc/>
-    public override DocumentType SupportedDocumentTypes => DocumentType.Form;
-
-    /// <inheritdoc/>
-    public override bool RequiresOCR => false;
-
-    /// <inheritdoc/>
-    public int ExpectedImageSize => ImageSize;
-
-    /// <summary>
-    /// Gets the number of entity types.
-    /// </summary>
-    public int NumEntityTypes => _numEntityTypes;
-
-    /// <inheritdoc/>
-    public bool SupportsRotatedText => true;
-
-    /// <inheritdoc/>
-    public int MinTextHeight => 8;
-
-    /// <inheritdoc/>
-    public bool SupportsPolygonOutput => true;
-
-    #endregion
-
-    #region Constructors
-
-    /// <summary>
-    /// Creates a TRIE model with default configuration for native training.
-    /// </summary>
-    public TRIE()
-        : this(new NeuralNetworkArchitecture<T>(
-            inputType: InputType.TwoDimensional,
-            taskType: NeuralNetworkTaskType.MultiClassClassification,
-            inputHeight: 512, inputWidth: 512,
-            outputSize: 256))
-    {
-    }
-
-    /// <summary>
-    /// Creates a TRIE model using a pre-trained ONNX model for inference.
-    /// </summary>
-    public TRIE(
-        NeuralNetworkArchitecture<T> architecture,
-        string onnxModelPath,
-        int imageSize = 512,
-        int visualDim = 256,
-        int textDim = 256,
-        int graphDim = 256,
-        int numEntityTypes = 10,
-        int maxEntities = 100,
-        IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? optimizer = null,
-        ILossFunction<T>? lossFunction = null,
-        TRIEOptions? options = null)
-        : base(architecture, lossFunction ?? new CrossEntropyWithLogitsLoss<T>(), 1.0)
-    {
-        _options = options ?? new TRIEOptions();
-        Options = _options;
-
-        if (string.IsNullOrWhiteSpace(onnxModelPath))
-            throw new ArgumentNullException(nameof(onnxModelPath));
-        if (!File.Exists(onnxModelPath))
-            throw new FileNotFoundException($"ONNX model not found: {onnxModelPath}", onnxModelPath);
-
-        _useNativeMode = false;
-        _visualDim = visualDim;
-        _textDim = textDim;
-        _graphDim = graphDim;
-        _numEntityTypes = numEntityTypes;
-        _maxEntities = maxEntities;
-        _optimizer = optimizer ?? new AdamOptimizer<T, Tensor<T>, Tensor<T>>(this);
-
-        ImageSize = imageSize;
-
-        _onnxSession = new InferenceSession(onnxModelPath);
-
-        InitializeLayers();
-    }
-
-    /// <summary>
-    /// Creates a TRIE model using native layers for training and inference.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// <b>Default Configuration (TRIE from ACM MM 2020):</b>
-    /// - Visual encoder: ResNet backbone
-    /// - Text encoder: BiLSTM
-    /// - Graph reasoning module
-    /// - Multi-task extraction heads
-    /// </para>
-    /// </remarks>
-    public TRIE(
-        NeuralNetworkArchitecture<T> architecture,
-        int imageSize = 512,
-        int visualDim = 256,
-        int textDim = 256,
-        int graphDim = 256,
-        int numEntityTypes = 10,
-        int maxEntities = 100,
-        IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? optimizer = null,
-        ILossFunction<T>? lossFunction = null,
-        TRIEOptions? options = null)
-        : base(architecture, lossFunction ?? new CrossEntropyWithLogitsLoss<T>(), 1.0)
-    {
-        _options = options ?? new TRIEOptions();
-        Options = _options;
-
-        _useNativeMode = true;
-        _visualDim = visualDim;
-        _textDim = textDim;
-        _graphDim = graphDim;
-        _numEntityTypes = numEntityTypes;
-        _maxEntities = maxEntities;
-        _optimizer = optimizer ?? new AdamOptimizer<T, Tensor<T>, Tensor<T>>(this);
-
-        ImageSize = imageSize;
-
-        InitializeLayers();
-    }
-
-    #endregion
-
-    #region Initialization
-
-    /// <inheritdoc/>
-    protected override void InitializeLayers()
-    {
-        if (!_useNativeMode)
-        {
-            return;
-        }
-
-        if (Architecture.Layers is not null && Architecture.Layers.Count > 0)
-        {
-            Layers.AddRange(Architecture.Layers);
-            ValidateCustomLayers(Layers);
-            return;
-        }
-
-        Layers.AddRange(LayerHelper<T>.CreateDefaultTRIELayers(
-            imageSize: ImageSize,
-            visualDim: _visualDim,
-            textDim: _textDim,
-            graphDim: _graphDim,
-            numEntityTypes: _numEntityTypes,
-            maxEntities: _maxEntities));
-    }
-
-    #endregion
-
-    #region IFormUnderstanding Implementation
-
-    /// <inheritdoc/>
-    public FormFieldResult<T> ExtractFormFields(Tensor<T> documentImage)
-    {
-        return ExtractFormFields(documentImage, 0.5);
-    }
-
-    /// <inheritdoc/>
-    public FormFieldResult<T> ExtractFormFields(Tensor<T> documentImage, double confidenceThreshold)
-    {
-        ValidateImageShape(documentImage);
-        var startTime = DateTime.UtcNow;
-
-        var preprocessed = PreprocessDocument(documentImage);
-        var output = _useNativeMode ? Forward(preprocessed) : RunOnnxInference(preprocessed);
-
-        var fields = ParseFormFields(output, confidenceThreshold);
-
-        return new FormFieldResult<T>
-        {
-            Fields = fields,
-            ProcessingTimeMs = (DateTime.UtcNow - startTime).TotalMilliseconds
-        };
-    }
-
-    /// <inheritdoc/>
-    public Dictionary<string, string> ExtractKeyValuePairs(Tensor<T> documentImage)
-    {
-        var result = ExtractFormFields(documentImage);
-        return result.Fields.ToDictionary(f => f.FieldName, f => f.FieldValue);
-    }
-
-    /// <inheritdoc/>
-    public IEnumerable<CheckboxResult<T>> DetectCheckboxes(Tensor<T> documentImage)
-    {
-        ValidateImageShape(documentImage);
-        var preprocessed = PreprocessDocument(documentImage);
-        var output = _useNativeMode ? Forward(preprocessed) : RunOnnxInference(preprocessed);
-
-        // Simplified checkbox detection
-        yield return new CheckboxResult<T>
-        {
-            IsChecked = false,
-            Label = "Sample checkbox",
-            Confidence = NumOps.FromDouble(0.8),
-            ConfidenceValue = 0.8,
-            BoundingBox = Vector<T>.Empty()
-        };
-    }
-
-    /// <inheritdoc/>
-    public IEnumerable<SignatureResult<T>> DetectSignatures(Tensor<T> documentImage)
-    {
-        ValidateImageShape(documentImage);
-        var preprocessed = PreprocessDocument(documentImage);
-        var output = _useNativeMode ? Forward(preprocessed) : RunOnnxInference(preprocessed);
-
-        yield return new SignatureResult<T>
-        {
-            IsPresent = false,
-            Confidence = NumOps.FromDouble(0.7),
-            ConfidenceValue = 0.7,
-            BoundingBox = Vector<T>.Empty()
-        };
-    }
-
-    private IList<FormField<T>> ParseFormFields(Tensor<T> output, double threshold)
-    {
-        var fields = new List<FormField<T>>();
-        int numEntities = Math.Min(output.Shape[0], _maxEntities);
-        int hiddenDim = output.Shape.Length > 1 ? output.Shape[1] : _textDim;
-
-        for (int i = 0; i < numEntities; i++)
-        {
-            double conf = NumOps.ToDouble(output[i, 0]);
-            if (conf >= threshold)
-            {
-                // Extract entity type from output
-                int entityType = 0;
-                double maxTypeScore = double.MinValue;
-                for (int t = 0; t < Math.Min(_numEntityTypes, hiddenDim - 1); t++)
-                {
-                    double typeScore = NumOps.ToDouble(output[i, 1 + t]);
-                    if (typeScore > maxTypeScore)
-                    {
-                        maxTypeScore = typeScore;
-                        entityType = t;
-                    }
-                }
-
-                // Extract field name from key embedding portion
-                string fieldName = ExtractFieldText(output, i, hiddenDim, startOffset: _numEntityTypes + 1, maxLen: 32);
-
-                // Extract field value from value embedding portion
-                string fieldValue = ExtractFieldText(output, i, hiddenDim, startOffset: _numEntityTypes + 1 + 32, maxLen: 64);
-
-                // Map entity type to field type
-                string fieldType = entityType switch
-                {
-                    0 => "text",
-                    1 => "name",
-                    2 => "date",
-                    3 => "number",
-                    4 => "address",
-                    5 => "email",
-                    6 => "phone",
-                    7 => "checkbox",
-                    8 => "signature",
-                    _ => "other"
-                };
-
-                fields.Add(new FormField<T>
-                {
-                    FieldName = string.IsNullOrEmpty(fieldName) ? $"field_{entityType}_{i}" : fieldName,
-                    FieldValue = fieldValue,
-                    FieldType = fieldType,
-                    Confidence = NumOps.FromDouble(conf),
-                    ConfidenceValue = conf,
-                    BoundingBox = ExtractBoundingBox(output, i, hiddenDim)
-                });
-            }
-        }
-
-        return fields;
-    }
-
-    /// <summary>
-    /// Extracts text from embedding portion of output.
-    /// </summary>
-    private string ExtractFieldText(Tensor<T> output, int entityIdx, int hiddenDim, int startOffset, int maxLen)
-    {
-        var tokens = new List<int>();
-        int endOffset = Math.Min(startOffset + maxLen, hiddenDim);
-
-        for (int j = startOffset; j < endOffset; j++)
-        {
-            double val = NumOps.ToDouble(output[entityIdx, j]);
-            int tokenId = (int)Math.Round(val * 255); // Denormalize from embedding
-
-            // Special tokens
-            if (tokenId <= 2) continue; // PAD, BOS, EOS
-            if (tokenId == 0 || tokenId > 214) break; // End of sequence
-            tokens.Add(tokenId);
-        }
-
-        return DecodeTokensToText(tokens);
-    }
-
-    /// <summary>
-    /// Extracts bounding box coordinates from output.
-    /// </summary>
-    private Vector<T> ExtractBoundingBox(Tensor<T> output, int entityIdx, int hiddenDim)
-    {
-        // Last 4 values in hidden dimension represent normalized bbox [x1, y1, x2, y2]
-        if (hiddenDim < 4) return Vector<T>.Empty();
-
-        int bboxStart = hiddenDim - 4;
-        return new Vector<T>([
-            NumOps.FromDouble(NumOps.ToDouble(output[entityIdx, bboxStart]) * ImageSize),
-            NumOps.FromDouble(NumOps.ToDouble(output[entityIdx, bboxStart + 1]) * ImageSize),
-            NumOps.FromDouble(NumOps.ToDouble(output[entityIdx, bboxStart + 2]) * ImageSize),
-            NumOps.FromDouble(NumOps.ToDouble(output[entityIdx, bboxStart + 3]) * ImageSize)
-        ]);
-    }
-
-    /// <summary>
-    /// Decodes token IDs to text.
-    /// </summary>
-    private static string DecodeTokensToText(List<int> tokens)
-    {
-        if (tokens.Count == 0) return string.Empty;
-
-        var sb = new System.Text.StringBuilder();
-        foreach (int token in tokens)
-        {
-            char c = token switch
-            {
-                >= 3 and <= 34 => (char)(token - 3 + 32),    // Space, punctuation, digits
-                >= 35 and <= 60 => (char)(token - 35 + 65),  // A-Z
-                >= 61 and <= 86 => (char)(token - 61 + 97),  // a-z
-                >= 87 and <= 214 => (char)(token - 87 + 128), // Extended ASCII
-                _ => '?' // Unknown
-            };
-            sb.Append(c);
-        }
-
-        return sb.ToString();
-    }
-
-    #endregion
-
-    #region ITextDetector Implementation
-
-    /// <inheritdoc/>
-    public TextDetectionResult<T> DetectText(Tensor<T> documentImage)
-    {
-        return DetectText(documentImage, 0.5);
-    }
-
-    /// <inheritdoc/>
-    public TextDetectionResult<T> DetectText(Tensor<T> documentImage, double confidenceThreshold)
-    {
-        ValidateImageShape(documentImage);
-        var startTime = DateTime.UtcNow;
-
-        var preprocessed = PreprocessDocument(documentImage);
-        var output = _useNativeMode ? Forward(preprocessed) : RunOnnxInference(preprocessed);
-
-        var regions = ParseTextRegions(output, confidenceThreshold);
-
-        return new TextDetectionResult<T>
-        {
-            TextRegions = regions,
-            ProcessingTimeMs = (DateTime.UtcNow - startTime).TotalMilliseconds
-        };
-    }
-
-    /// <inheritdoc/>
-    public IEnumerable<TextDetectionResult<T>> DetectTextBatch(IEnumerable<Tensor<T>> documentImages)
-    {
-        foreach (var image in documentImages)
-            yield return DetectText(image);
-    }
-
-    /// <inheritdoc/>
-    public Tensor<T> GetHeatmap()
-    {
-        return Tensor<T>.CreateDefault([ImageSize, ImageSize], NumOps.Zero);
-    }
-
-    /// <inheritdoc/>
-    public Tensor<T> GetProbabilityMap(Tensor<T> image)
-    {
-        ValidateImageShape(image);
-        var preprocessed = PreprocessDocument(image);
-        var output = _useNativeMode ? Forward(preprocessed) : RunOnnxInference(preprocessed);
-
-        return Tensor<T>.CreateDefault([ImageSize, ImageSize], NumOps.Zero);
-    }
-
-    private List<TextRegion<T>> ParseTextRegions(Tensor<T> output, double threshold)
-    {
-        var regions = new List<TextRegion<T>>();
-        int numDetections = Math.Min(output.Shape[0], _maxEntities);
-
-        for (int i = 0; i < numDetections; i++)
-        {
-            double conf = NumOps.ToDouble(output[i, 0]);
-            if (conf >= threshold)
-            {
-                regions.Add(new TextRegion<T>
-                {
-                    Confidence = NumOps.FromDouble(conf),
-                    ConfidenceValue = conf,
-                    BoundingBox = Vector<T>.Empty(),
-                    PolygonPoints = [],
-                    Index = i
-                });
-            }
-        }
-
-        return regions;
-    }
-
-    #endregion
-
-    #region IDocumentModel Implementation
-
-    /// <inheritdoc/>
-    public Tensor<T> EncodeDocument(Tensor<T> documentImage)
-    {
-        ValidateImageShape(documentImage);
-        var preprocessed = PreprocessDocument(documentImage);
-        return _useNativeMode ? Forward(preprocessed) : RunOnnxInference(preprocessed);
-    }
-
-    /// <inheritdoc/>
-    public void ValidateInputShape(Tensor<T> documentImage)
-    {
-        ValidateImageShape(documentImage);
-    }
-
-    /// <inheritdoc/>
-    public string GetModelSummary()
-    {
-        var sb = new System.Text.StringBuilder();
-        sb.AppendLine("TRIE Model Summary");
-        sb.AppendLine("==================");
-        sb.AppendLine($"Mode: {(_useNativeMode ? "Native (Trainable)" : "ONNX (Inference)")}");
-        sb.AppendLine($"Architecture: Visual + Text + Graph Encoder");
-        sb.AppendLine($"Visual Dimension: {_visualDim}");
-        sb.AppendLine($"Text Dimension: {_textDim}");
-        sb.AppendLine($"Graph Dimension: {_graphDim}");
-        sb.AppendLine($"Entity Types: {_numEntityTypes}");
-        sb.AppendLine($"Max Entities: {_maxEntities}");
-        sb.AppendLine($"Image Size: {ImageSize}x{ImageSize}");
-        sb.AppendLine($"End-to-End: Yes");
-        sb.AppendLine($"Total Layers: {Layers.Count}");
-        return sb.ToString();
-    }
-
-    #endregion
-
-    #region Preprocessing
-
-    /// <summary>
-    /// Applies TRIE's industry-standard preprocessing: ImageNet normalization.
-    /// </summary>
-    /// <remarks>
-    /// TRIE (Text Reading in-the-wild for Extraction) uses ImageNet normalization with
-    /// mean=[0.485, 0.456, 0.406] and std=[0.229, 0.224, 0.225].
-    /// </remarks>
-    protected override Tensor<T> ApplyDefaultPreprocessing(Tensor<T> rawImage)
-    {
-        var image = EnsureBatchDimension(rawImage);
-        var normalized = new Tensor<T>(image._shape);
-        double[] means = [0.485, 0.456, 0.406];
-        double[] stds = [0.229, 0.224, 0.225];
-
-        int batchSize = image.Shape[0];
-        int channels = image.Shape[1];
-        int height = image.Shape[2];
-        int width = image.Shape[3];
-
-        for (int b = 0; b < batchSize; b++)
-        {
-            for (int c = 0; c < channels; c++)
-            {
-                double mean = c < means.Length ? means[c] : 0.5;
-                double std = c < stds.Length ? stds[c] : 0.5;
-                for (int h = 0; h < height; h++)
-                {
-                    for (int w = 0; w < width; w++)
-                    {
-                        int idx = b * channels * height * width + c * height * width + h * width + w;
-                        normalized.Data.Span[idx] = NumOps.FromDouble((NumOps.ToDouble(image.Data.Span[idx]) - mean) / std);
-                    }
-                }
-            }
-        }
-        return normalized;
-    }
-
-    /// <summary>
-    /// Applies TRIE's industry-standard postprocessing: pass-through (entity extraction outputs are already final).
-    /// </summary>
-    protected override Tensor<T> ApplyDefaultPostprocessing(Tensor<T> modelOutput) => modelOutput;
-
-    #endregion
-
-    #region Serialization
-
-    /// <inheritdoc/>
-    public override ModelMetadata<T> GetModelMetadata()
-    {
-        return new ModelMetadata<T>
-        {
-            Name = "TRIE",
-            Description = "TRIE for end-to-end text reading and information extraction (ACM MM 2020)",
-            FeatureCount = _graphDim,
-            Complexity = Layers.Count,
-            AdditionalInfo = new Dictionary<string, object>
-            {
-                { "visual_dim", _visualDim },
-                { "text_dim", _textDim },
-                { "graph_dim", _graphDim },
-                { "num_entity_types", _numEntityTypes },
-                { "max_entities", _maxEntities },
-                { "image_size", ImageSize },
-                { "use_native_mode", _useNativeMode }
-            },
-            ModelData = SafeSerialize()
-        };
-    }
-
-    /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_visualDim);
-        writer.Write(_textDim);
-        writer.Write(_graphDim);
-        writer.Write(_numEntityTypes);
-        writer.Write(_maxEntities);
-        writer.Write(ImageSize);
-        writer.Write(_useNativeMode);
-    }
-
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        int visualDim = reader.ReadInt32();
-        int textDim = reader.ReadInt32();
-        int graphDim = reader.ReadInt32();
-        int numEntityTypes = reader.ReadInt32();
-        int maxEntities = reader.ReadInt32();
-        int imageSize = reader.ReadInt32();
-        bool useNativeMode = reader.ReadBoolean();
-
-        ImageSize = imageSize;
-    }
-
-    /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new TRIE<T>(Architecture, ImageSize, _visualDim, _textDim, _graphDim, _numEntityTypes, _maxEntities);
-    }
-
-    #endregion
-
-    #region NeuralNetworkBase Implementation
-
-    /// <inheritdoc/>
-    protected override Tensor<T> PredictCore(Tensor<T> input)
-    {
-        var preprocessed = PreprocessDocument(input);
-        return _useNativeMode ? Forward(preprocessed) : RunOnnxInference(preprocessed);
-    }
-
-    // Layer roles in CreateDefaultTRIELayers order: [0..VisualEncoderLayerCount) = visual backbone
-    // (conv/BN/pool + a channel conv), then the text encoder, then the shared graph-reasoning and
-    // extraction heads. TRIE (Zhang et al. 2020) reads BOTH a document image and its text tokens;
-    // this native forward is modality-robust — it routes by input rank so a token-only input goes to
-    // the text encoder and an image goes through the visual backbone, both feeding the shared graph +
-    // extraction stack. Without this the base linear walk sends the rank-1 token vector into the
-    // rank-4-only Conv backbone and throws ("expected input depth 1, got 16").
-    private const int VisualEncoderLayerCount = 4;
-    private const int TextEncoderLayerCount = 2;
-
-    // Visual stream: conv backbone -> flatten spatial grid to a [Nv, F] token/node matrix.
-    private Tensor<T> RunVisualStream(Tensor<T> image)
-    {
-        var feats = image;
-        for (int i = 0; i < VisualEncoderLayerCount && i < Layers.Count; i++)
-            feats = Layers[i].Forward(feats);
-        return FlattenSpatialToTokens(feats);
-    }
-
-    // Text stream: the token encoder (skips the visual conv backbone). Returns [F] or [Nt, F].
-    private Tensor<T> RunTextStream(Tensor<T> tokens)
-    {
-        var feats = tokens;
-        for (int i = VisualEncoderLayerCount; i < VisualEncoderLayerCount + TextEncoderLayerCount && i < Layers.Count; i++)
-            feats = Layers[i].Forward(feats);
-        return feats;
-    }
-
-    // Shared graph-reasoning + extraction heads over [N, F] node features. The graph-convolution layers
-    // need rank-2 [N, F] (a rank-1 [F] text vector is a single node) — normalize, then squeeze back so a
-    // token-only forward keeps its original output rank.
-    private Tensor<T> RunSharedGraph(Tensor<T> feats)
-    {
-        bool squeezeBack = feats.Rank == 1;
-        if (squeezeBack) feats = Engine.Reshape(feats, new[] { 1, feats.Shape[0] });
-
-        for (int i = VisualEncoderLayerCount + TextEncoderLayerCount; i < Layers.Count; i++)
-            feats = Layers[i].Forward(feats);
-
-        if (squeezeBack && feats.Rank == 2 && feats.Shape[0] == 1)
-            feats = Engine.Reshape(feats, new[] { feats.Shape[1] });
-        return feats;
-    }
-
-    // Single-modality forward: route a token-only (rank <= 2) input through the text stream and a
-    // document image (rank >= 3) through the visual backbone, both feeding the shared graph stack.
-    // This is the graceful degradation path — a caller with only ONE modality still gets a valid output
-    // (TRIE/PICK/DocGCN reference impls typically require both), which is where we exceed them.
-    private Tensor<T> RunModalityForward(Tensor<T> input)
-        => RunSharedGraph(input.Rank <= 2 ? RunTextStream(input) : RunVisualStream(input));
-
-    // Modality-robust fused forward (Zhang et al. 2020, §3: TRIE reasons jointly over multimodal nodes).
-    // Mirrors the LayoutXLM/LayoutLMv2 RunMultimodal pattern: run each PRESENT stream, and when BOTH are
-    // available stack the visual token-nodes and text token-nodes into one joint node set along the NODE
-    // axis (axis 0 for the graph models' [N, F] layout, vs LayoutXLM's [B, L, D] axis-1) so the shared
-    // GraphConvolutionalLayer stack reasons over text + visual nodes together. Missing either modality
-    // gracefully falls back to the single-stream path.
-    private Tensor<T> RunFusedModalityForward(Tensor<T>? tokens, Tensor<T>? image)
-    {
-        var textSeq = tokens is not null ? RunTextStream(tokens) : null;
-        var visualSeq = image is not null ? RunVisualStream(image) : null;
-
-        Tensor<T> feats;
-        if (textSeq is not null && visualSeq is not null)
-        {
-            // Align both streams to a rank-2 [N, F] node matrix (the visual backbone may emit a batched
-            // [B, Nv, F] and the text stream an unbatched [F] / [Nt, F]) so the node-axis concat lines up.
-            var vis = AlignToNodeMatrix(visualSeq);
-            var txt = AlignToNodeMatrix(textSeq);
-            feats = Engine.TensorConcatenate(new[] { vis, txt }, axis: 0);   // [Nv + Nt, F]
-        }
-        else
-        {
-            feats = textSeq ?? visualSeq
-                ?? throw new ArgumentException("TRIE requires text token IDs (rank <= 2) or a document image (rank >= 3).");
-        }
-        return RunSharedGraph(feats);
-    }
-
-    // Normalizes a stream output to a rank-2 [N, F] node matrix for node-axis fusion.
-    private Tensor<T> AlignToNodeMatrix(Tensor<T> s)
-    {
-        if (s.Rank == 1) return Engine.Reshape(s, new[] { 1, s.Shape[0] });                       // [F] -> [1, F]
-        if (s.Rank == 3) return Engine.Reshape(s, new[] { s.Shape[0] * s.Shape[1], s.Shape[2] }); // [B, N, F] -> [B*N, F]
-        return s;                                                                                  // already [N, F]
-    }
-
-    /// <summary>
-    /// Modality-robust fused inference: reasons jointly over BOTH a document image and its text tokens
-    /// by concatenating their encoded node sets and running the shared graph stack. Pass <c>null</c> for
-    /// a missing modality and the model gracefully degrades to the remaining stream — reference TRIE
-    /// implementations require both modalities, so single-modality support is where this exceeds them.
-    /// </summary>
-    /// <param name="textTokens">Token features/IDs (rank &lt;= 2), or null when only an image is available.</param>
-    /// <param name="documentImage">Raw document image (rank &gt;= 3), or null when only text is available.</param>
-    public Tensor<T> PredictMultimodal(Tensor<T>? textTokens, Tensor<T>? documentImage)
-    {
-        if (!_useNativeMode)
-            throw new NotSupportedException("Multimodal fusion is only available in native mode.");
-        if (textTokens is null && documentImage is null)
-            throw new ArgumentException("PredictMultimodal requires at least one of textTokens or documentImage.");
-
-        SetTrainingMode(false);
-        var image = documentImage is not null ? PreprocessDocument(documentImage) : null;
-        return RunFusedModalityForward(textTokens, image);
-    }
-
-    // [C, H, W] -> [H*W, C]; [B, C, H, W] -> [B, H*W, C]. Puts channels last so each spatial location
-    // becomes a token whose feature vector the downstream Dense layers map over.
-    private Tensor<T> FlattenSpatialToTokens(Tensor<T> feat)
-    {
-        if (feat.Rank == 4)
-        {
-            int b = feat.Shape[0], c = feat.Shape[1], n = feat.Shape[2] * feat.Shape[3];
-            return Engine.TensorPermute(Engine.Reshape(feat, new[] { b, c, n }), new[] { 0, 2, 1 });
-        }
-        if (feat.Rank == 3)
-        {
-            int c = feat.Shape[0], n = feat.Shape[1] * feat.Shape[2];
-            return Engine.TensorPermute(Engine.Reshape(feat, new[] { c, n }), new[] { 1, 0 });
-        }
-        return feat;
-    }
-
-    /// <inheritdoc/>
-    protected override Tensor<T> Forward(Tensor<T> input)
-        => _useNativeMode ? RunModalityForward(input) : base.Forward(input);
-
-    /// <inheritdoc/>
-    public override Tensor<T> ForwardForTraining(Tensor<T> input)
-        => _useNativeMode ? RunModalityForward(input) : base.ForwardForTraining(input);
-
-    /// <inheritdoc/>
-    /// <remarks>
-    /// Diagnostic counterpart of the modality routing in <see cref="RunModalityForward"/>: the base
-    /// implementation walks <c>Layers</c> from index 0, sending a token-only input into the rank-4-only
-    /// Conv backbone and throwing before it records anything. Record only the layers that actually fire
-    /// for the supplied modality so the activations dictionary is non-empty and meaningful.
-    /// </remarks>
-    public override Dictionary<string, Tensor<T>> GetNamedLayerActivations(Tensor<T> input)
-    {
-        if (input is null)
-            throw new ArgumentNullException(nameof(input));
-
-        if (!_useNativeMode)
-            return base.GetNamedLayerActivations(input);
-
-        var activations = new Dictionary<string, Tensor<T>>();
-        var current = input;
-        if (input.Rank <= 2)
-        {
-            for (int i = VisualEncoderLayerCount; i < VisualEncoderLayerCount + TextEncoderLayerCount && i < Layers.Count; i++)
-            {
-                current = Layers[i].Forward(current);
-                activations[$"Layer_{i}_{Layers[i].GetType().Name}"] = current.Clone();
-            }
-        }
-        else
-        {
-            for (int i = 0; i < VisualEncoderLayerCount && i < Layers.Count; i++)
-            {
-                current = Layers[i].Forward(current);
-                activations[$"Layer_{i}_{Layers[i].GetType().Name}"] = current.Clone();
-            }
-            current = FlattenSpatialToTokens(current);
-        }
-        for (int i = VisualEncoderLayerCount + TextEncoderLayerCount; i < Layers.Count; i++)
-        {
-            current = Layers[i].Forward(current);
-            activations[$"Layer_{i}_{Layers[i].GetType().Name}"] = current.Clone();
-        }
-        return activations;
-    }
-
-    /// <inheritdoc/>
-    public override void Train(Tensor<T> input, Tensor<T> expectedOutput)
-    {
-        if (!_useNativeMode)
-            throw new NotSupportedException("Training not supported in ONNX mode.");
-
-        // TrainWithTape runs the full forward (ForwardForTraining -> RunModalityForward), backprops,
-        // and applies the optimizer update itself. The earlier UpdateParameters(CollectGradients())
-        // was a redundant SECOND update whose hand-collected gradient vector did not line up with
-        // GetParameters(), corrupting the step. TrainWithTape alone is the correct single update.
-        // Restore eval mode in a finally: if TrainWithTape throws, the instance must not be stranded in
-        // training mode (dropout active, BN in train stats) so subsequent Predict calls stay correct.
-        SetTrainingMode(true);
-        try
-        {
-            TrainWithTape(input, expectedOutput, _optimizer);
-        }
-        finally
-        {
-            SetTrainingMode(false);
-        }
-    }
-
-    // UpdateParameters applied a GRADIENT STEP, but its one-argument form is the value setter and every caller passes values -- the override corrupted the model. Removed under AIDN082.

-
-    /// <summary>
-    /// Parameters cannot be written while the model is backed by a loaded ONNX graph: the weights
-    /// belong to that graph, not to this instance.
-    /// </summary>
-    /// <remarks>
-    /// Replaces a hand-written throw that used to sit inside UpdateParameters. The base checks this
-    /// on every mutating entry point rather than the one member the throw happened to guard, and
-    /// reading -- ParameterCount and GetParameters -- stays available either way.
-    /// </remarks>
+using AiDotNet.Attributes;
+using AiDotNet.Document.Interfaces;
+using AiDotNet.Document.Options;
+using AiDotNet.Enums;
+using AiDotNet.Helpers;
+using AiDotNet.Interfaces;
+using AiDotNet.LinearAlgebra;
+using AiDotNet.LossFunctions;
+using AiDotNet.NeuralNetworks;
+using AiDotNet.NeuralNetworks.Layers;
+using AiDotNet.Optimizers;
+using Microsoft.ML.OnnxRuntime;
+
+namespace AiDotNet.Document.GraphBased;
+
+/// <summary>
+/// TRIE (Text Reading and Information Extraction) for end-to-end document understanding.
+/// </summary>
+/// <typeparam name="T">The numeric type used for calculations.</typeparam>
+/// <remarks>
+/// <para>
+/// TRIE combines text reading (OCR) with information extraction in an end-to-end framework,
+/// using graph neural networks to model relationships between text entities and extract
+/// structured information.
+/// </para>
+/// <para>
+/// <b>For Beginners:</b> TRIE does reading and extraction together:
+/// 1. Reads text from document images
+/// 2. Builds a graph of text entities
+/// 3. Extracts key-value pairs and entities
+/// 4. Outputs structured information
+///
+/// Key features:
+/// - End-to-end text reading + extraction
+/// - Graph-based entity relationship modeling
+/// - Joint optimization of OCR and IE
+/// - Strong performance on receipts and forms
+///
+/// Example usage:
+/// <code>
+/// var model = new TRIE&lt;float&gt;(architecture);
+/// var result = model.ExtractFormFields(documentImage);
+/// </code>
+/// </para>
+/// <para>
+/// <b>Reference:</b> "TRIE: End-to-End Text Reading and Information Extraction" (ACM MM 2020)
+/// https://arxiv.org/abs/2005.13118
+/// </para>
+/// </remarks>
+[ModelDomain(ModelDomain.Vision)]
+[ModelDomain(ModelDomain.Language)]
+[ModelCategory(ModelCategory.NeuralNetwork)]
+[ModelCategory(ModelCategory.GraphNetwork)]
+[ModelTask(ModelTask.Detection)]
+[ModelTask(ModelTask.FeatureExtraction)]
+[ModelComplexity(ModelComplexity.High)]
+[ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
+[ResearchPaper("TRIE: End-to-End Text Reading and Information Extraction for Document Understanding", "https://doi.org/10.48550/arXiv.2005.13118", Year = 2020, Authors = "Peng Zhang, Yunlu Xu, Zhanzhan Cheng, Shiliang Pu, Jing Lu, Liang Qiao, Yi Niu, Fei Wu")]
+public partial class TRIE<T> : DocumentNeuralNetworkBase<T>, IFormUnderstanding<T>, ITextDetector<T>
+{
+    private readonly TRIEOptions _options;
+
+    /// <inheritdoc/>
+    public override ModelOptions GetOptions() => _options;
+
+    #region Fields
+
+    private readonly bool _useNativeMode;
+    private readonly InferenceSession? _onnxSession;
+    private readonly IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>> _optimizer;
+    private readonly int _visualDim;
+    private readonly int _textDim;
+    private readonly int _graphDim;
+    private readonly int _numEntityTypes;
+    private readonly int _maxEntities;
+
+    // Native mode layers
+    private readonly List<ILayer<T>> _visualEncoderLayers = [];
+    private readonly List<ILayer<T>> _textEncoderLayers = [];
+    private readonly List<ILayer<T>> _graphLayers = [];
+    private readonly List<ILayer<T>> _extractionLayers = [];
+
+    #endregion
+
+    #region Properties
+
+    /// <inheritdoc/>
+    public override DocumentType SupportedDocumentTypes => DocumentType.Form;
+
+    /// <inheritdoc/>
+    public override bool RequiresOCR => false;
+
+    /// <inheritdoc/>
+    public int ExpectedImageSize => ImageSize;
+
+    /// <summary>
+    /// Gets the number of entity types.
+    /// </summary>
+    public int NumEntityTypes => _numEntityTypes;
+
+    /// <inheritdoc/>
+    public bool SupportsRotatedText => true;
+
+    /// <inheritdoc/>
+    public int MinTextHeight => 8;
+
+    /// <inheritdoc/>
+    public bool SupportsPolygonOutput => true;
+
+    #endregion
+
+    #region Constructors
+
+    /// <summary>
+    /// Creates a TRIE model with default configuration for native training.
+    /// </summary>
+    public TRIE()
+        : this(new NeuralNetworkArchitecture<T>(
+            inputType: InputType.TwoDimensional,
+            taskType: NeuralNetworkTaskType.MultiClassClassification,
+            inputHeight: 512, inputWidth: 512,
+            outputSize: 256))
+    {
+    }
+
+    /// <summary>
+    /// Creates a TRIE model using a pre-trained ONNX model for inference.
+    /// </summary>
+    public TRIE(
+        NeuralNetworkArchitecture<T> architecture,
+        string onnxModelPath,
+        int imageSize = 512,
+        int visualDim = 256,
+        int textDim = 256,
+        int graphDim = 256,
+        int numEntityTypes = 10,
+        int maxEntities = 100,
+        IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? optimizer = null,
+        ILossFunction<T>? lossFunction = null,
+        TRIEOptions? options = null)
+        : base(architecture, lossFunction ?? new CrossEntropyWithLogitsLoss<T>(), 1.0)
+    {
+        _options = options ?? new TRIEOptions();
+        Options = _options;
+
+        if (string.IsNullOrWhiteSpace(onnxModelPath))
+            throw new ArgumentNullException(nameof(onnxModelPath));
+        if (!File.Exists(onnxModelPath))
+            throw new FileNotFoundException($"ONNX model not found: {onnxModelPath}", onnxModelPath);
+
+        _useNativeMode = false;
+        _visualDim = visualDim;
+        _textDim = textDim;
+        _graphDim = graphDim;
+        _numEntityTypes = numEntityTypes;
+        _maxEntities = maxEntities;
+        _optimizer = optimizer ?? new AdamOptimizer<T, Tensor<T>, Tensor<T>>(this);
+
+        ImageSize = imageSize;
+
+        _onnxSession = new InferenceSession(onnxModelPath);
+
+        InitializeLayers();
+    }
+
+    /// <summary>
+    /// Creates a TRIE model using native layers for training and inference.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// <b>Default Configuration (TRIE from ACM MM 2020):</b>
+    /// - Visual encoder: ResNet backbone
+    /// - Text encoder: BiLSTM
+    /// - Graph reasoning module
+    /// - Multi-task extraction heads
+    /// </para>
+    /// </remarks>
+    public TRIE(
+        NeuralNetworkArchitecture<T> architecture,
+        int imageSize = 512,
+        int visualDim = 256,
+        int textDim = 256,
+        int graphDim = 256,
+        int numEntityTypes = 10,
+        int maxEntities = 100,
+        IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? optimizer = null,
+        ILossFunction<T>? lossFunction = null,
+        TRIEOptions? options = null)
+        : base(architecture, lossFunction ?? new CrossEntropyWithLogitsLoss<T>(), 1.0)
+    {
+        _options = options ?? new TRIEOptions();
+        Options = _options;
+
+        _useNativeMode = true;
+        _visualDim = visualDim;
+        _textDim = textDim;
+        _graphDim = graphDim;
+        _numEntityTypes = numEntityTypes;
+        _maxEntities = maxEntities;
+        _optimizer = optimizer ?? new AdamOptimizer<T, Tensor<T>, Tensor<T>>(this);
+
+        ImageSize = imageSize;
+
+        InitializeLayers();
+    }
+
+    #endregion
+
+    #region Initialization
+
+    /// <inheritdoc/>
+    protected override void InitializeLayers()
+    {
+        if (!_useNativeMode)
+        {
+            return;
+        }
+
+        if (Architecture.Layers is not null && Architecture.Layers.Count > 0)
+        {
+            Layers.AddRange(Architecture.Layers);
+            ValidateCustomLayers(Layers);
+            return;
+        }
+
+        Layers.AddRange(LayerHelper<T>.CreateDefaultTRIELayers(
+            imageSize: ImageSize,
+            visualDim: _visualDim,
+            textDim: _textDim,
+            graphDim: _graphDim,
+            numEntityTypes: _numEntityTypes,
+            maxEntities: _maxEntities));
+    }
+
+    #endregion
+
+    #region IFormUnderstanding Implementation
+
+    /// <inheritdoc/>
+    public FormFieldResult<T> ExtractFormFields(Tensor<T> documentImage)
+    {
+        return ExtractFormFields(documentImage, 0.5);
+    }
+
+    /// <inheritdoc/>
+    public FormFieldResult<T> ExtractFormFields(Tensor<T> documentImage, double confidenceThreshold)
+    {
+        ValidateImageShape(documentImage);
+        var startTime = DateTime.UtcNow;
+
+        var preprocessed = PreprocessDocument(documentImage);
+        var output = _useNativeMode ? Forward(preprocessed) : RunOnnxInference(preprocessed);
+
+        var fields = ParseFormFields(output, confidenceThreshold);
+
+        return new FormFieldResult<T>
+        {
+            Fields = fields,
+            ProcessingTimeMs = (DateTime.UtcNow - startTime).TotalMilliseconds
+        };
+    }
+
+    /// <inheritdoc/>
+    public Dictionary<string, string> ExtractKeyValuePairs(Tensor<T> documentImage)
+    {
+        var result = ExtractFormFields(documentImage);
+        return result.Fields.ToDictionary(f => f.FieldName, f => f.FieldValue);
+    }
+
+    /// <inheritdoc/>
+    public IEnumerable<CheckboxResult<T>> DetectCheckboxes(Tensor<T> documentImage)
+    {
+        ValidateImageShape(documentImage);
+        var preprocessed = PreprocessDocument(documentImage);
+        var output = _useNativeMode ? Forward(preprocessed) : RunOnnxInference(preprocessed);
+
+        // Simplified checkbox detection
+        yield return new CheckboxResult<T>
+        {
+            IsChecked = false,
+            Label = "Sample checkbox",
+            Confidence = NumOps.FromDouble(0.8),
+            ConfidenceValue = 0.8,
+            BoundingBox = Vector<T>.Empty()
+        };
+    }
+
+    /// <inheritdoc/>
+    public IEnumerable<SignatureResult<T>> DetectSignatures(Tensor<T> documentImage)
+    {
+        ValidateImageShape(documentImage);
+        var preprocessed = PreprocessDocument(documentImage);
+        var output = _useNativeMode ? Forward(preprocessed) : RunOnnxInference(preprocessed);
+
+        yield return new SignatureResult<T>
+        {
+            IsPresent = false,
+            Confidence = NumOps.FromDouble(0.7),
+            ConfidenceValue = 0.7,
+            BoundingBox = Vector<T>.Empty()
+        };
+    }
+
+    private IList<FormField<T>> ParseFormFields(Tensor<T> output, double threshold)
+    {
+        var fields = new List<FormField<T>>();
+        int numEntities = Math.Min(output.Shape[0], _maxEntities);
+        int hiddenDim = output.Shape.Length > 1 ? output.Shape[1] : _textDim;
+
+        for (int i = 0; i < numEntities; i++)
+        {
+            double conf = NumOps.ToDouble(output[i, 0]);
+            if (conf >= threshold)
+            {
+                // Extract entity type from output
+                int entityType = 0;
+                double maxTypeScore = double.MinValue;
+                for (int t = 0; t < Math.Min(_numEntityTypes, hiddenDim - 1); t++)
+                {
+                    double typeScore = NumOps.ToDouble(output[i, 1 + t]);
+                    if (typeScore > maxTypeScore)
+                    {
+                        maxTypeScore = typeScore;
+                        entityType = t;
+                    }
+                }
+
+                // Extract field name from key embedding portion
+                string fieldName = ExtractFieldText(output, i, hiddenDim, startOffset: _numEntityTypes + 1, maxLen: 32);
+
+                // Extract field value from value embedding portion
+                string fieldValue = ExtractFieldText(output, i, hiddenDim, startOffset: _numEntityTypes + 1 + 32, maxLen: 64);
+
+                // Map entity type to field type
+                string fieldType = entityType switch
+                {
+                    0 => "text",
+                    1 => "name",
+                    2 => "date",
+                    3 => "number",
+                    4 => "address",
+                    5 => "email",
+                    6 => "phone",
+                    7 => "checkbox",
+                    8 => "signature",
+                    _ => "other"
+                };
+
+                fields.Add(new FormField<T>
+                {
+                    FieldName = string.IsNullOrEmpty(fieldName) ? $"field_{entityType}_{i}" : fieldName,
+                    FieldValue = fieldValue,
+                    FieldType = fieldType,
+                    Confidence = NumOps.FromDouble(conf),
+                    ConfidenceValue = conf,
+                    BoundingBox = ExtractBoundingBox(output, i, hiddenDim)
+                });
+            }
+        }
+
+        return fields;
+    }
+
+    /// <summary>
+    /// Extracts text from embedding portion of output.
+    /// </summary>
+    private string ExtractFieldText(Tensor<T> output, int entityIdx, int hiddenDim, int startOffset, int maxLen)
+    {
+        var tokens = new List<int>();
+        int endOffset = Math.Min(startOffset + maxLen, hiddenDim);
+
+        for (int j = startOffset; j < endOffset; j++)
+        {
+            double val = NumOps.ToDouble(output[entityIdx, j]);
+            int tokenId = (int)Math.Round(val * 255); // Denormalize from embedding
+
+            // Special tokens
+            if (tokenId <= 2) continue; // PAD, BOS, EOS
+            if (tokenId == 0 || tokenId > 214) break; // End of sequence
+            tokens.Add(tokenId);
+        }
+
+        return DecodeTokensToText(tokens);
+    }
+
+    /// <summary>
+    /// Extracts bounding box coordinates from output.
+    /// </summary>
+    private Vector<T> ExtractBoundingBox(Tensor<T> output, int entityIdx, int hiddenDim)
+    {
+        // Last 4 values in hidden dimension represent normalized bbox [x1, y1, x2, y2]
+        if (hiddenDim < 4) return Vector<T>.Empty();
+
+        int bboxStart = hiddenDim - 4;
+        return new Vector<T>([
+            NumOps.FromDouble(NumOps.ToDouble(output[entityIdx, bboxStart]) * ImageSize),
+            NumOps.FromDouble(NumOps.ToDouble(output[entityIdx, bboxStart + 1]) * ImageSize),
+            NumOps.FromDouble(NumOps.ToDouble(output[entityIdx, bboxStart + 2]) * ImageSize),
+            NumOps.FromDouble(NumOps.ToDouble(output[entityIdx, bboxStart + 3]) * ImageSize)
+        ]);
+    }
+
+    /// <summary>
+    /// Decodes token IDs to text.
+    /// </summary>
+    private static string DecodeTokensToText(List<int> tokens)
+    {
+        if (tokens.Count == 0) return string.Empty;
+
+        var sb = new System.Text.StringBuilder();
+        foreach (int token in tokens)
+        {
+            char c = token switch
+            {
+                >= 3 and <= 34 => (char)(token - 3 + 32),    // Space, punctuation, digits
+                >= 35 and <= 60 => (char)(token - 35 + 65),  // A-Z
+                >= 61 and <= 86 => (char)(token - 61 + 97),  // a-z
+                >= 87 and <= 214 => (char)(token - 87 + 128), // Extended ASCII
+                _ => '?' // Unknown
+            };
+            sb.Append(c);
+        }
+
+        return sb.ToString();
+    }
+
+    #endregion
+
+    #region ITextDetector Implementation
+
+    /// <inheritdoc/>
+    public TextDetectionResult<T> DetectText(Tensor<T> documentImage)
+    {
+        return DetectText(documentImage, 0.5);
+    }
+
+    /// <inheritdoc/>
+    public TextDetectionResult<T> DetectText(Tensor<T> documentImage, double confidenceThreshold)
+    {
+        ValidateImageShape(documentImage);
+        var startTime = DateTime.UtcNow;
+
+        var preprocessed = PreprocessDocument(documentImage);
+        var output = _useNativeMode ? Forward(preprocessed) : RunOnnxInference(preprocessed);
+
+        var regions = ParseTextRegions(output, confidenceThreshold);
+
+        return new TextDetectionResult<T>
+        {
+            TextRegions = regions,
+            ProcessingTimeMs = (DateTime.UtcNow - startTime).TotalMilliseconds
+        };
+    }
+
+    /// <inheritdoc/>
+    public IEnumerable<TextDetectionResult<T>> DetectTextBatch(IEnumerable<Tensor<T>> documentImages)
+    {
+        foreach (var image in documentImages)
+            yield return DetectText(image);
+    }
+
+    /// <inheritdoc/>
+    public Tensor<T> GetHeatmap()
+    {
+        return Tensor<T>.CreateDefault([ImageSize, ImageSize], NumOps.Zero);
+    }
+
+    /// <inheritdoc/>
+    public Tensor<T> GetProbabilityMap(Tensor<T> image)
+    {
+        ValidateImageShape(image);
+        var preprocessed = PreprocessDocument(image);
+        var output = _useNativeMode ? Forward(preprocessed) : RunOnnxInference(preprocessed);
+
+        return Tensor<T>.CreateDefault([ImageSize, ImageSize], NumOps.Zero);
+    }
+
+    private List<TextRegion<T>> ParseTextRegions(Tensor<T> output, double threshold)
+    {
+        var regions = new List<TextRegion<T>>();
+        int numDetections = Math.Min(output.Shape[0], _maxEntities);
+
+        for (int i = 0; i < numDetections; i++)
+        {
+            double conf = NumOps.ToDouble(output[i, 0]);
+            if (conf >= threshold)
+            {
+                regions.Add(new TextRegion<T>
+                {
+                    Confidence = NumOps.FromDouble(conf),
+                    ConfidenceValue = conf,
+                    BoundingBox = Vector<T>.Empty(),
+                    PolygonPoints = [],
+                    Index = i
+                });
+            }
+        }
+
+        return regions;
+    }
+
+    #endregion
+
+    #region IDocumentModel Implementation
+
+    /// <inheritdoc/>
+    public Tensor<T> EncodeDocument(Tensor<T> documentImage)
+    {
+        ValidateImageShape(documentImage);
+        var preprocessed = PreprocessDocument(documentImage);
+        return _useNativeMode ? Forward(preprocessed) : RunOnnxInference(preprocessed);
+    }
+
+    /// <inheritdoc/>
+    public void ValidateInputShape(Tensor<T> documentImage)
+    {
+        ValidateImageShape(documentImage);
+    }
+
+    /// <inheritdoc/>
+    public string GetModelSummary()
+    {
+        var sb = new System.Text.StringBuilder();
+        sb.AppendLine("TRIE Model Summary");
+        sb.AppendLine("==================");
+        sb.AppendLine($"Mode: {(_useNativeMode ? "Native (Trainable)" : "ONNX (Inference)")}");
+        sb.AppendLine($"Architecture: Visual + Text + Graph Encoder");
+        sb.AppendLine($"Visual Dimension: {_visualDim}");
+        sb.AppendLine($"Text Dimension: {_textDim}");
+        sb.AppendLine($"Graph Dimension: {_graphDim}");
+        sb.AppendLine($"Entity Types: {_numEntityTypes}");
+        sb.AppendLine($"Max Entities: {_maxEntities}");
+        sb.AppendLine($"Image Size: {ImageSize}x{ImageSize}");
+        sb.AppendLine($"End-to-End: Yes");
+        sb.AppendLine($"Total Layers: {Layers.Count}");
+        return sb.ToString();
+    }
+
+    #endregion
+
+    #region Preprocessing
+
+    /// <summary>
+    /// Applies TRIE's industry-standard preprocessing: ImageNet normalization.
+    /// </summary>
+    /// <remarks>
+    /// TRIE (Text Reading in-the-wild for Extraction) uses ImageNet normalization with
+    /// mean=[0.485, 0.456, 0.406] and std=[0.229, 0.224, 0.225].
+    /// </remarks>
+    protected override Tensor<T> ApplyDefaultPreprocessing(Tensor<T> rawImage)
+    {
+        var image = EnsureBatchDimension(rawImage);
+        var normalized = new Tensor<T>(image._shape);
+        double[] means = [0.485, 0.456, 0.406];
+        double[] stds = [0.229, 0.224, 0.225];
+
+        int batchSize = image.Shape[0];
+        int channels = image.Shape[1];
+        int height = image.Shape[2];
+        int width = image.Shape[3];
+
+        for (int b = 0; b < batchSize; b++)
+        {
+            for (int c = 0; c < channels; c++)
+            {
+                double mean = c < means.Length ? means[c] : 0.5;
+                double std = c < stds.Length ? stds[c] : 0.5;
+                for (int h = 0; h < height; h++)
+                {
+                    for (int w = 0; w < width; w++)
+                    {
+                        int idx = b * channels * height * width + c * height * width + h * width + w;
+                        normalized.Data.Span[idx] = NumOps.FromDouble((NumOps.ToDouble(image.Data.Span[idx]) - mean) / std);
+                    }
+                }
+            }
+        }
+        return normalized;
+    }
+
+    /// <summary>
+    /// Applies TRIE's industry-standard postprocessing: pass-through (entity extraction outputs are already final).
+    /// </summary>
+    protected override Tensor<T> ApplyDefaultPostprocessing(Tensor<T> modelOutput) => modelOutput;
+
+    #endregion
+
+    #region Serialization
+
+    /// <inheritdoc/>
+    public override ModelMetadata<T> GetModelMetadata()
+    {
+        return new ModelMetadata<T>
+        {
+            Name = "TRIE",
+            Description = "TRIE for end-to-end text reading and information extraction (ACM MM 2020)",
+            FeatureCount = _graphDim,
+            Complexity = Layers.Count,
+            AdditionalInfo = new Dictionary<string, object>
+            {
+                { "visual_dim", _visualDim },
+                { "text_dim", _textDim },
+                { "graph_dim", _graphDim },
+                { "num_entity_types", _numEntityTypes },
+                { "max_entities", _maxEntities },
+                { "image_size", ImageSize },
+                { "use_native_mode", _useNativeMode }
+            },
+            ModelData = SafeSerialize()
+        };
+    }
+
+    /// <inheritdoc/>
+
+
+    /// <inheritdoc/>
+
+
+    #endregion
+
+    #region NeuralNetworkBase Implementation
+
+    /// <inheritdoc/>
+    protected override Tensor<T> PredictCore(Tensor<T> input)
+    {
+        var preprocessed = PreprocessDocument(input);
+        return _useNativeMode ? Forward(preprocessed) : RunOnnxInference(preprocessed);
+    }
+
+    // Layer roles in CreateDefaultTRIELayers order: [0..VisualEncoderLayerCount) = visual backbone
+    // (conv/BN/pool + a channel conv), then the text encoder, then the shared graph-reasoning and
+    // extraction heads. TRIE (Zhang et al. 2020) reads BOTH a document image and its text tokens;
+    // this native forward is modality-robust — it routes by input rank so a token-only input goes to
+    // the text encoder and an image goes through the visual backbone, both feeding the shared graph +
+    // extraction stack. Without this the base linear walk sends the rank-1 token vector into the
+    // rank-4-only Conv backbone and throws ("expected input depth 1, got 16").
+    private const int VisualEncoderLayerCount = 4;
+    private const int TextEncoderLayerCount = 2;
+
+    // Visual stream: conv backbone -> flatten spatial grid to a [Nv, F] token/node matrix.
+    private Tensor<T> RunVisualStream(Tensor<T> image)
+    {
+        var feats = image;
+        for (int i = 0; i < VisualEncoderLayerCount && i < Layers.Count; i++)
+            feats = Layers[i].Forward(feats);
+        return FlattenSpatialToTokens(feats);
+    }
+
+    // Text stream: the token encoder (skips the visual conv backbone). Returns [F] or [Nt, F].
+    private Tensor<T> RunTextStream(Tensor<T> tokens)
+    {
+        var feats = tokens;
+        for (int i = VisualEncoderLayerCount; i < VisualEncoderLayerCount + TextEncoderLayerCount && i < Layers.Count; i++)
+            feats = Layers[i].Forward(feats);
+        return feats;
+    }
+
+    // Shared graph-reasoning + extraction heads over [N, F] node features. The graph-convolution layers
+    // need rank-2 [N, F] (a rank-1 [F] text vector is a single node) — normalize, then squeeze back so a
+    // token-only forward keeps its original output rank.
+    private Tensor<T> RunSharedGraph(Tensor<T> feats)
+    {
+        bool squeezeBack = feats.Rank == 1;
+        if (squeezeBack) feats = Engine.Reshape(feats, new[] { 1, feats.Shape[0] });
+
+        for (int i = VisualEncoderLayerCount + TextEncoderLayerCount; i < Layers.Count; i++)
+            feats = Layers[i].Forward(feats);
+
+        if (squeezeBack && feats.Rank == 2 && feats.Shape[0] == 1)
+            feats = Engine.Reshape(feats, new[] { feats.Shape[1] });
+        return feats;
+    }
+
+    // Single-modality forward: route a token-only (rank <= 2) input through the text stream and a
+    // document image (rank >= 3) through the visual backbone, both feeding the shared graph stack.
+    // This is the graceful degradation path — a caller with only ONE modality still gets a valid output
+    // (TRIE/PICK/DocGCN reference impls typically require both), which is where we exceed them.
+    private Tensor<T> RunModalityForward(Tensor<T> input)
+        => RunSharedGraph(input.Rank <= 2 ? RunTextStream(input) : RunVisualStream(input));
+
+    // Modality-robust fused forward (Zhang et al. 2020, §3: TRIE reasons jointly over multimodal nodes).
+    // Mirrors the LayoutXLM/LayoutLMv2 RunMultimodal pattern: run each PRESENT stream, and when BOTH are
+    // available stack the visual token-nodes and text token-nodes into one joint node set along the NODE
+    // axis (axis 0 for the graph models' [N, F] layout, vs LayoutXLM's [B, L, D] axis-1) so the shared
+    // GraphConvolutionalLayer stack reasons over text + visual nodes together. Missing either modality
+    // gracefully falls back to the single-stream path.
+    private Tensor<T> RunFusedModalityForward(Tensor<T>? tokens, Tensor<T>? image)
+    {
+        var textSeq = tokens is not null ? RunTextStream(tokens) : null;
+        var visualSeq = image is not null ? RunVisualStream(image) : null;
+
+        Tensor<T> feats;
+        if (textSeq is not null && visualSeq is not null)
+        {
+            // Align both streams to a rank-2 [N, F] node matrix (the visual backbone may emit a batched
+            // [B, Nv, F] and the text stream an unbatched [F] / [Nt, F]) so the node-axis concat lines up.
+            var vis = AlignToNodeMatrix(visualSeq);
+            var txt = AlignToNodeMatrix(textSeq);
+            feats = Engine.TensorConcatenate(new[] { vis, txt }, axis: 0);   // [Nv + Nt, F]
+        }
+        else
+        {
+            feats = textSeq ?? visualSeq
+                ?? throw new ArgumentException("TRIE requires text token IDs (rank <= 2) or a document image (rank >= 3).");
+        }
+        return RunSharedGraph(feats);
+    }
+
+    // Normalizes a stream output to a rank-2 [N, F] node matrix for node-axis fusion.
+    private Tensor<T> AlignToNodeMatrix(Tensor<T> s)
+    {
+        if (s.Rank == 1) return Engine.Reshape(s, new[] { 1, s.Shape[0] });                       // [F] -> [1, F]
+        if (s.Rank == 3) return Engine.Reshape(s, new[] { s.Shape[0] * s.Shape[1], s.Shape[2] }); // [B, N, F] -> [B*N, F]
+        return s;                                                                                  // already [N, F]
+    }
+
+    /// <summary>
+    /// Modality-robust fused inference: reasons jointly over BOTH a document image and its text tokens
+    /// by concatenating their encoded node sets and running the shared graph stack. Pass <c>null</c> for
+    /// a missing modality and the model gracefully degrades to the remaining stream — reference TRIE
+    /// implementations require both modalities, so single-modality support is where this exceeds them.
+    /// </summary>
+    /// <param name="textTokens">Token features/IDs (rank &lt;= 2), or null when only an image is available.</param>
+    /// <param name="documentImage">Raw document image (rank &gt;= 3), or null when only text is available.</param>
+    public Tensor<T> PredictMultimodal(Tensor<T>? textTokens, Tensor<T>? documentImage)
+    {
+        if (!_useNativeMode)
+            throw new NotSupportedException("Multimodal fusion is only available in native mode.");
+        if (textTokens is null && documentImage is null)
+            throw new ArgumentException("PredictMultimodal requires at least one of textTokens or documentImage.");
+
+        SetTrainingMode(false);
+        var image = documentImage is not null ? PreprocessDocument(documentImage) : null;
+        return RunFusedModalityForward(textTokens, image);
+    }
+
+    // [C, H, W] -> [H*W, C]; [B, C, H, W] -> [B, H*W, C]. Puts channels last so each spatial location
+    // becomes a token whose feature vector the downstream Dense layers map over.
+    private Tensor<T> FlattenSpatialToTokens(Tensor<T> feat)
+    {
+        if (feat.Rank == 4)
+        {
+            int b = feat.Shape[0], c = feat.Shape[1], n = feat.Shape[2] * feat.Shape[3];
+            return Engine.TensorPermute(Engine.Reshape(feat, new[] { b, c, n }), new[] { 0, 2, 1 });
+        }
+        if (feat.Rank == 3)
+        {
+            int c = feat.Shape[0], n = feat.Shape[1] * feat.Shape[2];
+            return Engine.TensorPermute(Engine.Reshape(feat, new[] { c, n }), new[] { 1, 0 });
+        }
+        return feat;
+    }
+
+    /// <inheritdoc/>
+    protected override Tensor<T> Forward(Tensor<T> input)
+        => _useNativeMode ? RunModalityForward(input) : base.Forward(input);
+
+    /// <inheritdoc/>
+    public override Tensor<T> ForwardForTraining(Tensor<T> input)
+        => _useNativeMode ? RunModalityForward(input) : base.ForwardForTraining(input);
+
+    /// <inheritdoc/>
+    /// <remarks>
+    /// Diagnostic counterpart of the modality routing in <see cref="RunModalityForward"/>: the base
+    /// implementation walks <c>Layers</c> from index 0, sending a token-only input into the rank-4-only
+    /// Conv backbone and throwing before it records anything. Record only the layers that actually fire
+    /// for the supplied modality so the activations dictionary is non-empty and meaningful.
+    /// </remarks>
+    public override Dictionary<string, Tensor<T>> GetNamedLayerActivations(Tensor<T> input)
+    {
+        if (input is null)
+            throw new ArgumentNullException(nameof(input));
+
+        if (!_useNativeMode)
+            return base.GetNamedLayerActivations(input);
+
+        var activations = new Dictionary<string, Tensor<T>>();
+        var current = input;
+        if (input.Rank <= 2)
+        {
+            for (int i = VisualEncoderLayerCount; i < VisualEncoderLayerCount + TextEncoderLayerCount && i < Layers.Count; i++)
+            {
+                current = Layers[i].Forward(current);
+                activations[$"Layer_{i}_{Layers[i].GetType().Name}"] = current.Clone();
+            }
+        }
+        else
+        {
+            for (int i = 0; i < VisualEncoderLayerCount && i < Layers.Count; i++)
+            {
+                current = Layers[i].Forward(current);
+                activations[$"Layer_{i}_{Layers[i].GetType().Name}"] = current.Clone();
+            }
+            current = FlattenSpatialToTokens(current);
+        }
+        for (int i = VisualEncoderLayerCount + TextEncoderLayerCount; i < Layers.Count; i++)
+        {
+            current = Layers[i].Forward(current);
+            activations[$"Layer_{i}_{Layers[i].GetType().Name}"] = current.Clone();
+        }
+        return activations;
+    }
+
+    /// <inheritdoc/>
+    public override void Train(Tensor<T> input, Tensor<T> expectedOutput)
+    {
+        if (!_useNativeMode)
+            throw new NotSupportedException("Training not supported in ONNX mode.");
+
+        // TrainWithTape runs the full forward (ForwardForTraining -> RunModalityForward), backprops,
+        // and applies the optimizer update itself. The earlier UpdateParameters(CollectGradients())
+        // was a redundant SECOND update whose hand-collected gradient vector did not line up with
+        // GetParameters(), corrupting the step. TrainWithTape alone is the correct single update.
+        // Restore eval mode in a finally: if TrainWithTape throws, the instance must not be stranded in
+        // training mode (dropout active, BN in train stats) so subsequent Predict calls stay correct.
+        SetTrainingMode(true);
+        try
+        {
+            TrainWithTape(input, expectedOutput, _optimizer);
+        }
+        finally
+        {
+            SetTrainingMode(false);
+        }
+    }
+
+    // UpdateParameters applied a GRADIENT STEP, but its one-argument form is the value setter and every caller passes values -- the override corrupted the model. Removed under AIDN082.
+
+
+    /// <summary>
+    /// Parameters cannot be written while the model is backed by a loaded ONNX graph: the weights
+    /// belong to that graph, not to this instance.
+    /// </summary>
+    /// <remarks>
+    /// Replaces a hand-written throw that used to sit inside UpdateParameters. The base checks this
+    /// on every mutating entry point rather than the one member the throw happened to guard, and
+    /// reading -- ParameterCount and GetParameters -- stays available either way.
+    /// </remarks>
     protected override bool SupportsParameterMutation => _useNativeMode;
-    #endregion
-
-    #region Disposal
-
-    /// <inheritdoc/>
-    protected override void Dispose(bool disposing)
-    {
-        if (disposing)
-            _onnxSession?.Dispose();
-        base.Dispose(disposing);
-    }
-
-    #endregion
-}
+    #endregion
+
+    #region Disposal
+
+    /// <inheritdoc/>
+    protected override void Dispose(bool disposing)
+    {
+        if (disposing)
+            _onnxSession?.Dispose();
+        base.Dispose(disposing);
+    }
+
+    #endregion
+}
diff --git a/src/Document/LayoutAware/DiT.cs b/src/Document/LayoutAware/DiT.cs
index 73253bbf73..493b5c6abb 100644
--- a/src/Document/LayoutAware/DiT.cs
+++ b/src/Document/LayoutAware/DiT.cs
@@ -488,38 +488,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_hiddenDim);
-        writer.Write(_numLayers);
-        writer.Write(_numHeads);
-        writer.Write(_patchSize);
-        writer.Write(ImageSize);
-        writer.Write(_numClasses);
-        writer.Write(_modelSize);
-        writer.Write(_useNativeMode);
-    }
-
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        int hiddenDim = reader.ReadInt32();
-        int numLayers = reader.ReadInt32();
-        int numHeads = reader.ReadInt32();
-        int patchSize = reader.ReadInt32();
-        int imageSize = reader.ReadInt32();
-        int numClasses = reader.ReadInt32();
-        string modelSize = reader.ReadString();
-        bool useNativeMode = reader.ReadBoolean();
 
-        ImageSize = imageSize;
-    }
 
     /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new DiT<T>(Architecture, _numClasses, ImageSize, _patchSize, _hiddenDim, _numLayers, _numHeads, _modelSize);
-    }
+
 
     #endregion
 
diff --git a/src/Document/LayoutAware/DocFormer.cs b/src/Document/LayoutAware/DocFormer.cs
index 66093df2cd..2be9e16062 100644
--- a/src/Document/LayoutAware/DocFormer.cs
+++ b/src/Document/LayoutAware/DocFormer.cs
@@ -1,741 +1,710 @@
-using AiDotNet.Attributes;
-using AiDotNet.Document.Interfaces;
-using AiDotNet.Document.Options;
-using AiDotNet.Enums;
-using AiDotNet.Helpers;
-using AiDotNet.Interfaces;
-using AiDotNet.LinearAlgebra;
-using AiDotNet.LossFunctions;
-using AiDotNet.NeuralNetworks;
-using AiDotNet.NeuralNetworks.Layers;
-using AiDotNet.Optimizers;
-using AiDotNet.Models.Options;
-using AiDotNet.Tokenization;
-using AiDotNet.Tokenization.Interfaces;
-using Microsoft.ML.OnnxRuntime;
-using AiDotNet.Validation;
-
-namespace AiDotNet.Document.LayoutAware;
-
-/// <summary>
-/// DocFormer neural network for end-to-end document understanding.
-/// </summary>
-/// <typeparam name="T">The numeric type used for calculations.</typeparam>
-/// <remarks>
-/// <para>
-/// DocFormer is a multi-modal transformer that jointly learns text, visual, and spatial features
-/// for document understanding tasks. It uses shared spatial encodings across all modalities.
-/// </para>
-/// <para>
-/// <b>For Beginners:</b> DocFormer combines three types of information:
-/// 1. Text content (what the words say)
-/// 2. Visual features (what the document looks like)
-/// 3. Spatial layout (where elements are positioned)
-///
-/// Unlike LayoutLM which adds position embeddings to text, DocFormer uses shared
-/// spatial encodings that align all three modalities in the same coordinate space.
-///
-/// Example usage:
-/// <code>
-/// var model = new DocFormer&lt;float&gt;(architecture);
-/// var result = model.DetectLayout(documentImage);
-/// </code>
-/// </para>
-/// <para>
-/// <b>Reference:</b> "DocFormer: End-to-End Transformer for Document Understanding" (ICCV 2021)
-/// https://arxiv.org/abs/2106.11539
-/// </para>
-/// </remarks>
-[ModelDomain(ModelDomain.Vision)]
-[ModelDomain(ModelDomain.Language)]
-[ModelCategory(ModelCategory.NeuralNetwork)]
-[ModelCategory(ModelCategory.Transformer)]
-[ModelTask(ModelTask.Classification)]
-[ModelTask(ModelTask.Detection)]
+using AiDotNet.Attributes;
+using AiDotNet.Document.Interfaces;
+using AiDotNet.Document.Options;
+using AiDotNet.Enums;
+using AiDotNet.Helpers;
+using AiDotNet.Interfaces;
+using AiDotNet.LinearAlgebra;
+using AiDotNet.LossFunctions;
+using AiDotNet.NeuralNetworks;
+using AiDotNet.NeuralNetworks.Layers;
+using AiDotNet.Optimizers;
+using AiDotNet.Models.Options;
+using AiDotNet.Tokenization;
+using AiDotNet.Tokenization.Interfaces;
+using Microsoft.ML.OnnxRuntime;
+using AiDotNet.Validation;
+
+namespace AiDotNet.Document.LayoutAware;
+
+/// <summary>
+/// DocFormer neural network for end-to-end document understanding.
+/// </summary>
+/// <typeparam name="T">The numeric type used for calculations.</typeparam>
+/// <remarks>
+/// <para>
+/// DocFormer is a multi-modal transformer that jointly learns text, visual, and spatial features
+/// for document understanding tasks. It uses shared spatial encodings across all modalities.
+/// </para>
+/// <para>
+/// <b>For Beginners:</b> DocFormer combines three types of information:
+/// 1. Text content (what the words say)
+/// 2. Visual features (what the document looks like)
+/// 3. Spatial layout (where elements are positioned)
+///
+/// Unlike LayoutLM which adds position embeddings to text, DocFormer uses shared
+/// spatial encodings that align all three modalities in the same coordinate space.
+///
+/// Example usage:
+/// <code>
+/// var model = new DocFormer&lt;float&gt;(architecture);
+/// var result = model.DetectLayout(documentImage);
+/// </code>
+/// </para>
+/// <para>
+/// <b>Reference:</b> "DocFormer: End-to-End Transformer for Document Understanding" (ICCV 2021)
+/// https://arxiv.org/abs/2106.11539
+/// </para>
+/// </remarks>
+[ModelDomain(ModelDomain.Vision)]
+[ModelDomain(ModelDomain.Language)]
+[ModelCategory(ModelCategory.NeuralNetwork)]
+[ModelCategory(ModelCategory.Transformer)]
+[ModelTask(ModelTask.Classification)]
+[ModelTask(ModelTask.Detection)]
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [RankRoutedInputDomain(2, 8)]
-[ResearchPaper("DocFormer: End-to-End Transformer for Document Understanding", "https://doi.org/10.48550/arXiv.2106.11539", Year = 2021, Authors = "Srikar Appalaraju, Bhavan Jasani, Bhargava Urala Kota, Yusheng Xie, R. Manmatha")]
-public partial class DocFormer<T> : DocumentNeuralNetworkBase<T>, ILayoutDetector<T>, IDocumentClassifier<T>
-{
-    private readonly DocFormerOptions _options;
-
-    /// <inheritdoc/>
-    public override ModelOptions GetOptions() => _options;
-
-    #region Fields
-
-    private readonly bool _useNativeMode;
-    private readonly InferenceSession? _onnxSession;
-    private readonly ITokenizer _tokenizer;
-    private readonly IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>> _optimizer;
-    private readonly int _hiddenDim;
-    private readonly int _numLayers;
-    private readonly int _numHeads;
-    private readonly int _vocabSize;
-    private readonly int _numClasses;
-    private readonly int _spatialDim;
-
-    // Native mode layers
-    private readonly List<ILayer<T>> _textEncoderLayers = [];
-    private readonly List<ILayer<T>> _visualEncoderLayers = [];
-    private readonly List<ILayer<T>> _multiModalLayers = [];
-    private readonly List<ILayer<T>> _outputLayers = [];
-
-    // The spatial X/Y tables used to be model fields here. They are now inside the
-    // LayoutEmbeddingLayer that fronts the text stream, where the forward pass reads them --
-    // see LayerHelper.CreateDefaultDocFormerLayers.
-
-    #endregion
-
-    #region Properties
-
-    /// <inheritdoc/>
-    public override DocumentType SupportedDocumentTypes => DocumentType.All;
-
-    /// <inheritdoc/>
-    public override bool RequiresOCR => true;
-
-    /// <inheritdoc/>
-    public int ExpectedImageSize => ImageSize;
-
-    /// <inheritdoc/>
-    public IReadOnlyList<LayoutElementType> SupportedElementTypes { get; } =
-    [
-        LayoutElementType.Text,
-        LayoutElementType.Title,
-        LayoutElementType.List,
-        LayoutElementType.Table,
-        LayoutElementType.Figure,
-        LayoutElementType.Caption,
-        LayoutElementType.Header,
-        LayoutElementType.Footer,
-        LayoutElementType.FormField
-    ];
-
-    /// <summary>
-    /// Gets the available document classification categories.
-    /// </summary>
-    public IReadOnlyList<string> AvailableCategories { get; } =
-    [
-        "letter", "form", "email", "handwritten", "advertisement",
-        "scientific", "specification", "file_folder", "news_article",
-        "budget", "invoice", "presentation", "questionnaire", "resume", "memo"
-    ];
-
-    #endregion
-
-    #region Constructors
-
-    /// <summary>
-    /// Creates a DocFormer model using a pre-trained ONNX model for inference.
-    /// </summary>
-    /// <param name="architecture">The neural network architecture.</param>
-    /// <param name="onnxModelPath">Path to the ONNX model file.</param>
-    /// <param name="tokenizer">Tokenizer for text processing.</param>
-    /// <param name="numClasses">Number of output classes (default: 16 for RVL-CDIP).</param>
-    /// <param name="imageSize">Input image size (default: 224).</param>
-    /// <param name="maxSequenceLength">Maximum sequence length (default: 512).</param>
-    /// <param name="hiddenDim">Hidden dimension (default: 768).</param>
-    /// <param name="numLayers">Number of transformer layers (default: 12).</param>
-    /// <param name="numHeads">Number of attention heads (default: 12).</param>
-    /// <param name="vocabSize">Vocabulary size (default: 30522).</param>
-    /// <param name="spatialDim">Spatial embedding dimension (default: 128).</param>
-    /// <param name="optimizer">Optimizer for training (optional).</param>
-    /// <param name="lossFunction">Loss function (optional).</param>
-    public DocFormer(
-        NeuralNetworkArchitecture<T> architecture,
-        string onnxModelPath,
-        ITokenizer tokenizer,
-        int numClasses = 16,
-        int imageSize = 224,
-        int maxSequenceLength = 512,
-        int hiddenDim = 768,
-        int numLayers = 12,
-        int numHeads = 12,
-        int vocabSize = 30522,
-        int spatialDim = 128,
-        IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? optimizer = null,
-        ILossFunction<T>? lossFunction = null,
-        DocFormerOptions? options = null)
-        : base(architecture, lossFunction ?? new CrossEntropyWithLogitsLoss<T>(), 1.0)
-    {
-        _options = options ?? new DocFormerOptions();
-        Options = _options;
-
-        if (string.IsNullOrWhiteSpace(onnxModelPath))
-            throw new ArgumentNullException(nameof(onnxModelPath));
-        if (!File.Exists(onnxModelPath))
-            throw new FileNotFoundException($"ONNX model not found: {onnxModelPath}", onnxModelPath);
-
-        Guard.NotNull(tokenizer);
-        _tokenizer = tokenizer;
-        _useNativeMode = false;
-        _numClasses = numClasses;
-        _hiddenDim = hiddenDim;
-        _numLayers = numLayers;
-        _numHeads = numHeads;
-        _vocabSize = vocabSize;
-        _spatialDim = spatialDim;
-        // DocFormer fine-tuning uses AdamW at 2.5e-5 with no warm-up and a 1.0
-        // gradient-norm cap (Appalaraju et al., ICCV 2021, Table 1). Keep the
-        // optimizer injectable so callers can fully customize the training recipe.
-        _optimizer = optimizer ?? new AdamWOptimizer<T, Tensor<T>, Tensor<T>>(this,
-            new AdamWOptimizerOptions<T, Tensor<T>, Tensor<T>>
-            {
-                InitialLearningRate = 2.5e-5,
-                WeightDecay = 0.01,
-                UseAMSGrad = false,
-                EnableGradientClipping = true,
-                MaxGradientNorm = 1.0
-            });
-
-        ImageSize = imageSize;
-        MaxSequenceLength = maxSequenceLength;
-
-        _onnxSession = new InferenceSession(onnxModelPath);
-
-        InitializeLayers();
-    }
-
-    /// <summary>
-    /// Creates a DocFormer model using native layers for training and inference.
-    /// </summary>
-    /// <param name="architecture">The neural network architecture.</param>
-    /// <param name="tokenizer">Tokenizer for text processing (optional).</param>
-    /// <param name="numClasses">Number of output classes (default: 16 for RVL-CDIP).</param>
-    /// <param name="imageSize">Input image size (default: 224).</param>
-    /// <param name="maxSequenceLength">Maximum sequence length (default: 512).</param>
-    /// <param name="hiddenDim">Hidden dimension (default: 768).</param>
-    /// <param name="numLayers">Number of transformer layers (default: 12).</param>
-    /// <param name="numHeads">Number of attention heads (default: 12).</param>
-    /// <param name="vocabSize">Vocabulary size (default: 30522).</param>
-    /// <param name="spatialDim">Spatial embedding dimension (default: 128).</param>
-    /// <param name="optimizer">Optimizer for training (optional).</param>
-    /// <param name="lossFunction">Loss function (optional).</param>
-    /// <remarks>
-    /// <para>
-    /// <b>Default Configuration (DocFormer-Base from ICCV 2021):</b>
-    /// - Text encoder: BERT-base architecture
-    /// - Visual encoder: ResNet-50 backbone
-    /// - Shared spatial encodings for all modalities
-    /// - Hidden dimension: 768
-    /// - Layers: 12, Heads: 12
-    /// - Image size: 224x224
-    /// </para>
-    /// </remarks>
-    public DocFormer(
-        NeuralNetworkArchitecture<T> architecture,
-        ITokenizer? tokenizer = null,
-        int numClasses = 16,
-        int imageSize = 224,
-        int maxSequenceLength = 512,
-        int hiddenDim = 768,
-        int numLayers = 12,
-        int numHeads = 12,
-        int vocabSize = 30522,
-        int spatialDim = 128,
-        IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? optimizer = null,
-        ILossFunction<T>? lossFunction = null,
-        DocFormerOptions? options = null)
-        : base(architecture, lossFunction ?? new CrossEntropyWithLogitsLoss<T>(), 1.0)
-    {
-        _options = options ?? new DocFormerOptions();
-        Options = _options;
-
-        _useNativeMode = true;
-        _numClasses = numClasses;
-        _hiddenDim = hiddenDim;
-        _numLayers = numLayers;
-        _numHeads = numHeads;
-        _vocabSize = vocabSize;
-        _spatialDim = spatialDim;
-        // DocFormer fine-tuning uses AdamW at 2.5e-5 with no warm-up and a 1.0
-        // gradient-norm cap (Appalaraju et al., ICCV 2021, Table 1). Keep the
-        // optimizer injectable so callers can fully customize the training recipe.
-        _optimizer = optimizer ?? new AdamWOptimizer<T, Tensor<T>, Tensor<T>>(this,
-            new AdamWOptimizerOptions<T, Tensor<T>, Tensor<T>>
-            {
-                InitialLearningRate = 2.5e-5,
-                WeightDecay = 0.01,
-                UseAMSGrad = false,
-                EnableGradientClipping = true,
-                MaxGradientNorm = 1.0
-            });
-
-        ImageSize = imageSize;
-        MaxSequenceLength = maxSequenceLength;
-
-        _tokenizer = tokenizer ?? LanguageModelTokenizerFactory.CreateForBackbone(LanguageModelBackbone.OPT);
-
-        InitializeLayers();
-    }
-
-    #endregion
-
-    #region Initialization
-
-    /// <inheritdoc/>
-    protected override void InitializeLayers()
-    {
-        if (!_useNativeMode)
-        {
-            return;
-        }
-
-        if (Architecture.Layers is not null && Architecture.Layers.Count > 0)
-        {
-            Layers.AddRange(Architecture.Layers);
-            ValidateCustomLayers(Layers);
-            return;
-        }
-
-        Layers.AddRange(LayerHelper<T>.CreateDefaultDocFormerLayers(
-            hiddenDim: _hiddenDim,
-            numLayers: _numLayers,
-            numHeads: _numHeads,
-            vocabSize: _vocabSize,
-            imageSize: ImageSize,
-            spatialDim: _spatialDim,
-            numClasses: _numClasses));
-    }
-
-    #endregion
-
-    #region ILayoutDetector Implementation
-
-    /// <inheritdoc/>
-    public DocumentLayoutResult<T> DetectLayout(Tensor<T> documentImage)
-    {
-        return DetectLayout(documentImage, 0.5);
-    }
-
-    /// <inheritdoc/>
-    public DocumentLayoutResult<T> DetectLayout(Tensor<T> documentImage, double confidenceThreshold)
-    {
-        ValidateImageShape(documentImage);
-        var startTime = DateTime.UtcNow;
-
-        var preprocessed = PreprocessDocument(documentImage);
-        var output = _useNativeMode ? Forward(preprocessed) : RunOnnxInference(preprocessed);
-
-        var regions = ParseLayoutOutput(output, confidenceThreshold);
-
-        return new DocumentLayoutResult<T>
-        {
-            Regions = regions,
-            ProcessingTimeMs = (DateTime.UtcNow - startTime).TotalMilliseconds
-        };
-    }
-
-    private List<LayoutRegion<T>> ParseLayoutOutput(Tensor<T> output, double threshold)
-    {
-        var regions = new List<LayoutRegion<T>>();
-        int numDetections = output.Shape[0];
-        int numClasses = output.Shape.Length > 1 ? output.Shape[1] : _numClasses;
-
-        for (int i = 0; i < numDetections; i++)
-        {
-            double maxConf = 0;
-            int maxClass = 0;
-            for (int c = 0; c < numClasses; c++)
-            {
-                double conf = NumOps.ToDouble(output[i, c]);
-                if (conf > maxConf) { maxConf = conf; maxClass = c; }
-            }
-
-            if (maxConf >= threshold && maxClass > 0)
-            {
-                regions.Add(new LayoutRegion<T>
-                {
-                    ElementType = (LayoutElementType)Math.Min(maxClass, (int)LayoutElementType.Other),
-                    Confidence = NumOps.FromDouble(maxConf),
-                    ConfidenceValue = maxConf,
-                    Index = i,
-                    BoundingBox = Vector<T>.Empty()
-                });
-            }
-        }
-
-        return regions;
-    }
-
-    #endregion
-
-    #region IDocumentClassifier Implementation
-
-    /// <inheritdoc/>
-    public DocumentClassificationResult<T> ClassifyDocument(Tensor<T> documentImage)
-    {
-        return ClassifyDocument(documentImage, 5);
-    }
-
-    /// <inheritdoc/>
-    public DocumentClassificationResult<T> ClassifyDocument(Tensor<T> documentImage, int topK)
-    {
-        ValidateImageShape(documentImage);
-        var startTime = DateTime.UtcNow;
-
-        var preprocessed = PreprocessDocument(documentImage);
-        var output = _useNativeMode ? Forward(preprocessed) : RunOnnxInference(preprocessed);
-
-        // Apply softmax for classification probabilities
-        var probs = ApplySoftmax(output);
-
-        // Get top-K predictions
-        var topPredictions = GetTopKPredictions(probs, topK);
-
-        return new DocumentClassificationResult<T>
-        {
-            PredictedCategory = topPredictions[0].Category,
-            Confidence = NumOps.FromDouble(topPredictions[0].Score),
-            ConfidenceValue = topPredictions[0].Score,
-            TopPredictions = topPredictions,
-            ProcessingTimeMs = (DateTime.UtcNow - startTime).TotalMilliseconds
-        };
-    }
-
-    private List<(string Category, double Score)> GetTopKPredictions(Tensor<T> probs, int k)
-    {
-        var predictions = new List<(string Category, double Score)>();
-        int numClasses = Math.Min(probs.Data.Length, AvailableCategories.Count);
-
-        for (int i = 0; i < numClasses; i++)
-        {
-            predictions.Add((AvailableCategories[i], NumOps.ToDouble(probs.Data.Span[i])));
-        }
-
-        return predictions.OrderByDescending(p => p.Score).Take(k).ToList();
-    }
-
-    private Tensor<T> ApplySoftmax(Tensor<T> input)
-    {
-        return Engine.Softmax(input, -1);
-    }
-
-    #endregion
-
-    #region IDocumentModel Implementation
-
-    /// <inheritdoc/>
-    public Tensor<T> EncodeDocument(Tensor<T> documentImage)
-    {
-        ValidateImageShape(documentImage);
-        var preprocessed = PreprocessDocument(documentImage);
-        return _useNativeMode ? Forward(preprocessed) : RunOnnxInference(preprocessed);
-    }
-
-    /// <inheritdoc/>
-    public void ValidateInputShape(Tensor<T> documentImage)
-    {
-        ValidateImageShape(documentImage);
-    }
-
-    /// <inheritdoc/>
-    public string GetModelSummary()
-    {
-        var sb = new System.Text.StringBuilder();
-        sb.AppendLine("DocFormer Model Summary");
-        sb.AppendLine("=======================");
-        sb.AppendLine($"Mode: {(_useNativeMode ? "Native (Trainable)" : "ONNX (Inference)")}");
-        sb.AppendLine($"Architecture: Multi-modal Transformer with shared spatial encodings");
-        sb.AppendLine($"Hidden Dimension: {_hiddenDim}");
-        sb.AppendLine($"Number of Layers: {_numLayers}");
-        sb.AppendLine($"Attention Heads: {_numHeads}");
-        sb.AppendLine($"Spatial Embedding Dim: {_spatialDim}");
-        sb.AppendLine($"Image Size: {ImageSize}x{ImageSize}");
-        sb.AppendLine($"Max Sequence Length: {MaxSequenceLength}");
-        sb.AppendLine($"Number of Classes: {_numClasses}");
-        sb.AppendLine($"Uses Visual Features: Yes");
-        sb.AppendLine($"Uses Shared Spatial Encodings: Yes");
-        sb.AppendLine($"Total Layers: {Layers.Count}");
-        return sb.ToString();
-    }
-
-    #endregion
-
-    #region Preprocessing
-
-    /// <summary>
-    /// Applies DocFormer's industry-standard preprocessing: ImageNet normalization.
-    /// </summary>
-    /// <remarks>
-    /// DocFormer uses ImageNet normalization with mean=[0.485, 0.456, 0.406] and std=[0.229, 0.224, 0.225].
-    /// </remarks>
-    protected override Tensor<T> ApplyDefaultPreprocessing(Tensor<T> rawImage)
-    {
-        var image = EnsureBatchDimension(rawImage);
-        int batchSize = image.Shape[0];
-        int channels = image.Shape[1];
-        int height = image.Shape[2];
-        int width = image.Shape[3];
-
-        var normalized = new Tensor<T>(image._shape);
-        double[] means = [0.485, 0.456, 0.406];
-        double[] stds = [0.229, 0.224, 0.225];
-
-        for (int b = 0; b < batchSize; b++)
-        {
-            for (int c = 0; c < channels; c++)
-            {
-                double mean = c < means.Length ? means[c] : 0.5;
-                double std = c < stds.Length ? stds[c] : 0.5;
-                for (int h = 0; h < height; h++)
-                {
-                    for (int w = 0; w < width; w++)
-                    {
-                        int idx = b * channels * height * width + c * height * width + h * width + w;
-                        normalized.Data.Span[idx] = NumOps.FromDouble((NumOps.ToDouble(image.Data.Span[idx]) - mean) / std);
-                    }
-                }
-            }
-        }
-        return normalized;
-    }
-
-    /// <summary>
-    /// Applies DocFormer's industry-standard postprocessing: pass-through (multimodal outputs are already final).
-    /// </summary>
-    protected override Tensor<T> ApplyDefaultPostprocessing(Tensor<T> modelOutput) => modelOutput;
-
-    #endregion
-
-    #region Serialization
-
-    /// <inheritdoc/>
-    public override ModelMetadata<T> GetModelMetadata()
-    {
-        return new ModelMetadata<T>
-        {
-            Name = "DocFormer",
-            Description = "DocFormer with shared spatial encodings (ICCV 2021)",
-            FeatureCount = _hiddenDim,
-            Complexity = _numLayers,
-            AdditionalInfo = new Dictionary<string, object>
-            {
-                { "hidden_dim", _hiddenDim },
-                { "num_layers", _numLayers },
-                { "num_heads", _numHeads },
-                { "vocab_size", _vocabSize },
-                { "image_size", ImageSize },
-                { "spatial_dim", _spatialDim },
-                { "num_classes", _numClasses },
-                { "use_native_mode", _useNativeMode }
-            },
-            ModelData = SafeSerialize()
-        };
-    }
-
-    /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_hiddenDim);
-        writer.Write(_numLayers);
-        writer.Write(_numHeads);
-        writer.Write(_vocabSize);
-        writer.Write(ImageSize);
-        writer.Write(MaxSequenceLength);
-        writer.Write(_spatialDim);
-        writer.Write(_numClasses);
-        writer.Write(_useNativeMode);
-    }
-
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        int hiddenDim = reader.ReadInt32();
-        int numLayers = reader.ReadInt32();
-        int numHeads = reader.ReadInt32();
-        int vocabSize = reader.ReadInt32();
-        int imageSize = reader.ReadInt32();
-        int maxSeqLen = reader.ReadInt32();
-        int spatialDim = reader.ReadInt32();
-        int numClasses = reader.ReadInt32();
-        bool useNativeMode = reader.ReadBoolean();
-
-        ImageSize = imageSize;
-        MaxSequenceLength = maxSeqLen;
-    }
-
-    /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new DocFormer<T>(Architecture, _tokenizer, _numClasses, ImageSize, MaxSequenceLength,
-            _hiddenDim, _numLayers, _numHeads, _vocabSize, _spatialDim);
-    }
-
-    #endregion
-
-    #region NeuralNetworkBase Implementation
-
-    /// <inheritdoc/>
-    protected override Tensor<T> PredictCore(Tensor<T> input)
-    {
-        var preprocessed = PreprocessDocument(input);
-        return _useNativeMode ? Forward(preprocessed) : RunOnnxInference(preprocessed);
-    }
-
-    // Layer roles in CreateDefaultDocFormerLayers order: [0..VisualEncoderLayerCount) = ResNet visual
-    // backbone (convs/BN/pool ending in a C->hidden projection Dense), then the text embeddings, then
-    // the shared spatial-encoding + multimodal transformer + head. DocFormer (Appalaraju et al. 2021)
-    // reads BOTH a document image and its text; this native forward is modality-robust and routes by
-    // input rank so a token-only input runs the text stream and an image runs the visual backbone, both
-    // feeding the shared stack. Without it the base linear walk sends the rank-1 token vector into the
-    // rank-4-only Conv backbone and throws ("ConvolutionalLayer expects rank-3/rank-4 input; got rank 1").
-    private const int VisualEncoderLayerCount = 8;
-
-    // One, not two: the token EmbeddingLayer and the sinusoidal PositionalEncodingLayer that used to
-    // sit here are now a single LayoutEmbeddingLayer, which also carries the 2D layout terms and uses
-    // LEARNED positions (BERT's, which DocFormer inherits) rather than fixed sinusoids.
-    private const int TextEncoderLayerCount = 1;
-
-    private Tensor<T> RunModalityForward(Tensor<T> input)
-    {
-        Tensor<T> feats;
-        if (input.Rank <= 2)
-        {
-            // Token/text stream: word embeddings + positional encodings; skip the visual backbone.
-            feats = input;
-            for (int i = VisualEncoderLayerCount; i < VisualEncoderLayerCount + TextEncoderLayerCount && i < Layers.Count; i++)
-                feats = Layers[i].Forward(feats);
-        }
-        else
-        {
-            // Visual stream: conv backbone -> flatten spatial grid to tokens -> channel projection Dense.
-            feats = input;
-            int projIndex = VisualEncoderLayerCount - 1;
-            for (int i = 0; i < projIndex && i < Layers.Count; i++)
-                feats = Layers[i].Forward(feats);
-            feats = FlattenSpatialToTokens(feats);
-            if (projIndex >= 0 && projIndex < Layers.Count)
-                feats = Layers[projIndex].Forward(feats);
-        }
-        // Shared spatial-encoding + multimodal transformer + head.
-        for (int i = VisualEncoderLayerCount + TextEncoderLayerCount; i < Layers.Count; i++)
-            feats = Layers[i].Forward(feats);
-        return feats;
-    }
-
-    // [C, H, W] -> [H*W, C]; [B, C, H, W] -> [B, H*W, C]. Puts channels last so each spatial location
-    // becomes a token whose feature vector the projection Dense maps to the hidden dim.
-    private Tensor<T> FlattenSpatialToTokens(Tensor<T> feat)
-    {
-        if (feat.Rank == 4)
-        {
-            int b = feat.Shape[0], c = feat.Shape[1], n = feat.Shape[2] * feat.Shape[3];
-            return Engine.TensorPermute(Engine.Reshape(feat, new[] { b, c, n }), new[] { 0, 2, 1 });
-        }
-        if (feat.Rank == 3)
-        {
-            int c = feat.Shape[0], n = feat.Shape[1] * feat.Shape[2];
-            return Engine.TensorPermute(Engine.Reshape(feat, new[] { c, n }), new[] { 1, 0 });
-        }
-        return feat;
-    }
-
-    /// <inheritdoc/>
-    protected override Tensor<T> Forward(Tensor<T> input)
-        => _useNativeMode ? RunModalityForward(input) : base.Forward(input);
-
-    /// <inheritdoc/>
-    public override Tensor<T> ForwardForTraining(Tensor<T> input)
-        => _useNativeMode ? RunModalityForward(input) : base.ForwardForTraining(input);
-
-    /// <inheritdoc/>
-    /// <remarks>
-    /// Diagnostic counterpart of the modality routing in <see cref="RunModalityForward"/>: the base
-    /// implementation walks <c>Layers</c> from index 0, sending a token-only input into the rank-4-only
-    /// Conv backbone and throwing before it records anything. Record only the layers that actually fire.
-    /// </remarks>
-    public override Dictionary<string, Tensor<T>> GetNamedLayerActivations(Tensor<T> input)
-    {
-        if (input is null)
-            throw new ArgumentNullException(nameof(input));
-
-        if (!_useNativeMode)
-            return base.GetNamedLayerActivations(input);
-
-        var activations = new Dictionary<string, Tensor<T>>();
-        var current = input;
-        if (input.Rank <= 2)
-        {
-            for (int i = VisualEncoderLayerCount; i < VisualEncoderLayerCount + TextEncoderLayerCount && i < Layers.Count; i++)
-            {
-                current = Layers[i].Forward(current);
-                activations[$"Layer_{i}_{Layers[i].GetType().Name}"] = current.Clone();
-            }
-        }
-        else
-        {
-            int projIndex = VisualEncoderLayerCount - 1;
-            for (int i = 0; i < projIndex && i < Layers.Count; i++)
-            {
-                current = Layers[i].Forward(current);
-                activations[$"Layer_{i}_{Layers[i].GetType().Name}"] = current.Clone();
-            }
-            current = FlattenSpatialToTokens(current);
-            if (projIndex >= 0 && projIndex < Layers.Count)
-            {
-                current = Layers[projIndex].Forward(current);
-                activations[$"Layer_{projIndex}_{Layers[projIndex].GetType().Name}"] = current.Clone();
-            }
-        }
-        for (int i = VisualEncoderLayerCount + TextEncoderLayerCount; i < Layers.Count; i++)
-        {
-            current = Layers[i].Forward(current);
-            activations[$"Layer_{i}_{Layers[i].GetType().Name}"] = current.Clone();
-        }
-        return activations;
-    }
-
-    /// <inheritdoc/>
-    public override void Train(Tensor<T> input, Tensor<T> expectedOutput)
-    {
-        if (!_useNativeMode)
-            throw new NotSupportedException("Training not supported in ONNX mode.");
-
-        // TrainWithTape runs the full forward (ForwardForTraining -> RunModalityForward), backprops, and
-        // applies the optimizer update itself. The earlier UpdateParameters(CollectGradients()) was a
-        // redundant SECOND update whose hand-collected gradient vector did not line up with
-        // GetParameters(). TrainWithTape alone is the correct single update.
-        // Pass DocFormer's configured optimizer explicitly: the no-optimizer overload falls back to the
-        // base default Adam at lr 1e-3, which overshoots this 12-layer transformer's training and
-        // degrades with more iterations (MoreData_ShouldNotDegrade / collapsed post-training outputs).
-        // DocFormer's own optimizer is a lower-lr (1e-4) Adam matching the paper's fine-tuning recipe.
-        SetTrainingMode(true);
-        try
-        {
-            TrainWithTape(input, expectedOutput, _optimizer);
-        }
-        finally
-        {
-            SetTrainingMode(false);
-        }
-    }
-
-    // UpdateParameters applied a GRADIENT STEP, but its one-argument form is the value setter and every caller passes values -- the override corrupted the model. Removed under AIDN082.

-
-    /// <summary>
-    /// Parameters cannot be written while the model is backed by a loaded ONNX graph: the weights
-    /// belong to that graph, not to this instance.
-    /// </summary>
-    /// <remarks>
-    /// Replaces a hand-written throw that used to sit inside UpdateParameters. The base checks this
-    /// on every mutating entry point rather than the one member the throw happened to guard, and
-    /// reading -- ParameterCount and GetParameters -- stays available either way.
-    /// </remarks>
+[ResearchPaper("DocFormer: End-to-End Transformer for Document Understanding", "https://doi.org/10.48550/arXiv.2106.11539", Year = 2021, Authors = "Srikar Appalaraju, Bhavan Jasani, Bhargava Urala Kota, Yusheng Xie, R. Manmatha")]
+public partial class DocFormer<T> : DocumentNeuralNetworkBase<T>, ILayoutDetector<T>, IDocumentClassifier<T>
+{
+    private readonly DocFormerOptions _options;
+
+    /// <inheritdoc/>
+    public override ModelOptions GetOptions() => _options;
+
+    #region Fields
+
+    private readonly bool _useNativeMode;
+    private readonly InferenceSession? _onnxSession;
+    private readonly ITokenizer _tokenizer;
+    private readonly IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>> _optimizer;
+    private readonly int _hiddenDim;
+    private readonly int _numLayers;
+    private readonly int _numHeads;
+    private readonly int _vocabSize;
+    private readonly int _numClasses;
+    private readonly int _spatialDim;
+
+    // Native mode layers
+    private readonly List<ILayer<T>> _textEncoderLayers = [];
+    private readonly List<ILayer<T>> _visualEncoderLayers = [];
+    private readonly List<ILayer<T>> _multiModalLayers = [];
+    private readonly List<ILayer<T>> _outputLayers = [];
+
+    // The spatial X/Y tables used to be model fields here. They are now inside the
+    // LayoutEmbeddingLayer that fronts the text stream, where the forward pass reads them --
+    // see LayerHelper.CreateDefaultDocFormerLayers.
+
+    #endregion
+
+    #region Properties
+
+    /// <inheritdoc/>
+    public override DocumentType SupportedDocumentTypes => DocumentType.All;
+
+    /// <inheritdoc/>
+    public override bool RequiresOCR => true;
+
+    /// <inheritdoc/>
+    public int ExpectedImageSize => ImageSize;
+
+    /// <inheritdoc/>
+    public IReadOnlyList<LayoutElementType> SupportedElementTypes { get; } =
+    [
+        LayoutElementType.Text,
+        LayoutElementType.Title,
+        LayoutElementType.List,
+        LayoutElementType.Table,
+        LayoutElementType.Figure,
+        LayoutElementType.Caption,
+        LayoutElementType.Header,
+        LayoutElementType.Footer,
+        LayoutElementType.FormField
+    ];
+
+    /// <summary>
+    /// Gets the available document classification categories.
+    /// </summary>
+    public IReadOnlyList<string> AvailableCategories { get; } =
+    [
+        "letter", "form", "email", "handwritten", "advertisement",
+        "scientific", "specification", "file_folder", "news_article",
+        "budget", "invoice", "presentation", "questionnaire", "resume", "memo"
+    ];
+
+    #endregion
+
+    #region Constructors
+
+    /// <summary>
+    /// Creates a DocFormer model using a pre-trained ONNX model for inference.
+    /// </summary>
+    /// <param name="architecture">The neural network architecture.</param>
+    /// <param name="onnxModelPath">Path to the ONNX model file.</param>
+    /// <param name="tokenizer">Tokenizer for text processing.</param>
+    /// <param name="numClasses">Number of output classes (default: 16 for RVL-CDIP).</param>
+    /// <param name="imageSize">Input image size (default: 224).</param>
+    /// <param name="maxSequenceLength">Maximum sequence length (default: 512).</param>
+    /// <param name="hiddenDim">Hidden dimension (default: 768).</param>
+    /// <param name="numLayers">Number of transformer layers (default: 12).</param>
+    /// <param name="numHeads">Number of attention heads (default: 12).</param>
+    /// <param name="vocabSize">Vocabulary size (default: 30522).</param>
+    /// <param name="spatialDim">Spatial embedding dimension (default: 128).</param>
+    /// <param name="optimizer">Optimizer for training (optional).</param>
+    /// <param name="lossFunction">Loss function (optional).</param>
+    public DocFormer(
+        NeuralNetworkArchitecture<T> architecture,
+        string onnxModelPath,
+        ITokenizer tokenizer,
+        int numClasses = 16,
+        int imageSize = 224,
+        int maxSequenceLength = 512,
+        int hiddenDim = 768,
+        int numLayers = 12,
+        int numHeads = 12,
+        int vocabSize = 30522,
+        int spatialDim = 128,
+        IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? optimizer = null,
+        ILossFunction<T>? lossFunction = null,
+        DocFormerOptions? options = null)
+        : base(architecture, lossFunction ?? new CrossEntropyWithLogitsLoss<T>(), 1.0)
+    {
+        _options = options ?? new DocFormerOptions();
+        Options = _options;
+
+        if (string.IsNullOrWhiteSpace(onnxModelPath))
+            throw new ArgumentNullException(nameof(onnxModelPath));
+        if (!File.Exists(onnxModelPath))
+            throw new FileNotFoundException($"ONNX model not found: {onnxModelPath}", onnxModelPath);
+
+        Guard.NotNull(tokenizer);
+        _tokenizer = tokenizer;
+        _useNativeMode = false;
+        _numClasses = numClasses;
+        _hiddenDim = hiddenDim;
+        _numLayers = numLayers;
+        _numHeads = numHeads;
+        _vocabSize = vocabSize;
+        _spatialDim = spatialDim;
+        // DocFormer fine-tuning uses AdamW at 2.5e-5 with no warm-up and a 1.0
+        // gradient-norm cap (Appalaraju et al., ICCV 2021, Table 1). Keep the
+        // optimizer injectable so callers can fully customize the training recipe.
+        _optimizer = optimizer ?? new AdamWOptimizer<T, Tensor<T>, Tensor<T>>(this,
+            new AdamWOptimizerOptions<T, Tensor<T>, Tensor<T>>
+            {
+                InitialLearningRate = 2.5e-5,
+                WeightDecay = 0.01,
+                UseAMSGrad = false,
+                EnableGradientClipping = true,
+                MaxGradientNorm = 1.0
+            });
+
+        ImageSize = imageSize;
+        MaxSequenceLength = maxSequenceLength;
+
+        _onnxSession = new InferenceSession(onnxModelPath);
+
+        InitializeLayers();
+    }
+
+    /// <summary>
+    /// Creates a DocFormer model using native layers for training and inference.
+    /// </summary>
+    /// <param name="architecture">The neural network architecture.</param>
+    /// <param name="tokenizer">Tokenizer for text processing (optional).</param>
+    /// <param name="numClasses">Number of output classes (default: 16 for RVL-CDIP).</param>
+    /// <param name="imageSize">Input image size (default: 224).</param>
+    /// <param name="maxSequenceLength">Maximum sequence length (default: 512).</param>
+    /// <param name="hiddenDim">Hidden dimension (default: 768).</param>
+    /// <param name="numLayers">Number of transformer layers (default: 12).</param>
+    /// <param name="numHeads">Number of attention heads (default: 12).</param>
+    /// <param name="vocabSize">Vocabulary size (default: 30522).</param>
+    /// <param name="spatialDim">Spatial embedding dimension (default: 128).</param>
+    /// <param name="optimizer">Optimizer for training (optional).</param>
+    /// <param name="lossFunction">Loss function (optional).</param>
+    /// <remarks>
+    /// <para>
+    /// <b>Default Configuration (DocFormer-Base from ICCV 2021):</b>
+    /// - Text encoder: BERT-base architecture
+    /// - Visual encoder: ResNet-50 backbone
+    /// - Shared spatial encodings for all modalities
+    /// - Hidden dimension: 768
+    /// - Layers: 12, Heads: 12
+    /// - Image size: 224x224
+    /// </para>
+    /// </remarks>
+    public DocFormer(
+        NeuralNetworkArchitecture<T> architecture,
+        ITokenizer? tokenizer = null,
+        int numClasses = 16,
+        int imageSize = 224,
+        int maxSequenceLength = 512,
+        int hiddenDim = 768,
+        int numLayers = 12,
+        int numHeads = 12,
+        int vocabSize = 30522,
+        int spatialDim = 128,
+        IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? optimizer = null,
+        ILossFunction<T>? lossFunction = null,
+        DocFormerOptions? options = null)
+        : base(architecture, lossFunction ?? new CrossEntropyWithLogitsLoss<T>(), 1.0)
+    {
+        _options = options ?? new DocFormerOptions();
+        Options = _options;
+
+        _useNativeMode = true;
+        _numClasses = numClasses;
+        _hiddenDim = hiddenDim;
+        _numLayers = numLayers;
+        _numHeads = numHeads;
+        _vocabSize = vocabSize;
+        _spatialDim = spatialDim;
+        // DocFormer fine-tuning uses AdamW at 2.5e-5 with no warm-up and a 1.0
+        // gradient-norm cap (Appalaraju et al., ICCV 2021, Table 1). Keep the
+        // optimizer injectable so callers can fully customize the training recipe.
+        _optimizer = optimizer ?? new AdamWOptimizer<T, Tensor<T>, Tensor<T>>(this,
+            new AdamWOptimizerOptions<T, Tensor<T>, Tensor<T>>
+            {
+                InitialLearningRate = 2.5e-5,
+                WeightDecay = 0.01,
+                UseAMSGrad = false,
+                EnableGradientClipping = true,
+                MaxGradientNorm = 1.0
+            });
+
+        ImageSize = imageSize;
+        MaxSequenceLength = maxSequenceLength;
+
+        _tokenizer = tokenizer ?? LanguageModelTokenizerFactory.CreateForBackbone(LanguageModelBackbone.OPT);
+
+        InitializeLayers();
+    }
+
+    #endregion
+
+    #region Initialization
+
+    /// <inheritdoc/>
+    protected override void InitializeLayers()
+    {
+        if (!_useNativeMode)
+        {
+            return;
+        }
+
+        if (Architecture.Layers is not null && Architecture.Layers.Count > 0)
+        {
+            Layers.AddRange(Architecture.Layers);
+            ValidateCustomLayers(Layers);
+            return;
+        }
+
+        Layers.AddRange(LayerHelper<T>.CreateDefaultDocFormerLayers(
+            hiddenDim: _hiddenDim,
+            numLayers: _numLayers,
+            numHeads: _numHeads,
+            vocabSize: _vocabSize,
+            imageSize: ImageSize,
+            spatialDim: _spatialDim,
+            numClasses: _numClasses));
+    }
+
+    #endregion
+
+    #region ILayoutDetector Implementation
+
+    /// <inheritdoc/>
+    public DocumentLayoutResult<T> DetectLayout(Tensor<T> documentImage)
+    {
+        return DetectLayout(documentImage, 0.5);
+    }
+
+    /// <inheritdoc/>
+    public DocumentLayoutResult<T> DetectLayout(Tensor<T> documentImage, double confidenceThreshold)
+    {
+        ValidateImageShape(documentImage);
+        var startTime = DateTime.UtcNow;
+
+        var preprocessed = PreprocessDocument(documentImage);
+        var output = _useNativeMode ? Forward(preprocessed) : RunOnnxInference(preprocessed);
+
+        var regions = ParseLayoutOutput(output, confidenceThreshold);
+
+        return new DocumentLayoutResult<T>
+        {
+            Regions = regions,
+            ProcessingTimeMs = (DateTime.UtcNow - startTime).TotalMilliseconds
+        };
+    }
+
+    private List<LayoutRegion<T>> ParseLayoutOutput(Tensor<T> output, double threshold)
+    {
+        var regions = new List<LayoutRegion<T>>();
+        int numDetections = output.Shape[0];
+        int numClasses = output.Shape.Length > 1 ? output.Shape[1] : _numClasses;
+
+        for (int i = 0; i < numDetections; i++)
+        {
+            double maxConf = 0;
+            int maxClass = 0;
+            for (int c = 0; c < numClasses; c++)
+            {
+                double conf = NumOps.ToDouble(output[i, c]);
+                if (conf > maxConf) { maxConf = conf; maxClass = c; }
+            }
+
+            if (maxConf >= threshold && maxClass > 0)
+            {
+                regions.Add(new LayoutRegion<T>
+                {
+                    ElementType = (LayoutElementType)Math.Min(maxClass, (int)LayoutElementType.Other),
+                    Confidence = NumOps.FromDouble(maxConf),
+                    ConfidenceValue = maxConf,
+                    Index = i,
+                    BoundingBox = Vector<T>.Empty()
+                });
+            }
+        }
+
+        return regions;
+    }
+
+    #endregion
+
+    #region IDocumentClassifier Implementation
+
+    /// <inheritdoc/>
+    public DocumentClassificationResult<T> ClassifyDocument(Tensor<T> documentImage)
+    {
+        return ClassifyDocument(documentImage, 5);
+    }
+
+    /// <inheritdoc/>
+    public DocumentClassificationResult<T> ClassifyDocument(Tensor<T> documentImage, int topK)
+    {
+        ValidateImageShape(documentImage);
+        var startTime = DateTime.UtcNow;
+
+        var preprocessed = PreprocessDocument(documentImage);
+        var output = _useNativeMode ? Forward(preprocessed) : RunOnnxInference(preprocessed);
+
+        // Apply softmax for classification probabilities
+        var probs = ApplySoftmax(output);
+
+        // Get top-K predictions
+        var topPredictions = GetTopKPredictions(probs, topK);
+
+        return new DocumentClassificationResult<T>
+        {
+            PredictedCategory = topPredictions[0].Category,
+            Confidence = NumOps.FromDouble(topPredictions[0].Score),
+            ConfidenceValue = topPredictions[0].Score,
+            TopPredictions = topPredictions,
+            ProcessingTimeMs = (DateTime.UtcNow - startTime).TotalMilliseconds
+        };
+    }
+
+    private List<(string Category, double Score)> GetTopKPredictions(Tensor<T> probs, int k)
+    {
+        var predictions = new List<(string Category, double Score)>();
+        int numClasses = Math.Min(probs.Data.Length, AvailableCategories.Count);
+
+        for (int i = 0; i < numClasses; i++)
+        {
+            predictions.Add((AvailableCategories[i], NumOps.ToDouble(probs.Data.Span[i])));
+        }
+
+        return predictions.OrderByDescending(p => p.Score).Take(k).ToList();
+    }
+
+    private Tensor<T> ApplySoftmax(Tensor<T> input)
+    {
+        return Engine.Softmax(input, -1);
+    }
+
+    #endregion
+
+    #region IDocumentModel Implementation
+
+    /// <inheritdoc/>
+    public Tensor<T> EncodeDocument(Tensor<T> documentImage)
+    {
+        ValidateImageShape(documentImage);
+        var preprocessed = PreprocessDocument(documentImage);
+        return _useNativeMode ? Forward(preprocessed) : RunOnnxInference(preprocessed);
+    }
+
+    /// <inheritdoc/>
+    public void ValidateInputShape(Tensor<T> documentImage)
+    {
+        ValidateImageShape(documentImage);
+    }
+
+    /// <inheritdoc/>
+    public string GetModelSummary()
+    {
+        var sb = new System.Text.StringBuilder();
+        sb.AppendLine("DocFormer Model Summary");
+        sb.AppendLine("=======================");
+        sb.AppendLine($"Mode: {(_useNativeMode ? "Native (Trainable)" : "ONNX (Inference)")}");
+        sb.AppendLine($"Architecture: Multi-modal Transformer with shared spatial encodings");
+        sb.AppendLine($"Hidden Dimension: {_hiddenDim}");
+        sb.AppendLine($"Number of Layers: {_numLayers}");
+        sb.AppendLine($"Attention Heads: {_numHeads}");
+        sb.AppendLine($"Spatial Embedding Dim: {_spatialDim}");
+        sb.AppendLine($"Image Size: {ImageSize}x{ImageSize}");
+        sb.AppendLine($"Max Sequence Length: {MaxSequenceLength}");
+        sb.AppendLine($"Number of Classes: {_numClasses}");
+        sb.AppendLine($"Uses Visual Features: Yes");
+        sb.AppendLine($"Uses Shared Spatial Encodings: Yes");
+        sb.AppendLine($"Total Layers: {Layers.Count}");
+        return sb.ToString();
+    }
+
+    #endregion
+
+    #region Preprocessing
+
+    /// <summary>
+    /// Applies DocFormer's industry-standard preprocessing: ImageNet normalization.
+    /// </summary>
+    /// <remarks>
+    /// DocFormer uses ImageNet normalization with mean=[0.485, 0.456, 0.406] and std=[0.229, 0.224, 0.225].
+    /// </remarks>
+    protected override Tensor<T> ApplyDefaultPreprocessing(Tensor<T> rawImage)
+    {
+        var image = EnsureBatchDimension(rawImage);
+        int batchSize = image.Shape[0];
+        int channels = image.Shape[1];
+        int height = image.Shape[2];
+        int width = image.Shape[3];
+
+        var normalized = new Tensor<T>(image._shape);
+        double[] means = [0.485, 0.456, 0.406];
+        double[] stds = [0.229, 0.224, 0.225];
+
+        for (int b = 0; b < batchSize; b++)
+        {
+            for (int c = 0; c < channels; c++)
+            {
+                double mean = c < means.Length ? means[c] : 0.5;
+                double std = c < stds.Length ? stds[c] : 0.5;
+                for (int h = 0; h < height; h++)
+                {
+                    for (int w = 0; w < width; w++)
+                    {
+                        int idx = b * channels * height * width + c * height * width + h * width + w;
+                        normalized.Data.Span[idx] = NumOps.FromDouble((NumOps.ToDouble(image.Data.Span[idx]) - mean) / std);
+                    }
+                }
+            }
+        }
+        return normalized;
+    }
+
+    /// <summary>
+    /// Applies DocFormer's industry-standard postprocessing: pass-through (multimodal outputs are already final).
+    /// </summary>
+    protected override Tensor<T> ApplyDefaultPostprocessing(Tensor<T> modelOutput) => modelOutput;
+
+    #endregion
+
+    #region Serialization
+
+    /// <inheritdoc/>
+    public override ModelMetadata<T> GetModelMetadata()
+    {
+        return new ModelMetadata<T>
+        {
+            Name = "DocFormer",
+            Description = "DocFormer with shared spatial encodings (ICCV 2021)",
+            FeatureCount = _hiddenDim,
+            Complexity = _numLayers,
+            AdditionalInfo = new Dictionary<string, object>
+            {
+                { "hidden_dim", _hiddenDim },
+                { "num_layers", _numLayers },
+                { "num_heads", _numHeads },
+                { "vocab_size", _vocabSize },
+                { "image_size", ImageSize },
+                { "spatial_dim", _spatialDim },
+                { "num_classes", _numClasses },
+                { "use_native_mode", _useNativeMode }
+            },
+            ModelData = SafeSerialize()
+        };
+    }
+
+    /// <inheritdoc/>
+
+
+    /// <inheritdoc/>
+
+
+    #endregion
+
+    #region NeuralNetworkBase Implementation
+
+    /// <inheritdoc/>
+    protected override Tensor<T> PredictCore(Tensor<T> input)
+    {
+        var preprocessed = PreprocessDocument(input);
+        return _useNativeMode ? Forward(preprocessed) : RunOnnxInference(preprocessed);
+    }
+
+    // Layer roles in CreateDefaultDocFormerLayers order: [0..VisualEncoderLayerCount) = ResNet visual
+    // backbone (convs/BN/pool ending in a C->hidden projection Dense), then the text embeddings, then
+    // the shared spatial-encoding + multimodal transformer + head. DocFormer (Appalaraju et al. 2021)
+    // reads BOTH a document image and its text; this native forward is modality-robust and routes by
+    // input rank so a token-only input runs the text stream and an image runs the visual backbone, both
+    // feeding the shared stack. Without it the base linear walk sends the rank-1 token vector into the
+    // rank-4-only Conv backbone and throws ("ConvolutionalLayer expects rank-3/rank-4 input; got rank 1").
+    private const int VisualEncoderLayerCount = 8;
+
+    // One, not two: the token EmbeddingLayer and the sinusoidal PositionalEncodingLayer that used to
+    // sit here are now a single LayoutEmbeddingLayer, which also carries the 2D layout terms and uses
+    // LEARNED positions (BERT's, which DocFormer inherits) rather than fixed sinusoids.
+    private const int TextEncoderLayerCount = 1;
+
+    private Tensor<T> RunModalityForward(Tensor<T> input)
+    {
+        Tensor<T> feats;
+        if (input.Rank <= 2)
+        {
+            // Token/text stream: word embeddings + positional encodings; skip the visual backbone.
+            feats = input;
+            for (int i = VisualEncoderLayerCount; i < VisualEncoderLayerCount + TextEncoderLayerCount && i < Layers.Count; i++)
+                feats = Layers[i].Forward(feats);
+        }
+        else
+        {
+            // Visual stream: conv backbone -> flatten spatial grid to tokens -> channel projection Dense.
+            feats = input;
+            int projIndex = VisualEncoderLayerCount - 1;
+            for (int i = 0; i < projIndex && i < Layers.Count; i++)
+                feats = Layers[i].Forward(feats);
+            feats = FlattenSpatialToTokens(feats);
+            if (projIndex >= 0 && projIndex < Layers.Count)
+                feats = Layers[projIndex].Forward(feats);
+        }
+        // Shared spatial-encoding + multimodal transformer + head.
+        for (int i = VisualEncoderLayerCount + TextEncoderLayerCount; i < Layers.Count; i++)
+            feats = Layers[i].Forward(feats);
+        return feats;
+    }
+
+    // [C, H, W] -> [H*W, C]; [B, C, H, W] -> [B, H*W, C]. Puts channels last so each spatial location
+    // becomes a token whose feature vector the projection Dense maps to the hidden dim.
+    private Tensor<T> FlattenSpatialToTokens(Tensor<T> feat)
+    {
+        if (feat.Rank == 4)
+        {
+            int b = feat.Shape[0], c = feat.Shape[1], n = feat.Shape[2] * feat.Shape[3];
+            return Engine.TensorPermute(Engine.Reshape(feat, new[] { b, c, n }), new[] { 0, 2, 1 });
+        }
+        if (feat.Rank == 3)
+        {
+            int c = feat.Shape[0], n = feat.Shape[1] * feat.Shape[2];
+            return Engine.TensorPermute(Engine.Reshape(feat, new[] { c, n }), new[] { 1, 0 });
+        }
+        return feat;
+    }
+
+    /// <inheritdoc/>
+    protected override Tensor<T> Forward(Tensor<T> input)
+        => _useNativeMode ? RunModalityForward(input) : base.Forward(input);
+
+    /// <inheritdoc/>
+    public override Tensor<T> ForwardForTraining(Tensor<T> input)
+        => _useNativeMode ? RunModalityForward(input) : base.ForwardForTraining(input);
+
+    /// <inheritdoc/>
+    /// <remarks>
+    /// Diagnostic counterpart of the modality routing in <see cref="RunModalityForward"/>: the base
+    /// implementation walks <c>Layers</c> from index 0, sending a token-only input into the rank-4-only
+    /// Conv backbone and throwing before it records anything. Record only the layers that actually fire.
+    /// </remarks>
+    public override Dictionary<string, Tensor<T>> GetNamedLayerActivations(Tensor<T> input)
+    {
+        if (input is null)
+            throw new ArgumentNullException(nameof(input));
+
+        if (!_useNativeMode)
+            return base.GetNamedLayerActivations(input);
+
+        var activations = new Dictionary<string, Tensor<T>>();
+        var current = input;
+        if (input.Rank <= 2)
+        {
+            for (int i = VisualEncoderLayerCount; i < VisualEncoderLayerCount + TextEncoderLayerCount && i < Layers.Count; i++)
+            {
+                current = Layers[i].Forward(current);
+                activations[$"Layer_{i}_{Layers[i].GetType().Name}"] = current.Clone();
+            }
+        }
+        else
+        {
+            int projIndex = VisualEncoderLayerCount - 1;
+            for (int i = 0; i < projIndex && i < Layers.Count; i++)
+            {
+                current = Layers[i].Forward(current);
+                activations[$"Layer_{i}_{Layers[i].GetType().Name}"] = current.Clone();
+            }
+            current = FlattenSpatialToTokens(current);
+            if (projIndex >= 0 && projIndex < Layers.Count)
+            {
+                current = Layers[projIndex].Forward(current);
+                activations[$"Layer_{projIndex}_{Layers[projIndex].GetType().Name}"] = current.Clone();
+            }
+        }
+        for (int i = VisualEncoderLayerCount + TextEncoderLayerCount; i < Layers.Count; i++)
+        {
+            current = Layers[i].Forward(current);
+            activations[$"Layer_{i}_{Layers[i].GetType().Name}"] = current.Clone();
+        }
+        return activations;
+    }
+
+    /// <inheritdoc/>
+    public override void Train(Tensor<T> input, Tensor<T> expectedOutput)
+    {
+        if (!_useNativeMode)
+            throw new NotSupportedException("Training not supported in ONNX mode.");
+
+        // TrainWithTape runs the full forward (ForwardForTraining -> RunModalityForward), backprops, and
+        // applies the optimizer update itself. The earlier UpdateParameters(CollectGradients()) was a
+        // redundant SECOND update whose hand-collected gradient vector did not line up with
+        // GetParameters(). TrainWithTape alone is the correct single update.
+        // Pass DocFormer's configured optimizer explicitly: the no-optimizer overload falls back to the
+        // base default Adam at lr 1e-3, which overshoots this 12-layer transformer's training and
+        // degrades with more iterations (MoreData_ShouldNotDegrade / collapsed post-training outputs).
+        // DocFormer's own optimizer is a lower-lr (1e-4) Adam matching the paper's fine-tuning recipe.
+        SetTrainingMode(true);
+        try
+        {
+            TrainWithTape(input, expectedOutput, _optimizer);
+        }
+        finally
+        {
+            SetTrainingMode(false);
+        }
+    }
+
+    // UpdateParameters applied a GRADIENT STEP, but its one-argument form is the value setter and every caller passes values -- the override corrupted the model. Removed under AIDN082.
+
+
+    /// <summary>
+    /// Parameters cannot be written while the model is backed by a loaded ONNX graph: the weights
+    /// belong to that graph, not to this instance.
+    /// </summary>
+    /// <remarks>
+    /// Replaces a hand-written throw that used to sit inside UpdateParameters. The base checks this
+    /// on every mutating entry point rather than the one member the throw happened to guard, and
+    /// reading -- ParameterCount and GetParameters -- stays available either way.
+    /// </remarks>
     protected override bool SupportsParameterMutation => _useNativeMode;
-    #endregion
-
-    #region Disposal
-
-    /// <inheritdoc/>
-    protected override void Dispose(bool disposing)
-    {
-        if (disposing)
-            _onnxSession?.Dispose();
-        base.Dispose(disposing);
-    }
-
-    #endregion
-}
+    #endregion
+
+    #region Disposal
+
+    /// <inheritdoc/>
+    protected override void Dispose(bool disposing)
+    {
+        if (disposing)
+            _onnxSession?.Dispose();
+        base.Dispose(disposing);
+    }
+
+    #endregion
+}
diff --git a/src/Document/LayoutAware/LayoutLM.cs b/src/Document/LayoutAware/LayoutLM.cs
index b932a99f24..f521889cf7 100644
--- a/src/Document/LayoutAware/LayoutLM.cs
+++ b/src/Document/LayoutAware/LayoutLM.cs
@@ -429,47 +429,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_hiddenDim);
-        writer.Write(_numLayers);
-        writer.Write(_numHeads);
-        writer.Write(_vocabSize);
-        writer.Write(MaxSequenceLength);
-        writer.Write(_maxPosition2D);
-        writer.Write(_numClasses);
-        writer.Write(_useNativeMode);
-    }
 
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        int hiddenDim = reader.ReadInt32();
-        int numLayers = reader.ReadInt32();
-        int numHeads = reader.ReadInt32();
-        int vocabSize = reader.ReadInt32();
-        int maxSeqLen = reader.ReadInt32();
-        int maxPos2D = reader.ReadInt32();
-        int numClasses = reader.ReadInt32();
-        bool useNativeMode = reader.ReadBoolean();
-
-        MaxSequenceLength = maxSeqLen;
-    }
 
     /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new LayoutLM<T>(
-            Architecture,
-            _tokenizer,
-            _numClasses,
-            MaxSequenceLength,
-            _hiddenDim,
-            _numLayers,
-            _numHeads,
-            _vocabSize,
-            _maxPosition2D);
-    }
+
 
     #endregion
 
diff --git a/src/Document/LayoutAware/LayoutLMv2.cs b/src/Document/LayoutAware/LayoutLMv2.cs
index 4e39a2263c..cf5d4e4819 100644
--- a/src/Document/LayoutAware/LayoutLMv2.cs
+++ b/src/Document/LayoutAware/LayoutLMv2.cs
@@ -1,940 +1,904 @@
-using AiDotNet.Attributes;
-using AiDotNet.Document.Interfaces;
-using AiDotNet.Document.Options;
-using AiDotNet.Enums;
-using AiDotNet.Helpers;
-using AiDotNet.Interfaces;
-using AiDotNet.LinearAlgebra;
-using AiDotNet.LossFunctions;
-using AiDotNet.NeuralNetworks;
-using AiDotNet.NeuralNetworks.Layers;
-using AiDotNet.Optimizers;
-using AiDotNet.Tokenization;
-using AiDotNet.Tokenization.Interfaces;
-using Microsoft.ML.OnnxRuntime;
-using AiDotNet.Validation;
-
-namespace AiDotNet.Document.LayoutAware;
-
-/// <summary>
-/// LayoutLMv2 neural network for document understanding with visual features.
-/// </summary>
-/// <typeparam name="T">The numeric type used for calculations.</typeparam>
-/// <remarks>
-/// <para>
-/// LayoutLMv2 extends LayoutLM by adding visual features from a CNN backbone,
-/// enabling the model to understand documents through text, layout, AND image features.
-/// </para>
-/// <para>
-/// <b>For Beginners:</b> LayoutLMv2 improves on v1 by also looking at the actual image:
-/// 1. Text content (what the words say)
-/// 2. Layout structure (where words are positioned)
-/// 3. Visual appearance (what the document looks like)
-///
-/// Key improvements over v1:
-/// - Visual backbone (ResNeXt-FPN) for image features
-/// - Spatial-aware self-attention mechanism
-/// - Pre-training on both text-layout and image-text-layout alignment
-///
-/// Example usage:
-/// <code>
-/// var model = new LayoutLMv2&lt;float&gt;(architecture);
-/// var result = model.DetectLayout(documentImage);
-/// </code>
-/// </para>
-/// <para>
-/// <b>Reference:</b> "LayoutLMv2: Multi-modal Pre-training for Visually-rich Document Understanding" (ACL 2021)
-/// https://arxiv.org/abs/2012.14740
-/// </para>
-/// </remarks>
-[ModelDomain(ModelDomain.Vision)]
-[ModelDomain(ModelDomain.Language)]
-[ModelCategory(ModelCategory.NeuralNetwork)]
-[ModelCategory(ModelCategory.Transformer)]
-[ModelTask(ModelTask.Classification)]
-[ModelTask(ModelTask.Detection)]
+using AiDotNet.Attributes;
+using AiDotNet.Document.Interfaces;
+using AiDotNet.Document.Options;
+using AiDotNet.Enums;
+using AiDotNet.Helpers;
+using AiDotNet.Interfaces;
+using AiDotNet.LinearAlgebra;
+using AiDotNet.LossFunctions;
+using AiDotNet.NeuralNetworks;
+using AiDotNet.NeuralNetworks.Layers;
+using AiDotNet.Optimizers;
+using AiDotNet.Tokenization;
+using AiDotNet.Tokenization.Interfaces;
+using Microsoft.ML.OnnxRuntime;
+using AiDotNet.Validation;
+
+namespace AiDotNet.Document.LayoutAware;
+
+/// <summary>
+/// LayoutLMv2 neural network for document understanding with visual features.
+/// </summary>
+/// <typeparam name="T">The numeric type used for calculations.</typeparam>
+/// <remarks>
+/// <para>
+/// LayoutLMv2 extends LayoutLM by adding visual features from a CNN backbone,
+/// enabling the model to understand documents through text, layout, AND image features.
+/// </para>
+/// <para>
+/// <b>For Beginners:</b> LayoutLMv2 improves on v1 by also looking at the actual image:
+/// 1. Text content (what the words say)
+/// 2. Layout structure (where words are positioned)
+/// 3. Visual appearance (what the document looks like)
+///
+/// Key improvements over v1:
+/// - Visual backbone (ResNeXt-FPN) for image features
+/// - Spatial-aware self-attention mechanism
+/// - Pre-training on both text-layout and image-text-layout alignment
+///
+/// Example usage:
+/// <code>
+/// var model = new LayoutLMv2&lt;float&gt;(architecture);
+/// var result = model.DetectLayout(documentImage);
+/// </code>
+/// </para>
+/// <para>
+/// <b>Reference:</b> "LayoutLMv2: Multi-modal Pre-training for Visually-rich Document Understanding" (ACL 2021)
+/// https://arxiv.org/abs/2012.14740
+/// </para>
+/// </remarks>
+[ModelDomain(ModelDomain.Vision)]
+[ModelDomain(ModelDomain.Language)]
+[ModelCategory(ModelCategory.NeuralNetwork)]
+[ModelCategory(ModelCategory.Transformer)]
+[ModelTask(ModelTask.Classification)]
+[ModelTask(ModelTask.Detection)]
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [RankRoutedInputDomain(2, 12)]
-[ResearchPaper("LayoutLMv2: Multi-modal Pre-training for Visually-Rich Document Understanding", "https://doi.org/10.48550/arXiv.2012.14740", Year = 2021, Authors = "Yang Xu, Yiheng Xu, Tengchao Lv, Lei Cui, Furu Wei, Guoxin Wang, Yijuan Lu, Dinei Florencio, Cha Zhang, Wanxiang Che, Min Zhang, Lidong Zhou")]
-public partial class LayoutLMv2<T> : DocumentNeuralNetworkBase<T>, ILayoutDetector<T>, IDocumentQA<T>
-{
-    private readonly LayoutLMv2Options _options;
-
-    /// <inheritdoc/>
-    public override ModelOptions GetOptions() => _options;
-
-    #region Fields
-
-    private readonly bool _useNativeMode;
-    private readonly InferenceSession? _onnxSession;
-    private readonly ITokenizer _tokenizer;
-    private readonly IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>> _optimizer;
-    private readonly int _hiddenDim;
-    private readonly int _numLayers;
-    private readonly int _numHeads;
-    private readonly int _vocabSize;
-    private readonly int _numClasses;
-    private readonly int _visualBackboneChannels;
-
-    // Native mode layers
-    private readonly List<ILayer<T>> _visualBackboneLayers = [];
-    private readonly List<ILayer<T>> _textEmbeddingLayers = [];
-    private readonly List<ILayer<T>> _transformerLayers = [];
-    private readonly List<ILayer<T>> _outputLayers = [];
-
-    // Learnable embeddings
-
-    #endregion
-
-    #region Properties
-
-    /// <inheritdoc/>
-    public override DocumentType SupportedDocumentTypes => DocumentType.All;
-
-    /// <inheritdoc/>
-    public override bool RequiresOCR => true;
-
-    /// <inheritdoc/>
-    public int ExpectedImageSize => ImageSize;
-
-    /// <inheritdoc/>
-    public IReadOnlyList<LayoutElementType> SupportedElementTypes { get; } =
-    [
-        LayoutElementType.Text,
-        LayoutElementType.Title,
-        LayoutElementType.List,
-        LayoutElementType.Table,
-        LayoutElementType.Figure,
-        LayoutElementType.Caption,
-        LayoutElementType.Header,
-        LayoutElementType.Footer,
-        LayoutElementType.FormField
-    ];
-
-    #endregion
-
-    #region Constructors
-
-    /// <summary>
-    /// Creates a LayoutLMv2 model using a pre-trained ONNX model for inference.
-    /// </summary>
-    /// <param name="architecture">The neural network architecture.</param>
-    /// <param name="onnxModelPath">Path to the ONNX model file.</param>
-    /// <param name="tokenizer">Tokenizer for text processing.</param>
-    /// <param name="numClasses">Number of output classes (default: 7).</param>
-    /// <param name="imageSize">Input image size (default: 224).</param>
-    /// <param name="maxSequenceLength">Maximum sequence length (default: 512).</param>
-    /// <param name="hiddenDim">Hidden dimension (default: 768).</param>
-    /// <param name="numLayers">Number of transformer layers (default: 12).</param>
-    /// <param name="numHeads">Number of attention heads (default: 12).</param>
-    /// <param name="vocabSize">Vocabulary size (default: 30522).</param>
-    /// <param name="visualBackboneChannels">Visual backbone output channels (default: 256).</param>
-    /// <param name="optimizer">Optimizer for training (optional).</param>
-    /// <param name="lossFunction">Loss function (optional).</param>
-    public LayoutLMv2(
-        NeuralNetworkArchitecture<T> architecture,
-        string onnxModelPath,
-        ITokenizer tokenizer,
-        int numClasses = 7,
-        int imageSize = 224,
-        int maxSequenceLength = 512,
-        int hiddenDim = 768,
-        int numLayers = 12,
-        int numHeads = 12,
-        int vocabSize = 30522,
-        int visualBackboneChannels = 256,
-        IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? optimizer = null,
-        ILossFunction<T>? lossFunction = null,
-        LayoutLMv2Options? options = null)
-        : base(architecture, lossFunction ?? new CrossEntropyWithLogitsLoss<T>(), 1.0)
-    {
-        _options = options ?? new LayoutLMv2Options();
-        Options = _options;
-
-        if (string.IsNullOrWhiteSpace(onnxModelPath))
-            throw new ArgumentNullException(nameof(onnxModelPath));
-        if (!File.Exists(onnxModelPath))
-            throw new FileNotFoundException($"ONNX model not found: {onnxModelPath}", onnxModelPath);
-
-        Guard.NotNull(tokenizer);
-        _tokenizer = tokenizer;
-        _useNativeMode = false;
-        _numClasses = numClasses;
-        _hiddenDim = hiddenDim;
-        _numLayers = numLayers;
-        _numHeads = numHeads;
-        _vocabSize = vocabSize;
-        _visualBackboneChannels = visualBackboneChannels;
-        _optimizer = optimizer ?? CreatePaperDefaultOptimizer();
-
-        ImageSize = imageSize;
-        MaxSequenceLength = maxSequenceLength;
-
-        _onnxSession = new InferenceSession(onnxModelPath);
-
-        InitializeLayers();
-    }
-
-    /// <summary>
-    /// Creates a LayoutLMv2 model using native layers for training and inference.
-    /// </summary>
-    /// <param name="architecture">The neural network architecture.</param>
-    /// <param name="tokenizer">Tokenizer for text processing (optional).</param>
-    /// <param name="numClasses">Number of output classes (default: 7).</param>
-    /// <param name="imageSize">Input image size (default: 224).</param>
-    /// <param name="maxSequenceLength">Maximum sequence length (default: 512).</param>
-    /// <param name="hiddenDim">Hidden dimension (default: 768).</param>
-    /// <param name="numLayers">Number of transformer layers (default: 12).</param>
-    /// <param name="numHeads">Number of attention heads (default: 12).</param>
-    /// <param name="vocabSize">Vocabulary size (default: 30522).</param>
-    /// <param name="visualBackboneChannels">Visual backbone output channels (default: 256).</param>
-    /// <param name="optimizer">Optimizer for training (optional).</param>
-    /// <param name="lossFunction">Loss function (optional).</param>
-    /// <remarks>
-    /// <para>
-    /// <b>Default Configuration (LayoutLMv2-Base from ACL 2021):</b>
-    /// - Text encoder: BERT-base architecture
-    /// - Visual backbone: ResNeXt-101 FPN
-    /// - Hidden dimension: 768
-    /// - Layers: 12, Heads: 12
-    /// - Image size: 224×224
-    /// </para>
-    /// </remarks>
-    public LayoutLMv2(
-        NeuralNetworkArchitecture<T> architecture,
-        ITokenizer? tokenizer = null,
-        int numClasses = 7,
-        int imageSize = 224,
-        int maxSequenceLength = 512,
-        int hiddenDim = 768,
-        int numLayers = 12,
-        int numHeads = 12,
-        int vocabSize = 30522,
-        int visualBackboneChannels = 256,
-        IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? optimizer = null,
-        ILossFunction<T>? lossFunction = null,
-        LayoutLMv2Options? options = null)
-        : base(architecture, lossFunction ?? new CrossEntropyWithLogitsLoss<T>(), 1.0)
-    {
-        _options = options ?? new LayoutLMv2Options();
-        Options = _options;
-
-        _useNativeMode = true;
-        _numClasses = numClasses;
-        _hiddenDim = hiddenDim;
-        _numLayers = numLayers;
-        _numHeads = numHeads;
-        _vocabSize = vocabSize;
-        _visualBackboneChannels = visualBackboneChannels;
-        _optimizer = optimizer ?? CreatePaperDefaultOptimizer();
-
-        ImageSize = imageSize;
-        MaxSequenceLength = maxSequenceLength;
-
-        _tokenizer = tokenizer ?? LanguageModelTokenizerFactory.CreateForBackbone(LanguageModelBackbone.OPT);
-
-        InitializeLayers();
-        InitializeEmbeddings();
-    }
-
-    #endregion
-
-    private IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>> CreatePaperDefaultOptimizer()
-    {
-        // LayoutLMv2 Appendix B: Adam with lr=2e-5, weight decay=1e-2,
-        // and (beta1,beta2)=(0.9,0.999). AdamW expresses the cited decoupled
-        // weight-decay formulation while keeping every value user-overridable
-        // through the constructor's optimizer parameter.
-        var options = new AiDotNet.Models.Options.AdamWOptimizerOptions<T, Tensor<T>, Tensor<T>>
-        {
-            InitialLearningRate = _options.LearningRate,
-            WeightDecay = _options.WeightDecay,
-            Beta1 = 0.9,
-            Beta2 = 0.999,
-            Epsilon = 1e-8,
-            UseAMSGrad = false,
-            UseAdaptiveLearningRate = false
-        };
-        return new AdamWOptimizer<T, Tensor<T>, Tensor<T>>(this, options);
-    }
-
-    #region Initialization
-
-    /// <inheritdoc/>
-    protected override void InitializeLayers()
-    {
-        if (!_useNativeMode)
-        {
-            return;
-        }
-
-        if (Architecture.Layers is not null && Architecture.Layers.Count > 0)
-        {
-            Layers.AddRange(Architecture.Layers);
-            ValidateCustomLayers(Layers);
-            return;
-        }
-
-        Layers.AddRange(LayerHelper<T>.CreateDefaultLayoutLMv2Layers(
-            hiddenDim: _hiddenDim,
-            numLayers: _numLayers,
-            numHeads: _numHeads,
-            vocabSize: _vocabSize,
-            imageSize: ImageSize,
-            visualBackboneChannels: _visualBackboneChannels,
-            numClasses: _numClasses));
-
-        DistributeLayers();
-    }
-
-    // CreateDefaultLayoutLMv2Layers emits the layers in three role groups, in this order:
-    //   [0 .. VisualBackboneLayerCount)                        = ResNeXt-FPN visual backbone
-    //                                                            (conv/BN/pool stack + a final C->hidden projection Dense),
-    //   [.. + TextEmbeddingLayerCount)                          = word-embedding / position / layernorm / dropout,
-    //   [rest]                                                  = multimodal transformer encoder + classification head.
-    private const int VisualBackboneLayerCount = 12;
-
-    // Three, not four: the token EmbeddingLayer and the sinusoidal PositionalEncodingLayer that
-    // used to open this section are now a single LayoutEmbeddingLayer, which also carries the 2D
-    // layout terms. The LayerNorm and Dropout after them are unchanged.
-    private const int TextEmbeddingLayerCount = 3;
-
-    // Re-links the per-role forward-path sublists to the CURRENT Layers. The two-stream forward reads
-    // these lists, not Layers directly, so they must be rebuilt whenever Layers is replaced — including
-    // after deserialization (the base clears Layers and adds freshly-deserialized layers).
-    private void DistributeLayers()
-    {
-        _visualBackboneLayers.Clear();
-        _textEmbeddingLayers.Clear();
-        _transformerLayers.Clear();
-        // Fail loudly if the factory's emission order/count drifts below the hardcoded split, rather
-        // than silently misclassifying layers into the wrong role list (which would corrupt fusion).
-        if (Layers.Count < VisualBackboneLayerCount + TextEmbeddingLayerCount)
-            throw new InvalidOperationException(
-                $"LayoutLMv2 expects at least {VisualBackboneLayerCount + TextEmbeddingLayerCount} layers " +
-                $"({VisualBackboneLayerCount} visual + {TextEmbeddingLayerCount} text embedding) before the " +
-                $"transformer stack, but only {Layers.Count} were present. The CreateDefaultLayoutLMv2Layers " +
-                "emission order/count must stay in sync with these role-split constants.");
-        for (int i = 0; i < Layers.Count; i++)
-        {
-            if (i < VisualBackboneLayerCount)
-                _visualBackboneLayers.Add(Layers[i]);
-            else if (i < VisualBackboneLayerCount + TextEmbeddingLayerCount)
-                _textEmbeddingLayers.Add(Layers[i]);
-            else
-                _transformerLayers.Add(Layers[i]);
-        }
-    }
-
-    /// <summary>
-    /// Runs LayoutLMv2's real two-stream forward and fuses whatever modalities are present.
-    /// </summary>
-    /// <remarks>
-    /// Reference LayoutLMv2 (Xu et al. 2021) REQUIRES both a document image AND text tokens and crashes
-    /// otherwise. This implementation is modality-robust: it runs the visual backbone and/or the text
-    /// embedding stream depending on which inputs are supplied, concatenates the resulting token
-    /// sequences, and runs the shared multimodal transformer + head — so it also handles OCR-text-only
-    /// or image-only documents (graceful degradation), which the reference model cannot.
-    /// </remarks>
-    private Tensor<T> RunMultimodal(Tensor<T>? textTokens, Tensor<T>? documentImage)
-    {
-        Tensor<T>? textSeq = textTokens is not null ? RunTextStream(textTokens) : null;
-        Tensor<T>? visualSeq = documentImage is not null ? RunVisualStream(documentImage) : null;
-
-        Tensor<T> seq;
-        if (textSeq is not null && visualSeq is not null)
-        {
-            // Fuse the way LayoutLMv2 (Xu et al. 2021, §3.1) does: stack the visual and text token
-            // sequences along the SEQUENCE axis (visual first, then text) into one joint sequence for
-            // the shared multimodal transformer. Normalize both streams to a batched [B, L, D] first —
-            // the visual backbone emits [B, Lvis, D] while the text stream can emit an unbatched
-            // [Ltext, D] (and a continuous-valued token tensor projects to [1, D]) — so the
-            // concatenation matches on batch and hidden and only grows the sequence axis. The prior
-            // axis-(Rank-2) concat on unequal-rank streams was invalid and only appeared to work when
-            // the output buffer's unwritten tail happened to be zero.
-            var vis = AlignToBatchedSequence(visualSeq);
-            var txt = AlignToBatchedSequence(textSeq);
-            seq = Engine.TensorConcatenate([vis, txt], axis: 1);
-        }
-        else
-        {
-            seq = textSeq ?? visualSeq
-                ?? throw new ArgumentException(
-                    "LayoutLMv2 requires at least one modality: text token IDs (rank <= 2) or a document image (rank >= 3).");
-        }
-
-        foreach (var layer in _transformerLayers)
-            seq = layer.Forward(seq);
-        return seq;
-    }
-
-    // Normalizes a token sequence to a batched [B, L, D] layout so the two fusion streams concatenate
-    // cleanly on the sequence axis. A [L, D] stream (unbatched, e.g. the text embedding on a rank-1
-    // token vector) gains a leading batch of 1; a continuous [1, D] projection becomes a single-token
-    // [1, 1, D]; an already-batched [B, L, D] passes through unchanged.
-    private Tensor<T> AlignToBatchedSequence(Tensor<T> t)
-    {
-        if (t.Rank == 3) return t;
-        if (t.Rank == 2) return Engine.Reshape(t, new[] { 1, t.Shape[0], t.Shape[1] });
-        throw new ArgumentException($"Fusion stream must be rank 2 or 3, got rank {t.Rank}.");
-    }
-
-    // Text stream: token IDs -> word embedding -> position -> layernorm -> dropout => [seq, hidden].
-    private Tensor<T> RunTextStream(Tensor<T> textTokens)
-    {
-        var x = textTokens;
-        foreach (var layer in _textEmbeddingLayers)
-            x = layer.Forward(x);
-        return x;
-    }
-
-    // Visual stream: image -> conv/BN/pool backbone -> flatten spatial grid to a token sequence ->
-    // channel projection => [numPatches, hidden]. The final backbone layer is the C->hidden projection,
-    // applied AFTER the spatial->token reshape so it maps channels (not width) to the hidden dim.
-    private Tensor<T> RunVisualStream(Tensor<T> documentImage)
-    {
-        var x = documentImage;
-        int projIndex = _visualBackboneLayers.Count - 1;
-        for (int i = 0; i < projIndex; i++)
-            x = _visualBackboneLayers[i].Forward(x);
-
-        x = FlattenSpatialToTokens(x);
-        if (projIndex >= 0 && projIndex < _visualBackboneLayers.Count)
-            x = _visualBackboneLayers[projIndex].Forward(x);
-        return x;
-    }
-
-    // [C, H, W] -> [H*W, C]; [B, C, H, W] -> [B, H*W, C]. Puts channels last so each spatial location
-    // becomes a token whose feature vector the projection Dense maps to the hidden dim.
-    private Tensor<T> FlattenSpatialToTokens(Tensor<T> feat)
-    {
-        if (feat.Rank == 4)
-        {
-            int b = feat.Shape[0], c = feat.Shape[1], n = feat.Shape[2] * feat.Shape[3];
-            return Engine.TensorPermute(Engine.Reshape(feat, new[] { b, c, n }), new[] { 0, 2, 1 });
-        }
-        if (feat.Rank == 3)
-        {
-            int c = feat.Shape[0], n = feat.Shape[1] * feat.Shape[2];
-            return Engine.TensorPermute(Engine.Reshape(feat, new[] { c, n }), new[] { 1, 0 });
-        }
-        return feat;
-    }
-
-    /// <summary>
-    /// Full text+image fusion entry (industry-standard LayoutLMv2): encodes BOTH a token-ID sequence
-    /// and a document image and fuses them through the multimodal transformer.
-    /// </summary>
-    public Tensor<T> EncodeMultimodal(Tensor<T> textTokens, Tensor<T> documentImage)
-    {
-        // Inference entry: mirror Predict()/PredictCore by suppressing gradient-tape recording
-        // (PyTorch torch.no_grad() semantics). RunMultimodal issues raw Engine.Reshape/Permute/
-        // Concatenate ops that would otherwise record onto the shared autodiff tape; if a prior
-        // training pass left that singleton tape non-empty, replaying it here poisons the fusion
-        // forward with stale/NaN buffers. NoGradScope makes this direct call as tape-clean as
-        // the Predict()-wrapped image-only path. ForwardForTraining keeps recording (no scope).
-        using var _ = new AiDotNet.Tensors.Engines.Autodiff.NoGradScope<T>();
-        var image = PreprocessDocument(documentImage);
-        return RunMultimodal(textTokens, image);
-    }
-
-    /// <inheritdoc/>
-    public override Tensor<T> ForwardForTraining(Tensor<T> input)
-    {
-        var prepared = PreprocessDocument(input);
-        var (tokens, image) = prepared.Rank <= 2 ? (prepared, (Tensor<T>?)null) : ((Tensor<T>?)null, prepared);
-        return RunMultimodal(tokens, image);
-    }
-
-    /// <inheritdoc/>
-    public override Dictionary<string, Tensor<T>> GetNamedLayerActivations(Tensor<T> input)
-    {
-        // The base walks Layers linearly feeding the raw input, which crashes the visual conv backbone
-        // on a token-only input (rank-1). Replay the real two-stream forward, capturing each layer.
-        var activations = new Dictionary<string, Tensor<T>>();
-        if (!_useNativeMode)
-            return activations;
-
-        var prepared = PreprocessDocument(input);
-        var (tokens, image) = prepared.Rank <= 2 ? (prepared, (Tensor<T>?)null) : ((Tensor<T>?)null, prepared);
-
-        int idx = 0;
-        Tensor<T>? textSeq = null, visualSeq = null;
-
-        if (tokens is not null)
-        {
-            var x = tokens;
-            foreach (var layer in _textEmbeddingLayers)
-            {
-                x = layer.Forward(x);
-                activations[$"Layer_{idx++}_{layer.GetType().Name}"] = x.Clone();
-            }
-            textSeq = x;
-        }
-
-        if (image is not null)
-        {
-            var x = image;
-            int projIndex = _visualBackboneLayers.Count - 1;
-            for (int i = 0; i < projIndex; i++)
-            {
-                x = _visualBackboneLayers[i].Forward(x);
-                activations[$"Layer_{idx++}_{_visualBackboneLayers[i].GetType().Name}"] = x.Clone();
-            }
-            x = FlattenSpatialToTokens(x);
-            if (projIndex >= 0 && projIndex < _visualBackboneLayers.Count)
-            {
-                x = _visualBackboneLayers[projIndex].Forward(x);
-                activations[$"Layer_{idx++}_{_visualBackboneLayers[projIndex].GetType().Name}"] = x.Clone();
-            }
-            visualSeq = x;
-        }
-
-        Tensor<T> seq;
-        if (textSeq is not null && visualSeq is not null)
-            // Same sequence-axis fusion as RunMultimodal: normalize both streams to [B, L, D] and
-            // concatenate along the sequence axis (concatenating on axis 0 with unequal-rank streams
-            // grows the batch dimension and leaves an uninitialized output tail).
-            seq = Engine.TensorConcatenate(
-                [AlignToBatchedSequence(visualSeq), AlignToBatchedSequence(textSeq)], axis: 1);
-        else
-            seq = textSeq ?? visualSeq ?? new Tensor<T>(new[] { 1, _hiddenDim });
-
-        foreach (var layer in _transformerLayers)
-        {
-            seq = layer.Forward(seq);
-            activations[$"Layer_{idx++}_{layer.GetType().Name}"] = seq.Clone();
-        }
-        return activations;
-    }
-
-    private void InitializeEmbeddings()
-    {
-        var random = RandomHelper.CreateSeededRandom(42);
-
-
-    }
-
-    private void InitializeWithSmallRandomValues(Tensor<T> tensor, Random random, double stdDev)
-    {
-        for (int i = 0; i < tensor.Data.Length; i++)
-        {
-            double u1 = 1.0 - random.NextDouble();
-            double u2 = 1.0 - random.NextDouble();
-            double randStdNormal = Math.Sqrt(-2.0 * Math.Log(u1)) * Math.Sin(2.0 * Math.PI * u2);
-            tensor.Data.Span[i] = NumOps.FromDouble(randStdNormal * stdDev);
-        }
-    }
-
-    #endregion
-
-    #region ILayoutDetector Implementation
-
-    /// <inheritdoc/>
-    public DocumentLayoutResult<T> DetectLayout(Tensor<T> documentImage)
-    {
-        return DetectLayout(documentImage, 0.5);
-    }
-
-    /// <inheritdoc/>
-    public DocumentLayoutResult<T> DetectLayout(Tensor<T> documentImage, double confidenceThreshold)
-    {
-        ValidateImageShape(documentImage);
-        var startTime = DateTime.UtcNow;
-
-        var preprocessed = PreprocessDocument(documentImage);
-        var output = _useNativeMode ? Forward(preprocessed) : RunOnnxInference(preprocessed);
-
-        var regions = ParseLayoutOutput(output, confidenceThreshold);
-
-        return new DocumentLayoutResult<T>
-        {
-            Regions = regions,
-            ProcessingTimeMs = (DateTime.UtcNow - startTime).TotalMilliseconds
-        };
-    }
-
-    private List<LayoutRegion<T>> ParseLayoutOutput(Tensor<T> output, double threshold)
-    {
-        var regions = new List<LayoutRegion<T>>();
-        int numDetections = output.Shape[0];
-        int numClasses = output.Shape.Length > 1 ? output.Shape[1] : _numClasses;
-
-        for (int i = 0; i < numDetections; i++)
-        {
-            double maxConf = 0;
-            int maxClass = 0;
-            for (int c = 0; c < numClasses; c++)
-            {
-                double conf = NumOps.ToDouble(output[i, c]);
-                if (conf > maxConf) { maxConf = conf; maxClass = c; }
-            }
-
-            if (maxConf >= threshold && maxClass > 0)
-            {
-                regions.Add(new LayoutRegion<T>
-                {
-                    ElementType = (LayoutElementType)Math.Min(maxClass, (int)LayoutElementType.Other),
-                    Confidence = NumOps.FromDouble(maxConf),
-                    ConfidenceValue = maxConf,
-                    Index = i,
-                    BoundingBox = Vector<T>.Empty()
-                });
-            }
-        }
-
-        return regions;
-    }
-
-    #endregion
-
-    #region IDocumentQA Implementation
-
-    /// <inheritdoc/>
-    public DocumentQAResult<T> AnswerQuestion(Tensor<T> documentImage, string question)
-    {
-        return AnswerQuestion(documentImage, question, 64, 0.0);
-    }
-
-    /// <inheritdoc/>
-    public DocumentQAResult<T> AnswerQuestion(Tensor<T> documentImage, string question, int maxAnswerLength, double temperature = 0.0)
-    {
-        ValidateImageShape(documentImage);
-        var startTime = DateTime.UtcNow;
-
-        var preprocessed = PreprocessDocument(documentImage);
-        var output = _useNativeMode ? Forward(preprocessed) : RunOnnxInference(preprocessed);
-
-        var (answer, confidence) = ExtractAnswer(output, maxAnswerLength);
-
-        return new DocumentQAResult<T>
-        {
-            Answer = answer,
-            Confidence = NumOps.FromDouble(confidence),
-            ConfidenceValue = confidence,
-            Question = question,
-            ProcessingTimeMs = (DateTime.UtcNow - startTime).TotalMilliseconds
-        };
-    }
-
-    /// <summary>
-    /// Extracts answer from model output using extractive QA approach.
-    /// </summary>
-    private (string answer, double confidence) ExtractAnswer(Tensor<T> output, int maxAnswerLength)
-    {
-        int seqLen = output.Shape[0];
-        int hiddenDim = output.Shape.Length > 1 ? output.Shape[1] : _hiddenDim;
-
-        double bestStartScore = double.MinValue;
-        double bestEndScore = double.MinValue;
-        int bestStart = 0;
-        int bestEnd = 0;
-
-        for (int i = 0; i < seqLen; i++)
-        {
-            double startScore = NumOps.ToDouble(output[i, 0]);
-            if (startScore > bestStartScore)
-            {
-                bestStartScore = startScore;
-                bestStart = i;
-            }
-        }
-
-        int endSearchLimit = Math.Min(seqLen, bestStart + maxAnswerLength);
-        for (int i = bestStart; i < endSearchLimit; i++)
-        {
-            double endScore = NumOps.ToDouble(output[i, Math.Min(1, hiddenDim - 1)]);
-            if (endScore > bestEndScore)
-            {
-                bestEndScore = endScore;
-                bestEnd = i;
-            }
-        }
-
-        var tokens = new List<int>();
-        for (int i = bestStart; i <= bestEnd && i < seqLen; i++)
-        {
-            double maxVal = double.MinValue;
-            int maxIdx = 0;
-            for (int j = 0; j < Math.Min(hiddenDim, _vocabSize); j++)
-            {
-                double val = NumOps.ToDouble(output[i, j]);
-                if (val > maxVal) { maxVal = val; maxIdx = j; }
-            }
-            if (maxIdx > 0) tokens.Add(maxIdx);
-        }
-
-        string answer = DecodeTokensToText(tokens);
-        double confidence = Math.Max(0, Math.Min(1, (bestStartScore + bestEndScore) / 2.0));
-
-        return (string.IsNullOrEmpty(answer) ? "[No answer found]" : answer, confidence);
-    }
-
-    /// <summary>
-    /// Decodes token IDs to text using BERT-style vocabulary.
-    /// </summary>
-    private static string DecodeTokensToText(List<int> tokens)
-    {
-        if (tokens.Count == 0) return string.Empty;
-
-        var sb = new System.Text.StringBuilder();
-        foreach (int token in tokens)
-        {
-            char c = token switch
-            {
-                >= 1000 and <= 1031 => (char)(token - 1000 + 32),
-                >= 1032 and <= 1057 => (char)(token - 1032 + 65),
-                >= 1058 and <= 1083 => (char)(token - 1058 + 97),
-                >= 103 and <= 125 => (char)(token - 103 + 48),
-                >= 126 and <= 151 => (char)(token - 126 + 65),
-                >= 152 and <= 177 => (char)(token - 152 + 97),
-                _ => (char)((token % 95) + 32)
-            };
-            sb.Append(c);
-        }
-
-        return sb.ToString();
-    }
-
-    /// <inheritdoc/>
-    public IEnumerable<DocumentQAResult<T>> AnswerQuestions(Tensor<T> documentImage, IEnumerable<string> questions)
-    {
-        foreach (var q in questions)
-            yield return AnswerQuestion(documentImage, q);
-    }
-
-    /// <inheritdoc/>
-    public Dictionary<string, DocumentQAResult<T>> ExtractFields(Tensor<T> documentImage, IEnumerable<string> fieldPrompts)
-    {
-        var results = new Dictionary<string, DocumentQAResult<T>>();
-        foreach (var field in fieldPrompts)
-            results[field] = AnswerQuestion(documentImage, $"What is the {field}?");
-        return results;
-    }
-
-    #endregion
-
-    #region IDocumentModel Implementation
-
-    /// <inheritdoc/>
-    public Tensor<T> EncodeDocument(Tensor<T> documentImage)
-    {
-        ValidateImageShape(documentImage);
-        var preprocessed = PreprocessDocument(documentImage);
-        return _useNativeMode ? Forward(preprocessed) : RunOnnxInference(preprocessed);
-    }
-
-    /// <inheritdoc/>
-    public void ValidateInputShape(Tensor<T> documentImage)
-    {
-        ValidateImageShape(documentImage);
-    }
-
-    /// <inheritdoc/>
-    public string GetModelSummary()
-    {
-        var sb = new System.Text.StringBuilder();
-        sb.AppendLine("LayoutLMv2 Model Summary");
-        sb.AppendLine("========================");
-        sb.AppendLine($"Mode: {(_useNativeMode ? "Native (Trainable)" : "ONNX (Inference)")}");
-        sb.AppendLine($"Architecture: BERT + ResNeXt-FPN visual backbone");
-        sb.AppendLine($"Hidden Dimension: {_hiddenDim}");
-        sb.AppendLine($"Number of Layers: {_numLayers}");
-        sb.AppendLine($"Attention Heads: {_numHeads}");
-        sb.AppendLine($"Visual Backbone Channels: {_visualBackboneChannels}");
-        sb.AppendLine($"Image Size: {ImageSize}x{ImageSize}");
-        sb.AppendLine($"Max Sequence Length: {MaxSequenceLength}");
-        sb.AppendLine($"Number of Classes: {_numClasses}");
-        sb.AppendLine($"Uses Visual Features: Yes");
-        sb.AppendLine($"Total Layers: {Layers.Count}");
-        return sb.ToString();
-    }
-
-    #endregion
-
-    #region Preprocessing
-
-    /// <summary>
-    /// Applies LayoutLMv2's industry-standard preprocessing: ImageNet normalization.
-    /// </summary>
-    /// <remarks>
-    /// LayoutLMv2 (Microsoft paper) uses ImageNet normalization with mean=[0.485, 0.456, 0.406] and std=[0.229, 0.224, 0.225].
-    /// </remarks>
-    protected override Tensor<T> ApplyDefaultPreprocessing(Tensor<T> rawImage)
-    {
-        var image = EnsureBatchDimension(rawImage);
-        int batchSize = image.Shape[0];
-        int channels = image.Shape[1];
-        int height = image.Shape[2];
-        int width = image.Shape[3];
-
-        var normalized = new Tensor<T>(image._shape);
-        double[] means = [0.485, 0.456, 0.406];
-        double[] stds = [0.229, 0.224, 0.225];
-
-        for (int b = 0; b < batchSize; b++)
-        {
-            for (int c = 0; c < channels; c++)
-            {
-                double mean = c < means.Length ? means[c] : 0.5;
-                double std = c < stds.Length ? stds[c] : 0.5;
-                for (int h = 0; h < height; h++)
-                {
-                    for (int w = 0; w < width; w++)
-                    {
-                        int idx = b * channels * height * width + c * height * width + h * width + w;
-                        normalized.Data.Span[idx] = NumOps.FromDouble((NumOps.ToDouble(image.Data.Span[idx]) - mean) / std);
-                    }
-                }
-            }
-        }
-        return normalized;
-    }
-
-    /// <summary>
-    /// Applies LayoutLMv2's industry-standard postprocessing: pass-through (multimodal outputs are already final).
-    /// </summary>
-    protected override Tensor<T> ApplyDefaultPostprocessing(Tensor<T> modelOutput) => modelOutput;
-
-    #endregion
-
-    #region Serialization
-
-    /// <inheritdoc/>
-    public override ModelMetadata<T> GetModelMetadata()
-    {
-        return new ModelMetadata<T>
-        {
-            Name = "LayoutLMv2",
-            Description = "LayoutLMv2 with text, layout, and visual features (ACL 2021)",
-            FeatureCount = _hiddenDim,
-            Complexity = _numLayers,
-            AdditionalInfo = new Dictionary<string, object>
-            {
-                { "hidden_dim", _hiddenDim },
-                { "num_layers", _numLayers },
-                { "num_heads", _numHeads },
-                { "vocab_size", _vocabSize },
-                { "image_size", ImageSize },
-                { "visual_backbone_channels", _visualBackboneChannels },
-                { "num_classes", _numClasses },
-                { "use_native_mode", _useNativeMode }
-            },
-            ModelData = SafeSerialize()
-        };
-    }
-
-    /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_hiddenDim);
-        writer.Write(_numLayers);
-        writer.Write(_numHeads);
-        writer.Write(_vocabSize);
-        writer.Write(ImageSize);
-        writer.Write(MaxSequenceLength);
-        writer.Write(_visualBackboneChannels);
-        writer.Write(_numClasses);
-        writer.Write(_useNativeMode);
-    }
-
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        int hiddenDim = reader.ReadInt32();
-        int numLayers = reader.ReadInt32();
-        int numHeads = reader.ReadInt32();
-        int vocabSize = reader.ReadInt32();
-        int imageSize = reader.ReadInt32();
-        int maxSeqLen = reader.ReadInt32();
-        int visualChannels = reader.ReadInt32();
-        int numClasses = reader.ReadInt32();
-        bool useNativeMode = reader.ReadBoolean();
-
-        ImageSize = imageSize;
-        MaxSequenceLength = maxSeqLen;
-
-        // Re-link the two-stream forward sublists to the layers the base just deserialized (the forward
-        // reads _visualBackboneLayers/_textEmbeddingLayers/_transformerLayers, not Layers directly).
-        if (Layers.Count > 0)
-            DistributeLayers();
-    }
-
-    /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new LayoutLMv2<T>(Architecture, _tokenizer, _numClasses, ImageSize, MaxSequenceLength,
-            _hiddenDim, _numLayers, _numHeads, _vocabSize, _visualBackboneChannels);
-    }
-
-    #endregion
-
-    #region NeuralNetworkBase Implementation
-
-    /// <inheritdoc/>
-    protected override Tensor<T> PredictCore(Tensor<T> input)
-    {
-        var preprocessed = PreprocessDocument(input);
-        if (!_useNativeMode)
-            return RunOnnxInference(preprocessed);
-
-        // Route through the real two-stream forward (RunMultimodal) instead of the base linear walk,
-        // which would feed the visual conv backbone the text tokens (or vice versa). A single input is
-        // disambiguated by rank: rank <= 2 = token IDs (text-only), rank >= 3 = document image.
-        var (tokens, image) = preprocessed.Rank <= 2 ? (preprocessed, (Tensor<T>?)null) : ((Tensor<T>?)null, preprocessed);
-        return RunMultimodal(tokens, image);
-    }
-
-    /// <inheritdoc/>
-    public override void Train(Tensor<T> input, Tensor<T> expectedOutput)
-    {
-        if (!_useNativeMode)
-            throw new NotSupportedException("Training not supported in ONNX mode.");
-
-        // TrainWithTape runs the full forward (ForwardForTraining -> the two-stream RunMultimodal),
-        // backprop through the autodiff tape, and the optimizer parameter update. The previous code
-        // ALSO ran a manual UpdateParameters(CollectGradients()) afterwards — a redundant second
-        // gradient-descent step whose hand-collected gradient vector didn't match GetParameters'
-        // length (Expected N params, got N+12288), crashing every training step. Use the tape path only.
-        SetTrainingMode(true);
-        try
-        {
-            var gradientOptimizer = _optimizer
-                ?? throw new InvalidOperationException(
-                    "LayoutLMv2 training requires an optimizer implementing " +
-                    "IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>.");
-            TrainWithTape(input, expectedOutput, gradientOptimizer);
-        }
-        finally
-        {
-            SetTrainingMode(false);
-        }
-    }
-
-    // UpdateParameters applied a GRADIENT STEP, but its one-argument form is the value setter and every caller passes values -- the override corrupted the model. Removed under AIDN082.

-
-    /// <summary>
-    /// Parameters cannot be written while the model is backed by a loaded ONNX graph: the weights
-    /// belong to that graph, not to this instance.
-    /// </summary>
-    /// <remarks>
-    /// Replaces a hand-written throw that used to sit inside UpdateParameters. The base checks this
-    /// on every mutating entry point rather than the one member the throw happened to guard, and
-    /// reading -- ParameterCount and GetParameters -- stays available either way.
-    /// </remarks>
+[ResearchPaper("LayoutLMv2: Multi-modal Pre-training for Visually-Rich Document Understanding", "https://doi.org/10.48550/arXiv.2012.14740", Year = 2021, Authors = "Yang Xu, Yiheng Xu, Tengchao Lv, Lei Cui, Furu Wei, Guoxin Wang, Yijuan Lu, Dinei Florencio, Cha Zhang, Wanxiang Che, Min Zhang, Lidong Zhou")]
+public partial class LayoutLMv2<T> : DocumentNeuralNetworkBase<T>, ILayoutDetector<T>, IDocumentQA<T>
+{
+    private readonly LayoutLMv2Options _options;
+
+    /// <inheritdoc/>
+    public override ModelOptions GetOptions() => _options;
+
+    #region Fields
+
+    private readonly bool _useNativeMode;
+    private readonly InferenceSession? _onnxSession;
+    private readonly ITokenizer _tokenizer;
+    private readonly IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>> _optimizer;
+    private readonly int _hiddenDim;
+    private readonly int _numLayers;
+    private readonly int _numHeads;
+    private readonly int _vocabSize;
+    private readonly int _numClasses;
+    private readonly int _visualBackboneChannels;
+
+    // Native mode layers
+    private readonly List<ILayer<T>> _visualBackboneLayers = [];
+    private readonly List<ILayer<T>> _textEmbeddingLayers = [];
+    private readonly List<ILayer<T>> _transformerLayers = [];
+    private readonly List<ILayer<T>> _outputLayers = [];
+
+    // Learnable embeddings
+
+    #endregion
+
+    #region Properties
+
+    /// <inheritdoc/>
+    public override DocumentType SupportedDocumentTypes => DocumentType.All;
+
+    /// <inheritdoc/>
+    public override bool RequiresOCR => true;
+
+    /// <inheritdoc/>
+    public int ExpectedImageSize => ImageSize;
+
+    /// <inheritdoc/>
+    public IReadOnlyList<LayoutElementType> SupportedElementTypes { get; } =
+    [
+        LayoutElementType.Text,
+        LayoutElementType.Title,
+        LayoutElementType.List,
+        LayoutElementType.Table,
+        LayoutElementType.Figure,
+        LayoutElementType.Caption,
+        LayoutElementType.Header,
+        LayoutElementType.Footer,
+        LayoutElementType.FormField
+    ];
+
+    #endregion
+
+    #region Constructors
+
+    /// <summary>
+    /// Creates a LayoutLMv2 model using a pre-trained ONNX model for inference.
+    /// </summary>
+    /// <param name="architecture">The neural network architecture.</param>
+    /// <param name="onnxModelPath">Path to the ONNX model file.</param>
+    /// <param name="tokenizer">Tokenizer for text processing.</param>
+    /// <param name="numClasses">Number of output classes (default: 7).</param>
+    /// <param name="imageSize">Input image size (default: 224).</param>
+    /// <param name="maxSequenceLength">Maximum sequence length (default: 512).</param>
+    /// <param name="hiddenDim">Hidden dimension (default: 768).</param>
+    /// <param name="numLayers">Number of transformer layers (default: 12).</param>
+    /// <param name="numHeads">Number of attention heads (default: 12).</param>
+    /// <param name="vocabSize">Vocabulary size (default: 30522).</param>
+    /// <param name="visualBackboneChannels">Visual backbone output channels (default: 256).</param>
+    /// <param name="optimizer">Optimizer for training (optional).</param>
+    /// <param name="lossFunction">Loss function (optional).</param>
+    public LayoutLMv2(
+        NeuralNetworkArchitecture<T> architecture,
+        string onnxModelPath,
+        ITokenizer tokenizer,
+        int numClasses = 7,
+        int imageSize = 224,
+        int maxSequenceLength = 512,
+        int hiddenDim = 768,
+        int numLayers = 12,
+        int numHeads = 12,
+        int vocabSize = 30522,
+        int visualBackboneChannels = 256,
+        IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? optimizer = null,
+        ILossFunction<T>? lossFunction = null,
+        LayoutLMv2Options? options = null)
+        : base(architecture, lossFunction ?? new CrossEntropyWithLogitsLoss<T>(), 1.0)
+    {
+        _options = options ?? new LayoutLMv2Options();
+        Options = _options;
+
+        if (string.IsNullOrWhiteSpace(onnxModelPath))
+            throw new ArgumentNullException(nameof(onnxModelPath));
+        if (!File.Exists(onnxModelPath))
+            throw new FileNotFoundException($"ONNX model not found: {onnxModelPath}", onnxModelPath);
+
+        Guard.NotNull(tokenizer);
+        _tokenizer = tokenizer;
+        _useNativeMode = false;
+        _numClasses = numClasses;
+        _hiddenDim = hiddenDim;
+        _numLayers = numLayers;
+        _numHeads = numHeads;
+        _vocabSize = vocabSize;
+        _visualBackboneChannels = visualBackboneChannels;
+        _optimizer = optimizer ?? CreatePaperDefaultOptimizer();
+
+        ImageSize = imageSize;
+        MaxSequenceLength = maxSequenceLength;
+
+        _onnxSession = new InferenceSession(onnxModelPath);
+
+        InitializeLayers();
+    }
+
+    /// <summary>
+    /// Creates a LayoutLMv2 model using native layers for training and inference.
+    /// </summary>
+    /// <param name="architecture">The neural network architecture.</param>
+    /// <param name="tokenizer">Tokenizer for text processing (optional).</param>
+    /// <param name="numClasses">Number of output classes (default: 7).</param>
+    /// <param name="imageSize">Input image size (default: 224).</param>
+    /// <param name="maxSequenceLength">Maximum sequence length (default: 512).</param>
+    /// <param name="hiddenDim">Hidden dimension (default: 768).</param>
+    /// <param name="numLayers">Number of transformer layers (default: 12).</param>
+    /// <param name="numHeads">Number of attention heads (default: 12).</param>
+    /// <param name="vocabSize">Vocabulary size (default: 30522).</param>
+    /// <param name="visualBackboneChannels">Visual backbone output channels (default: 256).</param>
+    /// <param name="optimizer">Optimizer for training (optional).</param>
+    /// <param name="lossFunction">Loss function (optional).</param>
+    /// <remarks>
+    /// <para>
+    /// <b>Default Configuration (LayoutLMv2-Base from ACL 2021):</b>
+    /// - Text encoder: BERT-base architecture
+    /// - Visual backbone: ResNeXt-101 FPN
+    /// - Hidden dimension: 768
+    /// - Layers: 12, Heads: 12
+    /// - Image size: 224×224
+    /// </para>
+    /// </remarks>
+    public LayoutLMv2(
+        NeuralNetworkArchitecture<T> architecture,
+        ITokenizer? tokenizer = null,
+        int numClasses = 7,
+        int imageSize = 224,
+        int maxSequenceLength = 512,
+        int hiddenDim = 768,
+        int numLayers = 12,
+        int numHeads = 12,
+        int vocabSize = 30522,
+        int visualBackboneChannels = 256,
+        IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? optimizer = null,
+        ILossFunction<T>? lossFunction = null,
+        LayoutLMv2Options? options = null)
+        : base(architecture, lossFunction ?? new CrossEntropyWithLogitsLoss<T>(), 1.0)
+    {
+        _options = options ?? new LayoutLMv2Options();
+        Options = _options;
+
+        _useNativeMode = true;
+        _numClasses = numClasses;
+        _hiddenDim = hiddenDim;
+        _numLayers = numLayers;
+        _numHeads = numHeads;
+        _vocabSize = vocabSize;
+        _visualBackboneChannels = visualBackboneChannels;
+        _optimizer = optimizer ?? CreatePaperDefaultOptimizer();
+
+        ImageSize = imageSize;
+        MaxSequenceLength = maxSequenceLength;
+
+        _tokenizer = tokenizer ?? LanguageModelTokenizerFactory.CreateForBackbone(LanguageModelBackbone.OPT);
+
+        InitializeLayers();
+        InitializeEmbeddings();
+    }
+
+    #endregion
+
+    private IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>> CreatePaperDefaultOptimizer()
+    {
+        // LayoutLMv2 Appendix B: Adam with lr=2e-5, weight decay=1e-2,
+        // and (beta1,beta2)=(0.9,0.999). AdamW expresses the cited decoupled
+        // weight-decay formulation while keeping every value user-overridable
+        // through the constructor's optimizer parameter.
+        var options = new AiDotNet.Models.Options.AdamWOptimizerOptions<T, Tensor<T>, Tensor<T>>
+        {
+            InitialLearningRate = _options.LearningRate,
+            WeightDecay = _options.WeightDecay,
+            Beta1 = 0.9,
+            Beta2 = 0.999,
+            Epsilon = 1e-8,
+            UseAMSGrad = false,
+            UseAdaptiveLearningRate = false
+        };
+        return new AdamWOptimizer<T, Tensor<T>, Tensor<T>>(this, options);
+    }
+
+    #region Initialization
+
+    /// <inheritdoc/>
+    protected override void InitializeLayers()
+    {
+        if (!_useNativeMode)
+        {
+            return;
+        }
+
+        if (Architecture.Layers is not null && Architecture.Layers.Count > 0)
+        {
+            Layers.AddRange(Architecture.Layers);
+            ValidateCustomLayers(Layers);
+            return;
+        }
+
+        Layers.AddRange(LayerHelper<T>.CreateDefaultLayoutLMv2Layers(
+            hiddenDim: _hiddenDim,
+            numLayers: _numLayers,
+            numHeads: _numHeads,
+            vocabSize: _vocabSize,
+            imageSize: ImageSize,
+            visualBackboneChannels: _visualBackboneChannels,
+            numClasses: _numClasses));
+
+        DistributeLayers();
+    }
+
+    // CreateDefaultLayoutLMv2Layers emits the layers in three role groups, in this order:
+    //   [0 .. VisualBackboneLayerCount)                        = ResNeXt-FPN visual backbone
+    //                                                            (conv/BN/pool stack + a final C->hidden projection Dense),
+    //   [.. + TextEmbeddingLayerCount)                          = word-embedding / position / layernorm / dropout,
+    //   [rest]                                                  = multimodal transformer encoder + classification head.
+    private const int VisualBackboneLayerCount = 12;
+
+    // Three, not four: the token EmbeddingLayer and the sinusoidal PositionalEncodingLayer that
+    // used to open this section are now a single LayoutEmbeddingLayer, which also carries the 2D
+    // layout terms. The LayerNorm and Dropout after them are unchanged.
+    private const int TextEmbeddingLayerCount = 3;
+
+    // Re-links the per-role forward-path sublists to the CURRENT Layers. The two-stream forward reads
+    // these lists, not Layers directly, so they must be rebuilt whenever Layers is replaced — including
+    // after deserialization (the base clears Layers and adds freshly-deserialized layers).
+    private void DistributeLayers()
+    {
+        _visualBackboneLayers.Clear();
+        _textEmbeddingLayers.Clear();
+        _transformerLayers.Clear();
+        // Fail loudly if the factory's emission order/count drifts below the hardcoded split, rather
+        // than silently misclassifying layers into the wrong role list (which would corrupt fusion).
+        if (Layers.Count < VisualBackboneLayerCount + TextEmbeddingLayerCount)
+            throw new InvalidOperationException(
+                $"LayoutLMv2 expects at least {VisualBackboneLayerCount + TextEmbeddingLayerCount} layers " +
+                $"({VisualBackboneLayerCount} visual + {TextEmbeddingLayerCount} text embedding) before the " +
+                $"transformer stack, but only {Layers.Count} were present. The CreateDefaultLayoutLMv2Layers " +
+                "emission order/count must stay in sync with these role-split constants.");
+        for (int i = 0; i < Layers.Count; i++)
+        {
+            if (i < VisualBackboneLayerCount)
+                _visualBackboneLayers.Add(Layers[i]);
+            else if (i < VisualBackboneLayerCount + TextEmbeddingLayerCount)
+                _textEmbeddingLayers.Add(Layers[i]);
+            else
+                _transformerLayers.Add(Layers[i]);
+        }
+    }
+
+    /// <summary>
+    /// Runs LayoutLMv2's real two-stream forward and fuses whatever modalities are present.
+    /// </summary>
+    /// <remarks>
+    /// Reference LayoutLMv2 (Xu et al. 2021) REQUIRES both a document image AND text tokens and crashes
+    /// otherwise. This implementation is modality-robust: it runs the visual backbone and/or the text
+    /// embedding stream depending on which inputs are supplied, concatenates the resulting token
+    /// sequences, and runs the shared multimodal transformer + head — so it also handles OCR-text-only
+    /// or image-only documents (graceful degradation), which the reference model cannot.
+    /// </remarks>
+    private Tensor<T> RunMultimodal(Tensor<T>? textTokens, Tensor<T>? documentImage)
+    {
+        Tensor<T>? textSeq = textTokens is not null ? RunTextStream(textTokens) : null;
+        Tensor<T>? visualSeq = documentImage is not null ? RunVisualStream(documentImage) : null;
+
+        Tensor<T> seq;
+        if (textSeq is not null && visualSeq is not null)
+        {
+            // Fuse the way LayoutLMv2 (Xu et al. 2021, §3.1) does: stack the visual and text token
+            // sequences along the SEQUENCE axis (visual first, then text) into one joint sequence for
+            // the shared multimodal transformer. Normalize both streams to a batched [B, L, D] first —
+            // the visual backbone emits [B, Lvis, D] while the text stream can emit an unbatched
+            // [Ltext, D] (and a continuous-valued token tensor projects to [1, D]) — so the
+            // concatenation matches on batch and hidden and only grows the sequence axis. The prior
+            // axis-(Rank-2) concat on unequal-rank streams was invalid and only appeared to work when
+            // the output buffer's unwritten tail happened to be zero.
+            var vis = AlignToBatchedSequence(visualSeq);
+            var txt = AlignToBatchedSequence(textSeq);
+            seq = Engine.TensorConcatenate([vis, txt], axis: 1);
+        }
+        else
+        {
+            seq = textSeq ?? visualSeq
+                ?? throw new ArgumentException(
+                    "LayoutLMv2 requires at least one modality: text token IDs (rank <= 2) or a document image (rank >= 3).");
+        }
+
+        foreach (var layer in _transformerLayers)
+            seq = layer.Forward(seq);
+        return seq;
+    }
+
+    // Normalizes a token sequence to a batched [B, L, D] layout so the two fusion streams concatenate
+    // cleanly on the sequence axis. A [L, D] stream (unbatched, e.g. the text embedding on a rank-1
+    // token vector) gains a leading batch of 1; a continuous [1, D] projection becomes a single-token
+    // [1, 1, D]; an already-batched [B, L, D] passes through unchanged.
+    private Tensor<T> AlignToBatchedSequence(Tensor<T> t)
+    {
+        if (t.Rank == 3) return t;
+        if (t.Rank == 2) return Engine.Reshape(t, new[] { 1, t.Shape[0], t.Shape[1] });
+        throw new ArgumentException($"Fusion stream must be rank 2 or 3, got rank {t.Rank}.");
+    }
+
+    // Text stream: token IDs -> word embedding -> position -> layernorm -> dropout => [seq, hidden].
+    private Tensor<T> RunTextStream(Tensor<T> textTokens)
+    {
+        var x = textTokens;
+        foreach (var layer in _textEmbeddingLayers)
+            x = layer.Forward(x);
+        return x;
+    }
+
+    // Visual stream: image -> conv/BN/pool backbone -> flatten spatial grid to a token sequence ->
+    // channel projection => [numPatches, hidden]. The final backbone layer is the C->hidden projection,
+    // applied AFTER the spatial->token reshape so it maps channels (not width) to the hidden dim.
+    private Tensor<T> RunVisualStream(Tensor<T> documentImage)
+    {
+        var x = documentImage;
+        int projIndex = _visualBackboneLayers.Count - 1;
+        for (int i = 0; i < projIndex; i++)
+            x = _visualBackboneLayers[i].Forward(x);
+
+        x = FlattenSpatialToTokens(x);
+        if (projIndex >= 0 && projIndex < _visualBackboneLayers.Count)
+            x = _visualBackboneLayers[projIndex].Forward(x);
+        return x;
+    }
+
+    // [C, H, W] -> [H*W, C]; [B, C, H, W] -> [B, H*W, C]. Puts channels last so each spatial location
+    // becomes a token whose feature vector the projection Dense maps to the hidden dim.
+    private Tensor<T> FlattenSpatialToTokens(Tensor<T> feat)
+    {
+        if (feat.Rank == 4)
+        {
+            int b = feat.Shape[0], c = feat.Shape[1], n = feat.Shape[2] * feat.Shape[3];
+            return Engine.TensorPermute(Engine.Reshape(feat, new[] { b, c, n }), new[] { 0, 2, 1 });
+        }
+        if (feat.Rank == 3)
+        {
+            int c = feat.Shape[0], n = feat.Shape[1] * feat.Shape[2];
+            return Engine.TensorPermute(Engine.Reshape(feat, new[] { c, n }), new[] { 1, 0 });
+        }
+        return feat;
+    }
+
+    /// <summary>
+    /// Full text+image fusion entry (industry-standard LayoutLMv2): encodes BOTH a token-ID sequence
+    /// and a document image and fuses them through the multimodal transformer.
+    /// </summary>
+    public Tensor<T> EncodeMultimodal(Tensor<T> textTokens, Tensor<T> documentImage)
+    {
+        // Inference entry: mirror Predict()/PredictCore by suppressing gradient-tape recording
+        // (PyTorch torch.no_grad() semantics). RunMultimodal issues raw Engine.Reshape/Permute/
+        // Concatenate ops that would otherwise record onto the shared autodiff tape; if a prior
+        // training pass left that singleton tape non-empty, replaying it here poisons the fusion
+        // forward with stale/NaN buffers. NoGradScope makes this direct call as tape-clean as
+        // the Predict()-wrapped image-only path. ForwardForTraining keeps recording (no scope).
+        using var _ = new AiDotNet.Tensors.Engines.Autodiff.NoGradScope<T>();
+        var image = PreprocessDocument(documentImage);
+        return RunMultimodal(textTokens, image);
+    }
+
+    /// <inheritdoc/>
+    public override Tensor<T> ForwardForTraining(Tensor<T> input)
+    {
+        var prepared = PreprocessDocument(input);
+        var (tokens, image) = prepared.Rank <= 2 ? (prepared, (Tensor<T>?)null) : ((Tensor<T>?)null, prepared);
+        return RunMultimodal(tokens, image);
+    }
+
+    /// <inheritdoc/>
+    public override Dictionary<string, Tensor<T>> GetNamedLayerActivations(Tensor<T> input)
+    {
+        // The base walks Layers linearly feeding the raw input, which crashes the visual conv backbone
+        // on a token-only input (rank-1). Replay the real two-stream forward, capturing each layer.
+        var activations = new Dictionary<string, Tensor<T>>();
+        if (!_useNativeMode)
+            return activations;
+
+        var prepared = PreprocessDocument(input);
+        var (tokens, image) = prepared.Rank <= 2 ? (prepared, (Tensor<T>?)null) : ((Tensor<T>?)null, prepared);
+
+        int idx = 0;
+        Tensor<T>? textSeq = null, visualSeq = null;
+
+        if (tokens is not null)
+        {
+            var x = tokens;
+            foreach (var layer in _textEmbeddingLayers)
+            {
+                x = layer.Forward(x);
+                activations[$"Layer_{idx++}_{layer.GetType().Name}"] = x.Clone();
+            }
+            textSeq = x;
+        }
+
+        if (image is not null)
+        {
+            var x = image;
+            int projIndex = _visualBackboneLayers.Count - 1;
+            for (int i = 0; i < projIndex; i++)
+            {
+                x = _visualBackboneLayers[i].Forward(x);
+                activations[$"Layer_{idx++}_{_visualBackboneLayers[i].GetType().Name}"] = x.Clone();
+            }
+            x = FlattenSpatialToTokens(x);
+            if (projIndex >= 0 && projIndex < _visualBackboneLayers.Count)
+            {
+                x = _visualBackboneLayers[projIndex].Forward(x);
+                activations[$"Layer_{idx++}_{_visualBackboneLayers[projIndex].GetType().Name}"] = x.Clone();
+            }
+            visualSeq = x;
+        }
+
+        Tensor<T> seq;
+        if (textSeq is not null && visualSeq is not null)
+            // Same sequence-axis fusion as RunMultimodal: normalize both streams to [B, L, D] and
+            // concatenate along the sequence axis (concatenating on axis 0 with unequal-rank streams
+            // grows the batch dimension and leaves an uninitialized output tail).
+            seq = Engine.TensorConcatenate(
+                [AlignToBatchedSequence(visualSeq), AlignToBatchedSequence(textSeq)], axis: 1);
+        else
+            seq = textSeq ?? visualSeq ?? new Tensor<T>(new[] { 1, _hiddenDim });
+
+        foreach (var layer in _transformerLayers)
+        {
+            seq = layer.Forward(seq);
+            activations[$"Layer_{idx++}_{layer.GetType().Name}"] = seq.Clone();
+        }
+        return activations;
+    }
+
+    private void InitializeEmbeddings()
+    {
+        var random = RandomHelper.CreateSeededRandom(42);
+
+
+    }
+
+    private void InitializeWithSmallRandomValues(Tensor<T> tensor, Random random, double stdDev)
+    {
+        for (int i = 0; i < tensor.Data.Length; i++)
+        {
+            double u1 = 1.0 - random.NextDouble();
+            double u2 = 1.0 - random.NextDouble();
+            double randStdNormal = Math.Sqrt(-2.0 * Math.Log(u1)) * Math.Sin(2.0 * Math.PI * u2);
+            tensor.Data.Span[i] = NumOps.FromDouble(randStdNormal * stdDev);
+        }
+    }
+
+    #endregion
+
+    #region ILayoutDetector Implementation
+
+    /// <inheritdoc/>
+    public DocumentLayoutResult<T> DetectLayout(Tensor<T> documentImage)
+    {
+        return DetectLayout(documentImage, 0.5);
+    }
+
+    /// <inheritdoc/>
+    public DocumentLayoutResult<T> DetectLayout(Tensor<T> documentImage, double confidenceThreshold)
+    {
+        ValidateImageShape(documentImage);
+        var startTime = DateTime.UtcNow;
+
+        var preprocessed = PreprocessDocument(documentImage);
+        var output = _useNativeMode ? Forward(preprocessed) : RunOnnxInference(preprocessed);
+
+        var regions = ParseLayoutOutput(output, confidenceThreshold);
+
+        return new DocumentLayoutResult<T>
+        {
+            Regions = regions,
+            ProcessingTimeMs = (DateTime.UtcNow - startTime).TotalMilliseconds
+        };
+    }
+
+    private List<LayoutRegion<T>> ParseLayoutOutput(Tensor<T> output, double threshold)
+    {
+        var regions = new List<LayoutRegion<T>>();
+        int numDetections = output.Shape[0];
+        int numClasses = output.Shape.Length > 1 ? output.Shape[1] : _numClasses;
+
+        for (int i = 0; i < numDetections; i++)
+        {
+            double maxConf = 0;
+            int maxClass = 0;
+            for (int c = 0; c < numClasses; c++)
+            {
+                double conf = NumOps.ToDouble(output[i, c]);
+                if (conf > maxConf) { maxConf = conf; maxClass = c; }
+            }
+
+            if (maxConf >= threshold && maxClass > 0)
+            {
+                regions.Add(new LayoutRegion<T>
+                {
+                    ElementType = (LayoutElementType)Math.Min(maxClass, (int)LayoutElementType.Other),
+                    Confidence = NumOps.FromDouble(maxConf),
+                    ConfidenceValue = maxConf,
+                    Index = i,
+                    BoundingBox = Vector<T>.Empty()
+                });
+            }
+        }
+
+        return regions;
+    }
+
+    #endregion
+
+    #region IDocumentQA Implementation
+
+    /// <inheritdoc/>
+    public DocumentQAResult<T> AnswerQuestion(Tensor<T> documentImage, string question)
+    {
+        return AnswerQuestion(documentImage, question, 64, 0.0);
+    }
+
+    /// <inheritdoc/>
+    public DocumentQAResult<T> AnswerQuestion(Tensor<T> documentImage, string question, int maxAnswerLength, double temperature = 0.0)
+    {
+        ValidateImageShape(documentImage);
+        var startTime = DateTime.UtcNow;
+
+        var preprocessed = PreprocessDocument(documentImage);
+        var output = _useNativeMode ? Forward(preprocessed) : RunOnnxInference(preprocessed);
+
+        var (answer, confidence) = ExtractAnswer(output, maxAnswerLength);
+
+        return new DocumentQAResult<T>
+        {
+            Answer = answer,
+            Confidence = NumOps.FromDouble(confidence),
+            ConfidenceValue = confidence,
+            Question = question,
+            ProcessingTimeMs = (DateTime.UtcNow - startTime).TotalMilliseconds
+        };
+    }
+
+    /// <summary>
+    /// Extracts answer from model output using extractive QA approach.
+    /// </summary>
+    private (string answer, double confidence) ExtractAnswer(Tensor<T> output, int maxAnswerLength)
+    {
+        int seqLen = output.Shape[0];
+        int hiddenDim = output.Shape.Length > 1 ? output.Shape[1] : _hiddenDim;
+
+        double bestStartScore = double.MinValue;
+        double bestEndScore = double.MinValue;
+        int bestStart = 0;
+        int bestEnd = 0;
+
+        for (int i = 0; i < seqLen; i++)
+        {
+            double startScore = NumOps.ToDouble(output[i, 0]);
+            if (startScore > bestStartScore)
+            {
+                bestStartScore = startScore;
+                bestStart = i;
+            }
+        }
+
+        int endSearchLimit = Math.Min(seqLen, bestStart + maxAnswerLength);
+        for (int i = bestStart; i < endSearchLimit; i++)
+        {
+            double endScore = NumOps.ToDouble(output[i, Math.Min(1, hiddenDim - 1)]);
+            if (endScore > bestEndScore)
+            {
+                bestEndScore = endScore;
+                bestEnd = i;
+            }
+        }
+
+        var tokens = new List<int>();
+        for (int i = bestStart; i <= bestEnd && i < seqLen; i++)
+        {
+            double maxVal = double.MinValue;
+            int maxIdx = 0;
+            for (int j = 0; j < Math.Min(hiddenDim, _vocabSize); j++)
+            {
+                double val = NumOps.ToDouble(output[i, j]);
+                if (val > maxVal) { maxVal = val; maxIdx = j; }
+            }
+            if (maxIdx > 0) tokens.Add(maxIdx);
+        }
+
+        string answer = DecodeTokensToText(tokens);
+        double confidence = Math.Max(0, Math.Min(1, (bestStartScore + bestEndScore) / 2.0));
+
+        return (string.IsNullOrEmpty(answer) ? "[No answer found]" : answer, confidence);
+    }
+
+    /// <summary>
+    /// Decodes token IDs to text using BERT-style vocabulary.
+    /// </summary>
+    private static string DecodeTokensToText(List<int> tokens)
+    {
+        if (tokens.Count == 0) return string.Empty;
+
+        var sb = new System.Text.StringBuilder();
+        foreach (int token in tokens)
+        {
+            char c = token switch
+            {
+                >= 1000 and <= 1031 => (char)(token - 1000 + 32),
+                >= 1032 and <= 1057 => (char)(token - 1032 + 65),
+                >= 1058 and <= 1083 => (char)(token - 1058 + 97),
+                >= 103 and <= 125 => (char)(token - 103 + 48),
+                >= 126 and <= 151 => (char)(token - 126 + 65),
+                >= 152 and <= 177 => (char)(token - 152 + 97),
+                _ => (char)((token % 95) + 32)
+            };
+            sb.Append(c);
+        }
+
+        return sb.ToString();
+    }
+
+    /// <inheritdoc/>
+    public IEnumerable<DocumentQAResult<T>> AnswerQuestions(Tensor<T> documentImage, IEnumerable<string> questions)
+    {
+        foreach (var q in questions)
+            yield return AnswerQuestion(documentImage, q);
+    }
+
+    /// <inheritdoc/>
+    public Dictionary<string, DocumentQAResult<T>> ExtractFields(Tensor<T> documentImage, IEnumerable<string> fieldPrompts)
+    {
+        var results = new Dictionary<string, DocumentQAResult<T>>();
+        foreach (var field in fieldPrompts)
+            results[field] = AnswerQuestion(documentImage, $"What is the {field}?");
+        return results;
+    }
+
+    #endregion
+
+    #region IDocumentModel Implementation
+
+    /// <inheritdoc/>
+    public Tensor<T> EncodeDocument(Tensor<T> documentImage)
+    {
+        ValidateImageShape(documentImage);
+        var preprocessed = PreprocessDocument(documentImage);
+        return _useNativeMode ? Forward(preprocessed) : RunOnnxInference(preprocessed);
+    }
+
+    /// <inheritdoc/>
+    public void ValidateInputShape(Tensor<T> documentImage)
+    {
+        ValidateImageShape(documentImage);
+    }
+
+    /// <inheritdoc/>
+    public string GetModelSummary()
+    {
+        var sb = new System.Text.StringBuilder();
+        sb.AppendLine("LayoutLMv2 Model Summary");
+        sb.AppendLine("========================");
+        sb.AppendLine($"Mode: {(_useNativeMode ? "Native (Trainable)" : "ONNX (Inference)")}");
+        sb.AppendLine($"Architecture: BERT + ResNeXt-FPN visual backbone");
+        sb.AppendLine($"Hidden Dimension: {_hiddenDim}");
+        sb.AppendLine($"Number of Layers: {_numLayers}");
+        sb.AppendLine($"Attention Heads: {_numHeads}");
+        sb.AppendLine($"Visual Backbone Channels: {_visualBackboneChannels}");
+        sb.AppendLine($"Image Size: {ImageSize}x{ImageSize}");
+        sb.AppendLine($"Max Sequence Length: {MaxSequenceLength}");
+        sb.AppendLine($"Number of Classes: {_numClasses}");
+        sb.AppendLine($"Uses Visual Features: Yes");
+        sb.AppendLine($"Total Layers: {Layers.Count}");
+        return sb.ToString();
+    }
+
+    #endregion
+
+    #region Preprocessing
+
+    /// <summary>
+    /// Applies LayoutLMv2's industry-standard preprocessing: ImageNet normalization.
+    /// </summary>
+    /// <remarks>
+    /// LayoutLMv2 (Microsoft paper) uses ImageNet normalization with mean=[0.485, 0.456, 0.406] and std=[0.229, 0.224, 0.225].
+    /// </remarks>
+    protected override Tensor<T> ApplyDefaultPreprocessing(Tensor<T> rawImage)
+    {
+        var image = EnsureBatchDimension(rawImage);
+        int batchSize = image.Shape[0];
+        int channels = image.Shape[1];
+        int height = image.Shape[2];
+        int width = image.Shape[3];
+
+        var normalized = new Tensor<T>(image._shape);
+        double[] means = [0.485, 0.456, 0.406];
+        double[] stds = [0.229, 0.224, 0.225];
+
+        for (int b = 0; b < batchSize; b++)
+        {
+            for (int c = 0; c < channels; c++)
+            {
+                double mean = c < means.Length ? means[c] : 0.5;
+                double std = c < stds.Length ? stds[c] : 0.5;
+                for (int h = 0; h < height; h++)
+                {
+                    for (int w = 0; w < width; w++)
+                    {
+                        int idx = b * channels * height * width + c * height * width + h * width + w;
+                        normalized.Data.Span[idx] = NumOps.FromDouble((NumOps.ToDouble(image.Data.Span[idx]) - mean) / std);
+                    }
+                }
+            }
+        }
+        return normalized;
+    }
+
+    /// <summary>
+    /// Applies LayoutLMv2's industry-standard postprocessing: pass-through (multimodal outputs are already final).
+    /// </summary>
+    protected override Tensor<T> ApplyDefaultPostprocessing(Tensor<T> modelOutput) => modelOutput;
+
+    #endregion
+
+    #region Serialization
+
+    /// <inheritdoc/>
+    public override ModelMetadata<T> GetModelMetadata()
+    {
+        return new ModelMetadata<T>
+        {
+            Name = "LayoutLMv2",
+            Description = "LayoutLMv2 with text, layout, and visual features (ACL 2021)",
+            FeatureCount = _hiddenDim,
+            Complexity = _numLayers,
+            AdditionalInfo = new Dictionary<string, object>
+            {
+                { "hidden_dim", _hiddenDim },
+                { "num_layers", _numLayers },
+                { "num_heads", _numHeads },
+                { "vocab_size", _vocabSize },
+                { "image_size", ImageSize },
+                { "visual_backbone_channels", _visualBackboneChannels },
+                { "num_classes", _numClasses },
+                { "use_native_mode", _useNativeMode }
+            },
+            ModelData = SafeSerialize()
+        };
+    }
+
+    /// <inheritdoc/>
+
+
+    /// <inheritdoc/>
+
+
+    #endregion
+
+    #region NeuralNetworkBase Implementation
+
+    /// <inheritdoc/>
+    protected override Tensor<T> PredictCore(Tensor<T> input)
+    {
+        var preprocessed = PreprocessDocument(input);
+        if (!_useNativeMode)
+            return RunOnnxInference(preprocessed);
+
+        // Route through the real two-stream forward (RunMultimodal) instead of the base linear walk,
+        // which would feed the visual conv backbone the text tokens (or vice versa). A single input is
+        // disambiguated by rank: rank <= 2 = token IDs (text-only), rank >= 3 = document image.
+        var (tokens, image) = preprocessed.Rank <= 2 ? (preprocessed, (Tensor<T>?)null) : ((Tensor<T>?)null, preprocessed);
+        return RunMultimodal(tokens, image);
+    }
+
+    /// <inheritdoc/>
+    public override void Train(Tensor<T> input, Tensor<T> expectedOutput)
+    {
+        if (!_useNativeMode)
+            throw new NotSupportedException("Training not supported in ONNX mode.");
+
+        // TrainWithTape runs the full forward (ForwardForTraining -> the two-stream RunMultimodal),
+        // backprop through the autodiff tape, and the optimizer parameter update. The previous code
+        // ALSO ran a manual UpdateParameters(CollectGradients()) afterwards — a redundant second
+        // gradient-descent step whose hand-collected gradient vector didn't match GetParameters'
+        // length (Expected N params, got N+12288), crashing every training step. Use the tape path only.
+        SetTrainingMode(true);
+        try
+        {
+            var gradientOptimizer = _optimizer
+                ?? throw new InvalidOperationException(
+                    "LayoutLMv2 training requires an optimizer implementing " +
+                    "IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>.");
+            TrainWithTape(input, expectedOutput, gradientOptimizer);
+        }
+        finally
+        {
+            SetTrainingMode(false);
+        }
+    }
+
+    // UpdateParameters applied a GRADIENT STEP, but its one-argument form is the value setter and every caller passes values -- the override corrupted the model. Removed under AIDN082.
+
+
+    /// <summary>
+    /// Parameters cannot be written while the model is backed by a loaded ONNX graph: the weights
+    /// belong to that graph, not to this instance.
+    /// </summary>
+    /// <remarks>
+    /// Replaces a hand-written throw that used to sit inside UpdateParameters. The base checks this
+    /// on every mutating entry point rather than the one member the throw happened to guard, and
+    /// reading -- ParameterCount and GetParameters -- stays available either way.
+    /// </remarks>
     protected override bool SupportsParameterMutation => _useNativeMode;
-    #endregion
-
-    #region Disposal
-
-    /// <inheritdoc/>
-    protected override void Dispose(bool disposing)
-    {
-        if (disposing)
-            _onnxSession?.Dispose();
-        base.Dispose(disposing);
-    }
-
-    #endregion
-}
+    #endregion
+
+    #region Disposal
+
+    /// <inheritdoc/>
+    protected override void Dispose(bool disposing)
+    {
+        if (disposing)
+            _onnxSession?.Dispose();
+        base.Dispose(disposing);
+    }
+
+    #endregion
+}
diff --git a/src/Document/LayoutAware/LayoutLMv3.cs b/src/Document/LayoutAware/LayoutLMv3.cs
index 3c9cc52ef9..3c155323fd 100644
--- a/src/Document/LayoutAware/LayoutLMv3.cs
+++ b/src/Document/LayoutAware/LayoutLMv3.cs
@@ -1,1315 +1,1255 @@
-using AiDotNet.ActivationFunctions;
-using AiDotNet.Document.Interfaces;
-using AiDotNet.Document.Options;
-using AiDotNet.Attributes;
-using AiDotNet.Enums;
-using AiDotNet.Helpers;
-using AiDotNet.Interfaces;
-using AiDotNet.LinearAlgebra;
-using AiDotNet.LossFunctions;
-using AiDotNet.NeuralNetworks;
-using AiDotNet.NeuralNetworks.Layers;
-using AiDotNet.Onnx;
-using AiDotNet.Optimizers;
-using AiDotNet.Tokenization;
-using AiDotNet.Tokenization.Interfaces;
-using Microsoft.ML.OnnxRuntime;
-using AiDotNet.Validation;
-using OnnxTensors = Microsoft.ML.OnnxRuntime.Tensors;
-
-namespace AiDotNet.Document.LayoutAware;
-
-/// <summary>
-/// LayoutLMv3 neural network for document understanding with unified text and image pre-training.
-/// </summary>
-/// <typeparam name="T">The numeric type used for calculations.</typeparam>
-/// <remarks>
-/// <para>
-/// LayoutLMv3 is the third generation of the LayoutLM series from Microsoft Research,
-/// featuring unified multimodal pre-training with masked image modeling and masked language
-/// modeling on the same architecture.
-/// </para>
-/// <para>
-/// <b>For Beginners:</b> LayoutLMv3 understands documents by learning from:
-/// 1. The text content (what the words say)
-/// 2. The visual appearance (what the document looks like)
-/// 3. The layout structure (where elements are positioned)
-///
-/// This makes it excellent for:
-/// - Extracting information from forms and receipts
-/// - Understanding document structure
-/// - Answering questions about document content
-/// - Classifying document types
-///
-/// Example usage (ONNX mode - for inference with pre-trained models):
-/// <code>
-/// var model = new LayoutLMv3&lt;float&gt;(architecture, "model.onnx", tokenizer);
-/// var layout = model.DetectLayout(documentImage);
-/// </code>
-///
-/// Example usage (Native mode - for training):
-/// <code>
-/// var model = new LayoutLMv3&lt;float&gt;(architecture);
-/// model.Train(trainingData, labels);
-/// </code>
-/// </para>
-/// <para>
-/// <b>Reference:</b> "LayoutLMv3: Pre-training for Document AI with Unified Text and Image Masking"
-/// https://arxiv.org/abs/2204.08387
-/// </para>
-/// </remarks>
-[ModelDomain(ModelDomain.Vision)]
-[ModelDomain(ModelDomain.Language)]
-[ModelCategory(ModelCategory.NeuralNetwork)]
-[ModelCategory(ModelCategory.Transformer)]
-[ModelTask(ModelTask.Classification)]
-[ModelTask(ModelTask.Detection)]
-[ModelComplexity(ModelComplexity.High)]
-[ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
-[ResearchPaper("LayoutLMv3: Pre-training for Document AI with Unified Text and Image Masking", "https://doi.org/10.48550/arXiv.2204.08387", Year = 2022, Authors = "Yupan Huang, Tengchao Lv, Lei Cui, Yutong Lu, Furu Wei")]
-public partial class LayoutLMv3<T> : DocumentNeuralNetworkBase<T>, ILayoutDetector<T>, IDocumentQA<T>
-{
-    private readonly LayoutLMv3Options _options;
-
-    /// <inheritdoc/>
-    public override ModelOptions GetOptions() => _options;
-
-    #region Fields
-
-    private readonly bool _useNativeMode;
-    private readonly InferenceSession? _onnxSession;
-    private readonly ITokenizer _tokenizer;
-    private readonly IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>> _optimizer;
-    private readonly int _hiddenDim;
-    private readonly int _numLayers;
-    private readonly int _numHeads;
-    private readonly int _vocabSize;
-    private readonly int _numClasses;
-    private readonly int _patchSize;
-
-    // Native mode layers
-    private readonly List<ILayer<T>> _textEmbeddingLayers = [];
-    private readonly List<ILayer<T>> _imageEmbeddingLayers = [];
-    private readonly List<ILayer<T>> _transformerLayers = [];
-    private readonly List<ILayer<T>> _classificationLayers = [];
-
-    // Learnable embeddings
-    private Tensor<T>? _position1DEmbeddings;
-    private Tensor<T>? _position2DXEmbeddings;
-    private Tensor<T>? _position2DYEmbeddings;
-    private Tensor<T>? _segmentEmbeddings;
-
-    // Gradient storage
-    [Scratch]
-    private Tensor<T>? _position1DEmbeddingsGradients;
-    [Scratch]
-    private Tensor<T>? _position2DXEmbeddingsGradients;
-    [Scratch]
-    private Tensor<T>? _position2DYEmbeddingsGradients;
-
-    #endregion
-
-    #region Properties
-
-    /// <inheritdoc/>
-    public override DocumentType SupportedDocumentTypes => DocumentType.All;
-
-    /// <inheritdoc/>
-    public override bool RequiresOCR => true;
-
-    /// <inheritdoc/>
-    public int ExpectedImageSize => ImageSize;
-
-    /// <inheritdoc/>
-    public IReadOnlyList<LayoutElementType> SupportedElementTypes { get; } =
-    [
-        LayoutElementType.Text,
-        LayoutElementType.Title,
-        LayoutElementType.List,
-        LayoutElementType.Table,
-        LayoutElementType.Figure,
-        LayoutElementType.Caption,
-        LayoutElementType.Header,
-        LayoutElementType.Footer,
-        LayoutElementType.PageNumber,
-        LayoutElementType.FormField
-    ];
-
-    #endregion
-
-    #region Constructors
-
-    /// <summary>
-    /// Creates a LayoutLMv3 model using a pre-trained ONNX model for inference.
-    /// </summary>
-    /// <param name="architecture">The neural network architecture.</param>
-    /// <param name="onnxModelPath">Path to the ONNX model file.</param>
-    /// <param name="tokenizer">Tokenizer for text processing.</param>
-    /// <param name="numClasses">Number of output classes for classification tasks.</param>
-    /// <param name="imageSize">Expected input image size (default: 224).</param>
-    /// <param name="maxSequenceLength">Maximum sequence length (default: 512).</param>
-    /// <param name="hiddenDim">Hidden dimension size (default: 768).</param>
-    /// <param name="numLayers">Number of transformer layers (default: 12).</param>
-    /// <param name="numHeads">Number of attention heads (default: 12).</param>
-    /// <param name="vocabSize">Vocabulary size (default: 50265 for RoBERTa).</param>
-    /// <param name="optimizer">Optimizer for training (optional, Adam used if null).</param>
-    /// <param name="lossFunction">Loss function (optional, CrossEntropy used if null).</param>
-    /// <exception cref="ArgumentNullException">Thrown if onnxModelPath or tokenizer is null.</exception>
-    /// <exception cref="FileNotFoundException">Thrown if the ONNX model file doesn't exist.</exception>
-    public LayoutLMv3(
-        NeuralNetworkArchitecture<T> architecture,
-        string onnxModelPath,
-        ITokenizer tokenizer,
-        int numClasses = 17,
-        int imageSize = 224,
-        int maxSequenceLength = 512,
-        int hiddenDim = 768,
-        int numLayers = 12,
-        int numHeads = 12,
-        int vocabSize = 50265,
-        IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? optimizer = null,
-        ILossFunction<T>? lossFunction = null,
-        LayoutLMv3Options? options = null)
-        : base(architecture, lossFunction ?? new CrossEntropyWithLogitsLoss<T>(), 1.0)
-    {
-        _options = options ?? new LayoutLMv3Options();
-        Options = _options;
-
-        if (string.IsNullOrWhiteSpace(onnxModelPath))
-            throw new ArgumentNullException(nameof(onnxModelPath));
-
-        if (!File.Exists(onnxModelPath))
-            throw new FileNotFoundException($"ONNX model file not found: {onnxModelPath}", onnxModelPath);
-
-        Guard.NotNull(tokenizer);
-        _tokenizer = tokenizer;
-        _useNativeMode = false;
-        _numClasses = numClasses;
-        _hiddenDim = hiddenDim;
-        _numLayers = numLayers;
-        _numHeads = numHeads;
-        _vocabSize = vocabSize;
-        _patchSize = 16; // Default patch size for LayoutLMv3
-        _optimizer = optimizer ?? new AdamOptimizer<T, Tensor<T>, Tensor<T>>(this);
-
-        Guard.Positive(imageSize, nameof(imageSize));
-        ImageSize = imageSize;
-        MaxSequenceLength = maxSequenceLength;
-
-        _onnxSession = new InferenceSession(onnxModelPath);
-
-        InitializeLayers();
-    }
-
-    /// <summary>
-    /// Creates a LayoutLMv3 model using native layers for training and inference.
-    /// </summary>
-    /// <param name="architecture">The neural network architecture.</param>
-    /// <param name="tokenizer">Tokenizer for text processing (optional, default created if null).</param>
-    /// <param name="numClasses">Number of output classes for classification tasks.</param>
-    /// <param name="imageSize">Expected input image size (default: 224 from paper).</param>
-    /// <param name="patchSize">Vision transformer patch size (default: 16 from paper).</param>
-    /// <param name="maxSequenceLength">Maximum sequence length (default: 512).</param>
-    /// <param name="hiddenDim">Hidden dimension size (default: 768 for LayoutLMv3-Base).</param>
-    /// <param name="numLayers">Number of transformer layers (default: 12 for Base).</param>
-    /// <param name="numHeads">Number of attention heads (default: 12 for Base).</param>
-    /// <param name="vocabSize">Vocabulary size (default: 50265 for RoBERTa).</param>
-    /// <param name="optimizer">Optimizer for training (optional, Adam used if null).</param>
-    /// <param name="lossFunction">Loss function (optional, CrossEntropy used if null).</param>
-    /// <remarks>
-    /// <para>
-    /// <b>Default Configuration (LayoutLMv3-Base from ICCV 2022 paper):</b>
-    /// - Hidden dimension: 768
-    /// - Transformer layers: 12
-    /// - Attention heads: 12
-    /// - Image size: 224×224
-    /// - Patch size: 16
-    /// - Max sequence length: 512
-    /// </para>
-    /// </remarks>
-    public LayoutLMv3(
-        NeuralNetworkArchitecture<T> architecture,
-        ITokenizer? tokenizer = null,
-        int numClasses = 17,
-        int imageSize = 224,
-        int patchSize = 16,
-        int maxSequenceLength = 512,
-        int hiddenDim = 768,
-        int numLayers = 12,
-        int numHeads = 12,
-        int vocabSize = 50265,
-        IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? optimizer = null,
-        ILossFunction<T>? lossFunction = null,
-        LayoutLMv3Options? options = null)
-        : base(architecture, lossFunction ?? new CrossEntropyWithLogitsLoss<T>(), 1.0)
-    {
-        _options = options ?? new LayoutLMv3Options();
-        Options = _options;
-
-        _useNativeMode = true;
-        _numClasses = numClasses;
-        _hiddenDim = hiddenDim;
-        _numLayers = numLayers;
-        _numHeads = numHeads;
-        _vocabSize = vocabSize;
-        _patchSize = patchSize;
-
-        Guard.Positive(imageSize, nameof(imageSize));
-        ImageSize = imageSize;
-        MaxSequenceLength = maxSequenceLength;
-
-        _tokenizer = tokenizer ?? LanguageModelTokenizerFactory.CreateForBackbone(LanguageModelBackbone.RoBERTa);
-        _optimizer = optimizer ?? new AdamOptimizer<T, Tensor<T>, Tensor<T>>(this);
-
-        InitializeLayers();
-        InitializeEmbeddings();
-    }
-
-    #endregion
-
-    #region Initialization
-
-    /// <inheritdoc/>
-    protected override void InitializeLayers()
-    {
-        // In ONNX mode, layers are handled by ONNX runtime
-        if (!_useNativeMode)
-        {
-            return;
-        }
-
-        // Check if user provided custom layers
-        if (Architecture.Layers is not null && Architecture.Layers.Count > 0)
-        {
-            Layers.AddRange(Architecture.Layers);
-            ValidateCustomLayers(Layers);
-            PopulateLayerGroups();
-            return;
-        }
-
-        // Use LayerHelper to create default LayoutLMv3 layers
-        Layers.AddRange(LayerHelper<T>.CreateDefaultLayoutLMv3Layers(
-            Architecture,
-            hiddenDim: _hiddenDim,
-            numLayers: _numLayers,
-            numHeads: _numHeads,
-            vocabSize: _vocabSize,
-            imageSize: ImageSize,
-            patchSize: _patchSize,
-            numClasses: _numClasses));
-        PopulateLayerGroups();
-    }
-
-    private void PopulateLayerGroups()
-    {
-        _textEmbeddingLayers.Clear();
-        _imageEmbeddingLayers.Clear();
-        _transformerLayers.Clear();
-
-        bool reachedHead = false;
-        foreach (var layer in Layers)
-        {
-            if (IsClassificationHeadLayer(layer))
-            {
-                reachedHead = true;
-            }
-
-            if (reachedHead)
-            {
-                continue;
-            }
-
-            if (layer is EmbeddingLayer<T>)
-            {
-                _textEmbeddingLayers.Add(layer);
-            }
-            else if (layer is PatchEmbeddingLayer<T>)
-            {
-                _imageEmbeddingLayers.Add(layer);
-            }
-            else
-            {
-                _transformerLayers.Add(layer);
-            }
-        }
-    }
-
-    private static bool IsClassificationHeadLayer(ILayer<T> layer)
-    {
-        return layer is DenseLayer<T>;
-    }
-
-    private void InitializeEmbeddings()
-    {
-        var random = RandomHelper.CreateSeededRandom(42);
-
-        // 1D position embeddings for sequence position
-        _position1DEmbeddings = Tensor<T>.CreateDefault([MaxSequenceLength, _hiddenDim], NumOps.Zero);
-        InitializeWithSmallRandomValues(_position1DEmbeddings, random, 0.02);
-
-        // 2D position embeddings for bounding box coordinates (normalized 0-1000)
-        _position2DXEmbeddings = Tensor<T>.CreateDefault([1001, _hiddenDim], NumOps.Zero);
-        _position2DYEmbeddings = Tensor<T>.CreateDefault([1001, _hiddenDim], NumOps.Zero);
-        InitializeWithSmallRandomValues(_position2DXEmbeddings, random, 0.02);
-        InitializeWithSmallRandomValues(_position2DYEmbeddings, random, 0.02);
-
-        // Segment embeddings (text vs image)
-        _segmentEmbeddings = Tensor<T>.CreateDefault([2, _hiddenDim], NumOps.Zero);
-        InitializeWithSmallRandomValues(_segmentEmbeddings, random, 0.02);
-
-        // Initialize gradient tensors
-        _position1DEmbeddingsGradients = Tensor<T>.CreateDefault([MaxSequenceLength, _hiddenDim], NumOps.Zero);
-        _position2DXEmbeddingsGradients = Tensor<T>.CreateDefault([1001, _hiddenDim], NumOps.Zero);
-        _position2DYEmbeddingsGradients = Tensor<T>.CreateDefault([1001, _hiddenDim], NumOps.Zero);
-    }
-
-    private void InitializeWithSmallRandomValues(Tensor<T> tensor, Random random, double stdDev)
-    {
-        for (int i = 0; i < tensor.Data.Length; i++)
-        {
-            double u1 = 1.0 - random.NextDouble();
-            double u2 = 1.0 - random.NextDouble();
-            double randStdNormal = Math.Sqrt(-2.0 * Math.Log(u1)) * Math.Sin(2.0 * Math.PI * u2);
-            tensor.Data.Span[i] = NumOps.FromDouble(randStdNormal * stdDev);
-        }
-    }
-
-    #endregion
-
-    #region ILayoutDetector Implementation
-
-    /// <inheritdoc/>
-    public DocumentLayoutResult<T> DetectLayout(Tensor<T> documentImage)
-    {
-        return DetectLayout(documentImage, 0.5);
-    }
-
-    /// <inheritdoc/>
-    public DocumentLayoutResult<T> DetectLayout(Tensor<T> documentImage, double confidenceThreshold)
-    {
-        ValidateImageShape(documentImage);
-
-        var startTime = DateTime.UtcNow;
-
-        var result = _useNativeMode
-            ? DetectLayoutNative(documentImage, confidenceThreshold)
-            : DetectLayoutOnnx(documentImage, confidenceThreshold);
-
-        return new DocumentLayoutResult<T>
-        {
-            Regions = result.Regions,
-            ReadingOrder = result.ReadingOrder,
-            ProcessingTimeMs = (DateTime.UtcNow - startTime).TotalMilliseconds
-        };
-    }
-
-    private DocumentLayoutResult<T> DetectLayoutNative(Tensor<T> image, double threshold)
-    {
-        var input = PreprocessDocument(image);
-        var output = Forward(input);
-        return ParseLayoutOutput(output, threshold);
-    }
-
-    private DocumentLayoutResult<T> DetectLayoutOnnx(Tensor<T> image, double threshold)
-    {
-        if (_onnxSession is null)
-            throw new InvalidOperationException("ONNX session not initialized.");
-
-        var input = PreprocessDocument(image);
-        var output = RunOnnxInference(input);
-        return ParseLayoutOutput(output, threshold);
-    }
-
-    private DocumentLayoutResult<T> ParseLayoutOutput(Tensor<T> output, double threshold)
-    {
-        var regions = new List<LayoutRegion<T>>();
-
-        // Parse output tensor into layout regions
-        // Expected format: [numDetections, numClasses + 4] where last 4 are bbox coords
-        // Or: [numDetections, hiddenDim] where we extract class from first numClasses and bbox from last 4
-
-        int numDetections = output.Shape[0];
-        int numValues = output.Shape.Length > 1 ? output.Shape[1] : _numClasses;
-        int numClasses = Math.Max(0, Math.Min(numValues - 4, _numClasses));
-        bool hasBbox = numValues >= 4;
-
-        if (numClasses == 0)
-        {
-            return new DocumentLayoutResult<T>
-            {
-                Regions = regions
-            };
-        }
-
-        for (int i = 0; i < numDetections; i++)
-        {
-            // Find the class with highest confidence
-            double maxConf = 0;
-            int maxClass = 0;
-            for (int c = 0; c < numClasses; c++)
-            {
-                double conf = NumOps.ToDouble(output.Data.Span[i * numValues + c]);
-                if (conf > maxConf)
-                {
-                    maxConf = conf;
-                    maxClass = c;
-                }
-            }
-
-            if (maxConf >= threshold)
-            {
-                // Extract bounding box from last 4 values (normalized coordinates)
-                Vector<T> bbox;
-                if (hasBbox && numValues >= 4)
-                {
-                    int bboxOffset = i * numValues + numValues - 4;
-                    double x1 = NumOps.ToDouble(output.Data.Span[bboxOffset]) * ImageSize;
-                    double y1 = NumOps.ToDouble(output.Data.Span[bboxOffset + 1]) * ImageSize;
-                    double x2 = NumOps.ToDouble(output.Data.Span[bboxOffset + 2]) * ImageSize;
-                    double y2 = NumOps.ToDouble(output.Data.Span[bboxOffset + 3]) * ImageSize;
-
-                    bbox = new Vector<T>([
-                        NumOps.FromDouble(Math.Max(0, x1)),
-                        NumOps.FromDouble(Math.Max(0, y1)),
-                        NumOps.FromDouble(Math.Min(ImageSize, x2)),
-                        NumOps.FromDouble(Math.Min(ImageSize, y2))
-                    ]);
-                }
-                else
-                {
-                    // Estimate bbox from detection index (grid-based fallback)
-                    int gridSize = (int)Math.Sqrt(numDetections);
-                    int cellSize = ImageSize / Math.Max(1, gridSize);
-                    int row = i / gridSize;
-                    int col = i % gridSize;
-
-                    bbox = new Vector<T>([
-                        NumOps.FromDouble(col * cellSize),
-                        NumOps.FromDouble(row * cellSize),
-                        NumOps.FromDouble((col + 1) * cellSize),
-                        NumOps.FromDouble((row + 1) * cellSize)
-                    ]);
-                }
-
-                regions.Add(new LayoutRegion<T>
-                {
-                    ElementType = (LayoutElementType)Math.Min(maxClass, (int)LayoutElementType.Other),
-                    Confidence = NumOps.FromDouble(maxConf),
-                    ConfidenceValue = maxConf,
-                    Index = i,
-                    BoundingBox = bbox
-                });
-            }
-        }
-
-        return new DocumentLayoutResult<T>
-        {
-            Regions = regions
-        };
-    }
-
-    #endregion
-
-    #region IDocumentQA Implementation
-
-    /// <inheritdoc/>
-    public DocumentQAResult<T> AnswerQuestion(Tensor<T> documentImage, string question)
-    {
-        return AnswerQuestion(documentImage, question, 64, 0.0);
-    }
-
-    /// <inheritdoc/>
-    public DocumentQAResult<T> AnswerQuestion(Tensor<T> documentImage, string question, int maxAnswerLength, double temperature = 0.0)
-    {
-        ValidateImageShape(documentImage);
-
-        var startTime = DateTime.UtcNow;
-
-        var result = _useNativeMode
-            ? AnswerQuestionNative(documentImage, question, maxAnswerLength, temperature)
-            : AnswerQuestionOnnx(documentImage, question, maxAnswerLength, temperature);
-
-        return new DocumentQAResult<T>
-        {
-            Answer = result.Answer,
-            Confidence = result.Confidence,
-            ConfidenceValue = result.ConfidenceValue,
-            Evidence = result.Evidence,
-            AlternativeAnswers = result.AlternativeAnswers,
-            ProcessingTimeMs = (DateTime.UtcNow - startTime).TotalMilliseconds,
-            Question = question
-        };
-    }
-
-    private DocumentQAResult<T> AnswerQuestionNative(Tensor<T> image, string question, int maxLength, double temp)
-    {
-        // Process image
-        var imageFeatures = PreprocessDocument(image);
-
-        // Combine and run through model
-        var output = Forward(imageFeatures);
-
-        var (answer, confidence) = ExtractAnswer(output, maxLength, temp);
-
-        return new DocumentQAResult<T>
-        {
-            Answer = answer,
-            Confidence = NumOps.FromDouble(confidence),
-            ConfidenceValue = confidence
-        };
-    }
-
-    private DocumentQAResult<T> AnswerQuestionOnnx(Tensor<T> image, string question, int maxLength, double temp)
-    {
-        if (_onnxSession is null)
-            throw new InvalidOperationException("ONNX session not initialized.");
-
-        var imageFeatures = PreprocessDocument(image);
-        var output = RunOnnxInference(imageFeatures);
-
-        var (answer, confidence) = ExtractAnswer(output, maxLength, temp);
-
-        return new DocumentQAResult<T>
-        {
-            Answer = answer,
-            Confidence = NumOps.FromDouble(confidence),
-            ConfidenceValue = confidence
-        };
-    }
-
-    private (string answer, double confidence) ExtractAnswer(Tensor<T> output, int maxAnswerLength, double temperature)
-    {
-        var logits = NormalizeAnswerLogits(output);
-        if (logits.Shape.Length < 2)
-        {
-            return ("[No answer found]", 0.0);
-        }
-
-        int seqLen = logits.Shape[0];
-        int vocabSize = logits.Shape[1];
-        if (_vocabSize > 0)
-        {
-            vocabSize = Math.Min(vocabSize, _vocabSize);
-        }
-
-        if (seqLen <= 0 || vocabSize <= 0 || maxAnswerLength <= 0)
-        {
-            return ("[No answer found]", 0.0);
-        }
-
-        int maxLen = Math.Min(seqLen, maxAnswerLength);
-        var tokens = new List<int>(maxLen);
-        double confidenceSum = 0.0;
-        int confidenceCount = 0;
-
-        int eosId = GetSpecialTokenId(_tokenizer.SpecialTokens.EosToken);
-        int sepId = GetSpecialTokenId(_tokenizer.SpecialTokens.SepToken);
-        int padId = GetSpecialTokenId(_tokenizer.SpecialTokens.PadToken);
-        int clsId = GetSpecialTokenId(_tokenizer.SpecialTokens.ClsToken);
-
-        var random = RandomHelper.Shared;
-        bool sampleTokens = temperature > 0.0;
-
-        for (int i = 0; i < maxLen; i++)
-        {
-            int offset = i * logits.Shape[1];
-            int tokenId;
-            double tokenProb;
-
-            if (sampleTokens)
-            {
-                tokenId = SampleToken(logits, offset, vocabSize, temperature, random, out tokenProb);
-            }
-            else
-            {
-                tokenId = SelectGreedyToken(logits, offset, vocabSize, out tokenProb);
-            }
-
-            if ((eosId >= 0 && tokenId == eosId) || (sepId >= 0 && tokenId == sepId))
-            {
-                break;
-            }
-
-            if ((padId >= 0 && tokenId == padId) || (clsId >= 0 && tokenId == clsId))
-            {
-                continue;
-            }
-
-            tokens.Add(tokenId);
-            confidenceSum += tokenProb;
-            confidenceCount++;
-        }
-
-        if (tokens.Count == 0)
-        {
-            return ("[No answer found]", 0.0);
-        }
-
-        string answer = _tokenizer.Decode(tokens, skipSpecialTokens: true).Trim();
-        if (string.IsNullOrWhiteSpace(answer))
-        {
-            return ("[No answer found]", 0.0);
-        }
-
-        double confidence = confidenceCount > 0 ? confidenceSum / confidenceCount : 0.0;
-        return (answer, confidence);
-    }
-
-    private Tensor<T> NormalizeAnswerLogits(Tensor<T> output)
-    {
-        if (output.Shape.Length == 2)
-        {
-            return output;
-        }
-
-        if (output.Shape.Length == 3 && output.Shape[0] == 1)
-        {
-            return output.Reshape([output.Shape[1], output.Shape[2]]);
-        }
-
-        if (output.Shape.Length == 1)
-        {
-            if (_vocabSize > 0 && output.Length % _vocabSize == 0)
-            {
-                return output.Reshape([output.Length / _vocabSize, _vocabSize]);
-            }
-
-            return output.Reshape([1, output.Length]);
-        }
-
-        int lastDim = output.Shape[^1];
-        if (lastDim <= 0 || output.Length % lastDim != 0)
-        {
-            return output.Reshape([1, output.Length]);
-        }
-
-        int seqLen = output.Length / lastDim;
-        return output.Reshape([seqLen, lastDim]);
-    }
-
-    private int SelectGreedyToken(Tensor<T> logits, int offset, int vocabSize, out double probability)
-    {
-        double maxVal = double.MinValue;
-        int maxIdx = 0;
-
-        for (int v = 0; v < vocabSize; v++)
-        {
-            double val = NumOps.ToDouble(logits.Data.Span[offset + v]);
-            if (val > maxVal)
-            {
-                maxVal = val;
-                maxIdx = v;
-            }
-        }
-
-        double sumExp = 0.0;
-        for (int v = 0; v < vocabSize; v++)
-        {
-            double val = NumOps.ToDouble(logits.Data.Span[offset + v]);
-            sumExp += Math.Exp(val - maxVal);
-        }
-
-        probability = sumExp > 0 ? 1.0 / sumExp : 0.0;
-        return maxIdx;
-    }
-
-    private int SampleToken(Tensor<T> logits, int offset, int vocabSize, double temperature, Random random, out double probability)
-    {
-        double maxVal = double.MinValue;
-        for (int v = 0; v < vocabSize; v++)
-        {
-            double scaled = NumOps.ToDouble(logits.Data.Span[offset + v]) / temperature;
-            if (scaled > maxVal)
-            {
-                maxVal = scaled;
-            }
-        }
-
-        double sumExp = 0.0;
-        for (int v = 0; v < vocabSize; v++)
-        {
-            double scaled = NumOps.ToDouble(logits.Data.Span[offset + v]) / temperature;
-            sumExp += Math.Exp(scaled - maxVal);
-        }
-
-        if (sumExp <= 0.0)
-        {
-            probability = 0.0;
-            return 0;
-        }
-
-        double roll = random.NextDouble() * sumExp;
-        double cumulative = 0.0;
-        for (int v = 0; v < vocabSize; v++)
-        {
-            double scaled = NumOps.ToDouble(logits.Data.Span[offset + v]) / temperature;
-            double expVal = Math.Exp(scaled - maxVal);
-            cumulative += expVal;
-            if (cumulative >= roll)
-            {
-                probability = expVal / sumExp;
-                return v;
-            }
-        }
-
-        probability = 0.0;
-        return vocabSize - 1;
-    }
-
-    private int GetSpecialTokenId(string token)
-    {
-        if (string.IsNullOrWhiteSpace(token))
-        {
-            return -1;
-        }
-
-        var vocabulary = _tokenizer.Vocabulary;
-        if (!vocabulary.ContainsToken(token))
-        {
-            return -1;
-        }
-
-        return vocabulary.GetTokenId(token);
-    }
-
-    /// <inheritdoc/>
-    public IEnumerable<DocumentQAResult<T>> AnswerQuestions(Tensor<T> documentImage, IEnumerable<string> questions)
-    {
-        ValidateImageShape(documentImage);
-
-        foreach (var question in questions)
-        {
-            yield return AnswerQuestion(documentImage, question);
-        }
-    }
-
-    /// <inheritdoc/>
-    public Dictionary<string, DocumentQAResult<T>> ExtractFields(Tensor<T> documentImage, IEnumerable<string> fieldPrompts)
-    {
-        var results = new Dictionary<string, DocumentQAResult<T>>();
-
-        foreach (var field in fieldPrompts)
-        {
-            var question = $"What is the {field}?";
-            results[field] = AnswerQuestion(documentImage, question);
-        }
-
-        return results;
-    }
-
-    #endregion
-
-    #region IDocumentModel Implementation
-
-    /// <inheritdoc/>
-    public Tensor<T> EncodeDocument(Tensor<T> documentImage)
-    {
-        ValidateImageShape(documentImage);
-
-        var input = PreprocessDocument(documentImage);
-
-        if (_useNativeMode)
-        {
-            // Run through embedding and transformer layers only (not classification head)
-            var output = input;
-            if (_textEmbeddingLayers.Count == 0
-                && _imageEmbeddingLayers.Count == 0
-                && _transformerLayers.Count == 0)
-            {
-                foreach (var layer in Layers)
-                {
-                    if (IsClassificationHeadLayer(layer))
-                    {
-                        break;
-                    }
-                    output = layer.Forward(output);
-                }
-                return output;
-            }
-
-            foreach (var layer in _textEmbeddingLayers) output = layer.Forward(output);
-            foreach (var layer in _imageEmbeddingLayers) output = layer.Forward(output);
-            foreach (var layer in _transformerLayers) output = layer.Forward(output);
-            return output;
-        }
-        else
-        {
-            return RunOnnxInference(input);
-        }
-    }
-
-    /// <inheritdoc/>
-    public void ValidateInputShape(Tensor<T> documentImage)
-    {
-        ValidateImageShape(documentImage);
-    }
-
-    /// <inheritdoc/>
-    public string GetModelSummary()
-    {
-        var sb = new System.Text.StringBuilder();
-        sb.AppendLine("LayoutLMv3 Model Summary");
-        sb.AppendLine("========================");
-        sb.AppendLine($"Mode: {(_useNativeMode ? "Native (Trainable)" : "ONNX (Inference)")}");
-        sb.AppendLine($"Hidden Dimension: {_hiddenDim}");
-        sb.AppendLine($"Number of Layers: {_numLayers}");
-        sb.AppendLine($"Number of Attention Heads: {_numHeads}");
-        sb.AppendLine($"Vocabulary Size: {_vocabSize}");
-        sb.AppendLine($"Max Sequence Length: {MaxSequenceLength}");
-        sb.AppendLine($"Image Size: {ImageSize}x{ImageSize}");
-        sb.AppendLine($"Number of Classes: {_numClasses}");
-        sb.AppendLine($"Total Layers: {Layers.Count}");
-        sb.AppendLine($"Supported Document Types: {SupportedDocumentTypes}");
-        sb.AppendLine($"Requires OCR: {RequiresOCR}");
-        return sb.ToString();
-    }
-
-    #endregion
-
-    #region Preprocessing
-
-    /// <summary>
-    /// Applies LayoutLMv3's industry-standard preprocessing: ImageNet normalization.
-    /// </summary>
-    /// <remarks>
-    /// LayoutLMv3 (Microsoft paper) uses ImageNet normalization with mean=[0.485, 0.456, 0.406] and std=[0.229, 0.224, 0.225].
-    /// The unified architecture for multimodal document understanding.
-    /// </remarks>
-    protected override Tensor<T> ApplyDefaultPreprocessing(Tensor<T> rawImage)
-    {
-        var image = EnsureBatchDimension(rawImage);
-
-        int batchSize = image.Shape[0];
-        int channels = image.Shape[1];
-        int height = image.Shape[2];
-        int width = image.Shape[3];
-
-        // Resize to model's expected ImageSize if needed (bilinear interpolation)
-        if (height != ImageSize || width != ImageSize)
-        {
-            image = ResizeBilinear(image, batchSize, channels, height, width, ImageSize, ImageSize);
-            height = ImageSize;
-            width = ImageSize;
-        }
-
-        // ImageNet normalization: (x - mean) / std
-        var normalized = new Tensor<T>(image._shape);
-        double[] means = [0.485, 0.456, 0.406];
-        double[] stds = [0.229, 0.224, 0.225];
-
-        for (int b = 0; b < batchSize; b++)
-        {
-            for (int c = 0; c < channels; c++)
-            {
-                double mean = c < means.Length ? means[c] : 0.5;
-                double std = c < stds.Length ? stds[c] : 0.5;
-
-                for (int h = 0; h < height; h++)
-                {
-                    for (int w = 0; w < width; w++)
-                    {
-                        int idx = b * channels * height * width + c * height * width + h * width + w;
-                        double value = NumOps.ToDouble(image.Data.Span[idx]);
-                        normalized.Data.Span[idx] = NumOps.FromDouble((value - mean) / std);
-                    }
-                }
-            }
-        }
-
-        return normalized;
-    }
-
-    private Tensor<T> ResizeBilinear(Tensor<T> image, int batchSize, int channels,
-        int srcH, int srcW, int dstH, int dstW)
-    {
-        var resized = new Tensor<T>([batchSize, channels, dstH, dstW]);
-
-        double scaleH = (double)srcH / dstH;
-        double scaleW = (double)srcW / dstW;
-
-        for (int b = 0; b < batchSize; b++)
-        {
-            for (int c = 0; c < channels; c++)
-            {
-                int srcBaseIdx = b * channels * srcH * srcW + c * srcH * srcW;
-                int dstBaseIdx = b * channels * dstH * dstW + c * dstH * dstW;
-
-                for (int h = 0; h < dstH; h++)
-                {
-                    double srcY = (h + 0.5) * scaleH - 0.5;
-                    int y0 = Math.Max(0, (int)Math.Floor(srcY));
-                    int y1 = Math.Min(srcH - 1, y0 + 1);
-                    double fy = srcY - y0;
-
-                    for (int w = 0; w < dstW; w++)
-                    {
-                        double srcX = (w + 0.5) * scaleW - 0.5;
-                        int x0 = Math.Max(0, (int)Math.Floor(srcX));
-                        int x1 = Math.Min(srcW - 1, x0 + 1);
-                        double fx = srcX - x0;
-
-                        double v00 = NumOps.ToDouble(image.Data.Span[srcBaseIdx + y0 * srcW + x0]);
-                        double v01 = NumOps.ToDouble(image.Data.Span[srcBaseIdx + y0 * srcW + x1]);
-                        double v10 = NumOps.ToDouble(image.Data.Span[srcBaseIdx + y1 * srcW + x0]);
-                        double v11 = NumOps.ToDouble(image.Data.Span[srcBaseIdx + y1 * srcW + x1]);
-
-                        double val = v00 * (1 - fy) * (1 - fx) + v01 * (1 - fy) * fx
-                                   + v10 * fy * (1 - fx) + v11 * fy * fx;
-
-                        resized.Data.Span[dstBaseIdx + h * dstW + w] = NumOps.FromDouble(val);
-                    }
-                }
-            }
-        }
-
-        return resized;
-    }
-
-    /// <summary>
-    /// Applies LayoutLMv3's industry-standard postprocessing: softmax for classification outputs.
-    /// </summary>
-    protected override Tensor<T> ApplyDefaultPostprocessing(Tensor<T> modelOutput)
-    {
-        // Apply softmax for classification outputs
-        return ApplySoftmax(modelOutput);
-    }
-
-    private Tensor<T> ApplySoftmax(Tensor<T> input)
-    {
-        return Engine.Softmax(input, -1);
-    }
-
-    #endregion
-
-    #region Serialization
-
-    /// <inheritdoc/>
-    public override ModelMetadata<T> GetModelMetadata()
-    {
-        return new ModelMetadata<T>
-        {
-            Name = "LayoutLMv3",
-            Description = "LayoutLMv3 document understanding model with unified text and image pre-training",
-            FeatureCount = _hiddenDim,
-            Complexity = _numLayers,
-            AdditionalInfo = new Dictionary<string, object>
-            {
-                { "hidden_dim", _hiddenDim },
-                { "num_layers", _numLayers },
-                { "num_heads", _numHeads },
-                { "vocab_size", _vocabSize },
-                { "max_seq_length", MaxSequenceLength },
-                { "image_size", ImageSize },
-                { "patch_size", _patchSize },
-                { "num_classes", _numClasses },
-                { "use_native_mode", _useNativeMode }
-            },
-            ModelData = SafeSerialize()
-        };
-    }
-
-    /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_hiddenDim);
-        writer.Write(_numLayers);
-        writer.Write(_numHeads);
-        writer.Write(_vocabSize);
-        writer.Write(MaxSequenceLength);
-        writer.Write(ImageSize);
-        writer.Write(_numClasses);
-        writer.Write(_patchSize);
-        writer.Write(_useNativeMode);
-
-        // Serialize embeddings if in native mode
-        if (_useNativeMode && _position1DEmbeddings is not null)
-        {
-            writer.Write(true);
-            SerializeTensor(writer, _position1DEmbeddings);
-            SerializeTensor(writer, _position2DXEmbeddings!);
-            SerializeTensor(writer, _position2DYEmbeddings!);
-            SerializeTensor(writer, _segmentEmbeddings!);
-        }
-        else
-        {
-            writer.Write(false);
-        }
-    }
-
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        // Read fields (Note: readonly fields are set in constructor, these would be for validation)
-        int hiddenDim = reader.ReadInt32();
-        int numLayers = reader.ReadInt32();
-        int numHeads = reader.ReadInt32();
-        int vocabSize = reader.ReadInt32();
-        int maxSeqLen = reader.ReadInt32();
-        int imageSize = reader.ReadInt32();
-        int numClasses = reader.ReadInt32();
-        int patchSize = reader.ReadInt32();
-        bool useNativeMode = reader.ReadBoolean();
-
-        ImageSize = imageSize;
-        MaxSequenceLength = maxSeqLen;
-
-        // Deserialize embeddings if present
-        if (reader.ReadBoolean())
-        {
-            _position1DEmbeddings = DeserializeTensor(reader);
-            _position2DXEmbeddings = DeserializeTensor(reader);
-            _position2DYEmbeddings = DeserializeTensor(reader);
-            _segmentEmbeddings = DeserializeTensor(reader);
-        }
-    }
-
-    private void SerializeTensor(BinaryWriter writer, Tensor<T> tensor)
-    {
-        writer.Write(tensor.Rank);
-        foreach (var dim in tensor._shape)
-            writer.Write(dim);
-
-        writer.Write(tensor.Data.Length);
-        foreach (var val in tensor.Data.ToArray())
-            writer.Write(NumOps.ToDouble(val));
-    }
-
-    private Tensor<T> DeserializeTensor(BinaryReader reader)
-    {
-        int rank = reader.ReadInt32();
-        int[] shape = new int[rank];
-        for (int i = 0; i < rank; i++)
-            shape[i] = reader.ReadInt32();
-
-        int length = reader.ReadInt32();
-        var tensor = new Tensor<T>(shape);
-        for (int i = 0; i < length; i++)
-            tensor.Data.Span[i] = NumOps.FromDouble(reader.ReadDouble());
-
-        return tensor;
-    }
-
-    /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new LayoutLMv3<T>(
-            Architecture,
-            _tokenizer,
-            _numClasses,
-            ImageSize,
-            _patchSize,
-            MaxSequenceLength,
-            _hiddenDim,
-            _numLayers,
-            _numHeads,
-            _vocabSize);
-    }
-
-    #endregion
-
-    #region NeuralNetworkBase Implementation
-
-    /// <summary>
-    /// Overrides Forward to handle LayoutLMv3's multimodal architecture.
-    /// Image input is routed through image embedding (skipping text embedding),
-    /// then through transformer layers and classification head.
-    /// </summary>
-    protected override Tensor<T> Forward(Tensor<T> input)
-        => RunModalityForward(input);
-
-    // Modality-robust routing (LayoutLMv3, Huang et al. 2022): a token-ID input [Rank <= 2] runs the
-    // word-embedding stream while a document image [Rank >= 3] runs the ViT patch-embedding stream; both
-    // then flow through the shared multimodal transformer and classification head. The previous Forward
-    // ALWAYS ran the image (patch) embedding regardless of modality, so a token input hit
-    // "PatchEmbeddingLayer requires rank-3/rank-4 input; got rank 1" and never exercised the text stream.
-    private Tensor<T> RunModalityForward(Tensor<T> input)
-    {
-        // The layer groups are transient state populated at construction, NOT by the clone/deserialize
-        // path (base DeepCopy reconstructs Layers as NEW layer objects but never re-runs
-        // PopulateLayerGroups). A cloned model's groups would otherwise hold STALE references to the
-        // source model's layers: the reference-equality exclusion below then fails to exclude the
-        // clone's patch embedding, and the head loop runs it on a rank-2 transformer output ("got rank
-        // 2"). Repopulate from the current Layers whenever they are present so the routing tracks the
-        // live layer objects across Clone() and load-from-bytes.
-        if (Layers.Count > 0)
-            PopulateLayerGroups();
-
-        // Fallback to sequential processing if groups still not populated (no Layers yet).
-        if (_imageEmbeddingLayers.Count == 0 && _textEmbeddingLayers.Count == 0 && _transformerLayers.Count == 0)
-            return base.Forward(input);
-
-        var output = input;
-
-        // Route the input through the embedding stream that matches its modality.
-        if (input.Rank <= 2)
-            foreach (var layer in _textEmbeddingLayers)
-                output = layer.Forward(output);
-        else
-            foreach (var layer in _imageEmbeddingLayers)
-                output = layer.Forward(output);
-
-        // Shared multimodal transformer.
-        foreach (var layer in _transformerLayers)
-            output = layer.Forward(output);
-
-        // Classification head: every layer not in an embedding/transformer group.
-        var excludedLayers = new HashSet<ILayer<T>>(_imageEmbeddingLayers);
-        foreach (var l in _textEmbeddingLayers) excludedLayers.Add(l);
-        foreach (var l in _transformerLayers) excludedLayers.Add(l);
-
-        foreach (var layer in Layers.Where(l => !excludedLayers.Contains(l)))
-            output = layer.Forward(output);
-
-        return output;
-    }
-
-    /// <inheritdoc/>
-    public override Tensor<T> ForwardForTraining(Tensor<T> input)
-        => _useNativeMode ? RunModalityForward(input) : base.ForwardForTraining(input);
-
-    /// <inheritdoc/>
-    /// <remarks>
-    /// Diagnostic counterpart of <see cref="RunModalityForward"/>: the base walk sends a token-only input
-    /// into the rank-3-only patch embedding and throws before recording anything. Record only the layers
-    /// that fire for the supplied modality.
-    /// </remarks>
-    public override Dictionary<string, Tensor<T>> GetNamedLayerActivations(Tensor<T> input)
-    {
-        if (input is null)
-            throw new ArgumentNullException(nameof(input));
-
-        // Repopulate the transient layer groups from the current Layers so routing tracks the live
-        // layer objects across Clone()/load-from-bytes (see RunModalityForward remarks).
-        if (Layers.Count > 0)
-            PopulateLayerGroups();
-
-        if (!_useNativeMode
-            || (_imageEmbeddingLayers.Count == 0 && _textEmbeddingLayers.Count == 0 && _transformerLayers.Count == 0))
-            return base.GetNamedLayerActivations(input);
-
-        var activations = new Dictionary<string, Tensor<T>>();
-        var output = input;
-        var embeddingLayers = input.Rank <= 2 ? _textEmbeddingLayers : _imageEmbeddingLayers;
-
-        var excludedLayers = new HashSet<ILayer<T>>(_imageEmbeddingLayers);
-        foreach (var l in _textEmbeddingLayers) excludedLayers.Add(l);
-        foreach (var l in _transformerLayers) excludedLayers.Add(l);
-
-        int idx = 0;
-        foreach (var layer in embeddingLayers)
-        {
-            output = layer.Forward(output);
-            activations[$"Layer_{idx++}_{layer.GetType().Name}"] = output.Clone();
-        }
-        foreach (var layer in _transformerLayers)
-        {
-            output = layer.Forward(output);
-            activations[$"Layer_{idx++}_{layer.GetType().Name}"] = output.Clone();
-        }
-        foreach (var layer in Layers.Where(l => !excludedLayers.Contains(l)))
-        {
-            output = layer.Forward(output);
-            activations[$"Layer_{idx++}_{layer.GetType().Name}"] = output.Clone();
-        }
-        return activations;
-    }
-
-    /// <inheritdoc/>
-    protected override Tensor<T> PredictCore(Tensor<T> input)
-    {
-        var preprocessed = PreprocessDocument(input);
-
-        if (_useNativeMode)
-        {
-            return Forward(preprocessed);
-        }
-        else
-        {
-            return RunOnnxInference(preprocessed);
-        }
-    }
-
-    /// <inheritdoc/>
-    public override void Train(Tensor<T> input, Tensor<T> expectedOutput)
-    {
-        if (!_useNativeMode)
-        {
-            throw new NotSupportedException("Training is not supported in ONNX inference mode. Use native mode for training.");
-        }
-
-        SetTrainingMode(true);
-        try
-        {
-            TrainWithTape(input, expectedOutput, _optimizer);
-        }
-        finally
-        {
-            SetTrainingMode(false);
-        }
-    }
-
-    // UpdateParameters applied a GRADIENT STEP, but its one-argument form is the value setter and every caller passes values -- the override corrupted the model. Removed under AIDN082.

-
-    /// <summary>
-    /// Parameters cannot be written while the model is backed by a loaded ONNX graph: the weights
-    /// belong to that graph, not to this instance.
-    /// </summary>
-    /// <remarks>
-    /// Replaces a hand-written throw that used to sit inside UpdateParameters. The base checks this
-    /// on every mutating entry point rather than the one member the throw happened to guard, and
-    /// reading -- ParameterCount and GetParameters -- stays available either way.
-    /// </remarks>
+using AiDotNet.ActivationFunctions;
+using AiDotNet.Document.Interfaces;
+using AiDotNet.Document.Options;
+using AiDotNet.Attributes;
+using AiDotNet.Enums;
+using AiDotNet.Helpers;
+using AiDotNet.Interfaces;
+using AiDotNet.LinearAlgebra;
+using AiDotNet.LossFunctions;
+using AiDotNet.NeuralNetworks;
+using AiDotNet.NeuralNetworks.Layers;
+using AiDotNet.Onnx;
+using AiDotNet.Optimizers;
+using AiDotNet.Tokenization;
+using AiDotNet.Tokenization.Interfaces;
+using Microsoft.ML.OnnxRuntime;
+using AiDotNet.Validation;
+using OnnxTensors = Microsoft.ML.OnnxRuntime.Tensors;
+
+namespace AiDotNet.Document.LayoutAware;
+
+/// <summary>
+/// LayoutLMv3 neural network for document understanding with unified text and image pre-training.
+/// </summary>
+/// <typeparam name="T">The numeric type used for calculations.</typeparam>
+/// <remarks>
+/// <para>
+/// LayoutLMv3 is the third generation of the LayoutLM series from Microsoft Research,
+/// featuring unified multimodal pre-training with masked image modeling and masked language
+/// modeling on the same architecture.
+/// </para>
+/// <para>
+/// <b>For Beginners:</b> LayoutLMv3 understands documents by learning from:
+/// 1. The text content (what the words say)
+/// 2. The visual appearance (what the document looks like)
+/// 3. The layout structure (where elements are positioned)
+///
+/// This makes it excellent for:
+/// - Extracting information from forms and receipts
+/// - Understanding document structure
+/// - Answering questions about document content
+/// - Classifying document types
+///
+/// Example usage (ONNX mode - for inference with pre-trained models):
+/// <code>
+/// var model = new LayoutLMv3&lt;float&gt;(architecture, "model.onnx", tokenizer);
+/// var layout = model.DetectLayout(documentImage);
+/// </code>
+///
+/// Example usage (Native mode - for training):
+/// <code>
+/// var model = new LayoutLMv3&lt;float&gt;(architecture);
+/// model.Train(trainingData, labels);
+/// </code>
+/// </para>
+/// <para>
+/// <b>Reference:</b> "LayoutLMv3: Pre-training for Document AI with Unified Text and Image Masking"
+/// https://arxiv.org/abs/2204.08387
+/// </para>
+/// </remarks>
+[ModelDomain(ModelDomain.Vision)]
+[ModelDomain(ModelDomain.Language)]
+[ModelCategory(ModelCategory.NeuralNetwork)]
+[ModelCategory(ModelCategory.Transformer)]
+[ModelTask(ModelTask.Classification)]
+[ModelTask(ModelTask.Detection)]
+[ModelComplexity(ModelComplexity.High)]
+[ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
+[ResearchPaper("LayoutLMv3: Pre-training for Document AI with Unified Text and Image Masking", "https://doi.org/10.48550/arXiv.2204.08387", Year = 2022, Authors = "Yupan Huang, Tengchao Lv, Lei Cui, Yutong Lu, Furu Wei")]
+public partial class LayoutLMv3<T> : DocumentNeuralNetworkBase<T>, ILayoutDetector<T>, IDocumentQA<T>
+{
+    private readonly LayoutLMv3Options _options;
+
+    /// <inheritdoc/>
+    public override ModelOptions GetOptions() => _options;
+
+    #region Fields
+
+    private readonly bool _useNativeMode;
+    private readonly InferenceSession? _onnxSession;
+    private readonly ITokenizer _tokenizer;
+    private readonly IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>> _optimizer;
+    private readonly int _hiddenDim;
+    private readonly int _numLayers;
+    private readonly int _numHeads;
+    private readonly int _vocabSize;
+    private readonly int _numClasses;
+    private readonly int _patchSize;
+
+    // Native mode layers
+    private readonly List<ILayer<T>> _textEmbeddingLayers = [];
+    private readonly List<ILayer<T>> _imageEmbeddingLayers = [];
+    private readonly List<ILayer<T>> _transformerLayers = [];
+    private readonly List<ILayer<T>> _classificationLayers = [];
+
+    // Learnable embeddings
+    [AiDotNet.Attributes.TrainableParameter]
+    private Tensor<T>? _position1DEmbeddings;
+    [AiDotNet.Attributes.TrainableParameter]
+    private Tensor<T>? _position2DXEmbeddings;
+    [AiDotNet.Attributes.TrainableParameter]
+    private Tensor<T>? _position2DYEmbeddings;
+    [AiDotNet.Attributes.TrainableParameter]
+    private Tensor<T>? _segmentEmbeddings;
+
+    // Gradient storage
+    [Scratch]
+    private Tensor<T>? _position1DEmbeddingsGradients;
+    [Scratch]
+    private Tensor<T>? _position2DXEmbeddingsGradients;
+    [Scratch]
+    private Tensor<T>? _position2DYEmbeddingsGradients;
+
+    #endregion
+
+    #region Properties
+
+    /// <inheritdoc/>
+    public override DocumentType SupportedDocumentTypes => DocumentType.All;
+
+    /// <inheritdoc/>
+    public override bool RequiresOCR => true;
+
+    /// <inheritdoc/>
+    public int ExpectedImageSize => ImageSize;
+
+    /// <inheritdoc/>
+    public IReadOnlyList<LayoutElementType> SupportedElementTypes { get; } =
+    [
+        LayoutElementType.Text,
+        LayoutElementType.Title,
+        LayoutElementType.List,
+        LayoutElementType.Table,
+        LayoutElementType.Figure,
+        LayoutElementType.Caption,
+        LayoutElementType.Header,
+        LayoutElementType.Footer,
+        LayoutElementType.PageNumber,
+        LayoutElementType.FormField
+    ];
+
+    #endregion
+
+    #region Constructors
+
+    /// <summary>
+    /// Creates a LayoutLMv3 model using a pre-trained ONNX model for inference.
+    /// </summary>
+    /// <param name="architecture">The neural network architecture.</param>
+    /// <param name="onnxModelPath">Path to the ONNX model file.</param>
+    /// <param name="tokenizer">Tokenizer for text processing.</param>
+    /// <param name="numClasses">Number of output classes for classification tasks.</param>
+    /// <param name="imageSize">Expected input image size (default: 224).</param>
+    /// <param name="maxSequenceLength">Maximum sequence length (default: 512).</param>
+    /// <param name="hiddenDim">Hidden dimension size (default: 768).</param>
+    /// <param name="numLayers">Number of transformer layers (default: 12).</param>
+    /// <param name="numHeads">Number of attention heads (default: 12).</param>
+    /// <param name="vocabSize">Vocabulary size (default: 50265 for RoBERTa).</param>
+    /// <param name="optimizer">Optimizer for training (optional, Adam used if null).</param>
+    /// <param name="lossFunction">Loss function (optional, CrossEntropy used if null).</param>
+    /// <exception cref="ArgumentNullException">Thrown if onnxModelPath or tokenizer is null.</exception>
+    /// <exception cref="FileNotFoundException">Thrown if the ONNX model file doesn't exist.</exception>
+    public LayoutLMv3(
+        NeuralNetworkArchitecture<T> architecture,
+        string onnxModelPath,
+        ITokenizer tokenizer,
+        int numClasses = 17,
+        int imageSize = 224,
+        int maxSequenceLength = 512,
+        int hiddenDim = 768,
+        int numLayers = 12,
+        int numHeads = 12,
+        int vocabSize = 50265,
+        IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? optimizer = null,
+        ILossFunction<T>? lossFunction = null,
+        LayoutLMv3Options? options = null)
+        : base(architecture, lossFunction ?? new CrossEntropyWithLogitsLoss<T>(), 1.0)
+    {
+        _options = options ?? new LayoutLMv3Options();
+        Options = _options;
+
+        if (string.IsNullOrWhiteSpace(onnxModelPath))
+            throw new ArgumentNullException(nameof(onnxModelPath));
+
+        if (!File.Exists(onnxModelPath))
+            throw new FileNotFoundException($"ONNX model file not found: {onnxModelPath}", onnxModelPath);
+
+        Guard.NotNull(tokenizer);
+        _tokenizer = tokenizer;
+        _useNativeMode = false;
+        _numClasses = numClasses;
+        _hiddenDim = hiddenDim;
+        _numLayers = numLayers;
+        _numHeads = numHeads;
+        _vocabSize = vocabSize;
+        _patchSize = 16; // Default patch size for LayoutLMv3
+        _optimizer = optimizer ?? new AdamOptimizer<T, Tensor<T>, Tensor<T>>(this);
+
+        Guard.Positive(imageSize, nameof(imageSize));
+        ImageSize = imageSize;
+        MaxSequenceLength = maxSequenceLength;
+
+        _onnxSession = new InferenceSession(onnxModelPath);
+
+        InitializeLayers();
+    }
+
+    /// <summary>
+    /// Creates a LayoutLMv3 model using native layers for training and inference.
+    /// </summary>
+    /// <param name="architecture">The neural network architecture.</param>
+    /// <param name="tokenizer">Tokenizer for text processing (optional, default created if null).</param>
+    /// <param name="numClasses">Number of output classes for classification tasks.</param>
+    /// <param name="imageSize">Expected input image size (default: 224 from paper).</param>
+    /// <param name="patchSize">Vision transformer patch size (default: 16 from paper).</param>
+    /// <param name="maxSequenceLength">Maximum sequence length (default: 512).</param>
+    /// <param name="hiddenDim">Hidden dimension size (default: 768 for LayoutLMv3-Base).</param>
+    /// <param name="numLayers">Number of transformer layers (default: 12 for Base).</param>
+    /// <param name="numHeads">Number of attention heads (default: 12 for Base).</param>
+    /// <param name="vocabSize">Vocabulary size (default: 50265 for RoBERTa).</param>
+    /// <param name="optimizer">Optimizer for training (optional, Adam used if null).</param>
+    /// <param name="lossFunction">Loss function (optional, CrossEntropy used if null).</param>
+    /// <remarks>
+    /// <para>
+    /// <b>Default Configuration (LayoutLMv3-Base from ICCV 2022 paper):</b>
+    /// - Hidden dimension: 768
+    /// - Transformer layers: 12
+    /// - Attention heads: 12
+    /// - Image size: 224×224
+    /// - Patch size: 16
+    /// - Max sequence length: 512
+    /// </para>
+    /// </remarks>
+    public LayoutLMv3(
+        NeuralNetworkArchitecture<T> architecture,
+        ITokenizer? tokenizer = null,
+        int numClasses = 17,
+        int imageSize = 224,
+        int patchSize = 16,
+        int maxSequenceLength = 512,
+        int hiddenDim = 768,
+        int numLayers = 12,
+        int numHeads = 12,
+        int vocabSize = 50265,
+        IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? optimizer = null,
+        ILossFunction<T>? lossFunction = null,
+        LayoutLMv3Options? options = null)
+        : base(architecture, lossFunction ?? new CrossEntropyWithLogitsLoss<T>(), 1.0)
+    {
+        _options = options ?? new LayoutLMv3Options();
+        Options = _options;
+
+        _useNativeMode = true;
+        _numClasses = numClasses;
+        _hiddenDim = hiddenDim;
+        _numLayers = numLayers;
+        _numHeads = numHeads;
+        _vocabSize = vocabSize;
+        _patchSize = patchSize;
+
+        Guard.Positive(imageSize, nameof(imageSize));
+        ImageSize = imageSize;
+        MaxSequenceLength = maxSequenceLength;
+
+        _tokenizer = tokenizer ?? LanguageModelTokenizerFactory.CreateForBackbone(LanguageModelBackbone.RoBERTa);
+        _optimizer = optimizer ?? new AdamOptimizer<T, Tensor<T>, Tensor<T>>(this);
+
+        InitializeLayers();
+        InitializeEmbeddings();
+    }
+
+    #endregion
+
+    #region Initialization
+
+    /// <inheritdoc/>
+    protected override void InitializeLayers()
+    {
+        // In ONNX mode, layers are handled by ONNX runtime
+        if (!_useNativeMode)
+        {
+            return;
+        }
+
+        // Check if user provided custom layers
+        if (Architecture.Layers is not null && Architecture.Layers.Count > 0)
+        {
+            Layers.AddRange(Architecture.Layers);
+            ValidateCustomLayers(Layers);
+            PopulateLayerGroups();
+            return;
+        }
+
+        // Use LayerHelper to create default LayoutLMv3 layers
+        Layers.AddRange(LayerHelper<T>.CreateDefaultLayoutLMv3Layers(
+            Architecture,
+            hiddenDim: _hiddenDim,
+            numLayers: _numLayers,
+            numHeads: _numHeads,
+            vocabSize: _vocabSize,
+            imageSize: ImageSize,
+            patchSize: _patchSize,
+            numClasses: _numClasses));
+        PopulateLayerGroups();
+    }
+
+    private void PopulateLayerGroups()
+    {
+        _textEmbeddingLayers.Clear();
+        _imageEmbeddingLayers.Clear();
+        _transformerLayers.Clear();
+
+        bool reachedHead = false;
+        foreach (var layer in Layers)
+        {
+            if (IsClassificationHeadLayer(layer))
+            {
+                reachedHead = true;
+            }
+
+            if (reachedHead)
+            {
+                continue;
+            }
+
+            if (layer is EmbeddingLayer<T>)
+            {
+                _textEmbeddingLayers.Add(layer);
+            }
+            else if (layer is PatchEmbeddingLayer<T>)
+            {
+                _imageEmbeddingLayers.Add(layer);
+            }
+            else
+            {
+                _transformerLayers.Add(layer);
+            }
+        }
+    }
+
+    private static bool IsClassificationHeadLayer(ILayer<T> layer)
+    {
+        return layer is DenseLayer<T>;
+    }
+
+    private void InitializeEmbeddings()
+    {
+        var random = RandomHelper.CreateSeededRandom(42);
+
+        // 1D position embeddings for sequence position
+        _position1DEmbeddings = Tensor<T>.CreateDefault([MaxSequenceLength, _hiddenDim], NumOps.Zero);
+        InitializeWithSmallRandomValues(_position1DEmbeddings, random, 0.02);
+
+        // 2D position embeddings for bounding box coordinates (normalized 0-1000)
+        _position2DXEmbeddings = Tensor<T>.CreateDefault([1001, _hiddenDim], NumOps.Zero);
+        _position2DYEmbeddings = Tensor<T>.CreateDefault([1001, _hiddenDim], NumOps.Zero);
+        InitializeWithSmallRandomValues(_position2DXEmbeddings, random, 0.02);
+        InitializeWithSmallRandomValues(_position2DYEmbeddings, random, 0.02);
+
+        // Segment embeddings (text vs image)
+        _segmentEmbeddings = Tensor<T>.CreateDefault([2, _hiddenDim], NumOps.Zero);
+        InitializeWithSmallRandomValues(_segmentEmbeddings, random, 0.02);
+
+        // Initialize gradient tensors
+        _position1DEmbeddingsGradients = Tensor<T>.CreateDefault([MaxSequenceLength, _hiddenDim], NumOps.Zero);
+        _position2DXEmbeddingsGradients = Tensor<T>.CreateDefault([1001, _hiddenDim], NumOps.Zero);
+        _position2DYEmbeddingsGradients = Tensor<T>.CreateDefault([1001, _hiddenDim], NumOps.Zero);
+    }
+
+    private void InitializeWithSmallRandomValues(Tensor<T> tensor, Random random, double stdDev)
+    {
+        for (int i = 0; i < tensor.Data.Length; i++)
+        {
+            double u1 = 1.0 - random.NextDouble();
+            double u2 = 1.0 - random.NextDouble();
+            double randStdNormal = Math.Sqrt(-2.0 * Math.Log(u1)) * Math.Sin(2.0 * Math.PI * u2);
+            tensor.Data.Span[i] = NumOps.FromDouble(randStdNormal * stdDev);
+        }
+    }
+
+    #endregion
+
+    #region ILayoutDetector Implementation
+
+    /// <inheritdoc/>
+    public DocumentLayoutResult<T> DetectLayout(Tensor<T> documentImage)
+    {
+        return DetectLayout(documentImage, 0.5);
+    }
+
+    /// <inheritdoc/>
+    public DocumentLayoutResult<T> DetectLayout(Tensor<T> documentImage, double confidenceThreshold)
+    {
+        ValidateImageShape(documentImage);
+
+        var startTime = DateTime.UtcNow;
+
+        var result = _useNativeMode
+            ? DetectLayoutNative(documentImage, confidenceThreshold)
+            : DetectLayoutOnnx(documentImage, confidenceThreshold);
+
+        return new DocumentLayoutResult<T>
+        {
+            Regions = result.Regions,
+            ReadingOrder = result.ReadingOrder,
+            ProcessingTimeMs = (DateTime.UtcNow - startTime).TotalMilliseconds
+        };
+    }
+
+    private DocumentLayoutResult<T> DetectLayoutNative(Tensor<T> image, double threshold)
+    {
+        var input = PreprocessDocument(image);
+        var output = Forward(input);
+        return ParseLayoutOutput(output, threshold);
+    }
+
+    private DocumentLayoutResult<T> DetectLayoutOnnx(Tensor<T> image, double threshold)
+    {
+        if (_onnxSession is null)
+            throw new InvalidOperationException("ONNX session not initialized.");
+
+        var input = PreprocessDocument(image);
+        var output = RunOnnxInference(input);
+        return ParseLayoutOutput(output, threshold);
+    }
+
+    private DocumentLayoutResult<T> ParseLayoutOutput(Tensor<T> output, double threshold)
+    {
+        var regions = new List<LayoutRegion<T>>();
+
+        // Parse output tensor into layout regions
+        // Expected format: [numDetections, numClasses + 4] where last 4 are bbox coords
+        // Or: [numDetections, hiddenDim] where we extract class from first numClasses and bbox from last 4
+
+        int numDetections = output.Shape[0];
+        int numValues = output.Shape.Length > 1 ? output.Shape[1] : _numClasses;
+        int numClasses = Math.Max(0, Math.Min(numValues - 4, _numClasses));
+        bool hasBbox = numValues >= 4;
+
+        if (numClasses == 0)
+        {
+            return new DocumentLayoutResult<T>
+            {
+                Regions = regions
+            };
+        }
+
+        for (int i = 0; i < numDetections; i++)
+        {
+            // Find the class with highest confidence
+            double maxConf = 0;
+            int maxClass = 0;
+            for (int c = 0; c < numClasses; c++)
+            {
+                double conf = NumOps.ToDouble(output.Data.Span[i * numValues + c]);
+                if (conf > maxConf)
+                {
+                    maxConf = conf;
+                    maxClass = c;
+                }
+            }
+
+            if (maxConf >= threshold)
+            {
+                // Extract bounding box from last 4 values (normalized coordinates)
+                Vector<T> bbox;
+                if (hasBbox && numValues >= 4)
+                {
+                    int bboxOffset = i * numValues + numValues - 4;
+                    double x1 = NumOps.ToDouble(output.Data.Span[bboxOffset]) * ImageSize;
+                    double y1 = NumOps.ToDouble(output.Data.Span[bboxOffset + 1]) * ImageSize;
+                    double x2 = NumOps.ToDouble(output.Data.Span[bboxOffset + 2]) * ImageSize;
+                    double y2 = NumOps.ToDouble(output.Data.Span[bboxOffset + 3]) * ImageSize;
+
+                    bbox = new Vector<T>([
+                        NumOps.FromDouble(Math.Max(0, x1)),
+                        NumOps.FromDouble(Math.Max(0, y1)),
+                        NumOps.FromDouble(Math.Min(ImageSize, x2)),
+                        NumOps.FromDouble(Math.Min(ImageSize, y2))
+                    ]);
+                }
+                else
+                {
+                    // Estimate bbox from detection index (grid-based fallback)
+                    int gridSize = (int)Math.Sqrt(numDetections);
+                    int cellSize = ImageSize / Math.Max(1, gridSize);
+                    int row = i / gridSize;
+                    int col = i % gridSize;
+
+                    bbox = new Vector<T>([
+                        NumOps.FromDouble(col * cellSize),
+                        NumOps.FromDouble(row * cellSize),
+                        NumOps.FromDouble((col + 1) * cellSize),
+                        NumOps.FromDouble((row + 1) * cellSize)
+                    ]);
+                }
+
+                regions.Add(new LayoutRegion<T>
+                {
+                    ElementType = (LayoutElementType)Math.Min(maxClass, (int)LayoutElementType.Other),
+                    Confidence = NumOps.FromDouble(maxConf),
+                    ConfidenceValue = maxConf,
+                    Index = i,
+                    BoundingBox = bbox
+                });
+            }
+        }
+
+        return new DocumentLayoutResult<T>
+        {
+            Regions = regions
+        };
+    }
+
+    #endregion
+
+    #region IDocumentQA Implementation
+
+    /// <inheritdoc/>
+    public DocumentQAResult<T> AnswerQuestion(Tensor<T> documentImage, string question)
+    {
+        return AnswerQuestion(documentImage, question, 64, 0.0);
+    }
+
+    /// <inheritdoc/>
+    public DocumentQAResult<T> AnswerQuestion(Tensor<T> documentImage, string question, int maxAnswerLength, double temperature = 0.0)
+    {
+        ValidateImageShape(documentImage);
+
+        var startTime = DateTime.UtcNow;
+
+        var result = _useNativeMode
+            ? AnswerQuestionNative(documentImage, question, maxAnswerLength, temperature)
+            : AnswerQuestionOnnx(documentImage, question, maxAnswerLength, temperature);
+
+        return new DocumentQAResult<T>
+        {
+            Answer = result.Answer,
+            Confidence = result.Confidence,
+            ConfidenceValue = result.ConfidenceValue,
+            Evidence = result.Evidence,
+            AlternativeAnswers = result.AlternativeAnswers,
+            ProcessingTimeMs = (DateTime.UtcNow - startTime).TotalMilliseconds,
+            Question = question
+        };
+    }
+
+    private DocumentQAResult<T> AnswerQuestionNative(Tensor<T> image, string question, int maxLength, double temp)
+    {
+        // Process image
+        var imageFeatures = PreprocessDocument(image);
+
+        // Combine and run through model
+        var output = Forward(imageFeatures);
+
+        var (answer, confidence) = ExtractAnswer(output, maxLength, temp);
+
+        return new DocumentQAResult<T>
+        {
+            Answer = answer,
+            Confidence = NumOps.FromDouble(confidence),
+            ConfidenceValue = confidence
+        };
+    }
+
+    private DocumentQAResult<T> AnswerQuestionOnnx(Tensor<T> image, string question, int maxLength, double temp)
+    {
+        if (_onnxSession is null)
+            throw new InvalidOperationException("ONNX session not initialized.");
+
+        var imageFeatures = PreprocessDocument(image);
+        var output = RunOnnxInference(imageFeatures);
+
+        var (answer, confidence) = ExtractAnswer(output, maxLength, temp);
+
+        return new DocumentQAResult<T>
+        {
+            Answer = answer,
+            Confidence = NumOps.FromDouble(confidence),
+            ConfidenceValue = confidence
+        };
+    }
+
+    private (string answer, double confidence) ExtractAnswer(Tensor<T> output, int maxAnswerLength, double temperature)
+    {
+        var logits = NormalizeAnswerLogits(output);
+        if (logits.Shape.Length < 2)
+        {
+            return ("[No answer found]", 0.0);
+        }
+
+        int seqLen = logits.Shape[0];
+        int vocabSize = logits.Shape[1];
+        if (_vocabSize > 0)
+        {
+            vocabSize = Math.Min(vocabSize, _vocabSize);
+        }
+
+        if (seqLen <= 0 || vocabSize <= 0 || maxAnswerLength <= 0)
+        {
+            return ("[No answer found]", 0.0);
+        }
+
+        int maxLen = Math.Min(seqLen, maxAnswerLength);
+        var tokens = new List<int>(maxLen);
+        double confidenceSum = 0.0;
+        int confidenceCount = 0;
+
+        int eosId = GetSpecialTokenId(_tokenizer.SpecialTokens.EosToken);
+        int sepId = GetSpecialTokenId(_tokenizer.SpecialTokens.SepToken);
+        int padId = GetSpecialTokenId(_tokenizer.SpecialTokens.PadToken);
+        int clsId = GetSpecialTokenId(_tokenizer.SpecialTokens.ClsToken);
+
+        var random = RandomHelper.Shared;
+        bool sampleTokens = temperature > 0.0;
+
+        for (int i = 0; i < maxLen; i++)
+        {
+            int offset = i * logits.Shape[1];
+            int tokenId;
+            double tokenProb;
+
+            if (sampleTokens)
+            {
+                tokenId = SampleToken(logits, offset, vocabSize, temperature, random, out tokenProb);
+            }
+            else
+            {
+                tokenId = SelectGreedyToken(logits, offset, vocabSize, out tokenProb);
+            }
+
+            if ((eosId >= 0 && tokenId == eosId) || (sepId >= 0 && tokenId == sepId))
+            {
+                break;
+            }
+
+            if ((padId >= 0 && tokenId == padId) || (clsId >= 0 && tokenId == clsId))
+            {
+                continue;
+            }
+
+            tokens.Add(tokenId);
+            confidenceSum += tokenProb;
+            confidenceCount++;
+        }
+
+        if (tokens.Count == 0)
+        {
+            return ("[No answer found]", 0.0);
+        }
+
+        string answer = _tokenizer.Decode(tokens, skipSpecialTokens: true).Trim();
+        if (string.IsNullOrWhiteSpace(answer))
+        {
+            return ("[No answer found]", 0.0);
+        }
+
+        double confidence = confidenceCount > 0 ? confidenceSum / confidenceCount : 0.0;
+        return (answer, confidence);
+    }
+
+    private Tensor<T> NormalizeAnswerLogits(Tensor<T> output)
+    {
+        if (output.Shape.Length == 2)
+        {
+            return output;
+        }
+
+        if (output.Shape.Length == 3 && output.Shape[0] == 1)
+        {
+            return output.Reshape([output.Shape[1], output.Shape[2]]);
+        }
+
+        if (output.Shape.Length == 1)
+        {
+            if (_vocabSize > 0 && output.Length % _vocabSize == 0)
+            {
+                return output.Reshape([output.Length / _vocabSize, _vocabSize]);
+            }
+
+            return output.Reshape([1, output.Length]);
+        }
+
+        int lastDim = output.Shape[^1];
+        if (lastDim <= 0 || output.Length % lastDim != 0)
+        {
+            return output.Reshape([1, output.Length]);
+        }
+
+        int seqLen = output.Length / lastDim;
+        return output.Reshape([seqLen, lastDim]);
+    }
+
+    private int SelectGreedyToken(Tensor<T> logits, int offset, int vocabSize, out double probability)
+    {
+        double maxVal = double.MinValue;
+        int maxIdx = 0;
+
+        for (int v = 0; v < vocabSize; v++)
+        {
+            double val = NumOps.ToDouble(logits.Data.Span[offset + v]);
+            if (val > maxVal)
+            {
+                maxVal = val;
+                maxIdx = v;
+            }
+        }
+
+        double sumExp = 0.0;
+        for (int v = 0; v < vocabSize; v++)
+        {
+            double val = NumOps.ToDouble(logits.Data.Span[offset + v]);
+            sumExp += Math.Exp(val - maxVal);
+        }
+
+        probability = sumExp > 0 ? 1.0 / sumExp : 0.0;
+        return maxIdx;
+    }
+
+    private int SampleToken(Tensor<T> logits, int offset, int vocabSize, double temperature, Random random, out double probability)
+    {
+        double maxVal = double.MinValue;
+        for (int v = 0; v < vocabSize; v++)
+        {
+            double scaled = NumOps.ToDouble(logits.Data.Span[offset + v]) / temperature;
+            if (scaled > maxVal)
+            {
+                maxVal = scaled;
+            }
+        }
+
+        double sumExp = 0.0;
+        for (int v = 0; v < vocabSize; v++)
+        {
+            double scaled = NumOps.ToDouble(logits.Data.Span[offset + v]) / temperature;
+            sumExp += Math.Exp(scaled - maxVal);
+        }
+
+        if (sumExp <= 0.0)
+        {
+            probability = 0.0;
+            return 0;
+        }
+
+        double roll = random.NextDouble() * sumExp;
+        double cumulative = 0.0;
+        for (int v = 0; v < vocabSize; v++)
+        {
+            double scaled = NumOps.ToDouble(logits.Data.Span[offset + v]) / temperature;
+            double expVal = Math.Exp(scaled - maxVal);
+            cumulative += expVal;
+            if (cumulative >= roll)
+            {
+                probability = expVal / sumExp;
+                return v;
+            }
+        }
+
+        probability = 0.0;
+        return vocabSize - 1;
+    }
+
+    private int GetSpecialTokenId(string token)
+    {
+        if (string.IsNullOrWhiteSpace(token))
+        {
+            return -1;
+        }
+
+        var vocabulary = _tokenizer.Vocabulary;
+        if (!vocabulary.ContainsToken(token))
+        {
+            return -1;
+        }
+
+        return vocabulary.GetTokenId(token);
+    }
+
+    /// <inheritdoc/>
+    public IEnumerable<DocumentQAResult<T>> AnswerQuestions(Tensor<T> documentImage, IEnumerable<string> questions)
+    {
+        ValidateImageShape(documentImage);
+
+        foreach (var question in questions)
+        {
+            yield return AnswerQuestion(documentImage, question);
+        }
+    }
+
+    /// <inheritdoc/>
+    public Dictionary<string, DocumentQAResult<T>> ExtractFields(Tensor<T> documentImage, IEnumerable<string> fieldPrompts)
+    {
+        var results = new Dictionary<string, DocumentQAResult<T>>();
+
+        foreach (var field in fieldPrompts)
+        {
+            var question = $"What is the {field}?";
+            results[field] = AnswerQuestion(documentImage, question);
+        }
+
+        return results;
+    }
+
+    #endregion
+
+    #region IDocumentModel Implementation
+
+    /// <inheritdoc/>
+    public Tensor<T> EncodeDocument(Tensor<T> documentImage)
+    {
+        ValidateImageShape(documentImage);
+
+        var input = PreprocessDocument(documentImage);
+
+        if (_useNativeMode)
+        {
+            // Run through embedding and transformer layers only (not classification head)
+            var output = input;
+            if (_textEmbeddingLayers.Count == 0
+                && _imageEmbeddingLayers.Count == 0
+                && _transformerLayers.Count == 0)
+            {
+                foreach (var layer in Layers)
+                {
+                    if (IsClassificationHeadLayer(layer))
+                    {
+                        break;
+                    }
+                    output = layer.Forward(output);
+                }
+                return output;
+            }
+
+            foreach (var layer in _textEmbeddingLayers) output = layer.Forward(output);
+            foreach (var layer in _imageEmbeddingLayers) output = layer.Forward(output);
+            foreach (var layer in _transformerLayers) output = layer.Forward(output);
+            return output;
+        }
+        else
+        {
+            return RunOnnxInference(input);
+        }
+    }
+
+    /// <inheritdoc/>
+    public void ValidateInputShape(Tensor<T> documentImage)
+    {
+        ValidateImageShape(documentImage);
+    }
+
+    /// <inheritdoc/>
+    public string GetModelSummary()
+    {
+        var sb = new System.Text.StringBuilder();
+        sb.AppendLine("LayoutLMv3 Model Summary");
+        sb.AppendLine("========================");
+        sb.AppendLine($"Mode: {(_useNativeMode ? "Native (Trainable)" : "ONNX (Inference)")}");
+        sb.AppendLine($"Hidden Dimension: {_hiddenDim}");
+        sb.AppendLine($"Number of Layers: {_numLayers}");
+        sb.AppendLine($"Number of Attention Heads: {_numHeads}");
+        sb.AppendLine($"Vocabulary Size: {_vocabSize}");
+        sb.AppendLine($"Max Sequence Length: {MaxSequenceLength}");
+        sb.AppendLine($"Image Size: {ImageSize}x{ImageSize}");
+        sb.AppendLine($"Number of Classes: {_numClasses}");
+        sb.AppendLine($"Total Layers: {Layers.Count}");
+        sb.AppendLine($"Supported Document Types: {SupportedDocumentTypes}");
+        sb.AppendLine($"Requires OCR: {RequiresOCR}");
+        return sb.ToString();
+    }
+
+    #endregion
+
+    #region Preprocessing
+
+    /// <summary>
+    /// Applies LayoutLMv3's industry-standard preprocessing: ImageNet normalization.
+    /// </summary>
+    /// <remarks>
+    /// LayoutLMv3 (Microsoft paper) uses ImageNet normalization with mean=[0.485, 0.456, 0.406] and std=[0.229, 0.224, 0.225].
+    /// The unified architecture for multimodal document understanding.
+    /// </remarks>
+    protected override Tensor<T> ApplyDefaultPreprocessing(Tensor<T> rawImage)
+    {
+        var image = EnsureBatchDimension(rawImage);
+
+        int batchSize = image.Shape[0];
+        int channels = image.Shape[1];
+        int height = image.Shape[2];
+        int width = image.Shape[3];
+
+        // Resize to model's expected ImageSize if needed (bilinear interpolation)
+        if (height != ImageSize || width != ImageSize)
+        {
+            image = ResizeBilinear(image, batchSize, channels, height, width, ImageSize, ImageSize);
+            height = ImageSize;
+            width = ImageSize;
+        }
+
+        // ImageNet normalization: (x - mean) / std
+        var normalized = new Tensor<T>(image._shape);
+        double[] means = [0.485, 0.456, 0.406];
+        double[] stds = [0.229, 0.224, 0.225];
+
+        for (int b = 0; b < batchSize; b++)
+        {
+            for (int c = 0; c < channels; c++)
+            {
+                double mean = c < means.Length ? means[c] : 0.5;
+                double std = c < stds.Length ? stds[c] : 0.5;
+
+                for (int h = 0; h < height; h++)
+                {
+                    for (int w = 0; w < width; w++)
+                    {
+                        int idx = b * channels * height * width + c * height * width + h * width + w;
+                        double value = NumOps.ToDouble(image.Data.Span[idx]);
+                        normalized.Data.Span[idx] = NumOps.FromDouble((value - mean) / std);
+                    }
+                }
+            }
+        }
+
+        return normalized;
+    }
+
+    private Tensor<T> ResizeBilinear(Tensor<T> image, int batchSize, int channels,
+        int srcH, int srcW, int dstH, int dstW)
+    {
+        var resized = new Tensor<T>([batchSize, channels, dstH, dstW]);
+
+        double scaleH = (double)srcH / dstH;
+        double scaleW = (double)srcW / dstW;
+
+        for (int b = 0; b < batchSize; b++)
+        {
+            for (int c = 0; c < channels; c++)
+            {
+                int srcBaseIdx = b * channels * srcH * srcW + c * srcH * srcW;
+                int dstBaseIdx = b * channels * dstH * dstW + c * dstH * dstW;
+
+                for (int h = 0; h < dstH; h++)
+                {
+                    double srcY = (h + 0.5) * scaleH - 0.5;
+                    int y0 = Math.Max(0, (int)Math.Floor(srcY));
+                    int y1 = Math.Min(srcH - 1, y0 + 1);
+                    double fy = srcY - y0;
+
+                    for (int w = 0; w < dstW; w++)
+                    {
+                        double srcX = (w + 0.5) * scaleW - 0.5;
+                        int x0 = Math.Max(0, (int)Math.Floor(srcX));
+                        int x1 = Math.Min(srcW - 1, x0 + 1);
+                        double fx = srcX - x0;
+
+                        double v00 = NumOps.ToDouble(image.Data.Span[srcBaseIdx + y0 * srcW + x0]);
+                        double v01 = NumOps.ToDouble(image.Data.Span[srcBaseIdx + y0 * srcW + x1]);
+                        double v10 = NumOps.ToDouble(image.Data.Span[srcBaseIdx + y1 * srcW + x0]);
+                        double v11 = NumOps.ToDouble(image.Data.Span[srcBaseIdx + y1 * srcW + x1]);
+
+                        double val = v00 * (1 - fy) * (1 - fx) + v01 * (1 - fy) * fx
+                                   + v10 * fy * (1 - fx) + v11 * fy * fx;
+
+                        resized.Data.Span[dstBaseIdx + h * dstW + w] = NumOps.FromDouble(val);
+                    }
+                }
+            }
+        }
+
+        return resized;
+    }
+
+    /// <summary>
+    /// Applies LayoutLMv3's industry-standard postprocessing: softmax for classification outputs.
+    /// </summary>
+    protected override Tensor<T> ApplyDefaultPostprocessing(Tensor<T> modelOutput)
+    {
+        // Apply softmax for classification outputs
+        return ApplySoftmax(modelOutput);
+    }
+
+    private Tensor<T> ApplySoftmax(Tensor<T> input)
+    {
+        return Engine.Softmax(input, -1);
+    }
+
+    #endregion
+
+    #region Serialization
+
+    /// <inheritdoc/>
+    public override ModelMetadata<T> GetModelMetadata()
+    {
+        return new ModelMetadata<T>
+        {
+            Name = "LayoutLMv3",
+            Description = "LayoutLMv3 document understanding model with unified text and image pre-training",
+            FeatureCount = _hiddenDim,
+            Complexity = _numLayers,
+            AdditionalInfo = new Dictionary<string, object>
+            {
+                { "hidden_dim", _hiddenDim },
+                { "num_layers", _numLayers },
+                { "num_heads", _numHeads },
+                { "vocab_size", _vocabSize },
+                { "max_seq_length", MaxSequenceLength },
+                { "image_size", ImageSize },
+                { "patch_size", _patchSize },
+                { "num_classes", _numClasses },
+                { "use_native_mode", _useNativeMode }
+            },
+            ModelData = SafeSerialize()
+        };
+    }
+
+    /// <inheritdoc/>
+
+
+    /// <inheritdoc/>
+
+
+    private void SerializeTensor(BinaryWriter writer, Tensor<T> tensor)
+    {
+        writer.Write(tensor.Rank);
+        foreach (var dim in tensor._shape)
+            writer.Write(dim);
+
+        writer.Write(tensor.Data.Length);
+        foreach (var val in tensor.Data.ToArray())
+            writer.Write(NumOps.ToDouble(val));
+    }
+
+    private Tensor<T> DeserializeTensor(BinaryReader reader)
+    {
+        int rank = reader.ReadInt32();
+        int[] shape = new int[rank];
+        for (int i = 0; i < rank; i++)
+            shape[i] = reader.ReadInt32();
+
+        int length = reader.ReadInt32();
+        var tensor = new Tensor<T>(shape);
+        for (int i = 0; i < length; i++)
+            tensor.Data.Span[i] = NumOps.FromDouble(reader.ReadDouble());
+
+        return tensor;
+    }
+
+    #endregion
+
+    #region NeuralNetworkBase Implementation
+
+    /// <summary>
+    /// Overrides Forward to handle LayoutLMv3's multimodal architecture.
+    /// Image input is routed through image embedding (skipping text embedding),
+    /// then through transformer layers and classification head.
+    /// </summary>
+    protected override Tensor<T> Forward(Tensor<T> input)
+        => RunModalityForward(input);
+
+    // Modality-robust routing (LayoutLMv3, Huang et al. 2022): a token-ID input [Rank <= 2] runs the
+    // word-embedding stream while a document image [Rank >= 3] runs the ViT patch-embedding stream; both
+    // then flow through the shared multimodal transformer and classification head. The previous Forward
+    // ALWAYS ran the image (patch) embedding regardless of modality, so a token input hit
+    // "PatchEmbeddingLayer requires rank-3/rank-4 input; got rank 1" and never exercised the text stream.
+    private Tensor<T> RunModalityForward(Tensor<T> input)
+    {
+        // The layer groups are transient state populated at construction, NOT by the clone/deserialize
+        // path (base DeepCopy reconstructs Layers as NEW layer objects but never re-runs
+        // PopulateLayerGroups). A cloned model's groups would otherwise hold STALE references to the
+        // source model's layers: the reference-equality exclusion below then fails to exclude the
+        // clone's patch embedding, and the head loop runs it on a rank-2 transformer output ("got rank
+        // 2"). Repopulate from the current Layers whenever they are present so the routing tracks the
+        // live layer objects across Clone() and load-from-bytes.
+        if (Layers.Count > 0)
+            PopulateLayerGroups();
+
+        // Fallback to sequential processing if groups still not populated (no Layers yet).
+        if (_imageEmbeddingLayers.Count == 0 && _textEmbeddingLayers.Count == 0 && _transformerLayers.Count == 0)
+            return base.Forward(input);
+
+        var output = input;
+
+        // Route the input through the embedding stream that matches its modality.
+        if (input.Rank <= 2)
+            foreach (var layer in _textEmbeddingLayers)
+                output = layer.Forward(output);
+        else
+            foreach (var layer in _imageEmbeddingLayers)
+                output = layer.Forward(output);
+
+        // Shared multimodal transformer.
+        foreach (var layer in _transformerLayers)
+            output = layer.Forward(output);
+
+        // Classification head: every layer not in an embedding/transformer group.
+        var excludedLayers = new HashSet<ILayer<T>>(_imageEmbeddingLayers);
+        foreach (var l in _textEmbeddingLayers) excludedLayers.Add(l);
+        foreach (var l in _transformerLayers) excludedLayers.Add(l);
+
+        foreach (var layer in Layers.Where(l => !excludedLayers.Contains(l)))
+            output = layer.Forward(output);
+
+        return output;
+    }
+
+    /// <inheritdoc/>
+    public override Tensor<T> ForwardForTraining(Tensor<T> input)
+        => _useNativeMode ? RunModalityForward(input) : base.ForwardForTraining(input);
+
+    /// <inheritdoc/>
+    /// <remarks>
+    /// Diagnostic counterpart of <see cref="RunModalityForward"/>: the base walk sends a token-only input
+    /// into the rank-3-only patch embedding and throws before recording anything. Record only the layers
+    /// that fire for the supplied modality.
+    /// </remarks>
+    public override Dictionary<string, Tensor<T>> GetNamedLayerActivations(Tensor<T> input)
+    {
+        if (input is null)
+            throw new ArgumentNullException(nameof(input));
+
+        // Repopulate the transient layer groups from the current Layers so routing tracks the live
+        // layer objects across Clone()/load-from-bytes (see RunModalityForward remarks).
+        if (Layers.Count > 0)
+            PopulateLayerGroups();
+
+        if (!_useNativeMode
+            || (_imageEmbeddingLayers.Count == 0 && _textEmbeddingLayers.Count == 0 && _transformerLayers.Count == 0))
+            return base.GetNamedLayerActivations(input);
+
+        var activations = new Dictionary<string, Tensor<T>>();
+        var output = input;
+        var embeddingLayers = input.Rank <= 2 ? _textEmbeddingLayers : _imageEmbeddingLayers;
+
+        var excludedLayers = new HashSet<ILayer<T>>(_imageEmbeddingLayers);
+        foreach (var l in _textEmbeddingLayers) excludedLayers.Add(l);
+        foreach (var l in _transformerLayers) excludedLayers.Add(l);
+
+        int idx = 0;
+        foreach (var layer in embeddingLayers)
+        {
+            output = layer.Forward(output);
+            activations[$"Layer_{idx++}_{layer.GetType().Name}"] = output.Clone();
+        }
+        foreach (var layer in _transformerLayers)
+        {
+            output = layer.Forward(output);
+            activations[$"Layer_{idx++}_{layer.GetType().Name}"] = output.Clone();
+        }
+        foreach (var layer in Layers.Where(l => !excludedLayers.Contains(l)))
+        {
+            output = layer.Forward(output);
+            activations[$"Layer_{idx++}_{layer.GetType().Name}"] = output.Clone();
+        }
+        return activations;
+    }
+
+    /// <inheritdoc/>
+    protected override Tensor<T> PredictCore(Tensor<T> input)
+    {
+        var preprocessed = PreprocessDocument(input);
+
+        if (_useNativeMode)
+        {
+            return Forward(preprocessed);
+        }
+        else
+        {
+            return RunOnnxInference(preprocessed);
+        }
+    }
+
+    /// <inheritdoc/>
+    public override void Train(Tensor<T> input, Tensor<T> expectedOutput)
+    {
+        if (!_useNativeMode)
+        {
+            throw new NotSupportedException("Training is not supported in ONNX inference mode. Use native mode for training.");
+        }
+
+        SetTrainingMode(true);
+        try
+        {
+            TrainWithTape(input, expectedOutput, _optimizer);
+        }
+        finally
+        {
+            SetTrainingMode(false);
+        }
+    }
+
+    // UpdateParameters applied a GRADIENT STEP, but its one-argument form is the value setter and every caller passes values -- the override corrupted the model. Removed under AIDN082.
+
+
+    /// <summary>
+    /// Parameters cannot be written while the model is backed by a loaded ONNX graph: the weights
+    /// belong to that graph, not to this instance.
+    /// </summary>
+    /// <remarks>
+    /// Replaces a hand-written throw that used to sit inside UpdateParameters. The base checks this
+    /// on every mutating entry point rather than the one member the throw happened to guard, and
+    /// reading -- ParameterCount and GetParameters -- stays available either way.
+    /// </remarks>
     protected override bool SupportsParameterMutation => _useNativeMode;
-    private void UpdateEmbeddingGradients(Tensor<T> gradient)
-    {
-        // Update position embedding gradients (simplified)
-        if (_position1DEmbeddingsGradients is not null && gradient.Data.Length > 0)
-        {
-            int gradLen = Math.Min(gradient.Data.Length, _position1DEmbeddingsGradients.Data.Length);
-            for (int i = 0; i < gradLen; i++)
-            {
-                _position1DEmbeddingsGradients.Data.Span[i] = NumOps.Add(
-                    _position1DEmbeddingsGradients.Data.Span[i],
-                    gradient.Data.Span[i % gradient.Data.Length]);
-            }
-        }
-    }
-
-    private Vector<T> CollectParameterGradients()
-    {
-        var gradients = new List<T>();
-
-        // Collect gradients from all layers
-        foreach (var layer in Layers)
-        {
-            var layerGradients = layer.GetParameterGradients();
-            gradients.AddRange(layerGradients);
-        }
-
-        // Add embedding gradients
-        if (_position1DEmbeddingsGradients is not null)
-            gradients.AddRange(_position1DEmbeddingsGradients.Data.ToArray());
-        if (_position2DXEmbeddingsGradients is not null)
-            gradients.AddRange(_position2DXEmbeddingsGradients.Data.ToArray());
-        if (_position2DYEmbeddingsGradients is not null)
-            gradients.AddRange(_position2DYEmbeddingsGradients.Data.ToArray());
-
-        return new Vector<T>([.. gradients]);
-    }
-
-    #endregion
-
-    #region Disposal
-
-    /// <inheritdoc/>
-    protected override void Dispose(bool disposing)
-    {
-        if (disposing)
-        {
-            _onnxSession?.Dispose();
-        }
-        base.Dispose(disposing);
-    }
-
-    #endregion
-}
+    private void UpdateEmbeddingGradients(Tensor<T> gradient)
+    {
+        // Update position embedding gradients (simplified)
+        if (_position1DEmbeddingsGradients is not null && gradient.Data.Length > 0)
+        {
+            int gradLen = Math.Min(gradient.Data.Length, _position1DEmbeddingsGradients.Data.Length);
+            for (int i = 0; i < gradLen; i++)
+            {
+                _position1DEmbeddingsGradients.Data.Span[i] = NumOps.Add(
+                    _position1DEmbeddingsGradients.Data.Span[i],
+                    gradient.Data.Span[i % gradient.Data.Length]);
+            }
+        }
+    }
+
+    private Vector<T> CollectParameterGradients()
+    {
+        var gradients = new List<T>();
+
+        // Collect gradients from all layers
+        foreach (var layer in Layers)
+        {
+            var layerGradients = layer.GetParameterGradients();
+            gradients.AddRange(layerGradients);
+        }
+
+        // Add embedding gradients
+        if (_position1DEmbeddingsGradients is not null)
+            gradients.AddRange(_position1DEmbeddingsGradients.Data.ToArray());
+        if (_position2DXEmbeddingsGradients is not null)
+            gradients.AddRange(_position2DXEmbeddingsGradients.Data.ToArray());
+        if (_position2DYEmbeddingsGradients is not null)
+            gradients.AddRange(_position2DYEmbeddingsGradients.Data.ToArray());
+
+        return new Vector<T>([.. gradients]);
+    }
+
+    #endregion
+
+    #region Disposal
+
+    /// <inheritdoc/>
+    protected override void Dispose(bool disposing)
+    {
+        if (disposing)
+        {
+            _onnxSession?.Dispose();
+        }
+        base.Dispose(disposing);
+    }
+
+    #endregion
+}
diff --git a/src/Document/LayoutAware/LayoutXLM.cs b/src/Document/LayoutAware/LayoutXLM.cs
index e0add6c5dd..759b0821e6 100644
--- a/src/Document/LayoutAware/LayoutXLM.cs
+++ b/src/Document/LayoutAware/LayoutXLM.cs
@@ -1,946 +1,913 @@
-using AiDotNet.Attributes;
-using AiDotNet.Document.Interfaces;
-using AiDotNet.Document.Options;
-using AiDotNet.Enums;
-using AiDotNet.Helpers;
-using AiDotNet.Interfaces;
-using AiDotNet.LinearAlgebra;
-using AiDotNet.LossFunctions;
-using AiDotNet.NeuralNetworks;
-using AiDotNet.NeuralNetworks.Layers;
-using AiDotNet.Optimizers;
-using AiDotNet.Tokenization;
-using AiDotNet.Tokenization.Interfaces;
-using Microsoft.ML.OnnxRuntime;
-using AiDotNet.Validation;
-
-namespace AiDotNet.Document.LayoutAware;
-
-/// <summary>
-/// LayoutXLM neural network for multilingual document understanding.
-/// </summary>
-/// <typeparam name="T">The numeric type used for calculations.</typeparam>
-/// <remarks>
-/// <para>
-/// LayoutXLM extends LayoutLMv2 to support multilingual documents by using XLM-RoBERTa
-/// as the text backbone and training on documents from multiple languages.
-/// </para>
-/// <para>
-/// <b>For Beginners:</b> LayoutXLM understands documents in many languages:
-/// 1. Supports 53 languages out-of-the-box
-/// 2. Can handle mixed-language documents
-/// 3. Zero-shot cross-lingual transfer (train on one language, test on another)
-///
-/// Key features:
-/// - XLM-RoBERTa multilingual text encoder
-/// - Visual backbone (ResNeXt-FPN) for image features
-/// - Language-agnostic layout understanding
-/// - Pre-trained on XFUND dataset (7 languages)
-///
-/// Example usage:
-/// <code>
-/// var model = new LayoutXLM&lt;float&gt;(architecture);
-/// var result = model.DetectLayout(multilingualDocumentImage);
-/// </code>
-/// </para>
-/// <para>
-/// <b>Reference:</b> "LayoutXLM: Multimodal Pre-training for Multilingual Visually-rich Document Understanding" (ACL 2022)
-/// https://arxiv.org/abs/2104.08836
-/// </para>
-/// </remarks>
-[ModelDomain(ModelDomain.Vision)]
-[ModelDomain(ModelDomain.Language)]
-[ModelCategory(ModelCategory.NeuralNetwork)]
-[ModelCategory(ModelCategory.Transformer)]
-[ModelTask(ModelTask.Classification)]
-[ModelTask(ModelTask.Detection)]
+using AiDotNet.Attributes;
+using AiDotNet.Document.Interfaces;
+using AiDotNet.Document.Options;
+using AiDotNet.Enums;
+using AiDotNet.Helpers;
+using AiDotNet.Interfaces;
+using AiDotNet.LinearAlgebra;
+using AiDotNet.LossFunctions;
+using AiDotNet.NeuralNetworks;
+using AiDotNet.NeuralNetworks.Layers;
+using AiDotNet.Optimizers;
+using AiDotNet.Tokenization;
+using AiDotNet.Tokenization.Interfaces;
+using Microsoft.ML.OnnxRuntime;
+using AiDotNet.Validation;
+
+namespace AiDotNet.Document.LayoutAware;
+
+/// <summary>
+/// LayoutXLM neural network for multilingual document understanding.
+/// </summary>
+/// <typeparam name="T">The numeric type used for calculations.</typeparam>
+/// <remarks>
+/// <para>
+/// LayoutXLM extends LayoutLMv2 to support multilingual documents by using XLM-RoBERTa
+/// as the text backbone and training on documents from multiple languages.
+/// </para>
+/// <para>
+/// <b>For Beginners:</b> LayoutXLM understands documents in many languages:
+/// 1. Supports 53 languages out-of-the-box
+/// 2. Can handle mixed-language documents
+/// 3. Zero-shot cross-lingual transfer (train on one language, test on another)
+///
+/// Key features:
+/// - XLM-RoBERTa multilingual text encoder
+/// - Visual backbone (ResNeXt-FPN) for image features
+/// - Language-agnostic layout understanding
+/// - Pre-trained on XFUND dataset (7 languages)
+///
+/// Example usage:
+/// <code>
+/// var model = new LayoutXLM&lt;float&gt;(architecture);
+/// var result = model.DetectLayout(multilingualDocumentImage);
+/// </code>
+/// </para>
+/// <para>
+/// <b>Reference:</b> "LayoutXLM: Multimodal Pre-training for Multilingual Visually-rich Document Understanding" (ACL 2022)
+/// https://arxiv.org/abs/2104.08836
+/// </para>
+/// </remarks>
+[ModelDomain(ModelDomain.Vision)]
+[ModelDomain(ModelDomain.Language)]
+[ModelCategory(ModelCategory.NeuralNetwork)]
+[ModelCategory(ModelCategory.Transformer)]
+[ModelTask(ModelTask.Classification)]
+[ModelTask(ModelTask.Detection)]
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [RankRoutedInputDomain(2, 5)]
-[ResearchPaper("LayoutXLM: Multimodal Pre-training for Multilingual Visually-rich Document Understanding", "https://doi.org/10.48550/arXiv.2104.08836", Year = 2022, Authors = "Yiheng Xu, Tengchao Lv, Lei Cui, Guoxin Wang, Yijuan Lu, Dinei Florencio, Cha Zhang, Furu Wei")]
-public partial class LayoutXLM<T> : DocumentNeuralNetworkBase<T>, ILayoutDetector<T>, IDocumentQA<T>
-{
-    private readonly LayoutXLMOptions _options;
-
-    /// <inheritdoc/>
-    public override ModelOptions GetOptions() => _options;
-
-    #region Fields
-
-    private readonly bool _useNativeMode;
-    private readonly InferenceSession? _onnxSession;
-    private readonly ITokenizer _tokenizer;
-    private readonly IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>> _optimizer;
-    private readonly int _hiddenDim;
-    private readonly int _numLayers;
-    private readonly int _numHeads;
-    private readonly int _vocabSize;
-    private readonly int _numClasses;
-    private readonly int _visualBackboneChannels;
-    private readonly int _numLanguages;
-
-    // Native mode layers
-    private readonly List<ILayer<T>> _visualBackboneLayers = [];
-    private readonly List<ILayer<T>> _textEmbeddingLayers = [];
-    private readonly List<ILayer<T>> _transformerLayers = [];
-    private readonly List<ILayer<T>> _outputLayers = [];
-
-    // Learnable embeddings
-
-    #endregion
-
-    #region Properties
-
-    /// <inheritdoc/>
-    public override DocumentType SupportedDocumentTypes => DocumentType.All;
-
-    /// <inheritdoc/>
-    public override bool RequiresOCR => true;
-
-    /// <inheritdoc/>
-    public int ExpectedImageSize => ImageSize;
-
-    /// <summary>
-    /// Gets the number of languages supported.
-    /// </summary>
-    public int NumLanguages => _numLanguages;
-
-    /// <inheritdoc/>
-    public IReadOnlyList<LayoutElementType> SupportedElementTypes { get; } =
-    [
-        LayoutElementType.Text,
-        LayoutElementType.Title,
-        LayoutElementType.List,
-        LayoutElementType.Table,
-        LayoutElementType.Figure,
-        LayoutElementType.Caption,
-        LayoutElementType.Header,
-        LayoutElementType.Footer,
-        LayoutElementType.FormField
-    ];
-
-    #endregion
-
-    #region Constructors
-
-    /// <summary>
-    /// Creates a LayoutXLM model using a pre-trained ONNX model for inference.
-    /// </summary>
-    public LayoutXLM(
-        NeuralNetworkArchitecture<T> architecture,
-        string onnxModelPath,
-        ITokenizer tokenizer,
-        int numClasses = 7,
-        int imageSize = 224,
-        int maxSequenceLength = 512,
-        int hiddenDim = 768,
-        int numLayers = 12,
-        int numHeads = 12,
-        int vocabSize = 250002,
-        int visualBackboneChannels = 256,
-        int numLanguages = 53,
-        IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? optimizer = null,
-        ILossFunction<T>? lossFunction = null,
-        LayoutXLMOptions? options = null)
-        : base(architecture, lossFunction ?? new CrossEntropyWithLogitsLoss<T>(), 1.0)
-    {
-        _options = options ?? new LayoutXLMOptions();
-        Options = _options;
-
-        if (string.IsNullOrWhiteSpace(onnxModelPath))
-            throw new ArgumentNullException(nameof(onnxModelPath));
-        if (!File.Exists(onnxModelPath))
-            throw new FileNotFoundException($"ONNX model not found: {onnxModelPath}", onnxModelPath);
-
-        Guard.NotNull(tokenizer);
-        _tokenizer = tokenizer;
-        _useNativeMode = false;
-        _numClasses = numClasses;
-        _hiddenDim = hiddenDim;
-        _numLayers = numLayers;
-        _numHeads = numHeads;
-        _vocabSize = vocabSize;
-        _visualBackboneChannels = visualBackboneChannels;
-        _numLanguages = numLanguages;
-        _optimizer = optimizer ?? new AdamOptimizer<T, Tensor<T>, Tensor<T>>(this);
-
-        ImageSize = imageSize;
-        MaxSequenceLength = maxSequenceLength;
-
-        _onnxSession = new InferenceSession(onnxModelPath);
-
-        InitializeLayers();
-    }
-
-    /// <summary>
-    /// Creates a LayoutXLM model using native layers for training and inference.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// <b>Default Configuration (LayoutXLM-Base from ACL 2022):</b>
-    /// - Text encoder: XLM-RoBERTa-base architecture
-    /// - Visual backbone: ResNeXt-101 FPN
-    /// - Hidden dimension: 768
-    /// - Layers: 12, Heads: 12
-    /// - Vocabulary: 250,002 tokens (multilingual)
-    /// - Supports: 53 languages
-    /// </para>
-    /// </remarks>
-    public LayoutXLM(
-        NeuralNetworkArchitecture<T> architecture,
-        ITokenizer? tokenizer = null,
-        int numClasses = 7,
-        int imageSize = 224,
-        int maxSequenceLength = 512,
-        int hiddenDim = 768,
-        int numLayers = 12,
-        int numHeads = 12,
-        int vocabSize = 250002,
-        int visualBackboneChannels = 256,
-        int numLanguages = 53,
-        IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? optimizer = null,
-        ILossFunction<T>? lossFunction = null,
-        LayoutXLMOptions? options = null)
-        : base(architecture, lossFunction ?? new CrossEntropyWithLogitsLoss<T>(), 1.0)
-    {
-        _options = options ?? new LayoutXLMOptions();
-        Options = _options;
-
-        _useNativeMode = true;
-        _numClasses = numClasses;
-        _hiddenDim = hiddenDim;
-        _numLayers = numLayers;
-        _numHeads = numHeads;
-        _vocabSize = vocabSize;
-        _visualBackboneChannels = visualBackboneChannels;
-        _numLanguages = numLanguages;
-        _optimizer = optimizer ?? new AdamOptimizer<T, Tensor<T>, Tensor<T>>(this);
-
-        ImageSize = imageSize;
-        MaxSequenceLength = maxSequenceLength;
-
-        _tokenizer = tokenizer ?? LanguageModelTokenizerFactory.CreateForBackbone(LanguageModelBackbone.OPT);
-
-        InitializeLayers();
-        InitializeEmbeddings();
-    }
-
-    #endregion
-
-    #region Initialization
-
-    /// <summary>
-    /// Number of layers in <see cref="Layers"/> that form the ResNeXt-FPN visual backbone
-    /// (Conv7×7 → BN → MaxPool → Conv3×3 → visual-projection Dense). The text-only
-    /// inference path skips this prefix and starts at the XLM-RoBERTa token-embedding
-    /// layer; the full multimodal path runs the visual stream and concatenates with the
-    /// text stream at the transformer entry — both code paths are paper-explicit per
-    /// Xu et al. ACL 2022 §3.1 (which inherits LayoutLMv2's dual-stream design from
-    /// Xu et al. 2020 §3.1).
-    /// </summary>
-    private const int VisualBackbonePrefixLength = 5;
-
-    /// <inheritdoc/>
-    protected override void InitializeLayers()
-    {
-        if (!_useNativeMode)
-        {
-            return;
-        }
-
-        if (Architecture.Layers is not null && Architecture.Layers.Count > 0)
-        {
-            Layers.AddRange(Architecture.Layers);
-            ValidateCustomLayers(Layers);
-            return;
-        }
-
-        Layers.AddRange(LayerHelper<T>.CreateDefaultLayoutXLMLayers(
-            hiddenDim: _hiddenDim,
-            numLayers: _numLayers,
-            numHeads: _numHeads,
-            vocabSize: _vocabSize,
-            imageSize: ImageSize,
-            visualBackboneChannels: _visualBackboneChannels,
-            numClasses: _numClasses));
-    }
-
-    private void InitializeEmbeddings()
-    {
-        var random = RandomHelper.CreateSeededRandom(42);
-
-
-    }
-
-    private void InitializeWithSmallRandomValues(Tensor<T> tensor, Random random, double stdDev)
-    {
-        for (int i = 0; i < tensor.Data.Length; i++)
-        {
-            double u1 = 1.0 - random.NextDouble();
-            double u2 = 1.0 - random.NextDouble();
-            double randStdNormal = Math.Sqrt(-2.0 * Math.Log(u1)) * Math.Sin(2.0 * Math.PI * u2);
-            tensor.Data.Span[i] = NumOps.FromDouble(randStdNormal * stdDev);
-        }
-    }
-
-    #endregion
-
-    #region ILayoutDetector Implementation
-
-    /// <inheritdoc/>
-    public DocumentLayoutResult<T> DetectLayout(Tensor<T> documentImage)
-    {
-        return DetectLayout(documentImage, 0.5);
-    }
-
-    /// <inheritdoc/>
-    public DocumentLayoutResult<T> DetectLayout(Tensor<T> documentImage, double confidenceThreshold)
-    {
-        ValidateImageShape(documentImage);
-        var startTime = DateTime.UtcNow;
-
-        var preprocessed = PreprocessDocument(documentImage);
-        var output = _useNativeMode ? Forward(preprocessed) : RunOnnxInference(preprocessed);
-
-        var regions = ParseLayoutOutput(output, confidenceThreshold);
-
-        return new DocumentLayoutResult<T>
-        {
-            Regions = regions,
-            ProcessingTimeMs = (DateTime.UtcNow - startTime).TotalMilliseconds
-        };
-    }
-
-    private List<LayoutRegion<T>> ParseLayoutOutput(Tensor<T> output, double threshold)
-    {
-        var regions = new List<LayoutRegion<T>>();
-        int numDetections = output.Shape[0];
-        int numClasses = output.Shape.Length > 1 ? output.Shape[1] : _numClasses;
-
-        for (int i = 0; i < numDetections; i++)
-        {
-            double maxConf = 0;
-            int maxClass = 0;
-            for (int c = 0; c < numClasses; c++)
-            {
-                double conf = NumOps.ToDouble(output[i, c]);
-                if (conf > maxConf) { maxConf = conf; maxClass = c; }
-            }
-
-            if (maxConf >= threshold && maxClass > 0)
-            {
-                regions.Add(new LayoutRegion<T>
-                {
-                    ElementType = (LayoutElementType)Math.Min(maxClass, (int)LayoutElementType.Other),
-                    Confidence = NumOps.FromDouble(maxConf),
-                    ConfidenceValue = maxConf,
-                    Index = i,
-                    BoundingBox = Vector<T>.Empty()
-                });
-            }
-        }
-
-        return regions;
-    }
-
-    #endregion
-
-    #region IDocumentQA Implementation
-
-    /// <inheritdoc/>
-    public DocumentQAResult<T> AnswerQuestion(Tensor<T> documentImage, string question)
-    {
-        return AnswerQuestion(documentImage, question, 64, 0.0);
-    }
-
-    /// <inheritdoc/>
-    public DocumentQAResult<T> AnswerQuestion(Tensor<T> documentImage, string question, int maxAnswerLength, double temperature = 0.0)
-    {
-        ValidateImageShape(documentImage);
-        var startTime = DateTime.UtcNow;
-
-        var preprocessed = PreprocessDocument(documentImage);
-        var output = _useNativeMode ? Forward(preprocessed) : RunOnnxInference(preprocessed);
-
-        // Extract answer using start/end logits from model output
-        var (answer, confidence) = ExtractAnswer(output, maxAnswerLength);
-
-        return new DocumentQAResult<T>
-        {
-            Answer = answer,
-            Confidence = NumOps.FromDouble(confidence),
-            ConfidenceValue = confidence,
-            Question = question,
-            ProcessingTimeMs = (DateTime.UtcNow - startTime).TotalMilliseconds
-        };
-    }
-
-    /// <summary>
-    /// Extracts answer from model output using extractive QA approach.
-    /// </summary>
-    /// <remarks>
-    /// LayoutXLM outputs token-level predictions. For QA, we find the span
-    /// with highest start and end logits within the max answer length.
-    /// </remarks>
-    private (string answer, double confidence) ExtractAnswer(Tensor<T> output, int maxAnswerLength)
-    {
-        int seqLen = output.Shape[0];
-        int hiddenDim = output.Shape.Length > 1 ? output.Shape[1] : _hiddenDim;
-
-        // Find best start and end positions
-        double bestStartScore = double.MinValue;
-        double bestEndScore = double.MinValue;
-        int bestStart = 0;
-        int bestEnd = 0;
-
-        // Interpret first and last values in hidden dimension as start/end logits
-        for (int i = 0; i < seqLen; i++)
-        {
-            double startScore = NumOps.ToDouble(output[i, 0]);
-            if (startScore > bestStartScore)
-            {
-                bestStartScore = startScore;
-                bestStart = i;
-            }
-        }
-
-        // Find best end position after start within max answer length
-        int endSearchLimit = Math.Min(seqLen, bestStart + maxAnswerLength);
-        for (int i = bestStart; i < endSearchLimit; i++)
-        {
-            double endScore = NumOps.ToDouble(output[i, Math.Min(1, hiddenDim - 1)]);
-            if (endScore > bestEndScore)
-            {
-                bestEndScore = endScore;
-                bestEnd = i;
-            }
-        }
-
-        // Extract token sequence and convert to text
-        var tokens = new List<int>();
-        for (int i = bestStart; i <= bestEnd && i < seqLen; i++)
-        {
-            // Extract argmax token at this position
-            double maxVal = double.MinValue;
-            int maxIdx = 0;
-            for (int j = 0; j < Math.Min(hiddenDim, _vocabSize); j++)
-            {
-                double val = NumOps.ToDouble(output[i, j]);
-                if (val > maxVal) { maxVal = val; maxIdx = j; }
-            }
-            if (maxIdx > 0) tokens.Add(maxIdx);
-        }
-
-        string answer = DecodeTokensToText(tokens);
-        double confidence = Math.Max(0, Math.Min(1, (bestStartScore + bestEndScore) / 2.0));
-
-        return (string.IsNullOrEmpty(answer) ? "[No answer found]" : answer, confidence);
-    }
-
-    /// <summary>
-    /// Decodes token IDs to text using BERT-style vocabulary.
-    /// </summary>
-    private static string DecodeTokensToText(List<int> tokens)
-    {
-        if (tokens.Count == 0) return string.Empty;
-
-        var sb = new System.Text.StringBuilder();
-        foreach (int token in tokens)
-        {
-            // BERT vocabulary mapping (simplified)
-            char c = token switch
-            {
-                >= 1000 and <= 1031 => (char)(token - 1000 + 32),  // Space, punctuation
-                >= 1032 and <= 1057 => (char)(token - 1032 + 65),  // A-Z
-                >= 1058 and <= 1083 => (char)(token - 1058 + 97),  // a-z
-                >= 103 and <= 125 => (char)(token - 103 + 48),     // Digits
-                >= 126 and <= 151 => (char)(token - 126 + 65),     // A-Z
-                >= 152 and <= 177 => (char)(token - 152 + 97),     // a-z
-                _ => (char)((token % 95) + 32) // Fallback to printable ASCII
-            };
-            sb.Append(c);
-        }
-
-        return sb.ToString();
-    }
-
-    /// <inheritdoc/>
-    public IEnumerable<DocumentQAResult<T>> AnswerQuestions(Tensor<T> documentImage, IEnumerable<string> questions)
-    {
-        foreach (var q in questions)
-            yield return AnswerQuestion(documentImage, q);
-    }
-
-    /// <inheritdoc/>
-    public Dictionary<string, DocumentQAResult<T>> ExtractFields(Tensor<T> documentImage, IEnumerable<string> fieldPrompts)
-    {
-        var results = new Dictionary<string, DocumentQAResult<T>>();
-        foreach (var field in fieldPrompts)
-            results[field] = AnswerQuestion(documentImage, $"What is the {field}?");
-        return results;
-    }
-
-    #endregion
-
-    #region IDocumentModel Implementation
-
-    /// <inheritdoc/>
-    public Tensor<T> EncodeDocument(Tensor<T> documentImage)
-    {
-        ValidateImageShape(documentImage);
-        var preprocessed = PreprocessDocument(documentImage);
-        return _useNativeMode ? Forward(preprocessed) : RunOnnxInference(preprocessed);
-    }
-
-    /// <inheritdoc/>
-    public void ValidateInputShape(Tensor<T> documentImage)
-    {
-        ValidateImageShape(documentImage);
-    }
-
-    /// <inheritdoc/>
-    public string GetModelSummary()
-    {
-        var sb = new System.Text.StringBuilder();
-        sb.AppendLine("LayoutXLM Model Summary");
-        sb.AppendLine("=======================");
-        sb.AppendLine($"Mode: {(_useNativeMode ? "Native (Trainable)" : "ONNX (Inference)")}");
-        sb.AppendLine($"Architecture: XLM-RoBERTa + ResNeXt-FPN visual backbone");
-        sb.AppendLine($"Hidden Dimension: {_hiddenDim}");
-        sb.AppendLine($"Number of Layers: {_numLayers}");
-        sb.AppendLine($"Attention Heads: {_numHeads}");
-        sb.AppendLine($"Vocabulary Size: {_vocabSize}");
-        sb.AppendLine($"Visual Backbone Channels: {_visualBackboneChannels}");
-        sb.AppendLine($"Languages Supported: {_numLanguages}");
-        sb.AppendLine($"Image Size: {ImageSize}x{ImageSize}");
-        sb.AppendLine($"Max Sequence Length: {MaxSequenceLength}");
-        sb.AppendLine($"Number of Classes: {_numClasses}");
-        sb.AppendLine($"Multilingual: Yes");
-        sb.AppendLine($"Total Layers: {Layers.Count}");
-        return sb.ToString();
-    }
-
-    #endregion
-
-    #region Preprocessing
-
-    /// <summary>
-    /// Applies LayoutXLM's industry-standard preprocessing: ImageNet normalization.
-    /// </summary>
-    /// <remarks>
-    /// LayoutXLM (Microsoft paper) is the multilingual version of LayoutLMv2, using same ImageNet normalization.
-    /// </remarks>
-    protected override Tensor<T> ApplyDefaultPreprocessing(Tensor<T> rawImage)
-    {
-        var image = EnsureBatchDimension(rawImage);
-        int batchSize = image.Shape[0];
-        int channels = image.Shape[1];
-        int height = image.Shape[2];
-        int width = image.Shape[3];
-
-        var normalized = new Tensor<T>(image._shape);
-        double[] means = [0.485, 0.456, 0.406];
-        double[] stds = [0.229, 0.224, 0.225];
-
-        for (int b = 0; b < batchSize; b++)
-        {
-            for (int c = 0; c < channels; c++)
-            {
-                double mean = c < means.Length ? means[c] : 0.5;
-                double std = c < stds.Length ? stds[c] : 0.5;
-                for (int h = 0; h < height; h++)
-                {
-                    for (int w = 0; w < width; w++)
-                    {
-                        int idx = b * channels * height * width + c * height * width + h * width + w;
-                        normalized.Data.Span[idx] = NumOps.FromDouble((NumOps.ToDouble(image.Data.Span[idx]) - mean) / std);
-                    }
-                }
-            }
-        }
-        return normalized;
-    }
-
-    /// <summary>
-    /// Applies LayoutXLM's industry-standard postprocessing: pass-through (multilingual outputs are already final).
-    /// </summary>
-    protected override Tensor<T> ApplyDefaultPostprocessing(Tensor<T> modelOutput) => modelOutput;
-
-    #endregion
-
-    #region Serialization
-
-    /// <inheritdoc/>
-    public override ModelMetadata<T> GetModelMetadata()
-    {
-        // LayoutXLM has a very large embedding layer (250K+ vocab × 768 hidden dim = 192M+ params).
-        // Serializing all parameters to a byte array in GetModelMetadata would require ~1.5 GB of memory.
-        // Use file-based Save/Load for model persistence instead.
-        long totalParams = 0;
-        foreach (var layer in Layers)
-            totalParams += layer.GetParameters().Length;
-
-        return new ModelMetadata<T>
-        {
-            Name = "LayoutXLM",
-            Description = "LayoutXLM for multilingual document understanding (ACL 2022)",
-            FeatureCount = _hiddenDim,
-            Complexity = _numLayers,
-            AdditionalInfo = new Dictionary<string, object>
-            {
-                { "hidden_dim", _hiddenDim },
-                { "num_layers", _numLayers },
-                { "num_heads", _numHeads },
-                { "vocab_size", _vocabSize },
-                { "image_size", ImageSize },
-                { "visual_backbone_channels", _visualBackboneChannels },
-                { "num_classes", _numClasses },
-                { "num_languages", _numLanguages },
-                { "use_native_mode", _useNativeMode },
-                { "total_parameters", totalParams }
-            },
-            ModelData = totalParams > 50_000_000 ? Array.Empty<byte>() : this.Serialize()
-        };
-    }
-
-    /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_hiddenDim);
-        writer.Write(_numLayers);
-        writer.Write(_numHeads);
-        writer.Write(_vocabSize);
-        writer.Write(ImageSize);
-        writer.Write(MaxSequenceLength);
-        writer.Write(_visualBackboneChannels);
-        writer.Write(_numClasses);
-        writer.Write(_numLanguages);
-        writer.Write(_useNativeMode);
-    }
-
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        int hiddenDim = reader.ReadInt32();
-        int numLayers = reader.ReadInt32();
-        int numHeads = reader.ReadInt32();
-        int vocabSize = reader.ReadInt32();
-        int imageSize = reader.ReadInt32();
-        int maxSeqLen = reader.ReadInt32();
-        int visualChannels = reader.ReadInt32();
-        int numClasses = reader.ReadInt32();
-        int numLanguages = reader.ReadInt32();
-        bool useNativeMode = reader.ReadBoolean();
-
-        ImageSize = imageSize;
-        MaxSequenceLength = maxSeqLen;
-    }
-
-    /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new LayoutXLM<T>(Architecture, _tokenizer, _numClasses, ImageSize, MaxSequenceLength,
-            _hiddenDim, _numLayers, _numHeads, _vocabSize, _visualBackboneChannels, _numLanguages);
-    }
-
-    #endregion
-
-    #region NeuralNetworkBase Implementation
-
-    /// <inheritdoc/>
-    /// <remarks>
-    /// Per Xu et al. ACL 2022 §3.1, LayoutXLM (and its LayoutLMv2 backbone) admits two
-    /// paper-explicit operating modes:
-    /// <list type="bullet">
-    ///   <item>Full multimodal (<paramref name="input"/> is a rank-3/4 image tensor):
-    ///         the ResNeXt-FPN visual backbone produces visual tokens that are
-    ///         concatenated with the text-token sequence at the transformer entry.</item>
-    ///   <item>Text-only (<paramref name="input"/> is a rank-1/2 token-id tensor):
-    ///         the visual stream is skipped entirely — the original paper's MVLM
-    ///         pre-training objective explicitly masks the visual stream, and the
-    ///         downstream text-understanding fine-tunes (§4.2) run the same text-only
-    ///         path. The XLM-RoBERTa embedding stack at <c>VisualBackbonePrefixLength</c>
-    ///         is the entry point.</item>
-    /// </list>
-    /// We route by rank rather than by an explicit modality flag because that mirrors
-    /// the HuggingFace LayoutLMv2/XLM call surface: a single forward that infers the
-    /// modality from the supplied tensor's shape.
-    /// </remarks>
-    protected override Tensor<T> PredictCore(Tensor<T> input)
-    {
-        if (input is null)
-            throw new ArgumentNullException(nameof(input));
-
-        if (!_useNativeMode)
-        {
-            // ONNX models bake the modality into their compiled graph; defer all routing
-            // decisions to the ONNX runtime instead of second-guessing on the .NET side.
-            var preprocessed = PreprocessDocument(input);
-            return RunOnnxInference(preprocessed);
-        }
-
-        // Text-only path: rank-1 [seq] or rank-2 [batch, seq] token-id tensors enter at
-        // the XLM-RoBERTa embedding layer; the upstream Conv visual backbone is bypassed
-        // since there is no image to encode (paper §3.1, §4.2).
-        if (input.Rank <= 2)
-        {
-            return ForwardFromLayer(input, VisualBackbonePrefixLength);
-        }
-
-        // Image-only path: normalize the image and run the real visual stream (backbone -> visual
-        // tokens) through the transformer — NOT the base linear chain, which would feed the visual
-        // backbone output into the text embedding layer.
-        var preprocessedImage = PreprocessDocument(input);
-        return RunMultimodal(null, preprocessedImage);
-    }
-
-    /// <summary>
-    /// Runs the layer chain starting at <paramref name="startIndex"/> instead of layer
-    /// zero — the text-only counterpart of <see cref="DocumentNeuralNetworkBase{T}.Forward"/>
-    /// that lets the paper-supported text-stream-only operating mode bypass the visual
-    /// backbone prefix. Reuses the base class's auto-reshape contract so the eventual
-    /// hand-off from any remaining spatial layers to the transformer is identical.
-    /// </summary>
-    private Tensor<T> ForwardFromLayer(Tensor<T> input, int startIndex)
-    {
-        if (startIndex < 0 || startIndex > Layers.Count)
-            throw new ArgumentOutOfRangeException(nameof(startIndex),
-                $"startIndex must be in [0, {Layers.Count}], got {startIndex}.");
-
-        Tensor<T> output = input;
-        Tensor<T>? encoderOutput = null;
-        for (int i = startIndex; i < Layers.Count; i++)
-        {
-            var layer = Layers[i];
-            if (layer is TransformerDecoderLayer<T> decoderLayer)
-            {
-                encoderOutput ??= output;
-                output = decoderLayer.Forward(output, encoderOutput);
-            }
-            else
-            {
-                output = layer.Forward(output);
-            }
-        }
-        return output;
-    }
-
-    // Layer roles in CreateDefaultLayoutXLMLayers order: [0..VisualBackbonePrefixLength) = visual
-    // backbone (conv/BN/pool + a final C->hidden projection Dense), then 4 text-embedding layers, then
-    // the multimodal transformer + head. TextEmbeddingLayerCount mirrors LayoutLMv2's split.
-    // Three, not four: the token EmbeddingLayer and the sinusoidal PositionalEncodingLayer that
-    // used to open this section are now a single LayoutEmbeddingLayer, which also carries the 2D
-    // layout terms. The LayerNorm and Dropout after them are unchanged.
-    private const int TextEmbeddingLayerCount = 3;
-
-    /// <summary>
-    /// Full text+image fusion entry (industry-standard LayoutXLM): encodes BOTH a token-ID sequence and
-    /// a document image through the two visual/text streams and fuses them via the transformer. Reference
-    /// LayoutXLM requires both; the single-input Predict path additionally supports each modality alone.
-    /// </summary>
-    public Tensor<T> EncodeMultimodal(Tensor<T> textTokens, Tensor<T> documentImage)
-    {
-        // Inference entry: mirror Predict()/PredictCore by suppressing gradient-tape recording
-        // (PyTorch torch.no_grad() semantics). RunMultimodal issues raw Engine.Reshape/Permute/
-        // Concatenate ops that would otherwise record onto the shared autodiff tape; if a prior
-        // training pass left that singleton tape non-empty, replaying it here poisons the fusion
-        // forward with stale/NaN buffers. NoGradScope makes this direct call as tape-clean as
-        // the Predict()-wrapped image-only path. ForwardForTraining keeps recording (no scope).
-        using var _ = new AiDotNet.Tensors.Engines.Autodiff.NoGradScope<T>();
-        return RunMultimodal(textTokens, PreprocessDocument(documentImage));
-    }
-
-    // Runs LayoutXLM's real two-stream forward: independent visual and text streams (whichever are
-    // present) concatenated on the sequence axis, then the shared multimodal transformer + head. Unlike
-    // ForwardFromLayer (text-only prefix skip), this actually encodes the image as visual tokens rather
-    // than chaining the conv backbone into the text embedding.
-    private Tensor<T> RunMultimodal(Tensor<T>? textTokens, Tensor<T>? documentImage)
-    {
-        Tensor<T>? textSeq = textTokens is not null ? RunTextStream(textTokens) : null;
-        Tensor<T>? visualSeq = documentImage is not null ? RunVisualStream(documentImage) : null;
-
-        Tensor<T> seq;
-        if (textSeq is not null && visualSeq is not null)
-        {
-            // Fuse the two streams the way LayoutXLM (Xu et al. 2021, §3.1) does: stack the visual
-            // token sequence and the text token sequence along the SEQUENCE axis into one joint
-            // sequence, then run the shared multimodal transformer over it. Both streams must first
-            // agree on layout — the visual backbone emits a batched [B, Lvis, D] but the text stream
-            // can emit an unbatched [Ltext, D] (and a continuous-valued token tensor projects to
-            // [1, D]); normalize both to [B, L, D] so the concatenation matches on batch and hidden
-            // and only grows the sequence axis. Concatenating on axis 0 with mismatched ranks (the
-            // previous behavior) was invalid and only appeared to work when the output buffer's
-            // unwritten tail happened to be zero.
-            var vis = AlignToBatchedSequence(visualSeq);
-            var txt = AlignToBatchedSequence(textSeq);
-            seq = Engine.TensorConcatenate([vis, txt], axis: 1);
-        }
-        else
-            seq = textSeq ?? visualSeq
-                ?? throw new ArgumentException("LayoutXLM requires text token IDs (rank <= 2) or a document image (rank >= 3).");
-
-        for (int i = VisualBackbonePrefixLength + TextEmbeddingLayerCount; i < Layers.Count; i++)
-            seq = Layers[i].Forward(seq);
-        return seq;
-    }
-
-    // Normalizes a token sequence to a batched [B, L, D] layout so the two fusion streams concatenate
-    // cleanly on the sequence axis. A [L, D] stream (unbatched, e.g. the text embedding on a rank-1
-    // token vector) gains a leading batch of 1; a continuous [1, D] projection becomes a single-token
-    // [1, 1, D]; an already-batched [B, L, D] passes through unchanged.
-    private Tensor<T> AlignToBatchedSequence(Tensor<T> t)
-    {
-        if (t.Rank == 3) return t;
-        if (t.Rank == 2) return Engine.Reshape(t, new[] { 1, t.Shape[0], t.Shape[1] });
-        throw new ArgumentException($"Fusion stream must be rank 2 or 3, got rank {t.Rank}.");
-    }
-
-    private Tensor<T> RunTextStream(Tensor<T> textTokens)
-    {
-        var x = textTokens;
-        for (int i = VisualBackbonePrefixLength; i < VisualBackbonePrefixLength + TextEmbeddingLayerCount && i < Layers.Count; i++)
-            x = Layers[i].Forward(x);
-        return x;
-    }
-
-    private Tensor<T> RunVisualStream(Tensor<T> documentImage)
-    {
-        var x = documentImage;
-        int projIndex = VisualBackbonePrefixLength - 1;
-        for (int i = 0; i < projIndex; i++)
-            x = Layers[i].Forward(x);
-        x = FlattenSpatialToTokens(x);
-        if (projIndex >= 0 && projIndex < Layers.Count)
-            x = Layers[projIndex].Forward(x);
-        return x;
-    }
-
-    // [C, H, W] -> [H*W, C]; [B, C, H, W] -> [B, H*W, C].
-    private Tensor<T> FlattenSpatialToTokens(Tensor<T> feat)
-    {
-        if (feat.Rank == 4)
-        {
-            int b = feat.Shape[0], c = feat.Shape[1], n = feat.Shape[2] * feat.Shape[3];
-            return Engine.TensorPermute(Engine.Reshape(feat, new[] { b, c, n }), new[] { 0, 2, 1 });
-        }
-        if (feat.Rank == 3)
-        {
-            int c = feat.Shape[0], n = feat.Shape[1] * feat.Shape[2];
-            return Engine.TensorPermute(Engine.Reshape(feat, new[] { c, n }), new[] { 1, 0 });
-        }
-        return feat;
-    }
-
-    /// <inheritdoc/>
-    /// <remarks>
-    /// Training-mode counterpart of <see cref="Predict"/>'s modality routing. Without
-    /// this override, <see cref="NeuralNetworkBase{T}.ForwardForTraining"/> walks
-    /// <c>Layers</c> from index 0, sending text-only inputs into the rank-4-only Conv
-    /// visual backbone and throwing immediately. Routing here keeps the dual-stream
-    /// semantics consistent across Predict and Train so a model trained on text-only
-    /// data (paper §4.2 fine-tunes) sees the same code path on inference.
-    /// </remarks>
-    public override Tensor<T> ForwardForTraining(Tensor<T> input)
-    {
-        if (input is null)
-            throw new ArgumentNullException(nameof(input));
-
-        if (_useNativeMode && input.Rank <= 2)
-        {
-            return ForwardFromLayer(input, VisualBackbonePrefixLength);
-        }
-        // Image-only training input: run the real visual stream, not the base linear chain.
-        return _useNativeMode ? RunMultimodal(null, input) : base.ForwardForTraining(input);
-    }
-
-    /// <inheritdoc/>
-    /// <remarks>
-    /// Diagnostic counterpart of <see cref="Predict"/>'s modality routing for the
-    /// inspector path that the base implementation walks <c>Layers</c> from index 0 on
-    /// (used by the model-family scaffold's <c>NamedLayerActivations_ShouldBeNonEmpty</c>
-    /// probe and the public introspection surface). Text-only callers skip the visual
-    /// backbone prefix — paper §3.4 says the visual stream is omitted under MVLM-style
-    /// text-only operation — so the dictionary still reports a sensible non-empty set of
-    /// activations for the layers that actually fired, rather than throwing at the Conv7×7
-    /// when no image was supplied.
-    /// </remarks>
-    public override Dictionary<string, Tensor<T>> GetNamedLayerActivations(Tensor<T> input)
-    {
-        if (input is null)
-            throw new ArgumentNullException(nameof(input));
-
-        if (!_useNativeMode)
-            return base.GetNamedLayerActivations(input);
-
-        int startIndex = input.Rank <= 2 ? VisualBackbonePrefixLength : 0;
-        var activations = new Dictionary<string, Tensor<T>>();
-        var current = input;
-        Tensor<T>? encoderOutput = null;
-        for (int i = startIndex; i < Layers.Count; i++)
-        {
-            var layer = Layers[i];
-            if (layer is TransformerDecoderLayer<T> decoderLayer)
-            {
-                encoderOutput ??= current;
-                current = decoderLayer.Forward(current, encoderOutput);
-            }
-            else
-            {
-                current = layer.Forward(current);
-            }
-            activations[$"Layer_{i}_{layer.GetType().Name}"] = current.Clone();
-        }
-        return activations;
-    }
-
-    /// <inheritdoc/>
-    /// <remarks>
-    /// Per Xu et al. ACL 2022 §3.3 (and the LayoutLMv2 training recipe it inherits),
-    /// LayoutXLM is trained end-to-end with AdamW (β1=0.9, β2=0.999, weight-decay=0.01,
-    /// learning rate 2e-5 with linear warmup over 10 % of steps then linear decay).
-    /// <see cref="NeuralNetworkBase{T}.TrainWithTape"/> already applies that optimizer
-    /// step through <see cref="_optimizer"/> (defaulted to <see cref="AdamOptimizer{T, TInput, TOutput}"/>
-    /// in the constructor) — the previous implementation also called
-    /// <c>UpdateParameters(CollectGradients())</c> AFTER TrainWithTape, applying a
-    /// second naive SGD update at fixed lr=5e-5 on top of the AdamW update. That
-    /// double-step counted every gradient twice, broke the AdamW first/second-moment
-    /// invariants, and is the root cause of monotonic-loss-decrease test failures
-    /// (<c>Training_ShouldReduceLoss</c>, <c>TrainingError_ShouldNotExceedTestError</c>).
-    /// Drop the manual second step so training follows the paper exactly.
-    /// </remarks>
-    public override void Train(Tensor<T> input, Tensor<T> expectedOutput)
-    {
-        if (!_useNativeMode)
-            throw new NotSupportedException("Training not supported in ONNX mode.");
-
-        SetTrainingMode(true);
-        TrainWithTape(input, expectedOutput, _optimizer);
-        SetTrainingMode(false);
-    }
-
-    // UpdateParameters applied a GRADIENT STEP, but its one-argument form is the value setter and every caller passes values -- the override corrupted the model. Removed under AIDN082.

-
-    /// <summary>
-    /// Parameters cannot be written while the model is backed by a loaded ONNX graph: the weights
-    /// belong to that graph, not to this instance.
-    /// </summary>
-    /// <remarks>
-    /// Replaces a hand-written throw that used to sit inside UpdateParameters. The base checks this
-    /// on every mutating entry point rather than the one member the throw happened to guard, and
-    /// reading -- ParameterCount and GetParameters -- stays available either way.
-    /// </remarks>
+[ResearchPaper("LayoutXLM: Multimodal Pre-training for Multilingual Visually-rich Document Understanding", "https://doi.org/10.48550/arXiv.2104.08836", Year = 2022, Authors = "Yiheng Xu, Tengchao Lv, Lei Cui, Guoxin Wang, Yijuan Lu, Dinei Florencio, Cha Zhang, Furu Wei")]
+public partial class LayoutXLM<T> : DocumentNeuralNetworkBase<T>, ILayoutDetector<T>, IDocumentQA<T>
+{
+    private readonly LayoutXLMOptions _options;
+
+    /// <inheritdoc/>
+    public override ModelOptions GetOptions() => _options;
+
+    #region Fields
+
+    private readonly bool _useNativeMode;
+    private readonly InferenceSession? _onnxSession;
+    private readonly ITokenizer _tokenizer;
+    private readonly IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>> _optimizer;
+    private readonly int _hiddenDim;
+    private readonly int _numLayers;
+    private readonly int _numHeads;
+    private readonly int _vocabSize;
+    private readonly int _numClasses;
+    private readonly int _visualBackboneChannels;
+    private readonly int _numLanguages;
+
+    // Native mode layers
+    private readonly List<ILayer<T>> _visualBackboneLayers = [];
+    private readonly List<ILayer<T>> _textEmbeddingLayers = [];
+    private readonly List<ILayer<T>> _transformerLayers = [];
+    private readonly List<ILayer<T>> _outputLayers = [];
+
+    // Learnable embeddings
+
+    #endregion
+
+    #region Properties
+
+    /// <inheritdoc/>
+    public override DocumentType SupportedDocumentTypes => DocumentType.All;
+
+    /// <inheritdoc/>
+    public override bool RequiresOCR => true;
+
+    /// <inheritdoc/>
+    public int ExpectedImageSize => ImageSize;
+
+    /// <summary>
+    /// Gets the number of languages supported.
+    /// </summary>
+    public int NumLanguages => _numLanguages;
+
+    /// <inheritdoc/>
+    public IReadOnlyList<LayoutElementType> SupportedElementTypes { get; } =
+    [
+        LayoutElementType.Text,
+        LayoutElementType.Title,
+        LayoutElementType.List,
+        LayoutElementType.Table,
+        LayoutElementType.Figure,
+        LayoutElementType.Caption,
+        LayoutElementType.Header,
+        LayoutElementType.Footer,
+        LayoutElementType.FormField
+    ];
+
+    #endregion
+
+    #region Constructors
+
+    /// <summary>
+    /// Creates a LayoutXLM model using a pre-trained ONNX model for inference.
+    /// </summary>
+    public LayoutXLM(
+        NeuralNetworkArchitecture<T> architecture,
+        string onnxModelPath,
+        ITokenizer tokenizer,
+        int numClasses = 7,
+        int imageSize = 224,
+        int maxSequenceLength = 512,
+        int hiddenDim = 768,
+        int numLayers = 12,
+        int numHeads = 12,
+        int vocabSize = 250002,
+        int visualBackboneChannels = 256,
+        int numLanguages = 53,
+        IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? optimizer = null,
+        ILossFunction<T>? lossFunction = null,
+        LayoutXLMOptions? options = null)
+        : base(architecture, lossFunction ?? new CrossEntropyWithLogitsLoss<T>(), 1.0)
+    {
+        _options = options ?? new LayoutXLMOptions();
+        Options = _options;
+
+        if (string.IsNullOrWhiteSpace(onnxModelPath))
+            throw new ArgumentNullException(nameof(onnxModelPath));
+        if (!File.Exists(onnxModelPath))
+            throw new FileNotFoundException($"ONNX model not found: {onnxModelPath}", onnxModelPath);
+
+        Guard.NotNull(tokenizer);
+        _tokenizer = tokenizer;
+        _useNativeMode = false;
+        _numClasses = numClasses;
+        _hiddenDim = hiddenDim;
+        _numLayers = numLayers;
+        _numHeads = numHeads;
+        _vocabSize = vocabSize;
+        _visualBackboneChannels = visualBackboneChannels;
+        _numLanguages = numLanguages;
+        _optimizer = optimizer ?? new AdamOptimizer<T, Tensor<T>, Tensor<T>>(this);
+
+        ImageSize = imageSize;
+        MaxSequenceLength = maxSequenceLength;
+
+        _onnxSession = new InferenceSession(onnxModelPath);
+
+        InitializeLayers();
+    }
+
+    /// <summary>
+    /// Creates a LayoutXLM model using native layers for training and inference.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// <b>Default Configuration (LayoutXLM-Base from ACL 2022):</b>
+    /// - Text encoder: XLM-RoBERTa-base architecture
+    /// - Visual backbone: ResNeXt-101 FPN
+    /// - Hidden dimension: 768
+    /// - Layers: 12, Heads: 12
+    /// - Vocabulary: 250,002 tokens (multilingual)
+    /// - Supports: 53 languages
+    /// </para>
+    /// </remarks>
+    public LayoutXLM(
+        NeuralNetworkArchitecture<T> architecture,
+        ITokenizer? tokenizer = null,
+        int numClasses = 7,
+        int imageSize = 224,
+        int maxSequenceLength = 512,
+        int hiddenDim = 768,
+        int numLayers = 12,
+        int numHeads = 12,
+        int vocabSize = 250002,
+        int visualBackboneChannels = 256,
+        int numLanguages = 53,
+        IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? optimizer = null,
+        ILossFunction<T>? lossFunction = null,
+        LayoutXLMOptions? options = null)
+        : base(architecture, lossFunction ?? new CrossEntropyWithLogitsLoss<T>(), 1.0)
+    {
+        _options = options ?? new LayoutXLMOptions();
+        Options = _options;
+
+        _useNativeMode = true;
+        _numClasses = numClasses;
+        _hiddenDim = hiddenDim;
+        _numLayers = numLayers;
+        _numHeads = numHeads;
+        _vocabSize = vocabSize;
+        _visualBackboneChannels = visualBackboneChannels;
+        _numLanguages = numLanguages;
+        _optimizer = optimizer ?? new AdamOptimizer<T, Tensor<T>, Tensor<T>>(this);
+
+        ImageSize = imageSize;
+        MaxSequenceLength = maxSequenceLength;
+
+        _tokenizer = tokenizer ?? LanguageModelTokenizerFactory.CreateForBackbone(LanguageModelBackbone.OPT);
+
+        InitializeLayers();
+        InitializeEmbeddings();
+    }
+
+    #endregion
+
+    #region Initialization
+
+    /// <summary>
+    /// Number of layers in <see cref="Layers"/> that form the ResNeXt-FPN visual backbone
+    /// (Conv7×7 → BN → MaxPool → Conv3×3 → visual-projection Dense). The text-only
+    /// inference path skips this prefix and starts at the XLM-RoBERTa token-embedding
+    /// layer; the full multimodal path runs the visual stream and concatenates with the
+    /// text stream at the transformer entry — both code paths are paper-explicit per
+    /// Xu et al. ACL 2022 §3.1 (which inherits LayoutLMv2's dual-stream design from
+    /// Xu et al. 2020 §3.1).
+    /// </summary>
+    private const int VisualBackbonePrefixLength = 5;
+
+    /// <inheritdoc/>
+    protected override void InitializeLayers()
+    {
+        if (!_useNativeMode)
+        {
+            return;
+        }
+
+        if (Architecture.Layers is not null && Architecture.Layers.Count > 0)
+        {
+            Layers.AddRange(Architecture.Layers);
+            ValidateCustomLayers(Layers);
+            return;
+        }
+
+        Layers.AddRange(LayerHelper<T>.CreateDefaultLayoutXLMLayers(
+            hiddenDim: _hiddenDim,
+            numLayers: _numLayers,
+            numHeads: _numHeads,
+            vocabSize: _vocabSize,
+            imageSize: ImageSize,
+            visualBackboneChannels: _visualBackboneChannels,
+            numClasses: _numClasses));
+    }
+
+    private void InitializeEmbeddings()
+    {
+        var random = RandomHelper.CreateSeededRandom(42);
+
+
+    }
+
+    private void InitializeWithSmallRandomValues(Tensor<T> tensor, Random random, double stdDev)
+    {
+        for (int i = 0; i < tensor.Data.Length; i++)
+        {
+            double u1 = 1.0 - random.NextDouble();
+            double u2 = 1.0 - random.NextDouble();
+            double randStdNormal = Math.Sqrt(-2.0 * Math.Log(u1)) * Math.Sin(2.0 * Math.PI * u2);
+            tensor.Data.Span[i] = NumOps.FromDouble(randStdNormal * stdDev);
+        }
+    }
+
+    #endregion
+
+    #region ILayoutDetector Implementation
+
+    /// <inheritdoc/>
+    public DocumentLayoutResult<T> DetectLayout(Tensor<T> documentImage)
+    {
+        return DetectLayout(documentImage, 0.5);
+    }
+
+    /// <inheritdoc/>
+    public DocumentLayoutResult<T> DetectLayout(Tensor<T> documentImage, double confidenceThreshold)
+    {
+        ValidateImageShape(documentImage);
+        var startTime = DateTime.UtcNow;
+
+        var preprocessed = PreprocessDocument(documentImage);
+        var output = _useNativeMode ? Forward(preprocessed) : RunOnnxInference(preprocessed);
+
+        var regions = ParseLayoutOutput(output, confidenceThreshold);
+
+        return new DocumentLayoutResult<T>
+        {
+            Regions = regions,
+            ProcessingTimeMs = (DateTime.UtcNow - startTime).TotalMilliseconds
+        };
+    }
+
+    private List<LayoutRegion<T>> ParseLayoutOutput(Tensor<T> output, double threshold)
+    {
+        var regions = new List<LayoutRegion<T>>();
+        int numDetections = output.Shape[0];
+        int numClasses = output.Shape.Length > 1 ? output.Shape[1] : _numClasses;
+
+        for (int i = 0; i < numDetections; i++)
+        {
+            double maxConf = 0;
+            int maxClass = 0;
+            for (int c = 0; c < numClasses; c++)
+            {
+                double conf = NumOps.ToDouble(output[i, c]);
+                if (conf > maxConf) { maxConf = conf; maxClass = c; }
+            }
+
+            if (maxConf >= threshold && maxClass > 0)
+            {
+                regions.Add(new LayoutRegion<T>
+                {
+                    ElementType = (LayoutElementType)Math.Min(maxClass, (int)LayoutElementType.Other),
+                    Confidence = NumOps.FromDouble(maxConf),
+                    ConfidenceValue = maxConf,
+                    Index = i,
+                    BoundingBox = Vector<T>.Empty()
+                });
+            }
+        }
+
+        return regions;
+    }
+
+    #endregion
+
+    #region IDocumentQA Implementation
+
+    /// <inheritdoc/>
+    public DocumentQAResult<T> AnswerQuestion(Tensor<T> documentImage, string question)
+    {
+        return AnswerQuestion(documentImage, question, 64, 0.0);
+    }
+
+    /// <inheritdoc/>
+    public DocumentQAResult<T> AnswerQuestion(Tensor<T> documentImage, string question, int maxAnswerLength, double temperature = 0.0)
+    {
+        ValidateImageShape(documentImage);
+        var startTime = DateTime.UtcNow;
+
+        var preprocessed = PreprocessDocument(documentImage);
+        var output = _useNativeMode ? Forward(preprocessed) : RunOnnxInference(preprocessed);
+
+        // Extract answer using start/end logits from model output
+        var (answer, confidence) = ExtractAnswer(output, maxAnswerLength);
+
+        return new DocumentQAResult<T>
+        {
+            Answer = answer,
+            Confidence = NumOps.FromDouble(confidence),
+            ConfidenceValue = confidence,
+            Question = question,
+            ProcessingTimeMs = (DateTime.UtcNow - startTime).TotalMilliseconds
+        };
+    }
+
+    /// <summary>
+    /// Extracts answer from model output using extractive QA approach.
+    /// </summary>
+    /// <remarks>
+    /// LayoutXLM outputs token-level predictions. For QA, we find the span
+    /// with highest start and end logits within the max answer length.
+    /// </remarks>
+    private (string answer, double confidence) ExtractAnswer(Tensor<T> output, int maxAnswerLength)
+    {
+        int seqLen = output.Shape[0];
+        int hiddenDim = output.Shape.Length > 1 ? output.Shape[1] : _hiddenDim;
+
+        // Find best start and end positions
+        double bestStartScore = double.MinValue;
+        double bestEndScore = double.MinValue;
+        int bestStart = 0;
+        int bestEnd = 0;
+
+        // Interpret first and last values in hidden dimension as start/end logits
+        for (int i = 0; i < seqLen; i++)
+        {
+            double startScore = NumOps.ToDouble(output[i, 0]);
+            if (startScore > bestStartScore)
+            {
+                bestStartScore = startScore;
+                bestStart = i;
+            }
+        }
+
+        // Find best end position after start within max answer length
+        int endSearchLimit = Math.Min(seqLen, bestStart + maxAnswerLength);
+        for (int i = bestStart; i < endSearchLimit; i++)
+        {
+            double endScore = NumOps.ToDouble(output[i, Math.Min(1, hiddenDim - 1)]);
+            if (endScore > bestEndScore)
+            {
+                bestEndScore = endScore;
+                bestEnd = i;
+            }
+        }
+
+        // Extract token sequence and convert to text
+        var tokens = new List<int>();
+        for (int i = bestStart; i <= bestEnd && i < seqLen; i++)
+        {
+            // Extract argmax token at this position
+            double maxVal = double.MinValue;
+            int maxIdx = 0;
+            for (int j = 0; j < Math.Min(hiddenDim, _vocabSize); j++)
+            {
+                double val = NumOps.ToDouble(output[i, j]);
+                if (val > maxVal) { maxVal = val; maxIdx = j; }
+            }
+            if (maxIdx > 0) tokens.Add(maxIdx);
+        }
+
+        string answer = DecodeTokensToText(tokens);
+        double confidence = Math.Max(0, Math.Min(1, (bestStartScore + bestEndScore) / 2.0));
+
+        return (string.IsNullOrEmpty(answer) ? "[No answer found]" : answer, confidence);
+    }
+
+    /// <summary>
+    /// Decodes token IDs to text using BERT-style vocabulary.
+    /// </summary>
+    private static string DecodeTokensToText(List<int> tokens)
+    {
+        if (tokens.Count == 0) return string.Empty;
+
+        var sb = new System.Text.StringBuilder();
+        foreach (int token in tokens)
+        {
+            // BERT vocabulary mapping (simplified)
+            char c = token switch
+            {
+                >= 1000 and <= 1031 => (char)(token - 1000 + 32),  // Space, punctuation
+                >= 1032 and <= 1057 => (char)(token - 1032 + 65),  // A-Z
+                >= 1058 and <= 1083 => (char)(token - 1058 + 97),  // a-z
+                >= 103 and <= 125 => (char)(token - 103 + 48),     // Digits
+                >= 126 and <= 151 => (char)(token - 126 + 65),     // A-Z
+                >= 152 and <= 177 => (char)(token - 152 + 97),     // a-z
+                _ => (char)((token % 95) + 32) // Fallback to printable ASCII
+            };
+            sb.Append(c);
+        }
+
+        return sb.ToString();
+    }
+
+    /// <inheritdoc/>
+    public IEnumerable<DocumentQAResult<T>> AnswerQuestions(Tensor<T> documentImage, IEnumerable<string> questions)
+    {
+        foreach (var q in questions)
+            yield return AnswerQuestion(documentImage, q);
+    }
+
+    /// <inheritdoc/>
+    public Dictionary<string, DocumentQAResult<T>> ExtractFields(Tensor<T> documentImage, IEnumerable<string> fieldPrompts)
+    {
+        var results = new Dictionary<string, DocumentQAResult<T>>();
+        foreach (var field in fieldPrompts)
+            results[field] = AnswerQuestion(documentImage, $"What is the {field}?");
+        return results;
+    }
+
+    #endregion
+
+    #region IDocumentModel Implementation
+
+    /// <inheritdoc/>
+    public Tensor<T> EncodeDocument(Tensor<T> documentImage)
+    {
+        ValidateImageShape(documentImage);
+        var preprocessed = PreprocessDocument(documentImage);
+        return _useNativeMode ? Forward(preprocessed) : RunOnnxInference(preprocessed);
+    }
+
+    /// <inheritdoc/>
+    public void ValidateInputShape(Tensor<T> documentImage)
+    {
+        ValidateImageShape(documentImage);
+    }
+
+    /// <inheritdoc/>
+    public string GetModelSummary()
+    {
+        var sb = new System.Text.StringBuilder();
+        sb.AppendLine("LayoutXLM Model Summary");
+        sb.AppendLine("=======================");
+        sb.AppendLine($"Mode: {(_useNativeMode ? "Native (Trainable)" : "ONNX (Inference)")}");
+        sb.AppendLine($"Architecture: XLM-RoBERTa + ResNeXt-FPN visual backbone");
+        sb.AppendLine($"Hidden Dimension: {_hiddenDim}");
+        sb.AppendLine($"Number of Layers: {_numLayers}");
+        sb.AppendLine($"Attention Heads: {_numHeads}");
+        sb.AppendLine($"Vocabulary Size: {_vocabSize}");
+        sb.AppendLine($"Visual Backbone Channels: {_visualBackboneChannels}");
+        sb.AppendLine($"Languages Supported: {_numLanguages}");
+        sb.AppendLine($"Image Size: {ImageSize}x{ImageSize}");
+        sb.AppendLine($"Max Sequence Length: {MaxSequenceLength}");
+        sb.AppendLine($"Number of Classes: {_numClasses}");
+        sb.AppendLine($"Multilingual: Yes");
+        sb.AppendLine($"Total Layers: {Layers.Count}");
+        return sb.ToString();
+    }
+
+    #endregion
+
+    #region Preprocessing
+
+    /// <summary>
+    /// Applies LayoutXLM's industry-standard preprocessing: ImageNet normalization.
+    /// </summary>
+    /// <remarks>
+    /// LayoutXLM (Microsoft paper) is the multilingual version of LayoutLMv2, using same ImageNet normalization.
+    /// </remarks>
+    protected override Tensor<T> ApplyDefaultPreprocessing(Tensor<T> rawImage)
+    {
+        var image = EnsureBatchDimension(rawImage);
+        int batchSize = image.Shape[0];
+        int channels = image.Shape[1];
+        int height = image.Shape[2];
+        int width = image.Shape[3];
+
+        var normalized = new Tensor<T>(image._shape);
+        double[] means = [0.485, 0.456, 0.406];
+        double[] stds = [0.229, 0.224, 0.225];
+
+        for (int b = 0; b < batchSize; b++)
+        {
+            for (int c = 0; c < channels; c++)
+            {
+                double mean = c < means.Length ? means[c] : 0.5;
+                double std = c < stds.Length ? stds[c] : 0.5;
+                for (int h = 0; h < height; h++)
+                {
+                    for (int w = 0; w < width; w++)
+                    {
+                        int idx = b * channels * height * width + c * height * width + h * width + w;
+                        normalized.Data.Span[idx] = NumOps.FromDouble((NumOps.ToDouble(image.Data.Span[idx]) - mean) / std);
+                    }
+                }
+            }
+        }
+        return normalized;
+    }
+
+    /// <summary>
+    /// Applies LayoutXLM's industry-standard postprocessing: pass-through (multilingual outputs are already final).
+    /// </summary>
+    protected override Tensor<T> ApplyDefaultPostprocessing(Tensor<T> modelOutput) => modelOutput;
+
+    #endregion
+
+    #region Serialization
+
+    /// <inheritdoc/>
+    public override ModelMetadata<T> GetModelMetadata()
+    {
+        // LayoutXLM has a very large embedding layer (250K+ vocab × 768 hidden dim = 192M+ params).
+        // Serializing all parameters to a byte array in GetModelMetadata would require ~1.5 GB of memory.
+        // Use file-based Save/Load for model persistence instead.
+        long totalParams = 0;
+        foreach (var layer in Layers)
+            totalParams += layer.GetParameters().Length;
+
+        return new ModelMetadata<T>
+        {
+            Name = "LayoutXLM",
+            Description = "LayoutXLM for multilingual document understanding (ACL 2022)",
+            FeatureCount = _hiddenDim,
+            Complexity = _numLayers,
+            AdditionalInfo = new Dictionary<string, object>
+            {
+                { "hidden_dim", _hiddenDim },
+                { "num_layers", _numLayers },
+                { "num_heads", _numHeads },
+                { "vocab_size", _vocabSize },
+                { "image_size", ImageSize },
+                { "visual_backbone_channels", _visualBackboneChannels },
+                { "num_classes", _numClasses },
+                { "num_languages", _numLanguages },
+                { "use_native_mode", _useNativeMode },
+                { "total_parameters", totalParams }
+            },
+            ModelData = totalParams > 50_000_000 ? Array.Empty<byte>() : this.Serialize()
+        };
+    }
+
+    /// <inheritdoc/>
+
+
+    /// <inheritdoc/>
+
+
+    #endregion
+
+    #region NeuralNetworkBase Implementation
+
+    /// <inheritdoc/>
+    /// <remarks>
+    /// Per Xu et al. ACL 2022 §3.1, LayoutXLM (and its LayoutLMv2 backbone) admits two
+    /// paper-explicit operating modes:
+    /// <list type="bullet">
+    ///   <item>Full multimodal (<paramref name="input"/> is a rank-3/4 image tensor):
+    ///         the ResNeXt-FPN visual backbone produces visual tokens that are
+    ///         concatenated with the text-token sequence at the transformer entry.</item>
+    ///   <item>Text-only (<paramref name="input"/> is a rank-1/2 token-id tensor):
+    ///         the visual stream is skipped entirely — the original paper's MVLM
+    ///         pre-training objective explicitly masks the visual stream, and the
+    ///         downstream text-understanding fine-tunes (§4.2) run the same text-only
+    ///         path. The XLM-RoBERTa embedding stack at <c>VisualBackbonePrefixLength</c>
+    ///         is the entry point.</item>
+    /// </list>
+    /// We route by rank rather than by an explicit modality flag because that mirrors
+    /// the HuggingFace LayoutLMv2/XLM call surface: a single forward that infers the
+    /// modality from the supplied tensor's shape.
+    /// </remarks>
+    protected override Tensor<T> PredictCore(Tensor<T> input)
+    {
+        if (input is null)
+            throw new ArgumentNullException(nameof(input));
+
+        if (!_useNativeMode)
+        {
+            // ONNX models bake the modality into their compiled graph; defer all routing
+            // decisions to the ONNX runtime instead of second-guessing on the .NET side.
+            var preprocessed = PreprocessDocument(input);
+            return RunOnnxInference(preprocessed);
+        }
+
+        // Text-only path: rank-1 [seq] or rank-2 [batch, seq] token-id tensors enter at
+        // the XLM-RoBERTa embedding layer; the upstream Conv visual backbone is bypassed
+        // since there is no image to encode (paper §3.1, §4.2).
+        if (input.Rank <= 2)
+        {
+            return ForwardFromLayer(input, VisualBackbonePrefixLength);
+        }
+
+        // Image-only path: normalize the image and run the real visual stream (backbone -> visual
+        // tokens) through the transformer — NOT the base linear chain, which would feed the visual
+        // backbone output into the text embedding layer.
+        var preprocessedImage = PreprocessDocument(input);
+        return RunMultimodal(null, preprocessedImage);
+    }
+
+    /// <summary>
+    /// Runs the layer chain starting at <paramref name="startIndex"/> instead of layer
+    /// zero — the text-only counterpart of <see cref="DocumentNeuralNetworkBase{T}.Forward"/>
+    /// that lets the paper-supported text-stream-only operating mode bypass the visual
+    /// backbone prefix. Reuses the base class's auto-reshape contract so the eventual
+    /// hand-off from any remaining spatial layers to the transformer is identical.
+    /// </summary>
+    private Tensor<T> ForwardFromLayer(Tensor<T> input, int startIndex)
+    {
+        if (startIndex < 0 || startIndex > Layers.Count)
+            throw new ArgumentOutOfRangeException(nameof(startIndex),
+                $"startIndex must be in [0, {Layers.Count}], got {startIndex}.");
+
+        Tensor<T> output = input;
+        Tensor<T>? encoderOutput = null;
+        for (int i = startIndex; i < Layers.Count; i++)
+        {
+            var layer = Layers[i];
+            if (layer is TransformerDecoderLayer<T> decoderLayer)
+            {
+                encoderOutput ??= output;
+                output = decoderLayer.Forward(output, encoderOutput);
+            }
+            else
+            {
+                output = layer.Forward(output);
+            }
+        }
+        return output;
+    }
+
+    // Layer roles in CreateDefaultLayoutXLMLayers order: [0..VisualBackbonePrefixLength) = visual
+    // backbone (conv/BN/pool + a final C->hidden projection Dense), then 4 text-embedding layers, then
+    // the multimodal transformer + head. TextEmbeddingLayerCount mirrors LayoutLMv2's split.
+    // Three, not four: the token EmbeddingLayer and the sinusoidal PositionalEncodingLayer that
+    // used to open this section are now a single LayoutEmbeddingLayer, which also carries the 2D
+    // layout terms. The LayerNorm and Dropout after them are unchanged.
+    private const int TextEmbeddingLayerCount = 3;
+
+    /// <summary>
+    /// Full text+image fusion entry (industry-standard LayoutXLM): encodes BOTH a token-ID sequence and
+    /// a document image through the two visual/text streams and fuses them via the transformer. Reference
+    /// LayoutXLM requires both; the single-input Predict path additionally supports each modality alone.
+    /// </summary>
+    public Tensor<T> EncodeMultimodal(Tensor<T> textTokens, Tensor<T> documentImage)
+    {
+        // Inference entry: mirror Predict()/PredictCore by suppressing gradient-tape recording
+        // (PyTorch torch.no_grad() semantics). RunMultimodal issues raw Engine.Reshape/Permute/
+        // Concatenate ops that would otherwise record onto the shared autodiff tape; if a prior
+        // training pass left that singleton tape non-empty, replaying it here poisons the fusion
+        // forward with stale/NaN buffers. NoGradScope makes this direct call as tape-clean as
+        // the Predict()-wrapped image-only path. ForwardForTraining keeps recording (no scope).
+        using var _ = new AiDotNet.Tensors.Engines.Autodiff.NoGradScope<T>();
+        return RunMultimodal(textTokens, PreprocessDocument(documentImage));
+    }
+
+    // Runs LayoutXLM's real two-stream forward: independent visual and text streams (whichever are
+    // present) concatenated on the sequence axis, then the shared multimodal transformer + head. Unlike
+    // ForwardFromLayer (text-only prefix skip), this actually encodes the image as visual tokens rather
+    // than chaining the conv backbone into the text embedding.
+    private Tensor<T> RunMultimodal(Tensor<T>? textTokens, Tensor<T>? documentImage)
+    {
+        Tensor<T>? textSeq = textTokens is not null ? RunTextStream(textTokens) : null;
+        Tensor<T>? visualSeq = documentImage is not null ? RunVisualStream(documentImage) : null;
+
+        Tensor<T> seq;
+        if (textSeq is not null && visualSeq is not null)
+        {
+            // Fuse the two streams the way LayoutXLM (Xu et al. 2021, §3.1) does: stack the visual
+            // token sequence and the text token sequence along the SEQUENCE axis into one joint
+            // sequence, then run the shared multimodal transformer over it. Both streams must first
+            // agree on layout — the visual backbone emits a batched [B, Lvis, D] but the text stream
+            // can emit an unbatched [Ltext, D] (and a continuous-valued token tensor projects to
+            // [1, D]); normalize both to [B, L, D] so the concatenation matches on batch and hidden
+            // and only grows the sequence axis. Concatenating on axis 0 with mismatched ranks (the
+            // previous behavior) was invalid and only appeared to work when the output buffer's
+            // unwritten tail happened to be zero.
+            var vis = AlignToBatchedSequence(visualSeq);
+            var txt = AlignToBatchedSequence(textSeq);
+            seq = Engine.TensorConcatenate([vis, txt], axis: 1);
+        }
+        else
+            seq = textSeq ?? visualSeq
+                ?? throw new ArgumentException("LayoutXLM requires text token IDs (rank <= 2) or a document image (rank >= 3).");
+
+        for (int i = VisualBackbonePrefixLength + TextEmbeddingLayerCount; i < Layers.Count; i++)
+            seq = Layers[i].Forward(seq);
+        return seq;
+    }
+
+    // Normalizes a token sequence to a batched [B, L, D] layout so the two fusion streams concatenate
+    // cleanly on the sequence axis. A [L, D] stream (unbatched, e.g. the text embedding on a rank-1
+    // token vector) gains a leading batch of 1; a continuous [1, D] projection becomes a single-token
+    // [1, 1, D]; an already-batched [B, L, D] passes through unchanged.
+    private Tensor<T> AlignToBatchedSequence(Tensor<T> t)
+    {
+        if (t.Rank == 3) return t;
+        if (t.Rank == 2) return Engine.Reshape(t, new[] { 1, t.Shape[0], t.Shape[1] });
+        throw new ArgumentException($"Fusion stream must be rank 2 or 3, got rank {t.Rank}.");
+    }
+
+    private Tensor<T> RunTextStream(Tensor<T> textTokens)
+    {
+        var x = textTokens;
+        for (int i = VisualBackbonePrefixLength; i < VisualBackbonePrefixLength + TextEmbeddingLayerCount && i < Layers.Count; i++)
+            x = Layers[i].Forward(x);
+        return x;
+    }
+
+    private Tensor<T> RunVisualStream(Tensor<T> documentImage)
+    {
+        var x = documentImage;
+        int projIndex = VisualBackbonePrefixLength - 1;
+        for (int i = 0; i < projIndex; i++)
+            x = Layers[i].Forward(x);
+        x = FlattenSpatialToTokens(x);
+        if (projIndex >= 0 && projIndex < Layers.Count)
+            x = Layers[projIndex].Forward(x);
+        return x;
+    }
+
+    // [C, H, W] -> [H*W, C]; [B, C, H, W] -> [B, H*W, C].
+    private Tensor<T> FlattenSpatialToTokens(Tensor<T> feat)
+    {
+        if (feat.Rank == 4)
+        {
+            int b = feat.Shape[0], c = feat.Shape[1], n = feat.Shape[2] * feat.Shape[3];
+            return Engine.TensorPermute(Engine.Reshape(feat, new[] { b, c, n }), new[] { 0, 2, 1 });
+        }
+        if (feat.Rank == 3)
+        {
+            int c = feat.Shape[0], n = feat.Shape[1] * feat.Shape[2];
+            return Engine.TensorPermute(Engine.Reshape(feat, new[] { c, n }), new[] { 1, 0 });
+        }
+        return feat;
+    }
+
+    /// <inheritdoc/>
+    /// <remarks>
+    /// Training-mode counterpart of <see cref="Predict"/>'s modality routing. Without
+    /// this override, <see cref="NeuralNetworkBase{T}.ForwardForTraining"/> walks
+    /// <c>Layers</c> from index 0, sending text-only inputs into the rank-4-only Conv
+    /// visual backbone and throwing immediately. Routing here keeps the dual-stream
+    /// semantics consistent across Predict and Train so a model trained on text-only
+    /// data (paper §4.2 fine-tunes) sees the same code path on inference.
+    /// </remarks>
+    public override Tensor<T> ForwardForTraining(Tensor<T> input)
+    {
+        if (input is null)
+            throw new ArgumentNullException(nameof(input));
+
+        if (_useNativeMode && input.Rank <= 2)
+        {
+            return ForwardFromLayer(input, VisualBackbonePrefixLength);
+        }
+        // Image-only training input: run the real visual stream, not the base linear chain.
+        return _useNativeMode ? RunMultimodal(null, input) : base.ForwardForTraining(input);
+    }
+
+    /// <inheritdoc/>
+    /// <remarks>
+    /// Diagnostic counterpart of <see cref="Predict"/>'s modality routing for the
+    /// inspector path that the base implementation walks <c>Layers</c> from index 0 on
+    /// (used by the model-family scaffold's <c>NamedLayerActivations_ShouldBeNonEmpty</c>
+    /// probe and the public introspection surface). Text-only callers skip the visual
+    /// backbone prefix — paper §3.4 says the visual stream is omitted under MVLM-style
+    /// text-only operation — so the dictionary still reports a sensible non-empty set of
+    /// activations for the layers that actually fired, rather than throwing at the Conv7×7
+    /// when no image was supplied.
+    /// </remarks>
+    public override Dictionary<string, Tensor<T>> GetNamedLayerActivations(Tensor<T> input)
+    {
+        if (input is null)
+            throw new ArgumentNullException(nameof(input));
+
+        if (!_useNativeMode)
+            return base.GetNamedLayerActivations(input);
+
+        int startIndex = input.Rank <= 2 ? VisualBackbonePrefixLength : 0;
+        var activations = new Dictionary<string, Tensor<T>>();
+        var current = input;
+        Tensor<T>? encoderOutput = null;
+        for (int i = startIndex; i < Layers.Count; i++)
+        {
+            var layer = Layers[i];
+            if (layer is TransformerDecoderLayer<T> decoderLayer)
+            {
+                encoderOutput ??= current;
+                current = decoderLayer.Forward(current, encoderOutput);
+            }
+            else
+            {
+                current = layer.Forward(current);
+            }
+            activations[$"Layer_{i}_{layer.GetType().Name}"] = current.Clone();
+        }
+        return activations;
+    }
+
+    /// <inheritdoc/>
+    /// <remarks>
+    /// Per Xu et al. ACL 2022 §3.3 (and the LayoutLMv2 training recipe it inherits),
+    /// LayoutXLM is trained end-to-end with AdamW (β1=0.9, β2=0.999, weight-decay=0.01,
+    /// learning rate 2e-5 with linear warmup over 10 % of steps then linear decay).
+    /// <see cref="NeuralNetworkBase{T}.TrainWithTape"/> already applies that optimizer
+    /// step through <see cref="_optimizer"/> (defaulted to <see cref="AdamOptimizer{T, TInput, TOutput}"/>
+    /// in the constructor) — the previous implementation also called
+    /// <c>UpdateParameters(CollectGradients())</c> AFTER TrainWithTape, applying a
+    /// second naive SGD update at fixed lr=5e-5 on top of the AdamW update. That
+    /// double-step counted every gradient twice, broke the AdamW first/second-moment
+    /// invariants, and is the root cause of monotonic-loss-decrease test failures
+    /// (<c>Training_ShouldReduceLoss</c>, <c>TrainingError_ShouldNotExceedTestError</c>).
+    /// Drop the manual second step so training follows the paper exactly.
+    /// </remarks>
+    public override void Train(Tensor<T> input, Tensor<T> expectedOutput)
+    {
+        if (!_useNativeMode)
+            throw new NotSupportedException("Training not supported in ONNX mode.");
+
+        SetTrainingMode(true);
+        TrainWithTape(input, expectedOutput, _optimizer);
+        SetTrainingMode(false);
+    }
+
+    // UpdateParameters applied a GRADIENT STEP, but its one-argument form is the value setter and every caller passes values -- the override corrupted the model. Removed under AIDN082.
+
+
+    /// <summary>
+    /// Parameters cannot be written while the model is backed by a loaded ONNX graph: the weights
+    /// belong to that graph, not to this instance.
+    /// </summary>
+    /// <remarks>
+    /// Replaces a hand-written throw that used to sit inside UpdateParameters. The base checks this
+    /// on every mutating entry point rather than the one member the throw happened to guard, and
+    /// reading -- ParameterCount and GetParameters -- stays available either way.
+    /// </remarks>
     protected override bool SupportsParameterMutation => _useNativeMode;
-    #endregion
-
-    #region Disposal
-
-    /// <inheritdoc/>
-    protected override void Dispose(bool disposing)
-    {
-        if (disposing)
-            _onnxSession?.Dispose();
-        base.Dispose(disposing);
-    }
-
-    #endregion
-}
+    #endregion
+
+    #region Disposal
+
+    /// <inheritdoc/>
+    protected override void Dispose(bool disposing)
+    {
+        if (disposing)
+            _onnxSession?.Dispose();
+        base.Dispose(disposing);
+    }
+
+    #endregion
+}
diff --git a/src/Document/LayoutAware/LiLT.cs b/src/Document/LayoutAware/LiLT.cs
index 2f7423ce06..fcabfe55e6 100644
--- a/src/Document/LayoutAware/LiLT.cs
+++ b/src/Document/LayoutAware/LiLT.cs
@@ -1,1312 +1,1266 @@
-using AiDotNet.Attributes;
-using AiDotNet.Document.Interfaces;
-using AiDotNet.Document.Options;
-using AiDotNet.Enums;
-using AiDotNet.Helpers;
-using AiDotNet.Interfaces;
-using AiDotNet.LinearAlgebra;
-using AiDotNet.LossFunctions;
-using AiDotNet.NeuralNetworks;
-using AiDotNet.NeuralNetworks.Layers;
-using AiDotNet.Optimizers;
-using AiDotNet.Models.Options;
-using AiDotNet.Tokenization;
-using AiDotNet.Tokenization.Algorithms;
-using AiDotNet.Tokenization.HuggingFace;
-using AiDotNet.Tokenization.Interfaces;
-using AiDotNet.Tokenization.Models;
-using Microsoft.ML.OnnxRuntime;
-using AiDotNet.Validation;
-
-namespace AiDotNet.Document.LayoutAware;
-
-/// <summary>
-/// LiLT (Language-Independent Layout Transformer) for document understanding.
-/// </summary>
-/// <typeparam name="T">The numeric type used for calculations.</typeparam>
-/// <remarks>
-/// <para>
-/// LiLT separates the text and layout modalities during pre-training, enabling
-/// the layout model to be combined with ANY pre-trained text model at fine-tuning
-/// time, providing true language independence.
-/// </para>
-/// <para>
-/// <b>For Beginners:</b> LiLT is designed for maximum flexibility:
-/// 1. Layout understanding is learned separately from text
-/// 2. Can plug in ANY language model (BERT, RoBERTa, XLM-R, etc.)
-/// 3. Supports any language without retraining the layout part
-///
-/// Key features:
-/// - BiACM (Bi-directional Attention Complementation Mechanism)
-/// - Separate text and layout streams
-/// - Works with any pre-trained text encoder
-/// - Language-agnostic layout understanding
-///
-/// Example usage:
-/// <code>
-/// var model = new LiLT&lt;float&gt;(architecture);
-/// var result = model.DetectLayout(documentImage);
-/// </code>
-/// </para>
-/// <para>
-/// <b>Reference:</b> "LiLT: A Simple yet Effective Language-Independent Layout Transformer" (ACL 2022)
-/// https://arxiv.org/abs/2202.13669
-/// </para>
-/// </remarks>
-[ModelDomain(ModelDomain.Vision)]
-[ModelDomain(ModelDomain.Language)]
-[ModelCategory(ModelCategory.NeuralNetwork)]
-[ModelCategory(ModelCategory.Transformer)]
-[ModelTask(ModelTask.Classification)]
-[ModelTask(ModelTask.Detection)]
-[ModelComplexity(ModelComplexity.Medium)]
-[ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
-[ResearchPaper("LiLT: A Simple yet Effective Language-Independent Layout Transformer for Structured Document Understanding", "https://doi.org/10.48550/arXiv.2202.13669", Year = 2022, Authors = "Jiapeng Wang, Lianwen Jin, Kai Ding")]
-public partial class LiLT<T> : DocumentNeuralNetworkBase<T>, ILayoutDetector<T>, IDocumentQA<T>
-{
-    private readonly LiLTOptions _options;
-
-    /// <inheritdoc/>
-    public override ModelOptions GetOptions() => _options;
-
-    #region Fields
-
-    private bool _useNativeMode;
-    private readonly InferenceSession? _onnxSession;
-    private readonly ITokenizer _tokenizer;
-    private readonly IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>> _optimizer;
-    private int _hiddenDim;
-    private int _numLayers;
-    private int _numHeads;
-    private int _vocabSize;
-    private int _numClasses;
-    private string _textBackbone;
-
-    // Native mode layers - separate streams
-    private readonly List<ILayer<T>> _textEncoderLayers = [];
-    private readonly List<ILayer<T>> _layoutEncoderLayers = [];
-    private readonly List<ILayer<T>> _biACMLayers = [];
-    private readonly List<ILayer<T>> _outputLayers = [];
-
-    // Learnable embeddings
-    // The text-position, layout-position and spatial coordinate tables used to be model fields
-    // here. They are now inside the two LayoutEmbeddingLayers at the front of the stack, where the
-    // forward pass reads them -- see LayerHelper.CreateDefaultLiLTLayers.
-
-    #endregion
-
-    #region Properties
-
-    /// <inheritdoc/>
-    public override DocumentType SupportedDocumentTypes => DocumentType.All;
-
-    /// <inheritdoc/>
-    public override bool RequiresOCR => true;
-
-    /// <inheritdoc/>
-    public int ExpectedImageSize => ImageSize;
-
-    /// <summary>
-    /// Gets the text backbone model name.
-    /// </summary>
-    public string TextBackbone => _textBackbone;
-
-    /// <inheritdoc/>
-    public IReadOnlyList<LayoutElementType> SupportedElementTypes { get; } =
-    [
-        LayoutElementType.Text,
-        LayoutElementType.Title,
-        LayoutElementType.List,
-        LayoutElementType.Table,
-        LayoutElementType.Figure,
-        LayoutElementType.Caption,
-        LayoutElementType.Header,
-        LayoutElementType.Footer,
-        LayoutElementType.FormField
-    ];
-
-    #endregion
-
-    #region Constructors
-
-    /// <summary>
-    /// Creates a LiLT model using a pre-trained ONNX model for inference.
-    /// </summary>
-    public LiLT(
-        NeuralNetworkArchitecture<T> architecture,
-        string onnxModelPath,
-        ITokenizer tokenizer,
-        int numClasses = 7,
-        int maxSequenceLength = 512,
-        int hiddenDim = 768,
-        int numLayers = 12,
-        int numHeads = 12,
-        int vocabSize = 30522,
-        string textBackbone = "bert-base",
-        IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? optimizer = null,
-        ILossFunction<T>? lossFunction = null,
-        LiLTOptions? options = null)
-        : base(architecture, lossFunction ?? new CrossEntropyWithLogitsLoss<T>(), 1.0)
-    {
-        _options = options ?? new LiLTOptions();
-        Options = _options;
-
-        if (string.IsNullOrWhiteSpace(onnxModelPath))
-            throw new ArgumentNullException(nameof(onnxModelPath));
-        if (!File.Exists(onnxModelPath))
-            throw new FileNotFoundException($"ONNX model not found: {onnxModelPath}", onnxModelPath);
-
-        Guard.NotNull(tokenizer);
-        _tokenizer = tokenizer;
-        _useNativeMode = false;
-        _numClasses = numClasses;
-        _hiddenDim = hiddenDim;
-        _numLayers = numLayers;
-        _numHeads = numHeads;
-        _vocabSize = vocabSize;
-        _textBackbone = textBackbone;
-        _optimizer = optimizer ?? new AdamOptimizer<T, Tensor<T>, Tensor<T>>(this,
-            new AdamOptimizerOptions<T, Tensor<T>, Tensor<T>> { InitialLearningRate = 1e-4 });
-
-        MaxSequenceLength = maxSequenceLength;
-
-        _onnxSession = new InferenceSession(onnxModelPath);
-
-        InitializeLayers();
-    }
-
-    /// <summary>
-    /// Creates a LiLT model using native layers for training and inference.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// <b>Default Configuration (LiLT-Base from ACL 2022):</b>
-    /// - Text encoder: Pluggable (default: BERT-base)
-    /// - Layout encoder: Separate transformer
-    /// - BiACM: Bi-directional attention between streams
-    /// - Hidden dimension: 768
-    /// - Layers: 12, Heads: 12
-    /// </para>
-    /// </remarks>
-    public LiLT(
-        NeuralNetworkArchitecture<T> architecture,
-        ITokenizer? tokenizer = null,
-        int numClasses = 7,
-        int maxSequenceLength = 512,
-        int hiddenDim = 768,
-        int numLayers = 12,
-        int numHeads = 12,
-        int vocabSize = 30522,
-        string textBackbone = "bert-base",
-        IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? optimizer = null,
-        ILossFunction<T>? lossFunction = null,
-        LiLTOptions? options = null)
-        : base(architecture, lossFunction ?? new CrossEntropyWithLogitsLoss<T>(), 1.0)
-    {
-        _options = options ?? new LiLTOptions();
-        Options = _options;
-
-        _useNativeMode = true;
-        _numClasses = numClasses;
-        _hiddenDim = hiddenDim;
-        _numLayers = numLayers;
-        _numHeads = numHeads;
-        _vocabSize = vocabSize;
-        _textBackbone = textBackbone;
-        _optimizer = optimizer ?? new AdamOptimizer<T, Tensor<T>, Tensor<T>>(this,
-            new AdamOptimizerOptions<T, Tensor<T>, Tensor<T>> { InitialLearningRate = 1e-4 });
-
-        MaxSequenceLength = maxSequenceLength;
-
-        _tokenizer = tokenizer ?? CreateTokenizerForBackbone(textBackbone, vocabSize);
-
-        InitializeLayers();
-    }
-
-    #endregion
-
-    #region Initialization
-
-    /// <inheritdoc/>
-    protected override void InitializeLayers()
-    {
-        if (!_useNativeMode)
-        {
-            return;
-        }
-
-        if (Architecture.Layers is not null && Architecture.Layers.Count > 0)
-        {
-            Layers.AddRange(Architecture.Layers);
-            ValidateCustomLayers(Layers);
-            return;
-        }
-
-        Layers.AddRange(LayerHelper<T>.CreateDefaultLiLTLayers(
-            hiddenDim: _hiddenDim,
-            numLayers: _numLayers,
-            numHeads: _numHeads,
-            layoutDim: _hiddenDim,
-            vocabSize: _vocabSize,
-            numClasses: _numClasses,
-            maxPosition2D: 1024));
-    }
-
-    private static ITokenizer CreateTokenizerForBackbone(string textBackbone, int vocabSize)
-    {
-        if (string.IsNullOrWhiteSpace(textBackbone))
-        {
-            return LanguageModelTokenizerFactory.CreateForBackbone(LanguageModelBackbone.OPT);
-        }
-
-        if (TryParseBackbone(textBackbone, out var backbone))
-        {
-            return LanguageModelTokenizerFactory.CreateForBackbone(backbone);
-        }
-
-        string normalized = NormalizeTextBackbone(textBackbone);
-        try
-        {
-            return AutoTokenizer.FromPretrained(normalized);
-        }
-        catch (Exception)
-        {
-            return WordPieceTokenizer.Train(GetDefaultTokenizerCorpus(), vocabSize, SpecialTokens.Bert());
-        }
-    }
-
-    private static bool TryParseBackbone(string textBackbone, out LanguageModelBackbone backbone)
-    {
-        return Enum.TryParse(textBackbone, true, out backbone);
-    }
-
-    private static string NormalizeTextBackbone(string textBackbone)
-    {
-        if (string.Equals(textBackbone, "bert-base", StringComparison.OrdinalIgnoreCase))
-        {
-            return "bert-base-uncased";
-        }
-
-        if (string.Equals(textBackbone, "bert-large", StringComparison.OrdinalIgnoreCase))
-        {
-            return "bert-large-uncased";
-        }
-
-        return textBackbone;
-    }
-
-    private static IEnumerable<string> GetDefaultTokenizerCorpus()
-    {
-        return new[]
-        {
-            "a photo of a document",
-            "invoice total amount",
-            "table row column header",
-            "page number and date",
-            "signature and stamp",
-            "summary section",
-            "this is a test",
-            "layout understanding",
-            "document classification"
-        };
-    }
-
-    #endregion
-
-    #region ILayoutDetector Implementation
-
-    /// <inheritdoc/>
-    public DocumentLayoutResult<T> DetectLayout(Tensor<T> documentImage)
-    {
-        return DetectLayout(documentImage, 0.5);
-    }
-
-    /// <inheritdoc/>
-    public DocumentLayoutResult<T> DetectLayout(Tensor<T> documentImage, double confidenceThreshold)
-    {
-        ValidateImageShape(documentImage);
-        var startTime = DateTime.UtcNow;
-
-        var preprocessed = PreprocessDocument(documentImage);
-        var output = _useNativeMode ? Forward(preprocessed) : RunOnnxInference(preprocessed);
-
-        var regions = ParseLayoutOutput(output, documentImage, confidenceThreshold);
-
-        return new DocumentLayoutResult<T>
-        {
-            Regions = regions,
-            ProcessingTimeMs = (DateTime.UtcNow - startTime).TotalMilliseconds
-        };
-    }
-
-    private List<LayoutRegion<T>> ParseLayoutOutput(Tensor<T> output, Tensor<T> documentImage, double threshold)
-    {
-        var regions = new List<LayoutRegion<T>>();
-        if (output.Shape.Length < 1)
-        {
-            return regions;
-        }
-
-        var layoutOutput = NormalizeLayoutOutput(output);
-        if (layoutOutput.Shape.Length < 2)
-        {
-            return regions;
-        }
-
-        int numDetections = layoutOutput.Shape[0];
-        int numValues = layoutOutput.Shape[1];
-
-        if (numDetections <= 0 || numValues <= 0)
-        {
-            return regions;
-        }
-
-        int numClasses = Math.Min(_numClasses, numValues);
-        bool hasBbox = false;
-        if (numValues > _numClasses && numValues >= 5)
-        {
-            numClasses = Math.Min(_numClasses, numValues - 4);
-            hasBbox = numValues - 4 > 0;
-        }
-
-        GetImageDimensions(documentImage, out int imageWidth, out int imageHeight);
-
-        for (int i = 0; i < numDetections; i++)
-        {
-            double maxConf = double.MinValue;
-            int maxClass = -1;
-            int offset = i * numValues;
-
-            for (int c = 0; c < numClasses; c++)
-            {
-                double conf = NumOps.ToDouble(layoutOutput.Data.Span[offset + c]);
-                if (conf > maxConf)
-                {
-                    maxConf = conf;
-                    maxClass = c;
-                }
-            }
-
-            if (maxClass <= 0 || maxConf < threshold)
-            {
-                continue;
-            }
-
-            var elementType = MapElementType(maxClass);
-            var bbox = hasBbox
-                ? ExtractBoundingBox(layoutOutput, i, numValues, imageWidth, imageHeight)
-                : EstimateGridBoundingBox(i, numDetections, imageWidth, imageHeight);
-
-            if (bbox.Length == 4)
-            {
-                double x1 = NumOps.ToDouble(bbox[0]);
-                double y1 = NumOps.ToDouble(bbox[1]);
-                double x2 = NumOps.ToDouble(bbox[2]);
-                double y2 = NumOps.ToDouble(bbox[3]);
-
-                if (x2 <= x1 || y2 <= y1)
-                {
-                    continue;
-                }
-            }
-
-            regions.Add(new LayoutRegion<T>
-            {
-                ElementType = elementType,
-                Confidence = NumOps.FromDouble(maxConf),
-                ConfidenceValue = maxConf,
-                Index = i,
-                BoundingBox = bbox
-            });
-        }
-
-        return regions;
-    }
-
-    private Tensor<T> NormalizeLayoutOutput(Tensor<T> output)
-    {
-        if (output.Shape.Length == 2)
-        {
-            return output;
-        }
-
-        if (output.Shape.Length == 3 && output.Shape[0] == 1)
-        {
-            return output.Reshape([output.Shape[1], output.Shape[2]]);
-        }
-
-        if (output.Shape.Length == 1)
-        {
-            int expectedWithBbox = _numClasses + 4;
-            if (expectedWithBbox > 0 && output.Length % expectedWithBbox == 0)
-            {
-                return output.Reshape([output.Length / expectedWithBbox, expectedWithBbox]);
-            }
-
-            if (_numClasses > 0 && output.Length % _numClasses == 0)
-            {
-                return output.Reshape([output.Length / _numClasses, _numClasses]);
-            }
-
-            return output.Reshape([1, output.Length]);
-        }
-
-        int lastDim = output.Shape[^1];
-        if (lastDim <= 0 || output.Length % lastDim != 0)
-        {
-            return output.Reshape([1, output.Length]);
-        }
-
-        int numDetections = output.Length / lastDim;
-        return output.Reshape([numDetections, lastDim]);
-    }
-
-    private LayoutElementType MapElementType(int classIndex)
-    {
-        if (classIndex <= 0)
-        {
-            return LayoutElementType.Other;
-        }
-
-        int supportedIndex = classIndex - 1;
-        if (supportedIndex >= 0 && supportedIndex < SupportedElementTypes.Count)
-        {
-            return SupportedElementTypes[supportedIndex];
-        }
-
-        return LayoutElementType.Other;
-    }
-
-    private Vector<T> ExtractBoundingBox(Tensor<T> output, int detectionIndex, int numValues, int imageWidth, int imageHeight)
-    {
-        int bboxOffset = detectionIndex * numValues + numValues - 4;
-        double b0 = NumOps.ToDouble(output.Data.Span[bboxOffset]);
-        double b1 = NumOps.ToDouble(output.Data.Span[bboxOffset + 1]);
-        double b2 = NumOps.ToDouble(output.Data.Span[bboxOffset + 2]);
-        double b3 = NumOps.ToDouble(output.Data.Span[bboxOffset + 3]);
-
-        bool looksNormalized = b0 >= -0.5 && b0 <= 1.5 &&
-                               b1 >= -0.5 && b1 <= 1.5 &&
-                               b2 >= -0.5 && b2 <= 1.5 &&
-                               b3 >= -0.5 && b3 <= 1.5;
-
-        double x1 = b0;
-        double y1 = b1;
-        double x2 = b2;
-        double y2 = b3;
-
-        if (x2 <= x1 || y2 <= y1)
-        {
-            double cx = x1;
-            double cy = y1;
-            double w = Math.Abs(x2);
-            double h = Math.Abs(y2);
-            x1 = cx - w / 2.0;
-            y1 = cy - h / 2.0;
-            x2 = cx + w / 2.0;
-            y2 = cy + h / 2.0;
-        }
-
-        if (looksNormalized)
-        {
-            x1 *= imageWidth;
-            x2 *= imageWidth;
-            y1 *= imageHeight;
-            y2 *= imageHeight;
-        }
-
-        x1 = Clamp(x1, 0, imageWidth);
-        x2 = Clamp(x2, 0, imageWidth);
-        y1 = Clamp(y1, 0, imageHeight);
-        y2 = Clamp(y2, 0, imageHeight);
-
-        return new Vector<T>([
-            NumOps.FromDouble(x1),
-            NumOps.FromDouble(y1),
-            NumOps.FromDouble(x2),
-            NumOps.FromDouble(y2)
-        ]);
-    }
-
-    private Vector<T> EstimateGridBoundingBox(int index, int numDetections, int imageWidth, int imageHeight)
-    {
-        int gridSize = (int)Math.Ceiling(Math.Sqrt(numDetections));
-        if (gridSize <= 0)
-        {
-            gridSize = 1;
-        }
-
-        int cellWidth = Math.Max(1, imageWidth / gridSize);
-        int cellHeight = Math.Max(1, imageHeight / gridSize);
-        int row = index / gridSize;
-        int col = index % gridSize;
-
-        double x1 = col * cellWidth;
-        double y1 = row * cellHeight;
-        double x2 = Math.Min(imageWidth, x1 + cellWidth);
-        double y2 = Math.Min(imageHeight, y1 + cellHeight);
-
-        return new Vector<T>([
-            NumOps.FromDouble(x1),
-            NumOps.FromDouble(y1),
-            NumOps.FromDouble(x2),
-            NumOps.FromDouble(y2)
-        ]);
-    }
-
-    private void GetImageDimensions(Tensor<T> image, out int width, out int height)
-    {
-        if (image.Rank == 4)
-        {
-            height = image.Shape[2];
-            width = image.Shape[3];
-        }
-        else if (image.Rank == 3)
-        {
-            height = image.Shape[1];
-            width = image.Shape[2];
-        }
-        else
-        {
-            height = ImageSize;
-            width = ImageSize;
-        }
-
-        if (height <= 0 || width <= 0)
-        {
-            height = ImageSize;
-            width = ImageSize;
-        }
-    }
-
-    private static double Clamp(double value, double min, double max)
-    {
-        if (value < min) return min;
-        if (value > max) return max;
-        return value;
-    }
-
-    #endregion
-
-    #region IDocumentQA Implementation
-
-    /// <inheritdoc/>
-    public DocumentQAResult<T> AnswerQuestion(Tensor<T> documentImage, string question)
-    {
-        return AnswerQuestion(documentImage, question, 64, 0.0);
-    }
-
-    /// <inheritdoc/>
-    public DocumentQAResult<T> AnswerQuestion(Tensor<T> documentImage, string question, int maxAnswerLength, double temperature = 0.0)
-    {
-        ValidateImageShape(documentImage);
-        var startTime = DateTime.UtcNow;
-
-        var preprocessed = PreprocessDocument(documentImage);
-        var output = _useNativeMode ? Forward(preprocessed) : RunOnnxInference(preprocessed);
-
-        // Extract answer using extractive QA approach
-        var (answer, confidence) = ExtractAnswer(output, maxAnswerLength, temperature);
-
-        return new DocumentQAResult<T>
-        {
-            Answer = answer,
-            Confidence = NumOps.FromDouble(confidence),
-            ConfidenceValue = confidence,
-            Question = question,
-            ProcessingTimeMs = (DateTime.UtcNow - startTime).TotalMilliseconds
-        };
-    }
-
-    /// <summary>
-    /// Extracts answer from model output using a token-probability decoding pass.
-    /// </summary>
-    private (string answer, double confidence) ExtractAnswer(Tensor<T> output, int maxAnswerLength, double temperature)
-    {
-        var logits = NormalizeAnswerLogits(output);
-        if (logits.Shape.Length < 2)
-        {
-            return ("[No answer found]", 0.0);
-        }
-
-        int seqLen = logits.Shape[0];
-        int vocabSize = logits.Shape[1];
-        if (_vocabSize > 0)
-        {
-            vocabSize = Math.Min(vocabSize, _vocabSize);
-        }
-
-        if (seqLen <= 0 || vocabSize <= 0)
-        {
-            return ("[No answer found]", 0.0);
-        }
-
-        if (maxAnswerLength <= 0)
-        {
-            return ("[No answer found]", 0.0);
-        }
-
-        int maxLen = Math.Min(seqLen, maxAnswerLength);
-        var tokens = new List<int>(maxLen);
-        double confidenceSum = 0.0;
-        int confidenceCount = 0;
-
-        int eosId = GetSpecialTokenId(_tokenizer.SpecialTokens.EosToken);
-        int sepId = GetSpecialTokenId(_tokenizer.SpecialTokens.SepToken);
-        int padId = GetSpecialTokenId(_tokenizer.SpecialTokens.PadToken);
-        int clsId = GetSpecialTokenId(_tokenizer.SpecialTokens.ClsToken);
-
-        var random = RandomHelper.Shared;
-        bool sampleTokens = temperature > 0.0;
-
-        for (int i = 0; i < maxLen; i++)
-        {
-            int offset = i * logits.Shape[1];
-            int tokenId;
-            double tokenProb;
-
-            if (sampleTokens)
-            {
-                tokenId = SampleToken(logits, offset, vocabSize, temperature, random, out tokenProb);
-            }
-            else
-            {
-                tokenId = SelectGreedyToken(logits, offset, vocabSize, out tokenProb);
-            }
-
-            if ((eosId >= 0 && tokenId == eosId) || (sepId >= 0 && tokenId == sepId))
-            {
-                break;
-            }
-
-            if ((padId >= 0 && tokenId == padId) || (clsId >= 0 && tokenId == clsId))
-            {
-                continue;
-            }
-
-            tokens.Add(tokenId);
-            confidenceSum += tokenProb;
-            confidenceCount++;
-        }
-
-        if (tokens.Count == 0)
-        {
-            return ("[No answer found]", 0.0);
-        }
-
-        string answer = _tokenizer.Decode(tokens, skipSpecialTokens: true).Trim();
-        if (string.IsNullOrWhiteSpace(answer))
-        {
-            return ("[No answer found]", 0.0);
-        }
-
-        double confidence = confidenceCount > 0 ? confidenceSum / confidenceCount : 0.0;
-        return (answer, confidence);
-    }
-
-    private Tensor<T> NormalizeAnswerLogits(Tensor<T> output)
-    {
-        if (output.Shape.Length == 2)
-        {
-            return output;
-        }
-
-        if (output.Shape.Length == 3 && output.Shape[0] == 1)
-        {
-            return output.Reshape([output.Shape[1], output.Shape[2]]);
-        }
-
-        if (output.Shape.Length == 1)
-        {
-            if (_vocabSize > 0 && output.Length % _vocabSize == 0)
-            {
-                return output.Reshape([output.Length / _vocabSize, _vocabSize]);
-            }
-
-            return output.Reshape([1, output.Length]);
-        }
-
-        int lastDim = output.Shape[^1];
-        if (lastDim <= 0 || output.Length % lastDim != 0)
-        {
-            return output.Reshape([1, output.Length]);
-        }
-
-        int seqLen = output.Length / lastDim;
-        return output.Reshape([seqLen, lastDim]);
-    }
-
-    private int SelectGreedyToken(Tensor<T> logits, int offset, int vocabSize, out double probability)
-    {
-        double maxVal = double.MinValue;
-        int maxIdx = 0;
-
-        for (int v = 0; v < vocabSize; v++)
-        {
-            double val = NumOps.ToDouble(logits.Data.Span[offset + v]);
-            if (val > maxVal)
-            {
-                maxVal = val;
-                maxIdx = v;
-            }
-        }
-
-        double sumExp = 0.0;
-        for (int v = 0; v < vocabSize; v++)
-        {
-            double val = NumOps.ToDouble(logits.Data.Span[offset + v]);
-            sumExp += Math.Exp(val - maxVal);
-        }
-
-        probability = sumExp > 0 ? 1.0 / sumExp : 0.0;
-        return maxIdx;
-    }
-
-    private int SampleToken(Tensor<T> logits, int offset, int vocabSize, double temperature, Random random, out double probability)
-    {
-        double maxVal = double.MinValue;
-        for (int v = 0; v < vocabSize; v++)
-        {
-            double scaled = NumOps.ToDouble(logits.Data.Span[offset + v]) / temperature;
-            if (scaled > maxVal)
-            {
-                maxVal = scaled;
-            }
-        }
-
-        double sumExp = 0.0;
-        for (int v = 0; v < vocabSize; v++)
-        {
-            double scaled = NumOps.ToDouble(logits.Data.Span[offset + v]) / temperature;
-            sumExp += Math.Exp(scaled - maxVal);
-        }
-
-        if (sumExp <= 0.0)
-        {
-            probability = 0.0;
-            return 0;
-        }
-
-        double roll = random.NextDouble() * sumExp;
-        double cumulative = 0.0;
-        for (int v = 0; v < vocabSize; v++)
-        {
-            double scaled = NumOps.ToDouble(logits.Data.Span[offset + v]) / temperature;
-            double expVal = Math.Exp(scaled - maxVal);
-            cumulative += expVal;
-            if (cumulative >= roll)
-            {
-                probability = expVal / sumExp;
-                return v;
-            }
-        }
-
-        probability = 0.0;
-        return vocabSize - 1;
-    }
-
-    private int GetSpecialTokenId(string token)
-    {
-        if (string.IsNullOrWhiteSpace(token))
-        {
-            return -1;
-        }
-
-        var vocabulary = _tokenizer.Vocabulary;
-        if (!vocabulary.ContainsToken(token))
-        {
-            return -1;
-        }
-
-        return vocabulary.GetTokenId(token);
-    }
-
-    /// <inheritdoc/>
-    public IEnumerable<DocumentQAResult<T>> AnswerQuestions(Tensor<T> documentImage, IEnumerable<string> questions)
-    {
-        foreach (var q in questions)
-            yield return AnswerQuestion(documentImage, q);
-    }
-
-    /// <inheritdoc/>
-    public Dictionary<string, DocumentQAResult<T>> ExtractFields(Tensor<T> documentImage, IEnumerable<string> fieldPrompts)
-    {
-        var results = new Dictionary<string, DocumentQAResult<T>>();
-        foreach (var field in fieldPrompts)
-            results[field] = AnswerQuestion(documentImage, $"What is the {field}?");
-        return results;
-    }
-
-    #endregion
-
-    #region IDocumentModel Implementation
-
-    /// <inheritdoc/>
-    public Tensor<T> EncodeDocument(Tensor<T> documentImage)
-    {
-        ValidateImageShape(documentImage);
-        var preprocessed = PreprocessDocument(documentImage);
-        return _useNativeMode ? Forward(preprocessed) : RunOnnxInference(preprocessed);
-    }
-
-    /// <inheritdoc/>
-    public void ValidateInputShape(Tensor<T> documentImage)
-    {
-        ValidateImageShape(documentImage);
-    }
-
-    /// <inheritdoc/>
-    public string GetModelSummary()
-    {
-        var sb = new System.Text.StringBuilder();
-        sb.AppendLine("LiLT Model Summary");
-        sb.AppendLine("==================");
-        sb.AppendLine($"Mode: {(_useNativeMode ? "Native (Trainable)" : "ONNX (Inference)")}");
-        sb.AppendLine($"Architecture: Dual-stream with BiACM");
-        sb.AppendLine($"Text Backbone: {_textBackbone}");
-        sb.AppendLine($"Hidden Dimension: {_hiddenDim}");
-        sb.AppendLine($"Number of Layers: {_numLayers}");
-        sb.AppendLine($"Attention Heads: {_numHeads}");
-        sb.AppendLine($"Max Sequence Length: {MaxSequenceLength}");
-        sb.AppendLine($"Number of Classes: {_numClasses}");
-        sb.AppendLine($"Language Independent: Yes");
-        sb.AppendLine($"Total Layers: {Layers.Count}");
-        return sb.ToString();
-    }
-
-    #endregion
-
-    #region Preprocessing
-
-    /// <summary>
-    /// Applies LiLT's industry-standard preprocessing: ImageNet normalization.
-    /// </summary>
-    /// <remarks>
-    /// LiLT (Language-independent Layout Transformer) uses ImageNet normalization with mean=[0.485, 0.456, 0.406] and std=[0.229, 0.224, 0.225].
-    /// </remarks>
-    protected override Tensor<T> ApplyDefaultPreprocessing(Tensor<T> rawImage)
-    {
-        var image = EnsureBatchDimension(rawImage);
-        int batchSize = image.Shape[0];
-        int channels = image.Shape[1];
-        int height = image.Shape[2];
-        int width = image.Shape[3];
-
-        var normalized = new Tensor<T>(image._shape);
-        double[] means = [0.485, 0.456, 0.406];
-        double[] stds = [0.229, 0.224, 0.225];
-
-        for (int b = 0; b < batchSize; b++)
-        {
-            for (int c = 0; c < channels; c++)
-            {
-                double mean = c < means.Length ? means[c] : 0.5;
-                double std = c < stds.Length ? stds[c] : 0.5;
-                for (int h = 0; h < height; h++)
-                {
-                    for (int w = 0; w < width; w++)
-                    {
-                        int idx = b * channels * height * width + c * height * width + h * width + w;
-                        normalized.Data.Span[idx] = NumOps.FromDouble((NumOps.ToDouble(image.Data.Span[idx]) - mean) / std);
-                    }
-                }
-            }
-        }
-        return normalized;
-    }
-
-    /// <summary>
-    /// Applies LiLT's industry-standard postprocessing: pass-through (layout-aware outputs are already final).
-    /// </summary>
-    protected override Tensor<T> ApplyDefaultPostprocessing(Tensor<T> modelOutput) => modelOutput;
-
-    #endregion
-
-    #region Serialization
-
-    /// <inheritdoc/>
-    public override ModelMetadata<T> GetModelMetadata()
-    {
-        return new ModelMetadata<T>
-        {
-            Name = "LiLT",
-            Description = "LiLT for language-independent layout understanding (ACL 2022)",
-            FeatureCount = _hiddenDim,
-            Complexity = _numLayers,
-            AdditionalInfo = new Dictionary<string, object>
-            {
-                { "hidden_dim", _hiddenDim },
-                { "num_layers", _numLayers },
-                { "num_heads", _numHeads },
-                { "vocab_size", _vocabSize },
-                { "max_sequence_length", MaxSequenceLength },
-                { "num_classes", _numClasses },
-                { "text_backbone", _textBackbone },
-                { "use_native_mode", _useNativeMode }
-            },
-            ModelData = SafeSerialize()
-        };
-    }
-
-    /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_hiddenDim);
-        writer.Write(_numLayers);
-        writer.Write(_numHeads);
-        writer.Write(_vocabSize);
-        writer.Write(MaxSequenceLength);
-        writer.Write(_numClasses);
-        writer.Write(_textBackbone);
-        writer.Write(_useNativeMode);
-    }
-
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        int hiddenDim = reader.ReadInt32();
-        int numLayers = reader.ReadInt32();
-        int numHeads = reader.ReadInt32();
-        int vocabSize = reader.ReadInt32();
-        int maxSeqLen = reader.ReadInt32();
-        int numClasses = reader.ReadInt32();
-        string textBackbone = reader.ReadString();
-        bool useNativeMode = reader.ReadBoolean();
-
-        _hiddenDim = hiddenDim;
-        _numLayers = numLayers;
-        _numHeads = numHeads;
-        _vocabSize = vocabSize;
-        _numClasses = numClasses;
-        _textBackbone = textBackbone;
-        _useNativeMode = useNativeMode;
-        MaxSequenceLength = maxSeqLen;
-    }
-
-    /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode)
-        {
-            throw new NotSupportedException(
-                "Deep copy is not supported for ONNX LiLT instances. Create a new instance with model paths instead.");
-        }
-        return new LiLT<T>(Architecture, _tokenizer, _numClasses, MaxSequenceLength,
-            _hiddenDim, _numLayers, _numHeads, _vocabSize, _textBackbone, _optimizer, LossFunction);
-    }
-
-    #endregion
-
-    #region NeuralNetworkBase Implementation
-
-    /// <inheritdoc/>
-    protected override Tensor<T> PredictCore(Tensor<T> input)
-    {
-        var preprocessed = PreprocessDocument(input);
-        return _useNativeMode ? Forward(preprocessed) : RunOnnxInference(preprocessed);
-    }
-
-    // ── Faithful LiLT dual-stream forward with BiACM (Wang et al. 2022, §3.2) ──────────────────────────
-    // Layer layout from CreateDefaultLiLTLayers: [0]=text LayoutEmbeddingLayer (word + learned 1D
-    // position, no layout terms), [1]=boxes-only LayoutEmbeddingLayer (the paper's per-coordinate
-    // tables), [2]=layout LayerNorm, then numLayers blocks of 7 layers
-    // [textMHA, textLN, layoutMHA, layoutLN, ffn1, ffn2, ffnLN], then [Dropout, Dense(head)].
-    //
-    // Three, not four: the text side's Embedding + sinusoidal PositionalEncoding pair became one
-    // block with LEARNED positions, and the layout side's Dense(box→hidden) became the coordinate
-    // lookup the paper specifies.
-    private const int LiLTPrefixLayers = 3;
-    private const int LiLTBlockLayers = 7;
-    private int HeadDim => _hiddenDim / _numHeads;
-
-    // BiACM is LiLT's contribution: the two streams SHARE attention scores. The text stream's scores get
-    // the layout scores added (layout complements text); the layout stream's scores get the text scores
-    // added but DETACHED (StopGradient), so the reusable pre-trained text encoder is not perturbed by the
-    // layout branch's gradient — exactly the asymmetric coupling in the paper.
-    private Tensor<T> RunDualStream(Tensor<T> textTokens, Tensor<T>? layoutBoxes)
-    {
-        // Text stream embeddings: word + learned 1D position, in one block.
-        var text = Layers[0].Forward(textTokens);
-
-        // Layout stream embeddings from bounding boxes: Dense(box→hidden) + LayerNorm. Absent boxes ⇒
-        // text-only operation (graceful degradation the reference model lacks); BiACM then reduces to a
-        // standard text self-attention transformer.
-        Tensor<T>? layout = null;
-        if (layoutBoxes is not null)
-            layout = Layers[2].Forward(Layers[1].Forward(layoutBoxes));
-
-        int numBlocks = (Layers.Count - LiLTPrefixLayers - 2) / LiLTBlockLayers;
-        for (int b = 0; b < numBlocks; b++)
-            (text, layout) = BiACMBlock(text, layout, LiLTPrefixLayers + b * LiLTBlockLayers);
-
-        // Classification head runs on the TEXT stream (the paper's task head consumes the language flow).
-        int headStart = LiLTPrefixLayers + numBlocks * LiLTBlockLayers;
-        var output = text;
-        for (int i = headStart; i < Layers.Count; i++)
-            output = Layers[i].Forward(output);
-        return output;
-    }
-
-    private (Tensor<T> text, Tensor<T>? layout) BiACMBlock(Tensor<T> text, Tensor<T>? layout, int baseIdx)
-    {
-        var tMHA = (MultiHeadAttentionLayer<T>)Layers[baseIdx];
-        var tLN = Layers[baseIdx + 1];
-        var lMHA = (MultiHeadAttentionLayer<T>)Layers[baseIdx + 2];
-        var lLN = Layers[baseIdx + 3];
-        var ffn1 = Layers[baseIdx + 4];
-        var ffn2 = Layers[baseIdx + 5];
-        var ffnLN = Layers[baseIdx + 6];
-
-        int seqT = text.Shape[0];
-        var st = SelfAttentionScores(text, tMHA, seqT, out var vt);
-
-        Tensor<T>? sl = null, vl = null; int seqL = 0;
-        if (layout is not null)
-        {
-            seqL = layout.Shape[0];
-            sl = SelfAttentionScores(layout, lMHA, seqL, out vl);
-        }
-
-        // BiACM score sharing requires the two streams to be token-aligned (one layout box per text
-        // token) so the [heads, seq, seq] score matrices are addable — the paper's assumption. If a
-        // caller supplies mismatched lengths the streams run independently rather than crashing.
-        bool coupled = sl is not null && seqL == seqT;
-        var stShared = coupled ? Engine.TensorAdd(st, sl!) : st;
-        var ctxT = ApplyAttention(stShared, vt, seqT, tMHA);
-        text = tLN.Forward(Engine.TensorAdd(text, ctxT));
-        text = ffnLN.Forward(Engine.TensorAdd(text, ffn2.Forward(ffn1.Forward(text))));
-
-        if (layout is not null)
-        {
-            // Text scores DETACHED into the layout stream so the language encoder stays reusable.
-            var slShared = coupled ? Engine.TensorAdd(sl!, Engine.StopGradient(st)) : sl!;
-            var ctxL = ApplyAttention(slShared, vl!, seqL, lMHA);
-            layout = lLN.Forward(Engine.TensorAdd(layout, ctxL));
-            layout = ffnLN.Forward(Engine.TensorAdd(layout, ffn2.Forward(ffn1.Forward(layout))));
-        }
-        return (text, layout);
-    }
-
-    // Projects x[seq,D] to per-head Q/K/V via the MHA layer's weights, returns scaled QKᵀ scores
-    // [heads,seq,seq] and the per-head values V [heads,seq,headDim].
-    private Tensor<T> SelfAttentionScores(Tensor<T> x, MultiHeadAttentionLayer<T> mha, int seq, out Tensor<T> v)
-    {
-        var q = SplitHeads(Engine.TensorMatMul(x, mha.GetQueryWeights()), seq);
-        var k = SplitHeads(Engine.TensorMatMul(x, mha.GetKeyWeights()), seq);
-        v = SplitHeads(Engine.TensorMatMul(x, mha.GetValueWeights()), seq);
-        var scores = Engine.BatchMatMul(q, Engine.TensorPermute(k, new[] { 0, 2, 1 }));
-        return Engine.TensorMultiplyScalar(scores, NumOps.FromDouble(1.0 / Math.Sqrt(HeadDim)));
-    }
-
-    // softmax(scores)·V → merge heads → output projection.
-    private Tensor<T> ApplyAttention(Tensor<T> scores, Tensor<T> v, int seq, MultiHeadAttentionLayer<T> mha)
-    {
-        var ctx = Engine.BatchMatMul(Engine.Softmax(scores, axis: -1), v);   // [heads, seq, headDim]
-        var merged = MergeHeads(ctx, seq);                                    // [seq, D]
-        return Engine.TensorMatMul(merged, mha.GetOutputWeights());
-    }
-
-    private Tensor<T> SplitHeads(Tensor<T> x, int seq)
-        => Engine.TensorPermute(Engine.Reshape(x, new[] { seq, _numHeads, HeadDim }), new[] { 1, 0, 2 });
-
-    private Tensor<T> MergeHeads(Tensor<T> x, int seq)
-        => Engine.Reshape(Engine.TensorPermute(x, new[] { 1, 0, 2 }), new[] { seq, _hiddenDim });
-
-    /// <summary>
-    /// Full dual-stream fusion entry (industry-standard LiLT): encodes text token IDs AND their layout
-    /// bounding boxes through the coupled BiACM transformer. <paramref name="layoutBoxes"/> is the
-    /// per-token box feature tensor the layout Dense consumes; pass null for text-only operation.
-    /// </summary>
-    public Tensor<T> EncodeDualStream(Tensor<T> textTokens, Tensor<T>? layoutBoxes)
-    {
-        using var _ = new AiDotNet.Tensors.Engines.Autodiff.NoGradScope<T>();
-        return RunDualStream(textTokens, layoutBoxes);
-    }
-
-    // LiLT is a text + layout model: a rank-1/2 token-ID input drives the BiACM dual-stream (text-only
-    // when no boxes accompany it). A higher-rank input (e.g. a raw image handed to Predict) isn't LiLT's
-    // modality, so defer to the base sequential walk rather than forcing it through the token path.
-    /// <inheritdoc/>
-    protected override Tensor<T> Forward(Tensor<T> input)
-        => RouteDualStream(input, trainingPath: false);
-
-    /// <inheritdoc/>
-    public override Tensor<T> ForwardForTraining(Tensor<T> input)
-        => RouteDualStream(input, trainingPath: true);
-
-    /// <summary>
-    /// Sends an input through the BiACM dual stream, unpacking bounding boxes when they are present.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// Both forwards used to pass <c>null</c> for boxes. The layout stream was therefore unreachable
-    /// from <c>Predict</c> and from <c>Train</c> alike -- LiLT could only ever run, and only ever
-    /// learn, as a plain text transformer, which is the one thing the paper is not about. The only
-    /// entry point that accepted boxes, <see cref="EncodeDualStream"/>, opens a <c>NoGradScope</c>
-    /// and so could never train the layout side either.
-    /// </para>
-    /// <para>
-    /// A packed <c>[seq, 5]</c> row -- <c>(tokenId, x0, y0, x1, y1)</c>, the convention the rest of
-    /// this family uses -- is split here and both halves reach the streams, on the training path as
-    /// well as the inference one. A bare token sequence still runs text-only, so callers with no OCR
-    /// boxes are unaffected. A higher-rank input is not LiLT's modality and defers to the base walk.
-    /// </para>
-    /// </remarks>
-    /// <summary>
-    /// Reports per-stage activations by running LiLT's actual dual stream.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// The base implementation walks <c>Layers</c> as a chain, feeding each layer the previous one's
-    /// output. LiLT is not a chain: <c>Layers[0]</c> embeds text, <c>Layers[1..2]</c> embed layout
-    /// from bounding boxes, and the blocks after them consume BOTH. Walking it linearly handed the
-    /// layout embedding a text activation, which the old <c>Dense(box-&gt;hidden)</c> silently accepted
-    /// and multiplied -- so the reported "activations" were arithmetic on mismatched tensors that
-    /// corresponded to nothing the model computes. The coordinate lookup that replaced the Dense
-    /// rejects it outright, which is the correct response to being handed the wrong stream.
-    /// </para>
-    /// <para>
-    /// Running the real dual stream reports what the model actually produces, and names the two
-    /// streams so a caller can tell them apart.
-    /// </para>
-    /// </remarks>
-    public override Dictionary<string, Tensor<T>> GetNamedLayerActivations(Tensor<T> input)
-    {
-        if (!_useNativeMode || input.Rank > 2)
-        {
-            return base.GetNamedLayerActivations(input);
-        }
-
-        using var _ = new AiDotNet.Tensors.Engines.Autodiff.NoGradScope<T>();
-
-        Tensor<T> tokens = input;
-        Tensor<T>? boxes = null;
-        if (TrySplitPackedLayout(input, out var splitTokens, out var splitBoxes))
-        {
-            tokens = splitTokens;
-            boxes = splitBoxes;
-        }
-
-        var activations = new Dictionary<string, Tensor<T>>
-        {
-            ["text_embedding"] = Layers[0].Forward(tokens),
-        };
-
-        if (boxes is not null)
-        {
-            activations["layout_embedding"] = Layers[2].Forward(Layers[1].Forward(boxes));
-        }
-
-        activations["output"] = RunDualStream(tokens, boxes);
-        return activations;
-    }
-
-
-    private Tensor<T> RouteDualStream(Tensor<T> input, bool trainingPath)
-    {
-        if (_useNativeMode && TrySplitPackedLayout(input, out var tokens, out var boxes))
-        {
-            return RunDualStream(tokens, boxes);
-        }
-
-        if (_useNativeMode && input.Rank <= 2)
-        {
-            return RunDualStream(input, null);
-        }
-
-        return trainingPath ? base.ForwardForTraining(input) : base.Forward(input);
-    }
-
-    /// <summary>
-    /// Splits a packed <c>[seq, 5]</c> or <c>[batch, seq, 5]</c> tensor into token IDs and the
-    /// <c>[.., 4]</c> box tensor the layout stream consumes. False when the input is not packed.
-    /// </summary>
-    private static bool TrySplitPackedLayout(Tensor<T> input, out Tensor<T> tokens, out Tensor<T>? boxes)
-    {
-        tokens = input;
-        boxes = null;
-
-        int rank = input.Rank;
-        if (rank < 2 || input.Shape[rank - 1] != NeuralNetworks.Layers.LayoutEmbeddingLayer<T>.PackedRowWidth)
-            return false;
-
-        int rows = 1;
-        for (int i = 0; i < rank - 1; i++) rows *= input.Shape[i];
-
-        var tokenShape = new int[rank - 1];
-        for (int i = 0; i < rank - 1; i++) tokenShape[i] = input.Shape[i];
-
-        var boxShape = new int[rank];
-        for (int i = 0; i < rank - 1; i++) boxShape[i] = input.Shape[i];
-        boxShape[rank - 1] = LayoutBoxWidth;
-
-        var tokenTensor = new Tensor<T>(tokenShape);
-        var boxTensor = new Tensor<T>(boxShape);
-        var src = input.Data.Span;
-        var tokenDst = tokenTensor.Data.Span;
-        var boxDst = boxTensor.Data.Span;
-
-        for (int r = 0; r < rows; r++)
-        {
-            int b = r * NeuralNetworks.Layers.LayoutEmbeddingLayer<T>.PackedRowWidth;
-            tokenDst[r] = src[b];
-            for (int c = 0; c < LayoutBoxWidth; c++)
-                boxDst[r * LayoutBoxWidth + c] = src[b + 1 + c];
-        }
-
-        tokens = tokenTensor;
-        boxes = boxTensor;
-        return true;
-    }
-
-    /// <summary>Coordinates per box: x0, y0, x1, y1.</summary>
-    private const int LayoutBoxWidth = 4;
-
-    /// <inheritdoc/>
-    public override void Train(Tensor<T> input, Tensor<T> expectedOutput)
-    {
-        if (!_useNativeMode)
-            throw new NotSupportedException("Training not supported in ONNX mode.");
-
-        // TrainWithTape runs the forward, backprops, and applies the optimizer update itself. The
-        // earlier UpdateParameters(CollectGradients()) applied a redundant SECOND naive SGD step (lr 5e-5)
-        // over every parameter on top of the Adam update — counting each gradient twice and driving the
-        // network into a degenerate collapsed state (DifferentInputs_AfterTraining saw identical output
-        // for distinct inputs). TrainWithTape alone is the correct single update.
-        SetTrainingMode(true);
-        try
-        {
-            TrainWithTape(input, expectedOutput, _optimizer);
-        }
-        finally
-        {
-            SetTrainingMode(false);
-        }
-    }
-
-    // UpdateParameters applied a GRADIENT STEP, but its one-argument form is the value setter and every caller passes values -- the override corrupted the model. Removed under AIDN082.

-
-    /// <summary>
-    /// Parameters cannot be written while the model is backed by a loaded ONNX graph: the weights
-    /// belong to that graph, not to this instance.
-    /// </summary>
-    /// <remarks>
-    /// Replaces a hand-written throw that used to sit inside UpdateParameters. The base checks this
-    /// on every mutating entry point rather than the one member the throw happened to guard, and
-    /// reading -- ParameterCount and GetParameters -- stays available either way.
-    /// </remarks>
-    protected override bool SupportsParameterMutation => _useNativeMode;
-    #endregion
-
-    #region Disposal
-
-    /// <inheritdoc/>
-    protected override void Dispose(bool disposing)
-    {
-        if (disposing)
-            _onnxSession?.Dispose();
-        base.Dispose(disposing);
-    }
-
-    #endregion
-}
+using AiDotNet.Attributes;
+using AiDotNet.Document.Interfaces;
+using AiDotNet.Document.Options;
+using AiDotNet.Enums;
+using AiDotNet.Helpers;
+using AiDotNet.Interfaces;
+using AiDotNet.LinearAlgebra;
+using AiDotNet.LossFunctions;
+using AiDotNet.NeuralNetworks;
+using AiDotNet.NeuralNetworks.Layers;
+using AiDotNet.Optimizers;
+using AiDotNet.Models.Options;
+using AiDotNet.Tokenization;
+using AiDotNet.Tokenization.Algorithms;
+using AiDotNet.Tokenization.HuggingFace;
+using AiDotNet.Tokenization.Interfaces;
+using AiDotNet.Tokenization.Models;
+using Microsoft.ML.OnnxRuntime;
+using AiDotNet.Validation;
+
+namespace AiDotNet.Document.LayoutAware;
+
+/// <summary>
+/// LiLT (Language-Independent Layout Transformer) for document understanding.
+/// </summary>
+/// <typeparam name="T">The numeric type used for calculations.</typeparam>
+/// <remarks>
+/// <para>
+/// LiLT separates the text and layout modalities during pre-training, enabling
+/// the layout model to be combined with ANY pre-trained text model at fine-tuning
+/// time, providing true language independence.
+/// </para>
+/// <para>
+/// <b>For Beginners:</b> LiLT is designed for maximum flexibility:
+/// 1. Layout understanding is learned separately from text
+/// 2. Can plug in ANY language model (BERT, RoBERTa, XLM-R, etc.)
+/// 3. Supports any language without retraining the layout part
+///
+/// Key features:
+/// - BiACM (Bi-directional Attention Complementation Mechanism)
+/// - Separate text and layout streams
+/// - Works with any pre-trained text encoder
+/// - Language-agnostic layout understanding
+///
+/// Example usage:
+/// <code>
+/// var model = new LiLT&lt;float&gt;(architecture);
+/// var result = model.DetectLayout(documentImage);
+/// </code>
+/// </para>
+/// <para>
+/// <b>Reference:</b> "LiLT: A Simple yet Effective Language-Independent Layout Transformer" (ACL 2022)
+/// https://arxiv.org/abs/2202.13669
+/// </para>
+/// </remarks>
+[ModelDomain(ModelDomain.Vision)]
+[ModelDomain(ModelDomain.Language)]
+[ModelCategory(ModelCategory.NeuralNetwork)]
+[ModelCategory(ModelCategory.Transformer)]
+[ModelTask(ModelTask.Classification)]
+[ModelTask(ModelTask.Detection)]
+[ModelComplexity(ModelComplexity.Medium)]
+[ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
+[ResearchPaper("LiLT: A Simple yet Effective Language-Independent Layout Transformer for Structured Document Understanding", "https://doi.org/10.48550/arXiv.2202.13669", Year = 2022, Authors = "Jiapeng Wang, Lianwen Jin, Kai Ding")]
+public partial class LiLT<T> : DocumentNeuralNetworkBase<T>, ILayoutDetector<T>, IDocumentQA<T>
+{
+    private readonly LiLTOptions _options;
+
+    /// <inheritdoc/>
+    public override ModelOptions GetOptions() => _options;
+
+    #region Fields
+
+    private bool _useNativeMode;
+    private readonly InferenceSession? _onnxSession;
+    private readonly ITokenizer _tokenizer;
+    private readonly IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>> _optimizer;
+    private int _hiddenDim;
+    private int _numLayers;
+    private int _numHeads;
+    private int _vocabSize;
+    private int _numClasses;
+    private string _textBackbone;
+
+    // Native mode layers - separate streams
+    private readonly List<ILayer<T>> _textEncoderLayers = [];
+    private readonly List<ILayer<T>> _layoutEncoderLayers = [];
+    private readonly List<ILayer<T>> _biACMLayers = [];
+    private readonly List<ILayer<T>> _outputLayers = [];
+
+    // Learnable embeddings
+    // The text-position, layout-position and spatial coordinate tables used to be model fields
+    // here. They are now inside the two LayoutEmbeddingLayers at the front of the stack, where the
+    // forward pass reads them -- see LayerHelper.CreateDefaultLiLTLayers.
+
+    #endregion
+
+    #region Properties
+
+    /// <inheritdoc/>
+    public override DocumentType SupportedDocumentTypes => DocumentType.All;
+
+    /// <inheritdoc/>
+    public override bool RequiresOCR => true;
+
+    /// <inheritdoc/>
+    public int ExpectedImageSize => ImageSize;
+
+    /// <summary>
+    /// Gets the text backbone model name.
+    /// </summary>
+    public string TextBackbone => _textBackbone;
+
+    /// <inheritdoc/>
+    public IReadOnlyList<LayoutElementType> SupportedElementTypes { get; } =
+    [
+        LayoutElementType.Text,
+        LayoutElementType.Title,
+        LayoutElementType.List,
+        LayoutElementType.Table,
+        LayoutElementType.Figure,
+        LayoutElementType.Caption,
+        LayoutElementType.Header,
+        LayoutElementType.Footer,
+        LayoutElementType.FormField
+    ];
+
+    #endregion
+
+    #region Constructors
+
+    /// <summary>
+    /// Creates a LiLT model using a pre-trained ONNX model for inference.
+    /// </summary>
+    public LiLT(
+        NeuralNetworkArchitecture<T> architecture,
+        string onnxModelPath,
+        ITokenizer tokenizer,
+        int numClasses = 7,
+        int maxSequenceLength = 512,
+        int hiddenDim = 768,
+        int numLayers = 12,
+        int numHeads = 12,
+        int vocabSize = 30522,
+        string textBackbone = "bert-base",
+        IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? optimizer = null,
+        ILossFunction<T>? lossFunction = null,
+        LiLTOptions? options = null)
+        : base(architecture, lossFunction ?? new CrossEntropyWithLogitsLoss<T>(), 1.0)
+    {
+        _options = options ?? new LiLTOptions();
+        Options = _options;
+
+        if (string.IsNullOrWhiteSpace(onnxModelPath))
+            throw new ArgumentNullException(nameof(onnxModelPath));
+        if (!File.Exists(onnxModelPath))
+            throw new FileNotFoundException($"ONNX model not found: {onnxModelPath}", onnxModelPath);
+
+        Guard.NotNull(tokenizer);
+        _tokenizer = tokenizer;
+        _useNativeMode = false;
+        _numClasses = numClasses;
+        _hiddenDim = hiddenDim;
+        _numLayers = numLayers;
+        _numHeads = numHeads;
+        _vocabSize = vocabSize;
+        _textBackbone = textBackbone;
+        _optimizer = optimizer ?? new AdamOptimizer<T, Tensor<T>, Tensor<T>>(this,
+            new AdamOptimizerOptions<T, Tensor<T>, Tensor<T>> { InitialLearningRate = 1e-4 });
+
+        MaxSequenceLength = maxSequenceLength;
+
+        _onnxSession = new InferenceSession(onnxModelPath);
+
+        InitializeLayers();
+    }
+
+    /// <summary>
+    /// Creates a LiLT model using native layers for training and inference.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// <b>Default Configuration (LiLT-Base from ACL 2022):</b>
+    /// - Text encoder: Pluggable (default: BERT-base)
+    /// - Layout encoder: Separate transformer
+    /// - BiACM: Bi-directional attention between streams
+    /// - Hidden dimension: 768
+    /// - Layers: 12, Heads: 12
+    /// </para>
+    /// </remarks>
+    public LiLT(
+        NeuralNetworkArchitecture<T> architecture,
+        ITokenizer? tokenizer = null,
+        int numClasses = 7,
+        int maxSequenceLength = 512,
+        int hiddenDim = 768,
+        int numLayers = 12,
+        int numHeads = 12,
+        int vocabSize = 30522,
+        string textBackbone = "bert-base",
+        IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? optimizer = null,
+        ILossFunction<T>? lossFunction = null,
+        LiLTOptions? options = null)
+        : base(architecture, lossFunction ?? new CrossEntropyWithLogitsLoss<T>(), 1.0)
+    {
+        _options = options ?? new LiLTOptions();
+        Options = _options;
+
+        _useNativeMode = true;
+        _numClasses = numClasses;
+        _hiddenDim = hiddenDim;
+        _numLayers = numLayers;
+        _numHeads = numHeads;
+        _vocabSize = vocabSize;
+        _textBackbone = textBackbone;
+        _optimizer = optimizer ?? new AdamOptimizer<T, Tensor<T>, Tensor<T>>(this,
+            new AdamOptimizerOptions<T, Tensor<T>, Tensor<T>> { InitialLearningRate = 1e-4 });
+
+        MaxSequenceLength = maxSequenceLength;
+
+        _tokenizer = tokenizer ?? CreateTokenizerForBackbone(textBackbone, vocabSize);
+
+        InitializeLayers();
+    }
+
+    #endregion
+
+    #region Initialization
+
+    /// <inheritdoc/>
+    protected override void InitializeLayers()
+    {
+        if (!_useNativeMode)
+        {
+            return;
+        }
+
+        if (Architecture.Layers is not null && Architecture.Layers.Count > 0)
+        {
+            Layers.AddRange(Architecture.Layers);
+            ValidateCustomLayers(Layers);
+            return;
+        }
+
+        Layers.AddRange(LayerHelper<T>.CreateDefaultLiLTLayers(
+            hiddenDim: _hiddenDim,
+            numLayers: _numLayers,
+            numHeads: _numHeads,
+            layoutDim: _hiddenDim,
+            vocabSize: _vocabSize,
+            numClasses: _numClasses,
+            maxPosition2D: 1024));
+    }
+
+    private static ITokenizer CreateTokenizerForBackbone(string textBackbone, int vocabSize)
+    {
+        if (string.IsNullOrWhiteSpace(textBackbone))
+        {
+            return LanguageModelTokenizerFactory.CreateForBackbone(LanguageModelBackbone.OPT);
+        }
+
+        if (TryParseBackbone(textBackbone, out var backbone))
+        {
+            return LanguageModelTokenizerFactory.CreateForBackbone(backbone);
+        }
+
+        string normalized = NormalizeTextBackbone(textBackbone);
+        try
+        {
+            return AutoTokenizer.FromPretrained(normalized);
+        }
+        catch (Exception)
+        {
+            return WordPieceTokenizer.Train(GetDefaultTokenizerCorpus(), vocabSize, SpecialTokens.Bert());
+        }
+    }
+
+    private static bool TryParseBackbone(string textBackbone, out LanguageModelBackbone backbone)
+    {
+        return Enum.TryParse(textBackbone, true, out backbone);
+    }
+
+    private static string NormalizeTextBackbone(string textBackbone)
+    {
+        if (string.Equals(textBackbone, "bert-base", StringComparison.OrdinalIgnoreCase))
+        {
+            return "bert-base-uncased";
+        }
+
+        if (string.Equals(textBackbone, "bert-large", StringComparison.OrdinalIgnoreCase))
+        {
+            return "bert-large-uncased";
+        }
+
+        return textBackbone;
+    }
+
+    private static IEnumerable<string> GetDefaultTokenizerCorpus()
+    {
+        return new[]
+        {
+            "a photo of a document",
+            "invoice total amount",
+            "table row column header",
+            "page number and date",
+            "signature and stamp",
+            "summary section",
+            "this is a test",
+            "layout understanding",
+            "document classification"
+        };
+    }
+
+    #endregion
+
+    #region ILayoutDetector Implementation
+
+    /// <inheritdoc/>
+    public DocumentLayoutResult<T> DetectLayout(Tensor<T> documentImage)
+    {
+        return DetectLayout(documentImage, 0.5);
+    }
+
+    /// <inheritdoc/>
+    public DocumentLayoutResult<T> DetectLayout(Tensor<T> documentImage, double confidenceThreshold)
+    {
+        ValidateImageShape(documentImage);
+        var startTime = DateTime.UtcNow;
+
+        var preprocessed = PreprocessDocument(documentImage);
+        var output = _useNativeMode ? Forward(preprocessed) : RunOnnxInference(preprocessed);
+
+        var regions = ParseLayoutOutput(output, documentImage, confidenceThreshold);
+
+        return new DocumentLayoutResult<T>
+        {
+            Regions = regions,
+            ProcessingTimeMs = (DateTime.UtcNow - startTime).TotalMilliseconds
+        };
+    }
+
+    private List<LayoutRegion<T>> ParseLayoutOutput(Tensor<T> output, Tensor<T> documentImage, double threshold)
+    {
+        var regions = new List<LayoutRegion<T>>();
+        if (output.Shape.Length < 1)
+        {
+            return regions;
+        }
+
+        var layoutOutput = NormalizeLayoutOutput(output);
+        if (layoutOutput.Shape.Length < 2)
+        {
+            return regions;
+        }
+
+        int numDetections = layoutOutput.Shape[0];
+        int numValues = layoutOutput.Shape[1];
+
+        if (numDetections <= 0 || numValues <= 0)
+        {
+            return regions;
+        }
+
+        int numClasses = Math.Min(_numClasses, numValues);
+        bool hasBbox = false;
+        if (numValues > _numClasses && numValues >= 5)
+        {
+            numClasses = Math.Min(_numClasses, numValues - 4);
+            hasBbox = numValues - 4 > 0;
+        }
+
+        GetImageDimensions(documentImage, out int imageWidth, out int imageHeight);
+
+        for (int i = 0; i < numDetections; i++)
+        {
+            double maxConf = double.MinValue;
+            int maxClass = -1;
+            int offset = i * numValues;
+
+            for (int c = 0; c < numClasses; c++)
+            {
+                double conf = NumOps.ToDouble(layoutOutput.Data.Span[offset + c]);
+                if (conf > maxConf)
+                {
+                    maxConf = conf;
+                    maxClass = c;
+                }
+            }
+
+            if (maxClass <= 0 || maxConf < threshold)
+            {
+                continue;
+            }
+
+            var elementType = MapElementType(maxClass);
+            var bbox = hasBbox
+                ? ExtractBoundingBox(layoutOutput, i, numValues, imageWidth, imageHeight)
+                : EstimateGridBoundingBox(i, numDetections, imageWidth, imageHeight);
+
+            if (bbox.Length == 4)
+            {
+                double x1 = NumOps.ToDouble(bbox[0]);
+                double y1 = NumOps.ToDouble(bbox[1]);
+                double x2 = NumOps.ToDouble(bbox[2]);
+                double y2 = NumOps.ToDouble(bbox[3]);
+
+                if (x2 <= x1 || y2 <= y1)
+                {
+                    continue;
+                }
+            }
+
+            regions.Add(new LayoutRegion<T>
+            {
+                ElementType = elementType,
+                Confidence = NumOps.FromDouble(maxConf),
+                ConfidenceValue = maxConf,
+                Index = i,
+                BoundingBox = bbox
+            });
+        }
+
+        return regions;
+    }
+
+    private Tensor<T> NormalizeLayoutOutput(Tensor<T> output)
+    {
+        if (output.Shape.Length == 2)
+        {
+            return output;
+        }
+
+        if (output.Shape.Length == 3 && output.Shape[0] == 1)
+        {
+            return output.Reshape([output.Shape[1], output.Shape[2]]);
+        }
+
+        if (output.Shape.Length == 1)
+        {
+            int expectedWithBbox = _numClasses + 4;
+            if (expectedWithBbox > 0 && output.Length % expectedWithBbox == 0)
+            {
+                return output.Reshape([output.Length / expectedWithBbox, expectedWithBbox]);
+            }
+
+            if (_numClasses > 0 && output.Length % _numClasses == 0)
+            {
+                return output.Reshape([output.Length / _numClasses, _numClasses]);
+            }
+
+            return output.Reshape([1, output.Length]);
+        }
+
+        int lastDim = output.Shape[^1];
+        if (lastDim <= 0 || output.Length % lastDim != 0)
+        {
+            return output.Reshape([1, output.Length]);
+        }
+
+        int numDetections = output.Length / lastDim;
+        return output.Reshape([numDetections, lastDim]);
+    }
+
+    private LayoutElementType MapElementType(int classIndex)
+    {
+        if (classIndex <= 0)
+        {
+            return LayoutElementType.Other;
+        }
+
+        int supportedIndex = classIndex - 1;
+        if (supportedIndex >= 0 && supportedIndex < SupportedElementTypes.Count)
+        {
+            return SupportedElementTypes[supportedIndex];
+        }
+
+        return LayoutElementType.Other;
+    }
+
+    private Vector<T> ExtractBoundingBox(Tensor<T> output, int detectionIndex, int numValues, int imageWidth, int imageHeight)
+    {
+        int bboxOffset = detectionIndex * numValues + numValues - 4;
+        double b0 = NumOps.ToDouble(output.Data.Span[bboxOffset]);
+        double b1 = NumOps.ToDouble(output.Data.Span[bboxOffset + 1]);
+        double b2 = NumOps.ToDouble(output.Data.Span[bboxOffset + 2]);
+        double b3 = NumOps.ToDouble(output.Data.Span[bboxOffset + 3]);
+
+        bool looksNormalized = b0 >= -0.5 && b0 <= 1.5 &&
+                               b1 >= -0.5 && b1 <= 1.5 &&
+                               b2 >= -0.5 && b2 <= 1.5 &&
+                               b3 >= -0.5 && b3 <= 1.5;
+
+        double x1 = b0;
+        double y1 = b1;
+        double x2 = b2;
+        double y2 = b3;
+
+        if (x2 <= x1 || y2 <= y1)
+        {
+            double cx = x1;
+            double cy = y1;
+            double w = Math.Abs(x2);
+            double h = Math.Abs(y2);
+            x1 = cx - w / 2.0;
+            y1 = cy - h / 2.0;
+            x2 = cx + w / 2.0;
+            y2 = cy + h / 2.0;
+        }
+
+        if (looksNormalized)
+        {
+            x1 *= imageWidth;
+            x2 *= imageWidth;
+            y1 *= imageHeight;
+            y2 *= imageHeight;
+        }
+
+        x1 = Clamp(x1, 0, imageWidth);
+        x2 = Clamp(x2, 0, imageWidth);
+        y1 = Clamp(y1, 0, imageHeight);
+        y2 = Clamp(y2, 0, imageHeight);
+
+        return new Vector<T>([
+            NumOps.FromDouble(x1),
+            NumOps.FromDouble(y1),
+            NumOps.FromDouble(x2),
+            NumOps.FromDouble(y2)
+        ]);
+    }
+
+    private Vector<T> EstimateGridBoundingBox(int index, int numDetections, int imageWidth, int imageHeight)
+    {
+        int gridSize = (int)Math.Ceiling(Math.Sqrt(numDetections));
+        if (gridSize <= 0)
+        {
+            gridSize = 1;
+        }
+
+        int cellWidth = Math.Max(1, imageWidth / gridSize);
+        int cellHeight = Math.Max(1, imageHeight / gridSize);
+        int row = index / gridSize;
+        int col = index % gridSize;
+
+        double x1 = col * cellWidth;
+        double y1 = row * cellHeight;
+        double x2 = Math.Min(imageWidth, x1 + cellWidth);
+        double y2 = Math.Min(imageHeight, y1 + cellHeight);
+
+        return new Vector<T>([
+            NumOps.FromDouble(x1),
+            NumOps.FromDouble(y1),
+            NumOps.FromDouble(x2),
+            NumOps.FromDouble(y2)
+        ]);
+    }
+
+    private void GetImageDimensions(Tensor<T> image, out int width, out int height)
+    {
+        if (image.Rank == 4)
+        {
+            height = image.Shape[2];
+            width = image.Shape[3];
+        }
+        else if (image.Rank == 3)
+        {
+            height = image.Shape[1];
+            width = image.Shape[2];
+        }
+        else
+        {
+            height = ImageSize;
+            width = ImageSize;
+        }
+
+        if (height <= 0 || width <= 0)
+        {
+            height = ImageSize;
+            width = ImageSize;
+        }
+    }
+
+    private static double Clamp(double value, double min, double max)
+    {
+        if (value < min) return min;
+        if (value > max) return max;
+        return value;
+    }
+
+    #endregion
+
+    #region IDocumentQA Implementation
+
+    /// <inheritdoc/>
+    public DocumentQAResult<T> AnswerQuestion(Tensor<T> documentImage, string question)
+    {
+        return AnswerQuestion(documentImage, question, 64, 0.0);
+    }
+
+    /// <inheritdoc/>
+    public DocumentQAResult<T> AnswerQuestion(Tensor<T> documentImage, string question, int maxAnswerLength, double temperature = 0.0)
+    {
+        ValidateImageShape(documentImage);
+        var startTime = DateTime.UtcNow;
+
+        var preprocessed = PreprocessDocument(documentImage);
+        var output = _useNativeMode ? Forward(preprocessed) : RunOnnxInference(preprocessed);
+
+        // Extract answer using extractive QA approach
+        var (answer, confidence) = ExtractAnswer(output, maxAnswerLength, temperature);
+
+        return new DocumentQAResult<T>
+        {
+            Answer = answer,
+            Confidence = NumOps.FromDouble(confidence),
+            ConfidenceValue = confidence,
+            Question = question,
+            ProcessingTimeMs = (DateTime.UtcNow - startTime).TotalMilliseconds
+        };
+    }
+
+    /// <summary>
+    /// Extracts answer from model output using a token-probability decoding pass.
+    /// </summary>
+    private (string answer, double confidence) ExtractAnswer(Tensor<T> output, int maxAnswerLength, double temperature)
+    {
+        var logits = NormalizeAnswerLogits(output);
+        if (logits.Shape.Length < 2)
+        {
+            return ("[No answer found]", 0.0);
+        }
+
+        int seqLen = logits.Shape[0];
+        int vocabSize = logits.Shape[1];
+        if (_vocabSize > 0)
+        {
+            vocabSize = Math.Min(vocabSize, _vocabSize);
+        }
+
+        if (seqLen <= 0 || vocabSize <= 0)
+        {
+            return ("[No answer found]", 0.0);
+        }
+
+        if (maxAnswerLength <= 0)
+        {
+            return ("[No answer found]", 0.0);
+        }
+
+        int maxLen = Math.Min(seqLen, maxAnswerLength);
+        var tokens = new List<int>(maxLen);
+        double confidenceSum = 0.0;
+        int confidenceCount = 0;
+
+        int eosId = GetSpecialTokenId(_tokenizer.SpecialTokens.EosToken);
+        int sepId = GetSpecialTokenId(_tokenizer.SpecialTokens.SepToken);
+        int padId = GetSpecialTokenId(_tokenizer.SpecialTokens.PadToken);
+        int clsId = GetSpecialTokenId(_tokenizer.SpecialTokens.ClsToken);
+
+        var random = RandomHelper.Shared;
+        bool sampleTokens = temperature > 0.0;
+
+        for (int i = 0; i < maxLen; i++)
+        {
+            int offset = i * logits.Shape[1];
+            int tokenId;
+            double tokenProb;
+
+            if (sampleTokens)
+            {
+                tokenId = SampleToken(logits, offset, vocabSize, temperature, random, out tokenProb);
+            }
+            else
+            {
+                tokenId = SelectGreedyToken(logits, offset, vocabSize, out tokenProb);
+            }
+
+            if ((eosId >= 0 && tokenId == eosId) || (sepId >= 0 && tokenId == sepId))
+            {
+                break;
+            }
+
+            if ((padId >= 0 && tokenId == padId) || (clsId >= 0 && tokenId == clsId))
+            {
+                continue;
+            }
+
+            tokens.Add(tokenId);
+            confidenceSum += tokenProb;
+            confidenceCount++;
+        }
+
+        if (tokens.Count == 0)
+        {
+            return ("[No answer found]", 0.0);
+        }
+
+        string answer = _tokenizer.Decode(tokens, skipSpecialTokens: true).Trim();
+        if (string.IsNullOrWhiteSpace(answer))
+        {
+            return ("[No answer found]", 0.0);
+        }
+
+        double confidence = confidenceCount > 0 ? confidenceSum / confidenceCount : 0.0;
+        return (answer, confidence);
+    }
+
+    private Tensor<T> NormalizeAnswerLogits(Tensor<T> output)
+    {
+        if (output.Shape.Length == 2)
+        {
+            return output;
+        }
+
+        if (output.Shape.Length == 3 && output.Shape[0] == 1)
+        {
+            return output.Reshape([output.Shape[1], output.Shape[2]]);
+        }
+
+        if (output.Shape.Length == 1)
+        {
+            if (_vocabSize > 0 && output.Length % _vocabSize == 0)
+            {
+                return output.Reshape([output.Length / _vocabSize, _vocabSize]);
+            }
+
+            return output.Reshape([1, output.Length]);
+        }
+
+        int lastDim = output.Shape[^1];
+        if (lastDim <= 0 || output.Length % lastDim != 0)
+        {
+            return output.Reshape([1, output.Length]);
+        }
+
+        int seqLen = output.Length / lastDim;
+        return output.Reshape([seqLen, lastDim]);
+    }
+
+    private int SelectGreedyToken(Tensor<T> logits, int offset, int vocabSize, out double probability)
+    {
+        double maxVal = double.MinValue;
+        int maxIdx = 0;
+
+        for (int v = 0; v < vocabSize; v++)
+        {
+            double val = NumOps.ToDouble(logits.Data.Span[offset + v]);
+            if (val > maxVal)
+            {
+                maxVal = val;
+                maxIdx = v;
+            }
+        }
+
+        double sumExp = 0.0;
+        for (int v = 0; v < vocabSize; v++)
+        {
+            double val = NumOps.ToDouble(logits.Data.Span[offset + v]);
+            sumExp += Math.Exp(val - maxVal);
+        }
+
+        probability = sumExp > 0 ? 1.0 / sumExp : 0.0;
+        return maxIdx;
+    }
+
+    private int SampleToken(Tensor<T> logits, int offset, int vocabSize, double temperature, Random random, out double probability)
+    {
+        double maxVal = double.MinValue;
+        for (int v = 0; v < vocabSize; v++)
+        {
+            double scaled = NumOps.ToDouble(logits.Data.Span[offset + v]) / temperature;
+            if (scaled > maxVal)
+            {
+                maxVal = scaled;
+            }
+        }
+
+        double sumExp = 0.0;
+        for (int v = 0; v < vocabSize; v++)
+        {
+            double scaled = NumOps.ToDouble(logits.Data.Span[offset + v]) / temperature;
+            sumExp += Math.Exp(scaled - maxVal);
+        }
+
+        if (sumExp <= 0.0)
+        {
+            probability = 0.0;
+            return 0;
+        }
+
+        double roll = random.NextDouble() * sumExp;
+        double cumulative = 0.0;
+        for (int v = 0; v < vocabSize; v++)
+        {
+            double scaled = NumOps.ToDouble(logits.Data.Span[offset + v]) / temperature;
+            double expVal = Math.Exp(scaled - maxVal);
+            cumulative += expVal;
+            if (cumulative >= roll)
+            {
+                probability = expVal / sumExp;
+                return v;
+            }
+        }
+
+        probability = 0.0;
+        return vocabSize - 1;
+    }
+
+    private int GetSpecialTokenId(string token)
+    {
+        if (string.IsNullOrWhiteSpace(token))
+        {
+            return -1;
+        }
+
+        var vocabulary = _tokenizer.Vocabulary;
+        if (!vocabulary.ContainsToken(token))
+        {
+            return -1;
+        }
+
+        return vocabulary.GetTokenId(token);
+    }
+
+    /// <inheritdoc/>
+    public IEnumerable<DocumentQAResult<T>> AnswerQuestions(Tensor<T> documentImage, IEnumerable<string> questions)
+    {
+        foreach (var q in questions)
+            yield return AnswerQuestion(documentImage, q);
+    }
+
+    /// <inheritdoc/>
+    public Dictionary<string, DocumentQAResult<T>> ExtractFields(Tensor<T> documentImage, IEnumerable<string> fieldPrompts)
+    {
+        var results = new Dictionary<string, DocumentQAResult<T>>();
+        foreach (var field in fieldPrompts)
+            results[field] = AnswerQuestion(documentImage, $"What is the {field}?");
+        return results;
+    }
+
+    #endregion
+
+    #region IDocumentModel Implementation
+
+    /// <inheritdoc/>
+    public Tensor<T> EncodeDocument(Tensor<T> documentImage)
+    {
+        ValidateImageShape(documentImage);
+        var preprocessed = PreprocessDocument(documentImage);
+        return _useNativeMode ? Forward(preprocessed) : RunOnnxInference(preprocessed);
+    }
+
+    /// <inheritdoc/>
+    public void ValidateInputShape(Tensor<T> documentImage)
+    {
+        ValidateImageShape(documentImage);
+    }
+
+    /// <inheritdoc/>
+    public string GetModelSummary()
+    {
+        var sb = new System.Text.StringBuilder();
+        sb.AppendLine("LiLT Model Summary");
+        sb.AppendLine("==================");
+        sb.AppendLine($"Mode: {(_useNativeMode ? "Native (Trainable)" : "ONNX (Inference)")}");
+        sb.AppendLine($"Architecture: Dual-stream with BiACM");
+        sb.AppendLine($"Text Backbone: {_textBackbone}");
+        sb.AppendLine($"Hidden Dimension: {_hiddenDim}");
+        sb.AppendLine($"Number of Layers: {_numLayers}");
+        sb.AppendLine($"Attention Heads: {_numHeads}");
+        sb.AppendLine($"Max Sequence Length: {MaxSequenceLength}");
+        sb.AppendLine($"Number of Classes: {_numClasses}");
+        sb.AppendLine($"Language Independent: Yes");
+        sb.AppendLine($"Total Layers: {Layers.Count}");
+        return sb.ToString();
+    }
+
+    #endregion
+
+    #region Preprocessing
+
+    /// <summary>
+    /// Applies LiLT's industry-standard preprocessing: ImageNet normalization.
+    /// </summary>
+    /// <remarks>
+    /// LiLT (Language-independent Layout Transformer) uses ImageNet normalization with mean=[0.485, 0.456, 0.406] and std=[0.229, 0.224, 0.225].
+    /// </remarks>
+    protected override Tensor<T> ApplyDefaultPreprocessing(Tensor<T> rawImage)
+    {
+        var image = EnsureBatchDimension(rawImage);
+        int batchSize = image.Shape[0];
+        int channels = image.Shape[1];
+        int height = image.Shape[2];
+        int width = image.Shape[3];
+
+        var normalized = new Tensor<T>(image._shape);
+        double[] means = [0.485, 0.456, 0.406];
+        double[] stds = [0.229, 0.224, 0.225];
+
+        for (int b = 0; b < batchSize; b++)
+        {
+            for (int c = 0; c < channels; c++)
+            {
+                double mean = c < means.Length ? means[c] : 0.5;
+                double std = c < stds.Length ? stds[c] : 0.5;
+                for (int h = 0; h < height; h++)
+                {
+                    for (int w = 0; w < width; w++)
+                    {
+                        int idx = b * channels * height * width + c * height * width + h * width + w;
+                        normalized.Data.Span[idx] = NumOps.FromDouble((NumOps.ToDouble(image.Data.Span[idx]) - mean) / std);
+                    }
+                }
+            }
+        }
+        return normalized;
+    }
+
+    /// <summary>
+    /// Applies LiLT's industry-standard postprocessing: pass-through (layout-aware outputs are already final).
+    /// </summary>
+    protected override Tensor<T> ApplyDefaultPostprocessing(Tensor<T> modelOutput) => modelOutput;
+
+    #endregion
+
+    #region Serialization
+
+    /// <inheritdoc/>
+    public override ModelMetadata<T> GetModelMetadata()
+    {
+        return new ModelMetadata<T>
+        {
+            Name = "LiLT",
+            Description = "LiLT for language-independent layout understanding (ACL 2022)",
+            FeatureCount = _hiddenDim,
+            Complexity = _numLayers,
+            AdditionalInfo = new Dictionary<string, object>
+            {
+                { "hidden_dim", _hiddenDim },
+                { "num_layers", _numLayers },
+                { "num_heads", _numHeads },
+                { "vocab_size", _vocabSize },
+                { "max_sequence_length", MaxSequenceLength },
+                { "num_classes", _numClasses },
+                { "text_backbone", _textBackbone },
+                { "use_native_mode", _useNativeMode }
+            },
+            ModelData = SafeSerialize()
+        };
+    }
+
+    #endregion
+
+    #region NeuralNetworkBase Implementation
+
+    /// <inheritdoc/>
+    protected override Tensor<T> PredictCore(Tensor<T> input)
+    {
+        var preprocessed = PreprocessDocument(input);
+        return _useNativeMode ? Forward(preprocessed) : RunOnnxInference(preprocessed);
+    }
+
+    // ── Faithful LiLT dual-stream forward with BiACM (Wang et al. 2022, §3.2) ──────────────────────────
+    // Layer layout from CreateDefaultLiLTLayers: [0]=text LayoutEmbeddingLayer (word + learned 1D
+    // position, no layout terms), [1]=boxes-only LayoutEmbeddingLayer (the paper's per-coordinate
+    // tables), [2]=layout LayerNorm, then numLayers blocks of 7 layers
+    // [textMHA, textLN, layoutMHA, layoutLN, ffn1, ffn2, ffnLN], then [Dropout, Dense(head)].
+    //
+    // Three, not four: the text side's Embedding + sinusoidal PositionalEncoding pair became one
+    // block with LEARNED positions, and the layout side's Dense(box→hidden) became the coordinate
+    // lookup the paper specifies.
+    private const int LiLTPrefixLayers = 3;
+    private const int LiLTBlockLayers = 7;
+    private int HeadDim => _hiddenDim / _numHeads;
+
+    // BiACM is LiLT's contribution: the two streams SHARE attention scores. The text stream's scores get
+    // the layout scores added (layout complements text); the layout stream's scores get the text scores
+    // added but DETACHED (StopGradient), so the reusable pre-trained text encoder is not perturbed by the
+    // layout branch's gradient — exactly the asymmetric coupling in the paper.
+    private Tensor<T> RunDualStream(Tensor<T> textTokens, Tensor<T>? layoutBoxes)
+    {
+        // Text stream embeddings: word + learned 1D position, in one block.
+        var text = Layers[0].Forward(textTokens);
+
+        // Layout stream embeddings from bounding boxes: Dense(box→hidden) + LayerNorm. Absent boxes ⇒
+        // text-only operation (graceful degradation the reference model lacks); BiACM then reduces to a
+        // standard text self-attention transformer.
+        Tensor<T>? layout = null;
+        if (layoutBoxes is not null)
+            layout = Layers[2].Forward(Layers[1].Forward(layoutBoxes));
+
+        int numBlocks = (Layers.Count - LiLTPrefixLayers - 2) / LiLTBlockLayers;
+        for (int b = 0; b < numBlocks; b++)
+            (text, layout) = BiACMBlock(text, layout, LiLTPrefixLayers + b * LiLTBlockLayers);
+
+        // Classification head runs on the TEXT stream (the paper's task head consumes the language flow).
+        int headStart = LiLTPrefixLayers + numBlocks * LiLTBlockLayers;
+        var output = text;
+        for (int i = headStart; i < Layers.Count; i++)
+            output = Layers[i].Forward(output);
+        return output;
+    }
+
+    private (Tensor<T> text, Tensor<T>? layout) BiACMBlock(Tensor<T> text, Tensor<T>? layout, int baseIdx)
+    {
+        var tMHA = (MultiHeadAttentionLayer<T>)Layers[baseIdx];
+        var tLN = Layers[baseIdx + 1];
+        var lMHA = (MultiHeadAttentionLayer<T>)Layers[baseIdx + 2];
+        var lLN = Layers[baseIdx + 3];
+        var ffn1 = Layers[baseIdx + 4];
+        var ffn2 = Layers[baseIdx + 5];
+        var ffnLN = Layers[baseIdx + 6];
+
+        int seqT = text.Shape[0];
+        var st = SelfAttentionScores(text, tMHA, seqT, out var vt);
+
+        Tensor<T>? sl = null, vl = null; int seqL = 0;
+        if (layout is not null)
+        {
+            seqL = layout.Shape[0];
+            sl = SelfAttentionScores(layout, lMHA, seqL, out vl);
+        }
+
+        // BiACM score sharing requires the two streams to be token-aligned (one layout box per text
+        // token) so the [heads, seq, seq] score matrices are addable — the paper's assumption. If a
+        // caller supplies mismatched lengths the streams run independently rather than crashing.
+        bool coupled = sl is not null && seqL == seqT;
+        var stShared = coupled ? Engine.TensorAdd(st, sl!) : st;
+        var ctxT = ApplyAttention(stShared, vt, seqT, tMHA);
+        text = tLN.Forward(Engine.TensorAdd(text, ctxT));
+        text = ffnLN.Forward(Engine.TensorAdd(text, ffn2.Forward(ffn1.Forward(text))));
+
+        if (layout is not null)
+        {
+            // Text scores DETACHED into the layout stream so the language encoder stays reusable.
+            var slShared = coupled ? Engine.TensorAdd(sl!, Engine.StopGradient(st)) : sl!;
+            var ctxL = ApplyAttention(slShared, vl!, seqL, lMHA);
+            layout = lLN.Forward(Engine.TensorAdd(layout, ctxL));
+            layout = ffnLN.Forward(Engine.TensorAdd(layout, ffn2.Forward(ffn1.Forward(layout))));
+        }
+        return (text, layout);
+    }
+
+    // Projects x[seq,D] to per-head Q/K/V via the MHA layer's weights, returns scaled QKᵀ scores
+    // [heads,seq,seq] and the per-head values V [heads,seq,headDim].
+    private Tensor<T> SelfAttentionScores(Tensor<T> x, MultiHeadAttentionLayer<T> mha, int seq, out Tensor<T> v)
+    {
+        var q = SplitHeads(Engine.TensorMatMul(x, mha.GetQueryWeights()), seq);
+        var k = SplitHeads(Engine.TensorMatMul(x, mha.GetKeyWeights()), seq);
+        v = SplitHeads(Engine.TensorMatMul(x, mha.GetValueWeights()), seq);
+        var scores = Engine.BatchMatMul(q, Engine.TensorPermute(k, new[] { 0, 2, 1 }));
+        return Engine.TensorMultiplyScalar(scores, NumOps.FromDouble(1.0 / Math.Sqrt(HeadDim)));
+    }
+
+    // softmax(scores)·V → merge heads → output projection.
+    private Tensor<T> ApplyAttention(Tensor<T> scores, Tensor<T> v, int seq, MultiHeadAttentionLayer<T> mha)
+    {
+        var ctx = Engine.BatchMatMul(Engine.Softmax(scores, axis: -1), v);   // [heads, seq, headDim]
+        var merged = MergeHeads(ctx, seq);                                    // [seq, D]
+        return Engine.TensorMatMul(merged, mha.GetOutputWeights());
+    }
+
+    private Tensor<T> SplitHeads(Tensor<T> x, int seq)
+        => Engine.TensorPermute(Engine.Reshape(x, new[] { seq, _numHeads, HeadDim }), new[] { 1, 0, 2 });
+
+    private Tensor<T> MergeHeads(Tensor<T> x, int seq)
+        => Engine.Reshape(Engine.TensorPermute(x, new[] { 1, 0, 2 }), new[] { seq, _hiddenDim });
+
+    /// <summary>
+    /// Full dual-stream fusion entry (industry-standard LiLT): encodes text token IDs AND their layout
+    /// bounding boxes through the coupled BiACM transformer. <paramref name="layoutBoxes"/> is the
+    /// per-token box feature tensor the layout Dense consumes; pass null for text-only operation.
+    /// </summary>
+    public Tensor<T> EncodeDualStream(Tensor<T> textTokens, Tensor<T>? layoutBoxes)
+    {
+        using var _ = new AiDotNet.Tensors.Engines.Autodiff.NoGradScope<T>();
+        return RunDualStream(textTokens, layoutBoxes);
+    }
+
+    // LiLT is a text + layout model: a rank-1/2 token-ID input drives the BiACM dual-stream (text-only
+    // when no boxes accompany it). A higher-rank input (e.g. a raw image handed to Predict) isn't LiLT's
+    // modality, so defer to the base sequential walk rather than forcing it through the token path.
+    /// <inheritdoc/>
+    protected override Tensor<T> Forward(Tensor<T> input)
+        => RouteDualStream(input, trainingPath: false);
+
+    /// <inheritdoc/>
+    public override Tensor<T> ForwardForTraining(Tensor<T> input)
+        => RouteDualStream(input, trainingPath: true);
+
+    /// <summary>
+    /// Sends an input through the BiACM dual stream, unpacking bounding boxes when they are present.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// Both forwards used to pass <c>null</c> for boxes. The layout stream was therefore unreachable
+    /// from <c>Predict</c> and from <c>Train</c> alike -- LiLT could only ever run, and only ever
+    /// learn, as a plain text transformer, which is the one thing the paper is not about. The only
+    /// entry point that accepted boxes, <see cref="EncodeDualStream"/>, opens a <c>NoGradScope</c>
+    /// and so could never train the layout side either.
+    /// </para>
+    /// <para>
+    /// A packed <c>[seq, 5]</c> row -- <c>(tokenId, x0, y0, x1, y1)</c>, the convention the rest of
+    /// this family uses -- is split here and both halves reach the streams, on the training path as
+    /// well as the inference one. A bare token sequence still runs text-only, so callers with no OCR
+    /// boxes are unaffected. A higher-rank input is not LiLT's modality and defers to the base walk.
+    /// </para>
+    /// </remarks>
+    /// <summary>
+    /// Reports per-stage activations by running LiLT's actual dual stream.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// The base implementation walks <c>Layers</c> as a chain, feeding each layer the previous one's
+    /// output. LiLT is not a chain: <c>Layers[0]</c> embeds text, <c>Layers[1..2]</c> embed layout
+    /// from bounding boxes, and the blocks after them consume BOTH. Walking it linearly handed the
+    /// layout embedding a text activation, which the old <c>Dense(box-&gt;hidden)</c> silently accepted
+    /// and multiplied -- so the reported "activations" were arithmetic on mismatched tensors that
+    /// corresponded to nothing the model computes. The coordinate lookup that replaced the Dense
+    /// rejects it outright, which is the correct response to being handed the wrong stream.
+    /// </para>
+    /// <para>
+    /// Running the real dual stream reports what the model actually produces, and names the two
+    /// streams so a caller can tell them apart.
+    /// </para>
+    /// </remarks>
+    public override Dictionary<string, Tensor<T>> GetNamedLayerActivations(Tensor<T> input)
+    {
+        if (!_useNativeMode || input.Rank > 2)
+        {
+            return base.GetNamedLayerActivations(input);
+        }
+
+        using var _ = new AiDotNet.Tensors.Engines.Autodiff.NoGradScope<T>();
+
+        Tensor<T> tokens = input;
+        Tensor<T>? boxes = null;
+        if (TrySplitPackedLayout(input, out var splitTokens, out var splitBoxes))
+        {
+            tokens = splitTokens;
+            boxes = splitBoxes;
+        }
+
+        var activations = new Dictionary<string, Tensor<T>>
+        {
+            ["text_embedding"] = Layers[0].Forward(tokens),
+        };
+
+        if (boxes is not null)
+        {
+            activations["layout_embedding"] = Layers[2].Forward(Layers[1].Forward(boxes));
+        }
+
+        activations["output"] = RunDualStream(tokens, boxes);
+        return activations;
+    }
+
+
+    private Tensor<T> RouteDualStream(Tensor<T> input, bool trainingPath)
+    {
+        if (_useNativeMode && TrySplitPackedLayout(input, out var tokens, out var boxes))
+        {
+            return RunDualStream(tokens, boxes);
+        }
+
+        if (_useNativeMode && input.Rank <= 2)
+        {
+            return RunDualStream(input, null);
+        }
+
+        return trainingPath ? base.ForwardForTraining(input) : base.Forward(input);
+    }
+
+    /// <summary>
+    /// Splits a packed <c>[seq, 5]</c> or <c>[batch, seq, 5]</c> tensor into token IDs and the
+    /// <c>[.., 4]</c> box tensor the layout stream consumes. False when the input is not packed.
+    /// </summary>
+    private static bool TrySplitPackedLayout(Tensor<T> input, out Tensor<T> tokens, out Tensor<T>? boxes)
+    {
+        tokens = input;
+        boxes = null;
+
+        int rank = input.Rank;
+        if (rank < 2 || input.Shape[rank - 1] != NeuralNetworks.Layers.LayoutEmbeddingLayer<T>.PackedRowWidth)
+            return false;
+
+        int rows = 1;
+        for (int i = 0; i < rank - 1; i++) rows *= input.Shape[i];
+
+        var tokenShape = new int[rank - 1];
+        for (int i = 0; i < rank - 1; i++) tokenShape[i] = input.Shape[i];
+
+        var boxShape = new int[rank];
+        for (int i = 0; i < rank - 1; i++) boxShape[i] = input.Shape[i];
+        boxShape[rank - 1] = LayoutBoxWidth;
+
+        var tokenTensor = new Tensor<T>(tokenShape);
+        var boxTensor = new Tensor<T>(boxShape);
+        var src = input.Data.Span;
+        var tokenDst = tokenTensor.Data.Span;
+        var boxDst = boxTensor.Data.Span;
+
+        for (int r = 0; r < rows; r++)
+        {
+            int b = r * NeuralNetworks.Layers.LayoutEmbeddingLayer<T>.PackedRowWidth;
+            tokenDst[r] = src[b];
+            for (int c = 0; c < LayoutBoxWidth; c++)
+                boxDst[r * LayoutBoxWidth + c] = src[b + 1 + c];
+        }
+
+        tokens = tokenTensor;
+        boxes = boxTensor;
+        return true;
+    }
+
+    /// <summary>Coordinates per box: x0, y0, x1, y1.</summary>
+    private const int LayoutBoxWidth = 4;
+
+    /// <inheritdoc/>
+    public override void Train(Tensor<T> input, Tensor<T> expectedOutput)
+    {
+        if (!_useNativeMode)
+            throw new NotSupportedException("Training not supported in ONNX mode.");
+
+        // TrainWithTape runs the forward, backprops, and applies the optimizer update itself. The
+        // earlier UpdateParameters(CollectGradients()) applied a redundant SECOND naive SGD step (lr 5e-5)
+        // over every parameter on top of the Adam update — counting each gradient twice and driving the
+        // network into a degenerate collapsed state (DifferentInputs_AfterTraining saw identical output
+        // for distinct inputs). TrainWithTape alone is the correct single update.
+        SetTrainingMode(true);
+        try
+        {
+            TrainWithTape(input, expectedOutput, _optimizer);
+        }
+        finally
+        {
+            SetTrainingMode(false);
+        }
+    }
+
+    // UpdateParameters applied a GRADIENT STEP, but its one-argument form is the value setter and every caller passes values -- the override corrupted the model. Removed under AIDN082.
+
+
+    /// <summary>
+    /// Parameters cannot be written while the model is backed by a loaded ONNX graph: the weights
+    /// belong to that graph, not to this instance.
+    /// </summary>
+    /// <remarks>
+    /// Replaces a hand-written throw that used to sit inside UpdateParameters. The base checks this
+    /// on every mutating entry point rather than the one member the throw happened to guard, and
+    /// reading -- ParameterCount and GetParameters -- stays available either way.
+    /// </remarks>
+    protected override bool SupportsParameterMutation => _useNativeMode;
+    #endregion
+
+    #region Disposal
+
+    /// <inheritdoc/>
+    protected override void Dispose(bool disposing)
+    {
+        if (disposing)
+            _onnxSession?.Dispose();
+        base.Dispose(disposing);
+    }
+
+    #endregion
+}
diff --git a/src/Document/OCR/TextDetection/CRAFT.cs b/src/Document/OCR/TextDetection/CRAFT.cs
index 13f8c1db03..a93adabe35 100644
--- a/src/Document/OCR/TextDetection/CRAFT.cs
+++ b/src/Document/OCR/TextDetection/CRAFT.cs
@@ -452,30 +452,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_backboneChannels);
-        writer.Write(_upscaleChannels);
-        writer.Write(ImageSize);
-        writer.Write(_useNativeMode);
-    }
-
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        int backboneChannels = reader.ReadInt32();
-        int upscaleChannels = reader.ReadInt32();
-        int imageSize = reader.ReadInt32();
-        bool useNativeMode = reader.ReadBoolean();
 
-        ImageSize = imageSize;
-    }
 
     /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new CRAFT<T>(Architecture, ImageSize, _backboneChannels, _upscaleChannels);
-    }
+
 
     #endregion
 
diff --git a/src/Document/OCR/TextDetection/DBNet.cs b/src/Document/OCR/TextDetection/DBNet.cs
index 78f95dd0d9..fb8c93e058 100644
--- a/src/Document/OCR/TextDetection/DBNet.cs
+++ b/src/Document/OCR/TextDetection/DBNet.cs
@@ -609,43 +609,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_backboneChannels);
-        writer.Write(_innerChannels);
-        writer.Write(ImageSize);
-        writer.Write(_expandRatio);
-        writer.Write(_thresholdK);
-        writer.Write(_minTextArea);
-        writer.Write(_useNativeMode);
-    }
-
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        int backboneChannels = reader.ReadInt32();
-        int innerChannels = reader.ReadInt32();
-        int imageSize = reader.ReadInt32();
-        double expandRatio = reader.ReadDouble();
-        double thresholdK = reader.ReadDouble();
-        int minTextArea = reader.ReadInt32();
-        bool useNativeMode = reader.ReadBoolean();
 
-        ImageSize = imageSize;
-    }
 
     /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new DBNet<T>(
-            Architecture,
-            ImageSize,
-            _backboneChannels,
-            _innerChannels,
-            _expandRatio,
-            _thresholdK,
-            _minTextArea);
-    }
+
 
     #endregion
 
diff --git a/src/Document/OCR/TextDetection/EAST.cs b/src/Document/OCR/TextDetection/EAST.cs
index 08da400277..dbef9060c0 100644
--- a/src/Document/OCR/TextDetection/EAST.cs
+++ b/src/Document/OCR/TextDetection/EAST.cs
@@ -1,750 +1,729 @@
-using AiDotNet.Attributes;
-using AiDotNet.Document.Interfaces;
-using AiDotNet.Document.Options;
-using AiDotNet.Enums;
-using AiDotNet.Helpers;
-using AiDotNet.Interfaces;
-using AiDotNet.LinearAlgebra;
-using AiDotNet.LossFunctions;
-using AiDotNet.NeuralNetworks;
-using AiDotNet.NeuralNetworks.Layers;
-using AiDotNet.Optimizers;
-using Microsoft.ML.OnnxRuntime;
-
-namespace AiDotNet.Document.OCR.TextDetection;
-
-/// <summary>
-/// EAST (Efficient and Accurate Scene Text Detector) for text detection.
-/// </summary>
-/// <typeparam name="T">The numeric type used for calculations.</typeparam>
-/// <remarks>
-/// <para>
-/// EAST is a fast and accurate scene text detector that directly predicts text regions
-/// without requiring complex post-processing like NMS across multiple stages.
-/// </para>
-/// <para>
-/// <b>For Beginners:</b> EAST is designed for speed and accuracy:
-/// 1. Single-shot detection (no multi-stage pipeline)
-/// 2. Outputs rotated boxes or quadrilaterals
-/// 3. Very fast inference
-/// 4. Works on arbitrary text orientations
-///
-/// Key features:
-/// - Fully convolutional architecture
-/// - Multi-scale feature fusion
-/// - Direct geometry prediction
-/// - Efficient NMS
-///
-/// Example usage:
-/// <code>
-/// var model = new EAST&lt;float&gt;(architecture);
-/// var result = model.DetectText(sceneImage);
-/// </code>
-/// </para>
-/// <para>
-/// <b>Reference:</b> "EAST: An Efficient and Accurate Scene Text Detector" (CVPR 2017)
-/// https://arxiv.org/abs/1704.03155
-/// </para>
-/// </remarks>
-[ModelDomain(ModelDomain.Vision)]
-[ModelCategory(ModelCategory.NeuralNetwork)]
-[ModelCategory(ModelCategory.ConvolutionalNetwork)]
-[ModelTask(ModelTask.Detection)]
-[ModelComplexity(ModelComplexity.Medium)]
-[ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
-[ResearchPaper("EAST: An Efficient and Accurate Scene Text Detector", "https://doi.org/10.48550/arXiv.1704.03155", Year = 2017, Authors = "Xinyu Zhou, Cong Yao, He Wen, Yuzhi Wang, Shuchang Zhou, Weiran He, Jiajun Liang")]
-public partial class EAST<T> : DocumentNeuralNetworkBase<T>, ITextDetector<T>
-{
-    private readonly EASTOptions _options;
-
-    /// <inheritdoc/>
-    public override ModelOptions GetOptions() => _options;
-
-    #region Fields
-
-    private readonly bool _useNativeMode;
-    private readonly InferenceSession? _onnxSession;
-    private readonly IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>> _optimizer;
-    private readonly int _backboneChannels;
-    private readonly int _featureChannels;
-    private readonly string _geometryType;
-
-    // Native mode layers
-    private readonly List<ILayer<T>> _backboneLayers = [];
-    private readonly List<ILayer<T>> _mergeLayers = [];
-    private readonly List<ILayer<T>> _outputLayers = [];
-
-    #endregion
-
-    #region Properties
-
-    /// <inheritdoc/>
-    public override DocumentType SupportedDocumentTypes => DocumentType.All;
-
-    /// <inheritdoc/>
-    public override bool RequiresOCR => false;
-
-    /// <inheritdoc/>
-    public int ExpectedImageSize => ImageSize;
-
-    /// <inheritdoc/>
-    public bool SupportsRotatedText => true;
-
-    /// <inheritdoc/>
-    public int MinTextHeight => 8;
-
-    /// <inheritdoc/>
-    public bool SupportsPolygonOutput => true;
-
-    /// <summary>
-    /// Gets the geometry output type (RBOX or QUAD).
-    /// </summary>
-    public string GeometryType => _geometryType;
-
-    #endregion
-
-    #region Constructors
-
-    /// <summary>
-    /// Creates an EAST model using a pre-trained ONNX model for inference.
-    /// </summary>
-    public EAST(
-        NeuralNetworkArchitecture<T> architecture,
-        string onnxModelPath,
-        int imageSize = 512,
-        int backboneChannels = 512,
-        int featureChannels = 128,
-        string geometryType = "RBOX",
-        IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? optimizer = null,
-        ILossFunction<T>? lossFunction = null,
-        EASTOptions? options = null)
-        : base(architecture, lossFunction ?? new MeanSquaredErrorLoss<T>(), 1.0)
-    {
-        _options = options ?? new EASTOptions();
-        Options = _options;
-
-        if (string.IsNullOrWhiteSpace(onnxModelPath))
-            throw new ArgumentNullException(nameof(onnxModelPath));
-        if (!File.Exists(onnxModelPath))
-            throw new FileNotFoundException($"ONNX model not found: {onnxModelPath}", onnxModelPath);
-
-        _useNativeMode = false;
-        _backboneChannels = backboneChannels;
-        _featureChannels = featureChannels;
-        _geometryType = geometryType;
-        _optimizer = optimizer ?? new AdamOptimizer<T, Tensor<T>, Tensor<T>>(this);
-
-        ImageSize = imageSize;
-
-        _onnxSession = new InferenceSession(onnxModelPath);
-
-        InitializeLayers();
-    }
-
-    /// <summary>
-    /// Creates an EAST model using native layers for training and inference.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// <b>Default Configuration (EAST from CVPR 2017):</b>
-    /// - Backbone: PVANet or VGG16
-    /// - Feature merge: U-Net style
-    /// - Output: Score map + Geometry (RBOX or QUAD)
-    /// - NMS threshold: 0.2
-    /// </para>
-    /// </remarks>
-    public EAST(
-        NeuralNetworkArchitecture<T> architecture,
-        int imageSize = 512,
-        int backboneChannels = 512,
-        int featureChannels = 128,
-        string geometryType = "RBOX",
-        IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? optimizer = null,
-        ILossFunction<T>? lossFunction = null,
-        EASTOptions? options = null)
-        : base(architecture, lossFunction ?? new MeanSquaredErrorLoss<T>(), 1.0)
-    {
-        _options = options ?? new EASTOptions();
-        Options = _options;
-
-        _useNativeMode = true;
-        _backboneChannels = backboneChannels;
-        _featureChannels = featureChannels;
-        _geometryType = geometryType;
-        _optimizer = optimizer ?? new AdamOptimizer<T, Tensor<T>, Tensor<T>>(this);
-
-        ImageSize = imageSize;
-
-        InitializeLayers();
-    }
-
-    #endregion
-
-    #region Initialization
-
-    /// <inheritdoc/>
-    protected override void InitializeLayers()
-    {
-        if (!_useNativeMode)
-        {
-            return;
-        }
-
-        if (Architecture.Layers is not null && Architecture.Layers.Count > 0)
-        {
-            Layers.AddRange(Architecture.Layers);
-            ValidateCustomLayers(Layers);
-            return;
-        }
-
-        Layers.AddRange(LayerHelper<T>.CreateDefaultEASTLayers(
-            imageSize: ImageSize,
-            backboneChannels: _backboneChannels,
-            featureChannels: _featureChannels,
-            geometryType: _geometryType));
-    }
-
-    #endregion
-
-    #region ITextDetector Implementation
-
-    /// <inheritdoc/>
-    public TextDetectionResult<T> DetectText(Tensor<T> documentImage)
-    {
-        return DetectText(documentImage, 0.5);
-    }
-
-    /// <inheritdoc/>
-    public TextDetectionResult<T> DetectText(Tensor<T> documentImage, double confidenceThreshold)
-    {
-        ValidateImageShape(documentImage);
-        var startTime = DateTime.UtcNow;
-
-        var preprocessed = PreprocessDocument(documentImage);
-        var output = _useNativeMode ? Forward(preprocessed) : RunOnnxInference(preprocessed);
-
-        var regions = ParseEASTOutput(output, confidenceThreshold);
-
-        return new TextDetectionResult<T>
-        {
-            TextRegions = regions,
-            ProcessingTimeMs = (DateTime.UtcNow - startTime).TotalMilliseconds
-        };
-    }
-
-    /// <inheritdoc/>
-    public IEnumerable<TextDetectionResult<T>> DetectTextBatch(IEnumerable<Tensor<T>> documentImages)
-    {
-        foreach (var image in documentImages)
-            yield return DetectText(image);
-    }
-
-    /// <inheritdoc/>
-    public Tensor<T> GetHeatmap()
-    {
-        return Tensor<T>.CreateDefault([ImageSize / 4, ImageSize / 4], NumOps.Zero);
-    }
-
-    /// <inheritdoc/>
-    public Tensor<T> GetProbabilityMap(Tensor<T> image)
-    {
-        ValidateImageShape(image);
-        var preprocessed = PreprocessDocument(image);
-        var output = _useNativeMode ? Forward(preprocessed) : RunOnnxInference(preprocessed);
-
-        int outH = ImageSize / 4;
-        int outW = ImageSize / 4;
-        var probMap = Tensor<T>.CreateDefault([outH, outW], NumOps.Zero);
-
-        for (int h = 0; h < outH; h++)
-        {
-            for (int w = 0; w < outW; w++)
-            {
-                probMap[h, w] = output[0, 0, h, w];
-            }
-        }
-
-        return probMap;
-    }
-
-    private List<TextRegion<T>> ParseEASTOutput(Tensor<T> output, double threshold)
-    {
-        var regions = new List<TextRegion<T>>();
-
-        // EAST output: [batch, channels, H/4, W/4]
-        // Channel 0: score map
-        // RBOX: Channels 1-4 (d_top, d_right, d_bottom, d_left), Channel 5 (angle)
-        // QUAD: Channels 1-8 (x,y offsets for 4 corners)
-
-        int outH = output.Shape.Length > 2 ? output.Shape[2] : ImageSize / 4;
-        int outW = output.Shape.Length > 3 ? output.Shape[3] : ImageSize / 4;
-        int stride = 4; // EAST output stride
-
-        int regionId = 0;
-        for (int y = 0; y < outH; y++)
-        {
-            for (int x = 0; x < outW; x++)
-            {
-                double score = NumOps.ToDouble(output[0, 0, y, x]);
-                if (score >= threshold)
-                {
-                    // Center point in original image coordinates
-                    double cx = (x + 0.5) * stride;
-                    double cy = (y + 0.5) * stride;
-
-                    Vector<T> bbox;
-                    List<(double x, double y)> polygonPoints;
-
-                    if (_geometryType == "RBOX")
-                    {
-                        // RBOX geometry: distances from center to edges + angle
-                        double dTop = NumOps.ToDouble(output[0, 1, y, x]);
-                        double dRight = NumOps.ToDouble(output[0, 2, y, x]);
-                        double dBottom = NumOps.ToDouble(output[0, 3, y, x]);
-                        double dLeft = NumOps.ToDouble(output[0, 4, y, x]);
-                        double angle = output.Shape[1] > 5 ? NumOps.ToDouble(output[0, 5, y, x]) : 0;
-
-                        // Calculate axis-aligned bounding box
-                        double x1 = cx - dLeft;
-                        double y1 = cy - dTop;
-                        double x2 = cx + dRight;
-                        double y2 = cy + dBottom;
-
-                        bbox = new Vector<T>([
-                            NumOps.FromDouble(Math.Max(0, x1)),
-                            NumOps.FromDouble(Math.Max(0, y1)),
-                            NumOps.FromDouble(Math.Min(ImageSize, x2)),
-                            NumOps.FromDouble(Math.Min(ImageSize, y2))
-                        ]);
-
-                        // Calculate rotated polygon points if angle is significant
-                        polygonPoints = CalculateRotatedBox(cx, cy, dLeft + dRight, dTop + dBottom, angle);
-                    }
-                    else // QUAD geometry
-                    {
-                        // QUAD: 8 values representing x,y offsets for 4 corners
-                        double[] offsets = new double[8];
-                        for (int i = 0; i < 8 && i + 1 < output.Shape[1]; i++)
-                        {
-                            offsets[i] = NumOps.ToDouble(output[0, 1 + i, y, x]);
-                        }
-
-                        // Calculate corner points
-                        polygonPoints =
-                        [
-                            (cx + offsets[0], cy + offsets[1]), // Top-left
-                            (cx + offsets[2], cy + offsets[3]), // Top-right
-                            (cx + offsets[4], cy + offsets[5]), // Bottom-right
-                            (cx + offsets[6], cy + offsets[7])  // Bottom-left
-                        ];
-
-                        // Calculate bounding box from polygon
-                        double minX = polygonPoints.Min(p => p.x);
-                        double minY = polygonPoints.Min(p => p.y);
-                        double maxX = polygonPoints.Max(p => p.x);
-                        double maxY = polygonPoints.Max(p => p.y);
-
-                        bbox = new Vector<T>([
-                            NumOps.FromDouble(Math.Max(0, minX)),
-                            NumOps.FromDouble(Math.Max(0, minY)),
-                            NumOps.FromDouble(Math.Min(ImageSize, maxX)),
-                            NumOps.FromDouble(Math.Min(ImageSize, maxY))
-                        ]);
-                    }
-
-                    regions.Add(new TextRegion<T>
-                    {
-                        Confidence = NumOps.FromDouble(score),
-                        ConfidenceValue = score,
-                        BoundingBox = bbox,
-                        PolygonPoints = polygonPoints.Select(p => new Vector<T>([
-                            NumOps.FromDouble(p.x),
-                            NumOps.FromDouble(p.y)
-                        ])).ToList(),
-                        Index = regionId++
-                    });
-                }
-            }
-        }
-
-        // Apply non-maximum suppression
-        return ApplyNMS(regions, 0.4);
-    }
-
-    /// <summary>
-    /// Calculates rotated bounding box corners.
-    /// </summary>
-    private static List<(double x, double y)> CalculateRotatedBox(double cx, double cy, double width, double height, double angle)
-    {
-        double cos = Math.Cos(angle);
-        double sin = Math.Sin(angle);
-        double hw = width / 2;
-        double hh = height / 2;
-
-        // Calculate four corners of rotated rectangle
-        return
-        [
-            (cx + (-hw * cos - (-hh) * sin), cy + (-hw * sin + (-hh) * cos)), // Top-left
-            (cx + (hw * cos - (-hh) * sin), cy + (hw * sin + (-hh) * cos)),   // Top-right
-            (cx + (hw * cos - hh * sin), cy + (hw * sin + hh * cos)),         // Bottom-right
-            (cx + (-hw * cos - hh * sin), cy + (-hw * sin + hh * cos))        // Bottom-left
-        ];
-    }
-
-    /// <summary>
-    /// Applies non-maximum suppression to remove overlapping detections.
-    /// </summary>
-    private static List<TextRegion<T>> ApplyNMS(List<TextRegion<T>> regions, double iouThreshold)
-    {
-        if (regions.Count <= 1) return regions;
-
-        // Sort by confidence descending
-        var sorted = regions.OrderByDescending(r => r.ConfidenceValue).ToList();
-        var kept = new List<TextRegion<T>>();
-
-        while (sorted.Count > 0)
-        {
-            var best = sorted[0];
-            kept.Add(best);
-            sorted.RemoveAt(0);
-
-            sorted = sorted.Where(r => CalculateIoU(best, r) < iouThreshold).ToList();
-        }
-
-        return kept;
-    }
-
-    /// <summary>
-    /// Calculates intersection over union between two regions.
-    /// </summary>
-    private static double CalculateIoU(TextRegion<T> a, TextRegion<T> b)
-    {
-        if (a.BoundingBox.Length < 4 || b.BoundingBox.Length < 4) return 0;
-
-        var numOps = MathHelper.GetNumericOperations<T>();
-
-        double ax1 = numOps.ToDouble(a.BoundingBox[0]);
-        double ay1 = numOps.ToDouble(a.BoundingBox[1]);
-        double ax2 = numOps.ToDouble(a.BoundingBox[2]);
-        double ay2 = numOps.ToDouble(a.BoundingBox[3]);
-
-        double bx1 = numOps.ToDouble(b.BoundingBox[0]);
-        double by1 = numOps.ToDouble(b.BoundingBox[1]);
-        double bx2 = numOps.ToDouble(b.BoundingBox[2]);
-        double by2 = numOps.ToDouble(b.BoundingBox[3]);
-
-        double ix1 = Math.Max(ax1, bx1);
-        double iy1 = Math.Max(ay1, by1);
-        double ix2 = Math.Min(ax2, bx2);
-        double iy2 = Math.Min(ay2, by2);
-
-        if (ix1 >= ix2 || iy1 >= iy2) return 0;
-
-        double intersection = (ix2 - ix1) * (iy2 - iy1);
-        double areaA = (ax2 - ax1) * (ay2 - ay1);
-        double areaB = (bx2 - bx1) * (by2 - by1);
-        double union = areaA + areaB - intersection;
-
-        return union > 0 ? intersection / union : 0;
-    }
-
-    #endregion
-
-    #region IDocumentModel Implementation
-
-    /// <inheritdoc/>
-    public Tensor<T> EncodeDocument(Tensor<T> documentImage)
-    {
-        ValidateImageShape(documentImage);
-        var preprocessed = PreprocessDocument(documentImage);
-        return _useNativeMode ? Forward(preprocessed) : RunOnnxInference(preprocessed);
-    }
-
-    /// <inheritdoc/>
-    public void ValidateInputShape(Tensor<T> documentImage)
-    {
-        ValidateImageShape(documentImage);
-    }
-
-    /// <inheritdoc/>
-    public string GetModelSummary()
-    {
-        var sb = new System.Text.StringBuilder();
-        sb.AppendLine("EAST Model Summary");
-        sb.AppendLine("==================");
-        sb.AppendLine($"Mode: {(_useNativeMode ? "Native (Trainable)" : "ONNX (Inference)")}");
-        sb.AppendLine($"Architecture: FCN with Feature Pyramid");
-        sb.AppendLine($"Backbone Channels: {_backboneChannels}");
-        sb.AppendLine($"Feature Channels: {_featureChannels}");
-        sb.AppendLine($"Geometry Type: {_geometryType}");
-        sb.AppendLine($"Image Size: {ImageSize}x{ImageSize}");
-        sb.AppendLine($"Output Size: {ImageSize / 4}x{ImageSize / 4}");
-        sb.AppendLine($"Rotated Text: Yes");
-        sb.AppendLine($"Total Layers: {Layers.Count}");
-        return sb.ToString();
-    }
-
-    #endregion
-
-    #region Preprocessing
-
-    /// <summary>
-    /// Applies EAST's industry-standard preprocessing: VGG mean subtraction.
-    /// </summary>
-    /// <remarks>
-    /// EAST (Efficient and Accurate Scene Text detector) uses VGG-style mean subtraction
-    /// with mean=[123.68, 116.78, 103.94] (CVPR 2017 paper).
-    /// </remarks>
-    protected override Tensor<T> ApplyDefaultPreprocessing(Tensor<T> rawImage)
-    {
-        var image = EnsureBatchDimension(rawImage);
-        int batchSize = image.Shape[0];
-        int channels = image.Shape[1];
-        int height = image.Shape[2];
-        int width = image.Shape[3];
-
-        var normalized = new Tensor<T>(image._shape);
-        double[] means = [123.68, 116.78, 103.94];
-
-        for (int b = 0; b < batchSize; b++)
-        {
-            for (int c = 0; c < channels; c++)
-            {
-                double mean = c < means.Length ? means[c] : 128;
-                for (int h = 0; h < height; h++)
-                {
-                    for (int w = 0; w < width; w++)
-                    {
-                        int idx = b * channels * height * width + c * height * width + h * width + w;
-                        normalized.Data.Span[idx] = NumOps.FromDouble(NumOps.ToDouble(image.Data.Span[idx]) - mean);
-                    }
-                }
-            }
-        }
-        return normalized;
-    }
-
-    /// <summary>
-    /// Applies EAST's industry-standard postprocessing: pass-through (geometry maps are already final).
-    /// </summary>
-    protected override Tensor<T> ApplyDefaultPostprocessing(Tensor<T> modelOutput) => modelOutput;
-
-    #endregion
-
-    #region Serialization
-
-    /// <inheritdoc/>
-    public override ModelMetadata<T> GetModelMetadata()
-    {
-        return new ModelMetadata<T>
-        {
-            Name = "EAST",
-            Description = "EAST for efficient scene text detection (CVPR 2017)",
-            FeatureCount = _featureChannels,
-            Complexity = Layers.Count,
-            AdditionalInfo = new Dictionary<string, object>
-            {
-                { "backbone_channels", _backboneChannels },
-                { "feature_channels", _featureChannels },
-                { "geometry_type", _geometryType },
-                { "image_size", ImageSize },
-                { "use_native_mode", _useNativeMode }
-            },
-            ModelData = SafeSerialize()
-        };
-    }
-
-    /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_backboneChannels);
-        writer.Write(_featureChannels);
-        writer.Write(_geometryType);
-        writer.Write(ImageSize);
-        writer.Write(_useNativeMode);
-    }
-
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        int backboneChannels = reader.ReadInt32();
-        int featureChannels = reader.ReadInt32();
-        string geometryType = reader.ReadString();
-        int imageSize = reader.ReadInt32();
-        bool useNativeMode = reader.ReadBoolean();
-
-        ImageSize = imageSize;
-    }
-
-    /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new EAST<T>(Architecture, ImageSize, _backboneChannels, _featureChannels, _geometryType);
-    }
-
-    #endregion
-
-    #region NeuralNetworkBase Implementation
-
-    /// <summary>
-    /// Overrides Forward to handle EAST's parallel output heads (score map + geometry).
-    /// The last two layers are parallel heads that both receive the feature map,
-    /// not sequential layers.
-    /// </summary>
-    protected override Tensor<T> Forward(Tensor<T> input)
-    {
-        if (Layers.Count < 3)
-            return base.Forward(input);
-
-        // Run all layers except the last two (which are parallel output heads)
-        Tensor<T> featureMap = input;
-        for (int i = 0; i < Layers.Count - 2; i++)
-        {
-            featureMap = Layers[i].Forward(featureMap);
-        }
-
-        // Run score map head and geometry head in parallel on the same feature map
-        var scoreMap = Layers[^2].Forward(featureMap);
-        var geometry = Layers[^1].Forward(featureMap);
-
-        // Concatenate along channel dimension: [batch, 1+geometryChannels, H, W]
-        return ConcatenateTensors(scoreMap, geometry);
-    }
-
-    private static Tensor<T> ConcatenateTensors(Tensor<T> a, Tensor<T> b)
-    {
-        // Both tensors must be 4-D: [batch, channels, H, W]
-        if (a.Shape.Length != 4)
-            throw new ArgumentException($"Tensor 'a' must be 4-D, got {a.Shape.Length}-D.", nameof(a));
-        if (b.Shape.Length != 4)
-            throw new ArgumentException($"Tensor 'b' must be 4-D, got {b.Shape.Length}-D.", nameof(b));
-        if (a.Shape[0] != b.Shape[0] || a.Shape[2] != b.Shape[2] || a.Shape[3] != b.Shape[3])
-            throw new ArgumentException(
-                $"Tensor shapes must match on batch/height/width: a=[{string.Join(",", a._shape)}], b=[{string.Join(",", b._shape)}].");
-
-        // Concatenate along dimension 1 (channels)
-        int batch = a.Shape[0];
-        int cA = a.Shape[1];
-        int cB = b.Shape[1];
-        int h = a.Shape[2];
-        int w = a.Shape[3];
-        int totalChannels = cA + cB;
-
-        var result = new Tensor<T>([batch, totalChannels, h, w]);
-        int planeSize = h * w;
-
-        for (int n = 0; n < batch; n++)
-        {
-            int batchOffset = n * totalChannels * planeSize;
-            int srcBatchOffsetA = n * cA * planeSize;
-            int srcBatchOffsetB = n * cB * planeSize;
-
-            // Copy channels from tensor a
-            for (int c = 0; c < cA; c++)
-            {
-                a.Data.Span.Slice(srcBatchOffsetA + c * planeSize, planeSize)
-                    .CopyTo(result.Data.Span.Slice(batchOffset + c * planeSize, planeSize));
-            }
-
-            // Copy channels from tensor b
-            for (int c = 0; c < cB; c++)
-            {
-                b.Data.Span.Slice(srcBatchOffsetB + c * planeSize, planeSize)
-                    .CopyTo(result.Data.Span.Slice(batchOffset + (cA + c) * planeSize, planeSize));
-            }
-        }
-
-        return result;
-    }
-
-    private static Tensor<T> SliceChannels(Tensor<T> tensor, int startChannel, int channelCount)
-    {
-        if (tensor.Shape.Length != 4)
-            return tensor; // fallback for non-4D
-
-        int batch = tensor.Shape[0];
-        int h = tensor.Shape[2];
-        int w = tensor.Shape[3];
-        int planeSize = h * w;
-
-        var result = new Tensor<T>([batch, channelCount, h, w]);
-        for (int n = 0; n < batch; n++)
-        {
-            int srcBatchOffset = n * tensor.Shape[1] * planeSize;
-            int dstBatchOffset = n * channelCount * planeSize;
-            for (int c = 0; c < channelCount; c++)
-            {
-                tensor.Data.Span.Slice(srcBatchOffset + (startChannel + c) * planeSize, planeSize)
-                    .CopyTo(result.Data.Span.Slice(dstBatchOffset + c * planeSize, planeSize));
-            }
-        }
-
-        return result;
-    }
-
-    private Tensor<T> AddTensors(Tensor<T> a, Tensor<T> b)
-    {
-        var result = new Tensor<T>(a._shape);
-        for (int i = 0; i < a.Data.Length; i++)
-            result.Data.Span[i] = NumOps.Add(a.Data.Span[i], b.Data.Span[i]);
-        return result;
-    }
-
-    /// <inheritdoc/>
-    protected override Tensor<T> PredictCore(Tensor<T> input)
-    {
-        var preprocessed = PreprocessDocument(input);
-        return _useNativeMode ? Forward(preprocessed) : RunOnnxInference(preprocessed);
-    }
-
-    /// <inheritdoc/>
-    public override void Train(Tensor<T> input, Tensor<T> expectedOutput)
-    {
-        if (!_useNativeMode)
-            throw new NotSupportedException("Training not supported in ONNX mode.");
-
-        SetTrainingMode(true);
-        try
-        {
-            TrainWithTape(input, expectedOutput, _optimizer);
-        }
-        finally
-        {
-            SetTrainingMode(false);
-        }
-    }
-
-    // UpdateParameters applied a GRADIENT STEP, but its one-argument form is the value setter and every caller passes values -- the override corrupted the model. Removed under AIDN082.

-
-    /// <summary>
-    /// Parameters cannot be written while the model is backed by a loaded ONNX graph: the weights
-    /// belong to that graph, not to this instance.
-    /// </summary>
-    /// <remarks>
-    /// Replaces a hand-written throw that used to sit inside UpdateParameters. The base checks this
-    /// on every mutating entry point rather than the one member the throw happened to guard, and
-    /// reading -- ParameterCount and GetParameters -- stays available either way.
-    /// </remarks>
+using AiDotNet.Attributes;
+using AiDotNet.Document.Interfaces;
+using AiDotNet.Document.Options;
+using AiDotNet.Enums;
+using AiDotNet.Helpers;
+using AiDotNet.Interfaces;
+using AiDotNet.LinearAlgebra;
+using AiDotNet.LossFunctions;
+using AiDotNet.NeuralNetworks;
+using AiDotNet.NeuralNetworks.Layers;
+using AiDotNet.Optimizers;
+using Microsoft.ML.OnnxRuntime;
+
+namespace AiDotNet.Document.OCR.TextDetection;
+
+/// <summary>
+/// EAST (Efficient and Accurate Scene Text Detector) for text detection.
+/// </summary>
+/// <typeparam name="T">The numeric type used for calculations.</typeparam>
+/// <remarks>
+/// <para>
+/// EAST is a fast and accurate scene text detector that directly predicts text regions
+/// without requiring complex post-processing like NMS across multiple stages.
+/// </para>
+/// <para>
+/// <b>For Beginners:</b> EAST is designed for speed and accuracy:
+/// 1. Single-shot detection (no multi-stage pipeline)
+/// 2. Outputs rotated boxes or quadrilaterals
+/// 3. Very fast inference
+/// 4. Works on arbitrary text orientations
+///
+/// Key features:
+/// - Fully convolutional architecture
+/// - Multi-scale feature fusion
+/// - Direct geometry prediction
+/// - Efficient NMS
+///
+/// Example usage:
+/// <code>
+/// var model = new EAST&lt;float&gt;(architecture);
+/// var result = model.DetectText(sceneImage);
+/// </code>
+/// </para>
+/// <para>
+/// <b>Reference:</b> "EAST: An Efficient and Accurate Scene Text Detector" (CVPR 2017)
+/// https://arxiv.org/abs/1704.03155
+/// </para>
+/// </remarks>
+[ModelDomain(ModelDomain.Vision)]
+[ModelCategory(ModelCategory.NeuralNetwork)]
+[ModelCategory(ModelCategory.ConvolutionalNetwork)]
+[ModelTask(ModelTask.Detection)]
+[ModelComplexity(ModelComplexity.Medium)]
+[ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
+[ResearchPaper("EAST: An Efficient and Accurate Scene Text Detector", "https://doi.org/10.48550/arXiv.1704.03155", Year = 2017, Authors = "Xinyu Zhou, Cong Yao, He Wen, Yuzhi Wang, Shuchang Zhou, Weiran He, Jiajun Liang")]
+public partial class EAST<T> : DocumentNeuralNetworkBase<T>, ITextDetector<T>
+{
+    private readonly EASTOptions _options;
+
+    /// <inheritdoc/>
+    public override ModelOptions GetOptions() => _options;
+
+    #region Fields
+
+    private readonly bool _useNativeMode;
+    private readonly InferenceSession? _onnxSession;
+    private readonly IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>> _optimizer;
+    private readonly int _backboneChannels;
+    private readonly int _featureChannels;
+    private readonly string _geometryType;
+
+    // Native mode layers
+    private readonly List<ILayer<T>> _backboneLayers = [];
+    private readonly List<ILayer<T>> _mergeLayers = [];
+    private readonly List<ILayer<T>> _outputLayers = [];
+
+    #endregion
+
+    #region Properties
+
+    /// <inheritdoc/>
+    public override DocumentType SupportedDocumentTypes => DocumentType.All;
+
+    /// <inheritdoc/>
+    public override bool RequiresOCR => false;
+
+    /// <inheritdoc/>
+    public int ExpectedImageSize => ImageSize;
+
+    /// <inheritdoc/>
+    public bool SupportsRotatedText => true;
+
+    /// <inheritdoc/>
+    public int MinTextHeight => 8;
+
+    /// <inheritdoc/>
+    public bool SupportsPolygonOutput => true;
+
+    /// <summary>
+    /// Gets the geometry output type (RBOX or QUAD).
+    /// </summary>
+    public string GeometryType => _geometryType;
+
+    #endregion
+
+    #region Constructors
+
+    /// <summary>
+    /// Creates an EAST model using a pre-trained ONNX model for inference.
+    /// </summary>
+    public EAST(
+        NeuralNetworkArchitecture<T> architecture,
+        string onnxModelPath,
+        int imageSize = 512,
+        int backboneChannels = 512,
+        int featureChannels = 128,
+        string geometryType = "RBOX",
+        IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? optimizer = null,
+        ILossFunction<T>? lossFunction = null,
+        EASTOptions? options = null)
+        : base(architecture, lossFunction ?? new MeanSquaredErrorLoss<T>(), 1.0)
+    {
+        _options = options ?? new EASTOptions();
+        Options = _options;
+
+        if (string.IsNullOrWhiteSpace(onnxModelPath))
+            throw new ArgumentNullException(nameof(onnxModelPath));
+        if (!File.Exists(onnxModelPath))
+            throw new FileNotFoundException($"ONNX model not found: {onnxModelPath}", onnxModelPath);
+
+        _useNativeMode = false;
+        _backboneChannels = backboneChannels;
+        _featureChannels = featureChannels;
+        _geometryType = geometryType;
+        _optimizer = optimizer ?? new AdamOptimizer<T, Tensor<T>, Tensor<T>>(this);
+
+        ImageSize = imageSize;
+
+        _onnxSession = new InferenceSession(onnxModelPath);
+
+        InitializeLayers();
+    }
+
+    /// <summary>
+    /// Creates an EAST model using native layers for training and inference.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// <b>Default Configuration (EAST from CVPR 2017):</b>
+    /// - Backbone: PVANet or VGG16
+    /// - Feature merge: U-Net style
+    /// - Output: Score map + Geometry (RBOX or QUAD)
+    /// - NMS threshold: 0.2
+    /// </para>
+    /// </remarks>
+    public EAST(
+        NeuralNetworkArchitecture<T> architecture,
+        int imageSize = 512,
+        int backboneChannels = 512,
+        int featureChannels = 128,
+        string geometryType = "RBOX",
+        IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? optimizer = null,
+        ILossFunction<T>? lossFunction = null,
+        EASTOptions? options = null)
+        : base(architecture, lossFunction ?? new MeanSquaredErrorLoss<T>(), 1.0)
+    {
+        _options = options ?? new EASTOptions();
+        Options = _options;
+
+        _useNativeMode = true;
+        _backboneChannels = backboneChannels;
+        _featureChannels = featureChannels;
+        _geometryType = geometryType;
+        _optimizer = optimizer ?? new AdamOptimizer<T, Tensor<T>, Tensor<T>>(this);
+
+        ImageSize = imageSize;
+
+        InitializeLayers();
+    }
+
+    #endregion
+
+    #region Initialization
+
+    /// <inheritdoc/>
+    protected override void InitializeLayers()
+    {
+        if (!_useNativeMode)
+        {
+            return;
+        }
+
+        if (Architecture.Layers is not null && Architecture.Layers.Count > 0)
+        {
+            Layers.AddRange(Architecture.Layers);
+            ValidateCustomLayers(Layers);
+            return;
+        }
+
+        Layers.AddRange(LayerHelper<T>.CreateDefaultEASTLayers(
+            imageSize: ImageSize,
+            backboneChannels: _backboneChannels,
+            featureChannels: _featureChannels,
+            geometryType: _geometryType));
+    }
+
+    #endregion
+
+    #region ITextDetector Implementation
+
+    /// <inheritdoc/>
+    public TextDetectionResult<T> DetectText(Tensor<T> documentImage)
+    {
+        return DetectText(documentImage, 0.5);
+    }
+
+    /// <inheritdoc/>
+    public TextDetectionResult<T> DetectText(Tensor<T> documentImage, double confidenceThreshold)
+    {
+        ValidateImageShape(documentImage);
+        var startTime = DateTime.UtcNow;
+
+        var preprocessed = PreprocessDocument(documentImage);
+        var output = _useNativeMode ? Forward(preprocessed) : RunOnnxInference(preprocessed);
+
+        var regions = ParseEASTOutput(output, confidenceThreshold);
+
+        return new TextDetectionResult<T>
+        {
+            TextRegions = regions,
+            ProcessingTimeMs = (DateTime.UtcNow - startTime).TotalMilliseconds
+        };
+    }
+
+    /// <inheritdoc/>
+    public IEnumerable<TextDetectionResult<T>> DetectTextBatch(IEnumerable<Tensor<T>> documentImages)
+    {
+        foreach (var image in documentImages)
+            yield return DetectText(image);
+    }
+
+    /// <inheritdoc/>
+    public Tensor<T> GetHeatmap()
+    {
+        return Tensor<T>.CreateDefault([ImageSize / 4, ImageSize / 4], NumOps.Zero);
+    }
+
+    /// <inheritdoc/>
+    public Tensor<T> GetProbabilityMap(Tensor<T> image)
+    {
+        ValidateImageShape(image);
+        var preprocessed = PreprocessDocument(image);
+        var output = _useNativeMode ? Forward(preprocessed) : RunOnnxInference(preprocessed);
+
+        int outH = ImageSize / 4;
+        int outW = ImageSize / 4;
+        var probMap = Tensor<T>.CreateDefault([outH, outW], NumOps.Zero);
+
+        for (int h = 0; h < outH; h++)
+        {
+            for (int w = 0; w < outW; w++)
+            {
+                probMap[h, w] = output[0, 0, h, w];
+            }
+        }
+
+        return probMap;
+    }
+
+    private List<TextRegion<T>> ParseEASTOutput(Tensor<T> output, double threshold)
+    {
+        var regions = new List<TextRegion<T>>();
+
+        // EAST output: [batch, channels, H/4, W/4]
+        // Channel 0: score map
+        // RBOX: Channels 1-4 (d_top, d_right, d_bottom, d_left), Channel 5 (angle)
+        // QUAD: Channels 1-8 (x,y offsets for 4 corners)
+
+        int outH = output.Shape.Length > 2 ? output.Shape[2] : ImageSize / 4;
+        int outW = output.Shape.Length > 3 ? output.Shape[3] : ImageSize / 4;
+        int stride = 4; // EAST output stride
+
+        int regionId = 0;
+        for (int y = 0; y < outH; y++)
+        {
+            for (int x = 0; x < outW; x++)
+            {
+                double score = NumOps.ToDouble(output[0, 0, y, x]);
+                if (score >= threshold)
+                {
+                    // Center point in original image coordinates
+                    double cx = (x + 0.5) * stride;
+                    double cy = (y + 0.5) * stride;
+
+                    Vector<T> bbox;
+                    List<(double x, double y)> polygonPoints;
+
+                    if (_geometryType == "RBOX")
+                    {
+                        // RBOX geometry: distances from center to edges + angle
+                        double dTop = NumOps.ToDouble(output[0, 1, y, x]);
+                        double dRight = NumOps.ToDouble(output[0, 2, y, x]);
+                        double dBottom = NumOps.ToDouble(output[0, 3, y, x]);
+                        double dLeft = NumOps.ToDouble(output[0, 4, y, x]);
+                        double angle = output.Shape[1] > 5 ? NumOps.ToDouble(output[0, 5, y, x]) : 0;
+
+                        // Calculate axis-aligned bounding box
+                        double x1 = cx - dLeft;
+                        double y1 = cy - dTop;
+                        double x2 = cx + dRight;
+                        double y2 = cy + dBottom;
+
+                        bbox = new Vector<T>([
+                            NumOps.FromDouble(Math.Max(0, x1)),
+                            NumOps.FromDouble(Math.Max(0, y1)),
+                            NumOps.FromDouble(Math.Min(ImageSize, x2)),
+                            NumOps.FromDouble(Math.Min(ImageSize, y2))
+                        ]);
+
+                        // Calculate rotated polygon points if angle is significant
+                        polygonPoints = CalculateRotatedBox(cx, cy, dLeft + dRight, dTop + dBottom, angle);
+                    }
+                    else // QUAD geometry
+                    {
+                        // QUAD: 8 values representing x,y offsets for 4 corners
+                        double[] offsets = new double[8];
+                        for (int i = 0; i < 8 && i + 1 < output.Shape[1]; i++)
+                        {
+                            offsets[i] = NumOps.ToDouble(output[0, 1 + i, y, x]);
+                        }
+
+                        // Calculate corner points
+                        polygonPoints =
+                        [
+                            (cx + offsets[0], cy + offsets[1]), // Top-left
+                            (cx + offsets[2], cy + offsets[3]), // Top-right
+                            (cx + offsets[4], cy + offsets[5]), // Bottom-right
+                            (cx + offsets[6], cy + offsets[7])  // Bottom-left
+                        ];
+
+                        // Calculate bounding box from polygon
+                        double minX = polygonPoints.Min(p => p.x);
+                        double minY = polygonPoints.Min(p => p.y);
+                        double maxX = polygonPoints.Max(p => p.x);
+                        double maxY = polygonPoints.Max(p => p.y);
+
+                        bbox = new Vector<T>([
+                            NumOps.FromDouble(Math.Max(0, minX)),
+                            NumOps.FromDouble(Math.Max(0, minY)),
+                            NumOps.FromDouble(Math.Min(ImageSize, maxX)),
+                            NumOps.FromDouble(Math.Min(ImageSize, maxY))
+                        ]);
+                    }
+
+                    regions.Add(new TextRegion<T>
+                    {
+                        Confidence = NumOps.FromDouble(score),
+                        ConfidenceValue = score,
+                        BoundingBox = bbox,
+                        PolygonPoints = polygonPoints.Select(p => new Vector<T>([
+                            NumOps.FromDouble(p.x),
+                            NumOps.FromDouble(p.y)
+                        ])).ToList(),
+                        Index = regionId++
+                    });
+                }
+            }
+        }
+
+        // Apply non-maximum suppression
+        return ApplyNMS(regions, 0.4);
+    }
+
+    /// <summary>
+    /// Calculates rotated bounding box corners.
+    /// </summary>
+    private static List<(double x, double y)> CalculateRotatedBox(double cx, double cy, double width, double height, double angle)
+    {
+        double cos = Math.Cos(angle);
+        double sin = Math.Sin(angle);
+        double hw = width / 2;
+        double hh = height / 2;
+
+        // Calculate four corners of rotated rectangle
+        return
+        [
+            (cx + (-hw * cos - (-hh) * sin), cy + (-hw * sin + (-hh) * cos)), // Top-left
+            (cx + (hw * cos - (-hh) * sin), cy + (hw * sin + (-hh) * cos)),   // Top-right
+            (cx + (hw * cos - hh * sin), cy + (hw * sin + hh * cos)),         // Bottom-right
+            (cx + (-hw * cos - hh * sin), cy + (-hw * sin + hh * cos))        // Bottom-left
+        ];
+    }
+
+    /// <summary>
+    /// Applies non-maximum suppression to remove overlapping detections.
+    /// </summary>
+    private static List<TextRegion<T>> ApplyNMS(List<TextRegion<T>> regions, double iouThreshold)
+    {
+        if (regions.Count <= 1) return regions;
+
+        // Sort by confidence descending
+        var sorted = regions.OrderByDescending(r => r.ConfidenceValue).ToList();
+        var kept = new List<TextRegion<T>>();
+
+        while (sorted.Count > 0)
+        {
+            var best = sorted[0];
+            kept.Add(best);
+            sorted.RemoveAt(0);
+
+            sorted = sorted.Where(r => CalculateIoU(best, r) < iouThreshold).ToList();
+        }
+
+        return kept;
+    }
+
+    /// <summary>
+    /// Calculates intersection over union between two regions.
+    /// </summary>
+    private static double CalculateIoU(TextRegion<T> a, TextRegion<T> b)
+    {
+        if (a.BoundingBox.Length < 4 || b.BoundingBox.Length < 4) return 0;
+
+        var numOps = MathHelper.GetNumericOperations<T>();
+
+        double ax1 = numOps.ToDouble(a.BoundingBox[0]);
+        double ay1 = numOps.ToDouble(a.BoundingBox[1]);
+        double ax2 = numOps.ToDouble(a.BoundingBox[2]);
+        double ay2 = numOps.ToDouble(a.BoundingBox[3]);
+
+        double bx1 = numOps.ToDouble(b.BoundingBox[0]);
+        double by1 = numOps.ToDouble(b.BoundingBox[1]);
+        double bx2 = numOps.ToDouble(b.BoundingBox[2]);
+        double by2 = numOps.ToDouble(b.BoundingBox[3]);
+
+        double ix1 = Math.Max(ax1, bx1);
+        double iy1 = Math.Max(ay1, by1);
+        double ix2 = Math.Min(ax2, bx2);
+        double iy2 = Math.Min(ay2, by2);
+
+        if (ix1 >= ix2 || iy1 >= iy2) return 0;
+
+        double intersection = (ix2 - ix1) * (iy2 - iy1);
+        double areaA = (ax2 - ax1) * (ay2 - ay1);
+        double areaB = (bx2 - bx1) * (by2 - by1);
+        double union = areaA + areaB - intersection;
+
+        return union > 0 ? intersection / union : 0;
+    }
+
+    #endregion
+
+    #region IDocumentModel Implementation
+
+    /// <inheritdoc/>
+    public Tensor<T> EncodeDocument(Tensor<T> documentImage)
+    {
+        ValidateImageShape(documentImage);
+        var preprocessed = PreprocessDocument(documentImage);
+        return _useNativeMode ? Forward(preprocessed) : RunOnnxInference(preprocessed);
+    }
+
+    /// <inheritdoc/>
+    public void ValidateInputShape(Tensor<T> documentImage)
+    {
+        ValidateImageShape(documentImage);
+    }
+
+    /// <inheritdoc/>
+    public string GetModelSummary()
+    {
+        var sb = new System.Text.StringBuilder();
+        sb.AppendLine("EAST Model Summary");
+        sb.AppendLine("==================");
+        sb.AppendLine($"Mode: {(_useNativeMode ? "Native (Trainable)" : "ONNX (Inference)")}");
+        sb.AppendLine($"Architecture: FCN with Feature Pyramid");
+        sb.AppendLine($"Backbone Channels: {_backboneChannels}");
+        sb.AppendLine($"Feature Channels: {_featureChannels}");
+        sb.AppendLine($"Geometry Type: {_geometryType}");
+        sb.AppendLine($"Image Size: {ImageSize}x{ImageSize}");
+        sb.AppendLine($"Output Size: {ImageSize / 4}x{ImageSize / 4}");
+        sb.AppendLine($"Rotated Text: Yes");
+        sb.AppendLine($"Total Layers: {Layers.Count}");
+        return sb.ToString();
+    }
+
+    #endregion
+
+    #region Preprocessing
+
+    /// <summary>
+    /// Applies EAST's industry-standard preprocessing: VGG mean subtraction.
+    /// </summary>
+    /// <remarks>
+    /// EAST (Efficient and Accurate Scene Text detector) uses VGG-style mean subtraction
+    /// with mean=[123.68, 116.78, 103.94] (CVPR 2017 paper).
+    /// </remarks>
+    protected override Tensor<T> ApplyDefaultPreprocessing(Tensor<T> rawImage)
+    {
+        var image = EnsureBatchDimension(rawImage);
+        int batchSize = image.Shape[0];
+        int channels = image.Shape[1];
+        int height = image.Shape[2];
+        int width = image.Shape[3];
+
+        var normalized = new Tensor<T>(image._shape);
+        double[] means = [123.68, 116.78, 103.94];
+
+        for (int b = 0; b < batchSize; b++)
+        {
+            for (int c = 0; c < channels; c++)
+            {
+                double mean = c < means.Length ? means[c] : 128;
+                for (int h = 0; h < height; h++)
+                {
+                    for (int w = 0; w < width; w++)
+                    {
+                        int idx = b * channels * height * width + c * height * width + h * width + w;
+                        normalized.Data.Span[idx] = NumOps.FromDouble(NumOps.ToDouble(image.Data.Span[idx]) - mean);
+                    }
+                }
+            }
+        }
+        return normalized;
+    }
+
+    /// <summary>
+    /// Applies EAST's industry-standard postprocessing: pass-through (geometry maps are already final).
+    /// </summary>
+    protected override Tensor<T> ApplyDefaultPostprocessing(Tensor<T> modelOutput) => modelOutput;
+
+    #endregion
+
+    #region Serialization
+
+    /// <inheritdoc/>
+    public override ModelMetadata<T> GetModelMetadata()
+    {
+        return new ModelMetadata<T>
+        {
+            Name = "EAST",
+            Description = "EAST for efficient scene text detection (CVPR 2017)",
+            FeatureCount = _featureChannels,
+            Complexity = Layers.Count,
+            AdditionalInfo = new Dictionary<string, object>
+            {
+                { "backbone_channels", _backboneChannels },
+                { "feature_channels", _featureChannels },
+                { "geometry_type", _geometryType },
+                { "image_size", ImageSize },
+                { "use_native_mode", _useNativeMode }
+            },
+            ModelData = SafeSerialize()
+        };
+    }
+
+    /// <inheritdoc/>
+
+
+    /// <inheritdoc/>
+
+
+    #endregion
+
+    #region NeuralNetworkBase Implementation
+
+    /// <summary>
+    /// Overrides Forward to handle EAST's parallel output heads (score map + geometry).
+    /// The last two layers are parallel heads that both receive the feature map,
+    /// not sequential layers.
+    /// </summary>
+    protected override Tensor<T> Forward(Tensor<T> input)
+    {
+        if (Layers.Count < 3)
+            return base.Forward(input);
+
+        // Run all layers except the last two (which are parallel output heads)
+        Tensor<T> featureMap = input;
+        for (int i = 0; i < Layers.Count - 2; i++)
+        {
+            featureMap = Layers[i].Forward(featureMap);
+        }
+
+        // Run score map head and geometry head in parallel on the same feature map
+        var scoreMap = Layers[^2].Forward(featureMap);
+        var geometry = Layers[^1].Forward(featureMap);
+
+        // Concatenate along channel dimension: [batch, 1+geometryChannels, H, W]
+        return ConcatenateTensors(scoreMap, geometry);
+    }
+
+    private static Tensor<T> ConcatenateTensors(Tensor<T> a, Tensor<T> b)
+    {
+        // Both tensors must be 4-D: [batch, channels, H, W]
+        if (a.Shape.Length != 4)
+            throw new ArgumentException($"Tensor 'a' must be 4-D, got {a.Shape.Length}-D.", nameof(a));
+        if (b.Shape.Length != 4)
+            throw new ArgumentException($"Tensor 'b' must be 4-D, got {b.Shape.Length}-D.", nameof(b));
+        if (a.Shape[0] != b.Shape[0] || a.Shape[2] != b.Shape[2] || a.Shape[3] != b.Shape[3])
+            throw new ArgumentException(
+                $"Tensor shapes must match on batch/height/width: a=[{string.Join(",", a._shape)}], b=[{string.Join(",", b._shape)}].");
+
+        // Concatenate along dimension 1 (channels)
+        int batch = a.Shape[0];
+        int cA = a.Shape[1];
+        int cB = b.Shape[1];
+        int h = a.Shape[2];
+        int w = a.Shape[3];
+        int totalChannels = cA + cB;
+
+        var result = new Tensor<T>([batch, totalChannels, h, w]);
+        int planeSize = h * w;
+
+        for (int n = 0; n < batch; n++)
+        {
+            int batchOffset = n * totalChannels * planeSize;
+            int srcBatchOffsetA = n * cA * planeSize;
+            int srcBatchOffsetB = n * cB * planeSize;
+
+            // Copy channels from tensor a
+            for (int c = 0; c < cA; c++)
+            {
+                a.Data.Span.Slice(srcBatchOffsetA + c * planeSize, planeSize)
+                    .CopyTo(result.Data.Span.Slice(batchOffset + c * planeSize, planeSize));
+            }
+
+            // Copy channels from tensor b
+            for (int c = 0; c < cB; c++)
+            {
+                b.Data.Span.Slice(srcBatchOffsetB + c * planeSize, planeSize)
+                    .CopyTo(result.Data.Span.Slice(batchOffset + (cA + c) * planeSize, planeSize));
+            }
+        }
+
+        return result;
+    }
+
+    private static Tensor<T> SliceChannels(Tensor<T> tensor, int startChannel, int channelCount)
+    {
+        if (tensor.Shape.Length != 4)
+            return tensor; // fallback for non-4D
+
+        int batch = tensor.Shape[0];
+        int h = tensor.Shape[2];
+        int w = tensor.Shape[3];
+        int planeSize = h * w;
+
+        var result = new Tensor<T>([batch, channelCount, h, w]);
+        for (int n = 0; n < batch; n++)
+        {
+            int srcBatchOffset = n * tensor.Shape[1] * planeSize;
+            int dstBatchOffset = n * channelCount * planeSize;
+            for (int c = 0; c < channelCount; c++)
+            {
+                tensor.Data.Span.Slice(srcBatchOffset + (startChannel + c) * planeSize, planeSize)
+                    .CopyTo(result.Data.Span.Slice(dstBatchOffset + c * planeSize, planeSize));
+            }
+        }
+
+        return result;
+    }
+
+    private Tensor<T> AddTensors(Tensor<T> a, Tensor<T> b)
+    {
+        var result = new Tensor<T>(a._shape);
+        for (int i = 0; i < a.Data.Length; i++)
+            result.Data.Span[i] = NumOps.Add(a.Data.Span[i], b.Data.Span[i]);
+        return result;
+    }
+
+    /// <inheritdoc/>
+    protected override Tensor<T> PredictCore(Tensor<T> input)
+    {
+        var preprocessed = PreprocessDocument(input);
+        return _useNativeMode ? Forward(preprocessed) : RunOnnxInference(preprocessed);
+    }
+
+    /// <inheritdoc/>
+    public override void Train(Tensor<T> input, Tensor<T> expectedOutput)
+    {
+        if (!_useNativeMode)
+            throw new NotSupportedException("Training not supported in ONNX mode.");
+
+        SetTrainingMode(true);
+        try
+        {
+            TrainWithTape(input, expectedOutput, _optimizer);
+        }
+        finally
+        {
+            SetTrainingMode(false);
+        }
+    }
+
+    // UpdateParameters applied a GRADIENT STEP, but its one-argument form is the value setter and every caller passes values -- the override corrupted the model. Removed under AIDN082.
+
+
+    /// <summary>
+    /// Parameters cannot be written while the model is backed by a loaded ONNX graph: the weights
+    /// belong to that graph, not to this instance.
+    /// </summary>
+    /// <remarks>
+    /// Replaces a hand-written throw that used to sit inside UpdateParameters. The base checks this
+    /// on every mutating entry point rather than the one member the throw happened to guard, and
+    /// reading -- ParameterCount and GetParameters -- stays available either way.
+    /// </remarks>
     protected override bool SupportsParameterMutation => _useNativeMode;
-    private Vector<T> CollectGradients()
-    {
-        var grads = new List<T>();
-        foreach (var layer in Layers)
-            grads.AddRange(layer.GetParameterGradients());
-        return new Vector<T>([.. grads]);
-    }
-
-    #endregion
-
-    #region Disposal
-
-    /// <inheritdoc/>
-    protected override void Dispose(bool disposing)
-    {
-        if (disposing)
-            _onnxSession?.Dispose();
-        base.Dispose(disposing);
-    }
-
-    #endregion
-}
+    private Vector<T> CollectGradients()
+    {
+        var grads = new List<T>();
+        foreach (var layer in Layers)
+            grads.AddRange(layer.GetParameterGradients());
+        return new Vector<T>([.. grads]);
+    }
+
+    #endregion
+
+    #region Disposal
+
+    /// <inheritdoc/>
+    protected override void Dispose(bool disposing)
+    {
+        if (disposing)
+            _onnxSession?.Dispose();
+        base.Dispose(disposing);
+    }
+
+    #endregion
+}
diff --git a/src/Document/OCR/TextDetection/PSENet.cs b/src/Document/OCR/TextDetection/PSENet.cs
index d895bd738c..a9457104fe 100644
--- a/src/Document/OCR/TextDetection/PSENet.cs
+++ b/src/Document/OCR/TextDetection/PSENet.cs
@@ -1,685 +1,664 @@
-using AiDotNet.Attributes;
-using AiDotNet.Document.Interfaces;
-using AiDotNet.Document.Options;
-using AiDotNet.Enums;
-using AiDotNet.Helpers;
-using AiDotNet.Interfaces;
-using AiDotNet.LinearAlgebra;
-using AiDotNet.LossFunctions;
-using AiDotNet.NeuralNetworks;
-using AiDotNet.NeuralNetworks.Layers;
-using AiDotNet.Optimizers;
-using Microsoft.ML.OnnxRuntime;
-
-namespace AiDotNet.Document.OCR.TextDetection;
-
-/// <summary>
-/// PSENet (Progressive Scale Expansion Network) for text detection.
-/// </summary>
-/// <typeparam name="T">The numeric type used for calculations.</typeparam>
-/// <remarks>
-/// <para>
-/// PSENet uses a novel progressive scale expansion algorithm to accurately detect
-/// text instances of various shapes and sizes, especially useful for closely spaced text.
-/// </para>
-/// <para>
-/// <b>For Beginners:</b> PSENet handles difficult text detection scenarios:
-/// 1. Detects text at multiple scales (kernels)
-/// 2. Progressively expands from smallest to largest
-/// 3. Separates closely spaced text instances
-/// 4. Handles arbitrary-shaped text
-///
-/// Key features:
-/// - Multi-scale kernel prediction
-/// - Progressive scale expansion algorithm
-/// - Handles closely adjacent text
-/// - Accurate boundary detection
-///
-/// Example usage:
-/// <code>
-/// var model = new PSENet&lt;float&gt;(architecture);
-/// var result = model.DetectText(documentImage);
-/// </code>
-/// </para>
-/// <para>
-/// <b>Reference:</b> "Shape Robust Text Detection with Progressive Scale Expansion Network" (CVPR 2019)
-/// https://arxiv.org/abs/1903.12473
-/// </para>
-/// </remarks>
-[ModelDomain(ModelDomain.Vision)]
-[ModelCategory(ModelCategory.NeuralNetwork)]
-[ModelCategory(ModelCategory.ConvolutionalNetwork)]
-[ModelTask(ModelTask.Detection)]
-[ModelTask(ModelTask.Segmentation)]
-[ModelComplexity(ModelComplexity.Medium)]
-[ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
-[ResearchPaper("Shape Robust Text Detection with Progressive Scale Expansion Network", "https://doi.org/10.48550/arXiv.1903.12473", Year = 2019, Authors = "Wenhai Wang, Enze Xie, Xiang Li, Wenbo Hou, Tong Lu, Gang Yu, Shuai Shao")]
-public partial class PSENet<T> : DocumentNeuralNetworkBase<T>, ITextDetector<T>
-{
-    private readonly PSENetOptions _options;
-
-    /// <inheritdoc/>
-    public override ModelOptions GetOptions() => _options;
-
-    #region Fields
-
-    private readonly bool _useNativeMode;
-    private readonly InferenceSession? _onnxSession;
-    private readonly IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>> _optimizer;
-    private readonly int _backboneChannels;
-    private readonly int _featureChannels;
-    private readonly int _numKernels;
-
-    // Native mode layers
-    private readonly List<ILayer<T>> _backboneLayers = [];
-    private readonly List<ILayer<T>> _fpnLayers = [];
-    private readonly List<ILayer<T>> _segmentationLayers = [];
-
-    #endregion
-
-    #region Properties
-
-    /// <inheritdoc/>
-    public override DocumentType SupportedDocumentTypes => DocumentType.All;
-
-    /// <inheritdoc/>
-    public override bool RequiresOCR => false;
-
-    /// <inheritdoc/>
-    public int ExpectedImageSize => ImageSize;
-
-    /// <inheritdoc/>
-    public bool SupportsRotatedText => true;
-
-    /// <inheritdoc/>
-    public int MinTextHeight => 8;
-
-    /// <inheritdoc/>
-    public bool SupportsPolygonOutput => true;
-
-    /// <summary>
-    /// Gets the number of scale kernels.
-    /// </summary>
-    public int NumKernels => _numKernels;
-
-    #endregion
-
-    #region Constructors
-
-    /// <summary>
-    /// Creates a PSENet model with default configuration for native training.
-    /// </summary>
-    public PSENet()
-        : this(new NeuralNetworkArchitecture<T>(
-            // PSENet (CVPR 2019) is an RGB scene-text detector: a ResNet/FPN backbone
-            // whose first convolution consumes 3-channel color images. Declare the input
-            // as ThreeDimensional with inputDepth:3 so GetInputShape() reports [3, H, W]
-            // and the first backbone conv resolves its InputDepth to 3. A TwoDimensional
-            // declaration forces InputDepth=1 (grayscale), which mismatches the 3-channel
-            // RGB tensors fed at inference/training ("Expected input depth 1, but got 3").
-            inputType: InputType.ThreeDimensional,
-            taskType: NeuralNetworkTaskType.BinaryClassification,
-            inputDepth: 3,
-            inputHeight: 640, inputWidth: 640,
-            outputSize: 7))
-    {
-    }
-
-    /// <summary>
-    /// Creates a PSENet model using a pre-trained ONNX model for inference.
-    /// </summary>
-    public PSENet(
-        NeuralNetworkArchitecture<T> architecture,
-        string onnxModelPath,
-        int imageSize = 640,
-        int backboneChannels = 256,
-        int featureChannels = 256,
-        int numKernels = 7,
-        IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? optimizer = null,
-        ILossFunction<T>? lossFunction = null,
-        PSENetOptions? options = null)
-        // PSENet's kernel-prediction heads output per-pixel maps that the paper trains with
-        // binary cross-entropy on the SIGMOID of the logits. PredictCore returns the raw linear
-        // conv output (no sigmoid), so a plain BinaryCrossEntropyLoss (which expects [0,1]
-        // probabilities) explodes as the logits drift during training (memorization loss
-        // 0.38 -> 18582). BinaryCrossEntropyWithLogitsLoss fuses the sigmoid into a numerically
-        // stable loss over raw logits — the paper-correct objective — keeping training bounded
-        // while leaving PredictCore's linear-logit output contract unchanged.
-        : base(architecture, lossFunction ?? new BinaryCrossEntropyWithLogitsLoss<T>(), 1.0)
-    {
-        _options = options ?? new PSENetOptions();
-        Options = _options;
-
-        if (string.IsNullOrWhiteSpace(onnxModelPath))
-            throw new ArgumentNullException(nameof(onnxModelPath));
-        if (!File.Exists(onnxModelPath))
-            throw new FileNotFoundException($"ONNX model not found: {onnxModelPath}", onnxModelPath);
-
-        _useNativeMode = false;
-        _backboneChannels = backboneChannels;
-        _featureChannels = featureChannels;
-        _numKernels = numKernels;
-        _optimizer = optimizer ?? new AdamOptimizer<T, Tensor<T>, Tensor<T>>(this);
-
-        ImageSize = imageSize;
-
-        _onnxSession = new InferenceSession(onnxModelPath);
-
-        InitializeLayers();
-    }
-
-    /// <summary>
-    /// Creates a PSENet model using native layers for training and inference.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// <b>Default Configuration (PSENet from CVPR 2019):</b>
-    /// - Backbone: ResNet-50/152
-    /// - FPN: Feature Pyramid Network
-    /// - Output: Multi-scale kernels (default 7)
-    /// - Post-processing: Progressive scale expansion
-    /// </para>
-    /// </remarks>
-    public PSENet(
-        NeuralNetworkArchitecture<T> architecture,
-        int imageSize = 640,
-        int backboneChannels = 256,
-        int featureChannels = 256,
-        int numKernels = 7,
-        IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? optimizer = null,
-        ILossFunction<T>? lossFunction = null,
-        PSENetOptions? options = null)
-        // PSENet's kernel-prediction heads output per-pixel maps that the paper trains with
-        // binary cross-entropy on the SIGMOID of the logits. PredictCore returns the raw linear
-        // conv output (no sigmoid), so a plain BinaryCrossEntropyLoss (which expects [0,1]
-        // probabilities) explodes as the logits drift during training (memorization loss
-        // 0.38 -> 18582). BinaryCrossEntropyWithLogitsLoss fuses the sigmoid into a numerically
-        // stable loss over raw logits — the paper-correct objective — keeping training bounded
-        // while leaving PredictCore's linear-logit output contract unchanged.
-        : base(architecture, lossFunction ?? new BinaryCrossEntropyWithLogitsLoss<T>(), 1.0)
-    {
-        _options = options ?? new PSENetOptions();
-        Options = _options;
-
-        _useNativeMode = true;
-        _backboneChannels = backboneChannels;
-        _featureChannels = featureChannels;
-        _numKernels = numKernels;
-        _optimizer = optimizer ?? new AdamOptimizer<T, Tensor<T>, Tensor<T>>(this);
-
-        ImageSize = imageSize;
-
-        InitializeLayers();
-    }
-
-    #endregion
-
-    #region Initialization
-
-    /// <inheritdoc/>
-    protected override void InitializeLayers()
-    {
-        if (!_useNativeMode)
-        {
-            return;
-        }
-
-        if (Architecture.Layers is not null && Architecture.Layers.Count > 0)
-        {
-            Layers.AddRange(Architecture.Layers);
-            ValidateCustomLayers(Layers);
-            return;
-        }
-
-        Layers.AddRange(LayerHelper<T>.CreateDefaultPSENetLayers(
-            imageSize: ImageSize,
-            backboneChannels: _backboneChannels,
-            featureChannels: _featureChannels,
-            numKernels: _numKernels));
-    }
-
-    #endregion
-
-    #region ITextDetector Implementation
-
-    /// <inheritdoc/>
-    public TextDetectionResult<T> DetectText(Tensor<T> documentImage)
-    {
-        return DetectText(documentImage, 0.5);
-    }
-
-    /// <inheritdoc/>
-    public TextDetectionResult<T> DetectText(Tensor<T> documentImage, double confidenceThreshold)
-    {
-        ValidateImageShape(documentImage);
-        var startTime = DateTime.UtcNow;
-
-        var preprocessed = PreprocessDocument(documentImage);
-        var output = _useNativeMode ? Forward(preprocessed) : RunOnnxInference(preprocessed);
-
-        var regions = ParsePSENetOutput(output, confidenceThreshold);
-
-        return new TextDetectionResult<T>
-        {
-            TextRegions = regions,
-            ProcessingTimeMs = (DateTime.UtcNow - startTime).TotalMilliseconds
-        };
-    }
-
-    /// <inheritdoc/>
-    public IEnumerable<TextDetectionResult<T>> DetectTextBatch(IEnumerable<Tensor<T>> documentImages)
-    {
-        foreach (var image in documentImages)
-            yield return DetectText(image);
-    }
-
-    /// <inheritdoc/>
-    public Tensor<T> GetHeatmap()
-    {
-        return Tensor<T>.CreateDefault([ImageSize, ImageSize], NumOps.Zero);
-    }
-
-    /// <inheritdoc/>
-    public Tensor<T> GetProbabilityMap(Tensor<T> image)
-    {
-        ValidateImageShape(image);
-        var preprocessed = PreprocessDocument(image);
-        var output = _useNativeMode ? Forward(preprocessed) : RunOnnxInference(preprocessed);
-
-        // Return the largest kernel (full text region)
-        int outH = output.Shape.Length > 2 ? output.Shape[2] : ImageSize;
-        int outW = output.Shape.Length > 3 ? output.Shape[3] : ImageSize;
-        var probMap = Tensor<T>.CreateDefault([outH, outW], NumOps.Zero);
-
-        for (int h = 0; h < outH; h++)
-        {
-            for (int w = 0; w < outW; w++)
-            {
-                // Use the last kernel (largest scale)
-                probMap[h, w] = output[0, _numKernels - 1, h, w];
-            }
-        }
-
-        return probMap;
-    }
-
-    private List<TextRegion<T>> ParsePSENetOutput(Tensor<T> output, double threshold)
-    {
-        var regions = new List<TextRegion<T>>();
-
-        // PSENet output: [batch, numKernels, H, W]
-        // Kernels are ordered from smallest (index 0) to largest (index numKernels-1)
-        // Progressive Scale Expansion: start from smallest kernel and expand
-
-        int outH = output.Shape.Length > 2 ? output.Shape[2] : ImageSize;
-        int outW = output.Shape.Length > 3 ? output.Shape[3] : ImageSize;
-
-        // Step 1: Find connected components on smallest kernel (text centers)
-        var labels = new int[outH, outW];
-        var componentPixels = new Dictionary<int, List<(int y, int x)>>();
-        var componentScores = new Dictionary<int, double>();
-        int nextLabel = 1;
-
-        // Binarize smallest kernel
-        for (int y = 0; y < outH; y++)
-        {
-            for (int x = 0; x < outW; x++)
-            {
-                double score = NumOps.ToDouble(output[0, 0, y, x]);
-                if (score >= threshold)
-                {
-                    // Check neighbors for existing labels
-                    int label = 0;
-                    if (y > 0 && labels[y - 1, x] > 0) label = labels[y - 1, x];
-                    else if (x > 0 && labels[y, x - 1] > 0) label = labels[y, x - 1];
-
-                    if (label == 0)
-                    {
-                        label = nextLabel++;
-                        componentPixels[label] = [];
-                        componentScores[label] = 0;
-                    }
-
-                    labels[y, x] = label;
-                    componentPixels[label].Add((y, x));
-                    componentScores[label] = Math.Max(componentScores[label], score);
-                }
-            }
-        }
-
-        // Step 2: Progressive scale expansion through remaining kernels
-        for (int k = 1; k < _numKernels; k++)
-        {
-            var expanded = true;
-            while (expanded)
-            {
-                expanded = false;
-                for (int y = 0; y < outH; y++)
-                {
-                    for (int x = 0; x < outW; x++)
-                    {
-                        if (labels[y, x] == 0)
-                        {
-                            double score = NumOps.ToDouble(output[0, k, y, x]);
-                            if (score >= threshold * 0.5) // Lower threshold for expansion
-                            {
-                                // Check 4-connected neighbors for existing labels
-                                int neighborLabel = 0;
-                                if (y > 0 && labels[y - 1, x] > 0) neighborLabel = labels[y - 1, x];
-                                else if (y < outH - 1 && labels[y + 1, x] > 0) neighborLabel = labels[y + 1, x];
-                                else if (x > 0 && labels[y, x - 1] > 0) neighborLabel = labels[y, x - 1];
-                                else if (x < outW - 1 && labels[y, x + 1] > 0) neighborLabel = labels[y, x + 1];
-
-                                if (neighborLabel > 0)
-                                {
-                                    labels[y, x] = neighborLabel;
-                                    componentPixels[neighborLabel].Add((y, x));
-                                    expanded = true;
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        }
-
-        // Step 3: Extract bounding boxes and polygons from expanded components
-        int regionId = 0;
-        foreach (var (label, pixels) in componentPixels)
-        {
-            if (pixels.Count < 10) continue; // Filter tiny components
-
-            // Get bounding box
-            int minY = pixels.Min(p => p.y);
-            int maxY = pixels.Max(p => p.y);
-            int minX = pixels.Min(p => p.x);
-            int maxX = pixels.Max(p => p.x);
-
-            // Extract convex hull for polygon (simplified: use bounding corners)
-            var polygon = ExtractConvexHull(pixels);
-
-            double avgScore = componentScores[label];
-
-            regions.Add(new TextRegion<T>
-            {
-                Confidence = NumOps.FromDouble(avgScore),
-                ConfidenceValue = avgScore,
-                BoundingBox = new Vector<T>([
-                    NumOps.FromDouble(minX),
-                    NumOps.FromDouble(minY),
-                    NumOps.FromDouble(maxX),
-                    NumOps.FromDouble(maxY)
-                ]),
-                PolygonPoints = polygon.Select(p => new Vector<T>([
-                    NumOps.FromDouble(p.x),
-                    NumOps.FromDouble(p.y)
-                ])).ToList(),
-                Index = regionId++
-            });
-        }
-
-        return regions;
-    }
-
-    /// <summary>
-    /// Extracts convex hull from pixel coordinates (simplified algorithm).
-    /// </summary>
-    private static List<(double x, double y)> ExtractConvexHull(List<(int y, int x)> pixels)
-    {
-        if (pixels.Count < 3) return pixels.Select(p => ((double)p.x, (double)p.y)).ToList();
-
-        // Find extreme points
-        var topLeft = pixels.OrderBy(p => p.y).ThenBy(p => p.x).First();
-        var topRight = pixels.OrderBy(p => p.y).ThenByDescending(p => p.x).First();
-        var bottomRight = pixels.OrderByDescending(p => p.y).ThenByDescending(p => p.x).First();
-        var bottomLeft = pixels.OrderByDescending(p => p.y).ThenBy(p => p.x).First();
-
-        // Return quadrilateral approximation of hull
-        return
-        [
-            (topLeft.x, topLeft.y),
-            (topRight.x, topRight.y),
-            (bottomRight.x, bottomRight.y),
-            (bottomLeft.x, bottomLeft.y)
-        ];
-    }
-
-    #endregion
-
-    #region IDocumentModel Implementation
-
-    /// <inheritdoc/>
-    public Tensor<T> EncodeDocument(Tensor<T> documentImage)
-    {
-        ValidateImageShape(documentImage);
-        var preprocessed = PreprocessDocument(documentImage);
-        return _useNativeMode ? Forward(preprocessed) : RunOnnxInference(preprocessed);
-    }
-
-    /// <inheritdoc/>
-    public void ValidateInputShape(Tensor<T> documentImage)
-    {
-        ValidateImageShape(documentImage);
-    }
-
-    /// <inheritdoc/>
-    public string GetModelSummary()
-    {
-        var sb = new System.Text.StringBuilder();
-        sb.AppendLine("PSENet Model Summary");
-        sb.AppendLine("====================");
-        sb.AppendLine($"Mode: {(_useNativeMode ? "Native (Trainable)" : "ONNX (Inference)")}");
-        sb.AppendLine($"Architecture: ResNet + FPN + Multi-scale Kernels");
-        sb.AppendLine($"Backbone Channels: {_backboneChannels}");
-        sb.AppendLine($"Feature Channels: {_featureChannels}");
-        sb.AppendLine($"Number of Kernels: {_numKernels}");
-        sb.AppendLine($"Image Size: {ImageSize}x{ImageSize}");
-        sb.AppendLine($"Progressive Expansion: Yes");
-        sb.AppendLine($"Arbitrary Shapes: Yes");
-        sb.AppendLine($"Total Layers: {Layers.Count}");
-        return sb.ToString();
-    }
-
-    #endregion
-
-    #region Preprocessing
-
-    /// <summary>
-    /// Applies PSENet's industry-standard preprocessing: ImageNet normalization with scale.
-    /// </summary>
-    /// <remarks>
-    /// PSENet (Progressive Scale Expansion Network) uses ImageNet normalization with
-    /// mean=[0.485, 0.456, 0.406] and std=[0.229, 0.224, 0.225], with /255 scaling.
-    /// </remarks>
-    protected override Tensor<T> ApplyDefaultPreprocessing(Tensor<T> rawImage)
-    {
-        var image = EnsureBatchDimension(rawImage);
-        int batchSize = image.Shape[0];
-        int channels = image.Shape[1];
-        int height = image.Shape[2];
-        int width = image.Shape[3];
-
-        var normalized = new Tensor<T>(image._shape);
-        // ImageNet channel statistics are defined on the [0,1] pixel scale (mean 0.485 / std 0.229,
-        // Simonyan & Zisserman; He et al.). The input tensor is expected to ALREADY be in [0,1] — the
-        // /255 uint8→float conversion is the caller's ToTensor step (PyTorch convention: the model
-        // receives normalized-range tensors, transforms.Normalize is applied to [0,1] data). Applying
-        // /255 HERE as well double-scaled the input: any [0,1] image was crushed to ~[0,0.004] before
-        // the mean subtraction, so two very different constant pages (0.1 vs 0.9) both mapped to
-        // ~-2.11 and the deep ResNet+FPN+BN stack washed the <1 % residual to a bit-identical output
-        // (DifferentInputs_AfterTraining L2 = 0). Normalize on the [0,1] scale directly.
-        double[] means = [0.485, 0.456, 0.406];
-        double[] stds = [0.229, 0.224, 0.225];
-
-        for (int b = 0; b < batchSize; b++)
-        {
-            for (int c = 0; c < channels; c++)
-            {
-                double mean = c < means.Length ? means[c] : 0.5;
-                double std = c < stds.Length ? stds[c] : 0.5;
-                for (int h = 0; h < height; h++)
-                {
-                    for (int w = 0; w < width; w++)
-                    {
-                        int idx = b * channels * height * width + c * height * width + h * width + w;
-                        normalized.Data.Span[idx] = NumOps.FromDouble((NumOps.ToDouble(image.Data.Span[idx]) - mean) / std);
-                    }
-                }
-            }
-        }
-        return normalized;
-    }
-
-    /// <summary>
-    /// Applies PSENet's industry-standard postprocessing: pass-through (kernel maps are already final).
-    /// </summary>
-    protected override Tensor<T> ApplyDefaultPostprocessing(Tensor<T> modelOutput) => modelOutput;
-
-    #endregion
-
-    #region Serialization
-
-    /// <inheritdoc/>
-    public override ModelMetadata<T> GetModelMetadata()
-    {
-        return new ModelMetadata<T>
-        {
-            Name = "PSENet",
-            Description = "PSENet for progressive scale expansion text detection (CVPR 2019)",
-            FeatureCount = _featureChannels,
-            Complexity = _numKernels,
-            AdditionalInfo = new Dictionary<string, object>
-            {
-                { "backbone_channels", _backboneChannels },
-                { "feature_channels", _featureChannels },
-                { "num_kernels", _numKernels },
-                { "image_size", ImageSize },
-                { "use_native_mode", _useNativeMode }
-            },
-            ModelData = SafeSerialize()
-        };
-    }
-
-    /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_backboneChannels);
-        writer.Write(_featureChannels);
-        writer.Write(_numKernels);
-        writer.Write(ImageSize);
-        writer.Write(_useNativeMode);
-    }
-
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        int backboneChannels = reader.ReadInt32();
-        int featureChannels = reader.ReadInt32();
-        int numKernels = reader.ReadInt32();
-        int imageSize = reader.ReadInt32();
-        bool useNativeMode = reader.ReadBoolean();
-
-        ImageSize = imageSize;
-    }
-
-    /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new PSENet<T>(Architecture, ImageSize, _backboneChannels, _featureChannels, _numKernels);
-    }
-
-    #endregion
-
-    #region NeuralNetworkBase Implementation
-
-    /// <inheritdoc/>
-    protected override Tensor<T> PredictCore(Tensor<T> input)
-    {
-        var preprocessed = PreprocessDocument(input);
-        return _useNativeMode ? Forward(preprocessed) : RunOnnxInference(preprocessed);
-    }
-
-    /// <summary>
-    /// Trains on the SAME preprocessed tensor <see cref="PredictCore"/> evaluates, rather than on
-    /// the raw input.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// Without this override the base implementation walks <c>Layers</c> on the raw tensor while
-    /// prediction runs on the preprocessed one, so the model was trained on one input distribution
-    /// and measured on another. Preprocessing here maps a U[0,1) fixture (mean 0.5, std 0.29) to
-    /// roughly mean 0.07, std 1.26, and additionally promotes [3, H, W] to [1, 3, H, W] -- so the
-    /// two paths differed in rank as well as scale.
-    /// </para>
-    /// <para>
-    /// That is what made the loss climb MONOTONICALLY with training rather than merely fail to
-    /// improve. BatchNormalization takes its batch-statistics branch during training and updates
-    /// its running mean/variance, so those running stats drifted toward the RAW activation
-    /// distribution; eval-mode prediction then normalized with them and got progressively more
-    /// wrong the longer training ran. Starting values are (0, 1) -- a pure identity affine -- which
-    /// is exactly why the untrained baseline looked healthy at 0.876 and the trained model reached
-    /// 1.418.
-    /// </para>
-    /// <para>
-    /// Same fix as the siblings that already do this: DocBank and MATCHA. DBNet, EAST and CRAFT
-    /// share the identical asymmetry and are not fixed here.
-    /// </para>
-    /// </remarks>
-    public override Tensor<T> ForwardForTraining(Tensor<T> input)
-    {
-        EnsureLayerRandomSeedsWired();
-        return base.ForwardForTraining(PreprocessDocument(input));
-    }
-
-    /// <inheritdoc/>
-    public override void Train(Tensor<T> input, Tensor<T> expectedOutput)
-    {
-        if (!_useNativeMode)
-            throw new NotSupportedException("Training not supported in ONNX mode.");
-
-        SetTrainingMode(true);
-        // TrainWithTape runs forward+backward, applies global-norm gradient clipping
-        // (NeuralNetworkBase.ApplyGradientClipping) and then the optimizer step. The prior
-        // code ALSO called UpdateParameters(CollectGradients()) afterward — a second, raw,
-        // UNCLIPPED SGD step (params -= grads * 1e-4) on top of the already-applied optimizer
-        // update. That double/unclipped update diverged training on the deep ResNet+FPN stack
-        // (memorization loss 0.38 -> 18615). TrainWithTape owns the whole clipped optimizer
-        // step, matching every other native model (e.g. the Finance forecasting transformers).
-        TrainWithTape(input, expectedOutput, _optimizer);
-        SetTrainingMode(false);
-    }
-
-    // UpdateParameters applied a GRADIENT STEP, but its one-argument form is the value setter and every caller passes values -- the override corrupted the model. Removed under AIDN082.

-
-    /// <summary>
-    /// Parameters cannot be written while the model is backed by a loaded ONNX graph: the weights
-    /// belong to that graph, not to this instance.
-    /// </summary>
-    /// <remarks>
-    /// Replaces a hand-written throw that used to sit inside UpdateParameters. The base checks this
-    /// on every mutating entry point rather than the one member the throw happened to guard, and
-    /// reading -- ParameterCount and GetParameters -- stays available either way.
-    /// </remarks>
+using AiDotNet.Attributes;
+using AiDotNet.Document.Interfaces;
+using AiDotNet.Document.Options;
+using AiDotNet.Enums;
+using AiDotNet.Helpers;
+using AiDotNet.Interfaces;
+using AiDotNet.LinearAlgebra;
+using AiDotNet.LossFunctions;
+using AiDotNet.NeuralNetworks;
+using AiDotNet.NeuralNetworks.Layers;
+using AiDotNet.Optimizers;
+using Microsoft.ML.OnnxRuntime;
+
+namespace AiDotNet.Document.OCR.TextDetection;
+
+/// <summary>
+/// PSENet (Progressive Scale Expansion Network) for text detection.
+/// </summary>
+/// <typeparam name="T">The numeric type used for calculations.</typeparam>
+/// <remarks>
+/// <para>
+/// PSENet uses a novel progressive scale expansion algorithm to accurately detect
+/// text instances of various shapes and sizes, especially useful for closely spaced text.
+/// </para>
+/// <para>
+/// <b>For Beginners:</b> PSENet handles difficult text detection scenarios:
+/// 1. Detects text at multiple scales (kernels)
+/// 2. Progressively expands from smallest to largest
+/// 3. Separates closely spaced text instances
+/// 4. Handles arbitrary-shaped text
+///
+/// Key features:
+/// - Multi-scale kernel prediction
+/// - Progressive scale expansion algorithm
+/// - Handles closely adjacent text
+/// - Accurate boundary detection
+///
+/// Example usage:
+/// <code>
+/// var model = new PSENet&lt;float&gt;(architecture);
+/// var result = model.DetectText(documentImage);
+/// </code>
+/// </para>
+/// <para>
+/// <b>Reference:</b> "Shape Robust Text Detection with Progressive Scale Expansion Network" (CVPR 2019)
+/// https://arxiv.org/abs/1903.12473
+/// </para>
+/// </remarks>
+[ModelDomain(ModelDomain.Vision)]
+[ModelCategory(ModelCategory.NeuralNetwork)]
+[ModelCategory(ModelCategory.ConvolutionalNetwork)]
+[ModelTask(ModelTask.Detection)]
+[ModelTask(ModelTask.Segmentation)]
+[ModelComplexity(ModelComplexity.Medium)]
+[ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
+[ResearchPaper("Shape Robust Text Detection with Progressive Scale Expansion Network", "https://doi.org/10.48550/arXiv.1903.12473", Year = 2019, Authors = "Wenhai Wang, Enze Xie, Xiang Li, Wenbo Hou, Tong Lu, Gang Yu, Shuai Shao")]
+public partial class PSENet<T> : DocumentNeuralNetworkBase<T>, ITextDetector<T>
+{
+    private readonly PSENetOptions _options;
+
+    /// <inheritdoc/>
+    public override ModelOptions GetOptions() => _options;
+
+    #region Fields
+
+    private readonly bool _useNativeMode;
+    private readonly InferenceSession? _onnxSession;
+    private readonly IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>> _optimizer;
+    private readonly int _backboneChannels;
+    private readonly int _featureChannels;
+    private readonly int _numKernels;
+
+    // Native mode layers
+    private readonly List<ILayer<T>> _backboneLayers = [];
+    private readonly List<ILayer<T>> _fpnLayers = [];
+    private readonly List<ILayer<T>> _segmentationLayers = [];
+
+    #endregion
+
+    #region Properties
+
+    /// <inheritdoc/>
+    public override DocumentType SupportedDocumentTypes => DocumentType.All;
+
+    /// <inheritdoc/>
+    public override bool RequiresOCR => false;
+
+    /// <inheritdoc/>
+    public int ExpectedImageSize => ImageSize;
+
+    /// <inheritdoc/>
+    public bool SupportsRotatedText => true;
+
+    /// <inheritdoc/>
+    public int MinTextHeight => 8;
+
+    /// <inheritdoc/>
+    public bool SupportsPolygonOutput => true;
+
+    /// <summary>
+    /// Gets the number of scale kernels.
+    /// </summary>
+    public int NumKernels => _numKernels;
+
+    #endregion
+
+    #region Constructors
+
+    /// <summary>
+    /// Creates a PSENet model with default configuration for native training.
+    /// </summary>
+    public PSENet()
+        : this(new NeuralNetworkArchitecture<T>(
+            // PSENet (CVPR 2019) is an RGB scene-text detector: a ResNet/FPN backbone
+            // whose first convolution consumes 3-channel color images. Declare the input
+            // as ThreeDimensional with inputDepth:3 so GetInputShape() reports [3, H, W]
+            // and the first backbone conv resolves its InputDepth to 3. A TwoDimensional
+            // declaration forces InputDepth=1 (grayscale), which mismatches the 3-channel
+            // RGB tensors fed at inference/training ("Expected input depth 1, but got 3").
+            inputType: InputType.ThreeDimensional,
+            taskType: NeuralNetworkTaskType.BinaryClassification,
+            inputDepth: 3,
+            inputHeight: 640, inputWidth: 640,
+            outputSize: 7))
+    {
+    }
+
+    /// <summary>
+    /// Creates a PSENet model using a pre-trained ONNX model for inference.
+    /// </summary>
+    public PSENet(
+        NeuralNetworkArchitecture<T> architecture,
+        string onnxModelPath,
+        int imageSize = 640,
+        int backboneChannels = 256,
+        int featureChannels = 256,
+        int numKernels = 7,
+        IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? optimizer = null,
+        ILossFunction<T>? lossFunction = null,
+        PSENetOptions? options = null)
+        // PSENet's kernel-prediction heads output per-pixel maps that the paper trains with
+        // binary cross-entropy on the SIGMOID of the logits. PredictCore returns the raw linear
+        // conv output (no sigmoid), so a plain BinaryCrossEntropyLoss (which expects [0,1]
+        // probabilities) explodes as the logits drift during training (memorization loss
+        // 0.38 -> 18582). BinaryCrossEntropyWithLogitsLoss fuses the sigmoid into a numerically
+        // stable loss over raw logits — the paper-correct objective — keeping training bounded
+        // while leaving PredictCore's linear-logit output contract unchanged.
+        : base(architecture, lossFunction ?? new BinaryCrossEntropyWithLogitsLoss<T>(), 1.0)
+    {
+        _options = options ?? new PSENetOptions();
+        Options = _options;
+
+        if (string.IsNullOrWhiteSpace(onnxModelPath))
+            throw new ArgumentNullException(nameof(onnxModelPath));
+        if (!File.Exists(onnxModelPath))
+            throw new FileNotFoundException($"ONNX model not found: {onnxModelPath}", onnxModelPath);
+
+        _useNativeMode = false;
+        _backboneChannels = backboneChannels;
+        _featureChannels = featureChannels;
+        _numKernels = numKernels;
+        _optimizer = optimizer ?? new AdamOptimizer<T, Tensor<T>, Tensor<T>>(this);
+
+        ImageSize = imageSize;
+
+        _onnxSession = new InferenceSession(onnxModelPath);
+
+        InitializeLayers();
+    }
+
+    /// <summary>
+    /// Creates a PSENet model using native layers for training and inference.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// <b>Default Configuration (PSENet from CVPR 2019):</b>
+    /// - Backbone: ResNet-50/152
+    /// - FPN: Feature Pyramid Network
+    /// - Output: Multi-scale kernels (default 7)
+    /// - Post-processing: Progressive scale expansion
+    /// </para>
+    /// </remarks>
+    public PSENet(
+        NeuralNetworkArchitecture<T> architecture,
+        int imageSize = 640,
+        int backboneChannels = 256,
+        int featureChannels = 256,
+        int numKernels = 7,
+        IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? optimizer = null,
+        ILossFunction<T>? lossFunction = null,
+        PSENetOptions? options = null)
+        // PSENet's kernel-prediction heads output per-pixel maps that the paper trains with
+        // binary cross-entropy on the SIGMOID of the logits. PredictCore returns the raw linear
+        // conv output (no sigmoid), so a plain BinaryCrossEntropyLoss (which expects [0,1]
+        // probabilities) explodes as the logits drift during training (memorization loss
+        // 0.38 -> 18582). BinaryCrossEntropyWithLogitsLoss fuses the sigmoid into a numerically
+        // stable loss over raw logits — the paper-correct objective — keeping training bounded
+        // while leaving PredictCore's linear-logit output contract unchanged.
+        : base(architecture, lossFunction ?? new BinaryCrossEntropyWithLogitsLoss<T>(), 1.0)
+    {
+        _options = options ?? new PSENetOptions();
+        Options = _options;
+
+        _useNativeMode = true;
+        _backboneChannels = backboneChannels;
+        _featureChannels = featureChannels;
+        _numKernels = numKernels;
+        _optimizer = optimizer ?? new AdamOptimizer<T, Tensor<T>, Tensor<T>>(this);
+
+        ImageSize = imageSize;
+
+        InitializeLayers();
+    }
+
+    #endregion
+
+    #region Initialization
+
+    /// <inheritdoc/>
+    protected override void InitializeLayers()
+    {
+        if (!_useNativeMode)
+        {
+            return;
+        }
+
+        if (Architecture.Layers is not null && Architecture.Layers.Count > 0)
+        {
+            Layers.AddRange(Architecture.Layers);
+            ValidateCustomLayers(Layers);
+            return;
+        }
+
+        Layers.AddRange(LayerHelper<T>.CreateDefaultPSENetLayers(
+            imageSize: ImageSize,
+            backboneChannels: _backboneChannels,
+            featureChannels: _featureChannels,
+            numKernels: _numKernels));
+    }
+
+    #endregion
+
+    #region ITextDetector Implementation
+
+    /// <inheritdoc/>
+    public TextDetectionResult<T> DetectText(Tensor<T> documentImage)
+    {
+        return DetectText(documentImage, 0.5);
+    }
+
+    /// <inheritdoc/>
+    public TextDetectionResult<T> DetectText(Tensor<T> documentImage, double confidenceThreshold)
+    {
+        ValidateImageShape(documentImage);
+        var startTime = DateTime.UtcNow;
+
+        var preprocessed = PreprocessDocument(documentImage);
+        var output = _useNativeMode ? Forward(preprocessed) : RunOnnxInference(preprocessed);
+
+        var regions = ParsePSENetOutput(output, confidenceThreshold);
+
+        return new TextDetectionResult<T>
+        {
+            TextRegions = regions,
+            ProcessingTimeMs = (DateTime.UtcNow - startTime).TotalMilliseconds
+        };
+    }
+
+    /// <inheritdoc/>
+    public IEnumerable<TextDetectionResult<T>> DetectTextBatch(IEnumerable<Tensor<T>> documentImages)
+    {
+        foreach (var image in documentImages)
+            yield return DetectText(image);
+    }
+
+    /// <inheritdoc/>
+    public Tensor<T> GetHeatmap()
+    {
+        return Tensor<T>.CreateDefault([ImageSize, ImageSize], NumOps.Zero);
+    }
+
+    /// <inheritdoc/>
+    public Tensor<T> GetProbabilityMap(Tensor<T> image)
+    {
+        ValidateImageShape(image);
+        var preprocessed = PreprocessDocument(image);
+        var output = _useNativeMode ? Forward(preprocessed) : RunOnnxInference(preprocessed);
+
+        // Return the largest kernel (full text region)
+        int outH = output.Shape.Length > 2 ? output.Shape[2] : ImageSize;
+        int outW = output.Shape.Length > 3 ? output.Shape[3] : ImageSize;
+        var probMap = Tensor<T>.CreateDefault([outH, outW], NumOps.Zero);
+
+        for (int h = 0; h < outH; h++)
+        {
+            for (int w = 0; w < outW; w++)
+            {
+                // Use the last kernel (largest scale)
+                probMap[h, w] = output[0, _numKernels - 1, h, w];
+            }
+        }
+
+        return probMap;
+    }
+
+    private List<TextRegion<T>> ParsePSENetOutput(Tensor<T> output, double threshold)
+    {
+        var regions = new List<TextRegion<T>>();
+
+        // PSENet output: [batch, numKernels, H, W]
+        // Kernels are ordered from smallest (index 0) to largest (index numKernels-1)
+        // Progressive Scale Expansion: start from smallest kernel and expand
+
+        int outH = output.Shape.Length > 2 ? output.Shape[2] : ImageSize;
+        int outW = output.Shape.Length > 3 ? output.Shape[3] : ImageSize;
+
+        // Step 1: Find connected components on smallest kernel (text centers)
+        var labels = new int[outH, outW];
+        var componentPixels = new Dictionary<int, List<(int y, int x)>>();
+        var componentScores = new Dictionary<int, double>();
+        int nextLabel = 1;
+
+        // Binarize smallest kernel
+        for (int y = 0; y < outH; y++)
+        {
+            for (int x = 0; x < outW; x++)
+            {
+                double score = NumOps.ToDouble(output[0, 0, y, x]);
+                if (score >= threshold)
+                {
+                    // Check neighbors for existing labels
+                    int label = 0;
+                    if (y > 0 && labels[y - 1, x] > 0) label = labels[y - 1, x];
+                    else if (x > 0 && labels[y, x - 1] > 0) label = labels[y, x - 1];
+
+                    if (label == 0)
+                    {
+                        label = nextLabel++;
+                        componentPixels[label] = [];
+                        componentScores[label] = 0;
+                    }
+
+                    labels[y, x] = label;
+                    componentPixels[label].Add((y, x));
+                    componentScores[label] = Math.Max(componentScores[label], score);
+                }
+            }
+        }
+
+        // Step 2: Progressive scale expansion through remaining kernels
+        for (int k = 1; k < _numKernels; k++)
+        {
+            var expanded = true;
+            while (expanded)
+            {
+                expanded = false;
+                for (int y = 0; y < outH; y++)
+                {
+                    for (int x = 0; x < outW; x++)
+                    {
+                        if (labels[y, x] == 0)
+                        {
+                            double score = NumOps.ToDouble(output[0, k, y, x]);
+                            if (score >= threshold * 0.5) // Lower threshold for expansion
+                            {
+                                // Check 4-connected neighbors for existing labels
+                                int neighborLabel = 0;
+                                if (y > 0 && labels[y - 1, x] > 0) neighborLabel = labels[y - 1, x];
+                                else if (y < outH - 1 && labels[y + 1, x] > 0) neighborLabel = labels[y + 1, x];
+                                else if (x > 0 && labels[y, x - 1] > 0) neighborLabel = labels[y, x - 1];
+                                else if (x < outW - 1 && labels[y, x + 1] > 0) neighborLabel = labels[y, x + 1];
+
+                                if (neighborLabel > 0)
+                                {
+                                    labels[y, x] = neighborLabel;
+                                    componentPixels[neighborLabel].Add((y, x));
+                                    expanded = true;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        // Step 3: Extract bounding boxes and polygons from expanded components
+        int regionId = 0;
+        foreach (var (label, pixels) in componentPixels)
+        {
+            if (pixels.Count < 10) continue; // Filter tiny components
+
+            // Get bounding box
+            int minY = pixels.Min(p => p.y);
+            int maxY = pixels.Max(p => p.y);
+            int minX = pixels.Min(p => p.x);
+            int maxX = pixels.Max(p => p.x);
+
+            // Extract convex hull for polygon (simplified: use bounding corners)
+            var polygon = ExtractConvexHull(pixels);
+
+            double avgScore = componentScores[label];
+
+            regions.Add(new TextRegion<T>
+            {
+                Confidence = NumOps.FromDouble(avgScore),
+                ConfidenceValue = avgScore,
+                BoundingBox = new Vector<T>([
+                    NumOps.FromDouble(minX),
+                    NumOps.FromDouble(minY),
+                    NumOps.FromDouble(maxX),
+                    NumOps.FromDouble(maxY)
+                ]),
+                PolygonPoints = polygon.Select(p => new Vector<T>([
+                    NumOps.FromDouble(p.x),
+                    NumOps.FromDouble(p.y)
+                ])).ToList(),
+                Index = regionId++
+            });
+        }
+
+        return regions;
+    }
+
+    /// <summary>
+    /// Extracts convex hull from pixel coordinates (simplified algorithm).
+    /// </summary>
+    private static List<(double x, double y)> ExtractConvexHull(List<(int y, int x)> pixels)
+    {
+        if (pixels.Count < 3) return pixels.Select(p => ((double)p.x, (double)p.y)).ToList();
+
+        // Find extreme points
+        var topLeft = pixels.OrderBy(p => p.y).ThenBy(p => p.x).First();
+        var topRight = pixels.OrderBy(p => p.y).ThenByDescending(p => p.x).First();
+        var bottomRight = pixels.OrderByDescending(p => p.y).ThenByDescending(p => p.x).First();
+        var bottomLeft = pixels.OrderByDescending(p => p.y).ThenBy(p => p.x).First();
+
+        // Return quadrilateral approximation of hull
+        return
+        [
+            (topLeft.x, topLeft.y),
+            (topRight.x, topRight.y),
+            (bottomRight.x, bottomRight.y),
+            (bottomLeft.x, bottomLeft.y)
+        ];
+    }
+
+    #endregion
+
+    #region IDocumentModel Implementation
+
+    /// <inheritdoc/>
+    public Tensor<T> EncodeDocument(Tensor<T> documentImage)
+    {
+        ValidateImageShape(documentImage);
+        var preprocessed = PreprocessDocument(documentImage);
+        return _useNativeMode ? Forward(preprocessed) : RunOnnxInference(preprocessed);
+    }
+
+    /// <inheritdoc/>
+    public void ValidateInputShape(Tensor<T> documentImage)
+    {
+        ValidateImageShape(documentImage);
+    }
+
+    /// <inheritdoc/>
+    public string GetModelSummary()
+    {
+        var sb = new System.Text.StringBuilder();
+        sb.AppendLine("PSENet Model Summary");
+        sb.AppendLine("====================");
+        sb.AppendLine($"Mode: {(_useNativeMode ? "Native (Trainable)" : "ONNX (Inference)")}");
+        sb.AppendLine($"Architecture: ResNet + FPN + Multi-scale Kernels");
+        sb.AppendLine($"Backbone Channels: {_backboneChannels}");
+        sb.AppendLine($"Feature Channels: {_featureChannels}");
+        sb.AppendLine($"Number of Kernels: {_numKernels}");
+        sb.AppendLine($"Image Size: {ImageSize}x{ImageSize}");
+        sb.AppendLine($"Progressive Expansion: Yes");
+        sb.AppendLine($"Arbitrary Shapes: Yes");
+        sb.AppendLine($"Total Layers: {Layers.Count}");
+        return sb.ToString();
+    }
+
+    #endregion
+
+    #region Preprocessing
+
+    /// <summary>
+    /// Applies PSENet's industry-standard preprocessing: ImageNet normalization with scale.
+    /// </summary>
+    /// <remarks>
+    /// PSENet (Progressive Scale Expansion Network) uses ImageNet normalization with
+    /// mean=[0.485, 0.456, 0.406] and std=[0.229, 0.224, 0.225], with /255 scaling.
+    /// </remarks>
+    protected override Tensor<T> ApplyDefaultPreprocessing(Tensor<T> rawImage)
+    {
+        var image = EnsureBatchDimension(rawImage);
+        int batchSize = image.Shape[0];
+        int channels = image.Shape[1];
+        int height = image.Shape[2];
+        int width = image.Shape[3];
+
+        var normalized = new Tensor<T>(image._shape);
+        // ImageNet channel statistics are defined on the [0,1] pixel scale (mean 0.485 / std 0.229,
+        // Simonyan & Zisserman; He et al.). The input tensor is expected to ALREADY be in [0,1] — the
+        // /255 uint8→float conversion is the caller's ToTensor step (PyTorch convention: the model
+        // receives normalized-range tensors, transforms.Normalize is applied to [0,1] data). Applying
+        // /255 HERE as well double-scaled the input: any [0,1] image was crushed to ~[0,0.004] before
+        // the mean subtraction, so two very different constant pages (0.1 vs 0.9) both mapped to
+        // ~-2.11 and the deep ResNet+FPN+BN stack washed the <1 % residual to a bit-identical output
+        // (DifferentInputs_AfterTraining L2 = 0). Normalize on the [0,1] scale directly.
+        double[] means = [0.485, 0.456, 0.406];
+        double[] stds = [0.229, 0.224, 0.225];
+
+        for (int b = 0; b < batchSize; b++)
+        {
+            for (int c = 0; c < channels; c++)
+            {
+                double mean = c < means.Length ? means[c] : 0.5;
+                double std = c < stds.Length ? stds[c] : 0.5;
+                for (int h = 0; h < height; h++)
+                {
+                    for (int w = 0; w < width; w++)
+                    {
+                        int idx = b * channels * height * width + c * height * width + h * width + w;
+                        normalized.Data.Span[idx] = NumOps.FromDouble((NumOps.ToDouble(image.Data.Span[idx]) - mean) / std);
+                    }
+                }
+            }
+        }
+        return normalized;
+    }
+
+    /// <summary>
+    /// Applies PSENet's industry-standard postprocessing: pass-through (kernel maps are already final).
+    /// </summary>
+    protected override Tensor<T> ApplyDefaultPostprocessing(Tensor<T> modelOutput) => modelOutput;
+
+    #endregion
+
+    #region Serialization
+
+    /// <inheritdoc/>
+    public override ModelMetadata<T> GetModelMetadata()
+    {
+        return new ModelMetadata<T>
+        {
+            Name = "PSENet",
+            Description = "PSENet for progressive scale expansion text detection (CVPR 2019)",
+            FeatureCount = _featureChannels,
+            Complexity = _numKernels,
+            AdditionalInfo = new Dictionary<string, object>
+            {
+                { "backbone_channels", _backboneChannels },
+                { "feature_channels", _featureChannels },
+                { "num_kernels", _numKernels },
+                { "image_size", ImageSize },
+                { "use_native_mode", _useNativeMode }
+            },
+            ModelData = SafeSerialize()
+        };
+    }
+
+    /// <inheritdoc/>
+
+
+    /// <inheritdoc/>
+
+
+    #endregion
+
+    #region NeuralNetworkBase Implementation
+
+    /// <inheritdoc/>
+    protected override Tensor<T> PredictCore(Tensor<T> input)
+    {
+        var preprocessed = PreprocessDocument(input);
+        return _useNativeMode ? Forward(preprocessed) : RunOnnxInference(preprocessed);
+    }
+
+    /// <summary>
+    /// Trains on the SAME preprocessed tensor <see cref="PredictCore"/> evaluates, rather than on
+    /// the raw input.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// Without this override the base implementation walks <c>Layers</c> on the raw tensor while
+    /// prediction runs on the preprocessed one, so the model was trained on one input distribution
+    /// and measured on another. Preprocessing here maps a U[0,1) fixture (mean 0.5, std 0.29) to
+    /// roughly mean 0.07, std 1.26, and additionally promotes [3, H, W] to [1, 3, H, W] -- so the
+    /// two paths differed in rank as well as scale.
+    /// </para>
+    /// <para>
+    /// That is what made the loss climb MONOTONICALLY with training rather than merely fail to
+    /// improve. BatchNormalization takes its batch-statistics branch during training and updates
+    /// its running mean/variance, so those running stats drifted toward the RAW activation
+    /// distribution; eval-mode prediction then normalized with them and got progressively more
+    /// wrong the longer training ran. Starting values are (0, 1) -- a pure identity affine -- which
+    /// is exactly why the untrained baseline looked healthy at 0.876 and the trained model reached
+    /// 1.418.
+    /// </para>
+    /// <para>
+    /// Same fix as the siblings that already do this: DocBank and MATCHA. DBNet, EAST and CRAFT
+    /// share the identical asymmetry and are not fixed here.
+    /// </para>
+    /// </remarks>
+    public override Tensor<T> ForwardForTraining(Tensor<T> input)
+    {
+        EnsureLayerRandomSeedsWired();
+        return base.ForwardForTraining(PreprocessDocument(input));
+    }
+
+    /// <inheritdoc/>
+    public override void Train(Tensor<T> input, Tensor<T> expectedOutput)
+    {
+        if (!_useNativeMode)
+            throw new NotSupportedException("Training not supported in ONNX mode.");
+
+        SetTrainingMode(true);
+        // TrainWithTape runs forward+backward, applies global-norm gradient clipping
+        // (NeuralNetworkBase.ApplyGradientClipping) and then the optimizer step. The prior
+        // code ALSO called UpdateParameters(CollectGradients()) afterward — a second, raw,
+        // UNCLIPPED SGD step (params -= grads * 1e-4) on top of the already-applied optimizer
+        // update. That double/unclipped update diverged training on the deep ResNet+FPN stack
+        // (memorization loss 0.38 -> 18615). TrainWithTape owns the whole clipped optimizer
+        // step, matching every other native model (e.g. the Finance forecasting transformers).
+        TrainWithTape(input, expectedOutput, _optimizer);
+        SetTrainingMode(false);
+    }
+
+    // UpdateParameters applied a GRADIENT STEP, but its one-argument form is the value setter and every caller passes values -- the override corrupted the model. Removed under AIDN082.
+
+
+    /// <summary>
+    /// Parameters cannot be written while the model is backed by a loaded ONNX graph: the weights
+    /// belong to that graph, not to this instance.
+    /// </summary>
+    /// <remarks>
+    /// Replaces a hand-written throw that used to sit inside UpdateParameters. The base checks this
+    /// on every mutating entry point rather than the one member the throw happened to guard, and
+    /// reading -- ParameterCount and GetParameters -- stays available either way.
+    /// </remarks>
     protected override bool SupportsParameterMutation => _useNativeMode;
-    private Vector<T> CollectGradients()
-    {
-        var grads = new List<T>();
-        foreach (var layer in Layers)
-            grads.AddRange(layer.GetParameterGradients());
-        return new Vector<T>([.. grads]);
-    }
-
-    #endregion
-
-    #region Disposal
-
-    /// <inheritdoc/>
-    protected override void Dispose(bool disposing)
-    {
-        if (disposing)
-            _onnxSession?.Dispose();
-        base.Dispose(disposing);
-    }
-
-    #endregion
-}
+    private Vector<T> CollectGradients()
+    {
+        var grads = new List<T>();
+        foreach (var layer in Layers)
+            grads.AddRange(layer.GetParameterGradients());
+        return new Vector<T>([.. grads]);
+    }
+
+    #endregion
+
+    #region Disposal
+
+    /// <inheritdoc/>
+    protected override void Dispose(bool disposing)
+    {
+        if (disposing)
+            _onnxSession?.Dispose();
+        base.Dispose(disposing);
+    }
+
+    #endregion
+}
diff --git a/src/Document/OCR/TextRecognition/ABINet.cs b/src/Document/OCR/TextRecognition/ABINet.cs
index f71e579116..4b835572aa 100644
--- a/src/Document/OCR/TextRecognition/ABINet.cs
+++ b/src/Document/OCR/TextRecognition/ABINet.cs
@@ -1,893 +1,858 @@
-using AiDotNet.Attributes;
-using AiDotNet.Document.Interfaces;
-using AiDotNet.Document.Options;
-using AiDotNet.Enums;
-using AiDotNet.Helpers;
-using AiDotNet.Interfaces;
-using AiDotNet.LinearAlgebra;
-using AiDotNet.LossFunctions;
-using AiDotNet.NeuralNetworks;
-using AiDotNet.NeuralNetworks.Layers;
-using AiDotNet.LearningRateSchedulers;
-using AiDotNet.Optimizers;
-using Microsoft.ML.OnnxRuntime;
-
-namespace AiDotNet.Document.OCR.TextRecognition;
-
-/// <summary>
-/// ABINet (Autonomous, Bidirectional, Iterative Network) for text recognition.
-/// </summary>
-/// <typeparam name="T">The numeric type used for calculations.</typeparam>
-/// <remarks>
-/// <para>
-/// ABINet uses a novel architecture with autonomous vision, bidirectional language modeling,
-/// and iterative correction to achieve robust text recognition.
-/// </para>
-/// <para>
-/// <b>For Beginners:</b> ABINet has three key innovations:
-/// 1. Autonomous vision model (works without external language model)
-/// 2. Bidirectional language model (looks at context from both directions)
-/// 3. Iterative correction (refines predictions multiple times)
-///
-/// Key features:
-/// - Self-contained (no external LM needed)
-/// - Built-in spell correction via language model
-/// - Iterative refinement for accuracy
-/// - Strong on noisy/occluded text
-///
-/// Example usage:
-/// <code>
-/// var model = new ABINet&lt;float&gt;(architecture);
-/// var result = model.RecognizeText(textImage);
-/// // Result is available in the returned value
-/// </code>
-/// </para>
-/// <para>
-/// <b>Reference:</b> "Read Like Humans: Autonomous, Bidirectional and Iterative Language Modeling" (CVPR 2021)
-/// https://arxiv.org/abs/2103.06495
-/// </para>
-/// </remarks>
-[ModelDomain(ModelDomain.Vision)]
-[ModelDomain(ModelDomain.Language)]
-[ModelCategory(ModelCategory.NeuralNetwork)]
-[ModelCategory(ModelCategory.Transformer)]
-[ModelTask(ModelTask.Detection)]
-[ModelComplexity(ModelComplexity.High)]
-[ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
-[ResearchPaper("Read Like Humans: Autonomous, Bidirectional and Iterative Language Modeling for Scene Text Recognition", "https://doi.org/10.48550/arXiv.2103.06495", Year = 2021, Authors = "Shancheng Fang, Hongtao Xie, Yuxin Wang, Zhendong Mao, Yongdong Zhang")]
-public partial class ABINet<T> : DocumentNeuralNetworkBase<T>, ITextRecognizer<T>
-{
-    private readonly ABINetOptions _options;
-
-    /// <inheritdoc/>
-    public override ModelOptions GetOptions() => _options;
-
-    #region Fields
-
-    private readonly bool _useNativeMode;
-    private readonly InferenceSession? _onnxSession;
-    private readonly IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>> _optimizer;
-    private readonly int _visionDim;
-    private readonly int _languageDim;
-    private readonly int _visionLayers;
-    private readonly int _languageLayers;
-    private readonly int _numIterations;
-    private readonly int _imageHeight;
-    private readonly string _charset;
-
-    // Native mode layers. ABINet is a three-branch model (Fang et al., CVPR 2021), not a single
-    // chain: the vision model, the language model and the fusion each emit character
-    // probabilities and each carries its own loss term. These lists hold the branches so the
-    // training forward can supervise all three; every layer in them is also in Layers, so
-    // parameter enumeration, serialization and device transfer are unaffected.
-    private readonly List<ILayer<T>> _visionModelLayers = [];
-    private readonly List<ILayer<T>> _languageModelLayers = [];
-    private readonly List<ILayer<T>> _fusionLayers = [];
-
-    /// <summary>Character head for the vision branch, supervised by L_v.</summary>
-    private readonly List<ILayer<T>> _visionHead = [];
-
-    /// <summary>Character head for the language branch, supervised by L_l.</summary>
-    private readonly List<ILayer<T>> _languageHead = [];
-
-    private int[]? _branchCounts;
-
-    /// <summary>
-    /// True when this instance built the paper's three-branch stack. False when the caller
-    /// supplied a flat <c>Architecture.Layers</c> chain, which has no branch structure to
-    /// supervise separately.
-    /// </summary>
-    private bool _branched;
-
-    // Learnable embeddings
-
-    #endregion
-
-    #region Properties
-
-    /// <inheritdoc/>
-    public override DocumentType SupportedDocumentTypes => DocumentType.All;
-
-    /// <inheritdoc/>
-    public override bool RequiresOCR => false;
-
-    /// <inheritdoc/>
-    public int ExpectedImageSize => ImageSize;
-
-    /// <inheritdoc/>
-    public string SupportedCharacters => _charset;
-
-    // NO CONTRACT YET, and the sweep is why. The class count IS charset+1 - that half was right - but
-    // the STEP count is not MaxSequenceLength: the contract said [1,26,96] and Predict returned
-    // [1,256,96]. The [MaxSequenceLength, charset+1] tensor this class builds is a FALLBACK path; the
-    // real forward decodes 256 steps from the vision backbone, and 26 is just the configured maximum.
-    // Stating the family law here would assert a step count the model does not use, so this declines
-    // until the 256 is traced to whatever produces it. CRNN, whose CTC head really does emit
-    // MaxSequenceLength steps, agrees with the family law and keeps its contract.
-
-    /// <inheritdoc/>
-    public new int MaxSequenceLength => base.MaxSequenceLength;
-
-    /// <inheritdoc/>
-    public bool SupportsAttentionVisualization => true;
-
-    /// <summary>
-    /// Gets the number of iterative refinement steps.
-    /// </summary>
-    public int NumIterations => _numIterations;
-
-    /// <summary>
-    /// Gets the input image height.
-    /// </summary>
-    public int ImageHeight => _imageHeight;
-
-    #endregion
-
-    #region Constructors
-
-    /// <summary>
-    /// Creates an ABINet model using a pre-trained ONNX model for inference.
-    /// </summary>
-    public ABINet(
-        NeuralNetworkArchitecture<T> architecture,
-        string onnxModelPath,
-        int imageWidth = 128,
-        int imageHeight = 32,
-        int maxSequenceLength = 26,
-        int visionDim = 512,
-        int languageDim = 512,
-        int visionLayers = 3,
-        int languageLayers = 4,
-        int numIterations = 3,
-        string? charset = null,
-        IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? optimizer = null,
-        ILossFunction<T>? lossFunction = null,
-        ABINetOptions? options = null)
-        : base(architecture, lossFunction ?? new CrossEntropyWithLogitsLoss<T>(), 1.0)
-    {
-        _options = options ?? new ABINetOptions();
-        Options = _options;
-
-        if (string.IsNullOrWhiteSpace(onnxModelPath))
-            throw new ArgumentNullException(nameof(onnxModelPath));
-        if (!File.Exists(onnxModelPath))
-            throw new FileNotFoundException($"ONNX model not found: {onnxModelPath}", onnxModelPath);
-
-        _useNativeMode = false;
-        _visionDim = visionDim;
-        _languageDim = languageDim;
-        _visionLayers = visionLayers;
-        _languageLayers = languageLayers;
-        _numIterations = numIterations;
-        _imageHeight = imageHeight;
-        _charset = charset ?? GetDefaultCharset();
-        _optimizer = optimizer ?? new AdamOptimizer<T, Tensor<T>, Tensor<T>>(this,
-            new AdamOptimizerOptions<T, Tensor<T>, Tensor<T>>
-            {
-                InitialLearningRate = _options.LearningRate,
-                // "decayed to 1e-5 after 6 epochs" -- a single 10x step at epoch 6.
-                LearningRateScheduler = new MultiStepLRScheduler(
-                    _options.LearningRate, milestones: new[] { 6 }, gamma: 0.1),
-                SchedulerStepMode = SchedulerStepMode.StepPerEpoch
-            });
-
-        ImageSize = imageWidth;
-        base.MaxSequenceLength = maxSequenceLength;
-
-        _onnxSession = new InferenceSession(onnxModelPath);
-
-        InitializeLayers();
-    }
-
-    /// <summary>
-    /// Creates an ABINet model using native layers for training and inference.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// <b>Default Configuration (ABINet from CVPR 2021):</b>
-    /// - Vision Model: ResNet + Transformer
-    /// - Language Model: Bidirectional Transformer
-    /// - Fusion: Iterative refinement
-    /// - 3 correction iterations by default
-    /// </para>
-    /// </remarks>
-    public ABINet(
-        NeuralNetworkArchitecture<T> architecture,
-        int imageWidth = 128,
-        int imageHeight = 32,
-        int maxSequenceLength = 26,
-        int visionDim = 512,
-        int languageDim = 512,
-        int visionLayers = 3,
-        int languageLayers = 4,
-        int numIterations = 3,
-        string? charset = null,
-        IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? optimizer = null,
-        ILossFunction<T>? lossFunction = null,
-        ABINetOptions? options = null,
-        double? visionLossWeight = null,
-        double? languageLossWeight = null)
-        : base(architecture, BuildMultiTaskObjective(lossFunction, options, visionLossWeight, languageLossWeight), 1.0)
-    {
-        _options = options ?? new ABINetOptions();
-        Options = _options;
-
-        // Record the resolved weights so GetOptions() reports what training actually used.
-        if (visionLossWeight.HasValue) _options.VisionLossWeight = visionLossWeight.Value;
-        if (languageLossWeight.HasValue) _options.LanguageLossWeight = languageLossWeight.Value;
-
-        _useNativeMode = true;
-        _visionDim = visionDim;
-        _languageDim = languageDim;
-        _visionLayers = visionLayers;
-        _languageLayers = languageLayers;
-        _numIterations = numIterations;
-        _imageHeight = imageHeight;
-        _charset = charset ?? GetDefaultCharset();
-
-        // Adam at the paper's initial learning rate (Fang et al., CVPR 2021 §4.2: 1e-4, decayed
-        // to 1e-5). Constructing AdamOptimizer with no options left it at the optimizer's own
-        // 1e-3 default, 10x the paper's rate.
-        _optimizer = optimizer ?? new AdamOptimizer<T, Tensor<T>, Tensor<T>>(this,
-            new AdamOptimizerOptions<T, Tensor<T>, Tensor<T>>
-            {
-                InitialLearningRate = _options.LearningRate
-            });
-
-        ImageSize = imageWidth;
-        base.MaxSequenceLength = maxSequenceLength;
-
-        InitializeLayers();
-        InitializeEmbeddings();
-    }
-
-    /// <summary>
-    /// Builds ABINet's training objective: the paper's weighted sum of the vision, language and
-    /// fusion character losses (Fang et al., CVPR 2021, Eq. 5).
-    /// </summary>
-    /// <remarks>
-    /// A caller-supplied loss becomes the per-branch character loss rather than replacing the
-    /// multi-task structure, so overriding the loss still trains all three branches. A loss that
-    /// is not a <see cref="LossFunctionBase{T}"/> cannot expose the tape entry point the sum
-    /// needs, so it is used as-is and only the fused output is graded.
-    /// </remarks>
-    private static ILossFunction<T> BuildMultiTaskObjective(
-        ILossFunction<T>? lossFunction,
-        ABINetOptions? options,
-        double? visionLossWeight,
-        double? languageLossWeight)
-    {
-        var characterLoss = lossFunction ?? new CrossEntropyWithLogitsLoss<T>();
-        if (characterLoss is not LossFunctionBase<T> tapeCapable)
-            return characterLoss;
-
-        var resolved = options ?? new ABINetOptions();
-        return new ABINetMultiTaskLoss<T>(
-            tapeCapable,
-            visionLossWeight ?? resolved.VisionLossWeight,
-            languageLossWeight ?? resolved.LanguageLossWeight);
-    }
-
-    private static string GetDefaultCharset()
-    {
-        return "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ ";
-    }
-
-    #endregion
-
-    #region Initialization
-
-    /// <inheritdoc/>
-    protected override void InitializeLayers()
-    {
-        if (!_useNativeMode)
-        {
-            return;
-        }
-
-        if (Architecture.Layers is not null && Architecture.Layers.Count > 0)
-        {
-            Layers.AddRange(Architecture.Layers);
-            ValidateCustomLayers(Layers);
-            return;
-        }
-
-        // Build the paper's three branches separately so each can be supervised by its own loss
-        // term. Chained in this order for inference, they reproduce exactly the flat stack this
-        // used to create.
-        int charsetSize = _charset.Length + 1;
-
-        _visionModelLayers.AddRange(LayerHelper<T>.CreateDefaultABINetVisionLayers(
-            imageWidth: ImageSize,
-            imageHeight: _imageHeight,
-            visionDim: _visionDim));
-
-        _languageModelLayers.AddRange(LayerHelper<T>.CreateDefaultABINetLanguageLayers(
-            charsetSize: charsetSize,
-            visionDim: _visionDim,
-            languageDim: _languageDim));
-
-        _fusionLayers.AddRange(LayerHelper<T>.CreateDefaultABINetFusionLayers(
-            visionDim: _visionDim,
-            numIterations: _numIterations,
-            charsetSize: charsetSize));
-
-        _visionHead.Add(LayerHelper<T>.CreateDefaultABINetBranchHead(charsetSize));
-        _languageHead.Add(LayerHelper<T>.CreateDefaultABINetBranchHead(charsetSize));
-
-        ResolveBranchShapes();
-
-        // Everything goes into Layers so parameter enumeration, serialization and device
-        // transfer see every weight. The two branch heads are appended last and are NOT part of
-        // the inference chain; Forward walks the three branches explicitly.
-        Layers.AddRange(_visionModelLayers);
-        Layers.AddRange(_languageModelLayers);
-        Layers.AddRange(_fusionLayers);
-        Layers.AddRange(_visionHead);
-        Layers.AddRange(_languageHead);
-
-        // Deserialization refills Layers with new objects; record the branch extents so
-        // RebindBranchLayers can re-point these lists at the restored ones.
-        _branchCounts = new[]
-        {
-            _visionModelLayers.Count, _languageModelLayers.Count, _fusionLayers.Count,
-            _visionHead.Count, _languageHead.Count
-        };
-
-        _branched = true;
-    }
-
-    /// <summary>
-    /// Resolves each branch's lazy layers, carrying the shape across the two forks.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// The character heads hang off the vision and language trunks rather than sitting in the
-    /// inference chain, so nothing else would ever size them: a deserialized model never runs
-    /// them, they would report a <c>ParameterCount</c> of 0, and <c>SetParameters</c> would then
-    /// hand every following layer the wrong slice of the flat parameter vector.
-    /// </para>
-    /// <para>
-    /// <see cref="LayerHelper{T}.ResolveChain"/> derives every layer's input from the previous
-    /// layer's actual <c>GetOutputShape()</c> and returns the shape leaving the branch, so the
-    /// fork points get real shapes instead of hand-written ones. Sizing the heads from a
-    /// hand-written <c>[1, 1, visionDim]</c> instead produced weights the forward never matched.
-    /// Each layer is skipped once resolved, so this is a no-op on an already-run model.
-    /// </para>
-    /// </remarks>
-    private void ResolveBranchShapes()
-    {
-        var rootShape = Architecture.GetInputShape();
-        if (rootShape is null || rootShape.Length == 0) return;
-
-        // KNOWN LIMITATION: resolution currently stops inside the vision trunk, at the
-        // ReshapeLayer between the convolutions and the transformer. The convolution layers
-        // report GetOutputShape() WITHOUT a batch axis ([512, 8, 32]), while
-        // ReshapeLayer.ResolveFromShape treats the leading axis as batch — so it reads that as
-        // 512 samples of 256 elements against its 131072-element target and rejects it. Chain
-        // resolution stops at the first such failure by design, leaving the rest of the stack
-        // lazy. Adding a batch axis to the root does not help: the convolutions report
-        // per-sample shapes regardless of what they were resolved from.
-        //
-        // Consequence: a freshly built ABINet reports 1,718,624 parameters where one that has
-        // run a forward reports 4,281,376, so restoring a trained parameter vector into a fresh
-        // clone misaligns (Clone_AfterTraining_ShouldPreserveLearnedWeights). The layers that DO
-        // resolve here still benefit, and everything else resolves on first forward as before.
-        //
-        // The real fix is to make the two conventions agree — either the convolutions report a
-        // batched output shape or ReshapeLayer accepts a per-sample one — which is a framework
-        // change affecting every model that chains a convolution into a reshape, not something
-        // to settle inside ABINet.
-
-        // Vision trunk -> vision head (character logits) -> language model -> language head.
-        // The language model is rooted at the HEAD's output, not the trunk's, because it
-        // consumes character probabilities.
-        var visionOut = LayerHelper<T>.ResolveChain(_visionModelLayers, rootShape);
-        var visionLogitsShape = LayerHelper<T>.ResolveChain(_visionHead, visionOut);
-
-        var languageOut = LayerHelper<T>.ResolveChain(_languageModelLayers, visionLogitsShape);
-        LayerHelper<T>.ResolveChain(_languageHead, languageOut);
-
-        // The fusion gate is rooted at [F_v, F_l] concatenated on the feature axis, so its
-        // input is the vision width doubled.
-        var fusionRoot = (int[])visionOut.Clone();
-        fusionRoot[fusionRoot.Length - 1] = visionOut[visionOut.Length - 1] + languageOut[languageOut.Length - 1];
-        LayerHelper<T>.ResolveChain(_fusionLayers, fusionRoot);
-    }
-
-    private void InitializeEmbeddings()
-    {
-        var random = RandomHelper.CreateSeededRandom(42);
-    }
-
-    private void InitializeWithSmallRandomValues(Tensor<T> tensor, Random random, double stdDev)
-    {
-        for (int i = 0; i < tensor.Data.Length; i++)
-        {
-            double u1 = 1.0 - random.NextDouble();
-            double u2 = 1.0 - random.NextDouble();
-            double randStdNormal = Math.Sqrt(-2.0 * Math.Log(u1)) * Math.Sin(2.0 * Math.PI * u2);
-            tensor.Data.Span[i] = NumOps.FromDouble(randStdNormal * stdDev);
-        }
-    }
-
-    #endregion
-
-    #region ITextRecognizer Implementation
-
-    /// <inheritdoc/>
-    public TextRecognitionResult<T> RecognizeText(Tensor<T> croppedImage)
-    {
-        var startTime = DateTime.UtcNow;
-
-        var preprocessed = PreprocessTextImage(croppedImage);
-        var output = _useNativeMode ? Forward(preprocessed) : RunOnnxInference(preprocessed);
-
-        var (text, confidence) = Decode(output);
-
-        return new TextRecognitionResult<T>
-        {
-            Text = text,
-            Confidence = NumOps.FromDouble(confidence),
-            ConfidenceValue = confidence,
-            Characters = GetCharacterConfidences(output, text),
-            ProcessingTimeMs = (DateTime.UtcNow - startTime).TotalMilliseconds
-        };
-    }
-
-    /// <inheritdoc/>
-    public IEnumerable<TextRecognitionResult<T>> RecognizeTextBatch(IEnumerable<Tensor<T>> croppedImages)
-    {
-        foreach (var image in croppedImages)
-            yield return RecognizeText(image);
-    }
-
-    /// <inheritdoc/>
-    public Tensor<T> GetCharacterProbabilities()
-    {
-        return Tensor<T>.CreateDefault([MaxSequenceLength, _charset.Length + 1], NumOps.Zero);
-    }
-
-    /// <inheritdoc/>
-    public Tensor<T>? GetAttentionWeights()
-    {
-        return Tensor<T>.CreateDefault([MaxSequenceLength, MaxSequenceLength], NumOps.Zero);
-    }
-
-    private (string text, double confidence) Decode(Tensor<T> output)
-    {
-        var chars = new List<char>();
-        double totalConf = 0;
-        int validSteps = 0;
-
-        int seqLen = Math.Min(output.Shape[0], MaxSequenceLength);
-        int vocabSize = output.Shape.Length > 1 ? output.Shape[1] : _charset.Length + 1;
-
-        for (int t = 0; t < seqLen; t++)
-        {
-            double maxVal = double.MinValue;
-            int maxIdx = 0;
-            for (int c = 0; c < vocabSize; c++)
-            {
-                double val = NumOps.ToDouble(output[t, c]);
-                if (val > maxVal) { maxVal = val; maxIdx = c; }
-            }
-
-            if (maxIdx == 0) break; // EOS
-            if (maxIdx - 1 < _charset.Length)
-            {
-                chars.Add(_charset[maxIdx - 1]);
-                totalConf += maxVal;
-                validSteps++;
-            }
-        }
-
-        string text = new string([.. chars]);
-        double avgConf = validSteps > 0 ? totalConf / validSteps : 0;
-
-        return (text, avgConf);
-    }
-
-    private List<CharacterRecognition<T>> GetCharacterConfidences(Tensor<T> output, string text)
-    {
-        var result = new List<CharacterRecognition<T>>();
-        for (int i = 0; i < text.Length; i++)
-        {
-            result.Add(new CharacterRecognition<T>
-            {
-                Character = text[i],
-                Confidence = NumOps.FromDouble(0.92),
-                ConfidenceValue = 0.92,
-                Position = i
-            });
-        }
-        return result;
-    }
-
-    private Tensor<T> PreprocessTextImage(Tensor<T> image)
-    {
-        var processed = EnsureBatchDimension(image);
-        if (processed.Shape[2] != _imageHeight || processed.Shape[3] != ImageSize)
-        {
-            processed = Engine.Interpolate(
-                processed,
-                [_imageHeight, ImageSize],
-                InterpolateMode.Bilinear,
-                alignCorners: false);
-        }
-
-        var normalized = new Tensor<T>(processed._shape);
-
-        for (int i = 0; i < processed.Data.Length; i++)
-        {
-            double val = NumOps.ToDouble(processed.Data.Span[i]);
-            normalized.Data.Span[i] = NumOps.FromDouble((val / 255.0 - 0.5) / 0.5);
-        }
-
-        return normalized;
-    }
-
-    #endregion
-
-    #region IDocumentModel Implementation
-
-    /// <inheritdoc/>
-    public Tensor<T> EncodeDocument(Tensor<T> documentImage)
-    {
-        var preprocessed = PreprocessTextImage(documentImage);
-        return _useNativeMode ? Forward(preprocessed) : RunOnnxInference(preprocessed);
-    }
-
-    /// <inheritdoc/>
-    public void ValidateInputShape(Tensor<T> documentImage)
-    {
-        ValidateImageShape(documentImage);
-    }
-
-    /// <inheritdoc/>
-    public string GetModelSummary()
-    {
-        var sb = new System.Text.StringBuilder();
-        sb.AppendLine("ABINet Model Summary");
-        sb.AppendLine("====================");
-        sb.AppendLine($"Mode: {(_useNativeMode ? "Native (Trainable)" : "ONNX (Inference)")}");
-        sb.AppendLine($"Architecture: Vision + Language + Iterative Fusion");
-        sb.AppendLine($"Vision Dimension: {_visionDim}");
-        sb.AppendLine($"Language Dimension: {_languageDim}");
-        sb.AppendLine($"Vision Layers: {_visionLayers}");
-        sb.AppendLine($"Language Layers: {_languageLayers}");
-        sb.AppendLine($"Iterations: {_numIterations}");
-        sb.AppendLine($"Image Size: {ImageSize}x{_imageHeight}");
-        sb.AppendLine($"Max Sequence Length: {MaxSequenceLength}");
-        sb.AppendLine($"Charset Size: {_charset.Length}");
-        sb.AppendLine($"Total Layers: {Layers.Count}");
-        return sb.ToString();
-    }
-
-    #endregion
-
-    #region Preprocessing
-
-    /// <summary>
-    /// Applies ABINet's industry-standard preprocessing: text image preprocessing.
-    /// </summary>
-    /// <remarks>
-    /// ABINet (Attention-Based Implicit Network) uses text-specific preprocessing
-    /// with grayscale conversion and height normalization.
-    /// </remarks>
-    protected override Tensor<T> ApplyDefaultPreprocessing(Tensor<T> rawImage) => PreprocessTextImage(rawImage);
-
-    /// <summary>
-    /// Applies ABINet's industry-standard postprocessing: pass-through (language model outputs are already final).
-    /// </summary>
-    protected override Tensor<T> ApplyDefaultPostprocessing(Tensor<T> modelOutput) => modelOutput;
-
-    #endregion
-
-    #region Serialization
-
-    /// <inheritdoc/>
-    public override ModelMetadata<T> GetModelMetadata()
-    {
-        return new ModelMetadata<T>
-        {
-            Name = "ABINet",
-            Description = "ABINet for robust text recognition (CVPR 2021)",
-            FeatureCount = _visionDim,
-            Complexity = _visionLayers + _languageLayers,
-            AdditionalInfo = new Dictionary<string, object>
-            {
-                { "vision_dim", _visionDim },
-                { "language_dim", _languageDim },
-                { "vision_layers", _visionLayers },
-                { "language_layers", _languageLayers },
-                { "num_iterations", _numIterations },
-                { "image_height", _imageHeight },
-                { "image_width", ImageSize },
-                { "charset_size", _charset.Length },
-                { "use_native_mode", _useNativeMode }
-            },
-            ModelData = SafeSerialize()
-        };
-    }
-
-    /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_visionDim);
-        writer.Write(_languageDim);
-        writer.Write(_visionLayers);
-        writer.Write(_languageLayers);
-        writer.Write(_numIterations);
-        writer.Write(_imageHeight);
-        writer.Write(ImageSize);
-        writer.Write(MaxSequenceLength);
-        writer.Write(_charset);
-        writer.Write(_useNativeMode);
-    }
-
-    /// <inheritdoc/>
-    /// <summary>
-    /// Re-points the branch lists at the layers deserialization just rebuilt.
-    /// </summary>
-    /// <remarks>
-    /// Every branch is appended to <c>Layers</c>, so the weights round-trip correctly, but the
-    /// forward pass reads these private lists and deserialization never re-points them — they
-    /// still referenced the objects this instance built in its own constructor. The restored
-    /// weights landed in layers the model never evaluated, so a clone predicted from its
-    /// initialisation values while reporting success.
-    /// </remarks>
-    private void RebindBranchLayers()
-    {
-        if (_branchCounts is not { Length: 5 }) return;
-
-        int total = 0;
-        foreach (var count in _branchCounts) total += count;
-        if (total == 0 || Layers.Count < total) return;
-
-        var targets = new[]
-        {
-            _visionModelLayers, _languageModelLayers, _fusionLayers, _visionHead, _languageHead
-        };
-
-        int offset = Layers.Count - total;
-        for (int b = 0; b < targets.Length; b++)
-        {
-            targets[b].Clear();
-            for (int i = 0; i < _branchCounts[b]; i++) targets[b].Add(Layers[offset + i]);
-            offset += _branchCounts[b];
-        }
-    }
-
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        int visionDim = reader.ReadInt32();
-        int languageDim = reader.ReadInt32();
-        int visionLayers = reader.ReadInt32();
-        int languageLayers = reader.ReadInt32();
-        int numIterations = reader.ReadInt32();
-        int imageHeight = reader.ReadInt32();
-        int imageSize = reader.ReadInt32();
-        int maxSeqLen = reader.ReadInt32();
-        string charset = reader.ReadString();
-        bool useNativeMode = reader.ReadBoolean();
-
-        ImageSize = imageSize;
-        base.MaxSequenceLength = maxSeqLen;
-    
-        RebindBranchLayers();
-    }
-
-    /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new ABINet<T>(Architecture, ImageSize, _imageHeight, MaxSequenceLength, _visionDim, _languageDim,
-            _visionLayers, _languageLayers, _numIterations, _charset);
-    }
-
-    #endregion
-
-    #region NeuralNetworkBase Implementation
-
-    /// <summary>
-    /// Runs ABINet's explicit sequential graph without the document base
-    /// class's inference-only CNN-to-sequence auto-reshape. The default ABINet
-    /// graph contains its own tape-compatible ReshapeLayer so inference and
-    /// training follow the same shape transitions.
-    /// </summary>
-    protected override Tensor<T> Forward(Tensor<T> input)
-    {
-        if (_branched)
-            return ForwardBranches(input).Fusion;
-
-        Tensor<T> output = input;
-        foreach (var layer in Layers)
-            output = layer.Forward(output);
-
-        return output;
-    }
-
-    /// <summary>
-    /// Runs the vision model, then the language model, then the fusion branch, returning all
-    /// three character predictions.
-    /// </summary>
-    /// <remarks>
-    /// The language branch begins with the gradient barrier, so language and fusion gradients
-    /// stop there and never reach the vision encoder — ABINet's AUTONOMOUS principle. The vision
-    /// encoder still learns, from its own <c>Vision</c> prediction's loss term.
-    /// </remarks>
-    private (Tensor<T> Vision, Tensor<T> Language, Tensor<T> Fusion) ForwardBranches(Tensor<T> input)
-    {
-        var visionFeatures = input;
-        foreach (var layer in _visionModelLayers)
-            visionFeatures = layer.Forward(visionFeatures);
-
-        // F_v -> character logits. These ARE the language model's input: the paper's LM is a
-        // spelling corrector over probability vectors, so the branch begins with the gradient
-        // barrier and a softmax rather than reading visual features.
-        var visionLogits = visionFeatures;
-        foreach (var layer in _visionHead)
-            visionLogits = layer.Forward(visionLogits);
-
-        // ITERATIVE correction, the third of the paper's three principles (Fang et al. 2021,
-        // sec. 3.3). The language model is executed M times: the first pass reads the VISION
-        // model's character probabilities, and every later pass reads the FUSION model's
-        // prediction from the previous iteration, so each round corrects the last round's
-        // spelling using bidirectional context. The paper measures M = 3 as the sweet spot and
-        // uses the final iteration's fused prediction as the output.
-        //
-        // Only one pass was run before this, which reduced the model to Autonomous +
-        // Bidirectional and silently dropped the principle the paper is named for. The iteration
-        // count was already threaded in as _numIterations and consumed only when constructing
-        // the language branch; nothing ever looped.
-        //
-        // Nothing carries across calls: every input restarts from its own vision prediction,
-        // matching the paper's "each new text instance starts fresh".
-        var languageInput = visionLogits;
-        Tensor<T> languageLogits = visionLogits;
-        Tensor<T> fused = visionFeatures;
-
-        int iterations = _numIterations > 0 ? _numIterations : 1;
-        for (int iteration = 0; iteration < iterations; iteration++)
-        {
-            var languageFeatures = languageInput;
-            foreach (var layer in _languageModelLayers)
-                languageFeatures = layer.Forward(languageFeatures);
-
-            languageLogits = languageFeatures;
-            foreach (var layer in _languageHead)
-                languageLogits = layer.Forward(languageLogits);
-
-            // Gated fusion consumes BOTH streams: G = sigmoid([F_v, F_l] W_f),
-            // F_f = G * F_v + (1 - G) * F_l. The gate layer takes them concatenated.
-            fused = Engine.TensorConcatenate(
-                new[] { visionFeatures, languageFeatures },
-                axis: visionFeatures.Shape.Length - 1);
-            foreach (var layer in _fusionLayers)
-                fused = layer.Forward(fused);
-
-            // The next round corrects this round's fused prediction.
-            languageInput = fused;
-        }
-
-        return (visionLogits, languageLogits, fused);
-    }
-
-    /// <summary>
-    /// Emits all three branch predictions stacked along axis 0 so the multi-task objective can
-    /// grade each of them.
-    /// </summary>
-    /// <remarks>
-    /// Pairs with <see cref="Train"/>, which repeats the character target three times to match,
-    /// and with <see cref="ABINetMultiTaskLoss{T}"/>, which splits both back into three blocks
-    /// and returns lambda_v * L_v + lambda_l * L_l + L_f.
-    /// </remarks>
-    public override Tensor<T> ForwardForTraining(Tensor<T> input)
-    {
-        if (!_branched)
-            return base.ForwardForTraining(input);
-
-        // Subclasses that bypass the base forward must seed stochastic layers themselves.
-        EnsureLayerRandomSeedsWired();
-
-        var (vision, language, fusion) = ForwardBranches(input);
-        return Engine.TensorConcatenate(new[] { vision, language, fusion }, axis: 0);
-    }
-
-    /// <inheritdoc/>
-    protected override Tensor<T> PredictCore(Tensor<T> input)
-    {
-        var preprocessed = PreprocessTextImage(input);
-        return _useNativeMode ? Forward(preprocessed) : RunOnnxInference(preprocessed);
-    }
-
-    /// <inheritdoc/>
-    public override Dictionary<string, Tensor<T>> GetNamedLayerActivations(Tensor<T> input)
-    {
-        return new Dictionary<string, Tensor<T>>
-        {
-            ["ABINetOutput"] = PredictCore(input)
-        };
-    }
-
-    /// <inheritdoc/>
-    public override void Train(Tensor<T> input, Tensor<T> expectedOutput)
-    {
-        if (!_useNativeMode)
-            throw new NotSupportedException("Training not supported in ONNX mode.");
-
-        SetTrainingMode(true);
-        try
-        {
-            // The branched forward returns the vision, language and fusion predictions stacked
-            // along axis 0, so the target is repeated three times to line up block-for-block.
-            // ABINetMultiTaskLoss splits both and returns lambda_v * L_v + lambda_l * L_l + L_f.
-            var target = _branched
-                ? Engine.TensorConcatenate(new[] { expectedOutput, expectedOutput, expectedOutput }, axis: 0)
-                : expectedOutput;
-
-            TrainWithTape(
-                PreprocessTextImage(input),
-                target,
-                _optimizer);
-        }
-        finally
-        {
-            SetTrainingMode(false);
-        }
-    }
-
-    // UpdateParameters applied a GRADIENT STEP, but its one-argument form is the value setter and every caller passes values -- the override corrupted the model. Removed under AIDN082.

-
-    /// <summary>
-    /// Parameters cannot be written while the model is backed by a loaded ONNX graph: the weights
-    /// belong to that graph, not to this instance.
-    /// </summary>
-    /// <remarks>
-    /// Replaces a hand-written throw that used to sit inside UpdateParameters. The base checks this
-    /// on every mutating entry point rather than the one member the throw happened to guard, and
-    /// reading -- ParameterCount and GetParameters -- stays available either way.
-    /// </remarks>
+using AiDotNet.Attributes;
+using AiDotNet.Document.Interfaces;
+using AiDotNet.Document.Options;
+using AiDotNet.Enums;
+using AiDotNet.Helpers;
+using AiDotNet.Interfaces;
+using AiDotNet.LinearAlgebra;
+using AiDotNet.LossFunctions;
+using AiDotNet.NeuralNetworks;
+using AiDotNet.NeuralNetworks.Layers;
+using AiDotNet.LearningRateSchedulers;
+using AiDotNet.Optimizers;
+using Microsoft.ML.OnnxRuntime;
+
+namespace AiDotNet.Document.OCR.TextRecognition;
+
+/// <summary>
+/// ABINet (Autonomous, Bidirectional, Iterative Network) for text recognition.
+/// </summary>
+/// <typeparam name="T">The numeric type used for calculations.</typeparam>
+/// <remarks>
+/// <para>
+/// ABINet uses a novel architecture with autonomous vision, bidirectional language modeling,
+/// and iterative correction to achieve robust text recognition.
+/// </para>
+/// <para>
+/// <b>For Beginners:</b> ABINet has three key innovations:
+/// 1. Autonomous vision model (works without external language model)
+/// 2. Bidirectional language model (looks at context from both directions)
+/// 3. Iterative correction (refines predictions multiple times)
+///
+/// Key features:
+/// - Self-contained (no external LM needed)
+/// - Built-in spell correction via language model
+/// - Iterative refinement for accuracy
+/// - Strong on noisy/occluded text
+///
+/// Example usage:
+/// <code>
+/// var model = new ABINet&lt;float&gt;(architecture);
+/// var result = model.RecognizeText(textImage);
+/// // Result is available in the returned value
+/// </code>
+/// </para>
+/// <para>
+/// <b>Reference:</b> "Read Like Humans: Autonomous, Bidirectional and Iterative Language Modeling" (CVPR 2021)
+/// https://arxiv.org/abs/2103.06495
+/// </para>
+/// </remarks>
+[ModelDomain(ModelDomain.Vision)]
+[ModelDomain(ModelDomain.Language)]
+[ModelCategory(ModelCategory.NeuralNetwork)]
+[ModelCategory(ModelCategory.Transformer)]
+[ModelTask(ModelTask.Detection)]
+[ModelComplexity(ModelComplexity.High)]
+[ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
+[ResearchPaper("Read Like Humans: Autonomous, Bidirectional and Iterative Language Modeling for Scene Text Recognition", "https://doi.org/10.48550/arXiv.2103.06495", Year = 2021, Authors = "Shancheng Fang, Hongtao Xie, Yuxin Wang, Zhendong Mao, Yongdong Zhang")]
+public partial class ABINet<T> : DocumentNeuralNetworkBase<T>, ITextRecognizer<T>
+{
+    private readonly ABINetOptions _options;
+
+    /// <inheritdoc/>
+    public override ModelOptions GetOptions() => _options;
+
+    #region Fields
+
+    private readonly bool _useNativeMode;
+    private readonly InferenceSession? _onnxSession;
+    private readonly IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>> _optimizer;
+    private readonly int _visionDim;
+    private readonly int _languageDim;
+    private readonly int _visionLayers;
+    private readonly int _languageLayers;
+    private readonly int _numIterations;
+    private readonly int _imageHeight;
+    private readonly string _charset;
+
+    // Native mode layers. ABINet is a three-branch model (Fang et al., CVPR 2021), not a single
+    // chain: the vision model, the language model and the fusion each emit character
+    // probabilities and each carries its own loss term. These lists hold the branches so the
+    // training forward can supervise all three; every layer in them is also in Layers, so
+    // parameter enumeration, serialization and device transfer are unaffected.
+    private readonly List<ILayer<T>> _visionModelLayers = [];
+    private readonly List<ILayer<T>> _languageModelLayers = [];
+    private readonly List<ILayer<T>> _fusionLayers = [];
+
+    /// <summary>Character head for the vision branch, supervised by L_v.</summary>
+    private readonly List<ILayer<T>> _visionHead = [];
+
+    /// <summary>Character head for the language branch, supervised by L_l.</summary>
+    private readonly List<ILayer<T>> _languageHead = [];
+
+    private int[]? _branchCounts;
+
+    /// <summary>
+    /// True when this instance built the paper's three-branch stack. False when the caller
+    /// supplied a flat <c>Architecture.Layers</c> chain, which has no branch structure to
+    /// supervise separately.
+    /// </summary>
+    private bool _branched;
+
+    // Learnable embeddings
+
+    #endregion
+
+    #region Properties
+
+    /// <inheritdoc/>
+    public override DocumentType SupportedDocumentTypes => DocumentType.All;
+
+    /// <inheritdoc/>
+    public override bool RequiresOCR => false;
+
+    /// <inheritdoc/>
+    public int ExpectedImageSize => ImageSize;
+
+    /// <inheritdoc/>
+    public string SupportedCharacters => _charset;
+
+    // NO CONTRACT YET, and the sweep is why. The class count IS charset+1 - that half was right - but
+    // the STEP count is not MaxSequenceLength: the contract said [1,26,96] and Predict returned
+    // [1,256,96]. The [MaxSequenceLength, charset+1] tensor this class builds is a FALLBACK path; the
+    // real forward decodes 256 steps from the vision backbone, and 26 is just the configured maximum.
+    // Stating the family law here would assert a step count the model does not use, so this declines
+    // until the 256 is traced to whatever produces it. CRNN, whose CTC head really does emit
+    // MaxSequenceLength steps, agrees with the family law and keeps its contract.
+
+    /// <inheritdoc/>
+    public new int MaxSequenceLength => base.MaxSequenceLength;
+
+    /// <inheritdoc/>
+    public bool SupportsAttentionVisualization => true;
+
+    /// <summary>
+    /// Gets the number of iterative refinement steps.
+    /// </summary>
+    public int NumIterations => _numIterations;
+
+    /// <summary>
+    /// Gets the input image height.
+    /// </summary>
+    public int ImageHeight => _imageHeight;
+
+    #endregion
+
+    #region Constructors
+
+    /// <summary>
+    /// Creates an ABINet model using a pre-trained ONNX model for inference.
+    /// </summary>
+    public ABINet(
+        NeuralNetworkArchitecture<T> architecture,
+        string onnxModelPath,
+        int imageWidth = 128,
+        int imageHeight = 32,
+        int maxSequenceLength = 26,
+        int visionDim = 512,
+        int languageDim = 512,
+        int visionLayers = 3,
+        int languageLayers = 4,
+        int numIterations = 3,
+        string? charset = null,
+        IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? optimizer = null,
+        ILossFunction<T>? lossFunction = null,
+        ABINetOptions? options = null)
+        : base(architecture, lossFunction ?? new CrossEntropyWithLogitsLoss<T>(), 1.0)
+    {
+        _options = options ?? new ABINetOptions();
+        Options = _options;
+
+        if (string.IsNullOrWhiteSpace(onnxModelPath))
+            throw new ArgumentNullException(nameof(onnxModelPath));
+        if (!File.Exists(onnxModelPath))
+            throw new FileNotFoundException($"ONNX model not found: {onnxModelPath}", onnxModelPath);
+
+        _useNativeMode = false;
+        _visionDim = visionDim;
+        _languageDim = languageDim;
+        _visionLayers = visionLayers;
+        _languageLayers = languageLayers;
+        _numIterations = numIterations;
+        _imageHeight = imageHeight;
+        _charset = charset ?? GetDefaultCharset();
+        _optimizer = optimizer ?? new AdamOptimizer<T, Tensor<T>, Tensor<T>>(this,
+            new AdamOptimizerOptions<T, Tensor<T>, Tensor<T>>
+            {
+                InitialLearningRate = _options.LearningRate,
+                // "decayed to 1e-5 after 6 epochs" -- a single 10x step at epoch 6.
+                LearningRateScheduler = new MultiStepLRScheduler(
+                    _options.LearningRate, milestones: new[] { 6 }, gamma: 0.1),
+                SchedulerStepMode = SchedulerStepMode.StepPerEpoch
+            });
+
+        ImageSize = imageWidth;
+        base.MaxSequenceLength = maxSequenceLength;
+
+        _onnxSession = new InferenceSession(onnxModelPath);
+
+        InitializeLayers();
+    }
+
+    /// <summary>
+    /// Creates an ABINet model using native layers for training and inference.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// <b>Default Configuration (ABINet from CVPR 2021):</b>
+    /// - Vision Model: ResNet + Transformer
+    /// - Language Model: Bidirectional Transformer
+    /// - Fusion: Iterative refinement
+    /// - 3 correction iterations by default
+    /// </para>
+    /// </remarks>
+    public ABINet(
+        NeuralNetworkArchitecture<T> architecture,
+        int imageWidth = 128,
+        int imageHeight = 32,
+        int maxSequenceLength = 26,
+        int visionDim = 512,
+        int languageDim = 512,
+        int visionLayers = 3,
+        int languageLayers = 4,
+        int numIterations = 3,
+        string? charset = null,
+        IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? optimizer = null,
+        ILossFunction<T>? lossFunction = null,
+        ABINetOptions? options = null,
+        double? visionLossWeight = null,
+        double? languageLossWeight = null)
+        : base(architecture, BuildMultiTaskObjective(lossFunction, options, visionLossWeight, languageLossWeight), 1.0)
+    {
+        _options = options ?? new ABINetOptions();
+        Options = _options;
+
+        // Record the resolved weights so GetOptions() reports what training actually used.
+        if (visionLossWeight.HasValue) _options.VisionLossWeight = visionLossWeight.Value;
+        if (languageLossWeight.HasValue) _options.LanguageLossWeight = languageLossWeight.Value;
+
+        _useNativeMode = true;
+        _visionDim = visionDim;
+        _languageDim = languageDim;
+        _visionLayers = visionLayers;
+        _languageLayers = languageLayers;
+        _numIterations = numIterations;
+        _imageHeight = imageHeight;
+        _charset = charset ?? GetDefaultCharset();
+
+        // Adam at the paper's initial learning rate (Fang et al., CVPR 2021 §4.2: 1e-4, decayed
+        // to 1e-5). Constructing AdamOptimizer with no options left it at the optimizer's own
+        // 1e-3 default, 10x the paper's rate.
+        _optimizer = optimizer ?? new AdamOptimizer<T, Tensor<T>, Tensor<T>>(this,
+            new AdamOptimizerOptions<T, Tensor<T>, Tensor<T>>
+            {
+                InitialLearningRate = _options.LearningRate
+            });
+
+        ImageSize = imageWidth;
+        base.MaxSequenceLength = maxSequenceLength;
+
+        InitializeLayers();
+        InitializeEmbeddings();
+    }
+
+    /// <summary>
+    /// Builds ABINet's training objective: the paper's weighted sum of the vision, language and
+    /// fusion character losses (Fang et al., CVPR 2021, Eq. 5).
+    /// </summary>
+    /// <remarks>
+    /// A caller-supplied loss becomes the per-branch character loss rather than replacing the
+    /// multi-task structure, so overriding the loss still trains all three branches. A loss that
+    /// is not a <see cref="LossFunctionBase{T}"/> cannot expose the tape entry point the sum
+    /// needs, so it is used as-is and only the fused output is graded.
+    /// </remarks>
+    private static ILossFunction<T> BuildMultiTaskObjective(
+        ILossFunction<T>? lossFunction,
+        ABINetOptions? options,
+        double? visionLossWeight,
+        double? languageLossWeight)
+    {
+        var characterLoss = lossFunction ?? new CrossEntropyWithLogitsLoss<T>();
+        if (characterLoss is not LossFunctionBase<T> tapeCapable)
+            return characterLoss;
+
+        var resolved = options ?? new ABINetOptions();
+        return new ABINetMultiTaskLoss<T>(
+            tapeCapable,
+            visionLossWeight ?? resolved.VisionLossWeight,
+            languageLossWeight ?? resolved.LanguageLossWeight);
+    }
+
+    private static string GetDefaultCharset()
+    {
+        return "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ ";
+    }
+
+    #endregion
+
+    #region Initialization
+
+    /// <inheritdoc/>
+    protected override void InitializeLayers()
+    {
+        if (!_useNativeMode)
+        {
+            return;
+        }
+
+        if (Architecture.Layers is not null && Architecture.Layers.Count > 0)
+        {
+            Layers.AddRange(Architecture.Layers);
+            ValidateCustomLayers(Layers);
+            return;
+        }
+
+        // Build the paper's three branches separately so each can be supervised by its own loss
+        // term. Chained in this order for inference, they reproduce exactly the flat stack this
+        // used to create.
+        int charsetSize = _charset.Length + 1;
+
+        _visionModelLayers.AddRange(LayerHelper<T>.CreateDefaultABINetVisionLayers(
+            imageWidth: ImageSize,
+            imageHeight: _imageHeight,
+            visionDim: _visionDim));
+
+        _languageModelLayers.AddRange(LayerHelper<T>.CreateDefaultABINetLanguageLayers(
+            charsetSize: charsetSize,
+            visionDim: _visionDim,
+            languageDim: _languageDim));
+
+        _fusionLayers.AddRange(LayerHelper<T>.CreateDefaultABINetFusionLayers(
+            visionDim: _visionDim,
+            numIterations: _numIterations,
+            charsetSize: charsetSize));
+
+        _visionHead.Add(LayerHelper<T>.CreateDefaultABINetBranchHead(charsetSize));
+        _languageHead.Add(LayerHelper<T>.CreateDefaultABINetBranchHead(charsetSize));
+
+        ResolveBranchShapes();
+
+        // Everything goes into Layers so parameter enumeration, serialization and device
+        // transfer see every weight. The two branch heads are appended last and are NOT part of
+        // the inference chain; Forward walks the three branches explicitly.
+        Layers.AddRange(_visionModelLayers);
+        Layers.AddRange(_languageModelLayers);
+        Layers.AddRange(_fusionLayers);
+        Layers.AddRange(_visionHead);
+        Layers.AddRange(_languageHead);
+
+        // Deserialization refills Layers with new objects; record the branch extents so
+        // RebindBranchLayers can re-point these lists at the restored ones.
+        _branchCounts = new[]
+        {
+            _visionModelLayers.Count, _languageModelLayers.Count, _fusionLayers.Count,
+            _visionHead.Count, _languageHead.Count
+        };
+
+        _branched = true;
+    }
+
+    /// <summary>
+    /// Resolves each branch's lazy layers, carrying the shape across the two forks.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// The character heads hang off the vision and language trunks rather than sitting in the
+    /// inference chain, so nothing else would ever size them: a deserialized model never runs
+    /// them, they would report a <c>ParameterCount</c> of 0, and <c>SetParameters</c> would then
+    /// hand every following layer the wrong slice of the flat parameter vector.
+    /// </para>
+    /// <para>
+    /// <see cref="LayerHelper{T}.ResolveChain"/> derives every layer's input from the previous
+    /// layer's actual <c>GetOutputShape()</c> and returns the shape leaving the branch, so the
+    /// fork points get real shapes instead of hand-written ones. Sizing the heads from a
+    /// hand-written <c>[1, 1, visionDim]</c> instead produced weights the forward never matched.
+    /// Each layer is skipped once resolved, so this is a no-op on an already-run model.
+    /// </para>
+    /// </remarks>
+    private void ResolveBranchShapes()
+    {
+        var rootShape = Architecture.GetInputShape();
+        if (rootShape is null || rootShape.Length == 0) return;
+
+        // KNOWN LIMITATION: resolution currently stops inside the vision trunk, at the
+        // ReshapeLayer between the convolutions and the transformer. The convolution layers
+        // report GetOutputShape() WITHOUT a batch axis ([512, 8, 32]), while
+        // ReshapeLayer.ResolveFromShape treats the leading axis as batch — so it reads that as
+        // 512 samples of 256 elements against its 131072-element target and rejects it. Chain
+        // resolution stops at the first such failure by design, leaving the rest of the stack
+        // lazy. Adding a batch axis to the root does not help: the convolutions report
+        // per-sample shapes regardless of what they were resolved from.
+        //
+        // Consequence: a freshly built ABINet reports 1,718,624 parameters where one that has
+        // run a forward reports 4,281,376, so restoring a trained parameter vector into a fresh
+        // clone misaligns (Clone_AfterTraining_ShouldPreserveLearnedWeights). The layers that DO
+        // resolve here still benefit, and everything else resolves on first forward as before.
+        //
+        // The real fix is to make the two conventions agree — either the convolutions report a
+        // batched output shape or ReshapeLayer accepts a per-sample one — which is a framework
+        // change affecting every model that chains a convolution into a reshape, not something
+        // to settle inside ABINet.
+
+        // Vision trunk -> vision head (character logits) -> language model -> language head.
+        // The language model is rooted at the HEAD's output, not the trunk's, because it
+        // consumes character probabilities.
+        var visionOut = LayerHelper<T>.ResolveChain(_visionModelLayers, rootShape);
+        var visionLogitsShape = LayerHelper<T>.ResolveChain(_visionHead, visionOut);
+
+        var languageOut = LayerHelper<T>.ResolveChain(_languageModelLayers, visionLogitsShape);
+        LayerHelper<T>.ResolveChain(_languageHead, languageOut);
+
+        // The fusion gate is rooted at [F_v, F_l] concatenated on the feature axis, so its
+        // input is the vision width doubled.
+        var fusionRoot = (int[])visionOut.Clone();
+        fusionRoot[fusionRoot.Length - 1] = visionOut[visionOut.Length - 1] + languageOut[languageOut.Length - 1];
+        LayerHelper<T>.ResolveChain(_fusionLayers, fusionRoot);
+    }
+
+    private void InitializeEmbeddings()
+    {
+        var random = RandomHelper.CreateSeededRandom(42);
+    }
+
+    private void InitializeWithSmallRandomValues(Tensor<T> tensor, Random random, double stdDev)
+    {
+        for (int i = 0; i < tensor.Data.Length; i++)
+        {
+            double u1 = 1.0 - random.NextDouble();
+            double u2 = 1.0 - random.NextDouble();
+            double randStdNormal = Math.Sqrt(-2.0 * Math.Log(u1)) * Math.Sin(2.0 * Math.PI * u2);
+            tensor.Data.Span[i] = NumOps.FromDouble(randStdNormal * stdDev);
+        }
+    }
+
+    #endregion
+
+    #region ITextRecognizer Implementation
+
+    /// <inheritdoc/>
+    public TextRecognitionResult<T> RecognizeText(Tensor<T> croppedImage)
+    {
+        var startTime = DateTime.UtcNow;
+
+        var preprocessed = PreprocessTextImage(croppedImage);
+        var output = _useNativeMode ? Forward(preprocessed) : RunOnnxInference(preprocessed);
+
+        var (text, confidence) = Decode(output);
+
+        return new TextRecognitionResult<T>
+        {
+            Text = text,
+            Confidence = NumOps.FromDouble(confidence),
+            ConfidenceValue = confidence,
+            Characters = GetCharacterConfidences(output, text),
+            ProcessingTimeMs = (DateTime.UtcNow - startTime).TotalMilliseconds
+        };
+    }
+
+    /// <inheritdoc/>
+    public IEnumerable<TextRecognitionResult<T>> RecognizeTextBatch(IEnumerable<Tensor<T>> croppedImages)
+    {
+        foreach (var image in croppedImages)
+            yield return RecognizeText(image);
+    }
+
+    /// <inheritdoc/>
+    public Tensor<T> GetCharacterProbabilities()
+    {
+        return Tensor<T>.CreateDefault([MaxSequenceLength, _charset.Length + 1], NumOps.Zero);
+    }
+
+    /// <inheritdoc/>
+    public Tensor<T>? GetAttentionWeights()
+    {
+        return Tensor<T>.CreateDefault([MaxSequenceLength, MaxSequenceLength], NumOps.Zero);
+    }
+
+    private (string text, double confidence) Decode(Tensor<T> output)
+    {
+        var chars = new List<char>();
+        double totalConf = 0;
+        int validSteps = 0;
+
+        int seqLen = Math.Min(output.Shape[0], MaxSequenceLength);
+        int vocabSize = output.Shape.Length > 1 ? output.Shape[1] : _charset.Length + 1;
+
+        for (int t = 0; t < seqLen; t++)
+        {
+            double maxVal = double.MinValue;
+            int maxIdx = 0;
+            for (int c = 0; c < vocabSize; c++)
+            {
+                double val = NumOps.ToDouble(output[t, c]);
+                if (val > maxVal) { maxVal = val; maxIdx = c; }
+            }
+
+            if (maxIdx == 0) break; // EOS
+            if (maxIdx - 1 < _charset.Length)
+            {
+                chars.Add(_charset[maxIdx - 1]);
+                totalConf += maxVal;
+                validSteps++;
+            }
+        }
+
+        string text = new string([.. chars]);
+        double avgConf = validSteps > 0 ? totalConf / validSteps : 0;
+
+        return (text, avgConf);
+    }
+
+    private List<CharacterRecognition<T>> GetCharacterConfidences(Tensor<T> output, string text)
+    {
+        var result = new List<CharacterRecognition<T>>();
+        for (int i = 0; i < text.Length; i++)
+        {
+            result.Add(new CharacterRecognition<T>
+            {
+                Character = text[i],
+                Confidence = NumOps.FromDouble(0.92),
+                ConfidenceValue = 0.92,
+                Position = i
+            });
+        }
+        return result;
+    }
+
+    private Tensor<T> PreprocessTextImage(Tensor<T> image)
+    {
+        var processed = EnsureBatchDimension(image);
+        if (processed.Shape[2] != _imageHeight || processed.Shape[3] != ImageSize)
+        {
+            processed = Engine.Interpolate(
+                processed,
+                [_imageHeight, ImageSize],
+                InterpolateMode.Bilinear,
+                alignCorners: false);
+        }
+
+        var normalized = new Tensor<T>(processed._shape);
+
+        for (int i = 0; i < processed.Data.Length; i++)
+        {
+            double val = NumOps.ToDouble(processed.Data.Span[i]);
+            normalized.Data.Span[i] = NumOps.FromDouble((val / 255.0 - 0.5) / 0.5);
+        }
+
+        return normalized;
+    }
+
+    #endregion
+
+    #region IDocumentModel Implementation
+
+    /// <inheritdoc/>
+    public Tensor<T> EncodeDocument(Tensor<T> documentImage)
+    {
+        var preprocessed = PreprocessTextImage(documentImage);
+        return _useNativeMode ? Forward(preprocessed) : RunOnnxInference(preprocessed);
+    }
+
+    /// <inheritdoc/>
+    public void ValidateInputShape(Tensor<T> documentImage)
+    {
+        ValidateImageShape(documentImage);
+    }
+
+    /// <inheritdoc/>
+    public string GetModelSummary()
+    {
+        var sb = new System.Text.StringBuilder();
+        sb.AppendLine("ABINet Model Summary");
+        sb.AppendLine("====================");
+        sb.AppendLine($"Mode: {(_useNativeMode ? "Native (Trainable)" : "ONNX (Inference)")}");
+        sb.AppendLine($"Architecture: Vision + Language + Iterative Fusion");
+        sb.AppendLine($"Vision Dimension: {_visionDim}");
+        sb.AppendLine($"Language Dimension: {_languageDim}");
+        sb.AppendLine($"Vision Layers: {_visionLayers}");
+        sb.AppendLine($"Language Layers: {_languageLayers}");
+        sb.AppendLine($"Iterations: {_numIterations}");
+        sb.AppendLine($"Image Size: {ImageSize}x{_imageHeight}");
+        sb.AppendLine($"Max Sequence Length: {MaxSequenceLength}");
+        sb.AppendLine($"Charset Size: {_charset.Length}");
+        sb.AppendLine($"Total Layers: {Layers.Count}");
+        return sb.ToString();
+    }
+
+    #endregion
+
+    #region Preprocessing
+
+    /// <summary>
+    /// Applies ABINet's industry-standard preprocessing: text image preprocessing.
+    /// </summary>
+    /// <remarks>
+    /// ABINet (Attention-Based Implicit Network) uses text-specific preprocessing
+    /// with grayscale conversion and height normalization.
+    /// </remarks>
+    protected override Tensor<T> ApplyDefaultPreprocessing(Tensor<T> rawImage) => PreprocessTextImage(rawImage);
+
+    /// <summary>
+    /// Applies ABINet's industry-standard postprocessing: pass-through (language model outputs are already final).
+    /// </summary>
+    protected override Tensor<T> ApplyDefaultPostprocessing(Tensor<T> modelOutput) => modelOutput;
+
+    #endregion
+
+    #region Serialization
+
+    /// <inheritdoc/>
+    public override ModelMetadata<T> GetModelMetadata()
+    {
+        return new ModelMetadata<T>
+        {
+            Name = "ABINet",
+            Description = "ABINet for robust text recognition (CVPR 2021)",
+            FeatureCount = _visionDim,
+            Complexity = _visionLayers + _languageLayers,
+            AdditionalInfo = new Dictionary<string, object>
+            {
+                { "vision_dim", _visionDim },
+                { "language_dim", _languageDim },
+                { "vision_layers", _visionLayers },
+                { "language_layers", _languageLayers },
+                { "num_iterations", _numIterations },
+                { "image_height", _imageHeight },
+                { "image_width", ImageSize },
+                { "charset_size", _charset.Length },
+                { "use_native_mode", _useNativeMode }
+            },
+            ModelData = SafeSerialize()
+        };
+    }
+
+    /// <inheritdoc/>
+
+
+    /// <inheritdoc/>
+    /// <summary>
+    /// Re-points the branch lists at the layers deserialization just rebuilt.
+    /// </summary>
+    /// <remarks>
+    /// Every branch is appended to <c>Layers</c>, so the weights round-trip correctly, but the
+    /// forward pass reads these private lists and deserialization never re-points them — they
+    /// still referenced the objects this instance built in its own constructor. The restored
+    /// weights landed in layers the model never evaluated, so a clone predicted from its
+    /// initialisation values while reporting success.
+    /// </remarks>
+    private void RebindBranchLayers()
+    {
+        if (_branchCounts is not { Length: 5 }) return;
+
+        int total = 0;
+        foreach (var count in _branchCounts) total += count;
+        if (total == 0 || Layers.Count < total) return;
+
+        var targets = new[]
+        {
+            _visionModelLayers, _languageModelLayers, _fusionLayers, _visionHead, _languageHead
+        };
+
+        int offset = Layers.Count - total;
+        for (int b = 0; b < targets.Length; b++)
+        {
+            targets[b].Clear();
+            for (int i = 0; i < _branchCounts[b]; i++) targets[b].Add(Layers[offset + i]);
+            offset += _branchCounts[b];
+        }
+    }
+
+
+
+    #endregion
+
+    #region NeuralNetworkBase Implementation
+
+    /// <summary>
+    /// Runs ABINet's explicit sequential graph without the document base
+    /// class's inference-only CNN-to-sequence auto-reshape. The default ABINet
+    /// graph contains its own tape-compatible ReshapeLayer so inference and
+    /// training follow the same shape transitions.
+    /// </summary>
+    protected override Tensor<T> Forward(Tensor<T> input)
+    {
+        if (_branched)
+            return ForwardBranches(input).Fusion;
+
+        Tensor<T> output = input;
+        foreach (var layer in Layers)
+            output = layer.Forward(output);
+
+        return output;
+    }
+
+    /// <summary>
+    /// Runs the vision model, then the language model, then the fusion branch, returning all
+    /// three character predictions.
+    /// </summary>
+    /// <remarks>
+    /// The language branch begins with the gradient barrier, so language and fusion gradients
+    /// stop there and never reach the vision encoder — ABINet's AUTONOMOUS principle. The vision
+    /// encoder still learns, from its own <c>Vision</c> prediction's loss term.
+    /// </remarks>
+    private (Tensor<T> Vision, Tensor<T> Language, Tensor<T> Fusion) ForwardBranches(Tensor<T> input)
+    {
+        var visionFeatures = input;
+        foreach (var layer in _visionModelLayers)
+            visionFeatures = layer.Forward(visionFeatures);
+
+        // F_v -> character logits. These ARE the language model's input: the paper's LM is a
+        // spelling corrector over probability vectors, so the branch begins with the gradient
+        // barrier and a softmax rather than reading visual features.
+        var visionLogits = visionFeatures;
+        foreach (var layer in _visionHead)
+            visionLogits = layer.Forward(visionLogits);
+
+        // ITERATIVE correction, the third of the paper's three principles (Fang et al. 2021,
+        // sec. 3.3). The language model is executed M times: the first pass reads the VISION
+        // model's character probabilities, and every later pass reads the FUSION model's
+        // prediction from the previous iteration, so each round corrects the last round's
+        // spelling using bidirectional context. The paper measures M = 3 as the sweet spot and
+        // uses the final iteration's fused prediction as the output.
+        //
+        // Only one pass was run before this, which reduced the model to Autonomous +
+        // Bidirectional and silently dropped the principle the paper is named for. The iteration
+        // count was already threaded in as _numIterations and consumed only when constructing
+        // the language branch; nothing ever looped.
+        //
+        // Nothing carries across calls: every input restarts from its own vision prediction,
+        // matching the paper's "each new text instance starts fresh".
+        var languageInput = visionLogits;
+        Tensor<T> languageLogits = visionLogits;
+        Tensor<T> fused = visionFeatures;
+
+        int iterations = _numIterations > 0 ? _numIterations : 1;
+        for (int iteration = 0; iteration < iterations; iteration++)
+        {
+            var languageFeatures = languageInput;
+            foreach (var layer in _languageModelLayers)
+                languageFeatures = layer.Forward(languageFeatures);
+
+            languageLogits = languageFeatures;
+            foreach (var layer in _languageHead)
+                languageLogits = layer.Forward(languageLogits);
+
+            // Gated fusion consumes BOTH streams: G = sigmoid([F_v, F_l] W_f),
+            // F_f = G * F_v + (1 - G) * F_l. The gate layer takes them concatenated.
+            fused = Engine.TensorConcatenate(
+                new[] { visionFeatures, languageFeatures },
+                axis: visionFeatures.Shape.Length - 1);
+            foreach (var layer in _fusionLayers)
+                fused = layer.Forward(fused);
+
+            // The next round corrects this round's fused prediction.
+            languageInput = fused;
+        }
+
+        return (visionLogits, languageLogits, fused);
+    }
+
+    /// <summary>
+    /// Emits all three branch predictions stacked along axis 0 so the multi-task objective can
+    /// grade each of them.
+    /// </summary>
+    /// <remarks>
+    /// Pairs with <see cref="Train"/>, which repeats the character target three times to match,
+    /// and with <see cref="ABINetMultiTaskLoss{T}"/>, which splits both back into three blocks
+    /// and returns lambda_v * L_v + lambda_l * L_l + L_f.
+    /// </remarks>
+    public override Tensor<T> ForwardForTraining(Tensor<T> input)
+    {
+        if (!_branched)
+            return base.ForwardForTraining(input);
+
+        // Subclasses that bypass the base forward must seed stochastic layers themselves.
+        EnsureLayerRandomSeedsWired();
+
+        var (vision, language, fusion) = ForwardBranches(input);
+        return Engine.TensorConcatenate(new[] { vision, language, fusion }, axis: 0);
+    }
+
+    /// <inheritdoc/>
+    protected override Tensor<T> PredictCore(Tensor<T> input)
+    {
+        var preprocessed = PreprocessTextImage(input);
+        return _useNativeMode ? Forward(preprocessed) : RunOnnxInference(preprocessed);
+    }
+
+    /// <inheritdoc/>
+    public override Dictionary<string, Tensor<T>> GetNamedLayerActivations(Tensor<T> input)
+    {
+        return new Dictionary<string, Tensor<T>>
+        {
+            ["ABINetOutput"] = PredictCore(input)
+        };
+    }
+
+    /// <inheritdoc/>
+    public override void Train(Tensor<T> input, Tensor<T> expectedOutput)
+    {
+        if (!_useNativeMode)
+            throw new NotSupportedException("Training not supported in ONNX mode.");
+
+        SetTrainingMode(true);
+        try
+        {
+            // The branched forward returns the vision, language and fusion predictions stacked
+            // along axis 0, so the target is repeated three times to line up block-for-block.
+            // ABINetMultiTaskLoss splits both and returns lambda_v * L_v + lambda_l * L_l + L_f.
+            var target = _branched
+                ? Engine.TensorConcatenate(new[] { expectedOutput, expectedOutput, expectedOutput }, axis: 0)
+                : expectedOutput;
+
+            TrainWithTape(
+                PreprocessTextImage(input),
+                target,
+                _optimizer);
+        }
+        finally
+        {
+            SetTrainingMode(false);
+        }
+    }
+
+    // UpdateParameters applied a GRADIENT STEP, but its one-argument form is the value setter and every caller passes values -- the override corrupted the model. Removed under AIDN082.
+
+
+    /// <summary>
+    /// Parameters cannot be written while the model is backed by a loaded ONNX graph: the weights
+    /// belong to that graph, not to this instance.
+    /// </summary>
+    /// <remarks>
+    /// Replaces a hand-written throw that used to sit inside UpdateParameters. The base checks this
+    /// on every mutating entry point rather than the one member the throw happened to guard, and
+    /// reading -- ParameterCount and GetParameters -- stays available either way.
+    /// </remarks>
     protected override bool SupportsParameterMutation => _useNativeMode;
-    private Vector<T> CollectGradients()
-    {
-        var grads = new List<T>();
-        foreach (var layer in Layers)
-            grads.AddRange(layer.GetParameterGradients());
-        return new Vector<T>([.. grads]);
-    }
-
-    #endregion
-
-    #region Disposal
-
-    /// <inheritdoc/>
-    protected override void Dispose(bool disposing)
-    {
-        if (disposing)
-            _onnxSession?.Dispose();
-        base.Dispose(disposing);
-    }
-
-    #endregion
-}
+    private Vector<T> CollectGradients()
+    {
+        var grads = new List<T>();
+        foreach (var layer in Layers)
+            grads.AddRange(layer.GetParameterGradients());
+        return new Vector<T>([.. grads]);
+    }
+
+    #endregion
+
+    #region Disposal
+
+    /// <inheritdoc/>
+    protected override void Dispose(bool disposing)
+    {
+        if (disposing)
+            _onnxSession?.Dispose();
+        base.Dispose(disposing);
+    }
+
+    #endregion
+}
diff --git a/src/Document/OCR/TextRecognition/CRNN.cs b/src/Document/OCR/TextRecognition/CRNN.cs
index 0d2022370e..1b9b2c732f 100644
--- a/src/Document/OCR/TextRecognition/CRNN.cs
+++ b/src/Document/OCR/TextRecognition/CRNN.cs
@@ -1,786 +1,666 @@
-using AiDotNet.Attributes;
-using AiDotNet.Document.Interfaces;
-using AiDotNet.Document.Options;
-using AiDotNet.Enums;
-using AiDotNet.Helpers;
-using AiDotNet.Interfaces;
-using AiDotNet.LinearAlgebra;
-using AiDotNet.LossFunctions;
-using AiDotNet.NeuralNetworks;
-using AiDotNet.NeuralNetworks.Layers;
-using AiDotNet.Optimizers;
-using Microsoft.ML.OnnxRuntime;
-
-namespace AiDotNet.Document.OCR.TextRecognition;
-
-/// <summary>
-/// CRNN (Convolutional Recurrent Neural Network) for sequence-based text recognition.
-/// </summary>
-/// <typeparam name="T">The numeric type used for calculations.</typeparam>
-/// <remarks>
-/// <para>
-/// CRNN combines CNN for image feature extraction with RNN (BiLSTM) for sequence modeling,
-/// trained with CTC loss for variable-length text recognition without explicit character
-/// segmentation.
-/// </para>
-/// <para>
-/// <b>For Beginners:</b> CRNN works by:
-/// 1. CNN extracts visual features from the text image
-/// 2. BiLSTM models the sequence of features
-/// 3. CTC decoding converts outputs to text
-///
-/// Key advantages:
-/// - No need to segment individual characters
-/// - Handles variable-length text
-/// - End-to-end trainable
-/// - Works with horizontal text lines
-///
-/// Example usage:
-/// <code>
-/// var model = new CRNN&lt;float&gt;(architecture);
-/// var result = model.RecognizeText(croppedTextImage);
-/// // Result is available in the returned value
-/// </code>
-/// </para>
-/// <para>
-/// <b>Reference:</b> "An End-to-End Trainable Neural Network for Image-based Sequence Recognition" (TPAMI 2017)
-/// https://arxiv.org/abs/1507.05717
-/// </para>
-/// </remarks>
-[ModelDomain(ModelDomain.Vision)]
-[ModelCategory(ModelCategory.NeuralNetwork)]
-[ModelCategory(ModelCategory.RecurrentNetwork)]
-[ModelCategory(ModelCategory.ConvolutionalNetwork)]
-[ModelTask(ModelTask.Detection)]
-[ModelComplexity(ModelComplexity.Medium)]
-[ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
-[ResearchPaper("An End-to-End Trainable Neural Network for Image-based Sequence Recognition and Its Application to Scene Text Recognition", "https://doi.org/10.48550/arXiv.1507.05717", Year = 2017, Authors = "Baoguang Shi, Xiang Bai, Cong Yao")]
-public partial class CRNN<T> : DocumentNeuralNetworkBase<T>, ITextRecognizer<T>
-{
-    private readonly CRNNOptions _options;
-
-    /// <inheritdoc/>
-    public override ModelOptions GetOptions() => _options;
-
-    #region Fields
-
-    private bool _useNativeMode;
-    private readonly InferenceSession? _onnxSession;
-    private string? _onnxModelPath;
-    private IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>> _optimizer;
-    private int _cnnChannels;
-    private int _rnnHiddenSize;
-    private int _rnnLayers;
-    private string _charset;
-
-    [Scratch]
-    private Tensor<T>? _lastCharacterProbs;
-
-    // Native mode layers
-    private readonly List<ILayer<T>> _cnnLayersList = [];
-    private readonly List<ILayer<T>> _rnnLayersList = [];
-    private readonly List<ILayer<T>> _outputLayersList = [];
-
-    #endregion
-
-    #region Properties
-
-    /// <inheritdoc/>
-    public override DocumentType SupportedDocumentTypes => DocumentType.All;
-
-    /// <inheritdoc/>
-    public override bool RequiresOCR => false; // CRNN is the OCR recognizer     
-
-    /// <inheritdoc/>
-    public int ExpectedImageSize => ImageSize;
-
-    /// <inheritdoc/>
-    public string SupportedCharacters => _charset;
-
-    /// <inheritdoc />
-    /// <remarks>
-    /// Traced: the CTC head builds <c>[MaxSequenceLength, _charset.Length + 1]</c>, the +1 being the
-    /// CTC blank.
-    /// </remarks>
-    protected override int OutputClassCount => _charset.Length + 1;
-
-    /// <inheritdoc/>
-    public new int MaxSequenceLength => base.MaxSequenceLength;
-
-    /// <inheritdoc/>
-    public bool SupportsAttentionVisualization => false;
-
-    /// <summary>
-    /// Gets the input image height expected by the model.
-    /// </summary>
-    public int ImageHeight => 32;
-
-    #endregion
-
-    #region Constructors
-
-    /// <summary>
-    /// Creates a CRNN model using a pre-trained ONNX model for inference.
-    /// </summary>
-    public CRNN(
-        NeuralNetworkArchitecture<T> architecture,
-        string onnxModelPath,
-        int imageWidth = 128,
-        int maxSequenceLength = 32,
-        int cnnChannels = 512,
-        int rnnHiddenSize = 256,
-        int rnnLayers = 2,
-        string? charset = null,
-        IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? optimizer = null,
-        ILossFunction<T>? lossFunction = null,
-        CRNNOptions? options = null)
-        : base(architecture, lossFunction ?? new CrossEntropyWithLogitsLoss<T>(), 1.0)
-    {
-        _options = options ?? new CRNNOptions();
-        Options = _options;
-
-        if (string.IsNullOrWhiteSpace(onnxModelPath))
-            throw new ArgumentNullException(nameof(onnxModelPath));
-        if (!File.Exists(onnxModelPath))
-            throw new FileNotFoundException($"ONNX model not found: {onnxModelPath}", onnxModelPath);
-
-        _useNativeMode = false;
-        _cnnChannels = cnnChannels;
-        _rnnHiddenSize = rnnHiddenSize;
-        _rnnLayers = rnnLayers;
-        _charset = charset ?? GetDefaultCharset();
-        _optimizer = optimizer ?? new AdamOptimizer<T, Tensor<T>, Tensor<T>>(this);
-        _onnxModelPath = onnxModelPath;
-
-        ImageSize = imageWidth;
-        base.MaxSequenceLength = maxSequenceLength;
-
-        _onnxSession = new InferenceSession(onnxModelPath);
-
-        InitializeLayers();
-    }
-
-    /// <summary>
-    /// Creates a CRNN model using native layers for training and inference.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// <b>Default Configuration (CRNN from TPAMI 2017):</b>
-    /// - 7-layer CNN with batch normalization
-    /// - 2-layer BiLSTM with 256 hidden units
-    /// - CTC loss for sequence training
-    /// - Input: 32×W×1 (grayscale) or 32×W×3 (RGB)
-    /// </para>
-    /// </remarks>
-    public CRNN(
-        NeuralNetworkArchitecture<T> architecture,
-        int imageWidth = 128,
-        int maxSequenceLength = 32,
-        int cnnChannels = 512,
-        int rnnHiddenSize = 256,
-        int rnnLayers = 2,
-        string? charset = null,
-        IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? optimizer = null,
-        ILossFunction<T>? lossFunction = null,
-        CRNNOptions? options = null)
-        : base(architecture, lossFunction ?? new CrossEntropyWithLogitsLoss<T>(), 1.0)
-    {
-        _options = options ?? new CRNNOptions();
-        Options = _options;
-
-        _useNativeMode = true;
-        _cnnChannels = cnnChannels;
-        _rnnHiddenSize = rnnHiddenSize;
-        _rnnLayers = rnnLayers;
-        _charset = charset ?? GetDefaultCharset();
-        _optimizer = optimizer ?? new AdamOptimizer<T, Tensor<T>, Tensor<T>>(this);
-        _onnxModelPath = null;
-
-        ImageSize = imageWidth;
-        base.MaxSequenceLength = maxSequenceLength;
-
-        InitializeLayers();
-    }
-
-    private static string GetDefaultCharset()
-    {
-        return "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ ";
-    }
-
-    #endregion
-
-    #region Initialization
-
-    /// <inheritdoc/>
-    protected override void InitializeLayers()
-    {
-        if (!_useNativeMode)
-        {
-            return;
-        }
-
-        if (Architecture.Layers is not null && Architecture.Layers.Count > 0)
-        {
-            Layers.AddRange(Architecture.Layers);
-            ValidateCustomLayers(Layers);
-            return;
-        }
-
-        Layers.AddRange(LayerHelper<T>.CreateDefaultCRNNLayers(
-            imageWidth: ImageSize,
-            imageHeight: ImageHeight,
-            cnnChannels: _cnnChannels,
-            rnnHiddenSize: _rnnHiddenSize,
-            rnnLayers: _rnnLayers,
-            charsetSize: _charset.Length + 1, // +1 for CTC blank
-            inputDepth: Architecture.InputDepth));
-    }
-
-    #endregion
-
-    #region ITextRecognizer Implementation
-
-    /// <inheritdoc/>
-    public TextRecognitionResult<T> RecognizeText(Tensor<T> croppedImage)
-    {
-        var startTime = DateTime.UtcNow;
-
-        var preprocessed = PreprocessTextImage(croppedImage);
-        var output = _useNativeMode
-            ? CanonicalizeCtcLogits(Forward(preprocessed))
-            : CanonicalizeCtcLogits(RunOnnxInference(preprocessed));
-
-        _lastCharacterProbs = output;
-
-        // CTC decoding
-        var (text, confidence, characters) = CTCDecode(output);
-
-        return new TextRecognitionResult<T>
-        {
-            Text = text,
-            Confidence = NumOps.FromDouble(confidence),
-            ConfidenceValue = confidence,
-            Characters = characters,
-            ProcessingTimeMs = (DateTime.UtcNow - startTime).TotalMilliseconds
-        };
-    }
-
-    /// <inheritdoc/>
-    public IEnumerable<TextRecognitionResult<T>> RecognizeTextBatch(IEnumerable<Tensor<T>> croppedImages)
-    {
-        foreach (var image in croppedImages)
-            yield return RecognizeText(image);
-    }
-
-    /// <inheritdoc/>
-    public Tensor<T> GetCharacterProbabilities()
-    {
-        return _lastCharacterProbs ?? Tensor<T>.CreateDefault([MaxSequenceLength, _charset.Length + 1], NumOps.Zero);
-    }
-
-    /// <inheritdoc/>
-    public Tensor<T>? GetAttentionWeights()
-    {
-        return null; // CRNN doesn't use attention
-    }
-
-    private (string text, double confidence, List<CharacterRecognition<T>> characters) CTCDecode(Tensor<T> output)
-    {
-        var chars = new List<char>();
-        var characterResults = new List<CharacterRecognition<T>>();
-        double totalConf = 0;
-        int validSteps = 0;
-        int prevIdx = -1;
-
-        var (seqLen, vocabSize, logitAt) = ResolveCtcOutput(output);
-
-        for (int t = 0; t < seqLen; t++)
-        {
-            double maxLogit = double.MinValue;
-            int maxIdx = 0;
-            for (int c = 0; c < vocabSize; c++)
-            {
-                double logit = logitAt(t, c);
-                if (logit > maxLogit) { maxLogit = logit; maxIdx = c; }
-            }
-
-            double sumExp = 0;
-            for (int c = 0; c < vocabSize; c++)
-            {
-                double logit = logitAt(t, c);
-                sumExp += Math.Exp(logit - maxLogit);
-            }
-
-            double prob = sumExp > 0 ? 1.0 / sumExp : 0.0;
-
-            // Skip blank (index 0) and repeated characters
-            if (maxIdx != 0 && maxIdx != prevIdx)
-            {
-                if (maxIdx - 1 < _charset.Length)
-                {
-                    char ch = _charset[maxIdx - 1];
-                    chars.Add(ch);
-                    characterResults.Add(new CharacterRecognition<T>
-                    {
-                        Character = ch,
-                        Confidence = NumOps.FromDouble(prob),
-                        ConfidenceValue = prob,
-                        Position = chars.Count - 1
-                    });
-                    totalConf += prob;
-                    validSteps++;
-                }
-            }
-            prevIdx = maxIdx;
-        }
-
-        string text = new string([.. chars]);
-        double avgConf = validSteps > 0 ? totalConf / validSteps : 0;
-
-        return (text, avgConf, characterResults);
-    }
-
-    private Tensor<T> PreprocessTextImage(Tensor<T> image)
-    {
-        var processed = EnsureBatchDimension(image);
-
-        // CRNN has a fixed-height image contract: every crop is resized to
-        // [ImageHeight, ImageSize] before the CNN (Shi et al., 2017). The old
-        // implementation only normalized, allowing the source instance's lazy
-        // convolution geometry to adapt to an arbitrary caller size while a
-        // fresh clone rebuilt from the configured dimensions. That changed the
-        // spatial token count across Clone (e.g. 18,816 vs 1,536 outputs).
-        // Nearest-neighbor sampling is deterministic and sufficient here; a
-        // caller that wants higher-quality interpolation can install the public
-        // preprocessing transformer.
-        int batchSize = processed.Shape[0];
-        int channels = processed.Shape[1];
-        int sourceHeight = processed.Shape[2];
-        int sourceWidth = processed.Shape[3];
-        int targetHeight = ImageHeight;
-        int targetWidth = ImageSize;
-
-        var normalized = new Tensor<T>([batchSize, channels, targetHeight, targetWidth]);
-        for (int b = 0; b < batchSize; b++)
-        {
-            for (int c = 0; c < channels; c++)
-            {
-                for (int y = 0; y < targetHeight; y++)
-                {
-                    int sourceY = Math.Min(sourceHeight - 1, y * sourceHeight / targetHeight);
-                    for (int x = 0; x < targetWidth; x++)
-                    {
-                        int sourceX = Math.Min(sourceWidth - 1, x * sourceWidth / targetWidth);
-                        double val = NumOps.ToDouble(processed[b, c, sourceY, sourceX]);
-                        normalized[b, c, y, x] = NumOps.FromDouble((val / 255.0 - 0.5) * 2.0);
-                    }
-                }
-            }
-        }
-
-        return normalized;
-    }
-
-    #endregion
-
-    #region IDocumentModel Implementation
-
-    /// <inheritdoc/>
-    public Tensor<T> EncodeDocument(Tensor<T> documentImage)
-    {
-        var preprocessed = PreprocessTextImage(documentImage);
-        var logits = _useNativeMode ? Forward(preprocessed) : RunOnnxInference(preprocessed);
-        return CanonicalizeCtcLogits(logits);
-    }
-
-    /// <inheritdoc/>
-    public void ValidateInputShape(Tensor<T> documentImage)
-    {
-        ValidateImageShape(documentImage);
-
-        int height = documentImage.Shape[^2];
-        if (height != ImageHeight)
-        {
-            throw new ArgumentException(
-                $"CRNN expects image height {ImageHeight} but got {height}.",
-                nameof(documentImage));
-        }
-
-        int width = documentImage.Shape[^1];
-        if (width <= 0)
-        {
-            throw new ArgumentException("CRNN expects a positive image width.", nameof(documentImage));
-        }
-    }
-
-    private (int timeSteps, int classCount, Func<int, int, double> logitAt) ResolveCtcOutput(Tensor<T> output)
-    {
-        int expectedClasses = _charset.Length + 1;
-
-        if (output.Rank == 2)
-        {
-            int classDim;
-            int timeDim;
-
-            if (output.Shape[1] == expectedClasses)
-            {
-                classDim = 1;
-                timeDim = 0;
-            }
-            else if (output.Shape[0] == expectedClasses)
-            {
-                classDim = 0;
-                timeDim = 1;
-            }
-            else
-            {
-                classDim = 1;
-                timeDim = 0;
-            }
-
-            int timeSteps = output.Shape[timeDim];
-            int classCount = output.Shape[classDim];
-            if (classDim == 1)
-            {
-                return (timeSteps, classCount, (t, c) => NumOps.ToDouble(output[t, c]));
-            }
-
-            return (timeSteps, classCount, (t, c) => NumOps.ToDouble(output[c, t]));
-        }
-
-        if (output.Rank == 3)
-        {
-            int classDim = Array.IndexOf(output._shape, expectedClasses);
-            if (classDim < 0)
-            {
-                classDim = 2;
-            }
-
-            int dimA;
-            int dimB;
-            switch (classDim)
-            {
-                case 0:
-                    dimA = 1;
-                    dimB = 2;
-                    break;
-                case 1:
-                    dimA = 0;
-                    dimB = 2;
-                    break;
-                default:
-                    dimA = 0;
-                    dimB = 1;
-                    break;
-            }
-            int batchDim = output.Shape[dimA] == 1 ? dimA : output.Shape[dimB] == 1 ? dimB : dimA;
-            int timeDim = batchDim == dimA ? dimB : dimA;
-
-            int timeSteps = output.Shape[timeDim];
-            int classCount = output.Shape[classDim];
-            int[] indices = new int[3];
-            indices[batchDim] = 0;
-
-            return (timeSteps, classCount, (t, c) =>
-            {
-                indices[timeDim] = t;
-                indices[classDim] = c;
-                return NumOps.ToDouble(output[indices]);
-            }
-            );
-        }
-
-        throw new ArgumentException("CTC output must be a 2D or 3D tensor.", nameof(output));
-    }
-
-    /// <inheritdoc/>
-    public string GetModelSummary()
-    {
-        var sb = new System.Text.StringBuilder();
-        sb.AppendLine("CRNN Model Summary");
-        sb.AppendLine("==================");
-        sb.AppendLine($"Mode: {(_useNativeMode ? "Native (Trainable)" : "ONNX (Inference)")}");
-        sb.AppendLine($"Architecture: VGG-style CNN + BiLSTM");
-        sb.AppendLine($"CNN Channels: {_cnnChannels}");
-        sb.AppendLine($"RNN Hidden Size: {_rnnHiddenSize}");
-        sb.AppendLine($"RNN Layers: {_rnnLayers}");
-        sb.AppendLine($"Image Height: {ImageHeight}");
-        sb.AppendLine($"Image Width: {ImageSize}");
-        sb.AppendLine($"Max Sequence Length: {MaxSequenceLength}");
-        sb.AppendLine($"Charset Size: {_charset.Length}");
-        sb.AppendLine($"Decoder: CTC (Greedy)");
-        sb.AppendLine($"Total Layers: {Layers.Count}");
-        return sb.ToString();
-    }
-
-    #endregion
-
-    #region Preprocessing
-
-    /// <summary>
-    /// Applies CRNN's industry-standard preprocessing: text image preprocessing.
-    /// </summary>
-    /// <remarks>
-    /// CRNN (Convolutional Recurrent Neural Network) uses text-specific preprocessing
-    /// with grayscale conversion and height normalization to 32px.
-    /// </remarks>
-    protected override Tensor<T> ApplyDefaultPreprocessing(Tensor<T> rawImage)
-    {
-        return PreprocessTextImage(rawImage);
-    }
-
-    /// <summary>
-    /// Applies CRNN's industry-standard postprocessing: pass-through (CTC outputs are already final).
-    /// </summary>
-    protected override Tensor<T> ApplyDefaultPostprocessing(Tensor<T> modelOutput) => modelOutput;
-
-    #endregion
-
-    #region Serialization
-
-    /// <inheritdoc/>
-    public override ModelMetadata<T> GetModelMetadata()
-    {
-        return new ModelMetadata<T>
-        {
-            Name = "CRNN",
-            Description = "CRNN for sequence text recognition (TPAMI 2017)",
-            FeatureCount = _cnnChannels,
-            Complexity = _rnnLayers,
-            AdditionalInfo = new Dictionary<string, object>
-            {
-                { "cnn_channels", _cnnChannels },
-                { "rnn_hidden_size", _rnnHiddenSize },
-                { "rnn_layers", _rnnLayers },
-                { "charset_size", _charset.Length },
-                { "image_height", ImageHeight },
-                { "image_width", ImageSize },
-                { "use_native_mode", _useNativeMode }
-            },
-            ModelData = SafeSerialize()
-        };
-    }
-
-    /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_cnnChannels);
-        writer.Write(_rnnHiddenSize);
-        writer.Write(_rnnLayers);
-        writer.Write(ImageSize);
-        writer.Write(MaxSequenceLength);
-        writer.Write(_charset);
-        writer.Write(_useNativeMode);
-        writer.Write(_onnxModelPath ?? string.Empty);
-    }
-
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        int cnnChannels = reader.ReadInt32();
-        int rnnHiddenSize = reader.ReadInt32();
-        int rnnLayers = reader.ReadInt32();
-        int imageSize = reader.ReadInt32();
-        int maxSeqLen = reader.ReadInt32();
-        string charset = reader.ReadString();
-        bool useNativeMode = reader.ReadBoolean();
-        string? onnxModelPath = null;
-        if (reader.BaseStream.Position < reader.BaseStream.Length)
-        {
-            onnxModelPath = reader.ReadString();
-        }
-
-        _cnnChannels = cnnChannels;
-        _rnnHiddenSize = rnnHiddenSize;
-        _rnnLayers = rnnLayers;
-        _charset = charset;
-        _useNativeMode = useNativeMode;
-        _onnxModelPath = string.IsNullOrWhiteSpace(onnxModelPath) ? null : onnxModelPath;
-
-        ImageSize = imageSize;
-        base.MaxSequenceLength = maxSeqLen;
-
-        // Native-mode layers (with their trained weights) are already reconstructed by
-        // the base DeserializeInternalUnchecked before this override runs, so do NOT
-        // clear + re-initialize them here — that would discard the deserialized weights
-        // and leave the model randomly initialized. (In ONNX mode InitializeLayers is a
-        // no-op, so dropping the call changes nothing there.)
-    }
-
-    /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode)
-        {
-            string onnxModelPath = _onnxModelPath ?? throw new InvalidOperationException(
-                "Missing ONNX model path required to clone CRNN instance.");
-            if (string.IsNullOrWhiteSpace(onnxModelPath))
-            {
-                throw new InvalidOperationException(
-                    "Missing ONNX model path required to clone CRNN instance.");
-            }
-
-            return new CRNN<T>(
-                Architecture,
-                onnxModelPath,
-                ImageSize,
-                MaxSequenceLength,
-                _cnnChannels,
-                _rnnHiddenSize,
-                _rnnLayers,
-                _charset,
-                optimizer: null,
-                lossFunction: LossFunction);
-        }
-
-        return new CRNN<T>(
-            Architecture,
-            ImageSize,
-            MaxSequenceLength,
-            _cnnChannels,
-            _rnnHiddenSize,
-            _rnnLayers,
-            _charset,
-            optimizer: null,
-            lossFunction: LossFunction);
-    }
-
-    /// <inheritdoc/>
-    /// <remarks>
-    /// CRNN's convolutional and dense layers resolve their parameter shapes on
-    /// the first image forward. Recreate that resolved state before copying so
-    /// a clone cannot silently retain freshly initialized lazy weights.
-    /// </remarks>
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy()
-    {
-        var copy = (CRNN<T>)CreateNewInstance();
-        if (copy.Layers.Count != Layers.Count)
-            throw new InvalidOperationException("CRNN clone layer topology does not match the source model.");
-
-        for (int i = 0; i < Layers.Count; i++)
-        {
-            var source = Layers[i];
-            var destination = copy.Layers[i];
-            int[] inputShape = source.GetInputShape();
-            if (destination is LayerBase<T> destinationBase &&
-                !destinationBase.IsShapeResolved &&
-                inputShape.Length > 0 &&
-                Array.TrueForAll(inputShape, dimension => dimension > 0))
-            {
-                destinationBase.ResolveFromShape(inputShape);
-            }
-
-            destination.SetParameters(source.GetParameters());
-            if (source is ILayerSerializationExtras<T> sourceExtras &&
-                destination is ILayerSerializationExtras<T> destinationExtras)
-            {
-                destinationExtras.SetExtraParameters(sourceExtras.GetExtraParameters());
-            }
-        }
-
-        copy.SetTrainingMode(false);
-        return copy;
-    }
-
-    #endregion
-
-    #region NeuralNetworkBase Implementation
-
-    /// <inheritdoc/>
-    protected override Tensor<T> PredictCore(Tensor<T> input)
-    {
-        var preprocessed = PreprocessTextImage(input);
-        var logits = _useNativeMode ? Forward(preprocessed) : RunOnnxInference(preprocessed);
-        return CanonicalizeCtcLogits(logits);
-    }
-
-    /// <inheritdoc/>
-    public override Tensor<T> ForwardForTraining(Tensor<T> input) =>
-        CanonicalizeCtcLogits(Forward(input));
-
-    /// <summary>
-    /// Converts the CNN/recurrent head's spatial logits to the public CTC contract
-    /// [batch, time, classes], pooling deterministically to MaxSequenceLength.
-    /// </summary>
-    private Tensor<T> CanonicalizeCtcLogits(Tensor<T> logits)
-    {
-        int classes = _charset.Length + 1;
-        if (logits.Rank == 3 && logits.Shape[^1] == classes &&
-            logits.Shape[1] == MaxSequenceLength)
-            return logits;
-
-        if (logits.Shape[^1] != classes)
-            throw new InvalidOperationException(
-                $"CRNN output must have {classes} classes in its final dimension, but got shape [{string.Join(", ", logits.Shape)}].");
-
-        int batch = logits.Rank >= 3 ? logits.Shape[0] : 1;
-        int positions = logits.Length / checked(batch * classes);
-        var flattened = Engine.Reshape(logits, [batch, positions, classes]);
-        int timeSteps = MaxSequenceLength;
-        if (positions == timeSteps)
-            return flattened;
-
-        if (positions < timeSteps)
-        {
-            int repeats = (timeSteps + positions - 1) / positions;
-            var expanded = Engine.TensorRepeatElements(flattened, repeats, axis: 1);
-            return expanded.Shape[1] == timeSteps
-                ? expanded
-                : Engine.TensorSlice(expanded, [0, 0, 0], [batch, timeSteps, classes]);
-        }
-
-        if (positions % timeSteps != 0)
-            return Engine.TensorSlice(flattened, [0, 0, 0], [batch, timeSteps, classes]);
-
-        int positionsPerStep = positions / timeSteps;
-        var grouped = Engine.Reshape(flattened, [batch, timeSteps, positionsPerStep, classes]);
-        return Engine.ReduceMean(grouped, [2], keepDims: false);
-    }
-
-    /// <inheritdoc/>
-    public override void Train(Tensor<T> input, Tensor<T> expectedOutput)
-    {
-        if (!_useNativeMode)
-            throw new NotSupportedException("Training not supported in ONNX mode.");
-
-        SetTrainingMode(true);
-        try
-        {
-            var preprocessedInput = PreprocessTextImage(input);
-            if (_optimizer is IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>> gradientOptimizer)
-                TrainWithTape(preprocessedInput, expectedOutput, gradientOptimizer);
-            else
-                TrainWithTape(preprocessedInput, expectedOutput, _optimizer);
-        }
-        finally
-        {
-            SetTrainingMode(false);
-        }
-    }
-
-    // UpdateParameters applied a GRADIENT STEP, but its one-argument form is the value setter and every caller passes values -- the override corrupted the model. Removed under AIDN082.

-
-    /// <summary>
-    /// Parameters cannot be written while the model is backed by a loaded ONNX graph: the weights
-    /// belong to that graph, not to this instance.
-    /// </summary>
-    /// <remarks>
-    /// Replaces a hand-written throw that used to sit inside UpdateParameters. The base checks this
-    /// on every mutating entry point rather than the one member the throw happened to guard, and
-    /// reading -- ParameterCount and GetParameters -- stays available either way.
-    /// </remarks>
+using AiDotNet.Attributes;
+using AiDotNet.Document.Interfaces;
+using AiDotNet.Document.Options;
+using AiDotNet.Enums;
+using AiDotNet.Helpers;
+using AiDotNet.Interfaces;
+using AiDotNet.LinearAlgebra;
+using AiDotNet.LossFunctions;
+using AiDotNet.NeuralNetworks;
+using AiDotNet.NeuralNetworks.Layers;
+using AiDotNet.Optimizers;
+using Microsoft.ML.OnnxRuntime;
+
+namespace AiDotNet.Document.OCR.TextRecognition;
+
+/// <summary>
+/// CRNN (Convolutional Recurrent Neural Network) for sequence-based text recognition.
+/// </summary>
+/// <typeparam name="T">The numeric type used for calculations.</typeparam>
+/// <remarks>
+/// <para>
+/// CRNN combines CNN for image feature extraction with RNN (BiLSTM) for sequence modeling,
+/// trained with CTC loss for variable-length text recognition without explicit character
+/// segmentation.
+/// </para>
+/// <para>
+/// <b>For Beginners:</b> CRNN works by:
+/// 1. CNN extracts visual features from the text image
+/// 2. BiLSTM models the sequence of features
+/// 3. CTC decoding converts outputs to text
+///
+/// Key advantages:
+/// - No need to segment individual characters
+/// - Handles variable-length text
+/// - End-to-end trainable
+/// - Works with horizontal text lines
+///
+/// Example usage:
+/// <code>
+/// var model = new CRNN&lt;float&gt;(architecture);
+/// var result = model.RecognizeText(croppedTextImage);
+/// // Result is available in the returned value
+/// </code>
+/// </para>
+/// <para>
+/// <b>Reference:</b> "An End-to-End Trainable Neural Network for Image-based Sequence Recognition" (TPAMI 2017)
+/// https://arxiv.org/abs/1507.05717
+/// </para>
+/// </remarks>
+[ModelDomain(ModelDomain.Vision)]
+[ModelCategory(ModelCategory.NeuralNetwork)]
+[ModelCategory(ModelCategory.RecurrentNetwork)]
+[ModelCategory(ModelCategory.ConvolutionalNetwork)]
+[ModelTask(ModelTask.Detection)]
+[ModelComplexity(ModelComplexity.Medium)]
+[ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
+[ResearchPaper("An End-to-End Trainable Neural Network for Image-based Sequence Recognition and Its Application to Scene Text Recognition", "https://doi.org/10.48550/arXiv.1507.05717", Year = 2017, Authors = "Baoguang Shi, Xiang Bai, Cong Yao")]
+public partial class CRNN<T> : DocumentNeuralNetworkBase<T>, ITextRecognizer<T>
+{
+    private readonly CRNNOptions _options;
+
+    /// <inheritdoc/>
+    public override ModelOptions GetOptions() => _options;
+
+    #region Fields
+
+    private bool _useNativeMode;
+    private readonly InferenceSession? _onnxSession;
+    private string? _onnxModelPath;
+    private IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>> _optimizer;
+    private int _cnnChannels;
+    private int _rnnHiddenSize;
+    private int _rnnLayers;
+    private string _charset;
+
+    [Scratch]
+    private Tensor<T>? _lastCharacterProbs;
+
+    // Native mode layers
+    private readonly List<ILayer<T>> _cnnLayersList = [];
+    private readonly List<ILayer<T>> _rnnLayersList = [];
+    private readonly List<ILayer<T>> _outputLayersList = [];
+
+    #endregion
+
+    #region Properties
+
+    /// <inheritdoc/>
+    public override DocumentType SupportedDocumentTypes => DocumentType.All;
+
+    /// <inheritdoc/>
+    public override bool RequiresOCR => false; // CRNN is the OCR recognizer     
+
+    /// <inheritdoc/>
+    public int ExpectedImageSize => ImageSize;
+
+    /// <inheritdoc/>
+    public string SupportedCharacters => _charset;
+
+    /// <inheritdoc />
+    /// <remarks>
+    /// Traced: the CTC head builds <c>[MaxSequenceLength, _charset.Length + 1]</c>, the +1 being the
+    /// CTC blank.
+    /// </remarks>
+    protected override int OutputClassCount => _charset.Length + 1;
+
+    /// <inheritdoc/>
+    public new int MaxSequenceLength => base.MaxSequenceLength;
+
+    /// <inheritdoc/>
+    public bool SupportsAttentionVisualization => false;
+
+    /// <summary>
+    /// Gets the input image height expected by the model.
+    /// </summary>
+    public int ImageHeight => 32;
+
+    #endregion
+
+    #region Constructors
+
+    /// <summary>
+    /// Creates a CRNN model using a pre-trained ONNX model for inference.
+    /// </summary>
+    public CRNN(
+        NeuralNetworkArchitecture<T> architecture,
+        string onnxModelPath,
+        int imageWidth = 128,
+        int maxSequenceLength = 32,
+        int cnnChannels = 512,
+        int rnnHiddenSize = 256,
+        int rnnLayers = 2,
+        string? charset = null,
+        IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? optimizer = null,
+        ILossFunction<T>? lossFunction = null,
+        CRNNOptions? options = null)
+        : base(architecture, lossFunction ?? new CrossEntropyWithLogitsLoss<T>(), 1.0)
+    {
+        _options = options ?? new CRNNOptions();
+        Options = _options;
+
+        if (string.IsNullOrWhiteSpace(onnxModelPath))
+            throw new ArgumentNullException(nameof(onnxModelPath));
+        if (!File.Exists(onnxModelPath))
+            throw new FileNotFoundException($"ONNX model not found: {onnxModelPath}", onnxModelPath);
+
+        _useNativeMode = false;
+        _cnnChannels = cnnChannels;
+        _rnnHiddenSize = rnnHiddenSize;
+        _rnnLayers = rnnLayers;
+        _charset = charset ?? GetDefaultCharset();
+        _optimizer = optimizer ?? new AdamOptimizer<T, Tensor<T>, Tensor<T>>(this);
+        _onnxModelPath = onnxModelPath;
+
+        ImageSize = imageWidth;
+        base.MaxSequenceLength = maxSequenceLength;
+
+        _onnxSession = new InferenceSession(onnxModelPath);
+
+        InitializeLayers();
+    }
+
+    /// <summary>
+    /// Creates a CRNN model using native layers for training and inference.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// <b>Default Configuration (CRNN from TPAMI 2017):</b>
+    /// - 7-layer CNN with batch normalization
+    /// - 2-layer BiLSTM with 256 hidden units
+    /// - CTC loss for sequence training
+    /// - Input: 32×W×1 (grayscale) or 32×W×3 (RGB)
+    /// </para>
+    /// </remarks>
+    public CRNN(
+        NeuralNetworkArchitecture<T> architecture,
+        int imageWidth = 128,
+        int maxSequenceLength = 32,
+        int cnnChannels = 512,
+        int rnnHiddenSize = 256,
+        int rnnLayers = 2,
+        string? charset = null,
+        IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? optimizer = null,
+        ILossFunction<T>? lossFunction = null,
+        CRNNOptions? options = null)
+        : base(architecture, lossFunction ?? new CrossEntropyWithLogitsLoss<T>(), 1.0)
+    {
+        _options = options ?? new CRNNOptions();
+        Options = _options;
+
+        _useNativeMode = true;
+        _cnnChannels = cnnChannels;
+        _rnnHiddenSize = rnnHiddenSize;
+        _rnnLayers = rnnLayers;
+        _charset = charset ?? GetDefaultCharset();
+        _optimizer = optimizer ?? new AdamOptimizer<T, Tensor<T>, Tensor<T>>(this);
+        _onnxModelPath = null;
+
+        ImageSize = imageWidth;
+        base.MaxSequenceLength = maxSequenceLength;
+
+        InitializeLayers();
+    }
+
+    private static string GetDefaultCharset()
+    {
+        return "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ ";
+    }
+
+    #endregion
+
+    #region Initialization
+
+    /// <inheritdoc/>
+    protected override void InitializeLayers()
+    {
+        if (!_useNativeMode)
+        {
+            return;
+        }
+
+        if (Architecture.Layers is not null && Architecture.Layers.Count > 0)
+        {
+            Layers.AddRange(Architecture.Layers);
+            ValidateCustomLayers(Layers);
+            return;
+        }
+
+        Layers.AddRange(LayerHelper<T>.CreateDefaultCRNNLayers(
+            imageWidth: ImageSize,
+            imageHeight: ImageHeight,
+            cnnChannels: _cnnChannels,
+            rnnHiddenSize: _rnnHiddenSize,
+            rnnLayers: _rnnLayers,
+            charsetSize: _charset.Length + 1, // +1 for CTC blank
+            inputDepth: Architecture.InputDepth));
+    }
+
+    #endregion
+
+    #region ITextRecognizer Implementation
+
+    /// <inheritdoc/>
+    public TextRecognitionResult<T> RecognizeText(Tensor<T> croppedImage)
+    {
+        var startTime = DateTime.UtcNow;
+
+        var preprocessed = PreprocessTextImage(croppedImage);
+        var output = _useNativeMode
+            ? CanonicalizeCtcLogits(Forward(preprocessed))
+            : CanonicalizeCtcLogits(RunOnnxInference(preprocessed));
+
+        _lastCharacterProbs = output;
+
+        // CTC decoding
+        var (text, confidence, characters) = CTCDecode(output);
+
+        return new TextRecognitionResult<T>
+        {
+            Text = text,
+            Confidence = NumOps.FromDouble(confidence),
+            ConfidenceValue = confidence,
+            Characters = characters,
+            ProcessingTimeMs = (DateTime.UtcNow - startTime).TotalMilliseconds
+        };
+    }
+
+    /// <inheritdoc/>
+    public IEnumerable<TextRecognitionResult<T>> RecognizeTextBatch(IEnumerable<Tensor<T>> croppedImages)
+    {
+        foreach (var image in croppedImages)
+            yield return RecognizeText(image);
+    }
+
+    /// <inheritdoc/>
+    public Tensor<T> GetCharacterProbabilities()
+    {
+        return _lastCharacterProbs ?? Tensor<T>.CreateDefault([MaxSequenceLength, _charset.Length + 1], NumOps.Zero);
+    }
+
+    /// <inheritdoc/>
+    public Tensor<T>? GetAttentionWeights()
+    {
+        return null; // CRNN doesn't use attention
+    }
+
+    private (string text, double confidence, List<CharacterRecognition<T>> characters) CTCDecode(Tensor<T> output)
+    {
+        var chars = new List<char>();
+        var characterResults = new List<CharacterRecognition<T>>();
+        double totalConf = 0;
+        int validSteps = 0;
+        int prevIdx = -1;
+
+        var (seqLen, vocabSize, logitAt) = ResolveCtcOutput(output);
+
+        for (int t = 0; t < seqLen; t++)
+        {
+            double maxLogit = double.MinValue;
+            int maxIdx = 0;
+            for (int c = 0; c < vocabSize; c++)
+            {
+                double logit = logitAt(t, c);
+                if (logit > maxLogit) { maxLogit = logit; maxIdx = c; }
+            }
+
+            double sumExp = 0;
+            for (int c = 0; c < vocabSize; c++)
+            {
+                double logit = logitAt(t, c);
+                sumExp += Math.Exp(logit - maxLogit);
+            }
+
+            double prob = sumExp > 0 ? 1.0 / sumExp : 0.0;
+
+            // Skip blank (index 0) and repeated characters
+            if (maxIdx != 0 && maxIdx != prevIdx)
+            {
+                if (maxIdx - 1 < _charset.Length)
+                {
+                    char ch = _charset[maxIdx - 1];
+                    chars.Add(ch);
+                    characterResults.Add(new CharacterRecognition<T>
+                    {
+                        Character = ch,
+                        Confidence = NumOps.FromDouble(prob),
+                        ConfidenceValue = prob,
+                        Position = chars.Count - 1
+                    });
+                    totalConf += prob;
+                    validSteps++;
+                }
+            }
+            prevIdx = maxIdx;
+        }
+
+        string text = new string([.. chars]);
+        double avgConf = validSteps > 0 ? totalConf / validSteps : 0;
+
+        return (text, avgConf, characterResults);
+    }
+
+    private Tensor<T> PreprocessTextImage(Tensor<T> image)
+    {
+        var processed = EnsureBatchDimension(image);
+
+        // CRNN has a fixed-height image contract: every crop is resized to
+        // [ImageHeight, ImageSize] before the CNN (Shi et al., 2017). The old
+        // implementation only normalized, allowing the source instance's lazy
+        // convolution geometry to adapt to an arbitrary caller size while a
+        // fresh clone rebuilt from the configured dimensions. That changed the
+        // spatial token count across Clone (e.g. 18,816 vs 1,536 outputs).
+        // Nearest-neighbor sampling is deterministic and sufficient here; a
+        // caller that wants higher-quality interpolation can install the public
+        // preprocessing transformer.
+        int batchSize = processed.Shape[0];
+        int channels = processed.Shape[1];
+        int sourceHeight = processed.Shape[2];
+        int sourceWidth = processed.Shape[3];
+        int targetHeight = ImageHeight;
+        int targetWidth = ImageSize;
+
+        var normalized = new Tensor<T>([batchSize, channels, targetHeight, targetWidth]);
+        for (int b = 0; b < batchSize; b++)
+        {
+            for (int c = 0; c < channels; c++)
+            {
+                for (int y = 0; y < targetHeight; y++)
+                {
+                    int sourceY = Math.Min(sourceHeight - 1, y * sourceHeight / targetHeight);
+                    for (int x = 0; x < targetWidth; x++)
+                    {
+                        int sourceX = Math.Min(sourceWidth - 1, x * sourceWidth / targetWidth);
+                        double val = NumOps.ToDouble(processed[b, c, sourceY, sourceX]);
+                        normalized[b, c, y, x] = NumOps.FromDouble((val / 255.0 - 0.5) * 2.0);
+                    }
+                }
+            }
+        }
+
+        return normalized;
+    }
+
+    #endregion
+
+    #region IDocumentModel Implementation
+
+    /// <inheritdoc/>
+    public Tensor<T> EncodeDocument(Tensor<T> documentImage)
+    {
+        var preprocessed = PreprocessTextImage(documentImage);
+        var logits = _useNativeMode ? Forward(preprocessed) : RunOnnxInference(preprocessed);
+        return CanonicalizeCtcLogits(logits);
+    }
+
+    /// <inheritdoc/>
+    public void ValidateInputShape(Tensor<T> documentImage)
+    {
+        ValidateImageShape(documentImage);
+
+        int height = documentImage.Shape[^2];
+        if (height != ImageHeight)
+        {
+            throw new ArgumentException(
+                $"CRNN expects image height {ImageHeight} but got {height}.",
+                nameof(documentImage));
+        }
+
+        int width = documentImage.Shape[^1];
+        if (width <= 0)
+        {
+            throw new ArgumentException("CRNN expects a positive image width.", nameof(documentImage));
+        }
+    }
+
+    private (int timeSteps, int classCount, Func<int, int, double> logitAt) ResolveCtcOutput(Tensor<T> output)
+    {
+        int expectedClasses = _charset.Length + 1;
+
+        if (output.Rank == 2)
+        {
+            int classDim;
+            int timeDim;
+
+            if (output.Shape[1] == expectedClasses)
+            {
+                classDim = 1;
+                timeDim = 0;
+            }
+            else if (output.Shape[0] == expectedClasses)
+            {
+                classDim = 0;
+                timeDim = 1;
+            }
+            else
+            {
+                classDim = 1;
+                timeDim = 0;
+            }
+
+            int timeSteps = output.Shape[timeDim];
+            int classCount = output.Shape[classDim];
+            if (classDim == 1)
+            {
+                return (timeSteps, classCount, (t, c) => NumOps.ToDouble(output[t, c]));
+            }
+
+            return (timeSteps, classCount, (t, c) => NumOps.ToDouble(output[c, t]));
+        }
+
+        if (output.Rank == 3)
+        {
+            int classDim = Array.IndexOf(output._shape, expectedClasses);
+            if (classDim < 0)
+            {
+                classDim = 2;
+            }
+
+            int dimA;
+            int dimB;
+            switch (classDim)
+            {
+                case 0:
+                    dimA = 1;
+                    dimB = 2;
+                    break;
+                case 1:
+                    dimA = 0;
+                    dimB = 2;
+                    break;
+                default:
+                    dimA = 0;
+                    dimB = 1;
+                    break;
+            }
+            int batchDim = output.Shape[dimA] == 1 ? dimA : output.Shape[dimB] == 1 ? dimB : dimA;
+            int timeDim = batchDim == dimA ? dimB : dimA;
+
+            int timeSteps = output.Shape[timeDim];
+            int classCount = output.Shape[classDim];
+            int[] indices = new int[3];
+            indices[batchDim] = 0;
+
+            return (timeSteps, classCount, (t, c) =>
+            {
+                indices[timeDim] = t;
+                indices[classDim] = c;
+                return NumOps.ToDouble(output[indices]);
+            }
+            );
+        }
+
+        throw new ArgumentException("CTC output must be a 2D or 3D tensor.", nameof(output));
+    }
+
+    /// <inheritdoc/>
+    public string GetModelSummary()
+    {
+        var sb = new System.Text.StringBuilder();
+        sb.AppendLine("CRNN Model Summary");
+        sb.AppendLine("==================");
+        sb.AppendLine($"Mode: {(_useNativeMode ? "Native (Trainable)" : "ONNX (Inference)")}");
+        sb.AppendLine($"Architecture: VGG-style CNN + BiLSTM");
+        sb.AppendLine($"CNN Channels: {_cnnChannels}");
+        sb.AppendLine($"RNN Hidden Size: {_rnnHiddenSize}");
+        sb.AppendLine($"RNN Layers: {_rnnLayers}");
+        sb.AppendLine($"Image Height: {ImageHeight}");
+        sb.AppendLine($"Image Width: {ImageSize}");
+        sb.AppendLine($"Max Sequence Length: {MaxSequenceLength}");
+        sb.AppendLine($"Charset Size: {_charset.Length}");
+        sb.AppendLine($"Decoder: CTC (Greedy)");
+        sb.AppendLine($"Total Layers: {Layers.Count}");
+        return sb.ToString();
+    }
+
+    #endregion
+
+    #region Preprocessing
+
+    /// <summary>
+    /// Applies CRNN's industry-standard preprocessing: text image preprocessing.
+    /// </summary>
+    /// <remarks>
+    /// CRNN (Convolutional Recurrent Neural Network) uses text-specific preprocessing
+    /// with grayscale conversion and height normalization to 32px.
+    /// </remarks>
+    protected override Tensor<T> ApplyDefaultPreprocessing(Tensor<T> rawImage)
+    {
+        return PreprocessTextImage(rawImage);
+    }
+
+    /// <summary>
+    /// Applies CRNN's industry-standard postprocessing: pass-through (CTC outputs are already final).
+    /// </summary>
+    protected override Tensor<T> ApplyDefaultPostprocessing(Tensor<T> modelOutput) => modelOutput;
+
+    #endregion
+
+    #region Serialization
+
+    /// <inheritdoc/>
+    public override ModelMetadata<T> GetModelMetadata()
+    {
+        return new ModelMetadata<T>
+        {
+            Name = "CRNN",
+            Description = "CRNN for sequence text recognition (TPAMI 2017)",
+            FeatureCount = _cnnChannels,
+            Complexity = _rnnLayers,
+            AdditionalInfo = new Dictionary<string, object>
+            {
+                { "cnn_channels", _cnnChannels },
+                { "rnn_hidden_size", _rnnHiddenSize },
+                { "rnn_layers", _rnnLayers },
+                { "charset_size", _charset.Length },
+                { "image_height", ImageHeight },
+                { "image_width", ImageSize },
+                { "use_native_mode", _useNativeMode }
+            },
+            ModelData = SafeSerialize()
+        };
+    }
+
+    #endregion
+
+    #region NeuralNetworkBase Implementation
+
+    /// <inheritdoc/>
+    protected override Tensor<T> PredictCore(Tensor<T> input)
+    {
+        var preprocessed = PreprocessTextImage(input);
+        var logits = _useNativeMode ? Forward(preprocessed) : RunOnnxInference(preprocessed);
+        return CanonicalizeCtcLogits(logits);
+    }
+
+    /// <inheritdoc/>
+    public override Tensor<T> ForwardForTraining(Tensor<T> input) =>
+        CanonicalizeCtcLogits(Forward(input));
+
+    /// <summary>
+    /// Converts the CNN/recurrent head's spatial logits to the public CTC contract
+    /// [batch, time, classes], pooling deterministically to MaxSequenceLength.
+    /// </summary>
+    private Tensor<T> CanonicalizeCtcLogits(Tensor<T> logits)
+    {
+        int classes = _charset.Length + 1;
+        if (logits.Rank == 3 && logits.Shape[^1] == classes &&
+            logits.Shape[1] == MaxSequenceLength)
+            return logits;
+
+        if (logits.Shape[^1] != classes)
+            throw new InvalidOperationException(
+                $"CRNN output must have {classes} classes in its final dimension, but got shape [{string.Join(", ", logits.Shape)}].");
+
+        int batch = logits.Rank >= 3 ? logits.Shape[0] : 1;
+        int positions = logits.Length / checked(batch * classes);
+        var flattened = Engine.Reshape(logits, [batch, positions, classes]);
+        int timeSteps = MaxSequenceLength;
+        if (positions == timeSteps)
+            return flattened;
+
+        if (positions < timeSteps)
+        {
+            int repeats = (timeSteps + positions - 1) / positions;
+            var expanded = Engine.TensorRepeatElements(flattened, repeats, axis: 1);
+            return expanded.Shape[1] == timeSteps
+                ? expanded
+                : Engine.TensorSlice(expanded, [0, 0, 0], [batch, timeSteps, classes]);
+        }
+
+        if (positions % timeSteps != 0)
+            return Engine.TensorSlice(flattened, [0, 0, 0], [batch, timeSteps, classes]);
+
+        int positionsPerStep = positions / timeSteps;
+        var grouped = Engine.Reshape(flattened, [batch, timeSteps, positionsPerStep, classes]);
+        return Engine.ReduceMean(grouped, [2], keepDims: false);
+    }
+
+    /// <inheritdoc/>
+    public override void Train(Tensor<T> input, Tensor<T> expectedOutput)
+    {
+        if (!_useNativeMode)
+            throw new NotSupportedException("Training not supported in ONNX mode.");
+
+        SetTrainingMode(true);
+        try
+        {
+            var preprocessedInput = PreprocessTextImage(input);
+            if (_optimizer is IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>> gradientOptimizer)
+                TrainWithTape(preprocessedInput, expectedOutput, gradientOptimizer);
+            else
+                TrainWithTape(preprocessedInput, expectedOutput, _optimizer);
+        }
+        finally
+        {
+            SetTrainingMode(false);
+        }
+    }
+
+    // UpdateParameters applied a GRADIENT STEP, but its one-argument form is the value setter and every caller passes values -- the override corrupted the model. Removed under AIDN082.
+
+
+    /// <summary>
+    /// Parameters cannot be written while the model is backed by a loaded ONNX graph: the weights
+    /// belong to that graph, not to this instance.
+    /// </summary>
+    /// <remarks>
+    /// Replaces a hand-written throw that used to sit inside UpdateParameters. The base checks this
+    /// on every mutating entry point rather than the one member the throw happened to guard, and
+    /// reading -- ParameterCount and GetParameters -- stays available either way.
+    /// </remarks>
     protected override bool SupportsParameterMutation => _useNativeMode;
-    #endregion
-
-    #region Disposal
-
-    /// <inheritdoc/>
-    protected override void Dispose(bool disposing)
-    {
-        if (disposing)
-            _onnxSession?.Dispose();
-        base.Dispose(disposing);
-    }
-
-    #endregion
-}
+    #endregion
+
+    #region Disposal
+
+    /// <inheritdoc/>
+    protected override void Dispose(bool disposing)
+    {
+        if (disposing)
+            _onnxSession?.Dispose();
+        base.Dispose(disposing);
+    }
+
+    #endregion
+}
diff --git a/src/Document/OCR/TextRecognition/SVTR.cs b/src/Document/OCR/TextRecognition/SVTR.cs
index 9ce925954f..98d2a2df76 100644
--- a/src/Document/OCR/TextRecognition/SVTR.cs
+++ b/src/Document/OCR/TextRecognition/SVTR.cs
@@ -687,70 +687,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(NetworkDataVersion);
-        writer.Write(_embedDim);
-        writer.Write(_numLayers);
-        writer.Write(_numHeads);
-        writer.Write(_imageHeight);
-        writer.Write(ImageSize);
-        writer.Write(MaxSequenceLength);
-        writer.Write(_charset);
-        writer.Write(_useNativeMode);
-        writer.Write(_options.UseTpsRectification);
-        writer.Write(_options.DropPathRate);
-        writer.Write(_options.TpsInputHeight);
-        writer.Write(_options.TpsInputWidth);
-        writer.Write(_options.TpsControlPointCount);
-        writer.Write(_options.TpsMarginX);
-        writer.Write(_options.TpsMarginY);
-    }
 
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        int version = reader.ReadInt32();
-        if (version != NetworkDataVersion)
-            throw new InvalidDataException(
-                $"Unsupported SVTR network data version {version}; expected {NetworkDataVersion}.");
-
-        int embedDim = reader.ReadInt32();
-        int numLayers = reader.ReadInt32();
-        int numHeads = reader.ReadInt32();
-        int imageHeight = reader.ReadInt32();
-        int imageSize = reader.ReadInt32();
-        int maxSeqLen = reader.ReadInt32();
-        string charset = reader.ReadString();
-        bool useNativeMode = reader.ReadBoolean();
-
-        bool useTpsRectification = reader.ReadBoolean();
-        double dropPathRate = reader.ReadDouble();
-        int tpsInputHeight = reader.ReadInt32();
-        int tpsInputWidth = reader.ReadInt32();
-        int tpsControlPointCount = reader.ReadInt32();
-        double tpsMarginX = reader.ReadDouble();
-        double tpsMarginY = reader.ReadDouble();
-
-        if (embedDim != _embedDim || numLayers != _numLayers || numHeads != _numHeads ||
-            imageHeight != _imageHeight || imageSize != ImageSize || maxSeqLen != MaxSequenceLength ||
-            !string.Equals(charset, _charset, StringComparison.Ordinal) || useNativeMode != _useNativeMode ||
-            useTpsRectification != _options.UseTpsRectification ||
-            dropPathRate != _options.DropPathRate ||
-            tpsInputHeight != _options.TpsInputHeight || tpsInputWidth != _options.TpsInputWidth ||
-            tpsControlPointCount != _options.TpsControlPointCount ||
-            tpsMarginX != _options.TpsMarginX || tpsMarginY != _options.TpsMarginY)
-        {
-            throw new InvalidDataException(
-                "Serialized SVTR configuration does not match the constructed layer topology.");
-        }
-    }
 
     /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new SVTR<T>(Architecture, charset: _charset, options: new SVTROptions(_options));
-    }
+
 
     #endregion
 
diff --git a/src/Document/OCR/TextRecognition/TrOCR.cs b/src/Document/OCR/TextRecognition/TrOCR.cs
index 7b65eebf9c..adabdb32ad 100644
--- a/src/Document/OCR/TextRecognition/TrOCR.cs
+++ b/src/Document/OCR/TextRecognition/TrOCR.cs
@@ -1,868 +1,823 @@
-using AiDotNet.Attributes;
-using AiDotNet.Document.Interfaces;
-using AiDotNet.Document.Options;
-using AiDotNet.Enums;
-using AiDotNet.Helpers;
-using AiDotNet.Interfaces;
-using AiDotNet.LinearAlgebra;
-using AiDotNet.LossFunctions;
-using AiDotNet.NeuralNetworks;
-using AiDotNet.NeuralNetworks.Layers;
-using AiDotNet.Optimizers;
-using AiDotNet.Tokenization;
-using AiDotNet.Tokenization.Interfaces;
-using Microsoft.ML.OnnxRuntime;
-using AiDotNet.Validation;
-
-namespace AiDotNet.Document.OCR.TextRecognition;
-
-/// <summary>
-/// TrOCR (Transformer-based OCR) for text recognition from cropped images.
-/// </summary>
-/// <typeparam name="T">The numeric type used for calculations.</typeparam>
-/// <remarks>
-/// <para>
-/// TrOCR is an end-to-end text recognition model that uses a Vision Transformer (ViT)
-/// encoder and a Transformer decoder (similar to BART/GPT-2) for sequence generation.
-/// </para>
-/// <para>
-/// <b>For Beginners:</b> TrOCR reads text from images. Given a cropped image of text
-/// (like a single word or line), it outputs the actual characters. It works by:
-/// 1. The encoder (ViT) analyzes the image and creates feature representations
-/// 2. The decoder generates text one character at a time, using attention to focus on relevant image regions
-///
-/// Example usage:
-/// <code>
-/// var trocr = new TrOCR&lt;float&gt;(architecture);
-/// var result = trocr.RecognizeText(croppedTextImage);
-/// // Result is available in the returned value
-/// </code>
-/// </para>
-/// <para>
-/// <b>Reference:</b> "TrOCR: Transformer-based Optical Character Recognition with Pre-trained Models" (AAAI 2022)
-/// https://arxiv.org/abs/2109.10282
-/// </para>
-/// </remarks>
-[ModelDomain(ModelDomain.Vision)]
-[ModelDomain(ModelDomain.Language)]
-[ModelCategory(ModelCategory.NeuralNetwork)]
-[ModelCategory(ModelCategory.Transformer)]
-[ModelTask(ModelTask.Detection)]
-[ModelComplexity(ModelComplexity.High)]
-[ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
-[ResearchPaper("TrOCR: Transformer-based Optical Character Recognition with Pre-trained Models", "https://doi.org/10.48550/arXiv.2109.10282", Year = 2022, Authors = "Minghao Li, Tengchao Lv, Jingye Chen, Lei Cui, Yijuan Lu, Dinei Florencio, Cha Zhang, Zhoujun Li, Furu Wei")]
-public partial class TrOCR<T> : DocumentNeuralNetworkBase<T>, ITextRecognizer<T>
-{
-    private readonly TrOCROptions _options;
-
-    /// <inheritdoc/>
-    public override ModelOptions GetOptions() => _options;
-
-    #region Fields
-
-    private readonly bool _useNativeMode;
-    private readonly InferenceSession? _onnxEncoderSession;
-    private readonly InferenceSession? _onnxDecoderSession;
-    private readonly ITokenizer _tokenizer;
-    private readonly IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>> _optimizer;
-    private readonly int _encoderHiddenDim;
-    private readonly int _decoderHiddenDim;
-    private readonly int _numEncoderLayers;
-    private readonly int _numDecoderLayers;
-    private readonly int _numEncoderHeads;
-    private readonly int _numDecoderHeads;
-    private readonly int _patchSize;
-    private readonly int _vocabSize;
-    private readonly int _maxSequenceLength;
-
-    // Native mode layers
-    private readonly List<ILayer<T>> _encoderLayers = [];
-    private readonly List<ILayer<T>> _decoderLayers = [];
-
-    // Learnable embeddings
-    private Tensor<T>? _decoderPositionEmbeddings;
-    private Tensor<T>? _decoderWordEmbeddings;
-
-    // Cached outputs
-    [Scratch]
-    private Tensor<T>? _lastCharacterProbabilities;
-#pragma warning disable CS0649 // Field is never assigned - attention weights are computed but not yet stored
-    [Scratch]
-    private Tensor<T>? _lastAttentionWeights;
-#pragma warning restore CS0649
-
-    #endregion
-
-    #region Properties
-
-    /// <inheritdoc/>
-    public override DocumentType SupportedDocumentTypes => DocumentType.All;
-
-    /// <inheritdoc/>
-    public override bool RequiresOCR => false;
-
-    /// <inheritdoc/>
-    public int ExpectedImageSize => ImageSize;
-
-    /// <inheritdoc/>
-    public string SupportedCharacters { get; }
-
-    /// <inheritdoc/>
-    int ITextRecognizer<T>.MaxSequenceLength => _maxSequenceLength;
-
-    /// <inheritdoc/>
-    public bool SupportsAttentionVisualization => true;
-
-    #endregion
-
-    #region Constructors
-
-    /// <summary>
-    /// Creates a TrOCR model using pre-trained ONNX models for inference.
-    /// </summary>
-    /// <param name="architecture">The neural network architecture.</param>
-    /// <param name="encoderPath">Path to the ONNX encoder model.</param>
-    /// <param name="decoderPath">Path to the ONNX decoder model.</param>
-    /// <param name="tokenizer">Tokenizer for text generation.</param>
-    /// <param name="imageHeight">Input image height (default: 384 for TrOCR-base).</param>
-    /// <param name="imageWidth">Input image width (default: 384).</param>
-    /// <param name="maxSequenceLength">Maximum output sequence length (default: 128).</param>
-    /// <param name="encoderHiddenDim">Encoder hidden dimension (default: 768 for base).</param>
-    /// <param name="decoderHiddenDim">Decoder hidden dimension (default: 768 for base).</param>
-    /// <param name="numEncoderLayers">Number of encoder layers (default: 12).</param>
-    /// <param name="numDecoderLayers">Number of decoder layers (default: 6).</param>
-    /// <param name="numEncoderHeads">Number of encoder attention heads (default: 12).</param>
-    /// <param name="numDecoderHeads">Number of decoder attention heads (default: 12).</param>
-    /// <param name="patchSize">ViT patch size (default: 16).</param>
-    /// <param name="vocabSize">Vocabulary size (default: 50265 for RoBERTa tokenizer).</param>
-    /// <param name="optimizer">Optimizer for training (optional).</param>
-    /// <param name="lossFunction">Loss function (optional).</param>
-    /// <exception cref="ArgumentNullException">Thrown if paths or tokenizer is null.</exception>
-    /// <exception cref="FileNotFoundException">Thrown if ONNX model files don't exist.</exception>
-    public TrOCR(
-        NeuralNetworkArchitecture<T> architecture,
-        string encoderPath,
-        string decoderPath,
-        ITokenizer tokenizer,
-        int imageHeight = 384,
-        int imageWidth = 384,
-        int maxSequenceLength = 128,
-        int encoderHiddenDim = 768,
-        int decoderHiddenDim = 768,
-        int numEncoderLayers = 12,
-        int numDecoderLayers = 6,
-        int numEncoderHeads = 12,
-        int numDecoderHeads = 12,
-        int patchSize = 16,
-        int vocabSize = 50265,
-        IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? optimizer = null,
-        ILossFunction<T>? lossFunction = null,
-        TrOCROptions? options = null)
-        : base(architecture, lossFunction ?? new CrossEntropyWithLogitsLoss<T>(), 1.0)
-    {
-        _options = options ?? new TrOCROptions();
-        Options = _options;
-
-        if (string.IsNullOrWhiteSpace(encoderPath))
-            throw new ArgumentNullException(nameof(encoderPath));
-        if (string.IsNullOrWhiteSpace(decoderPath))
-            throw new ArgumentNullException(nameof(decoderPath));
-        if (!File.Exists(encoderPath))
-            throw new FileNotFoundException($"Encoder model not found: {encoderPath}", encoderPath);
-        if (!File.Exists(decoderPath))
-            throw new FileNotFoundException($"Decoder model not found: {decoderPath}", decoderPath);
-
-        Guard.NotNull(tokenizer);
-        _tokenizer = tokenizer;
-        _useNativeMode = false;
-        _encoderHiddenDim = encoderHiddenDim;
-        _decoderHiddenDim = decoderHiddenDim;
-        _numEncoderLayers = numEncoderLayers;
-        _numDecoderLayers = numDecoderLayers;
-        _numEncoderHeads = numEncoderHeads;
-        _numDecoderHeads = numDecoderHeads;
-        _patchSize = patchSize;
-        _vocabSize = vocabSize;
-        _maxSequenceLength = maxSequenceLength;
-        _optimizer = optimizer ?? new AdamOptimizer<T, Tensor<T>, Tensor<T>>(this,
-            new AdamOptimizerOptions<T, Tensor<T>, Tensor<T>>
-            {
-                InitialLearningRate = _options.LearningRate
-            });
-
-        ImageSize = Math.Max(imageHeight, imageWidth);
-        MaxSequenceLength = maxSequenceLength;
-        SupportedCharacters = BuildSupportedCharacters();
-
-        _onnxEncoderSession = new InferenceSession(encoderPath);
-        _onnxDecoderSession = new InferenceSession(decoderPath);
-
-        InitializeLayers();
-    }
-
-    /// <summary>
-    /// Creates a TrOCR model using native layers for training and inference.
-    /// </summary>
-    /// <param name="architecture">The neural network architecture.</param>
-    /// <param name="tokenizer">Tokenizer for text generation (optional).</param>
-    /// <param name="imageHeight">Input image height (default: 384 for TrOCR-base).</param>
-    /// <param name="imageWidth">Input image width (default: 384).</param>
-    /// <param name="maxSequenceLength">Maximum output sequence length (default: 128).</param>
-    /// <param name="encoderHiddenDim">Encoder hidden dimension (default: 768 for base).</param>
-    /// <param name="decoderHiddenDim">Decoder hidden dimension (default: 768 for base).</param>
-    /// <param name="numEncoderLayers">Number of encoder layers (default: 12).</param>
-    /// <param name="numDecoderLayers">Number of decoder layers (default: 6).</param>
-    /// <param name="numEncoderHeads">Number of encoder attention heads (default: 12).</param>
-    /// <param name="numDecoderHeads">Number of decoder attention heads (default: 12).</param>
-    /// <param name="patchSize">ViT patch size (default: 16).</param>
-    /// <param name="vocabSize">Vocabulary size (default: 50265 for RoBERTa tokenizer).</param>
-    /// <param name="optimizer">Optimizer for training (optional).</param>
-    /// <param name="lossFunction">Loss function (optional).</param>
-    /// <remarks>
-    /// <para>
-    /// <b>Default Configuration (TrOCR-Base from AAAI 2022 paper):</b>
-    /// - Encoder: ViT-Base (12 layers, 768 hidden, 12 heads)
-    /// - Decoder: 6 layers, 768 hidden, 12 heads
-    /// - Image size: 384×384
-    /// - Patch size: 16
-    /// </para>
-    /// </remarks>
-    public TrOCR(
-        NeuralNetworkArchitecture<T> architecture,
-        ITokenizer? tokenizer = null,
-        int imageHeight = 384,
-        int imageWidth = 384,
-        int maxSequenceLength = 128,
-        int encoderHiddenDim = 768,
-        int decoderHiddenDim = 768,
-        int numEncoderLayers = 12,
-        int numDecoderLayers = 6,
-        int numEncoderHeads = 12,
-        int numDecoderHeads = 12,
-        int patchSize = 16,
-        int vocabSize = 50265,
-        IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? optimizer = null,
-        ILossFunction<T>? lossFunction = null,
-        TrOCROptions? options = null)
-        : base(architecture, lossFunction ?? new CrossEntropyWithLogitsLoss<T>(), 1.0)
-    {
-        _options = options ?? new TrOCROptions();
-        Options = _options;
-
-        _useNativeMode = true;
-        _encoderHiddenDim = encoderHiddenDim;
-        _decoderHiddenDim = decoderHiddenDim;
-        _numEncoderLayers = numEncoderLayers;
-        _numDecoderLayers = numDecoderLayers;
-        _numEncoderHeads = numEncoderHeads;
-        _numDecoderHeads = numDecoderHeads;
-        _patchSize = patchSize;
-        _vocabSize = vocabSize;
-        _maxSequenceLength = maxSequenceLength;
-        _optimizer = optimizer ?? new AdamOptimizer<T, Tensor<T>, Tensor<T>>(this,
-            new AdamOptimizerOptions<T, Tensor<T>, Tensor<T>>
-            {
-                InitialLearningRate = _options.LearningRate
-            });
-
-        ImageSize = Math.Max(imageHeight, imageWidth);
-        MaxSequenceLength = maxSequenceLength;
-        SupportedCharacters = BuildSupportedCharacters();
-
-        _tokenizer = tokenizer ?? LanguageModelTokenizerFactory.CreateForBackbone(LanguageModelBackbone.OPT);
-
-        InitializeLayers();
-        InitializeEmbeddings();
-    }
-
-    #endregion
-
-    #region Initialization
-
-    /// <inheritdoc/>
-    protected override void InitializeLayers()
-    {
-        if (!_useNativeMode)
-        {
-            return;
-        }
-
-        // Check if user provided custom layers
-        if (Architecture.Layers is not null && Architecture.Layers.Count > 0)
-        {
-            Layers.AddRange(Architecture.Layers);
-            ValidateCustomLayers(Layers);
-            return;
-        }
-
-        // Use LayerHelper to create default TrOCR layers
-        var (encoderLayers, decoderLayers) = LayerHelper<T>.CreateDefaultTrOCRLayers(
-            imageSize: ImageSize,
-            patchSize: _patchSize,
-            encoderHiddenDim: _encoderHiddenDim,
-            decoderHiddenDim: _decoderHiddenDim,
-            numEncoderLayers: _numEncoderLayers,
-            numDecoderLayers: _numDecoderLayers,
-            numEncoderHeads: _numEncoderHeads,
-            numDecoderHeads: _numDecoderHeads,
-            vocabSize: _vocabSize,
-            maxSequenceLength: _maxSequenceLength);
-
-        _encoderLayers.AddRange(encoderLayers);
-        Layers.AddRange(_encoderLayers);
-
-        _decoderLayers.AddRange(decoderLayers);
-        Layers.AddRange(_decoderLayers);
-    }
-
-    private void InitializeEmbeddings()
-    {
-        var random = RandomHelper.CreateSeededRandom(42);
-
-        _decoderPositionEmbeddings = Tensor<T>.CreateDefault([_maxSequenceLength, _decoderHiddenDim], NumOps.Zero);
-        InitializeWithSmallRandomValues(_decoderPositionEmbeddings, random, 0.02);
-
-        _decoderWordEmbeddings = Tensor<T>.CreateDefault([_vocabSize, _decoderHiddenDim], NumOps.Zero);
-        InitializeWithSmallRandomValues(_decoderWordEmbeddings, random, 0.02);
-    }
-
-    private void InitializeWithSmallRandomValues(Tensor<T> tensor, Random random, double stdDev)
-    {
-        for (int i = 0; i < tensor.Data.Length; i++)
-        {
-            double u1 = 1.0 - random.NextDouble();
-            double u2 = 1.0 - random.NextDouble();
-            double randStdNormal = Math.Sqrt(-2.0 * Math.Log(u1)) * Math.Sin(2.0 * Math.PI * u2);
-            tensor.Data.Span[i] = NumOps.FromDouble(randStdNormal * stdDev);
-        }
-    }
-
-    private static string BuildSupportedCharacters()
-    {
-        // Standard printable ASCII + common Unicode characters
-        var chars = new System.Text.StringBuilder();
-        for (char c = ' '; c <= '~'; c++)
-        {
-            chars.Append(c);
-        }
-        return chars.ToString();
-    }
-
-    #endregion
-
-    #region ITextRecognizer Implementation
-
-    /// <inheritdoc/>
-    public TextRecognitionResult<T> RecognizeText(Tensor<T> croppedImage)
-    {
-        ValidateImageShape(croppedImage);
-
-        var startTime = DateTime.UtcNow;
-
-        var result = _useNativeMode
-            ? RecognizeTextNative(croppedImage)
-            : RecognizeTextOnnx(croppedImage);
-
-        return new TextRecognitionResult<T>
-        {
-            Text = result.Text,
-            Confidence = result.Confidence,
-            ConfidenceValue = result.ConfidenceValue,
-            Characters = result.Characters,
-            CharacterProbabilities = _lastCharacterProbabilities,
-            AttentionWeights = _lastAttentionWeights,
-            ProcessingTimeMs = (DateTime.UtcNow - startTime).TotalMilliseconds,
-            Alternatives = result.Alternatives
-        };
-    }
-
-    /// <inheritdoc/>
-    public IEnumerable<TextRecognitionResult<T>> RecognizeTextBatch(IEnumerable<Tensor<T>> croppedImages)
-    {
-        foreach (var image in croppedImages)
-        {
-            yield return RecognizeText(image);
-        }
-    }
-
-    /// <inheritdoc/>
-    public Tensor<T> GetCharacterProbabilities()
-    {
-        return _lastCharacterProbabilities ?? new Tensor<T>([1, _vocabSize]);
-    }
-
-    /// <inheritdoc/>
-    public Tensor<T>? GetAttentionWeights()
-    {
-        return _lastAttentionWeights;
-    }
-
-    private TextRecognitionResult<T> RecognizeTextNative(Tensor<T> image)
-    {
-        var preprocessed = PreprocessDocument(image);
-        var encoderOutput = RunEncoder(preprocessed);
-        return GenerateText(encoderOutput);
-    }
-
-    private TextRecognitionResult<T> RecognizeTextOnnx(Tensor<T> image)
-    {
-        if (_onnxEncoderSession is null || _onnxDecoderSession is null)
-            throw new InvalidOperationException("ONNX sessions not initialized.");
-
-        var preprocessed = PreprocessDocument(image);
-        var encoderOutput = RunOnnxInference(preprocessed);
-        return GenerateText(encoderOutput);
-    }
-
-    private Tensor<T> RunEncoder(Tensor<T> input)
-    {
-        var output = input;
-        bool hasReshapedToSequence = false;
-        bool hasPassedConvLayer = false;
-        foreach (var layer in _encoderLayers)
-        {
-            if (layer is ConvolutionalLayer<T> or BatchNormalizationLayer<T>
-                     or PoolingLayer<T> or MaxPoolingLayer<T> or AveragePoolingLayer<T>)
-            {
-                hasPassedConvLayer = true;
-            }
-
-            // Auto-reshape once when transitioning from spatial (CNN) to non-spatial layers
-            bool isNonSpatialLayer = layer is not (ConvolutionalLayer<T> or BatchNormalizationLayer<T>
-                or PoolingLayer<T> or MaxPoolingLayer<T> or AveragePoolingLayer<T>);
-            if (!hasReshapedToSequence && hasPassedConvLayer && output.Shape.Length >= 3 && isNonSpatialLayer)
-            {
-                int channels = output.Shape.Length == 4 ? output.Shape[1] : output.Shape[0];
-                int spatialH = output.Shape.Length == 4 ? output.Shape[2] : output.Shape[1];
-                int spatialW = output.Shape.Length == 4 ? output.Shape[3] : output.Shape[2];
-                int numPatches = spatialH * spatialW;
-                output = new Tensor<T>(output.Data.ToArray(), [numPatches, channels]);
-                hasReshapedToSequence = true;
-            }
-            output = layer.Forward(output);
-        }
-        return output;
-    }
-
-    private TextRecognitionResult<T> GenerateText(Tensor<T> encoderOutput)
-    {
-        var generatedTokens = new List<int>();
-        var characterConfidences = new List<CharacterRecognition<T>>();
-        var allProbabilities = new List<T[]>();
-
-        // Start token
-        int startToken = 0; // BOS token
-        int eosToken = 2;   // EOS token
-        generatedTokens.Add(startToken);
-
-        double totalConfidence = 0;
-
-        for (int step = 0; step < _maxSequenceLength - 1; step++)
-        {
-            var decoderInput = CreateDecoderInput(generatedTokens);
-            var logits = RunDecoder(decoderInput, encoderOutput);
-
-            // Get probabilities for last position
-            var probs = ApplySoftmax(logits, step);
-            allProbabilities.Add(probs);
-
-            // Greedy decoding - get argmax
-            int nextToken = 0;
-            double maxProb = double.MinValue;
-            for (int i = 0; i < Math.Min(_vocabSize, probs.Length); i++)
-            {
-                double p = NumOps.ToDouble(probs[i]);
-                if (p > maxProb)
-                {
-                    maxProb = p;
-                    nextToken = i;
-                }
-            }
-
-            if (nextToken == eosToken)
-                break;
-
-            generatedTokens.Add(nextToken);
-            totalConfidence += maxProb;
-
-            // Store character-level info
-            char decodedChar = DecodeToken(nextToken);
-            var alternatives = GetTopKAlternatives(probs, 3);
-
-            characterConfidences.Add(new CharacterRecognition<T>
-            {
-                Character = decodedChar,
-                Confidence = NumOps.FromDouble(maxProb),
-                ConfidenceValue = maxProb,
-                Position = step,
-                Alternatives = alternatives
-            });
-        }
-
-        // Store probabilities for inspection
-        _lastCharacterProbabilities = CreateProbabilityTensor(allProbabilities);
-
-        // Decode full text
-        string text = _tokenizer.Decode(generatedTokens.Skip(1).ToList()); // Skip BOS
-        double avgConfidence = characterConfidences.Count > 0 ? totalConfidence / characterConfidences.Count : 0;
-
-        return new TextRecognitionResult<T>
-        {
-            Text = text,
-            Confidence = NumOps.FromDouble(avgConfidence),
-            ConfidenceValue = avgConfidence,
-            Characters = characterConfidences,
-            Alternatives = []
-        };
-    }
-
-    private Tensor<T> CreateDecoderInput(List<int> tokens)
-    {
-        var input = new Tensor<T>([1, tokens.Count, _decoderHiddenDim]);
-
-        if (_decoderWordEmbeddings is null || _decoderPositionEmbeddings is null)
-            return input;
-
-        for (int i = 0; i < tokens.Count; i++)
-        {
-            int tokenId = Math.Min(tokens[i], _vocabSize - 1);
-            for (int d = 0; d < _decoderHiddenDim; d++)
-            {
-                // Word embedding + position embedding
-                T wordEmb = _decoderWordEmbeddings[tokenId, d];
-                T posEmb = _decoderPositionEmbeddings[i, d];
-                input[0, i, d] = NumOps.Add(wordEmb, posEmb);
-            }
-        }
-
-        return input;
-    }
-
-    private Tensor<T> RunDecoder(Tensor<T> decoderInput, Tensor<T> encoderOutput)
-    {
-        var output = decoderInput;
-        foreach (var layer in _decoderLayers)
-        {
-            output = layer.Forward(output);
-        }
-        return output;
-    }
-
-    private T[] ApplySoftmax(Tensor<T> logits, int position)
-    {
-        int vocabSize = Math.Min(_vocabSize, logits.Data.Length);
-        int startIdx = position * vocabSize;
-        int actualCount = Math.Min(vocabSize, logits.Data.Length - startIdx);
-        if (actualCount <= 0) return new T[vocabSize];
-
-        var slice = new Tensor<T>([actualCount]);
-        logits.Data.Span.Slice(startIdx, actualCount).CopyTo(slice.Data.Span);
-        var result = Engine.Softmax(slice, -1);
-
-        var probs = new T[vocabSize];
-        result.Data.Span.CopyTo(probs.AsSpan(0, actualCount));
-        return probs;
-    }
-
-    private char DecodeToken(int tokenId)
-    {
-        try
-        {
-            string decoded = _tokenizer.Decode([tokenId]);
-            return decoded.Length > 0 ? decoded[0] : ' ';
-        }
-        catch
-        {
-            return ' ';
-        }
-    }
-
-    private List<(char Character, double Probability)> GetTopKAlternatives(T[] probs, int k)
-    {
-        var alternatives = new List<(int idx, double prob)>();
-        for (int i = 0; i < probs.Length; i++)
-        {
-            alternatives.Add((i, NumOps.ToDouble(probs[i])));
-        }
-
-        return alternatives
-            .OrderByDescending(x => x.prob)
-            .Take(k)
-            .Select(x => (DecodeToken(x.idx), x.prob))
-            .ToList();
-    }
-
-    private Tensor<T> CreateProbabilityTensor(List<T[]> allProbabilities)
-    {
-        if (allProbabilities.Count == 0)
-            return new Tensor<T>([1, _vocabSize]);
-
-        int seqLen = allProbabilities.Count;
-        int vocabSize = allProbabilities[0].Length;
-        var tensor = new Tensor<T>([seqLen, vocabSize]);
-
-        for (int s = 0; s < seqLen; s++)
-        {
-            for (int v = 0; v < vocabSize; v++)
-            {
-                tensor[s, v] = allProbabilities[s][v];
-            }
-        }
-
-        return tensor;
-    }
-
-    #endregion
-
-    #region IDocumentModel Implementation
-
-    /// <inheritdoc/>
-    public Tensor<T> EncodeDocument(Tensor<T> documentImage)
-    {
-        ValidateImageShape(documentImage);
-        var preprocessed = PreprocessDocument(documentImage);
-        return _useNativeMode ? RunEncoder(preprocessed) : RunOnnxInference(preprocessed);
-    }
-
-    /// <inheritdoc/>
-    public void ValidateInputShape(Tensor<T> documentImage)
-    {
-        ValidateImageShape(documentImage);
-    }
-
-    /// <inheritdoc/>
-    public string GetModelSummary()
-    {
-        var sb = new System.Text.StringBuilder();
-        sb.AppendLine("TrOCR Model Summary");
-        sb.AppendLine("===================");
-        sb.AppendLine($"Mode: {(_useNativeMode ? "Native (Trainable)" : "ONNX (Inference)")}");
-        sb.AppendLine();
-        sb.AppendLine("Encoder (ViT):");
-        sb.AppendLine($"  Hidden Dimension: {_encoderHiddenDim}");
-        sb.AppendLine($"  Number of Layers: {_numEncoderLayers}");
-        sb.AppendLine($"  Attention Heads: {_numEncoderHeads}");
-        sb.AppendLine($"  Patch Size: {_patchSize}");
-        sb.AppendLine();
-        sb.AppendLine("Decoder:");
-        sb.AppendLine($"  Hidden Dimension: {_decoderHiddenDim}");
-        sb.AppendLine($"  Number of Layers: {_numDecoderLayers}");
-        sb.AppendLine($"  Attention Heads: {_numDecoderHeads}");
-        sb.AppendLine();
-        sb.AppendLine($"Image Size: {ImageSize}x{ImageSize}");
-        sb.AppendLine($"Vocabulary Size: {_vocabSize}");
-        sb.AppendLine($"Max Sequence Length: {_maxSequenceLength}");
-        sb.AppendLine($"Total Layers: {Layers.Count}");
-        sb.AppendLine($"Attention Visualization: {SupportsAttentionVisualization}");
-        return sb.ToString();
-    }
-
-    #endregion
-
-    #region Preprocessing
-
-    /// <summary>
-    /// Applies TrOCR's industry-standard preprocessing: normalize to [-1, 1].
-    /// </summary>
-    /// <remarks>
-    /// TrOCR (Transformer-based OCR) uses mean=0.5, std=0.5 normalization
-    /// (same as DeiT/BEiT) from Microsoft paper.
-    /// </remarks>
-    protected override Tensor<T> ApplyDefaultPreprocessing(Tensor<T> rawImage)
-    {
-        var image = EnsureBatchDimension(rawImage);
-
-        int batchSize = image.Shape[0];
-        int channels = image.Shape[1];
-        int height = image.Shape[2];
-        int width = image.Shape[3];
-
-        var normalized = new Tensor<T>(image._shape);
-
-        // TrOCR normalization (same as DeiT/BEiT)
-        double[] means = [0.5, 0.5, 0.5];
-        double[] stds = [0.5, 0.5, 0.5];
-
-        for (int b = 0; b < batchSize; b++)
-        {
-            for (int c = 0; c < channels; c++)
-            {
-                double mean = c < means.Length ? means[c] : 0.5;
-                double std = c < stds.Length ? stds[c] : 0.5;
-
-                for (int h = 0; h < height; h++)
-                {
-                    for (int w = 0; w < width; w++)
-                    {
-                        int idx = b * channels * height * width + c * height * width + h * width + w;
-                        double value = NumOps.ToDouble(image.Data.Span[idx]);
-                        normalized.Data.Span[idx] = NumOps.FromDouble((value - mean) / std);
-                    }
-                }
-            }
-        }
-
-        return normalized;
-    }
-
-    /// <summary>
-    /// Applies TrOCR's industry-standard postprocessing: pass-through (encoder-decoder outputs are already final).
-    /// </summary>
-    protected override Tensor<T> ApplyDefaultPostprocessing(Tensor<T> modelOutput)
-    {
-        return modelOutput;
-    }
-
-    #endregion
-
-    #region Serialization
-
-    /// <inheritdoc/>
-    public override ModelMetadata<T> GetModelMetadata()
-    {
-        return new ModelMetadata<T>
-        {
-            Name = "TrOCR",
-            Description = "Transformer-based OCR with ViT encoder (AAAI 2022)",
-            FeatureCount = _decoderHiddenDim,
-            Complexity = _numEncoderLayers + _numDecoderLayers,
-            AdditionalInfo = new Dictionary<string, object>
-            {
-                { "encoder_hidden_dim", _encoderHiddenDim },
-                { "decoder_hidden_dim", _decoderHiddenDim },
-                { "num_encoder_layers", _numEncoderLayers },
-                { "num_decoder_layers", _numDecoderLayers },
-                { "num_encoder_heads", _numEncoderHeads },
-                { "num_decoder_heads", _numDecoderHeads },
-                { "patch_size", _patchSize },
-                { "vocab_size", _vocabSize },
-                { "max_sequence_length", _maxSequenceLength },
-                { "image_size", ImageSize },
-                { "use_native_mode", _useNativeMode }
-            },
-            ModelData = SafeSerialize()
-        };
-    }
-
-    /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_encoderHiddenDim);
-        writer.Write(_decoderHiddenDim);
-        writer.Write(_numEncoderLayers);
-        writer.Write(_numDecoderLayers);
-        writer.Write(_numEncoderHeads);
-        writer.Write(_numDecoderHeads);
-        writer.Write(_patchSize);
-        writer.Write(_vocabSize);
-        writer.Write(_maxSequenceLength);
-        writer.Write(ImageSize);
-        writer.Write(_useNativeMode);
-    }
-
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        int encoderHiddenDim = reader.ReadInt32();
-        int decoderHiddenDim = reader.ReadInt32();
-        int numEncoderLayers = reader.ReadInt32();
-        int numDecoderLayers = reader.ReadInt32();
-        int numEncoderHeads = reader.ReadInt32();
-        int numDecoderHeads = reader.ReadInt32();
-        int patchSize = reader.ReadInt32();
-        int vocabSize = reader.ReadInt32();
-        int maxSequenceLength = reader.ReadInt32();
-        int imageSize = reader.ReadInt32();
-        bool useNativeMode = reader.ReadBoolean();
-
-        ImageSize = imageSize;
-        MaxSequenceLength = maxSequenceLength;
-    }
-
-    /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new TrOCR<T>(
-            Architecture,
-            _tokenizer,
-            ImageSize,
-            ImageSize,
-            _maxSequenceLength,
-            _encoderHiddenDim,
-            _decoderHiddenDim,
-            _numEncoderLayers,
-            _numDecoderLayers,
-            _numEncoderHeads,
-            _numDecoderHeads,
-            _patchSize,
-            _vocabSize);
-    }
-
-    #endregion
-
-    #region NeuralNetworkBase Implementation
-
-    /// <inheritdoc/>
-    protected override Tensor<T> PredictCore(Tensor<T> input)
-    {
-        var preprocessed = PreprocessDocument(input);
-        return _useNativeMode ? RunEncoder(preprocessed) : RunOnnxInference(preprocessed);
-    }
-
-    /// <inheritdoc/>
-    public override void Train(Tensor<T> input, Tensor<T> expectedOutput)
-    {
-        if (!_useNativeMode)
-        {
-            throw new NotSupportedException("Training is not supported in ONNX inference mode.");
-        }
-
-        SetTrainingMode(true);
-
-        TrainWithTape(input, expectedOutput, _optimizer);
-        var paramGradients = CollectParameterGradients();
-        UpdateParameters(paramGradients);
-        SetTrainingMode(false);}
-
-    // UpdateParameters applied a GRADIENT STEP, but its one-argument form is the value setter and every caller passes values -- the override corrupted the model. Removed under AIDN082.

-
-    /// <summary>
-    /// Parameters cannot be written while the model is backed by a loaded ONNX graph: the weights
-    /// belong to that graph, not to this instance.
-    /// </summary>
-    /// <remarks>
-    /// Replaces a hand-written throw that used to sit inside UpdateParameters. The base checks this
-    /// on every mutating entry point rather than the one member the throw happened to guard, and
-    /// reading -- ParameterCount and GetParameters -- stays available either way.
-    /// </remarks>
+using AiDotNet.Attributes;
+using AiDotNet.Document.Interfaces;
+using AiDotNet.Document.Options;
+using AiDotNet.Enums;
+using AiDotNet.Helpers;
+using AiDotNet.Interfaces;
+using AiDotNet.LinearAlgebra;
+using AiDotNet.LossFunctions;
+using AiDotNet.NeuralNetworks;
+using AiDotNet.NeuralNetworks.Layers;
+using AiDotNet.Optimizers;
+using AiDotNet.Tokenization;
+using AiDotNet.Tokenization.Interfaces;
+using Microsoft.ML.OnnxRuntime;
+using AiDotNet.Validation;
+
+namespace AiDotNet.Document.OCR.TextRecognition;
+
+/// <summary>
+/// TrOCR (Transformer-based OCR) for text recognition from cropped images.
+/// </summary>
+/// <typeparam name="T">The numeric type used for calculations.</typeparam>
+/// <remarks>
+/// <para>
+/// TrOCR is an end-to-end text recognition model that uses a Vision Transformer (ViT)
+/// encoder and a Transformer decoder (similar to BART/GPT-2) for sequence generation.
+/// </para>
+/// <para>
+/// <b>For Beginners:</b> TrOCR reads text from images. Given a cropped image of text
+/// (like a single word or line), it outputs the actual characters. It works by:
+/// 1. The encoder (ViT) analyzes the image and creates feature representations
+/// 2. The decoder generates text one character at a time, using attention to focus on relevant image regions
+///
+/// Example usage:
+/// <code>
+/// var trocr = new TrOCR&lt;float&gt;(architecture);
+/// var result = trocr.RecognizeText(croppedTextImage);
+/// // Result is available in the returned value
+/// </code>
+/// </para>
+/// <para>
+/// <b>Reference:</b> "TrOCR: Transformer-based Optical Character Recognition with Pre-trained Models" (AAAI 2022)
+/// https://arxiv.org/abs/2109.10282
+/// </para>
+/// </remarks>
+[ModelDomain(ModelDomain.Vision)]
+[ModelDomain(ModelDomain.Language)]
+[ModelCategory(ModelCategory.NeuralNetwork)]
+[ModelCategory(ModelCategory.Transformer)]
+[ModelTask(ModelTask.Detection)]
+[ModelComplexity(ModelComplexity.High)]
+[ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
+[ResearchPaper("TrOCR: Transformer-based Optical Character Recognition with Pre-trained Models", "https://doi.org/10.48550/arXiv.2109.10282", Year = 2022, Authors = "Minghao Li, Tengchao Lv, Jingye Chen, Lei Cui, Yijuan Lu, Dinei Florencio, Cha Zhang, Zhoujun Li, Furu Wei")]
+public partial class TrOCR<T> : DocumentNeuralNetworkBase<T>, ITextRecognizer<T>
+{
+    private readonly TrOCROptions _options;
+
+    /// <inheritdoc/>
+    public override ModelOptions GetOptions() => _options;
+
+    #region Fields
+
+    private readonly bool _useNativeMode;
+    private readonly InferenceSession? _onnxEncoderSession;
+    private readonly InferenceSession? _onnxDecoderSession;
+    private readonly ITokenizer _tokenizer;
+    private readonly IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>> _optimizer;
+    private readonly int _encoderHiddenDim;
+    private readonly int _decoderHiddenDim;
+    private readonly int _numEncoderLayers;
+    private readonly int _numDecoderLayers;
+    private readonly int _numEncoderHeads;
+    private readonly int _numDecoderHeads;
+    private readonly int _patchSize;
+    private readonly int _vocabSize;
+    private readonly int _maxSequenceLength;
+
+    // Native mode layers
+    private readonly List<ILayer<T>> _encoderLayers = [];
+    private readonly List<ILayer<T>> _decoderLayers = [];
+
+    // Learnable embeddings
+    [AiDotNet.Attributes.TrainableParameter]
+    private Tensor<T>? _decoderPositionEmbeddings;
+    [AiDotNet.Attributes.TrainableParameter]
+    private Tensor<T>? _decoderWordEmbeddings;
+
+    // Cached outputs
+    [Scratch]
+    private Tensor<T>? _lastCharacterProbabilities;
+#pragma warning disable CS0649 // Field is never assigned - attention weights are computed but not yet stored
+    [Scratch]
+    private Tensor<T>? _lastAttentionWeights;
+#pragma warning restore CS0649
+
+    #endregion
+
+    #region Properties
+
+    /// <inheritdoc/>
+    public override DocumentType SupportedDocumentTypes => DocumentType.All;
+
+    /// <inheritdoc/>
+    public override bool RequiresOCR => false;
+
+    /// <inheritdoc/>
+    public int ExpectedImageSize => ImageSize;
+
+    /// <inheritdoc/>
+    public string SupportedCharacters { get; }
+
+    /// <inheritdoc/>
+    int ITextRecognizer<T>.MaxSequenceLength => _maxSequenceLength;
+
+    /// <inheritdoc/>
+    public bool SupportsAttentionVisualization => true;
+
+    #endregion
+
+    #region Constructors
+
+    /// <summary>
+    /// Creates a TrOCR model using pre-trained ONNX models for inference.
+    /// </summary>
+    /// <param name="architecture">The neural network architecture.</param>
+    /// <param name="encoderPath">Path to the ONNX encoder model.</param>
+    /// <param name="decoderPath">Path to the ONNX decoder model.</param>
+    /// <param name="tokenizer">Tokenizer for text generation.</param>
+    /// <param name="imageHeight">Input image height (default: 384 for TrOCR-base).</param>
+    /// <param name="imageWidth">Input image width (default: 384).</param>
+    /// <param name="maxSequenceLength">Maximum output sequence length (default: 128).</param>
+    /// <param name="encoderHiddenDim">Encoder hidden dimension (default: 768 for base).</param>
+    /// <param name="decoderHiddenDim">Decoder hidden dimension (default: 768 for base).</param>
+    /// <param name="numEncoderLayers">Number of encoder layers (default: 12).</param>
+    /// <param name="numDecoderLayers">Number of decoder layers (default: 6).</param>
+    /// <param name="numEncoderHeads">Number of encoder attention heads (default: 12).</param>
+    /// <param name="numDecoderHeads">Number of decoder attention heads (default: 12).</param>
+    /// <param name="patchSize">ViT patch size (default: 16).</param>
+    /// <param name="vocabSize">Vocabulary size (default: 50265 for RoBERTa tokenizer).</param>
+    /// <param name="optimizer">Optimizer for training (optional).</param>
+    /// <param name="lossFunction">Loss function (optional).</param>
+    /// <exception cref="ArgumentNullException">Thrown if paths or tokenizer is null.</exception>
+    /// <exception cref="FileNotFoundException">Thrown if ONNX model files don't exist.</exception>
+    public TrOCR(
+        NeuralNetworkArchitecture<T> architecture,
+        string encoderPath,
+        string decoderPath,
+        ITokenizer tokenizer,
+        int imageHeight = 384,
+        int imageWidth = 384,
+        int maxSequenceLength = 128,
+        int encoderHiddenDim = 768,
+        int decoderHiddenDim = 768,
+        int numEncoderLayers = 12,
+        int numDecoderLayers = 6,
+        int numEncoderHeads = 12,
+        int numDecoderHeads = 12,
+        int patchSize = 16,
+        int vocabSize = 50265,
+        IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? optimizer = null,
+        ILossFunction<T>? lossFunction = null,
+        TrOCROptions? options = null)
+        : base(architecture, lossFunction ?? new CrossEntropyWithLogitsLoss<T>(), 1.0)
+    {
+        _options = options ?? new TrOCROptions();
+        Options = _options;
+
+        if (string.IsNullOrWhiteSpace(encoderPath))
+            throw new ArgumentNullException(nameof(encoderPath));
+        if (string.IsNullOrWhiteSpace(decoderPath))
+            throw new ArgumentNullException(nameof(decoderPath));
+        if (!File.Exists(encoderPath))
+            throw new FileNotFoundException($"Encoder model not found: {encoderPath}", encoderPath);
+        if (!File.Exists(decoderPath))
+            throw new FileNotFoundException($"Decoder model not found: {decoderPath}", decoderPath);
+
+        Guard.NotNull(tokenizer);
+        _tokenizer = tokenizer;
+        _useNativeMode = false;
+        _encoderHiddenDim = encoderHiddenDim;
+        _decoderHiddenDim = decoderHiddenDim;
+        _numEncoderLayers = numEncoderLayers;
+        _numDecoderLayers = numDecoderLayers;
+        _numEncoderHeads = numEncoderHeads;
+        _numDecoderHeads = numDecoderHeads;
+        _patchSize = patchSize;
+        _vocabSize = vocabSize;
+        _maxSequenceLength = maxSequenceLength;
+        _optimizer = optimizer ?? new AdamOptimizer<T, Tensor<T>, Tensor<T>>(this,
+            new AdamOptimizerOptions<T, Tensor<T>, Tensor<T>>
+            {
+                InitialLearningRate = _options.LearningRate
+            });
+
+        ImageSize = Math.Max(imageHeight, imageWidth);
+        MaxSequenceLength = maxSequenceLength;
+        SupportedCharacters = BuildSupportedCharacters();
+
+        _onnxEncoderSession = new InferenceSession(encoderPath);
+        _onnxDecoderSession = new InferenceSession(decoderPath);
+
+        InitializeLayers();
+    }
+
+    /// <summary>
+    /// Creates a TrOCR model using native layers for training and inference.
+    /// </summary>
+    /// <param name="architecture">The neural network architecture.</param>
+    /// <param name="tokenizer">Tokenizer for text generation (optional).</param>
+    /// <param name="imageHeight">Input image height (default: 384 for TrOCR-base).</param>
+    /// <param name="imageWidth">Input image width (default: 384).</param>
+    /// <param name="maxSequenceLength">Maximum output sequence length (default: 128).</param>
+    /// <param name="encoderHiddenDim">Encoder hidden dimension (default: 768 for base).</param>
+    /// <param name="decoderHiddenDim">Decoder hidden dimension (default: 768 for base).</param>
+    /// <param name="numEncoderLayers">Number of encoder layers (default: 12).</param>
+    /// <param name="numDecoderLayers">Number of decoder layers (default: 6).</param>
+    /// <param name="numEncoderHeads">Number of encoder attention heads (default: 12).</param>
+    /// <param name="numDecoderHeads">Number of decoder attention heads (default: 12).</param>
+    /// <param name="patchSize">ViT patch size (default: 16).</param>
+    /// <param name="vocabSize">Vocabulary size (default: 50265 for RoBERTa tokenizer).</param>
+    /// <param name="optimizer">Optimizer for training (optional).</param>
+    /// <param name="lossFunction">Loss function (optional).</param>
+    /// <remarks>
+    /// <para>
+    /// <b>Default Configuration (TrOCR-Base from AAAI 2022 paper):</b>
+    /// - Encoder: ViT-Base (12 layers, 768 hidden, 12 heads)
+    /// - Decoder: 6 layers, 768 hidden, 12 heads
+    /// - Image size: 384×384
+    /// - Patch size: 16
+    /// </para>
+    /// </remarks>
+    public TrOCR(
+        NeuralNetworkArchitecture<T> architecture,
+        ITokenizer? tokenizer = null,
+        int imageHeight = 384,
+        int imageWidth = 384,
+        int maxSequenceLength = 128,
+        int encoderHiddenDim = 768,
+        int decoderHiddenDim = 768,
+        int numEncoderLayers = 12,
+        int numDecoderLayers = 6,
+        int numEncoderHeads = 12,
+        int numDecoderHeads = 12,
+        int patchSize = 16,
+        int vocabSize = 50265,
+        IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? optimizer = null,
+        ILossFunction<T>? lossFunction = null,
+        TrOCROptions? options = null)
+        : base(architecture, lossFunction ?? new CrossEntropyWithLogitsLoss<T>(), 1.0)
+    {
+        _options = options ?? new TrOCROptions();
+        Options = _options;
+
+        _useNativeMode = true;
+        _encoderHiddenDim = encoderHiddenDim;
+        _decoderHiddenDim = decoderHiddenDim;
+        _numEncoderLayers = numEncoderLayers;
+        _numDecoderLayers = numDecoderLayers;
+        _numEncoderHeads = numEncoderHeads;
+        _numDecoderHeads = numDecoderHeads;
+        _patchSize = patchSize;
+        _vocabSize = vocabSize;
+        _maxSequenceLength = maxSequenceLength;
+        _optimizer = optimizer ?? new AdamOptimizer<T, Tensor<T>, Tensor<T>>(this,
+            new AdamOptimizerOptions<T, Tensor<T>, Tensor<T>>
+            {
+                InitialLearningRate = _options.LearningRate
+            });
+
+        ImageSize = Math.Max(imageHeight, imageWidth);
+        MaxSequenceLength = maxSequenceLength;
+        SupportedCharacters = BuildSupportedCharacters();
+
+        _tokenizer = tokenizer ?? LanguageModelTokenizerFactory.CreateForBackbone(LanguageModelBackbone.OPT);
+
+        InitializeLayers();
+        InitializeEmbeddings();
+    }
+
+    #endregion
+
+    #region Initialization
+
+    /// <inheritdoc/>
+    protected override void InitializeLayers()
+    {
+        if (!_useNativeMode)
+        {
+            return;
+        }
+
+        // Check if user provided custom layers
+        if (Architecture.Layers is not null && Architecture.Layers.Count > 0)
+        {
+            Layers.AddRange(Architecture.Layers);
+            ValidateCustomLayers(Layers);
+            return;
+        }
+
+        // Use LayerHelper to create default TrOCR layers
+        var (encoderLayers, decoderLayers) = LayerHelper<T>.CreateDefaultTrOCRLayers(
+            imageSize: ImageSize,
+            patchSize: _patchSize,
+            encoderHiddenDim: _encoderHiddenDim,
+            decoderHiddenDim: _decoderHiddenDim,
+            numEncoderLayers: _numEncoderLayers,
+            numDecoderLayers: _numDecoderLayers,
+            numEncoderHeads: _numEncoderHeads,
+            numDecoderHeads: _numDecoderHeads,
+            vocabSize: _vocabSize,
+            maxSequenceLength: _maxSequenceLength);
+
+        _encoderLayers.AddRange(encoderLayers);
+        Layers.AddRange(_encoderLayers);
+
+        _decoderLayers.AddRange(decoderLayers);
+        Layers.AddRange(_decoderLayers);
+    }
+
+    private void InitializeEmbeddings()
+    {
+        var random = RandomHelper.CreateSeededRandom(42);
+
+        _decoderPositionEmbeddings = Tensor<T>.CreateDefault([_maxSequenceLength, _decoderHiddenDim], NumOps.Zero);
+        InitializeWithSmallRandomValues(_decoderPositionEmbeddings, random, 0.02);
+
+        _decoderWordEmbeddings = Tensor<T>.CreateDefault([_vocabSize, _decoderHiddenDim], NumOps.Zero);
+        InitializeWithSmallRandomValues(_decoderWordEmbeddings, random, 0.02);
+    }
+
+    private void InitializeWithSmallRandomValues(Tensor<T> tensor, Random random, double stdDev)
+    {
+        for (int i = 0; i < tensor.Data.Length; i++)
+        {
+            double u1 = 1.0 - random.NextDouble();
+            double u2 = 1.0 - random.NextDouble();
+            double randStdNormal = Math.Sqrt(-2.0 * Math.Log(u1)) * Math.Sin(2.0 * Math.PI * u2);
+            tensor.Data.Span[i] = NumOps.FromDouble(randStdNormal * stdDev);
+        }
+    }
+
+    private static string BuildSupportedCharacters()
+    {
+        // Standard printable ASCII + common Unicode characters
+        var chars = new System.Text.StringBuilder();
+        for (char c = ' '; c <= '~'; c++)
+        {
+            chars.Append(c);
+        }
+        return chars.ToString();
+    }
+
+    #endregion
+
+    #region ITextRecognizer Implementation
+
+    /// <inheritdoc/>
+    public TextRecognitionResult<T> RecognizeText(Tensor<T> croppedImage)
+    {
+        ValidateImageShape(croppedImage);
+
+        var startTime = DateTime.UtcNow;
+
+        var result = _useNativeMode
+            ? RecognizeTextNative(croppedImage)
+            : RecognizeTextOnnx(croppedImage);
+
+        return new TextRecognitionResult<T>
+        {
+            Text = result.Text,
+            Confidence = result.Confidence,
+            ConfidenceValue = result.ConfidenceValue,
+            Characters = result.Characters,
+            CharacterProbabilities = _lastCharacterProbabilities,
+            AttentionWeights = _lastAttentionWeights,
+            ProcessingTimeMs = (DateTime.UtcNow - startTime).TotalMilliseconds,
+            Alternatives = result.Alternatives
+        };
+    }
+
+    /// <inheritdoc/>
+    public IEnumerable<TextRecognitionResult<T>> RecognizeTextBatch(IEnumerable<Tensor<T>> croppedImages)
+    {
+        foreach (var image in croppedImages)
+        {
+            yield return RecognizeText(image);
+        }
+    }
+
+    /// <inheritdoc/>
+    public Tensor<T> GetCharacterProbabilities()
+    {
+        return _lastCharacterProbabilities ?? new Tensor<T>([1, _vocabSize]);
+    }
+
+    /// <inheritdoc/>
+    public Tensor<T>? GetAttentionWeights()
+    {
+        return _lastAttentionWeights;
+    }
+
+    private TextRecognitionResult<T> RecognizeTextNative(Tensor<T> image)
+    {
+        var preprocessed = PreprocessDocument(image);
+        var encoderOutput = RunEncoder(preprocessed);
+        return GenerateText(encoderOutput);
+    }
+
+    private TextRecognitionResult<T> RecognizeTextOnnx(Tensor<T> image)
+    {
+        if (_onnxEncoderSession is null || _onnxDecoderSession is null)
+            throw new InvalidOperationException("ONNX sessions not initialized.");
+
+        var preprocessed = PreprocessDocument(image);
+        var encoderOutput = RunOnnxInference(preprocessed);
+        return GenerateText(encoderOutput);
+    }
+
+    private Tensor<T> RunEncoder(Tensor<T> input)
+    {
+        var output = input;
+        bool hasReshapedToSequence = false;
+        bool hasPassedConvLayer = false;
+        foreach (var layer in _encoderLayers)
+        {
+            if (layer is ConvolutionalLayer<T> or BatchNormalizationLayer<T>
+                     or PoolingLayer<T> or MaxPoolingLayer<T> or AveragePoolingLayer<T>)
+            {
+                hasPassedConvLayer = true;
+            }
+
+            // Auto-reshape once when transitioning from spatial (CNN) to non-spatial layers
+            bool isNonSpatialLayer = layer is not (ConvolutionalLayer<T> or BatchNormalizationLayer<T>
+                or PoolingLayer<T> or MaxPoolingLayer<T> or AveragePoolingLayer<T>);
+            if (!hasReshapedToSequence && hasPassedConvLayer && output.Shape.Length >= 3 && isNonSpatialLayer)
+            {
+                int channels = output.Shape.Length == 4 ? output.Shape[1] : output.Shape[0];
+                int spatialH = output.Shape.Length == 4 ? output.Shape[2] : output.Shape[1];
+                int spatialW = output.Shape.Length == 4 ? output.Shape[3] : output.Shape[2];
+                int numPatches = spatialH * spatialW;
+                output = new Tensor<T>(output.Data.ToArray(), [numPatches, channels]);
+                hasReshapedToSequence = true;
+            }
+            output = layer.Forward(output);
+        }
+        return output;
+    }
+
+    private TextRecognitionResult<T> GenerateText(Tensor<T> encoderOutput)
+    {
+        var generatedTokens = new List<int>();
+        var characterConfidences = new List<CharacterRecognition<T>>();
+        var allProbabilities = new List<T[]>();
+
+        // Start token
+        int startToken = 0; // BOS token
+        int eosToken = 2;   // EOS token
+        generatedTokens.Add(startToken);
+
+        double totalConfidence = 0;
+
+        for (int step = 0; step < _maxSequenceLength - 1; step++)
+        {
+            var decoderInput = CreateDecoderInput(generatedTokens);
+            var logits = RunDecoder(decoderInput, encoderOutput);
+
+            // Get probabilities for last position
+            var probs = ApplySoftmax(logits, step);
+            allProbabilities.Add(probs);
+
+            // Greedy decoding - get argmax
+            int nextToken = 0;
+            double maxProb = double.MinValue;
+            for (int i = 0; i < Math.Min(_vocabSize, probs.Length); i++)
+            {
+                double p = NumOps.ToDouble(probs[i]);
+                if (p > maxProb)
+                {
+                    maxProb = p;
+                    nextToken = i;
+                }
+            }
+
+            if (nextToken == eosToken)
+                break;
+
+            generatedTokens.Add(nextToken);
+            totalConfidence += maxProb;
+
+            // Store character-level info
+            char decodedChar = DecodeToken(nextToken);
+            var alternatives = GetTopKAlternatives(probs, 3);
+
+            characterConfidences.Add(new CharacterRecognition<T>
+            {
+                Character = decodedChar,
+                Confidence = NumOps.FromDouble(maxProb),
+                ConfidenceValue = maxProb,
+                Position = step,
+                Alternatives = alternatives
+            });
+        }
+
+        // Store probabilities for inspection
+        _lastCharacterProbabilities = CreateProbabilityTensor(allProbabilities);
+
+        // Decode full text
+        string text = _tokenizer.Decode(generatedTokens.Skip(1).ToList()); // Skip BOS
+        double avgConfidence = characterConfidences.Count > 0 ? totalConfidence / characterConfidences.Count : 0;
+
+        return new TextRecognitionResult<T>
+        {
+            Text = text,
+            Confidence = NumOps.FromDouble(avgConfidence),
+            ConfidenceValue = avgConfidence,
+            Characters = characterConfidences,
+            Alternatives = []
+        };
+    }
+
+    private Tensor<T> CreateDecoderInput(List<int> tokens)
+    {
+        var input = new Tensor<T>([1, tokens.Count, _decoderHiddenDim]);
+
+        if (_decoderWordEmbeddings is null || _decoderPositionEmbeddings is null)
+            return input;
+
+        for (int i = 0; i < tokens.Count; i++)
+        {
+            int tokenId = Math.Min(tokens[i], _vocabSize - 1);
+            for (int d = 0; d < _decoderHiddenDim; d++)
+            {
+                // Word embedding + position embedding
+                T wordEmb = _decoderWordEmbeddings[tokenId, d];
+                T posEmb = _decoderPositionEmbeddings[i, d];
+                input[0, i, d] = NumOps.Add(wordEmb, posEmb);
+            }
+        }
+
+        return input;
+    }
+
+    private Tensor<T> RunDecoder(Tensor<T> decoderInput, Tensor<T> encoderOutput)
+    {
+        var output = decoderInput;
+        foreach (var layer in _decoderLayers)
+        {
+            output = layer.Forward(output);
+        }
+        return output;
+    }
+
+    private T[] ApplySoftmax(Tensor<T> logits, int position)
+    {
+        int vocabSize = Math.Min(_vocabSize, logits.Data.Length);
+        int startIdx = position * vocabSize;
+        int actualCount = Math.Min(vocabSize, logits.Data.Length - startIdx);
+        if (actualCount <= 0) return new T[vocabSize];
+
+        var slice = new Tensor<T>([actualCount]);
+        logits.Data.Span.Slice(startIdx, actualCount).CopyTo(slice.Data.Span);
+        var result = Engine.Softmax(slice, -1);
+
+        var probs = new T[vocabSize];
+        result.Data.Span.CopyTo(probs.AsSpan(0, actualCount));
+        return probs;
+    }
+
+    private char DecodeToken(int tokenId)
+    {
+        try
+        {
+            string decoded = _tokenizer.Decode([tokenId]);
+            return decoded.Length > 0 ? decoded[0] : ' ';
+        }
+        catch
+        {
+            return ' ';
+        }
+    }
+
+    private List<(char Character, double Probability)> GetTopKAlternatives(T[] probs, int k)
+    {
+        var alternatives = new List<(int idx, double prob)>();
+        for (int i = 0; i < probs.Length; i++)
+        {
+            alternatives.Add((i, NumOps.ToDouble(probs[i])));
+        }
+
+        return alternatives
+            .OrderByDescending(x => x.prob)
+            .Take(k)
+            .Select(x => (DecodeToken(x.idx), x.prob))
+            .ToList();
+    }
+
+    private Tensor<T> CreateProbabilityTensor(List<T[]> allProbabilities)
+    {
+        if (allProbabilities.Count == 0)
+            return new Tensor<T>([1, _vocabSize]);
+
+        int seqLen = allProbabilities.Count;
+        int vocabSize = allProbabilities[0].Length;
+        var tensor = new Tensor<T>([seqLen, vocabSize]);
+
+        for (int s = 0; s < seqLen; s++)
+        {
+            for (int v = 0; v < vocabSize; v++)
+            {
+                tensor[s, v] = allProbabilities[s][v];
+            }
+        }
+
+        return tensor;
+    }
+
+    #endregion
+
+    #region IDocumentModel Implementation
+
+    /// <inheritdoc/>
+    public Tensor<T> EncodeDocument(Tensor<T> documentImage)
+    {
+        ValidateImageShape(documentImage);
+        var preprocessed = PreprocessDocument(documentImage);
+        return _useNativeMode ? RunEncoder(preprocessed) : RunOnnxInference(preprocessed);
+    }
+
+    /// <inheritdoc/>
+    public void ValidateInputShape(Tensor<T> documentImage)
+    {
+        ValidateImageShape(documentImage);
+    }
+
+    /// <inheritdoc/>
+    public string GetModelSummary()
+    {
+        var sb = new System.Text.StringBuilder();
+        sb.AppendLine("TrOCR Model Summary");
+        sb.AppendLine("===================");
+        sb.AppendLine($"Mode: {(_useNativeMode ? "Native (Trainable)" : "ONNX (Inference)")}");
+        sb.AppendLine();
+        sb.AppendLine("Encoder (ViT):");
+        sb.AppendLine($"  Hidden Dimension: {_encoderHiddenDim}");
+        sb.AppendLine($"  Number of Layers: {_numEncoderLayers}");
+        sb.AppendLine($"  Attention Heads: {_numEncoderHeads}");
+        sb.AppendLine($"  Patch Size: {_patchSize}");
+        sb.AppendLine();
+        sb.AppendLine("Decoder:");
+        sb.AppendLine($"  Hidden Dimension: {_decoderHiddenDim}");
+        sb.AppendLine($"  Number of Layers: {_numDecoderLayers}");
+        sb.AppendLine($"  Attention Heads: {_numDecoderHeads}");
+        sb.AppendLine();
+        sb.AppendLine($"Image Size: {ImageSize}x{ImageSize}");
+        sb.AppendLine($"Vocabulary Size: {_vocabSize}");
+        sb.AppendLine($"Max Sequence Length: {_maxSequenceLength}");
+        sb.AppendLine($"Total Layers: {Layers.Count}");
+        sb.AppendLine($"Attention Visualization: {SupportsAttentionVisualization}");
+        return sb.ToString();
+    }
+
+    #endregion
+
+    #region Preprocessing
+
+    /// <summary>
+    /// Applies TrOCR's industry-standard preprocessing: normalize to [-1, 1].
+    /// </summary>
+    /// <remarks>
+    /// TrOCR (Transformer-based OCR) uses mean=0.5, std=0.5 normalization
+    /// (same as DeiT/BEiT) from Microsoft paper.
+    /// </remarks>
+    protected override Tensor<T> ApplyDefaultPreprocessing(Tensor<T> rawImage)
+    {
+        var image = EnsureBatchDimension(rawImage);
+
+        int batchSize = image.Shape[0];
+        int channels = image.Shape[1];
+        int height = image.Shape[2];
+        int width = image.Shape[3];
+
+        var normalized = new Tensor<T>(image._shape);
+
+        // TrOCR normalization (same as DeiT/BEiT)
+        double[] means = [0.5, 0.5, 0.5];
+        double[] stds = [0.5, 0.5, 0.5];
+
+        for (int b = 0; b < batchSize; b++)
+        {
+            for (int c = 0; c < channels; c++)
+            {
+                double mean = c < means.Length ? means[c] : 0.5;
+                double std = c < stds.Length ? stds[c] : 0.5;
+
+                for (int h = 0; h < height; h++)
+                {
+                    for (int w = 0; w < width; w++)
+                    {
+                        int idx = b * channels * height * width + c * height * width + h * width + w;
+                        double value = NumOps.ToDouble(image.Data.Span[idx]);
+                        normalized.Data.Span[idx] = NumOps.FromDouble((value - mean) / std);
+                    }
+                }
+            }
+        }
+
+        return normalized;
+    }
+
+    /// <summary>
+    /// Applies TrOCR's industry-standard postprocessing: pass-through (encoder-decoder outputs are already final).
+    /// </summary>
+    protected override Tensor<T> ApplyDefaultPostprocessing(Tensor<T> modelOutput)
+    {
+        return modelOutput;
+    }
+
+    #endregion
+
+    #region Serialization
+
+    /// <inheritdoc/>
+    public override ModelMetadata<T> GetModelMetadata()
+    {
+        return new ModelMetadata<T>
+        {
+            Name = "TrOCR",
+            Description = "Transformer-based OCR with ViT encoder (AAAI 2022)",
+            FeatureCount = _decoderHiddenDim,
+            Complexity = _numEncoderLayers + _numDecoderLayers,
+            AdditionalInfo = new Dictionary<string, object>
+            {
+                { "encoder_hidden_dim", _encoderHiddenDim },
+                { "decoder_hidden_dim", _decoderHiddenDim },
+                { "num_encoder_layers", _numEncoderLayers },
+                { "num_decoder_layers", _numDecoderLayers },
+                { "num_encoder_heads", _numEncoderHeads },
+                { "num_decoder_heads", _numDecoderHeads },
+                { "patch_size", _patchSize },
+                { "vocab_size", _vocabSize },
+                { "max_sequence_length", _maxSequenceLength },
+                { "image_size", ImageSize },
+                { "use_native_mode", _useNativeMode }
+            },
+            ModelData = SafeSerialize()
+        };
+    }
+
+    /// <inheritdoc/>
+
+
+    /// <inheritdoc/>
+
+
+    #endregion
+
+    #region NeuralNetworkBase Implementation
+
+    /// <inheritdoc/>
+    protected override Tensor<T> PredictCore(Tensor<T> input)
+    {
+        var preprocessed = PreprocessDocument(input);
+        return _useNativeMode ? RunEncoder(preprocessed) : RunOnnxInference(preprocessed);
+    }
+
+    /// <inheritdoc/>
+    public override void Train(Tensor<T> input, Tensor<T> expectedOutput)
+    {
+        if (!_useNativeMode)
+        {
+            throw new NotSupportedException("Training is not supported in ONNX inference mode.");
+        }
+
+        SetTrainingMode(true);
+
+        TrainWithTape(input, expectedOutput, _optimizer);
+        var paramGradients = CollectParameterGradients();
+        UpdateParameters(paramGradients);
+        SetTrainingMode(false);}
+
+    // UpdateParameters applied a GRADIENT STEP, but its one-argument form is the value setter and every caller passes values -- the override corrupted the model. Removed under AIDN082.
+
+
+    /// <summary>
+    /// Parameters cannot be written while the model is backed by a loaded ONNX graph: the weights
+    /// belong to that graph, not to this instance.
+    /// </summary>
+    /// <remarks>
+    /// Replaces a hand-written throw that used to sit inside UpdateParameters. The base checks this
+    /// on every mutating entry point rather than the one member the throw happened to guard, and
+    /// reading -- ParameterCount and GetParameters -- stays available either way.
+    /// </remarks>
     protected override bool SupportsParameterMutation => _useNativeMode;
-    private Vector<T> CollectParameterGradients()
-    {
-        var gradients = new List<T>();
-
-        foreach (var layer in Layers)
-        {
-            var layerGradients = layer.GetParameterGradients();
-            gradients.AddRange(layerGradients);
-        }
-
-        return new Vector<T>([.. gradients]);
-    }
-
-    #endregion
-
-    #region Disposal
-
-    /// <inheritdoc/>
-    protected override void Dispose(bool disposing)
-    {
-        if (disposing)
-        {
-            _onnxEncoderSession?.Dispose();
-            _onnxDecoderSession?.Dispose();
-        }
-        base.Dispose(disposing);
-    }
-
-    #endregion
-}
+    private Vector<T> CollectParameterGradients()
+    {
+        var gradients = new List<T>();
+
+        foreach (var layer in Layers)
+        {
+            var layerGradients = layer.GetParameterGradients();
+            gradients.AddRange(layerGradients);
+        }
+
+        return new Vector<T>([.. gradients]);
+    }
+
+    #endregion
+
+    #region Disposal
+
+    /// <inheritdoc/>
+    protected override void Dispose(bool disposing)
+    {
+        if (disposing)
+        {
+            _onnxEncoderSession?.Dispose();
+            _onnxDecoderSession?.Dispose();
+        }
+        base.Dispose(disposing);
+    }
+
+    #endregion
+}
diff --git a/src/Document/PixelToSequence/Dessurt.cs b/src/Document/PixelToSequence/Dessurt.cs
index e08a23c4aa..bf0e8f107f 100644
--- a/src/Document/PixelToSequence/Dessurt.cs
+++ b/src/Document/PixelToSequence/Dessurt.cs
@@ -1,662 +1,618 @@
-using AiDotNet.Attributes;
-using AiDotNet.Document.Interfaces;
-using AiDotNet.Document.Options;
-using AiDotNet.Enums;
-using AiDotNet.Helpers;
-using AiDotNet.Interfaces;
-using AiDotNet.LinearAlgebra;
-using AiDotNet.LossFunctions;
-using AiDotNet.Models.Options;
-using AiDotNet.NeuralNetworks;
-using AiDotNet.NeuralNetworks.Layers;
-using AiDotNet.Optimizers;
-using Microsoft.ML.OnnxRuntime;
-
-namespace AiDotNet.Document.PixelToSequence;
-
-/// <summary>
-/// Dessurt (Document End-to-end Self-Supervised Understanding and RecogniTion) for document understanding.
-/// </summary>
-/// <typeparam name="T">The numeric type used for calculations.</typeparam>
-/// <remarks>
-/// <para>
-/// Dessurt is a self-supervised pre-training approach for document understanding that learns
-/// from document images without any labeled data. It uses a denoising autoencoder objective
-/// to learn robust document representations.
-/// </para>
-/// <para>
-/// <b>For Beginners:</b> Dessurt learns document understanding without labels:
-/// 1. Pre-trains by reconstructing corrupted document images
-/// 2. Learns to understand text, layout, and visual patterns
-/// 3. Fine-tunes on downstream tasks with minimal supervision
-///
-/// Key features:
-/// - Self-supervised pre-training (no labels needed)
-/// - Denoising autoencoder objective
-/// - Vision encoder + text decoder architecture
-/// - OCR-free document understanding
-///
-/// Example usage:
-/// <code>
-/// var model = new Dessurt&lt;float&gt;(architecture);
-/// var result = model.GenerateText(documentImage, "Extract all text");
-/// </code>
-/// </para>
-/// <para>
-/// <b>Reference:</b> "Dessurt: A Dessert for Document Understanding" (arXiv 2022)
-/// https://arxiv.org/abs/2203.16618
-/// </para>
-/// </remarks>
-[ModelDomain(ModelDomain.Vision)]
-[ModelDomain(ModelDomain.Language)]
-[ModelCategory(ModelCategory.NeuralNetwork)]
-[ModelCategory(ModelCategory.Transformer)]
-[ModelTask(ModelTask.Classification)]
-[ModelTask(ModelTask.FeatureExtraction)]
-[ModelComplexity(ModelComplexity.High)]
-[ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
-[ResearchPaper("Dessurt: A Dessert for Document Understanding Transformer", "https://doi.org/10.48550/arXiv.2203.16618", Year = 2022, Authors = "Brian Davis, Bryan Morse, Brian Price, Chris Tensmeyer, Curtis Wigington")]
-public partial class Dessurt<T> : DocumentNeuralNetworkBase<T>, IDocumentQA<T>
-{
-    private readonly DessurtOptions _options;
-
-    /// <inheritdoc/>
-    public override ModelOptions GetOptions() => _options;
-
-    #region Fields
-
-    private readonly bool _useNativeMode;
-    private readonly InferenceSession? _onnxSession;
-    private readonly IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>> _optimizer;
-    private readonly int _encoderDim;
-    private readonly int _decoderDim;
-    private readonly int _encoderLayers;
-    private readonly int _decoderLayers;
-    private readonly int _numHeads;
-    private readonly int _vocabSize;
-
-    // Native mode layers
-    private readonly List<ILayer<T>> _encoderLayersList = [];
-    private readonly List<ILayer<T>> _decoderLayersList = [];
-    private bool _nativeLayersInitialized;
-
-    // Learnable embeddings
-
-    #endregion
-
-    #region Properties
-
-    /// <inheritdoc/>
-    public override DocumentType SupportedDocumentTypes => DocumentType.All;
-
-    /// <inheritdoc/>
-    public override bool RequiresOCR => false;
-
-    /// <inheritdoc/>
-    public int ExpectedImageSize => ImageSize;
-
-    /// <summary>
-    /// Gets the encoder hidden dimension.
-    /// </summary>
-    public int EncoderDim => _encoderDim;
-
-    /// <summary>
-    /// Gets the decoder hidden dimension.
-    /// </summary>
-    public int DecoderDim => _decoderDim;
-
-    #endregion
-
-    #region Constructors
-
-    /// <summary>
-    /// Creates a Dessurt model using a pre-trained ONNX model for inference.
-    /// </summary>
-    public Dessurt(
-        NeuralNetworkArchitecture<T> architecture,
-        string onnxModelPath,
-        int imageSize = 1024,
-        int maxSequenceLength = 512,
-        int encoderDim = 1024,
-        int decoderDim = 768,
-        int encoderLayers = 24,
-        int decoderLayers = 12,
-        int numHeads = 16,
-        int vocabSize = 50265,
-        IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? optimizer = null,
-        ILossFunction<T>? lossFunction = null,
-        DessurtOptions? options = null)
-        : base(architecture, lossFunction ?? new CrossEntropyWithLogitsLoss<T>(), 1.0)
-    {
-        _options = options ?? new DessurtOptions();
-        Options = _options;
-
-        if (string.IsNullOrWhiteSpace(onnxModelPath))
-            throw new ArgumentNullException(nameof(onnxModelPath));
-        if (!File.Exists(onnxModelPath))
-            throw new FileNotFoundException($"ONNX model not found: {onnxModelPath}", onnxModelPath);
-
-        _useNativeMode = false;
-        _encoderDim = encoderDim;
-        _decoderDim = decoderDim;
-        _encoderLayers = encoderLayers;
-        _decoderLayers = decoderLayers;
-        _numHeads = numHeads;
-        _vocabSize = vocabSize;
-        _optimizer = optimizer ?? CreatePaperDefaultOptimizer();
-
-        ImageSize = imageSize;
-        MaxSequenceLength = maxSequenceLength;
-
-        _onnxSession = new InferenceSession(onnxModelPath);
-
-        InitializeLayers();
-    }
-
-    /// <summary>
-    /// Creates a Dessurt model using native layers for training and inference.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// <b>Default Configuration (Dessurt from arXiv 2022):</b>
-    /// - Vision encoder: ViT-Large style
-    /// - Text decoder: Transformer decoder
-    /// - Encoder: 24 layers, 1024 dim, 16 heads
-    /// - Decoder: 12 layers, 768 dim
-    /// - Pre-training: Denoising autoencoder
-    /// </para>
-    /// </remarks>
-    public Dessurt(
-        NeuralNetworkArchitecture<T> architecture,
-        int imageSize = 1024,
-        int maxSequenceLength = 512,
-        int encoderDim = 1024,
-        int decoderDim = 768,
-        int encoderLayers = 24,
-        int decoderLayers = 12,
-        int numHeads = 16,
-        int vocabSize = 50265,
-        IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? optimizer = null,
-        ILossFunction<T>? lossFunction = null,
-        DessurtOptions? options = null)
-        : base(architecture, lossFunction ?? new CrossEntropyWithLogitsLoss<T>(), 1.0)
-    {
-        _options = options ?? new DessurtOptions();
-        Options = _options;
-
-        _useNativeMode = true;
-        _encoderDim = encoderDim;
-        _decoderDim = decoderDim;
-        _encoderLayers = encoderLayers;
-        _decoderLayers = decoderLayers;
-        _numHeads = numHeads;
-        _vocabSize = vocabSize;
-        _optimizer = optimizer ?? CreatePaperDefaultOptimizer();
-
-        ImageSize = imageSize;
-        MaxSequenceLength = maxSequenceLength;
-
-        // Native layers/embeddings are materialized on first use to avoid
-        // constructor-time allocation for metadata and construction probes.
-        if (Architecture.Layers is { Count: > 0 })
-        {
-            EnsureNativeInitialized();
-        }
-    }
-
-    #endregion
-
-    /// <summary>
-    /// Creates the optimizer used by the original Dessurt training recipe.
-    /// </summary>
-    /// <remarks>
-    /// Davis et al. use AdamW with a learning rate of 1e-4 and weight decay of
-    /// 0.01 (section 4.6). A caller-supplied optimizer still takes precedence in
-    /// both constructors, so every optimizer and hyperparameter remains fully
-    /// customizable.
-    /// </remarks>
-    private IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>> CreatePaperDefaultOptimizer()
-        => new AdamWOptimizer<T, Tensor<T>, Tensor<T>>(
-            this,
-            new AdamWOptimizerOptions<T, Tensor<T>, Tensor<T>>
-            {
-                InitialLearningRate = 1e-4,
-                WeightDecay = 0.01
-            });
-
-    #region Initialization
-
-    /// <inheritdoc/>
-    protected override void InitializeLayers()
-    {
-        if (!_useNativeMode)
-        {
-            return;
-        }
-
-        if (Architecture.Layers is not null && Architecture.Layers.Count > 0)
-        {
-            Layers.AddRange(Architecture.Layers);
-            ValidateCustomLayers(Layers);
-            return;
-        }
-
-        var (encoderLayers, decoderLayers) = LayerHelper<T>.CreateDefaultDessurtLayers(
-            encoderDim: _encoderDim,
-            decoderDim: _decoderDim,
-            encoderLayers: _encoderLayers,
-            decoderLayers: _decoderLayers,
-            numHeads: _numHeads,
-            vocabSize: _vocabSize);
-
-        _encoderLayersList.AddRange(encoderLayers);
-        _decoderLayersList.AddRange(decoderLayers);
-        Layers.AddRange(encoderLayers);
-        Layers.AddRange(decoderLayers);
-    }
-
-    private void InitializeEmbeddings()
-    {
-        var random = RandomHelper.CreateSeededRandom(42);
-        int numPatches = (ImageSize / 16) * (ImageSize / 16);
-
-
-    }
-
-    /// <summary>
-    /// Ensures native layers and embeddings are initialized on first use.
-    /// </summary>
-    /// <remarks>
-    /// This method is not thread-safe during initialization. Native document
-    /// models must be initialized on one thread before concurrent access; calling
-    /// this on a freshly constructed instance from multiple threads can corrupt
-    /// the shared layer and embedding state.
-    /// </remarks>
-    private void EnsureNativeInitialized()
-    {
-        if (!_useNativeMode || _nativeLayersInitialized)
-        {
-            return;
-        }
-
-        InitializeLayers();
-        InitializeEmbeddings();
-        _nativeLayersInitialized = true;
-        InvalidateParameterCountCache();
-    }
-
-    private void InitializeWithSmallRandomValues(Tensor<T> tensor, Random random, double stdDev)
-    {
-        for (int i = 0; i < tensor.Data.Length; i++)
-        {
-            double u1 = 1.0 - random.NextDouble();
-            double u2 = 1.0 - random.NextDouble();
-            double randStdNormal = Math.Sqrt(-2.0 * Math.Log(u1)) * Math.Sin(2.0 * Math.PI * u2);
-            tensor.Data.Span[i] = NumOps.FromDouble(randStdNormal * stdDev);
-        }
-    }
-
-    #endregion
-
-    #region IDocumentQA Implementation
-
-    /// <inheritdoc/>
-    public DocumentQAResult<T> AnswerQuestion(Tensor<T> documentImage, string question)
-    {
-        return AnswerQuestion(documentImage, question, 128, 0.0);
-    }
-
-    /// <inheritdoc/>
-    public DocumentQAResult<T> AnswerQuestion(Tensor<T> documentImage, string question, int maxAnswerLength, double temperature = 0.0)
-    {
-        ValidateImageShape(documentImage);
-        var startTime = DateTime.UtcNow;
-
-        var preprocessed = PreprocessDocument(documentImage);
-        var output = _useNativeMode
-            ? ForwardAfterNativeInitialization(preprocessed)
-            : RunOnnxInference(preprocessed);
-
-        // Decode output to text
-        var answer = DecodeOutput(output, maxAnswerLength);
-
-        return new DocumentQAResult<T>
-        {
-            Answer = answer,
-            Confidence = NumOps.FromDouble(0.85),
-            ConfidenceValue = 0.85,
-            Question = question,
-            ProcessingTimeMs = (DateTime.UtcNow - startTime).TotalMilliseconds
-        };
-    }
-
-    /// <inheritdoc/>
-    public IEnumerable<DocumentQAResult<T>> AnswerQuestions(Tensor<T> documentImage, IEnumerable<string> questions)
-    {
-        foreach (var q in questions)
-            yield return AnswerQuestion(documentImage, q);
-    }
-
-    /// <inheritdoc/>
-    public Dictionary<string, DocumentQAResult<T>> ExtractFields(Tensor<T> documentImage, IEnumerable<string> fieldPrompts)
-    {
-        var results = new Dictionary<string, DocumentQAResult<T>>();
-        foreach (var field in fieldPrompts)
-            results[field] = AnswerQuestion(documentImage, $"What is the {field}?");
-        return results;
-    }
-
-    private string DecodeOutput(Tensor<T> output, int maxLength)
-    {
-        // Greedy decoding with token-to-character conversion
-        var tokens = new List<int>();
-        int seqLen = Math.Min(output.Shape[0], maxLength);
-
-        for (int t = 0; t < seqLen; t++)
-        {
-            int vocabSize = output.Shape.Length > 1 ? output.Shape[1] : _vocabSize;
-            double maxVal = double.MinValue;
-            int maxIdx = 0;
-
-            for (int v = 0; v < vocabSize; v++)
-            {
-                double val = NumOps.ToDouble(output[t, v]);
-                if (val > maxVal) { maxVal = val; maxIdx = v; }
-            }
-
-            // Special tokens: 0=PAD, 1=BOS, 2=EOS
-            if (maxIdx == 2) break; // EOS token
-            if (maxIdx <= 2) continue; // Skip special tokens
-            tokens.Add(maxIdx);
-        }
-
-        return DecodeTokensToText(tokens);
-    }
-
-    /// <summary>
-    /// Converts token IDs to text using character-level decoding.
-    /// </summary>
-    /// <remarks>
-    /// Token mapping:
-    /// 0-2: Special tokens (PAD, BOS, EOS)
-    /// 3-34: Digits and punctuation (offset by 3 from ASCII 32)
-    /// 35-60: Uppercase letters (A-Z, offset from ASCII 65)
-    /// 61-86: Lowercase letters (a-z, offset from ASCII 97)
-    /// 87+: Extended characters
-    /// </remarks>
-    private static string DecodeTokensToText(List<int> tokens)
-    {
-        if (tokens.Count == 0) return string.Empty;
-
-        var sb = new System.Text.StringBuilder();
-        foreach (int token in tokens)
-        {
-            // Map token ID to character
-            char c = token switch
-            {
-                >= 3 and <= 34 => (char)(token - 3 + 32),   // Space, punctuation, digits
-                >= 35 and <= 60 => (char)(token - 35 + 65), // A-Z
-                >= 61 and <= 86 => (char)(token - 61 + 97), // a-z
-                >= 87 and <= 214 => (char)(token - 87 + 128), // Extended ASCII
-                _ => '?' // Unknown token
-            };
-            sb.Append(c);
-        }
-
-        return sb.ToString();
-    }
-
-    #endregion
-
-    #region IDocumentModel Implementation
-
-    /// <inheritdoc/>
-    public Tensor<T> EncodeDocument(Tensor<T> documentImage)
-    {
-        ValidateImageShape(documentImage);
-        var preprocessed = PreprocessDocument(documentImage);
-        return _useNativeMode
-            ? ForwardAfterNativeInitialization(preprocessed)
-            : RunOnnxInference(preprocessed);
-    }
-
-    /// <inheritdoc/>
-    public void ValidateInputShape(Tensor<T> documentImage)
-    {
-        ValidateImageShape(documentImage);
-    }
-
-    /// <inheritdoc/>
-    public string GetModelSummary()
-    {
-        var sb = new System.Text.StringBuilder();
-        sb.AppendLine("Dessurt Model Summary");
-        sb.AppendLine("=====================");
-        sb.AppendLine($"Mode: {(_useNativeMode ? "Native (Trainable)" : "ONNX (Inference)")}");
-        sb.AppendLine($"Architecture: Vision Encoder + Text Decoder");
-        sb.AppendLine($"Encoder Dimension: {_encoderDim}");
-        sb.AppendLine($"Decoder Dimension: {_decoderDim}");
-        sb.AppendLine($"Encoder Layers: {_encoderLayers}");
-        sb.AppendLine($"Decoder Layers: {_decoderLayers}");
-        sb.AppendLine($"Attention Heads: {_numHeads}");
-        sb.AppendLine($"Image Size: {ImageSize}x{ImageSize}");
-        sb.AppendLine($"Max Sequence Length: {MaxSequenceLength}");
-        sb.AppendLine($"Vocabulary Size: {_vocabSize}");
-        sb.AppendLine($"OCR-Free: Yes");
-        sb.AppendLine($"Self-Supervised: Yes");
-        sb.AppendLine($"Total Layers: {Layers.Count}");
-        return sb.ToString();
-    }
-
-    #endregion
-
-    #region Preprocessing
-
-    /// <summary>
-    /// Applies Dessurt's industry-standard preprocessing: ImageNet normalization.
-    /// </summary>
-    /// <remarks>
-    /// Dessurt (Document understanding with Spatially-structured Retrieval and Token) uses
-    /// ImageNet normalization with mean=[0.485, 0.456, 0.406] and std=[0.229, 0.224, 0.225].
-    /// </remarks>
-    protected override Tensor<T> ApplyDefaultPreprocessing(Tensor<T> rawImage)
-    {
-        var image = EnsureBatchDimension(rawImage);
-        int batchSize = image.Shape[0];
-        int channels = image.Shape[1];
-        int height = image.Shape[2];
-        int width = image.Shape[3];
-
-        var normalized = new Tensor<T>(image._shape);
-        double[] means = [0.485, 0.456, 0.406];
-        double[] stds = [0.229, 0.224, 0.225];
-
-        for (int b = 0; b < batchSize; b++)
-        {
-            for (int c = 0; c < channels; c++)
-            {
-                double mean = c < means.Length ? means[c] : 0.5;
-                double std = c < stds.Length ? stds[c] : 0.5;
-                for (int h = 0; h < height; h++)
-                {
-                    for (int w = 0; w < width; w++)
-                    {
-                        int idx = b * channels * height * width + c * height * width + h * width + w;
-                        normalized.Data.Span[idx] = NumOps.FromDouble((NumOps.ToDouble(image.Data.Span[idx]) - mean) / std);
-                    }
-                }
-            }
-        }
-        return normalized;
-    }
-
-    /// <summary>
-    /// Applies Dessurt's industry-standard postprocessing: pass-through (sequence outputs are already final).
-    /// </summary>
-    protected override Tensor<T> ApplyDefaultPostprocessing(Tensor<T> modelOutput) => modelOutput;
-
-    #endregion
-
-    #region Serialization
-
-    /// <inheritdoc/>
-    public override ModelMetadata<T> GetModelMetadata()
-    {
-        return new ModelMetadata<T>
-        {
-            Name = "Dessurt",
-            Description = "Dessurt for self-supervised document understanding (arXiv 2022)",
-            FeatureCount = _encoderDim,
-            Complexity = _encoderLayers + _decoderLayers,
-            AdditionalInfo = new Dictionary<string, object>
-            {
-                { "encoder_dim", _encoderDim },
-                { "decoder_dim", _decoderDim },
-                { "encoder_layers", _encoderLayers },
-                { "decoder_layers", _decoderLayers },
-                { "num_heads", _numHeads },
-                { "vocab_size", _vocabSize },
-                { "image_size", ImageSize },
-                { "use_native_mode", _useNativeMode }
-            },
-            ModelData = SafeSerializeMaterializedModel()
-        };
-    }
-
-    private byte[] SafeSerializeMaterializedModel()
-    {
-        return _useNativeMode && !_nativeLayersInitialized
-            ? Array.Empty<byte>()
-            : SafeSerialize();
-    }
-
-    /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_encoderDim);
-        writer.Write(_decoderDim);
-        writer.Write(_encoderLayers);
-        writer.Write(_decoderLayers);
-        writer.Write(_numHeads);
-        writer.Write(_vocabSize);
-        writer.Write(ImageSize);
-        writer.Write(MaxSequenceLength);
-        writer.Write(_useNativeMode);
-    }
-
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        int encoderDim = reader.ReadInt32();
-        int decoderDim = reader.ReadInt32();
-        int encoderLayers = reader.ReadInt32();
-        int decoderLayers = reader.ReadInt32();
-        int numHeads = reader.ReadInt32();
-        int vocabSize = reader.ReadInt32();
-        int imageSize = reader.ReadInt32();
-        int maxSeqLen = reader.ReadInt32();
-        bool useNativeMode = reader.ReadBoolean();
-
-        ImageSize = imageSize;
-        MaxSequenceLength = maxSeqLen;
-        _nativeLayersInitialized = Layers.Count > 0;
-    }
-
-    /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var model = new Dessurt<T>(Architecture, ImageSize, MaxSequenceLength, _encoderDim, _decoderDim,
-            _encoderLayers, _decoderLayers, _numHeads, _vocabSize);
-        if (_nativeLayersInitialized)
-        {
-            model.EnsureNativeInitialized();
-        }
-
-        return model;
-    }
-
-    #endregion
-
-    #region NeuralNetworkBase Implementation
-
-    /// <inheritdoc/>
-    protected override Tensor<T> PredictCore(Tensor<T> input)
-    {
-        var preprocessed = PreprocessDocument(input);
-        return _useNativeMode
-            ? ForwardAfterNativeInitialization(preprocessed)
-            : RunOnnxInference(preprocessed);
-    }
-
-    private Tensor<T> ForwardAfterNativeInitialization(Tensor<T> input)
-    {
-        EnsureNativeInitialized();
-        return Forward(input);
-    }
-
-    /// <inheritdoc/>
-    public override void Train(Tensor<T> input, Tensor<T> expectedOutput)
-    {
-        if (!_useNativeMode)
-            throw new NotSupportedException("Training not supported in ONNX mode.");
-
-        EnsureNativeInitialized();
-        SetTrainingMode(true);
-        try
-        {
-            // TrainWithTape already performs the optimizer step. The previous
-            // implementation followed it with UpdateParameters(CollectGradients),
-            // applying a second, fixed-rate update and causing longer training
-            // runs to drift upward. Use the caller-supplied optimizer as the
-            // single source of truth and fail loudly if it cannot drive tape
-            // gradients instead of silently substituting the base optimizer.
-            var gradientOptimizer = _optimizer
-                ?? throw new InvalidOperationException(
-                    "Dessurt training requires an optimizer implementing " +
-                    "IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>.");
-            // PredictCore evaluates the ImageNet-normalized document. Train on that same
-            // representation so the optimizer descends the objective users observe from
-            // Predict instead of fitting raw pixels and being evaluated on normalized ones.
-            TrainWithTape(PreprocessDocument(input), expectedOutput, gradientOptimizer);
-        }
-        finally
-        {
-            SetTrainingMode(false);
-        }
-    }
-
-    // UpdateParameters applied a GRADIENT STEP, but its one-argument form is the value setter and every caller passes values -- the override corrupted the model. Removed under AIDN082.

-
-    /// <summary>
-    /// Parameters cannot be written while the model is backed by a loaded ONNX graph: the weights
-    /// belong to that graph, not to this instance.
-    /// </summary>
-    /// <remarks>
-    /// Replaces a hand-written throw that used to sit inside UpdateParameters. The base checks this
-    /// on every mutating entry point rather than the one member the throw happened to guard, and
-    /// reading -- ParameterCount and GetParameters -- stays available either way.
-    /// </remarks>
+using AiDotNet.Attributes;
+using AiDotNet.Document.Interfaces;
+using AiDotNet.Document.Options;
+using AiDotNet.Enums;
+using AiDotNet.Helpers;
+using AiDotNet.Interfaces;
+using AiDotNet.LinearAlgebra;
+using AiDotNet.LossFunctions;
+using AiDotNet.Models.Options;
+using AiDotNet.NeuralNetworks;
+using AiDotNet.NeuralNetworks.Layers;
+using AiDotNet.Optimizers;
+using Microsoft.ML.OnnxRuntime;
+
+namespace AiDotNet.Document.PixelToSequence;
+
+/// <summary>
+/// Dessurt (Document End-to-end Self-Supervised Understanding and RecogniTion) for document understanding.
+/// </summary>
+/// <typeparam name="T">The numeric type used for calculations.</typeparam>
+/// <remarks>
+/// <para>
+/// Dessurt is a self-supervised pre-training approach for document understanding that learns
+/// from document images without any labeled data. It uses a denoising autoencoder objective
+/// to learn robust document representations.
+/// </para>
+/// <para>
+/// <b>For Beginners:</b> Dessurt learns document understanding without labels:
+/// 1. Pre-trains by reconstructing corrupted document images
+/// 2. Learns to understand text, layout, and visual patterns
+/// 3. Fine-tunes on downstream tasks with minimal supervision
+///
+/// Key features:
+/// - Self-supervised pre-training (no labels needed)
+/// - Denoising autoencoder objective
+/// - Vision encoder + text decoder architecture
+/// - OCR-free document understanding
+///
+/// Example usage:
+/// <code>
+/// var model = new Dessurt&lt;float&gt;(architecture);
+/// var result = model.GenerateText(documentImage, "Extract all text");
+/// </code>
+/// </para>
+/// <para>
+/// <b>Reference:</b> "Dessurt: A Dessert for Document Understanding" (arXiv 2022)
+/// https://arxiv.org/abs/2203.16618
+/// </para>
+/// </remarks>
+[ModelDomain(ModelDomain.Vision)]
+[ModelDomain(ModelDomain.Language)]
+[ModelCategory(ModelCategory.NeuralNetwork)]
+[ModelCategory(ModelCategory.Transformer)]
+[ModelTask(ModelTask.Classification)]
+[ModelTask(ModelTask.FeatureExtraction)]
+[ModelComplexity(ModelComplexity.High)]
+[ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
+[ResearchPaper("Dessurt: A Dessert for Document Understanding Transformer", "https://doi.org/10.48550/arXiv.2203.16618", Year = 2022, Authors = "Brian Davis, Bryan Morse, Brian Price, Chris Tensmeyer, Curtis Wigington")]
+public partial class Dessurt<T> : DocumentNeuralNetworkBase<T>, IDocumentQA<T>
+{
+    private readonly DessurtOptions _options;
+
+    /// <inheritdoc/>
+    public override ModelOptions GetOptions() => _options;
+
+    #region Fields
+
+    private readonly bool _useNativeMode;
+    private readonly InferenceSession? _onnxSession;
+    private readonly IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>> _optimizer;
+    private readonly int _encoderDim;
+    private readonly int _decoderDim;
+    private readonly int _encoderLayers;
+    private readonly int _decoderLayers;
+    private readonly int _numHeads;
+    private readonly int _vocabSize;
+
+    // Native mode layers
+    private readonly List<ILayer<T>> _encoderLayersList = [];
+    private readonly List<ILayer<T>> _decoderLayersList = [];
+    private bool _nativeLayersInitialized;
+
+    // Learnable embeddings
+
+    #endregion
+
+    #region Properties
+
+    /// <inheritdoc/>
+    public override DocumentType SupportedDocumentTypes => DocumentType.All;
+
+    /// <inheritdoc/>
+    public override bool RequiresOCR => false;
+
+    /// <inheritdoc/>
+    public int ExpectedImageSize => ImageSize;
+
+    /// <summary>
+    /// Gets the encoder hidden dimension.
+    /// </summary>
+    public int EncoderDim => _encoderDim;
+
+    /// <summary>
+    /// Gets the decoder hidden dimension.
+    /// </summary>
+    public int DecoderDim => _decoderDim;
+
+    #endregion
+
+    #region Constructors
+
+    /// <summary>
+    /// Creates a Dessurt model using a pre-trained ONNX model for inference.
+    /// </summary>
+    public Dessurt(
+        NeuralNetworkArchitecture<T> architecture,
+        string onnxModelPath,
+        int imageSize = 1024,
+        int maxSequenceLength = 512,
+        int encoderDim = 1024,
+        int decoderDim = 768,
+        int encoderLayers = 24,
+        int decoderLayers = 12,
+        int numHeads = 16,
+        int vocabSize = 50265,
+        IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? optimizer = null,
+        ILossFunction<T>? lossFunction = null,
+        DessurtOptions? options = null)
+        : base(architecture, lossFunction ?? new CrossEntropyWithLogitsLoss<T>(), 1.0)
+    {
+        _options = options ?? new DessurtOptions();
+        Options = _options;
+
+        if (string.IsNullOrWhiteSpace(onnxModelPath))
+            throw new ArgumentNullException(nameof(onnxModelPath));
+        if (!File.Exists(onnxModelPath))
+            throw new FileNotFoundException($"ONNX model not found: {onnxModelPath}", onnxModelPath);
+
+        _useNativeMode = false;
+        _encoderDim = encoderDim;
+        _decoderDim = decoderDim;
+        _encoderLayers = encoderLayers;
+        _decoderLayers = decoderLayers;
+        _numHeads = numHeads;
+        _vocabSize = vocabSize;
+        _optimizer = optimizer ?? CreatePaperDefaultOptimizer();
+
+        ImageSize = imageSize;
+        MaxSequenceLength = maxSequenceLength;
+
+        _onnxSession = new InferenceSession(onnxModelPath);
+
+        InitializeLayers();
+    }
+
+    /// <summary>
+    /// Creates a Dessurt model using native layers for training and inference.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// <b>Default Configuration (Dessurt from arXiv 2022):</b>
+    /// - Vision encoder: ViT-Large style
+    /// - Text decoder: Transformer decoder
+    /// - Encoder: 24 layers, 1024 dim, 16 heads
+    /// - Decoder: 12 layers, 768 dim
+    /// - Pre-training: Denoising autoencoder
+    /// </para>
+    /// </remarks>
+    public Dessurt(
+        NeuralNetworkArchitecture<T> architecture,
+        int imageSize = 1024,
+        int maxSequenceLength = 512,
+        int encoderDim = 1024,
+        int decoderDim = 768,
+        int encoderLayers = 24,
+        int decoderLayers = 12,
+        int numHeads = 16,
+        int vocabSize = 50265,
+        IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? optimizer = null,
+        ILossFunction<T>? lossFunction = null,
+        DessurtOptions? options = null)
+        : base(architecture, lossFunction ?? new CrossEntropyWithLogitsLoss<T>(), 1.0)
+    {
+        _options = options ?? new DessurtOptions();
+        Options = _options;
+
+        _useNativeMode = true;
+        _encoderDim = encoderDim;
+        _decoderDim = decoderDim;
+        _encoderLayers = encoderLayers;
+        _decoderLayers = decoderLayers;
+        _numHeads = numHeads;
+        _vocabSize = vocabSize;
+        _optimizer = optimizer ?? CreatePaperDefaultOptimizer();
+
+        ImageSize = imageSize;
+        MaxSequenceLength = maxSequenceLength;
+
+        // Native layers/embeddings are materialized on first use to avoid
+        // constructor-time allocation for metadata and construction probes.
+        if (Architecture.Layers is { Count: > 0 })
+        {
+            EnsureNativeInitialized();
+        }
+    }
+
+    #endregion
+
+    /// <summary>
+    /// Creates the optimizer used by the original Dessurt training recipe.
+    /// </summary>
+    /// <remarks>
+    /// Davis et al. use AdamW with a learning rate of 1e-4 and weight decay of
+    /// 0.01 (section 4.6). A caller-supplied optimizer still takes precedence in
+    /// both constructors, so every optimizer and hyperparameter remains fully
+    /// customizable.
+    /// </remarks>
+    private IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>> CreatePaperDefaultOptimizer()
+        => new AdamWOptimizer<T, Tensor<T>, Tensor<T>>(
+            this,
+            new AdamWOptimizerOptions<T, Tensor<T>, Tensor<T>>
+            {
+                InitialLearningRate = 1e-4,
+                WeightDecay = 0.01
+            });
+
+    #region Initialization
+
+    /// <inheritdoc/>
+    protected override void InitializeLayers()
+    {
+        if (!_useNativeMode)
+        {
+            return;
+        }
+
+        if (Architecture.Layers is not null && Architecture.Layers.Count > 0)
+        {
+            Layers.AddRange(Architecture.Layers);
+            ValidateCustomLayers(Layers);
+            return;
+        }
+
+        var (encoderLayers, decoderLayers) = LayerHelper<T>.CreateDefaultDessurtLayers(
+            encoderDim: _encoderDim,
+            decoderDim: _decoderDim,
+            encoderLayers: _encoderLayers,
+            decoderLayers: _decoderLayers,
+            numHeads: _numHeads,
+            vocabSize: _vocabSize);
+
+        _encoderLayersList.AddRange(encoderLayers);
+        _decoderLayersList.AddRange(decoderLayers);
+        Layers.AddRange(encoderLayers);
+        Layers.AddRange(decoderLayers);
+    }
+
+    private void InitializeEmbeddings()
+    {
+        var random = RandomHelper.CreateSeededRandom(42);
+        int numPatches = (ImageSize / 16) * (ImageSize / 16);
+
+
+    }
+
+    /// <summary>
+    /// Ensures native layers and embeddings are initialized on first use.
+    /// </summary>
+    /// <remarks>
+    /// This method is not thread-safe during initialization. Native document
+    /// models must be initialized on one thread before concurrent access; calling
+    /// this on a freshly constructed instance from multiple threads can corrupt
+    /// the shared layer and embedding state.
+    /// </remarks>
+    private void EnsureNativeInitialized()
+    {
+        if (!_useNativeMode || _nativeLayersInitialized)
+        {
+            return;
+        }
+
+        InitializeLayers();
+        InitializeEmbeddings();
+        _nativeLayersInitialized = true;
+        InvalidateParameterCountCache();
+    }
+
+    private void InitializeWithSmallRandomValues(Tensor<T> tensor, Random random, double stdDev)
+    {
+        for (int i = 0; i < tensor.Data.Length; i++)
+        {
+            double u1 = 1.0 - random.NextDouble();
+            double u2 = 1.0 - random.NextDouble();
+            double randStdNormal = Math.Sqrt(-2.0 * Math.Log(u1)) * Math.Sin(2.0 * Math.PI * u2);
+            tensor.Data.Span[i] = NumOps.FromDouble(randStdNormal * stdDev);
+        }
+    }
+
+    #endregion
+
+    #region IDocumentQA Implementation
+
+    /// <inheritdoc/>
+    public DocumentQAResult<T> AnswerQuestion(Tensor<T> documentImage, string question)
+    {
+        return AnswerQuestion(documentImage, question, 128, 0.0);
+    }
+
+    /// <inheritdoc/>
+    public DocumentQAResult<T> AnswerQuestion(Tensor<T> documentImage, string question, int maxAnswerLength, double temperature = 0.0)
+    {
+        ValidateImageShape(documentImage);
+        var startTime = DateTime.UtcNow;
+
+        var preprocessed = PreprocessDocument(documentImage);
+        var output = _useNativeMode
+            ? ForwardAfterNativeInitialization(preprocessed)
+            : RunOnnxInference(preprocessed);
+
+        // Decode output to text
+        var answer = DecodeOutput(output, maxAnswerLength);
+
+        return new DocumentQAResult<T>
+        {
+            Answer = answer,
+            Confidence = NumOps.FromDouble(0.85),
+            ConfidenceValue = 0.85,
+            Question = question,
+            ProcessingTimeMs = (DateTime.UtcNow - startTime).TotalMilliseconds
+        };
+    }
+
+    /// <inheritdoc/>
+    public IEnumerable<DocumentQAResult<T>> AnswerQuestions(Tensor<T> documentImage, IEnumerable<string> questions)
+    {
+        foreach (var q in questions)
+            yield return AnswerQuestion(documentImage, q);
+    }
+
+    /// <inheritdoc/>
+    public Dictionary<string, DocumentQAResult<T>> ExtractFields(Tensor<T> documentImage, IEnumerable<string> fieldPrompts)
+    {
+        var results = new Dictionary<string, DocumentQAResult<T>>();
+        foreach (var field in fieldPrompts)
+            results[field] = AnswerQuestion(documentImage, $"What is the {field}?");
+        return results;
+    }
+
+    private string DecodeOutput(Tensor<T> output, int maxLength)
+    {
+        // Greedy decoding with token-to-character conversion
+        var tokens = new List<int>();
+        int seqLen = Math.Min(output.Shape[0], maxLength);
+
+        for (int t = 0; t < seqLen; t++)
+        {
+            int vocabSize = output.Shape.Length > 1 ? output.Shape[1] : _vocabSize;
+            double maxVal = double.MinValue;
+            int maxIdx = 0;
+
+            for (int v = 0; v < vocabSize; v++)
+            {
+                double val = NumOps.ToDouble(output[t, v]);
+                if (val > maxVal) { maxVal = val; maxIdx = v; }
+            }
+
+            // Special tokens: 0=PAD, 1=BOS, 2=EOS
+            if (maxIdx == 2) break; // EOS token
+            if (maxIdx <= 2) continue; // Skip special tokens
+            tokens.Add(maxIdx);
+        }
+
+        return DecodeTokensToText(tokens);
+    }
+
+    /// <summary>
+    /// Converts token IDs to text using character-level decoding.
+    /// </summary>
+    /// <remarks>
+    /// Token mapping:
+    /// 0-2: Special tokens (PAD, BOS, EOS)
+    /// 3-34: Digits and punctuation (offset by 3 from ASCII 32)
+    /// 35-60: Uppercase letters (A-Z, offset from ASCII 65)
+    /// 61-86: Lowercase letters (a-z, offset from ASCII 97)
+    /// 87+: Extended characters
+    /// </remarks>
+    private static string DecodeTokensToText(List<int> tokens)
+    {
+        if (tokens.Count == 0) return string.Empty;
+
+        var sb = new System.Text.StringBuilder();
+        foreach (int token in tokens)
+        {
+            // Map token ID to character
+            char c = token switch
+            {
+                >= 3 and <= 34 => (char)(token - 3 + 32),   // Space, punctuation, digits
+                >= 35 and <= 60 => (char)(token - 35 + 65), // A-Z
+                >= 61 and <= 86 => (char)(token - 61 + 97), // a-z
+                >= 87 and <= 214 => (char)(token - 87 + 128), // Extended ASCII
+                _ => '?' // Unknown token
+            };
+            sb.Append(c);
+        }
+
+        return sb.ToString();
+    }
+
+    #endregion
+
+    #region IDocumentModel Implementation
+
+    /// <inheritdoc/>
+    public Tensor<T> EncodeDocument(Tensor<T> documentImage)
+    {
+        ValidateImageShape(documentImage);
+        var preprocessed = PreprocessDocument(documentImage);
+        return _useNativeMode
+            ? ForwardAfterNativeInitialization(preprocessed)
+            : RunOnnxInference(preprocessed);
+    }
+
+    /// <inheritdoc/>
+    public void ValidateInputShape(Tensor<T> documentImage)
+    {
+        ValidateImageShape(documentImage);
+    }
+
+    /// <inheritdoc/>
+    public string GetModelSummary()
+    {
+        var sb = new System.Text.StringBuilder();
+        sb.AppendLine("Dessurt Model Summary");
+        sb.AppendLine("=====================");
+        sb.AppendLine($"Mode: {(_useNativeMode ? "Native (Trainable)" : "ONNX (Inference)")}");
+        sb.AppendLine($"Architecture: Vision Encoder + Text Decoder");
+        sb.AppendLine($"Encoder Dimension: {_encoderDim}");
+        sb.AppendLine($"Decoder Dimension: {_decoderDim}");
+        sb.AppendLine($"Encoder Layers: {_encoderLayers}");
+        sb.AppendLine($"Decoder Layers: {_decoderLayers}");
+        sb.AppendLine($"Attention Heads: {_numHeads}");
+        sb.AppendLine($"Image Size: {ImageSize}x{ImageSize}");
+        sb.AppendLine($"Max Sequence Length: {MaxSequenceLength}");
+        sb.AppendLine($"Vocabulary Size: {_vocabSize}");
+        sb.AppendLine($"OCR-Free: Yes");
+        sb.AppendLine($"Self-Supervised: Yes");
+        sb.AppendLine($"Total Layers: {Layers.Count}");
+        return sb.ToString();
+    }
+
+    #endregion
+
+    #region Preprocessing
+
+    /// <summary>
+    /// Applies Dessurt's industry-standard preprocessing: ImageNet normalization.
+    /// </summary>
+    /// <remarks>
+    /// Dessurt (Document understanding with Spatially-structured Retrieval and Token) uses
+    /// ImageNet normalization with mean=[0.485, 0.456, 0.406] and std=[0.229, 0.224, 0.225].
+    /// </remarks>
+    protected override Tensor<T> ApplyDefaultPreprocessing(Tensor<T> rawImage)
+    {
+        var image = EnsureBatchDimension(rawImage);
+        int batchSize = image.Shape[0];
+        int channels = image.Shape[1];
+        int height = image.Shape[2];
+        int width = image.Shape[3];
+
+        var normalized = new Tensor<T>(image._shape);
+        double[] means = [0.485, 0.456, 0.406];
+        double[] stds = [0.229, 0.224, 0.225];
+
+        for (int b = 0; b < batchSize; b++)
+        {
+            for (int c = 0; c < channels; c++)
+            {
+                double mean = c < means.Length ? means[c] : 0.5;
+                double std = c < stds.Length ? stds[c] : 0.5;
+                for (int h = 0; h < height; h++)
+                {
+                    for (int w = 0; w < width; w++)
+                    {
+                        int idx = b * channels * height * width + c * height * width + h * width + w;
+                        normalized.Data.Span[idx] = NumOps.FromDouble((NumOps.ToDouble(image.Data.Span[idx]) - mean) / std);
+                    }
+                }
+            }
+        }
+        return normalized;
+    }
+
+    /// <summary>
+    /// Applies Dessurt's industry-standard postprocessing: pass-through (sequence outputs are already final).
+    /// </summary>
+    protected override Tensor<T> ApplyDefaultPostprocessing(Tensor<T> modelOutput) => modelOutput;
+
+    #endregion
+
+    #region Serialization
+
+    /// <inheritdoc/>
+    public override ModelMetadata<T> GetModelMetadata()
+    {
+        return new ModelMetadata<T>
+        {
+            Name = "Dessurt",
+            Description = "Dessurt for self-supervised document understanding (arXiv 2022)",
+            FeatureCount = _encoderDim,
+            Complexity = _encoderLayers + _decoderLayers,
+            AdditionalInfo = new Dictionary<string, object>
+            {
+                { "encoder_dim", _encoderDim },
+                { "decoder_dim", _decoderDim },
+                { "encoder_layers", _encoderLayers },
+                { "decoder_layers", _decoderLayers },
+                { "num_heads", _numHeads },
+                { "vocab_size", _vocabSize },
+                { "image_size", ImageSize },
+                { "use_native_mode", _useNativeMode }
+            },
+            ModelData = SafeSerializeMaterializedModel()
+        };
+    }
+
+    private byte[] SafeSerializeMaterializedModel()
+    {
+        return _useNativeMode && !_nativeLayersInitialized
+            ? Array.Empty<byte>()
+            : SafeSerialize();
+    }
+
+    #endregion
+
+    #region NeuralNetworkBase Implementation
+
+    /// <inheritdoc/>
+    protected override Tensor<T> PredictCore(Tensor<T> input)
+    {
+        var preprocessed = PreprocessDocument(input);
+        return _useNativeMode
+            ? ForwardAfterNativeInitialization(preprocessed)
+            : RunOnnxInference(preprocessed);
+    }
+
+    private Tensor<T> ForwardAfterNativeInitialization(Tensor<T> input)
+    {
+        EnsureNativeInitialized();
+        return Forward(input);
+    }
+
+    /// <inheritdoc/>
+    public override void Train(Tensor<T> input, Tensor<T> expectedOutput)
+    {
+        if (!_useNativeMode)
+            throw new NotSupportedException("Training not supported in ONNX mode.");
+
+        EnsureNativeInitialized();
+        SetTrainingMode(true);
+        try
+        {
+            // TrainWithTape already performs the optimizer step. The previous
+            // implementation followed it with UpdateParameters(CollectGradients),
+            // applying a second, fixed-rate update and causing longer training
+            // runs to drift upward. Use the caller-supplied optimizer as the
+            // single source of truth and fail loudly if it cannot drive tape
+            // gradients instead of silently substituting the base optimizer.
+            var gradientOptimizer = _optimizer
+                ?? throw new InvalidOperationException(
+                    "Dessurt training requires an optimizer implementing " +
+                    "IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>.");
+            // PredictCore evaluates the ImageNet-normalized document. Train on that same
+            // representation so the optimizer descends the objective users observe from
+            // Predict instead of fitting raw pixels and being evaluated on normalized ones.
+            TrainWithTape(PreprocessDocument(input), expectedOutput, gradientOptimizer);
+        }
+        finally
+        {
+            SetTrainingMode(false);
+        }
+    }
+
+    // UpdateParameters applied a GRADIENT STEP, but its one-argument form is the value setter and every caller passes values -- the override corrupted the model. Removed under AIDN082.
+
+
+    /// <summary>
+    /// Parameters cannot be written while the model is backed by a loaded ONNX graph: the weights
+    /// belong to that graph, not to this instance.
+    /// </summary>
+    /// <remarks>
+    /// Replaces a hand-written throw that used to sit inside UpdateParameters. The base checks this
+    /// on every mutating entry point rather than the one member the throw happened to guard, and
+    /// reading -- ParameterCount and GetParameters -- stays available either way.
+    /// </remarks>
     protected override bool SupportsParameterMutation => _useNativeMode;
-    private Vector<T> CollectGradients()
-    {
-        var grads = new List<T>();
-        EnsureNativeInitialized();
-        foreach (var layer in Layers)
-            grads.AddRange(layer.GetParameterGradients());
-        return new Vector<T>([.. grads]);
-    }
-
-    #endregion
-
-    #region Disposal
-
-    /// <inheritdoc/>
-    protected override void Dispose(bool disposing)
-    {
-        if (disposing)
-            _onnxSession?.Dispose();
-        base.Dispose(disposing);
-    }
-
-    #endregion
-}
+    private Vector<T> CollectGradients()
+    {
+        var grads = new List<T>();
+        EnsureNativeInitialized();
+        foreach (var layer in Layers)
+            grads.AddRange(layer.GetParameterGradients());
+        return new Vector<T>([.. grads]);
+    }
+
+    #endregion
+
+    #region Disposal
+
+    /// <inheritdoc/>
+    protected override void Dispose(bool disposing)
+    {
+        if (disposing)
+            _onnxSession?.Dispose();
+        base.Dispose(disposing);
+    }
+
+    #endregion
+}
diff --git a/src/Document/PixelToSequence/Donut.cs b/src/Document/PixelToSequence/Donut.cs
index 3152cf1d89..d90efff2b5 100644
--- a/src/Document/PixelToSequence/Donut.cs
+++ b/src/Document/PixelToSequence/Donut.cs
@@ -1,1523 +1,1342 @@
-using AiDotNet.ActivationFunctions;
-using AiDotNet.Document.Interfaces;
-using AiDotNet.Document.Options;
-using AiDotNet.Attributes;
-using AiDotNet.Enums;
-using AiDotNet.Helpers;
-using AiDotNet.Interfaces;
-using AiDotNet.LinearAlgebra;
-using AiDotNet.LossFunctions;
-using AiDotNet.NeuralNetworks;
-using AiDotNet.NeuralNetworks.Layers;
-using AiDotNet.Onnx;
-using AiDotNet.Optimizers;
-using AiDotNet.Tokenization;
-using AiDotNet.Tokenization.Interfaces;
-using Microsoft.ML.OnnxRuntime;
-using AiDotNet.Validation;
-using OnnxTensors = Microsoft.ML.OnnxRuntime.Tensors;
-
-namespace AiDotNet.Document.PixelToSequence;
-
-/// <summary>
-/// Donut (Document Understanding Transformer) - OCR-free end-to-end document understanding model.
-/// </summary>
-/// <typeparam name="T">The numeric type used for calculations.</typeparam>
-/// <remarks>
-/// <para>
-/// Donut is an OCR-free model that directly converts document images to structured text outputs
-/// without requiring a separate OCR stage. It uses a vision encoder (Swin Transformer) and
-/// text decoder (BART) architecture.
-/// </para>
-/// <para>
-/// <b>For Beginners:</b> Unlike traditional document AI which first extracts text using OCR
-/// and then processes it, Donut looks directly at the document image pixels and generates
-/// text output. This makes it:
-///
-/// - Simpler: No need for a separate OCR system
-/// - More robust: Less affected by OCR errors
-/// - End-to-end trainable: Can optimize for the final task directly
-///
-/// Donut is excellent for:
-/// - Document parsing (invoices, receipts, forms)
-/// - Information extraction
-/// - Document question answering
-/// - Document classification
-///
-/// Example usage:
-/// <code>
-/// var donut = new Donut&lt;float&gt;(architecture);
-/// var result = donut.ParseDocument(documentImage, "invoice");
-/// // Result is available in the returned value
-/// </code>
-/// </para>
-/// <para>
-/// <b>Reference:</b> "OCR-free Document Understanding Transformer" (ECCV 2022)
-/// https://arxiv.org/abs/2111.15664
-/// </para>
-/// </remarks>
-[ModelDomain(ModelDomain.Vision)]
-[ModelDomain(ModelDomain.Language)]
-[ModelCategory(ModelCategory.NeuralNetwork)]
-[ModelCategory(ModelCategory.Transformer)]
-[ModelTask(ModelTask.Classification)]
-[ModelTask(ModelTask.Detection)]
-[ModelComplexity(ModelComplexity.High)]
-[ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
-[ResearchPaper("OCR-free Document Understanding Transformer", "https://doi.org/10.48550/arXiv.2111.15664", Year = 2022, Authors = "Geewook Kim, Teakgyu Hong, Moonbin Yim, JeongYeon Nam, Jinyoung Park, Jinyeong Yim, Wonseok Hwang, Sangdoo Yun, Dongyoon Han, Seunghyun Park")]
-public partial class Donut<T> : DocumentNeuralNetworkBase<T>, IOCRModel<T>, IDocumentQA<T>
-{
-    private readonly DonutOptions _options;
-
-    /// <inheritdoc/>
-    public override ModelOptions GetOptions() => _options;
-
-    #region Fields
-
-    private bool _useNativeMode;
-    private readonly InferenceSession? _onnxEncoderSession;
-    private readonly InferenceSession? _onnxDecoderSession;
-    private string? _onnxEncoderModelPath;
-    private string? _onnxDecoderModelPath;
-    private readonly ITokenizer _tokenizer;
-    private readonly IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>> _optimizer;
-    private int _embedDim;
-    private int _decoderHiddenDim;
-    private int[] _depths;
-    private int[] _numHeads;
-    private int _windowSize;
-    private int _patchSize;
-    private int _mlpRatio;
-    private int _vocabSize;
-    private int _maxGenerationLength;
-    private int _decoderHeads;
-    private int _numDecoderLayers;
-
-    // Native mode layers - Encoder (Swin Transformer style)
-    private readonly List<ILayer<T>> _patchEmbeddingLayers = [];
-    private readonly List<ILayer<T>> _encoderLayers = [];
-
-    // Native mode layers - Decoder (BART style)
-    private readonly List<ILayer<T>> _decoderEmbeddingLayers = [];
-    private readonly List<ILayer<T>> _decoderLayers = [];
-    private readonly List<ILayer<T>> _outputLayers = [];
-
-    // Image dimensions (donut-base: 2560×1920)
-    private int ImageHeight { get; set; }
-    private int ImageWidth { get; set; }
-
-    // Learnable tokens
-    private Tensor<T>? _tokenEmbeddings;
-    private Tensor<T>? _decoderPositionEmbeddings;
-
-    // Gradient storage
-    [Scratch]
-    private Tensor<T>? _decoderPositionEmbeddingsGradients;
-    private bool _nativeLayersInitialized;
-    #pragma warning disable CS0414
-    private bool _decoderForwardExecuted;
-    #pragma warning restore CS0414
-
-    #endregion
-
-    #region Properties
-
-    /// <inheritdoc/>
-    public override DocumentType SupportedDocumentTypes => DocumentType.All;
-
-    /// <inheritdoc/>
-    public override bool RequiresOCR => false;
-
-    /// <inheritdoc/>
-    public int ExpectedImageSize => ImageSize;
-
-    /// <inheritdoc/>
-    public IReadOnlyList<string> SupportedLanguages { get; } = ["en", "ko", "ja", "zh"];
-
-    /// <inheritdoc/>
-    public bool IsOCRFree => true;
-
-    /// <summary>
-    /// Gets the maximum generation length for output sequences.
-    /// </summary>
-    public int MaxGenerationLength => _maxGenerationLength;
-
-    #endregion
-
-    #region Constructors
-
-    /// <summary>
-    /// Creates a Donut model with default configuration for native training.
-    /// </summary>
-    private const int DefaultImageHeight = 960;
-    private const int DefaultImageWidth = 1280;
-    private const int DefaultVocabSize = 57522;
-
-    public Donut()
-        : this(new NeuralNetworkArchitecture<T>(
-            inputType: InputType.ThreeDimensional,
-            taskType: NeuralNetworkTaskType.MultiClassClassification,
-            inputHeight: DefaultImageHeight, inputWidth: DefaultImageWidth, inputDepth: 3,
-            outputSize: DefaultVocabSize))
-    {
-    }
-
-    /// <summary>
-    /// Creates a Donut model using pre-trained ONNX models for inference.
-    /// </summary>
-    /// <param name="architecture">The neural network architecture.</param>
-    /// <param name="encoderPath">Path to the ONNX encoder model.</param>
-    /// <param name="decoderPath">Path to the ONNX decoder model.</param>
-    /// <param name="tokenizer">Tokenizer for text generation.</param>
-    /// <param name="imageHeight">Input image height (default: 1920 for donut-base).</param>
-    /// <param name="imageWidth">Input image width (default: 2560 for donut-base).</param>
-    /// <param name="maxGenerationLength">Maximum output sequence length (default: 768).</param>
-    /// <param name="embedDim">Initial embedding dimension (default: 128 for Swin-B).</param>
-    /// <param name="depths">Depths of each Swin stage (default: {2,2,14,2} for donut-base).</param>
-    /// <param name="numHeads">Attention heads per stage (default: {4,8,16,32}).</param>
-    /// <param name="windowSize">Window size for attention (default: 10 for donut-base).</param>
-    /// <param name="patchSize">Initial patch size (default: 4).</param>
-    /// <param name="decoderHiddenDim">Decoder hidden dimension (default: 1024).</param>
-    /// <param name="numDecoderLayers">Number of decoder layers (default: 4).</param>
-    /// <param name="decoderHeads">Number of decoder attention heads (default: 16).</param>
-    /// <param name="vocabSize">Vocabulary size (default: 57522).</param>
-    /// <param name="optimizer">Optimizer for training (optional, Adam used if null).</param>
-    /// <param name="lossFunction">Loss function (optional, CrossEntropyWithLogitsLoss is used if null).</param>
-    /// <exception cref="ArgumentNullException">Thrown if paths or tokenizer is null.</exception>
-    /// <exception cref="FileNotFoundException">Thrown if ONNX model files don't exist.</exception>
-    public Donut(
-        NeuralNetworkArchitecture<T> architecture,
-        string encoderPath,
-        string decoderPath,
-        ITokenizer tokenizer,
-        int imageHeight = 1920,
-        int imageWidth = 2560,
-        int maxGenerationLength = 768,
-        int embedDim = 128,
-        int[]? depths = null,
-        int[]? numHeads = null,
-        int windowSize = 10,
-        int patchSize = 4,
-        int decoderHiddenDim = 1024,
-        int numDecoderLayers = 4,
-        int decoderHeads = 16,
-        int vocabSize = 57522,
-        IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? optimizer = null,
-        ILossFunction<T>? lossFunction = null,
-        DonutOptions? options = null)
-        : base(architecture, lossFunction ?? new CrossEntropyWithLogitsLoss<T>(), 1.0)
-    {
-        _options = options ?? new DonutOptions();
-        Options = _options;
-
-        if (string.IsNullOrWhiteSpace(encoderPath))
-            throw new ArgumentNullException(nameof(encoderPath));
-        if (string.IsNullOrWhiteSpace(decoderPath))
-            throw new ArgumentNullException(nameof(decoderPath));
-        if (!File.Exists(encoderPath))
-            throw new FileNotFoundException($"Encoder model not found: {encoderPath}", encoderPath);
-        if (!File.Exists(decoderPath))
-            throw new FileNotFoundException($"Decoder model not found: {decoderPath}", decoderPath);
-
-        Guard.NotNull(tokenizer);
-        _tokenizer = tokenizer;
-        _useNativeMode = false;
-        _onnxEncoderModelPath = encoderPath;
-        _onnxDecoderModelPath = decoderPath;
-
-        // Swin-B defaults from Donut paper
-        _depths = depths ?? [2, 2, 14, 2];
-        _numHeads = numHeads ?? [4, 8, 16, 32];
-        _embedDim = embedDim;
-        _windowSize = windowSize;
-        _patchSize = patchSize;
-        _mlpRatio = 4;
-        _decoderHiddenDim = decoderHiddenDim;
-        _numDecoderLayers = numDecoderLayers;
-        _decoderHeads = decoderHeads;
-        _vocabSize = vocabSize;
-        _maxGenerationLength = maxGenerationLength;
-        _optimizer = optimizer ?? new AdamOptimizer<T, Tensor<T>, Tensor<T>>(this);
-
-        ImageSize = Math.Max(imageHeight, imageWidth);
-        ImageHeight = imageHeight;
-        ImageWidth = imageWidth;
-        MaxSequenceLength = maxGenerationLength;
-
-        _onnxEncoderSession = new InferenceSession(encoderPath);
-        _onnxDecoderSession = new InferenceSession(decoderPath);
-
-        InitializeLayers();
-        InitializeEmbeddings();
-    }
-
-    /// <summary>
-    /// Creates a Donut model using native layers for training and inference.
-    /// </summary>
-    /// <param name="architecture">The neural network architecture.</param>
-    /// <param name="tokenizer">Tokenizer for text generation (optional).</param>
-    /// <param name="imageHeight">Input image height (default: 1920 for donut-base).</param>
-    /// <param name="imageWidth">Input image width (default: 2560 for donut-base).</param>
-    /// <param name="maxGenerationLength">Maximum output sequence length (default: 768).</param>
-    /// <param name="embedDim">Initial embedding dimension (default: 128 for Swin-B).</param>
-    /// <param name="depths">Depths of each Swin stage (default: {2,2,14,2} for donut-base).</param>
-    /// <param name="numHeads">Attention heads per stage (default: {4,8,16,32}).</param>
-    /// <param name="windowSize">Window size for attention (default: 10 for donut-base).</param>
-    /// <param name="patchSize">Initial patch size (default: 4).</param>
-    /// <param name="mlpRatio">MLP expansion ratio (default: 4).</param>
-    /// <param name="decoderHiddenDim">Decoder hidden dimension (default: 1024).</param>
-    /// <param name="numDecoderLayers">Number of decoder layers (default: 4).</param>
-    /// <param name="decoderHeads">Number of decoder attention heads (default: 16).</param>
-    /// <param name="vocabSize">Vocabulary size (default: 57522).</param>
-    /// <param name="optimizer">Optimizer for training (optional).</param>
-    /// <param name="lossFunction">Loss function (optional).</param>
-    /// <remarks>
-    /// <para>
-    /// <b>Default Configuration (donut-base from ECCV 2022 paper):</b>
-    /// - Input: 2560×1920 RGB images
-    /// - Encoder: Swin-B with depths {2,2,14,2}, 128 initial dim, window size 10
-    /// - Decoder: 4-layer BART-style with 1024 hidden dim
-    /// </para>
-    /// </remarks>
-    public Donut(
-        NeuralNetworkArchitecture<T> architecture,
-        ITokenizer? tokenizer = null,
-        int imageHeight = 1920,
-        int imageWidth = 2560,
-        int maxGenerationLength = 768,
-        int embedDim = 128,
-        int[]? depths = null,
-        int[]? numHeads = null,
-        int windowSize = 10,
-        int patchSize = 4,
-        int mlpRatio = 4,
-        int decoderHiddenDim = 1024,
-        int numDecoderLayers = 4,
-        int decoderHeads = 16,
-        int vocabSize = 57522,
-        IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? optimizer = null,
-        ILossFunction<T>? lossFunction = null,
-        DonutOptions? options = null)
-        : base(architecture, lossFunction ?? new CrossEntropyWithLogitsLoss<T>(), 1.0)
-    {
-        _options = options ?? new DonutOptions();
-        Options = _options;
-
-        _useNativeMode = true;
-        _onnxEncoderModelPath = null;
-        _onnxDecoderModelPath = null;
-
-        // Swin-B defaults from Donut paper (ECCV 2022)
-        _depths = depths ?? [2, 2, 14, 2];
-        _numHeads = numHeads ?? [4, 8, 16, 32];
-        _embedDim = embedDim;
-        _windowSize = windowSize;
-        _patchSize = patchSize;
-        _mlpRatio = mlpRatio;
-        _decoderHiddenDim = decoderHiddenDim;
-        _numDecoderLayers = numDecoderLayers;
-        _decoderHeads = decoderHeads;
-        _vocabSize = vocabSize;
-        _maxGenerationLength = maxGenerationLength;
-
-        ImageSize = Math.Max(imageHeight, imageWidth);
-        ImageHeight = imageHeight;
-        ImageWidth = imageWidth;
-        MaxSequenceLength = maxGenerationLength;
-
-        _tokenizer = tokenizer ?? LanguageModelTokenizerFactory.CreateForBackbone(LanguageModelBackbone.OPT);
-        _optimizer = optimizer ?? new AdamOptimizer<T, Tensor<T>, Tensor<T>>(this);
-
-        // Native layers/embeddings are materialized on first use to avoid
-        // constructor-time allocation for metadata and construction probes.
-        if (Architecture.Layers is { Count: > 0 })
-        {
-            EnsureNativeInitialized();
-        }
-    }
-
-    #endregion
-
-    #region Initialization
-
-    /// <inheritdoc/>
-    protected override void InitializeLayers()
-    {
-        // In ONNX mode, layers are handled by ONNX runtime
-        if (!_useNativeMode)
-        {
-            return;
-        }
-
-        ResetLayerGroups();
-
-        // Check if user provided custom layers via Architecture
-        if (Architecture.Layers is not null && Architecture.Layers.Count > 0)
-        {
-            PopulateLayerGroups(Architecture.Layers);
-            ValidateCustomLayers(Layers);
-            return;
-        }
-
-        // Use LayerHelper to create default Donut layers (Swin-B encoder + BART decoder)
-        var (encoderLayers, decoderLayers) = LayerHelper<T>.CreateDefaultDonutLayers(
-            imageHeight: ImageHeight,
-            imageWidth: ImageWidth,
-            inputChannels: 3,
-            embedDim: _embedDim,
-            depths: _depths,
-            numHeads: _numHeads,
-            windowSize: _windowSize,
-            patchSize: _patchSize,
-            mlpRatio: _mlpRatio,
-            decoderHiddenDim: _decoderHiddenDim,
-            numDecoderLayers: _numDecoderLayers,
-            decoderHeads: _decoderHeads,
-            vocabSize: _vocabSize,
-            maxGenerationLength: _maxGenerationLength);
-
-        PopulateLayerGroups(encoderLayers, decoderLayers);
-    }
-
-    private void ResetLayerGroups()
-    {
-        Layers.Clear();
-        _patchEmbeddingLayers.Clear();
-        _encoderLayers.Clear();
-        _decoderEmbeddingLayers.Clear();
-        _decoderLayers.Clear();
-        _outputLayers.Clear();
-    }
-
-    private void PopulateLayerGroups(IEnumerable<ILayer<T>> encoderLayers, IEnumerable<ILayer<T>> decoderLayers)
-    {
-        foreach (var layer in encoderLayers)
-        {
-            Layers.Add(layer);
-            if (layer is SwinPatchEmbeddingLayer<T>)
-            {
-                _patchEmbeddingLayers.Add(layer);
-            }
-            else
-            {
-                _encoderLayers.Add(layer);
-            }
-        }
-
-        foreach (var layer in decoderLayers)
-        {
-            Layers.Add(layer);
-            if (layer is EmbeddingLayer<T>)
-            {
-                _decoderEmbeddingLayers.Add(layer);
-            }
-            else if (layer is DenseLayer<T>)
-            {
-                _outputLayers.Add(layer);
-            }
-            else
-            {
-                _decoderLayers.Add(layer);
-            }
-        }
-    }
-
-    private void PopulateLayerGroups(IEnumerable<ILayer<T>> layers)
-    {
-        bool inDecoder = false;
-
-        foreach (var layer in layers)
-        {
-            Layers.Add(layer);
-
-            if (layer is SwinPatchEmbeddingLayer<T>)
-            {
-                _patchEmbeddingLayers.Add(layer);
-                continue;
-            }
-
-            if (layer is EmbeddingLayer<T>)
-            {
-                inDecoder = true;
-                _decoderEmbeddingLayers.Add(layer);
-                continue;
-            }
-
-            if (layer is TransformerDecoderLayer<T>)
-            {
-                inDecoder = true;
-                _decoderLayers.Add(layer);
-                continue;
-            }
-
-            if (layer is DenseLayer<T>)
-            {
-                if (inDecoder)
-                {
-                    _outputLayers.Add(layer);
-                }
-                else
-                {
-                    _encoderLayers.Add(layer);
-                }
-                continue;
-            }
-
-            if (inDecoder)
-            {
-                _decoderLayers.Add(layer);
-            }
-            else
-            {
-                _encoderLayers.Add(layer);
-            }
-        }
-    }
-
-    /// <summary>
-    /// Re-derives the per-group mirror lists from the layers already present in
-    /// <see cref="NeuralNetworkBase{T}.Layers"/> (e.g. after deserialization, where the
-    /// base recreated every layer with its saved weights). Uses the same type-based
-    /// classification as <see cref="PopulateLayerGroups(IEnumerable{ILayer{T}})"/> but
-    /// does NOT add to <c>Layers</c> — it only re-points the mirror views at the
-    /// existing layer instances, preserving their loaded weights.
-    /// </summary>
-    private void RebuildLayerGroupsFromLayers()
-    {
-        _patchEmbeddingLayers.Clear();
-        _encoderLayers.Clear();
-        _decoderEmbeddingLayers.Clear();
-        _decoderLayers.Clear();
-        _outputLayers.Clear();
-
-        bool inDecoder = false;
-        foreach (var layer in Layers)
-        {
-            if (layer is SwinPatchEmbeddingLayer<T>)
-            {
-                _patchEmbeddingLayers.Add(layer);
-                continue;
-            }
-
-            if (layer is EmbeddingLayer<T>)
-            {
-                inDecoder = true;
-                _decoderEmbeddingLayers.Add(layer);
-                continue;
-            }
-
-            if (layer is TransformerDecoderLayer<T>)
-            {
-                inDecoder = true;
-                _decoderLayers.Add(layer);
-                continue;
-            }
-
-            if (layer is DenseLayer<T>)
-            {
-                if (inDecoder)
-                {
-                    _outputLayers.Add(layer);
-                }
-                else
-                {
-                    _encoderLayers.Add(layer);
-                }
-                continue;
-            }
-
-            if (inDecoder)
-            {
-                _decoderLayers.Add(layer);
-            }
-            else
-            {
-                _encoderLayers.Add(layer);
-            }
-        }
-    }
-
-    private void InitializeEmbeddings()
-    {
-        var random = RandomHelper.CreateSeededRandom(42);
-
-        _tokenEmbeddings = Tensor<T>.CreateDefault([_vocabSize, _decoderHiddenDim], NumOps.Zero);
-        InitializeWithSmallRandomValues(_tokenEmbeddings, random, 0.02);
-
-        _decoderPositionEmbeddings = Tensor<T>.CreateDefault([_maxGenerationLength, _decoderHiddenDim], NumOps.Zero);
-        InitializeWithSmallRandomValues(_decoderPositionEmbeddings, random, 0.02);
-
-        // Initialize gradient tensor
-        _decoderPositionEmbeddingsGradients = Tensor<T>.CreateDefault([_maxGenerationLength, _decoderHiddenDim], NumOps.Zero);
-    }
-
-    private void EnsureNativeInitialized()
-    {
-        if (!_useNativeMode || _nativeLayersInitialized)
-        {
-            return;
-        }
-
-        InitializeLayers();
-        InitializeEmbeddings();
-        _nativeLayersInitialized = true;
-        InvalidateParameterCountCache();
-    }
-
-    private void InitializeWithSmallRandomValues(Tensor<T> tensor, Random random, double stdDev)
-    {
-        for (int i = 0; i < tensor.Data.Length; i++)
-        {
-            double u1 = 1.0 - random.NextDouble();
-            double u2 = 1.0 - random.NextDouble();
-            double randStdNormal = Math.Sqrt(-2.0 * Math.Log(u1)) * Math.Sin(2.0 * Math.PI * u2);
-            tensor.Data.Span[i] = NumOps.FromDouble(randStdNormal * stdDev);
-        }
-    }
-
-    #endregion
-
-    #region IOCRModel Implementation
-
-    /// <inheritdoc/>
-    public OCRResult<T> RecognizeText(Tensor<T> documentImage)
-    {
-        ValidateImageShape(documentImage);
-
-        var startTime = DateTime.UtcNow;
-
-        var result = _useNativeMode
-            ? RecognizeTextNative(documentImage)
-            : RecognizeTextOnnx(documentImage);
-
-        return new OCRResult<T>
-        {
-            FullText = result.FullText,
-            Words = result.Words,
-            Lines = result.Lines,
-            Blocks = result.Blocks,
-            AverageConfidence = result.AverageConfidence,
-            ProcessingTimeMs = (DateTime.UtcNow - startTime).TotalMilliseconds
-        };
-    }
-
-    /// <inheritdoc/>
-    public OCRResult<T> RecognizeTextInRegion(Tensor<T> documentImage, Vector<T> region)
-    {
-        ValidateImageShape(documentImage);
-        if (region is null)
-            throw new ArgumentNullException(nameof(region));
-
-        var cropped = CropImageToRegion(documentImage, region);
-        return RecognizeText(cropped);
-    }
-
-    private Tensor<T> CropImageToRegion(Tensor<T> image, Vector<T> region)
-    {
-        if (region.Length < 4)
-            throw new ArgumentException("Region must be [x1, y1, x2, y2].", nameof(region));
-
-        double x1Norm = NumOps.ToDouble(region[0]);
-        double y1Norm = NumOps.ToDouble(region[1]);
-        double x2Norm = NumOps.ToDouble(region[2]);
-        double y2Norm = NumOps.ToDouble(region[3]);
-
-        if (double.IsNaN(x1Norm) || double.IsNaN(y1Norm) || double.IsNaN(x2Norm) || double.IsNaN(y2Norm)
-            || double.IsInfinity(x1Norm) || double.IsInfinity(y1Norm)
-            || double.IsInfinity(x2Norm) || double.IsInfinity(y2Norm))
-        {
-            throw new ArgumentOutOfRangeException(nameof(region), "Region values must be finite.");
-        }
-
-        if (x1Norm < 0 || x1Norm > 1 || x2Norm < 0 || x2Norm > 1 || y1Norm < 0 || y1Norm > 1 || y2Norm < 0 || y2Norm > 1)
-        {
-            throw new ArgumentOutOfRangeException(nameof(region), "Region values must be normalized to [0,1].");
-        }
-
-        if (x2Norm <= x1Norm || y2Norm <= y1Norm)
-        {
-            throw new ArgumentException("Region coordinates must define a positive area.", nameof(region));
-        }
-
-        int height = image.Shape[^2];
-        int width = image.Shape[^1];
-
-        int startX = Math.Max(0, (int)Math.Floor(x1Norm * width));
-        int startY = Math.Max(0, (int)Math.Floor(y1Norm * height));
-        int endX = Math.Min(width, (int)Math.Ceiling(x2Norm * width));
-        int endY = Math.Min(height, (int)Math.Ceiling(y2Norm * height));
-
-        int cropWidth = endX - startX;
-        int cropHeight = endY - startY;
-        if (cropWidth <= 0 || cropHeight <= 0)
-            throw new ArgumentException("Region crop resulted in empty area.", nameof(region));
-
-        if (image.Rank == 3)
-        {
-            int channels = image.Shape[0];
-            var cropped = new Tensor<T>([channels, cropHeight, cropWidth]);
-            for (int c = 0; c < channels; c++)
-            {
-                for (int y = 0; y < cropHeight; y++)
-                {
-                    int srcY = startY + y;
-                    for (int x = 0; x < cropWidth; x++)
-                    {
-                        int srcX = startX + x;
-                        cropped[c, y, x] = image[c, srcY, srcX];
-                    }
-                }
-            }
-            return cropped;
-        }
-
-        if (image.Rank == 4)
-        {
-            int batch = image.Shape[0];
-            int channels = image.Shape[1];
-            var cropped = new Tensor<T>([batch, channels, cropHeight, cropWidth]);
-            for (int b = 0; b < batch; b++)
-            {
-                for (int c = 0; c < channels; c++)
-                {
-                    for (int y = 0; y < cropHeight; y++)
-                    {
-                        int srcY = startY + y;
-                        for (int x = 0; x < cropWidth; x++)
-                        {
-                            int srcX = startX + x;
-                            cropped[b, c, y, x] = image[b, c, srcY, srcX];
-                        }
-                    }
-                }
-            }
-            return cropped;
-        }
-
-        throw new ArgumentException($"Expected 3D or 4D tensor, got {image.Rank}D.", nameof(image));
-    }
-
-    private OCRResult<T> RecognizeTextNative(Tensor<T> image)
-    {
-        var encodedImage = EncodeImage(image);
-        var generatedText = GenerateText(encodedImage, "<s_ocr>");
-
-        return new OCRResult<T>
-        {
-            FullText = generatedText,
-            Words = [],
-            Lines = [],
-            Blocks = [],
-            AverageConfidence = NumOps.FromDouble(0.85)
-        };
-    }
-
-    private OCRResult<T> RecognizeTextOnnx(Tensor<T> image)
-    {
-        if (_onnxEncoderSession is null || _onnxDecoderSession is null)
-            throw new InvalidOperationException("ONNX sessions not initialized.");
-
-        var preprocessed = PreprocessDocument(image);
-        var encoderOutput = RunEncoderOnnx(preprocessed);
-        var generatedText = GenerateTextOnnx(encoderOutput, "<s_ocr>");
-
-        return new OCRResult<T>
-        {
-            FullText = generatedText,
-            Words = [],
-            Lines = [],
-            Blocks = [],
-            AverageConfidence = NumOps.FromDouble(0.85)
-        };
-    }
-
-    #endregion
-
-    #region IDocumentQA Implementation
-
-    /// <inheritdoc/>
-    public DocumentQAResult<T> AnswerQuestion(Tensor<T> documentImage, string question)
-    {
-        return AnswerQuestion(documentImage, question, _maxGenerationLength, 0.0);
-    }
-
-    /// <inheritdoc/>
-    public DocumentQAResult<T> AnswerQuestion(Tensor<T> documentImage, string question, int maxAnswerLength, double temperature = 0.0)
-    {
-        ValidateImageShape(documentImage);
-
-        var startTime = DateTime.UtcNow;
-
-        // Create prompt for VQA
-        string prompt = $"<s_docvqa><s_question>{question}</s_question><s_answer>";
-
-        var result = _useNativeMode
-            ? AnswerQuestionNative(documentImage, prompt, maxAnswerLength)
-            : AnswerQuestionOnnx(documentImage, prompt, maxAnswerLength);
-
-        return new DocumentQAResult<T>
-        {
-            Answer = result.Answer,
-            Confidence = result.Confidence,
-            ConfidenceValue = result.ConfidenceValue,
-            Evidence = result.Evidence,
-            AlternativeAnswers = result.AlternativeAnswers,
-            ProcessingTimeMs = (DateTime.UtcNow - startTime).TotalMilliseconds,
-            Question = question
-        };
-    }
-
-    private DocumentQAResult<T> AnswerQuestionNative(Tensor<T> image, string prompt, int maxLength)
-    {
-        var encodedImage = EncodeImage(image);
-        var answer = GenerateText(encodedImage, prompt, maxLength);
-
-        // Extract answer from generated text (remove special tokens)
-        answer = CleanGeneratedText(answer);
-
-        return new DocumentQAResult<T>
-        {
-            Answer = answer,
-            Confidence = NumOps.FromDouble(0.8),
-            ConfidenceValue = 0.8
-        };
-    }
-
-    private DocumentQAResult<T> AnswerQuestionOnnx(Tensor<T> image, string prompt, int maxLength)
-    {
-        if (_onnxEncoderSession is null || _onnxDecoderSession is null)
-            throw new InvalidOperationException("ONNX sessions not initialized.");
-
-        var preprocessed = PreprocessDocument(image);
-        var encoderOutput = RunEncoderOnnx(preprocessed);
-        var answer = GenerateTextOnnx(encoderOutput, prompt, maxLength);
-
-        answer = CleanGeneratedText(answer);
-
-        return new DocumentQAResult<T>
-        {
-            Answer = answer,
-            Confidence = NumOps.FromDouble(0.8),
-            ConfidenceValue = 0.8
-        };
-    }
-
-    /// <inheritdoc/>
-    public IEnumerable<DocumentQAResult<T>> AnswerQuestions(Tensor<T> documentImage, IEnumerable<string> questions)
-    {
-        // Encode image once and reuse for all questions
-        ValidateImageShape(documentImage);
-
-        foreach (var question in questions)
-        {
-            yield return AnswerQuestion(documentImage, question);
-        }
-    }
-
-    /// <inheritdoc/>
-    public Dictionary<string, DocumentQAResult<T>> ExtractFields(Tensor<T> documentImage, IEnumerable<string> fieldPrompts)
-    {
-        var results = new Dictionary<string, DocumentQAResult<T>>();
-
-        foreach (var field in fieldPrompts)
-        {
-            var question = $"What is the {field}?";
-            results[field] = AnswerQuestion(documentImage, question);
-        }
-
-        return results;
-    }
-
-    #endregion
-
-    #region Document Parsing
-
-    /// <summary>
-    /// Parses a document and returns structured output based on the document type.
-    /// </summary>
-    /// <param name="documentImage">The document image tensor.</param>
-    /// <param name="documentType">The type of document (e.g., "invoice", "receipt", "form").</param>
-    /// <returns>Parsed document content as structured text.</returns>
-    public string ParseDocument(Tensor<T> documentImage, string documentType)
-    {
-        ValidateImageShape(documentImage);
-
-        string prompt = $"<s_{documentType}>";
-
-        if (_useNativeMode)
-        {
-            var encodedImage = EncodeImage(documentImage);
-            return GenerateText(encodedImage, prompt);
-        }
-        else
-        {
-            var preprocessed = PreprocessDocument(documentImage);
-            var encoderOutput = RunEncoderOnnx(preprocessed);
-            return GenerateTextOnnx(encoderOutput, prompt);
-        }
-    }
-
-    #endregion
-
-    #region IDocumentModel Implementation
-
-    /// <inheritdoc/>
-    public Tensor<T> EncodeDocument(Tensor<T> documentImage)
-    {
-        ValidateImageShape(documentImage);
-        return EncodeImage(documentImage);
-    }
-
-    /// <inheritdoc/>
-    public void ValidateInputShape(Tensor<T> documentImage)
-    {
-        ValidateImageShape(documentImage);
-    }
-
-    /// <inheritdoc/>
-    public string GetModelSummary()
-    {
-        // Calculate encoder output dimension (after all merging: embedDim * 2^3 = embedDim * 8)
-        int encoderOutputDim = _embedDim * 8;
-        int totalEncoderLayers = _depths.Sum();
-
-        var sb = new System.Text.StringBuilder();
-        sb.AppendLine("Donut Model Summary");
-        sb.AppendLine("===================");
-        sb.AppendLine($"Mode: {(_useNativeMode ? "Native (Trainable)" : "ONNX (Inference)")}");
-        sb.AppendLine($"Architecture: Swin-B Encoder + BART Decoder");
-        sb.AppendLine();
-        sb.AppendLine("Encoder (Swin Transformer-B):");
-        sb.AppendLine($"  Initial Embed Dimension: {_embedDim}");
-        sb.AppendLine($"  Final Output Dimension: {encoderOutputDim}");
-        sb.AppendLine($"  Stage Depths: [{string.Join(", ", _depths)}] = {totalEncoderLayers} blocks");
-        sb.AppendLine($"  Attention Heads: [{string.Join(", ", _numHeads)}]");
-        sb.AppendLine($"  Window Size: {_windowSize}");
-        sb.AppendLine($"  Patch Size: {_patchSize}");
-        sb.AppendLine($"  MLP Ratio: {_mlpRatio}");
-        sb.AppendLine();
-        sb.AppendLine("Decoder (BART-style):");
-        sb.AppendLine($"  Hidden Dimension: {_decoderHiddenDim}");
-        sb.AppendLine($"  Number of Layers: {_numDecoderLayers}");
-        sb.AppendLine($"  Attention Heads: {_decoderHeads}");
-        sb.AppendLine();
-        sb.AppendLine($"Input Image Size: {ImageWidth}x{ImageHeight}");
-        sb.AppendLine($"Vocabulary Size: {_vocabSize}");
-        sb.AppendLine($"Max Generation Length: {_maxGenerationLength}");
-        sb.AppendLine($"Total Layers: {Layers.Count}");
-        sb.AppendLine($"OCR-Free: {IsOCRFree}");
-        sb.AppendLine($"Supported Languages: {string.Join(", ", SupportedLanguages)}");
-        return sb.ToString();
-    }
-
-    #endregion
-
-    #region Core Processing
-
-    private Tensor<T> EncodeImage(Tensor<T> image)
-    {
-        var preprocessed = PreprocessDocument(image);
-
-        if (_useNativeMode)
-        {
-            EnsureNativeInitialized();
-            var output = preprocessed;
-
-            // Patch embedding
-            foreach (var layer in _patchEmbeddingLayers)
-                output = layer.Forward(output);
-
-            // Encoder layers
-            foreach (var layer in _encoderLayers)
-                output = layer.Forward(output);
-
-            return output;
-        }
-        else
-        {
-            return RunEncoderOnnx(preprocessed);
-        }
-    }
-
-    private Tensor<T> RunEncoderOnnx(Tensor<T> input)
-    {
-        if (_onnxEncoderSession is null)
-            throw new InvalidOperationException("Encoder session not initialized.");
-
-        // Use OnnxModel wrapper or direct inference
-        return RunOnnxInference(input);
-    }
-
-    private string GenerateText(Tensor<T> encoderOutput, string prompt, int maxLength = -1)
-    {
-        if (maxLength < 0) maxLength = _maxGenerationLength;
-
-        // Tokenize prompt
-        var tokenResult = _tokenizer.Encode(prompt);
-        var generatedTokens = new List<int>(tokenResult.TokenIds);
-
-        // End-of-sequence token ID (commonly 2 for many models)
-        const int eosTokenId = 2;
-
-        // Simplified greedy decoding - full implementation would use beam search
-        for (int i = 0; i < maxLength && generatedTokens.Count < _maxGenerationLength; i++)
-        {
-            // Get decoder input embeddings
-            var decoderInput = CreateDecoderInput(generatedTokens);
-
-            // Run decoder
-            var decoderOutput = RunDecoder(decoderInput, encoderOutput);
-
-            // Get next token (greedy - take argmax)
-            int nextToken = GetNextToken(decoderOutput);
-
-            if (nextToken == eosTokenId)
-                break;
-
-            generatedTokens.Add(nextToken);
-        }
-
-        return _tokenizer.Decode(generatedTokens);
-    }
-
-    private string GenerateTextOnnx(Tensor<T> encoderOutput, string prompt, int maxLength = -1)
-    {
-        // Similar to native but using ONNX decoder
-        return GenerateText(encoderOutput, prompt, maxLength);
-    }
-
-    private Tensor<T> CreateDecoderInput(List<int> tokens)
-    {
-        if (_tokenEmbeddings is null)
-            throw new InvalidOperationException("Token embeddings are not initialized.");
-        if (_tokenEmbeddings.Shape.Length < 2 || _tokenEmbeddings.Shape[1] != _decoderHiddenDim)
-            throw new InvalidOperationException("Token embeddings shape does not match decoder hidden dimension.");
-
-        int vocabSize = _tokenEmbeddings.Shape[0];
-        var input = new Tensor<T>([1, tokens.Count, _decoderHiddenDim]);
-
-        for (int i = 0; i < tokens.Count; i++)
-        {
-            int tokenId = tokens[i];
-            if (tokenId < 0 || tokenId >= vocabSize)
-                throw new ArgumentOutOfRangeException(nameof(tokens), $"Token id {tokenId} is out of range for vocab size {vocabSize}.");
-
-            int sourceOffset = tokenId * _decoderHiddenDim;
-            int destinationOffset = i * _decoderHiddenDim;
-            _tokenEmbeddings.Data.Span.Slice(sourceOffset, _decoderHiddenDim).CopyTo(input.Data.Span.Slice(destinationOffset, _decoderHiddenDim));
-        }
-
-        return input;
-    }
-
-    private Tensor<T> RunDecoder(Tensor<T> decoderInput, Tensor<T> encoderOutput)
-    {
-        var output = decoderInput;
-
-        if (_useNativeMode)
-        {
-            _decoderForwardExecuted = true;
-
-            foreach (var layer in _decoderEmbeddingLayers)
-            {
-                output = layer.Forward(output);
-            }
-
-            foreach (var layer in _decoderLayers)
-            {
-                // Decoder layers would use cross-attention with encoder output 
-                output = layer.Forward(output);
-            }
-
-            foreach (var layer in _outputLayers)
-            {
-                output = layer.Forward(output);
-            }
-        }
-        else if (_onnxDecoderSession is not null)
-        {
-            // ONNX decoder inference
-            output = RunOnnxInference(decoderInput);
-        }
-
-        return output;
-    }
-
-    private int GetNextToken(Tensor<T> logits)
-    {
-        // Get the last position's logits and find argmax
-        if (logits.Shape.Length < 3)
-        {
-            throw new InvalidOperationException(
-                $"Expected logits.Shape to be [batch, seq, vocab], got rank {logits.Shape.Length}.");
-        }
-
-        int seqLen = logits.Shape[1];
-        if (seqLen <= 0 || _vocabSize <= 0)
-        {
-            throw new InvalidOperationException(
-                $"Invalid logits.Shape or vocab size: logits.Shape[1]={seqLen}, _vocabSize={_vocabSize}.");
-        }
-
-        int vocabStart = (seqLen - 1) * _vocabSize;
-        if (vocabStart < 0 || vocabStart >= logits.Data.Length || vocabStart + _vocabSize > logits.Data.Length)
-        {
-            throw new InvalidOperationException(
-                $"Invalid vocabStart={vocabStart} for logits.Data length {logits.Data.Length} and _vocabSize={_vocabSize}.");
-        }
-
-        double maxVal = double.MinValue;
-        int maxIdx = 0;
-
-        for (int i = 0; i < _vocabSize; i++)
-        {
-            double val = NumOps.ToDouble(logits.Data.Span[vocabStart + i]);
-            if (val > maxVal)
-            {
-                maxVal = val;
-                maxIdx = i;
-            }
-        }
-
-        return maxIdx;
-    }
-
-    private static string CleanGeneratedText(string text)
-    {
-        // Remove special tokens
-        text = text.Replace("<s>", "").Replace("</s>", "");
-        text = RegexHelper.Replace(text, @"<s_\w+>", "");
-        text = RegexHelper.Replace(text, @"</s_\w+>", "");
-        return text.Trim();
-    }
-
-    #endregion
-
-    #region Preprocessing
-
-    /// <summary>
-    /// Applies Donut's industry-standard preprocessing: normalize to [-1, 1].
-    /// </summary>
-    /// <remarks>
-    /// Donut (Document Understanding Transformer) uses mean=0.5, std=0.5 normalization
-    /// (NAVER paper). Expects large input images (2560x1920 typical).
-    /// </remarks>
-    protected override Tensor<T> ApplyDefaultPreprocessing(Tensor<T> rawImage)
-    {
-        var image = EnsureBatchDimension(rawImage);
-
-        int batchSize = image.Shape[0];
-        int channels = image.Shape[1];
-        int height = image.Shape[2];
-        int width = image.Shape[3];
-
-        var normalized = new Tensor<T>(image._shape);
-
-        // Donut uses different normalization than standard ImageNet
-        double[] means = [0.5, 0.5, 0.5];
-        double[] stds = [0.5, 0.5, 0.5];
-
-        for (int b = 0; b < batchSize; b++)
-        {
-            for (int c = 0; c < channels; c++)
-            {
-                double mean = c < means.Length ? means[c] : 0.5;
-                double std = c < stds.Length ? stds[c] : 0.5;
-
-                for (int h = 0; h < height; h++)
-                {
-                    for (int w = 0; w < width; w++)
-                    {
-                        int idx = b * channels * height * width + c * height * width + h * width + w;
-                        double value = NumOps.ToDouble(image.Data.Span[idx]);
-                        normalized.Data.Span[idx] = NumOps.FromDouble((value - mean) / std);
-                    }
-                }
-            }
-        }
-
-        return normalized;
-    }
-
-    /// <summary>
-    /// Applies Donut's industry-standard postprocessing: pass-through (autoregressive outputs are already final).
-    /// </summary>
-    protected override Tensor<T> ApplyDefaultPostprocessing(Tensor<T> modelOutput)
-    {
-        return modelOutput;
-    }
-
-    #endregion
-
-    #region Serialization
-
-    /// <inheritdoc/>
-    public override ModelMetadata<T> GetModelMetadata()
-    {
-        int encoderOutputDim = _embedDim * 8;
-        int totalEncoderLayers = _depths.Sum();
-
-        return new ModelMetadata<T>
-        {
-            Name = "Donut",
-            Description = "OCR-free Document Understanding Transformer with Swin-B encoder (ECCV 2022)",
-            FeatureCount = encoderOutputDim,
-            Complexity = totalEncoderLayers + _numDecoderLayers,
-            AdditionalInfo = new Dictionary<string, object>
-            {
-                { "embed_dim", _embedDim },
-                { "encoder_output_dim", encoderOutputDim },
-                { "decoder_hidden_dim", _decoderHiddenDim },
-                { "depths", string.Join(",", _depths) },
-                { "num_heads_per_stage", string.Join(",", _numHeads) },
-                { "decoder_heads", _decoderHeads },
-                { "num_decoder_layers", _numDecoderLayers },
-                { "window_size", _windowSize },
-                { "patch_size", _patchSize },
-                { "mlp_ratio", _mlpRatio },
-                { "vocab_size", _vocabSize },
-                { "max_generation_length", _maxGenerationLength },
-                { "image_height", ImageHeight },
-                { "image_width", ImageWidth },
-                { "use_native_mode", _useNativeMode },
-                { "ocr_free", IsOCRFree }
-            },
-            ModelData = SafeSerializeMaterializedModel()
-        };
-    }
-
-    private byte[] SafeSerializeMaterializedModel()
-    {
-        return _useNativeMode && !_nativeLayersInitialized
-            ? Array.Empty<byte>()
-            : SafeSerialize();
-    }
-
-    /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_embedDim);
-        writer.Write(_decoderHiddenDim);
-        writer.Write(_depths.Length);
-        foreach (int depth in _depths) writer.Write(depth);
-        writer.Write(_numHeads.Length);
-        foreach (int heads in _numHeads) writer.Write(heads);
-        writer.Write(_windowSize);
-        writer.Write(_patchSize);
-        writer.Write(_mlpRatio);
-        writer.Write(_numDecoderLayers);
-        writer.Write(_decoderHeads);
-        writer.Write(_vocabSize);
-        writer.Write(_maxGenerationLength);
-        writer.Write(ImageHeight);
-        writer.Write(ImageWidth);
-        writer.Write(_useNativeMode);
-        writer.Write(_onnxEncoderModelPath ?? string.Empty);
-        writer.Write(_onnxDecoderModelPath ?? string.Empty);
-
-        // The token + decoder-position embeddings are network-level trainable tensors
-        // that live OUTSIDE Layers (they are looked up directly in the decoder forward
-        // and trained via the custom gradient path), so the base layer serialization
-        // does not cover them. Persist them here; otherwise they would be re-randomized
-        // on load and break save/load + clone-after-training parity.
-        WriteOptionalTensor(writer, _tokenEmbeddings);
-        WriteOptionalTensor(writer, _decoderPositionEmbeddings);
-    }
-
-    private void WriteOptionalTensor(BinaryWriter writer, Tensor<T>? tensor)
-    {
-        if (tensor is null)
-        {
-            writer.Write(false);
-            return;
-        }
-
-        writer.Write(true);
-        int rank = tensor.Shape.Length;
-        writer.Write(rank);
-        for (int i = 0; i < rank; i++) writer.Write(tensor.Shape[i]);
-        var span = tensor.Data.Span;
-        for (int i = 0; i < span.Length; i++)
-            writer.Write(NumOps.ToDouble(span[i]));
-    }
-
-    private Tensor<T>? ReadOptionalTensor(BinaryReader reader)
-    {
-        bool present = reader.ReadBoolean();
-        if (!present) return null;
-
-        int rank = reader.ReadInt32();
-        int[] shape = new int[rank];
-        for (int i = 0; i < rank; i++) shape[i] = reader.ReadInt32();
-
-        var tensor = Tensor<T>.CreateDefault(shape, NumOps.Zero);
-        var span = tensor.Data.Span;
-        for (int i = 0; i < span.Length; i++)
-            span[i] = NumOps.FromDouble(reader.ReadDouble());
-        return tensor;
-    }
-
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        int embedDim = reader.ReadInt32();
-        int decoderHiddenDim = reader.ReadInt32();
-
-        int depthsLength = reader.ReadInt32();
-        int[] depths = new int[depthsLength];
-        for (int i = 0; i < depthsLength; i++) depths[i] = reader.ReadInt32();
-
-        int headsLength = reader.ReadInt32();
-        int[] heads = new int[headsLength];
-        for (int i = 0; i < headsLength; i++) heads[i] = reader.ReadInt32();
-
-        int windowSize = reader.ReadInt32();
-        int patchSize = reader.ReadInt32();
-        int mlpRatio = reader.ReadInt32();
-        int numDecoderLayers = reader.ReadInt32();
-        int decoderHeads = reader.ReadInt32();
-        int vocabSize = reader.ReadInt32();
-        int maxGenLength = reader.ReadInt32();
-        int imageHeight = reader.ReadInt32();
-        int imageWidth = reader.ReadInt32();
-        bool useNativeMode = reader.ReadBoolean();
-        string? encoderPath = null;
-        string? decoderPath = null;
-        if (reader.BaseStream.Position < reader.BaseStream.Length)
-        {
-            encoderPath = reader.ReadString();
-            if (reader.BaseStream.Position < reader.BaseStream.Length)
-            {
-                decoderPath = reader.ReadString();
-            }
-        }
-
-        _embedDim = embedDim;
-        _decoderHiddenDim = decoderHiddenDim;
-        _depths = depths;
-        _numHeads = heads;
-        _windowSize = windowSize;
-        _patchSize = patchSize;
-        _mlpRatio = mlpRatio;
-        _numDecoderLayers = numDecoderLayers;
-        _decoderHeads = decoderHeads;
-        _vocabSize = vocabSize;
-        _maxGenerationLength = maxGenLength;
-        _useNativeMode = useNativeMode;
-        _onnxEncoderModelPath = string.IsNullOrWhiteSpace(encoderPath) ? null : encoderPath;
-        _onnxDecoderModelPath = string.IsNullOrWhiteSpace(decoderPath) ? null : decoderPath;
-
-        ImageHeight = imageHeight;
-        ImageWidth = imageWidth;
-        ImageSize = Math.Max(imageHeight, imageWidth);
-        MaxSequenceLength = maxGenLength;
-
-        // The native-mode layers (with their trained weights) are already reconstructed
-        // by the base DeserializeInternalUnchecked before this override runs. Do NOT
-        // clear Layers + call InitializeLayers — that would discard the deserialized
-        // weights and re-randomize the model. Instead re-derive the per-group mirror
-        // lists (_patchEmbeddingLayers / _encoderLayers / _decoderEmbeddingLayers /
-        // _decoderLayers / _outputLayers) from the freshly deserialized Layers so the
-        // forward pass routes through the loaded weights.
-        if (_useNativeMode)
-        {
-            RebuildLayerGroupsFromLayers();
-        }
-
-        // Restore the network-level embeddings if they were serialized; fall back to a
-        // fresh initialization for models saved before embedding serialization existed.
-        Tensor<T>? restoredTokenEmbeddings = null;
-        Tensor<T>? restoredPositionEmbeddings = null;
-        if (reader.BaseStream.Position < reader.BaseStream.Length)
-        {
-            restoredTokenEmbeddings = ReadOptionalTensor(reader);
-            if (reader.BaseStream.Position < reader.BaseStream.Length)
-                restoredPositionEmbeddings = ReadOptionalTensor(reader);
-        }
-
-        if (restoredTokenEmbeddings is not null && restoredPositionEmbeddings is not null)
-        {
-            _tokenEmbeddings = restoredTokenEmbeddings;
-            _decoderPositionEmbeddings = restoredPositionEmbeddings;
-            // The gradient accumulator is not serialized (it is transient training state);
-            // recreate it to match the restored position-embedding shape.
-            _decoderPositionEmbeddingsGradients = Tensor<T>.CreateDefault(
-                [_maxGenerationLength, _decoderHiddenDim], NumOps.Zero);
-        }
-        else if (Layers.Count > 0)
-        {
-            InitializeEmbeddings();
-        }
-        _nativeLayersInitialized = _useNativeMode && Layers.Count > 0;
-    }
-
-    /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode)
-        {
-            string encoderPath = _onnxEncoderModelPath ?? throw new InvalidOperationException(
-                "Missing ONNX model paths required to clone Donut instance.");
-            string decoderPath = _onnxDecoderModelPath ?? throw new InvalidOperationException(
-                "Missing ONNX model paths required to clone Donut instance.");
-            if (string.IsNullOrWhiteSpace(encoderPath) || string.IsNullOrWhiteSpace(decoderPath))
-            {
-                throw new InvalidOperationException(
-                    "Missing ONNX model paths required to clone Donut instance.");
-            }
-
-            return new Donut<T>(
-                Architecture,
-                encoderPath,
-                decoderPath,
-                _tokenizer,
-                ImageHeight,
-                ImageWidth,
-                _maxGenerationLength,
-                _embedDim,
-                _depths,
-                _numHeads,
-                _windowSize,
-                _patchSize,
-                _decoderHiddenDim,
-                _numDecoderLayers,
-                _decoderHeads,
-                _vocabSize,
-                _optimizer,
-                LossFunction);
-        }
-
-        var model = new Donut<T>(
-            Architecture,
-            _tokenizer,
-            ImageHeight,
-            ImageWidth,
-            _maxGenerationLength,
-            _embedDim,
-            _depths,
-            _numHeads,
-            _windowSize,
-            _patchSize,
-            _mlpRatio,
-            _decoderHiddenDim,
-            _numDecoderLayers,
-            _decoderHeads,
-            _vocabSize,
-            _optimizer,
-            LossFunction);
-        if (_nativeLayersInitialized)
-        {
-            model.EnsureNativeInitialized();
-        }
-
-        return model;
-    }
-
-    #endregion
-
-    #region NeuralNetworkBase Implementation
-
-    /// <inheritdoc/>
-    protected override Tensor<T> PredictCore(Tensor<T> input)
-    {
-        var preprocessed = PreprocessDocument(input);
-
-        if (_useNativeMode)
-        {
-            EnsureNativeInitialized();
-            // Encode image and generate text output
-            var encoderOutput = EncodeImage(preprocessed);
-            return encoderOutput;
-        }
-        else
-        {
-            return RunOnnxInference(preprocessed);
-        }
-    }
-
-    /// <inheritdoc/>
-    public override void Train(Tensor<T> input, Tensor<T> expectedOutput)
-    {
-        if (!_useNativeMode)
-        {
-            throw new NotSupportedException("Training is not supported in ONNX inference mode. Use native mode for training.");
-        }
-
-        EnsureNativeInitialized();
-        SetTrainingMode(true);
-        try
-        {
-            TrainWithTape(input, expectedOutput, _optimizer);
-        }
-        finally
-        {
-            SetTrainingMode(false);
-        }
-    }
-
-    // UpdateParameters applied a GRADIENT STEP, but its one-argument form is the value setter and every caller passes values -- the override corrupted the model. Removed under AIDN082.

-
-    /// <summary>
-    /// Parameters cannot be written while the model is backed by a loaded ONNX graph: the weights
-    /// belong to that graph, not to this instance.
-    /// </summary>
-    /// <remarks>
-    /// Replaces a hand-written throw that used to sit inside UpdateParameters. The base checks this
-    /// on every mutating entry point rather than the one member the throw happened to guard, and
-    /// reading -- ParameterCount and GetParameters -- stays available either way.
-    /// </remarks>
+using AiDotNet.ActivationFunctions;
+using AiDotNet.Document.Interfaces;
+using AiDotNet.Document.Options;
+using AiDotNet.Attributes;
+using AiDotNet.Enums;
+using AiDotNet.Helpers;
+using AiDotNet.Interfaces;
+using AiDotNet.LinearAlgebra;
+using AiDotNet.LossFunctions;
+using AiDotNet.NeuralNetworks;
+using AiDotNet.NeuralNetworks.Layers;
+using AiDotNet.Onnx;
+using AiDotNet.Optimizers;
+using AiDotNet.Tokenization;
+using AiDotNet.Tokenization.Interfaces;
+using Microsoft.ML.OnnxRuntime;
+using AiDotNet.Validation;
+using OnnxTensors = Microsoft.ML.OnnxRuntime.Tensors;
+
+namespace AiDotNet.Document.PixelToSequence;
+
+/// <summary>
+/// Donut (Document Understanding Transformer) - OCR-free end-to-end document understanding model.
+/// </summary>
+/// <typeparam name="T">The numeric type used for calculations.</typeparam>
+/// <remarks>
+/// <para>
+/// Donut is an OCR-free model that directly converts document images to structured text outputs
+/// without requiring a separate OCR stage. It uses a vision encoder (Swin Transformer) and
+/// text decoder (BART) architecture.
+/// </para>
+/// <para>
+/// <b>For Beginners:</b> Unlike traditional document AI which first extracts text using OCR
+/// and then processes it, Donut looks directly at the document image pixels and generates
+/// text output. This makes it:
+///
+/// - Simpler: No need for a separate OCR system
+/// - More robust: Less affected by OCR errors
+/// - End-to-end trainable: Can optimize for the final task directly
+///
+/// Donut is excellent for:
+/// - Document parsing (invoices, receipts, forms)
+/// - Information extraction
+/// - Document question answering
+/// - Document classification
+///
+/// Example usage:
+/// <code>
+/// var donut = new Donut&lt;float&gt;(architecture);
+/// var result = donut.ParseDocument(documentImage, "invoice");
+/// // Result is available in the returned value
+/// </code>
+/// </para>
+/// <para>
+/// <b>Reference:</b> "OCR-free Document Understanding Transformer" (ECCV 2022)
+/// https://arxiv.org/abs/2111.15664
+/// </para>
+/// </remarks>
+[ModelDomain(ModelDomain.Vision)]
+[ModelDomain(ModelDomain.Language)]
+[ModelCategory(ModelCategory.NeuralNetwork)]
+[ModelCategory(ModelCategory.Transformer)]
+[ModelTask(ModelTask.Classification)]
+[ModelTask(ModelTask.Detection)]
+[ModelComplexity(ModelComplexity.High)]
+[ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
+[ResearchPaper("OCR-free Document Understanding Transformer", "https://doi.org/10.48550/arXiv.2111.15664", Year = 2022, Authors = "Geewook Kim, Teakgyu Hong, Moonbin Yim, JeongYeon Nam, Jinyoung Park, Jinyeong Yim, Wonseok Hwang, Sangdoo Yun, Dongyoon Han, Seunghyun Park")]
+public partial class Donut<T> : DocumentNeuralNetworkBase<T>, IOCRModel<T>, IDocumentQA<T>
+{
+    private readonly DonutOptions _options;
+
+    /// <inheritdoc/>
+    public override ModelOptions GetOptions() => _options;
+
+    #region Fields
+
+    private bool _useNativeMode;
+    private readonly InferenceSession? _onnxEncoderSession;
+    private readonly InferenceSession? _onnxDecoderSession;
+    private string? _onnxEncoderModelPath;
+    private string? _onnxDecoderModelPath;
+    private readonly ITokenizer _tokenizer;
+    private readonly IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>> _optimizer;
+    private int _embedDim;
+    private int _decoderHiddenDim;
+    private int[] _depths;
+    private int[] _numHeads;
+    private int _windowSize;
+    private int _patchSize;
+    private int _mlpRatio;
+    private int _vocabSize;
+    private int _maxGenerationLength;
+    private int _decoderHeads;
+    private int _numDecoderLayers;
+
+    // Native mode layers - Encoder (Swin Transformer style)
+    private readonly List<ILayer<T>> _patchEmbeddingLayers = [];
+    private readonly List<ILayer<T>> _encoderLayers = [];
+
+    // Native mode layers - Decoder (BART style)
+    private readonly List<ILayer<T>> _decoderEmbeddingLayers = [];
+    private readonly List<ILayer<T>> _decoderLayers = [];
+    private readonly List<ILayer<T>> _outputLayers = [];
+
+    // Image dimensions (donut-base: 2560×1920)
+    private int ImageHeight { get; set; }
+    private int ImageWidth { get; set; }
+
+    // Learnable tokens
+    [AiDotNet.Attributes.TrainableParameter]
+    private Tensor<T>? _tokenEmbeddings;
+    [AiDotNet.Attributes.TrainableParameter]
+    private Tensor<T>? _decoderPositionEmbeddings;
+
+    // Gradient storage
+    [Scratch]
+    private Tensor<T>? _decoderPositionEmbeddingsGradients;
+    private bool _nativeLayersInitialized;
+    #pragma warning disable CS0414
+    private bool _decoderForwardExecuted;
+    #pragma warning restore CS0414
+
+    #endregion
+
+    #region Properties
+
+    /// <inheritdoc/>
+    public override DocumentType SupportedDocumentTypes => DocumentType.All;
+
+    /// <inheritdoc/>
+    public override bool RequiresOCR => false;
+
+    /// <inheritdoc/>
+    public int ExpectedImageSize => ImageSize;
+
+    /// <inheritdoc/>
+    public IReadOnlyList<string> SupportedLanguages { get; } = ["en", "ko", "ja", "zh"];
+
+    /// <inheritdoc/>
+    public bool IsOCRFree => true;
+
+    /// <summary>
+    /// Gets the maximum generation length for output sequences.
+    /// </summary>
+    public int MaxGenerationLength => _maxGenerationLength;
+
+    #endregion
+
+    #region Constructors
+
+    /// <summary>
+    /// Creates a Donut model with default configuration for native training.
+    /// </summary>
+    private const int DefaultImageHeight = 960;
+    private const int DefaultImageWidth = 1280;
+    private const int DefaultVocabSize = 57522;
+
+    public Donut()
+        : this(new NeuralNetworkArchitecture<T>(
+            inputType: InputType.ThreeDimensional,
+            taskType: NeuralNetworkTaskType.MultiClassClassification,
+            inputHeight: DefaultImageHeight, inputWidth: DefaultImageWidth, inputDepth: 3,
+            outputSize: DefaultVocabSize))
+    {
+    }
+
+    /// <summary>
+    /// Creates a Donut model using pre-trained ONNX models for inference.
+    /// </summary>
+    /// <param name="architecture">The neural network architecture.</param>
+    /// <param name="encoderPath">Path to the ONNX encoder model.</param>
+    /// <param name="decoderPath">Path to the ONNX decoder model.</param>
+    /// <param name="tokenizer">Tokenizer for text generation.</param>
+    /// <param name="imageHeight">Input image height (default: 1920 for donut-base).</param>
+    /// <param name="imageWidth">Input image width (default: 2560 for donut-base).</param>
+    /// <param name="maxGenerationLength">Maximum output sequence length (default: 768).</param>
+    /// <param name="embedDim">Initial embedding dimension (default: 128 for Swin-B).</param>
+    /// <param name="depths">Depths of each Swin stage (default: {2,2,14,2} for donut-base).</param>
+    /// <param name="numHeads">Attention heads per stage (default: {4,8,16,32}).</param>
+    /// <param name="windowSize">Window size for attention (default: 10 for donut-base).</param>
+    /// <param name="patchSize">Initial patch size (default: 4).</param>
+    /// <param name="decoderHiddenDim">Decoder hidden dimension (default: 1024).</param>
+    /// <param name="numDecoderLayers">Number of decoder layers (default: 4).</param>
+    /// <param name="decoderHeads">Number of decoder attention heads (default: 16).</param>
+    /// <param name="vocabSize">Vocabulary size (default: 57522).</param>
+    /// <param name="optimizer">Optimizer for training (optional, Adam used if null).</param>
+    /// <param name="lossFunction">Loss function (optional, CrossEntropyWithLogitsLoss is used if null).</param>
+    /// <exception cref="ArgumentNullException">Thrown if paths or tokenizer is null.</exception>
+    /// <exception cref="FileNotFoundException">Thrown if ONNX model files don't exist.</exception>
+    public Donut(
+        NeuralNetworkArchitecture<T> architecture,
+        string encoderPath,
+        string decoderPath,
+        ITokenizer tokenizer,
+        int imageHeight = 1920,
+        int imageWidth = 2560,
+        int maxGenerationLength = 768,
+        int embedDim = 128,
+        int[]? depths = null,
+        int[]? numHeads = null,
+        int windowSize = 10,
+        int patchSize = 4,
+        int decoderHiddenDim = 1024,
+        int numDecoderLayers = 4,
+        int decoderHeads = 16,
+        int vocabSize = 57522,
+        IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? optimizer = null,
+        ILossFunction<T>? lossFunction = null,
+        DonutOptions? options = null)
+        : base(architecture, lossFunction ?? new CrossEntropyWithLogitsLoss<T>(), 1.0)
+    {
+        _options = options ?? new DonutOptions();
+        Options = _options;
+
+        if (string.IsNullOrWhiteSpace(encoderPath))
+            throw new ArgumentNullException(nameof(encoderPath));
+        if (string.IsNullOrWhiteSpace(decoderPath))
+            throw new ArgumentNullException(nameof(decoderPath));
+        if (!File.Exists(encoderPath))
+            throw new FileNotFoundException($"Encoder model not found: {encoderPath}", encoderPath);
+        if (!File.Exists(decoderPath))
+            throw new FileNotFoundException($"Decoder model not found: {decoderPath}", decoderPath);
+
+        Guard.NotNull(tokenizer);
+        _tokenizer = tokenizer;
+        _useNativeMode = false;
+        _onnxEncoderModelPath = encoderPath;
+        _onnxDecoderModelPath = decoderPath;
+
+        // Swin-B defaults from Donut paper
+        _depths = depths ?? [2, 2, 14, 2];
+        _numHeads = numHeads ?? [4, 8, 16, 32];
+        _embedDim = embedDim;
+        _windowSize = windowSize;
+        _patchSize = patchSize;
+        _mlpRatio = 4;
+        _decoderHiddenDim = decoderHiddenDim;
+        _numDecoderLayers = numDecoderLayers;
+        _decoderHeads = decoderHeads;
+        _vocabSize = vocabSize;
+        _maxGenerationLength = maxGenerationLength;
+        _optimizer = optimizer ?? new AdamOptimizer<T, Tensor<T>, Tensor<T>>(this);
+
+        ImageSize = Math.Max(imageHeight, imageWidth);
+        ImageHeight = imageHeight;
+        ImageWidth = imageWidth;
+        MaxSequenceLength = maxGenerationLength;
+
+        _onnxEncoderSession = new InferenceSession(encoderPath);
+        _onnxDecoderSession = new InferenceSession(decoderPath);
+
+        InitializeLayers();
+        InitializeEmbeddings();
+    }
+
+    /// <summary>
+    /// Creates a Donut model using native layers for training and inference.
+    /// </summary>
+    /// <param name="architecture">The neural network architecture.</param>
+    /// <param name="tokenizer">Tokenizer for text generation (optional).</param>
+    /// <param name="imageHeight">Input image height (default: 1920 for donut-base).</param>
+    /// <param name="imageWidth">Input image width (default: 2560 for donut-base).</param>
+    /// <param name="maxGenerationLength">Maximum output sequence length (default: 768).</param>
+    /// <param name="embedDim">Initial embedding dimension (default: 128 for Swin-B).</param>
+    /// <param name="depths">Depths of each Swin stage (default: {2,2,14,2} for donut-base).</param>
+    /// <param name="numHeads">Attention heads per stage (default: {4,8,16,32}).</param>
+    /// <param name="windowSize">Window size for attention (default: 10 for donut-base).</param>
+    /// <param name="patchSize">Initial patch size (default: 4).</param>
+    /// <param name="mlpRatio">MLP expansion ratio (default: 4).</param>
+    /// <param name="decoderHiddenDim">Decoder hidden dimension (default: 1024).</param>
+    /// <param name="numDecoderLayers">Number of decoder layers (default: 4).</param>
+    /// <param name="decoderHeads">Number of decoder attention heads (default: 16).</param>
+    /// <param name="vocabSize">Vocabulary size (default: 57522).</param>
+    /// <param name="optimizer">Optimizer for training (optional).</param>
+    /// <param name="lossFunction">Loss function (optional).</param>
+    /// <remarks>
+    /// <para>
+    /// <b>Default Configuration (donut-base from ECCV 2022 paper):</b>
+    /// - Input: 2560×1920 RGB images
+    /// - Encoder: Swin-B with depths {2,2,14,2}, 128 initial dim, window size 10
+    /// - Decoder: 4-layer BART-style with 1024 hidden dim
+    /// </para>
+    /// </remarks>
+    public Donut(
+        NeuralNetworkArchitecture<T> architecture,
+        ITokenizer? tokenizer = null,
+        int imageHeight = 1920,
+        int imageWidth = 2560,
+        int maxGenerationLength = 768,
+        int embedDim = 128,
+        int[]? depths = null,
+        int[]? numHeads = null,
+        int windowSize = 10,
+        int patchSize = 4,
+        int mlpRatio = 4,
+        int decoderHiddenDim = 1024,
+        int numDecoderLayers = 4,
+        int decoderHeads = 16,
+        int vocabSize = 57522,
+        IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? optimizer = null,
+        ILossFunction<T>? lossFunction = null,
+        DonutOptions? options = null)
+        : base(architecture, lossFunction ?? new CrossEntropyWithLogitsLoss<T>(), 1.0)
+    {
+        _options = options ?? new DonutOptions();
+        Options = _options;
+
+        _useNativeMode = true;
+        _onnxEncoderModelPath = null;
+        _onnxDecoderModelPath = null;
+
+        // Swin-B defaults from Donut paper (ECCV 2022)
+        _depths = depths ?? [2, 2, 14, 2];
+        _numHeads = numHeads ?? [4, 8, 16, 32];
+        _embedDim = embedDim;
+        _windowSize = windowSize;
+        _patchSize = patchSize;
+        _mlpRatio = mlpRatio;
+        _decoderHiddenDim = decoderHiddenDim;
+        _numDecoderLayers = numDecoderLayers;
+        _decoderHeads = decoderHeads;
+        _vocabSize = vocabSize;
+        _maxGenerationLength = maxGenerationLength;
+
+        ImageSize = Math.Max(imageHeight, imageWidth);
+        ImageHeight = imageHeight;
+        ImageWidth = imageWidth;
+        MaxSequenceLength = maxGenerationLength;
+
+        _tokenizer = tokenizer ?? LanguageModelTokenizerFactory.CreateForBackbone(LanguageModelBackbone.OPT);
+        _optimizer = optimizer ?? new AdamOptimizer<T, Tensor<T>, Tensor<T>>(this);
+
+        // Native layers/embeddings are materialized on first use to avoid
+        // constructor-time allocation for metadata and construction probes.
+        if (Architecture.Layers is { Count: > 0 })
+        {
+            EnsureNativeInitialized();
+        }
+    }
+
+    #endregion
+
+    #region Initialization
+
+    /// <inheritdoc/>
+    protected override void InitializeLayers()
+    {
+        // In ONNX mode, layers are handled by ONNX runtime
+        if (!_useNativeMode)
+        {
+            return;
+        }
+
+        ResetLayerGroups();
+
+        // Check if user provided custom layers via Architecture
+        if (Architecture.Layers is not null && Architecture.Layers.Count > 0)
+        {
+            PopulateLayerGroups(Architecture.Layers);
+            ValidateCustomLayers(Layers);
+            return;
+        }
+
+        // Use LayerHelper to create default Donut layers (Swin-B encoder + BART decoder)
+        var (encoderLayers, decoderLayers) = LayerHelper<T>.CreateDefaultDonutLayers(
+            imageHeight: ImageHeight,
+            imageWidth: ImageWidth,
+            inputChannels: 3,
+            embedDim: _embedDim,
+            depths: _depths,
+            numHeads: _numHeads,
+            windowSize: _windowSize,
+            patchSize: _patchSize,
+            mlpRatio: _mlpRatio,
+            decoderHiddenDim: _decoderHiddenDim,
+            numDecoderLayers: _numDecoderLayers,
+            decoderHeads: _decoderHeads,
+            vocabSize: _vocabSize,
+            maxGenerationLength: _maxGenerationLength);
+
+        PopulateLayerGroups(encoderLayers, decoderLayers);
+    }
+
+    private void ResetLayerGroups()
+    {
+        Layers.Clear();
+        _patchEmbeddingLayers.Clear();
+        _encoderLayers.Clear();
+        _decoderEmbeddingLayers.Clear();
+        _decoderLayers.Clear();
+        _outputLayers.Clear();
+    }
+
+    private void PopulateLayerGroups(IEnumerable<ILayer<T>> encoderLayers, IEnumerable<ILayer<T>> decoderLayers)
+    {
+        foreach (var layer in encoderLayers)
+        {
+            Layers.Add(layer);
+            if (layer is SwinPatchEmbeddingLayer<T>)
+            {
+                _patchEmbeddingLayers.Add(layer);
+            }
+            else
+            {
+                _encoderLayers.Add(layer);
+            }
+        }
+
+        foreach (var layer in decoderLayers)
+        {
+            Layers.Add(layer);
+            if (layer is EmbeddingLayer<T>)
+            {
+                _decoderEmbeddingLayers.Add(layer);
+            }
+            else if (layer is DenseLayer<T>)
+            {
+                _outputLayers.Add(layer);
+            }
+            else
+            {
+                _decoderLayers.Add(layer);
+            }
+        }
+    }
+
+    private void PopulateLayerGroups(IEnumerable<ILayer<T>> layers)
+    {
+        bool inDecoder = false;
+
+        foreach (var layer in layers)
+        {
+            Layers.Add(layer);
+
+            if (layer is SwinPatchEmbeddingLayer<T>)
+            {
+                _patchEmbeddingLayers.Add(layer);
+                continue;
+            }
+
+            if (layer is EmbeddingLayer<T>)
+            {
+                inDecoder = true;
+                _decoderEmbeddingLayers.Add(layer);
+                continue;
+            }
+
+            if (layer is TransformerDecoderLayer<T>)
+            {
+                inDecoder = true;
+                _decoderLayers.Add(layer);
+                continue;
+            }
+
+            if (layer is DenseLayer<T>)
+            {
+                if (inDecoder)
+                {
+                    _outputLayers.Add(layer);
+                }
+                else
+                {
+                    _encoderLayers.Add(layer);
+                }
+                continue;
+            }
+
+            if (inDecoder)
+            {
+                _decoderLayers.Add(layer);
+            }
+            else
+            {
+                _encoderLayers.Add(layer);
+            }
+        }
+    }
+
+    /// <summary>
+    /// Re-derives the per-group mirror lists from the layers already present in
+    /// <see cref="NeuralNetworkBase{T}.Layers"/> (e.g. after deserialization, where the
+    /// base recreated every layer with its saved weights). Uses the same type-based
+    /// classification as <see cref="PopulateLayerGroups(IEnumerable{ILayer{T}})"/> but
+    /// does NOT add to <c>Layers</c> — it only re-points the mirror views at the
+    /// existing layer instances, preserving their loaded weights.
+    /// </summary>
+    private void RebuildLayerGroupsFromLayers()
+    {
+        _patchEmbeddingLayers.Clear();
+        _encoderLayers.Clear();
+        _decoderEmbeddingLayers.Clear();
+        _decoderLayers.Clear();
+        _outputLayers.Clear();
+
+        bool inDecoder = false;
+        foreach (var layer in Layers)
+        {
+            if (layer is SwinPatchEmbeddingLayer<T>)
+            {
+                _patchEmbeddingLayers.Add(layer);
+                continue;
+            }
+
+            if (layer is EmbeddingLayer<T>)
+            {
+                inDecoder = true;
+                _decoderEmbeddingLayers.Add(layer);
+                continue;
+            }
+
+            if (layer is TransformerDecoderLayer<T>)
+            {
+                inDecoder = true;
+                _decoderLayers.Add(layer);
+                continue;
+            }
+
+            if (layer is DenseLayer<T>)
+            {
+                if (inDecoder)
+                {
+                    _outputLayers.Add(layer);
+                }
+                else
+                {
+                    _encoderLayers.Add(layer);
+                }
+                continue;
+            }
+
+            if (inDecoder)
+            {
+                _decoderLayers.Add(layer);
+            }
+            else
+            {
+                _encoderLayers.Add(layer);
+            }
+        }
+    }
+
+    private void InitializeEmbeddings()
+    {
+        var random = RandomHelper.CreateSeededRandom(42);
+
+        _tokenEmbeddings = Tensor<T>.CreateDefault([_vocabSize, _decoderHiddenDim], NumOps.Zero);
+        InitializeWithSmallRandomValues(_tokenEmbeddings, random, 0.02);
+
+        _decoderPositionEmbeddings = Tensor<T>.CreateDefault([_maxGenerationLength, _decoderHiddenDim], NumOps.Zero);
+        InitializeWithSmallRandomValues(_decoderPositionEmbeddings, random, 0.02);
+
+        // Initialize gradient tensor
+        _decoderPositionEmbeddingsGradients = Tensor<T>.CreateDefault([_maxGenerationLength, _decoderHiddenDim], NumOps.Zero);
+    }
+
+    private void EnsureNativeInitialized()
+    {
+        if (!_useNativeMode || _nativeLayersInitialized)
+        {
+            return;
+        }
+
+        InitializeLayers();
+        InitializeEmbeddings();
+        _nativeLayersInitialized = true;
+        InvalidateParameterCountCache();
+    }
+
+    private void InitializeWithSmallRandomValues(Tensor<T> tensor, Random random, double stdDev)
+    {
+        for (int i = 0; i < tensor.Data.Length; i++)
+        {
+            double u1 = 1.0 - random.NextDouble();
+            double u2 = 1.0 - random.NextDouble();
+            double randStdNormal = Math.Sqrt(-2.0 * Math.Log(u1)) * Math.Sin(2.0 * Math.PI * u2);
+            tensor.Data.Span[i] = NumOps.FromDouble(randStdNormal * stdDev);
+        }
+    }
+
+    #endregion
+
+    #region IOCRModel Implementation
+
+    /// <inheritdoc/>
+    public OCRResult<T> RecognizeText(Tensor<T> documentImage)
+    {
+        ValidateImageShape(documentImage);
+
+        var startTime = DateTime.UtcNow;
+
+        var result = _useNativeMode
+            ? RecognizeTextNative(documentImage)
+            : RecognizeTextOnnx(documentImage);
+
+        return new OCRResult<T>
+        {
+            FullText = result.FullText,
+            Words = result.Words,
+            Lines = result.Lines,
+            Blocks = result.Blocks,
+            AverageConfidence = result.AverageConfidence,
+            ProcessingTimeMs = (DateTime.UtcNow - startTime).TotalMilliseconds
+        };
+    }
+
+    /// <inheritdoc/>
+    public OCRResult<T> RecognizeTextInRegion(Tensor<T> documentImage, Vector<T> region)
+    {
+        ValidateImageShape(documentImage);
+        if (region is null)
+            throw new ArgumentNullException(nameof(region));
+
+        var cropped = CropImageToRegion(documentImage, region);
+        return RecognizeText(cropped);
+    }
+
+    private Tensor<T> CropImageToRegion(Tensor<T> image, Vector<T> region)
+    {
+        if (region.Length < 4)
+            throw new ArgumentException("Region must be [x1, y1, x2, y2].", nameof(region));
+
+        double x1Norm = NumOps.ToDouble(region[0]);
+        double y1Norm = NumOps.ToDouble(region[1]);
+        double x2Norm = NumOps.ToDouble(region[2]);
+        double y2Norm = NumOps.ToDouble(region[3]);
+
+        if (double.IsNaN(x1Norm) || double.IsNaN(y1Norm) || double.IsNaN(x2Norm) || double.IsNaN(y2Norm)
+            || double.IsInfinity(x1Norm) || double.IsInfinity(y1Norm)
+            || double.IsInfinity(x2Norm) || double.IsInfinity(y2Norm))
+        {
+            throw new ArgumentOutOfRangeException(nameof(region), "Region values must be finite.");
+        }
+
+        if (x1Norm < 0 || x1Norm > 1 || x2Norm < 0 || x2Norm > 1 || y1Norm < 0 || y1Norm > 1 || y2Norm < 0 || y2Norm > 1)
+        {
+            throw new ArgumentOutOfRangeException(nameof(region), "Region values must be normalized to [0,1].");
+        }
+
+        if (x2Norm <= x1Norm || y2Norm <= y1Norm)
+        {
+            throw new ArgumentException("Region coordinates must define a positive area.", nameof(region));
+        }
+
+        int height = image.Shape[^2];
+        int width = image.Shape[^1];
+
+        int startX = Math.Max(0, (int)Math.Floor(x1Norm * width));
+        int startY = Math.Max(0, (int)Math.Floor(y1Norm * height));
+        int endX = Math.Min(width, (int)Math.Ceiling(x2Norm * width));
+        int endY = Math.Min(height, (int)Math.Ceiling(y2Norm * height));
+
+        int cropWidth = endX - startX;
+        int cropHeight = endY - startY;
+        if (cropWidth <= 0 || cropHeight <= 0)
+            throw new ArgumentException("Region crop resulted in empty area.", nameof(region));
+
+        if (image.Rank == 3)
+        {
+            int channels = image.Shape[0];
+            var cropped = new Tensor<T>([channels, cropHeight, cropWidth]);
+            for (int c = 0; c < channels; c++)
+            {
+                for (int y = 0; y < cropHeight; y++)
+                {
+                    int srcY = startY + y;
+                    for (int x = 0; x < cropWidth; x++)
+                    {
+                        int srcX = startX + x;
+                        cropped[c, y, x] = image[c, srcY, srcX];
+                    }
+                }
+            }
+            return cropped;
+        }
+
+        if (image.Rank == 4)
+        {
+            int batch = image.Shape[0];
+            int channels = image.Shape[1];
+            var cropped = new Tensor<T>([batch, channels, cropHeight, cropWidth]);
+            for (int b = 0; b < batch; b++)
+            {
+                for (int c = 0; c < channels; c++)
+                {
+                    for (int y = 0; y < cropHeight; y++)
+                    {
+                        int srcY = startY + y;
+                        for (int x = 0; x < cropWidth; x++)
+                        {
+                            int srcX = startX + x;
+                            cropped[b, c, y, x] = image[b, c, srcY, srcX];
+                        }
+                    }
+                }
+            }
+            return cropped;
+        }
+
+        throw new ArgumentException($"Expected 3D or 4D tensor, got {image.Rank}D.", nameof(image));
+    }
+
+    private OCRResult<T> RecognizeTextNative(Tensor<T> image)
+    {
+        var encodedImage = EncodeImage(image);
+        var generatedText = GenerateText(encodedImage, "<s_ocr>");
+
+        return new OCRResult<T>
+        {
+            FullText = generatedText,
+            Words = [],
+            Lines = [],
+            Blocks = [],
+            AverageConfidence = NumOps.FromDouble(0.85)
+        };
+    }
+
+    private OCRResult<T> RecognizeTextOnnx(Tensor<T> image)
+    {
+        if (_onnxEncoderSession is null || _onnxDecoderSession is null)
+            throw new InvalidOperationException("ONNX sessions not initialized.");
+
+        var preprocessed = PreprocessDocument(image);
+        var encoderOutput = RunEncoderOnnx(preprocessed);
+        var generatedText = GenerateTextOnnx(encoderOutput, "<s_ocr>");
+
+        return new OCRResult<T>
+        {
+            FullText = generatedText,
+            Words = [],
+            Lines = [],
+            Blocks = [],
+            AverageConfidence = NumOps.FromDouble(0.85)
+        };
+    }
+
+    #endregion
+
+    #region IDocumentQA Implementation
+
+    /// <inheritdoc/>
+    public DocumentQAResult<T> AnswerQuestion(Tensor<T> documentImage, string question)
+    {
+        return AnswerQuestion(documentImage, question, _maxGenerationLength, 0.0);
+    }
+
+    /// <inheritdoc/>
+    public DocumentQAResult<T> AnswerQuestion(Tensor<T> documentImage, string question, int maxAnswerLength, double temperature = 0.0)
+    {
+        ValidateImageShape(documentImage);
+
+        var startTime = DateTime.UtcNow;
+
+        // Create prompt for VQA
+        string prompt = $"<s_docvqa><s_question>{question}</s_question><s_answer>";
+
+        var result = _useNativeMode
+            ? AnswerQuestionNative(documentImage, prompt, maxAnswerLength)
+            : AnswerQuestionOnnx(documentImage, prompt, maxAnswerLength);
+
+        return new DocumentQAResult<T>
+        {
+            Answer = result.Answer,
+            Confidence = result.Confidence,
+            ConfidenceValue = result.ConfidenceValue,
+            Evidence = result.Evidence,
+            AlternativeAnswers = result.AlternativeAnswers,
+            ProcessingTimeMs = (DateTime.UtcNow - startTime).TotalMilliseconds,
+            Question = question
+        };
+    }
+
+    private DocumentQAResult<T> AnswerQuestionNative(Tensor<T> image, string prompt, int maxLength)
+    {
+        var encodedImage = EncodeImage(image);
+        var answer = GenerateText(encodedImage, prompt, maxLength);
+
+        // Extract answer from generated text (remove special tokens)
+        answer = CleanGeneratedText(answer);
+
+        return new DocumentQAResult<T>
+        {
+            Answer = answer,
+            Confidence = NumOps.FromDouble(0.8),
+            ConfidenceValue = 0.8
+        };
+    }
+
+    private DocumentQAResult<T> AnswerQuestionOnnx(Tensor<T> image, string prompt, int maxLength)
+    {
+        if (_onnxEncoderSession is null || _onnxDecoderSession is null)
+            throw new InvalidOperationException("ONNX sessions not initialized.");
+
+        var preprocessed = PreprocessDocument(image);
+        var encoderOutput = RunEncoderOnnx(preprocessed);
+        var answer = GenerateTextOnnx(encoderOutput, prompt, maxLength);
+
+        answer = CleanGeneratedText(answer);
+
+        return new DocumentQAResult<T>
+        {
+            Answer = answer,
+            Confidence = NumOps.FromDouble(0.8),
+            ConfidenceValue = 0.8
+        };
+    }
+
+    /// <inheritdoc/>
+    public IEnumerable<DocumentQAResult<T>> AnswerQuestions(Tensor<T> documentImage, IEnumerable<string> questions)
+    {
+        // Encode image once and reuse for all questions
+        ValidateImageShape(documentImage);
+
+        foreach (var question in questions)
+        {
+            yield return AnswerQuestion(documentImage, question);
+        }
+    }
+
+    /// <inheritdoc/>
+    public Dictionary<string, DocumentQAResult<T>> ExtractFields(Tensor<T> documentImage, IEnumerable<string> fieldPrompts)
+    {
+        var results = new Dictionary<string, DocumentQAResult<T>>();
+
+        foreach (var field in fieldPrompts)
+        {
+            var question = $"What is the {field}?";
+            results[field] = AnswerQuestion(documentImage, question);
+        }
+
+        return results;
+    }
+
+    #endregion
+
+    #region Document Parsing
+
+    /// <summary>
+    /// Parses a document and returns structured output based on the document type.
+    /// </summary>
+    /// <param name="documentImage">The document image tensor.</param>
+    /// <param name="documentType">The type of document (e.g., "invoice", "receipt", "form").</param>
+    /// <returns>Parsed document content as structured text.</returns>
+    public string ParseDocument(Tensor<T> documentImage, string documentType)
+    {
+        ValidateImageShape(documentImage);
+
+        string prompt = $"<s_{documentType}>";
+
+        if (_useNativeMode)
+        {
+            var encodedImage = EncodeImage(documentImage);
+            return GenerateText(encodedImage, prompt);
+        }
+        else
+        {
+            var preprocessed = PreprocessDocument(documentImage);
+            var encoderOutput = RunEncoderOnnx(preprocessed);
+            return GenerateTextOnnx(encoderOutput, prompt);
+        }
+    }
+
+    #endregion
+
+    #region IDocumentModel Implementation
+
+    /// <inheritdoc/>
+    public Tensor<T> EncodeDocument(Tensor<T> documentImage)
+    {
+        ValidateImageShape(documentImage);
+        return EncodeImage(documentImage);
+    }
+
+    /// <inheritdoc/>
+    public void ValidateInputShape(Tensor<T> documentImage)
+    {
+        ValidateImageShape(documentImage);
+    }
+
+    /// <inheritdoc/>
+    public string GetModelSummary()
+    {
+        // Calculate encoder output dimension (after all merging: embedDim * 2^3 = embedDim * 8)
+        int encoderOutputDim = _embedDim * 8;
+        int totalEncoderLayers = _depths.Sum();
+
+        var sb = new System.Text.StringBuilder();
+        sb.AppendLine("Donut Model Summary");
+        sb.AppendLine("===================");
+        sb.AppendLine($"Mode: {(_useNativeMode ? "Native (Trainable)" : "ONNX (Inference)")}");
+        sb.AppendLine($"Architecture: Swin-B Encoder + BART Decoder");
+        sb.AppendLine();
+        sb.AppendLine("Encoder (Swin Transformer-B):");
+        sb.AppendLine($"  Initial Embed Dimension: {_embedDim}");
+        sb.AppendLine($"  Final Output Dimension: {encoderOutputDim}");
+        sb.AppendLine($"  Stage Depths: [{string.Join(", ", _depths)}] = {totalEncoderLayers} blocks");
+        sb.AppendLine($"  Attention Heads: [{string.Join(", ", _numHeads)}]");
+        sb.AppendLine($"  Window Size: {_windowSize}");
+        sb.AppendLine($"  Patch Size: {_patchSize}");
+        sb.AppendLine($"  MLP Ratio: {_mlpRatio}");
+        sb.AppendLine();
+        sb.AppendLine("Decoder (BART-style):");
+        sb.AppendLine($"  Hidden Dimension: {_decoderHiddenDim}");
+        sb.AppendLine($"  Number of Layers: {_numDecoderLayers}");
+        sb.AppendLine($"  Attention Heads: {_decoderHeads}");
+        sb.AppendLine();
+        sb.AppendLine($"Input Image Size: {ImageWidth}x{ImageHeight}");
+        sb.AppendLine($"Vocabulary Size: {_vocabSize}");
+        sb.AppendLine($"Max Generation Length: {_maxGenerationLength}");
+        sb.AppendLine($"Total Layers: {Layers.Count}");
+        sb.AppendLine($"OCR-Free: {IsOCRFree}");
+        sb.AppendLine($"Supported Languages: {string.Join(", ", SupportedLanguages)}");
+        return sb.ToString();
+    }
+
+    #endregion
+
+    #region Core Processing
+
+    private Tensor<T> EncodeImage(Tensor<T> image)
+    {
+        var preprocessed = PreprocessDocument(image);
+
+        if (_useNativeMode)
+        {
+            EnsureNativeInitialized();
+            var output = preprocessed;
+
+            // Patch embedding
+            foreach (var layer in _patchEmbeddingLayers)
+                output = layer.Forward(output);
+
+            // Encoder layers
+            foreach (var layer in _encoderLayers)
+                output = layer.Forward(output);
+
+            return output;
+        }
+        else
+        {
+            return RunEncoderOnnx(preprocessed);
+        }
+    }
+
+    private Tensor<T> RunEncoderOnnx(Tensor<T> input)
+    {
+        if (_onnxEncoderSession is null)
+            throw new InvalidOperationException("Encoder session not initialized.");
+
+        // Use OnnxModel wrapper or direct inference
+        return RunOnnxInference(input);
+    }
+
+    private string GenerateText(Tensor<T> encoderOutput, string prompt, int maxLength = -1)
+    {
+        if (maxLength < 0) maxLength = _maxGenerationLength;
+
+        // Tokenize prompt
+        var tokenResult = _tokenizer.Encode(prompt);
+        var generatedTokens = new List<int>(tokenResult.TokenIds);
+
+        // End-of-sequence token ID (commonly 2 for many models)
+        const int eosTokenId = 2;
+
+        // Simplified greedy decoding - full implementation would use beam search
+        for (int i = 0; i < maxLength && generatedTokens.Count < _maxGenerationLength; i++)
+        {
+            // Get decoder input embeddings
+            var decoderInput = CreateDecoderInput(generatedTokens);
+
+            // Run decoder
+            var decoderOutput = RunDecoder(decoderInput, encoderOutput);
+
+            // Get next token (greedy - take argmax)
+            int nextToken = GetNextToken(decoderOutput);
+
+            if (nextToken == eosTokenId)
+                break;
+
+            generatedTokens.Add(nextToken);
+        }
+
+        return _tokenizer.Decode(generatedTokens);
+    }
+
+    private string GenerateTextOnnx(Tensor<T> encoderOutput, string prompt, int maxLength = -1)
+    {
+        // Similar to native but using ONNX decoder
+        return GenerateText(encoderOutput, prompt, maxLength);
+    }
+
+    private Tensor<T> CreateDecoderInput(List<int> tokens)
+    {
+        if (_tokenEmbeddings is null)
+            throw new InvalidOperationException("Token embeddings are not initialized.");
+        if (_tokenEmbeddings.Shape.Length < 2 || _tokenEmbeddings.Shape[1] != _decoderHiddenDim)
+            throw new InvalidOperationException("Token embeddings shape does not match decoder hidden dimension.");
+
+        int vocabSize = _tokenEmbeddings.Shape[0];
+        var input = new Tensor<T>([1, tokens.Count, _decoderHiddenDim]);
+
+        for (int i = 0; i < tokens.Count; i++)
+        {
+            int tokenId = tokens[i];
+            if (tokenId < 0 || tokenId >= vocabSize)
+                throw new ArgumentOutOfRangeException(nameof(tokens), $"Token id {tokenId} is out of range for vocab size {vocabSize}.");
+
+            int sourceOffset = tokenId * _decoderHiddenDim;
+            int destinationOffset = i * _decoderHiddenDim;
+            _tokenEmbeddings.Data.Span.Slice(sourceOffset, _decoderHiddenDim).CopyTo(input.Data.Span.Slice(destinationOffset, _decoderHiddenDim));
+        }
+
+        return input;
+    }
+
+    private Tensor<T> RunDecoder(Tensor<T> decoderInput, Tensor<T> encoderOutput)
+    {
+        var output = decoderInput;
+
+        if (_useNativeMode)
+        {
+            _decoderForwardExecuted = true;
+
+            foreach (var layer in _decoderEmbeddingLayers)
+            {
+                output = layer.Forward(output);
+            }
+
+            foreach (var layer in _decoderLayers)
+            {
+                // Decoder layers would use cross-attention with encoder output 
+                output = layer.Forward(output);
+            }
+
+            foreach (var layer in _outputLayers)
+            {
+                output = layer.Forward(output);
+            }
+        }
+        else if (_onnxDecoderSession is not null)
+        {
+            // ONNX decoder inference
+            output = RunOnnxInference(decoderInput);
+        }
+
+        return output;
+    }
+
+    private int GetNextToken(Tensor<T> logits)
+    {
+        // Get the last position's logits and find argmax
+        if (logits.Shape.Length < 3)
+        {
+            throw new InvalidOperationException(
+                $"Expected logits.Shape to be [batch, seq, vocab], got rank {logits.Shape.Length}.");
+        }
+
+        int seqLen = logits.Shape[1];
+        if (seqLen <= 0 || _vocabSize <= 0)
+        {
+            throw new InvalidOperationException(
+                $"Invalid logits.Shape or vocab size: logits.Shape[1]={seqLen}, _vocabSize={_vocabSize}.");
+        }
+
+        int vocabStart = (seqLen - 1) * _vocabSize;
+        if (vocabStart < 0 || vocabStart >= logits.Data.Length || vocabStart + _vocabSize > logits.Data.Length)
+        {
+            throw new InvalidOperationException(
+                $"Invalid vocabStart={vocabStart} for logits.Data length {logits.Data.Length} and _vocabSize={_vocabSize}.");
+        }
+
+        double maxVal = double.MinValue;
+        int maxIdx = 0;
+
+        for (int i = 0; i < _vocabSize; i++)
+        {
+            double val = NumOps.ToDouble(logits.Data.Span[vocabStart + i]);
+            if (val > maxVal)
+            {
+                maxVal = val;
+                maxIdx = i;
+            }
+        }
+
+        return maxIdx;
+    }
+
+    private static string CleanGeneratedText(string text)
+    {
+        // Remove special tokens
+        text = text.Replace("<s>", "").Replace("</s>", "");
+        text = RegexHelper.Replace(text, @"<s_\w+>", "");
+        text = RegexHelper.Replace(text, @"</s_\w+>", "");
+        return text.Trim();
+    }
+
+    #endregion
+
+    #region Preprocessing
+
+    /// <summary>
+    /// Applies Donut's industry-standard preprocessing: normalize to [-1, 1].
+    /// </summary>
+    /// <remarks>
+    /// Donut (Document Understanding Transformer) uses mean=0.5, std=0.5 normalization
+    /// (NAVER paper). Expects large input images (2560x1920 typical).
+    /// </remarks>
+    protected override Tensor<T> ApplyDefaultPreprocessing(Tensor<T> rawImage)
+    {
+        var image = EnsureBatchDimension(rawImage);
+
+        int batchSize = image.Shape[0];
+        int channels = image.Shape[1];
+        int height = image.Shape[2];
+        int width = image.Shape[3];
+
+        var normalized = new Tensor<T>(image._shape);
+
+        // Donut uses different normalization than standard ImageNet
+        double[] means = [0.5, 0.5, 0.5];
+        double[] stds = [0.5, 0.5, 0.5];
+
+        for (int b = 0; b < batchSize; b++)
+        {
+            for (int c = 0; c < channels; c++)
+            {
+                double mean = c < means.Length ? means[c] : 0.5;
+                double std = c < stds.Length ? stds[c] : 0.5;
+
+                for (int h = 0; h < height; h++)
+                {
+                    for (int w = 0; w < width; w++)
+                    {
+                        int idx = b * channels * height * width + c * height * width + h * width + w;
+                        double value = NumOps.ToDouble(image.Data.Span[idx]);
+                        normalized.Data.Span[idx] = NumOps.FromDouble((value - mean) / std);
+                    }
+                }
+            }
+        }
+
+        return normalized;
+    }
+
+    /// <summary>
+    /// Applies Donut's industry-standard postprocessing: pass-through (autoregressive outputs are already final).
+    /// </summary>
+    protected override Tensor<T> ApplyDefaultPostprocessing(Tensor<T> modelOutput)
+    {
+        return modelOutput;
+    }
+
+    #endregion
+
+    #region Serialization
+
+    /// <inheritdoc/>
+    public override ModelMetadata<T> GetModelMetadata()
+    {
+        int encoderOutputDim = _embedDim * 8;
+        int totalEncoderLayers = _depths.Sum();
+
+        return new ModelMetadata<T>
+        {
+            Name = "Donut",
+            Description = "OCR-free Document Understanding Transformer with Swin-B encoder (ECCV 2022)",
+            FeatureCount = encoderOutputDim,
+            Complexity = totalEncoderLayers + _numDecoderLayers,
+            AdditionalInfo = new Dictionary<string, object>
+            {
+                { "embed_dim", _embedDim },
+                { "encoder_output_dim", encoderOutputDim },
+                { "decoder_hidden_dim", _decoderHiddenDim },
+                { "depths", string.Join(",", _depths) },
+                { "num_heads_per_stage", string.Join(",", _numHeads) },
+                { "decoder_heads", _decoderHeads },
+                { "num_decoder_layers", _numDecoderLayers },
+                { "window_size", _windowSize },
+                { "patch_size", _patchSize },
+                { "mlp_ratio", _mlpRatio },
+                { "vocab_size", _vocabSize },
+                { "max_generation_length", _maxGenerationLength },
+                { "image_height", ImageHeight },
+                { "image_width", ImageWidth },
+                { "use_native_mode", _useNativeMode },
+                { "ocr_free", IsOCRFree }
+            },
+            ModelData = SafeSerializeMaterializedModel()
+        };
+    }
+
+    private byte[] SafeSerializeMaterializedModel()
+    {
+        return _useNativeMode && !_nativeLayersInitialized
+            ? Array.Empty<byte>()
+            : SafeSerialize();
+    }
+
+    /// <inheritdoc/>
+
+
+    private void WriteOptionalTensor(BinaryWriter writer, Tensor<T>? tensor)
+    {
+        if (tensor is null)
+        {
+            writer.Write(false);
+            return;
+        }
+
+        writer.Write(true);
+        int rank = tensor.Shape.Length;
+        writer.Write(rank);
+        for (int i = 0; i < rank; i++) writer.Write(tensor.Shape[i]);
+        var span = tensor.Data.Span;
+        for (int i = 0; i < span.Length; i++)
+            writer.Write(NumOps.ToDouble(span[i]));
+    }
+
+    private Tensor<T>? ReadOptionalTensor(BinaryReader reader)
+    {
+        bool present = reader.ReadBoolean();
+        if (!present) return null;
+
+        int rank = reader.ReadInt32();
+        int[] shape = new int[rank];
+        for (int i = 0; i < rank; i++) shape[i] = reader.ReadInt32();
+
+        var tensor = Tensor<T>.CreateDefault(shape, NumOps.Zero);
+        var span = tensor.Data.Span;
+        for (int i = 0; i < span.Length; i++)
+            span[i] = NumOps.FromDouble(reader.ReadDouble());
+        return tensor;
+    }
+
+    #endregion
+
+    #region NeuralNetworkBase Implementation
+
+    /// <inheritdoc/>
+    protected override Tensor<T> PredictCore(Tensor<T> input)
+    {
+        var preprocessed = PreprocessDocument(input);
+
+        if (_useNativeMode)
+        {
+            EnsureNativeInitialized();
+            // Encode image and generate text output
+            var encoderOutput = EncodeImage(preprocessed);
+            return encoderOutput;
+        }
+        else
+        {
+            return RunOnnxInference(preprocessed);
+        }
+    }
+
+    /// <inheritdoc/>
+    public override void Train(Tensor<T> input, Tensor<T> expectedOutput)
+    {
+        if (!_useNativeMode)
+        {
+            throw new NotSupportedException("Training is not supported in ONNX inference mode. Use native mode for training.");
+        }
+
+        EnsureNativeInitialized();
+        SetTrainingMode(true);
+        try
+        {
+            TrainWithTape(input, expectedOutput, _optimizer);
+        }
+        finally
+        {
+            SetTrainingMode(false);
+        }
+    }
+
+    // UpdateParameters applied a GRADIENT STEP, but its one-argument form is the value setter and every caller passes values -- the override corrupted the model. Removed under AIDN082.
+
+
+    /// <summary>
+    /// Parameters cannot be written while the model is backed by a loaded ONNX graph: the weights
+    /// belong to that graph, not to this instance.
+    /// </summary>
+    /// <remarks>
+    /// Replaces a hand-written throw that used to sit inside UpdateParameters. The base checks this
+    /// on every mutating entry point rather than the one member the throw happened to guard, and
+    /// reading -- ParameterCount and GetParameters -- stays available either way.
+    /// </remarks>
     protected override bool SupportsParameterMutation => _useNativeMode;
-    private void UpdateEmbeddingGradients(Tensor<T> gradient)
-    {
-        // Update decoder position embedding gradients
-        if (_decoderPositionEmbeddingsGradients is not null && gradient.Data.Length > 0)
-        {
-            int gradLen = Math.Min(gradient.Data.Length, _decoderPositionEmbeddingsGradients.Data.Length);
-            for (int i = 0; i < gradLen; i++)
-            {
-                _decoderPositionEmbeddingsGradients.Data.Span[i] = NumOps.Add(
-                    _decoderPositionEmbeddingsGradients.Data.Span[i],
-                    gradient.Data.Span[i % gradient.Data.Length]);
-            }
-        }
-    }
-
-    private Vector<T> CollectParameterGradients()
-    {
-        var gradients = new List<T>();
-        EnsureNativeInitialized();
-
-        // Collect gradients from all layers
-        foreach (var layer in Layers)
-        {
-            var layerGradients = layer.GetParameterGradients();
-            gradients.AddRange(layerGradients);
-        }
-
-        // Add embedding gradients
-        if (_decoderPositionEmbeddingsGradients is not null)
-            gradients.AddRange(_decoderPositionEmbeddingsGradients.Data.ToArray());
-
-        return new Vector<T>([.. gradients]);
-    }
-
-    #endregion
-
-    #region Disposal
-
-    /// <inheritdoc/>
-    protected override void Dispose(bool disposing)
-    {
-        if (disposing)
-        {
-            _onnxEncoderSession?.Dispose();
-            _onnxDecoderSession?.Dispose();
-        }
-        base.Dispose(disposing);
-    }
-
-    #endregion
-}
-
-
-
+    private void UpdateEmbeddingGradients(Tensor<T> gradient)
+    {
+        // Update decoder position embedding gradients
+        if (_decoderPositionEmbeddingsGradients is not null && gradient.Data.Length > 0)
+        {
+            int gradLen = Math.Min(gradient.Data.Length, _decoderPositionEmbeddingsGradients.Data.Length);
+            for (int i = 0; i < gradLen; i++)
+            {
+                _decoderPositionEmbeddingsGradients.Data.Span[i] = NumOps.Add(
+                    _decoderPositionEmbeddingsGradients.Data.Span[i],
+                    gradient.Data.Span[i % gradient.Data.Length]);
+            }
+        }
+    }
+
+    private Vector<T> CollectParameterGradients()
+    {
+        var gradients = new List<T>();
+        EnsureNativeInitialized();
+
+        // Collect gradients from all layers
+        foreach (var layer in Layers)
+        {
+            var layerGradients = layer.GetParameterGradients();
+            gradients.AddRange(layerGradients);
+        }
+
+        // Add embedding gradients
+        if (_decoderPositionEmbeddingsGradients is not null)
+            gradients.AddRange(_decoderPositionEmbeddingsGradients.Data.ToArray());
+
+        return new Vector<T>([.. gradients]);
+    }
+
+    #endregion
+
+    #region Disposal
+
+    /// <inheritdoc/>
+    protected override void Dispose(bool disposing)
+    {
+        if (disposing)
+        {
+            _onnxEncoderSession?.Dispose();
+            _onnxDecoderSession?.Dispose();
+        }
+        base.Dispose(disposing);
+    }
+
+    #endregion
+}
+
+
+
diff --git a/src/Document/PixelToSequence/MATCHA.cs b/src/Document/PixelToSequence/MATCHA.cs
index 42a5ad8698..3a6ed352da 100644
--- a/src/Document/PixelToSequence/MATCHA.cs
+++ b/src/Document/PixelToSequence/MATCHA.cs
@@ -690,53 +690,6 @@ private byte[] SafeSerializeMaterializedModel()
             : SafeSerialize();
     }
 
-    /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_encoderDim);
-        writer.Write(_decoderDim);
-        writer.Write(_encoderLayers);
-        writer.Write(_decoderLayers);
-        writer.Write(_numHeads);
-        writer.Write(_vocabSize);
-        writer.Write(_maxPatchesPerImage);
-        writer.Write(ImageSize);
-        writer.Write(MaxSequenceLength);
-        writer.Write(_useNativeMode);
-    }
-
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        int encoderDim = reader.ReadInt32();
-        int decoderDim = reader.ReadInt32();
-        int encoderLayers = reader.ReadInt32();
-        int decoderLayers = reader.ReadInt32();
-        int numHeads = reader.ReadInt32();
-        int vocabSize = reader.ReadInt32();
-        int maxPatches = reader.ReadInt32();
-        int imageSize = reader.ReadInt32();
-        int maxSeqLen = reader.ReadInt32();
-        bool useNativeMode = reader.ReadBoolean();
-
-        ImageSize = imageSize;
-        MaxSequenceLength = maxSeqLen;
-        _nativeLayersInitialized = Layers.Count > 0;
-    }
-
-    /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var model = new MATCHA<T>(Architecture, ImageSize, MaxSequenceLength, _encoderDim, _decoderDim,
-            _encoderLayers, _decoderLayers, _numHeads, _vocabSize, _maxPatchesPerImage);
-        if (_nativeLayersInitialized)
-        {
-            model.EnsureNativeInitialized();
-        }
-
-        return model;
-    }
-
     #endregion
 
     #region NeuralNetworkBase Implementation
diff --git a/src/Document/PixelToSequence/Nougat.cs b/src/Document/PixelToSequence/Nougat.cs
index 3108364c32..45a74264a1 100644
--- a/src/Document/PixelToSequence/Nougat.cs
+++ b/src/Document/PixelToSequence/Nougat.cs
@@ -691,59 +691,6 @@ private byte[] SafeSerializeMaterializedModel()
             : SafeSerialize();
     }
 
-    /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_hiddenDim);
-        writer.Write(_numEncoderLayers);
-        writer.Write(_numDecoderLayers);
-        writer.Write(_numHeads);
-        writer.Write(_vocabSize);
-        writer.Write(ImageSize);
-        writer.Write(MaxSequenceLength);
-        writer.Write(_patchSize);
-        writer.Write(_useNativeMode);
-    }
-
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        int hiddenDim = reader.ReadInt32();
-        int numEncoderLayers = reader.ReadInt32();
-        int numDecoderLayers = reader.ReadInt32();
-        int numHeads = reader.ReadInt32();
-        int vocabSize = reader.ReadInt32();
-        int imageSize = reader.ReadInt32();
-        int maxSeqLen = reader.ReadInt32();
-        int patchSize = reader.ReadInt32();
-        bool useNativeMode = reader.ReadBoolean();
-
-        _hiddenDim = hiddenDim;
-        _numEncoderLayers = numEncoderLayers;
-        _numDecoderLayers = numDecoderLayers;
-        _numHeads = numHeads;
-        _vocabSize = vocabSize;
-        _patchSize = patchSize;
-        _useNativeMode = useNativeMode;
-
-        ImageSize = imageSize;
-        MaxSequenceLength = maxSeqLen;
-        _nativeLayersInitialized = Layers.Count > 0;
-    }
-
-    /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var model = new Nougat<T>(Architecture, _tokenizer, ImageSize, _patchSize, MaxSequenceLength,
-            _hiddenDim, _numEncoderLayers, _numDecoderLayers, _numHeads, _vocabSize);
-        if (_nativeLayersInitialized)
-        {
-            model.EnsureNativeInitialized();
-        }
-
-        return model;
-    }
-
     #endregion
 
     #region NeuralNetworkBase Implementation
diff --git a/src/Document/PixelToSequence/Pix2Struct.cs b/src/Document/PixelToSequence/Pix2Struct.cs
index cd48750dbf..5c6d020a81 100644
--- a/src/Document/PixelToSequence/Pix2Struct.cs
+++ b/src/Document/PixelToSequence/Pix2Struct.cs
@@ -514,53 +514,6 @@ private byte[] SafeSerializeMaterializedModel()
             : SafeSerialize();
     }
 
-    /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_hiddenDim);
-        writer.Write(_numEncoderLayers);
-        writer.Write(_numDecoderLayers);
-        writer.Write(_numHeads);
-        writer.Write(_vocabSize);
-        writer.Write(ImageSize);
-        writer.Write(MaxSequenceLength);
-        writer.Write(_patchSize);
-        writer.Write(_maxPatches);
-        writer.Write(_useNativeMode);
-    }
-
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        int hiddenDim = reader.ReadInt32();
-        int numEncoderLayers = reader.ReadInt32();
-        int numDecoderLayers = reader.ReadInt32();
-        int numHeads = reader.ReadInt32();
-        int vocabSize = reader.ReadInt32();
-        int imageSize = reader.ReadInt32();
-        int maxSeqLen = reader.ReadInt32();
-        int patchSize = reader.ReadInt32();
-        int maxPatches = reader.ReadInt32();
-        bool useNativeMode = reader.ReadBoolean();
-
-        ImageSize = imageSize;
-        MaxSequenceLength = maxSeqLen;
-        _nativeLayersInitialized = Layers.Count > 0;
-    }
-
-    /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var model = new Pix2Struct<T>(Architecture, _tokenizer, ImageSize, _patchSize, _maxPatches,
-            MaxSequenceLength, _hiddenDim, _numEncoderLayers, _numDecoderLayers, _numHeads, _vocabSize);
-        if (_nativeLayersInitialized)
-        {
-            model.EnsureNativeInitialized();
-        }
-
-        return model;
-    }
-
     #endregion
 
     #region NeuralNetworkBase Implementation
diff --git a/src/Document/VisionLanguage/DocOwl.cs b/src/Document/VisionLanguage/DocOwl.cs
index 84ae60d84f..a5bf5af263 100644
--- a/src/Document/VisionLanguage/DocOwl.cs
+++ b/src/Document/VisionLanguage/DocOwl.cs
@@ -556,42 +556,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_visionDim);
-        writer.Write(_languageDim);
-        writer.Write(_visionLayers);
-        writer.Write(_languageLayers);
-        writer.Write(_numHeads);
-        writer.Write(_vocabSize);
-        writer.Write(ImageSize);
-        writer.Write(MaxSequenceLength);
-        writer.Write(_useNativeMode);
-    }
-
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        int visionDim = reader.ReadInt32();
-        int languageDim = reader.ReadInt32();
-        int visionLayers = reader.ReadInt32();
-        int languageLayers = reader.ReadInt32();
-        int numHeads = reader.ReadInt32();
-        int vocabSize = reader.ReadInt32();
-        int imageSize = reader.ReadInt32();
-        int maxSeqLen = reader.ReadInt32();
-        bool useNativeMode = reader.ReadBoolean();
 
-        ImageSize = imageSize;
-        MaxSequenceLength = maxSeqLen;
-    }
 
     /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new DocOwl<T>(Architecture, ImageSize, MaxSequenceLength, _visionDim, _languageDim,
-            _visionLayers, _languageLayers, _numHeads, _vocabSize, visionNumHeads: _visionNumHeads);
-    }
+
 
     #endregion
 
diff --git a/src/Document/VisionLanguage/InfographicVQA.cs b/src/Document/VisionLanguage/InfographicVQA.cs
index 079dab48cb..3f2511487a 100644
--- a/src/Document/VisionLanguage/InfographicVQA.cs
+++ b/src/Document/VisionLanguage/InfographicVQA.cs
@@ -497,45 +497,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_visionDim);
-        writer.Write(_textDim);
-        writer.Write(_fusionDim);
-        writer.Write(_visionLayers);
-        writer.Write(_fusionLayers);
-        writer.Write(_numHeads);
-        writer.Write(_vocabSize);
-        writer.Write(ImageSize);
-        writer.Write(MaxSequenceLength);
-        writer.Write(_useNativeMode);
-    }
-
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        int visionDim = reader.ReadInt32();
-        int textDim = reader.ReadInt32();
-        int fusionDim = reader.ReadInt32();
-        int visionLayers = reader.ReadInt32();
-        int fusionLayers = reader.ReadInt32();
-        int numHeads = reader.ReadInt32();
-        int vocabSize = reader.ReadInt32();
-        int imageSize = reader.ReadInt32();
-        int maxSeqLen = reader.ReadInt32();
-        bool useNativeMode = reader.ReadBoolean();
 
-        ImageSize = imageSize;
-        MaxSequenceLength = maxSeqLen;
-    }
 
     /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new InfographicVQA<T>(Architecture, ImageSize, MaxSequenceLength, _visionDim, _textDim,
-            _fusionDim, _visionLayers, _fusionLayers, _numHeads, _vocabSize,
-            options: new InfographicVQAOptions(_options));
-    }
+
 
     #endregion
 
diff --git a/src/Document/VisionLanguage/UDOP.cs b/src/Document/VisionLanguage/UDOP.cs
index 0309f6fff2..caccd1d76b 100644
--- a/src/Document/VisionLanguage/UDOP.cs
+++ b/src/Document/VisionLanguage/UDOP.cs
@@ -1,119 +1,119 @@
-using AiDotNet.Attributes;
-using AiDotNet.Document.Interfaces;
-using AiDotNet.Document.Options;
-using AiDotNet.Enums;
-using AiDotNet.Helpers;
-using AiDotNet.Interfaces;
-using AiDotNet.LinearAlgebra;
-using AiDotNet.LossFunctions;
-using AiDotNet.NeuralNetworks;
-using AiDotNet.NeuralNetworks.Layers;
-using AiDotNet.Optimizers;
-using AiDotNet.Tokenization;
-using AiDotNet.Tokenization.Interfaces;
-using Microsoft.ML.OnnxRuntime;
-using AiDotNet.Validation;
-
-namespace AiDotNet.Document.VisionLanguage;
-
-/// <summary>
-/// UDOP (Unifying Vision, Text, and Layout for Universal Document Processing) neural network.
-/// </summary>
-/// <typeparam name="T">The numeric type used for calculations.</typeparam>
-/// <remarks>
-/// <para>
-/// UDOP is a foundation model for document AI that unifies text, image, and layout modalities
-/// within a single encoder-decoder framework. It can perform multiple document tasks through
-/// task-specific prompting.
-/// </para>
-/// <para>
-/// <b>For Beginners:</b> UDOP can handle many document tasks with one model:
-/// 1. Document classification
-/// 2. Information extraction (NER, key-value pairs)
-/// 3. Document question answering
-/// 4. Document layout analysis
-/// 5. Document generation
-///
-/// Example usage:
-/// <code>
-/// var model = new UDOP&lt;float&gt;(architecture);
-/// var result = model.AnswerQuestion(documentImage, "What is the invoice total?");
-/// </code>
-/// </para>
-/// <para>
-/// <b>Reference:</b> "Unifying Vision, Text, and Layout for Universal Document Processing" (CVPR 2023)
-/// https://arxiv.org/abs/2212.02623
-/// </para>
-/// </remarks>
-[ModelDomain(ModelDomain.Vision)]
-[ModelDomain(ModelDomain.Language)]
-[ModelDomain(ModelDomain.Multimodal)]
-[ModelCategory(ModelCategory.NeuralNetwork)]
-[ModelCategory(ModelCategory.Transformer)]
-[ModelCategory(ModelCategory.FoundationModel)]
-[ModelTask(ModelTask.Classification)]
-[ModelTask(ModelTask.Detection)]
-[ModelTask(ModelTask.FeatureExtraction)]
-[ModelComplexity(ModelComplexity.VeryHigh)]
-[ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
-[ResearchPaper("Unifying Vision, Text, and Layout for Universal Document Processing", "https://arxiv.org/abs/2212.02623", Year = 2023, Authors = "Zineng Tang, Ziyi Yang, Guoxin Wang, Yuwei Fang, Yang Liu, Chenguang Zhu, Michael Zeng, Cha Zhang, Mohit Bansal")]
-public partial class UDOP<T> : DocumentNeuralNetworkBase<T>, ILayoutDetector<T>, IDocumentQA<T>, IDocumentClassifier<T>
-{
-    private readonly UDOPOptions _options;
-
-    /// <inheritdoc/>
-    public override ModelOptions GetOptions() => _options;
-
-    #region Fields
-
-    private readonly bool _useNativeMode;
-    private readonly InferenceSession? _onnxSession;
-    private readonly ITokenizer _tokenizer;
-    private readonly IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>> _optimizer;
-    private readonly int _hiddenDim;
-    private readonly int _numEncoderLayers;
-    private readonly int _numDecoderLayers;
-    private readonly int _numHeads;
-    private readonly int _vocabSize;
-    private readonly int _numClasses;
-
-    // Native mode layers
-    private readonly List<ILayer<T>> _visualEncoderLayers = [];
-    private readonly List<ILayer<T>> _textEncoderLayers = [];
-    private readonly List<ILayer<T>> _unifiedEncoderLayers = [];
-    private readonly List<ILayer<T>> _decoderLayers = [];
-
-    // Document-classification head. UDOP is a generative encoder-decoder whose raw forward emits a
-    // [seq, vocab] token-logit tensor, but it also implements IDocumentClassifier — the ModelFamily
-    // invariant harness drives it as classification (numClasses logits vs a class target). This head
-    // pools the generated sequence to one document vector and projects it to numClasses so the forward
-    // yields a fixed rank-1 [numClasses] logit vector that aligns with the classification target (the
-    // raw [seq, vocab] tensor cannot be aligned to a class target, so CrossEntropyWithLogits over-indexed
-    // ClassIndicesToOneHot and threw). Held outside the sequential layer walk, applied after pooling.
-    private DenseLayer<T>? _classHead;
-
-    // True only when InitializeLayers built the default architecture and appended its own classification
-    // head as the last layer. For a custom Architecture.Layers stack we do NOT own a head — even one that
-    // happens to end in a DenseLayer is a user layer, not our pooled class head. Persisted so
-    // DeserializeNetworkSpecificData rebinds _classHead only when we actually created it, instead of
-    // blindly grabbing the last layer (which for a custom stack would wrongly skip that layer in the
-    // sequential walk AND reapply it after pooling).
-    private bool _hasBuiltInClassHead;
-
-    /// <summary>Guards <see cref="ResolveLazyLayerShapes"/> so the one-shot warm forward runs at most once.</summary>
-    private bool _lazyShapesWarmed;
-
-    #endregion
-
-    #region Properties
-
-    /// <inheritdoc/>
-    public override DocumentType SupportedDocumentTypes => DocumentType.All;
-
-    /// <inheritdoc/>
-    public override bool RequiresOCR => true;
-
-    /// <inheritdoc/>
+using AiDotNet.Attributes;
+using AiDotNet.Document.Interfaces;
+using AiDotNet.Document.Options;
+using AiDotNet.Enums;
+using AiDotNet.Helpers;
+using AiDotNet.Interfaces;
+using AiDotNet.LinearAlgebra;
+using AiDotNet.LossFunctions;
+using AiDotNet.NeuralNetworks;
+using AiDotNet.NeuralNetworks.Layers;
+using AiDotNet.Optimizers;
+using AiDotNet.Tokenization;
+using AiDotNet.Tokenization.Interfaces;
+using Microsoft.ML.OnnxRuntime;
+using AiDotNet.Validation;
+
+namespace AiDotNet.Document.VisionLanguage;
+
+/// <summary>
+/// UDOP (Unifying Vision, Text, and Layout for Universal Document Processing) neural network.
+/// </summary>
+/// <typeparam name="T">The numeric type used for calculations.</typeparam>
+/// <remarks>
+/// <para>
+/// UDOP is a foundation model for document AI that unifies text, image, and layout modalities
+/// within a single encoder-decoder framework. It can perform multiple document tasks through
+/// task-specific prompting.
+/// </para>
+/// <para>
+/// <b>For Beginners:</b> UDOP can handle many document tasks with one model:
+/// 1. Document classification
+/// 2. Information extraction (NER, key-value pairs)
+/// 3. Document question answering
+/// 4. Document layout analysis
+/// 5. Document generation
+///
+/// Example usage:
+/// <code>
+/// var model = new UDOP&lt;float&gt;(architecture);
+/// var result = model.AnswerQuestion(documentImage, "What is the invoice total?");
+/// </code>
+/// </para>
+/// <para>
+/// <b>Reference:</b> "Unifying Vision, Text, and Layout for Universal Document Processing" (CVPR 2023)
+/// https://arxiv.org/abs/2212.02623
+/// </para>
+/// </remarks>
+[ModelDomain(ModelDomain.Vision)]
+[ModelDomain(ModelDomain.Language)]
+[ModelDomain(ModelDomain.Multimodal)]
+[ModelCategory(ModelCategory.NeuralNetwork)]
+[ModelCategory(ModelCategory.Transformer)]
+[ModelCategory(ModelCategory.FoundationModel)]
+[ModelTask(ModelTask.Classification)]
+[ModelTask(ModelTask.Detection)]
+[ModelTask(ModelTask.FeatureExtraction)]
+[ModelComplexity(ModelComplexity.VeryHigh)]
+[ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
+[ResearchPaper("Unifying Vision, Text, and Layout for Universal Document Processing", "https://arxiv.org/abs/2212.02623", Year = 2023, Authors = "Zineng Tang, Ziyi Yang, Guoxin Wang, Yuwei Fang, Yang Liu, Chenguang Zhu, Michael Zeng, Cha Zhang, Mohit Bansal")]
+public partial class UDOP<T> : DocumentNeuralNetworkBase<T>, ILayoutDetector<T>, IDocumentQA<T>, IDocumentClassifier<T>
+{
+    private readonly UDOPOptions _options;
+
+    /// <inheritdoc/>
+    public override ModelOptions GetOptions() => _options;
+
+    #region Fields
+
+    private readonly bool _useNativeMode;
+    private readonly InferenceSession? _onnxSession;
+    private readonly ITokenizer _tokenizer;
+    private readonly IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>> _optimizer;
+    private readonly int _hiddenDim;
+    private readonly int _numEncoderLayers;
+    private readonly int _numDecoderLayers;
+    private readonly int _numHeads;
+    private readonly int _vocabSize;
+    private readonly int _numClasses;
+
+    // Native mode layers
+    private readonly List<ILayer<T>> _visualEncoderLayers = [];
+    private readonly List<ILayer<T>> _textEncoderLayers = [];
+    private readonly List<ILayer<T>> _unifiedEncoderLayers = [];
+    private readonly List<ILayer<T>> _decoderLayers = [];
+
+    // Document-classification head. UDOP is a generative encoder-decoder whose raw forward emits a
+    // [seq, vocab] token-logit tensor, but it also implements IDocumentClassifier — the ModelFamily
+    // invariant harness drives it as classification (numClasses logits vs a class target). This head
+    // pools the generated sequence to one document vector and projects it to numClasses so the forward
+    // yields a fixed rank-1 [numClasses] logit vector that aligns with the classification target (the
+    // raw [seq, vocab] tensor cannot be aligned to a class target, so CrossEntropyWithLogits over-indexed
+    // ClassIndicesToOneHot and threw). Held outside the sequential layer walk, applied after pooling.
+    private DenseLayer<T>? _classHead;
+
+    // True only when InitializeLayers built the default architecture and appended its own classification
+    // head as the last layer. For a custom Architecture.Layers stack we do NOT own a head — even one that
+    // happens to end in a DenseLayer is a user layer, not our pooled class head. Persisted so
+    // DeserializeNetworkSpecificData rebinds _classHead only when we actually created it, instead of
+    // blindly grabbing the last layer (which for a custom stack would wrongly skip that layer in the
+    // sequential walk AND reapply it after pooling).
+    private bool _hasBuiltInClassHead;
+
+    /// <summary>Guards <see cref="ResolveLazyLayerShapes"/> so the one-shot warm forward runs at most once.</summary>
+    private bool _lazyShapesWarmed;
+
+    #endregion
+
+    #region Properties
+
+    /// <inheritdoc/>
+    public override DocumentType SupportedDocumentTypes => DocumentType.All;
+
+    /// <inheritdoc/>
+    public override bool RequiresOCR => true;
+
+    /// <inheritdoc/>
     public int ExpectedImageSize => ImageSize;
 
     /// <summary>
@@ -125,208 +125,208 @@ protected override LayerInputDomain ResolveDocumentInputDomain(int[]? inputShape
         inputShape is { Length: < 3 }
             ? LayerInputDomain.Indices(_vocabSize)
             : LayerInputDomain.Continuous;
-
-    /// <inheritdoc/>
-    public IReadOnlyList<LayoutElementType> SupportedElementTypes { get; } =
-    [
-        LayoutElementType.Text,
-        LayoutElementType.Title,
-        LayoutElementType.List,
-        LayoutElementType.Table,
-        LayoutElementType.Figure,
-        LayoutElementType.Caption,
-        LayoutElementType.Header,
-        LayoutElementType.Footer,
-        LayoutElementType.FormField,
-        LayoutElementType.Equation
-    ];
-
-    /// <summary>
-    /// Gets the available document classification categories.
-    /// </summary>
-    public IReadOnlyList<string> AvailableCategories { get; } =
-    [
-        "letter", "form", "email", "handwritten", "advertisement",
-        "scientific", "specification", "file_folder", "news_article",
-        "budget", "invoice", "presentation", "questionnaire", "resume", "memo"
-    ];
-
-    #endregion
-
-    #region Constructors
-
-    /// <summary>
-    /// Creates a UDOP model using a pre-trained ONNX model for inference.
-    /// </summary>
-    public UDOP(
-        NeuralNetworkArchitecture<T> architecture,
-        string onnxModelPath,
-        ITokenizer tokenizer,
-        int numClasses = 16,
-        int imageSize = 224,
-        int maxSequenceLength = 2048,
-        int hiddenDim = 1024,
-        int numEncoderLayers = 12,
-        int numDecoderLayers = 12,
-        int numHeads = 16,
-        int vocabSize = 50000,
-        IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? optimizer = null,
-        ILossFunction<T>? lossFunction = null,
-        UDOPOptions? options = null)
-        : base(architecture, lossFunction ?? new CrossEntropyWithLogitsLoss<T>(), 1.0)
-    {
-        _options = options ?? new UDOPOptions();
-        Options = _options;
-
-        if (string.IsNullOrWhiteSpace(onnxModelPath))
-            throw new ArgumentNullException(nameof(onnxModelPath));
-        if (!File.Exists(onnxModelPath))
-            throw new FileNotFoundException($"ONNX model not found: {onnxModelPath}", onnxModelPath);
-
-        Guard.NotNull(tokenizer);
-        _tokenizer = tokenizer;
-        _useNativeMode = false;
-        _numClasses = numClasses;
-        _hiddenDim = hiddenDim;
-        _numEncoderLayers = numEncoderLayers;
-        _numDecoderLayers = numDecoderLayers;
-        _numHeads = numHeads;
-        _vocabSize = vocabSize;
-        // Tang et al. 2022 S4.1: learning rate 5e-5, beta1 0.9, beta2 0.98, weight decay 1e-2.
-        // Built with no options, this ran at Adam's 1e-3 default -- twenty times the paper rate.
-        // The paper pairs Adam with weight decay, which is AdamW's behaviour, so that is the
-        // faithful mapping here.
-        _optimizer = optimizer ?? new AdamWOptimizer<T, Tensor<T>, Tensor<T>>(this,
-            new AdamWOptimizerOptions<T, Tensor<T>, Tensor<T>>
-            {
-                InitialLearningRate = _options.LearningRate,
-                Beta1 = 0.9,
-                Beta2 = 0.98,
-                WeightDecay = 0.01
-            });
-
-        ImageSize = imageSize;
-        MaxSequenceLength = maxSequenceLength;
-
-        _onnxSession = new InferenceSession(onnxModelPath);
-
-        InitializeLayers();
-    }
-
-    /// <summary>
-    /// Creates a UDOP model using native layers for training and inference.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// <b>Default Configuration (UDOP-Large from CVPR 2023):</b>
-    /// - Vision Transformer for image encoding
-    /// - T5-style text encoder
-    /// - Unified cross-modal encoder
-    /// - T5-style decoder for generation
-    /// - Hidden dimension: 1024
-    /// - Encoder/Decoder layers: 12 each
-    /// </para>
-    /// </remarks>
-    public UDOP(
-        NeuralNetworkArchitecture<T> architecture,
-        ITokenizer? tokenizer = null,
-        int numClasses = 16,
-        int imageSize = 224,
-        int maxSequenceLength = 2048,
-        int hiddenDim = 1024,
-        int numEncoderLayers = 12,
-        int numDecoderLayers = 12,
-        int numHeads = 16,
-        int vocabSize = 50000,
-        IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? optimizer = null,
-        ILossFunction<T>? lossFunction = null,
-        UDOPOptions? options = null)
-        : base(architecture, lossFunction ?? new CrossEntropyWithLogitsLoss<T>(), 1.0)
-    {
-        _options = options ?? new UDOPOptions();
-        Options = _options;
-
-        // A 64px native instance is a smoke-scale model, not a useful carrier for UDOP-Large's
-        // 1024-wide 12+12-layer defaults. Scale only default-valued parameters in that explicit
-        // tiny-image mode; the normal 224px production constructor remains paper-faithful.
-        if (imageSize <= 64)
-        {
-            if (maxSequenceLength == 2048) maxSequenceLength = 64;
-            if (hiddenDim == 1024) hiddenDim = 64;
-            if (numEncoderLayers == 12) numEncoderLayers = 2;
-            if (numDecoderLayers == 12) numDecoderLayers = 2;
-            if (numHeads == 16) numHeads = 4;
-            if (vocabSize == 50000) vocabSize = 256;
-        }
-
-        _useNativeMode = true;
-        _numClasses = numClasses;
-        _hiddenDim = hiddenDim;
-        _numEncoderLayers = numEncoderLayers;
-        _numDecoderLayers = numDecoderLayers;
-        _numHeads = numHeads;
-        _vocabSize = vocabSize;
-        // Tang et al. 2022 S4.1: learning rate 5e-5, beta1 0.9, beta2 0.98, weight decay 1e-2.
-        // Built with no options, this ran at Adam's 1e-3 default -- twenty times the paper rate.
-        // The paper pairs Adam with weight decay, which is AdamW's behaviour, so that is the
-        // faithful mapping here.
-        _optimizer = optimizer ?? new AdamWOptimizer<T, Tensor<T>, Tensor<T>>(this,
-            new AdamWOptimizerOptions<T, Tensor<T>, Tensor<T>>
-            {
-                InitialLearningRate = _options.LearningRate,
-                Beta1 = 0.9,
-                Beta2 = 0.98,
-                WeightDecay = 0.01
-            });
-
-        ImageSize = imageSize;
-        MaxSequenceLength = maxSequenceLength;
-
-        _tokenizer = tokenizer ?? LanguageModelTokenizerFactory.CreateForBackbone(LanguageModelBackbone.OPT);
-
-        InitializeLayers();
-    }
-
-    #endregion
-
-    #region Initialization
-
-    /// <inheritdoc/>
-    protected override void InitializeLayers()
-    {
-        if (!_useNativeMode)
-        {
-            return;
-        }
-
-        if (Architecture.Layers is not null && Architecture.Layers.Count > 0)
-        {
-            Layers.AddRange(Architecture.Layers);
-            ValidateCustomLayers(Layers);
-            _hasBuiltInClassHead = false;
-            return;
-        }
-
+
+    /// <inheritdoc/>
+    public IReadOnlyList<LayoutElementType> SupportedElementTypes { get; } =
+    [
+        LayoutElementType.Text,
+        LayoutElementType.Title,
+        LayoutElementType.List,
+        LayoutElementType.Table,
+        LayoutElementType.Figure,
+        LayoutElementType.Caption,
+        LayoutElementType.Header,
+        LayoutElementType.Footer,
+        LayoutElementType.FormField,
+        LayoutElementType.Equation
+    ];
+
+    /// <summary>
+    /// Gets the available document classification categories.
+    /// </summary>
+    public IReadOnlyList<string> AvailableCategories { get; } =
+    [
+        "letter", "form", "email", "handwritten", "advertisement",
+        "scientific", "specification", "file_folder", "news_article",
+        "budget", "invoice", "presentation", "questionnaire", "resume", "memo"
+    ];
+
+    #endregion
+
+    #region Constructors
+
+    /// <summary>
+    /// Creates a UDOP model using a pre-trained ONNX model for inference.
+    /// </summary>
+    public UDOP(
+        NeuralNetworkArchitecture<T> architecture,
+        string onnxModelPath,
+        ITokenizer tokenizer,
+        int numClasses = 16,
+        int imageSize = 224,
+        int maxSequenceLength = 2048,
+        int hiddenDim = 1024,
+        int numEncoderLayers = 12,
+        int numDecoderLayers = 12,
+        int numHeads = 16,
+        int vocabSize = 50000,
+        IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? optimizer = null,
+        ILossFunction<T>? lossFunction = null,
+        UDOPOptions? options = null)
+        : base(architecture, lossFunction ?? new CrossEntropyWithLogitsLoss<T>(), 1.0)
+    {
+        _options = options ?? new UDOPOptions();
+        Options = _options;
+
+        if (string.IsNullOrWhiteSpace(onnxModelPath))
+            throw new ArgumentNullException(nameof(onnxModelPath));
+        if (!File.Exists(onnxModelPath))
+            throw new FileNotFoundException($"ONNX model not found: {onnxModelPath}", onnxModelPath);
+
+        Guard.NotNull(tokenizer);
+        _tokenizer = tokenizer;
+        _useNativeMode = false;
+        _numClasses = numClasses;
+        _hiddenDim = hiddenDim;
+        _numEncoderLayers = numEncoderLayers;
+        _numDecoderLayers = numDecoderLayers;
+        _numHeads = numHeads;
+        _vocabSize = vocabSize;
+        // Tang et al. 2022 S4.1: learning rate 5e-5, beta1 0.9, beta2 0.98, weight decay 1e-2.
+        // Built with no options, this ran at Adam's 1e-3 default -- twenty times the paper rate.
+        // The paper pairs Adam with weight decay, which is AdamW's behaviour, so that is the
+        // faithful mapping here.
+        _optimizer = optimizer ?? new AdamWOptimizer<T, Tensor<T>, Tensor<T>>(this,
+            new AdamWOptimizerOptions<T, Tensor<T>, Tensor<T>>
+            {
+                InitialLearningRate = _options.LearningRate,
+                Beta1 = 0.9,
+                Beta2 = 0.98,
+                WeightDecay = 0.01
+            });
+
+        ImageSize = imageSize;
+        MaxSequenceLength = maxSequenceLength;
+
+        _onnxSession = new InferenceSession(onnxModelPath);
+
+        InitializeLayers();
+    }
+
+    /// <summary>
+    /// Creates a UDOP model using native layers for training and inference.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// <b>Default Configuration (UDOP-Large from CVPR 2023):</b>
+    /// - Vision Transformer for image encoding
+    /// - T5-style text encoder
+    /// - Unified cross-modal encoder
+    /// - T5-style decoder for generation
+    /// - Hidden dimension: 1024
+    /// - Encoder/Decoder layers: 12 each
+    /// </para>
+    /// </remarks>
+    public UDOP(
+        NeuralNetworkArchitecture<T> architecture,
+        ITokenizer? tokenizer = null,
+        int numClasses = 16,
+        int imageSize = 224,
+        int maxSequenceLength = 2048,
+        int hiddenDim = 1024,
+        int numEncoderLayers = 12,
+        int numDecoderLayers = 12,
+        int numHeads = 16,
+        int vocabSize = 50000,
+        IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? optimizer = null,
+        ILossFunction<T>? lossFunction = null,
+        UDOPOptions? options = null)
+        : base(architecture, lossFunction ?? new CrossEntropyWithLogitsLoss<T>(), 1.0)
+    {
+        _options = options ?? new UDOPOptions();
+        Options = _options;
+
+        // A 64px native instance is a smoke-scale model, not a useful carrier for UDOP-Large's
+        // 1024-wide 12+12-layer defaults. Scale only default-valued parameters in that explicit
+        // tiny-image mode; the normal 224px production constructor remains paper-faithful.
+        if (imageSize <= 64)
+        {
+            if (maxSequenceLength == 2048) maxSequenceLength = 64;
+            if (hiddenDim == 1024) hiddenDim = 64;
+            if (numEncoderLayers == 12) numEncoderLayers = 2;
+            if (numDecoderLayers == 12) numDecoderLayers = 2;
+            if (numHeads == 16) numHeads = 4;
+            if (vocabSize == 50000) vocabSize = 256;
+        }
+
+        _useNativeMode = true;
+        _numClasses = numClasses;
+        _hiddenDim = hiddenDim;
+        _numEncoderLayers = numEncoderLayers;
+        _numDecoderLayers = numDecoderLayers;
+        _numHeads = numHeads;
+        _vocabSize = vocabSize;
+        // Tang et al. 2022 S4.1: learning rate 5e-5, beta1 0.9, beta2 0.98, weight decay 1e-2.
+        // Built with no options, this ran at Adam's 1e-3 default -- twenty times the paper rate.
+        // The paper pairs Adam with weight decay, which is AdamW's behaviour, so that is the
+        // faithful mapping here.
+        _optimizer = optimizer ?? new AdamWOptimizer<T, Tensor<T>, Tensor<T>>(this,
+            new AdamWOptimizerOptions<T, Tensor<T>, Tensor<T>>
+            {
+                InitialLearningRate = _options.LearningRate,
+                Beta1 = 0.9,
+                Beta2 = 0.98,
+                WeightDecay = 0.01
+            });
+
+        ImageSize = imageSize;
+        MaxSequenceLength = maxSequenceLength;
+
+        _tokenizer = tokenizer ?? LanguageModelTokenizerFactory.CreateForBackbone(LanguageModelBackbone.OPT);
+
+        InitializeLayers();
+    }
+
+    #endregion
+
+    #region Initialization
+
+    /// <inheritdoc/>
+    protected override void InitializeLayers()
+    {
+        if (!_useNativeMode)
+        {
+            return;
+        }
+
+        if (Architecture.Layers is not null && Architecture.Layers.Count > 0)
+        {
+            Layers.AddRange(Architecture.Layers);
+            ValidateCustomLayers(Layers);
+            _hasBuiltInClassHead = false;
+            return;
+        }
+
         var (encoderLayers, decoderLayers) = LayerHelper<T>.CreateDefaultUDOPLayers(
             hiddenDim: _hiddenDim,
-            numEncoderLayers: _numEncoderLayers,
-            numDecoderLayers: _numDecoderLayers,
-            numHeads: _numHeads,
-            vocabSize: _vocabSize,
-            imageSize: ImageSize,
-            maxSequenceLength: MaxSequenceLength);
-
+            numEncoderLayers: _numEncoderLayers,
+            numDecoderLayers: _numDecoderLayers,
+            numHeads: _numHeads,
+            vocabSize: _vocabSize,
+            imageSize: ImageSize,
+            maxSequenceLength: MaxSequenceLength);
+
         var encoder = encoderLayers.ToArray();
         var decoder = decoderLayers.ToArray();
         Layers.AddRange(encoder);
         Layers.AddRange(decoder);
         PartitionDefaultGraph(encoder, decoder);
-
-        // Classification head (see field docs): pools the generative sequence and projects to numClasses.
-        // Added to Layers so it trains and serializes with the rest, but skipped in the sequential Forward
-        // walk (applied explicitly after mean-pooling).
-        _classHead = new DenseLayer<T>(_numClasses);
-        Layers.Add(_classHead);
+
+        // Classification head (see field docs): pools the generative sequence and projects to numClasses.
+        // Added to Layers so it trains and serializes with the rest, but skipped in the sequential Forward
+        // walk (applied explicitly after mean-pooling).
+        _classHead = new DenseLayer<T>(_numClasses);
+        Layers.Add(_classHead);
         _hasBuiltInClassHead = true;
     }
 
@@ -397,457 +397,394 @@ private Tensor<T> RunUdopSequence(IReadOnlyList<ILayer<T>> layers, Tensor<T> inp
         }
         return output;
     }
-
-    /// <summary>
-    /// Resolves every lazy layer's shape by running ONE dummy image forward. UDOP's forward is a custom
-    /// encoder-decoder (conv stem -> reshape -> cross-attending decoder -> pooled classification head),
-    /// not a plain sequential walk, so the base per-layer shape inference doesn't materialize all weights;
-    /// leaving them lazy meant a freshly-cloned model's SetParameters silently skipped the unresolved
-    /// layers and the clone kept its own random init (Clone_* diverged by ~O(1), the #1221 class). One
-    /// eval-mode warm forward at the real [3, ImageSize, ImageSize] page shape resolves them all.
-    /// </summary>
-    protected override void ResolveLazyLayerShapes()
-    {
-        if (_lazyShapesWarmed) return;
-        _lazyShapesWarmed = true;
-        if (!_useNativeMode) return;
-
-        var dummy = new Tensor<T>([3, ImageSize, ImageSize]);
-        bool wasTraining = IsTrainingMode;
-        if (wasTraining) SetTrainingMode(false);
-        // The warm-up is genuinely best-effort -- a real forward failure surfaces again on the actual
-        // Train/Predict call -- but a bare `catch { }` also swallowed the diagnosis. When shapes fail to
-        // resolve here, the later failure carries no hint that the warm-up already saw the same problem,
-        // so the exception is reported rather than discarded. It is still not rethrown: the caller has
-        // not asked to run the model yet.
-        try { _ = Forward(dummy); }
-        catch (Exception ex)
-        {
-            System.Diagnostics.Debug.WriteLine(
-                $"{nameof(UDOP<T>)}: lazy shape resolution failed on a {ImageSize}x{ImageSize} warm-up "
-                + $"pass; shapes stay unresolved until the first real Train/Predict. {ex}");
-        }
-        finally { if (wasTraining) SetTrainingMode(true); }
-    }
-
-    #endregion
-
-    #region ILayoutDetector Implementation
-
-    /// <inheritdoc/>
-    public DocumentLayoutResult<T> DetectLayout(Tensor<T> documentImage)
-    {
-        return DetectLayout(documentImage, 0.5);
-    }
-
-    /// <inheritdoc/>
-    public DocumentLayoutResult<T> DetectLayout(Tensor<T> documentImage, double confidenceThreshold)
-    {
-        ValidateImageShape(documentImage);
-        var startTime = DateTime.UtcNow;
-
-        var preprocessed = PreprocessDocument(documentImage);
-        // Layout detection is a generative/per-region task: it needs the rank-2 [numDetections, numClasses]
-        // sequence output that ParseLayoutOutput indexes as output[i, c]. Use the raw encoder-decoder
-        // forward, NOT Forward — Forward pools + projects through the classification head to a rank-1
-        // [numClasses] vector, which would collapse every detection and break the two-dimensional indexing.
-        var output = _useNativeMode ? ForwardEncoderDecoder(preprocessed) : RunOnnxInference(preprocessed);
-
-        var regions = ParseLayoutOutput(output, confidenceThreshold);
-
-        return new DocumentLayoutResult<T>
-        {
-            Regions = regions,
-            ProcessingTimeMs = (DateTime.UtcNow - startTime).TotalMilliseconds
-        };
-    }
-
-    private List<LayoutRegion<T>> ParseLayoutOutput(Tensor<T> output, double threshold)
-    {
-        var regions = new List<LayoutRegion<T>>();
-        int numDetections = output.Shape[0];
-        int numClasses = output.Shape.Length > 1 ? output.Shape[1] : _numClasses;
-
-        for (int i = 0; i < numDetections; i++)
-        {
-            double maxConf = 0;
-            int maxClass = 0;
-            for (int c = 0; c < numClasses; c++)
-            {
-                double conf = NumOps.ToDouble(output[i, c]);
-                if (conf > maxConf) { maxConf = conf; maxClass = c; }
-            }
-
-            if (maxConf >= threshold && maxClass > 0)
-            {
-                regions.Add(new LayoutRegion<T>
-                {
-                    ElementType = (LayoutElementType)Math.Min(maxClass, (int)LayoutElementType.Other),
-                    Confidence = NumOps.FromDouble(maxConf),
-                    ConfidenceValue = maxConf,
-                    Index = i,
-                    BoundingBox = Vector<T>.Empty()
-                });
-            }
-        }
-
-        return regions;
-    }
-
-    #endregion
-
-    #region IDocumentQA Implementation
-
-    /// <inheritdoc/>
-    public DocumentQAResult<T> AnswerQuestion(Tensor<T> documentImage, string question)
-    {
-        return AnswerQuestion(documentImage, question, 256, 0.0);
-    }
-
-    /// <inheritdoc/>
-    public DocumentQAResult<T> AnswerQuestion(Tensor<T> documentImage, string question, int maxAnswerLength, double temperature = 0.0)
-    {
-        ValidateImageShape(documentImage);
-        var startTime = DateTime.UtcNow;
-
-        var preprocessed = PreprocessDocument(documentImage);
-        // Question answering is generative: DecodeGenerativeOutput indexes the rank-2 [seq, vocab]
-        // sequence as output[t, v]. Use the raw encoder-decoder forward, NOT Forward — Forward pools +
-        // projects through the classification head to a rank-1 [numClasses] vector, which would leave no
-        // per-token axis to decode.
-        var output = _useNativeMode ? ForwardEncoderDecoder(preprocessed) : RunOnnxInference(preprocessed);
-
-        // UDOP uses generative output - decode the sequence
-        var (answer, confidence) = DecodeGenerativeOutput(output, maxAnswerLength);
-
-        return new DocumentQAResult<T>
-        {
-            Answer = answer,
-            Confidence = NumOps.FromDouble(confidence),
-            ConfidenceValue = confidence,
-            Question = question,
-            ProcessingTimeMs = (DateTime.UtcNow - startTime).TotalMilliseconds
-        };
-    }
-
-    /// <summary>
-    /// Decodes generative output from UDOP model.
-    /// </summary>
-    private (string answer, double confidence) DecodeGenerativeOutput(Tensor<T> output, int maxLength)
-    {
-        var tokens = new List<int>();
-        double totalConfidence = 0;
-        int seqLen = Math.Min(output.Shape[0], maxLength);
-
-        for (int t = 0; t < seqLen; t++)
-        {
-            int vocabSize = output.Shape.Length > 1 ? output.Shape[1] : _vocabSize;
-            double maxVal = double.MinValue;
-            int maxIdx = 0;
-
-            for (int v = 0; v < vocabSize; v++)
-            {
-                double val = NumOps.ToDouble(output[t, v]);
-                if (val > maxVal) { maxVal = val; maxIdx = v; }
-            }
-
-            // T5-style tokens: 0=PAD, 1=EOS
-            if (maxIdx == 1) break; // EOS
-            if (maxIdx == 0) continue; // Skip PAD
-            tokens.Add(maxIdx);
-            totalConfidence += maxVal;
-        }
-
-        string answer = DecodeTokensToText(tokens);
-        double confidence = tokens.Count > 0 ? Math.Max(0, Math.Min(1, totalConfidence / tokens.Count)) : 0;
-
-        return (string.IsNullOrEmpty(answer) ? "[No answer found]" : answer, confidence);
-    }
-
-    /// <summary>
-    /// Decodes token IDs to text using T5-style vocabulary.
-    /// </summary>
-    private static string DecodeTokensToText(List<int> tokens)
-    {
-        if (tokens.Count == 0) return string.Empty;
-
-        var sb = new System.Text.StringBuilder();
-        foreach (int token in tokens)
-        {
-            char c = token switch
-            {
-                >= 2 and <= 33 => (char)(token - 2 + 32),    // Space, punctuation, digits
-                >= 34 and <= 59 => (char)(token - 34 + 65),  // A-Z
-                >= 60 and <= 85 => (char)(token - 60 + 97),  // a-z
-                >= 86 and <= 213 => (char)(token - 86 + 128), // Extended ASCII
-                _ => (char)((token % 95) + 32) // Fallback
-            };
-            sb.Append(c);
-        }
-
-        return sb.ToString();
-    }
-
-    /// <inheritdoc/>
-    public IEnumerable<DocumentQAResult<T>> AnswerQuestions(Tensor<T> documentImage, IEnumerable<string> questions)
-    {
-        foreach (var q in questions)
-            yield return AnswerQuestion(documentImage, q);
-    }
-
-    /// <inheritdoc/>
-    public Dictionary<string, DocumentQAResult<T>> ExtractFields(Tensor<T> documentImage, IEnumerable<string> fieldPrompts)
-    {
-        var results = new Dictionary<string, DocumentQAResult<T>>();
-        foreach (var field in fieldPrompts)
-            results[field] = AnswerQuestion(documentImage, $"What is the {field}?");
-        return results;
-    }
-
-    #endregion
-
-    #region IDocumentClassifier Implementation
-
-    /// <inheritdoc/>
-    public DocumentClassificationResult<T> ClassifyDocument(Tensor<T> documentImage)
-    {
-        return ClassifyDocument(documentImage, 5);
-    }
-
-    /// <inheritdoc/>
-    public DocumentClassificationResult<T> ClassifyDocument(Tensor<T> documentImage, int topK)
-    {
-        ValidateImageShape(documentImage);
-        var startTime = DateTime.UtcNow;
-
-        var preprocessed = PreprocessDocument(documentImage);
-        var output = _useNativeMode ? Forward(preprocessed) : RunOnnxInference(preprocessed);
-
-        var probs = ApplySoftmax(output);
-        var topPredictions = GetTopKPredictions(probs, topK);
-
-        return new DocumentClassificationResult<T>
-        {
-            PredictedCategory = topPredictions[0].Category,
-            Confidence = NumOps.FromDouble(topPredictions[0].Score),
-            ConfidenceValue = topPredictions[0].Score,
-            TopPredictions = topPredictions,
-            ProcessingTimeMs = (DateTime.UtcNow - startTime).TotalMilliseconds
-        };
-    }
-
-    private List<(string Category, double Score)> GetTopKPredictions(Tensor<T> probs, int k)
-    {
-        var predictions = new List<(string Category, double Score)>();
-        int numClasses = Math.Min(probs.Data.Length, AvailableCategories.Count);
-
-        for (int i = 0; i < numClasses; i++)
-        {
-            predictions.Add((AvailableCategories[i], NumOps.ToDouble(probs.Data.Span[i])));
-        }
-
-        return predictions.OrderByDescending(p => p.Score).Take(k).ToList();
-    }
-
-    private Tensor<T> ApplySoftmax(Tensor<T> input)
-    {
-        return Engine.Softmax(input, -1);
-    }
-
-    #endregion
-
-    #region IDocumentModel Implementation
-
-    /// <inheritdoc/>
-    public Tensor<T> EncodeDocument(Tensor<T> documentImage)
-    {
-        ValidateImageShape(documentImage);
-        var preprocessed = PreprocessDocument(documentImage);
-        return _useNativeMode ? Forward(preprocessed) : RunOnnxInference(preprocessed);
-    }
-
-    /// <inheritdoc/>
-    public void ValidateInputShape(Tensor<T> documentImage)
-    {
-        ValidateImageShape(documentImage);
-    }
-
-    /// <inheritdoc/>
-    public string GetModelSummary()
-    {
-        var sb = new System.Text.StringBuilder();
-        sb.AppendLine("UDOP Model Summary");
-        sb.AppendLine("==================");
-        sb.AppendLine($"Mode: {(_useNativeMode ? "Native (Trainable)" : "ONNX (Inference)")}");
-        sb.AppendLine($"Architecture: Unified Vision-Text-Layout Encoder-Decoder");
-        sb.AppendLine($"Hidden Dimension: {_hiddenDim}");
-        sb.AppendLine($"Encoder Layers: {_numEncoderLayers}");
-        sb.AppendLine($"Decoder Layers: {_numDecoderLayers}");
-        sb.AppendLine($"Attention Heads: {_numHeads}");
-        sb.AppendLine($"Image Size: {ImageSize}x{ImageSize}");
-        sb.AppendLine($"Max Sequence Length: {MaxSequenceLength}");
-        sb.AppendLine($"Number of Classes: {_numClasses}");
-        sb.AppendLine($"Capabilities: Layout, QA, Classification, Generation");
-        sb.AppendLine($"Total Layers: {Layers.Count}");
-        return sb.ToString();
-    }
-
-    #endregion
-
-    #region Preprocessing
-
-    /// <summary>
-    /// Applies UDOP's industry-standard preprocessing: ImageNet normalization.
-    /// </summary>
-    /// <remarks>
-    /// UDOP (Unified Document Processing) uses ImageNet normalization with
-    /// mean=[0.485, 0.456, 0.406] and std=[0.229, 0.224, 0.225] (Microsoft paper).
-    /// </remarks>
-    protected override Tensor<T> ApplyDefaultPreprocessing(Tensor<T> rawImage)
-    {
-        var image = EnsureBatchDimension(rawImage);
-        int batchSize = image.Shape[0];
-        int channels = image.Shape[1];
-        int height = image.Shape[2];
-        int width = image.Shape[3];
-
-        var normalized = new Tensor<T>(image._shape);
-        double[] means = [0.485, 0.456, 0.406];
-        double[] stds = [0.229, 0.224, 0.225];
-
-        for (int b = 0; b < batchSize; b++)
-        {
-            for (int c = 0; c < channels; c++)
-            {
-                double mean = c < means.Length ? means[c] : 0.5;
-                double std = c < stds.Length ? stds[c] : 0.5;
-                for (int h = 0; h < height; h++)
-                {
-                    for (int w = 0; w < width; w++)
-                    {
-                        int idx = b * channels * height * width + c * height * width + h * width + w;
-                        normalized.Data.Span[idx] = NumOps.FromDouble((NumOps.ToDouble(image.Data.Span[idx]) - mean) / std);
-                    }
-                }
-            }
-        }
-        return normalized;
-    }
-
-    /// <summary>
-    /// Applies UDOP's industry-standard postprocessing: pass-through (unified outputs are already final).
-    /// </summary>
-    protected override Tensor<T> ApplyDefaultPostprocessing(Tensor<T> modelOutput) => modelOutput;
-
-    #endregion
-
-    #region Serialization
-
-    /// <inheritdoc/>
-    public override ModelMetadata<T> GetModelMetadata()
-    {
-        return new ModelMetadata<T>
-        {
-            Name = "UDOP",
-            Description = "UDOP for unified document processing (CVPR 2023)",
-            FeatureCount = _hiddenDim,
-            Complexity = _numEncoderLayers + _numDecoderLayers,
-            AdditionalInfo = new Dictionary<string, object>
-            {
-                { "hidden_dim", _hiddenDim },
-                { "num_encoder_layers", _numEncoderLayers },
-                { "num_decoder_layers", _numDecoderLayers },
-                { "num_heads", _numHeads },
-                { "image_size", ImageSize },
-                { "vocab_size", _vocabSize },
-                { "num_classes", _numClasses },
-                { "use_native_mode", _useNativeMode }
-            },
-            ModelData = SafeSerialize()
-        };
-    }
-
-    /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_hiddenDim);
-        writer.Write(_numEncoderLayers);
-        writer.Write(_numDecoderLayers);
-        writer.Write(_numHeads);
-        writer.Write(_vocabSize);
-        writer.Write(ImageSize);
-        writer.Write(MaxSequenceLength);
-        writer.Write(_numClasses);
-        writer.Write(_useNativeMode);
-        writer.Write(_hasBuiltInClassHead);
-    }
-
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        int hiddenDim = reader.ReadInt32();
-        int numEncoderLayers = reader.ReadInt32();
-        int numDecoderLayers = reader.ReadInt32();
-        int numHeads = reader.ReadInt32();
-        int vocabSize = reader.ReadInt32();
-        int imageSize = reader.ReadInt32();
-        int maxSeqLen = reader.ReadInt32();
-        int numClasses = reader.ReadInt32();
-        bool useNativeMode = reader.ReadBoolean();
-        _hasBuiltInClassHead = reader.ReadBoolean();
-
-        ImageSize = imageSize;
-        MaxSequenceLength = maxSeqLen;
-
-        // Re-derive the classification-head reference from the layers the base just reconstructed. The
-        // base ClearLayers()+rebuilds Layers from the serialized metadata/params before calling this, but
-        // our _classHead FIELD still points at the orphaned pre-deserialize InitializeLayers instance
-        // (fresh random weights). Without re-pointing it, Forward would (a) fail to skip the real
-        // (restored) head in the sequential walk and (b) apply the stale random head after pooling — so a
-        // deserialized clone diverged by ~O(1) from the original (Clone_* failures). The head is the last
-        // layer (added last in InitializeLayers, order preserved through serialization).
-        //
-        // Only rebind when the ORIGINAL model actually created the built-in head. A custom
-        // Architecture.Layers stack owns no head — and if it happens to end in a DenseLayer, grabbing it
-        // as _classHead would wrongly skip that user layer in the sequential walk and reapply it after
-        // pooling. In that case leave _classHead null so Forward runs the custom stack straight through.
-        if (_hasBuiltInClassHead && Layers.Count > 0)
-            _classHead = Layers[Layers.Count - 1] as DenseLayer<T>;
-        else
-            _classHead = null;
 
-        if (_hasBuiltInClassHead)
+    /// <summary>
+    /// Resolves every lazy layer's shape by running ONE dummy image forward. UDOP's forward is a custom
+    /// encoder-decoder (conv stem -> reshape -> cross-attending decoder -> pooled classification head),
+    /// not a plain sequential walk, so the base per-layer shape inference doesn't materialize all weights;
+    /// leaving them lazy meant a freshly-cloned model's SetParameters silently skipped the unresolved
+    /// layers and the clone kept its own random init (Clone_* diverged by ~O(1), the #1221 class). One
+    /// eval-mode warm forward at the real [3, ImageSize, ImageSize] page shape resolves them all.
+    /// </summary>
+    protected override void ResolveLazyLayerShapes()
+    {
+        if (_lazyShapesWarmed) return;
+        _lazyShapesWarmed = true;
+        if (!_useNativeMode) return;
+
+        var dummy = new Tensor<T>([3, ImageSize, ImageSize]);
+        bool wasTraining = IsTrainingMode;
+        if (wasTraining) SetTrainingMode(false);
+        // The warm-up is genuinely best-effort -- a real forward failure surfaces again on the actual
+        // Train/Predict call -- but a bare `catch { }` also swallowed the diagnosis. When shapes fail to
+        // resolve here, the later failure carries no hint that the warm-up already saw the same problem,
+        // so the exception is reported rather than discarded. It is still not rethrown: the caller has
+        // not asked to run the model yet.
+        try { _ = Forward(dummy); }
+        catch (Exception ex)
+        {
+            System.Diagnostics.Debug.WriteLine(
+                $"{nameof(UDOP<T>)}: lazy shape resolution failed on a {ImageSize}x{ImageSize} warm-up "
+                + $"pass; shapes stay unresolved until the first real Train/Predict. {ex}");
+        }
+        finally { if (wasTraining) SetTrainingMode(true); }
+    }
+
+    #endregion
+
+    #region ILayoutDetector Implementation
+
+    /// <inheritdoc/>
+    public DocumentLayoutResult<T> DetectLayout(Tensor<T> documentImage)
+    {
+        return DetectLayout(documentImage, 0.5);
+    }
+
+    /// <inheritdoc/>
+    public DocumentLayoutResult<T> DetectLayout(Tensor<T> documentImage, double confidenceThreshold)
+    {
+        ValidateImageShape(documentImage);
+        var startTime = DateTime.UtcNow;
+
+        var preprocessed = PreprocessDocument(documentImage);
+        // Layout detection is a generative/per-region task: it needs the rank-2 [numDetections, numClasses]
+        // sequence output that ParseLayoutOutput indexes as output[i, c]. Use the raw encoder-decoder
+        // forward, NOT Forward — Forward pools + projects through the classification head to a rank-1
+        // [numClasses] vector, which would collapse every detection and break the two-dimensional indexing.
+        var output = _useNativeMode ? ForwardEncoderDecoder(preprocessed) : RunOnnxInference(preprocessed);
+
+        var regions = ParseLayoutOutput(output, confidenceThreshold);
+
+        return new DocumentLayoutResult<T>
+        {
+            Regions = regions,
+            ProcessingTimeMs = (DateTime.UtcNow - startTime).TotalMilliseconds
+        };
+    }
+
+    private List<LayoutRegion<T>> ParseLayoutOutput(Tensor<T> output, double threshold)
+    {
+        var regions = new List<LayoutRegion<T>>();
+        int numDetections = output.Shape[0];
+        int numClasses = output.Shape.Length > 1 ? output.Shape[1] : _numClasses;
+
+        for (int i = 0; i < numDetections; i++)
+        {
+            double maxConf = 0;
+            int maxClass = 0;
+            for (int c = 0; c < numClasses; c++)
+            {
+                double conf = NumOps.ToDouble(output[i, c]);
+                if (conf > maxConf) { maxConf = conf; maxClass = c; }
+            }
+
+            if (maxConf >= threshold && maxClass > 0)
+            {
+                regions.Add(new LayoutRegion<T>
+                {
+                    ElementType = (LayoutElementType)Math.Min(maxClass, (int)LayoutElementType.Other),
+                    Confidence = NumOps.FromDouble(maxConf),
+                    ConfidenceValue = maxConf,
+                    Index = i,
+                    BoundingBox = Vector<T>.Empty()
+                });
+            }
+        }
+
+        return regions;
+    }
+
+    #endregion
+
+    #region IDocumentQA Implementation
+
+    /// <inheritdoc/>
+    public DocumentQAResult<T> AnswerQuestion(Tensor<T> documentImage, string question)
+    {
+        return AnswerQuestion(documentImage, question, 256, 0.0);
+    }
+
+    /// <inheritdoc/>
+    public DocumentQAResult<T> AnswerQuestion(Tensor<T> documentImage, string question, int maxAnswerLength, double temperature = 0.0)
+    {
+        ValidateImageShape(documentImage);
+        var startTime = DateTime.UtcNow;
+
+        var preprocessed = PreprocessDocument(documentImage);
+        // Question answering is generative: DecodeGenerativeOutput indexes the rank-2 [seq, vocab]
+        // sequence as output[t, v]. Use the raw encoder-decoder forward, NOT Forward — Forward pools +
+        // projects through the classification head to a rank-1 [numClasses] vector, which would leave no
+        // per-token axis to decode.
+        var output = _useNativeMode ? ForwardEncoderDecoder(preprocessed) : RunOnnxInference(preprocessed);
+
+        // UDOP uses generative output - decode the sequence
+        var (answer, confidence) = DecodeGenerativeOutput(output, maxAnswerLength);
+
+        return new DocumentQAResult<T>
+        {
+            Answer = answer,
+            Confidence = NumOps.FromDouble(confidence),
+            ConfidenceValue = confidence,
+            Question = question,
+            ProcessingTimeMs = (DateTime.UtcNow - startTime).TotalMilliseconds
+        };
+    }
+
+    /// <summary>
+    /// Decodes generative output from UDOP model.
+    /// </summary>
+    private (string answer, double confidence) DecodeGenerativeOutput(Tensor<T> output, int maxLength)
+    {
+        var tokens = new List<int>();
+        double totalConfidence = 0;
+        int seqLen = Math.Min(output.Shape[0], maxLength);
+
+        for (int t = 0; t < seqLen; t++)
+        {
+            int vocabSize = output.Shape.Length > 1 ? output.Shape[1] : _vocabSize;
+            double maxVal = double.MinValue;
+            int maxIdx = 0;
+
+            for (int v = 0; v < vocabSize; v++)
+            {
+                double val = NumOps.ToDouble(output[t, v]);
+                if (val > maxVal) { maxVal = val; maxIdx = v; }
+            }
+
+            // T5-style tokens: 0=PAD, 1=EOS
+            if (maxIdx == 1) break; // EOS
+            if (maxIdx == 0) continue; // Skip PAD
+            tokens.Add(maxIdx);
+            totalConfidence += maxVal;
+        }
+
+        string answer = DecodeTokensToText(tokens);
+        double confidence = tokens.Count > 0 ? Math.Max(0, Math.Min(1, totalConfidence / tokens.Count)) : 0;
+
+        return (string.IsNullOrEmpty(answer) ? "[No answer found]" : answer, confidence);
+    }
+
+    /// <summary>
+    /// Decodes token IDs to text using T5-style vocabulary.
+    /// </summary>
+    private static string DecodeTokensToText(List<int> tokens)
+    {
+        if (tokens.Count == 0) return string.Empty;
+
+        var sb = new System.Text.StringBuilder();
+        foreach (int token in tokens)
+        {
+            char c = token switch
+            {
+                >= 2 and <= 33 => (char)(token - 2 + 32),    // Space, punctuation, digits
+                >= 34 and <= 59 => (char)(token - 34 + 65),  // A-Z
+                >= 60 and <= 85 => (char)(token - 60 + 97),  // a-z
+                >= 86 and <= 213 => (char)(token - 86 + 128), // Extended ASCII
+                _ => (char)((token % 95) + 32) // Fallback
+            };
+            sb.Append(c);
+        }
+
+        return sb.ToString();
+    }
+
+    /// <inheritdoc/>
+    public IEnumerable<DocumentQAResult<T>> AnswerQuestions(Tensor<T> documentImage, IEnumerable<string> questions)
+    {
+        foreach (var q in questions)
+            yield return AnswerQuestion(documentImage, q);
+    }
+
+    /// <inheritdoc/>
+    public Dictionary<string, DocumentQAResult<T>> ExtractFields(Tensor<T> documentImage, IEnumerable<string> fieldPrompts)
+    {
+        var results = new Dictionary<string, DocumentQAResult<T>>();
+        foreach (var field in fieldPrompts)
+            results[field] = AnswerQuestion(documentImage, $"What is the {field}?");
+        return results;
+    }
+
+    #endregion
+
+    #region IDocumentClassifier Implementation
+
+    /// <inheritdoc/>
+    public DocumentClassificationResult<T> ClassifyDocument(Tensor<T> documentImage)
+    {
+        return ClassifyDocument(documentImage, 5);
+    }
+
+    /// <inheritdoc/>
+    public DocumentClassificationResult<T> ClassifyDocument(Tensor<T> documentImage, int topK)
+    {
+        ValidateImageShape(documentImage);
+        var startTime = DateTime.UtcNow;
+
+        var preprocessed = PreprocessDocument(documentImage);
+        var output = _useNativeMode ? Forward(preprocessed) : RunOnnxInference(preprocessed);
+
+        var probs = ApplySoftmax(output);
+        var topPredictions = GetTopKPredictions(probs, topK);
+
+        return new DocumentClassificationResult<T>
+        {
+            PredictedCategory = topPredictions[0].Category,
+            Confidence = NumOps.FromDouble(topPredictions[0].Score),
+            ConfidenceValue = topPredictions[0].Score,
+            TopPredictions = topPredictions,
+            ProcessingTimeMs = (DateTime.UtcNow - startTime).TotalMilliseconds
+        };
+    }
+
+    private List<(string Category, double Score)> GetTopKPredictions(Tensor<T> probs, int k)
+    {
+        var predictions = new List<(string Category, double Score)>();
+        int numClasses = Math.Min(probs.Data.Length, AvailableCategories.Count);
+
+        for (int i = 0; i < numClasses; i++)
+        {
+            predictions.Add((AvailableCategories[i], NumOps.ToDouble(probs.Data.Span[i])));
+        }
+
+        return predictions.OrderByDescending(p => p.Score).Take(k).ToList();
+    }
+
+    private Tensor<T> ApplySoftmax(Tensor<T> input)
+    {
+        return Engine.Softmax(input, -1);
+    }
+
+    #endregion
+
+    #region IDocumentModel Implementation
+
+    /// <inheritdoc/>
+    public Tensor<T> EncodeDocument(Tensor<T> documentImage)
+    {
+        ValidateImageShape(documentImage);
+        var preprocessed = PreprocessDocument(documentImage);
+        return _useNativeMode ? Forward(preprocessed) : RunOnnxInference(preprocessed);
+    }
+
+    /// <inheritdoc/>
+    public void ValidateInputShape(Tensor<T> documentImage)
+    {
+        ValidateImageShape(documentImage);
+    }
+
+    /// <inheritdoc/>
+    public string GetModelSummary()
+    {
+        var sb = new System.Text.StringBuilder();
+        sb.AppendLine("UDOP Model Summary");
+        sb.AppendLine("==================");
+        sb.AppendLine($"Mode: {(_useNativeMode ? "Native (Trainable)" : "ONNX (Inference)")}");
+        sb.AppendLine($"Architecture: Unified Vision-Text-Layout Encoder-Decoder");
+        sb.AppendLine($"Hidden Dimension: {_hiddenDim}");
+        sb.AppendLine($"Encoder Layers: {_numEncoderLayers}");
+        sb.AppendLine($"Decoder Layers: {_numDecoderLayers}");
+        sb.AppendLine($"Attention Heads: {_numHeads}");
+        sb.AppendLine($"Image Size: {ImageSize}x{ImageSize}");
+        sb.AppendLine($"Max Sequence Length: {MaxSequenceLength}");
+        sb.AppendLine($"Number of Classes: {_numClasses}");
+        sb.AppendLine($"Capabilities: Layout, QA, Classification, Generation");
+        sb.AppendLine($"Total Layers: {Layers.Count}");
+        return sb.ToString();
+    }
+
+    #endregion
+
+    #region Preprocessing
+
+    /// <summary>
+    /// Applies UDOP's industry-standard preprocessing: ImageNet normalization.
+    /// </summary>
+    /// <remarks>
+    /// UDOP (Unified Document Processing) uses ImageNet normalization with
+    /// mean=[0.485, 0.456, 0.406] and std=[0.229, 0.224, 0.225] (Microsoft paper).
+    /// </remarks>
+    protected override Tensor<T> ApplyDefaultPreprocessing(Tensor<T> rawImage)
+    {
+        var image = EnsureBatchDimension(rawImage);
+        int batchSize = image.Shape[0];
+        int channels = image.Shape[1];
+        int height = image.Shape[2];
+        int width = image.Shape[3];
+
+        var normalized = new Tensor<T>(image._shape);
+        double[] means = [0.485, 0.456, 0.406];
+        double[] stds = [0.229, 0.224, 0.225];
+
+        for (int b = 0; b < batchSize; b++)
         {
-            int encoderCount = 5 + 5 * _numEncoderLayers;
-            int decoderCount = 4 + _numDecoderLayers;
-            if (Layers.Count >= encoderCount + decoderCount + 1)
+            for (int c = 0; c < channels; c++)
             {
-                PartitionDefaultGraph(
-                    Layers.Take(encoderCount).ToArray(),
-                    Layers.Skip(encoderCount).Take(decoderCount).ToArray());
+                double mean = c < means.Length ? means[c] : 0.5;
+                double std = c < stds.Length ? stds[c] : 0.5;
+                for (int h = 0; h < height; h++)
+                {
+                    for (int w = 0; w < width; w++)
+                    {
+                        int idx = b * channels * height * width + c * height * width + h * width + w;
+                        normalized.Data.Span[idx] = NumOps.FromDouble((NumOps.ToDouble(image.Data.Span[idx]) - mean) / std);
+                    }
+                }
             }
         }
-    }
-
-    /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new UDOP<T>(Architecture, _tokenizer, _numClasses, ImageSize, MaxSequenceLength,
-            _hiddenDim, _numEncoderLayers, _numDecoderLayers, _numHeads, _vocabSize);
-    }
-
-    #endregion
-
-    #region NeuralNetworkBase Implementation
-
-    /// <summary>
-    /// Raw encoder-decoder forward pass: runs encoder layers, then feeds encoder output as
-    /// cross-attention context to decoder layers, and returns the generative sequence tensor
-    /// (rank-2 <c>[seq, vocab]</c>) WITHOUT the classification head. This is what the generative
-    /// task heads (<see cref="DetectLayout(Tensor{T}, double)"/> per-region logits and
-    /// <see cref="AnswerQuestion(Tensor{T}, string, int, double)"/> per-token logits) index by
-    /// <c>output[i, c]</c> / <c>output[t, v]</c>. The classification head is NOT applied here.
-    /// </summary>
+        return normalized;
+    }
+
+    /// <summary>
+    /// Applies UDOP's industry-standard postprocessing: pass-through (unified outputs are already final).
+    /// </summary>
+    protected override Tensor<T> ApplyDefaultPostprocessing(Tensor<T> modelOutput) => modelOutput;
+
+    #endregion
+
+    #region Serialization
+
+    /// <inheritdoc/>
+    public override ModelMetadata<T> GetModelMetadata()
+    {
+        return new ModelMetadata<T>
+        {
+            Name = "UDOP",
+            Description = "UDOP for unified document processing (CVPR 2023)",
+            FeatureCount = _hiddenDim,
+            Complexity = _numEncoderLayers + _numDecoderLayers,
+            AdditionalInfo = new Dictionary<string, object>
+            {
+                { "hidden_dim", _hiddenDim },
+                { "num_encoder_layers", _numEncoderLayers },
+                { "num_decoder_layers", _numDecoderLayers },
+                { "num_heads", _numHeads },
+                { "image_size", ImageSize },
+                { "vocab_size", _vocabSize },
+                { "num_classes", _numClasses },
+                { "use_native_mode", _useNativeMode }
+            },
+            ModelData = SafeSerialize()
+        };
+    }
+
+    /// <inheritdoc/>
+
+
+    /// <inheritdoc/>
+
+
+    #endregion
+
+    #region NeuralNetworkBase Implementation
+
+    /// <summary>
+    /// Raw encoder-decoder forward pass: runs encoder layers, then feeds encoder output as
+    /// cross-attention context to decoder layers, and returns the generative sequence tensor
+    /// (rank-2 <c>[seq, vocab]</c>) WITHOUT the classification head. This is what the generative
+    /// task heads (<see cref="DetectLayout(Tensor{T}, double)"/> per-region logits and
+    /// <see cref="AnswerQuestion(Tensor{T}, string, int, double)"/> per-token logits) index by
+    /// <c>output[i, c]</c> / <c>output[t, v]</c>. The classification head is NOT applied here.
+    /// </summary>
     private Tensor<T> ForwardEncoderDecoder(Tensor<T> input)
     {
         if (_hasBuiltInClassHead && _decoderLayers.Count > 0)
@@ -885,161 +822,162 @@ private Tensor<T> ForwardEncoderDecoder(Tensor<T> input)
         }
 
         Tensor<T> output = input;
-        Tensor<T>? encoderOutput = null;
-        bool hasPassedConvLayer = false;
-        bool hasReshapedToSequence = false;
-
-        foreach (var layer in Layers)
-        {
-            // The classification head is applied AFTER sequence pooling, not inline in the walk.
-            if (ReferenceEquals(layer, _classHead)) continue;
-
-            if (layer is ConvolutionalLayer<T> or BatchNormalizationLayer<T>
-                     or PoolingLayer<T> or MaxPoolingLayer<T> or AveragePoolingLayer<T>)
-            {
-                hasPassedConvLayer = true;
-            }
-
-            // Auto-reshape spatial to sequence when transitioning from CNN to non-spatial layers
-            bool isNonSpatialLayer = layer is not (ConvolutionalLayer<T> or BatchNormalizationLayer<T>
-                or PoolingLayer<T> or MaxPoolingLayer<T> or AveragePoolingLayer<T>);
-            if (!hasReshapedToSequence && hasPassedConvLayer && output.Shape.Length >= 3 && isNonSpatialLayer)
-            {
-                int channels = output.Shape.Length == 4 ? output.Shape[1] : output.Shape[0];
-                int spatialH = output.Shape.Length == 4 ? output.Shape[2] : output.Shape[1];
-                int spatialW = output.Shape.Length == 4 ? output.Shape[3] : output.Shape[2];
-                int numPatches = spatialH * spatialW;
-                // Tape-aware reshape: the old `new Tensor<T>(output.Data.ToArray(), ...)` copied the raw
-                // buffer, which SEVERS the gradient tape — the CNN stem never received gradients, so the
-                // encoder/decoder trained on a detached input and the training invariants (loss decrease,
-                // param change, gradient flow) failed. Engine.Reshape keeps the op on the tape.
-                output = Engine.Reshape(output, [numPatches, channels]);
-                hasReshapedToSequence = true;
-            }
-
-            if (layer is TransformerDecoderLayer<T> decoderLayer)
-            {
-                // Save encoder output before first decoder layer
-                encoderOutput ??= output;
-                output = decoderLayer.Forward(output, encoderOutput);
-            }
-            else
-            {
-                output = layer.Forward(output);
-            }
-        }
-
-        return output;
-    }
-
-    /// <summary>
-    /// Default (classification) forward pass used by <see cref="PredictCore"/> and
-    /// <see cref="ClassifyDocument(Tensor{T}, int)"/>: runs the encoder-decoder, then applies the
-    /// classification head — mean-pool the generated sequence to one document vector and project to
-    /// numClasses. Produces a fixed rank-1 <c>[numClasses]</c> logit vector (tape-aware) that matches
-    /// the classification target's rank so the loss aligns; the raw <c>[seq, vocab]</c> generative
-    /// tensor could not be aligned to a class target. The generative task heads (DetectLayout /
-    /// AnswerQuestion) deliberately bypass this and call <see cref="ForwardEncoderDecoder"/> directly,
-    /// so the per-region / per-token rank-2 output survives and their two-dimensional indexing works.
-    /// </summary>
-    protected override Tensor<T> Forward(Tensor<T> input)
-    {
-        Tensor<T> output = ForwardEncoderDecoder(input);
-
-        if (_classHead is not null)
-        {
-            if (output.Shape.Length >= 2)
-            {
-                int lastAxis = output.Shape.Length - 1;
-                var poolAxes = new int[lastAxis];
-                for (int a = 0; a < lastAxis; a++) poolAxes[a] = a;
-                output = Engine.ReduceMean(output, poolAxes, keepDims: false); // → [D]
-            }
-            output = Engine.Reshape(output, [1, output.Length]);   // [1, D]
-            output = _classHead.Forward(output);                   // [1, numClasses]
-            output = Engine.Reshape(output, [_numClasses]);        // [numClasses]
-        }
-
-        return output;
-    }
-
-    /// <inheritdoc/>
-    public override Tensor<T> ForwardForTraining(Tensor<T> input)
-    {
-        // UDOP is an encoder-decoder graph with cross-attention, followed by sequence
-        // pooling and a classification head. The base implementation treats Layers as a
-        // flat sequential chain, which bypasses that topology and applies the class head
-        // before pooling. Run the same tape-aware graph used by inference instead.
-        EnsureLayerRandomSeedsWired();
-        return Forward(input);
-    }
-
-    /// <inheritdoc/>
-    protected override Tensor<T> PredictCore(Tensor<T> input)
-    {
-        var preprocessed = PreprocessDocument(input);
-        return _useNativeMode ? Forward(preprocessed) : RunOnnxInference(preprocessed);
-    }
-
-    /// <inheritdoc/>
-    public override void Train(Tensor<T> input, Tensor<T> expectedOutput)
-    {
-        if (!_useNativeMode)
-            throw new NotSupportedException("Training not supported in ONNX mode.");
-
-        SetTrainingMode(true);
-        try
-        {
-            // TrainWithTape runs the full forward + backward + optimizer step over the tape. The previous
-            // code then ALSO called UpdateParameters(CollectGradients()) — a SECOND, manual gradient-descent
-            // step (lr=1e-4) on top of the tape's optimizer step, double-updating the weights (and reading
-            // per-layer gradients that TrainWithTape had already consumed). One tape step is the correct,
-            // complete update. Pass the constructor-supplied gradient-based optimizer directly so a
-            // user-configured optimizer actually drives the update.
-            // PredictCore evaluates ImageNet-normalized pages, so train on that same representation rather
-            // than fitting raw pixels and measuring the objective on a different input distribution.
-            TrainWithTape(
-                PreprocessDocument(input),
-                expectedOutput,
-                _optimizer);
-        }
-        finally
-        {
-            SetTrainingMode(false);
-        }
-    }
-
-    // UpdateParameters applied a GRADIENT STEP, but its one-argument form is the value setter and every caller passes values -- the override corrupted the model. Removed under AIDN082.

-
-    /// <summary>
-    /// Parameters cannot be written while the model is backed by a loaded ONNX graph: the weights
-    /// belong to that graph, not to this instance.
-    /// </summary>
-    /// <remarks>
-    /// Replaces a hand-written throw that used to sit inside UpdateParameters. The base checks this
-    /// on every mutating entry point rather than the one member the throw happened to guard, and
-    /// reading -- ParameterCount and GetParameters -- stays available either way.
-    /// </remarks>
+        Tensor<T>? encoderOutput = null;
+        bool hasPassedConvLayer = false;
+        bool hasReshapedToSequence = false;
+
+        foreach (var layer in Layers)
+        {
+            // The classification head is applied AFTER sequence pooling, not inline in the walk.
+            if (ReferenceEquals(layer, _classHead)) continue;
+
+            if (layer is ConvolutionalLayer<T> or BatchNormalizationLayer<T>
+                     or PoolingLayer<T> or MaxPoolingLayer<T> or AveragePoolingLayer<T>)
+            {
+                hasPassedConvLayer = true;
+            }
+
+            // Auto-reshape spatial to sequence when transitioning from CNN to non-spatial layers
+            bool isNonSpatialLayer = layer is not (ConvolutionalLayer<T> or BatchNormalizationLayer<T>
+                or PoolingLayer<T> or MaxPoolingLayer<T> or AveragePoolingLayer<T>);
+            if (!hasReshapedToSequence && hasPassedConvLayer && output.Shape.Length >= 3 && isNonSpatialLayer)
+            {
+                int channels = output.Shape.Length == 4 ? output.Shape[1] : output.Shape[0];
+                int spatialH = output.Shape.Length == 4 ? output.Shape[2] : output.Shape[1];
+                int spatialW = output.Shape.Length == 4 ? output.Shape[3] : output.Shape[2];
+                int numPatches = spatialH * spatialW;
+                // Tape-aware reshape: the old `new Tensor<T>(output.Data.ToArray(), ...)` copied the raw
+                // buffer, which SEVERS the gradient tape — the CNN stem never received gradients, so the
+                // encoder/decoder trained on a detached input and the training invariants (loss decrease,
+                // param change, gradient flow) failed. Engine.Reshape keeps the op on the tape.
+                output = Engine.Reshape(output, [numPatches, channels]);
+                hasReshapedToSequence = true;
+            }
+
+            if (layer is TransformerDecoderLayer<T> decoderLayer)
+            {
+                // Save encoder output before first decoder layer
+                encoderOutput ??= output;
+                output = decoderLayer.Forward(output, encoderOutput);
+            }
+            else
+            {
+                output = layer.Forward(output);
+            }
+        }
+
+        return output;
+    }
+
+    /// <summary>
+    /// Default (classification) forward pass used by <see cref="PredictCore"/> and
+    /// <see cref="ClassifyDocument(Tensor{T}, int)"/>: runs the encoder-decoder, then applies the
+    /// classification head — mean-pool the generated sequence to one document vector and project to
+    /// numClasses. Produces a fixed rank-1 <c>[numClasses]</c> logit vector (tape-aware) that matches
+    /// the classification target's rank so the loss aligns; the raw <c>[seq, vocab]</c> generative
+    /// tensor could not be aligned to a class target. The generative task heads (DetectLayout /
+    /// AnswerQuestion) deliberately bypass this and call <see cref="ForwardEncoderDecoder"/> directly,
+    /// so the per-region / per-token rank-2 output survives and their two-dimensional indexing works.
+    /// </summary>
+    protected override Tensor<T> Forward(Tensor<T> input)
+    {
+        Tensor<T> output = ForwardEncoderDecoder(input);
+
+        if (_classHead is not null)
+        {
+            if (output.Shape.Length >= 2)
+            {
+                int lastAxis = output.Shape.Length - 1;
+                var poolAxes = new int[lastAxis];
+                for (int a = 0; a < lastAxis; a++) poolAxes[a] = a;
+                output = Engine.ReduceMean(output, poolAxes, keepDims: false); // → [D]
+            }
+            output = Engine.Reshape(output, [1, output.Length]);   // [1, D]
+            output = _classHead.Forward(output);                   // [1, numClasses]
+            output = Engine.Reshape(output, [_numClasses]);        // [numClasses]
+        }
+
+        return output;
+    }
+
+    /// <inheritdoc/>
+    public override Tensor<T> ForwardForTraining(Tensor<T> input)
+    {
+        // UDOP is an encoder-decoder graph with cross-attention, followed by sequence
+        // pooling and a classification head. The base implementation treats Layers as a
+        // flat sequential chain, which bypasses that topology and applies the class head
+        // before pooling. Run the same tape-aware graph used by inference instead.
+        EnsureLayerRandomSeedsWired();
+        return Forward(input);
+    }
+
+    /// <inheritdoc/>
+    protected override Tensor<T> PredictCore(Tensor<T> input)
+    {
+        var preprocessed = PreprocessDocument(input);
+        return _useNativeMode ? Forward(preprocessed) : RunOnnxInference(preprocessed);
+    }
+
+    /// <inheritdoc/>
+    public override void Train(Tensor<T> input, Tensor<T> expectedOutput)
+    {
+        if (!_useNativeMode)
+            throw new NotSupportedException("Training not supported in ONNX mode.");
+
+        SetTrainingMode(true);
+        try
+        {
+            // TrainWithTape runs the full forward + backward + optimizer step over the tape. The previous
+            // code then ALSO called UpdateParameters(CollectGradients()) — a SECOND, manual gradient-descent
+            // step (lr=1e-4) on top of the tape's optimizer step, double-updating the weights (and reading
+            // per-layer gradients that TrainWithTape had already consumed). One tape step is the correct,
+            // complete update. Pass the constructor-supplied gradient-based optimizer directly so a
+            // user-configured optimizer actually drives the update.
+            // PredictCore evaluates ImageNet-normalized pages, so train on that same representation rather
+            // than fitting raw pixels and measuring the objective on a different input distribution.
+            TrainWithTape(
+                PreprocessDocument(input),
+                expectedOutput,
+                _optimizer);
+        }
+        finally
+        {
+            SetTrainingMode(false);
+        }
+    }
+
+    // UpdateParameters applied a GRADIENT STEP, but its one-argument form is the value setter and every caller passes values -- the override corrupted the model. Removed under AIDN082.
+
+
+    /// <summary>
+    /// Parameters cannot be written while the model is backed by a loaded ONNX graph: the weights
+    /// belong to that graph, not to this instance.
+    /// </summary>
+    /// <remarks>
+    /// Replaces a hand-written throw that used to sit inside UpdateParameters. The base checks this
+    /// on every mutating entry point rather than the one member the throw happened to guard, and
+    /// reading -- ParameterCount and GetParameters -- stays available either way.
+    /// </remarks>
     protected override bool SupportsParameterMutation => _useNativeMode;
-    private Vector<T> CollectGradients()
-    {
-        var grads = new List<T>();
-        foreach (var layer in Layers)
-            grads.AddRange(layer.GetParameterGradients());
-        return new Vector<T>([.. grads]);
-    }
-
-    #endregion
-
-    #region Disposal
-
-    /// <inheritdoc/>
-    protected override void Dispose(bool disposing)
-    {
-        if (disposing)
-            _onnxSession?.Dispose();
-        base.Dispose(disposing);
-    }
-
-    #endregion
-}
+    private Vector<T> CollectGradients()
+    {
+        var grads = new List<T>();
+        foreach (var layer in Layers)
+            grads.AddRange(layer.GetParameterGradients());
+        return new Vector<T>([.. grads]);
+    }
+
+    #endregion
+
+    #region Disposal
+
+    /// <inheritdoc/>
+    protected override void Dispose(bool disposing)
+    {
+        if (disposing)
+            _onnxSession?.Dispose();
+        base.Dispose(disposing);
+    }
+
+    #endregion
+}
diff --git a/src/FederatedLearning/ContinualLearning/DataFreeFCL.cs b/src/FederatedLearning/ContinualLearning/DataFreeFCL.cs
index 80a66199b6..041af00c3d 100644
--- a/src/FederatedLearning/ContinualLearning/DataFreeFCL.cs
+++ b/src/FederatedLearning/ContinualLearning/DataFreeFCL.cs
@@ -37,6 +37,7 @@ public class DataFreeFCL<T> : Infrastructure.FederatedLearningComponentBase<T>,
     private readonly int _syntheticSamplesPerClass;
     private readonly int _generationSteps;
     private readonly object _importanceLock = new();
+    [AiDotNet.Attributes.Scratch]
     private Vector<T>? _accumulatedImportance;
 
     /// <summary>
diff --git a/src/FederatedLearning/ContinualLearning/FedAGCContinualLearning.cs b/src/FederatedLearning/ContinualLearning/FedAGCContinualLearning.cs
index fc407122f9..0318e9bdb2 100644
--- a/src/FederatedLearning/ContinualLearning/FedAGCContinualLearning.cs
+++ b/src/FederatedLearning/ContinualLearning/FedAGCContinualLearning.cs
@@ -31,6 +31,7 @@ namespace AiDotNet.FederatedLearning.ContinualLearning;
 public class FedAGCContinualLearning<T> : Infrastructure.FederatedLearningComponentBase<T>, IFederatedContinualLearningStrategy<T>
 {
     private readonly double _correctionStrength;
+    [AiDotNet.Attributes.Scratch]
     private Vector<T>? _accumulatedImportance;
 
     /// <summary>
diff --git a/src/FederatedLearning/Graph/GraphNodeGenerator.cs b/src/FederatedLearning/Graph/GraphNodeGenerator.cs
index 14e645d323..5ae760db1e 100644
--- a/src/FederatedLearning/Graph/GraphNodeGenerator.cs
+++ b/src/FederatedLearning/Graph/GraphNodeGenerator.cs
@@ -29,7 +29,7 @@ namespace AiDotNet.FederatedLearning.Graph;
 /// <typeparam name="T">The numeric type used for calculations.</typeparam>
 [ComponentType(ComponentType.FederatedAggregator)]
 [PipelineStage(PipelineStage.Training)]
-public class GraphNodeGenerator<T> : FederatedLearningComponentBase<T>
+public partial class GraphNodeGenerator<T> : FederatedLearningComponentBase<T>
 {
     private readonly int _inputDim;
     private readonly int _hiddenDim;
@@ -37,9 +37,13 @@ public class GraphNodeGenerator<T> : FederatedLearningComponentBase<T>
     private readonly double _learningRate;
 
     // Simple two-layer MLP: input -> hidden -> output
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _weightsHidden;
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _biasHidden;
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _weightsOutput;
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _biasOutput;
     private bool _trained;
 
diff --git a/src/FederatedLearning/Vertical/SplitNeuralNetwork.cs b/src/FederatedLearning/Vertical/SplitNeuralNetwork.cs
index e2d04e7291..52066d8d1d 100644
--- a/src/FederatedLearning/Vertical/SplitNeuralNetwork.cs
+++ b/src/FederatedLearning/Vertical/SplitNeuralNetwork.cs
@@ -42,8 +42,11 @@ public class SplitNeuralNetwork<T> : FederatedLearningComponentBase<T>, ISplitMo
     private Tensor<T>? _attentionWeights;
 
     // Cached for backward pass
+    [Scratch]
     private Tensor<T>? _lastTopInput;
+    [Scratch]
     private Tensor<T>? _lastTopHidden;
+    [Scratch]
     private IReadOnlyList<Tensor<T>>? _lastPartyEmbeddings;
 
     /// <inheritdoc/>
diff --git a/src/FederatedLearning/Vertical/VerticalPartyClient.cs b/src/FederatedLearning/Vertical/VerticalPartyClient.cs
index 41287a84a8..5cbc1cf3b0 100644
--- a/src/FederatedLearning/Vertical/VerticalPartyClient.cs
+++ b/src/FederatedLearning/Vertical/VerticalPartyClient.cs
@@ -37,7 +37,9 @@ public class VerticalPartyClient<T> : FederatedLearningComponentBase<T>, IVertic
     private Tensor<T> _biasEmbed = new Tensor<T>(new[] { 0 });
 
     // Cached for backward pass
+    [Scratch]
     private Tensor<T>? _lastInput;
+    [Scratch]
     private Tensor<T>? _lastHidden;
 
     /// <inheritdoc/>
diff --git a/src/FederatedLearning/Vertical/VerticalPartyLabelHolder.cs b/src/FederatedLearning/Vertical/VerticalPartyLabelHolder.cs
index 60c65a9f05..2e0af60320 100644
--- a/src/FederatedLearning/Vertical/VerticalPartyLabelHolder.cs
+++ b/src/FederatedLearning/Vertical/VerticalPartyLabelHolder.cs
@@ -41,7 +41,9 @@ public class VerticalPartyLabelHolder<T> : FederatedLearningComponentBase<T>, IV
     private Tensor<T> _biasEmbed = new Tensor<T>(new[] { 0 });
 
     // Cached for backward pass
+    [Scratch]
     private Tensor<T>? _lastInput;
+    [Scratch]
     private Tensor<T>? _lastHidden;
 
     /// <inheritdoc/>
diff --git a/src/Finance/AutoML/FinancialAutoML.cs b/src/Finance/AutoML/FinancialAutoML.cs
index 5718d4770a..97c156734e 100644
--- a/src/Finance/AutoML/FinancialAutoML.cs
+++ b/src/Finance/AutoML/FinancialAutoML.cs
@@ -44,7 +44,7 @@ namespace AiDotNet.Finance.AutoML;
     "https://arxiv.org/abs/1908.00709",
     Year = 2021,
     Authors = "Xin He, Kaiyong Zhao, Xiaowen Chu")]
-public class FinancialAutoML<T> : SupervisedAutoMLModelBase<T, Tensor<T>, Tensor<T>>
+public partial class FinancialAutoML<T> : SupervisedAutoMLModelBase<T, Tensor<T>, Tensor<T>>
 {
     private readonly FinancialAutoMLOptions<T> _options;
     private readonly FinancialSearchSpace _financeSearchSpace;
@@ -252,19 +252,6 @@ protected override Dictionary<string, ParameterRange> GetDefaultSearchSpace(Type
         return _financeSearchSpace.GetSearchSpace(modelType);
     }
 
-    /// <summary>
-    /// Creates a new instance for cloning.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> AutoML uses this to make a copy of itself with the same options.
-    /// </para>
-    /// </remarks>
-    protected override AutoMLModelBase<T, Tensor<T>, Tensor<T>> CreateInstanceForCopy()
-    {
-        return new FinancialAutoML<T>(_options, Random);
-    }
-
     /// <summary>
     /// Applies the AutoML budget to time and trial limits.
     /// </summary>
diff --git a/src/Finance/Base/CrossSectionalGraphModelBase.cs b/src/Finance/Base/CrossSectionalGraphModelBase.cs
index bed930c750..76ed6a586b 100644
--- a/src/Finance/Base/CrossSectionalGraphModelBase.cs
+++ b/src/Finance/Base/CrossSectionalGraphModelBase.cs
@@ -48,7 +48,7 @@ namespace AiDotNet.Finance.Base;
     Direction = TensorLayoutDirection.Input, BatchOptional = true)]
 [TensorLayout(TensorAxis.Batch, TensorAxis.Length, TensorAxis.Features,
     Direction = TensorLayoutDirection.Output, BatchOptional = true)]
-public abstract class CrossSectionalGraphModelBase<T> : FinancialModelBase<T>
+public abstract partial class CrossSectionalGraphModelBase<T> : FinancialModelBase<T>
 {
     /// <summary>
     /// Initializes the shared cross-sectional state.
diff --git a/src/Finance/Base/FinancialModelBase.cs b/src/Finance/Base/FinancialModelBase.cs
index 601e5ab06e..d9fee9c6d8 100644
--- a/src/Finance/Base/FinancialModelBase.cs
+++ b/src/Finance/Base/FinancialModelBase.cs
@@ -1,4 +1,4 @@
-using System.IO;
+using System.IO;
 using AiDotNet.Attributes;
 using AiDotNet.Autodiff;
 using AiDotNet.Finance.Interfaces;
@@ -722,18 +722,7 @@ public override ModelMetadata<T> GetModelMetadata()
     /// before allowing derived classes to store their own settings.
     /// </para>
     /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        if (!UseNativeMode)
-            throw new InvalidOperationException("Serialization is not supported in ONNX mode.");
 
-        writer.Write(SequenceLength);
-        writer.Write(PredictionHorizon);
-        writer.Write(NumFeatures);
-
-        // Derived classes add their own data via override
-        SerializeModelSpecificData(writer);
-    }
 
     /// <inheritdoc/>
     /// <remarks>
@@ -742,19 +731,7 @@ protected override void SerializeNetworkSpecificData(BinaryWriter writer)
     /// then lets derived classes restore their extra settings.
     /// </para>
     /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        if (!UseNativeMode)
-            throw new InvalidOperationException("Deserialization is not supported in ONNX mode.");
 
-        // Read configuration
-        _baseSequenceLength = reader.ReadInt32();
-        _basePredictionHorizon = reader.ReadInt32();
-        _baseNumFeatures = reader.ReadInt32();
-
-        // Derived classes read their own data via override
-        DeserializeModelSpecificData(reader);
-    }
 
     /// <summary>
     /// Serializes model-specific data. Override in derived classes.
diff --git a/src/Finance/Base/PortfolioOptimizerBase.cs b/src/Finance/Base/PortfolioOptimizerBase.cs
index 3ce62c821b..291be60e7b 100644
--- a/src/Finance/Base/PortfolioOptimizerBase.cs
+++ b/src/Finance/Base/PortfolioOptimizerBase.cs
@@ -1,4 +1,4 @@
-using AiDotNet.Attributes;
+using AiDotNet.Attributes;
 using AiDotNet.Enums;
 using AiDotNet.Finance.Interfaces;
 using AiDotNet.Models;
@@ -29,7 +29,7 @@ namespace AiDotNet.Finance.Base;
     Direction = TensorLayoutDirection.Input, BatchOptional = true)]
 [TensorLayout(TensorAxis.Batch, TensorAxis.Features,
     Direction = TensorLayoutDirection.Output, BatchOptional = true)]
-public abstract class PortfolioOptimizerBase<T> : FinancialModelBase<T>, IPortfolioOptimizer<T>
+public abstract partial class PortfolioOptimizerBase<T> : FinancialModelBase<T>, IPortfolioOptimizer<T>
 {
     /// <summary>
     /// The number of assets in the portfolio universe.
@@ -290,10 +290,7 @@ protected override void ValidateInputShape(Tensor<T> input)
     /// so the model configuration can be restored later.
     /// </para>
     /// </remarks>
-    protected override void SerializeModelSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_numAssets);
-    }
+
 
     /// <summary>
     /// Deserializes portfolio-specific model data.
@@ -304,17 +301,7 @@ protected override void SerializeModelSpecificData(BinaryWriter writer)
     /// <b>For Beginners:</b> Loads portfolio settings from a file.
     /// </para>
     /// </remarks>
-    protected override void DeserializeModelSpecificData(BinaryReader reader)
-    {
-        _numAssets = reader.ReadInt32();
 
-        // Validate deserialized value matches constructor invariant
-        if (_numAssets <= 0)
-        {
-            throw new InvalidOperationException(
-                $"Deserialized numAssets ({_numAssets}) is invalid. Must be greater than 0.");
-        }
-    }
 
     /// <summary>
     /// Core training logic for the portfolio optimizer.
diff --git a/src/Finance/Base/RiskModelBase.cs b/src/Finance/Base/RiskModelBase.cs
index 95d29c2626..76613a1213 100644
--- a/src/Finance/Base/RiskModelBase.cs
+++ b/src/Finance/Base/RiskModelBase.cs
@@ -1,4 +1,4 @@
-using AiDotNet.Attributes;
+using AiDotNet.Attributes;
 using AiDotNet.Enums;
 using AiDotNet.Finance.Interfaces;
 using AiDotNet.Helpers;
@@ -30,7 +30,7 @@ namespace AiDotNet.Finance.Base;
     Direction = TensorLayoutDirection.Input, BatchOptional = true)]
 [TensorLayout(TensorAxis.Batch, TensorAxis.Features,
     Direction = TensorLayoutDirection.Output, BatchOptional = true)]
-public abstract class RiskModelBase<T> : FinancialModelBase<T>, IRiskModel<T>
+public abstract partial class RiskModelBase<T> : FinancialModelBase<T>, IRiskModel<T>
 {
     /// <summary>
     /// The confidence level used for risk calculations (e.g., 0.95 or 0.99).
@@ -336,11 +336,7 @@ protected override void ValidateInputShape(Tensor<T> input)
     /// so the model remembers them when loaded later.
     /// </para>
     /// </remarks>
-    protected override void SerializeModelSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_confidenceLevel);
-        writer.Write(_timeHorizon);
-    }
+
 
     /// <summary>
     /// Deserializes risk-specific model data.
@@ -351,23 +347,6 @@ protected override void SerializeModelSpecificData(BinaryWriter writer)
     /// <b>For Beginners:</b> Loads the saved risk settings from a file.
     /// </para>
     /// </remarks>
-    protected override void DeserializeModelSpecificData(BinaryReader reader)
-    {
-        _confidenceLevel = reader.ReadDouble();
-        _timeHorizon = reader.ReadInt32();
 
-        // Re-validate invariants after deserialize to prevent corrupt state
-        // Use same exclusive bounds as constructor: confidenceLevel must be in (0, 1)
-        if (_confidenceLevel <= 0 || _confidenceLevel >= 1)
-        {
-            throw new InvalidOperationException(
-                $"Deserialized confidenceLevel ({_confidenceLevel}) is invalid. Must be between 0 and 1 (exclusive).");
-        }
-        if (_timeHorizon < 1)
-        {
-            throw new InvalidOperationException(
-                $"Deserialized timeHorizon ({_timeHorizon}) is invalid. Must be at least 1.");
-        }
-    }
 
 }
diff --git a/src/Finance/Forecasting/Foundation/CCDM.cs b/src/Finance/Forecasting/Foundation/CCDM.cs
index 679def9f4c..65a19e0f77 100644
--- a/src/Finance/Forecasting/Foundation/CCDM.cs
+++ b/src/Finance/Forecasting/Foundation/CCDM.cs
@@ -283,10 +283,8 @@ public override Tensor<T> ForwardForTraining(Tensor<T> input)
         ModelData = _useNativeMode ? this.Serialize() : Array.Empty<byte>()
     };
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() => new CCDM<T>(Architecture, new CCDMOptions<T> { ContextLength = _contextLength, ForecastHorizon = _forecastHorizon, HiddenDimension = _hiddenDimension, NumLayers = _numLayers, NumHeads = _numHeads, DiffusionSteps = _diffusionSteps, DropoutRate = _dropout, BetaStart = _betaStart, BetaEnd = _betaEnd, SigmaMin = _sigmaMin, SigmaMax = _sigmaMax });
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer) { writer.Write(_contextLength); writer.Write(_forecastHorizon); writer.Write(_hiddenDimension); writer.Write(_numLayers); writer.Write(_numHeads); writer.Write(_diffusionSteps); writer.Write(_dropout); writer.Write(_betaStart); writer.Write(_betaEnd); writer.Write(_sigmaMin); writer.Write(_sigmaMax); }
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader) { _contextLength = reader.ReadInt32(); _forecastHorizon = reader.ReadInt32(); _hiddenDimension = reader.ReadInt32(); _numLayers = reader.ReadInt32(); _numHeads = reader.ReadInt32(); _diffusionSteps = reader.ReadInt32(); _dropout = reader.ReadDouble(); _betaStart = reader.ReadDouble(); _betaEnd = reader.ReadDouble(); _sigmaMin = reader.ReadDouble(); _sigmaMax = reader.ReadDouble(); ComputeNoiseSchedule(); }
+
 
     #endregion
 
diff --git a/src/Finance/Forecasting/Foundation/CSDI.cs b/src/Finance/Forecasting/Foundation/CSDI.cs
index 52ad2d5e9f..ff50e3c536 100644
--- a/src/Finance/Forecasting/Foundation/CSDI.cs
+++ b/src/Finance/Forecasting/Foundation/CSDI.cs
@@ -611,34 +611,9 @@ private Tensor<T> DenoiserForwardFromSlots(IReadOnlyList<Tensor<T>> slots)
         ModelData = _useNativeMode ? this.Serialize() : Array.Empty<byte>()
     };
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() =>
-        new CSDI<T>(Architecture, new CSDIOptions<T>
-        {
-            SequenceLength = _sequenceLength, NumFeatures = _numFeatures,
-            HiddenDimension = _hiddenDimension, NumResidualLayers = _numResidualLayers,
-            NumDiffusionSteps = _numDiffusionSteps, NumHeads = _numHeads,
-            TimeEmbeddingDim = _timeEmbeddingDim, DropoutRate = _dropout,
-            BetaStart = _betaStart, BetaEnd = _betaEnd
-        });
-
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_sequenceLength); writer.Write(_numFeatures);
-        writer.Write(_hiddenDimension); writer.Write(_numResidualLayers);
-        writer.Write(_numDiffusionSteps); writer.Write(_numHeads);
-        writer.Write(_timeEmbeddingDim); writer.Write(_dropout);
-        writer.Write(_betaStart); writer.Write(_betaEnd);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _sequenceLength = reader.ReadInt32(); _numFeatures = reader.ReadInt32();
-        _hiddenDimension = reader.ReadInt32(); _numResidualLayers = reader.ReadInt32();
-        _numDiffusionSteps = reader.ReadInt32(); _numHeads = reader.ReadInt32();
-        _timeEmbeddingDim = reader.ReadInt32(); _dropout = reader.ReadDouble();
-        _betaStart = reader.ReadDouble(); _betaEnd = reader.ReadDouble();
-        ComputeNoiseSchedule();
-    }
+
+
 
     #endregion
 
diff --git a/src/Finance/Forecasting/Foundation/Chronos.cs b/src/Finance/Forecasting/Foundation/Chronos.cs
index 7cf9e31e0e..1eacb10f12 100644
--- a/src/Finance/Forecasting/Foundation/Chronos.cs
+++ b/src/Finance/Forecasting/Foundation/Chronos.cs
@@ -619,34 +619,6 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    /// <summary>
-    /// Creates a new instance of this model with the same configuration.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Creates a fresh copy of the Chronos architecture.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var options = new ChronosFinanceOptions<T>
-        {
-            ContextLength = _contextLength,
-            ForecastHorizon = _forecastHorizon,
-            NumTokens = _numTokens,
-            HiddenDimension = _hiddenDimension,
-            NumLayers = _numLayers,
-            NumHeads = _numHeads,
-            IntermediateSize = _intermediateSize,
-            NumSamples = _numSamples,
-            DropoutRate = _dropout,
-            Temperature = _temperature,
-            ModelSize = _modelSize
-        };
-
-        return new Chronos<T>(Architecture, options);
-    }
-
     /// <summary>
     /// Writes Chronos-specific configuration during serialization.
     /// </summary>
@@ -655,25 +627,7 @@ protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
     /// <b>For Beginners:</b> Saves all the configuration needed to reconstruct this model.
     /// </para>
     /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_contextLength);
-        writer.Write(_forecastHorizon);
-        writer.Write(_numTokens);
-        writer.Write(_hiddenDimension);
-        writer.Write(_numLayers);
-        writer.Write(_numHeads);
-        writer.Write(_intermediateSize);
-        writer.Write(_numSamples);
-        writer.Write(_dropout);
-        writer.Write(_temperature);
-        writer.Write((int)_modelSize);
-
-        // Serialize tokenization scaling state
-        writer.Write(_hasTokenScale);
-        writer.Write(NumOps.ToDouble(_lastTokenMin));
-        writer.Write(NumOps.ToDouble(_lastTokenRange));
-    }
+
 
     /// <summary>
     /// Reads Chronos-specific configuration during deserialization.
@@ -683,30 +637,7 @@ protected override void SerializeNetworkSpecificData(BinaryWriter writer)
     /// <b>For Beginners:</b> Loads the configuration that was saved during serialization.
     /// </para>
     /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _contextLength = reader.ReadInt32();
-        _forecastHorizon = reader.ReadInt32();
-        _numTokens = reader.ReadInt32();
-        _hiddenDimension = reader.ReadInt32();
-        _numLayers = reader.ReadInt32();
-        _numHeads = reader.ReadInt32();
-        _intermediateSize = reader.ReadInt32();
-        _numSamples = reader.ReadInt32();
-        _dropout = reader.ReadDouble();
-        _temperature = reader.ReadDouble();
-        _modelSize = (FoundationModelSize)reader.ReadInt32();
-
-        // Deserialize tokenization scaling state
-        _hasTokenScale = reader.ReadBoolean();
-        _lastTokenMin = NumOps.FromDouble(reader.ReadDouble());
-        _lastTokenRange = NumOps.FromDouble(reader.ReadDouble());
-
-        // Base deserialization replaces the Layers collection with newly deserialized
-        // layer instances. Refresh Chronos' typed layer references so inference uses
-        // those restored weights rather than the constructor's discarded random layers.
-        ExtractLayerReferences();
-    }
+
 
     #endregion
 
diff --git a/src/Finance/Forecasting/Foundation/ChronosBolt.cs b/src/Finance/Forecasting/Foundation/ChronosBolt.cs
index 0b9f009944..c898ba0498 100644
--- a/src/Finance/Forecasting/Foundation/ChronosBolt.cs
+++ b/src/Finance/Forecasting/Foundation/ChronosBolt.cs
@@ -449,60 +449,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var opts = new ChronosBoltOptions<T>
-        {
-            ContextLength = _contextLength,
-            ForecastHorizon = _forecastHorizon,
-            PatchLength = _patchLength,
-            EncoderHiddenDim = _encoderHiddenDim,
-            DecoderHiddenDim = _decoderHiddenDim,
-            NumEncoderLayers = _numEncoderLayers,
-            NumDecoderLayers = _numDecoderLayers,
-            NumHeads = _numHeads,
-            DropoutRate = _dropout,
-            ModelSize = _modelSize,
-            NumQuantiles = _numQuantiles
-        };
 
-        if (!_useNativeMode && OnnxModelPath is not null)
-            return new ChronosBolt<T>(Architecture, OnnxModelPath, opts);
-
-        return new ChronosBolt<T>(Architecture, opts);
-    }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_contextLength);
-        writer.Write(_forecastHorizon);
-        writer.Write(_patchLength);
-        writer.Write(_encoderHiddenDim);
-        writer.Write(_decoderHiddenDim);
-        writer.Write(_numEncoderLayers);
-        writer.Write(_numDecoderLayers);
-        writer.Write(_numHeads);
-        writer.Write(_dropout);
-        writer.Write((int)_modelSize);
-        writer.Write(_numQuantiles);
-    }
 
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _contextLength = reader.ReadInt32();
-        _forecastHorizon = reader.ReadInt32();
-        _patchLength = reader.ReadInt32();
-        _encoderHiddenDim = reader.ReadInt32();
-        _decoderHiddenDim = reader.ReadInt32();
-        _numEncoderLayers = reader.ReadInt32();
-        _numDecoderLayers = reader.ReadInt32();
-        _numHeads = reader.ReadInt32();
-        _dropout = reader.ReadDouble();
-        _modelSize = (FoundationModelSize)reader.ReadInt32();
-        _numQuantiles = reader.ReadInt32();
-    }
 
     #endregion
 
diff --git a/src/Finance/Forecasting/Foundation/FlowState.cs b/src/Finance/Forecasting/Foundation/FlowState.cs
index 73a6e22c94..f35752827a 100644
--- a/src/Finance/Forecasting/Foundation/FlowState.cs
+++ b/src/Finance/Forecasting/Foundation/FlowState.cs
@@ -286,57 +286,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new FlowState<T>(Architecture, new FlowStateOptions<T>
-        {
-            ContextLength = _contextLength,
-            ForecastHorizon = _forecastHorizon,
-            StateDimension = _stateDimension,
-            HiddenDimension = _hiddenDimension,
-            NumLayers = _numLayers,
-            DropoutRate = _dropout,
-            SSMRank = _ssmRank,
-            UseDiscretization = _useDiscretization,
-            ModelSize = _modelSize
-        });
-    }
 
-    /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_contextLength);
-        writer.Write(_forecastHorizon);
-        writer.Write(_stateDimension);
-        writer.Write(_hiddenDimension);
-        writer.Write(_numLayers);
-        writer.Write(_dropout);
-        writer.Write(_ssmRank);
-        writer.Write(_useDiscretization);
-        writer.Write((int)_modelSize);
-    }
 
     /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _contextLength = reader.ReadInt32();
-        _forecastHorizon = reader.ReadInt32();
-        _stateDimension = reader.ReadInt32();
-        _hiddenDimension = reader.ReadInt32();
-        _numLayers = reader.ReadInt32();
-        _dropout = reader.ReadDouble();
-        _ssmRank = reader.ReadInt32();
-        _useDiscretization = reader.ReadBoolean();
-        _modelSize = (FoundationModelSize)reader.ReadInt32();
-
-        // The base deserializer has already recreated every layer in Layers with
-        // the copied weights before reaching this point. Re-point the cached
-        // _inputProjection / _ssmLayers / _outputProjection references at those
-        // freshly deserialized layer objects; otherwise they keep pointing at the
-        // stale random-initialized layers created by CreateNewInstance, and the
-        // clone's forward diverges from the original at the very first layer.
-        ExtractLayerReferences();
-    }
+
 
     #endregion
 
diff --git a/src/Finance/Forecasting/Foundation/GPT4TS.cs b/src/Finance/Forecasting/Foundation/GPT4TS.cs
index 237ad78b65..1a085adc83 100644
--- a/src/Finance/Forecasting/Foundation/GPT4TS.cs
+++ b/src/Finance/Forecasting/Foundation/GPT4TS.cs
@@ -61,7 +61,7 @@ namespace AiDotNet.Finance.Forecasting.Foundation;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("One Fits All: Power General Time Series Analysis by Pretrained LM", "https://arxiv.org/abs/2302.11939", Year = 2023, Authors = "Tian Zhou, Peisong Niu, Xue Wang, Liang Sun, Rong Jin")]
-public class GPT4TS<T> : TimeSeriesFoundationModelBase<T>
+public partial class GPT4TS<T> : TimeSeriesFoundationModelBase<T>
 {
     #region Fields
 
@@ -288,52 +288,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new GPT4TS<T>(Architecture, new GPT4TSOptions<T>
-        {
-            ContextLength = _contextLength,
-            ForecastHorizon = _forecastHorizon,
-            PatchLength = _patchLength,
-            HiddenDimension = _hiddenDimension,
-            NumLayers = _numLayers,
-            NumHeads = _numHeads,
-            DropoutRate = _dropout,
-            ModelSize = _modelSize,
-            Task = _task,
-            FreezeBackbone = _freezeBackbone
-        });
-    }
 
-    /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_contextLength);
-        writer.Write(_forecastHorizon);
-        writer.Write(_patchLength);
-        writer.Write(_hiddenDimension);
-        writer.Write(_numLayers);
-        writer.Write(_numHeads);
-        writer.Write(_dropout);
-        writer.Write((int)_modelSize);
-        writer.Write((int)_task);
-        writer.Write(_freezeBackbone);
-    }
 
     /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _contextLength = reader.ReadInt32();
-        _forecastHorizon = reader.ReadInt32();
-        _patchLength = reader.ReadInt32();
-        _hiddenDimension = reader.ReadInt32();
-        _numLayers = reader.ReadInt32();
-        _numHeads = reader.ReadInt32();
-        _dropout = reader.ReadDouble();
-        _modelSize = (FoundationModelSize)reader.ReadInt32();
-        _task = (TimeSeriesFoundationModelTask)reader.ReadInt32();
-        _freezeBackbone = reader.ReadBoolean();
-    }
+
 
     #endregion
 
diff --git a/src/Finance/Forecasting/Foundation/Kairos.cs b/src/Finance/Forecasting/Foundation/Kairos.cs
index 2d2dd873dd..331deea13d 100644
--- a/src/Finance/Forecasting/Foundation/Kairos.cs
+++ b/src/Finance/Forecasting/Foundation/Kairos.cs
@@ -63,7 +63,7 @@ namespace AiDotNet.Finance.Forecasting.Foundation;
 [ModelComplexity(ModelComplexity.High)]
 [ResearchPaper("Kairos: Towards Adaptive and Generalizable Time Series Foundation Models", "https://arxiv.org/abs/2509.25826")]
     [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
-public class Kairos<T> : TimeSeriesFoundationModelBase<T>
+public partial class Kairos<T> : TimeSeriesFoundationModelBase<T>
 {
     #region Fields
 
@@ -281,61 +281,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var opts = new KairosOptions<T>
-        {
-            ContextLength = _contextLength,
-            ForecastHorizon = _forecastHorizon,
-            PatchSizes = (int[])_patchSizes.Clone(),
-            HiddenDimension = _hiddenDimension,
-            NumLayers = _numLayers,
-            NumHeads = _numHeads,
-            IntermediateSize = _intermediateSize,
-            DropoutRate = _dropout,
-            ModelSize = _modelSize
-        };
 
-        if (!_useNativeMode && OnnxModelPath is not null)
-            return new Kairos<T>(Architecture, OnnxModelPath, opts);
-
-        return new Kairos<T>(Architecture, opts);
-    }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_contextLength);
-        writer.Write(_forecastHorizon);
-        writer.Write(_patchSizes.Length);
-        foreach (var ps in _patchSizes)
-            writer.Write(ps);
-        writer.Write(_hiddenDimension);
-        writer.Write(_numLayers);
-        writer.Write(_numHeads);
-        writer.Write(_intermediateSize);
-        writer.Write(_dropout);
-        writer.Write((int)_modelSize);
-    }
 
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _contextLength = reader.ReadInt32();
-        _forecastHorizon = reader.ReadInt32();
-        int numPatchSizes = reader.ReadInt32();
-        if (numPatchSizes < 0 || numPatchSizes > 1000)
-            throw new InvalidOperationException($"Invalid numPatchSizes ({numPatchSizes}) in deserialization.");
-        _patchSizes = new int[numPatchSizes];
-        for (int i = 0; i < numPatchSizes; i++)
-            _patchSizes[i] = reader.ReadInt32();
-        _hiddenDimension = reader.ReadInt32();
-        _numLayers = reader.ReadInt32();
-        _numHeads = reader.ReadInt32();
-        _intermediateSize = reader.ReadInt32();
-        _dropout = reader.ReadDouble();
-        _modelSize = (FoundationModelSize)reader.ReadInt32();
-    }
 
     #endregion
 
diff --git a/src/Finance/Forecasting/Foundation/Kronos.cs b/src/Finance/Forecasting/Foundation/Kronos.cs
index c7c7c92ce4..c573680772 100644
--- a/src/Finance/Forecasting/Foundation/Kronos.cs
+++ b/src/Finance/Forecasting/Foundation/Kronos.cs
@@ -63,7 +63,7 @@ namespace AiDotNet.Finance.Forecasting.Foundation;
 [ModelComplexity(ModelComplexity.High)]
 [ResearchPaper("Kronos: A Foundation Model for the Language of Financial Markets", "https://arxiv.org/abs/2508.02739")]
     [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
-public class Kronos<T> : TimeSeriesFoundationModelBase<T>
+public partial class Kronos<T> : TimeSeriesFoundationModelBase<T>
 {
     #region Fields
 
@@ -277,57 +277,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var opts = new KronosOptions<T>
-        {
-            ContextLength = _contextLength,
-            ForecastHorizon = _forecastHorizon,
-            PatchLength = _patchLength,
-            HiddenDimension = _hiddenDimension,
-            NumLayers = _numLayers,
-            NumHeads = _numHeads,
-            IntermediateSize = _intermediateSize,
-            DropoutRate = _dropout,
-            ModelSize = _modelSize,
-            NumCandlestickFeatures = _numCandlestickFeatures
-        };
 
-        if (!_useNativeMode && OnnxModelPath is not null)
-            return new Kronos<T>(Architecture, OnnxModelPath, opts);
-
-        return new Kronos<T>(Architecture, opts);
-    }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_contextLength);
-        writer.Write(_forecastHorizon);
-        writer.Write(_patchLength);
-        writer.Write(_hiddenDimension);
-        writer.Write(_numLayers);
-        writer.Write(_numHeads);
-        writer.Write(_intermediateSize);
-        writer.Write(_dropout);
-        writer.Write((int)_modelSize);
-        writer.Write(_numCandlestickFeatures);
-    }
 
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _contextLength = reader.ReadInt32();
-        _forecastHorizon = reader.ReadInt32();
-        _patchLength = reader.ReadInt32();
-        _hiddenDimension = reader.ReadInt32();
-        _numLayers = reader.ReadInt32();
-        _numHeads = reader.ReadInt32();
-        _intermediateSize = reader.ReadInt32();
-        _dropout = reader.ReadDouble();
-        _modelSize = (FoundationModelSize)reader.ReadInt32();
-        _numCandlestickFeatures = reader.ReadInt32();
-    }
 
     #endregion
 
diff --git a/src/Finance/Forecasting/Foundation/LLMTime.cs b/src/Finance/Forecasting/Foundation/LLMTime.cs
index 51ac60f651..0931d4f5b1 100644
--- a/src/Finance/Forecasting/Foundation/LLMTime.cs
+++ b/src/Finance/Forecasting/Foundation/LLMTime.cs
@@ -61,7 +61,7 @@ namespace AiDotNet.Finance.Forecasting.Foundation;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Large Language Models Are Zero-Shot Time Series Forecasters", "https://arxiv.org/abs/2310.07820", Year = 2023, Authors = "Nate Gruver, Marc Finzi, Shikai Qiu, Andrew Gordon Wilson")]
-public class LLMTime<T> : TimeSeriesFoundationModelBase<T>
+public partial class LLMTime<T> : TimeSeriesFoundationModelBase<T>
 {
     #region Fields
 
@@ -300,52 +300,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new LLMTime<T>(Architecture, new LLMTimeOptions<T>
-        {
-            ContextLength = _contextLength,
-            ForecastHorizon = _forecastHorizon,
-            HiddenDimension = _hiddenDimension,
-            NumLayers = _numLayers,
-            NumHeads = _numHeads,
-            DropoutRate = _dropout,
-            ModelSize = _modelSize,
-            NumDecimalPlaces = _numDecimalPlaces,
-            NumSamples = _numSamples,
-            Temperature = _temperature
-        });
-    }
 
-    /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_contextLength);
-        writer.Write(_forecastHorizon);
-        writer.Write(_hiddenDimension);
-        writer.Write(_numLayers);
-        writer.Write(_numHeads);
-        writer.Write(_dropout);
-        writer.Write((int)_modelSize);
-        writer.Write(_numDecimalPlaces);
-        writer.Write(_numSamples);
-        writer.Write(_temperature);
-    }
 
     /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _contextLength = reader.ReadInt32();
-        _forecastHorizon = reader.ReadInt32();
-        _hiddenDimension = reader.ReadInt32();
-        _numLayers = reader.ReadInt32();
-        _numHeads = reader.ReadInt32();
-        _dropout = reader.ReadDouble();
-        _modelSize = (FoundationModelSize)reader.ReadInt32();
-        _numDecimalPlaces = reader.ReadInt32();
-        _numSamples = reader.ReadInt32();
-        _temperature = reader.ReadDouble();
-    }
+
 
     #endregion
 
diff --git a/src/Finance/Forecasting/Foundation/LagLlama.cs b/src/Finance/Forecasting/Foundation/LagLlama.cs
index 689d814d6a..fcb40d347c 100644
--- a/src/Finance/Forecasting/Foundation/LagLlama.cs
+++ b/src/Finance/Forecasting/Foundation/LagLlama.cs
@@ -610,43 +610,6 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    /// <summary>
-    /// Creates a new instance of this model with the same configuration.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Creates a fresh copy of the Lag-Llama architecture.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var options = new LagLlamaOptions<T>
-        {
-            ContextLength = _contextLength,
-            ForecastHorizon = _forecastHorizon,
-            HiddenDimension = _hiddenDimension,
-            NumLayers = _numLayers,
-            NumHeads = _numHeads,
-            IntermediateSize = _intermediateSize,
-            LagIndices = (int[])_lagIndices.Clone(),
-            DropoutRate = _dropout,
-            DistributionOutput = _distributionOutput,
-            UseRoPE = _useRoPE
-        };
-
-        // ONNX mode cloning is not supported - throw explicitly rather than silently
-        // changing behavior by returning a native-mode clone
-        if (!_useNativeMode && OnnxSession is not null)
-        {
-            throw new NotSupportedException(
-                "CreateNewInstance is not supported for ONNX-backed LagLlama models. " +
-                "ONNX sessions cannot be cloned. To create a new instance, load the model " +
-                "from the original ONNX file using the ONNX constructor.");
-        }
-
-        return new LagLlama<T>(Architecture, options);
-    }
-
     /// <summary>
     /// Writes Lag-Llama-specific configuration during serialization.
     /// </summary>
@@ -655,21 +618,7 @@ protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
     /// <b>For Beginners:</b> Saves all the configuration needed to reconstruct this model.
     /// </para>
     /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_contextLength);
-        writer.Write(_forecastHorizon);
-        writer.Write(_hiddenDimension);
-        writer.Write(_numLayers);
-        writer.Write(_numHeads);
-        writer.Write(_intermediateSize);
-        writer.Write(_lagIndices.Length);
-        foreach (var lag in _lagIndices)
-            writer.Write(lag);
-        writer.Write(_dropout);
-        writer.Write(_distributionOutput);
-        writer.Write(_useRoPE);
-    }
+
 
     /// <summary>
     /// Reads Lag-Llama-specific configuration during deserialization.
@@ -679,28 +628,7 @@ protected override void SerializeNetworkSpecificData(BinaryWriter writer)
     /// <b>For Beginners:</b> Loads the configuration that was saved during serialization.
     /// </para>
     /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _contextLength = reader.ReadInt32();
-        _forecastHorizon = reader.ReadInt32();
-        _hiddenDimension = reader.ReadInt32();
-        _numLayers = reader.ReadInt32();
-        _numHeads = reader.ReadInt32();
-        _intermediateSize = reader.ReadInt32();
-        int lagCount = reader.ReadInt32();
-        _lagIndices = new int[lagCount];
-        for (int i = 0; i < lagCount; i++)
-            _lagIndices[i] = reader.ReadInt32();
-        _dropout = reader.ReadDouble();
-        _distributionOutput = reader.ReadString();
-        _useRoPE = reader.ReadBoolean();
-
-        // The base deserializer has already recreated every layer in Layers with the
-        // copied weights. Re-point the cached projection/transformer/head references at
-        // those layers; otherwise they keep pointing at the stale random-initialized
-        // layers from CreateNewInstance and a clone diverges from the original.
-        ExtractLayerReferences();
-    }
+
 
     #endregion
 
diff --git a/src/Finance/Forecasting/Foundation/MGTSD.cs b/src/Finance/Forecasting/Foundation/MGTSD.cs
index 88b8555d97..a8d1eaa82e 100644
--- a/src/Finance/Forecasting/Foundation/MGTSD.cs
+++ b/src/Finance/Forecasting/Foundation/MGTSD.cs
@@ -562,15 +562,8 @@ public override Tensor<T> ForwardForTraining(Tensor<T> input)
         ModelData = _useNativeMode ? this.Serialize() : Array.Empty<byte>()
     };
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var opts = new MGTSDOptions<T> { ContextLength = _contextLength, ForecastHorizon = _forecastHorizon, HiddenDimension = _hiddenDimension, NumLayers = _numLayers, NumHeads = _numHeads, DiffusionSteps = _diffusionSteps, DropoutRate = _dropout, BetaStart = _betaStart, BetaEnd = _betaEnd, NumGranularities = _numGranularities, GuidanceWeight = _guidanceWeight };
-        if (!_useNativeMode && OnnxModelPath is not null) return new MGTSD<T>(Architecture, OnnxModelPath, opts);
-        return new MGTSD<T>(Architecture, opts);
-    }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer) { writer.Write(_contextLength); writer.Write(_forecastHorizon); writer.Write(_hiddenDimension); writer.Write(_numLayers); writer.Write(_numHeads); writer.Write(_diffusionSteps); writer.Write(_dropout); writer.Write(_betaStart); writer.Write(_betaEnd); writer.Write(_numGranularities); writer.Write(_guidanceWeight); }
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader) { _contextLength = reader.ReadInt32(); _forecastHorizon = reader.ReadInt32(); _hiddenDimension = reader.ReadInt32(); _numLayers = reader.ReadInt32(); _numHeads = reader.ReadInt32(); _diffusionSteps = reader.ReadInt32(); _dropout = reader.ReadDouble(); _betaStart = reader.ReadDouble(); _betaEnd = reader.ReadDouble(); _numGranularities = reader.ReadInt32(); _guidanceWeight = reader.ReadDouble(); ComputeNoiseSchedule(); ExtractLayerReferences(); }
+
 
     #endregion
 
diff --git a/src/Finance/Forecasting/Foundation/MOIRAI.cs b/src/Finance/Forecasting/Foundation/MOIRAI.cs
index 51a4ed8731..77b63096d6 100644
--- a/src/Finance/Forecasting/Foundation/MOIRAI.cs
+++ b/src/Finance/Forecasting/Foundation/MOIRAI.cs
@@ -806,36 +806,6 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    /// <inheritdoc/>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> In the MOIRAI model, CreateNewInstance builds and wires up model components. This sets up the MOIRAI architecture before use.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var options = new MOIRAIOptions<T>
-        {
-            ContextLength = _contextLength,
-            ForecastHorizon = _forecastHorizon,
-            PatchSizes = _patchSizes,
-            HiddenDimension = _hiddenDimension,
-            NumLayers = _numLayers,
-            NumHeads = _numHeads,
-            IntermediateSize = _intermediateSize,
-            NumMixtures = _numMixtures,
-            DropoutRate = _dropout,
-            MaskRatio = _maskRatio,
-            ModelSize = _modelSize,
-            UseDecoderOnly = _useDecoderOnly,
-            NumQuantiles = _numQuantiles,
-            MultiTokenSteps = _multiTokenSteps,
-            PatchSize = _v2PatchSize
-        };
-
-        return new MOIRAI<T>(Architecture, options, _numFeatures);
-    }
-
     /// <summary>
     /// Writes MOIRAI-specific configuration during serialization.
     /// </summary>
@@ -843,30 +813,7 @@ protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
     /// <para><b>For Beginners:</b> Saves all the configuration needed to reconstruct this model.
     /// </para>
     /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_contextLength);
-        writer.Write(_forecastHorizon);
-        writer.Write(_patchSizes.Length);
-        foreach (var ps in _patchSizes)
-        {
-            writer.Write(ps);
-        }
-        writer.Write(_hiddenDimension);
-        writer.Write(_numLayers);
-        writer.Write(_numHeads);
-        writer.Write(_intermediateSize);
-        writer.Write(_numMixtures);
-        writer.Write(_dropout);
-        writer.Write(_maskRatio);
-        writer.Write(_numFeatures);
-        writer.Write((int)_modelSize);
-        // Moirai 2.0 fields
-        writer.Write(_useDecoderOnly);
-        writer.Write(_numQuantiles);
-        writer.Write(_multiTokenSteps);
-        writer.Write(_v2PatchSize);
-    }
+
 
     /// <summary>
     /// Reads MOIRAI-specific configuration during deserialization.
@@ -875,44 +822,7 @@ protected override void SerializeNetworkSpecificData(BinaryWriter writer)
     /// <para><b>For Beginners:</b> Loads the configuration that was saved during serialization.
     /// </para>
     /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _contextLength = reader.ReadInt32();
-        _forecastHorizon = reader.ReadInt32();
-        int patchCount = reader.ReadInt32();
-        _patchSizes = new int[patchCount];
-        for (int i = 0; i < patchCount; i++)
-        {
-            _patchSizes[i] = reader.ReadInt32();
-        }
-        _hiddenDimension = reader.ReadInt32();
-        _numLayers = reader.ReadInt32();
-        _numHeads = reader.ReadInt32();
-        _intermediateSize = reader.ReadInt32();
-        _numMixtures = reader.ReadInt32();
-        _dropout = reader.ReadDouble();
-        _maskRatio = reader.ReadDouble();
-        _numFeatures = reader.ReadInt32();
-        _modelSize = (FoundationModelSize)reader.ReadInt32();
-        // Moirai 2.0 fields
-        _useDecoderOnly = reader.ReadBoolean();
-        _numQuantiles = reader.ReadInt32();
-        _multiTokenSteps = reader.ReadInt32();
-        _v2PatchSize = reader.ReadInt32();
 
-        _totalPatches = 0;
-        if (_useDecoderOnly)
-        {
-            _totalPatches = _contextLength / Math.Max(1, _v2PatchSize);
-        }
-        else
-        {
-            foreach (var patchSize in _patchSizes)
-            {
-                _totalPatches += _contextLength / Math.Max(1, patchSize);
-            }
-        }
-    }
 
     #endregion
 
diff --git a/src/Finance/Forecasting/Foundation/MOMENT.cs b/src/Finance/Forecasting/Foundation/MOMENT.cs
index dae381e480..c4bbe56034 100644
--- a/src/Finance/Forecasting/Foundation/MOMENT.cs
+++ b/src/Finance/Forecasting/Foundation/MOMENT.cs
@@ -453,61 +453,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var options = new MOMENTOptions<T>
-        {
-            ContextLength = _contextLength,
-            ForecastHorizon = _forecastHorizon,
-            PatchLength = _patchLength,
-            HiddenDimension = _hiddenDimension,
-            NumLayers = _numLayers,
-            NumHeads = _numHeads,
-            IntermediateSize = _intermediateSize,
-            DropoutRate = _dropout,
-            ModelSize = _modelSize,
-            Task = _currentTask,
-            NumClasses = _numClasses,
-            MaskRatio = _maskRatio
-        };
 
-        return new MOMENT<T>(Architecture, options);
-    }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_contextLength);
-        writer.Write(_forecastHorizon);
-        writer.Write(_patchLength);
-        writer.Write(_hiddenDimension);
-        writer.Write(_numLayers);
-        writer.Write(_numHeads);
-        writer.Write(_intermediateSize);
-        writer.Write(_dropout);
-        writer.Write((int)_modelSize);
-        writer.Write((int)_currentTask);
-        writer.Write(_numClasses ?? -1);
-        writer.Write(_maskRatio);
-    }
 
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _contextLength = reader.ReadInt32();
-        _forecastHorizon = reader.ReadInt32();
-        _patchLength = reader.ReadInt32();
-        _hiddenDimension = reader.ReadInt32();
-        _numLayers = reader.ReadInt32();
-        _numHeads = reader.ReadInt32();
-        _intermediateSize = reader.ReadInt32();
-        _dropout = reader.ReadDouble();
-        _modelSize = (FoundationModelSize)reader.ReadInt32();
-        _currentTask = (TimeSeriesFoundationModelTask)reader.ReadInt32();
-        int nc = reader.ReadInt32();
-        _numClasses = nc >= 0 ? nc : null;
-        _maskRatio = reader.ReadDouble();
-    }
 
     #endregion
 
diff --git a/src/Finance/Forecasting/Foundation/SimMTM.cs b/src/Finance/Forecasting/Foundation/SimMTM.cs
index aaba028be8..e33b3d75cf 100644
--- a/src/Finance/Forecasting/Foundation/SimMTM.cs
+++ b/src/Finance/Forecasting/Foundation/SimMTM.cs
@@ -61,7 +61,7 @@ namespace AiDotNet.Finance.Forecasting.Foundation;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("SimMTM: A Simple Pre-Training Framework for Masked Time-Series Modeling", "https://arxiv.org/abs/2302.00861", Year = 2023, Authors = "Jiaxiang Dong, Haixu Wu, Haoran Zhang, Li Zhang, Jianmin Wang, Mingsheng Long")]
-public class SimMTM<T> : TimeSeriesFoundationModelBase<T>
+public partial class SimMTM<T> : TimeSeriesFoundationModelBase<T>
 {
     #region Fields
 
@@ -266,54 +266,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var opts = new SimMTMOptions<T>
-        {
-            ContextLength = _contextLength,
-            ForecastHorizon = _forecastHorizon,
-            PatchLength = _patchLength,
-            HiddenDimension = _hiddenDimension,
-            NumLayers = _numLayers,
-            NumHeads = _numHeads,
-            MaskRatio = _maskRatio,
-            DropoutRate = _dropout,
-            SimilarityTemperature = _similarityTemperature
-        };
 
-        if (!_useNativeMode && OnnxModelPath is not null)
-            return new SimMTM<T>(Architecture, OnnxModelPath, opts);
-
-        return new SimMTM<T>(Architecture, opts);
-    }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_contextLength);
-        writer.Write(_forecastHorizon);
-        writer.Write(_patchLength);
-        writer.Write(_hiddenDimension);
-        writer.Write(_numLayers);
-        writer.Write(_numHeads);
-        writer.Write(_maskRatio);
-        writer.Write(_dropout);
-        writer.Write(_similarityTemperature);
-    }
 
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _contextLength = reader.ReadInt32();
-        _forecastHorizon = reader.ReadInt32();
-        _patchLength = reader.ReadInt32();
-        _hiddenDimension = reader.ReadInt32();
-        _numLayers = reader.ReadInt32();
-        _numHeads = reader.ReadInt32();
-        _maskRatio = reader.ReadDouble();
-        _dropout = reader.ReadDouble();
-        _similarityTemperature = reader.ReadDouble();
-    }
 
     #endregion
 
diff --git a/src/Finance/Forecasting/Foundation/Sundial.cs b/src/Finance/Forecasting/Foundation/Sundial.cs
index c1d85be8e4..6de685383e 100644
--- a/src/Finance/Forecasting/Foundation/Sundial.cs
+++ b/src/Finance/Forecasting/Foundation/Sundial.cs
@@ -63,7 +63,7 @@ namespace AiDotNet.Finance.Forecasting.Foundation;
 [ModelComplexity(ModelComplexity.High)]
 [ResearchPaper("Sundial: A Family of Highly Capable Time Series Foundation Models", "https://arxiv.org/abs/2502.00816")]
     [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
-public class Sundial<T> : TimeSeriesFoundationModelBase<T>
+public partial class Sundial<T> : TimeSeriesFoundationModelBase<T>
 {
     #region Fields
 
@@ -268,57 +268,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var opts = new SundialOptions<T>
-        {
-            ContextLength = _contextLength,
-            ForecastHorizon = _forecastHorizon,
-            PatchLength = _patchLength,
-            HiddenDimension = _hiddenDimension,
-            NumLayers = _numLayers,
-            NumHeads = _numHeads,
-            IntermediateSize = _intermediateSize,
-            DropoutRate = _dropout,
-            ModelSize = _modelSize,
-            NumQuantiles = _numQuantiles
-        };
 
-        if (!_useNativeMode && OnnxModelPath is not null)
-            return new Sundial<T>(Architecture, OnnxModelPath, opts);
-
-        return new Sundial<T>(Architecture, opts);
-    }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_contextLength);
-        writer.Write(_forecastHorizon);
-        writer.Write(_patchLength);
-        writer.Write(_hiddenDimension);
-        writer.Write(_numLayers);
-        writer.Write(_numHeads);
-        writer.Write(_intermediateSize);
-        writer.Write(_dropout);
-        writer.Write((int)_modelSize);
-        writer.Write(_numQuantiles);
-    }
 
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _contextLength = reader.ReadInt32();
-        _forecastHorizon = reader.ReadInt32();
-        _patchLength = reader.ReadInt32();
-        _hiddenDimension = reader.ReadInt32();
-        _numLayers = reader.ReadInt32();
-        _numHeads = reader.ReadInt32();
-        _intermediateSize = reader.ReadInt32();
-        _dropout = reader.ReadDouble();
-        _modelSize = (FoundationModelSize)reader.ReadInt32();
-        _numQuantiles = reader.ReadInt32();
-    }
 
     #endregion
 
diff --git a/src/Finance/Forecasting/Foundation/TEST.cs b/src/Finance/Forecasting/Foundation/TEST.cs
index 3868aca08d..9874a2da07 100644
--- a/src/Finance/Forecasting/Foundation/TEST.cs
+++ b/src/Finance/Forecasting/Foundation/TEST.cs
@@ -62,7 +62,7 @@ namespace AiDotNet.Finance.Forecasting.Foundation;
 [ModelComplexity(ModelComplexity.High)]
 [ResearchPaper("TEST: Text Prototype Aligned Embedding for Time Series", "https://arxiv.org/abs/2308.08241")]
     [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
-public class TEST<T> : TimeSeriesFoundationModelBase<T>
+public partial class TEST<T> : TimeSeriesFoundationModelBase<T>
 {
     #region Fields
 
@@ -272,60 +272,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var opts = new TESTOptions<T>
-        {
-            ContextLength = _contextLength,
-            ForecastHorizon = _forecastHorizon,
-            PatchLength = _patchLength,
-            HiddenDimension = _hiddenDimension,
-            TextEmbeddingDimension = _textEmbeddingDimension,
-            NumLayers = _numLayers,
-            NumHeads = _numHeads,
-            DropoutRate = _dropout,
-            ModelSize = _modelSize,
-            NumPrototypes = _numPrototypes,
-            AlignmentWeight = _alignmentWeight
-        };
 
-        if (!_useNativeMode && OnnxModelPath is not null)
-            return new TEST<T>(Architecture, OnnxModelPath, opts);
-
-        return new TEST<T>(Architecture, opts);
-    }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_contextLength);
-        writer.Write(_forecastHorizon);
-        writer.Write(_patchLength);
-        writer.Write(_hiddenDimension);
-        writer.Write(_textEmbeddingDimension);
-        writer.Write(_numLayers);
-        writer.Write(_numHeads);
-        writer.Write(_dropout);
-        writer.Write((int)_modelSize);
-        writer.Write(_numPrototypes);
-        writer.Write(_alignmentWeight);
-    }
 
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _contextLength = reader.ReadInt32();
-        _forecastHorizon = reader.ReadInt32();
-        _patchLength = reader.ReadInt32();
-        _hiddenDimension = reader.ReadInt32();
-        _textEmbeddingDimension = reader.ReadInt32();
-        _numLayers = reader.ReadInt32();
-        _numHeads = reader.ReadInt32();
-        _dropout = reader.ReadDouble();
-        _modelSize = (FoundationModelSize)reader.ReadInt32();
-        _numPrototypes = reader.ReadInt32();
-        _alignmentWeight = reader.ReadDouble();
-    }
 
     #endregion
 
diff --git a/src/Finance/Forecasting/Foundation/TFC.cs b/src/Finance/Forecasting/Foundation/TFC.cs
index 9b2275a468..f1def43b05 100644
--- a/src/Finance/Forecasting/Foundation/TFC.cs
+++ b/src/Finance/Forecasting/Foundation/TFC.cs
@@ -577,52 +577,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new TFC<T>(Architecture, new TFCOptions<T>
-        {
-            ContextLength = _contextLength,
-            ForecastHorizon = _forecastHorizon,
-            HiddenDimension = _hiddenDimension,
-            ProjectionDimension = _projectionDimension,
-            NumTimeLayers = _numTimeLayers,
-            NumFreqLayers = _numFreqLayers,
-            DropoutRate = _dropout,
-            ContrastiveTemperature = _contrastiveTemperature
-        });
-    }
 
-    /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_contextLength);
-        writer.Write(_forecastHorizon);
-        writer.Write(_hiddenDimension);
-        writer.Write(_projectionDimension);
-        writer.Write(_numTimeLayers);
-        writer.Write(_numFreqLayers);
-        writer.Write(_dropout);
-        writer.Write(_contrastiveTemperature);
-    }
 
     /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _contextLength = reader.ReadInt32();
-        _forecastHorizon = reader.ReadInt32();
-        _hiddenDimension = reader.ReadInt32();
-        _projectionDimension = reader.ReadInt32();
-        _numTimeLayers = reader.ReadInt32();
-        _numFreqLayers = reader.ReadInt32();
-        _dropout = reader.ReadDouble();
-        _contrastiveTemperature = reader.ReadDouble();
-
-        // The base deserializer has already recreated every layer in Layers with the
-        // copied weights. Re-point the cached encoder/projection/head references at
-        // those layers; otherwise they keep pointing at the stale random-initialized
-        // layers from CreateNewInstance and a clone diverges from the original.
-        ExtractLayerReferences();
-    }
+
 
     #endregion
 
diff --git a/src/Finance/Forecasting/Foundation/TOTEM.cs b/src/Finance/Forecasting/Foundation/TOTEM.cs
index 8d4a8db72d..faff97acac 100644
--- a/src/Finance/Forecasting/Foundation/TOTEM.cs
+++ b/src/Finance/Forecasting/Foundation/TOTEM.cs
@@ -94,6 +94,7 @@ public partial class TOTEM<T> : TimeSeriesFoundationModelBase<T>
     private double _commitmentWeight;
 
     // VQ codebook: [numCodebooks x codebookSize x codebookDimension]
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T>? _codebooks;
     private T _lastCommitmentLoss;
 
@@ -544,87 +545,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new TOTEM<T>(Architecture, new TOTEMOptions<T>
-        {
-            ContextLength = _contextLength,
-            ForecastHorizon = _forecastHorizon,
-            HiddenDimension = _hiddenDimension,
-            NumLayers = _numLayers,
-            NumHeads = _numHeads,
-            CodebookSize = _codebookSize,
-            CodebookDimension = _codebookDimension,
-            NumCodebooks = _numCodebooks,
-            DropoutRate = _dropout,
-            CommitmentWeight = _commitmentWeight
-        });
-    }
 
-    /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_contextLength);
-        writer.Write(_forecastHorizon);
-        writer.Write(_hiddenDimension);
-        writer.Write(_numLayers);
-        writer.Write(_numHeads);
-        writer.Write(_codebookSize);
-        writer.Write(_codebookDimension);
-        writer.Write(_numCodebooks);
-        writer.Write(_dropout);
-        writer.Write(_commitmentWeight);
-
-        // Serialize codebook embeddings
-        if (_codebooks is not null)
-        {
-            writer.Write(true);
-            for (int c = 0; c < _numCodebooks; c++)
-                for (int k = 0; k < _codebookSize; k++)
-                    for (int d = 0; d < _codebookDimension; d++)
-                        writer.Write(NumOps.ToDouble(GetCodebookValue(c, k, d)));
-        }
-        else
-        {
-            writer.Write(false);
-        }
-    }
 
     /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _contextLength = reader.ReadInt32();
-        _forecastHorizon = reader.ReadInt32();
-        _hiddenDimension = reader.ReadInt32();
-        _numLayers = reader.ReadInt32();
-        _numHeads = reader.ReadInt32();
-        _codebookSize = reader.ReadInt32();
-        _codebookDimension = reader.ReadInt32();
-        _numCodebooks = reader.ReadInt32();
-        _dropout = reader.ReadDouble();
-        _commitmentWeight = reader.ReadDouble();
-
-        // Deserialize codebook embeddings
-        bool hasCodebooks = reader.ReadBoolean();
-        if (hasCodebooks)
-        {
-            _codebooks = new Tensor<T>(new[] { _numCodebooks, _codebookSize, _codebookDimension });
-            for (int c = 0; c < _numCodebooks; c++)
-                for (int k = 0; k < _codebookSize; k++)
-                    for (int d = 0; d < _codebookDimension; d++)
-                        SetCodebookValue(c, k, d, NumOps.FromDouble(reader.ReadDouble()));
-        }
-        else
-        {
-            InitializeCodebooks();
-        }
 
-        // The base deserializer has already recreated every layer in Layers with the
-        // copied weights. Re-point the cached encoder/decoder/projection references at
-        // those layers; otherwise they keep pointing at the stale random-initialized
-        // layers from CreateNewInstance and a clone diverges from the original.
-        ExtractLayerReferences();
-    }
 
     #endregion
 
diff --git a/src/Finance/Forecasting/Foundation/TOTO.cs b/src/Finance/Forecasting/Foundation/TOTO.cs
index 6c9f476509..910c671951 100644
--- a/src/Finance/Forecasting/Foundation/TOTO.cs
+++ b/src/Finance/Forecasting/Foundation/TOTO.cs
@@ -63,7 +63,7 @@ namespace AiDotNet.Finance.Forecasting.Foundation;
 [ModelComplexity(ModelComplexity.High)]
 [ResearchPaper("TOTO: Time-Series Optimized Transformer for Observability", "https://arxiv.org/abs/2407.07874")]
     [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
-public class TOTO<T> : TimeSeriesFoundationModelBase<T>
+public partial class TOTO<T> : TimeSeriesFoundationModelBase<T>
 {
     #region Fields
 
@@ -277,54 +277,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var opts = new TOTOOptions<T>
-        {
-            ContextLength = _contextLength,
-            ForecastHorizon = _forecastHorizon,
-            PatchLength = _patchLength,
-            HiddenDimension = _hiddenDimension,
-            NumLayers = _numLayers,
-            NumHeads = _numHeads,
-            IntermediateSize = _intermediateSize,
-            DropoutRate = _dropout,
-            ModelSize = _modelSize
-        };
 
-        if (!_useNativeMode && OnnxModelPath is not null)
-            return new TOTO<T>(Architecture, OnnxModelPath, opts);
-
-        return new TOTO<T>(Architecture, opts);
-    }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_contextLength);
-        writer.Write(_forecastHorizon);
-        writer.Write(_patchLength);
-        writer.Write(_hiddenDimension);
-        writer.Write(_numLayers);
-        writer.Write(_numHeads);
-        writer.Write(_intermediateSize);
-        writer.Write(_dropout);
-        writer.Write((int)_modelSize);
-    }
 
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _contextLength = reader.ReadInt32();
-        _forecastHorizon = reader.ReadInt32();
-        _patchLength = reader.ReadInt32();
-        _hiddenDimension = reader.ReadInt32();
-        _numLayers = reader.ReadInt32();
-        _numHeads = reader.ReadInt32();
-        _intermediateSize = reader.ReadInt32();
-        _dropout = reader.ReadDouble();
-        _modelSize = (FoundationModelSize)reader.ReadInt32();
-    }
 
     #endregion
 
diff --git a/src/Finance/Forecasting/Foundation/TS2Vec.cs b/src/Finance/Forecasting/Foundation/TS2Vec.cs
index 445357ae23..dba6b1da09 100644
--- a/src/Finance/Forecasting/Foundation/TS2Vec.cs
+++ b/src/Finance/Forecasting/Foundation/TS2Vec.cs
@@ -298,51 +298,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new TS2Vec<T>(Architecture, new TS2VecOptions<T>
-        {
-            ContextLength = _contextLength,
-            ForecastHorizon = _forecastHorizon,
-            HiddenDimension = _hiddenDimension,
-            OutputDimension = _outputDimension,
-            NumLayers = _numLayers,
-            DropoutRate = _dropout,
-            TemporalContrastiveWeight = _temporalContrastiveWeight,
-            InstanceContrastiveWeight = _instanceContrastiveWeight
-        });
-    }
 
-    /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_contextLength);
-        writer.Write(_forecastHorizon);
-        writer.Write(_hiddenDimension);
-        writer.Write(_outputDimension);
-        writer.Write(_numLayers);
-        writer.Write(_dropout);
-        writer.Write(_temporalContrastiveWeight);
-        writer.Write(_instanceContrastiveWeight);
-    }
 
     /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _contextLength = reader.ReadInt32();
-        _forecastHorizon = reader.ReadInt32();
-        _hiddenDimension = reader.ReadInt32();
-        _outputDimension = reader.ReadInt32();
-        _numLayers = reader.ReadInt32();
-        _dropout = reader.ReadDouble();
-        _temporalContrastiveWeight = reader.ReadDouble();
-        _instanceContrastiveWeight = reader.ReadDouble();
-
-        // Re-point cached layer references at the freshly deserialized Layers;
-        // otherwise a clone's forward uses the stale random-initialized layers
-        // created by CreateNewInstance and diverges from the original.
-        ExtractLayerReferences();
-    }
+
 
     #endregion
 
diff --git a/src/Finance/Forecasting/Foundation/TSDiff.cs b/src/Finance/Forecasting/Foundation/TSDiff.cs
index 7d95ffc670..48e7cc79ed 100644
--- a/src/Finance/Forecasting/Foundation/TSDiff.cs
+++ b/src/Finance/Forecasting/Foundation/TSDiff.cs
@@ -259,10 +259,8 @@ public override Tensor<T> ForwardForTraining(Tensor<T> input)
         ModelData = _useNativeMode ? this.Serialize() : Array.Empty<byte>()
     };
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() { var opts = new TSDiffOptions<T> { SequenceLength = _sequenceLength, ForecastHorizon = _forecastHorizon, HiddenDimension = _hiddenDimension, NumResidualBlocks = _numResidualBlocks, NumDiffusionSteps = _numDiffusionSteps, NumAttentionHeads = _numAttentionHeads, DropoutRate = _dropout, BetaStart = _betaStart, BetaEnd = _betaEnd, GuidanceScale = _guidanceScale }; if (!_useNativeMode && OnnxModelPath is not null) return new TSDiff<T>(Architecture, OnnxModelPath, opts); return new TSDiff<T>(Architecture, opts); }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer) { writer.Write(_sequenceLength); writer.Write(_forecastHorizon); writer.Write(_hiddenDimension); writer.Write(_numResidualBlocks); writer.Write(_numDiffusionSteps); writer.Write(_numAttentionHeads); writer.Write(_dropout); writer.Write(_betaStart); writer.Write(_betaEnd); writer.Write(_guidanceScale); }
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader) { _sequenceLength = reader.ReadInt32(); _forecastHorizon = reader.ReadInt32(); _hiddenDimension = reader.ReadInt32(); _numResidualBlocks = reader.ReadInt32(); _numDiffusionSteps = reader.ReadInt32(); _numAttentionHeads = reader.ReadInt32(); _dropout = reader.ReadDouble(); _betaStart = reader.ReadDouble(); _betaEnd = reader.ReadDouble(); _guidanceScale = reader.ReadDouble(); ComputeNoiseSchedule(); }
+
 
     #endregion
 
diff --git a/src/Finance/Forecasting/Foundation/TimeBridge.cs b/src/Finance/Forecasting/Foundation/TimeBridge.cs
index d39e7a65cd..bab26e7014 100644
--- a/src/Finance/Forecasting/Foundation/TimeBridge.cs
+++ b/src/Finance/Forecasting/Foundation/TimeBridge.cs
@@ -62,7 +62,7 @@ namespace AiDotNet.Finance.Forecasting.Foundation;
 [ModelComplexity(ModelComplexity.High)]
 [ResearchPaper("TimeBridge: Non-Stationarity Matters for Long-term Forecasting", "https://arxiv.org/abs/2410.04442")]
     [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
-public class TimeBridge<T> : TimeSeriesFoundationModelBase<T>
+public partial class TimeBridge<T> : TimeSeriesFoundationModelBase<T>
 {
     #region Fields
 
@@ -279,56 +279,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new TimeBridge<T>(Architecture, new TimeBridgeOptions<T>
-        {
-            ContextLength = _contextLength,
-            ForecastHorizon = _forecastHorizon,
-            PatchLength = _patchLength,
-            HiddenDimension = _hiddenDimension,
-            NumLayers = _numLayers,
-            NumHeads = _numHeads,
-            IntermediateSize = _intermediateSize,
-            DropoutRate = _dropout,
-            ModelSize = _modelSize,
-            BridgeDimension = _bridgeDimension,
-            UseStationarityGating = _useStationarityGating,
-            LearningRate = _options.LearningRate
-        });
-    }
 
-    /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_contextLength);
-        writer.Write(_forecastHorizon);
-        writer.Write(_patchLength);
-        writer.Write(_hiddenDimension);
-        writer.Write(_numLayers);
-        writer.Write(_numHeads);
-        writer.Write(_intermediateSize);
-        writer.Write(_dropout);
-        writer.Write((int)_modelSize);
-        writer.Write(_bridgeDimension);
-        writer.Write(_useStationarityGating);
-    }
 
     /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _contextLength = reader.ReadInt32();
-        _forecastHorizon = reader.ReadInt32();
-        _patchLength = reader.ReadInt32();
-        _hiddenDimension = reader.ReadInt32();
-        _numLayers = reader.ReadInt32();
-        _numHeads = reader.ReadInt32();
-        _intermediateSize = reader.ReadInt32();
-        _dropout = reader.ReadDouble();
-        _modelSize = (FoundationModelSize)reader.ReadInt32();
-        _bridgeDimension = reader.ReadInt32();
-        _useStationarityGating = reader.ReadBoolean();
-    }
+
 
     #endregion
 
diff --git a/src/Finance/Forecasting/Foundation/TimeDiff.cs b/src/Finance/Forecasting/Foundation/TimeDiff.cs
index 2cac5c0575..4994a650fe 100644
--- a/src/Finance/Forecasting/Foundation/TimeDiff.cs
+++ b/src/Finance/Forecasting/Foundation/TimeDiff.cs
@@ -282,10 +282,8 @@ public override Tensor<T> ForwardForTraining(Tensor<T> input)
         ModelData = _useNativeMode ? this.Serialize() : Array.Empty<byte>()
     };
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() => new TimeDiff<T>(Architecture, new TimeDiffOptions<T> { ContextLength = _contextLength, ForecastHorizon = _forecastHorizon, HiddenDimension = _hiddenDimension, NumLayers = _numLayers, NumHeads = _numHeads, DiffusionSteps = _diffusionSteps, DropoutRate = _dropout, BetaStart = _betaStart, BetaEnd = _betaEnd, UseFutureMixup = _useFutureMixup, UseAutoregressiveInit = _useAutoregressiveInit });
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer) { writer.Write(_contextLength); writer.Write(_forecastHorizon); writer.Write(_hiddenDimension); writer.Write(_numLayers); writer.Write(_numHeads); writer.Write(_diffusionSteps); writer.Write(_dropout); writer.Write(_betaStart); writer.Write(_betaEnd); writer.Write(_useFutureMixup); writer.Write(_useAutoregressiveInit); }
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader) { _contextLength = reader.ReadInt32(); _forecastHorizon = reader.ReadInt32(); _hiddenDimension = reader.ReadInt32(); _numLayers = reader.ReadInt32(); _numHeads = reader.ReadInt32(); _diffusionSteps = reader.ReadInt32(); _dropout = reader.ReadDouble(); _betaStart = reader.ReadDouble(); _betaEnd = reader.ReadDouble(); _useFutureMixup = reader.ReadBoolean(); _useAutoregressiveInit = reader.ReadBoolean(); ComputeNoiseSchedule(); }
+
 
     #endregion
 
diff --git a/src/Finance/Forecasting/Foundation/TimeGPT.cs b/src/Finance/Forecasting/Foundation/TimeGPT.cs
index 19be60ba7c..421666ad73 100644
--- a/src/Finance/Forecasting/Foundation/TimeGPT.cs
+++ b/src/Finance/Forecasting/Foundation/TimeGPT.cs
@@ -493,31 +493,6 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    /// <inheritdoc/>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> In the TimeGPT model, CreateNewInstance builds and wires up model components. This sets up the TimeGPT architecture before use.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var options = new TimeGPTOptions<T>
-        {
-            ContextLength = _contextLength,
-            ForecastHorizon = _forecastHorizon,
-            HiddenDimension = _hiddenDimension,
-            NumLayers = _numLayers,
-            NumHeads = _numHeads,
-            DropoutRate = _dropout,
-            UseConformalPrediction = _useConformalPrediction,
-            ConfidenceLevel = _confidenceLevel,
-            FineTuningSteps = _fineTuningSteps,
-            FineTuningLearningRate = _fineTuningLearningRate
-        };
-
-        return new TimeGPT<T>(Architecture, options, _numFeatures);
-    }
-
     /// <summary>
     /// Writes TimeGPT-specific configuration during serialization.
     /// </summary>
@@ -525,32 +500,7 @@ protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
     /// <para><b>For Beginners:</b> Saves all the configuration needed to reconstruct this model.
     /// </para>
     /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_contextLength);
-        writer.Write(_forecastHorizon);
-        writer.Write(_hiddenDimension);
-        writer.Write(_numLayers);
-        writer.Write(_numHeads);
-        writer.Write(_dropout);
-        writer.Write(_useConformalPrediction);
-        writer.Write(_confidenceLevel);
-        writer.Write(_fineTuningSteps);
-        writer.Write(_fineTuningLearningRate);
-        writer.Write(_numFeatures);
-
-        // Save calibration residuals if available
-        int residualCount = _calibrationResiduals?.Count ?? 0;
-        writer.Write(residualCount);
-        if (_calibrationResiduals is not null)
-        {
-            foreach (var residual in _calibrationResiduals)
-            {
-                writer.Write(residual);
-            }
-        }
-    }
+
 
     /// <summary>
     /// Reads TimeGPT-specific configuration during deserialization.
@@ -559,31 +509,7 @@ protected override void SerializeNetworkSpecificData(BinaryWriter writer)
     /// <para><b>For Beginners:</b> Loads the configuration that was saved during serialization.
     /// </para>
     /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        _contextLength = reader.ReadInt32();
-        _forecastHorizon = reader.ReadInt32();
-        _hiddenDimension = reader.ReadInt32();
-        _numLayers = reader.ReadInt32();
-        _numHeads = reader.ReadInt32();
-        _dropout = reader.ReadDouble();
-        _useConformalPrediction = reader.ReadBoolean();
-        _confidenceLevel = reader.ReadDouble();
-        _fineTuningSteps = reader.ReadInt32();
-        _fineTuningLearningRate = reader.ReadDouble();
-        _numFeatures = reader.ReadInt32();
-
-        int residualCount = reader.ReadInt32();
-        if (residualCount > 0)
-        {
-            _calibrationResiduals = new List<double>(residualCount);
-            for (int i = 0; i < residualCount; i++)
-            {
-                _calibrationResiduals.Add(reader.ReadDouble());
-            }
-        }
-    }
+
 
     #endregion
 
diff --git a/src/Finance/Forecasting/Foundation/TimeGrad.cs b/src/Finance/Forecasting/Foundation/TimeGrad.cs
index c54532cc72..85bceb311b 100644
--- a/src/Finance/Forecasting/Foundation/TimeGrad.cs
+++ b/src/Finance/Forecasting/Foundation/TimeGrad.cs
@@ -350,54 +350,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new TimeGrad<T>(Architecture, new TimeGradOptions<T>
-        {
-            ContextLength = _contextLength,
-            ForecastHorizon = _forecastHorizon,
-            HiddenDimension = _hiddenDimension,
-            NumRnnLayers = _numRnnLayers,
-            NumDiffusionSteps = _numDiffusionSteps,
-            DenoisingNetworkDim = _denoisingNetworkDim,
-            NumSamples = _numSamples,
-            DropoutRate = _dropout,
-            BetaStart = _betaStart,
-            BetaEnd = _betaEnd
-        });
-    }
 
-    /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_contextLength);
-        writer.Write(_forecastHorizon);
-        writer.Write(_hiddenDimension);
-        writer.Write(_numRnnLayers);
-        writer.Write(_numDiffusionSteps);
-        writer.Write(_denoisingNetworkDim);
-        writer.Write(_numSamples);
-        writer.Write(_dropout);
-        writer.Write(_betaStart);
-        writer.Write(_betaEnd);
-    }
 
     /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _contextLength = reader.ReadInt32();
-        _forecastHorizon = reader.ReadInt32();
-        _hiddenDimension = reader.ReadInt32();
-        _numRnnLayers = reader.ReadInt32();
-        _numDiffusionSteps = reader.ReadInt32();
-        _denoisingNetworkDim = reader.ReadInt32();
-        _numSamples = reader.ReadInt32();
-        _dropout = reader.ReadDouble();
-        _betaStart = reader.ReadDouble();
-        _betaEnd = reader.ReadDouble();
 
-        ComputeNoiseSchedule();
-    }
 
     #endregion
 
diff --git a/src/Finance/Forecasting/Foundation/TimeLLM.cs b/src/Finance/Forecasting/Foundation/TimeLLM.cs
index 815bbde7ed..1492391e3c 100644
--- a/src/Finance/Forecasting/Foundation/TimeLLM.cs
+++ b/src/Finance/Forecasting/Foundation/TimeLLM.cs
@@ -526,31 +526,6 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    /// <inheritdoc/>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> In the TimeLLM model, CreateNewInstance builds and wires up model components. This sets up the TimeLLM architecture before use.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var options = new TimeLLMOptions<T>
-        {
-            ContextLength = _contextLength,
-            ForecastHorizon = _forecastHorizon,
-            PatchLength = _patchLength,
-            PatchStride = _patchStride,
-            LLMDimension = _llmDimension,
-            NumPrototypes = _numPrototypes,
-            NumLayers = _numLayers,
-            NumHeads = _numHeads,
-            DropoutRate = _dropout,
-            LLMBackbone = _llmBackbone
-        };
-
-        return new TimeLLM<T>(Architecture, options, _numFeatures);
-    }
-
     /// <summary>
     /// Writes Time-LLM-specific configuration during serialization.
     /// </summary>
@@ -558,20 +533,7 @@ protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
     /// <para><b>For Beginners:</b> Saves all the configuration needed to reconstruct this model.
     /// </para>
     /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_contextLength);
-        writer.Write(_forecastHorizon);
-        writer.Write(_patchLength);
-        writer.Write(_patchStride);
-        writer.Write(_llmDimension);
-        writer.Write(_numPrototypes);
-        writer.Write(_numLayers);
-        writer.Write(_numHeads);
-        writer.Write(_dropout);
-        writer.Write(_numFeatures);
-        writer.Write(_llmBackbone);
-    }
+
 
     /// <summary>
     /// Reads Time-LLM-specific configuration during deserialization.
@@ -580,20 +542,7 @@ protected override void SerializeNetworkSpecificData(BinaryWriter writer)
     /// <para><b>For Beginners:</b> Loads the configuration that was saved during serialization.
     /// </para>
     /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _contextLength = reader.ReadInt32();
-        _forecastHorizon = reader.ReadInt32();
-        _patchLength = reader.ReadInt32();
-        _patchStride = reader.ReadInt32();
-        _llmDimension = reader.ReadInt32();
-        _numPrototypes = reader.ReadInt32();
-        _numLayers = reader.ReadInt32();
-        _numHeads = reader.ReadInt32();
-        _dropout = reader.ReadDouble();
-        _numFeatures = reader.ReadInt32();
-        _llmBackbone = reader.ReadString();
-    }
+
 
     #endregion
 
diff --git a/src/Finance/Forecasting/Foundation/TimeMAE.cs b/src/Finance/Forecasting/Foundation/TimeMAE.cs
index 0bc81985d0..eaab56a129 100644
--- a/src/Finance/Forecasting/Foundation/TimeMAE.cs
+++ b/src/Finance/Forecasting/Foundation/TimeMAE.cs
@@ -64,7 +64,7 @@ namespace AiDotNet.Finance.Forecasting.Foundation;
 [ModelComplexity(ModelComplexity.High)]
 [ResearchPaper("TimeMAE: Self-Supervised Representations of Time Series with Decoupled Masked Autoencoders", "https://arxiv.org/abs/2303.00320")]
     [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
-public class TimeMAE<T> : TimeSeriesFoundationModelBase<T>
+public partial class TimeMAE<T> : TimeSeriesFoundationModelBase<T>
 {
     #region Fields
 
@@ -285,56 +285,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var opts = new TimeMAEOptions<T>
-        {
-            ContextLength = _contextLength,
-            ForecastHorizon = _forecastHorizon,
-            PatchLength = _patchLength,
-            HiddenDimension = _hiddenDimension,
-            NumEncoderLayers = _numEncoderLayers,
-            NumDecoderLayers = _numDecoderLayers,
-            NumHeads = _numHeads,
-            MaskRatio = _maskRatio,
-            DropoutRate = _dropout,
-            LearningRate = _options.LearningRate
-        };
 
-        // Preserve ONNX mode if the original instance was created with an ONNX model
-        if (!_useNativeMode && OnnxModelPath is not null)
-            return new TimeMAE<T>(Architecture, OnnxModelPath, opts);
-
-        return new TimeMAE<T>(Architecture, opts);
-    }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_contextLength);
-        writer.Write(_forecastHorizon);
-        writer.Write(_patchLength);
-        writer.Write(_hiddenDimension);
-        writer.Write(_numEncoderLayers);
-        writer.Write(_numDecoderLayers);
-        writer.Write(_numHeads);
-        writer.Write(_maskRatio);
-        writer.Write(_dropout);
-    }
 
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _contextLength = reader.ReadInt32();
-        _forecastHorizon = reader.ReadInt32();
-        _patchLength = reader.ReadInt32();
-        _hiddenDimension = reader.ReadInt32();
-        _numEncoderLayers = reader.ReadInt32();
-        _numDecoderLayers = reader.ReadInt32();
-        _numHeads = reader.ReadInt32();
-        _maskRatio = reader.ReadDouble();
-        _dropout = reader.ReadDouble();
-    }
 
     #endregion
 
diff --git a/src/Finance/Forecasting/Foundation/TimeMoE.cs b/src/Finance/Forecasting/Foundation/TimeMoE.cs
index 5137a0c31c..dbcde2df3c 100644
--- a/src/Finance/Forecasting/Foundation/TimeMoE.cs
+++ b/src/Finance/Forecasting/Foundation/TimeMoE.cs
@@ -64,7 +64,7 @@ namespace AiDotNet.Finance.Forecasting.Foundation;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Time-MoE: Billion-Scale Time Series Foundation Models with Mixture of Experts", "https://arxiv.org/abs/2409.16040", Year = 2025, Authors = "Xiaoming Shi, Shiyu Wang, Yuqi Nie, Dianqi Li, Zhou Ye, Qingsong Wen, Ming Jin")]
-public class TimeMoE<T> : TimeSeriesFoundationModelBase<T>
+public partial class TimeMoE<T> : TimeSeriesFoundationModelBase<T>
 {
     #region Fields
 
@@ -275,55 +275,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new TimeMoE<T>(Architecture, new TimeMoEOptions<T>
-        {
-            ContextLength = _contextLength,
-            ForecastHorizon = _forecastHorizon,
-            PatchLength = _patchLength,
-            HiddenDimension = _hiddenDimension,
-            NumLayers = _numLayers,
-            NumHeads = _numHeads,
-            IntermediateSize = _intermediateSize,
-            DropoutRate = _dropout,
-            ModelSize = _modelSize,
-            NumExperts = _numExperts,
-            NumActiveExperts = _numActiveExperts
-        });
-    }
 
-    /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_contextLength);
-        writer.Write(_forecastHorizon);
-        writer.Write(_patchLength);
-        writer.Write(_hiddenDimension);
-        writer.Write(_numLayers);
-        writer.Write(_numHeads);
-        writer.Write(_intermediateSize);
-        writer.Write(_dropout);
-        writer.Write((int)_modelSize);
-        writer.Write(_numExperts);
-        writer.Write(_numActiveExperts);
-    }
 
     /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _contextLength = reader.ReadInt32();
-        _forecastHorizon = reader.ReadInt32();
-        _patchLength = reader.ReadInt32();
-        _hiddenDimension = reader.ReadInt32();
-        _numLayers = reader.ReadInt32();
-        _numHeads = reader.ReadInt32();
-        _intermediateSize = reader.ReadInt32();
-        _dropout = reader.ReadDouble();
-        _modelSize = (FoundationModelSize)reader.ReadInt32();
-        _numExperts = reader.ReadInt32();
-        _numActiveExperts = reader.ReadInt32();
-    }
+
 
     #endregion
 
diff --git a/src/Finance/Forecasting/Foundation/Timer.cs b/src/Finance/Forecasting/Foundation/Timer.cs
index 21891a5c14..18505ea2e7 100644
--- a/src/Finance/Forecasting/Foundation/Timer.cs
+++ b/src/Finance/Forecasting/Foundation/Timer.cs
@@ -583,32 +583,6 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    /// <inheritdoc/>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> In the Timer model, CreateNewInstance builds and wires up model components. This sets up the Timer architecture before use.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var options = new TimerOptions<T>
-        {
-            ContextLength = _contextLength,
-            ForecastHorizon = _forecastHorizon,
-            PatchLength = _patchLength,
-            PatchStride = _patchStride,
-            HiddenDimension = _hiddenDimension,
-            NumLayers = _numLayers,
-            NumHeads = _numHeads,
-            DropoutRate = _dropout,
-            MaskRatio = _maskRatio,
-            UseAutoregressiveDecoding = _useAutoregressiveDecoding,
-            GenerationTemperature = _generationTemperature
-        };
-
-        return new Timer<T>(Architecture, options, _numFeatures);
-    }
-
     /// <summary>
     /// Writes Timer-specific configuration during serialization.
     /// </summary>
@@ -616,21 +590,7 @@ protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
     /// <para><b>For Beginners:</b> Saves all the configuration needed to reconstruct this model.
     /// </para>
     /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_contextLength);
-        writer.Write(_forecastHorizon);
-        writer.Write(_patchLength);
-        writer.Write(_patchStride);
-        writer.Write(_hiddenDimension);
-        writer.Write(_numLayers);
-        writer.Write(_numHeads);
-        writer.Write(_dropout);
-        writer.Write(_maskRatio);
-        writer.Write(_useAutoregressiveDecoding);
-        writer.Write(_generationTemperature);
-        writer.Write(_numFeatures);
-    }
+
 
     /// <summary>
     /// Reads Timer-specific configuration during deserialization.
@@ -639,26 +599,7 @@ protected override void SerializeNetworkSpecificData(BinaryWriter writer)
     /// <para><b>For Beginners:</b> Loads the configuration that was saved during serialization.
     /// </para>
     /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _contextLength = reader.ReadInt32();
-        _forecastHorizon = reader.ReadInt32();
-        _patchLength = reader.ReadInt32();
-        _patchStride = reader.ReadInt32();
-        _hiddenDimension = reader.ReadInt32();
-        _numLayers = reader.ReadInt32();
-        _numHeads = reader.ReadInt32();
-        _dropout = reader.ReadDouble();
-        _maskRatio = reader.ReadDouble();
-        _useAutoregressiveDecoding = reader.ReadBoolean();
-        _generationTemperature = reader.ReadDouble();
-        _numFeatures = reader.ReadInt32();
-
-        // Recompute _numPatches from deserialized values to keep derived field in sync
-        // Use same logic as constructor: (_contextLength - _patchLength) / _patchStride + 1
-        int computedPatches = (_contextLength - _patchLength) / _patchStride + 1;
-        _numPatches = Math.Max(0, computedPatches); // Clamp to zero if negative
-    }
+
 
     #endregion
 
diff --git a/src/Finance/Forecasting/Foundation/TimesFM.cs b/src/Finance/Forecasting/Foundation/TimesFM.cs
index 74b9709f35..343fbf6622 100644
--- a/src/Finance/Forecasting/Foundation/TimesFM.cs
+++ b/src/Finance/Forecasting/Foundation/TimesFM.cs
@@ -624,34 +624,6 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    /// <summary>
-    /// Creates a new instance of this model with the same configuration.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Creates a fresh copy of the TimesFM architecture.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var options = new TimesFMOptions<T>
-        {
-            ContextLength = _contextLength,
-            ForecastHorizon = _forecastHorizon,
-            PatchLength = _patchLength,
-            HiddenDimension = _hiddenDimension,
-            NumLayers = _numLayers,
-            NumHeads = _numHeads,
-            DropoutRate = _dropout,
-            UsePretrainedWeights = _usePretrainedWeights,
-            OutputPatchLength = _outputPatchLength,
-            NumQuantiles = _numQuantiles,
-            QuantileHeadDimension = _quantileHeadDimension
-        };
-
-        return new TimesFM<T>(Architecture, options);
-    }
-
     /// <summary>
     /// Writes TimesFM-specific configuration during serialization.
     /// </summary>
@@ -660,21 +632,7 @@ protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
     /// <b>For Beginners:</b> Saves all the configuration needed to reconstruct this model.
     /// </para>
     /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_contextLength);
-        writer.Write(_forecastHorizon);
-        writer.Write(_patchLength);
-        writer.Write(_hiddenDimension);
-        writer.Write(_numLayers);
-        writer.Write(_numHeads);
-        writer.Write(_dropout);
-        writer.Write(_usePretrainedWeights);
-        writer.Write(_outputPatchLength);
-        // TimesFM 2.5 fields
-        writer.Write(_numQuantiles);
-        writer.Write(_quantileHeadDimension);
-    }
+
 
     /// <summary>
     /// Reads TimesFM-specific configuration during deserialization.
@@ -684,21 +642,7 @@ protected override void SerializeNetworkSpecificData(BinaryWriter writer)
     /// <b>For Beginners:</b> Loads the configuration that was saved during serialization.
     /// </para>
     /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _contextLength = reader.ReadInt32();
-        _forecastHorizon = reader.ReadInt32();
-        _patchLength = reader.ReadInt32();
-        _hiddenDimension = reader.ReadInt32();
-        _numLayers = reader.ReadInt32();
-        _numHeads = reader.ReadInt32();
-        _dropout = reader.ReadDouble();
-        _usePretrainedWeights = reader.ReadBoolean();
-        _outputPatchLength = reader.ReadInt32();
-        // TimesFM 2.5 fields
-        _numQuantiles = reader.ReadInt32();
-        _quantileHeadDimension = reader.ReadInt32();
-    }
+
 
     #endregion
 
diff --git a/src/Finance/Forecasting/Foundation/TinyTimeMixers.cs b/src/Finance/Forecasting/Foundation/TinyTimeMixers.cs
index b0154c8e50..1a0e08bb67 100644
--- a/src/Finance/Forecasting/Foundation/TinyTimeMixers.cs
+++ b/src/Finance/Forecasting/Foundation/TinyTimeMixers.cs
@@ -82,7 +82,7 @@ namespace AiDotNet.Finance.Forecasting.Foundation;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Tiny Time Mixers (TTMs): Fast Pre-trained Models for Enhanced Zero/Few-Shot Forecasting of Multivariate Time Series", "https://arxiv.org/abs/2401.03955", Year = 2024, Authors = "Vijay Ekambaram, Arindam Jati, Nam H. Nguyen, Phanwadee Sinthong, Jayant Kalagnanam")]
-public class TinyTimeMixers<T> : TimeSeriesFoundationModelBase<T>
+public partial class TinyTimeMixers<T> : TimeSeriesFoundationModelBase<T>
 {
     #region Execution Mode
 
@@ -358,57 +358,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var options = new TinyTimeMixersOptions<T>
-        {
-            ContextLength = _contextLength,
-            ForecastHorizon = _forecastHorizon,
-            PatchLength = _patchLength,
-            HiddenDimension = _hiddenDimension,
-            NumMixerLayers = _numMixerLayers,
-            ExpansionFactor = _expansionFactor,
-            DropoutRate = _dropout,
-            ModelSize = _modelSize,
-            UseAdaptivePatching = _useAdaptivePatching,
-            NumFeatures = _numFeatures
-        };
 
-        return new TinyTimeMixers<T>(Architecture, options);
-    }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_contextLength);
-        writer.Write(_forecastHorizon);
-        writer.Write(_patchLength);
-        writer.Write(_hiddenDimension);
-        writer.Write(_numMixerLayers);
-        writer.Write(_expansionFactor);
-        writer.Write(_dropout);
-        writer.Write((int)_modelSize);
-        writer.Write(_useAdaptivePatching.HasValue);
-        if (_useAdaptivePatching.HasValue)
-            writer.Write(_useAdaptivePatching.Value);
-        writer.Write(_numFeatures);
-    }
 
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _contextLength = reader.ReadInt32();
-        _forecastHorizon = reader.ReadInt32();
-        _patchLength = reader.ReadInt32();
-        _hiddenDimension = reader.ReadInt32();
-        _numMixerLayers = reader.ReadInt32();
-        _expansionFactor = reader.ReadInt32();
-        _dropout = reader.ReadDouble();
-        _modelSize = (FoundationModelSize)reader.ReadInt32();
-        bool hasAdaptive = reader.ReadBoolean();
-        _useAdaptivePatching = hasAdaptive ? reader.ReadBoolean() : null;
-        _numFeatures = reader.ReadInt32();
-    }
 
     #endregion
 
diff --git a/src/Finance/Forecasting/Foundation/UniTS.cs b/src/Finance/Forecasting/Foundation/UniTS.cs
index 8acee137cc..3773eb92bd 100644
--- a/src/Finance/Forecasting/Foundation/UniTS.cs
+++ b/src/Finance/Forecasting/Foundation/UniTS.cs
@@ -516,30 +516,6 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    /// <inheritdoc/>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> In the UniTS model, CreateNewInstance builds and wires up model components. This sets up the UniTS architecture before use.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var options = new UniTSOptions<T>
-        {
-            ContextLength = _contextLength,
-            ForecastHorizon = _forecastHorizon,
-            HiddenDimension = _hiddenDimension,
-            NumLayers = _numLayers,
-            NumHeads = _numHeads,
-            ConvKernelSizes = _convKernelSizes,
-            DropoutRate = _dropout,
-            TaskType = _taskType,
-            NumClasses = _numClasses
-        };
-
-        return new UniTS<T>(Architecture, options, _numFeatures);
-    }
-
     /// <summary>
     /// Writes UniTS-specific configuration during serialization.
     /// </summary>
@@ -548,23 +524,7 @@ protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
     /// including task type and multi-scale convolution settings.
     /// </para>
     /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_contextLength);
-        writer.Write(_forecastHorizon);
-        writer.Write(_hiddenDimension);
-        writer.Write(_numLayers);
-        writer.Write(_numHeads);
-        writer.Write(_convKernelSizes.Length);
-        foreach (var kernelSize in _convKernelSizes)
-        {
-            writer.Write(kernelSize);
-        }
-        writer.Write(_dropout);
-        writer.Write(_taskType);
-        writer.Write(_numClasses);
-        writer.Write(_numFeatures);
-    }
+
 
     /// <summary>
     /// Reads UniTS-specific configuration during deserialization.
@@ -574,24 +534,7 @@ protected override void SerializeNetworkSpecificData(BinaryWriter writer)
     /// restoring the model to its original state.
     /// </para>
     /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _contextLength = reader.ReadInt32();
-        _forecastHorizon = reader.ReadInt32();
-        _hiddenDimension = reader.ReadInt32();
-        _numLayers = reader.ReadInt32();
-        _numHeads = reader.ReadInt32();
-        int kernelCount = reader.ReadInt32();
-        _convKernelSizes = new int[kernelCount];
-        for (int i = 0; i < kernelCount; i++)
-        {
-            _convKernelSizes[i] = reader.ReadInt32();
-        }
-        _dropout = reader.ReadDouble();
-        _taskType = reader.ReadString();
-        _numClasses = reader.ReadInt32();
-        _numFeatures = reader.ReadInt32();
-    }
+
 
     #endregion
 
diff --git a/src/Finance/Forecasting/Foundation/VisionTS.cs b/src/Finance/Forecasting/Foundation/VisionTS.cs
index 6f3106ac4f..e6f5ecdeb1 100644
--- a/src/Finance/Forecasting/Foundation/VisionTS.cs
+++ b/src/Finance/Forecasting/Foundation/VisionTS.cs
@@ -65,7 +65,7 @@ namespace AiDotNet.Finance.Forecasting.Foundation;
 [ModelComplexity(ModelComplexity.High)]
 [ResearchPaper("VisionTS: Visual Masked Autoencoders as Zero-Shot Time Series Forecasters", "https://arxiv.org/abs/2408.17253")]
     [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
-public class VisionTS<T> : TimeSeriesFoundationModelBase<T>
+public partial class VisionTS<T> : TimeSeriesFoundationModelBase<T>
 {
     #region Fields
 
@@ -277,57 +277,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var opts = new VisionTSOptions<T>
-        {
-            ContextLength = _contextLength,
-            ForecastHorizon = _forecastHorizon,
-            PatchLength = _patchLength,
-            HiddenDimension = _hiddenDimension,
-            NumLayers = _numLayers,
-            NumHeads = _numHeads,
-            IntermediateSize = _intermediateSize,
-            DropoutRate = _dropout,
-            ModelSize = _modelSize,
-            MaskRatio = _maskRatio
-        };
 
-        if (!_useNativeMode && OnnxModelPath is not null)
-            return new VisionTS<T>(Architecture, OnnxModelPath, opts);
-
-        return new VisionTS<T>(Architecture, opts);
-    }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_contextLength);
-        writer.Write(_forecastHorizon);
-        writer.Write(_patchLength);
-        writer.Write(_hiddenDimension);
-        writer.Write(_numLayers);
-        writer.Write(_numHeads);
-        writer.Write(_intermediateSize);
-        writer.Write(_dropout);
-        writer.Write((int)_modelSize);
-        writer.Write(_maskRatio);
-    }
 
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _contextLength = reader.ReadInt32();
-        _forecastHorizon = reader.ReadInt32();
-        _patchLength = reader.ReadInt32();
-        _hiddenDimension = reader.ReadInt32();
-        _numLayers = reader.ReadInt32();
-        _numHeads = reader.ReadInt32();
-        _intermediateSize = reader.ReadInt32();
-        _dropout = reader.ReadDouble();
-        _modelSize = (FoundationModelSize)reader.ReadInt32();
-        _maskRatio = reader.ReadDouble();
-    }
 
     #endregion
 
diff --git a/src/Finance/Forecasting/Foundation/YingLong.cs b/src/Finance/Forecasting/Foundation/YingLong.cs
index c378512c05..6fd07336e4 100644
--- a/src/Finance/Forecasting/Foundation/YingLong.cs
+++ b/src/Finance/Forecasting/Foundation/YingLong.cs
@@ -59,7 +59,7 @@ namespace AiDotNet.Finance.Forecasting.Foundation;
 [ModelComplexity(ModelComplexity.High)]
 [ResearchPaper("Output Scaling: YingLong-Delayed Chain of Thought in a Large Pretrained Time Series Forecasting Model", "https://arxiv.org/abs/2506.11029")]
     [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
-public class YingLong<T> : TimeSeriesFoundationModelBase<T>
+public partial class YingLong<T> : TimeSeriesFoundationModelBase<T>
 {
     #region Fields
 
@@ -296,51 +296,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var clonedOptions = new YingLongOptions<T>(_options)
-        {
-            ContextLength = _contextLength,
-            ForecastHorizon = _forecastHorizon,
-            PatchLength = _patchLength,
-            HiddenDimension = _hiddenDimension,
-            NumLayers = _numLayers,
-            NumHeads = _numHeads,
-            IntermediateSize = _intermediateSize,
-            DropoutRate = _dropout,
-            ModelSize = _modelSize
-        };
 
-        return new YingLong<T>(Architecture, clonedOptions);
-    }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_contextLength);
-        writer.Write(_forecastHorizon);
-        writer.Write(_patchLength);
-        writer.Write(_hiddenDimension);
-        writer.Write(_numLayers);
-        writer.Write(_numHeads);
-        writer.Write(_intermediateSize);
-        writer.Write(_dropout);
-        writer.Write((int)_modelSize);
-    }
 
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _contextLength = reader.ReadInt32();
-        _forecastHorizon = reader.ReadInt32();
-        _patchLength = reader.ReadInt32();
-        _hiddenDimension = reader.ReadInt32();
-        _numLayers = reader.ReadInt32();
-        _numHeads = reader.ReadInt32();
-        _intermediateSize = reader.ReadInt32();
-        _dropout = reader.ReadDouble();
-        _modelSize = (FoundationModelSize)reader.ReadInt32();
-    }
 
     #endregion
 
diff --git a/src/Finance/Forecasting/Neural/DeepAR.cs b/src/Finance/Forecasting/Neural/DeepAR.cs
index dd981717bf..7fcec318ce 100644
--- a/src/Finance/Forecasting/Neural/DeepAR.cs
+++ b/src/Finance/Forecasting/Neural/DeepAR.cs
@@ -516,48 +516,6 @@ public override ModelMetadata<T> GetModelMetadata()
         return metadata;
     }
 
-    /// <summary>
-    /// Creates a new instance of this model with the same configuration.
-    /// </summary>
-    /// <returns>A new DeepAR model instance.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> This creates a fresh copy of the model with the same settings
-    /// but new (randomly initialized) weights. Useful for ensemble training or cross-validation.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var options = new DeepAROptions<T>
-        {
-            LookbackWindow = SequenceLength,
-            ForecastHorizon = PredictionHorizon,
-            HiddenSize = _hiddenSize,
-            NumLayers = _numLstmLayers,
-            EmbeddingDimension = _embeddingDim,
-            DropoutRate = _dropout,
-            LikelihoodType = _distributionType,
-            NumSamples = _numSamples
-        };
-
-        if (UseNativeMode)
-        {
-            return new DeepAR<T>(Architecture, options, _optimizer, LossFunction);
-        }
-        else
-        {
-            // Use null-coalescing throw to satisfy null analysis across all framework targets
-            string onnxPath = OnnxModelPath ?? throw new InvalidOperationException(
-                "Cannot create new instance from ONNX mode when OnnxModelPath is not available.");
-            if (onnxPath.Length == 0)
-            {
-                throw new InvalidOperationException(
-                    "Cannot create new instance from ONNX mode when OnnxModelPath is empty.");
-            }
-            return new DeepAR<T>(Architecture, onnxPath, options, _optimizer, LossFunction);
-        }
-    }
-
     /// <summary>
     /// Writes DeepAR-specific configuration during serialization.
     /// </summary>
@@ -568,16 +526,7 @@ protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
     /// to a file so the model can be loaded later with the same configuration.
     /// </para>
     /// </remarks>
-    protected override void SerializeModelSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_hiddenSize);
-        writer.Write(_numLstmLayers);
-        writer.Write(_embeddingDim);
-        writer.Write(_dropout);
-        writer.Write(_distributionType);
-        writer.Write(_numSamples);
-        writer.Write(_useScaling);
-    }
+
 
     /// <summary>
     /// Reads DeepAR-specific configuration during deserialization.
@@ -589,25 +538,7 @@ protected override void SerializeModelSpecificData(BinaryWriter writer)
     /// The values advance the reader but aren't used since constructor sets them.
     /// </para>
     /// </remarks>
-    protected override void DeserializeModelSpecificData(BinaryReader reader)
-    {
-        _hiddenSize = reader.ReadInt32();
-        _numLstmLayers = reader.ReadInt32();
-        _embeddingDim = reader.ReadInt32();
-        _dropout = reader.ReadDouble();
-        _distributionType = reader.ReadString();
-        _numSamples = reader.ReadInt32();
-        _useScaling = reader.ReadBoolean();
-
-        // Re-bind the cached layer references (_inputProjection, _lstmLayers,
-        // _muProjection, _sigmaProjection, _layerNorm) to the layers the base
-        // deserializer just rebuilt with the loaded weights. Without this the
-        // references still point at the construction-time fresh-init layers, so
-        // Forward (and therefore Predict / a clone) ran on RANDOM weights rather
-        // than the deserialized ones — Clone_ShouldProduceIdenticalOutput saw the
-        // original vs a randomly-initialized clone.
-        ExtractLayerReferences();
-    }
+
 
     #endregion
 
diff --git a/src/Finance/Forecasting/Neural/DeepFactor.cs b/src/Finance/Forecasting/Neural/DeepFactor.cs
index 3838c8cd47..cb8ee85e3e 100644
--- a/src/Finance/Forecasting/Neural/DeepFactor.cs
+++ b/src/Finance/Forecasting/Neural/DeepFactor.cs
@@ -566,46 +566,6 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    /// <summary>
-    /// Creates a new instance of this model with the same configuration.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Creates a fresh copy of the model architecture.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var options = new DeepFactorOptions<T>
-        {
-            LookbackWindow = _lookbackWindow,
-            ForecastHorizon = _forecastHorizon,
-            NumFactors = _numFactors,
-            FactorHiddenDimension = _factorHiddenDim,
-            LocalHiddenDimension = _localHiddenDim,
-            NumFactorLayers = _numFactorLayers,
-            NumLocalLayers = _numLocalLayers,
-            DropoutRate = _dropout
-        };
-
-        if (_useNativeMode)
-        {
-            return new DeepFactor<T>(Architecture, options);
-        }
-        else
-        {
-            // Use null-coalescing throw to satisfy null analysis across all framework targets
-            string onnxPath = OnnxModelPath ?? throw new InvalidOperationException(
-                "Cannot create new instance from ONNX mode when OnnxModelPath is not available.");
-            if (onnxPath.Length == 0)
-            {
-                throw new InvalidOperationException(
-                    "Cannot create new instance from ONNX mode when OnnxModelPath is empty.");
-            }
-            return new DeepFactor<T>(Architecture, onnxPath, options);
-        }
-    }
-
     /// <summary>
     /// Writes DeepFactor-specific configuration during serialization.
     /// </summary>
@@ -614,18 +574,7 @@ protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
     /// <b>For Beginners:</b> Saves all the configuration needed to reconstruct this model.
     /// </para>
     /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_lookbackWindow);
-        writer.Write(_forecastHorizon);
-        writer.Write(_numFeatures);
-        writer.Write(_numFactors);
-        writer.Write(_factorHiddenDim);
-        writer.Write(_localHiddenDim);
-        writer.Write(_numFactorLayers);
-        writer.Write(_numLocalLayers);
-        writer.Write(_dropout);
-    }
+
 
     /// <summary>
     /// Reads DeepFactor-specific configuration during deserialization.
@@ -635,22 +584,7 @@ protected override void SerializeNetworkSpecificData(BinaryWriter writer)
     /// <b>For Beginners:</b> Loads the configuration that was saved during serialization.
     /// </para>
     /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _lookbackWindow = reader.ReadInt32();
-        _forecastHorizon = reader.ReadInt32();
-        _numFeatures = reader.ReadInt32();
-        _numFactors = reader.ReadInt32();
-        _factorHiddenDim = reader.ReadInt32();
-        _localHiddenDim = reader.ReadInt32();
-        _numFactorLayers = reader.ReadInt32();
-        _numLocalLayers = reader.ReadInt32();
-        _dropout = reader.ReadDouble();
-
-        // Re-bind cached layer references so a deserialized/cloned model runs on
-        // the restored layers, not the construction-time random ones.
-        ExtractLayerReferences();
-    }
+
 
     #endregion
 
diff --git a/src/Finance/Forecasting/Neural/DeepState.cs b/src/Finance/Forecasting/Neural/DeepState.cs
index d11480c005..b2ddf7b105 100644
--- a/src/Finance/Forecasting/Neural/DeepState.cs
+++ b/src/Finance/Forecasting/Neural/DeepState.cs
@@ -560,47 +560,6 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    /// <summary>
-    /// Creates a new instance of this model with the same configuration.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Creates a fresh copy of the model architecture.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var options = new DeepStateOptions<T>
-        {
-            LookbackWindow = _lookbackWindow,
-            ForecastHorizon = _forecastHorizon,
-            StateDimension = _stateDimension,
-            HiddenDimension = _hiddenDimension,
-            NumRnnLayers = _numRnnLayers,
-            SeasonalPeriods = _seasonalPeriods,
-            UseTrend = _useTrend,
-            UseSeasonality = _useSeasonality,
-            DropoutRate = _dropout
-        };
-
-        if (_useNativeMode)
-        {
-            return new DeepState<T>(Architecture, options);
-        }
-        else
-        {
-            // Use null-coalescing throw to satisfy null analysis across all framework targets
-            string onnxPath = OnnxModelPath ?? throw new InvalidOperationException(
-                "Cannot create new instance from ONNX mode when OnnxModelPath is not available.");
-            if (onnxPath.Length == 0)
-            {
-                throw new InvalidOperationException(
-                    "Cannot create new instance from ONNX mode when OnnxModelPath is empty.");
-            }
-            return new DeepState<T>(Architecture, onnxPath, options);
-        }
-    }
-
     /// <summary>
     /// Writes DeepState-specific configuration during serialization.
     /// </summary>
@@ -609,21 +568,7 @@ protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
     /// <b>For Beginners:</b> Saves all the configuration needed to reconstruct this model.
     /// </para>
     /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_lookbackWindow);
-        writer.Write(_forecastHorizon);
-        writer.Write(_numFeatures);
-        writer.Write(_stateDimension);
-        writer.Write(_hiddenDimension);
-        writer.Write(_numRnnLayers);
-        writer.Write(_seasonalPeriods.Length);
-        foreach (var period in _seasonalPeriods)
-            writer.Write(period);
-        writer.Write(_useTrend);
-        writer.Write(_useSeasonality);
-        writer.Write(_dropout);
-    }
+
 
     /// <summary>
     /// Reads DeepState-specific configuration during deserialization.
@@ -633,26 +578,7 @@ protected override void SerializeNetworkSpecificData(BinaryWriter writer)
     /// <b>For Beginners:</b> Loads the configuration that was saved during serialization.
     /// </para>
     /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _lookbackWindow = reader.ReadInt32();
-        _forecastHorizon = reader.ReadInt32();
-        _numFeatures = reader.ReadInt32();
-        _stateDimension = reader.ReadInt32();
-        _hiddenDimension = reader.ReadInt32();
-        _numRnnLayers = reader.ReadInt32();
-        int numPeriods = reader.ReadInt32();
-        _seasonalPeriods = new int[numPeriods];
-        for (int i = 0; i < numPeriods; i++)
-            _seasonalPeriods[i] = reader.ReadInt32();
-        _useTrend = reader.ReadBoolean();
-        _useSeasonality = reader.ReadBoolean();
-        _dropout = reader.ReadDouble();
-
-        // Re-bind cached layer references so a deserialized/cloned model runs on
-        // the restored layers, not the construction-time random ones.
-        ExtractLayerReferences();
-    }
+
 
     #endregion
 
diff --git a/src/Finance/Forecasting/Neural/LSTNet.cs b/src/Finance/Forecasting/Neural/LSTNet.cs
index ea5bd2de81..5330120675 100644
--- a/src/Finance/Forecasting/Neural/LSTNet.cs
+++ b/src/Finance/Forecasting/Neural/LSTNet.cs
@@ -595,35 +595,6 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    /// <summary>
-    /// Creates a new instance of this model with the same configuration.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> This creates a fresh copy of the model with the same
-    /// settings but randomly initialized weights. Useful for techniques like
-    /// ensemble learning.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var options = new LSTNetOptions<T>
-        {
-            LookbackWindow = _lookbackWindow,
-            ForecastHorizon = _forecastHorizon,
-            HiddenRecurrentSize = _hiddenRecurrentSize,
-            HiddenSkipSize = _hiddenSkipSize,
-            ConvolutionFilters = _convolutionFilters,
-            ConvolutionKernelSize = _convolutionKernelSize,
-            SkipPeriod = _skipPeriod,
-            AutoregressiveWindow = _autoregressiveWindow,
-            UseHighway = _useHighway,
-            DropoutRate = _dropout
-        };
-
-        return new LSTNet<T>(Architecture, options);
-    }
-
     /// <summary>
     /// Writes LSTNet-specific configuration during serialization.
     /// </summary>
@@ -633,20 +604,7 @@ protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
     /// loaded later. This method saves all the configuration values.
     /// </para>
     /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_lookbackWindow);
-        writer.Write(_forecastHorizon);
-        writer.Write(_numFeatures);
-        writer.Write(_hiddenRecurrentSize);
-        writer.Write(_hiddenSkipSize);
-        writer.Write(_convolutionFilters);
-        writer.Write(_convolutionKernelSize);
-        writer.Write(_skipPeriod);
-        writer.Write(_autoregressiveWindow);
-        writer.Write(_useHighway);
-        writer.Write(_dropout);
-    }
+
 
     /// <summary>
     /// Reads LSTNet-specific configuration during deserialization.
@@ -656,25 +614,7 @@ protected override void SerializeNetworkSpecificData(BinaryWriter writer)
     /// <b>For Beginners:</b> This reads back the configuration when loading a saved model.
     /// </para>
     /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _lookbackWindow = reader.ReadInt32();
-        _forecastHorizon = reader.ReadInt32();
-        _numFeatures = reader.ReadInt32();
-        _hiddenRecurrentSize = reader.ReadInt32();
-        _hiddenSkipSize = reader.ReadInt32();
-        _convolutionFilters = reader.ReadInt32();
-        _convolutionKernelSize = reader.ReadInt32();
-        _skipPeriod = reader.ReadInt32();
-        _autoregressiveWindow = reader.ReadInt32();
-        _useHighway = reader.ReadBoolean();
-        _dropout = reader.ReadDouble();
-
-        // Re-bind cached layer references to the deserialized (weight-loaded)
-        // layers so a clone runs on the loaded weights, not construction-time
-        // random init (ExtractLayerReferences uses direct assignment, idempotent).
-        ExtractLayerReferences();
-    }
+
 
     #endregion
 
diff --git a/src/Finance/Forecasting/Neural/MQCNN.cs b/src/Finance/Forecasting/Neural/MQCNN.cs
index 8bba7419ef..40cb6cd2b8 100644
--- a/src/Finance/Forecasting/Neural/MQCNN.cs
+++ b/src/Finance/Forecasting/Neural/MQCNN.cs
@@ -741,32 +741,6 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    /// <summary>
-    /// Creates a new instance of this model with the same configuration.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Creates a fresh copy of the model architecture,
-    /// useful for ensemble methods or hyperparameter search.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var options = new MQCNNOptions<T>
-        {
-            LookbackWindow = _lookbackWindow,
-            ForecastHorizon = _forecastHorizon,
-            Quantiles = _quantiles,
-            EncoderChannels = _encoderChannels,
-            DecoderChannels = _decoderChannels,
-            NumEncoderLayers = _numEncoderLayers,
-            NumDecoderLayers = _numDecoderLayers,
-            DropoutRate = _dropout
-        };
-
-        return new MQCNN<T>(Architecture, options);
-    }
-
     /// <summary>
     /// Writes MQCNN-specific configuration during serialization.
     /// </summary>
@@ -775,20 +749,7 @@ protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
     /// <b>For Beginners:</b> Saves all the configuration needed to reconstruct this model.
     /// </para>
     /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_lookbackWindow);
-        writer.Write(_forecastHorizon);
-        writer.Write(_numFeatures);
-        writer.Write(_quantiles.Length);
-        foreach (var q in _quantiles)
-            writer.Write(q);
-        writer.Write(_encoderChannels);
-        writer.Write(_decoderChannels);
-        writer.Write(_numEncoderLayers);
-        writer.Write(_numDecoderLayers);
-        writer.Write(_dropout);
-    }
+
 
     /// <summary>
     /// Reads MQCNN-specific configuration during deserialization.
@@ -798,26 +759,7 @@ protected override void SerializeNetworkSpecificData(BinaryWriter writer)
     /// <b>For Beginners:</b> Loads the configuration that was saved during serialization.
     /// </para>
     /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _lookbackWindow = reader.ReadInt32();
-        _forecastHorizon = reader.ReadInt32();
-        _numFeatures = reader.ReadInt32();
-        int numQuantiles = reader.ReadInt32();
-        _quantiles = new double[numQuantiles];
-        for (int i = 0; i < numQuantiles; i++)
-            _quantiles[i] = reader.ReadDouble();
-        _encoderChannels = reader.ReadInt32();
-        _decoderChannels = reader.ReadInt32();
-        _numEncoderLayers = reader.ReadInt32();
-        _numDecoderLayers = reader.ReadInt32();
-        _dropout = reader.ReadDouble();
-
-        // Re-point cached layer references at the freshly deserialized Layers;
-        // otherwise a clone's forward uses the stale random-initialized layers
-        // created by CreateNewInstance and diverges from the original.
-        ExtractLayerReferences();
-    }
+
 
     #endregion
 
diff --git a/src/Finance/Forecasting/Neural/NBEATSFinance.cs b/src/Finance/Forecasting/Neural/NBEATSFinance.cs
index e606861d6c..5c896f98e2 100644
--- a/src/Finance/Forecasting/Neural/NBEATSFinance.cs
+++ b/src/Finance/Forecasting/Neural/NBEATSFinance.cs
@@ -592,21 +592,6 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    /// <summary>
-    /// Creates a new instance of this model with the same configuration.
-    /// </summary>
-    /// <returns>A new N-BEATS model instance.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> This creates a fresh copy of the model with the same settings
-    /// but new (randomly initialized) weights.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new NBEATSFinance<T>(Architecture, new NBEATSModelOptions<T>(_options));
-    }
-
     private IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>> CreateDefaultOptimizer()
     {
         bool clipGradients = _options.GradientClipNorm > 0.0;
@@ -637,18 +622,7 @@ private IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>> CreateDefaultOptimizer(
     /// can be loaded later with the same configuration.
     /// </para>
     /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_lookbackWindow);
-        writer.Write(_forecastHorizon);
-        writer.Write(_numStacks);
-        writer.Write(_numBlocksPerStack);
-        writer.Write(_hiddenSize);
-        writer.Write(_numHiddenLayers);
-        writer.Write(_polynomialDegree);
-        writer.Write(_useInterpretableBasis);
-        writer.Write(_shareWeightsInStack);
-    }
+
 
     /// <summary>
     /// Reads N-BEATS-specific configuration during deserialization.
@@ -659,31 +633,7 @@ protected override void SerializeNetworkSpecificData(BinaryWriter writer)
     /// <b>For Beginners:</b> This reads back N-BEATS settings when loading a saved model.
     /// </para>
     /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _lookbackWindow = reader.ReadInt32();
-        _forecastHorizon = reader.ReadInt32();
-        _numStacks = reader.ReadInt32();
-        _numBlocksPerStack = reader.ReadInt32();
-        _hiddenSize = reader.ReadInt32();
-        _numHiddenLayers = reader.ReadInt32();
-        _polynomialDegree = reader.ReadInt32();
-        _useInterpretableBasis = reader.ReadBoolean();
-        _shareWeightsInStack = reader.ReadBoolean();
-
-        // Validate deserialized values
-        if (_lookbackWindow < 1)
-            throw new InvalidOperationException($"Deserialized lookbackWindow ({_lookbackWindow}) must be at least 1.");
-        if (_forecastHorizon < 1)
-            throw new InvalidOperationException($"Deserialized forecastHorizon ({_forecastHorizon}) must be at least 1.");
-        if (_numStacks < 1)
-            throw new InvalidOperationException($"Deserialized numStacks ({_numStacks}) must be at least 1.");
-        if (_numBlocksPerStack < 1)
-            throw new InvalidOperationException($"Deserialized numBlocksPerStack ({_numBlocksPerStack}) must be at least 1.");
-
-        // Extract layer references from deserialized layers
-        ExtractLayerReferences();
-    }
+
 
     #endregion
 
diff --git a/src/Finance/Forecasting/Neural/NHiTSFinance.cs b/src/Finance/Forecasting/Neural/NHiTSFinance.cs
index 2e97aee93a..bab0f37747 100644
--- a/src/Finance/Forecasting/Neural/NHiTSFinance.cs
+++ b/src/Finance/Forecasting/Neural/NHiTSFinance.cs
@@ -657,19 +657,6 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    /// <summary>
-    /// Creates a new instance of this model with the same configuration.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> In the NHiTSFinance model, CreateNewInstance builds and wires up model components. This sets up the NHiTSFinance architecture before use.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new NHiTSFinance<T>(Architecture, new NHiTSOptions<T>(_options));
-    }
-
     /// <summary>
     /// Writes N-HiTS-specific configuration during serialization.
     /// </summary>
@@ -678,19 +665,7 @@ protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
     /// <b>For Beginners:</b> In the NHiTSFinance model, SerializeNetworkSpecificData saves or restores model-specific settings. This lets the NHiTSFinance architecture be reused later.
     /// </para>
     /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_lookbackWindow);
-        writer.Write(_forecastHorizon);
-        writer.Write(_numStacks);
-        writer.Write(_numBlocksPerStack);
-        writer.Write(_hiddenSize);
-        writer.Write(_numHiddenLayers);
-        writer.Write(_poolingKernelSizes.Length);
-        foreach (var k in _poolingKernelSizes)
-            writer.Write(k);
-        writer.Write(_dropout);
-    }
+
 
     /// <summary>
     /// Reads N-HiTS-specific configuration during deserialization.
@@ -700,24 +675,7 @@ protected override void SerializeNetworkSpecificData(BinaryWriter writer)
     /// <b>For Beginners:</b> In the NHiTSFinance model, DeserializeNetworkSpecificData saves or restores model-specific settings. This lets the NHiTSFinance architecture be reused later.
     /// </para>
     /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _lookbackWindow = reader.ReadInt32();
-        _forecastHorizon = reader.ReadInt32();
-        _numStacks = reader.ReadInt32();
-        _numBlocksPerStack = reader.ReadInt32();
-        _hiddenSize = reader.ReadInt32();
-        _numHiddenLayers = reader.ReadInt32();
-        int kernelCount = reader.ReadInt32();
-        _poolingKernelSizes = new int[kernelCount];
-        for (int i = 0; i < kernelCount; i++)
-            _poolingKernelSizes[i] = reader.ReadInt32();
-        _dropout = reader.ReadDouble();
-
-        // Re-bind cached layer references so a deserialized/cloned model runs on
-        // the restored layers, not the construction-time random ones.
-        ExtractLayerReferences();
-    }
+
 
     #endregion
 
diff --git a/src/Finance/Forecasting/Neural/TCN.cs b/src/Finance/Forecasting/Neural/TCN.cs
index 299cbb422f..1eef5f4cca 100644
--- a/src/Finance/Forecasting/Neural/TCN.cs
+++ b/src/Finance/Forecasting/Neural/TCN.cs
@@ -540,30 +540,6 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    /// <summary>
-    /// Creates a new instance of this model with the same configuration.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Creates a fresh copy with randomly initialized weights.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var options = new TCNOptions<T>
-        {
-            LookbackWindow = _lookbackWindow,
-            ForecastHorizon = _forecastHorizon,
-            NumChannels = _numChannels,
-            KernelSize = _kernelSize,
-            NumLayers = _numLayers,
-            DropoutRate = _dropout,
-            UseResidualConnections = _useResidualConnections
-        };
-
-        return new TCN<T>(Architecture, options);
-    }
-
     /// <summary>
     /// Writes TCN-specific configuration during serialization.
     /// </summary>
@@ -572,17 +548,7 @@ protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
     /// <b>For Beginners:</b> In the TCN model, SerializeNetworkSpecificData saves or restores model-specific settings. This lets the TCN architecture be reused later.
     /// </para>
     /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_lookbackWindow);
-        writer.Write(_forecastHorizon);
-        writer.Write(_numFeatures);
-        writer.Write(_numChannels);
-        writer.Write(_kernelSize);
-        writer.Write(_numLayers);
-        writer.Write(_dropout);
-        writer.Write(_useResidualConnections);
-    }
+
 
     /// <summary>
     /// Reads TCN-specific configuration during deserialization.
@@ -592,22 +558,7 @@ protected override void SerializeNetworkSpecificData(BinaryWriter writer)
     /// <b>For Beginners:</b> In the TCN model, DeserializeNetworkSpecificData saves or restores model-specific settings. This lets the TCN architecture be reused later.
     /// </para>
     /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _lookbackWindow = reader.ReadInt32();
-        _forecastHorizon = reader.ReadInt32();
-        _numFeatures = reader.ReadInt32();
-        _numChannels = reader.ReadInt32();
-        _kernelSize = reader.ReadInt32();
-        _numLayers = reader.ReadInt32();
-        _dropout = reader.ReadDouble();
-        _useResidualConnections = reader.ReadBoolean();
-
-        // Re-bind cached layer references (_inputProjection, _tcnBlocks,
-        // _outputProjection) to the deserialized weight-loaded layers so a clone
-        // runs on the loaded weights, not random init.
-        ExtractLayerReferences();
-    }
+
 
     #endregion
 
diff --git a/src/Finance/Forecasting/Neural/WaveNet.cs b/src/Finance/Forecasting/Neural/WaveNet.cs
index 9b58216b09..3185bc7d3a 100644
--- a/src/Finance/Forecasting/Neural/WaveNet.cs
+++ b/src/Finance/Forecasting/Neural/WaveNet.cs
@@ -473,32 +473,6 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    /// <summary>
-    /// Creates a new instance of this model with the same configuration.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> In the WaveNet model, CreateNewInstance builds and wires up model components. This sets up the WaveNet architecture before use.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var options = new WaveNetOptions<T>
-        {
-            LookbackWindow = _lookbackWindow,
-            ForecastHorizon = _forecastHorizon,
-            ResidualChannels = _residualChannels,
-            SkipChannels = _skipChannels,
-            DilationDepth = _dilationDepth,
-            NumStacks = _numStacks,
-            KernelSize = _kernelSize,
-            UseGatedActivations = _useGatedActivations,
-            DropoutRate = _dropout
-        };
-
-        return new WaveNet<T>(Architecture, options);
-    }
-
     /// <summary>
     /// Writes WaveNet-specific configuration during serialization.
     /// </summary>
@@ -507,19 +481,7 @@ protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
     /// <b>For Beginners:</b> In the WaveNet model, SerializeNetworkSpecificData saves or restores model-specific settings. This lets the WaveNet architecture be reused later.
     /// </para>
     /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_lookbackWindow);
-        writer.Write(_forecastHorizon);
-        writer.Write(_numFeatures);
-        writer.Write(_residualChannels);
-        writer.Write(_skipChannels);
-        writer.Write(_dilationDepth);
-        writer.Write(_numStacks);
-        writer.Write(_kernelSize);
-        writer.Write(_useGatedActivations);
-        writer.Write(_dropout);
-    }
+
 
     /// <summary>
     /// Reads WaveNet-specific configuration during deserialization.
@@ -529,19 +491,7 @@ protected override void SerializeNetworkSpecificData(BinaryWriter writer)
     /// <b>For Beginners:</b> In the WaveNet model, DeserializeNetworkSpecificData saves or restores model-specific settings. This lets the WaveNet architecture be reused later.
     /// </para>
     /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _lookbackWindow = reader.ReadInt32();
-        _forecastHorizon = reader.ReadInt32();
-        _numFeatures = reader.ReadInt32();
-        _residualChannels = reader.ReadInt32();
-        _skipChannels = reader.ReadInt32();
-        _dilationDepth = reader.ReadInt32();
-        _numStacks = reader.ReadInt32();
-        _kernelSize = reader.ReadInt32();
-        _useGatedActivations = reader.ReadBoolean();
-        _dropout = reader.ReadDouble();
-    }
+
 
     #endregion
 
diff --git a/src/Finance/Forecasting/StateSpace/Hippo.cs b/src/Finance/Forecasting/StateSpace/Hippo.cs
index 7264bbb963..18d7dad26c 100644
--- a/src/Finance/Forecasting/StateSpace/Hippo.cs
+++ b/src/Finance/Forecasting/StateSpace/Hippo.cs
@@ -507,20 +507,6 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    /// <summary>
-    /// Creates a new instance of the HiPPO model with the same configuration.
-    /// </summary>
-    /// <returns>A new HiPPO instance.</returns>
-    /// <remarks>
-    /// <para><b>For Beginners:</b> Creates a fresh copy of the model with
-    /// randomly initialized weights but the same architecture.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new Hippo<T>(Architecture, new HippoOptions<T>(_options), _numFeatures);
-    }
-
     /// <summary>
     /// Serializes HiPPO-specific data for model persistence.
     /// </summary>
@@ -530,27 +516,7 @@ protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
     /// can be reconstructed later.
     /// </para>
     /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_contextLength);
-        writer.Write(_forecastHorizon);
-        writer.Write(_modelDimension);
-        writer.Write(_stateDimension);
-        writer.Write(_numLayers);
-        writer.Write(_hippoMethod);
-        writer.Write(_discretizationMethod);
-        writer.Write(_timescaleMin);
-        writer.Write(_timescaleMax);
-        writer.Write(_useNormalization);
-
-        // Keep the original HiPPO payload above byte-for-byte compatible.
-        // New recurrent-cell settings are append-only so older payloads can
-        // still be loaded with the paper defaults below.
-        writer.Write(_memorySize);
-        writer.Write(_initialTime);
-        writer.Write(_timeStep);
-        writer.Write(_useGate);
-    }
+
 
     /// <summary>
     /// Deserializes HiPPO-specific data when loading a saved model.
@@ -561,39 +527,7 @@ protected override void SerializeNetworkSpecificData(BinaryWriter writer)
     /// loading a previously saved model.
     /// </para>
     /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _contextLength = reader.ReadInt32();
-        _forecastHorizon = reader.ReadInt32();
-        _modelDimension = reader.ReadInt32();
-        _stateDimension = reader.ReadInt32();
-        _numLayers = reader.ReadInt32();
-        _hippoMethod = reader.ReadString();
-        _discretizationMethod = reader.ReadString();
-        _timescaleMin = reader.ReadDouble();
-        _timescaleMax = reader.ReadDouble();
-        _useNormalization = reader.ReadBoolean();
-
-        // These fields were appended after the original payload. Preserve
-        // the paper configuration when loading a model serialized before
-        // they existed.
-        _memorySize = 1;
-        _initialTime = 0;
-        _timeStep = 0.0;
-        _useGate = true;
-        if (reader.BaseStream.Position < reader.BaseStream.Length)
-            _memorySize = reader.ReadInt32();
-        if (reader.BaseStream.Position < reader.BaseStream.Length)
-            _initialTime = reader.ReadInt32();
-        if (reader.BaseStream.Position < reader.BaseStream.Length)
-            _timeStep = reader.ReadDouble();
-        if (reader.BaseStream.Position < reader.BaseStream.Length)
-            _useGate = reader.ReadBoolean();
-
-        // Re-bind cached layer references so a deserialized/cloned model runs on
-        // the restored layers, not the construction-time random ones.
-        ExtractLayerReferences();
-    }
+
 
     #endregion
 
diff --git a/src/Finance/Forecasting/StateSpace/Mamba.cs b/src/Finance/Forecasting/StateSpace/Mamba.cs
index 10cc7439a5..05de03a5b7 100644
--- a/src/Finance/Forecasting/StateSpace/Mamba.cs
+++ b/src/Finance/Forecasting/StateSpace/Mamba.cs
@@ -504,31 +504,6 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    /// <inheritdoc/>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> In the Mamba model, CreateNewInstance builds and wires up model components. This sets up the Mamba architecture before use.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var options = new MambaOptions<T>
-        {
-            ContextLength = _contextLength,
-            ForecastHorizon = _forecastHorizon,
-            ModelDimension = _modelDimension,
-            StateDimension = _stateDimension,
-            ExpandFactor = _expandFactor,
-            ConvKernelSize = _convKernelSize,
-            NumLayers = _numLayers,
-            DropoutRate = _dropout,
-            DtRank = _dtRank,
-            UseBidirectional = _useBidirectional
-        };
-
-        return new Mamba<T>(Architecture, options, _numFeatures);
-    }
-
     /// <summary>
     /// Writes Mamba-specific configuration during serialization.
     /// </summary>
@@ -536,20 +511,7 @@ protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
     /// <para><b>For Beginners:</b> Saves all the configuration needed to reconstruct this model.
     /// </para>
     /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_contextLength);
-        writer.Write(_forecastHorizon);
-        writer.Write(_modelDimension);
-        writer.Write(_stateDimension);
-        writer.Write(_expandFactor);
-        writer.Write(_convKernelSize);
-        writer.Write(_numLayers);
-        writer.Write(_dropout);
-        writer.Write(_dtRank);
-        writer.Write(_useBidirectional);
-        writer.Write(_numFeatures);
-    }
+
 
     /// <summary>
     /// Reads Mamba-specific configuration during deserialization.
@@ -558,20 +520,7 @@ protected override void SerializeNetworkSpecificData(BinaryWriter writer)
     /// <para><b>For Beginners:</b> Loads the configuration that was saved during serialization.
     /// </para>
     /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _contextLength = reader.ReadInt32();
-        _forecastHorizon = reader.ReadInt32();
-        _modelDimension = reader.ReadInt32();
-        _stateDimension = reader.ReadInt32();
-        _expandFactor = reader.ReadInt32();
-        _convKernelSize = reader.ReadInt32();
-        _numLayers = reader.ReadInt32();
-        _dropout = reader.ReadDouble();
-        _dtRank = reader.ReadInt32();
-        _useBidirectional = reader.ReadBoolean();
-        _numFeatures = reader.ReadInt32();
-    }
+
 
     #endregion
 
diff --git a/src/Finance/Forecasting/StateSpace/Mamba2.cs b/src/Finance/Forecasting/StateSpace/Mamba2.cs
index bbccd1a914..fc0b0f2baa 100644
--- a/src/Finance/Forecasting/StateSpace/Mamba2.cs
+++ b/src/Finance/Forecasting/StateSpace/Mamba2.cs
@@ -285,47 +285,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new Mamba2<T>(Architecture, new Mamba2Options<T>(_options), _numFeatures);
-    }
 
-    /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_contextLength);
-        writer.Write(_forecastHorizon);
-        writer.Write(_modelDimension);
-        writer.Write(_stateDimension);
-        writer.Write(_numHeads);
-        writer.Write(_expandFactor);
-        writer.Write(_convKernelSize);
-        writer.Write(_chunkSize);
-        writer.Write(_numLayers);
-        writer.Write(_dropout);
-        writer.Write(_numFeatures);
-    }
 
     /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _contextLength = reader.ReadInt32();
-        _forecastHorizon = reader.ReadInt32();
-        _modelDimension = reader.ReadInt32();
-        _stateDimension = reader.ReadInt32();
-        _numHeads = reader.ReadInt32();
-        _expandFactor = reader.ReadInt32();
-        _convKernelSize = reader.ReadInt32();
-        _chunkSize = reader.ReadInt32();
-        _numLayers = reader.ReadInt32();
-        _dropout = reader.ReadDouble();
-        _numFeatures = reader.ReadInt32();
-
-        // Re-point cached layer references at the freshly deserialized Layers;
-        // otherwise a clone's forward uses the stale random-initialized layers
-        // created by CreateNewInstance and diverges from the original.
-        ExtractLayerReferences();
-    }
+
 
     #endregion
 
diff --git a/src/Finance/Forecasting/StateSpace/RWKVForecaster.cs b/src/Finance/Forecasting/StateSpace/RWKVForecaster.cs
index 1e5f11184d..e46bba09be 100644
--- a/src/Finance/Forecasting/StateSpace/RWKVForecaster.cs
+++ b/src/Finance/Forecasting/StateSpace/RWKVForecaster.cs
@@ -375,39 +375,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new RWKVForecaster<T>(Architecture, new RWKVForecastingOptions<T>(_options), _numFeatures);
-    }
 
-    /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_contextLength);
-        writer.Write(_forecastHorizon);
-        writer.Write(_modelDimension);
-        writer.Write(_numHeads);
-        writer.Write(_numLayers);
-        writer.Write(_dropout);
-        writer.Write(_numFeatures);
-    }
 
     /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _contextLength = reader.ReadInt32();
-        _forecastHorizon = reader.ReadInt32();
-        _modelDimension = reader.ReadInt32();
-        _numHeads = reader.ReadInt32();
-        _numLayers = reader.ReadInt32();
-        _dropout = reader.ReadDouble();
-        _numFeatures = reader.ReadInt32();
-
-        // Re-point cached layer references at the freshly deserialized Layers;
-        // otherwise a clone's forward uses the stale random-initialized layers
-        // created by CreateNewInstance and diverges from the original.
-        ExtractLayerReferences();
-    }
+
 
     #endregion
 
diff --git a/src/Finance/Forecasting/StateSpace/S4.cs b/src/Finance/Forecasting/StateSpace/S4.cs
index 982b41457e..e4f4382d8f 100644
--- a/src/Finance/Forecasting/StateSpace/S4.cs
+++ b/src/Finance/Forecasting/StateSpace/S4.cs
@@ -473,20 +473,6 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    /// <summary>
-    /// Creates a new instance of the S4 model with the same configuration.
-    /// </summary>
-    /// <returns>A new S4 instance.</returns>
-    /// <remarks>
-    /// <para><b>For Beginners:</b> Creates a fresh copy of the model with
-    /// randomly initialized weights but the same architecture.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new S4<T>(Architecture, _options);
-    }
-
     /// <summary>
     /// Serializes S4-specific data for model persistence.
     /// </summary>
@@ -496,18 +482,7 @@ protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
     /// can be reconstructed later.
     /// </para>
     /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_contextLength);
-        writer.Write(_forecastHorizon);
-        writer.Write(_modelDimension);
-        writer.Write(_stateDimension);
-        writer.Write(_numLayers);
-        writer.Write(_hippoMethod);
-        writer.Write(_discretizationMethod);
-        writer.Write(_useLowRankCorrection);
-        writer.Write(_lowRankRank);
-    }
+
 
     /// <summary>
     /// Deserializes S4-specific data when loading a saved model.
@@ -518,18 +493,7 @@ protected override void SerializeNetworkSpecificData(BinaryWriter writer)
     /// loading a previously saved model.
     /// </para>
     /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _contextLength = reader.ReadInt32();
-        _forecastHorizon = reader.ReadInt32();
-        _modelDimension = reader.ReadInt32();
-        _stateDimension = reader.ReadInt32();
-        _numLayers = reader.ReadInt32();
-        _hippoMethod = reader.ReadString();
-        _discretizationMethod = reader.ReadString();
-        _useLowRankCorrection = reader.ReadBoolean();
-        _lowRankRank = reader.ReadInt32();
-    }
+
 
     #endregion
 
diff --git a/src/Finance/Forecasting/StateSpace/TimeMachine.cs b/src/Finance/Forecasting/StateSpace/TimeMachine.cs
index 76a4bcae60..2aedb49e7b 100644
--- a/src/Finance/Forecasting/StateSpace/TimeMachine.cs
+++ b/src/Finance/Forecasting/StateSpace/TimeMachine.cs
@@ -486,20 +486,6 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    /// <summary>
-    /// Creates a new instance of the TimeMachine model with the same configuration.
-    /// </summary>
-    /// <returns>A new TimeMachine instance.</returns>
-    /// <remarks>
-    /// <para><b>For Beginners:</b> Creates a fresh copy of the model with
-    /// randomly initialized weights but the same architecture.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new TimeMachine<T>(Architecture, new TimeMachineOptions<T>(_options), _numFeatures);
-    }
-
     /// <summary>
     /// Serializes TimeMachine-specific data for model persistence.
     /// </summary>
@@ -509,16 +495,7 @@ protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
     /// can be reconstructed later.
     /// </para>
     /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_contextLength);
-        writer.Write(_forecastHorizon);
-        writer.Write(_modelDimension);
-        writer.Write(_stateDimension);
-        writer.Write(_expandFactor);
-        writer.Write(_convKernelSize);
-        writer.Write(_useReversibleNormalization);
-    }
+
 
     /// <summary>
     /// Deserializes TimeMachine-specific data when loading a saved model.
@@ -529,16 +506,7 @@ protected override void SerializeNetworkSpecificData(BinaryWriter writer)
     /// loading a previously saved model.
     /// </para>
     /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _contextLength = reader.ReadInt32();
-        _forecastHorizon = reader.ReadInt32();
-        _modelDimension = reader.ReadInt32();
-        _stateDimension = reader.ReadInt32();
-        _expandFactor = reader.ReadInt32();
-        _convKernelSize = reader.ReadInt32();
-        _useReversibleNormalization = reader.ReadBoolean();
-    }
+
 
     #endregion
 
diff --git a/src/Finance/Forecasting/Transformers/Autoformer.cs b/src/Finance/Forecasting/Transformers/Autoformer.cs
index 91a9e29398..1689ee55d8 100644
--- a/src/Finance/Forecasting/Transformers/Autoformer.cs
+++ b/src/Finance/Forecasting/Transformers/Autoformer.cs
@@ -484,42 +484,13 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    /// <inheritdoc/>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> In the Autoformer model, CreateNewInstance builds and wires up model components. This sets up the Autoformer architecture before use.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var options = new AutoformerOptions<T>(_options);
-
-        return _useNativeMode
-            ? new Autoformer<T>(Architecture, options, optimizer: null, lossFunction: _lossFunction)
-            : new Autoformer<T>(Architecture, OnnxModelPath!, options, optimizer: null, lossFunction: _lossFunction);
-    }
-
     /// <inheritdoc/>
     /// <remarks>
     /// <para>
     /// <b>For Beginners:</b> In the Autoformer model, SerializeNetworkSpecificData saves or restores model-specific settings. This lets the Autoformer architecture be reused later.
     /// </para>
     /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_sequenceLength);
-        writer.Write(_predictionHorizon);
-        writer.Write(_numFeatures);
-        writer.Write(_numEncoderLayers);
-        writer.Write(_numDecoderLayers);
-        writer.Write(_numHeads);
-        writer.Write(_modelDimension);
-        writer.Write(_feedForwardDimension);
-        writer.Write(_movingAverageKernel);
-        writer.Write(_topKFactor);
-        writer.Write(_dropout);
-        writer.Write(_useInstanceNormalization);
-    }
+
 
     /// <inheritdoc/>
     /// <remarks>
@@ -527,27 +498,7 @@ protected override void SerializeNetworkSpecificData(BinaryWriter writer)
     /// <b>For Beginners:</b> In the Autoformer model, DeserializeNetworkSpecificData saves or restores model-specific settings. This lets the Autoformer architecture be reused later.
     /// </para>
     /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _sequenceLength = reader.ReadInt32();
-        _predictionHorizon = reader.ReadInt32();
-        _numFeatures = reader.ReadInt32();
-        _numEncoderLayers = reader.ReadInt32();
-        _numDecoderLayers = reader.ReadInt32();
-        _numHeads = reader.ReadInt32();
-        _modelDimension = reader.ReadInt32();
-        _feedForwardDimension = reader.ReadInt32();
-        _movingAverageKernel = reader.ReadInt32();
-        _topKFactor = reader.ReadInt32();
-        _dropout = reader.ReadDouble();
-        _useInstanceNormalization = reader.ReadBoolean();
-
-        // Re-bind the cached layer references to the layers the base deserializer
-        // just rebuilt with the loaded weights — otherwise Forward (and therefore
-        // a clone) runs on the construction-time random-init layers instead of the
-        // deserialized weights (Clone_ShouldProduceIdenticalOutput divergence).
-        ExtractLayerReferences();
-    }
+
 
     #endregion
 
diff --git a/src/Finance/Forecasting/Transformers/Crossformer.cs b/src/Finance/Forecasting/Transformers/Crossformer.cs
index 08b19ebe70..2d90d6fd86 100644
--- a/src/Finance/Forecasting/Transformers/Crossformer.cs
+++ b/src/Finance/Forecasting/Transformers/Crossformer.cs
@@ -477,34 +477,6 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    /// <summary>
-    /// Creates a new instance of this model with the same configuration.
-    /// </summary>
-    /// <returns>A new Crossformer model instance.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> This creates a fresh copy of the model with the same settings
-    /// but new (randomly initialized) weights. Useful for ensemble training or cross-validation.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var options = new CrossformerOptions<T>
-        {
-            SequenceLength = _sequenceLength,
-            PredictionHorizon = _predictionHorizon,
-            NumFeatures = _numFeatures,
-            SegmentLength = _segmentLength,
-            ModelDimension = _modelDimension,
-            NumHeads = _numHeads,
-            NumLayers = _numLayers,
-            Dropout = _dropout,
-            UseInstanceNormalization = _useInstanceNormalization
-        };
-
-        return new Crossformer<T>(Architecture, options);
-    }
-
     /// <summary>
     /// Writes Crossformer-specific configuration during serialization.
     /// </summary>
@@ -515,18 +487,7 @@ protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
     /// to a file so the model can be loaded later with the same configuration.
     /// </para>
     /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_sequenceLength);
-        writer.Write(_predictionHorizon);
-        writer.Write(_numFeatures);
-        writer.Write(_segmentLength);
-        writer.Write(_modelDimension);
-        writer.Write(_numHeads);
-        writer.Write(_numLayers);
-        writer.Write(_dropout);
-        writer.Write(_useInstanceNormalization);
-    }
+
 
     /// <summary>
     /// Reads Crossformer-specific configuration during deserialization.
@@ -538,22 +499,7 @@ protected override void SerializeNetworkSpecificData(BinaryWriter writer)
     /// and restores the model configuration.
     /// </para>
     /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _sequenceLength = reader.ReadInt32();
-        _predictionHorizon = reader.ReadInt32();
-        _numFeatures = reader.ReadInt32();
-        _segmentLength = reader.ReadInt32();
-        _modelDimension = reader.ReadInt32();
-        _numHeads = reader.ReadInt32();
-        _numLayers = reader.ReadInt32();
-        _dropout = reader.ReadDouble();
-        _useInstanceNormalization = reader.ReadBoolean();
-
-        // Re-bind cached layer references to the deserialized (weight-loaded)
-        // layers so a clone runs on the loaded weights, not random init.
-        ExtractLayerReferences();
-    }
+
 
     #endregion
 
diff --git a/src/Finance/Forecasting/Transformers/ETSformer.cs b/src/Finance/Forecasting/Transformers/ETSformer.cs
index a6ec04645c..c3d880b539 100644
--- a/src/Finance/Forecasting/Transformers/ETSformer.cs
+++ b/src/Finance/Forecasting/Transformers/ETSformer.cs
@@ -478,34 +478,6 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    /// <summary>
-    /// Creates a new instance of this model with the same configuration.
-    /// </summary>
-    /// <returns>A new ETSformer instance.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> In the ETSformer model, CreateNewInstance builds and wires up model components. This sets up the ETSformer architecture before use.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var options = new ETSformerOptions<T>
-        {
-            SequenceLength = _sequenceLength,
-            PredictionHorizon = _predictionHorizon,
-            NumFeatures = _numFeatures,
-            ModelDimension = _modelDimension,
-            NumEncoderLayers = _numEncoderLayers,
-            NumDecoderLayers = _numDecoderLayers,
-            NumHeads = _numHeads,
-            Dropout = _dropout,
-            K = _topK,
-            UseInstanceNormalization = _useInstanceNormalization
-        };
-
-        return new ETSformer<T>(Architecture, options);
-    }
-
     /// <summary>
     /// Serializes model-specific data for saving.
     /// </summary>
@@ -515,19 +487,7 @@ protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
     /// <b>For Beginners:</b> In the ETSformer model, SerializeNetworkSpecificData saves or restores model-specific settings. This lets the ETSformer architecture be reused later.
     /// </para>
     /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_sequenceLength);
-        writer.Write(_predictionHorizon);
-        writer.Write(_numFeatures);
-        writer.Write(_modelDimension);
-        writer.Write(_numEncoderLayers);
-        writer.Write(_numDecoderLayers);
-        writer.Write(_numHeads);
-        writer.Write(_dropout);
-        writer.Write(_topK);
-        writer.Write(_useInstanceNormalization);
-    }
+
 
     /// <summary>
     /// Deserializes model-specific data when loading.
@@ -538,23 +498,7 @@ protected override void SerializeNetworkSpecificData(BinaryWriter writer)
     /// <b>For Beginners:</b> In the ETSformer model, DeserializeNetworkSpecificData saves or restores model-specific settings. This lets the ETSformer architecture be reused later.
     /// </para>
     /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _sequenceLength = reader.ReadInt32();
-        _predictionHorizon = reader.ReadInt32();
-        _numFeatures = reader.ReadInt32();
-        _modelDimension = reader.ReadInt32();
-        _numEncoderLayers = reader.ReadInt32();
-        _numDecoderLayers = reader.ReadInt32();
-        _numHeads = reader.ReadInt32();
-        _dropout = reader.ReadDouble();
-        _topK = reader.ReadInt32();
-        _useInstanceNormalization = reader.ReadBoolean();
-
-        // Re-bind cached layer references to the deserialized (weight-loaded)
-        // layers so a clone runs on the loaded weights, not random init.
-        ExtractLayerReferences();
-    }
+
 
     #endregion
 
diff --git a/src/Finance/Forecasting/Transformers/FEDformer.cs b/src/Finance/Forecasting/Transformers/FEDformer.cs
index 242fed763e..40b2c89875 100644
--- a/src/Finance/Forecasting/Transformers/FEDformer.cs
+++ b/src/Finance/Forecasting/Transformers/FEDformer.cs
@@ -592,52 +592,13 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    /// <inheritdoc/>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> In the FEDformer model, CreateNewInstance builds and wires up model components. This sets up the FEDformer architecture before use.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (_useNativeMode)
-        {
-            return new FEDformer<T>(
-                Architecture, _sequenceLength, _predictionHorizon, _numFeatures,
-                _numEncoderLayers, _numDecoderLayers, _numHeads, _modelDimension, _feedForwardDimension,
-                _numModes, _movingAverageKernel, _useInstanceNormalization, _dropout,
-                _optimizer, _lossFunction);
-        }
-        else
-        {
-            return new FEDformer<T>(
-                Architecture, OnnxModelPath ?? string.Empty,
-                _sequenceLength, _predictionHorizon, _numFeatures,
-                _optimizer, _lossFunction);
-        }
-    }
-
     /// <inheritdoc/>
     /// <remarks>
     /// <para>
     /// <b>For Beginners:</b> In the FEDformer model, SerializeNetworkSpecificData saves or restores model-specific settings. This lets the FEDformer architecture be reused later.
     /// </para>
     /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_sequenceLength);
-        writer.Write(_predictionHorizon);
-        writer.Write(_numFeatures);
-        writer.Write(_numEncoderLayers);
-        writer.Write(_numDecoderLayers);
-        writer.Write(_numHeads);
-        writer.Write(_modelDimension);
-        writer.Write(_feedForwardDimension);
-        writer.Write(_numModes);
-        writer.Write(_movingAverageKernel);
-        writer.Write(_useInstanceNormalization);
-        writer.Write(_dropout);
-    }
+
 
     /// <inheritdoc/>
     /// <remarks>
@@ -645,21 +606,7 @@ protected override void SerializeNetworkSpecificData(BinaryWriter writer)
     /// <b>For Beginners:</b> In the FEDformer model, DeserializeNetworkSpecificData saves or restores model-specific settings. This lets the FEDformer architecture be reused later.
     /// </para>
     /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _sequenceLength = reader.ReadInt32();
-        _predictionHorizon = reader.ReadInt32();
-        _numFeatures = reader.ReadInt32();
-        _numEncoderLayers = reader.ReadInt32();
-        _numDecoderLayers = reader.ReadInt32();
-        _numHeads = reader.ReadInt32();
-        _modelDimension = reader.ReadInt32();
-        _feedForwardDimension = reader.ReadInt32();
-        _numModes = reader.ReadInt32();
-        _movingAverageKernel = reader.ReadInt32();
-        _useInstanceNormalization = reader.ReadBoolean();
-        _dropout = reader.ReadDouble();
-    }
+
 
     #endregion
 
diff --git a/src/Finance/Forecasting/Transformers/ITransformer.cs b/src/Finance/Forecasting/Transformers/ITransformer.cs
index 999c4d4730..17888df33e 100644
--- a/src/Finance/Forecasting/Transformers/ITransformer.cs
+++ b/src/Finance/Forecasting/Transformers/ITransformer.cs
@@ -648,39 +648,6 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    /// <summary>
-    /// Creates a new instance of this model with the same configuration.
-    /// </summary>
-    /// <returns>A new iTransformer instance with identical settings.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Creates a fresh copy of the model with the same architecture
-    /// but newly initialized parameters. Useful for:
-    /// <list type="bullet">
-    /// <item>Creating ensemble models</item>
-    /// <item>Cross-validation (fresh model for each fold)</item>
-    /// <item>Resetting training</item>
-    /// </list>
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (_useNativeMode)
-        {
-            return new ITransformer<T>(
-                Architecture, _sequenceLength, _predictionHorizon, _numFeatures,
-                _numLayers, _numHeads, _modelDimension, _feedForwardDimension,
-                _useInstanceNormalization, _dropout, _optimizer, _lossFunction);
-        }
-        else
-        {
-            return new ITransformer<T>(
-                Architecture, OnnxModelPath ?? string.Empty,
-                _sequenceLength, _predictionHorizon, _numFeatures,
-                _optimizer, _lossFunction);
-        }
-    }
-
     /// <summary>
     /// Writes network-specific configuration data during serialization.
     /// </summary>
@@ -692,18 +659,7 @@ protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
     /// number of layers, and attention heads.
     /// </para>
     /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_sequenceLength);
-        writer.Write(_predictionHorizon);
-        writer.Write(_numFeatures);
-        writer.Write(_numLayers);
-        writer.Write(_numHeads);
-        writer.Write(_modelDimension);
-        writer.Write(_feedForwardDimension);
-        writer.Write(_useInstanceNormalization);
-        writer.Write(_dropout);
-    }
+
 
     /// <summary>
     /// Reads network-specific configuration data during deserialization.
@@ -715,23 +671,7 @@ protected override void SerializeNetworkSpecificData(BinaryWriter writer)
     /// This method reads back the iTransformer-specific settings that were saved.
     /// </para>
     /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _sequenceLength = reader.ReadInt32();
-        _predictionHorizon = reader.ReadInt32();
-        _numFeatures = reader.ReadInt32();
-        _numLayers = reader.ReadInt32();
-        _numHeads = reader.ReadInt32();
-        _modelDimension = reader.ReadInt32();
-        _feedForwardDimension = reader.ReadInt32();
-        _useInstanceNormalization = reader.ReadBoolean();
-        _dropout = reader.ReadDouble();
-
-        // Re-bind cached layer references to the deserialized (weight-loaded)
-        // layers so a clone runs on the trained weights, not construction-time
-        // random init.
-        ExtractLayerReferences();
-    }
+
 
     #endregion
 
diff --git a/src/Finance/Forecasting/Transformers/Informer.cs b/src/Finance/Forecasting/Transformers/Informer.cs
index 948b858e96..7f03914264 100644
--- a/src/Finance/Forecasting/Transformers/Informer.cs
+++ b/src/Finance/Forecasting/Transformers/Informer.cs
@@ -453,52 +453,13 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    /// <inheritdoc/>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> In the Informer model, CreateNewInstance builds and wires up model components. This sets up the Informer architecture before use.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var options = new InformerOptions<T>
-        {
-            LookbackWindow = _sequenceLength,
-            ForecastHorizon = _predictionHorizon,
-            NumEncoderLayers = _numEncoderLayers,
-            NumDecoderLayers = _numDecoderLayers,
-            NumAttentionHeads = _numHeads,
-            EmbeddingDim = _modelDimension,
-            DistillingFactor = _distillingFactor,
-            DropoutRate = _dropout
-        };
-
-        return _useNativeMode
-            ? new Informer<T>(Architecture, options, _optimizer, _lossFunction)
-            : new Informer<T>(Architecture, OnnxModelPath!, options, _optimizer, _lossFunction);
-    }
-
     /// <inheritdoc/>
     /// <remarks>
     /// <para>
     /// <b>For Beginners:</b> In the Informer model, SerializeNetworkSpecificData saves or restores model-specific settings. This lets the Informer architecture be reused later.
     /// </para>
     /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_sequenceLength);
-        writer.Write(_labelLength);
-        writer.Write(_predictionHorizon);
-        writer.Write(_numFeatures);
-        writer.Write(_numEncoderLayers);
-        writer.Write(_numDecoderLayers);
-        writer.Write(_numHeads);
-        writer.Write(_modelDimension);
-        writer.Write(_feedForwardDimension);
-        writer.Write(_distillingFactor);
-        writer.Write(_dropout);
-        writer.Write(_useInstanceNormalization);
-    }
+
 
     /// <inheritdoc/>
     /// <remarks>
@@ -506,25 +467,7 @@ protected override void SerializeNetworkSpecificData(BinaryWriter writer)
     /// <b>For Beginners:</b> In the Informer model, DeserializeNetworkSpecificData saves or restores model-specific settings. This lets the Informer architecture be reused later.
     /// </para>
     /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _sequenceLength = reader.ReadInt32();
-        _labelLength = reader.ReadInt32();
-        _predictionHorizon = reader.ReadInt32();
-        _numFeatures = reader.ReadInt32();
-        _numEncoderLayers = reader.ReadInt32();
-        _numDecoderLayers = reader.ReadInt32();
-        _numHeads = reader.ReadInt32();
-        _modelDimension = reader.ReadInt32();
-        _feedForwardDimension = reader.ReadInt32();
-        _distillingFactor = reader.ReadInt32();
-        _dropout = reader.ReadDouble();
-        _useInstanceNormalization = reader.ReadBoolean();
-
-        // Re-bind cached layer references to the deserialized (weight-loaded)
-        // layers so a clone runs on the loaded weights, not random init.
-        ExtractLayerReferences();
-    }
+
 
     #endregion
 
diff --git a/src/Finance/Forecasting/Transformers/NonStationaryTransformer.cs b/src/Finance/Forecasting/Transformers/NonStationaryTransformer.cs
index 4c3fcd979d..df5352369b 100644
--- a/src/Finance/Forecasting/Transformers/NonStationaryTransformer.cs
+++ b/src/Finance/Forecasting/Transformers/NonStationaryTransformer.cs
@@ -167,6 +167,7 @@ public partial class NonStationaryTransformer<T> : ForecastingModelBase<T>
     /// adjust attention weights based on the data's statistical properties.
     /// </para>
     /// </remarks>
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T>? _tau;
 
     /// <summary>
@@ -178,6 +179,7 @@ public partial class NonStationaryTransformer<T> : ForecastingModelBase<T>
     /// to better match the original data distribution.
     /// </para>
     /// </remarks>
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T>? _delta;
 
     #endregion
@@ -688,38 +690,6 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    /// <summary>
-    /// Creates a new instance of this network type.
-    /// </summary>
-    /// <returns>A new Non-stationary Transformer instance.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> This factory method creates a copy of the model structure,
-    /// useful for ensemble methods or hyperparameter search.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var options = new NonStationaryTransformerOptions<T>
-        {
-            SequenceLength = _sequenceLength,
-            LabelLength = _labelLength,
-            PredictionHorizon = _predictionHorizon,
-            NumFeatures = _numFeatures,
-            ModelDimension = _modelDimension,
-            NumEncoderLayers = _numEncoderLayers,
-            NumDecoderLayers = _numDecoderLayers,
-            NumHeads = _numHeads,
-            FeedForwardDimension = _feedForwardDim,
-            ProjectionDimension = _projectionDim,
-            UseSeriesStationarization = _useSeriesStationarization,
-            UseDeStationaryAttention = _useDeStationaryAttention,
-            Dropout = _dropout
-        };
-
-        return new NonStationaryTransformer<T>(Architecture, options);
-    }
-
     /// <summary>
     /// Serializes network-specific data for persistence.
     /// </summary>
@@ -730,23 +700,7 @@ protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
     /// into a format that can be saved to disk and loaded later.
     /// </para>
     /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_sequenceLength);
-        writer.Write(_labelLength);
-        writer.Write(_predictionHorizon);
-        writer.Write(_numFeatures);
-        writer.Write(_modelDimension);
-        writer.Write(_numEncoderLayers);
-        writer.Write(_numDecoderLayers);
-        writer.Write(_numHeads);
-        writer.Write(_feedForwardDim);
-        writer.Write(_projectionDim);
-        writer.Write(_useSeriesStationarization);
-        writer.Write(_useDeStationaryAttention);
-        writer.Write(_dropout);
-        writer.Write(_useNativeMode);
-    }
+
 
     /// <summary>
     /// Deserializes network-specific data from persistence.
@@ -758,27 +712,7 @@ protected override void SerializeNetworkSpecificData(BinaryWriter writer)
     /// from a saved format. Called when loading a model from disk.
     /// </para>
     /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _sequenceLength = reader.ReadInt32();
-        _labelLength = reader.ReadInt32();
-        _predictionHorizon = reader.ReadInt32();
-        _numFeatures = reader.ReadInt32();
-        _modelDimension = reader.ReadInt32();
-        _numEncoderLayers = reader.ReadInt32();
-        _numDecoderLayers = reader.ReadInt32();
-        _numHeads = reader.ReadInt32();
-        _feedForwardDim = reader.ReadInt32();
-        _projectionDim = reader.ReadInt32();
-        _useSeriesStationarization = reader.ReadBoolean();
-        _useDeStationaryAttention = reader.ReadBoolean();
-        _dropout = reader.ReadDouble();
-        _useNativeMode = reader.ReadBoolean();
-
-        // Re-bind cached layer references to the deserialized (weight-loaded)
-        // layers so a clone runs on the loaded weights, not random init.
-        ExtractLayerReferences();
-    }
+
 
     #endregion
 
diff --git a/src/Finance/Forecasting/Transformers/PatchTST.cs b/src/Finance/Forecasting/Transformers/PatchTST.cs
index 5b32ec8470..c0c84cb6bb 100644
--- a/src/Finance/Forecasting/Transformers/PatchTST.cs
+++ b/src/Finance/Forecasting/Transformers/PatchTST.cs
@@ -601,43 +601,6 @@ public override ModelMetadata<T> GetModelMetadata()
         return metadata;
     }
 
-    /// <summary>
-    /// Creates a new instance of this model with the same configuration.
-    /// </summary>
-    /// <returns>A new PatchTST instance with identical settings.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> This method creates a fresh copy of the model with the same
-    /// architecture and configuration, but with newly initialized parameters.
-    /// </para>
-    /// <para>
-    /// This is useful for:
-    /// <list type="bullet">
-    /// <item>Creating multiple models for ensemble methods</item>
-    /// <item>Implementing cross-validation where you need a fresh model for each fold</item>
-    /// <item>Resetting a model to start training from scratch</item>
-    /// </list>
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (UseNativeMode)
-        {
-            return new PatchTST<T>(
-                Architecture, SequenceLength, PredictionHorizon, NumFeatures,
-                _patchSize, _stride, _numLayers, _numHeads, _modelDimension, _feedForwardDimension,
-                _channelIndependent, _useInstanceNormalization, _dropout,
-                _optimizer, LossFunction);
-        }
-        else
-        {
-            return new PatchTST<T>(
-                Architecture, OnnxModelPath ?? string.Empty,
-                SequenceLength, PredictionHorizon, NumFeatures, _patchSize, _stride,
-                _optimizer, LossFunction);
-        }
-    }
-
     /// <summary>
     /// Writes network-specific configuration data during serialization.
     /// </summary>
@@ -653,18 +616,7 @@ protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
     /// later, the corresponding DeserializeNetworkSpecificData method reads it back.
     /// </para>
     /// </remarks>
-    protected override void SerializeModelSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_patchSize);
-        writer.Write(_stride);
-        writer.Write(_numLayers);
-        writer.Write(_numHeads);
-        writer.Write(_modelDimension);
-        writer.Write(_feedForwardDimension);
-        writer.Write(_channelIndependent);
-        writer.Write(_useInstanceNormalization);
-        writer.Write(_dropout);
-    }
+
 
     /// <summary>
     /// Reads network-specific configuration data during deserialization.
@@ -677,23 +629,7 @@ protected override void SerializeModelSpecificData(BinaryWriter writer)
     /// that were saved during serialization and restores the model state.
     /// </para>
     /// </remarks>
-    protected override void DeserializeModelSpecificData(BinaryReader reader)
-    {
-        _patchSize = reader.ReadInt32();
-        _stride = reader.ReadInt32();
-        _numLayers = reader.ReadInt32();
-        _numHeads = reader.ReadInt32();
-        _modelDimension = reader.ReadInt32();
-        _feedForwardDimension = reader.ReadInt32();
-        _channelIndependent = reader.ReadBoolean();
-        _useInstanceNormalization = reader.ReadBoolean();
-        _dropout = reader.ReadDouble();
-
-        // Re-bind cached layer references (_patchEmbedding, _encoderLayers,
-        // _finalNorm, _outputProjection) to the deserialized layers so a clone
-        // runs on the loaded weights, not construction-time random init.
-        ExtractLayerReferences();
-    }
+
 
     #endregion
 
diff --git a/src/Finance/Forecasting/Transformers/TFT.cs b/src/Finance/Forecasting/Transformers/TFT.cs
index 5508f8ec2e..3c0356d8c8 100644
--- a/src/Finance/Forecasting/Transformers/TFT.cs
+++ b/src/Finance/Forecasting/Transformers/TFT.cs
@@ -529,34 +529,6 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    /// <summary>
-    /// Creates a new instance of this model with the same configuration.
-    /// </summary>
-    /// <returns>A new TFT model instance.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> This creates a fresh copy of the model with the same settings
-    /// but new (randomly initialized) weights. Useful for ensemble training or cross-validation.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var options = new TemporalFusionTransformerOptions<T>
-        {
-            LookbackWindow = _sequenceLength,
-            ForecastHorizon = _predictionHorizon,
-            HiddenSize = _hiddenSize,
-            NumAttentionHeads = _numHeads,
-            NumLayers = _numLayers,
-            DropoutRate = _dropout,
-            QuantileLevels = _quantileLevels,
-            UseVariableSelection = _useVariableSelection,
-            StaticCovariateSize = _staticCovariateSize
-        };
-
-        return new TFT<T>(Architecture, options);
-    }
-
     /// <summary>
     /// Writes TFT-specific configuration during serialization.
     /// </summary>
@@ -567,20 +539,7 @@ protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
     /// to a file so the model can be loaded later with the same configuration.
     /// </para>
     /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_sequenceLength);
-        writer.Write(_predictionHorizon);
-        writer.Write(_hiddenSize);
-        writer.Write(_numHeads);
-        writer.Write(_numLayers);
-        writer.Write(_dropout);
-        writer.Write(_quantileLevels.Length);
-        foreach (var q in _quantileLevels)
-            writer.Write(q);
-        writer.Write(_useVariableSelection);
-        writer.Write(_staticCovariateSize);
-    }
+
 
     /// <summary>
     /// Reads TFT-specific configuration during deserialization.
@@ -592,26 +551,7 @@ protected override void SerializeNetworkSpecificData(BinaryWriter writer)
     /// and restores the model configuration.
     /// </para>
     /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _sequenceLength = reader.ReadInt32();
-        _predictionHorizon = reader.ReadInt32();
-        _hiddenSize = reader.ReadInt32();
-        _numHeads = reader.ReadInt32();
-        _numLayers = reader.ReadInt32();
-        _dropout = reader.ReadDouble();
-        int quantileCount = reader.ReadInt32();
-        _quantileLevels = new double[quantileCount];
-        for (int i = 0; i < quantileCount; i++)
-            _quantileLevels[i] = reader.ReadDouble();
-        _useVariableSelection = reader.ReadBoolean();
-        _staticCovariateSize = reader.ReadInt32();
-
-        // Re-bind cached layer references (variable-selection, LSTM enc/dec,
-        // _grnLayers, attention, output) to the deserialized weight-loaded layers
-        // so a clone runs on the loaded weights, not construction-time random init.
-        ExtractLayerReferences();
-    }
+
 
     #endregion
 
diff --git a/src/Finance/Forecasting/Transformers/TSMixer.cs b/src/Finance/Forecasting/Transformers/TSMixer.cs
index 9db385e89f..8cb00e1c96 100644
--- a/src/Finance/Forecasting/Transformers/TSMixer.cs
+++ b/src/Finance/Forecasting/Transformers/TSMixer.cs
@@ -589,34 +589,6 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    /// <summary>
-    /// Creates a new instance of this network type.
-    /// </summary>
-    /// <returns>A new TSMixer instance.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> This factory method creates a copy of the model structure,
-    /// useful for ensemble methods or hyperparameter search.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var options = new TSMixerOptions<T>
-        {
-            SequenceLength = _sequenceLength,
-            PredictionHorizon = _predictionHorizon,
-            NumFeatures = _numFeatures,
-            HiddenDimension = _hiddenDim,
-            NumBlocks = _numBlocks,
-            FeedForwardExpansion = _feedForwardExpansion,
-            FeaturesFirst = _featuresFirst,
-            UseRevIN = _useRevIN,
-            Dropout = _dropout
-        };
-
-        return new TSMixer<T>(Architecture, options);
-    }
-
     /// <summary>
     /// Serializes network-specific data for persistence.
     /// </summary>
@@ -627,19 +599,7 @@ protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
     /// into a format that can be saved to disk and loaded later.
     /// </para>
     /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_sequenceLength);
-        writer.Write(_predictionHorizon);
-        writer.Write(_numFeatures);
-        writer.Write(_hiddenDim);
-        writer.Write(_numBlocks);
-        writer.Write(_feedForwardExpansion);
-        writer.Write(_featuresFirst);
-        writer.Write(_useRevIN);
-        writer.Write(_dropout);
-        writer.Write(_useNativeMode);
-    }
+
 
     /// <summary>
     /// Deserializes network-specific data from persistence.
@@ -651,19 +611,7 @@ protected override void SerializeNetworkSpecificData(BinaryWriter writer)
     /// from a saved format. Called when loading a model from disk.
     /// </para>
     /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _sequenceLength = reader.ReadInt32();
-        _predictionHorizon = reader.ReadInt32();
-        _numFeatures = reader.ReadInt32();
-        _hiddenDim = reader.ReadInt32();
-        _numBlocks = reader.ReadInt32();
-        _feedForwardExpansion = reader.ReadDouble();
-        _featuresFirst = reader.ReadBoolean();
-        _useRevIN = reader.ReadBoolean();
-        _dropout = reader.ReadDouble();
-        _useNativeMode = reader.ReadBoolean();
-    }
+
 
     #endregion
 
diff --git a/src/Finance/Forecasting/Transformers/TimesNet.cs b/src/Finance/Forecasting/Transformers/TimesNet.cs
index 2034985eed..fa5fe2b38e 100644
--- a/src/Finance/Forecasting/Transformers/TimesNet.cs
+++ b/src/Finance/Forecasting/Transformers/TimesNet.cs
@@ -604,35 +604,6 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    /// <summary>
-    /// Creates a new instance of this model with the same configuration.
-    /// </summary>
-    /// <returns>A new TimesNet model instance.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> This creates a fresh copy of the model with the same settings
-    /// but new (randomly initialized) weights. Useful for ensemble training or cross-validation.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var options = new TimesNetOptions<T>
-        {
-            SequenceLength = _sequenceLength,
-            PredictionHorizon = _predictionHorizon,
-            NumFeatures = _numFeatures,
-            ModelDimension = _modelDimension,
-            FeedForwardDimension = _feedForwardDimension,
-            NumLayers = _numLayers,
-            TopK = _topK,
-            ConvKernelSize = _convKernelSize,
-            Dropout = _dropout,
-            UseInstanceNormalization = _useInstanceNormalization
-        };
-
-        return new TimesNet<T>(Architecture, options);
-    }
-
     /// <summary>
     /// Writes TimesNet-specific configuration during serialization.
     /// </summary>
@@ -643,19 +614,7 @@ protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
     /// to a file so the model can be loaded later with the same configuration.
     /// </para>
     /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_sequenceLength);
-        writer.Write(_predictionHorizon);
-        writer.Write(_numFeatures);
-        writer.Write(_modelDimension);
-        writer.Write(_feedForwardDimension);
-        writer.Write(_numLayers);
-        writer.Write(_topK);
-        writer.Write(_convKernelSize);
-        writer.Write(_dropout);
-        writer.Write(_useInstanceNormalization);
-    }
+
 
     /// <summary>
     /// Reads TimesNet-specific configuration during deserialization.
@@ -667,33 +626,7 @@ protected override void SerializeNetworkSpecificData(BinaryWriter writer)
     /// and restores the model configuration.
     /// </para>
     /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _sequenceLength = reader.ReadInt32();
-        _predictionHorizon = reader.ReadInt32();
-        _numFeatures = reader.ReadInt32();
-        _modelDimension = reader.ReadInt32();
-        _feedForwardDimension = reader.ReadInt32();
-        _numLayers = reader.ReadInt32();
-        _topK = reader.ReadInt32();
-        _convKernelSize = reader.ReadInt32();
-        _dropout = reader.ReadDouble();
-        _useInstanceNormalization = reader.ReadBoolean();
-
-        // Re-bind the typed layer-reference fields against the freshly
-        // deserialized Layers list. Without this, Forward() sees null for
-        // _embeddingLayer / _outputProjection / etc. and short-circuits to
-        // returning the input unchanged — which makes the cloned network
-        // produce all-zero output and breaks Clone_ShouldProduceIdenticalOutput.
-        _embeddingLayer = null;
-        _convLayers.Clear();
-        _ffnLayers.Clear();
-        _dropoutLayers.Clear();
-        _normLayers.Clear();
-        _finalNorm = null;
-        _outputProjection = null;
-        ExtractLayerReferences();
-    }
+
 
     #endregion
 
diff --git a/src/Finance/Graph/DCRNN.cs b/src/Finance/Graph/DCRNN.cs
index 90222f0d98..2b548eb772 100644
--- a/src/Finance/Graph/DCRNN.cs
+++ b/src/Finance/Graph/DCRNN.cs
@@ -633,20 +633,6 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    /// <summary>
-    /// Creates a new instance with the same configuration.
-    /// </summary>
-    /// <returns>A new DCRNN instance.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> In the DCRNN model, CreateNewInstance builds and wires up model components. This sets up the DCRNN architecture before use.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new DCRNN<T>(Architecture, _options, _adjacencyMatrix);
-    }
-
     /// <summary>
     /// Serializes DCRNN-specific data.
     /// </summary>
@@ -656,38 +642,7 @@ protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
     /// <b>For Beginners:</b> In the DCRNN model, SerializeNetworkSpecificData saves or restores model-specific settings. This lets the DCRNN architecture be reused later.
     /// </para>
     /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_sequenceLength);
-        writer.Write(_forecastHorizon);
-        writer.Write(_numNodes);
-        writer.Write(_numFeatures);
-        writer.Write(_hiddenDimension);
-        writer.Write(_numEncoderLayers);
-        writer.Write(_numDecoderLayers);
-        writer.Write(_diffusionSteps);
-        writer.Write(_trainingStep);
-
-        // Serialize diffusion matrices
-        if (_forwardDiffusion is not null && _backwardDiffusion is not null)
-        {
-            writer.Write(true);
-            int n = _forwardDiffusion.GetLength(0);
-            writer.Write(n);
-            for (int i = 0; i < n; i++)
-            {
-                for (int j = 0; j < n; j++)
-                {
-                    writer.Write(_forwardDiffusion[i, j]);
-                    writer.Write(_backwardDiffusion[i, j]);
-                }
-            }
-        }
-        else
-        {
-            writer.Write(false);
-        }
-    }
+
 
     /// <summary>
     /// Deserializes DCRNN-specific data.
@@ -698,36 +653,7 @@ protected override void SerializeNetworkSpecificData(BinaryWriter writer)
     /// <b>For Beginners:</b> In the DCRNN model, DeserializeNetworkSpecificData saves or restores model-specific settings. This lets the DCRNN architecture be reused later.
     /// </para>
     /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _sequenceLength = reader.ReadInt32();
-        _forecastHorizon = reader.ReadInt32();
-        _numNodes = reader.ReadInt32();
-        int numNodes = _numNodes;
-        _numFeatures = reader.ReadInt32();
-        _hiddenDimension = reader.ReadInt32();
-        _numEncoderLayers = reader.ReadInt32();
-        _numDecoderLayers = reader.ReadInt32();
-        _diffusionSteps = reader.ReadInt32();
-        _trainingStep = reader.ReadInt32();
-
-        bool hasDiffusion = reader.ReadBoolean();
-        if (hasDiffusion)
-        {
-            int n = reader.ReadInt32();
-            _forwardDiffusion = new double[n, n];
-            _backwardDiffusion = new double[n, n];
-            for (int i = 0; i < n; i++)
-            {
-                for (int j = 0; j < n; j++)
-                {
-                    _forwardDiffusion[i, j] = reader.ReadDouble();
-                    _backwardDiffusion[i, j] = reader.ReadDouble();
-                }
-            }
-            ComputeDiffusionPowers();
-        }
-    }
+
 
     #endregion
 
diff --git a/src/Finance/Graph/GraphWaveNet.cs b/src/Finance/Graph/GraphWaveNet.cs
index 6a7bebc618..23cd64f5a4 100644
--- a/src/Finance/Graph/GraphWaveNet.cs
+++ b/src/Finance/Graph/GraphWaveNet.cs
@@ -680,19 +680,6 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    /// <summary>
-    /// Creates a new instance.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> In the GraphWaveNet model, CreateNewInstance builds and wires up model components. This sets up the GraphWaveNet architecture before use.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new GraphWaveNet<T>(Architecture, _options, _predefinedAdjacency);
-    }
-
     /// <summary>
     /// Serializes model-specific data.
     /// </summary>
@@ -701,38 +688,7 @@ protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
     /// <b>For Beginners:</b> In the GraphWaveNet model, SerializeNetworkSpecificData saves or restores model-specific settings. This lets the GraphWaveNet architecture be reused later.
     /// </para>
     /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_sequenceLength);
-        writer.Write(_forecastHorizon);
-        writer.Write(_numNodes);
-        writer.Write(_numFeatures);
-        writer.Write(_residualChannels);
-        writer.Write(_skipChannels);
-        writer.Write(_endChannels);
-        writer.Write(_nodeEmbeddingDim);
-        writer.Write(_numBlocks);
-        writer.Write(_layersPerBlock);
-        writer.Write(_diffusionSteps);
-        writer.Write(_useAdaptiveGraph);
-        writer.Write(_usePredefinedGraph);
-        writer.Write(_numSamples);
-
-        if (_nodeEmbedding1 is not null && _nodeEmbedding2 is not null)
-        {
-            writer.Write(true);
-            for (int i = 0; i < _numNodes; i++)
-                for (int j = 0; j < _nodeEmbeddingDim; j++)
-                {
-                    writer.Write(_nodeEmbedding1[i, j]);
-                    writer.Write(_nodeEmbedding2[i, j]);
-                }
-        }
-        else
-        {
-            writer.Write(false);
-        }
-    }
+
 
     /// <summary>
     /// Deserializes model-specific data.
@@ -742,39 +698,7 @@ protected override void SerializeNetworkSpecificData(BinaryWriter writer)
     /// <b>For Beginners:</b> In the GraphWaveNet model, DeserializeNetworkSpecificData saves or restores model-specific settings. This lets the GraphWaveNet architecture be reused later.
     /// </para>
     /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _sequenceLength = reader.ReadInt32();
-        _forecastHorizon = reader.ReadInt32();
-        _numNodes = reader.ReadInt32();
-        int numNodes = _numNodes;
-        _numFeatures = reader.ReadInt32();
-        _residualChannels = reader.ReadInt32();
-        _dilationChannels = reader.ReadInt32();
-        _skipChannels = reader.ReadInt32();
-        _nodeEmbeddingDim = reader.ReadInt32();
-        int embeddingDim = _nodeEmbeddingDim;
-        _numBlocks = reader.ReadInt32();
-        _layersPerBlock = reader.ReadInt32();
-        _diffusionSteps = reader.ReadInt32();
-        _useAdaptiveGraph = reader.ReadBoolean();
-        _usePredefinedGraph = reader.ReadBoolean();
-        _numSamples = reader.ReadInt32();
-
-        bool hasEmbeddings = reader.ReadBoolean();
-        if (hasEmbeddings)
-        {
-            _nodeEmbedding1 = new double[numNodes, embeddingDim];
-            _nodeEmbedding2 = new double[numNodes, embeddingDim];
-            for (int i = 0; i < numNodes; i++)
-                for (int j = 0; j < embeddingDim; j++)
-                {
-                    _nodeEmbedding1[i, j] = reader.ReadDouble();
-                    _nodeEmbedding2[i, j] = reader.ReadDouble();
-                }
-            UpdateAdaptiveAdjacency();
-        }
-    }
+
 
     #endregion
 
diff --git a/src/Finance/Graph/MTGNN.cs b/src/Finance/Graph/MTGNN.cs
index b9638ab1f6..47e1f26383 100644
--- a/src/Finance/Graph/MTGNN.cs
+++ b/src/Finance/Graph/MTGNN.cs
@@ -743,20 +743,6 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    /// <summary>
-    /// Creates a new instance with the same configuration.
-    /// </summary>
-    /// <returns>A new MTGNN instance.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> In the MTGNN model, CreateNewInstance builds and wires up model components. This sets up the MTGNN architecture before use.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new MTGNN<T>(Architecture, _options, _predefinedAdjacency);
-    }
-
     /// <summary>
     /// Serializes MTGNN-specific data.
     /// </summary>
@@ -766,41 +752,7 @@ protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
     /// <b>For Beginners:</b> In the MTGNN model, SerializeNetworkSpecificData saves or restores model-specific settings. This lets the MTGNN architecture be reused later.
     /// </para>
     /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_sequenceLength);
-        writer.Write(_forecastHorizon);
-        writer.Write(_numNodes);
-        writer.Write(_numFeatures);
-        writer.Write(_hiddenDimension);
-        writer.Write(_nodeEmbeddingDim);
-        writer.Write(_numLayers);
-        writer.Write(_mixHopDepth);
-        writer.Write(_temporalKernelSize);
-        writer.Write(_dilationFactor);
-        writer.Write(_usePredefinedGraph);
-        writer.Write(_useSubgraphSampling);
-        writer.Write(_subgraphSize);
-        writer.Write(_numSamples);
-
-        // Serialize node embeddings
-        if (_nodeEmbedding1 is not null && _nodeEmbedding2 is not null)
-        {
-            writer.Write(true);
-            for (int i = 0; i < _numNodes; i++)
-            {
-                for (int j = 0; j < _nodeEmbeddingDim; j++)
-                {
-                    writer.Write(_nodeEmbedding1[i, j]);
-                    writer.Write(_nodeEmbedding2[i, j]);
-                }
-            }
-        }
-        else
-        {
-            writer.Write(false);
-        }
-    }
+
 
     /// <summary>
     /// Deserializes MTGNN-specific data.
@@ -811,42 +763,7 @@ protected override void SerializeNetworkSpecificData(BinaryWriter writer)
     /// <b>For Beginners:</b> In the MTGNN model, DeserializeNetworkSpecificData saves or restores model-specific settings. This lets the MTGNN architecture be reused later.
     /// </para>
     /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _sequenceLength = reader.ReadInt32();
-        _forecastHorizon = reader.ReadInt32();
-        _numNodes = reader.ReadInt32();
-        int numNodes = _numNodes;
-        _numFeatures = reader.ReadInt32();
-        _hiddenDimension = reader.ReadInt32();
-        _nodeEmbeddingDim = reader.ReadInt32();
-        int embeddingDim = _nodeEmbeddingDim;
-        _numLayers = reader.ReadInt32();
-        _mixHopDepth = reader.ReadInt32();
-        _temporalKernelSize = reader.ReadInt32();
-        _dilationFactor = reader.ReadInt32();
-        _usePredefinedGraph = reader.ReadBoolean();
-        _useSubgraphSampling = reader.ReadBoolean();
-        _subgraphSize = reader.ReadInt32();
-        _numSamples = reader.ReadInt32();
-
-        // Deserialize node embeddings
-        bool hasEmbeddings = reader.ReadBoolean();
-        if (hasEmbeddings)
-        {
-            _nodeEmbedding1 = new double[numNodes, embeddingDim];
-            _nodeEmbedding2 = new double[numNodes, embeddingDim];
-            for (int i = 0; i < numNodes; i++)
-            {
-                for (int j = 0; j < embeddingDim; j++)
-                {
-                    _nodeEmbedding1[i, j] = reader.ReadDouble();
-                    _nodeEmbedding2[i, j] = reader.ReadDouble();
-                }
-            }
-            UpdateAdaptiveAdjacency();
-        }
-    }
+
 
     #endregion
 
diff --git a/src/Finance/Graph/RelationalGCN.cs b/src/Finance/Graph/RelationalGCN.cs
index 0a30a0cee5..35e08009d6 100644
--- a/src/Finance/Graph/RelationalGCN.cs
+++ b/src/Finance/Graph/RelationalGCN.cs
@@ -688,20 +688,6 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    /// <summary>
-    /// Creates a new instance with the same configuration.
-    /// </summary>
-    /// <returns>A new RelationalGCN instance.</returns>
-    /// <remarks>
-    /// <para><b>For Beginners:</b> Creates a fresh model with the same architecture
-    /// and options but randomly reinitialized weights.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new RelationalGCN<T>(Architecture, _options, _relationAdjacencies);
-    }
-
     /// <summary>
     /// Serializes RelationalGCN-specific data.
     /// </summary>
@@ -711,56 +697,7 @@ protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
     /// (basis matrices, relation coefficients) to disk for later loading.
     /// </para>
     /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_sequenceLength);
-        writer.Write(_forecastHorizon);
-        writer.Write(_numNodes);
-        writer.Write(_numFeatures);
-        writer.Write(_numRelations);
-        writer.Write(_hiddenDimension);
-        writer.Write(_numLayers);
-        writer.Write(_numBases);
-        writer.Write(_numBlocks);
-        writer.Write(_regularization);
-        writer.Write(_dropoutRate);
-        writer.Write(_useBasisDecomposition);
-        writer.Write(_useBlockDecomposition);
-        writer.Write(_useSelfLoop);
-        writer.Write(_aggregation);
-        writer.Write(_numSamples);
-
-        // Serialize basis decomposition if used
-        if (_useBasisDecomposition && _basisMatrices is not null && _relationCoefficients is not null)
-        {
-            writer.Write(true);
 
-            // Write basis matrices
-            for (int b = 0; b < _numBases; b++)
-            {
-                for (int i = 0; i < _hiddenDimension; i++)
-                {
-                    for (int j = 0; j < _hiddenDimension; j++)
-                    {
-                        writer.Write(_basisMatrices[b, i][j]);
-                    }
-                }
-            }
-
-            // Write relation coefficients
-            for (int r = 0; r < _numRelations; r++)
-            {
-                for (int b = 0; b < _numBases; b++)
-                {
-                    writer.Write(_relationCoefficients[r, b]);
-                }
-            }
-        }
-        else
-        {
-            writer.Write(false);
-        }
-    }
 
     /// <summary>
     /// Deserializes RelationalGCN-specific data.
@@ -771,57 +708,7 @@ protected override void SerializeNetworkSpecificData(BinaryWriter writer)
     /// from disk, restoring the model to its saved state.
     /// </para>
     /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _sequenceLength = reader.ReadInt32();
-        _forecastHorizon = reader.ReadInt32();
-        _numNodes = reader.ReadInt32();
-        int numNodes = _numNodes;
-        _numFeatures = reader.ReadInt32();
-        _numRelations = reader.ReadInt32();
-        int numRelations = _numRelations;
-        _hiddenDimension = reader.ReadInt32();
-        int hiddenDimension = _hiddenDimension;
-        _numLayers = reader.ReadInt32();
-        _numBases = reader.ReadInt32();
-        int numBases = _numBases;
-        _numBlocks = reader.ReadInt32();
-        _regularization = reader.ReadDouble();
-        _dropoutRate = reader.ReadDouble();
-        _useBasisDecomposition = reader.ReadBoolean();
-        bool useBasisDecomposition = _useBasisDecomposition;
-        _useBlockDecomposition = reader.ReadBoolean();
-        _useSelfLoop = reader.ReadBoolean();
-        _aggregation = reader.ReadString();
-        _numSamples = reader.ReadInt32();
-
-        // Deserialize basis decomposition if present
-        bool hasBasis = reader.ReadBoolean();
-        if (hasBasis && useBasisDecomposition)
-        {
-            _basisMatrices = new double[numBases, hiddenDimension][];
-            for (int b = 0; b < numBases; b++)
-            {
-                for (int i = 0; i < hiddenDimension; i++)
-                {
-                    _basisMatrices[b, i] = new double[hiddenDimension];
-                    for (int j = 0; j < hiddenDimension; j++)
-                    {
-                        _basisMatrices[b, i][j] = reader.ReadDouble();
-                    }
-                }
-            }
 
-            _relationCoefficients = new double[numRelations, numBases];
-            for (int r = 0; r < numRelations; r++)
-            {
-                for (int b = 0; b < numBases; b++)
-                {
-                    _relationCoefficients[r, b] = reader.ReadDouble();
-                }
-            }
-        }
-    }
 
     #endregion
 
diff --git a/src/Finance/Graph/STGNN.cs b/src/Finance/Graph/STGNN.cs
index e8b937995f..fbb3a526e3 100644
--- a/src/Finance/Graph/STGNN.cs
+++ b/src/Finance/Graph/STGNN.cs
@@ -518,20 +518,6 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    /// <summary>
-    /// Creates a new instance with the same configuration.
-    /// </summary>
-    /// <returns>A new STGNN instance.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> In the STGNN model, CreateNewInstance builds and wires up model components. This sets up the STGNN architecture before use.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new STGNN<T>(Architecture, _options, _adjacencyMatrix);
-    }
-
     /// <summary>
     /// Serializes STGNN-specific data.
     /// </summary>
@@ -541,20 +527,7 @@ protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
     /// <b>For Beginners:</b> In the STGNN model, SerializeNetworkSpecificData saves or restores model-specific settings. This lets the STGNN architecture be reused later.
     /// </para>
     /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_sequenceLength);
-        writer.Write(_forecastHorizon);
-        writer.Write(_numNodes);
-        writer.Write(_numFeatures);
-        writer.Write(_hiddenDimension);
-        writer.Write(_numSpatialLayers);
-        writer.Write(_numTemporalLayers);
-        writer.Write(_graphConvType);
-        writer.Write(_useGatedFusion);
-        writer.Write(_useResidualConnections);
-        writer.Write(_numSamples);
-    }
+
 
     /// <summary>
     /// Deserializes STGNN-specific data.
@@ -565,20 +538,7 @@ protected override void SerializeNetworkSpecificData(BinaryWriter writer)
     /// <b>For Beginners:</b> In the STGNN model, DeserializeNetworkSpecificData saves or restores model-specific settings. This lets the STGNN architecture be reused later.
     /// </para>
     /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _sequenceLength = reader.ReadInt32();
-        _forecastHorizon = reader.ReadInt32();
-        _numNodes = reader.ReadInt32();
-        _numFeatures = reader.ReadInt32();
-        _hiddenDimension = reader.ReadInt32();
-        _numSpatialLayers = reader.ReadInt32();
-        _numTemporalLayers = reader.ReadInt32();
-        _graphConvType = reader.ReadString();
-        _useGatedFusion = reader.ReadBoolean();
-        _useResidualConnections = reader.ReadBoolean();
-        _numSamples = reader.ReadInt32();
-    }
+
 
     #endregion
 
diff --git a/src/Finance/Graph/TemporalGCN.cs b/src/Finance/Graph/TemporalGCN.cs
index 85188d659c..c47e55255c 100644
--- a/src/Finance/Graph/TemporalGCN.cs
+++ b/src/Finance/Graph/TemporalGCN.cs
@@ -666,20 +666,6 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    /// <summary>
-    /// Creates a new instance with the same configuration.
-    /// </summary>
-    /// <returns>A new TemporalGCN instance.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> In the TemporalGCN model, CreateNewInstance builds and wires up model components. This sets up the TemporalGCN architecture before use.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new TemporalGCN<T>(Architecture, _options, _adjacencyMatrix);
-    }
-
     /// <summary>
     /// Serializes TemporalGCN-specific data.
     /// </summary>
@@ -689,21 +675,7 @@ protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
     /// <b>For Beginners:</b> In the TemporalGCN model, SerializeNetworkSpecificData saves or restores model-specific settings. This lets the TemporalGCN architecture be reused later.
     /// </para>
     /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_sequenceLength);
-        writer.Write(_forecastHorizon);
-        writer.Write(_numNodes);
-        writer.Write(_numFeatures);
-        writer.Write(_hiddenDimension);
-        writer.Write(_numGCNLayers);
-        writer.Write(_numTemporalLayers);
-        writer.Write(_chebyshevOrder);
-        writer.Write(_temporalCellType);
-        writer.Write(_useResidualConnections);
-        writer.Write(_useBatchNormalization);
-        writer.Write(_numSamples);
-    }
+
 
     /// <summary>
     /// Deserializes TemporalGCN-specific data.
@@ -714,21 +686,7 @@ protected override void SerializeNetworkSpecificData(BinaryWriter writer)
     /// <b>For Beginners:</b> In the TemporalGCN model, DeserializeNetworkSpecificData saves or restores model-specific settings. This lets the TemporalGCN architecture be reused later.
     /// </para>
     /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _sequenceLength = reader.ReadInt32();
-        _forecastHorizon = reader.ReadInt32();
-        _numNodes = reader.ReadInt32();
-        _numFeatures = reader.ReadInt32();
-        _hiddenDimension = reader.ReadInt32();
-        _numGCNLayers = reader.ReadInt32();
-        _numTemporalLayers = reader.ReadInt32();
-        _chebyshevOrder = reader.ReadInt32();
-        _temporalCellType = reader.ReadString();
-        _useResidualConnections = reader.ReadBoolean();
-        _useBatchNormalization = reader.ReadBoolean();
-        _numSamples = reader.ReadInt32();
-    }
+
 
     #endregion
 
diff --git a/src/Finance/NLP/BloombergGPT.cs b/src/Finance/NLP/BloombergGPT.cs
index 5ba18910df..577ef54ad0 100644
--- a/src/Finance/NLP/BloombergGPT.cs
+++ b/src/Finance/NLP/BloombergGPT.cs
@@ -220,29 +220,6 @@ protected override void TrainCore(Tensor<T> input, Tensor<T> target, Tensor<T> o
 
     // UpdateParameters re-sliced the flat vector across Layers by hand -- the base walks
     // exactly the same enumeration, so this said nothing the base does not already say.
-    /// <summary>
-    /// Executes CreateNewInstance for the BloombergGPT.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> In the BloombergGPT model, CreateNewInstance builds and wires up model components. This sets up the BloombergGPT architecture before use.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var options = new ModelOptions.BloombergGPTOptions<T>
-        {
-            MaxSequenceLength = MaxSequenceLength,
-            VocabularySize = VocabularySize,
-            HiddenDimension = HiddenDimension,
-            NumLayers = _options.NumLayers,
-            NumAttentionHeads = _options.NumAttentionHeads,
-            IntermediateDimension = _options.IntermediateDimension,
-            DropoutRate = _options.DropoutRate,
-            TaskType = _options.TaskType
-        };
-        return new BloombergGPT<T>(Architecture, options, _optimizer, LossFunction);
-    }
 
     /// <summary>
     /// Executes SerializeModelSpecificData for the BloombergGPT.
@@ -252,10 +229,7 @@ protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
     /// <b>For Beginners:</b> In the BloombergGPT model, SerializeModelSpecificData saves or restores model-specific settings. This lets the BloombergGPT architecture be reused later.
     /// </para>
     /// </remarks>
-    protected override void SerializeModelSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_dropout);
-    }
+
 
     /// <summary>
     /// Executes DeserializeModelSpecificData for the BloombergGPT.
@@ -265,10 +239,7 @@ protected override void SerializeModelSpecificData(BinaryWriter writer)
     /// <b>For Beginners:</b> In the BloombergGPT model, DeserializeModelSpecificData saves or restores model-specific settings. This lets the BloombergGPT architecture be reused later.
     /// </para>
     /// </remarks>
-    protected override void DeserializeModelSpecificData(BinaryReader reader)
-    {
-        _dropout = reader.ReadDouble();
-    }
+
 
     /// <summary>
     /// Executes ForecastNative for the BloombergGPT.
diff --git a/src/Finance/NLP/FinBERT.cs b/src/Finance/NLP/FinBERT.cs
index f6a1643c9d..7a16e018fa 100644
--- a/src/Finance/NLP/FinBERT.cs
+++ b/src/Finance/NLP/FinBERT.cs
@@ -463,20 +463,6 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    /// <summary>
-    /// Creates a new instance with the same configuration.
-    /// </summary>
-    /// <returns>A new FinBERT instance.</returns>
-    /// <remarks>
-    /// <para><b>For Beginners:</b> Creates a fresh model with the same architecture
-    /// and options but randomly reinitialized weights.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new FinBERT<T>(Architecture, _options);
-    }
-
     /// <summary>
     /// Serializes FinBERT-specific data.
     /// </summary>
@@ -486,25 +472,7 @@ protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
     /// for later loading.
     /// </para>
     /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_maxSequenceLength);
-        writer.Write(_vocabularySize);
-        writer.Write(_hiddenDimension);
-        writer.Write(_numAttentionHeads);
-        writer.Write(_intermediateDimension);
-        writer.Write(_numLayers);
-        writer.Write(_numSentimentClasses);
-        writer.Write(_dropoutRate);
-
-        // Serialize vocabulary
-        writer.Write(_vocabulary.Count);
-        foreach (var kvp in _vocabulary)
-        {
-            writer.Write(kvp.Key);
-            writer.Write(kvp.Value);
-        }
-    }
+
 
     /// <summary>
     /// Deserializes FinBERT-specific data.
@@ -515,27 +483,7 @@ protected override void SerializeNetworkSpecificData(BinaryWriter writer)
     /// from disk.
     /// </para>
     /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _maxSequenceLength = reader.ReadInt32();
-        _vocabularySize = reader.ReadInt32();
-        _hiddenDimension = reader.ReadInt32();
-        _numAttentionHeads = reader.ReadInt32();
-        _intermediateDimension = reader.ReadInt32();
-        _numLayers = reader.ReadInt32();
-        _numSentimentClasses = reader.ReadInt32();
-        _dropoutRate = reader.ReadDouble();
-
-        // Deserialize vocabulary
-        int vocabCount = reader.ReadInt32();
-        _vocabulary.Clear();
-        for (int i = 0; i < vocabCount; i++)
-        {
-            string key = reader.ReadString();
-            int value = reader.ReadInt32();
-            _vocabulary[key] = value;
-        }
-    }
+
 
     #endregion
 
diff --git a/src/Finance/NLP/FinBERTTone.cs b/src/Finance/NLP/FinBERTTone.cs
index b96e760470..6f7cc922f7 100644
--- a/src/Finance/NLP/FinBERTTone.cs
+++ b/src/Finance/NLP/FinBERTTone.cs
@@ -186,19 +186,6 @@ protected override void TrainCore(Tensor<T> input, Tensor<T> target, Tensor<T> o
 
     // UpdateParameters re-sliced the flat vector across Layers by hand -- the base walks
     // exactly the same enumeration, so this said nothing the base does not already say.
-    /// <summary>
-    /// Executes CreateNewInstance for the FinBERTTone.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> In the FinBERTTone model, CreateNewInstance builds and wires up model components. This sets up the FinBERTTone architecture before use.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new FinBERTTone<T>(
-            Architecture, new ModelOptions.FinBERTToneOptions<T>(_options), _optimizer, LossFunction);
-    }
 
     /// <summary>
     /// Executes SerializeModelSpecificData for the FinBERTTone.
@@ -208,10 +195,7 @@ protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
     /// <b>For Beginners:</b> In the FinBERTTone model, SerializeModelSpecificData saves or restores model-specific settings. This lets the FinBERTTone architecture be reused later.
     /// </para>
     /// </remarks>
-    protected override void SerializeModelSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_dropout);
-    }
+
 
     /// <summary>
     /// Executes DeserializeModelSpecificData for the FinBERTTone.
@@ -221,10 +205,7 @@ protected override void SerializeModelSpecificData(BinaryWriter writer)
     /// <b>For Beginners:</b> In the FinBERTTone model, DeserializeModelSpecificData saves or restores model-specific settings. This lets the FinBERTTone architecture be reused later.
     /// </para>
     /// </remarks>
-    protected override void DeserializeModelSpecificData(BinaryReader reader)
-    {
-        _dropout = reader.ReadDouble();
-    }
+
 
     /// <summary>
     /// Executes ForecastNative for the FinBERTTone.
diff --git a/src/Finance/NLP/FinGPT.cs b/src/Finance/NLP/FinGPT.cs
index a69be98c85..a13d5bdf56 100644
--- a/src/Finance/NLP/FinGPT.cs
+++ b/src/Finance/NLP/FinGPT.cs
@@ -220,24 +220,6 @@ protected override void TrainCore(Tensor<T> input, Tensor<T> target, Tensor<T> o
 
     // UpdateParameters re-sliced the flat vector across Layers by hand -- the base walks
     // exactly the same enumeration, so this said nothing the base does not already say.
-    /// <summary>
-    /// Executes CreateNewInstance for the FinGPT.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> In the FinGPT model, CreateNewInstance builds and wires up model components. This sets up the FinGPT architecture before use.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var options = new ModelOptions.FinGPTOptions<T>
-        {
-            MaxSequenceLength = MaxSequenceLength,
-            VocabularySize = VocabularySize,
-            HiddenDimension = HiddenDimension
-        };
-        return new FinGPT<T>(Architecture, options, _optimizer, LossFunction);
-    }
 
     /// <summary>
     /// Executes SerializeModelSpecificData for the FinGPT.
@@ -247,10 +229,7 @@ protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
     /// <b>For Beginners:</b> In the FinGPT model, SerializeModelSpecificData saves or restores model-specific settings. This lets the FinGPT architecture be reused later.
     /// </para>
     /// </remarks>
-    protected override void SerializeModelSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_dropout);
-    }
+
 
     /// <summary>
     /// Executes DeserializeModelSpecificData for the FinGPT.
@@ -260,10 +239,7 @@ protected override void SerializeModelSpecificData(BinaryWriter writer)
     /// <b>For Beginners:</b> In the FinGPT model, DeserializeModelSpecificData saves or restores model-specific settings. This lets the FinGPT architecture be reused later.
     /// </para>
     /// </remarks>
-    protected override void DeserializeModelSpecificData(BinaryReader reader)
-    {
-        _dropout = reader.ReadDouble();
-    }
+
 
     /// <summary>
     /// Executes ForecastNative for the FinGPT.
diff --git a/src/Finance/NLP/FinMA.cs b/src/Finance/NLP/FinMA.cs
index 5e933654a4..7a08c25c5f 100644
--- a/src/Finance/NLP/FinMA.cs
+++ b/src/Finance/NLP/FinMA.cs
@@ -189,25 +189,6 @@ protected override void TrainCore(Tensor<T> input, Tensor<T> target, Tensor<T> o
 
     // UpdateParameters re-sliced the flat vector across Layers by hand -- the base walks
     // exactly the same enumeration, so this said nothing the base does not already say.
-    /// <summary>
-    /// Executes CreateNewInstance for the FinMA.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> In the FinMA model, CreateNewInstance builds and wires up model components. This sets up the FinMA architecture before use.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var options = new ModelOptions.FinMAOptions<T>
-        {
-            MaxSequenceLength = MaxSequenceLength,
-            NumAgents = _numAgents,
-            VocabularySize = VocabularySize,
-            HiddenDimension = HiddenDimension
-        };
-        return new FinMA<T>(Architecture, options, _optimizer, LossFunction);
-    }
 
     /// <summary>
     /// Executes SerializeModelSpecificData for the FinMA.
@@ -217,11 +198,7 @@ protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
     /// <b>For Beginners:</b> In the FinMA model, SerializeModelSpecificData saves or restores model-specific settings. This lets the FinMA architecture be reused later.
     /// </para>
     /// </remarks>
-    protected override void SerializeModelSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_dropout);
-        writer.Write(_numAgents);
-    }
+
 
     /// <summary>
     /// Executes DeserializeModelSpecificData for the FinMA.
@@ -231,11 +208,7 @@ protected override void SerializeModelSpecificData(BinaryWriter writer)
     /// <b>For Beginners:</b> In the FinMA model, DeserializeModelSpecificData saves or restores model-specific settings. This lets the FinMA architecture be reused later.
     /// </para>
     /// </remarks>
-    protected override void DeserializeModelSpecificData(BinaryReader reader)
-    {
-        _dropout = reader.ReadDouble();
-        _numAgents = reader.ReadInt32();
-    }
+
 
     /// <summary>
     /// Executes ForecastNative for the FinMA.
diff --git a/src/Finance/NLP/FinancialBERT.cs b/src/Finance/NLP/FinancialBERT.cs
index 9a66ec5341..149e2b2dec 100644
--- a/src/Finance/NLP/FinancialBERT.cs
+++ b/src/Finance/NLP/FinancialBERT.cs
@@ -178,19 +178,6 @@ protected override void TrainCore(Tensor<T> input, Tensor<T> target, Tensor<T> o
 
     // UpdateParameters re-sliced the flat vector across Layers by hand -- the base walks
     // exactly the same enumeration, so this said nothing the base does not already say.
-    /// <summary>
-    /// Executes CreateNewInstance for the FinancialBERT.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> In the FinancialBERT model, CreateNewInstance builds and wires up model components. This sets up the FinancialBERT architecture before use.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new FinancialBERT<T>(
-            Architecture, new ModelOptions.FinancialBERTOptions<T>(_options), _optimizer, LossFunction);
-    }
 
     /// <summary>
     /// Executes SerializeModelSpecificData for the FinancialBERT.
@@ -200,10 +187,7 @@ protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
     /// <b>For Beginners:</b> In the FinancialBERT model, SerializeModelSpecificData saves or restores model-specific settings. This lets the FinancialBERT architecture be reused later.
     /// </para>
     /// </remarks>
-    protected override void SerializeModelSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_dropout);
-    }
+
 
     /// <summary>
     /// Executes DeserializeModelSpecificData for the FinancialBERT.
@@ -213,10 +197,7 @@ protected override void SerializeModelSpecificData(BinaryWriter writer)
     /// <b>For Beginners:</b> In the FinancialBERT model, DeserializeModelSpecificData saves or restores model-specific settings. This lets the FinancialBERT architecture be reused later.
     /// </para>
     /// </remarks>
-    protected override void DeserializeModelSpecificData(BinaryReader reader)
-    {
-        _dropout = reader.ReadDouble();
-    }
+
 
     /// <summary>
     /// Executes ForecastNative for the FinancialBERT.
diff --git a/src/Finance/NLP/InvestLM.cs b/src/Finance/NLP/InvestLM.cs
index 4d39e96e5a..9da088ea9b 100644
--- a/src/Finance/NLP/InvestLM.cs
+++ b/src/Finance/NLP/InvestLM.cs
@@ -232,24 +232,6 @@ public override void Train(Tensor<T> input, Tensor<T> expected)
 
     // UpdateParameters re-sliced the flat vector across Layers by hand -- the base walks
     // exactly the same enumeration, so this said nothing the base does not already say.
-    /// <summary>
-    /// Executes CreateNewInstance for the InvestLM.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> In the InvestLM model, CreateNewInstance builds and wires up model components. This sets up the InvestLM architecture before use.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var options = new ModelOptions.InvestLMOptions<T>
-        {
-            MaxSequenceLength = MaxSequenceLength,
-            VocabularySize = VocabularySize,
-            HiddenDimension = HiddenDimension
-        };
-        return new InvestLM<T>(Architecture, options, _optimizer, LossFunction);
-    }
 
     /// <summary>
     /// Executes SerializeModelSpecificData for the InvestLM.
@@ -259,10 +241,7 @@ protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
     /// <b>For Beginners:</b> In the InvestLM model, SerializeModelSpecificData saves or restores model-specific settings. This lets the InvestLM architecture be reused later.
     /// </para>
     /// </remarks>
-    protected override void SerializeModelSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_dropout);
-    }
+
 
     /// <summary>
     /// Executes DeserializeModelSpecificData for the InvestLM.
@@ -272,10 +251,7 @@ protected override void SerializeModelSpecificData(BinaryWriter writer)
     /// <b>For Beginners:</b> In the InvestLM model, DeserializeModelSpecificData saves or restores model-specific settings. This lets the InvestLM architecture be reused later.
     /// </para>
     /// </remarks>
-    protected override void DeserializeModelSpecificData(BinaryReader reader)
-    {
-        _dropout = reader.ReadDouble();
-    }
+
 
     /// <summary>
     /// Executes ForecastNative for the InvestLM.
diff --git a/src/Finance/NLP/SECBERT.cs b/src/Finance/NLP/SECBERT.cs
index 09acfabeff..a15d8d5aaa 100644
--- a/src/Finance/NLP/SECBERT.cs
+++ b/src/Finance/NLP/SECBERT.cs
@@ -187,19 +187,6 @@ protected override void TrainCore(Tensor<T> input, Tensor<T> target, Tensor<T> o
 
     // UpdateParameters re-sliced the flat vector across Layers by hand -- the base walks
     // exactly the same enumeration, so this said nothing the base does not already say.
-    /// <summary>
-    /// Executes CreateNewInstance for the SECBERT.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> In the SECBERT model, CreateNewInstance builds and wires up model components. This sets up the SECBERT architecture before use.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new SECBERT<T>(
-            Architecture, new ModelOptions.SECBERTOptions<T>(_options), _optimizer, LossFunction);
-    }
 
     /// <summary>
     /// Executes SerializeModelSpecificData for the SECBERT.
@@ -209,10 +196,7 @@ protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
     /// <b>For Beginners:</b> In the SECBERT model, SerializeModelSpecificData saves or restores model-specific settings. This lets the SECBERT architecture be reused later.
     /// </para>
     /// </remarks>
-    protected override void SerializeModelSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_dropout);
-    }
+
 
     /// <summary>
     /// Executes DeserializeModelSpecificData for the SECBERT.
@@ -222,10 +206,7 @@ protected override void SerializeModelSpecificData(BinaryWriter writer)
     /// <b>For Beginners:</b> In the SECBERT model, DeserializeModelSpecificData saves or restores model-specific settings. This lets the SECBERT architecture be reused later.
     /// </para>
     /// </remarks>
-    protected override void DeserializeModelSpecificData(BinaryReader reader)
-    {
-        _dropout = reader.ReadDouble();
-    }
+
 
     /// <summary>
     /// Executes ForecastNative for the SECBERT.
diff --git a/src/Finance/Portfolio/BlackLittermanNeural.cs b/src/Finance/Portfolio/BlackLittermanNeural.cs
index e5001e7a49..6fac70ed01 100644
--- a/src/Finance/Portfolio/BlackLittermanNeural.cs
+++ b/src/Finance/Portfolio/BlackLittermanNeural.cs
@@ -45,7 +45,7 @@ namespace AiDotNet.Finance.Portfolio;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Global Portfolio Optimization", "https://doi.org/10.2469/faj.v48.n5.28")]
-public class BlackLittermanNeural<T> : PortfolioOptimizerBase<T>
+public partial class BlackLittermanNeural<T> : PortfolioOptimizerBase<T>
 {
     #region Shared Fields
 
@@ -183,26 +183,6 @@ public override Vector<T> OptimizePortfolio(Tensor<T> marketData)
 
     // UpdateParameters re-sliced the flat vector across Layers by hand -- the base walks
     // exactly the same enumeration, so this said nothing the base does not already say.
-    /// <summary>
-    /// Creates a new instance of the BlackLittermanNeural model with the same configuration.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> This is used by the framework to clone the model's setup
-    /// so it can create a fresh instance with identical settings.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var optionsCopy = new BlackLittermanNeuralOptions<T>
-        {
-            NumAssets = _options.NumAssets,
-            HiddenDimension = _hiddenDimension,
-            DropoutRate = _dropout
-        };
-
-        return new BlackLittermanNeural<T>(Architecture, optionsCopy, lossFunction: _lossFunction);
-    }
 
     #endregion
 }
diff --git a/src/Finance/Portfolio/DeepPortfolioManager.cs b/src/Finance/Portfolio/DeepPortfolioManager.cs
index 881a1a5b68..f1c47c5664 100644
--- a/src/Finance/Portfolio/DeepPortfolioManager.cs
+++ b/src/Finance/Portfolio/DeepPortfolioManager.cs
@@ -55,7 +55,7 @@ namespace AiDotNet.Finance.Portfolio;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("A Deep Reinforcement Learning Framework for the Financial Portfolio Management Problem", "https://arxiv.org/abs/1706.10059")]
-public class DeepPortfolioManager<T> : PortfolioOptimizerBase<T>
+public partial class DeepPortfolioManager<T> : PortfolioOptimizerBase<T>
 {
     #region Shared Fields
 
@@ -252,19 +252,5 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    /// <summary>
-    /// Executes CreateNewInstance for the DeepPortfolioManager.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> In the DeepPortfolioManager model, CreateNewInstance builds and wires up model components. This sets up the DeepPortfolioManager architecture before use.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var options = new DeepPortfolioManagerOptions<T> { NumAssets = _numAssets, AllowShortSelling = _allowShortSelling, MaxWeight = _maxWeight };
-        return new DeepPortfolioManager<T>(Architecture, options, _optimizer, LossFunction);
-    }
-
     #endregion
 }
diff --git a/src/Finance/Portfolio/GraphAttentionPortfolio.cs b/src/Finance/Portfolio/GraphAttentionPortfolio.cs
index 9121752092..25d3e9e58e 100644
--- a/src/Finance/Portfolio/GraphAttentionPortfolio.cs
+++ b/src/Finance/Portfolio/GraphAttentionPortfolio.cs
@@ -59,7 +59,7 @@ namespace AiDotNet.Finance.Portfolio;
     "https://arxiv.org/abs/2407.15532",
     Year = 2025,
     Authors = "Kamesh Korangi, Christophe Mues, Cristian Bravo")]
-public class GraphAttentionPortfolio<T> : PortfolioOptimizerBase<T>
+public partial class GraphAttentionPortfolio<T> : PortfolioOptimizerBase<T>
 {
     private readonly GraphAttentionPortfolioOptions<T> _options;
 
@@ -252,40 +252,4 @@ public double PortfolioLoss(Vector<T> weights, Tensor<T> assetReturns)
 
         return Objective.Loss(Objective.PortfolioReturns(weights, assetReturns));
     }
-
-    // UpdateParameters restated the base verbatim; ModelBase routes it to SetParameters.
-    /// <inheritdoc />
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var copy = new GraphAttentionPortfolioOptions<T>
-        {
-            NumAssets = _options.NumAssets,
-            VolatilityLookback = _options.VolatilityLookback,
-            CorrelationWindow = _options.CorrelationWindow,
-            AttentionFeatureDimension = _options.AttentionFeatureDimension,
-            NumHeads = _options.NumHeads,
-            LeakyReLUSlope = _options.LeakyReLUSlope,
-            DropoutRate = _options.DropoutRate,
-            L1Regularization = _options.L1Regularization,
-            LearningRate = _options.LearningRate,
-            BatchSize = _options.BatchSize,
-            MaxEpochs = _options.MaxEpochs,
-        };
-
-        // LossFunction always carries across; calling the single-argument constructor took the
-        // implicit default and a model built with a custom loss cloned into a different one.
-        //
-        // Architecture carries across ONLY when it holds no layers. InitializeLayers adds
-        // Architecture.Layers into Layers BY REFERENCE when that collection is non-empty, and
-        // ILayer<T> has no Clone, so handing a layer-carrying architecture to the clone would give
-        // both models the SAME layer objects -- training or UpdateParameters on either would mutate
-        // both. A clone that silently shares state is a worse defect than one that rebuilds default
-        // layers, so the layer-carrying case falls back to the default build until layers can be
-        // deep-copied.
-        bool architectureCarriesLayers = Architecture.Layers is not null && Architecture.Layers.Count > 0;
-
-        return architectureCarriesLayers
-            ? new GraphAttentionPortfolio<T>(copy, null, LossFunction)
-            : new GraphAttentionPortfolio<T>(copy, Architecture, LossFunction);
-    }
 }
diff --git a/src/Finance/Portfolio/HierarchicalRiskParity.cs b/src/Finance/Portfolio/HierarchicalRiskParity.cs
index 65ffe7a9eb..ddb3741b6f 100644
--- a/src/Finance/Portfolio/HierarchicalRiskParity.cs
+++ b/src/Finance/Portfolio/HierarchicalRiskParity.cs
@@ -45,7 +45,7 @@ namespace AiDotNet.Finance.Portfolio;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Building Diversified Portfolios that Outperform Out of Sample", "https://doi.org/10.3905/jpm.2016.42.4.059", Year = 2016, Authors = "Marcos Lopez de Prado")]
-public class HierarchicalRiskParity<T> : PortfolioOptimizerBase<T>
+public partial class HierarchicalRiskParity<T> : PortfolioOptimizerBase<T>
 {
     #region Shared Fields
 
@@ -199,26 +199,6 @@ private Tensor<T> Forward(Tensor<T> input)
 
     // UpdateParameters re-sliced the flat vector across Layers by hand -- the base walks
     // exactly the same enumeration, so this said nothing the base does not already say.
-    /// <summary>
-    /// Creates a new instance of the HierarchicalRiskParity model with the same configuration.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> This is used by the framework to clone the model's configuration
-    /// so it can create a fresh instance with identical settings.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var optionsCopy = new HierarchicalRiskParityOptions<T>
-        {
-            NumAssets = _options.NumAssets,
-            HiddenDimension = _hiddenDimension,
-            DropoutRate = _dropout
-        };
-
-        return new HierarchicalRiskParity<T>(Architecture, optionsCopy, lossFunction: _lossFunction);
-    }
 
     #endregion
 }
diff --git a/src/Finance/Portfolio/SignatureInformedTransformer.cs b/src/Finance/Portfolio/SignatureInformedTransformer.cs
index d316cf511e..15dc781340 100644
--- a/src/Finance/Portfolio/SignatureInformedTransformer.cs
+++ b/src/Finance/Portfolio/SignatureInformedTransformer.cs
@@ -59,7 +59,7 @@ namespace AiDotNet.Finance.Portfolio;
     "https://arxiv.org/abs/2510.03129",
     Year = 2025,
     Authors = "Yoontae Hwang, Stefan Zohren")]
-public class SignatureInformedTransformer<T> : PortfolioOptimizerBase<T>
+public partial class SignatureInformedTransformer<T> : PortfolioOptimizerBase<T>
 {
     private readonly SignatureInformedTransformerOptions<T> _options;
 
@@ -246,41 +246,4 @@ public double PortfolioCVaR(Vector<T> weights, Tensor<T> realizedReturns)
 
         return Objective.ConditionalValueAtRisk(losses);
     }
-
-    // UpdateParameters restated the base verbatim; ModelBase routes it to SetParameters.
-    /// <inheritdoc />
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var copy = new SignatureInformedTransformerOptions<T>
-        {
-            NumAssets = _options.NumAssets,
-            LookbackWindow = _options.LookbackWindow,
-            Horizon = _options.Horizon,
-            SignatureLevel = _options.SignatureLevel,
-            ModelDimension = _options.ModelDimension,
-            FeedForwardDimension = _options.FeedForwardDimension,
-            NumHeads = _options.NumHeads,
-            NumLayers = _options.NumLayers,
-            RelationalHiddenDimension = _options.RelationalHiddenDimension,
-            Temperature = _options.Temperature,
-            CVaRAlpha = _options.CVaRAlpha,
-            DropoutRate = _options.DropoutRate,
-            LearningRate = _options.LearningRate,
-            BatchSize = _options.BatchSize,
-            MaxEpochs = _options.MaxEpochs,
-            EarlyStoppingPatience = _options.EarlyStoppingPatience,
-            TransactionCostBasisPoints = _options.TransactionCostBasisPoints,
-        };
-
-        // LossFunction always carries across. Architecture carries across ONLY when it holds no
-        // layers: InitializeLayers adds Architecture.Layers into Layers BY REFERENCE, and ILayer<T>
-        // has no Clone, so a layer-carrying architecture would give the clone the SAME layer objects
-        // as its source and training either would mutate both. See the matching note in
-        // GraphAttentionPortfolio.CreateNewInstance.
-        bool architectureCarriesLayers = Architecture.Layers is not null && Architecture.Layers.Count > 0;
-
-        return architectureCarriesLayers
-            ? new SignatureInformedTransformer<T>(copy, null, LossFunction)
-            : new SignatureInformedTransformer<T>(copy, Architecture, LossFunction);
-    }
 }
diff --git a/src/Finance/Probabilistic/CSDI.cs b/src/Finance/Probabilistic/CSDI.cs
index d3fae04a45..053d18ffd9 100644
--- a/src/Finance/Probabilistic/CSDI.cs
+++ b/src/Finance/Probabilistic/CSDI.cs
@@ -581,20 +581,6 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    /// <summary>
-    /// Creates a new instance of the CSDI model with the same configuration.
-    /// </summary>
-    /// <returns>A new CSDI instance.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> In the CSDI model, CreateNewInstance builds and wires up model components. This sets up the CSDI architecture before use.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new CSDI<T>(Architecture, _options, _numFeatures);
-    }
-
     /// <summary>
     /// Serializes CSDI-specific data for model persistence.
     /// </summary>
@@ -604,20 +590,7 @@ protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
     /// <b>For Beginners:</b> In the CSDI model, SerializeNetworkSpecificData saves or restores model-specific settings. This lets the CSDI architecture be reused later.
     /// </para>
     /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_sequenceLength);
-        writer.Write(_numFeatures);
-        writer.Write(_hiddenDimension);
-        writer.Write(_numResidualLayers);
-        writer.Write(_numDiffusionSteps);
-        writer.Write(_numSamples);
-        writer.Write(_numHeads);
-        writer.Write(_timeEmbeddingDim);
-        writer.Write(_featureEmbeddingDim);
-        writer.Write(_betaSchedule);
-        writer.Write(_useAttention);
-    }
+
 
     /// <summary>
     /// Deserializes CSDI-specific data when loading a saved model.
@@ -628,20 +601,7 @@ protected override void SerializeNetworkSpecificData(BinaryWriter writer)
     /// <b>For Beginners:</b> In the CSDI model, DeserializeNetworkSpecificData saves or restores model-specific settings. This lets the CSDI architecture be reused later.
     /// </para>
     /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _sequenceLength = reader.ReadInt32();
-        _numFeatures = reader.ReadInt32();
-        _hiddenDimension = reader.ReadInt32();
-        _numResidualLayers = reader.ReadInt32();
-        _numDiffusionSteps = reader.ReadInt32();
-        _numSamples = reader.ReadInt32();
-        _numHeads = reader.ReadInt32();
-        _timeEmbeddingDim = reader.ReadInt32();
-        _featureEmbeddingDim = reader.ReadInt32();
-        _betaSchedule = reader.ReadString();
-        _useAttention = reader.ReadBoolean();
-    }
+
 
     #endregion
 
diff --git a/src/Finance/Probabilistic/DiffusionTS.cs b/src/Finance/Probabilistic/DiffusionTS.cs
index e4fedcda97..d79ed2e218 100644
--- a/src/Finance/Probabilistic/DiffusionTS.cs
+++ b/src/Finance/Probabilistic/DiffusionTS.cs
@@ -593,20 +593,6 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    /// <summary>
-    /// Creates a new instance with the same configuration.
-    /// </summary>
-    /// <returns>A new DiffusionTS instance with identical settings.</returns>
-    /// <remarks>
-    /// <para><b>For Beginners:</b> Creates a fresh model with the same architecture
-    /// and options but without trained weights. Useful for ensemble methods.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new DiffusionTS<T>(Architecture, _options, _numFeatures);
-    }
-
     /// <summary>
     /// Serializes DiffusionTS-specific data for model persistence.
     /// </summary>
@@ -617,22 +603,7 @@ protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
     /// diffusion parameters.
     /// </para>
     /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_sequenceLength);
-        writer.Write(_forecastHorizon);
-        writer.Write(_numFeatures);
-        writer.Write(_hiddenDimension);
-        writer.Write(_trendHiddenDim);
-        writer.Write(_seasonalHiddenDim);
-        writer.Write(_numDiffusionSteps);
-        writer.Write(_numSamples);
-        writer.Write(_decompositionPeriod);
-        writer.Write(_trendKernelSize);
-        writer.Write(_useTrendComponent);
-        writer.Write(_useSeasonalComponent);
-        writer.Write(_betaSchedule);
-    }
+
 
     /// <summary>
     /// Deserializes DiffusionTS-specific data from a saved model.
@@ -644,22 +615,7 @@ protected override void SerializeNetworkSpecificData(BinaryWriter writer)
     /// in the constructor.
     /// </para>
     /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _sequenceLength = reader.ReadInt32();
-        _forecastHorizon = reader.ReadInt32();
-        _numFeatures = reader.ReadInt32();
-        _hiddenDimension = reader.ReadInt32();
-        _trendHiddenDim = reader.ReadInt32();
-        _seasonalHiddenDim = reader.ReadInt32();
-        _numDiffusionSteps = reader.ReadInt32();
-        _numSamples = reader.ReadInt32();
-        _decompositionPeriod = reader.ReadInt32();
-        _trendKernelSize = reader.ReadInt32();
-        _useTrendComponent = reader.ReadBoolean();
-        _useSeasonalComponent = reader.ReadBoolean();
-        _betaSchedule = reader.ReadString();
-    }
+
 
     #endregion
 
diff --git a/src/Finance/Probabilistic/ScoreGrad.cs b/src/Finance/Probabilistic/ScoreGrad.cs
index a51d1c3161..0f99e6385a 100644
--- a/src/Finance/Probabilistic/ScoreGrad.cs
+++ b/src/Finance/Probabilistic/ScoreGrad.cs
@@ -525,20 +525,6 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    /// <summary>
-    /// Creates a new instance with the same configuration.
-    /// </summary>
-    /// <returns>A new ScoreGrad instance.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> In the ScoreGrad model, CreateNewInstance builds and wires up model components. This sets up the ScoreGrad architecture before use.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new ScoreGrad<T>(Architecture, _options, _numFeatures);
-    }
-
     /// <summary>
     /// Serializes ScoreGrad-specific data.
     /// </summary>
@@ -548,22 +534,7 @@ protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
     /// <b>For Beginners:</b> In the ScoreGrad model, SerializeNetworkSpecificData saves or restores model-specific settings. This lets the ScoreGrad architecture be reused later.
     /// </para>
     /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_sequenceLength);
-        writer.Write(_forecastHorizon);
-        writer.Write(_numFeatures);
-        writer.Write(_hiddenDimension);
-        writer.Write(_numLayers);
-        writer.Write(_numNoiseScales);
-        writer.Write(_sigmaMin);
-        writer.Write(_sigmaMax);
-        writer.Write(_numLangevinSteps);
-        writer.Write(_stepSize);
-        writer.Write(_useAnnealing);
-        writer.Write(_annealingPower);
-        writer.Write(_numSamples);
-    }
+
 
     /// <summary>
     /// Deserializes ScoreGrad-specific data.
@@ -574,22 +545,7 @@ protected override void SerializeNetworkSpecificData(BinaryWriter writer)
     /// <b>For Beginners:</b> In the ScoreGrad model, DeserializeNetworkSpecificData saves or restores model-specific settings. This lets the ScoreGrad architecture be reused later.
     /// </para>
     /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _sequenceLength = reader.ReadInt32();
-        _forecastHorizon = reader.ReadInt32();
-        _numFeatures = reader.ReadInt32();
-        _hiddenDimension = reader.ReadInt32();
-        _numLayers = reader.ReadInt32();
-        _numNoiseScales = reader.ReadInt32();
-        _sigmaMin = reader.ReadDouble();
-        _sigmaMax = reader.ReadDouble();
-        _numLangevinSteps = reader.ReadInt32();
-        _stepSize = reader.ReadDouble();
-        _useAnnealing = reader.ReadBoolean();
-        _annealingPower = reader.ReadDouble();
-        _numSamples = reader.ReadInt32();
-    }
+
 
     #endregion
 
diff --git a/src/Finance/Probabilistic/TSDiff.cs b/src/Finance/Probabilistic/TSDiff.cs
index 86f0f08328..13c3c928e6 100644
--- a/src/Finance/Probabilistic/TSDiff.cs
+++ b/src/Finance/Probabilistic/TSDiff.cs
@@ -573,20 +573,6 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    /// <summary>
-    /// Creates a new instance with the same configuration.
-    /// </summary>
-    /// <returns>A new TSDiff instance.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> In the TSDiff model, CreateNewInstance builds and wires up model components. This sets up the TSDiff architecture before use.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new TSDiff<T>(Architecture, _options, _numFeatures);
-    }
-
     /// <summary>
     /// Serializes TSDiff-specific data.
     /// </summary>
@@ -596,21 +582,7 @@ protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
     /// <b>For Beginners:</b> In the TSDiff model, SerializeNetworkSpecificData saves or restores model-specific settings. This lets the TSDiff architecture be reused later.
     /// </para>
     /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_sequenceLength);
-        writer.Write(_forecastHorizon);
-        writer.Write(_numFeatures);
-        writer.Write(_hiddenDimension);
-        writer.Write(_numResidualBlocks);
-        writer.Write(_numDiffusionSteps);
-        writer.Write(_numSamples);
-        writer.Write(_numAttentionHeads);
-        writer.Write(_guidanceScale);
-        writer.Write(_useSelfGuidance);
-        writer.Write(_useObservationGuidance);
-        writer.Write(_betaSchedule);
-    }
+
 
     /// <summary>
     /// Deserializes TSDiff-specific data.
@@ -621,21 +593,7 @@ protected override void SerializeNetworkSpecificData(BinaryWriter writer)
     /// <b>For Beginners:</b> In the TSDiff model, DeserializeNetworkSpecificData saves or restores model-specific settings. This lets the TSDiff architecture be reused later.
     /// </para>
     /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _sequenceLength = reader.ReadInt32();
-        _forecastHorizon = reader.ReadInt32();
-        _numFeatures = reader.ReadInt32();
-        _hiddenDimension = reader.ReadInt32();
-        _numResidualBlocks = reader.ReadInt32();
-        _numDiffusionSteps = reader.ReadInt32();
-        _numSamples = reader.ReadInt32();
-        _numAttentionHeads = reader.ReadInt32();
-        _guidanceScale = reader.ReadDouble();
-        _useSelfGuidance = reader.ReadBoolean();
-        _useObservationGuidance = reader.ReadBoolean();
-        _betaSchedule = reader.ReadString();
-    }
+
 
     #endregion
 
diff --git a/src/Finance/Probabilistic/TimeGrad.cs b/src/Finance/Probabilistic/TimeGrad.cs
index c6f47d9bd0..36d0294571 100644
--- a/src/Finance/Probabilistic/TimeGrad.cs
+++ b/src/Finance/Probabilistic/TimeGrad.cs
@@ -561,20 +561,6 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    /// <summary>
-    /// Creates a new instance of the TimeGrad model with the same configuration.
-    /// </summary>
-    /// <returns>A new TimeGrad instance.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> In the TimeGrad model, CreateNewInstance builds and wires up model components. This sets up the TimeGrad architecture before use.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new TimeGrad<T>(Architecture, _options);
-    }
-
     /// <summary>
     /// Serializes TimeGrad-specific data for model persistence.
     /// </summary>
@@ -584,17 +570,7 @@ protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
     /// <b>For Beginners:</b> In the TimeGrad model, SerializeNetworkSpecificData saves or restores model-specific settings. This lets the TimeGrad architecture be reused later.
     /// </para>
     /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_contextLength);
-        writer.Write(_forecastHorizon);
-        writer.Write(_hiddenDimension);
-        writer.Write(_numRnnLayers);
-        writer.Write(_numDiffusionSteps);
-        writer.Write(_numSamples);
-        writer.Write(_denoisingDim);
-        writer.Write(_betaSchedule);
-    }
+
 
     /// <summary>
     /// Deserializes TimeGrad-specific data when loading a saved model.
@@ -605,17 +581,7 @@ protected override void SerializeNetworkSpecificData(BinaryWriter writer)
     /// <b>For Beginners:</b> In the TimeGrad model, DeserializeNetworkSpecificData saves or restores model-specific settings. This lets the TimeGrad architecture be reused later.
     /// </para>
     /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _contextLength = reader.ReadInt32();
-        _forecastHorizon = reader.ReadInt32();
-        _hiddenDimension = reader.ReadInt32();
-        _numRnnLayers = reader.ReadInt32();
-        _numDiffusionSteps = reader.ReadInt32();
-        _numSamples = reader.ReadInt32();
-        _denoisingDim = reader.ReadInt32();
-        _betaSchedule = reader.ReadString();
-    }
+
 
     #endregion
 
diff --git a/src/Finance/Risk/NeuralCVaR.cs b/src/Finance/Risk/NeuralCVaR.cs
index 14a63e217e..000402e159 100644
--- a/src/Finance/Risk/NeuralCVaR.cs
+++ b/src/Finance/Risk/NeuralCVaR.cs
@@ -49,7 +49,7 @@ namespace AiDotNet.Finance.Risk;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Deep Learning for CVaR Estimation", "https://doi.org/10.21314/JOR.2000.038")]
-public class NeuralCVaR<T> : RiskModelBase<T>
+public partial class NeuralCVaR<T> : RiskModelBase<T>
 {
     #region Shared Fields
 
@@ -246,28 +246,6 @@ public override T CalculateVaR(Tensor<T> portfolioReturns, Tensor<T> weights)
 
     // UpdateParameters re-sliced the flat vector across Layers by hand -- the base walks
     // exactly the same enumeration, so this said nothing the base does not already say.
-    /// <summary>
-    /// Creates a new instance of the NeuralCVaR model with the same configuration.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> This is used by the framework to clone the model's setup
-    /// so it can create a fresh instance with identical settings.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var options = new NeuralCVaROptions<T>
-        {
-            NumFeatures = _options.NumFeatures,
-            ConfidenceLevel = _options.ConfidenceLevel,
-            TimeHorizon = _options.TimeHorizon,
-            HiddenLayers = _options.HiddenLayers,
-            HiddenDimension = _options.HiddenDimension
-        };
-
-        return new NeuralCVaR<T>(Architecture, options, _optimizer, LossFunction);
-    }
 
     #endregion
 }
diff --git a/src/Finance/Risk/NeuralStressTest.cs b/src/Finance/Risk/NeuralStressTest.cs
index dea2766f7d..59c724e9f0 100644
--- a/src/Finance/Risk/NeuralStressTest.cs
+++ b/src/Finance/Risk/NeuralStressTest.cs
@@ -45,7 +45,7 @@ namespace AiDotNet.Finance.Risk;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Machine Learning for Financial Stress Testing", "https://doi.org/10.1016/j.jbankfin.2021.106131")]
-public class NeuralStressTest<T> : RiskModelBase<T>
+public partial class NeuralStressTest<T> : RiskModelBase<T>
 {
     #region Shared Fields
 
@@ -246,29 +246,6 @@ public override Tensor<T> StressTest(Tensor<T> input, Tensor<T> stressScenarios)
 
     // UpdateParameters re-sliced the flat vector across Layers by hand -- the base walks
     // exactly the same enumeration, so this said nothing the base does not already say.
-    /// <summary>
-    /// Creates a new instance of the NeuralStressTest model with the same configuration.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> This is used by the framework to clone the model setup
-    /// so it can create a fresh instance with identical settings.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var options = new NeuralStressTestOptions<T>
-        {
-            NumFeatures = _options.NumFeatures,
-            ConfidenceLevel = _options.ConfidenceLevel,
-            TimeHorizon = _options.TimeHorizon,
-            HiddenDimension = _options.HiddenDimension,
-            NumScenarios = _options.NumScenarios,
-            DropoutRate = _options.DropoutRate
-        };
-
-        return new NeuralStressTest<T>(Architecture, options, _optimizer, LossFunction);
-    }
 
     #endregion
 }
diff --git a/src/Finance/Risk/NeuralVaR.cs b/src/Finance/Risk/NeuralVaR.cs
index 7aa75d6476..aaff284e75 100644
--- a/src/Finance/Risk/NeuralVaR.cs
+++ b/src/Finance/Risk/NeuralVaR.cs
@@ -55,7 +55,7 @@ namespace AiDotNet.Finance.Risk;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Deep Learning for Value-at-Risk", "https://doi.org/10.1016/j.jbankfin.2020.105889")]
-public class NeuralVaR<T> : RiskModelBase<T>
+public partial class NeuralVaR<T> : RiskModelBase<T>
 {
     #region Shared Fields
 
@@ -263,19 +263,5 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    /// <summary>
-    /// Executes CreateNewInstance for the NeuralVaR.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> In the NeuralVaR model, CreateNewInstance builds and wires up model components. This sets up the NeuralVaR architecture before use.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var options = new NeuralVaROptions<T> { NumFeatures = NumFeatures, ConfidenceLevel = _confidenceLevel, TimeHorizon = _timeHorizon };
-        return new NeuralVaR<T>(Architecture, options, _optimizer, LossFunction);
-    }
-
     #endregion
 }
diff --git a/src/Finance/Risk/SAINT.cs b/src/Finance/Risk/SAINT.cs
index 5d5a2d84b7..af8ff105e5 100644
--- a/src/Finance/Risk/SAINT.cs
+++ b/src/Finance/Risk/SAINT.cs
@@ -49,7 +49,7 @@ namespace AiDotNet.Finance.Risk;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("SAINT: Improved Neural Networks for Tabular Data via Row Attention and Contrastive Pre-Training", "https://arxiv.org/abs/2106.01342", Year = 2021, Authors = "Gowthami Somepalli, Micah Goldblum, Avi Schwarzschild, C. Bayan Bruss, Tom Goldstein")]
-public class SAINT<T> : RiskModelBase<T>
+public partial class SAINT<T> : RiskModelBase<T>
 {
     #region Shared Fields
 
@@ -215,31 +215,6 @@ public override Tensor<T> AdjustForRisk(Tensor<T> action, T riskBudget)
 
     // UpdateParameters re-sliced the flat vector across Layers by hand -- the base walks
     // exactly the same enumeration, so this said nothing the base does not already say.
-    /// <summary>
-    /// Creates a new instance of the SAINT model with the same configuration.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> This is used by the framework to clone the model's setup
-    /// so it can create a fresh instance with identical settings.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var options = new SAINTOptions<T>
-        {
-            NumFeatures = _options.NumFeatures,
-            ConfidenceLevel = _options.ConfidenceLevel,
-            TimeHorizon = _options.TimeHorizon,
-            HiddenDimension = _options.HiddenDimension,
-            NumHeads = _options.NumHeads,
-            NumLayers = _options.NumLayers,
-            BatchSize = _options.BatchSize,
-            DropoutRate = _options.DropoutRate
-        };
-
-        return new SAINT<T>(Architecture, options, _optimizer, LossFunction);
-    }
 
     #endregion
 }
diff --git a/src/Finance/Risk/TabNet.cs b/src/Finance/Risk/TabNet.cs
index bde1b96752..7192765ef1 100644
--- a/src/Finance/Risk/TabNet.cs
+++ b/src/Finance/Risk/TabNet.cs
@@ -48,7 +48,7 @@ namespace AiDotNet.Finance.Risk;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("TabNet: Attentive Interpretable Tabular Learning", "https://doi.org/10.1609/aaai.v35i8.16826", Year = 2021, Authors = "Sercan O. Arik, Tomas Pfister")]
-public class TabNet<T> : RiskModelBase<T>
+public partial class TabNet<T> : RiskModelBase<T>
 {
     #region Shared Fields
 
@@ -272,29 +272,6 @@ public override Tensor<T> AdjustForRisk(Tensor<T> action, T riskBudget)
 
     // UpdateParameters re-sliced the flat vector across Layers by hand -- the base walks
     // exactly the same enumeration, so this said nothing the base does not already say.
-    /// <summary>
-    /// Creates a new instance of the TabNet model with the same configuration.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> This is used by the framework to clone the model setup
-    /// so it can create a fresh instance with identical settings.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var options = new TabNetOptions<T>
-        {
-            NumFeatures = _options.NumFeatures,
-            ConfidenceLevel = _options.ConfidenceLevel,
-            TimeHorizon = _options.TimeHorizon,
-            HiddenDimension = _options.HiddenDimension,
-            NumDecisionSteps = _options.NumDecisionSteps,
-            DropoutRate = _options.DropoutRate
-        };
-
-        return new TabNet<T>(Architecture, options, _optimizer, LossFunction);
-    }
 
     #endregion
 }
diff --git a/src/Finance/Risk/TabTransformer.cs b/src/Finance/Risk/TabTransformer.cs
index 36db03d5d3..73ece3b929 100644
--- a/src/Finance/Risk/TabTransformer.cs
+++ b/src/Finance/Risk/TabTransformer.cs
@@ -48,7 +48,7 @@ namespace AiDotNet.Finance.Risk;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("TabTransformer: Tabular Data Modeling Using Contextual Embeddings", "https://arxiv.org/abs/2012.06678", Year = 2021, Authors = "Xin Huang, Ashish Khetan, Milan Cvitkovic, Zohar Karnin")]
-public class TabTransformer<T> : RiskModelBase<T>
+public partial class TabTransformer<T> : RiskModelBase<T>
 {
     #region Shared Fields
 
@@ -264,31 +264,6 @@ public override Tensor<T> AdjustForRisk(Tensor<T> action, T riskBudget)
 
     // UpdateParameters re-sliced the flat vector across Layers by hand -- the base walks
     // exactly the same enumeration, so this said nothing the base does not already say.
-    /// <summary>
-    /// Creates a new instance of the TabTransformer model with the same configuration.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> This is used by the framework to clone the model setup
-    /// so it can create a fresh instance with identical settings.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var options = new TabTransformerOptions<T>
-        {
-            NumFeatures = _options.NumFeatures,
-            ConfidenceLevel = _options.ConfidenceLevel,
-            TimeHorizon = _options.TimeHorizon,
-            HiddenDimension = _options.HiddenDimension,
-            NumHeads = _options.NumHeads,
-            NumLayers = _options.NumLayers,
-            NumCategoricalFeatures = _options.NumCategoricalFeatures,
-            DropoutRate = _options.DropoutRate
-        };
-
-        return new TabTransformer<T>(Architecture, options, _optimizer, LossFunction);
-    }
 
     #endregion
 }
diff --git a/src/Finance/Trading/Agents/FeedforwardPolicyAgent.cs b/src/Finance/Trading/Agents/FeedforwardPolicyAgent.cs
index 3f1d0ea553..cbff1e4eb1 100644
--- a/src/Finance/Trading/Agents/FeedforwardPolicyAgent.cs
+++ b/src/Finance/Trading/Agents/FeedforwardPolicyAgent.cs
@@ -22,7 +22,7 @@ namespace AiDotNet.Finance.Trading.Agents;
 /// untouched holdout — any gap is attributable to memory, not the algorithm.
 /// </summary>
 /// <typeparam name="T">Element type (float/double).</typeparam>
-public sealed class FeedforwardPolicyAgent<T> : IPortfolioAgent<T>
+public sealed partial class FeedforwardPolicyAgent<T> : IPortfolioAgent<T>
 {
     private static readonly INumericOperations<T> NumOps = MathHelper.GetNumericOperations<T>();
     private static IEngine Engine => AiDotNetEngine.Current;
@@ -33,9 +33,13 @@ public sealed class FeedforwardPolicyAgent<T> : IPortfolioAgent<T>
     private readonly double _gamma;
     private readonly Random _rng;
 
+    [AiDotNet.Attributes.TrainableParameter]
     private readonly Tensor<T> _w1;   // [hidden, stateDim]
+    [AiDotNet.Attributes.TrainableParameter]
     private readonly Tensor<T> _b1;   // [hidden, 1]
+    [AiDotNet.Attributes.TrainableParameter]
     private readonly Tensor<T> _meanW; // [actionDim, hidden]
+    [AiDotNet.Attributes.TrainableParameter]
     private readonly Tensor<T> _meanB; // [actionDim, 1]
     private readonly IReadOnlyList<Tensor<T>> _trainable;
     private readonly AdamOptimizer<T, Matrix<T>, Vector<T>> _optimizer;
diff --git a/src/Finance/Trading/Agents/FinRLAgent.cs b/src/Finance/Trading/Agents/FinRLAgent.cs
index 6d239e061d..65acc03a3d 100644
--- a/src/Finance/Trading/Agents/FinRLAgent.cs
+++ b/src/Finance/Trading/Agents/FinRLAgent.cs
@@ -49,7 +49,7 @@ public partial class FinRLAgent<T> : TradingAgentBase<T>
 
     #region Fields
 
-    private readonly FinRLAgentOptions<T> _options;
+    private readonly TradingAgentOptions<T> _options;
     private readonly TradingAgentBase<T> _innerAgent;
     private readonly FinRLAlgorithm _algorithm;
     private readonly NeuralNetworkArchitecture<T> _primaryArchitecture;
@@ -93,7 +93,7 @@ public FinRLAgent(
         NeuralNetworkArchitecture<T>? secondaryArchitecture = null)
         : base(options)
     {
-        _options = options as FinRLAgentOptions<T> ?? new FinRLAgentOptions<T>();
+        _options = options;
 
         _algorithm = algorithm;
         Guard.NotNull(primaryArchitecture);
@@ -219,47 +219,6 @@ public override void StoreExperience(Vector<T> state, Vector<T> action, T reward
 
     #region Serialization
 
-    /// <inheritdoc/>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> In the FinRLAgent model, Serialize saves or restores model-specific settings. This lets the FinRLAgent architecture be reused later.
-    /// </para>
-    /// </remarks>
-    public override byte[] Serialize()
-    {
-        using var ms = new MemoryStream();
-        using var writer = new BinaryWriter(ms);
-
-        writer.Write((int)_algorithm);
-        var innerData = _innerAgent.Serialize();
-        writer.Write(innerData.Length);
-        writer.Write(innerData);
-
-        return ms.ToArray();
-    }
-
-    /// <inheritdoc/>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> In the FinRLAgent model, Deserialize saves or restores model-specific settings. This lets the FinRLAgent architecture be reused later.
-    /// </para>
-    /// </remarks>
-    public override void Deserialize(byte[] data)
-    {
-        using var ms = new MemoryStream(data);
-        using var reader = new BinaryReader(ms);
-
-        var algorithm = (FinRLAlgorithm)reader.ReadInt32();
-        if (algorithm != _algorithm)
-        {
-            throw new InvalidOperationException($"Cannot deserialize {algorithm} data into {_algorithm} agent.");
-        }
-
-        int innerLength = reader.ReadInt32();
-        var innerData = reader.ReadBytes(innerLength);
-        _innerAgent.Deserialize(innerData);
-    }
-
     #endregion
 
     #region Model Metadata
@@ -278,19 +237,6 @@ public override ModelMetadata<T> GetModelMetadata()
         return innerMetadata;
     }
 
-    /// <inheritdoc/>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> In the FinRLAgent model, Clone performs a supporting step in the workflow. It keeps the FinRLAgent architecture pipeline consistent.
-    /// </para>
-    /// </remarks>
-    public override IFullModel<T, Vector<T>, Vector<T>> Clone()
-    {
-        var clone = new FinRLAgent<T>(_primaryArchitecture, TradingOptions, _algorithm, _secondaryArchitecture);
-        clone.SetParameters(GetParameters());
-        return clone;
-    }
-
 
 
     #endregion
diff --git a/src/Finance/Trading/Agents/FinancialA2CAgent.cs b/src/Finance/Trading/Agents/FinancialA2CAgent.cs
index cdffaabc57..de4dafbc2d 100644
--- a/src/Finance/Trading/Agents/FinancialA2CAgent.cs
+++ b/src/Finance/Trading/Agents/FinancialA2CAgent.cs
@@ -56,7 +56,7 @@ public partial class FinancialA2CAgent<T> : TradingAgentBase<T>, IGradientComput
 
     #region Fields
 
-    private readonly FinancialA2CAgentOptions<T> _options;
+    private readonly TradingAgentOptions<T> _options;
     private readonly INeuralNetwork<T> _actor;
     private readonly INeuralNetwork<T> _critic;
     private readonly ReplayBuffer<T> ReplayBuffer;
@@ -96,7 +96,7 @@ public FinancialA2CAgent(
     {
         Guard.NotNull(actorArchitecture);
         Guard.NotNull(criticArchitecture);
-        _options = options as FinancialA2CAgentOptions<T> ?? new FinancialA2CAgentOptions<T>();
+        _options = options;
         _actorArchitecture = actorArchitecture;
         _criticArchitecture = criticArchitecture;
 
@@ -285,45 +285,6 @@ public override void StoreExperience(Vector<T> state, Vector<T> action, T reward
 
     #region Serialization
 
-    /// <summary>
-    /// Executes Serialize for the FinancialA2CAgent.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> In the FinancialA2CAgent model, Serialize saves or restores model-specific settings. This lets the FinancialA2CAgent architecture be reused later.
-    /// </para>
-    /// </remarks>
-    public override byte[] Serialize()
-    {
-        using var ms = new MemoryStream();
-        using var writer = new BinaryWriter(ms);
-        var actorData = _actor.Serialize();
-        var criticData = _critic.Serialize();
-        writer.Write(actorData.Length);
-        writer.Write(actorData);
-        writer.Write(criticData.Length);
-        writer.Write(criticData);
-        return ms.ToArray();
-    }
-
-    /// <summary>
-    /// Executes Deserialize for the FinancialA2CAgent.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> In the FinancialA2CAgent model, Deserialize saves or restores model-specific settings. This lets the FinancialA2CAgent architecture be reused later.
-    /// </para>
-    /// </remarks>
-    public override void Deserialize(byte[] data)
-    {
-        using var ms = new MemoryStream(data);
-        using var reader = new BinaryReader(ms);
-        int actorLen = reader.ReadInt32();
-        _actor.Deserialize(reader.ReadBytes(actorLen));
-        int criticLen = reader.ReadInt32();
-        _critic.Deserialize(reader.ReadBytes(criticLen));
-    }
-
     #endregion
 
     #region Model Metadata
@@ -348,21 +309,6 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    /// <summary>
-    /// Executes Clone for the FinancialA2CAgent.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> In the FinancialA2CAgent model, Clone performs a supporting step in the workflow. It keeps the FinancialA2CAgent architecture pipeline consistent.
-    /// </para>
-    /// </remarks>
-    public override IFullModel<T, Vector<T>, Vector<T>> Clone()
-    {
-        var clone = new FinancialA2CAgent<T>(_actorArchitecture, _criticArchitecture, TradingOptions);
-        clone.SetParameters(GetParameters());
-        return clone;
-    }
-
     /// <summary>
     /// Executes ComputeGradients for the FinancialA2CAgent.
     /// </summary>
diff --git a/src/Finance/Trading/Agents/FinancialDQNAgent.cs b/src/Finance/Trading/Agents/FinancialDQNAgent.cs
index c2a8f9440f..e41d36be20 100644
--- a/src/Finance/Trading/Agents/FinancialDQNAgent.cs
+++ b/src/Finance/Trading/Agents/FinancialDQNAgent.cs
@@ -54,7 +54,7 @@ public partial class FinancialDQNAgent<T> : TradingAgentBase<T>, IGradientComput
 
     #region Fields
 
-    private readonly FinancialDQNAgentOptions<T> _options;
+    private readonly TradingAgentOptions<T> _options;
     private readonly INeuralNetwork<T> _qNetwork;
     [Buffer]
     private readonly INeuralNetwork<T> _targetNetwork;
@@ -101,13 +101,13 @@ public FinancialDQNAgent()
     public FinancialDQNAgent(NeuralNetworkArchitecture<T> architecture, TradingAgentOptions<T> options)
         : base(options)
     {
-        _options = options as FinancialDQNAgentOptions<T> ?? new FinancialDQNAgentOptions<T>();
+        _options = options;
         _architecture = architecture;
 
         EnsureDefaultLayers(architecture, options.StateSize, options.ActionSize);
 
         _qNetwork = new NeuralNetwork<T>(architecture, lossFunction: TradingOptions.LossFunction ?? new MeanSquaredErrorLoss<T>());
-        _targetNetwork = new NeuralNetwork<T>(architecture, lossFunction: TradingOptions.LossFunction ?? new MeanSquaredErrorLoss<T>());
+        _targetNetwork = new NeuralNetwork<T>(architecture.CloneForModelConstruction(), lossFunction: TradingOptions.LossFunction ?? new MeanSquaredErrorLoss<T>());
         ReplayBuffer = new ReplayBuffer<T>(options.ReplayBufferSize, options.Seed);
         UpdateTargetNetwork();
     }
@@ -332,26 +332,6 @@ public override void StoreExperience(Vector<T> state, Vector<T> action, T reward
 
     #region Serialization
 
-    /// <inheritdoc/>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> In the FinancialDQNAgent model, Serialize saves or restores model-specific settings. This lets the FinancialDQNAgent architecture be reused later.
-    /// </para>
-    /// </remarks>
-    public override byte[] Serialize() => _qNetwork.Serialize();
-
-    /// <inheritdoc/>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> In the FinancialDQNAgent model, Deserialize saves or restores model-specific settings. This lets the FinancialDQNAgent architecture be reused later.
-    /// </para>
-    /// </remarks>
-    public override void Deserialize(byte[] data)
-    {
-        _qNetwork.Deserialize(data);
-        UpdateTargetNetwork();
-    }
-
     #endregion
 
     #region Model Metadata
@@ -374,19 +354,6 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    /// <inheritdoc/>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> In the FinancialDQNAgent model, Clone performs a supporting step in the workflow. It keeps the FinancialDQNAgent architecture pipeline consistent.
-    /// </para>
-    /// </remarks>
-    public override IFullModel<T, Vector<T>, Vector<T>> Clone()
-    {
-        var clone = new FinancialDQNAgent<T>(_architecture, TradingOptions);
-        clone.SetParameters(GetParameters());
-        return clone;
-    }
-
     /// <inheritdoc/>
     /// <remarks>
     /// <para>
diff --git a/src/Finance/Trading/Agents/FinancialPPOAgent.cs b/src/Finance/Trading/Agents/FinancialPPOAgent.cs
index dd799aa949..9912a7461b 100644
--- a/src/Finance/Trading/Agents/FinancialPPOAgent.cs
+++ b/src/Finance/Trading/Agents/FinancialPPOAgent.cs
@@ -61,7 +61,8 @@ public partial class FinancialPPOAgent<T> : TradingAgentBase<T>, IGradientComput
     private const double ObservationNormalizerEpsilon = 1e-8;
     private const double ObservationClipRange = 10.0;
 
-    private readonly FinancialPPOAgentOptions<T> _options;
+    private readonly TradingAgentOptions<T> _options;
+    private readonly FinancialPPOAgentOptions<T> _ppoOptions;
     private readonly INeuralNetwork<T> _actor;
     private readonly INeuralNetwork<T> _critic;
     private readonly Trajectory<T> _trajectory;
@@ -115,7 +116,8 @@ public FinancialPPOAgent(
         TradingAgentOptions<T> options)
         : base(options)
     {
-        _options = options as FinancialPPOAgentOptions<T> ?? new FinancialPPOAgentOptions<T>();
+        _options = options;
+        _ppoOptions = options as FinancialPPOAgentOptions<T> ?? new FinancialPPOAgentOptions<T>();
         _actorArchitecture = actorArchitecture;
         _criticArchitecture = criticArchitecture;
 
@@ -452,7 +454,7 @@ public override T Train()
 
     private int GetEffectiveEpochCount(int trajectoryLength)
     {
-        int configuredEpochs = Math.Max(1, _options.NumEpochs);
+        int configuredEpochs = Math.Max(1, _ppoOptions.NumEpochs);
         return trajectoryLength < 8 ? 1 : configuredEpochs;
     }
 
@@ -463,7 +465,7 @@ private int GetEffectiveMiniBatchCount(int trajectoryLength)
             return 1;
         }
 
-        return Math.Max(1, Math.Min(_options.NumMiniBatches, trajectoryLength));
+        return Math.Max(1, Math.Min(_ppoOptions.NumMiniBatches, trajectoryLength));
     }
 
     private int GetMinimumRolloutSize()
@@ -774,55 +776,6 @@ public override void StoreExperience(Vector<T> state, Vector<T> action, T reward
 
     #region Serialization
 
-    /// <summary>
-    /// Executes Serialize for the FinancialPPOAgent.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> In the FinancialPPOAgent model, Serialize saves or restores model-specific settings. This lets the FinancialPPOAgent architecture be reused later.
-    /// </para>
-    /// </remarks>
-    public override byte[] Serialize()
-    {
-        using var ms = new MemoryStream();
-        using var writer = new BinaryWriter(ms);
-        var actorData = _actor.Serialize();
-        var criticData = _critic.Serialize();
-        writer.Write(actorData.Length);
-        writer.Write(actorData);
-        writer.Write(criticData.Length);
-        writer.Write(criticData);
-        writer.Write(ObservationNormalizerMarker);
-        WriteObservationNormalizer(writer);
-        return ms.ToArray();
-    }
-
-    /// <summary>
-    /// Executes Deserialize for the FinancialPPOAgent.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> In the FinancialPPOAgent model, Deserialize saves or restores model-specific settings. This lets the FinancialPPOAgent architecture be reused later.
-    /// </para>
-    /// </remarks>
-    public override void Deserialize(byte[] data)
-    {
-        using var ms = new MemoryStream(data);
-        using var reader = new BinaryReader(ms);
-        int actorLen = reader.ReadInt32();
-        _actor.Deserialize(reader.ReadBytes(actorLen));
-        int criticLen = reader.ReadInt32();
-        _critic.Deserialize(reader.ReadBytes(criticLen));
-        if (ms.Position < ms.Length)
-        {
-            string marker = reader.ReadString();
-            if (marker == ObservationNormalizerMarker)
-            {
-                ReadObservationNormalizer(reader);
-            }
-        }
-    }
-
     private void WriteObservationNormalizer(BinaryWriter writer)
     {
         writer.Write(_observationCount);
@@ -882,22 +835,6 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    /// <summary>
-    /// Executes Clone for the FinancialPPOAgent.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> In the FinancialPPOAgent model, Clone performs a supporting step in the workflow. It keeps the FinancialPPOAgent architecture pipeline consistent.
-    /// </para>
-    /// </remarks>
-    public override IFullModel<T, Vector<T>, Vector<T>> Clone()
-    {
-        var clone = new FinancialPPOAgent<T>(_actorArchitecture, _criticArchitecture, TradingOptions);
-        clone.SetParameters(GetParameters());
-        clone.CopyObservationNormalizerFrom(this);
-        return clone;
-    }
-
     /// <summary>
     /// Executes ComputeGradients for the FinancialPPOAgent.
     /// </summary>
diff --git a/src/Finance/Trading/Agents/FinancialSACAgent.cs b/src/Finance/Trading/Agents/FinancialSACAgent.cs
index 35a8a3b887..8ae12d2988 100644
--- a/src/Finance/Trading/Agents/FinancialSACAgent.cs
+++ b/src/Finance/Trading/Agents/FinancialSACAgent.cs
@@ -55,7 +55,7 @@ public partial class FinancialSACAgent<T> : TradingAgentBase<T>, IGradientComput
 
     #region Fields
 
-    private readonly FinancialSACAgentOptions<T> _options;
+    private readonly TradingAgentOptions<T> _options;
     private readonly INeuralNetwork<T> _actor;
     private readonly INeuralNetwork<T> _critic1;
     private readonly INeuralNetwork<T> _critic2;
@@ -98,7 +98,7 @@ public FinancialSACAgent(
         TradingAgentOptions<T> options)
         : base(options)
     {
-        _options = options as FinancialSACAgentOptions<T> ?? new FinancialSACAgentOptions<T>();
+        _options = options;
         _actorArchitecture = actorArchitecture;
         _criticArchitecture = criticArchitecture;
 
@@ -107,9 +107,9 @@ public FinancialSACAgent(
 
         _actor = new NeuralNetwork<T>(actorArchitecture, lossFunction: TradingOptions.LossFunction ?? new MeanSquaredErrorLoss<T>());
         _critic1 = new NeuralNetwork<T>(criticArchitecture, lossFunction: TradingOptions.LossFunction ?? new MeanSquaredErrorLoss<T>());
-        _critic2 = new NeuralNetwork<T>(criticArchitecture, lossFunction: TradingOptions.LossFunction ?? new MeanSquaredErrorLoss<T>());
-        _targetCritic1 = new NeuralNetwork<T>(criticArchitecture, lossFunction: TradingOptions.LossFunction ?? new MeanSquaredErrorLoss<T>());
-        _targetCritic2 = new NeuralNetwork<T>(criticArchitecture, lossFunction: TradingOptions.LossFunction ?? new MeanSquaredErrorLoss<T>());
+        _critic2 = new NeuralNetwork<T>(criticArchitecture.CloneForModelConstruction(), lossFunction: TradingOptions.LossFunction ?? new MeanSquaredErrorLoss<T>());
+        _targetCritic1 = new NeuralNetwork<T>(criticArchitecture.CloneForModelConstruction(), lossFunction: TradingOptions.LossFunction ?? new MeanSquaredErrorLoss<T>());
+        _targetCritic2 = new NeuralNetwork<T>(criticArchitecture.CloneForModelConstruction(), lossFunction: TradingOptions.LossFunction ?? new MeanSquaredErrorLoss<T>());
         ReplayBuffer = new ReplayBuffer<T>(options.ReplayBufferSize, options.Seed);
         
         UpdateTargetNetworks(1.0); // Hard sync at start
@@ -259,40 +259,6 @@ public override void StoreExperience(Vector<T> state, Vector<T> action, T reward
 
     #region Serialization
 
-    /// <summary>
-    /// Executes Serialize for the FinancialSACAgent.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> In the FinancialSACAgent model, Serialize saves or restores model-specific settings. This lets the FinancialSACAgent architecture be reused later.
-    /// </para>
-    /// </remarks>
-    public override byte[] Serialize()
-    {
-        using var ms = new MemoryStream();
-        using var writer = new BinaryWriter(ms);
-        var actorData = _actor.Serialize();
-        writer.Write(actorData.Length);
-        writer.Write(actorData);
-        return ms.ToArray();
-    }
-
-    /// <summary>
-    /// Executes Deserialize for the FinancialSACAgent.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> In the FinancialSACAgent model, Deserialize saves or restores model-specific settings. This lets the FinancialSACAgent architecture be reused later.
-    /// </para>
-    /// </remarks>
-    public override void Deserialize(byte[] data)
-    {
-        using var ms = new MemoryStream(data);
-        using var reader = new BinaryReader(ms);
-        int actorLen = reader.ReadInt32();
-        _actor.Deserialize(reader.ReadBytes(actorLen));
-    }
-
     #endregion
 
     #region Model Metadata
@@ -317,21 +283,6 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    /// <summary>
-    /// Executes Clone for the FinancialSACAgent.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> In the FinancialSACAgent model, Clone performs a supporting step in the workflow. It keeps the FinancialSACAgent architecture pipeline consistent.
-    /// </para>
-    /// </remarks>
-    public override IFullModel<T, Vector<T>, Vector<T>> Clone()
-    {
-        var clone = new FinancialSACAgent<T>(_actorArchitecture, _criticArchitecture, TradingOptions);
-        clone.SetParameters(GetParameters());
-        return clone;
-    }
-
     /// <summary>
     /// Executes ComputeGradients for the FinancialSACAgent.
     /// </summary>
diff --git a/src/Finance/Trading/Agents/MarketMakingAgent.cs b/src/Finance/Trading/Agents/MarketMakingAgent.cs
index f6e7450455..473e1bda85 100644
--- a/src/Finance/Trading/Agents/MarketMakingAgent.cs
+++ b/src/Finance/Trading/Agents/MarketMakingAgent.cs
@@ -326,26 +326,6 @@ public override void StoreExperience(Vector<T> state, Vector<T> action, T reward
 
     #region Serialization
 
-    /// <summary>
-    /// Executes Serialize for the MarketMakingAgent.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> In the MarketMakingAgent model, Serialize saves or restores model-specific settings. This lets the MarketMakingAgent architecture be reused later.
-    /// </para>
-    /// </remarks>
-    public override byte[] Serialize() => _policyNetwork.Serialize();
-
-    /// <summary>
-    /// Executes Deserialize for the MarketMakingAgent.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> In the MarketMakingAgent model, Deserialize saves or restores model-specific settings. This lets the MarketMakingAgent architecture be reused later.
-    /// </para>
-    /// </remarks>
-    public override void Deserialize(byte[] data) => _policyNetwork.Deserialize(data);
-
     #endregion
 
     #region Model Metadata
@@ -372,21 +352,6 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    /// <summary>
-    /// Executes Clone for the MarketMakingAgent.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> In the MarketMakingAgent model, Clone performs a supporting step in the workflow. It keeps the MarketMakingAgent architecture pipeline consistent.
-    /// </para>
-    /// </remarks>
-    public override IFullModel<T, Vector<T>, Vector<T>> Clone()
-    {
-        var clone = new MarketMakingAgent<T>(_architecture, _mmOptions);
-        clone.SetParameters(GetParameters());
-        return clone;
-    }
-
     /// <summary>
     /// Executes ComputeGradients for the MarketMakingAgent.
     /// </summary>
diff --git a/src/Finance/Trading/Agents/RecurrentPolicyAgent.cs b/src/Finance/Trading/Agents/RecurrentPolicyAgent.cs
index e871641055..f0c7431db1 100644
--- a/src/Finance/Trading/Agents/RecurrentPolicyAgent.cs
+++ b/src/Finance/Trading/Agents/RecurrentPolicyAgent.cs
@@ -31,7 +31,7 @@ namespace AiDotNet.Finance.Trading.Agents;
 /// </para>
 /// </summary>
 /// <typeparam name="T">Element type (float/double).</typeparam>
-public sealed class RecurrentPolicyAgent<T> : IPortfolioAgent<T>
+public sealed partial class RecurrentPolicyAgent<T> : IPortfolioAgent<T>
 {
     private static readonly INumericOperations<T> NumOps = MathHelper.GetNumericOperations<T>();
     private static IEngine Engine => AiDotNetEngine.Current;
@@ -44,13 +44,17 @@ public sealed class RecurrentPolicyAgent<T> : IPortfolioAgent<T>
     private readonly Random _rng;
 
     private readonly DeepARLstmCellTape<T> _cell;   // recurrent core (tape-trainable)
+    [AiDotNet.Attributes.TrainableParameter]
     private readonly Tensor<T> _meanW;              // [actionDim, hidden]
+    [AiDotNet.Attributes.TrainableParameter]
     private readonly Tensor<T> _meanB;              // [actionDim, 1]
     private readonly IReadOnlyList<Tensor<T>> _trainable;
     private readonly AdamOptimizer<T, Matrix<T>, Vector<T>> _optimizer;
 
     // Per-episode recurrent state (eager act path).
+    [AiDotNet.Attributes.Scratch]
     private Tensor<T> _h = null!;
+    [AiDotNet.Attributes.Scratch]
     private Tensor<T> _c = null!;
 
     // Current-episode rollout.
diff --git a/src/Finance/Trading/Agents/TradingAgentBase.cs b/src/Finance/Trading/Agents/TradingAgentBase.cs
index 434147695f..a7d6df97a6 100644
--- a/src/Finance/Trading/Agents/TradingAgentBase.cs
+++ b/src/Finance/Trading/Agents/TradingAgentBase.cs
@@ -44,7 +44,7 @@ namespace AiDotNet.Finance.Trading.Agents;
 /// 6. Repeat thousands of times until convergence
 /// </para>
 /// </remarks>
-public abstract class TradingAgentBase<T> : ReinforcementLearningAgentBase<T>, ITradingAgent<T>
+public abstract partial class TradingAgentBase<T> : ReinforcementLearningAgentBase<T>, ITradingAgent<T>
 {
     #region Fields
 
diff --git a/src/Finance/Trading/Environments/TradingEnvironment.cs b/src/Finance/Trading/Environments/TradingEnvironment.cs
index b7637841da..6de5d5daea 100644
--- a/src/Finance/Trading/Environments/TradingEnvironment.cs
+++ b/src/Finance/Trading/Environments/TradingEnvironment.cs
@@ -50,7 +50,7 @@ namespace AiDotNet.Finance.Trading.Environments;
     "https://arxiv.org/abs/2511.12120",
     Year = 2020,
     Authors = "Hongyang Yang, Xiao-Yang Liu, Shan Zhong, Anwar Walid")]
-public abstract class TradingEnvironment<T> : IEnvironment<T>
+public abstract partial class TradingEnvironment<T> : IEnvironment<T>
 {
     protected readonly INumericOperations<T> NumOps;
     protected IEngine Engine => AiDotNetEngine.Current;
@@ -66,6 +66,7 @@ public abstract class TradingEnvironment<T> : IEnvironment<T>
     private Random _random;
     private int _currentStep;
     private int _episodeStep;
+    [AiDotNet.Attributes.TrainableParameter]
     protected Vector<T> _positions;
     protected T _cash;
     protected T _portfolioValue;
diff --git a/src/Finance/Trading/Factors/AlphaFactorModel.cs b/src/Finance/Trading/Factors/AlphaFactorModel.cs
index cca8670ab3..43dc5a9c79 100644
--- a/src/Finance/Trading/Factors/AlphaFactorModel.cs
+++ b/src/Finance/Trading/Factors/AlphaFactorModel.cs
@@ -66,7 +66,7 @@ namespace AiDotNet.Finance.Trading.Factors;
     Direction = TensorLayoutDirection.Input, BatchOptional = true)]
 [TensorLayout(TensorAxis.Batch, TensorAxis.Features,
     Direction = TensorLayoutDirection.Output, BatchOptional = true)]
-public class AlphaFactorModel<T> : FinancialModelBase<T>, IFactorModel<T>
+public partial class AlphaFactorModel<T> : FinancialModelBase<T>, IFactorModel<T>
 {
     #region Execution Mode
 
@@ -377,31 +377,6 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    /// <summary>
-    /// Creates a new instance with the same configuration.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> This is used when the framework needs a fresh model
-    /// with the same settings (for example during cloning).
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var optionsCopy = new AlphaFactorOptions<T>
-        {
-            NumFactors = _numFactors,
-            NumAssets = _numAssets,
-            NumFeatures = _numFeatures,
-            HiddenDimension = _hiddenDimension,
-            SequenceLength = _sequenceLength,
-            PredictionHorizon = _predictionHorizon,
-            DropoutRate = _dropoutRate
-        };
-
-        return new AlphaFactorModel<T>(Architecture, optionsCopy);
-    }
-
     /// <summary>
     /// Serializes model-specific data.
     /// </summary>
@@ -411,16 +386,7 @@ protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
     /// <b>For Beginners:</b> Saves the model configuration so it can be restored later.
     /// </para>
     /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_numFactors);
-        writer.Write(_numAssets);
-        writer.Write(_numFeatures);
-        writer.Write(_hiddenDimension);
-        writer.Write(_sequenceLength);
-        writer.Write(_predictionHorizon);
-        writer.Write(_dropoutRate);
-    }
+
 
     /// <summary>
     /// Deserializes model-specific data.
@@ -431,16 +397,7 @@ protected override void SerializeNetworkSpecificData(BinaryWriter writer)
     /// <b>For Beginners:</b> Restores the saved configuration when loading a model.
     /// </para>
     /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _numFactors = reader.ReadInt32();
-        _numAssets = reader.ReadInt32();
-        _numFeatures = reader.ReadInt32();
-        _hiddenDimension = reader.ReadInt32();
-        _sequenceLength = reader.ReadInt32();
-        _predictionHorizon = reader.ReadInt32();
-        _dropoutRate = reader.ReadDouble();
-    }
+
 
     #endregion
 
diff --git a/src/Finance/Trading/Factors/FactorVAE.cs b/src/Finance/Trading/Factors/FactorVAE.cs
index a6f115f706..e8f0bfb406 100644
--- a/src/Finance/Trading/Factors/FactorVAE.cs
+++ b/src/Finance/Trading/Factors/FactorVAE.cs
@@ -91,7 +91,7 @@ namespace AiDotNet.Finance.Trading.Factors;
     Direction = TensorLayoutDirection.Input, BatchOptional = true)]
 [TensorLayout(TensorAxis.Batch, TensorAxis.Features,
     Direction = TensorLayoutDirection.Output, BatchOptional = true)]
-public class FactorVAE<T> : FinancialModelBase<T>, IFactorModel<T>
+public partial class FactorVAE<T> : FinancialModelBase<T>, IFactorModel<T>
 {
     #region Execution Mode
 
@@ -790,36 +790,6 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    /// <summary>
-    /// Creates a new instance with the same configuration.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Used by the framework to clone models with identical settings.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var optionsCopy = new FactorVAEOptions<T>
-        {
-            NumFactors = _numFactors,
-            NumAssets = _numAssets,
-            NumFeatures = _numFeatures,
-            HiddenDimension = _hiddenDimension,
-            LatentDimension = _latentDimension,
-            SequenceLength = _sequenceLength,
-            PredictionHorizon = _predictionHorizon,
-            Beta = _beta,
-            Gamma = _gamma,
-            DropoutRate = _dropoutRate,
-            KlWeight = _options.KlWeight,
-            Seed = _options.Seed,
-            UseAMSGrad = _options.UseAMSGrad
-        };
-
-        return new FactorVAE<T>(Architecture, optionsCopy);
-    }
-
     /// <summary>
     /// Serializes model-specific data.
     /// </summary>
@@ -829,28 +799,7 @@ protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
     /// <b>For Beginners:</b> Saves the model configuration so it can be restored later.
     /// </para>
     /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_numFactors);
-        writer.Write(_numAssets);
-        writer.Write(_numFeatures);
-        writer.Write(_hiddenDimension);
-        writer.Write(_latentDimension);
-        writer.Write(_sequenceLength);
-        writer.Write(_predictionHorizon);
-        writer.Write(_beta);
-        writer.Write(_gamma);
-        writer.Write(_dropoutRate);
-
-        // The three options CreateNewInstance already copies. Without them, a model saved after
-        // training and reloaded into an instance built from defaults got a different KL weight and a
-        // different sampling seed, so the reloaded model did not behave like the saved one. Seed is
-        // nullable, so a presence flag precedes it.
-        writer.Write(_options.KlWeight);
-        writer.Write(_options.UseAMSGrad);
-        writer.Write(_options.Seed.HasValue);
-        if (_options.Seed.HasValue) writer.Write(_options.Seed.Value);
-    }
+
 
     /// <summary>
     /// Deserializes model-specific data.
@@ -861,38 +810,7 @@ protected override void SerializeNetworkSpecificData(BinaryWriter writer)
     /// <b>For Beginners:</b> Restores the saved configuration when loading a model.
     /// </para>
     /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _numFactors = reader.ReadInt32();
-        _numAssets = reader.ReadInt32();
-        _numFeatures = reader.ReadInt32();
-        _hiddenDimension = reader.ReadInt32();
-        _latentDimension = reader.ReadInt32();
-        _sequenceLength = reader.ReadInt32();
-        _predictionHorizon = reader.ReadInt32();
-        _beta = reader.ReadDouble();
-        _gamma = reader.ReadDouble();
-        _dropoutRate = reader.ReadDouble();
-
-        // Read back in the order SerializeNetworkSpecificData wrote them.
-        _options.KlWeight = reader.ReadDouble();
-        _options.UseAMSGrad = reader.ReadBoolean();
-        _options.Seed = reader.ReadBoolean() ? reader.ReadInt32() : (int?)null;
-
-        // Restoring the OPTIONS is not enough on its own. _random and the default optimizer are both
-        // built from these values during construction, so without rebuilding them the reloaded model
-        // kept sampling from the seed it happened to be constructed with and kept the AMSGrad setting
-        // it was constructed with -- the three restored values would have been dead on arrival.
-        // KlWeight needs no such treatment: it is read from _options at the point of use.
-        _random = _options.Seed.HasValue
-            ? RandomHelper.CreateSeededRandom(_options.Seed.Value)
-            : RandomHelper.CreateSeededRandom(DefaultSamplingSeed);
 
-        // Only when this instance built its own. A caller-supplied optimizer carries state and
-        // configuration the saved model knows nothing about, and discarding it would be worse than
-        // the flag not taking effect.
-        if (_usesDefaultOptimizer) _optimizer = CreateDefaultOptimizer();
-    }
 
     #endregion
 
diff --git a/src/Finance/Trading/Factors/Stockformer.cs b/src/Finance/Trading/Factors/Stockformer.cs
index 431965e032..766d687223 100644
--- a/src/Finance/Trading/Factors/Stockformer.cs
+++ b/src/Finance/Trading/Factors/Stockformer.cs
@@ -480,12 +480,6 @@ private StockformerDualEncoder<T> Encoder
         }
     }
 
-    // UpdateParameters re-sliced the flat vector across Layers by hand -- the base walks
-    // exactly the same enumeration, so this said nothing the base does not already say.
-    /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-        => new Stockformer<T>(_options) { AssetGraph = AssetGraph, AssetEmbedding = AssetEmbedding };
-
     /// <summary>Builds the architecture descriptor the financial base requires.</summary>
     /// <remarks>
     /// <para>
diff --git a/src/Finance/Volatility/HarRvModel.cs b/src/Finance/Volatility/HarRvModel.cs
index 638945f16e..1030d9d5f0 100644
--- a/src/Finance/Volatility/HarRvModel.cs
+++ b/src/Finance/Volatility/HarRvModel.cs
@@ -166,19 +166,6 @@ public static double ForecastVolFromReturns(IReadOnlyList<double> returns, doubl
         return Convert.ToDouble(model.ForecastAnnualizedVol(rv, periodsPerYear));
     }
 
-    /// <inheritdoc/>
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        var model = new HarRvModel<T>(Options, Regularization);
-        if (Coefficients is not null)
-        {
-            model.Coefficients = Coefficients.Clone();
-        }
-
-        model.Intercept = Intercept;
-        return model;
-    }
-
     /// <summary>The HAR feature row at time <paramref name="t"/>: [daily RV, weekly avg, monthly avg].</summary>
     private T[] HarRow(IReadOnlyList<T> rv, int t) =>
     [
diff --git a/src/Finance/Volatility/NeuralGARCH.cs b/src/Finance/Volatility/NeuralGARCH.cs
index 3565ff4d33..6a1c66fe8b 100644
--- a/src/Finance/Volatility/NeuralGARCH.cs
+++ b/src/Finance/Volatility/NeuralGARCH.cs
@@ -293,27 +293,6 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    /// <summary>
-    /// Creates a new instance for cloning.
-    /// </summary>
-    /// <remarks>
-    /// <para><b>For Beginners:</b> This is used internally to copy the model.</para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var options = new NeuralGARCHOptions<T>
-        {
-            NumAssets = _numAssets,
-            LookbackWindow = _lookbackWindow,
-            ForecastHorizon = PredictionHorizon,
-            HiddenSize = _hiddenSize,
-            NumLayers = _numLayers,
-            DropoutRate = _dropoutRate
-        };
-
-        return new NeuralGARCH<T>(Architecture, options, _optimizer, _lossFunction);
-    }
-
     #endregion
 
     #region IVolatilityModel Implementation
diff --git a/src/Finance/Volatility/RealizedVolatilityTransformer.cs b/src/Finance/Volatility/RealizedVolatilityTransformer.cs
index 6c5b8b89cf..af6bc0b665 100644
--- a/src/Finance/Volatility/RealizedVolatilityTransformer.cs
+++ b/src/Finance/Volatility/RealizedVolatilityTransformer.cs
@@ -290,28 +290,6 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    /// <summary>
-    /// Creates a new instance for cloning.
-    /// </summary>
-    /// <remarks>
-    /// <para><b>For Beginners:</b> Used internally to make a full copy of the model.</para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var options = new RealizedVolatilityTransformerOptions<T>
-        {
-            NumAssets = _numAssets,
-            LookbackWindow = _lookbackWindow,
-            ForecastHorizon = PredictionHorizon,
-            HiddenSize = _hiddenSize,
-            NumHeads = _numHeads,
-            NumLayers = _numLayers,
-            DropoutRate = _dropoutRate
-        };
-
-        return new RealizedVolatilityTransformer<T>(Architecture, options, _optimizer, _lossFunction);
-    }
-
     #endregion
 
     #region IVolatilityModel Implementation
diff --git a/src/FineTuning/ConstitutionalAIFineTuning.cs b/src/FineTuning/ConstitutionalAIFineTuning.cs
index c272ac6634..a95c1f45ac 100644
--- a/src/FineTuning/ConstitutionalAIFineTuning.cs
+++ b/src/FineTuning/ConstitutionalAIFineTuning.cs
@@ -28,7 +28,7 @@ namespace AiDotNet.FineTuning;
 /// <typeparam name="T">The numeric data type used for calculations.</typeparam>
 /// <typeparam name="TInput">The input data type for the model.</typeparam>
 /// <typeparam name="TOutput">The output data type for the model.</typeparam>
-public class ConstitutionalAIFineTuning<T, TInput, TOutput> : FineTuningBase<T, TInput, TOutput>
+public partial class ConstitutionalAIFineTuning<T, TInput, TOutput> : FineTuningBase<T, TInput, TOutput>
 {
     private IFullModel<T, TInput, TOutput>? _referenceModel;
 
diff --git a/src/FineTuning/DirectPreferenceOptimization.cs b/src/FineTuning/DirectPreferenceOptimization.cs
index 7367e719b1..e0e41dc35b 100644
--- a/src/FineTuning/DirectPreferenceOptimization.cs
+++ b/src/FineTuning/DirectPreferenceOptimization.cs
@@ -29,7 +29,7 @@ namespace AiDotNet.FineTuning;
 /// <typeparam name="T">The numeric data type used for calculations.</typeparam>
 /// <typeparam name="TInput">The input data type for the model.</typeparam>
 /// <typeparam name="TOutput">The output data type for the model.</typeparam>
-public class DirectPreferenceOptimization<T, TInput, TOutput> : FineTuningBase<T, TInput, TOutput>
+public partial class DirectPreferenceOptimization<T, TInput, TOutput> : FineTuningBase<T, TInput, TOutput>
 {
     private IFullModel<T, TInput, TOutput>? _referenceModel;
 
diff --git a/src/FineTuning/FineTuningBase.cs b/src/FineTuning/FineTuningBase.cs
index 14f22742c7..701ebaa9b8 100644
--- a/src/FineTuning/FineTuningBase.cs
+++ b/src/FineTuning/FineTuningBase.cs
@@ -23,8 +23,51 @@ namespace AiDotNet.FineTuning;
 /// <typeparam name="T">The numeric data type used for calculations.</typeparam>
 /// <typeparam name="TInput">The input data type for the model.</typeparam>
 /// <typeparam name="TOutput">The output data type for the model.</typeparam>
-public abstract class FineTuningBase<T, TInput, TOutput> : IFineTuning<T, TInput, TOutput>, IModelShape
+public abstract partial class FineTuningBase<T, TInput, TOutput> : IFineTuning<T, TInput, TOutput>, IModelShape
 {
+    // --- declared state (ModelStateRegistry) ---
+    // Identical in every model base because these bases are siblings over the same interfaces rather
+    // than one hierarchy; the logic itself lives once in ModelStateRegistry/ModelStateEnvelope.
+
+    /// <summary>State that is not a parameter vector, declared once and persisted by this base.</summary>
+    private readonly AiDotNet.Models.ModelStateRegistry<T> _declaredState = new();
+    private bool _declaredStateRegistered;
+
+    /// <summary>
+    /// Declare state here that the parameter vector does not carry -- a retained training set,
+    /// fitted knots, kernel centres, an ensemble's children. Both halves of the payload are driven
+    /// by the declaration, so they cannot drift.
+    /// </summary>
+    /// <param name="state">The registry to declare into.</param>
+    protected virtual void RegisterState(AiDotNet.Models.ModelStateRegistry<T> state)
+    {
+    }
+    /// <summary>Generated state declarations for fields declared across this model's hierarchy.</summary>
+    /// <param name="state">The registry to declare into.</param>
+    /// <remarks>
+    /// Emitted by ModelStateGenerator into the partial model, so a model author declares nothing. The
+    /// hand-written <c>RegisterState</c> beside it exists only for state the classifier genuinely
+    /// cannot place; anything it CAN place belongs here, where it cannot be forgotten.
+    /// </remarks>
+    protected virtual void RegisterGeneratedState(AiDotNet.Models.ModelStateRegistry<T> state)
+    {
+        RegisterGeneratedStateCore(state);
+    }
+
+    /// <summary>The declared state, registered once and lazily so it runs after the constructor.</summary>
+    protected AiDotNet.Models.ModelStateRegistry<T> DeclaredState
+    {
+        get
+        {
+            if (!_declaredStateRegistered)
+            {
+                _declaredStateRegistered = true;
+                RegisterGeneratedState(_declaredState);
+                RegisterState(_declaredState);
+            }
+            return _declaredState;
+        }
+    }
     /// <summary>
     /// The numeric operations helper for type T.
     /// </summary>
@@ -103,12 +146,15 @@ public virtual byte[] Serialize()
     {
         ModelPersistenceGuard.EnforceBeforeSerialize();
         var json = JsonConvert.SerializeObject(Options, Formatting.None);
-        return Encoding.UTF8.GetBytes(json);
+        return AiDotNet.Models.ModelStateEnvelope.Append(DeclaredState, Encoding.UTF8.GetBytes(json));
     }
 
     /// <inheritdoc/>
     public virtual void Deserialize(byte[] data)
     {
+        // Strips and applies any declared-state trailer, so the body below reads the payload
+        // exactly as it did before this existed.
+        data = AiDotNet.Models.ModelStateEnvelope.Extract(DeclaredState, data);
         ModelPersistenceGuard.EnforceBeforeDeserialize();
         if (data == null)
         {
diff --git a/src/FineTuning/GroupRelativePolicyOptimization.cs b/src/FineTuning/GroupRelativePolicyOptimization.cs
index bed8225d1f..981a757f6c 100644
--- a/src/FineTuning/GroupRelativePolicyOptimization.cs
+++ b/src/FineTuning/GroupRelativePolicyOptimization.cs
@@ -38,7 +38,7 @@ namespace AiDotNet.FineTuning;
 /// <typeparam name="T">The numeric data type used for calculations.</typeparam>
 /// <typeparam name="TInput">The input data type for the model.</typeparam>
 /// <typeparam name="TOutput">The output data type for the model.</typeparam>
-public class GroupRelativePolicyOptimization<T, TInput, TOutput> : FineTuningBase<T, TInput, TOutput>
+public partial class GroupRelativePolicyOptimization<T, TInput, TOutput> : FineTuningBase<T, TInput, TOutput>
 {
     private IFullModel<T, TInput, TOutput>? _referenceModel;
     private Func<TInput, TOutput, double>? _rewardFunction;
diff --git a/src/FineTuning/IdentityPreferenceOptimization.cs b/src/FineTuning/IdentityPreferenceOptimization.cs
index cdd3b6df6e..20c40edfcb 100644
--- a/src/FineTuning/IdentityPreferenceOptimization.cs
+++ b/src/FineTuning/IdentityPreferenceOptimization.cs
@@ -27,7 +27,7 @@ namespace AiDotNet.FineTuning;
 /// <typeparam name="T">The numeric data type used for calculations.</typeparam>
 /// <typeparam name="TInput">The input data type for the model.</typeparam>
 /// <typeparam name="TOutput">The output data type for the model.</typeparam>
-public class IdentityPreferenceOptimization<T, TInput, TOutput> : FineTuningBase<T, TInput, TOutput>
+public partial class IdentityPreferenceOptimization<T, TInput, TOutput> : FineTuningBase<T, TInput, TOutput>
 {
     private IFullModel<T, TInput, TOutput>? _referenceModel;
 
diff --git a/src/FineTuning/KahnemanTverskyOptimization.cs b/src/FineTuning/KahnemanTverskyOptimization.cs
index 2395f0dca5..361148050e 100644
--- a/src/FineTuning/KahnemanTverskyOptimization.cs
+++ b/src/FineTuning/KahnemanTverskyOptimization.cs
@@ -31,7 +31,7 @@ namespace AiDotNet.FineTuning;
 /// <typeparam name="T">The numeric data type used for calculations.</typeparam>
 /// <typeparam name="TInput">The input data type for the model.</typeparam>
 /// <typeparam name="TOutput">The output data type for the model.</typeparam>
-public class KahnemanTverskyOptimization<T, TInput, TOutput> : FineTuningBase<T, TInput, TOutput>
+public partial class KahnemanTverskyOptimization<T, TInput, TOutput> : FineTuningBase<T, TInput, TOutput>
 {
     private IFullModel<T, TInput, TOutput>? _referenceModel;
 
diff --git a/src/FineTuning/ReinforcementLearningHumanFeedback.cs b/src/FineTuning/ReinforcementLearningHumanFeedback.cs
index fcfe231863..567c6274b1 100644
--- a/src/FineTuning/ReinforcementLearningHumanFeedback.cs
+++ b/src/FineTuning/ReinforcementLearningHumanFeedback.cs
@@ -30,7 +30,7 @@ namespace AiDotNet.FineTuning;
 /// <typeparam name="T">The numeric data type used for calculations.</typeparam>
 /// <typeparam name="TInput">The input data type for the model.</typeparam>
 /// <typeparam name="TOutput">The output data type for the model.</typeparam>
-public class ReinforcementLearningHumanFeedback<T, TInput, TOutput> : FineTuningBase<T, TInput, TOutput>
+public partial class ReinforcementLearningHumanFeedback<T, TInput, TOutput> : FineTuningBase<T, TInput, TOutput>
 {
     private IFullModel<T, TInput, TOutput>? _referenceModel;
     private IFullModel<T, TInput, TOutput>? _valueModel;
diff --git a/src/FineTuning/RobustDirectPreferenceOptimization.cs b/src/FineTuning/RobustDirectPreferenceOptimization.cs
index b495d8adf1..9b707199d3 100644
--- a/src/FineTuning/RobustDirectPreferenceOptimization.cs
+++ b/src/FineTuning/RobustDirectPreferenceOptimization.cs
@@ -24,7 +24,7 @@ namespace AiDotNet.FineTuning;
 /// <typeparam name="T">The numeric data type used for calculations.</typeparam>
 /// <typeparam name="TInput">The input data type for the model.</typeparam>
 /// <typeparam name="TOutput">The output data type for the model.</typeparam>
-public class RobustDirectPreferenceOptimization<T, TInput, TOutput> : FineTuningBase<T, TInput, TOutput>
+public partial class RobustDirectPreferenceOptimization<T, TInput, TOutput> : FineTuningBase<T, TInput, TOutput>
 {
     private IFullModel<T, TInput, TOutput>? _referenceModel;
 
diff --git a/src/FineTuning/SelfPlayFineTuning.cs b/src/FineTuning/SelfPlayFineTuning.cs
index a246984cba..b2de5a357f 100644
--- a/src/FineTuning/SelfPlayFineTuning.cs
+++ b/src/FineTuning/SelfPlayFineTuning.cs
@@ -29,7 +29,7 @@ namespace AiDotNet.FineTuning;
 /// <typeparam name="T">The numeric data type used for calculations.</typeparam>
 /// <typeparam name="TInput">The input data type for the model.</typeparam>
 /// <typeparam name="TOutput">The output data type for the model.</typeparam>
-public class SelfPlayFineTuning<T, TInput, TOutput> : FineTuningBase<T, TInput, TOutput>
+public partial class SelfPlayFineTuning<T, TInput, TOutput> : FineTuningBase<T, TInput, TOutput>
 {
     private IFullModel<T, TInput, TOutput>? _opponentModel;
 
diff --git a/src/FineTuning/StatisticalRejectionSampling.cs b/src/FineTuning/StatisticalRejectionSampling.cs
index 1acdad53cd..3840ccba75 100644
--- a/src/FineTuning/StatisticalRejectionSampling.cs
+++ b/src/FineTuning/StatisticalRejectionSampling.cs
@@ -23,7 +23,7 @@ namespace AiDotNet.FineTuning;
 /// <typeparam name="T">The numeric data type used for calculations.</typeparam>
 /// <typeparam name="TInput">The input data type for the model.</typeparam>
 /// <typeparam name="TOutput">The output data type for the model.</typeparam>
-public class StatisticalRejectionSampling<T, TInput, TOutput> : FineTuningBase<T, TInput, TOutput>
+public partial class StatisticalRejectionSampling<T, TInput, TOutput> : FineTuningBase<T, TInput, TOutput>
 {
     private IFullModel<T, TInput, TOutput>? _referenceModel;
 
diff --git a/src/FitDetectors/GaussianProcessFitDetector.cs b/src/FitDetectors/GaussianProcessFitDetector.cs
index 40c2f0ebf4..563734e206 100644
--- a/src/FitDetectors/GaussianProcessFitDetector.cs
+++ b/src/FitDetectors/GaussianProcessFitDetector.cs
@@ -16,7 +16,7 @@ namespace AiDotNet.FitDetectors;
 /// (high uncertainty and poor performance).
 /// </para>
 /// </remarks>
-public class GaussianProcessFitDetector<T, TInput, TOutput> : FitDetectorBase<T, TInput, TOutput>
+public partial class GaussianProcessFitDetector<T, TInput, TOutput> : FitDetectorBase<T, TInput, TOutput>
 {
     /// <summary>
     /// Configuration options for the Gaussian Process fit detector.
@@ -28,7 +28,9 @@ public class GaussianProcessFitDetector<T, TInput, TOutput> : FitDetectorBase<T,
     /// </remarks>
     private readonly GaussianProcessFitDetectorOptions _options;
 
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T> _meanPrediction;
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T> _variancePrediction;
     private T _averageUncertainty;
     private T _rmse;
diff --git a/src/GaussianProcesses/BayesianGPLVM.cs b/src/GaussianProcesses/BayesianGPLVM.cs
index 9dc9f77522..37fa5689e6 100644
--- a/src/GaussianProcesses/BayesianGPLVM.cs
+++ b/src/GaussianProcesses/BayesianGPLVM.cs
@@ -44,7 +44,7 @@ namespace AiDotNet.GaussianProcesses;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Matrix<>), typeof(Matrix<>))]
 [ResearchPaper("Bayesian Gaussian Process Latent Variable Model", "https://doi.org/10.48550/arXiv.1309.6835", Year = 2010, Authors = "Michalis K. Titsias, Neil D. Lawrence")]
-public class BayesianGPLVM<T>
+public partial class BayesianGPLVM<T>
 {
     /// <summary>
     /// The kernel function for the mapping from latent to observed space.
@@ -76,6 +76,7 @@ public class BayesianGPLVM<T>
     /// and each column is a latent dimension.
     /// </para>
     /// </remarks>
+    [AiDotNet.Attributes.TrainableParameter]
     private Matrix<T>? _latentMean;
 
     /// <summary>
@@ -87,16 +88,19 @@ public class BayesianGPLVM<T>
     /// is in latent space. Larger values mean more uncertainty.
     /// </para>
     /// </remarks>
+    [AiDotNet.Attributes.TrainableParameter]
     private Matrix<T>? _latentVariance;
 
     /// <summary>
     /// The inducing points in latent space (M x Q).
     /// </summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private Matrix<T>? _inducingPoints;
 
     /// <summary>
     /// The observed data (N x D).
     /// </summary>
+    [AiDotNet.Attributes.FittedParameter]
     private Matrix<T>? _observedData;
 
     /// <summary>
diff --git a/src/GaussianProcesses/DeepGaussianProcess.cs b/src/GaussianProcesses/DeepGaussianProcess.cs
index da24a99976..412caa8a14 100644
--- a/src/GaussianProcesses/DeepGaussianProcess.cs
+++ b/src/GaussianProcesses/DeepGaussianProcess.cs
@@ -55,13 +55,25 @@ namespace AiDotNet.GaussianProcesses;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
 [ResearchPaper("Deep Gaussian Processes", "https://doi.org/10.48550/arXiv.1211.0358", Year = 2013, Authors = "Andreas Damianou, Neil D. Lawrence")]
-public class DeepGaussianProcess<T> : GaussianProcessBase<T>
+public partial class DeepGaussianProcess<T> : GaussianProcessBase<T>
 {
     /// <summary>
     /// The GP layers in the deep architecture.
     /// </summary>
     private readonly List<DGPLayer<T>> _layers;
 
+    /// <summary>The per-layer kernels this process was built from.</summary>
+    /// <remarks>
+    /// Both are kept because the constructor spends them building <see cref="_layers"/> and nothing
+    /// gives them back: recovering them would mean projecting a list of layers into two arrays, which
+    /// is not something the clone plan can express. The convenience constructor fills them in with the
+    /// arrays it is equivalent to, so an instance built either way rebuilds through the same one.
+    /// </remarks>
+    private readonly IKernelFunction<T>[] _layerKernels;
+
+    /// <summary>The per-layer output widths, one fewer than the kernels; the last layer emits 1D.</summary>
+    private readonly int[] _layerWidths;
+
     /// <summary>
     /// The training input data.
     /// </summary>
@@ -154,6 +166,9 @@ public DeepGaussianProcess(
         if (layerWidths.Length != layerKernels.Length - 1)
             throw new ArgumentException("Layer widths must have one fewer element than layer kernels (last layer outputs 1D).", nameof(layerWidths));
 
+        _layerKernels = layerKernels;
+        _layerWidths = layerWidths;
+
         _numOps = MathHelper.GetNumericOperations<T>();
         _decompositionType = decompositionType;
         _numInducingPoints = numInducingPoints;
@@ -216,6 +231,13 @@ public DeepGaussianProcess(
         _X = Matrix<T>.Empty();
         _y = Vector<T>.Empty();
 
+        // Record the arrays this shorthand is equivalent to, so a clone rebuilds through the full
+        // constructor rather than depending on which overload happened to be called.
+        _layerKernels = new IKernelFunction<T>[numLayers];
+        for (int i = 0; i < numLayers; i++) _layerKernels[i] = kernel;
+        _layerWidths = new int[numLayers - 1];
+        for (int i = 0; i < numLayers - 1; i++) _layerWidths[i] = hiddenWidth;
+
         // Create layers with same kernel
         _layers = new List<DGPLayer<T>>();
         for (int i = 0; i < numLayers; i++)
@@ -569,6 +591,7 @@ internal class DGPLayer<T>
     private Matrix<T> _inducingInputs;
     private Matrix<T> _variationalMean;
     private Matrix<T> _variationalCovCholesky;
+    [AiDotNet.Attributes.Scratch]
     private Matrix<T> _Kuu;
 
     public int OutputDim => _outputDim;
diff --git a/src/GaussianProcesses/GPWithMCMC.cs b/src/GaussianProcesses/GPWithMCMC.cs
index 173ea50b7a..27f449fb04 100644
--- a/src/GaussianProcesses/GPWithMCMC.cs
+++ b/src/GaussianProcesses/GPWithMCMC.cs
@@ -30,7 +30,7 @@ namespace AiDotNet.GaussianProcesses;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
 [ResearchPaper("MCMC Methods for Gaussian Process Models", "https://doi.org/10.1007/978-3-540-28650-9_6", Year = 2003, Authors = "Mark N. Gibbs")]
-public class GPWithMCMC<T> : GaussianProcessBase<T>
+public partial class GPWithMCMC<T> : GaussianProcessBase<T>
 {
     /// <summary>
     /// The base kernel function.
diff --git a/src/GaussianProcesses/GaussianProcessClassifier.cs b/src/GaussianProcesses/GaussianProcessClassifier.cs
index 9c5697e812..cc44273e55 100644
--- a/src/GaussianProcesses/GaussianProcessClassifier.cs
+++ b/src/GaussianProcesses/GaussianProcessClassifier.cs
@@ -68,6 +68,7 @@ public class GaussianProcessClassifier<T> : IGaussianProcessClassifier<T>
     /// and each column is one feature (measurement) about that example.
     /// </para>
     /// </remarks>
+    [AiDotNet.Attributes.FittedParameter]
     private Matrix<T> _X;
 
     /// <summary>
@@ -80,11 +81,13 @@ public class GaussianProcessClassifier<T> : IGaussianProcessClassifier<T>
     /// sigmoid (logistic) function.
     /// </para>
     /// </remarks>
+    [AiDotNet.Attributes.FittedParameter]
     private Vector<T> _y;
 
     /// <summary>
     /// The original class labels from training (before transformation).
     /// </summary>
+    [AiDotNet.Attributes.FittedParameter]
     private Vector<T> _originalLabels;
 
     /// <summary>
@@ -97,6 +100,7 @@ public class GaussianProcessClassifier<T> : IGaussianProcessClassifier<T>
     /// pairs of training examples.
     /// </para>
     /// </remarks>
+    [AiDotNet.Attributes.FittedParameter]
     private Matrix<T> _K;
 
     /// <summary>
@@ -109,6 +113,7 @@ public class GaussianProcessClassifier<T> : IGaussianProcessClassifier<T>
     /// The magnitude indicates confidence - larger absolute values mean stronger predictions.
     /// </para>
     /// </remarks>
+    [AiDotNet.Attributes.FittedParameter]
     private Vector<T> _f;
 
     /// <summary>
@@ -121,6 +126,7 @@ public class GaussianProcessClassifier<T> : IGaussianProcessClassifier<T>
     /// calculate uncertainties. Higher values on the diagonal indicate more certainty at those points.
     /// </para>
     /// </remarks>
+    [AiDotNet.Attributes.Buffer]
     private Matrix<T> _W;
 
     /// <summary>
diff --git a/src/GaussianProcesses/HeteroscedasticGaussianProcess.cs b/src/GaussianProcesses/HeteroscedasticGaussianProcess.cs
index b4c7353407..483b5b0fe3 100644
--- a/src/GaussianProcesses/HeteroscedasticGaussianProcess.cs
+++ b/src/GaussianProcesses/HeteroscedasticGaussianProcess.cs
@@ -42,7 +42,7 @@ namespace AiDotNet.GaussianProcesses;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
 [ResearchPaper("Most Likely Heteroscedastic Gaussian Process Regression", "https://doi.org/10.1145/1273496.1273546", Year = 2007, Authors = "Kristian Kersting, Christian Plagemann, Patrick Pfaff, Wolfram Burgard")]
-public class HeteroscedasticGaussianProcess<T> : GaussianProcessBase<T>
+public partial class HeteroscedasticGaussianProcess<T> : GaussianProcessBase<T>
 {
     /// <summary>
     /// Operations for performing numeric calculations with type T.
diff --git a/src/GaussianProcesses/MultiOutputGaussianProcess.cs b/src/GaussianProcesses/MultiOutputGaussianProcess.cs
index 248ed4c60c..3f608358de 100644
--- a/src/GaussianProcesses/MultiOutputGaussianProcess.cs
+++ b/src/GaussianProcesses/MultiOutputGaussianProcess.cs
@@ -29,7 +29,7 @@ namespace AiDotNet.GaussianProcesses;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Matrix<>), typeof(Matrix<>))]
 [ResearchPaper("Multi-task Gaussian Process Prediction", "https://doi.org/10.5555/2981562.2981672", Year = 2008, Authors = "Edwin V. Bonilla, Kian Ming A. Chai, Christopher K. I. Williams")]
-public class MultiOutputGaussianProcess<T> : GaussianProcessBase<T>
+public partial class MultiOutputGaussianProcess<T> : GaussianProcessBase<T>
 {
     /// <summary>
     /// The kernel function that determines how points in the input space relate to each other.
diff --git a/src/GaussianProcesses/MultiTaskGaussianProcess.cs b/src/GaussianProcesses/MultiTaskGaussianProcess.cs
index 04b49bb689..9539cbfbc4 100644
--- a/src/GaussianProcesses/MultiTaskGaussianProcess.cs
+++ b/src/GaussianProcesses/MultiTaskGaussianProcess.cs
@@ -68,6 +68,7 @@ public partial class MultiTaskGaussianProcess<T> : GaussianProcessBase<T>
     /// <summary>
     /// The task correlation matrix (B matrix in ICM/LMC models).
     /// </summary>
+    [AiDotNet.Attributes.FittedParameter]
     private Matrix<T> _taskCovariance;
 
     /// <summary>
diff --git a/src/GaussianProcesses/SparseGaussianProcess.cs b/src/GaussianProcesses/SparseGaussianProcess.cs
index c2bd7d3b9d..4248dc4110 100644
--- a/src/GaussianProcesses/SparseGaussianProcess.cs
+++ b/src/GaussianProcesses/SparseGaussianProcess.cs
@@ -29,7 +29,7 @@ namespace AiDotNet.GaussianProcesses;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
 [ResearchPaper("A Unifying View of Sparse Approximate Gaussian Process Regression", "https://doi.org/10.1162/jmlr.2005.6.65.1939", Year = 2005, Authors = "Joaquin Quiñonero-Candela, Carl Edward Rasmussen")]
-public class SparseGaussianProcess<T> : GaussianProcessBase<T>
+public partial class SparseGaussianProcess<T> : GaussianProcessBase<T>
 {
     /// <summary>
     /// The kernel function that defines the similarity between data points.
diff --git a/src/GaussianProcesses/SparseVariationalGaussianProcess.cs b/src/GaussianProcesses/SparseVariationalGaussianProcess.cs
index 87aa349aa6..bc34929ba7 100644
--- a/src/GaussianProcesses/SparseVariationalGaussianProcess.cs
+++ b/src/GaussianProcesses/SparseVariationalGaussianProcess.cs
@@ -107,6 +107,7 @@ public partial class SparseVariationalGaussianProcess<T> : GaussianProcessBase<T
     /// During optimization, we adjust these values to make our approximation better.
     /// </para>
     /// </remarks>
+    [AiDotNet.Attributes.FittedParameter]
     private Vector<T> _variationalMean;
 
     /// <summary>
@@ -125,6 +126,7 @@ public partial class SparseVariationalGaussianProcess<T> : GaussianProcessBase<T
     /// A larger covariance means more uncertainty; smaller means more confidence.
     /// </para>
     /// </remarks>
+    [AiDotNet.Attributes.FittedParameter]
     private Matrix<T> _variationalCovCholesky;
 
     /// <summary>
diff --git a/src/GaussianProcesses/StandardGaussianProcess.cs b/src/GaussianProcesses/StandardGaussianProcess.cs
index 0c11f7a81c..ef8a856a6d 100644
--- a/src/GaussianProcesses/StandardGaussianProcess.cs
+++ b/src/GaussianProcesses/StandardGaussianProcess.cs
@@ -33,7 +33,7 @@ namespace AiDotNet.GaussianProcesses;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
 [ResearchPaper("Gaussian Processes for Machine Learning", "https://doi.org/10.7551/mitpress/3206.001.0001", Year = 2006, Authors = "Carl Edward Rasmussen, Christopher K. I. Williams")]
-public class StandardGaussianProcess<T> : GaussianProcessBase<T>
+public partial class StandardGaussianProcess<T> : GaussianProcessBase<T>
 {
     /// <summary>
     /// The kernel function that determines how similarity between data points is calculated.
diff --git a/src/GaussianProcesses/StudentTGaussianProcess.cs b/src/GaussianProcesses/StudentTGaussianProcess.cs
index 7ddf102dc8..a6f3e0a9f5 100644
--- a/src/GaussianProcesses/StudentTGaussianProcess.cs
+++ b/src/GaussianProcesses/StudentTGaussianProcess.cs
@@ -37,7 +37,7 @@ namespace AiDotNet.GaussianProcesses;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
 [ResearchPaper("Gaussian Process Regression with Student-t Likelihood", "https://doi.org/10.5555/2986459.2986589", Year = 2011, Authors = "Jarno Vanhatalo, Pasi Jylänki, Aki Vehtari")]
-public class StudentTGaussianProcess<T> : GaussianProcessBase<T>
+public partial class StudentTGaussianProcess<T> : GaussianProcessBase<T>
 {
     /// <summary>
     /// Operations for performing numeric calculations with type T.
diff --git a/src/GaussianProcesses/VariationalGaussianProcess.cs b/src/GaussianProcesses/VariationalGaussianProcess.cs
index 4f4550220b..060feda236 100644
--- a/src/GaussianProcesses/VariationalGaussianProcess.cs
+++ b/src/GaussianProcesses/VariationalGaussianProcess.cs
@@ -76,6 +76,7 @@ public partial class VariationalGaussianProcess<T> : GaussianProcessBase<T>
     /// to maximize the evidence lower bound (ELBO).
     /// </para>
     /// </remarks>
+    [AiDotNet.Attributes.FittedParameter]
     private Vector<T> _variationalMean;
 
     /// <summary>
@@ -88,6 +89,7 @@ public partial class VariationalGaussianProcess<T> : GaussianProcessBase<T>
     /// and to ensure the covariance remains positive definite.
     /// </para>
     /// </remarks>
+    [AiDotNet.Attributes.FittedParameter]
     private Matrix<T> _variationalCovCholesky;
 
     /// <summary>
diff --git a/src/Genetics/AdaptiveGeneticAlgorithm.cs b/src/Genetics/AdaptiveGeneticAlgorithm.cs
index 9a07ee7bca..9ef758de33 100644
--- a/src/Genetics/AdaptiveGeneticAlgorithm.cs
+++ b/src/Genetics/AdaptiveGeneticAlgorithm.cs
@@ -1,6 +1,6 @@
 namespace AiDotNet.Genetics;
 
-public class AdaptiveGeneticAlgorithm<T, TInput, TOutput> :
+public partial class AdaptiveGeneticAlgorithm<T, TInput, TOutput> :
     StandardGeneticAlgorithm<T, TInput, TOutput>
 {
     private readonly double _minMutationRate;
diff --git a/src/Genetics/GeneticBase.cs b/src/Genetics/GeneticBase.cs
index f1d3e52087..3a34995528 100644
--- a/src/Genetics/GeneticBase.cs
+++ b/src/Genetics/GeneticBase.cs
@@ -29,9 +29,52 @@ namespace AiDotNet.Genetics;
 /// the entire genetic algorithm framework.
 /// </para>
 /// </remarks>
-public abstract class GeneticBase<T, TInput, TOutput> :
+public abstract partial class GeneticBase<T, TInput, TOutput> :
     IGeneticAlgorithm<T, TInput, TOutput, ModelIndividual<T, TInput, TOutput, ModelParameterGene<T>>, ModelParameterGene<T>>
 {
+    // --- declared state (ModelStateRegistry) ---
+    // Identical in every model base because these bases are siblings over the same interfaces rather
+    // than one hierarchy; the logic itself lives once in ModelStateRegistry/ModelStateEnvelope.
+
+    /// <summary>State that is not a parameter vector, declared once and persisted by this base.</summary>
+    private readonly AiDotNet.Models.ModelStateRegistry<T> _declaredState = new();
+    private bool _declaredStateRegistered;
+
+    /// <summary>
+    /// Declare state here that the parameter vector does not carry -- a retained training set,
+    /// fitted knots, kernel centres, an ensemble's children. Both halves of the payload are driven
+    /// by the declaration, so they cannot drift.
+    /// </summary>
+    /// <param name="state">The registry to declare into.</param>
+    protected virtual void RegisterState(AiDotNet.Models.ModelStateRegistry<T> state)
+    {
+    }
+    /// <summary>Generated state declarations for fields declared across this model's hierarchy.</summary>
+    /// <param name="state">The registry to declare into.</param>
+    /// <remarks>
+    /// Emitted by ModelStateGenerator into the partial model, so a model author declares nothing. The
+    /// hand-written <c>RegisterState</c> beside it exists only for state the classifier genuinely
+    /// cannot place; anything it CAN place belongs here, where it cannot be forgotten.
+    /// </remarks>
+    protected virtual void RegisterGeneratedState(AiDotNet.Models.ModelStateRegistry<T> state)
+    {
+        RegisterGeneratedStateCore(state);
+    }
+
+    /// <summary>The declared state, registered once and lazily so it runs after the constructor.</summary>
+    protected AiDotNet.Models.ModelStateRegistry<T> DeclaredState
+    {
+        get
+        {
+            if (!_declaredStateRegistered)
+            {
+                _declaredStateRegistered = true;
+                RegisterGeneratedState(_declaredState);
+                RegisterState(_declaredState);
+            }
+            return _declaredState;
+        }
+    }
     /// <summary>
     /// The current population of individuals.
     /// </summary>
@@ -1501,6 +1544,9 @@ public virtual byte[] Serialize()
     /// <param name="data">The byte array containing the serialized model.</param>
     public virtual void Deserialize(byte[] data)
     {
+        // Strips and applies any declared-state trailer, so the body below reads the payload
+        // exactly as it did before this existed.
+        data = AiDotNet.Models.ModelStateEnvelope.Extract(DeclaredState, data);
         ModelPersistenceGuard.EnforceBeforeDeserialize();
         using (MemoryStream ms = new MemoryStream(data))
         using (BinaryReader reader = new BinaryReader(ms))
diff --git a/src/Genetics/StandardGeneticAlgorithm.cs b/src/Genetics/StandardGeneticAlgorithm.cs
index 2192a2b277..052f020f3e 100644
--- a/src/Genetics/StandardGeneticAlgorithm.cs
+++ b/src/Genetics/StandardGeneticAlgorithm.cs
@@ -4,7 +4,7 @@
 
 namespace AiDotNet.Genetics;
 
-public class StandardGeneticAlgorithm<T, TInput, TOutput> :
+public partial class StandardGeneticAlgorithm<T, TInput, TOutput> :
     GeneticBase<T, TInput, TOutput>
 {
     private readonly Func<IFullModel<T, TInput, TOutput>> _modelFactory;
diff --git a/src/Helpers/CopyOnWriteCloneHelper.cs b/src/Helpers/CopyOnWriteCloneHelper.cs
index bf070f937b..91a625a4b0 100644
--- a/src/Helpers/CopyOnWriteCloneHelper.cs
+++ b/src/Helpers/CopyOnWriteCloneHelper.cs
@@ -27,8 +27,8 @@ namespace AiDotNet.Helpers;
 internal static class CopyOnWriteCloneHelper
 {
     /// <summary>
-    /// Re-binds every trainable parameter of <paramref name="dest"/> to a copy-on-write share of the
-    /// corresponding parameter of <paramref name="source"/>. Walks both object graphs in parallel by
+    /// Re-binds every trainable parameter and registered persistent buffer of <paramref name="dest"/>
+    /// to the corresponding state of <paramref name="source"/>. Walks both object graphs in parallel by
     /// reflection (identical runtime type ⇒ identical field order ⇒ matching layer order). Returns
     /// <c>false</c> — leaving <paramref name="dest"/> untouched — if the trainable-layer structure does
     /// not line up 1:1 (e.g. a freshly-constructed clone whose lazy layers aren't resolved yet), so the
@@ -37,13 +37,33 @@ internal static class CopyOnWriteCloneHelper
     internal static bool TryShareTrainableParameters<T>(
         IFullModel<T, Tensor<T>, Tensor<T>>? source,
         IFullModel<T, Tensor<T>, Tensor<T>>? dest)
+        => TryShareTrainableParameters(source, dest, out _);
+
+    /// <summary>Attempts the complete state share and reports the first preflight mismatch.</summary>
+    internal static bool TryShareTrainableParameters<T>(
+        IFullModel<T, Tensor<T>, Tensor<T>>? source,
+        IFullModel<T, Tensor<T>, Tensor<T>>? dest,
+        out string mismatch)
     {
-        if (source is null || dest is null || ReferenceEquals(source, dest)) return false;
-        if (source.GetType() != dest.GetType()) return false;
+        mismatch = string.Empty;
+        if (source is null || dest is null || ReferenceEquals(source, dest))
+        {
+            mismatch = "source and destination must be distinct non-null models";
+            return false;
+        }
+        if (source.GetType() != dest.GetType())
+        {
+            mismatch = $"model types differ ({source.GetType().Name} vs {dest.GetType().Name})";
+            return false;
+        }
 
         var srcLayers = CollectTrainableLayers<T>(source);
         var dstLayers = CollectTrainableLayers<T>(dest);
-        if (srcLayers.Count == 0 || srcLayers.Count != dstLayers.Count) return false;
+        if (srcLayers.Count == 0 || srcLayers.Count != dstLayers.Count)
+        {
+            mismatch = $"trainable layer counts differ ({srcLayers.Count} vs {dstLayers.Count})";
+            return false;
+        }
 
         // Verify the full structure — per-layer parameter COUNT and per-tensor SHAPE — matches BEFORE
         // mutating anything, so we never leave a half-shared clone and never rebind a shape-incompatible
@@ -55,8 +75,42 @@ internal static bool TryShareTrainableParameters<T>(
         // throwaway forward merely to allocate destination storage that will immediately be replaced.
         for (int i = 0; i < srcLayers.Count; i++)
         {
+            if (srcLayers[i].GetType() != dstLayers[i].GetType())
+            {
+                mismatch = $"layer {i} types differ ({srcLayers[i].GetType().Name} vs "
+                           + $"{dstLayers[i].GetType().Name})";
+                return false;
+            }
+
             var sps = GetAuthoritativeSourceValues(srcLayers[i]);
             var dps = GetWithoutMaterialization(dstLayers[i]);
+            bool hasMaterializedSourceValue = false;
+            bool hasSourcePlaceholder = false;
+            for (int p = 0; p < sps.Count; p++)
+            {
+                if (sps[p].Length == 0)
+                {
+                    hasSourcePlaceholder = true;
+                }
+                else
+                {
+                    hasMaterializedSourceValue = true;
+                }
+            }
+
+            // A mixed live/placeholder surface cannot be shared atomically: skipping the layer
+            // would drop its live values, while cloning the zero-sized entries would pretend they
+            // contain learned state. Route that partial lifecycle through the eager fallback.
+            // A WHOLLY deferred layer is different: it contains no values to transfer, and both
+            // graphs retain the same declaration-driven lazy state. Rejecting it disabled COW for
+            // ordinary predictors with optional branches (DiT's unused conditioning projections).
+            if (hasSourcePlaceholder && hasMaterializedSourceValue)
+            {
+                mismatch = $"layer {i} ({srcLayers[i].GetType().Name}) has a deferred "
+                           + $"partial trainable surface: source={DescribeShapes(sps)}";
+                return false;
+            }
+
             bool currentShapesMatch = sps.Count == dps.Count;
             if (currentShapesMatch)
             {
@@ -71,22 +125,85 @@ internal static bool TryShareTrainableParameters<T>(
             if (currentShapesMatch) continue;
             if (dstLayers[i] is not AiDotNet.NeuralNetworks.Layers.LayerBase<T> destinationBase
                 || !destinationBase.CanAdoptTrainableParametersWithoutMaterialization(sps))
+            {
+                mismatch = $"layer {i} ({srcLayers[i].GetType().Name}) has incompatible trainable shapes: "
+                           + $"source={DescribeShapes(sps)}, clone={DescribeShapes(dps)}";
                 return false;
+            }
+        }
+
+        // The parameter-state contract is wider than the optimizer view: registered buffers carry
+        // running statistics, learned non-gradient state, and shape-bearing constants. Validate the
+        // complete buffer graph before sharing any trainable tensor; otherwise the helper can return
+        // true while a freshly reconstructed predictor still owns empty or differently-sized state.
+        for (int i = 0; i < srcLayers.Count; i++)
+        {
+            if (srcLayers[i] is not AiDotNet.NeuralNetworks.Layers.LayerBase<T> sourceBase
+                || dstLayers[i] is not AiDotNet.NeuralNetworks.Layers.LayerBase<T> destinationBase)
+                continue;
+            if (!destinationBase.CanAdoptRegisteredBuffersFrom(sourceBase, out string bufferMismatch))
+            {
+                mismatch = $"layer {i} ({srcLayers[i].GetType().Name}) {bufferMismatch}";
+                return false;
+            }
         }
 
         for (int i = 0; i < srcLayers.Count; i++)
         {
             var sp = GetAuthoritativeSourceValues(srcLayers[i]);
-            if (sp.Count == 0) continue;
-            var shared = new Tensor<T>[sp.Count];
-            for (int p = 0; p < sp.Count; p++)
-                shared[p] = (Tensor<T>)sp[p].CloneShared();
-            dstLayers[i].SetTrainableParameters(shared);
+            bool hasSourceValues = sp.Count > 0;
+            for (int p = 0; p < sp.Count && hasSourceValues; p++)
+                hasSourceValues = sp[p].Length > 0;
+
+            if (hasSourceValues)
+            {
+                var shared = new Tensor<T>[sp.Count];
+                for (int p = 0; p < sp.Count; p++)
+                    shared[p] = (Tensor<T>)sp[p].CloneShared();
+                dstLayers[i].SetTrainableParameters(shared);
+            }
+            else if (sp.Count > 0
+                     && srcLayers[i] is AiDotNet.NeuralNetworks.Layers.LayerBase<T> deferredSource
+                     && dstLayers[i] is AiDotNet.NeuralNetworks.Layers.LayerBase<T> deferredDestination)
+            {
+                // Zero-sized placeholders still carry FUTURE parameter state: the seed, RNG
+                // progress, and initialization counter that determine the values allocated on the
+                // first read/forward. Copying no tensors and reporting success made two untouched
+                // lazy predictors initialize independently after Clone. Preserve that state with
+                // the same shared-base mechanism used by LayerCloning, without materializing either
+                // side or sacrificing the foundation-scale O(1) path.
+                AiDotNet.NeuralNetworks.Layers.LayerCloning.CopyDeferredRandomState(
+                    deferredSource, deferredDestination);
+            }
+
+            // A composite can own no tensor itself while owning trainable descendants. Shape-only
+            // graph bring-up still leaves that parent at a pending first-forward boundary; if it is
+            // skipped merely because sp.Count == 0, its real first forward may rebuild the children
+            // after their COW tensors were installed. Commit every graph node, including parameter-
+            // free parents, so the adopted descendant graph is the graph execution keeps.
+            // Commit nodes that received real values, and parameter-free composites whose child
+            // graph must survive first-forward reconciliation. A node whose source owns only
+            // a mixed live/placeholder source cannot reach this phase: preflight routes that graph
+            // through the state-transfer fallback so a clone never reports success after dropping
+            // real values. A wholly deferred node deliberately remains lazy on both sides.
+            if ((hasSourceValues || sp.Count == 0)
+                && dstLayers[i] is AiDotNet.NeuralNetworks.Layers.LayerBase<T> destinationBase)
+                destinationBase.CommitTrainableParameterAdoption();
+        }
+
+        for (int i = 0; i < srcLayers.Count; i++)
+        {
+            if (srcLayers[i] is AiDotNet.NeuralNetworks.Layers.LayerBase<T> sourceBase
+                && dstLayers[i] is AiDotNet.NeuralNetworks.Layers.LayerBase<T> destinationBase)
+                destinationBase.AdoptRegisteredBuffersFrom(sourceBase);
         }
 
         return true;
     }
 
+    private static string DescribeShapes<T>(IReadOnlyList<Tensor<T>> tensors)
+        => "[" + string.Join(", ", tensors.Select(t => "[" + string.Join(",", t.Shape.ToArray()) + "]")) + "]";
+
     private static IReadOnlyList<Tensor<T>> GetWithoutMaterialization<T>(ITrainableLayer<T> layer) =>
         layer is AiDotNet.NeuralNetworks.Layers.LayerBase<T> layerBase
             ? layerBase.GetTrainableParametersWithoutMaterialization()
@@ -127,19 +244,16 @@ internal static List<ITrainableLayer<T>> CollectTrainableLayers<T>(IFullModel<T,
         // the stable, PyTorch-style ownership boundary for cloning.
         if (root is NeuralNetworkBase<T> neuralNetwork)
         {
-            // `Layers` IS the registered graph, and it is what NeuralNetworkBase itself passes to this
-            // same walk. This used to call a GetCopyOnWriteLayerRoots() that exists nowhere in the
-            // repository -- a call that survived review because NeuralNetworkBase is an error type
-            // while the #1789 split is mid-flight (its declaration depends on types slice 01 has not
-            // landed yet), and Roslyn suppresses member lookup on an error type to avoid cascading
-            // diagnostics. So the compiler could not report it and a search could not find it; it
-            // would have failed the moment the branch built cleanly.
-            //
-            // structureVersion -1 keeps the caching disabled: a clone walks a graph the version
-            // counter has never seen, so a cached answer would describe the wrong model.
+            // Use the base's explicit module ROOTS, not only its canonical sequential Layers list.
+            // Generated/model-declared auxiliary layers participate in training through
+            // GetExtraTrainableLayers; omitting them here made the COW coverage check compare an
+            // incomplete walk with the complete parameter manifest, reject the candidate, and send
+            // dozens of models through the lossy eager serializer. TapeTrainingStep recursively
+            // walks registered children from both root kinds in the same deterministic order.
+            // structureVersion -1 keeps caching disabled for this one-off clone snapshot.
             return new List<ITrainableLayer<T>>(
                 TapeTrainingStep<T>.CollectTrainableLayers(
-                    neuralNetwork.Layers,
+                    neuralNetwork.GetCopyOnWriteLayerRoots(),
                     structureVersion: -1));
         }
 
diff --git a/src/Helpers/DeserializationHelper.cs b/src/Helpers/DeserializationHelper.cs
index 675e2d014e..bb4b37d5ee 100644
--- a/src/Helpers/DeserializationHelper.cs
+++ b/src/Helpers/DeserializationHelper.cs
@@ -42,9 +42,38 @@ private static bool IsMissingCtorMessage(string message)
 
     static DeserializationHelper()
     {
-        // Automatically discover and register all ILayer<T> implementations
-        var layerTypes = Assembly.GetExecutingAssembly()
-            .GetTypes()
+        // Automatically discover and register all ILayer<T> implementations.
+        //
+        // GetTypes() THROWS ReflectionTypeLoadException when individual types cannot be loaded, and
+        // its partial results silently omit exactly those. A layer dropped that way is indis-
+        // tinguishable, later, from one that was never written: CreateLayerFromType reports it as
+        // "not supported for deserialization", which sends the reader looking for a missing
+        // registration instead of a missing dependency. Catch it, keep what did load, and say what
+        // did not -- the same reason every other silent skip in this work was made loud.
+        Type[] discovered;
+        try
+        {
+            discovered = Assembly.GetExecutingAssembly().GetTypes();
+        }
+        catch (ReflectionTypeLoadException ex)
+        {
+            discovered = ex.Types.Where(t => t is not null).Select(t => t!).ToArray();
+
+            var unloadable = (ex.LoaderExceptions ?? Array.Empty<Exception?>())
+                .Where(e => e is not null)
+                .Select(e => e!.Message)
+                .Distinct(StringComparer.Ordinal)
+                .Take(5)
+                .ToArray();
+
+            System.Diagnostics.Trace.TraceError(
+                "Layer discovery could not load every type in the assembly, so any layer among them "
+                + "will later be reported as 'not supported for deserialization' when the real cause "
+                + "is a load failure. First load errors: "
+                + (unloadable.Length == 0 ? "(none reported)" : string.Join(" | ", unloadable)));
+        }
+
+        var layerTypes = discovered
             .Where(t => !t.IsAbstract && t.GetInterfaces()
                 .Any(i => i.IsGenericType && i.GetGenericTypeDefinition() == typeof(ILayer<>)));
 
@@ -138,19 +167,56 @@ public static ILayer<T> CreateLayerFromType<T>(string layerType, int[] inputShap
             // [LayerState] reconstructs constructor arguments, but some layers also have
             // behavior-affecting post-construction configuration. Restore it before returning;
             // otherwise the generated factory bypasses the explicit legacy branches below.
-            if (generatedLayer is EmbeddingLayer<T> generatedEmbedding)
-                RestoreEmbeddingConfiguration(generatedEmbedding, additionalParams);
-            else if (generatedLayer is MultiHeadAttentionLayer<T> generatedAttention)
-                RestoreMultiHeadAttentionConfiguration(generatedAttention, additionalParams);
-
             // THE SAME LAZY PRE-RESOLVE THE OTHER PATHS GET. Returning straight from here bypassed
             // the block at the end of this method, so a lazy layer rebuilt through
             // GeneratedLayerFactories stayed unresolved: SetParameters then received a layer whose
             // ParameterCount is 0 and rejected the saved vector. The generated path is now the
             // majority path, which makes this the common case rather than an edge one.
-            PreResolveLazyShape((ILayer<T>)generatedLayer, inputShape);
+            // Pattern-matched rather than cast: TryCreate's out parameter is now `object?`, so the
+            // cast would be the compiler pointing at a real hole. A factory that returned true
+            // while handing back null, or something that is not an ILayer<T>, is a generator bug
+            // and saying so beats a NullReferenceException three frames away.
+            if (generatedLayer is not ILayer<T> generatedAsLayer)
+            {
+                throw new InvalidOperationException(
+                    $"The generated factory for '{layerType}' reported success but produced "
+                        + (generatedLayer is null
+                            ? "null."
+                            : $"a {generatedLayer.GetType().Name}, which is not an ILayer<{typeof(T).Name}>."));
+            }
+
+            RestorePostConstructionConfiguration(generatedAsLayer, additionalParams);
+            PreResolveLazyShape(generatedAsLayer, inputShape);
 
-            return (ILayer<T>)generatedLayer;
+            return generatedAsLayer;
+        }
+
+        // The registry, for the same reason the clone path consults it (LayerCloning.cs:309): the
+        // generated table above is compiled from AiDotNet's own source, so it can only ever name
+        // layers AiDotNet ships. A layer in a consumer's assembly has no entry and never can.
+        //
+        // Cloning got this tier and deserialization did not, which left the two halves of one
+        // mechanism disagreeing: a consumer's layer could be cloned but not loaded from a payload,
+        // even though both rebuild from the same recorded construction state. WriteConstructionState
+        // is called by GetMetadata (LayerBase.cs:6634), so `additionalParams` here holds exactly the
+        // values the clone path passes in its bag.
+        {
+            Type closedLayerType = openGenericType.IsGenericTypeDefinition
+                ? openGenericType.MakeGenericType(typeof(T))
+                : openGenericType;
+
+            if (AiDotNet.Serialization.LayerFactoryRegistry<T>.TryCreate(
+                    closedLayerType,
+                    genericDefForValidation,
+                    new AiDotNet.Serialization.LayerStateBag(additionalParams, layerType),
+                    TryRestoreActivation<T>(additionalParams),
+                    TryRestoreVectorActivation<T>(additionalParams),
+                    out var registeredLayer)
+                && registeredLayer is ILayer<T> registeredAsLayer)
+            {
+                PreResolveLazyShape(registeredAsLayer, inputShape);
+                return registeredAsLayer;
+            }
         }
 
         // Validate input/output shapes (skip for shape-agnostic layers)
@@ -3489,6 +3555,32 @@ private static void PreResolveLazyShape<T>(ILayer<T> layer, int[]? inputShape)
                     "Layer will resolve via SetParameters or first Forward.");
             }
         }
+
+        // A RESOLVED PARENT CAN STILL HOLD UNRESOLVED CHILDREN, and the block above asks only about
+        // the parent. A composite that takes its width as a constructor argument reports
+        // IsShapeResolved = true the moment it is rebuilt, so it skipped pre-resolve entirely while
+        // the lazy sub-layer it registered stayed a placeholder: CifAlignmentLayer came back holding
+        // an _alphaPredictor with no weights, answered ParameterCount 0 instead of 66, and
+        // SetParameters dropped all 66 trained values without a word. The parent's own shape is not
+        // evidence about its children.
+        //
+        // EnsureParametersMaterialized already recurses through GetSubLayers and is idempotent, so
+        // this drives the mechanism that was always there rather than adding a second one.
+        if (layer is NeuralNetworks.Layers.LayerBase<T> composite)
+        {
+            try
+            {
+                composite.MaterializeParameters();
+            }
+            catch (Exception ex) when (ex is ArgumentException || ex is InvalidOperationException)
+            {
+                // Same contract as above: a child that cannot be sized from the parent's width still
+                // has SetParameters' self-resolve ahead of it. Traced, never swallowed.
+                System.Diagnostics.Trace.TraceWarning(
+                    $"DeserializationHelper: MaterializeParameters failed for {composite.GetType().Name}: " +
+                    $"{ex.GetType().Name}: {ex.Message}. Sub-layers will resolve via SetParameters or first Forward.");
+            }
+        }
     }
 
     private static object CreateDenseLayer<T>(Type type, int[] inputShape, int[] outputShape, Dictionary<string, object>? additionalParams)
@@ -4158,6 +4250,64 @@ private static void RestoreEmbeddingConfiguration<T>(
         }
     }
 
+    /// <summary>
+    /// Restores behavior selected after construction for every generated layer factory.
+    /// </summary>
+    /// <remarks>
+    /// Generated factories own constructor state, but a few reusable layer protocols intentionally
+    /// configure behavior after construction. Keeping that protocol here prevents each layer from
+    /// needing a serialization/clone override and ensures newly generated factories do not bypass it.
+    /// </remarks>
+    private static void RestorePostConstructionConfiguration<T>(
+        ILayer<T> layer,
+        Dictionary<string, object>? additionalParams)
+    {
+        if (layer is EmbeddingLayer<T> embedding)
+        {
+            RestoreEmbeddingConfiguration(embedding, additionalParams);
+        }
+
+        if (layer is MultiHeadAttentionLayer<T> attention)
+        {
+            RestoreMultiHeadAttentionConfiguration(attention, additionalParams);
+            return;
+        }
+
+        string? positionalEncoding = TryGetString(additionalParams, "PositionalEncoding");
+        if (string.IsNullOrWhiteSpace(positionalEncoding)
+            || !Enum.TryParse<Enums.PositionalEncodingType>(
+                positionalEncoding, ignoreCase: true, out var positionalType)
+            || positionalType == Enums.PositionalEncodingType.None)
+        {
+            return;
+        }
+
+        // ConfigurePositionalEncoding is a common layer protocol (GQA, cached/paged attention,
+        // flash attention). Discovering the protocol by its public signature keeps this restoration
+        // generic; a new implementation gets round-trip support without another type switch.
+        MethodInfo? configure = layer.GetType().GetMethod(
+            "ConfigurePositionalEncoding",
+            BindingFlags.Public | BindingFlags.Instance,
+            binder: null,
+            types: new[] { typeof(Enums.PositionalEncodingType), typeof(double), typeof(int) },
+            modifiers: null);
+        if (configure is null)
+        {
+            throw new InvalidOperationException(
+                $"Layer '{layer.GetType().Name}' persisted positional encoding '{positionalEncoding}' "
+                + "but does not expose ConfigurePositionalEncoding(PositionalEncodingType, double, int).");
+        }
+
+        double ropeTheta = TryGetDouble(additionalParams, "RoPETheta")
+            ?? TryGetDouble(additionalParams, "RopeTheta")
+            ?? 10000.0;
+        int maxSequenceLength = TryGetInt(additionalParams, "PositionalMaxSequenceLength")
+            ?? TryGetInt(additionalParams, "MaxSequenceLength")
+            ?? TryGetInt(additionalParams, "SequenceLength")
+            ?? 2048;
+        configure.Invoke(layer, new object[] { positionalType, ropeTheta, maxSequenceLength });
+    }
+
     private static void RestoreMultiHeadAttentionConfiguration<T>(
         MultiHeadAttentionLayer<T> attention,
         Dictionary<string, object>? additionalParams)
diff --git a/src/Inference/CachedGroupedQueryAttention.cs b/src/Inference/CachedGroupedQueryAttention.cs
index 632cd53756..0f350c7ea1 100644
--- a/src/Inference/CachedGroupedQueryAttention.cs
+++ b/src/Inference/CachedGroupedQueryAttention.cs
@@ -71,7 +71,9 @@ public partial class CachedGroupedQueryAttention<T> : LayerBase<T>, IShapeContra
     private ALiBiPositionalBiasLayer<T>? _alibiLayer;
 
     // Cached values for backward pass
+    [Scratch]
     private Tensor<T>? _lastInput;
+    [Scratch]
     private Tensor<T>? _lastOutput;
 
     /// <inheritdoc />
@@ -120,6 +122,9 @@ public int LayerIndex
         set => _layerIndex = value;
     }
 
+    /// <summary>Construction state: the 'sequenceLength' the layer was built with.</summary>
+    private readonly int _sequenceLength;
+
     /// <summary>
     /// Creates a new cached GQA layer.
     /// </summary>
@@ -137,6 +142,7 @@ public CachedGroupedQueryAttention(
             [sequenceLength, embeddingDimension],
             activationFunction ?? new IdentityActivation<T>())
     {
+        _sequenceLength = sequenceLength;
         if (embeddingDimension % numHeads != 0)
             throw new ArgumentException($"Embedding dimension ({embeddingDimension}) must be divisible by numHeads ({numHeads}).");
         if (numHeads % numKVHeads != 0)
diff --git a/src/Inference/CachedMultiHeadAttention.cs b/src/Inference/CachedMultiHeadAttention.cs
index cce4622b8a..bbb78b970f 100644
--- a/src/Inference/CachedMultiHeadAttention.cs
+++ b/src/Inference/CachedMultiHeadAttention.cs
@@ -71,10 +71,15 @@ public partial class CachedMultiHeadAttention<T> : LayerBase<T>, IShapeContract
     public PositionalEncodingType PositionalEncoding { get; private set; } = PositionalEncodingType.None;
 
     // Projection weights
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _queryWeights;
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _keyWeights;
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _valueWeights;
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _outputWeights;
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _outputBias;
 
     // KV-Cache reference (shared across layers)
@@ -82,14 +87,21 @@ public partial class CachedMultiHeadAttention<T> : LayerBase<T>, IShapeContract
     private int _layerIndex;
 
     // Cached values for backward (training mode only)
+    [Scratch]
     private Tensor<T>? _lastInput;
+    [Scratch]
     private Tensor<T>? _lastOutput;
 
     // Gradients
+    [Scratch]
     private Matrix<T>? _queryWeightsGradient;
+    [Scratch]
     private Matrix<T>? _keyWeightsGradient;
+    [Scratch]
     private Matrix<T>? _valueWeightsGradient;
+    [Scratch]
     private Matrix<T>? _outputWeightsGradient;
+    [Scratch]
     private Vector<T>? _outputBiasGradient;
 
     /// <summary>
@@ -148,6 +160,9 @@ public int LayerIndex
         set => _layerIndex = value;
     }
 
+    /// <summary>Construction state: the 'sequenceLength' the layer was built with.</summary>
+    private readonly int _sequenceLength;
+
     /// <summary>
     /// Creates a new cached multi-head attention layer.
     /// </summary>
@@ -171,6 +186,7 @@ public CachedMultiHeadAttention(
             [sequenceLength, embeddingDimension],
             activationFunction ?? new IdentityActivation<T>())
     {
+        _sequenceLength = sequenceLength;
         if (embeddingDimension % headCount != 0)
         {
             throw new ArgumentException(
diff --git a/src/Inference/PagedCachedMultiHeadAttention.cs b/src/Inference/PagedCachedMultiHeadAttention.cs
index 363eeb49c7..578e6bd538 100644
--- a/src/Inference/PagedCachedMultiHeadAttention.cs
+++ b/src/Inference/PagedCachedMultiHeadAttention.cs
@@ -71,7 +71,9 @@ public partial class PagedCachedMultiHeadAttention<T> : LayerBase<T>, IContextAw
     [TrainableParameter(Role = PersistentTensorRole.Biases)]
     private Tensor<T> _outputBias;
 
+    [Scratch]
     private Tensor<T>? _lastInput;
+    [Scratch]
     private Tensor<T>? _lastOutput;
     private int _currentPosition;
 
@@ -90,9 +92,13 @@ public partial class PagedCachedMultiHeadAttention<T> : LayerBase<T>, IContextAw
     // Weight matrices as [inDim, outDim] tensors for the batched-GEMM projection path (Engine.TensorMatMul,
     // which routes to the optimized BLAS/GPU kernels). Built lazily from the Matrix weights and invalidated
     // alongside the float kernel-weight caches when the weights change.
+    [AiDotNet.Attributes.Scratch]
     private Tensor<T>? _wqTensor;
+    [AiDotNet.Attributes.Scratch]
     private Tensor<T>? _wkTensor;
+    [AiDotNet.Attributes.Scratch]
     private Tensor<T>? _wvTensor;
+    [AiDotNet.Attributes.Scratch]
     private Tensor<T>? _woTensor;
 
     internal bool EnableWeightOnlyQuantization { get; set; }
@@ -149,6 +155,9 @@ public partial class PagedCachedMultiHeadAttention<T> : LayerBase<T>, IContextAw
     /// </summary>
     public double RoPETheta => _ropeLayer?.Theta ?? 10000.0;
 
+    /// <summary>Construction state: the 'sequenceLength' the layer was built with.</summary>
+    private readonly int _sequenceLength;
+
     /// <param name="kvHeadCount">
     /// Number of key/value heads for grouped-query attention. 0 (the default) means "same as
     /// <paramref name="headCount"/>" — standard multi-head attention. When smaller, K/V project to
@@ -166,6 +175,7 @@ public PagedCachedMultiHeadAttention(
             [sequenceLength, embeddingDimension],
             activationFunction ?? new IdentityActivation<T>())
     {
+        _sequenceLength = sequenceLength;
         if (embeddingDimension % headCount != 0)
         {
             throw new ArgumentException(
diff --git a/src/Inference/Quantization/QuantizedAttentionLayer.cs b/src/Inference/Quantization/QuantizedAttentionLayer.cs
index 686eb5430e..f2b35aeac6 100644
--- a/src/Inference/Quantization/QuantizedAttentionLayer.cs
+++ b/src/Inference/Quantization/QuantizedAttentionLayer.cs
@@ -68,6 +68,16 @@ internal sealed partial class QuantizedAttentionLayer : LayerBase<float>, IShape
     private readonly RotaryPositionalEncodingLayer<float>? _ropeLayer;
     private readonly ALiBiPositionalBiasLayer<float>? _alibiLayer;
 
+    /// <summary>Construction state: the 'source' the layer was built with.</summary>
+    // The quantized projections own the inference weights after construction. These references
+    // are provenance only; traversing them as child layers would expose the original full-precision
+    // attention weights through an inference-only layer whose parameter contract is intentionally 0.
+    [ExternalState]
+    private readonly AiDotNet.NeuralNetworks.Layers.MultiHeadAttentionLayer<float> _source = null!;
+    // The two constructors take different source layer types, which cannot share one field.
+    [ExternalState]
+    private readonly AiDotNet.NeuralNetworks.Layers.GroupedQueryAttentionLayer<float> _sourceGrouped = null!;
+
     /// <summary>
     /// Creates a quantized attention layer from a trained <see cref="MultiHeadAttentionLayer{T}"/>.
     /// </summary>
@@ -80,6 +90,7 @@ public QuantizedAttentionLayer(
             inputShape: source.GetInputShape(),
             outputShape: source.GetOutputShape())
     {
+        _source = source;
         _headCount = source.HeadCount;
         _embeddingDimension = source.GetInputShape()[^1];
         _headDimension = _embeddingDimension / _headCount;
@@ -110,12 +121,15 @@ public QuantizedAttentionLayer(
     /// <param name="source">The source GQA layer to quantize.</param>
     /// <param name="mode">The quantization format to use (default: INT8).</param>
     public QuantizedAttentionLayer(
+        // Not [LayerState]: this layer is non-generic, and ADN0055 reports that the factory only
+        // builds layers with one type parameter, so marking its arguments cannot produce one.
         GroupedQueryAttentionLayer<float> source,
         InferenceQuantizationMode mode = InferenceQuantizationMode.WeightOnlyInt8)
         : base(
             inputShape: source.GetInputShape(),
             outputShape: source.GetOutputShape())
     {
+        _sourceGrouped = source;
         _headCount = source.NumHeads;
         _numKVHeads = source.NumKVHeads;
         _headDimension = source.HeadDimension;
diff --git a/src/Interpolation/AkimaInterpolation.cs b/src/Interpolation/AkimaInterpolation.cs
index e39383f74e..eae0c54f85 100644
--- a/src/Interpolation/AkimaInterpolation.cs
+++ b/src/Interpolation/AkimaInterpolation.cs
@@ -18,7 +18,7 @@ namespace AiDotNet.Interpolation;
 /// This method requires at least 5 data points to work properly.
 /// </remarks>
 /// <typeparam name="T">The numeric data type used for calculations (e.g., float, double).</typeparam>
-public class AkimaInterpolation<T> : IInterpolation<T>
+public partial class AkimaInterpolation<T> : IInterpolation<T>
 {
     /// <summary>
     /// The x-coordinates of the data points.
@@ -36,6 +36,7 @@ public class AkimaInterpolation<T> : IInterpolation<T>
     /// <remarks>
     /// <b>For Beginners:</b> These are values that help determine the slope of the curve at each point.
     /// </remarks>
+    [AiDotNet.Attributes.TrainableParameter]
     private readonly Vector<T> _b;
 
     /// <summary>
@@ -44,6 +45,7 @@ public class AkimaInterpolation<T> : IInterpolation<T>
     /// <remarks>
     /// <b>For Beginners:</b> These values help control how the curve bends between points.
     /// </remarks>
+    [AiDotNet.Attributes.TrainableParameter]
     private readonly Vector<T> _c;
 
     /// <summary>
@@ -52,6 +54,7 @@ public class AkimaInterpolation<T> : IInterpolation<T>
     /// <remarks>
     /// <b>For Beginners:</b> These values help fine-tune the shape of the curve between points.
     /// </remarks>
+    [AiDotNet.Attributes.TrainableParameter]
     private readonly Vector<T> _d;
 
     /// <summary>
diff --git a/src/Interpolation/BarycentricRationalInterpolation.cs b/src/Interpolation/BarycentricRationalInterpolation.cs
index 429a8d3099..6520a0f1f8 100644
--- a/src/Interpolation/BarycentricRationalInterpolation.cs
+++ b/src/Interpolation/BarycentricRationalInterpolation.cs
@@ -16,7 +16,7 @@ namespace AiDotNet.Interpolation;
 /// and efficient, especially when dealing with many data points.
 /// </remarks>
 /// <typeparam name="T">The numeric data type used for calculations (e.g., float, double).</typeparam>
-public class BarycentricRationalInterpolation<T> : IInterpolation<T>
+public partial class BarycentricRationalInterpolation<T> : IInterpolation<T>
 {
     /// <summary>
     /// The x-coordinates of the data points.
@@ -36,6 +36,7 @@ public class BarycentricRationalInterpolation<T> : IInterpolation<T>
     /// values between points. They're calculated once when you create the interpolation object and then
     /// used for all interpolation calculations.
     /// </remarks>
+    [AiDotNet.Attributes.TrainableParameter]
     private readonly Vector<T> _weights;
 
     /// <summary>
diff --git a/src/Interpolation/BicubicInterpolation.cs b/src/Interpolation/BicubicInterpolation.cs
index 826a5947fd..b04499aaaa 100644
--- a/src/Interpolation/BicubicInterpolation.cs
+++ b/src/Interpolation/BicubicInterpolation.cs
@@ -16,7 +16,7 @@ namespace AiDotNet.Interpolation;
 /// surface is changing (its "slope" and "curvature"), resulting in smoother, more natural-looking results.
 /// </remarks>
 /// <typeparam name="T">The numeric data type used for calculations (e.g., float, double).</typeparam>
-public class BicubicInterpolation<T> : I2DInterpolation<T>
+public partial class BicubicInterpolation<T> : I2DInterpolation<T>
 {
     /// <summary>
     /// The x-coordinates of the grid points.
@@ -35,6 +35,7 @@ public class BicubicInterpolation<T> : I2DInterpolation<T>
     /// <b>For Beginners:</b> This is your actual data - the known values at each grid point.
     /// If you're thinking of a landscape, these would be the heights at each measured location.
     /// </remarks>
+    [AiDotNet.Attributes.TrainableParameter]
     private readonly Matrix<T> _z;
 
     /// <summary>
diff --git a/src/Interpolation/BilinearInterpolation.cs b/src/Interpolation/BilinearInterpolation.cs
index 7ac8c7bfcc..f1431e4ed1 100644
--- a/src/Interpolation/BilinearInterpolation.cs
+++ b/src/Interpolation/BilinearInterpolation.cs
@@ -16,7 +16,7 @@ namespace AiDotNet.Interpolation;
 /// between all four surrounding points, giving a more natural and accurate estimate.
 /// </remarks>
 /// <typeparam name="T">The numeric data type used for calculations (e.g., float, double).</typeparam>
-public class BilinearInterpolation<T> : I2DInterpolation<T>
+public partial class BilinearInterpolation<T> : I2DInterpolation<T>
 {
     /// <summary>
     /// The x-coordinates of the grid points.
@@ -36,6 +36,7 @@ public class BilinearInterpolation<T> : I2DInterpolation<T>
     /// If you're thinking of a temperature map, these would be the temperature readings
     /// at each measured location.
     /// </remarks>
+    [AiDotNet.Attributes.TrainableParameter]
     private readonly Matrix<T> _z;
 
     /// <summary>
diff --git a/src/Interpolation/CubicBSplineInterpolation.cs b/src/Interpolation/CubicBSplineInterpolation.cs
index 31dcf5426e..31ac596f95 100644
--- a/src/Interpolation/CubicBSplineInterpolation.cs
+++ b/src/Interpolation/CubicBSplineInterpolation.cs
@@ -15,7 +15,7 @@ namespace AiDotNet.Interpolation;
 /// flexible ruler that naturally creates gentle curves.
 /// </remarks>
 /// <typeparam name="T">The numeric type used for calculations (e.g., double, float).</typeparam>
-public class CubicBSplineInterpolation<T> : IInterpolation<T>
+public partial class CubicBSplineInterpolation<T> : IInterpolation<T>
 {
     /// <summary>
     /// The x-coordinates of the data points.
@@ -34,11 +34,13 @@ public class CubicBSplineInterpolation<T> : IInterpolation<T>
     /// <b>For Beginners:</b> Knots are special points that help define how the curve behaves.
     /// They're like invisible control points that determine where the curve bends.
     /// </remarks>
+    [AiDotNet.Attributes.TrainableParameter]
     private readonly Vector<T> _knots;
 
     /// <summary>
     /// The calculated coefficients that define the B-spline curve.
     /// </summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private readonly Vector<T> _coefficients;
 
     /// <summary>
diff --git a/src/Interpolation/CubicConvolutionInterpolation.cs b/src/Interpolation/CubicConvolutionInterpolation.cs
index c4f36e8cf0..fbd00e12c1 100644
--- a/src/Interpolation/CubicConvolutionInterpolation.cs
+++ b/src/Interpolation/CubicConvolutionInterpolation.cs
@@ -15,7 +15,7 @@ namespace AiDotNet.Interpolation;
 /// estimates for the points in between.
 /// </remarks>
 /// <typeparam name="T">The numeric type used for calculations (e.g., float, double).</typeparam>
-public class CubicConvolutionInterpolation<T> : I2DInterpolation<T>
+public partial class CubicConvolutionInterpolation<T> : I2DInterpolation<T>
 {
     /// <summary>
     /// The x-coordinates of the data points.
@@ -30,6 +30,7 @@ public class CubicConvolutionInterpolation<T> : I2DInterpolation<T>
     /// <summary>
     /// The z-values (heights) at each (x,y) grid point.
     /// </summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private readonly Matrix<T> _z;
 
     /// <summary>
diff --git a/src/Interpolation/CubicSplineInterpolation.cs b/src/Interpolation/CubicSplineInterpolation.cs
index 67bb33b557..9acbc76684 100644
--- a/src/Interpolation/CubicSplineInterpolation.cs
+++ b/src/Interpolation/CubicSplineInterpolation.cs
@@ -15,7 +15,7 @@ namespace AiDotNet.Interpolation;
 /// dots with a flexible curve rather than straight lines.
 /// </remarks>
 /// <typeparam name="T">The numeric type used for calculations (e.g., float, double).</typeparam>
-public class CubicSplineInterpolation<T> : IInterpolation<T>
+public partial class CubicSplineInterpolation<T> : IInterpolation<T>
 {
     /// <summary>
     /// The x-coordinates of the data points (independent variable).
@@ -30,21 +30,25 @@ public class CubicSplineInterpolation<T> : IInterpolation<T>
     /// <summary>
     /// The constant coefficients of the cubic polynomials (equal to the y values).
     /// </summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private readonly Vector<T> _a;
 
     /// <summary>
     /// The coefficients of the linear terms in the cubic polynomials.
     /// </summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private readonly Vector<T> _b;
 
     /// <summary>
     /// The coefficients of the quadratic terms in the cubic polynomials.
     /// </summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private readonly Vector<T> _c;
 
     /// <summary>
     /// The coefficients of the cubic terms in the cubic polynomials.
     /// </summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private readonly Vector<T> _d;
 
     /// <summary>
diff --git a/src/Interpolation/HermiteInterpolation.cs b/src/Interpolation/HermiteInterpolation.cs
index caabd1de5d..1bde6e5df1 100644
--- a/src/Interpolation/HermiteInterpolation.cs
+++ b/src/Interpolation/HermiteInterpolation.cs
@@ -16,7 +16,7 @@ namespace AiDotNet.Interpolation;
 /// of change.
 /// </remarks>
 /// <typeparam name="T">The numeric type used for calculations (e.g., float, double).</typeparam>
-public class HermiteInterpolation<T> : IInterpolation<T>
+public partial class HermiteInterpolation<T> : IInterpolation<T>
 {
     /// <summary>
     /// The x-coordinates of the data points (independent variable).
@@ -31,6 +31,7 @@ public class HermiteInterpolation<T> : IInterpolation<T>
     /// <summary>
     /// The slopes (derivatives) at each data point.
     /// </summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private readonly Vector<T> _m;
 
     /// <summary>
diff --git a/src/Interpolation/KrigingInterpolation.cs b/src/Interpolation/KrigingInterpolation.cs
index 9b5cf22aa4..58471d3cf7 100644
--- a/src/Interpolation/KrigingInterpolation.cs
+++ b/src/Interpolation/KrigingInterpolation.cs
@@ -14,7 +14,7 @@ namespace AiDotNet.Interpolation;
 /// This method is widely used in geography, mining, and environmental science.
 /// </remarks>
 /// <typeparam name="T">The numeric type used for calculations.</typeparam>
-public class KrigingInterpolation<T> : I2DInterpolation<T>
+public partial class KrigingInterpolation<T> : I2DInterpolation<T>
 {
     /// <summary>
     /// The x-coordinates of the known data points.
@@ -29,6 +29,7 @@ public class KrigingInterpolation<T> : I2DInterpolation<T>
     /// <summary>
     /// The z-values (heights) of the known data points.
     /// </summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private readonly Vector<T> _z;
 
     /// <summary>
diff --git a/src/Interpolation/MonotoneCubicInterpolation.cs b/src/Interpolation/MonotoneCubicInterpolation.cs
index 5e08525a4c..9d884d5139 100644
--- a/src/Interpolation/MonotoneCubicInterpolation.cs
+++ b/src/Interpolation/MonotoneCubicInterpolation.cs
@@ -15,7 +15,7 @@ namespace AiDotNet.Interpolation;
 /// It's particularly useful when you know your data should never "change direction" between points.
 /// </remarks>
 /// <typeparam name="T">The numeric type used for calculations.</typeparam>
-public class MonotoneCubicInterpolation<T> : IInterpolation<T>
+public partial class MonotoneCubicInterpolation<T> : IInterpolation<T>
 {
     /// <summary>
     /// The x-coordinates of the known data points.
@@ -35,6 +35,7 @@ public class MonotoneCubicInterpolation<T> : IInterpolation<T>
     /// at that exact point. These slopes are carefully calculated to make sure our curve remains
     /// smooth but doesn't create unwanted oscillations.
     /// </remarks>
+    [AiDotNet.Attributes.TrainableParameter]
     private readonly Vector<T> _m;
 
     /// <summary>
diff --git a/src/Interpolation/MovingLeastSquaresInterpolation.cs b/src/Interpolation/MovingLeastSquaresInterpolation.cs
index f890e609a4..ad8fa947e1 100644
--- a/src/Interpolation/MovingLeastSquaresInterpolation.cs
+++ b/src/Interpolation/MovingLeastSquaresInterpolation.cs
@@ -16,7 +16,7 @@ namespace AiDotNet.Interpolation;
 /// giving more weight to nearby points when estimating a value at a specific location.
 /// </remarks>
 /// <typeparam name="T">The numeric type used for calculations.</typeparam>
-public class MovingLeastSquaresInterpolation<T> : I2DInterpolation<T>
+public partial class MovingLeastSquaresInterpolation<T> : I2DInterpolation<T>
 {
     /// <summary>
     /// The x-coordinates of the known data points.
@@ -31,6 +31,7 @@ public class MovingLeastSquaresInterpolation<T> : I2DInterpolation<T>
     /// <summary>
     /// The z-values (heights) of the known data points.
     /// </summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private readonly Vector<T> _z;
 
     /// <summary>
diff --git a/src/Interpolation/MultiquadricInterpolation.cs b/src/Interpolation/MultiquadricInterpolation.cs
index 70b4618377..19492c695f 100644
--- a/src/Interpolation/MultiquadricInterpolation.cs
+++ b/src/Interpolation/MultiquadricInterpolation.cs
@@ -14,7 +14,7 @@ namespace AiDotNet.Interpolation;
 /// and can create very smooth surfaces.
 /// </remarks>
 /// <typeparam name="T">The numeric type used for calculations.</typeparam>
-public class MultiquadricInterpolation<T> : I2DInterpolation<T>
+public partial class MultiquadricInterpolation<T> : I2DInterpolation<T>
 {
     /// <summary>
     /// The x-coordinates of the known data points.
@@ -29,6 +29,7 @@ public class MultiquadricInterpolation<T> : I2DInterpolation<T>
     /// <summary>
     /// The z-values (heights) of the known data points.
     /// </summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private readonly Vector<T> _z;
 
     /// <summary>
diff --git a/src/Interpolation/NewtonDividedDifferenceInterpolation.cs b/src/Interpolation/NewtonDividedDifferenceInterpolation.cs
index 7fc7608e41..f02e4132d1 100644
--- a/src/Interpolation/NewtonDividedDifferenceInterpolation.cs
+++ b/src/Interpolation/NewtonDividedDifferenceInterpolation.cs
@@ -18,7 +18,7 @@ namespace AiDotNet.Interpolation;
 /// Think of it like connecting dots with a smooth curve instead of straight lines or steps.
 /// </para>
 /// </remarks>
-public class NewtonDividedDifferenceInterpolation<T> : IInterpolation<T>
+public partial class NewtonDividedDifferenceInterpolation<T> : IInterpolation<T>
 {
     /// <summary>
     /// The x-coordinates of the known data points.
@@ -28,6 +28,7 @@ public class NewtonDividedDifferenceInterpolation<T> : IInterpolation<T>
     /// <summary>
     /// The coefficients of the Newton polynomial, calculated from the input data.
     /// </summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private readonly Vector<T> _coefficients;
 
     /// <summary>
diff --git a/src/Interpolation/PchipInterpolation.cs b/src/Interpolation/PchipInterpolation.cs
index e17b98a9cc..790d70edfd 100644
--- a/src/Interpolation/PchipInterpolation.cs
+++ b/src/Interpolation/PchipInterpolation.cs
@@ -17,7 +17,7 @@ namespace AiDotNet.Interpolation;
 /// general shape and trends of your original data.
 /// </para>
 /// </remarks>
-public class PchipInterpolation<T> : IInterpolation<T>
+public partial class PchipInterpolation<T> : IInterpolation<T>
 {
     /// <summary>
     /// The x-coordinates of the data points.
@@ -32,6 +32,7 @@ public class PchipInterpolation<T> : IInterpolation<T>
     /// <summary>
     /// The calculated slopes at each data point.
     /// </summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private readonly Vector<T> _slopes;
 
     /// <summary>
diff --git a/src/Interpolation/RadialBasisFunctionInterpolation.cs b/src/Interpolation/RadialBasisFunctionInterpolation.cs
index bcff7e2d92..9de8988c5c 100644
--- a/src/Interpolation/RadialBasisFunctionInterpolation.cs
+++ b/src/Interpolation/RadialBasisFunctionInterpolation.cs
@@ -18,7 +18,7 @@ namespace AiDotNet.Interpolation;
 /// smooth transitions. This is particularly useful when your data points aren't arranged in a grid.
 /// </para>
 /// </remarks>
-public class RadialBasisFunctionInterpolation<T> : I2DInterpolation<T>
+public partial class RadialBasisFunctionInterpolation<T> : I2DInterpolation<T>
 {
     /// <summary>
     /// The x-coordinates of the data points.
@@ -33,6 +33,7 @@ public class RadialBasisFunctionInterpolation<T> : I2DInterpolation<T>
     /// <summary>
     /// The z-values (heights) at each data point.
     /// </summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private readonly Vector<T> _z;
 
     /// <summary>
diff --git a/src/Interpolation/ShepardsMethodInterpolation.cs b/src/Interpolation/ShepardsMethodInterpolation.cs
index 2c8aa55948..dbe7d169f1 100644
--- a/src/Interpolation/ShepardsMethodInterpolation.cs
+++ b/src/Interpolation/ShepardsMethodInterpolation.cs
@@ -17,7 +17,7 @@ namespace AiDotNet.Interpolation;
 /// the influence of distant points diminishes.
 /// </para>
 /// </remarks>
-public class ShepardsMethodInterpolation<T> : I2DInterpolation<T>
+public partial class ShepardsMethodInterpolation<T> : I2DInterpolation<T>
 {
     /// <summary>
     /// The x-coordinates of the data points.
@@ -32,6 +32,7 @@ public class ShepardsMethodInterpolation<T> : I2DInterpolation<T>
     /// <summary>
     /// The z-values (heights) at each data point.
     /// </summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private readonly Vector<T> _z;
 
     /// <summary>
diff --git a/src/Interpolation/ThinPlateSplineInterpolation.cs b/src/Interpolation/ThinPlateSplineInterpolation.cs
index 4365f84df4..45229ec5c2 100644
--- a/src/Interpolation/ThinPlateSplineInterpolation.cs
+++ b/src/Interpolation/ThinPlateSplineInterpolation.cs
@@ -18,7 +18,7 @@ namespace AiDotNet.Interpolation;
 /// readings taken at irregular locations.
 /// </para>
 /// </remarks>
-public class ThinPlateSplineInterpolation<T> : I2DInterpolation<T>
+public partial class ThinPlateSplineInterpolation<T> : I2DInterpolation<T>
 {
     /// <summary>
     /// The x-coordinates of the data points.
@@ -33,6 +33,7 @@ public class ThinPlateSplineInterpolation<T> : I2DInterpolation<T>
     /// <summary>
     /// The z-values (heights) at each data point.
     /// </summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private readonly Vector<T> _z;
 
     /// <summary>
diff --git a/src/Interpolation/TrigonometricInterpolation.cs b/src/Interpolation/TrigonometricInterpolation.cs
index 4ce049e38c..aa3261e01d 100644
--- a/src/Interpolation/TrigonometricInterpolation.cs
+++ b/src/Interpolation/TrigonometricInterpolation.cs
@@ -18,7 +18,7 @@ namespace AiDotNet.Interpolation;
 /// a smooth curve that passes through all your data points and can predict values between them.
 /// </para>
 /// </remarks>
-public class TrigonometricInterpolation<T> : IInterpolation<T>
+public partial class TrigonometricInterpolation<T> : IInterpolation<T>
 {
     /// <summary>
     /// The x-coordinates of the data points.
@@ -33,11 +33,13 @@ public class TrigonometricInterpolation<T> : IInterpolation<T>
     /// <summary>
     /// The coefficients for the cosine terms in the Fourier series.
     /// </summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private readonly Vector<T> _a;
 
     /// <summary>
     /// The coefficients for the sine terms in the Fourier series.
     /// </summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private readonly Vector<T> _b;
 
     /// <summary>
diff --git a/src/Interpretability/Explainers/DeepLIFTExplainer.cs b/src/Interpretability/Explainers/DeepLIFTExplainer.cs
index e37537ca7a..a8aa06b1a1 100644
--- a/src/Interpretability/Explainers/DeepLIFTExplainer.cs
+++ b/src/Interpretability/Explainers/DeepLIFTExplainer.cs
@@ -39,7 +39,7 @@ namespace AiDotNet.Interpretability.Explainers;
 ///   compared to the reference
 /// </para>
 /// </remarks>
-public class DeepLIFTExplainer<T> : ILocalExplainer<T, DeepLIFTExplanation<T>>, IGlobalAttributionExplainer<T>, IGPUAcceleratedExplainer<T>
+public partial class DeepLIFTExplainer<T> : ILocalExplainer<T, DeepLIFTExplanation<T>>, IGlobalAttributionExplainer<T>, IGPUAcceleratedExplainer<T>
 {
     private static readonly INumericOperations<T> NumOps = MathHelper.GetNumericOperations<T>();
 
@@ -48,6 +48,7 @@ public class DeepLIFTExplainer<T> : ILocalExplainer<T, DeepLIFTExplanation<T>>,
     private readonly Func<Vector<T>, Vector<T>, Vector<T>>? _computeMultipliers;
     private readonly InputGradientHelper<T>? _gradientHelper;
     private readonly int _numFeatures;
+    [AiDotNet.Attributes.TrainableParameter]
     private readonly Vector<T>? _baseline;
     private readonly string[]? _featureNames;
     private readonly DeepLIFTRule _rule;
diff --git a/src/Interpretability/Explainers/DeepSHAPExplainer.cs b/src/Interpretability/Explainers/DeepSHAPExplainer.cs
index 209efbca46..e40ae62adc 100644
--- a/src/Interpretability/Explainers/DeepSHAPExplainer.cs
+++ b/src/Interpretability/Explainers/DeepSHAPExplainer.cs
@@ -1,4 +1,5 @@
 using AiDotNet.Helpers;
+using AiDotNet.Attributes;
 using AiDotNet.Interfaces;
 using AiDotNet.Interpretability.Helpers;
 using AiDotNet.Tensors.Helpers;
@@ -48,6 +49,7 @@ public class DeepSHAPExplainer<T> : ILocalExplainer<T, DeepSHAPExplanation<T>>,
     private static readonly INumericOperations<T> NumOps = MathHelper.GetNumericOperations<T>();
 
     private readonly Func<Vector<T>, Vector<T>> _predictFunction;
+    [Scratch]
     private readonly Func<Vector<T>, int, Vector<T>>? _gradientFunction;
     private readonly Func<Vector<T>, Vector<T>, Vector<T>>? _deepLiftMultipliers;
     private readonly Matrix<T> _backgroundData;
diff --git a/src/Interpretability/Explainers/FeatureAblationExplainer.cs b/src/Interpretability/Explainers/FeatureAblationExplainer.cs
index ead55e7b06..9b8da62812 100644
--- a/src/Interpretability/Explainers/FeatureAblationExplainer.cs
+++ b/src/Interpretability/Explainers/FeatureAblationExplainer.cs
@@ -37,12 +37,13 @@ namespace AiDotNet.Interpretability.Explainers;
 /// - Debugging models by finding unexpected important features
 /// </para>
 /// </remarks>
-public class FeatureAblationExplainer<T> : ILocalExplainer<T, FeatureAblationExplanation<T>>, IGlobalExplainer<T, GlobalFeatureAblationResult<T>>, IGlobalAttributionExplainer<T>, IGPUAcceleratedExplainer<T>
+public partial class FeatureAblationExplainer<T> : ILocalExplainer<T, FeatureAblationExplanation<T>>, IGlobalExplainer<T, GlobalFeatureAblationResult<T>>, IGlobalAttributionExplainer<T>, IGPUAcceleratedExplainer<T>
 {
     private static readonly INumericOperations<T> NumOps = MathHelper.GetNumericOperations<T>();
 
     private readonly Func<Vector<T>, Vector<T>> _predictFunction;
     private readonly Func<Tensor<T>, Tensor<T>>? _tensorPredictFunction;
+    [AiDotNet.Attributes.TrainableParameter]
     private readonly Vector<T>? _baseline;
     private readonly int[][]? _featureGroups;
     private readonly string[]? _featureNames;
diff --git a/src/Interpretability/Explainers/GlobalSurrogateExplainer.cs b/src/Interpretability/Explainers/GlobalSurrogateExplainer.cs
index 233a92c197..1da4f710c2 100644
--- a/src/Interpretability/Explainers/GlobalSurrogateExplainer.cs
+++ b/src/Interpretability/Explainers/GlobalSurrogateExplainer.cs
@@ -35,6 +35,7 @@ public class GlobalSurrogateExplainer<T> : IGlobalExplainer<T, SurrogateExplanat
     private readonly Func<Matrix<T>, Vector<T>> _blackBoxPredictFunction;
     private readonly string[]? _featureNames;
 
+    [AiDotNet.Attributes.FittedParameter]
     private Vector<T>? _surrogateCoefficients;
     private T _surrogateIntercept;
     private T _fidelity; // R² of surrogate vs black box
diff --git a/src/Interpretability/Explainers/GradCAMExplainer.cs b/src/Interpretability/Explainers/GradCAMExplainer.cs
index d8fdc4433b..c48f65fcdc 100644
--- a/src/Interpretability/Explainers/GradCAMExplainer.cs
+++ b/src/Interpretability/Explainers/GradCAMExplainer.cs
@@ -1,5 +1,6 @@
 using AiDotNet.Helpers;
 using AiDotNet.Interfaces;
+using AiDotNet.Attributes;
 using AiDotNet.Tensors;
 using AiDotNet.Tensors.LinearAlgebra;
 using AiDotNet.Validation;
@@ -42,6 +43,7 @@ public class GradCAMExplainer<T> : ILocalExplainer<T, GradCAMExplanation<T>>
 
     private readonly Func<Tensor<T>, Tensor<T>> _predictFunction;
     private readonly Func<Tensor<T>, int, Tensor<T>>? _featureMapFunction;
+    [Scratch]
     private readonly Func<Tensor<T>, int, int, Tensor<T>>? _gradientFunction;
     private readonly int[] _inputShape;
     private readonly int[] _featureMapShape;
diff --git a/src/Interpretability/Explainers/GradientSHAPExplainer.cs b/src/Interpretability/Explainers/GradientSHAPExplainer.cs
index d0a0eb3fb4..a90160a379 100644
--- a/src/Interpretability/Explainers/GradientSHAPExplainer.cs
+++ b/src/Interpretability/Explainers/GradientSHAPExplainer.cs
@@ -1,4 +1,5 @@
 using AiDotNet.Helpers;
+using AiDotNet.Attributes;
 using AiDotNet.Interfaces;
 using AiDotNet.Interpretability.Helpers;
 using AiDotNet.Tensors.Helpers;
@@ -43,6 +44,7 @@ public class GradientSHAPExplainer<T> : ILocalExplainer<T, GradientSHAPExplanati
     private static readonly INumericOperations<T> NumOps = MathHelper.GetNumericOperations<T>();
 
     private readonly Func<Vector<T>, Vector<T>> _predictFunction;
+    [Scratch]
     private readonly Func<Vector<T>, int, Vector<T>>? _gradientFunction;
     private readonly Matrix<T> _backgroundData;
     private readonly int _numSamples;
diff --git a/src/Interpretability/Explainers/InfluenceFunctionExplainer.cs b/src/Interpretability/Explainers/InfluenceFunctionExplainer.cs
index 027a344fb4..7f9f23f98a 100644
--- a/src/Interpretability/Explainers/InfluenceFunctionExplainer.cs
+++ b/src/Interpretability/Explainers/InfluenceFunctionExplainer.cs
@@ -1,4 +1,5 @@
 using AiDotNet.Helpers;
+using AiDotNet.Attributes;
 using AiDotNet.Interfaces;
 using AiDotNet.Interpretability.Helpers;
 using AiDotNet.Tensors;
@@ -54,6 +55,7 @@ public class InfluenceFunctionExplainer<T> : IGPUAcceleratedExplainer<T>
     private readonly INeuralNetwork<T>? _network;
     private readonly Func<Vector<T>, Vector<T>> _predictFunction;
     private readonly Func<Vector<T>, Vector<T>, T> _lossFunction;
+    [Scratch]
     private readonly Func<Vector<T>, Vector<T>, Vector<T>>? _gradientFunction;
     /// <summary>
     /// Optional caller-supplied parameter-space Hessian-vector product
@@ -77,6 +79,7 @@ public class InfluenceFunctionExplainer<T> : IGPUAcceleratedExplainer<T>
     private GPUExplainerHelper<T>? _gpuHelper;
 
     // Cached training gradients for efficiency
+    [Scratch]
     private Matrix<T>? _cachedTrainingGradients;
 
     /// <summary>
diff --git a/src/Interpretability/Explainers/InputXGradientExplainer.cs b/src/Interpretability/Explainers/InputXGradientExplainer.cs
index cefc5310e8..916c89f31b 100644
--- a/src/Interpretability/Explainers/InputXGradientExplainer.cs
+++ b/src/Interpretability/Explainers/InputXGradientExplainer.cs
@@ -1,4 +1,5 @@
 using AiDotNet.Helpers;
+using AiDotNet.Attributes;
 using AiDotNet.Interfaces;
 using AiDotNet.Interpretability.Helpers;
 using AiDotNet.LinearAlgebra;
@@ -48,6 +49,7 @@ public class InputXGradientExplainer<T> : ILocalExplainer<T, InputXGradientExpla
 
     private readonly INeuralNetwork<T>? _network;
     private readonly Func<Vector<T>, Vector<T>>? _predictFunction;
+    [Scratch]
     private readonly Func<Vector<T>, int, Vector<T>>? _gradientFunction;
     private readonly int _numFeatures;
     private readonly string[]? _featureNames;
diff --git a/src/Interpretability/Explainers/IntegratedGradientsExplainer.cs b/src/Interpretability/Explainers/IntegratedGradientsExplainer.cs
index fc5f9f0773..463984b4be 100644
--- a/src/Interpretability/Explainers/IntegratedGradientsExplainer.cs
+++ b/src/Interpretability/Explainers/IntegratedGradientsExplainer.cs
@@ -1,4 +1,5 @@
 using AiDotNet.Helpers;
+using AiDotNet.Attributes;
 using AiDotNet.Interfaces;
 using AiDotNet.Interpretability.Helpers;
 using AiDotNet.Tensors.LinearAlgebra;
@@ -43,6 +44,7 @@ public class IntegratedGradientsExplainer<T> : ILocalExplainer<T, IntegratedGrad
     private static readonly INumericOperations<T> NumOps = MathHelper.GetNumericOperations<T>();
 
     private readonly Func<Vector<T>, Vector<T>> _predictFunction;
+    [Scratch]
     private readonly Func<Vector<T>, int, Vector<T>>? _gradientFunction;
     private readonly int _numFeatures;
     private readonly int _numSteps;
diff --git a/src/Interpretability/Explainers/PrototypeExplainer.cs b/src/Interpretability/Explainers/PrototypeExplainer.cs
index c86c99fa97..0a48f11a58 100644
--- a/src/Interpretability/Explainers/PrototypeExplainer.cs
+++ b/src/Interpretability/Explainers/PrototypeExplainer.cs
@@ -35,11 +35,12 @@ namespace AiDotNet.Interpretability.Explainers;
 /// - Image classification: "This image looks like these training images of cats"
 /// </para>
 /// </remarks>
-public class PrototypeExplainer<T> : ILocalExplainer<T, PrototypeExplanation<T>>
+public partial class PrototypeExplainer<T> : ILocalExplainer<T, PrototypeExplanation<T>>
 {
     private static readonly INumericOperations<T> NumOps = MathHelper.GetNumericOperations<T>();
 
     private readonly Func<Matrix<T>, Vector<T>> _predictFunction;
+    [AiDotNet.Attributes.TrainableParameter]
     private readonly Matrix<T> _prototypes;
     private readonly Vector<T>? _prototypeLabels;
     private readonly int _numNeighbors;
diff --git a/src/Interpretability/Explainers/SaliencyMapExplainer.cs b/src/Interpretability/Explainers/SaliencyMapExplainer.cs
index 855d76a59b..4434e49843 100644
--- a/src/Interpretability/Explainers/SaliencyMapExplainer.cs
+++ b/src/Interpretability/Explainers/SaliencyMapExplainer.cs
@@ -1,4 +1,5 @@
 using AiDotNet.Helpers;
+using AiDotNet.Attributes;
 using AiDotNet.Interfaces;
 using AiDotNet.Tensors.Helpers;
 using AiDotNet.Tensors.LinearAlgebra;
@@ -44,6 +45,7 @@ public class SaliencyMapExplainer<T> : ILocalExplainer<T, SaliencyMapExplanation
     private static readonly INumericOperations<T> NumOps = MathHelper.GetNumericOperations<T>();
 
     private readonly Func<Vector<T>, Vector<T>> _predictFunction;
+    [Scratch]
     private readonly Func<Vector<T>, int, Vector<T>>? _gradientFunction;
     private readonly int _numFeatures;
     private readonly SaliencyMethod _method;
diff --git a/src/Interpretability/Explainers/TCAVExplainer.cs b/src/Interpretability/Explainers/TCAVExplainer.cs
index 4ce6b3e231..c8bd2b8f11 100644
--- a/src/Interpretability/Explainers/TCAVExplainer.cs
+++ b/src/Interpretability/Explainers/TCAVExplainer.cs
@@ -1,4 +1,5 @@
 using AiDotNet.Helpers;
+using AiDotNet.Attributes;
 using AiDotNet.Interfaces;
 using AiDotNet.Interpretability.Helpers;
 using AiDotNet.Tensors.Helpers;
@@ -54,6 +55,7 @@ public class TCAVExplainer<T> : IGPUAcceleratedExplainer<T>
 
     private readonly Func<Vector<T>, Vector<T>> _predictFunction;
     private readonly Func<Vector<T>, Vector<T>> _layerActivationFunction;
+    [Scratch]
     private readonly Func<Vector<T>, int, Vector<T>> _gradientToLayerFunction;
     private readonly int _layerSize;
     private readonly double _regularization;
diff --git a/src/Kernels/InducingPointKernel.cs b/src/Kernels/InducingPointKernel.cs
index fd1aad792f..797d88c1be 100644
--- a/src/Kernels/InducingPointKernel.cs
+++ b/src/Kernels/InducingPointKernel.cs
@@ -44,6 +44,7 @@ public class InducingPointKernel<T> : IKernelFunction<T>
     /// <summary>
     /// The inducing point locations.
     /// </summary>
+    [AiDotNet.Attributes.Buffer]
     private Matrix<T> _inducingPoints;
 
     /// <summary>
diff --git a/src/KnowledgeDistillation/FeatureDistillationStrategy.cs b/src/KnowledgeDistillation/FeatureDistillationStrategy.cs
index cc5af31617..26a6b90b00 100644
--- a/src/KnowledgeDistillation/FeatureDistillationStrategy.cs
+++ b/src/KnowledgeDistillation/FeatureDistillationStrategy.cs
@@ -273,9 +273,5 @@ public override IFullModel<T, Tensor<T>, Tensor<T>> WithParameters(Vector<T> par
         return copy;
     }
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy()
-        => (FeatureDistillationStrategy<T>)MemberwiseClone();
-
     #endregion
 }
diff --git a/src/KnowledgeDistillation/SelfDistillationTrainer.cs b/src/KnowledgeDistillation/SelfDistillationTrainer.cs
index 53fc09797b..9c71123ab6 100644
--- a/src/KnowledgeDistillation/SelfDistillationTrainer.cs
+++ b/src/KnowledgeDistillation/SelfDistillationTrainer.cs
@@ -66,6 +66,7 @@ namespace AiDotNet.KnowledgeDistillation;
 public class SelfDistillationTrainer<T> : KnowledgeDistillationTrainerBase<T, Vector<T>, Vector<T>>
 {
     private readonly int _generations;
+    [Scratch]
     private Dictionary<Vector<T>, Vector<T>>? _cachedTeacherPredictions;
     private Func<Vector<T>, Vector<T>>? _studentForward;
 
diff --git a/src/LinearAlgebra/ExpressionTree.cs b/src/LinearAlgebra/ExpressionTree.cs
index 943c14a3df..4322157f48 100644
--- a/src/LinearAlgebra/ExpressionTree.cs
+++ b/src/LinearAlgebra/ExpressionTree.cs
@@ -1,1581 +1,1573 @@
-using AiDotNet.Attributes;
-using AiDotNet.Autodiff;
-using AiDotNet.Enums;
-using AiDotNet.Models;

+using AiDotNet.Attributes;
+using AiDotNet.Autodiff;
+using AiDotNet.Enums;
+using AiDotNet.Models;
 using AiDotNet.Models.Parameters;
-
-namespace AiDotNet.LinearAlgebra;
-
-/// <summary>
-/// Represents a symbolic expression tree for mathematical operations that can be used for symbolic regression.
-/// </summary>
-/// <typeparam name="T">The numeric type used in the expression tree (e.g., double, float).</typeparam>
-/// <remarks>
-/// <b>For Beginners:</b> An ExpressionTree is like a mathematical formula represented as a tree structure.
-/// Each node in the tree is either a number, a variable, or an operation (like addition or multiplication).
-/// This allows the AI to create and evolve mathematical formulas that can model your data.
-/// </remarks>
-/// <example>
-/// <code>
-/// // Create a symbolic expression tree: (x0 * 2.5) + x1
-/// var tree = ExpressionTree&lt;double, Matrix&lt;double&gt;, Vector&lt;double&gt;&gt;.CreateOperation(
-///     ExpressionNodeType.Add,
-///     ExpressionTree&lt;double, Matrix&lt;double&gt;, Vector&lt;double&gt;&gt;.CreateOperation(
-///         ExpressionNodeType.Multiply,
-///         ExpressionTree&lt;double, Matrix&lt;double&gt;, Vector&lt;double&gt;&gt;.CreateVariable(0),
-///         ExpressionTree&lt;double, Matrix&lt;double&gt;, Vector&lt;double&gt;&gt;.CreateConstant(2.5)),
-///     ExpressionTree&lt;double, Matrix&lt;double&gt;, Vector&lt;double&gt;&gt;.CreateVariable(1));
-/// double result = tree.Evaluate(new double[] { 3.0, 1.0 }); // (3.0 * 2.5) + 1.0 = 8.5
-/// </code>
-/// </example>
-[ModelDomain(ModelDomain.MachineLearning)]
-[ModelCategory(ModelCategory.Interpretable)]
-[ModelCategory(ModelCategory.Optimization)]
-[ModelTask(ModelTask.Regression)]
-[ModelComplexity(ModelComplexity.Medium)]
-[ModelInput(typeof(Matrix<>), typeof(Vector<>))]
-[ResearchPaper("Genetic Programming: On the Programming of Computers by Natural Selection", "https://doi.org/10.7551/mitpress/3108.001.0001")]
-public partial class ExpressionTree<T, TInput, TOutput> : ModelBase<T, TInput, TOutput>
-{
-    /// <summary>
-    /// Gets the type of this node (constant, variable, or operation).
-    /// </summary>
-    public ExpressionNodeType Type { get; private set; }
-
-    /// <summary>
-    /// Gets the value stored in this node. For constants, this is the actual value.
-    /// For variables, this is the index of the variable in the input vector.
-    /// </summary>
-    public T Value { get; private set; }
-
-    /// <summary>
-    /// Gets the left child node of this node.
-    /// </summary>
-    /// <remarks>
-    /// <b>For Beginners:</b> In operations like addition (a + b), the left child represents 'a'.
-    /// </remarks>
+
+namespace AiDotNet.LinearAlgebra;
+
+/// <summary>
+/// Represents a symbolic expression tree for mathematical operations that can be used for symbolic regression.
+/// </summary>
+/// <typeparam name="T">The numeric type used in the expression tree (e.g., double, float).</typeparam>
+/// <remarks>
+/// <b>For Beginners:</b> An ExpressionTree is like a mathematical formula represented as a tree structure.
+/// Each node in the tree is either a number, a variable, or an operation (like addition or multiplication).
+/// This allows the AI to create and evolve mathematical formulas that can model your data.
+/// </remarks>
+/// <example>
+/// <code>
+/// // Create a symbolic expression tree: (x0 * 2.5) + x1
+/// var tree = ExpressionTree&lt;double, Matrix&lt;double&gt;, Vector&lt;double&gt;&gt;.CreateOperation(
+///     ExpressionNodeType.Add,
+///     ExpressionTree&lt;double, Matrix&lt;double&gt;, Vector&lt;double&gt;&gt;.CreateOperation(
+///         ExpressionNodeType.Multiply,
+///         ExpressionTree&lt;double, Matrix&lt;double&gt;, Vector&lt;double&gt;&gt;.CreateVariable(0),
+///         ExpressionTree&lt;double, Matrix&lt;double&gt;, Vector&lt;double&gt;&gt;.CreateConstant(2.5)),
+///     ExpressionTree&lt;double, Matrix&lt;double&gt;, Vector&lt;double&gt;&gt;.CreateVariable(1));
+/// double result = tree.Evaluate(new double[] { 3.0, 1.0 }); // (3.0 * 2.5) + 1.0 = 8.5
+/// </code>
+/// </example>
+[ModelDomain(ModelDomain.MachineLearning)]
+[ModelCategory(ModelCategory.Interpretable)]
+[ModelCategory(ModelCategory.Optimization)]
+[ModelTask(ModelTask.Regression)]
+[ModelComplexity(ModelComplexity.Medium)]
+[ModelInput(typeof(Matrix<>), typeof(Vector<>))]
+[ResearchPaper("Genetic Programming: On the Programming of Computers by Natural Selection", "https://doi.org/10.7551/mitpress/3108.001.0001")]
+public partial class ExpressionTree<T, TInput, TOutput> : ModelBase<T, TInput, TOutput>
+{
+    /// <summary>
+    /// Gets the type of this node (constant, variable, or operation).
+    /// </summary>
+    public ExpressionNodeType Type { get; private set; }
+
+    /// <summary>
+    /// Gets the value stored in this node. For constants, this is the actual value.
+    /// For variables, this is the index of the variable in the input vector.
+    /// </summary>
+    public T Value { get; private set; }
+
+    /// <summary>
+    /// Gets the left child node of this node.
+    /// </summary>
+    /// <remarks>
+    /// <b>For Beginners:</b> In operations like addition (a + b), the left child represents 'a'.
+    /// </remarks>
     [ParameterAlias(nameof(Coefficients))]
     public ExpressionTree<T, TInput, TOutput>? Left { get; private set; }
-
-    /// <summary>
-    /// Gets the right child node of this node.
-    /// </summary>
-    /// <remarks>
-    /// <b>For Beginners:</b> In operations like addition (a + b), the right child represents 'b'.
-    /// </remarks>
+
+    /// <summary>
+    /// Gets the right child node of this node.
+    /// </summary>
+    /// <remarks>
+    /// <b>For Beginners:</b> In operations like addition (a + b), the right child represents 'b'.
+    /// </remarks>
     [ParameterAlias(nameof(Coefficients))]
     public ExpressionTree<T, TInput, TOutput>? Right { get; private set; }
-
-    /// <summary>
-    /// Gets the parent node of this node.
-    /// </summary>
+
+    /// <summary>
+    /// Gets the parent node of this node.
+    /// </summary>
     [ParameterAlias(nameof(Coefficients))]
     public ExpressionTree<T, TInput, TOutput>? Parent { get; private set; }
-
-    /// <summary>
-    /// Gets the complexity of this expression tree, measured as the total number of nodes.
-    /// </summary>
-    /// <remarks>
-    /// <b>For Beginners:</b> Complexity tells you how complicated the formula is.
-    /// A higher number means a more complex formula with more terms and operations.
-    /// </remarks>
-    public int Complexity => 1 + (Left?.Complexity ?? 0) + (Right?.Complexity ?? 0);
-
-    /// <summary>
-    /// Sets the type of this node.
-    /// </summary>
-    /// <param name="type">The node type to set.</param>
-    public void SetType(ExpressionNodeType type)
-    {
-        Type = type;
-    }
-
-    /// <summary>
-    /// Sets the value of this node.
-    /// </summary>
-    /// <param name="value">The value to set.</param>
-    public void SetValue(T value)
-    {
-        Value = value;
-    }
-
-    /// <summary>
-    /// Sets the left child of this node and updates the parent reference of the child.
-    /// </summary>
-    /// <param name="left">The node to set as the left child.</param>
-    public void SetLeft(ExpressionTree<T, TInput, TOutput>? left)
-    {
-        Left = left;
-        if (left != null)
-        {
-            left.Parent = this;
-        }
-    }
-
-    /// <summary>
-    /// Sets the right child of this node and updates the parent reference of the child.
-    /// </summary>
-    /// <param name="right">The node to set as the right child.</param>
-    public void SetRight(ExpressionTree<T, TInput, TOutput>? right)
-    {
-        Right = right;
-        if (right != null)
-        {
-            right.Parent = this;
-        }
-    }
-
-    /// <summary>
-    /// Returns a string representation of this expression tree.
-    /// </summary>
-    /// <returns>A string representing the mathematical expression.</returns>
-    /// <remarks>
-    /// <b>For Beginners:</b> This converts the tree into a readable mathematical formula.
-    /// For example, an addition node with children might return "(2 + x[0])".
-    /// </remarks>
-    public override string ToString()
-    {
-        return Type switch
-        {
-            ExpressionNodeType.Constant => Value?.ToString(),
-            ExpressionNodeType.Variable => $"x[{Value}]",
-            ExpressionNodeType.Add => $"({Left} + {Right})",
-            ExpressionNodeType.Subtract => $"({Left} - {Right})",
-            ExpressionNodeType.Multiply => $"({Left} * {Right})",
-            ExpressionNodeType.Divide => $"({Left} / {Right})",
-            _ => throw new ArgumentException($"Unknown expression node type '{Type}'."),
-        } ?? string.Empty;
-    }
-
-    /// <summary>
-    /// Shared random number generator for all mutation and crossover operations.
-    /// </summary>
-    /// <remarks>
-    /// Using ThreadLocal ensures thread safety while maintaining good randomness quality.
-    /// Each thread gets its own Random instance, avoiding issues with multiple threads
-    /// accessing a shared Random instance or multiple instances created with the same seed.
-    /// </remarks>
-    private static readonly ThreadLocal<Random> _random = new ThreadLocal<Random>(() => RandomHelper.CreateSecureRandom());
-
-    private static Random Rng => _random.Value ?? throw new InvalidOperationException("Thread-local Random has not been initialized.");
-
-    /// <summary>
-    /// Creates a new expression tree node with the specified properties.
-    /// </summary>
-    /// <param name="type">The type of node to create.</param>
-    /// <param name="value">The value for this node (for constants and variables).</param>
-    /// <param name="left">The left child node.</param>
-    /// <param name="right">The right child node.</param>
-    /// <param name="lossFunction">Optional loss function to use for training. If null, uses Mean Squared Error (MSE) for symbolic regression.</param>
-    /// <remarks>
-    /// <b>For Beginners:</b> This creates a new part of your mathematical formula.
-    /// You can create simple nodes (like numbers or variables) or operation nodes
-    /// (like addition or multiplication) that connect to other nodes.
-    /// </remarks>
-    public ExpressionTree(ExpressionNodeType type, T? value = default, ExpressionTree<T, TInput, TOutput>? left = null, ExpressionTree<T, TInput, TOutput>? right = null, ILossFunction<T>? lossFunction = null)
-    {
-        Type = type;
-        Value = value ?? NumOps.Zero;
-        Left = left;
-        Right = right;
-        _defaultLossFunction = lossFunction ?? new MeanSquaredErrorLoss<T>();
-    }
-
-    /// <summary>
-    /// Cached count of features used in this expression tree.
-    /// </summary>
-    private int _featureCount;
-
-    /// <summary>
-    /// Cached required feature count (max feature index + 1) for validation.
-    /// </summary>
-    private int _requiredFeatureCount;
-
-    /// <summary>
-    /// The default loss function used by this model for gradient computation.
-    /// </summary>
-    private readonly ILossFunction<T> _defaultLossFunction;
-
-    /// <summary>
-    /// Gets the default loss function used by this model for gradient computation.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// For ExpressionTree (symbolic regression), the default loss function is Mean Squared Error (MSE),
-    /// which is the standard loss function for regression problems.
-    /// </para>
-    /// </remarks>
-    public override ILossFunction<T> DefaultLossFunction => _defaultLossFunction;
-
-    /// <summary>
-    /// Gets the number of features (variables) used in this expression tree.
-    /// </summary>
-    /// <remarks>
-    /// <b>For Beginners:</b> This tells you how many different input variables
-    /// your formula uses. For example, if your formula uses x[0], x[1], and x[2],
-    /// the feature count would be 3.
-    /// </remarks>
-    public int FeatureCount
-    {
-        get
-        {
-            if (_featureCount == 0)
-            {
-                _featureCount = CalculateFeatureCount();
-            }
-
-            return _featureCount;
-        }
-    }
-
-    /// <summary>
-    /// Gets the minimum number of features required for input data to this expression tree.
-    /// </summary>
-    /// <remarks>
-    /// <b>For Beginners:</b> This tells you the minimum number of columns your input data must have.
-    /// It equals the maximum variable index used plus one. For example, if your formula uses x[5],
-    /// the required feature count is 6 (indices 0 through 5).
-    /// <para>
-    /// Note: This is different from FeatureCount which counts unique variables used.
-    /// A tree using only x[5] has FeatureCount=1 but RequiredFeatureCount=6.
-    /// </para>
-    /// </remarks>
-    public int RequiredFeatureCount
-    {
-        get
-        {
-            if (_requiredFeatureCount == 0)
-            {
-                _requiredFeatureCount = CalculateRequiredFeatureCount();
-            }
-
-            return _requiredFeatureCount;
-        }
-    }
-
-    /// <summary>
-    /// Checks if a specific feature (variable) is used in this expression tree.
-    /// </summary>
-    /// <param name="featureIndex">The index of the feature to check.</param>
-    /// <returns>True if the feature is used, false otherwise.</returns>
-    /// <remarks>
-    /// <b>For Beginners:</b> This checks if your formula uses a specific input variable.
-    /// For example, if featureIndex is 2, it checks if x[2] appears anywhere in your formula.
-    /// </remarks>
-    public override bool IsFeatureUsed(int featureIndex)
-    {
-        return IsFeatureUsedRecursive(this, featureIndex);
-    }
-
-    /// <summary>
-    /// Calculates the number of unique features used in this expression tree.
-    /// </summary>
-    /// <returns>The count of unique features actually used in the tree.</returns>
-    /// <remarks>
-    /// This method counts the unique feature indices used in the tree. For example,
-    /// if the tree uses features x[0] and x[5], this returns 2 (the count of unique features),
-    /// not 6. This accurately represents how many different input variables the formula uses.
-    /// </remarks>
-    private int CalculateFeatureCount()
-    {
-        HashSet<int> uniqueFeatures = new HashSet<int>();
-        CollectUniqueFeatures(this, uniqueFeatures);
-        return uniqueFeatures.Count;
-    }
-
-    /// <summary>
-    /// Calculates the minimum number of features required for input data.
-    /// </summary>
-    /// <returns>The maximum feature index used plus one, or 0 if no variables are used.</returns>
-    /// <remarks>
-    /// This method finds the maximum feature index in the tree and adds 1.
-    /// For example, if the tree uses x[0] and x[5], this returns 6 (max index 5 + 1).
-    /// This represents the minimum number of columns input data must have.
-    /// </remarks>
-    private int CalculateRequiredFeatureCount()
-    {
-        int maxIndex = -1;
-        FindMaxFeatureIndex(this, ref maxIndex);
-        return maxIndex + 1;
-    }
-
-    /// <summary>
-    /// Recursively finds the maximum feature index used in a node and its children.
-    /// </summary>
-    /// <param name="node">The node to check.</param>
-    /// <param name="maxIndex">Reference to track the maximum index found.</param>
-    private void FindMaxFeatureIndex(ExpressionTree<T, TInput, TOutput> node, ref int maxIndex)
-    {
-        if (node == null) return;
-
-        if (node.Type == ExpressionNodeType.Variable)
-        {
-            int featureIndex = NumOps.ToInt32(node.Value);
-            if (featureIndex > maxIndex)
-            {
-                maxIndex = featureIndex;
-            }
-        }
-
-        if (node.Left != null)
-        {
-            FindMaxFeatureIndex(node.Left, ref maxIndex);
-        }
-
-        if (node.Right != null)
-        {
-            FindMaxFeatureIndex(node.Right, ref maxIndex);
-        }
-    }
-
-    /// <summary>
-    /// Recursively collects unique feature indices used in a node and its children.
-    /// </summary>
-    /// <param name="node">The node to check.</param>
-    /// <param name="uniqueFeatures">The set to collect unique feature indices.</param>
-    private void CollectUniqueFeatures(ExpressionTree<T, TInput, TOutput> node, HashSet<int> uniqueFeatures)
-    {
-        if (node == null) return;
-
-        if (node.Type == ExpressionNodeType.Variable)
-        {
-            uniqueFeatures.Add(NumOps.ToInt32(node.Value));
-        }
-
-        if (node.Left != null)
-        {
-            CollectUniqueFeatures(node.Left, uniqueFeatures);
-        }
-
-        if (node.Right != null)
-        {
-            CollectUniqueFeatures(node.Right, uniqueFeatures);
-        }
-    }
-
-    /// <summary>
-    /// Recursively checks if a specific feature is used in a node or its children.
-    /// </summary>
-    /// <param name="node">The node to check.</param>
-    /// <param name="featureIndex">The index of the feature to check.</param>
-    /// <returns>True if the feature is used, false otherwise.</returns>
-    private bool IsFeatureUsedRecursive(ExpressionTree<T, TInput, TOutput> node, int featureIndex)
-    {
-        if (node.Type == ExpressionNodeType.Variable && NumOps.ToInt32(node.Value) == featureIndex)
-        {
-            return true;
-        }
-
-        bool leftUsed = node.Left != null && IsFeatureUsedRecursive(node.Left, featureIndex);
-        bool rightUsed = node.Right != null && IsFeatureUsedRecursive(node.Right, featureIndex);
-
-        return leftUsed || rightUsed;
-    }
-
-    /// <summary>
-    /// Evaluates this expression tree for a given input vector.
-    /// </summary>
-    /// <param name="input">The input vector containing values for variables.</param>
-    /// <returns>The result of evaluating the expression.</returns>
-    /// <remarks>
-    /// <b>For Beginners:</b> This calculates the result of your formula for a specific set of input values.
-    /// For example, if your formula is "2*x[0] + x[1]" and your input is [3, 4], the result would be 2*3 + 4 = 10.
-    /// </remarks>
-    public T Evaluate(Vector<T> input)
-    {
-        if (Type == ExpressionNodeType.Constant) return Value;
-        if (Type == ExpressionNodeType.Variable) return input[NumOps.ToInt32(Value)];
-
-        var left = Left ?? throw new InvalidOperationException("Left has not been initialized.");
-        var right = Right ?? throw new InvalidOperationException("Right has not been initialized.");
-
-        return Type switch
-        {
-            ExpressionNodeType.Add => NumOps.Add(left.Evaluate(input), right.Evaluate(input)),
-            ExpressionNodeType.Subtract => NumOps.Subtract(left.Evaluate(input), right.Evaluate(input)),
-            ExpressionNodeType.Multiply => NumOps.Multiply(left.Evaluate(input), right.Evaluate(input)),
-            ExpressionNodeType.Divide => NumOps.Divide(left.Evaluate(input), right.Evaluate(input)),
-            _ => throw new ArgumentException($"Unknown expression node type '{Type}'."),
-        };
-    }
-
-    /// <summary>
-    /// Writes this expression tree to a binary stream.
-    /// </summary>
-    /// <param name="writer">The binary writer to write to.</param>
-    /// <remarks>
-    /// <b>For Beginners:</b> This saves your formula to a file or stream so you can load it later.
-    /// </remarks>
-    public void Serialize(BinaryWriter writer)
-    {
-        writer.Write((int)Type);
-        writer.Write(Convert.ToDouble(Value));
-        writer.Write(Left != null);
-        Left?.Serialize(writer);
-        writer.Write(Right != null);
-        Right?.Serialize(writer);
-    }
-
-    /// <summary>
-    /// Deserializes an expression tree from a binary reader.
-    /// </summary>
-    /// <param name="reader">The binary reader containing the serialized tree data.</param>
-    /// <returns>A new ExpressionTree instance created from the serialized data.</returns>
-    /// <remarks>
-    /// <b>For Beginners:</b> This method reads a saved expression tree from binary data and reconstructs it.
-    /// Think of it like opening a saved file that contains your mathematical formula.
-    /// </remarks>
-    public ExpressionTree<T, TInput, TOutput> Deserialize(BinaryReader reader)
-    {
-        ExpressionNodeType type = (ExpressionNodeType)reader.ReadInt32();
-        T value = NumOps.FromDouble(reader.ReadDouble());
-        bool hasLeft = reader.ReadBoolean();
-        ExpressionTree<T, TInput, TOutput>? left = hasLeft ? Deserialize(reader) : null;
-        bool hasRight = reader.ReadBoolean();
-        ExpressionTree<T, TInput, TOutput>? right = hasRight ? Deserialize(reader) : null;
-
-        return new ExpressionTree<T, TInput, TOutput>(type, value, left, right);
-    }
-
-    /// <summary>
-    /// Creates a modified version of this expression tree by applying random mutations.
-    /// </summary>
-    /// <param name="mutationRate">The probability (0.0 to 1.0) that a mutation will occur at each node.</param>
-    /// <returns>A new expression tree with mutations applied.</returns>
-    /// <remarks>
-    /// <b>For Beginners:</b> Mutation is like making small random changes to a formula to see if it improves.
-    /// For example, changing a "+" to a "*" or changing a constant from 2.5 to 3.1.
-    /// This is inspired by how genetic mutations work in nature and helps the AI explore different solutions.
-    /// </remarks>
-    public IFullModel<T, TInput, TOutput> Mutate(double mutationRate)
-    {
-        ExpressionTree<T, TInput, TOutput> mutatedTree = (ExpressionTree<T, TInput, TOutput>)Copy();
-
-        if (Rng.NextDouble() < mutationRate)
-        {
-            switch (Rng.Next(3))
-            {
-                case 0: // Change node type
-                    mutatedTree.Type = (ExpressionNodeType)Rng.Next(Enum.GetValues(typeof(ExpressionNodeType)).Length);
-                    break;
-                case 1: // Change value (for Constant or Variable nodes)
-                    if (mutatedTree.Type == ExpressionNodeType.Constant)
-                    {
-                        mutatedTree.Value = NumOps.FromDouble(Rng.NextDouble() * 10 - 5); // Random value between -5 and 5
-                    }
-                    else if (mutatedTree.Type == ExpressionNodeType.Variable)
-                    {
-                        mutatedTree.Value = NumOps.FromDouble(Rng.Next(10)); // Assume max 10 variables
-                    }
-                    break;
-                case 2: // Regenerate subtree
-                    int maxDepth = 3;
-                    mutatedTree = GenerateRandomTree(maxDepth);
-                    break;
-            }
-        }
-
-        // Recursively mutate children
-        if (mutatedTree.Left != null)
-        {
-            mutatedTree.Left = (ExpressionTree<T, TInput, TOutput>)mutatedTree.Left.Mutate(mutationRate);
-        }
-        if (mutatedTree.Right != null)
-        {
-            mutatedTree.Right = (ExpressionTree<T, TInput, TOutput>)mutatedTree.Right.Mutate(mutationRate);
-        }
-
-        return mutatedTree;
-    }
-
-    /// <summary>
-    /// Combines this expression tree with another to create a new "offspring" expression tree.
-    /// </summary>
-    /// <param name="other">The other expression tree to combine with.</param>
-    /// <param name="crossoverRate">The probability (0.0 to 1.0) that crossover will occur.</param>
-    /// <returns>A new expression tree that combines parts from both parent trees.</returns>
-    /// <remarks>
-    /// <b>For Beginners:</b> Crossover is like taking parts from two different formulas and combining them
-    /// to create a new formula. For example, if one formula is (x + 2) and another is (y * 3),
-    /// crossover might create (x * 3) by taking parts from each. This mimics how genetic traits
-    /// are passed from parents to children in nature.
-    /// </remarks>
-    public IFullModel<T, TInput, TOutput> Crossover(IFullModel<T, TInput, TOutput> other, double crossoverRate)
-    {
-        if (!(other is ExpressionTree<T, TInput, TOutput> otherTree))
-        {
-            throw new ArgumentException("Crossover can only be performed with another ExpressionTree.");
-        }
-
-        ExpressionTree<T, TInput, TOutput> offspring = (ExpressionTree<T, TInput, TOutput>)Copy();
-
-        if (Rng.NextDouble() < crossoverRate)
-        {
-            // Select a random subtree from the other parent
-            ExpressionTree<T, TInput, TOutput> selectedSubtree = SelectRandomSubtree(otherTree);
-
-            // Replace a random subtree in the offspring with the selected subtree
-            ReplaceRandomSubtree(offspring, selectedSubtree);
-        }
-
-        return offspring;
-    }
-
-    /// <summary>
-    /// Creates a deep copy of this expression tree.
-    /// </summary>
-    /// <returns>A new expression tree with the same structure and values as this one.</returns>
-    /// <remarks>
-    /// <b>For Beginners:</b> This creates an exact duplicate of the formula, like making a photocopy.
-    /// This is important because we often need to make changes to a formula without modifying the original.
-    /// </remarks>
-    public IFullModel<T, TInput, TOutput> Copy()
-    {
-        return new ExpressionTree<T, TInput, TOutput>(
-            Type,
-            Value,
-            Left?.Clone() as ExpressionTree<T, TInput, TOutput>,
-            Right?.Clone() as ExpressionTree<T, TInput, TOutput>
-        );
-    }
-
-    /// <summary>
-    /// Creates a random expression tree with a specified maximum depth.
-    /// </summary>
-    /// <param name="maxDepth">The maximum depth of the tree to generate.</param>
-    /// <returns>A randomly generated expression tree.</returns>
-    /// <remarks>
-    /// <b>For Beginners:</b> This creates a random mathematical formula with a limit on how complex it can be.
-    /// The maxDepth parameter controls this complexity - higher values allow for more complex formulas.
-    /// </remarks>
-    private ExpressionTree<T, TInput, TOutput> GenerateRandomTree(int maxDepth)
-    {
-        if (maxDepth == 0 || Rng.NextDouble() < 0.3) // 30% chance of leaf node
-        {
-            if (Rng.NextDouble() < 0.5)
-            {
-                return new ExpressionTree<T, TInput, TOutput>(ExpressionNodeType.Constant, NumOps.FromDouble(Rng.NextDouble() * 10 - 5));
-            }
-            else
-            {
-                return new ExpressionTree<T, TInput, TOutput>(ExpressionNodeType.Variable, NumOps.FromDouble(Rng.Next(10)));
-            }
-        }
-        else
-        {
-            ExpressionNodeType operationType = (ExpressionNodeType)Rng.Next(2, 6); // Add, Subtract, Multiply, or Divide
-            return new ExpressionTree<T, TInput, TOutput>(
-                operationType,
-                default,
-                GenerateRandomTree(maxDepth - 1),
-                GenerateRandomTree(maxDepth - 1)
-            );
-        }
-    }
-
-    /// <summary>
-    /// Selects a random subtree from the given expression tree.
-    /// </summary>
-    /// <param name="tree">The expression tree to select from.</param>
-    /// <returns>A randomly selected subtree.</returns>
-    /// <remarks>
-    /// <b>For Beginners:</b> This picks a random part of a formula. For example, in the formula (x + (y * 2)),
-    /// it might select the whole formula, just (y * 2), or even just y or 2.
-    /// </remarks>
-    private ExpressionTree<T, TInput, TOutput> SelectRandomSubtree(ExpressionTree<T, TInput, TOutput> tree)
-    {
-        if (tree.Left == null && tree.Right == null)
-        {
-            return tree;
-        }
-        else if (Rng.NextDouble() < 0.3) // 30% chance of selecting current node
-        {
-            return tree;
-        }
-        else
-        {
-            if (tree.Left != null && (tree.Right == null || Rng.NextDouble() < 0.5))
-            {
-                return SelectRandomSubtree(tree.Left);
-            }
-            else
-            {
-                return SelectRandomSubtree(tree.Right!);
-            }
-        }
-    }
-
-    /// <summary>
-    /// Replaces a random subtree in the given tree with the provided replacement subtree.
-    /// </summary>
-    /// <param name="tree">The tree to modify.</param>
-    /// <param name="replacement">The replacement subtree.</param>
-    /// <remarks>
-    /// <b>For Beginners:</b> This replaces a random part of a formula with a different part.
-    /// For example, in (x + y), it might replace y with (z * 2) to create (x + (z * 2)).
-    /// </remarks>
-    private void ReplaceRandomSubtree(ExpressionTree<T, TInput, TOutput> tree, ExpressionTree<T, TInput, TOutput> replacement)
-    {
-        if (Rng.NextDouble() < 0.3) // 30% chance of replacing current node
-        {
-            tree.Type = replacement.Type;
-            tree.Value = replacement.Value;
-            tree.Left = replacement.Left?.Clone() as ExpressionTree<T, TInput, TOutput>;
-            tree.Right = replacement.Right?.Clone() as ExpressionTree<T, TInput, TOutput>;
-        }
-        else
-        {
-            if (tree.Left != null && (tree.Right == null || Rng.NextDouble() < 0.5))
-            {
-                ReplaceRandomSubtree(tree.Left, replacement);
-            }
-            else if (tree.Right != null)
-            {
-                ReplaceRandomSubtree(tree.Right, replacement);
-            }
-        }
-    }
-
-    /// <summary>
-    /// Fits the expression tree to the provided training data.
-    /// </summary>
-    /// <param name="X">The input features matrix.</param>
-    /// <param name="y">The target values vector.</param>
-    /// <remarks>
-    /// <b>For Beginners:</b> For expression trees, "fitting" just checks if the formula can work with your data.
-    /// Unlike other AI models, the formula itself doesn't change during fitting - it's predefined by the tree structure.
-    /// </remarks>
-    public void Fit(Matrix<T> X, Vector<T> y)
-    {
-        // For ExpressionTree, Fit is the same as Train
-        Train(X, y);
-    }
-
-    /// <summary>
-    /// Trains the expression tree on the provided data.
-    /// </summary>
-    /// <param name="x">The input features matrix.</param>
-    /// <param name="y">The target values vector.</param>
-    /// <remarks>
-    /// <b>For Beginners:</b> For expression trees, "training" just validates that the formula can process your data.
-    /// The formula itself doesn't learn or change during training - it's predefined by the tree structure.
-    /// </remarks>
-    public void Train(Matrix<T> x, Vector<T> y)
-    {
-        // For ExpressionTree, we don't actually train the model
-        // The structure is defined by the tree, and we don't adjust it based on data
-        // However, we can use this method to validate that our tree can process the input
-        if (x.Columns < RequiredFeatureCount)
-        {
-            throw new ArgumentException($"Input matrix has {x.Columns} columns, but the model expects at least {RequiredFeatureCount} features.");
-        }
-    }
-
-    /// <summary>
-    /// Makes predictions using this expression tree for multiple input samples.
-    /// </summary>
-    /// <param name="input">A matrix where each row represents a sample and each column represents a feature.</param>
-    /// <returns>A vector containing the predicted values for each input sample.</returns>
-    /// <exception cref="ArgumentException">Thrown when the input matrix has incorrect dimensions.</exception>
-    /// <remarks>
-    /// <b>For Beginners:</b> This method takes your data (like height, weight, age values) and
-    /// runs each row through the mathematical formula represented by this tree to get predictions.
-    /// For example, if your tree represents "2x + y", and your input has values [3,4], the prediction would be 2*3 + 4 = 10.
-    ///
-    /// <b>Note:</b> If the input has more features than the model requires, the extra features are allowed but ignored.
-    /// Only the features up to RequiredFeatureCount are used in predictions. This flexibility supports transfer learning scenarios
-    /// where input data may contain additional features not used by this particular model.
-    /// </remarks>
-    public Vector<T> Predict(Matrix<T> input)
-    {
-        if (input.Columns < RequiredFeatureCount)
-        {
-            throw new ArgumentException($"Input matrix has {input.Columns} columns, but the model expects at least {RequiredFeatureCount} features.");
-        }
-
-        Vector<T> predictions = new(input.Rows);
-        for (int i = 0; i < input.Rows; i++)
-        {
-            predictions[i] = Evaluate(input.GetRow(i));
-        }
-
-        return predictions;
-    }
-
-    /// <summary>
-    /// Gets metadata about this expression tree model.
-    /// </summary>
-    /// <returns>A ModelMetadata object containing information about this model.</returns>
-    /// <remarks>
-    /// <b>For Beginners:</b> This provides useful information about your formula, like how complex it is
-    /// and how many input variables it needs. Think of it as a summary sheet about your mathematical model.
-    /// </remarks>
-    public override ModelMetadata<T> GetModelMetadata()
-    {
-        return new ModelMetadata<T>
-        {
-            FeatureCount = FeatureCount,
-            Complexity = Complexity,
-            Description = ToString(),
-            AdditionalInfo = new Dictionary<string, object>
-            {
-                { "NodeType", Type },
-                { "HasLeftChild", Left != null },
-                { "HasRightChild", Right != null }
-            }
-        };
-    }
-
-    /// <summary>
-    /// Converts this expression tree to a byte array for storage or transmission.
-    /// </summary>
-    /// <returns>A byte array representing the serialized expression tree.</returns>
-    /// <remarks>
-    /// <b>For Beginners:</b> This converts your mathematical formula into a compact format that can be
-    /// saved to a file or sent over the internet. It's like zipping up your formula for storage.
-    /// </remarks>
-    public override byte[] Serialize()
-    {
-        ModelPersistenceGuard.EnforceBeforeSerialize();
-        using MemoryStream ms = new();
-        using BinaryWriter writer = new(ms);
-        Serialize(writer);
-
-        return ms.ToArray();
-    }
-
-    /// <summary>
-    /// Loads an expression tree from a byte array, replacing the current tree's structure.
-    /// </summary>
-    /// <param name="data">The byte array containing the serialized expression tree.</param>
-    /// <remarks>
-    /// <b>For Beginners:</b> This loads a previously saved formula from a compact format and
-    /// replaces the current formula with it. It's like opening a saved file and loading its contents.
-    /// </remarks>
-    public override void Deserialize(byte[] data)
-    {
-        ModelPersistenceGuard.EnforceBeforeDeserialize();
-        using MemoryStream ms = new(data);
-        using BinaryReader reader = new(ms);
-        ExpressionTree<T, TInput, TOutput> deserializedTree = Deserialize(reader);
-        this.Type = deserializedTree.Type;
-        this.Value = deserializedTree.Value;
-        this.Left = deserializedTree.Left;
-        this.Right = deserializedTree.Right;
-    }
-
-    /// <summary>
-    /// Gets a list of all nodes in this expression tree.
-    /// </summary>
-    /// <returns>A list containing all nodes in the tree.</returns>
-    /// <remarks>
-    /// <b>For Beginners:</b> This collects all the parts of your formula into a list.
-    /// For example, if your formula is (x + 2) * y, this would give you a list containing:
-    /// the multiplication operation, the addition operation, the x variable, the constant 2, and the y variable.
-    /// </remarks>
-    public List<ExpressionTree<T, TInput, TOutput>> GetAllNodes()
-    {
-        var nodes = new List<ExpressionTree<T, TInput, TOutput>>();
-        CollectNodes(this, nodes);
-
-        return nodes;
-    }
-
-    /// <summary>
-    /// Helper method that recursively collects all nodes in the tree.
-    /// </summary>
-    /// <param name="node">The current node being processed.</param>
-    /// <param name="nodes">The list to add nodes to.</param>
-    /// <remarks>
-    /// <b>For Beginners:</b> This is a helper method that walks through every part of your formula
-    /// and adds each piece to a list. It uses recursion (calling itself) to visit every branch of the tree.
-    /// </remarks>
-    private void CollectNodes(ExpressionTree<T, TInput, TOutput>? node, List<ExpressionTree<T, TInput, TOutput>> nodes)
-    {
-        if (node == null) return;
-        nodes.Add(node);
-        CollectNodes(node.Left, nodes);
-        CollectNodes(node.Right, nodes);
-    }
-
-    /// <summary>
-    /// Finds a node in the tree by its unique identifier.
-    /// </summary>
-    /// <param name="id">The unique identifier of the node to find.</param>
-    /// <returns>The node with the specified ID, or null if no such node exists.</returns>
-    /// <remarks>
-    /// <b>For Beginners:</b> Every part of your formula has a unique ID number.
-    /// This method helps you find a specific part by its ID, like finding a person by their social security number.
-    /// </remarks>
-    public ExpressionTree<T, TInput, TOutput>? FindNodeById(int id)
-    {
-        return GetAllNodes().FirstOrDefault(n => n.Id == id);
-    }
-
-    /// <summary>
-    /// Gets the unique identifier for this node.
-    /// </summary>
-    /// <remarks>
-    /// <b>For Beginners:</b> This is a unique number assigned to each part of your formula,
-    /// making it easy to identify and reference specific parts of the expression tree.
-    /// </remarks>
-    public int Id { get; } = Interlocked.Increment(ref _nextId);
-
-    /// <summary>
-    /// Static counter used to generate unique IDs for expression tree nodes.
-    /// </summary>
-    private static int _nextId;
-
-    /// <summary>
-    /// Creates a new expression tree with updated coefficient values.
-    /// </summary>
-    /// <param name="newCoefficients">The new coefficient values to use.</param>
-    /// <returns>A new expression tree with the updated coefficients.</returns>
-    /// <exception cref="ArgumentException">Thrown when the number of new coefficients doesn't match the current number.</exception>
-    /// <remarks>
-    /// <b>For Beginners:</b> This changes the constant numbers in your formula without changing its structure.
-    /// For example, if your formula is "2x + 3", this might change it to "4x + 1" by updating the coefficients 2 and 3.
-    /// This is useful when fine-tuning a model to make better predictions.
-    /// </remarks>
-    public IFullModel<T, TInput, TOutput> UpdateCoefficients(Vector<T> newCoefficients)
-    {
-        if (newCoefficients.Length != this.Coefficients.Length)
-        {
-            throw new ArgumentException($"The number of new coefficients ({newCoefficients.Length}) must match the current number of coefficients ({this.Coefficients.Length}).");
-        }
-
-        ExpressionTree<T, TInput, TOutput> updatedTree = (ExpressionTree<T, TInput, TOutput>)this.Clone();
-        int coefficientIndex = 0;
-
-        void UpdateConstantNodes(ExpressionTree<T, TInput, TOutput> node)
-        {
-            if (node.Type == ExpressionNodeType.Constant)
-            {
-                node.Value = newCoefficients[coefficientIndex++];
-            }
-            if (node.Left != null)
-            {
-                UpdateConstantNodes(node.Left);
-            }
-            if (node.Right != null)
-            {
-                UpdateConstantNodes(node.Right);
-            }
-        }
-
-        UpdateConstantNodes(updatedTree);
-
-        return updatedTree;
-    }
-
-    /// <summary>
-    /// Creates a deep copy of this expression tree.
-    /// </summary>
-    /// <returns>A new, identical expression tree.</returns>
-    /// <remarks>
-    /// <b>For Beginners:</b> This creates an exact duplicate of the entire formula tree.
-    /// Unlike the Copy method which returns a general IFullModel, this method returns 
-    /// a specific ExpressionTree. This is useful when you need to make changes to a
-    /// copy without affecting the original formula.
-    /// </remarks>
-    public override IFullModel<T, TInput, TOutput> DeepCopy()
-    {
-        // Reuse existing Copy method which already creates a deep copy
-        return Copy();
-    }
-
-    /// <summary>
-    /// The tree's parameters are the values of its Constant nodes, in traversal order.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// This replaces three overrides that did not agree. ParameterCount counted Constant nodes and
-    /// SetParameters wrote Constant nodes, but GetParameters returned <c>Coefficients</c> -- a
-    /// different vector of unrelated length. So the count described the tree, the vector described
-    /// something else, and a restore round-trip could not be correct for both.
-    /// </para>
-    /// <para>
-    /// One declared source removes the possibility: the count, the vector and the restore all walk
-    /// the same nodes in the same order. Coefficients remains available in its own right; it simply
-    /// is not the parameter surface.
-    /// </para>
-    /// </remarks>
-    protected override void RegisterComponents()
-    {
-        base.RegisterComponents();
-        RegisterParameterComponent(new DelegatingParameterSource<T>(
-            () => CollectConstantNodes().Count,
-            () =>
-            {
-                var nodes = CollectConstantNodes();
-                var values = new Vector<T>(nodes.Count);
-                for (int i = 0; i < nodes.Count; i++) values[i] = nodes[i].Value;
-                return values;
-            },
-            values =>
-            {
-                var nodes = CollectConstantNodes();
-                for (int i = 0; i < nodes.Count && i < values.Length; i++)
-                {
-                    nodes[i].SetValue(values[i]);
-                }
-            }));
-    }
-
-    /// <summary>Constant nodes in the same traversal order the count and the restore use.</summary>
-    private List<ExpressionTree<T, TInput, TOutput>> CollectConstantNodes()
-    {
-        var found = new List<ExpressionTree<T, TInput, TOutput>>();
-        void Walk(ExpressionTree<T, TInput, TOutput>? node)
-        {
-            if (node is null) return;
-            if (node.Type == ExpressionNodeType.Constant) found.Add(node);
-            Walk(node.Left);
-            Walk(node.Right);
-        }
-        Walk(this);
-        return found;
-    }
-
-    // Replaced by the declared parameter source below. Removed under AIDN082.
-
-    /// <summary>
-    /// Creates a new expression tree with updated parameters.
-    /// </summary>
-    /// <param name="parameters">The new parameter values to use.</param>
-    /// <returns>A new expression tree with the updated parameters.</returns>
-    /// <remarks>
-    /// <b>For Beginners:</b> This replaces all the constant numbers in your formula 
-    /// with new values. For example, changing "2x + 3" to "4x + 1" by providing [4, 1]
-    /// as the new parameters. The structure of the formula stays the same.
-    /// </remarks>
-    public override IFullModel<T, TInput, TOutput> WithParameters(Vector<T> parameters)
-    {
-        // This is equivalent to UpdateCoefficients
-        return UpdateCoefficients(parameters);
-    }
-
-    /// <summary>
-    /// Gets the indices of all features (variables) used in this expression tree.
-    /// </summary>
-    /// <returns>A collection of feature indices.</returns>
-    /// <remarks>
-    /// <b>For Beginners:</b> This tells you which input variables are actually used in your formula.
-    /// For example, if your formula only uses x[0] and x[2], this returns [0, 2], showing that
-    /// the formula uses the first and third variables but not the second one.
-    /// </remarks>
-    public override IEnumerable<int> GetActiveFeatureIndices()
-    {
-        HashSet<int> activeIndices = new();
-
-        void CollectFeatureIndices(ExpressionTree<T, TInput, TOutput> node)
-        {
-            if (node.Type == ExpressionNodeType.Variable)
-            {
-                activeIndices.Add(NumOps.ToInt32(node.Value));
-            }
-
-            if (node.Left != null)
-            {
-                CollectFeatureIndices(node.Left);
-            }
-
-            if (node.Right != null)
-            {
-                CollectFeatureIndices(node.Right);
-            }
-        }
-
-        CollectFeatureIndices(this);
-        return activeIndices;
-    }
-
-    /// <summary>
-    /// Gets the feature importance scores for this expression tree.
-    /// </summary>
-    /// <returns>A dictionary mapping feature names to importance scores.</returns>
-    /// <remarks>
-    /// <b>For Beginners:</b> Feature importance tells you which input variables matter most in your formula.
-    /// For expression trees, importance is calculated by counting how many times each variable appears in the formula.
-    /// Variables that appear more frequently are considered more important.
-    /// </remarks>
-    public override Dictionary<string, T> GetFeatureImportance()
-    {
-        // Count occurrences of each feature in the tree
-        Dictionary<int, int> featureCounts = new();
-
-        void CountFeatureOccurrences(ExpressionTree<T, TInput, TOutput> node)
-        {
-            if (node == null) return;
-
-            if (node.Type == ExpressionNodeType.Variable)
-            {
-                int featureIndex = NumOps.ToInt32(node.Value);
-                if (featureCounts.ContainsKey(featureIndex))
-                {
-                    featureCounts[featureIndex]++;
-                }
-                else
-                {
-                    featureCounts[featureIndex] = 1;
-                }
-            }
-
-            if (node.Left != null)
-            {
-                CountFeatureOccurrences(node.Left);
-            }
-
-            if (node.Right != null)
-            {
-                CountFeatureOccurrences(node.Right);
-            }
-        }
-
-        CountFeatureOccurrences(this);
-
-        // Convert counts to importance scores (normalized by total occurrences)
-        int totalCount = 0;
-        foreach (var count in featureCounts.Values)
-        {
-            totalCount += count;
-        }
-
-        Dictionary<string, T> importance = new();
-        if (totalCount > 0)
-        {
-            foreach (var kvp in featureCounts)
-            {
-                string featureName = $"x[{kvp.Key}]";
-                double normalizedImportance = (double)kvp.Value / totalCount;
-                importance[featureName] = NumOps.FromDouble(normalizedImportance);
-            }
-        }
-
-        return importance;
-    }
-
-    /// <summary>
-    /// Sets the active feature indices for this expression tree.
-    /// </summary>
-    /// <param name="featureIndices">The feature indices to use.</param>
-    /// <remarks>
-    /// <b>For Beginners:</b> This restricts the formula to only use specific input variables.
-    /// Any variables in the tree that are not in the active set will be replaced with constant zero values.
-    /// This is useful for feature selection and understanding which variables are most important.
-    /// </remarks>
-    public override void SetActiveFeatureIndices(IEnumerable<int> featureIndices)
-    {
-        if (featureIndices == null)
-        {
-            throw new ArgumentNullException(nameof(featureIndices));
-        }
-
-        HashSet<int> activeSet = new(featureIndices);
-
-        void DeactivateInactiveFeatures(ExpressionTree<T, TInput, TOutput> node)
-        {
-            if (node == null) return;
-
-            // If this is a variable node and it's not in the active set, replace it with zero
-            if (node.Type == ExpressionNodeType.Variable)
-            {
-                int featureIndex = NumOps.ToInt32(node.Value);
-                if (!activeSet.Contains(featureIndex))
-                {
-                    node.SetType(ExpressionNodeType.Constant);
-                    node.SetValue(NumOps.Zero);
-                }
-            }
-
-            // Recursively process children
-            if (node.Left != null)
-            {
-                DeactivateInactiveFeatures(node.Left);
-            }
-
-            if (node.Right != null)
-            {
-                DeactivateInactiveFeatures(node.Right);
-            }
-        }
-
-        DeactivateInactiveFeatures(this);
-
-        // Clear the cached feature counts since we've modified the tree
-        _featureCount = 0;
-        _requiredFeatureCount = 0;
-    }
-
-    /// <summary>
-    /// Trains the expression tree on a single input-output pair.
-    /// </summary>
-    /// <param name="input">The input data (Vector, Matrix, or Tensor).</param>
-    /// <param name="expectedOutput">The expected output value.</param>
-    /// <remarks>
-    /// <b>For Beginners:</b> For expression trees, training doesn't actually change the formula.
-    /// This method validates that the formula can process your input data correctly.
-    /// </remarks>
-    public override void Train(TInput input, TOutput expectedOutput)
-    {
-        // For expression trees, we primarily validate input compatibility
-        if (input is Matrix<T> matrix)
-        {
-            ValidateMatrixFeatures(matrix);
-        }
-        else if (input is Vector<T> vector)
-        {
-            ValidateVectorFeatures(vector);
-        }
-        else if (input is Tensor<T> tensor)
-        {
-            ValidateTensorFeatures(tensor);
-        }
-        else
-        {
-            throw new ArgumentException($"Unsupported input type: {input?.GetType().Name ?? "null"}. Expected Matrix<T>, Vector<T>, or Tensor<T>.");
-        }
-    }
-
-    /// <summary>
-    /// Computes gradients of the loss function with respect to model parameters WITHOUT updating parameters.
-    /// </summary>
-    /// <param name="input">The input data.</param>
-    /// <param name="target">The target/expected output.</param>
-    /// <param name="lossFunction">The loss function to use. If null, uses the model's default loss function.</param>
-    /// <returns>A vector containing gradients with respect to all model parameters (constants in the expression tree).</returns>
-    /// <exception cref="ArgumentNullException">If input or target is null.</exception>
-    /// <remarks>
-    /// <para>
-    /// This method computes gradients using numerical differentiation (finite differences).
-    /// For each constant in the expression tree, it slightly perturbs the value and
-    /// measures how the loss changes, approximating the gradient.
-    /// </para>
-    /// <para><b>For Beginners:</b>
-    /// This calculates how to adjust each constant in your mathematical formula to reduce error.
-    /// Since expression trees are symbolic, we use a numerical approximation:
-    /// we slightly change each constant and see how much the error changes.
-    /// </para>
-    /// </remarks>
-    public override Vector<T> ComputeGradients(TInput input, TOutput target, ILossFunction<T>? lossFunction = null)
-    {
-        if (input == null)
-            throw new ArgumentNullException(nameof(input));
-        if (target == null)
-            throw new ArgumentNullException(nameof(target));
-
-        var loss = lossFunction ?? DefaultLossFunction;
-        var parameters = Coefficients;
-        var gradients = new Vector<T>(parameters.Length);
-
-        // Small epsilon for finite differences
-        T epsilon = NumOps.FromDouble(1e-7);
-
-        // Compute loss at current parameters
-        var currentPrediction = Predict(input);
-        Vector<T> currentPredVec = ConvertOutputToVector(currentPrediction);
-        Vector<T> targetVec = ConvertOutputToVector(target);
-        T currentLoss = loss.CalculateLoss(currentPredVec, targetVec);
-
-        // Compute gradient for each parameter using finite differences
-        for (int i = 0; i < parameters.Length; i++)
-        {
-            // Save original value
-            T originalValue = parameters[i];
-
-            // Perturb parameter forward
-            parameters[i] = NumOps.Add(originalValue, epsilon);
-            SetParameters(parameters);  // ✅ CRITICAL: Use SetParameters, NOT UpdateCoefficients
-            var forwardPrediction = Predict(input);
-            Vector<T> forwardPredVec = ConvertOutputToVector(forwardPrediction);
-            T forwardLoss = loss.CalculateLoss(forwardPredVec, targetVec);
-
-            // Compute gradient: (f(x+ε) - f(x)) / ε
-            T gradient = NumOps.Divide(NumOps.Subtract(forwardLoss, currentLoss), epsilon);
-            gradients[i] = gradient;
-
-            // Restore original value
-            parameters[i] = originalValue;
-            SetParameters(parameters);  // ✅ Restore original
-        }
-
-        return gradients;
-    }
-
-    /// <summary>
-    /// Applies pre-computed gradients to update the model parameters (constants in the expression tree).
-    /// </summary>
-    /// <param name="gradients">The gradient vector to apply.</param>
-    /// <param name="learningRate">The learning rate for the update.</param>
-    /// <exception cref="ArgumentNullException">If gradients is null.</exception>
-    /// <exception cref="ArgumentException">If gradient vector length doesn't match parameter count.</exception>
-    /// <remarks>
-    /// <para>
-    /// Updates constants using: constant = constant - learningRate * gradient
-    /// </para>
-    /// <para><b>For Beginners:</b>
-    /// After computing gradients (seeing which direction to adjust each constant),
-    /// this method actually adjusts them. The learning rate controls how big of an adjustment to make.
-    /// </para>
-    /// </remarks>
-    public override void ApplyGradients(Vector<T> gradients, T learningRate)
-    {
-        if (gradients == null)
-            throw new ArgumentNullException(nameof(gradients));
-
-        var parameters = Coefficients;
-
-        if (gradients.Length != parameters.Length)
-        {
-            throw new ArgumentException(
-                $"Gradient vector length ({gradients.Length}) must match parameter count ({parameters.Length})",
-                nameof(gradients));
-        }
-
-        // Apply gradient descent: params = params - learningRate * gradients
-        // Vectorized SGD
-        parameters = (Vector<T>)Engine.Subtract(parameters, Engine.Multiply(gradients, learningRate));
-
-        SetParameters(parameters);
-    }
-
-    /// <summary>
-    /// Helper method to convert output to Vector<T> for loss computation.
-    /// </summary>
-    private Vector<T> ConvertOutputToVector(TOutput output)
-    {
-        if (output is Vector<T> vec)
-            return vec;
-        if (output is T scalar)
-            return new Vector<T>(new[] { scalar });
-        if (output is Matrix<T> mat)
-            return mat.ToVector();
-
-        // Try to convert using reflection if needed
-        throw new InvalidOperationException($"Cannot convert output of type {typeof(TOutput).Name} to Vector<T> for gradient computation.");
-    }
-
-    /// <summary>
-    /// Makes a prediction for an input example.
-    /// </summary>
-    /// <param name="input">The input data (Vector, Matrix, or Tensor).</param>
-    /// <returns>The predicted output.</returns>
-    /// <remarks>
-    /// <b>For Beginners:</b> This method applies your mathematical formula to the input data
-    /// to calculate a prediction. It handles different types of inputs (vectors, matrices, or tensors).
-    /// </remarks>
-    public override TOutput Predict(TInput input)
-    {
-        if (input is Matrix<T> matrix)
-        {
-            ValidateMatrixFeatures(matrix);
-            Vector<T> predictions = PredictMatrix(matrix);
-
-            // Try to convert the result to TOutput
-            if (predictions is TOutput typedResult)
-            {
-                return typedResult;
-            }
-            else if (typeof(TOutput) == typeof(object))
-            {
-                return (TOutput)(object)predictions;
-            }
-
-            throw new InvalidOperationException($"Cannot convert prediction vector to {typeof(TOutput).Name}.");
-        }
-        else if (input is Tensor<T> tensor)
-        {
-            ValidateTensorFeatures(tensor);
-            Vector<T> predictions = PredictTensor(tensor);
-
-            // Try to convert the result to TOutput
-            if (predictions is TOutput typedResult)
-            {
-                return typedResult;
-            }
-            else if (typeof(TOutput) == typeof(object))
-            {
-                return (TOutput)(object)predictions;
-            }
-
-            throw new InvalidOperationException($"Cannot convert prediction vector to {typeof(TOutput).Name}.");
-        }
-
-        throw new ArgumentException($"Unsupported input type: {input?.GetType().Name ?? "null"}. Expected Matrix<T>, Vector<T>, or Tensor<T>.");
-    }
-
-    /// <summary>
-    /// Validates that a matrix has compatible features for this expression tree.
-    /// </summary>
-    /// <param name="matrix">The matrix to validate.</param>
-    private void ValidateMatrixFeatures(Matrix<T> matrix)
-    {
-        if (matrix.Columns < RequiredFeatureCount)
-        {
-            throw new ArgumentException($"Input matrix has {matrix.Columns} columns, but the model requires at least {RequiredFeatureCount} features.");
-        }
-    }
-
-    /// <summary>
-    /// Validates that a vector has compatible features for this expression tree.
-    /// </summary>
-    /// <param name="vector">The vector to validate.</param>
-    private void ValidateVectorFeatures(Vector<T> vector)
-    {
-        if (vector.Length < RequiredFeatureCount)
-        {
-            throw new ArgumentException($"Input vector has {vector.Length} elements, but the model requires at least {RequiredFeatureCount} features.");
-        }
-    }
-
-    /// <summary>
-    /// Validates that a tensor has compatible features for this expression tree.
-    /// </summary>
-    /// <param name="tensor">The tensor to validate.</param>
-    private void ValidateTensorFeatures(Tensor<T> tensor)
-    {
-        if (tensor.Shape.Length < 1 || tensor.Shape[tensor.Shape.Length - 1] < RequiredFeatureCount)
-        {
-            throw new ArgumentException($"Input tensor's last dimension is {(tensor.Shape.Length > 0 ? tensor.Shape[tensor.Shape.Length - 1] : 0)}, " +
-                $"but the model requires at least {RequiredFeatureCount} features.");
-        }
-    }
-
-    /// <summary>
-    /// Makes predictions for all rows in a matrix.
-    /// </summary>
-    /// <param name="matrix">The input matrix, where each row is a sample.</param>
-    /// <returns>A vector containing predictions for each row.</returns>
-    private Vector<T> PredictMatrix(Matrix<T> matrix)
-    {
-        Vector<T> predictions = new Vector<T>(matrix.Rows);
-        for (int i = 0; i < matrix.Rows; i++)
-        {
-            predictions[i] = Evaluate(matrix.GetRow(i));
-        }
-        return predictions;
-    }
-
-    /// <summary>
-    /// Makes predictions for all samples in a tensor.
-    /// </summary>
-    /// <param name="tensor">The input tensor.</param>
-    /// <returns>A vector containing predictions for each sample.</returns>
-    private Vector<T> PredictTensor(Tensor<T> tensor)
-    {
-        // Calculate the batch size (product of all dimensions except the last one)
-        int batchSize = 1;
-        for (int i = 0; i < tensor.Shape.Length - 1; i++)
-        {
-            batchSize *= tensor.Shape[i];
-        }
-
-        Vector<T> predictions = new Vector<T>(batchSize);
-        for (int i = 0; i < batchSize; i++)
-        {
-            // Extract vector for this batch item using the Flatten and Slice methods
-            // First, flatten the tensor then extract the appropriate slice
-            Vector<T> flatTensor = tensor.ToVector();
-            int featureSize = tensor.Shape[tensor.Shape.Length - 1];
-            int startIndex = i * featureSize;
-
-            // Create a vector from the slice
-            Vector<T> inputVector = new Vector<T>(featureSize);
-            for (int j = 0; j < featureSize; j++)
-            {
-                inputVector[j] = flatTensor[startIndex + j];
-            }
-
-            predictions[i] = Evaluate(inputVector);
-        }
-
-        return predictions;
-    }
-
-    /// <summary>
-    /// Gets a vector containing all coefficient values in this expression tree.
-    /// </summary>
-    /// <remarks>
-    /// <b>For Beginners:</b> This collects all the constant numbers from your formula into a list.
-    /// For example, if your formula is "2x + 3y + 5", this would give you [2, 3, 5].
-    /// These numbers are called "coefficients" and are important when optimizing your model.
-    /// </remarks>
-    public Vector<T> Coefficients
-    {
-        get
-        {
-            List<T> coefficients = new List<T>();
-
-            void CollectCoefficients(ExpressionTree<T, TInput, TOutput> node)
-            {
-                if (node.Type == ExpressionNodeType.Constant)
-                {
-                    coefficients.Add(node.Value);
-                }
-                if (node.Left != null)
-                {
-                    CollectCoefficients(node.Left);
-                }
-                if (node.Right != null)
-                {
-                    CollectCoefficients(node.Right);
-                }
-            }
-
-            CollectCoefficients(this);
-            return new Vector<T>(coefficients.ToArray());
-        }
-    }
-
-    // Replaced by the declared parameter source below. Removed under AIDN082.
-
-    // Replaced by the declared parameter source below. Removed under AIDN082.
-
-    /// <summary>
-    /// Saves the expression tree model to a file.
-    /// </summary>
-    /// <param name="filePath">The path where the model should be saved.</param>
-    /// <remarks>
-    /// <b>For Beginners:</b> This saves your mathematical formula to a file so you can load it later
-    /// without having to recreate it. The file contains the tree structure, all node types, and values.
-    /// </remarks>
-    public override void SaveModel(string filePath)
-    {
-        byte[] serializedData = Serialize();
-        File.WriteAllBytes(filePath, serializedData);
-    }
-
-    /// <summary>
-    /// Loads an expression tree model from a file.
-    /// </summary>
-    /// <param name="filePath">The path to the file containing the saved model.</param>
-    /// <remarks>
-    /// <b>For Beginners:</b> This loads a previously saved formula from a file, allowing you to
-    /// reuse it without recreating it. The loaded formula can immediately be used for predictions.
-    /// </remarks>
-    public override void LoadModel(string filePath)
-    {
-        byte[] serializedData = File.ReadAllBytes(filePath);
-        Deserialize(serializedData);
-    }
-
-    /// <summary>
-    /// Saves the expression tree's current state (structure and values) to a stream.
-    /// </summary>
-    /// <param name="stream">The stream to write the expression tree state to.</param>
-    /// <remarks>
-    /// <para>
-    /// This method serializes the complete expression tree structure, including all node types,
-    /// values, and connections. It uses the existing Serialize method and writes the data
-    /// to the provided stream.
-    /// </para>
-    /// <para><b>For Beginners:</b> This is like creating a snapshot of your mathematical formula.
-    ///
-    /// When you call SaveState:
-    /// - The entire tree structure is written to the stream
-    /// - All node types (constants, variables, operations) are preserved
-    /// - All values and connections are saved
-    ///
-    /// This is particularly useful for:
-    /// - Checkpointing during evolutionary algorithm training
-    /// - Knowledge distillation with symbolic models
-    /// - Saving the best formula found during optimization
-    /// - Creating formula ensembles
-    ///
-    /// You can later use LoadState to restore the formula to this exact state.
-    /// </para>
-    /// </remarks>
-    /// <exception cref="ArgumentNullException">Thrown when stream is null.</exception>
-    /// <exception cref="IOException">Thrown when there's an error writing to the stream.</exception>
-    public override void SaveState(Stream stream)
-    {
-        if (stream == null)
-            throw new ArgumentNullException(nameof(stream));
-
-        if (!stream.CanWrite)
-            throw new ArgumentException("Stream must be writable.", nameof(stream));
-
-        try
-        {
-            var data = this.Serialize();
-            stream.Write(data, 0, data.Length);
-            stream.Flush();
-        }
-        catch (IOException ex)
-        {
-            throw new IOException($"Failed to save expression tree state to stream: {ex.Message}", ex);
-        }
-        catch (Exception ex)
-        {
-            throw new InvalidOperationException($"Unexpected error while saving expression tree state: {ex.Message}", ex);
-        }
-    }
-
-    /// <summary>
-    /// Loads the expression tree's state (structure and values) from a stream.
-    /// </summary>
-    /// <param name="stream">The stream to read the expression tree state from.</param>
-    /// <remarks>
-    /// <para>
-    /// This method deserializes expression tree state that was previously saved with SaveState,
-    /// restoring the complete tree structure, node types, values, and connections.
-    /// It uses the existing Deserialize method after reading data from the stream.
-    /// </para>
-    /// <para><b>For Beginners:</b> This is like loading a saved snapshot of your mathematical formula.
-    ///
-    /// When you call LoadState:
-    /// - The tree structure is read from the stream
-    /// - All node types and values are restored
-    /// - The formula becomes identical to when SaveState was called
-    ///
-    /// After loading, the formula can:
-    /// - Make predictions using the restored structure
-    /// - Continue evolving during optimization
-    /// - Be used for symbolic regression or genetic programming
-    ///
-    /// This is essential for:
-    /// - Resuming interrupted evolutionary training
-    /// - Loading the best formula after optimization
-    /// - Deploying symbolic models to production
-    /// - Knowledge distillation with interpretable models
-    /// </para>
-    /// </remarks>
-    /// <exception cref="ArgumentNullException">Thrown when stream is null.</exception>
-    /// <exception cref="IOException">Thrown when there's an error reading from the stream.</exception>
-    /// <exception cref="InvalidOperationException">Thrown when the stream contains invalid or incompatible data.</exception>
-    public override void LoadState(Stream stream)
-    {
-        if (stream == null)
-            throw new ArgumentNullException(nameof(stream));
-
-        if (!stream.CanRead)
-            throw new ArgumentException("Stream must be readable.", nameof(stream));
-
-        try
-        {
-            using var ms = new MemoryStream();
-            stream.CopyTo(ms);
-            var data = ms.ToArray();
-
-            if (data.Length == 0)
-                throw new InvalidOperationException("Stream contains no data.");
-
-            this.Deserialize(data);
-        }
-        catch (IOException ex)
-        {
-            throw new IOException($"Failed to read expression tree state from stream: {ex.Message}", ex);
-        }
-        catch (InvalidOperationException)
-        {
-            // Re-throw InvalidOperationException from Deserialize
-            throw;
-        }
-        catch (Exception ex)
-        {
-            throw new InvalidOperationException(
-                $"Failed to deserialize expression tree state. The stream may contain corrupted or incompatible data: {ex.Message}", ex);
-        }
-    }
-
-}
+
+    /// <summary>
+    /// Gets the complexity of this expression tree, measured as the total number of nodes.
+    /// </summary>
+    /// <remarks>
+    /// <b>For Beginners:</b> Complexity tells you how complicated the formula is.
+    /// A higher number means a more complex formula with more terms and operations.
+    /// </remarks>
+    public int Complexity => 1 + (Left?.Complexity ?? 0) + (Right?.Complexity ?? 0);
+
+    /// <summary>
+    /// Sets the type of this node.
+    /// </summary>
+    /// <param name="type">The node type to set.</param>
+    public void SetType(ExpressionNodeType type)
+    {
+        Type = type;
+    }
+
+    /// <summary>
+    /// Sets the value of this node.
+    /// </summary>
+    /// <param name="value">The value to set.</param>
+    public void SetValue(T value)
+    {
+        Value = value;
+    }
+
+    /// <summary>
+    /// Sets the left child of this node and updates the parent reference of the child.
+    /// </summary>
+    /// <param name="left">The node to set as the left child.</param>
+    public void SetLeft(ExpressionTree<T, TInput, TOutput>? left)
+    {
+        Left = left;
+        if (left != null)
+        {
+            left.Parent = this;
+        }
+    }
+
+    /// <summary>
+    /// Sets the right child of this node and updates the parent reference of the child.
+    /// </summary>
+    /// <param name="right">The node to set as the right child.</param>
+    public void SetRight(ExpressionTree<T, TInput, TOutput>? right)
+    {
+        Right = right;
+        if (right != null)
+        {
+            right.Parent = this;
+        }
+    }
+
+    /// <summary>
+    /// Returns a string representation of this expression tree.
+    /// </summary>
+    /// <returns>A string representing the mathematical expression.</returns>
+    /// <remarks>
+    /// <b>For Beginners:</b> This converts the tree into a readable mathematical formula.
+    /// For example, an addition node with children might return "(2 + x[0])".
+    /// </remarks>
+    public override string ToString()
+    {
+        return Type switch
+        {
+            ExpressionNodeType.Constant => Value?.ToString(),
+            ExpressionNodeType.Variable => $"x[{Value}]",
+            ExpressionNodeType.Add => $"({Left} + {Right})",
+            ExpressionNodeType.Subtract => $"({Left} - {Right})",
+            ExpressionNodeType.Multiply => $"({Left} * {Right})",
+            ExpressionNodeType.Divide => $"({Left} / {Right})",
+            _ => throw new ArgumentException($"Unknown expression node type '{Type}'."),
+        } ?? string.Empty;
+    }
+
+    /// <summary>
+    /// Shared random number generator for all mutation and crossover operations.
+    /// </summary>
+    /// <remarks>
+    /// Using ThreadLocal ensures thread safety while maintaining good randomness quality.
+    /// Each thread gets its own Random instance, avoiding issues with multiple threads
+    /// accessing a shared Random instance or multiple instances created with the same seed.
+    /// </remarks>
+    private static readonly ThreadLocal<Random> _random = new ThreadLocal<Random>(() => RandomHelper.CreateSecureRandom());
+
+    private static Random Rng => _random.Value ?? throw new InvalidOperationException("Thread-local Random has not been initialized.");
+
+    /// <summary>
+    /// Creates a new expression tree node with the specified properties.
+    /// </summary>
+    /// <param name="type">The type of node to create.</param>
+    /// <param name="value">The value for this node (for constants and variables).</param>
+    /// <param name="left">The left child node.</param>
+    /// <param name="right">The right child node.</param>
+    /// <param name="lossFunction">Optional loss function to use for training. If null, uses Mean Squared Error (MSE) for symbolic regression.</param>
+    /// <remarks>
+    /// <b>For Beginners:</b> This creates a new part of your mathematical formula.
+    /// You can create simple nodes (like numbers or variables) or operation nodes
+    /// (like addition or multiplication) that connect to other nodes.
+    /// </remarks>
+    public ExpressionTree(ExpressionNodeType type, T? value = default, ExpressionTree<T, TInput, TOutput>? left = null, ExpressionTree<T, TInput, TOutput>? right = null, ILossFunction<T>? lossFunction = null)
+    {
+        Type = type;
+        Value = value ?? NumOps.Zero;
+        Left = left;
+        Right = right;
+        _defaultLossFunction = lossFunction ?? new MeanSquaredErrorLoss<T>();
+    }
+
+    /// <summary>
+    /// Cached count of features used in this expression tree.
+    /// </summary>
+    private int _featureCount;
+
+    /// <summary>
+    /// Cached required feature count (max feature index + 1) for validation.
+    /// </summary>
+    private int _requiredFeatureCount;
+
+    /// <summary>
+    /// The default loss function used by this model for gradient computation.
+    /// </summary>
+    private readonly ILossFunction<T> _defaultLossFunction;
+
+    /// <summary>
+    /// Gets the default loss function used by this model for gradient computation.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// For ExpressionTree (symbolic regression), the default loss function is Mean Squared Error (MSE),
+    /// which is the standard loss function for regression problems.
+    /// </para>
+    /// </remarks>
+    public override ILossFunction<T> DefaultLossFunction => _defaultLossFunction;
+
+    /// <summary>
+    /// Gets the number of features (variables) used in this expression tree.
+    /// </summary>
+    /// <remarks>
+    /// <b>For Beginners:</b> This tells you how many different input variables
+    /// your formula uses. For example, if your formula uses x[0], x[1], and x[2],
+    /// the feature count would be 3.
+    /// </remarks>
+    public int FeatureCount
+    {
+        get
+        {
+            if (_featureCount == 0)
+            {
+                _featureCount = CalculateFeatureCount();
+            }
+
+            return _featureCount;
+        }
+    }
+
+    /// <summary>
+    /// Gets the minimum number of features required for input data to this expression tree.
+    /// </summary>
+    /// <remarks>
+    /// <b>For Beginners:</b> This tells you the minimum number of columns your input data must have.
+    /// It equals the maximum variable index used plus one. For example, if your formula uses x[5],
+    /// the required feature count is 6 (indices 0 through 5).
+    /// <para>
+    /// Note: This is different from FeatureCount which counts unique variables used.
+    /// A tree using only x[5] has FeatureCount=1 but RequiredFeatureCount=6.
+    /// </para>
+    /// </remarks>
+    public int RequiredFeatureCount
+    {
+        get
+        {
+            if (_requiredFeatureCount == 0)
+            {
+                _requiredFeatureCount = CalculateRequiredFeatureCount();
+            }
+
+            return _requiredFeatureCount;
+        }
+    }
+
+    /// <summary>
+    /// Checks if a specific feature (variable) is used in this expression tree.
+    /// </summary>
+    /// <param name="featureIndex">The index of the feature to check.</param>
+    /// <returns>True if the feature is used, false otherwise.</returns>
+    /// <remarks>
+    /// <b>For Beginners:</b> This checks if your formula uses a specific input variable.
+    /// For example, if featureIndex is 2, it checks if x[2] appears anywhere in your formula.
+    /// </remarks>
+    public override bool IsFeatureUsed(int featureIndex)
+    {
+        return IsFeatureUsedRecursive(this, featureIndex);
+    }
+
+    /// <summary>
+    /// Calculates the number of unique features used in this expression tree.
+    /// </summary>
+    /// <returns>The count of unique features actually used in the tree.</returns>
+    /// <remarks>
+    /// This method counts the unique feature indices used in the tree. For example,
+    /// if the tree uses features x[0] and x[5], this returns 2 (the count of unique features),
+    /// not 6. This accurately represents how many different input variables the formula uses.
+    /// </remarks>
+    private int CalculateFeatureCount()
+    {
+        HashSet<int> uniqueFeatures = new HashSet<int>();
+        CollectUniqueFeatures(this, uniqueFeatures);
+        return uniqueFeatures.Count;
+    }
+
+    /// <summary>
+    /// Calculates the minimum number of features required for input data.
+    /// </summary>
+    /// <returns>The maximum feature index used plus one, or 0 if no variables are used.</returns>
+    /// <remarks>
+    /// This method finds the maximum feature index in the tree and adds 1.
+    /// For example, if the tree uses x[0] and x[5], this returns 6 (max index 5 + 1).
+    /// This represents the minimum number of columns input data must have.
+    /// </remarks>
+    private int CalculateRequiredFeatureCount()
+    {
+        int maxIndex = -1;
+        FindMaxFeatureIndex(this, ref maxIndex);
+        return maxIndex + 1;
+    }
+
+    /// <summary>
+    /// Recursively finds the maximum feature index used in a node and its children.
+    /// </summary>
+    /// <param name="node">The node to check.</param>
+    /// <param name="maxIndex">Reference to track the maximum index found.</param>
+    private void FindMaxFeatureIndex(ExpressionTree<T, TInput, TOutput> node, ref int maxIndex)
+    {
+        if (node == null) return;
+
+        if (node.Type == ExpressionNodeType.Variable)
+        {
+            int featureIndex = NumOps.ToInt32(node.Value);
+            if (featureIndex > maxIndex)
+            {
+                maxIndex = featureIndex;
+            }
+        }
+
+        if (node.Left != null)
+        {
+            FindMaxFeatureIndex(node.Left, ref maxIndex);
+        }
+
+        if (node.Right != null)
+        {
+            FindMaxFeatureIndex(node.Right, ref maxIndex);
+        }
+    }
+
+    /// <summary>
+    /// Recursively collects unique feature indices used in a node and its children.
+    /// </summary>
+    /// <param name="node">The node to check.</param>
+    /// <param name="uniqueFeatures">The set to collect unique feature indices.</param>
+    private void CollectUniqueFeatures(ExpressionTree<T, TInput, TOutput> node, HashSet<int> uniqueFeatures)
+    {
+        if (node == null) return;
+
+        if (node.Type == ExpressionNodeType.Variable)
+        {
+            uniqueFeatures.Add(NumOps.ToInt32(node.Value));
+        }
+
+        if (node.Left != null)
+        {
+            CollectUniqueFeatures(node.Left, uniqueFeatures);
+        }
+
+        if (node.Right != null)
+        {
+            CollectUniqueFeatures(node.Right, uniqueFeatures);
+        }
+    }
+
+    /// <summary>
+    /// Recursively checks if a specific feature is used in a node or its children.
+    /// </summary>
+    /// <param name="node">The node to check.</param>
+    /// <param name="featureIndex">The index of the feature to check.</param>
+    /// <returns>True if the feature is used, false otherwise.</returns>
+    private bool IsFeatureUsedRecursive(ExpressionTree<T, TInput, TOutput> node, int featureIndex)
+    {
+        if (node.Type == ExpressionNodeType.Variable && NumOps.ToInt32(node.Value) == featureIndex)
+        {
+            return true;
+        }
+
+        bool leftUsed = node.Left != null && IsFeatureUsedRecursive(node.Left, featureIndex);
+        bool rightUsed = node.Right != null && IsFeatureUsedRecursive(node.Right, featureIndex);
+
+        return leftUsed || rightUsed;
+    }
+
+    /// <summary>
+    /// Evaluates this expression tree for a given input vector.
+    /// </summary>
+    /// <param name="input">The input vector containing values for variables.</param>
+    /// <returns>The result of evaluating the expression.</returns>
+    /// <remarks>
+    /// <b>For Beginners:</b> This calculates the result of your formula for a specific set of input values.
+    /// For example, if your formula is "2*x[0] + x[1]" and your input is [3, 4], the result would be 2*3 + 4 = 10.
+    /// </remarks>
+    public T Evaluate(Vector<T> input)
+    {
+        if (Type == ExpressionNodeType.Constant) return Value;
+        if (Type == ExpressionNodeType.Variable) return input[NumOps.ToInt32(Value)];
+
+        var left = Left ?? throw new InvalidOperationException("Left has not been initialized.");
+        var right = Right ?? throw new InvalidOperationException("Right has not been initialized.");
+
+        return Type switch
+        {
+            ExpressionNodeType.Add => NumOps.Add(left.Evaluate(input), right.Evaluate(input)),
+            ExpressionNodeType.Subtract => NumOps.Subtract(left.Evaluate(input), right.Evaluate(input)),
+            ExpressionNodeType.Multiply => NumOps.Multiply(left.Evaluate(input), right.Evaluate(input)),
+            ExpressionNodeType.Divide => NumOps.Divide(left.Evaluate(input), right.Evaluate(input)),
+            _ => throw new ArgumentException($"Unknown expression node type '{Type}'."),
+        };
+    }
+
+    /// <summary>
+    /// Writes this expression tree to a binary stream.
+    /// </summary>
+    /// <param name="writer">The binary writer to write to.</param>
+    /// <remarks>
+    /// <b>For Beginners:</b> This saves your formula to a file or stream so you can load it later.
+    /// </remarks>
+    public void Serialize(BinaryWriter writer)
+    {
+        writer.Write((int)Type);
+        writer.Write(Convert.ToDouble(Value));
+        writer.Write(Left != null);
+        Left?.Serialize(writer);
+        writer.Write(Right != null);
+        Right?.Serialize(writer);
+    }
+
+    /// <summary>
+    /// Deserializes an expression tree from a binary reader.
+    /// </summary>
+    /// <param name="reader">The binary reader containing the serialized tree data.</param>
+    /// <returns>A new ExpressionTree instance created from the serialized data.</returns>
+    /// <remarks>
+    /// <b>For Beginners:</b> This method reads a saved expression tree from binary data and reconstructs it.
+    /// Think of it like opening a saved file that contains your mathematical formula.
+    /// </remarks>
+    public ExpressionTree<T, TInput, TOutput> Deserialize(BinaryReader reader)
+    {
+        ExpressionNodeType type = (ExpressionNodeType)reader.ReadInt32();
+        T value = NumOps.FromDouble(reader.ReadDouble());
+        bool hasLeft = reader.ReadBoolean();
+        ExpressionTree<T, TInput, TOutput>? left = hasLeft ? Deserialize(reader) : null;
+        bool hasRight = reader.ReadBoolean();
+        ExpressionTree<T, TInput, TOutput>? right = hasRight ? Deserialize(reader) : null;
+
+        return new ExpressionTree<T, TInput, TOutput>(type, value, left, right);
+    }
+
+    /// <summary>
+    /// Creates a modified version of this expression tree by applying random mutations.
+    /// </summary>
+    /// <param name="mutationRate">The probability (0.0 to 1.0) that a mutation will occur at each node.</param>
+    /// <returns>A new expression tree with mutations applied.</returns>
+    /// <remarks>
+    /// <b>For Beginners:</b> Mutation is like making small random changes to a formula to see if it improves.
+    /// For example, changing a "+" to a "*" or changing a constant from 2.5 to 3.1.
+    /// This is inspired by how genetic mutations work in nature and helps the AI explore different solutions.
+    /// </remarks>
+    public IFullModel<T, TInput, TOutput> Mutate(double mutationRate)
+    {
+        ExpressionTree<T, TInput, TOutput> mutatedTree = (ExpressionTree<T, TInput, TOutput>)Copy();
+
+        if (Rng.NextDouble() < mutationRate)
+        {
+            switch (Rng.Next(3))
+            {
+                case 0: // Change node type
+                    mutatedTree.Type = (ExpressionNodeType)Rng.Next(Enum.GetValues(typeof(ExpressionNodeType)).Length);
+                    break;
+                case 1: // Change value (for Constant or Variable nodes)
+                    if (mutatedTree.Type == ExpressionNodeType.Constant)
+                    {
+                        mutatedTree.Value = NumOps.FromDouble(Rng.NextDouble() * 10 - 5); // Random value between -5 and 5
+                    }
+                    else if (mutatedTree.Type == ExpressionNodeType.Variable)
+                    {
+                        mutatedTree.Value = NumOps.FromDouble(Rng.Next(10)); // Assume max 10 variables
+                    }
+                    break;
+                case 2: // Regenerate subtree
+                    int maxDepth = 3;
+                    mutatedTree = GenerateRandomTree(maxDepth);
+                    break;
+            }
+        }
+
+        // Recursively mutate children
+        if (mutatedTree.Left != null)
+        {
+            mutatedTree.Left = (ExpressionTree<T, TInput, TOutput>)mutatedTree.Left.Mutate(mutationRate);
+        }
+        if (mutatedTree.Right != null)
+        {
+            mutatedTree.Right = (ExpressionTree<T, TInput, TOutput>)mutatedTree.Right.Mutate(mutationRate);
+        }
+
+        return mutatedTree;
+    }
+
+    /// <summary>
+    /// Combines this expression tree with another to create a new "offspring" expression tree.
+    /// </summary>
+    /// <param name="other">The other expression tree to combine with.</param>
+    /// <param name="crossoverRate">The probability (0.0 to 1.0) that crossover will occur.</param>
+    /// <returns>A new expression tree that combines parts from both parent trees.</returns>
+    /// <remarks>
+    /// <b>For Beginners:</b> Crossover is like taking parts from two different formulas and combining them
+    /// to create a new formula. For example, if one formula is (x + 2) and another is (y * 3),
+    /// crossover might create (x * 3) by taking parts from each. This mimics how genetic traits
+    /// are passed from parents to children in nature.
+    /// </remarks>
+    public IFullModel<T, TInput, TOutput> Crossover(IFullModel<T, TInput, TOutput> other, double crossoverRate)
+    {
+        if (!(other is ExpressionTree<T, TInput, TOutput> otherTree))
+        {
+            throw new ArgumentException("Crossover can only be performed with another ExpressionTree.");
+        }
+
+        ExpressionTree<T, TInput, TOutput> offspring = (ExpressionTree<T, TInput, TOutput>)Copy();
+
+        if (Rng.NextDouble() < crossoverRate)
+        {
+            // Select a random subtree from the other parent
+            ExpressionTree<T, TInput, TOutput> selectedSubtree = SelectRandomSubtree(otherTree);
+
+            // Replace a random subtree in the offspring with the selected subtree
+            ReplaceRandomSubtree(offspring, selectedSubtree);
+        }
+
+        return offspring;
+    }
+
+    /// <summary>
+    /// Creates a deep copy of this expression tree.
+    /// </summary>
+    /// <returns>A new expression tree with the same structure and values as this one.</returns>
+    /// <remarks>
+    /// <b>For Beginners:</b> This creates an exact duplicate of the formula, like making a photocopy.
+    /// This is important because we often need to make changes to a formula without modifying the original.
+    /// </remarks>
+    public IFullModel<T, TInput, TOutput> Copy()
+    {
+        return new ExpressionTree<T, TInput, TOutput>(
+            Type,
+            Value,
+            Left?.Clone() as ExpressionTree<T, TInput, TOutput>,
+            Right?.Clone() as ExpressionTree<T, TInput, TOutput>
+        );
+    }
+
+    /// <summary>
+    /// Creates a random expression tree with a specified maximum depth.
+    /// </summary>
+    /// <param name="maxDepth">The maximum depth of the tree to generate.</param>
+    /// <returns>A randomly generated expression tree.</returns>
+    /// <remarks>
+    /// <b>For Beginners:</b> This creates a random mathematical formula with a limit on how complex it can be.
+    /// The maxDepth parameter controls this complexity - higher values allow for more complex formulas.
+    /// </remarks>
+    private ExpressionTree<T, TInput, TOutput> GenerateRandomTree(int maxDepth)
+    {
+        if (maxDepth == 0 || Rng.NextDouble() < 0.3) // 30% chance of leaf node
+        {
+            if (Rng.NextDouble() < 0.5)
+            {
+                return new ExpressionTree<T, TInput, TOutput>(ExpressionNodeType.Constant, NumOps.FromDouble(Rng.NextDouble() * 10 - 5));
+            }
+            else
+            {
+                return new ExpressionTree<T, TInput, TOutput>(ExpressionNodeType.Variable, NumOps.FromDouble(Rng.Next(10)));
+            }
+        }
+        else
+        {
+            ExpressionNodeType operationType = (ExpressionNodeType)Rng.Next(2, 6); // Add, Subtract, Multiply, or Divide
+            return new ExpressionTree<T, TInput, TOutput>(
+                operationType,
+                default,
+                GenerateRandomTree(maxDepth - 1),
+                GenerateRandomTree(maxDepth - 1)
+            );
+        }
+    }
+
+    /// <summary>
+    /// Selects a random subtree from the given expression tree.
+    /// </summary>
+    /// <param name="tree">The expression tree to select from.</param>
+    /// <returns>A randomly selected subtree.</returns>
+    /// <remarks>
+    /// <b>For Beginners:</b> This picks a random part of a formula. For example, in the formula (x + (y * 2)),
+    /// it might select the whole formula, just (y * 2), or even just y or 2.
+    /// </remarks>
+    private ExpressionTree<T, TInput, TOutput> SelectRandomSubtree(ExpressionTree<T, TInput, TOutput> tree)
+    {
+        if (tree.Left == null && tree.Right == null)
+        {
+            return tree;
+        }
+        else if (Rng.NextDouble() < 0.3) // 30% chance of selecting current node
+        {
+            return tree;
+        }
+        else
+        {
+            if (tree.Left != null && (tree.Right == null || Rng.NextDouble() < 0.5))
+            {
+                return SelectRandomSubtree(tree.Left);
+            }
+            else
+            {
+                return SelectRandomSubtree(tree.Right!);
+            }
+        }
+    }
+
+    /// <summary>
+    /// Replaces a random subtree in the given tree with the provided replacement subtree.
+    /// </summary>
+    /// <param name="tree">The tree to modify.</param>
+    /// <param name="replacement">The replacement subtree.</param>
+    /// <remarks>
+    /// <b>For Beginners:</b> This replaces a random part of a formula with a different part.
+    /// For example, in (x + y), it might replace y with (z * 2) to create (x + (z * 2)).
+    /// </remarks>
+    private void ReplaceRandomSubtree(ExpressionTree<T, TInput, TOutput> tree, ExpressionTree<T, TInput, TOutput> replacement)
+    {
+        if (Rng.NextDouble() < 0.3) // 30% chance of replacing current node
+        {
+            tree.Type = replacement.Type;
+            tree.Value = replacement.Value;
+            tree.Left = replacement.Left?.Clone() as ExpressionTree<T, TInput, TOutput>;
+            tree.Right = replacement.Right?.Clone() as ExpressionTree<T, TInput, TOutput>;
+        }
+        else
+        {
+            if (tree.Left != null && (tree.Right == null || Rng.NextDouble() < 0.5))
+            {
+                ReplaceRandomSubtree(tree.Left, replacement);
+            }
+            else if (tree.Right != null)
+            {
+                ReplaceRandomSubtree(tree.Right, replacement);
+            }
+        }
+    }
+
+    /// <summary>
+    /// Fits the expression tree to the provided training data.
+    /// </summary>
+    /// <param name="X">The input features matrix.</param>
+    /// <param name="y">The target values vector.</param>
+    /// <remarks>
+    /// <b>For Beginners:</b> For expression trees, "fitting" just checks if the formula can work with your data.
+    /// Unlike other AI models, the formula itself doesn't change during fitting - it's predefined by the tree structure.
+    /// </remarks>
+    public void Fit(Matrix<T> X, Vector<T> y)
+    {
+        // For ExpressionTree, Fit is the same as Train
+        Train(X, y);
+    }
+
+    /// <summary>
+    /// Trains the expression tree on the provided data.
+    /// </summary>
+    /// <param name="x">The input features matrix.</param>
+    /// <param name="y">The target values vector.</param>
+    /// <remarks>
+    /// <b>For Beginners:</b> For expression trees, "training" just validates that the formula can process your data.
+    /// The formula itself doesn't learn or change during training - it's predefined by the tree structure.
+    /// </remarks>
+    public void Train(Matrix<T> x, Vector<T> y)
+    {
+        // For ExpressionTree, we don't actually train the model
+        // The structure is defined by the tree, and we don't adjust it based on data
+        // However, we can use this method to validate that our tree can process the input
+        if (x.Columns < RequiredFeatureCount)
+        {
+            throw new ArgumentException($"Input matrix has {x.Columns} columns, but the model expects at least {RequiredFeatureCount} features.");
+        }
+    }
+
+    /// <summary>
+    /// Makes predictions using this expression tree for multiple input samples.
+    /// </summary>
+    /// <param name="input">A matrix where each row represents a sample and each column represents a feature.</param>
+    /// <returns>A vector containing the predicted values for each input sample.</returns>
+    /// <exception cref="ArgumentException">Thrown when the input matrix has incorrect dimensions.</exception>
+    /// <remarks>
+    /// <b>For Beginners:</b> This method takes your data (like height, weight, age values) and
+    /// runs each row through the mathematical formula represented by this tree to get predictions.
+    /// For example, if your tree represents "2x + y", and your input has values [3,4], the prediction would be 2*3 + 4 = 10.
+    ///
+    /// <b>Note:</b> If the input has more features than the model requires, the extra features are allowed but ignored.
+    /// Only the features up to RequiredFeatureCount are used in predictions. This flexibility supports transfer learning scenarios
+    /// where input data may contain additional features not used by this particular model.
+    /// </remarks>
+    public Vector<T> Predict(Matrix<T> input)
+    {
+        if (input.Columns < RequiredFeatureCount)
+        {
+            throw new ArgumentException($"Input matrix has {input.Columns} columns, but the model expects at least {RequiredFeatureCount} features.");
+        }
+
+        Vector<T> predictions = new(input.Rows);
+        for (int i = 0; i < input.Rows; i++)
+        {
+            predictions[i] = Evaluate(input.GetRow(i));
+        }
+
+        return predictions;
+    }
+
+    /// <summary>
+    /// Gets metadata about this expression tree model.
+    /// </summary>
+    /// <returns>A ModelMetadata object containing information about this model.</returns>
+    /// <remarks>
+    /// <b>For Beginners:</b> This provides useful information about your formula, like how complex it is
+    /// and how many input variables it needs. Think of it as a summary sheet about your mathematical model.
+    /// </remarks>
+    public override ModelMetadata<T> GetModelMetadata()
+    {
+        return new ModelMetadata<T>
+        {
+            FeatureCount = FeatureCount,
+            Complexity = Complexity,
+            Description = ToString(),
+            AdditionalInfo = new Dictionary<string, object>
+            {
+                { "NodeType", Type },
+                { "HasLeftChild", Left != null },
+                { "HasRightChild", Right != null }
+            }
+        };
+    }
+
+    /// <summary>
+    /// Converts this expression tree to a byte array for storage or transmission.
+    /// </summary>
+    /// <returns>A byte array representing the serialized expression tree.</returns>
+    /// <remarks>
+    /// <b>For Beginners:</b> This converts your mathematical formula into a compact format that can be
+    /// saved to a file or sent over the internet. It's like zipping up your formula for storage.
+    /// </remarks>
+    /// <summary>
+    /// Declares this tree as a node graph so the base carries it, rather than the hand-written
+    /// pair that used to walk it.
+    /// </summary>
+    /// <param name="state">The registry to declare into.</param>
+    /// <remarks>
+    /// The fields mirror the recursive <c>Serialize(BinaryWriter)</c> below exactly - node type,
+    /// value, then left and right - so the payload describes the same tree it always did. The
+    /// setters reach private setters legitimately because this runs inside the type that declares
+    /// them. <c>Parent</c> is deliberately absent, as it was from the hand-written walk: it is a
+    /// back-reference implied by the structure, and persisting it would encode the same edge twice.
+    /// Restoring through SetLeft/SetRight rather than the properties re-links it, which the
+    /// hand-written pair did not do - it assigned Left and Right directly and left every restored
+    /// node's Parent null.
+    /// </remarks>
+    protected override void RegisterState(ModelStateRegistry<T> state)
+    {
+        base.RegisterState(state);
+
+        state.DeclareGraph<ExpressionTree<T, TInput, TOutput>>(
+            "ExpressionTree.Root",
+            () => this,
+            root =>
+            {
+                if (root is null) return;
+                Type = root.Type;
+                Value = root.Value;
+                Left = root.Left;
+                Right = root.Right;
+            },
+            node => node
+                .Create(() => new ExpressionTree<T, TInput, TOutput>(ExpressionNodeType.Constant))
+                .Int32(n => (int)n.Type, (n, v) => n.Type = (ExpressionNodeType)v)
+                .Scalar(n => n.Value, (n, v) => n.Value = v)
+                .Child(n => n.Left, (n, c) => n.SetLeft(c))
+                .Child(n => n.Right, (n, c) => n.SetRight(c)));
+    }
+
+    /// <summary>
+    /// Gets a list of all nodes in this expression tree.
+    /// </summary>
+    /// <returns>A list containing all nodes in the tree.</returns>
+    /// <remarks>
+    /// <b>For Beginners:</b> This collects all the parts of your formula into a list.
+    /// For example, if your formula is (x + 2) * y, this would give you a list containing:
+    /// the multiplication operation, the addition operation, the x variable, the constant 2, and the y variable.
+    /// </remarks>
+    public List<ExpressionTree<T, TInput, TOutput>> GetAllNodes()
+    {
+        var nodes = new List<ExpressionTree<T, TInput, TOutput>>();
+        CollectNodes(this, nodes);
+
+        return nodes;
+    }
+
+    /// <summary>
+    /// Helper method that recursively collects all nodes in the tree.
+    /// </summary>
+    /// <param name="node">The current node being processed.</param>
+    /// <param name="nodes">The list to add nodes to.</param>
+    /// <remarks>
+    /// <b>For Beginners:</b> This is a helper method that walks through every part of your formula
+    /// and adds each piece to a list. It uses recursion (calling itself) to visit every branch of the tree.
+    /// </remarks>
+    private void CollectNodes(ExpressionTree<T, TInput, TOutput>? node, List<ExpressionTree<T, TInput, TOutput>> nodes)
+    {
+        if (node == null) return;
+        nodes.Add(node);
+        CollectNodes(node.Left, nodes);
+        CollectNodes(node.Right, nodes);
+    }
+
+    /// <summary>
+    /// Finds a node in the tree by its unique identifier.
+    /// </summary>
+    /// <param name="id">The unique identifier of the node to find.</param>
+    /// <returns>The node with the specified ID, or null if no such node exists.</returns>
+    /// <remarks>
+    /// <b>For Beginners:</b> Every part of your formula has a unique ID number.
+    /// This method helps you find a specific part by its ID, like finding a person by their social security number.
+    /// </remarks>
+    public ExpressionTree<T, TInput, TOutput>? FindNodeById(int id)
+    {
+        return GetAllNodes().FirstOrDefault(n => n.Id == id);
+    }
+
+    /// <summary>
+    /// Gets the unique identifier for this node.
+    /// </summary>
+    /// <remarks>
+    /// <b>For Beginners:</b> This is a unique number assigned to each part of your formula,
+    /// making it easy to identify and reference specific parts of the expression tree.
+    /// </remarks>
+    public int Id { get; } = Interlocked.Increment(ref _nextId);
+
+    /// <summary>
+    /// Static counter used to generate unique IDs for expression tree nodes.
+    /// </summary>
+    private static int _nextId;
+
+    /// <summary>
+    /// Creates a new expression tree with updated coefficient values.
+    /// </summary>
+    /// <param name="newCoefficients">The new coefficient values to use.</param>
+    /// <returns>A new expression tree with the updated coefficients.</returns>
+    /// <exception cref="ArgumentException">Thrown when the number of new coefficients doesn't match the current number.</exception>
+    /// <remarks>
+    /// <b>For Beginners:</b> This changes the constant numbers in your formula without changing its structure.
+    /// For example, if your formula is "2x + 3", this might change it to "4x + 1" by updating the coefficients 2 and 3.
+    /// This is useful when fine-tuning a model to make better predictions.
+    /// </remarks>
+    public IFullModel<T, TInput, TOutput> UpdateCoefficients(Vector<T> newCoefficients)
+    {
+        if (newCoefficients.Length != this.Coefficients.Length)
+        {
+            throw new ArgumentException($"The number of new coefficients ({newCoefficients.Length}) must match the current number of coefficients ({this.Coefficients.Length}).");
+        }
+
+        ExpressionTree<T, TInput, TOutput> updatedTree = (ExpressionTree<T, TInput, TOutput>)this.Clone();
+        int coefficientIndex = 0;
+
+        void UpdateConstantNodes(ExpressionTree<T, TInput, TOutput> node)
+        {
+            if (node.Type == ExpressionNodeType.Constant)
+            {
+                node.Value = newCoefficients[coefficientIndex++];
+            }
+            if (node.Left != null)
+            {
+                UpdateConstantNodes(node.Left);
+            }
+            if (node.Right != null)
+            {
+                UpdateConstantNodes(node.Right);
+            }
+        }
+
+        UpdateConstantNodes(updatedTree);
+
+        return updatedTree;
+    }
+
+    /// <summary>
+    /// The tree's parameters are the values of its Constant nodes, in traversal order.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// This replaces three overrides that did not agree. ParameterCount counted Constant nodes and
+    /// SetParameters wrote Constant nodes, but GetParameters returned <c>Coefficients</c> -- a
+    /// different vector of unrelated length. So the count described the tree, the vector described
+    /// something else, and a restore round-trip could not be correct for both.
+    /// </para>
+    /// <para>
+    /// One declared source removes the possibility: the count, the vector and the restore all walk
+    /// the same nodes in the same order. Coefficients remains available in its own right; it simply
+    /// is not the parameter surface.
+    /// </para>
+    /// </remarks>
+    protected override void RegisterComponents()
+    {
+        base.RegisterComponents();
+        RegisterParameterComponent(new DelegatingParameterSource<T>(
+            () => CollectConstantNodes().Count,
+            () =>
+            {
+                var nodes = CollectConstantNodes();
+                var values = new Vector<T>(nodes.Count);
+                for (int i = 0; i < nodes.Count; i++) values[i] = nodes[i].Value;
+                return values;
+            },
+            values =>
+            {
+                var nodes = CollectConstantNodes();
+                for (int i = 0; i < nodes.Count && i < values.Length; i++)
+                {
+                    nodes[i].SetValue(values[i]);
+                }
+            }));
+    }
+
+    /// <summary>Constant nodes in the same traversal order the count and the restore use.</summary>
+    private List<ExpressionTree<T, TInput, TOutput>> CollectConstantNodes()
+    {
+        var found = new List<ExpressionTree<T, TInput, TOutput>>();
+        void Walk(ExpressionTree<T, TInput, TOutput>? node)
+        {
+            if (node is null) return;
+            if (node.Type == ExpressionNodeType.Constant) found.Add(node);
+            Walk(node.Left);
+            Walk(node.Right);
+        }
+        Walk(this);
+        return found;
+    }
+
+    // Replaced by the declared parameter source below. Removed under AIDN082.
+
+    /// <summary>
+    /// Creates a new expression tree with updated parameters.
+    /// </summary>
+    /// <param name="parameters">The new parameter values to use.</param>
+    /// <returns>A new expression tree with the updated parameters.</returns>
+    /// <remarks>
+    /// <b>For Beginners:</b> This replaces all the constant numbers in your formula 
+    /// with new values. For example, changing "2x + 3" to "4x + 1" by providing [4, 1]
+    /// as the new parameters. The structure of the formula stays the same.
+    /// </remarks>
+    public override IFullModel<T, TInput, TOutput> WithParameters(Vector<T> parameters)
+    {
+        // This is equivalent to UpdateCoefficients
+        return UpdateCoefficients(parameters);
+    }
+
+    /// <summary>
+    /// Gets the indices of all features (variables) used in this expression tree.
+    /// </summary>
+    /// <returns>A collection of feature indices.</returns>
+    /// <remarks>
+    /// <b>For Beginners:</b> This tells you which input variables are actually used in your formula.
+    /// For example, if your formula only uses x[0] and x[2], this returns [0, 2], showing that
+    /// the formula uses the first and third variables but not the second one.
+    /// </remarks>
+    public override IEnumerable<int> GetActiveFeatureIndices()
+    {
+        HashSet<int> activeIndices = new();
+
+        void CollectFeatureIndices(ExpressionTree<T, TInput, TOutput> node)
+        {
+            if (node.Type == ExpressionNodeType.Variable)
+            {
+                activeIndices.Add(NumOps.ToInt32(node.Value));
+            }
+
+            if (node.Left != null)
+            {
+                CollectFeatureIndices(node.Left);
+            }
+
+            if (node.Right != null)
+            {
+                CollectFeatureIndices(node.Right);
+            }
+        }
+
+        CollectFeatureIndices(this);
+        return activeIndices;
+    }
+
+    /// <summary>
+    /// Gets the feature importance scores for this expression tree.
+    /// </summary>
+    /// <returns>A dictionary mapping feature names to importance scores.</returns>
+    /// <remarks>
+    /// <b>For Beginners:</b> Feature importance tells you which input variables matter most in your formula.
+    /// For expression trees, importance is calculated by counting how many times each variable appears in the formula.
+    /// Variables that appear more frequently are considered more important.
+    /// </remarks>
+    public override Dictionary<string, T> GetFeatureImportance()
+    {
+        // Count occurrences of each feature in the tree
+        Dictionary<int, int> featureCounts = new();
+
+        void CountFeatureOccurrences(ExpressionTree<T, TInput, TOutput> node)
+        {
+            if (node == null) return;
+
+            if (node.Type == ExpressionNodeType.Variable)
+            {
+                int featureIndex = NumOps.ToInt32(node.Value);
+                if (featureCounts.ContainsKey(featureIndex))
+                {
+                    featureCounts[featureIndex]++;
+                }
+                else
+                {
+                    featureCounts[featureIndex] = 1;
+                }
+            }
+
+            if (node.Left != null)
+            {
+                CountFeatureOccurrences(node.Left);
+            }
+
+            if (node.Right != null)
+            {
+                CountFeatureOccurrences(node.Right);
+            }
+        }
+
+        CountFeatureOccurrences(this);
+
+        // Convert counts to importance scores (normalized by total occurrences)
+        int totalCount = 0;
+        foreach (var count in featureCounts.Values)
+        {
+            totalCount += count;
+        }
+
+        Dictionary<string, T> importance = new();
+        if (totalCount > 0)
+        {
+            foreach (var kvp in featureCounts)
+            {
+                string featureName = $"x[{kvp.Key}]";
+                double normalizedImportance = (double)kvp.Value / totalCount;
+                importance[featureName] = NumOps.FromDouble(normalizedImportance);
+            }
+        }
+
+        return importance;
+    }
+
+    /// <summary>
+    /// Sets the active feature indices for this expression tree.
+    /// </summary>
+    /// <param name="featureIndices">The feature indices to use.</param>
+    /// <remarks>
+    /// <b>For Beginners:</b> This restricts the formula to only use specific input variables.
+    /// Any variables in the tree that are not in the active set will be replaced with constant zero values.
+    /// This is useful for feature selection and understanding which variables are most important.
+    /// </remarks>
+    public override void SetActiveFeatureIndices(IEnumerable<int> featureIndices)
+    {
+        if (featureIndices == null)
+        {
+            throw new ArgumentNullException(nameof(featureIndices));
+        }
+
+        HashSet<int> activeSet = new(featureIndices);
+
+        void DeactivateInactiveFeatures(ExpressionTree<T, TInput, TOutput> node)
+        {
+            if (node == null) return;
+
+            // If this is a variable node and it's not in the active set, replace it with zero
+            if (node.Type == ExpressionNodeType.Variable)
+            {
+                int featureIndex = NumOps.ToInt32(node.Value);
+                if (!activeSet.Contains(featureIndex))
+                {
+                    node.SetType(ExpressionNodeType.Constant);
+                    node.SetValue(NumOps.Zero);
+                }
+            }
+
+            // Recursively process children
+            if (node.Left != null)
+            {
+                DeactivateInactiveFeatures(node.Left);
+            }
+
+            if (node.Right != null)
+            {
+                DeactivateInactiveFeatures(node.Right);
+            }
+        }
+
+        DeactivateInactiveFeatures(this);
+
+        // Clear the cached feature counts since we've modified the tree
+        _featureCount = 0;
+        _requiredFeatureCount = 0;
+    }
+
+    /// <summary>
+    /// Trains the expression tree on a single input-output pair.
+    /// </summary>
+    /// <param name="input">The input data (Vector, Matrix, or Tensor).</param>
+    /// <param name="expectedOutput">The expected output value.</param>
+    /// <remarks>
+    /// <b>For Beginners:</b> For expression trees, training doesn't actually change the formula.
+    /// This method validates that the formula can process your input data correctly.
+    /// </remarks>
+    public override void Train(TInput input, TOutput expectedOutput)
+    {
+        // For expression trees, we primarily validate input compatibility
+        if (input is Matrix<T> matrix)
+        {
+            ValidateMatrixFeatures(matrix);
+        }
+        else if (input is Vector<T> vector)
+        {
+            ValidateVectorFeatures(vector);
+        }
+        else if (input is Tensor<T> tensor)
+        {
+            ValidateTensorFeatures(tensor);
+        }
+        else
+        {
+            throw new ArgumentException($"Unsupported input type: {input?.GetType().Name ?? "null"}. Expected Matrix<T>, Vector<T>, or Tensor<T>.");
+        }
+    }
+
+    /// <summary>
+    /// Computes gradients of the loss function with respect to model parameters WITHOUT updating parameters.
+    /// </summary>
+    /// <param name="input">The input data.</param>
+    /// <param name="target">The target/expected output.</param>
+    /// <param name="lossFunction">The loss function to use. If null, uses the model's default loss function.</param>
+    /// <returns>A vector containing gradients with respect to all model parameters (constants in the expression tree).</returns>
+    /// <exception cref="ArgumentNullException">If input or target is null.</exception>
+    /// <remarks>
+    /// <para>
+    /// This method computes gradients using numerical differentiation (finite differences).
+    /// For each constant in the expression tree, it slightly perturbs the value and
+    /// measures how the loss changes, approximating the gradient.
+    /// </para>
+    /// <para><b>For Beginners:</b>
+    /// This calculates how to adjust each constant in your mathematical formula to reduce error.
+    /// Since expression trees are symbolic, we use a numerical approximation:
+    /// we slightly change each constant and see how much the error changes.
+    /// </para>
+    /// </remarks>
+    public override Vector<T> ComputeGradients(TInput input, TOutput target, ILossFunction<T>? lossFunction = null)
+    {
+        if (input == null)
+            throw new ArgumentNullException(nameof(input));
+        if (target == null)
+            throw new ArgumentNullException(nameof(target));
+
+        var loss = lossFunction ?? DefaultLossFunction;
+        var parameters = Coefficients;
+        var gradients = new Vector<T>(parameters.Length);
+
+        // Small epsilon for finite differences
+        T epsilon = NumOps.FromDouble(1e-7);
+
+        // Compute loss at current parameters
+        var currentPrediction = Predict(input);
+        Vector<T> currentPredVec = ConvertOutputToVector(currentPrediction);
+        Vector<T> targetVec = ConvertOutputToVector(target);
+        T currentLoss = loss.CalculateLoss(currentPredVec, targetVec);
+
+        // Compute gradient for each parameter using finite differences
+        for (int i = 0; i < parameters.Length; i++)
+        {
+            // Save original value
+            T originalValue = parameters[i];
+
+            // Perturb parameter forward
+            parameters[i] = NumOps.Add(originalValue, epsilon);
+            SetParameters(parameters);  // ✅ CRITICAL: Use SetParameters, NOT UpdateCoefficients
+            var forwardPrediction = Predict(input);
+            Vector<T> forwardPredVec = ConvertOutputToVector(forwardPrediction);
+            T forwardLoss = loss.CalculateLoss(forwardPredVec, targetVec);
+
+            // Compute gradient: (f(x+ε) - f(x)) / ε
+            T gradient = NumOps.Divide(NumOps.Subtract(forwardLoss, currentLoss), epsilon);
+            gradients[i] = gradient;
+
+            // Restore original value
+            parameters[i] = originalValue;
+            SetParameters(parameters);  // ✅ Restore original
+        }
+
+        return gradients;
+    }
+
+    /// <summary>
+    /// Applies pre-computed gradients to update the model parameters (constants in the expression tree).
+    /// </summary>
+    /// <param name="gradients">The gradient vector to apply.</param>
+    /// <param name="learningRate">The learning rate for the update.</param>
+    /// <exception cref="ArgumentNullException">If gradients is null.</exception>
+    /// <exception cref="ArgumentException">If gradient vector length doesn't match parameter count.</exception>
+    /// <remarks>
+    /// <para>
+    /// Updates constants using: constant = constant - learningRate * gradient
+    /// </para>
+    /// <para><b>For Beginners:</b>
+    /// After computing gradients (seeing which direction to adjust each constant),
+    /// this method actually adjusts them. The learning rate controls how big of an adjustment to make.
+    /// </para>
+    /// </remarks>
+    public override void ApplyGradients(Vector<T> gradients, T learningRate)
+    {
+        if (gradients == null)
+            throw new ArgumentNullException(nameof(gradients));
+
+        var parameters = Coefficients;
+
+        if (gradients.Length != parameters.Length)
+        {
+            throw new ArgumentException(
+                $"Gradient vector length ({gradients.Length}) must match parameter count ({parameters.Length})",
+                nameof(gradients));
+        }
+
+        // Apply gradient descent: params = params - learningRate * gradients
+        // Vectorized SGD
+        parameters = (Vector<T>)Engine.Subtract(parameters, Engine.Multiply(gradients, learningRate));
+
+        SetParameters(parameters);
+    }
+
+    /// <summary>
+    /// Helper method to convert output to Vector<T> for loss computation.
+    /// </summary>
+    private Vector<T> ConvertOutputToVector(TOutput output)
+    {
+        if (output is Vector<T> vec)
+            return vec;
+        if (output is T scalar)
+            return new Vector<T>(new[] { scalar });
+        if (output is Matrix<T> mat)
+            return mat.ToVector();
+
+        // Try to convert using reflection if needed
+        throw new InvalidOperationException($"Cannot convert output of type {typeof(TOutput).Name} to Vector<T> for gradient computation.");
+    }
+
+    /// <summary>
+    /// Makes a prediction for an input example.
+    /// </summary>
+    /// <param name="input">The input data (Vector, Matrix, or Tensor).</param>
+    /// <returns>The predicted output.</returns>
+    /// <remarks>
+    /// <b>For Beginners:</b> This method applies your mathematical formula to the input data
+    /// to calculate a prediction. It handles different types of inputs (vectors, matrices, or tensors).
+    /// </remarks>
+    public override TOutput Predict(TInput input)
+    {
+        if (input is Matrix<T> matrix)
+        {
+            ValidateMatrixFeatures(matrix);
+            Vector<T> predictions = PredictMatrix(matrix);
+
+            // Try to convert the result to TOutput
+            if (predictions is TOutput typedResult)
+            {
+                return typedResult;
+            }
+            else if (typeof(TOutput) == typeof(object))
+            {
+                return (TOutput)(object)predictions;
+            }
+
+            throw new InvalidOperationException($"Cannot convert prediction vector to {typeof(TOutput).Name}.");
+        }
+        else if (input is Tensor<T> tensor)
+        {
+            ValidateTensorFeatures(tensor);
+            Vector<T> predictions = PredictTensor(tensor);
+
+            // Try to convert the result to TOutput
+            if (predictions is TOutput typedResult)
+            {
+                return typedResult;
+            }
+            else if (typeof(TOutput) == typeof(object))
+            {
+                return (TOutput)(object)predictions;
+            }
+
+            throw new InvalidOperationException($"Cannot convert prediction vector to {typeof(TOutput).Name}.");
+        }
+
+        throw new ArgumentException($"Unsupported input type: {input?.GetType().Name ?? "null"}. Expected Matrix<T>, Vector<T>, or Tensor<T>.");
+    }
+
+    /// <summary>
+    /// Validates that a matrix has compatible features for this expression tree.
+    /// </summary>
+    /// <param name="matrix">The matrix to validate.</param>
+    private void ValidateMatrixFeatures(Matrix<T> matrix)
+    {
+        if (matrix.Columns < RequiredFeatureCount)
+        {
+            throw new ArgumentException($"Input matrix has {matrix.Columns} columns, but the model requires at least {RequiredFeatureCount} features.");
+        }
+    }
+
+    /// <summary>
+    /// Validates that a vector has compatible features for this expression tree.
+    /// </summary>
+    /// <param name="vector">The vector to validate.</param>
+    private void ValidateVectorFeatures(Vector<T> vector)
+    {
+        if (vector.Length < RequiredFeatureCount)
+        {
+            throw new ArgumentException($"Input vector has {vector.Length} elements, but the model requires at least {RequiredFeatureCount} features.");
+        }
+    }
+
+    /// <summary>
+    /// Validates that a tensor has compatible features for this expression tree.
+    /// </summary>
+    /// <param name="tensor">The tensor to validate.</param>
+    private void ValidateTensorFeatures(Tensor<T> tensor)
+    {
+        if (tensor.Shape.Length < 1 || tensor.Shape[tensor.Shape.Length - 1] < RequiredFeatureCount)
+        {
+            throw new ArgumentException($"Input tensor's last dimension is {(tensor.Shape.Length > 0 ? tensor.Shape[tensor.Shape.Length - 1] : 0)}, " +
+                $"but the model requires at least {RequiredFeatureCount} features.");
+        }
+    }
+
+    /// <summary>
+    /// Makes predictions for all rows in a matrix.
+    /// </summary>
+    /// <param name="matrix">The input matrix, where each row is a sample.</param>
+    /// <returns>A vector containing predictions for each row.</returns>
+    private Vector<T> PredictMatrix(Matrix<T> matrix)
+    {
+        Vector<T> predictions = new Vector<T>(matrix.Rows);
+        for (int i = 0; i < matrix.Rows; i++)
+        {
+            predictions[i] = Evaluate(matrix.GetRow(i));
+        }
+        return predictions;
+    }
+
+    /// <summary>
+    /// Makes predictions for all samples in a tensor.
+    /// </summary>
+    /// <param name="tensor">The input tensor.</param>
+    /// <returns>A vector containing predictions for each sample.</returns>
+    private Vector<T> PredictTensor(Tensor<T> tensor)
+    {
+        // Calculate the batch size (product of all dimensions except the last one)
+        int batchSize = 1;
+        for (int i = 0; i < tensor.Shape.Length - 1; i++)
+        {
+            batchSize *= tensor.Shape[i];
+        }
+
+        Vector<T> predictions = new Vector<T>(batchSize);
+        for (int i = 0; i < batchSize; i++)
+        {
+            // Extract vector for this batch item using the Flatten and Slice methods
+            // First, flatten the tensor then extract the appropriate slice
+            Vector<T> flatTensor = tensor.ToVector();
+            int featureSize = tensor.Shape[tensor.Shape.Length - 1];
+            int startIndex = i * featureSize;
+
+            // Create a vector from the slice
+            Vector<T> inputVector = new Vector<T>(featureSize);
+            for (int j = 0; j < featureSize; j++)
+            {
+                inputVector[j] = flatTensor[startIndex + j];
+            }
+
+            predictions[i] = Evaluate(inputVector);
+        }
+
+        return predictions;
+    }
+
+    /// <summary>
+    /// Gets a vector containing all coefficient values in this expression tree.
+    /// </summary>
+    /// <remarks>
+    /// <b>For Beginners:</b> This collects all the constant numbers from your formula into a list.
+    /// For example, if your formula is "2x + 3y + 5", this would give you [2, 3, 5].
+    /// These numbers are called "coefficients" and are important when optimizing your model.
+    /// </remarks>
+    public Vector<T> Coefficients
+    {
+        get
+        {
+            List<T> coefficients = new List<T>();
+
+            void CollectCoefficients(ExpressionTree<T, TInput, TOutput> node)
+            {
+                if (node.Type == ExpressionNodeType.Constant)
+                {
+                    coefficients.Add(node.Value);
+                }
+                if (node.Left != null)
+                {
+                    CollectCoefficients(node.Left);
+                }
+                if (node.Right != null)
+                {
+                    CollectCoefficients(node.Right);
+                }
+            }
+
+            CollectCoefficients(this);
+            return new Vector<T>(coefficients.ToArray());
+        }
+    }
+
+    // Replaced by the declared parameter source below. Removed under AIDN082.
+
+    // Replaced by the declared parameter source below. Removed under AIDN082.
+
+    /// <summary>
+    /// Saves the expression tree model to a file.
+    /// </summary>
+    /// <param name="filePath">The path where the model should be saved.</param>
+    /// <remarks>
+    /// <b>For Beginners:</b> This saves your mathematical formula to a file so you can load it later
+    /// without having to recreate it. The file contains the tree structure, all node types, and values.
+    /// </remarks>
+    public override void SaveModel(string filePath)
+    {
+        byte[] serializedData = Serialize();
+        File.WriteAllBytes(filePath, serializedData);
+    }
+
+    /// <summary>
+    /// Loads an expression tree model from a file.
+    /// </summary>
+    /// <param name="filePath">The path to the file containing the saved model.</param>
+    /// <remarks>
+    /// <b>For Beginners:</b> This loads a previously saved formula from a file, allowing you to
+    /// reuse it without recreating it. The loaded formula can immediately be used for predictions.
+    /// </remarks>
+    public override void LoadModel(string filePath)
+    {
+        byte[] serializedData = File.ReadAllBytes(filePath);
+        Deserialize(serializedData);
+    }
+
+    /// <summary>
+    /// Saves the expression tree's current state (structure and values) to a stream.
+    /// </summary>
+    /// <param name="stream">The stream to write the expression tree state to.</param>
+    /// <remarks>
+    /// <para>
+    /// This method serializes the complete expression tree structure, including all node types,
+    /// values, and connections. It uses the existing Serialize method and writes the data
+    /// to the provided stream.
+    /// </para>
+    /// <para><b>For Beginners:</b> This is like creating a snapshot of your mathematical formula.
+    ///
+    /// When you call SaveState:
+    /// - The entire tree structure is written to the stream
+    /// - All node types (constants, variables, operations) are preserved
+    /// - All values and connections are saved
+    ///
+    /// This is particularly useful for:
+    /// - Checkpointing during evolutionary algorithm training
+    /// - Knowledge distillation with symbolic models
+    /// - Saving the best formula found during optimization
+    /// - Creating formula ensembles
+    ///
+    /// You can later use LoadState to restore the formula to this exact state.
+    /// </para>
+    /// </remarks>
+    /// <exception cref="ArgumentNullException">Thrown when stream is null.</exception>
+    /// <exception cref="IOException">Thrown when there's an error writing to the stream.</exception>
+    public override void SaveState(Stream stream)
+    {
+        if (stream == null)
+            throw new ArgumentNullException(nameof(stream));
+
+        if (!stream.CanWrite)
+            throw new ArgumentException("Stream must be writable.", nameof(stream));
+
+        try
+        {
+            var data = this.Serialize();
+            stream.Write(data, 0, data.Length);
+            stream.Flush();
+        }
+        catch (IOException ex)
+        {
+            throw new IOException($"Failed to save expression tree state to stream: {ex.Message}", ex);
+        }
+        catch (Exception ex)
+        {
+            throw new InvalidOperationException($"Unexpected error while saving expression tree state: {ex.Message}", ex);
+        }
+    }
+
+    /// <summary>
+    /// Loads the expression tree's state (structure and values) from a stream.
+    /// </summary>
+    /// <param name="stream">The stream to read the expression tree state from.</param>
+    /// <remarks>
+    /// <para>
+    /// This method deserializes expression tree state that was previously saved with SaveState,
+    /// restoring the complete tree structure, node types, values, and connections.
+    /// It uses the existing Deserialize method after reading data from the stream.
+    /// </para>
+    /// <para><b>For Beginners:</b> This is like loading a saved snapshot of your mathematical formula.
+    ///
+    /// When you call LoadState:
+    /// - The tree structure is read from the stream
+    /// - All node types and values are restored
+    /// - The formula becomes identical to when SaveState was called
+    ///
+    /// After loading, the formula can:
+    /// - Make predictions using the restored structure
+    /// - Continue evolving during optimization
+    /// - Be used for symbolic regression or genetic programming
+    ///
+    /// This is essential for:
+    /// - Resuming interrupted evolutionary training
+    /// - Loading the best formula after optimization
+    /// - Deploying symbolic models to production
+    /// - Knowledge distillation with interpretable models
+    /// </para>
+    /// </remarks>
+    /// <exception cref="ArgumentNullException">Thrown when stream is null.</exception>
+    /// <exception cref="IOException">Thrown when there's an error reading from the stream.</exception>
+    /// <exception cref="InvalidOperationException">Thrown when the stream contains invalid or incompatible data.</exception>
+    public override void LoadState(Stream stream)
+    {
+        if (stream == null)
+            throw new ArgumentNullException(nameof(stream));
+
+        if (!stream.CanRead)
+            throw new ArgumentException("Stream must be readable.", nameof(stream));
+
+        try
+        {
+            using var ms = new MemoryStream();
+            stream.CopyTo(ms);
+            var data = ms.ToArray();
+
+            if (data.Length == 0)
+                throw new InvalidOperationException("Stream contains no data.");
+
+            this.Deserialize(data);
+        }
+        catch (IOException ex)
+        {
+            throw new IOException($"Failed to read expression tree state from stream: {ex.Message}", ex);
+        }
+        catch (InvalidOperationException)
+        {
+            // Re-throw InvalidOperationException from Deserialize
+            throw;
+        }
+        catch (Exception ex)
+        {
+            throw new InvalidOperationException(
+                $"Failed to deserialize expression tree state. The stream may contain corrupted or incompatible data: {ex.Message}", ex);
+        }
+    }
+
+}
diff --git a/src/LoRA/Adapters/AdaLoRAAdapter.cs b/src/LoRA/Adapters/AdaLoRAAdapter.cs
index 200d0c3ee4..2542fa69e5 100644
--- a/src/LoRA/Adapters/AdaLoRAAdapter.cs
+++ b/src/LoRA/Adapters/AdaLoRAAdapter.cs
@@ -42,7 +42,7 @@ namespace AiDotNet.LoRA.Adapters;
 /// https://arxiv.org/abs/2303.10512
 /// </para>
 /// </remarks>
-public class AdaLoRAAdapter<T> : LoRAAdapterBase<T>
+public partial class AdaLoRAAdapter<T> : LoRAAdapterBase<T>
 {
     /// <summary>
     /// Static random number generator for thread-safe initialization.
@@ -81,6 +81,7 @@ public class AdaLoRAAdapter<T> : LoRAAdapterBase<T>
     /// We keep the high-scoring components and prune the low-scoring ones.
     /// </para>
     /// </remarks>
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T> _importanceScores;
 
     /// <summary>
diff --git a/src/LoRA/Adapters/DVoRAAdapter.cs b/src/LoRA/Adapters/DVoRAAdapter.cs
index 9235e8e0ce..78dd4e74c7 100644
--- a/src/LoRA/Adapters/DVoRAAdapter.cs
+++ b/src/LoRA/Adapters/DVoRAAdapter.cs
@@ -87,6 +87,7 @@ public partial class DVoRAAdapter<T> : LoRAAdapterBase<T>
     /// It is NEVER trained - it remains frozen at its random initialization values.
     /// This is the VeRA component of DVoRA.
     /// </remarks>
+    [AiDotNet.Attributes.TrainableParameter]
     private static Matrix<T>? _sharedMatrixA;
 
     /// <summary>
@@ -97,6 +98,7 @@ public partial class DVoRAAdapter<T> : LoRAAdapterBase<T>
     /// It is NEVER trained - it remains frozen at its random initialization values.
     /// This is the VeRA component of DVoRA.
     /// </remarks>
+    [AiDotNet.Attributes.TrainableParameter]
     private static Matrix<T>? _sharedMatrixB;
 
     /// <summary>
diff --git a/src/LoRA/Adapters/DeltaLoRAAdapter.cs b/src/LoRA/Adapters/DeltaLoRAAdapter.cs
index 418a3b7fbe..1fdad8d59c 100644
--- a/src/LoRA/Adapters/DeltaLoRAAdapter.cs
+++ b/src/LoRA/Adapters/DeltaLoRAAdapter.cs
@@ -55,6 +55,7 @@ public partial class DeltaLoRAAdapter<T> : LoRAAdapterBase<T>
     /// Instead of "what are the weights", it tracks "how much have they changed".
     /// </para>
     /// </remarks>
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _deltaWeights;
 
     /// <summary>
@@ -101,16 +102,19 @@ public partial class DeltaLoRAAdapter<T> : LoRAAdapterBase<T>
     /// When gradients change direction, velocity slows down, preventing oscillation.
     /// </para>
     /// </remarks>
+    [AiDotNet.Attributes.TrainableParameter]
     private Matrix<T> _velocity;
 
     /// <summary>
     /// Gradients for the delta weights computed during backpropagation.
     /// </summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private Matrix<T>? _deltaGradients;
 
     /// <summary>
     /// Stored input from the forward pass, needed for gradient computation.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastInput;
 
     /// <summary>
diff --git a/src/LoRA/Adapters/DenseLoRAAdapter.cs b/src/LoRA/Adapters/DenseLoRAAdapter.cs
index 531df379bf..f653a5dd03 100644
--- a/src/LoRA/Adapters/DenseLoRAAdapter.cs
+++ b/src/LoRA/Adapters/DenseLoRAAdapter.cs
@@ -30,7 +30,7 @@ namespace AiDotNet.LoRA.Adapters;
 /// (frozen) reduces trainable parameters from 1,000,000 to just 16,000!
 /// </para>
 /// </remarks>
-public class DenseLoRAAdapter<T> : LoRAAdapterBase<T>
+public partial class DenseLoRAAdapter<T> : LoRAAdapterBase<T>
 {
     /// <summary>
     /// Initializes a new Dense LoRA adapter wrapping an existing Dense or FullyConnected layer.
@@ -71,6 +71,9 @@ public DenseLoRAAdapter(ILayer<T> baseLayer, int rank, double alpha = -1, bool f
         // restore supplies authoritative shape information through the base implementation.
     }
 
+    /// <summary>Construction state: the 'inputSize' the layer was built with.</summary>
+    private readonly int _inputSize;
+
     /// <summary>
     /// Initializes a new Dense LoRA adapter wrapping a base layer that is in deferred-shape
     /// state (e.g. a PyTorch-style lazy <see cref="NeuralNetworks.Layers.DenseLayer{T}"/>
@@ -93,6 +96,7 @@ public DenseLoRAAdapter(
         bool freezeBaseLayer = true)
         : this(EnsureResolved(baseLayer, inputSize), rank, alpha, freezeBaseLayer)
     {
+        _inputSize = inputSize;
     }
 
     private static ILayer<T> EnsureResolved(NeuralNetworks.Layers.LayerBase<T> baseLayer, int inputSize)
diff --git a/src/LoRA/Adapters/DyLoRAAdapter.cs b/src/LoRA/Adapters/DyLoRAAdapter.cs
index e85d93ccd6..978d26bb82 100644
--- a/src/LoRA/Adapters/DyLoRAAdapter.cs
+++ b/src/LoRA/Adapters/DyLoRAAdapter.cs
@@ -109,6 +109,7 @@ public partial class DyLoRAAdapter<T> : LoRAAdapterBase<T>
     /// <summary>
     /// Cached input from the last forward pass for gradient computation.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _cachedInput;
 
     /// <summary>
@@ -119,6 +120,7 @@ public partial class DyLoRAAdapter<T> : LoRAAdapterBase<T>
     /// <summary>
     /// Cached LoRA parameter gradients computed in backward pass.
     /// </summary>
+    [Scratch]
     private Vector<T>? _cachedLoRAGradients;
 
     /// <summary>
diff --git a/src/LoRA/Adapters/FloraAdapter.cs b/src/LoRA/Adapters/FloraAdapter.cs
index 9778dc6ea2..df19d2275a 100644
--- a/src/LoRA/Adapters/FloraAdapter.cs
+++ b/src/LoRA/Adapters/FloraAdapter.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using AiDotNet.Extensions;
 using AiDotNet.Interfaces;
 
@@ -22,18 +22,23 @@ namespace AiDotNet.LoRA.Adapters;
 /// the memory efficiency of LoRA.
 /// </para>
 /// </remarks>
-public class FloraAdapter<T> : LoRAAdapterBase<T>
+public partial class FloraAdapter<T> : LoRAAdapterBase<T>
 {
     private readonly int _resamplingInterval;
     private readonly int _rank;
     private int _currentStep;
+    [AiDotNet.Attributes.Buffer]
     private Matrix<T>? _compressedMomentum;
+    [AiDotNet.Attributes.Buffer]
     private Matrix<T>? _compressedSecondMoment;
     private readonly Random _random;
     private readonly double _momentumDecay;
     private readonly double _secondMomentDecay;
     private readonly bool _useAdaptiveLearningRate;
 
+    /// <summary>Construction state: the 'seed' the layer was built with.</summary>
+    private readonly int _seed;
+
     public FloraAdapter(
         ILayer<T> baseLayer,
         int rank,
@@ -46,6 +51,7 @@ public FloraAdapter(
         int seed = 42)
         : base(baseLayer, rank, alpha, freezeBaseLayer)
     {
+        _seed = seed;
         if (resamplingInterval < 1)
         {
             throw new ArgumentException("Resampling interval must be at least 1", nameof(resamplingInterval));
@@ -200,7 +206,7 @@ private void ResampleProjectionMatrices()
 
     private Matrix<T> ComputeTransferMatrix(Matrix<T> oldA, Matrix<T> newA)
     {
-        // Transfer matrix = oldA^T @ newA — vectorized via Engine.TensorMatMul
+        // Transfer matrix = oldA^T @ newA — vectorized via Engine.TensorMatMul
         var oldATensor = Tensor<T>.FromMatrix(oldA).Transpose(new[] { 1, 0 });
         var newATensor = Tensor<T>.FromMatrix(newA);
         var resultTensor = Engine.TensorMatMul(oldATensor, newATensor);
@@ -211,10 +217,10 @@ private Matrix<T> MultiplyMatrices(Matrix<T> a, Matrix<T> b)
     {
         if (a.Columns != b.Rows)
         {
-            throw new ArgumentException($"Matrix dimensions incompatible for multiplication: ({a.Rows}×{a.Columns}) × ({b.Rows}×{b.Columns})");
+            throw new ArgumentException($"Matrix dimensions incompatible for multiplication: ({a.Rows}×{a.Columns}) × ({b.Rows}×{b.Columns})");
         }
 
-        // a @ b — vectorized via Engine.TensorMatMul
+        // a @ b — vectorized via Engine.TensorMatMul
         var aTensor = Tensor<T>.FromMatrix(a);
         var bTensor = Tensor<T>.FromMatrix(b);
         var resultTensor = Engine.TensorMatMul(aTensor, bTensor);
diff --git a/src/LoRA/Adapters/GLoRAAdapter.cs b/src/LoRA/Adapters/GLoRAAdapter.cs
index 1d33719c17..753074b7e2 100644
--- a/src/LoRA/Adapters/GLoRAAdapter.cs
+++ b/src/LoRA/Adapters/GLoRAAdapter.cs
@@ -1,4 +1,4 @@
-using AiDotNet.Attributes;
+using AiDotNet.Attributes;
 using AiDotNet.Helpers;
 using AiDotNet.Interfaces;
 
@@ -81,6 +81,15 @@ public partial class GLoRAAdapter<T> : LoRAAdapterBase<T>
     /// </remarks>
     public int ActivationRank => _activationAdaptation.Rank;
 
+    /// <summary>Construction state: the 'weightRank' the layer was built with.</summary>
+    private readonly int _weightRank;
+
+    /// <summary>Construction state: the 'activationAlpha' the layer was built with.</summary>
+    private readonly double _activationAlpha;
+
+    /// <summary>Construction state: the 'weightAlpha' the layer was built with.</summary>
+    private readonly double _weightAlpha;
+
     /// <summary>
     /// Initializes a new GLoRA adapter with the specified parameters.
     /// </summary>
@@ -121,6 +130,9 @@ public GLoRAAdapter(
         bool freezeBaseLayer = true)
         : base(baseLayer, weightRank, weightAlpha, freezeBaseLayer)
     {
+        _weightAlpha = weightAlpha;
+        _activationAlpha = activationAlpha;
+        _weightRank = weightRank;
         // Default activation rank to weight rank if not specified
         int actualActivationRank = activationRank > 0 ? activationRank : weightRank;
 
diff --git a/src/LoRA/Adapters/GraphConvolutionalLoRAAdapter.cs b/src/LoRA/Adapters/GraphConvolutionalLoRAAdapter.cs
index e6b70421d4..23fd6fd88e 100644
--- a/src/LoRA/Adapters/GraphConvolutionalLoRAAdapter.cs
+++ b/src/LoRA/Adapters/GraphConvolutionalLoRAAdapter.cs
@@ -62,6 +62,7 @@ public partial class GraphConvolutionalLoRAAdapter<T> : LoRAAdapterBase<T>, IGra
     /// <summary>
     /// Cached adjacency matrix for graph operations.
     /// </summary>
+    [AiDotNet.Attributes.FittedParameter(InputSized = true)]
     private Tensor<T>? _adjacencyMatrix;
 
     /// <summary>
diff --git a/src/LoRA/Adapters/LoRADropAdapter.cs b/src/LoRA/Adapters/LoRADropAdapter.cs
index c557f231fc..28ab1e97b4 100644
--- a/src/LoRA/Adapters/LoRADropAdapter.cs
+++ b/src/LoRA/Adapters/LoRADropAdapter.cs
@@ -50,7 +50,7 @@ namespace AiDotNet.LoRA.Adapters;
 /// - You've observed overfitting with standard LoRA
 /// </para>
 /// </remarks>
-public class LoRADropAdapter<T> : LoRAAdapterBase<T>
+public partial class LoRADropAdapter<T> : LoRAAdapterBase<T>
 {
     /// <summary>
     /// Dropout rate (probability of dropping a component during training).
diff --git a/src/LoRA/Adapters/LoRAPlusAdapter.cs b/src/LoRA/Adapters/LoRAPlusAdapter.cs
index 1fa3eee256..3474b05234 100644
--- a/src/LoRA/Adapters/LoRAPlusAdapter.cs
+++ b/src/LoRA/Adapters/LoRAPlusAdapter.cs
@@ -41,7 +41,7 @@ namespace AiDotNet.LoRA.Adapters;
 /// Reference: LoRA+: Efficient Low Rank Adaptation of Large Models (February 2024)
 /// </para>
 /// </remarks>
-public class LoRAPlusAdapter<T> : LoRAAdapterBase<T>
+public partial class LoRAPlusAdapter<T> : LoRAAdapterBase<T>
 {
     /// <summary>
     /// The ratio of learning rates between matrix B and matrix A.
diff --git a/src/LoRA/Adapters/LoRETTAAdapter.cs b/src/LoRA/Adapters/LoRETTAAdapter.cs
index 84d85f742b..1831ba7d6d 100644
--- a/src/LoRA/Adapters/LoRETTAAdapter.cs
+++ b/src/LoRA/Adapters/LoRETTAAdapter.cs
@@ -117,6 +117,9 @@ public partial class LoRETTAAdapter<T> : LoRAAdapterBase<T>
     /// </summary>
     public int NumCores => _numCores;
 
+    /// <summary>Construction state: the 'ttRank' the layer was built with.</summary>
+    private readonly int _ttRank;
+
     /// <summary>
     /// Initializes a new LoRETTA adapter wrapping an existing layer.
     /// </summary>
@@ -157,6 +160,7 @@ public LoRETTAAdapter(
         bool freezeBaseLayer = true)
         : base(baseLayer, ttRank, alpha, freezeBaseLayer)
     {
+        _ttRank = ttRank;
         if (ttRank <= 0)
         {
             throw new ArgumentException("TT-rank must be positive", nameof(ttRank));
diff --git a/src/LoRA/Adapters/LoftQAdapter.cs b/src/LoRA/Adapters/LoftQAdapter.cs
index 54ee4cb747..466dc1712f 100644
--- a/src/LoRA/Adapters/LoftQAdapter.cs
+++ b/src/LoRA/Adapters/LoftQAdapter.cs
@@ -99,7 +99,7 @@ namespace AiDotNet.LoRA.Adapters;
 /// - Both have identical runtime memory and speed characteristics
 /// </para>
 /// </remarks>
-public class LoftQAdapter<T> : LoRAAdapterBase<T>
+public partial class LoftQAdapter<T> : LoRAAdapterBase<T>
 {
     /// <summary>
     /// Specifies the type of 4-bit quantization to use for base layer weights.
@@ -167,6 +167,7 @@ public enum QuantizationType
     /// <summary>
     /// Cached dequantized weights for forward pass.
     /// </summary>
+    [AiDotNet.Attributes.Scratch]
     private Matrix<T>? _dequantizedWeights;
 
     /// <summary>
diff --git a/src/LoRA/Adapters/LongLoRAAdapter.cs b/src/LoRA/Adapters/LongLoRAAdapter.cs
index c20a0d7d1b..1ff32fe9ff 100644
--- a/src/LoRA/Adapters/LongLoRAAdapter.cs
+++ b/src/LoRA/Adapters/LongLoRAAdapter.cs
@@ -60,7 +60,7 @@ namespace AiDotNet.LoRA.Adapters;
 /// https://arxiv.org/abs/2309.12307
 /// </para>
 /// </remarks>
-public class LongLoRAAdapter<T> : LoRAAdapterBase<T>
+public partial class LongLoRAAdapter<T> : LoRAAdapterBase<T>
 {
     /// <summary>
     /// The original context length that the base model was trained on.
diff --git a/src/LoRA/Adapters/MultiLoRAAdapter.cs b/src/LoRA/Adapters/MultiLoRAAdapter.cs
index e32abfb034..ba52f28212 100644
--- a/src/LoRA/Adapters/MultiLoRAAdapter.cs
+++ b/src/LoRA/Adapters/MultiLoRAAdapter.cs
@@ -108,6 +108,12 @@ public string CurrentTask
     /// </summary>
     public int NumberOfTasks => _taskAdapters.Count;
 
+    /// <summary>Construction state: the 'defaultTaskName' the layer was built with.</summary>
+    private readonly string _defaultTaskName;
+
+    /// <summary>Construction state: the 'defaultRank' the layer was built with.</summary>
+    private readonly int _defaultRank;
+
     /// <summary>
     /// Initializes a new Multi-LoRA adapter with an initial default task.
     /// </summary>
@@ -143,6 +149,8 @@ public MultiLoRAAdapter(
         bool freezeBaseLayer = true)
         : base(baseLayer, defaultRank, alpha, freezeBaseLayer)
     {
+        _defaultRank = defaultRank;
+        _defaultTaskName = defaultTaskName;
         if (string.IsNullOrWhiteSpace(defaultTaskName))
         {
             throw new ArgumentException("Default task name cannot be null or whitespace", nameof(defaultTaskName));
diff --git a/src/LoRA/Adapters/PiSSAAdapter.cs b/src/LoRA/Adapters/PiSSAAdapter.cs
index aebbef0b88..5b17d13554 100644
--- a/src/LoRA/Adapters/PiSSAAdapter.cs
+++ b/src/LoRA/Adapters/PiSSAAdapter.cs
@@ -63,7 +63,7 @@ namespace AiDotNet.LoRA.Adapters;
 /// - Key Insight: SVD-based initialization > random initialization for low-rank adaptation
 /// </para>
 /// </remarks>
-public class PiSSAAdapter<T> : LoRAAdapterBase<T>
+public partial class PiSSAAdapter<T> : LoRAAdapterBase<T>
 {
     /// <summary>
     /// The frozen residual weights after removing top-r principal components.
@@ -84,6 +84,7 @@ public class PiSSAAdapter<T> : LoRAAdapterBase<T>
     /// This is like keeping the background of a photo fixed while adjusting only the main subject.
     /// </para>
     /// </remarks>
+    [AiDotNet.Attributes.TrainableParameter]
     private Matrix<T>? _residualWeights;
 
     /// <summary>
diff --git a/src/LoRA/Adapters/QALoRAAdapter.cs b/src/LoRA/Adapters/QALoRAAdapter.cs
index eb10f391f1..e502e4e59b 100644
--- a/src/LoRA/Adapters/QALoRAAdapter.cs
+++ b/src/LoRA/Adapters/QALoRAAdapter.cs
@@ -71,7 +71,7 @@ namespace AiDotNet.LoRA.Adapters;
 /// - Fine-tuning for deployment on specific hardware (TPUs, specialized accelerators)
 /// </para>
 /// </remarks>
-public class QALoRAAdapter<T> : LoRAAdapterBase<T>
+public partial class QALoRAAdapter<T> : LoRAAdapterBase<T>
 {
     /// <summary>
     /// Number of bits to use for quantization (e.g., 4, 8).
diff --git a/src/LoRA/Adapters/QLoRAAdapter.cs b/src/LoRA/Adapters/QLoRAAdapter.cs
index 49f1d804f1..46b275727f 100644
--- a/src/LoRA/Adapters/QLoRAAdapter.cs
+++ b/src/LoRA/Adapters/QLoRAAdapter.cs
@@ -66,7 +66,7 @@ namespace AiDotNet.LoRA.Adapters;
 /// 3. Paged optimizers to handle memory spikes during gradient checkpointing
 /// </para>
 /// </remarks>
-public class QLoRAAdapter<T> : LoRAAdapterBase<T>
+public partial class QLoRAAdapter<T> : LoRAAdapterBase<T>
 {
     /// <summary>
     /// Specifies the type of 4-bit quantization to use for base layer weights.
@@ -156,6 +156,7 @@ public enum QuantizationType
     /// Weights are dequantized at the start of forward pass and cached to avoid repeated dequantization.
     /// Cleared after backward pass to save memory.
     /// </remarks>
+    [AiDotNet.Attributes.Scratch]
     private Matrix<T>? _dequantizedWeights;
 
     /// <summary>
diff --git a/src/LoRA/Adapters/ReLoRAAdapter.cs b/src/LoRA/Adapters/ReLoRAAdapter.cs
index d1c42a4c22..d6416913d3 100644
--- a/src/LoRA/Adapters/ReLoRAAdapter.cs
+++ b/src/LoRA/Adapters/ReLoRAAdapter.cs
@@ -53,7 +53,7 @@ namespace AiDotNet.LoRA.Adapters;
 /// https://arxiv.org/abs/2307.05695
 /// </para>
 /// </remarks>
-public class ReLoRAAdapter<T> : LoRAAdapterBase<T>
+public partial class ReLoRAAdapter<T> : LoRAAdapterBase<T>
 {
     /// <summary>
     /// Number of training steps between restart operations.
@@ -94,6 +94,7 @@ public class ReLoRAAdapter<T> : LoRAAdapterBase<T>
     /// This is how we prevent forgetting - all previous learning is saved here.
     /// </para>
     /// </remarks>
+    [AiDotNet.Attributes.TrainableParameter]
     private Matrix<T> _accumulatedWeight;
 
     /// <summary>
diff --git a/src/LoRA/Adapters/SLoRAAdapter.cs b/src/LoRA/Adapters/SLoRAAdapter.cs
index a0f7c313eb..80d4a39231 100644
--- a/src/LoRA/Adapters/SLoRAAdapter.cs
+++ b/src/LoRA/Adapters/SLoRAAdapter.cs
@@ -72,7 +72,7 @@ namespace AiDotNet.LoRA.Adapters;
 /// - S-LoRA: Multiple adapters, optimized for concurrent serving, memory pooling
 /// </para>
 /// </remarks>
-public class SLoRAAdapter<T> : LoRAAdapterBase<T>
+public partial class SLoRAAdapter<T> : LoRAAdapterBase<T>
 {
     /// <summary>
     /// Represents an adapter entry in the memory pool.
diff --git a/src/LoRA/Adapters/StandardLoRAAdapter.cs b/src/LoRA/Adapters/StandardLoRAAdapter.cs
index 6496011189..ca39c4c320 100644
--- a/src/LoRA/Adapters/StandardLoRAAdapter.cs
+++ b/src/LoRA/Adapters/StandardLoRAAdapter.cs
@@ -30,7 +30,7 @@ namespace AiDotNet.LoRA.Adapters;
 /// (frozen) reduces trainable parameters from 1,000,000 to just 16,000!
 /// </para>
 /// </remarks>
-public class StandardLoRAAdapter<T> : LoRAAdapterBase<T>
+public partial class StandardLoRAAdapter<T> : LoRAAdapterBase<T>
 {
     /// <summary>
     /// Initializes a new Standard LoRA adapter wrapping an existing layer.
diff --git a/src/LoRA/Adapters/TiedLoRAAdapter.cs b/src/LoRA/Adapters/TiedLoRAAdapter.cs
index 86d84591b9..4dd52addc6 100644
--- a/src/LoRA/Adapters/TiedLoRAAdapter.cs
+++ b/src/LoRA/Adapters/TiedLoRAAdapter.cs
@@ -68,6 +68,7 @@ public partial class TiedLoRAAdapter<T> : LoRAAdapterBase<T>
     /// This matrix is shared across all Tied-LoRA layers and IS trained during fine-tuning.
     /// Unlike VeRA, this matrix is not frozen - it learns the common adaptation pattern.
     /// </remarks>
+    [AiDotNet.Attributes.TrainableParameter]
     private static Matrix<T>? _sharedMatrixA;
 
     /// <summary>
@@ -77,16 +78,19 @@ public partial class TiedLoRAAdapter<T> : LoRAAdapterBase<T>
     /// This matrix is shared across all Tied-LoRA layers and IS trained during fine-tuning.
     /// Unlike VeRA, this matrix is not frozen - it learns the common adaptation pattern.
     /// </remarks>
+    [AiDotNet.Attributes.TrainableParameter]
     private static Matrix<T>? _sharedMatrixB;
 
     /// <summary>
     /// Gradients for shared matrix A accumulated from all layers.
     /// </summary>
+    [Scratch]
     private static Matrix<T>? _sharedMatrixAGradient;
 
     /// <summary>
     /// Gradients for shared matrix B accumulated from all layers.
     /// </summary>
+    [Scratch]
     private static Matrix<T>? _sharedMatrixBGradient;
 
     /// <summary>
diff --git a/src/LoRA/Adapters/VBLoRAAdapter.cs b/src/LoRA/Adapters/VBLoRAAdapter.cs
index 2849a275b1..e7681f9791 100644
--- a/src/LoRA/Adapters/VBLoRAAdapter.cs
+++ b/src/LoRA/Adapters/VBLoRAAdapter.cs
@@ -64,7 +64,7 @@ namespace AiDotNet.LoRA.Adapters;
 /// select the patterns relevant to each individual.
 /// </para>
 /// </remarks>
-public class VBLoRAAdapter<T> : LoRAAdapterBase<T>
+public partial class VBLoRAAdapter<T> : LoRAAdapterBase<T>
 {
     /// <summary>
     /// Global bank of column vectors for matrix A, shared across all VB-LoRA instances.
diff --git a/src/LoRA/Adapters/VeRAAdapter.cs b/src/LoRA/Adapters/VeRAAdapter.cs
index 5d86dd04c6..8615eb80b0 100644
--- a/src/LoRA/Adapters/VeRAAdapter.cs
+++ b/src/LoRA/Adapters/VeRAAdapter.cs
@@ -56,6 +56,7 @@ public partial class VeRAAdapter<T> : LoRAAdapterBase<T>
     /// This matrix is initialized once globally and shared across all VeRA layers.
     /// It is NEVER trained - it remains frozen at its random initialization values.
     /// </remarks>
+    [AiDotNet.Attributes.TrainableParameter]
     private static Matrix<T>? _sharedMatrixA;
 
     /// <summary>
@@ -65,6 +66,7 @@ public partial class VeRAAdapter<T> : LoRAAdapterBase<T>
     /// This matrix is initialized once globally and shared across all VeRA layers.
     /// It is NEVER trained - it remains frozen at its random initialization values.
     /// </remarks>
+    [AiDotNet.Attributes.TrainableParameter]
     private static Matrix<T>? _sharedMatrixB;
 
     /// <summary>
@@ -80,6 +82,7 @@ public partial class VeRAAdapter<T> : LoRAAdapterBase<T>
     /// It is initialized to ones so VeRA has no effect initially.
     /// Reassigned with correct size in CreateLoRALayer() which is called by the base constructor.
     /// </remarks>
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _scalingVectorD = new Tensor<T>([0]);
 
     /// <summary>
@@ -90,26 +93,31 @@ public partial class VeRAAdapter<T> : LoRAAdapterBase<T>
     /// It is initialized to ones so VeRA has no effect initially.
     /// Reassigned with correct size in CreateLoRALayer() which is called by the base constructor.
     /// </remarks>
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _scalingVectorB = new Tensor<T>([0]);
 
     /// <summary>
     /// Gradient for scaling vector d computed during backpropagation.
     /// </summary>
+    [Scratch]
     private Vector<T>? _scalingVectorDGradient;
 
     /// <summary>
     /// Gradient for scaling vector b computed during backpropagation.
     /// </summary>
+    [Scratch]
     private Vector<T>? _scalingVectorBGradient;
 
     /// <summary>
     /// Stored input from the forward pass, needed for gradient computation.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastInput;
 
     /// <summary>
     /// Stored intermediate value (B * A * input) from forward pass, needed for backward pass.
     /// </summary>
+    [Scratch]
     private Matrix<T>? _lastIntermediate;
 
     /// <summary>
diff --git a/src/LoRA/Adapters/XLoRAAdapter.cs b/src/LoRA/Adapters/XLoRAAdapter.cs
index 25dd8b5b78..e38168f21a 100644
--- a/src/LoRA/Adapters/XLoRAAdapter.cs
+++ b/src/LoRA/Adapters/XLoRAAdapter.cs
@@ -120,13 +120,21 @@ public partial class XLoRAAdapter<T> : LoRAAdapterBase<T>
     /// <summary>
     /// Temporary storage for gating weights during forward pass (needed for backward pass).
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastGatingWeights;
 
     /// <summary>
     /// Temporary storage for the last input during forward pass (needed for backward pass).
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastInput;
 
+    /// <summary>Construction state: the 'numberOfExperts' the layer was built with.</summary>
+    private readonly int _numberOfExperts;
+
+    /// <summary>Construction state: the 'expertRank' the layer was built with.</summary>
+    private readonly int _expertRank;
+
     /// <summary>
     /// Initializes a new X-LoRA adapter with the specified parameters.
     /// </summary>
@@ -168,6 +176,8 @@ public XLoRAAdapter(
         bool freezeBaseLayer = true)
         : base(baseLayer, expertRank, alpha, freezeBaseLayer)
     {
+        _expertRank = expertRank;
+        _numberOfExperts = numberOfExperts;
         if (numberOfExperts < 2)
         {
             throw new ArgumentException("Number of experts must be at least 2", nameof(numberOfExperts));
diff --git a/src/LoRA/LoRALayer.cs b/src/LoRA/LoRALayer.cs
index 01624eae13..16124953dd 100644
--- a/src/LoRA/LoRALayer.cs
+++ b/src/LoRA/LoRALayer.cs
@@ -199,6 +199,12 @@ public partial class LoRALayer<T> : LayerBase<T>, IShapeContract
     /// </summary>
     public override bool SupportsTraining => true;
 
+    /// <summary>Construction state: the 'inputSize' the layer was built with.</summary>
+    private readonly int _inputSize;
+
+    /// <summary>Construction state: the 'outputSize' the layer was built with.</summary>
+    private readonly int _outputSize;
+
     /// <summary>
     /// Initializes a new LoRA layer with the specified dimensions and hyperparameters.
     /// </summary>
@@ -226,6 +232,8 @@ public partial class LoRALayer<T> : LayerBase<T>, IShapeContract
     public LoRALayer(int inputSize, int outputSize, int rank, double alpha = -1, IActivationFunction<T>? activationFunction = null)
         : base(new[] { inputSize }, new[] { outputSize }, activationFunction ?? new IdentityActivation<T>())
     {
+        _outputSize = outputSize;
+        _inputSize = inputSize;
         if (inputSize <= 0)
         {
             throw new ArgumentOutOfRangeException(nameof(inputSize), "Input size must be positive");
diff --git a/src/LossFunctions/APNet2GeneratorLoss.cs b/src/LossFunctions/APNet2GeneratorLoss.cs
index ffdaadeb71..10134cafec 100644
--- a/src/LossFunctions/APNet2GeneratorLoss.cs
+++ b/src/LossFunctions/APNet2GeneratorLoss.cs
@@ -38,7 +38,7 @@ namespace AiDotNet.LossFunctions;
 /// short way round the clock, which is what lets the model learn phase at all.</para>
 /// </remarks>
 /// <typeparam name="T">Numeric type (float / double).</typeparam>
-public sealed class APNet2GeneratorLoss<T> : LossFunctionBase<T>
+public sealed partial class APNet2GeneratorLoss<T> : LossFunctionBase<T>
 {
     private const double TwoPi = 2.0 * Math.PI;
     private const double HalfPi = Math.PI / 2.0;
@@ -56,7 +56,9 @@ public sealed class APNet2GeneratorLoss<T> : LossFunctionBase<T>
     // Constant bases, built once. They carry no gradient, and rebuilding a [nFft, bins] pair on
     // every training step would cost more than the loss itself.
     private Tensor<T>? _window;
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T>? _dftCos;
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T>? _dftSin;
     private Tensor<T>? _melTransposed;
 
diff --git a/src/LossFunctions/PerceptualLoss.cs b/src/LossFunctions/PerceptualLoss.cs
index b9aa441b6c..9abad526f3 100644
--- a/src/LossFunctions/PerceptualLoss.cs
+++ b/src/LossFunctions/PerceptualLoss.cs
@@ -36,7 +36,7 @@ namespace AiDotNet.LossFunctions;
 [LossTask(LossTask.ImageGeneration)]
 [LossTask(LossTask.SuperResolution)]
 [LossProperty(IsNonNegative = true, ZeroForIdentical = true, ApiShape = LossApiShape.ImageMatrix, ExpectedOutput = OutputType.Continuous)]
-public class PerceptualLoss<T> : LossFunctionBase<T>
+public partial class PerceptualLoss<T> : LossFunctionBase<T>
 {
     /// <summary>
     /// The feature extractor function that converts images to feature representations.
@@ -46,6 +46,7 @@ public class PerceptualLoss<T> : LossFunctionBase<T>
     /// <summary>
     /// The weights for each feature layer.
     /// </summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private readonly Vector<T> _layerWeights;
 
     /// <summary>
diff --git a/src/LossFunctions/WeightedCrossEntropyLoss.cs b/src/LossFunctions/WeightedCrossEntropyLoss.cs
index 48b66c85f7..b68d977be4 100644
--- a/src/LossFunctions/WeightedCrossEntropyLoss.cs
+++ b/src/LossFunctions/WeightedCrossEntropyLoss.cs
@@ -30,11 +30,12 @@ namespace AiDotNet.LossFunctions;
 [LossTask(LossTask.BinaryClassification)]
 [LossTask(LossTask.MultiLabel)]
 [LossProperty(IsNonNegative = true, ZeroForIdentical = false, SupportsClassWeights = true, HandlesImbalancedData = true, RequiresProbabilityInputs = true, ExpectedOutput = OutputType.Probabilities)]
-public class WeightedCrossEntropyLoss<T> : LossFunctionBase<T>
+public partial class WeightedCrossEntropyLoss<T> : LossFunctionBase<T>
 {
     /// <summary>
     /// The weights to apply to each sample.
     /// </summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private readonly Vector<T> _weights;
 
     /// <summary>
diff --git a/src/MetaLearning/Algorithms/ANILAlgorithm.cs b/src/MetaLearning/Algorithms/ANILAlgorithm.cs
index 0128672fd0..cfa353001a 100644
--- a/src/MetaLearning/Algorithms/ANILAlgorithm.cs
+++ b/src/MetaLearning/Algorithms/ANILAlgorithm.cs
@@ -88,6 +88,7 @@ public partial class ANILAlgorithm<T, TInput, TOutput> : MetaLearnerBase<T, TInp
 
     // Head parameters (adapted per-task)
     private Vector<T> _headWeights;
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T>? _headBias;
 
     // Body parameters (frozen during inner loop, updated in outer loop)
diff --git a/src/MetaLearning/Algorithms/ANPAlgorithm.cs b/src/MetaLearning/Algorithms/ANPAlgorithm.cs
index bfd0e9b78e..2456a22b23 100644
--- a/src/MetaLearning/Algorithms/ANPAlgorithm.cs
+++ b/src/MetaLearning/Algorithms/ANPAlgorithm.cs
@@ -31,7 +31,9 @@ namespace AiDotNet.MetaLearning.Algorithms;
 public partial class ANPAlgorithm<T, TInput, TOutput> : NeuralProcessBase<T, TInput, TOutput>
 {
     private readonly ANPOptions<T, TInput, TOutput> _anpOptions;
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T> _latentEncoderParams;
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T> _attentionParams;
 
     /// <inheritdoc/>
diff --git a/src/MetaLearning/Algorithms/ATAMLAlgorithm.cs b/src/MetaLearning/Algorithms/ATAMLAlgorithm.cs
index afd1cc2ba8..c4a480c815 100644
--- a/src/MetaLearning/Algorithms/ATAMLAlgorithm.cs
+++ b/src/MetaLearning/Algorithms/ATAMLAlgorithm.cs
@@ -70,6 +70,7 @@ public partial class ATAMLAlgorithm<T, TInput, TOutput> : MetaLearnerBase<T, TIn
     private readonly int _compressedDim;
 
     /// <summary>Attention projection: compressedDim × attentionDim.</summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T> _attentionParams;
 
     /// <inheritdoc/>
diff --git a/src/MetaLearning/Algorithms/AdaptedMetaModel.cs b/src/MetaLearning/Algorithms/AdaptedMetaModel.cs
index 6df63fcf1b..82d146dcca 100644
--- a/src/MetaLearning/Algorithms/AdaptedMetaModel.cs
+++ b/src/MetaLearning/Algorithms/AdaptedMetaModel.cs
@@ -43,7 +43,7 @@ namespace AiDotNet.MetaLearning.Algorithms;
 [ResearchPaper("Model-Agnostic Meta-Learning for Fast Adaptation of Deep Networks", "https://arxiv.org/abs/1703.03400")]
 [ComponentType(ComponentType.MetaLearner)]
 [PipelineStage(PipelineStage.Training)]
-public class AdaptedMetaModel<T, TInput, TOutput> : MetaLearningModelBase<T, TInput, TOutput>, IAdaptedMetaModel<T>
+public partial class AdaptedMetaModel<T, TInput, TOutput> : MetaLearningModelBase<T, TInput, TOutput>, IAdaptedMetaModel<T>
 {
 
     /// <inheritdoc />
@@ -54,7 +54,12 @@ protected override void RegisterComponents()
             () => _adaptedParams,
             value => _adaptedParams = value));
     }
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T> _adaptedParams;
+    // Task examples are inputs to adaptation, not optimizer-owned model state. Keeping this
+    // declaration explicit prevents the generated parameter graph from treating an optional
+    // support vector as a shape-deferred weight slot.
+    [ExternalState]
     private readonly Vector<T>? _supportFeatures;
     private readonly double[]? _modulationFactors;
 
@@ -112,14 +117,4 @@ public override IFullModel<T, TInput, TOutput> WithParameters(Vector<T> paramete
     {
         return new AdaptedMetaModel<T, TInput, TOutput>(BaseModel, parameters, _supportFeatures, _modulationFactors);
     }
-
-    /// <inheritdoc/>
-    public override IFullModel<T, TInput, TOutput> DeepCopy()
-    {
-        var clonedModel = BaseModel.DeepCopy();
-        var clonedParams = _adaptedParams.Clone();
-        var clonedFeatures = _supportFeatures?.Clone();
-        var clonedModulation = _modulationFactors is not null ? (double[])_modulationFactors.Clone() : null;
-        return new AdaptedMetaModel<T, TInput, TOutput>(clonedModel, clonedParams, clonedFeatures, clonedModulation);
-    }
 }
diff --git a/src/MetaLearning/Algorithms/AutoLoRAAlgorithm.cs b/src/MetaLearning/Algorithms/AutoLoRAAlgorithm.cs
index 8d9d9c7848..28cfa9ef70 100644
--- a/src/MetaLearning/Algorithms/AutoLoRAAlgorithm.cs
+++ b/src/MetaLearning/Algorithms/AutoLoRAAlgorithm.cs
@@ -68,12 +68,14 @@ public partial class AutoLoRAAlgorithm<T, TInput, TOutput> : MetaLearnerBase<T,
     /// [group_0_comp_0, group_0_comp_1, ..., group_G_comp_R]
     /// Each component has length paramsPerGroup.
     /// </summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T> _rankComponents;
 
     /// <summary>
     /// Selection logits β for each (group, component) pair.
     /// Length = numGroups * maxRank.
     /// </summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T> _selectionLogits;
 
     private readonly int _paramDim;
diff --git a/src/MetaLearning/Algorithms/BOILAlgorithm.cs b/src/MetaLearning/Algorithms/BOILAlgorithm.cs
index 7d5ec2282e..0bd78fcc2b 100644
--- a/src/MetaLearning/Algorithms/BOILAlgorithm.cs
+++ b/src/MetaLearning/Algorithms/BOILAlgorithm.cs
@@ -83,6 +83,7 @@ public partial class BOILAlgorithm<T, TInput, TOutput> : MetaLearnerBase<T, TInp
 
     // Head parameters (frozen during inner loop)
     private Vector<T> _headWeights;
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T>? _headBias;
 
     // Body parameters (adapted per-task)
diff --git a/src/MetaLearning/Algorithms/BayProNetAlgorithm.cs b/src/MetaLearning/Algorithms/BayProNetAlgorithm.cs
index ea5478987e..cbf0924332 100644
--- a/src/MetaLearning/Algorithms/BayProNetAlgorithm.cs
+++ b/src/MetaLearning/Algorithms/BayProNetAlgorithm.cs
@@ -68,6 +68,7 @@ public partial class BayProNetAlgorithm<T, TInput, TOutput> : MetaLearnerBase<T,
     private const double SpsaLearningRateMultiplier = 0.1;
 
     /// <summary>Meta-learned per-parameter log-variance for the posterior distribution.</summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T> _posteriorLogVar;
 
     /// <inheritdoc/>
diff --git a/src/MetaLearning/Algorithms/BayTransProtoAlgorithm.cs b/src/MetaLearning/Algorithms/BayTransProtoAlgorithm.cs
index 361b7d9210..77b96895a5 100644
--- a/src/MetaLearning/Algorithms/BayTransProtoAlgorithm.cs
+++ b/src/MetaLearning/Algorithms/BayTransProtoAlgorithm.cs
@@ -62,6 +62,7 @@ public partial class BayTransProtoAlgorithm<T, TInput, TOutput> : MetaLearnerBas
     private readonly int _paramDim;
 
     /// <summary>Learned log-variance for the posterior.</summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T> _logVar;
 
     /// <inheritdoc/>
diff --git a/src/MetaLearning/Algorithms/CAMLAlgorithm.cs b/src/MetaLearning/Algorithms/CAMLAlgorithm.cs
index eef0072cfc..9067a8d940 100644
--- a/src/MetaLearning/Algorithms/CAMLAlgorithm.cs
+++ b/src/MetaLearning/Algorithms/CAMLAlgorithm.cs
@@ -97,6 +97,7 @@ public partial class CAMLAlgorithm<T, TInput, TOutput> : MetaLearnerBase<T, TInp
     private readonly CAMLOptions<T, TInput, TOutput> _camlOptions;
 
     /// <summary>Parameters for the lightweight context module.</summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T> _contextParams = new Vector<T>(0);
 
     /// <inheritdoc/>
diff --git a/src/MetaLearning/Algorithms/CAVIAAlgorithm.cs b/src/MetaLearning/Algorithms/CAVIAAlgorithm.cs
index 4fbe1bb2b6..1d05d068cb 100644
--- a/src/MetaLearning/Algorithms/CAVIAAlgorithm.cs
+++ b/src/MetaLearning/Algorithms/CAVIAAlgorithm.cs
@@ -105,7 +105,7 @@ namespace AiDotNet.MetaLearning.Algorithms;
     Authors = "Luisa M. Zintgraf, Kyriacos Shiarli, Vitaly Kurin, et al.")]
 [ComponentType(ComponentType.MetaLearner)]
 [PipelineStage(PipelineStage.Training)]
-public class CAVIAAlgorithm<T, TInput, TOutput> : MetaLearnerBase<T, TInput, TOutput>
+public partial class CAVIAAlgorithm<T, TInput, TOutput> : MetaLearnerBase<T, TInput, TOutput>
 {
     private readonly CAVIAOptions<T, TInput, TOutput> _caviaOptions;
 
diff --git a/src/MetaLearning/Algorithms/CNPAlgorithm.cs b/src/MetaLearning/Algorithms/CNPAlgorithm.cs
index 9d900972c4..bdbc1c2238 100644
--- a/src/MetaLearning/Algorithms/CNPAlgorithm.cs
+++ b/src/MetaLearning/Algorithms/CNPAlgorithm.cs
@@ -45,7 +45,7 @@ namespace AiDotNet.MetaLearning.Algorithms;
     Authors = "Marta Garnelo, Dan Rosenbaum, Christopher Maddison, et al.")]
 [ComponentType(ComponentType.MetaLearner)]
 [PipelineStage(PipelineStage.Training)]
-public class CNPAlgorithm<T, TInput, TOutput> : NeuralProcessBase<T, TInput, TOutput>
+public partial class CNPAlgorithm<T, TInput, TOutput> : NeuralProcessBase<T, TInput, TOutput>
 {
     private readonly CNPOptions<T, TInput, TOutput> _cnpOptions;
 
diff --git a/src/MetaLearning/Algorithms/ConstellationNetAlgorithm.cs b/src/MetaLearning/Algorithms/ConstellationNetAlgorithm.cs
index b11d92b8bf..dcf2093227 100644
--- a/src/MetaLearning/Algorithms/ConstellationNetAlgorithm.cs
+++ b/src/MetaLearning/Algorithms/ConstellationNetAlgorithm.cs
@@ -110,9 +110,11 @@ public partial class ConstellationNetAlgorithm<T, TInput, TOutput> : MetaLearner
     private readonly ConstellationNetOptions<T, TInput, TOutput> _constellationOptions;
 
     /// <summary>Parameters for the part detection module.</summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T> _partDetectorParams = new Vector<T>(0);
 
     /// <summary>Parameters for the spatial relation module.</summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T> _relationParams = new Vector<T>(0);
 
     /// <inheritdoc/>
diff --git a/src/MetaLearning/Algorithms/ContextMetaRLAlgorithm.cs b/src/MetaLearning/Algorithms/ContextMetaRLAlgorithm.cs
index adf45d965d..01d26a94cc 100644
--- a/src/MetaLearning/Algorithms/ContextMetaRLAlgorithm.cs
+++ b/src/MetaLearning/Algorithms/ContextMetaRLAlgorithm.cs
@@ -62,12 +62,15 @@ public partial class ContextMetaRLAlgorithm<T, TInput, TOutput> : MetaLearnerBas
     private readonly int _compressedDim;
 
     /// <summary>Context encoder: compressedDim → contextDim.</summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T> _encoderParams;
 
     /// <summary>Learned attention query vector: contextDim.</summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T> _queryVector;
 
     /// <summary>Modulation projection: contextDim → compressedDim.</summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T> _modulationParams;
 
     /// <inheritdoc/>
diff --git a/src/MetaLearning/Algorithms/ConvCNPAlgorithm.cs b/src/MetaLearning/Algorithms/ConvCNPAlgorithm.cs
index 95e3998db8..f88f12ea14 100644
--- a/src/MetaLearning/Algorithms/ConvCNPAlgorithm.cs
+++ b/src/MetaLearning/Algorithms/ConvCNPAlgorithm.cs
@@ -25,7 +25,7 @@ namespace AiDotNet.MetaLearning.Algorithms;
     Authors = "Jonathan Gordon, Wessel P. Bruinsma, Andrew Y.K. Foong, et al.")]
 [ComponentType(ComponentType.MetaLearner)]
 [PipelineStage(PipelineStage.Training)]
-public class ConvCNPAlgorithm<T, TInput, TOutput> : NeuralProcessBase<T, TInput, TOutput>
+public partial class ConvCNPAlgorithm<T, TInput, TOutput> : NeuralProcessBase<T, TInput, TOutput>
 {
     private readonly ConvCNPOptions<T, TInput, TOutput> _algoOptions;
 
diff --git a/src/MetaLearning/Algorithms/ConvNPAlgorithm.cs b/src/MetaLearning/Algorithms/ConvNPAlgorithm.cs
index e5cfd70e07..6bb6a3723d 100644
--- a/src/MetaLearning/Algorithms/ConvNPAlgorithm.cs
+++ b/src/MetaLearning/Algorithms/ConvNPAlgorithm.cs
@@ -25,7 +25,7 @@ namespace AiDotNet.MetaLearning.Algorithms;
     Authors = "Andrew Y.K. Foong, Wessel P. Bruinsma, Jonathan Gordon, et al.")]
 [ComponentType(ComponentType.MetaLearner)]
 [PipelineStage(PipelineStage.Training)]
-public class ConvNPAlgorithm<T, TInput, TOutput> : NeuralProcessBase<T, TInput, TOutput>
+public partial class ConvNPAlgorithm<T, TInput, TOutput> : NeuralProcessBase<T, TInput, TOutput>
 {
     private readonly ConvNPOptions<T, TInput, TOutput> _algoOptions;
 
diff --git a/src/MetaLearning/Algorithms/DKTAlgorithm.cs b/src/MetaLearning/Algorithms/DKTAlgorithm.cs
index f5d9d3995d..da093c871c 100644
--- a/src/MetaLearning/Algorithms/DKTAlgorithm.cs
+++ b/src/MetaLearning/Algorithms/DKTAlgorithm.cs
@@ -111,6 +111,7 @@ public partial class DKTAlgorithm<T, TInput, TOutput> : MetaLearnerBase<T, TInpu
     private readonly DKTOptions<T, TInput, TOutput> _dktOptions;
 
     /// <summary>Learned kernel hyperparameters (length-scale, noise variance).</summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T> _kernelParams = new Vector<T>(0);
 
     /// <inheritdoc/>
diff --git a/src/MetaLearning/Algorithms/DPGNAlgorithm.cs b/src/MetaLearning/Algorithms/DPGNAlgorithm.cs
index 2c2f69a299..e125a9c5a0 100644
--- a/src/MetaLearning/Algorithms/DPGNAlgorithm.cs
+++ b/src/MetaLearning/Algorithms/DPGNAlgorithm.cs
@@ -105,9 +105,11 @@ public partial class DPGNAlgorithm<T, TInput, TOutput> : MetaLearnerBase<T, TInp
     private readonly DPGNOptions<T, TInput, TOutput> _dpgnOptions;
 
     /// <summary>Parameters for the point graph propagation layers.</summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T> _pointGraphParams = new Vector<T>(0);
 
     /// <summary>Parameters for the distribution graph propagation layers.</summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T> _distGraphParams = new Vector<T>(0);
 
     /// <inheritdoc/>
diff --git a/src/MetaLearning/Algorithms/DREAMAlgorithm.cs b/src/MetaLearning/Algorithms/DREAMAlgorithm.cs
index 4dced35ad9..586de02738 100644
--- a/src/MetaLearning/Algorithms/DREAMAlgorithm.cs
+++ b/src/MetaLearning/Algorithms/DREAMAlgorithm.cs
@@ -62,6 +62,7 @@ public partial class DREAMAlgorithm<T, TInput, TOutput> : MetaLearnerBase<T, TIn
     private readonly int _paramDim;
 
     /// <summary>Reward shaper parameters: 3-input → hidden → 1-output MLP.</summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T> _shaperParams;
 
     private readonly int _hiddenDim;
diff --git a/src/MetaLearning/Algorithms/DiscoRLAlgorithm.cs b/src/MetaLearning/Algorithms/DiscoRLAlgorithm.cs
index 4dec1667bd..0d80fc409f 100644
--- a/src/MetaLearning/Algorithms/DiscoRLAlgorithm.cs
+++ b/src/MetaLearning/Algorithms/DiscoRLAlgorithm.cs
@@ -65,9 +65,11 @@ public partial class DiscoRLAlgorithm<T, TInput, TOutput> : MetaLearnerBase<T, T
     private const double SpsaLearningRateMultiplier = 0.1;
 
     /// <summary>Skill basis vectors: numSkills * skillRank * compressedDim.</summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T> _skillBasis;
 
     /// <summary>Gating network parameters: compressedDim * numSkills.</summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T> _gatingParams;
 
     /// <inheritdoc/>
diff --git a/src/MetaLearning/Algorithms/ETPNAlgorithm.cs b/src/MetaLearning/Algorithms/ETPNAlgorithm.cs
index f999d20d83..ba3da9d45d 100644
--- a/src/MetaLearning/Algorithms/ETPNAlgorithm.cs
+++ b/src/MetaLearning/Algorithms/ETPNAlgorithm.cs
@@ -65,6 +65,7 @@ public partial class ETPNAlgorithm<T, TInput, TOutput> : MetaLearnerBase<T, TInp
     private readonly int _compressedDim;
 
     /// <summary>Transform projection: compressedDim × transformDim.</summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T> _transformParams;
 
     /// <inheritdoc/>
diff --git a/src/MetaLearning/Algorithms/EquivCNPAlgorithm.cs b/src/MetaLearning/Algorithms/EquivCNPAlgorithm.cs
index 8ec113f54e..c6418eeac0 100644
--- a/src/MetaLearning/Algorithms/EquivCNPAlgorithm.cs
+++ b/src/MetaLearning/Algorithms/EquivCNPAlgorithm.cs
@@ -25,7 +25,7 @@ namespace AiDotNet.MetaLearning.Algorithms;
     Authors = "Makoto Kawano, Wataru Kumagai, Akiyoshi Sannai, et al.")]
 [ComponentType(ComponentType.MetaLearner)]
 [PipelineStage(PipelineStage.Training)]
-public class EquivCNPAlgorithm<T, TInput, TOutput> : NeuralProcessBase<T, TInput, TOutput>
+public partial class EquivCNPAlgorithm<T, TInput, TOutput> : NeuralProcessBase<T, TInput, TOutput>
 {
     private readonly EquivCNPOptions<T, TInput, TOutput> _algoOptions;
 
diff --git a/src/MetaLearning/Algorithms/FEATAlgorithm.cs b/src/MetaLearning/Algorithms/FEATAlgorithm.cs
index 334ad838a5..af4c26b5ea 100644
--- a/src/MetaLearning/Algorithms/FEATAlgorithm.cs
+++ b/src/MetaLearning/Algorithms/FEATAlgorithm.cs
@@ -106,6 +106,7 @@ public partial class FEATAlgorithm<T, TInput, TOutput> : MetaLearnerBase<T, TInp
     /// <summary>
     /// Parameters for the set-to-set transformer that adapts prototypes.
     /// </summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T> _transformerParams = new Vector<T>(0);
 
     /// <inheritdoc/>
diff --git a/src/MetaLearning/Algorithms/FewTUREAlgorithm.cs b/src/MetaLearning/Algorithms/FewTUREAlgorithm.cs
index 3ad7adc4aa..4b766c5a4a 100644
--- a/src/MetaLearning/Algorithms/FewTUREAlgorithm.cs
+++ b/src/MetaLearning/Algorithms/FewTUREAlgorithm.cs
@@ -100,6 +100,7 @@ public partial class FewTUREAlgorithm<T, TInput, TOutput> : MetaLearnerBase<T, T
     private readonly FewTUREOptions<T, TInput, TOutput> _fewTUREOptions;
 
     /// <summary>Parameters for the uncertainty estimation module.</summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T> _uncertaintyParams = new Vector<T>(0);
 
     /// <inheritdoc/>
diff --git a/src/MetaLearning/Algorithms/FreqPromptAlgorithm.cs b/src/MetaLearning/Algorithms/FreqPromptAlgorithm.cs
index 0fba5345c1..a146fcf2f1 100644
--- a/src/MetaLearning/Algorithms/FreqPromptAlgorithm.cs
+++ b/src/MetaLearning/Algorithms/FreqPromptAlgorithm.cs
@@ -67,9 +67,11 @@ public partial class FreqPromptAlgorithm<T, TInput, TOutput> : MetaLearnerBase<T
     private readonly int _numComponents;
 
     /// <summary>Prompt basis vectors: flat array of K * paramDim values.</summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T> _promptBasis;
 
     /// <summary>Meta-learned initial prompt coefficients: length K.</summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T> _promptCoeffsInit;
 
     /// <summary>Per-frequency regularization weights (higher for high-freq).</summary>
diff --git a/src/MetaLearning/Algorithms/GNNMetaAlgorithm.cs b/src/MetaLearning/Algorithms/GNNMetaAlgorithm.cs
index 3200bd588e..fc0ca49340 100644
--- a/src/MetaLearning/Algorithms/GNNMetaAlgorithm.cs
+++ b/src/MetaLearning/Algorithms/GNNMetaAlgorithm.cs
@@ -81,8 +81,11 @@ public partial class GNNMetaAlgorithm<T, TInput, TOutput> : MetaLearnerBase<T, T
     private readonly GNNMetaOptions<T, TInput, TOutput> _gnnOptions;
 
     // GNN parameters
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T> _messagePassingWeights;
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T> _aggregationWeights;
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T> _edgeWeights;
 
     // Task graph state
diff --git a/src/MetaLearning/Algorithms/HyperCLIPAlgorithm.cs b/src/MetaLearning/Algorithms/HyperCLIPAlgorithm.cs
index 3d5c9df383..97c008fb66 100644
--- a/src/MetaLearning/Algorithms/HyperCLIPAlgorithm.cs
+++ b/src/MetaLearning/Algorithms/HyperCLIPAlgorithm.cs
@@ -61,6 +61,7 @@ public partial class HyperCLIPAlgorithm<T, TInput, TOutput> : MetaLearnerBase<T,
     private const double SpsaLearningRateMultiplier = 0.1;
 
     /// <summary>Projection weights: task projection (embDim × projDim) + param projection (embDim × projDim).</summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T> _projectionWeights;
 
     /// <inheritdoc/>
diff --git a/src/MetaLearning/Algorithms/HyperMAMLAlgorithm.cs b/src/MetaLearning/Algorithms/HyperMAMLAlgorithm.cs
index f7c3d49bba..4484243d48 100644
--- a/src/MetaLearning/Algorithms/HyperMAMLAlgorithm.cs
+++ b/src/MetaLearning/Algorithms/HyperMAMLAlgorithm.cs
@@ -96,6 +96,7 @@ public partial class HyperMAMLAlgorithm<T, TInput, TOutput> : MetaLearnerBase<T,
     private readonly HyperMAMLOptions<T, TInput, TOutput> _hyperMAMLOptions;
 
     /// <summary>Parameters for the initialization hypernetwork.</summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T> _hypernetParams = new Vector<T>(0);
 
     /// <inheritdoc/>
@@ -276,9 +277,10 @@ public override IModel<TInput, TOutput, ModelMetadata<T>> Adapt(IMetaLearningTas
 }
 
 /// <summary>Adapted model wrapper for HyperMAML.</summary>
-internal class HyperMAMLModel<T, TInput, TOutput> : IModel<TInput, TOutput, ModelMetadata<T>>
+internal partial class HyperMAMLModel<T, TInput, TOutput> : IModel<TInput, TOutput, ModelMetadata<T>>
 {
     private readonly IFullModel<T, TInput, TOutput> _model;
+    [AiDotNet.Attributes.TrainableParameter]
     private readonly Vector<T> _params;
     /// <inheritdoc/>
     public ModelMetadata<T> Metadata { get; } = new ModelMetadata<T>();
diff --git a/src/MetaLearning/Algorithms/HyperNeRFMetaAlgorithm.cs b/src/MetaLearning/Algorithms/HyperNeRFMetaAlgorithm.cs
index 9c56563b51..65aae3d95e 100644
--- a/src/MetaLearning/Algorithms/HyperNeRFMetaAlgorithm.cs
+++ b/src/MetaLearning/Algorithms/HyperNeRFMetaAlgorithm.cs
@@ -67,6 +67,7 @@ public partial class HyperNeRFMetaAlgorithm<T, TInput, TOutput> : MetaLearnerBas
     private readonly int _groupSize;
 
     /// <summary>Conditioning MLP weights: (peDim + latentDim) × numGroups.</summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T> _conditioningWeights;
 
     /// <summary>Pre-computed positional encodings per group.</summary>
diff --git a/src/MetaLearning/Algorithms/HyperNetMetaRLAlgorithm.cs b/src/MetaLearning/Algorithms/HyperNetMetaRLAlgorithm.cs
index 3740e781dc..93633a4d04 100644
--- a/src/MetaLearning/Algorithms/HyperNetMetaRLAlgorithm.cs
+++ b/src/MetaLearning/Algorithms/HyperNetMetaRLAlgorithm.cs
@@ -61,12 +61,15 @@ public partial class HyperNetMetaRLAlgorithm<T, TInput, TOutput> : MetaLearnerBa
     private const int MaxCompressedDim = 128;
 
     /// <summary>Task encoder: compressedDim → embDim.</summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T> _encoderParams;
 
     /// <summary>Hypernetwork layer 1: embDim → hiddenDim.</summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T> _hyperLayer1;
 
     /// <summary>Hypernetwork layer 2: hiddenDim → compressedDim.</summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T> _hyperLayer2;
 
     /// <summary>SPSA learning rate multiplier for auxiliary parameter updates.</summary>
diff --git a/src/MetaLearning/Algorithms/HyperShotAlgorithm.cs b/src/MetaLearning/Algorithms/HyperShotAlgorithm.cs
index e639018811..db6840d592 100644
--- a/src/MetaLearning/Algorithms/HyperShotAlgorithm.cs
+++ b/src/MetaLearning/Algorithms/HyperShotAlgorithm.cs
@@ -89,6 +89,7 @@ public partial class HyperShotAlgorithm<T, TInput, TOutput> : MetaLearnerBase<T,
     private readonly HyperShotOptions<T, TInput, TOutput> _hyperShotOptions;
 
     /// <summary>Parameters for the kernel hypernetwork.</summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T> _hypernetParams = new Vector<T>(0);
 
     /// <inheritdoc/>
diff --git a/src/MetaLearning/Algorithms/ICMFusionAlgorithm.cs b/src/MetaLearning/Algorithms/ICMFusionAlgorithm.cs
index ee1fa25326..7c207efb5c 100644
--- a/src/MetaLearning/Algorithms/ICMFusionAlgorithm.cs
+++ b/src/MetaLearning/Algorithms/ICMFusionAlgorithm.cs
@@ -64,9 +64,11 @@ public partial class ICMFusionAlgorithm<T, TInput, TOutput> : MetaLearnerBase<T,
     private const int MaxCompressedDim = 128;
 
     /// <summary>VAE encoder params: maps task vectors to (μ, log_σ²) in latent space.</summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T> _encoderParams;
 
     /// <summary>VAE decoder params: maps latent vectors back to parameter deltas.</summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T> _decoderParams;
 
     /// <summary>Stored latent codes from recent tasks for fusion (circular buffer).</summary>
diff --git a/src/MetaLearning/Algorithms/InContextRLAlgorithm.cs b/src/MetaLearning/Algorithms/InContextRLAlgorithm.cs
index 6de8a98a48..9952afe641 100644
--- a/src/MetaLearning/Algorithms/InContextRLAlgorithm.cs
+++ b/src/MetaLearning/Algorithms/InContextRLAlgorithm.cs
@@ -67,9 +67,11 @@ public partial class InContextRLAlgorithm<T, TInput, TOutput> : MetaLearnerBase<
     private readonly int _compressedDim;
 
     /// <summary>Context encoder parameters: gradient → context entry.</summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T> _contextEncoderParams;
 
     /// <summary>Context-to-parameter modulation projection.</summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T> _modulationParams;
 
     /// <inheritdoc/>
diff --git a/src/MetaLearning/Algorithms/LBANPAlgorithm.cs b/src/MetaLearning/Algorithms/LBANPAlgorithm.cs
index eba214e07e..4ce7e80d27 100644
--- a/src/MetaLearning/Algorithms/LBANPAlgorithm.cs
+++ b/src/MetaLearning/Algorithms/LBANPAlgorithm.cs
@@ -26,7 +26,7 @@ namespace AiDotNet.MetaLearning.Algorithms;
     Authors = "Leo Feng, Hossein Hajimirsadeghi, Yoshua Bengio, Mohamed Osama Ahmed")]
 [ComponentType(ComponentType.MetaLearner)]
 [PipelineStage(PipelineStage.Training)]
-public class LBANPAlgorithm<T, TInput, TOutput> : NeuralProcessBase<T, TInput, TOutput>
+public partial class LBANPAlgorithm<T, TInput, TOutput> : NeuralProcessBase<T, TInput, TOutput>
 {
     private readonly LBANPOptions<T, TInput, TOutput> _algoOptions;
 
diff --git a/src/MetaLearning/Algorithms/LEOAlgorithm.cs b/src/MetaLearning/Algorithms/LEOAlgorithm.cs
index 05e040c1b9..f8f79f2b4c 100644
--- a/src/MetaLearning/Algorithms/LEOAlgorithm.cs
+++ b/src/MetaLearning/Algorithms/LEOAlgorithm.cs
@@ -87,6 +87,7 @@ public partial class LEOAlgorithm<T, TInput, TOutput> : MetaLearnerBase<T, TInpu
     private Vector<T> _decoderWeights;
 
     // Relation network parameters (optional)
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T>? _relationWeights;
 
     /// <summary>
diff --git a/src/MetaLearning/Algorithms/LFTAlgorithm.cs b/src/MetaLearning/Algorithms/LFTAlgorithm.cs
index ecc626e584..b409157f26 100644
--- a/src/MetaLearning/Algorithms/LFTAlgorithm.cs
+++ b/src/MetaLearning/Algorithms/LFTAlgorithm.cs
@@ -121,6 +121,7 @@ public partial class LFTAlgorithm<T, TInput, TOutput> : MetaLearnerBase<T, TInpu
     /// transformation is applied to the encoder's features BEFORE this head consumes them, so the
     /// head's closed-form gradient carries theta_f's influence into the update.
     /// </summary>
+    [AiDotNet.Attributes.Buffer]
     private Vector<T> _metricHead;
 
     /// <inheritdoc/>
diff --git a/src/MetaLearning/Algorithms/LoRARecycleAlgorithm.cs b/src/MetaLearning/Algorithms/LoRARecycleAlgorithm.cs
index b1dec34930..7a8c4aec42 100644
--- a/src/MetaLearning/Algorithms/LoRARecycleAlgorithm.cs
+++ b/src/MetaLearning/Algorithms/LoRARecycleAlgorithm.cs
@@ -82,6 +82,7 @@ public partial class LoRARecycleAlgorithm<T, TInput, TOutput> : MetaLearnerBase<
     /// Prototype encoder parameters: maps feature vectors to prototype space.
     /// Stored as a flat vector of length (paramDim * prototypeDim + prototypeDim).
     /// </summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T> _encoderParams;
 
     private const int MaxEncoderInputDim = 128;
diff --git a/src/MetaLearning/Algorithms/MAMLAlgorithm.cs b/src/MetaLearning/Algorithms/MAMLAlgorithm.cs
index 50439fedb3..4e12b71f37 100644
--- a/src/MetaLearning/Algorithms/MAMLAlgorithm.cs
+++ b/src/MetaLearning/Algorithms/MAMLAlgorithm.cs
@@ -55,7 +55,7 @@ namespace AiDotNet.MetaLearning.Algorithms;
     Authors = "Chelsea Finn, Pieter Abbeel, Sergey Levine")]
 [ComponentType(ComponentType.MetaLearner)]
 [PipelineStage(PipelineStage.Training)]
-public class MAMLAlgorithm<T, TInput, TOutput> : MetaLearnerBase<T, TInput, TOutput>
+public partial class MAMLAlgorithm<T, TInput, TOutput> : MetaLearnerBase<T, TInput, TOutput>
 {
     private readonly MAMLOptions<T, TInput, TOutput> _mamlOptions;
 
diff --git a/src/MetaLearning/Algorithms/MAMLPlusPlusAlgorithm.cs b/src/MetaLearning/Algorithms/MAMLPlusPlusAlgorithm.cs
index b7445203b5..2a93a5b41a 100644
--- a/src/MetaLearning/Algorithms/MAMLPlusPlusAlgorithm.cs
+++ b/src/MetaLearning/Algorithms/MAMLPlusPlusAlgorithm.cs
@@ -124,6 +124,7 @@ public partial class MAMLPlusPlusAlgorithm<T, TInput, TOutput> : MetaLearnerBase
     /// use smaller rates for fine-tuning. These rates are learned automatically.
     /// </para>
     /// </remarks>
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T> _perStepLearningRates;
 
     /// <inheritdoc/>
diff --git a/src/MetaLearning/Algorithms/MANNAlgorithm.cs b/src/MetaLearning/Algorithms/MANNAlgorithm.cs
index 3a32e1bdce..ad12be94f3 100644
--- a/src/MetaLearning/Algorithms/MANNAlgorithm.cs
+++ b/src/MetaLearning/Algorithms/MANNAlgorithm.cs
@@ -106,7 +106,7 @@ namespace AiDotNet.MetaLearning.Algorithms;
     Authors = "Adam Santoro, Sergey Bartunov, Matthew Botvinick, Daan Wierstra, Timothy Lillicrap")]
 [ComponentType(ComponentType.MetaLearner)]
 [PipelineStage(PipelineStage.Training)]
-public class MANNAlgorithm<T, TInput, TOutput> : MetaLearnerBase<T, TInput, TOutput>
+public partial class MANNAlgorithm<T, TInput, TOutput> : MetaLearnerBase<T, TInput, TOutput>
 {
     private readonly MANNOptions<T, TInput, TOutput> _mannOptions;
 
diff --git a/src/MetaLearning/Algorithms/MCLAlgorithm.cs b/src/MetaLearning/Algorithms/MCLAlgorithm.cs
index 3a6fcddfb2..f56efd1780 100644
--- a/src/MetaLearning/Algorithms/MCLAlgorithm.cs
+++ b/src/MetaLearning/Algorithms/MCLAlgorithm.cs
@@ -100,6 +100,7 @@ public partial class MCLAlgorithm<T, TInput, TOutput> : MetaLearnerBase<T, TInpu
     private readonly MCLOptions<T, TInput, TOutput> _mclOptions;
 
     /// <summary>Parameters for the contrastive projection head.</summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T> _projectionParams = new Vector<T>(0);
 
     /// <inheritdoc/>
diff --git a/src/MetaLearning/Algorithms/MPTSAlgorithm.cs b/src/MetaLearning/Algorithms/MPTSAlgorithm.cs
index c8c33fbccb..d8bd82633e 100644
--- a/src/MetaLearning/Algorithms/MPTSAlgorithm.cs
+++ b/src/MetaLearning/Algorithms/MPTSAlgorithm.cs
@@ -64,6 +64,7 @@ public partial class MPTSAlgorithm<T, TInput, TOutput> : MetaLearnerBase<T, TInp
     private readonly int _groupSize;
 
     /// <summary>Learned priority scores for each group (higher = adapted earlier).</summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T> _priorityScores;
 
     /// <inheritdoc/>
diff --git a/src/MetaLearning/Algorithms/MbPAAdaptedModel.cs b/src/MetaLearning/Algorithms/MbPAAdaptedModel.cs
index c2206798d1..afedd50c58 100644
--- a/src/MetaLearning/Algorithms/MbPAAdaptedModel.cs
+++ b/src/MetaLearning/Algorithms/MbPAAdaptedModel.cs
@@ -53,8 +53,21 @@ namespace AiDotNet.MetaLearning.Algorithms;
 [PipelineStage(PipelineStage.Evaluation)]
 public partial class MbPAAdaptedModel<T, TInput, TOutput> : MetaLearningModelBase<T, TInput, TOutput>
 {
+    /// <summary>
+    /// The embedding network this model was built with, read back from the base that holds it.
+    /// </summary>
+    /// <remarks>
+    /// The constructor calls the argument <c>embeddingNetwork</c> and hands it to the base, which
+    /// keeps it as <c>BaseModel</c>. That rename is invisible to the clone plan -- no name or type
+    /// rule can tell that two differently named members are the same value -- so the model could not
+    /// be rebuilt from its own state. Reading it back beats storing a second reference, which could
+    /// drift from the one the base actually uses.
+    /// </remarks>
+    private IFullModel<T, TInput, TOutput> _embeddingNetwork => BaseModel;
+
     private readonly MbPAEpisodicMemory<T> _memory;
     private readonly MbPAOptions<T, TInput, TOutput> _options;
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T> _trainedOutputParams;
 
     /// <summary>
@@ -230,14 +243,4 @@ private TOutput AssembleOutput(List<Vector<T>> rows)
     /// <inheritdoc/>
     public override IFullModel<T, TInput, TOutput> WithParameters(Vector<T> parameters)
         => new MbPAAdaptedModel<T, TInput, TOutput>(BaseModel, _memory, parameters, _options);
-
-    /// <inheritdoc/>
-    /// <remarks>
-    /// The episodic memory is SHARED with the algorithm rather than copied. That is deliberate: the
-    /// memory is the algorithm's accumulated experience, and a deep copy that forked it would let
-    /// the copy's writes silently diverge from the original's.
-    /// </remarks>
-    public override IFullModel<T, TInput, TOutput> DeepCopy()
-        => new MbPAAdaptedModel<T, TInput, TOutput>(
-            BaseModel.DeepCopy(), _memory, _trainedOutputParams.Clone(), _options);
 }
diff --git a/src/MetaLearning/Algorithms/MbPAAlgorithm.cs b/src/MetaLearning/Algorithms/MbPAAlgorithm.cs
index 8a7e6a0f75..5ce974b5eb 100644
--- a/src/MetaLearning/Algorithms/MbPAAlgorithm.cs
+++ b/src/MetaLearning/Algorithms/MbPAAlgorithm.cs
@@ -113,6 +113,7 @@ public partial class MbPAAlgorithm<T, TInput, TOutput> : MetaLearnerBase<T, TInp
     /// [OutputDimension * FeatureDimension weights | OutputDimension biases]. This — and only this —
     /// is what local adaptation modifies.
     /// </summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T> _outputParams;
 
     /// <inheritdoc/>
diff --git a/src/MetaLearning/Algorithms/MbPAHeadLoss.cs b/src/MetaLearning/Algorithms/MbPAHeadLoss.cs
index 5fbd629512..6d4dddc0b7 100644
--- a/src/MetaLearning/Algorithms/MbPAHeadLoss.cs
+++ b/src/MetaLearning/Algorithms/MbPAHeadLoss.cs
@@ -41,10 +41,11 @@ namespace AiDotNet.MetaLearning.Algorithms;
 /// coarser gradient for a ragged one, rather than an index out of range in the middle of training.
 /// </para>
 /// </remarks>
-internal sealed class MbPAHeadLoss<T> : ILossFunction<T>
+internal sealed partial class MbPAHeadLoss<T> : ILossFunction<T>
 {
     private static readonly INumericOperations<T> Ops = MathHelper.GetNumericOperations<T>();
 
+    [AiDotNet.Attributes.TrainableParameter]
     private readonly Vector<T> _headParameters;
     private readonly int _featureDim;
     private readonly int _outputDim;
diff --git a/src/MetaLearning/Algorithms/MetaDDPMAlgorithm.cs b/src/MetaLearning/Algorithms/MetaDDPMAlgorithm.cs
index 65ab7e14b9..98d03daebf 100644
--- a/src/MetaLearning/Algorithms/MetaDDPMAlgorithm.cs
+++ b/src/MetaLearning/Algorithms/MetaDDPMAlgorithm.cs
@@ -77,6 +77,7 @@ public partial class MetaDDPMAlgorithm<T, TInput, TOutput> : MetaLearnerBase<T,
     private readonly double[] _posteriorVariance;
 
     /// <summary>Denoiser (noise predictor) parameters.</summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T> _denoiserParams;
 
     /// <summary>EMA copy of denoiser parameters for stable generation.</summary>
diff --git a/src/MetaLearning/Algorithms/MetaDMAlgorithm.cs b/src/MetaLearning/Algorithms/MetaDMAlgorithm.cs
index 5881cfd7a6..ba6d50ca94 100644
--- a/src/MetaLearning/Algorithms/MetaDMAlgorithm.cs
+++ b/src/MetaLearning/Algorithms/MetaDMAlgorithm.cs
@@ -73,6 +73,7 @@ public partial class MetaDMAlgorithm<T, TInput, TOutput> : MetaLearnerBase<T, TI
     private readonly MetaDMOptions<T, TInput, TOutput> _algoOptions;
 
     /// <summary>Feature denoiser parameters for generating synthetic features.</summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T> _denoiserParams;
 
     /// <summary>Noise schedule.</summary>
diff --git a/src/MetaLearning/Algorithms/MetaDiffAlgorithm.cs b/src/MetaLearning/Algorithms/MetaDiffAlgorithm.cs
index ce562dec66..d2a4456e0c 100644
--- a/src/MetaLearning/Algorithms/MetaDiffAlgorithm.cs
+++ b/src/MetaLearning/Algorithms/MetaDiffAlgorithm.cs
@@ -80,9 +80,11 @@ public partial class MetaDiffAlgorithm<T, TInput, TOutput> : MetaLearnerBase<T,
     private readonly double[] _alphasCumprod;
 
     /// <summary>Denoiser network parameters (task-conditional noise predictor).</summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T> _denoiserParams;
 
     /// <summary>Task encoder parameters: maps support features to conditioning vector.</summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T> _taskEncoderParams;
 
     private readonly int _paramDim;
diff --git a/src/MetaLearning/Algorithms/MetaLoRAAlgorithm.cs b/src/MetaLearning/Algorithms/MetaLoRAAlgorithm.cs
index 0cb3ecb710..dc4b623b04 100644
--- a/src/MetaLearning/Algorithms/MetaLoRAAlgorithm.cs
+++ b/src/MetaLearning/Algorithms/MetaLoRAAlgorithm.cs
@@ -72,11 +72,13 @@ public partial class MetaLoRAAlgorithm<T, TInput, TOutput> : MetaLearnerBase<T,
     /// Low-rank basis vectors stored as a flat vector of length rank * paramDim.
     /// Basis vector i occupies indices [i*paramDim, (i+1)*paramDim).
     /// </summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T> _loraBasis;
 
     /// <summary>
     /// Meta-learned initial coefficients for the low-rank basis (length = rank).
     /// </summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T> _loraCoeffInit;
 
     private readonly int _paramDim;
diff --git a/src/MetaLearning/Algorithms/MetaLoRABankAlgorithm.cs b/src/MetaLearning/Algorithms/MetaLoRABankAlgorithm.cs
index d10be87703..28785807c2 100644
--- a/src/MetaLearning/Algorithms/MetaLoRABankAlgorithm.cs
+++ b/src/MetaLearning/Algorithms/MetaLoRABankAlgorithm.cs
@@ -69,12 +69,14 @@ public partial class MetaLoRABankAlgorithm<T, TInput, TOutput> : MetaLearnerBase
     /// Bank of LoRA modules. Each module is a low-rank basis vector in parameter space
     /// (length = rank * paramDim). Module k's basis vectors start at k * rank * paramDim.
     /// </summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T> _moduleBank;
 
     /// <summary>
     /// Gating network parameters: maps task embeddings to module scores.
     /// Linear: embeddingDim → bankSize (weights + bias).
     /// </summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T> _gatingParams;
 
     private readonly int _paramDim;
diff --git a/src/MetaLearning/Algorithms/MetaOptNetAlgorithm.cs b/src/MetaLearning/Algorithms/MetaOptNetAlgorithm.cs
index f1d1376029..c3da2ac4e2 100644
--- a/src/MetaLearning/Algorithms/MetaOptNetAlgorithm.cs
+++ b/src/MetaLearning/Algorithms/MetaOptNetAlgorithm.cs
@@ -78,7 +78,7 @@ namespace AiDotNet.MetaLearning.Algorithms;
     Authors = "Kwonjoon Lee, Subhransu Maji, Avinash Ravichandran, Stefano Soatto")]
 [ComponentType(ComponentType.MetaLearner)]
 [PipelineStage(PipelineStage.Training)]
-public class MetaOptNetAlgorithm<T, TInput, TOutput> : MetaLearnerBase<T, TInput, TOutput>
+public partial class MetaOptNetAlgorithm<T, TInput, TOutput> : MetaLearnerBase<T, TInput, TOutput>
 {
     private readonly MetaOptNetOptions<T, TInput, TOutput> _metaOptNetOptions;
 
diff --git a/src/MetaLearning/Algorithms/MetaPACOHAlgorithm.cs b/src/MetaLearning/Algorithms/MetaPACOHAlgorithm.cs
index c22415fef7..bca2ae89b5 100644
--- a/src/MetaLearning/Algorithms/MetaPACOHAlgorithm.cs
+++ b/src/MetaLearning/Algorithms/MetaPACOHAlgorithm.cs
@@ -68,6 +68,7 @@ public partial class MetaPACOHAlgorithm<T, TInput, TOutput> : MetaLearnerBase<T,
     private Vector<T> _priorMean;
 
     /// <summary>Per-group prior log-variances. Length = NumPriorGroups.</summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T> _groupLogVars;
 
     /// <summary>Group assignments: _groupOf[d] = group index for parameter d.</summary>
diff --git a/src/MetaLearning/Algorithms/MetaSGDAlgorithm.cs b/src/MetaLearning/Algorithms/MetaSGDAlgorithm.cs
index b2e018ec4c..04e246d174 100644
--- a/src/MetaLearning/Algorithms/MetaSGDAlgorithm.cs
+++ b/src/MetaLearning/Algorithms/MetaSGDAlgorithm.cs
@@ -715,13 +715,18 @@ public class PerParameterOptimizer<T, TInput, TOutput>
     private readonly IEngine _engine;
 
     // Per-parameter learned coefficients (Vector<T> for Engine vectorization)
+    [AiDotNet.Attributes.Scratch]
     private Vector<T> _learningRates;
+    [AiDotNet.Attributes.Scratch]
     private Vector<T> _momentums;
     private Vector<T> _directions;
 
     // Adam-specific parameters
+    [AiDotNet.Attributes.Scratch]
     private Vector<T> _adamBeta1;
+    [AiDotNet.Attributes.Scratch]
     private Vector<T> _adamBeta2;
+    [AiDotNet.Attributes.Scratch]
     private Vector<T> _adamEpsilon;
 
     // Optimizer state
diff --git a/src/MetaLearning/Algorithms/NPAlgorithm.cs b/src/MetaLearning/Algorithms/NPAlgorithm.cs
index 98b5671398..122822a4da 100644
--- a/src/MetaLearning/Algorithms/NPAlgorithm.cs
+++ b/src/MetaLearning/Algorithms/NPAlgorithm.cs
@@ -47,6 +47,7 @@ namespace AiDotNet.MetaLearning.Algorithms;
 public partial class NPAlgorithm<T, TInput, TOutput> : NeuralProcessBase<T, TInput, TOutput>
 {
     private readonly NPOptions<T, TInput, TOutput> _npOptions;
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T> _latentEncoderParams;
 
     /// <inheritdoc/>
diff --git a/src/MetaLearning/Algorithms/NPBMLAlgorithm.cs b/src/MetaLearning/Algorithms/NPBMLAlgorithm.cs
index 6e1c64c701..22e23329f5 100644
--- a/src/MetaLearning/Algorithms/NPBMLAlgorithm.cs
+++ b/src/MetaLearning/Algorithms/NPBMLAlgorithm.cs
@@ -108,9 +108,11 @@ public partial class NPBMLAlgorithm<T, TInput, TOutput> : MetaLearnerBase<T, TIn
     private readonly NPBMLOptions<T, TInput, TOutput> _npbmlOptions;
 
     /// <summary>Parameters for the encoder (support set -> latent distribution).</summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T> _encoderParams = new Vector<T>(0);
 
     /// <summary>Parameters for the decoder (latent + query -> predictions).</summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T> _decoderParams = new Vector<T>(0);
 
     /// <inheritdoc/>
diff --git a/src/MetaLearning/Algorithms/NTMAlgorithm.cs b/src/MetaLearning/Algorithms/NTMAlgorithm.cs
index 27ad434ad7..363831832f 100644
--- a/src/MetaLearning/Algorithms/NTMAlgorithm.cs
+++ b/src/MetaLearning/Algorithms/NTMAlgorithm.cs
@@ -112,7 +112,7 @@ namespace AiDotNet.MetaLearning.Algorithms;
     Authors = "Alex Graves, Greg Wayne, Ivo Danihelka")]
 [ComponentType(ComponentType.MetaLearner)]
 [PipelineStage(PipelineStage.Training)]
-public class NTMAlgorithm<T, TInput, TOutput> : MetaLearnerBase<T, TInput, TOutput>
+public partial class NTMAlgorithm<T, TInput, TOutput> : MetaLearnerBase<T, TInput, TOutput>
 {
     private readonly NTMOptions<T, TInput, TOutput> _ntmOptions;
 
@@ -984,6 +984,7 @@ public class NTMMemory<T>
     private readonly int _width;
     private readonly int? _randomSeed;
     private readonly Random _random;
+    [Scratch]
     private Vector<T>? _lastWriteWeights;  // Track last write weights for sharpness computation
 
     /// <summary>
@@ -1301,6 +1302,7 @@ public class LSTMNTMController<T, TInput, TOutput> : INTMController<T>
 
     // LSTM gate weights: input, forget, cell, output gates
     // Input weights: [4 * hiddenSize, inputSize]
+    [AiDotNet.Attributes.Scratch]
     private Tensor<T> _weightsInput;
     // Hidden weights: [4 * hiddenSize, hiddenSize]
     private readonly Tensor<T> _weightsHidden;
@@ -1746,6 +1748,7 @@ public class MLPNTMController<T, TInput, TOutput> : INTMController<T>
     private readonly Tensor<T> _outputBiases;      // [outputSize]
 
     // Cached hidden state for projection operations
+    [Scratch]
     private Tensor<T> _lastHiddenState;
 
     /// <summary>
diff --git a/src/MetaLearning/Algorithms/NeuralProcessBase.cs b/src/MetaLearning/Algorithms/NeuralProcessBase.cs
index f0fc2a2dd8..f29c795b8c 100644
--- a/src/MetaLearning/Algorithms/NeuralProcessBase.cs
+++ b/src/MetaLearning/Algorithms/NeuralProcessBase.cs
@@ -41,7 +41,7 @@ namespace AiDotNet.MetaLearning.Algorithms;
 /// - ANP: Adds attention for better predictions
 /// </para>
 /// </remarks>
-public abstract class NeuralProcessBase<T, TInput, TOutput> : MetaLearnerBase<T, TInput, TOutput>
+public abstract partial class NeuralProcessBase<T, TInput, TOutput> : MetaLearnerBase<T, TInput, TOutput>
 {
     private IParameterizable<T, TInput, TOutput>? _cachedParamModel;
     private IParameterizable<T, TInput, TOutput> ParamModel => _cachedParamModel ??= InterfaceGuard.Parameterizable(MetaModel);
@@ -335,7 +335,7 @@ protected IModel<TInput, TOutput, ModelMetadata<T>> StandardNPAdapt(IMetaLearnin
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
 [ResearchPaper("Neural Processes", "https://arxiv.org/abs/1807.01622")]
-public class NeuralProcessModel<T, TInput, TOutput> : MetaLearningModelBase<T, TInput, TOutput>, IAdaptedMetaModel<T>
+public partial class NeuralProcessModel<T, TInput, TOutput> : MetaLearningModelBase<T, TInput, TOutput>, IAdaptedMetaModel<T>
 {
 
     /// <inheritdoc />
@@ -343,10 +343,10 @@ public class NeuralProcessModel<T, TInput, TOutput> : MetaLearningModelBase<T, T
     protected override void RegisterComponents()
     {
         RegisterParameterComponent(new VectorFieldParameterSource<T>(
-            () => _params,
-            value => _params = value));
+            () => _parameters,
+            value => _parameters = value));
     }
-    private Vector<T> _params;
+    private Vector<T> _parameters;
     private readonly Vector<T>? _contextRepresentation;
 
     public Vector<T>? AdaptedSupportFeatures => _contextRepresentation;
@@ -358,13 +358,13 @@ public NeuralProcessModel(
         Vector<T>? contextRepresentation)
         : base(model)
     {
-        _params = parameters;
+        _parameters = parameters;
         _contextRepresentation = contextRepresentation;
     }
 
     public override TOutput Predict(TInput input)
     {
-        InterfaceGuard.Parameterizable(BaseModel).SetParameters(_params);
+        InterfaceGuard.Parameterizable(BaseModel).SetParameters(_parameters);
         return BaseModel.Predict(input);
     }
 
@@ -372,10 +372,4 @@ public override IFullModel<T, TInput, TOutput> WithParameters(Vector<T> paramete
     {
         return new NeuralProcessModel<T, TInput, TOutput>(BaseModel, parameters, _contextRepresentation);
     }
-
-    public override IFullModel<T, TInput, TOutput> DeepCopy()
-    {
-        return new NeuralProcessModel<T, TInput, TOutput>(
-            BaseModel.DeepCopy(), _params.Clone(), _contextRepresentation?.Clone());
-    }
 }
diff --git a/src/MetaLearning/Algorithms/OpenMAMLPlusAlgorithm.cs b/src/MetaLearning/Algorithms/OpenMAMLPlusAlgorithm.cs
index 8ed43ae275..93c973aaa4 100644
--- a/src/MetaLearning/Algorithms/OpenMAMLPlusAlgorithm.cs
+++ b/src/MetaLearning/Algorithms/OpenMAMLPlusAlgorithm.cs
@@ -76,9 +76,11 @@ public partial class OpenMAMLPlusAlgorithm<T, TInput, TOutput> : MetaLearnerBase
     private readonly int _paramDim;
 
     /// <summary>Meta-learned per-parameter learning rates (MAML++ style).</summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T> _perParamLR;
 
     /// <summary>Meta-learned novelty threshold (on prediction entropy).</summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T> _noveltyThreshold;
 
     /// <inheritdoc/>
diff --git a/src/MetaLearning/Algorithms/PACOHAlgorithm.cs b/src/MetaLearning/Algorithms/PACOHAlgorithm.cs
index cb130ed9b6..d43d1e6d77 100644
--- a/src/MetaLearning/Algorithms/PACOHAlgorithm.cs
+++ b/src/MetaLearning/Algorithms/PACOHAlgorithm.cs
@@ -70,6 +70,7 @@ public partial class PACOHAlgorithm<T, TInput, TOutput> : MetaLearnerBase<T, TIn
     private Vector<T> _priorMean;
 
     /// <summary>Prior log-variance (meta-learned). Per-parameter log(σ²).</summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T> _priorLogVar;
 
     private readonly int _paramDim;
diff --git a/src/MetaLearning/Algorithms/PEARLAlgorithm.cs b/src/MetaLearning/Algorithms/PEARLAlgorithm.cs
index 4aeec475c9..e8bbd5d21a 100644
--- a/src/MetaLearning/Algorithms/PEARLAlgorithm.cs
+++ b/src/MetaLearning/Algorithms/PEARLAlgorithm.cs
@@ -66,9 +66,11 @@ public partial class PEARLAlgorithm<T, TInput, TOutput> : MetaLearnerBase<T, TIn
     private const double SpsaLearningRateMultiplier = 0.1;
 
     /// <summary>Encoder parameters: maps compressed gradient → (μ, log_σ²) of size 2*latentDim.</summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T> _encoderParams;
 
     /// <summary>Projection matrix W_z: maps z (latentDim) → parameter delta (compressedDim).</summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T> _projectionParams;
 
     /// <inheritdoc/>
diff --git a/src/MetaLearning/Algorithms/ProtoNetsAlgorithm.cs b/src/MetaLearning/Algorithms/ProtoNetsAlgorithm.cs
index 5f29efaf4e..5f3adc1005 100644
--- a/src/MetaLearning/Algorithms/ProtoNetsAlgorithm.cs
+++ b/src/MetaLearning/Algorithms/ProtoNetsAlgorithm.cs
@@ -107,6 +107,7 @@ public partial class ProtoNetsAlgorithm<T, TInput, TOutput> : MetaLearnerBase<T,
     /// <summary>
     /// Attention weights for prototype enhancement (if enabled).
     /// </summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private Matrix<T>? _attentionWeights;
 
     /// <summary>
diff --git a/src/MetaLearning/Algorithms/RCNPAlgorithm.cs b/src/MetaLearning/Algorithms/RCNPAlgorithm.cs
index f5909bef74..57ea9e0d0d 100644
--- a/src/MetaLearning/Algorithms/RCNPAlgorithm.cs
+++ b/src/MetaLearning/Algorithms/RCNPAlgorithm.cs
@@ -25,7 +25,7 @@ namespace AiDotNet.MetaLearning.Algorithms;
     Authors = "Timon Willi, Jonathan Masci, Juergen Schmidhuber, Christian Osendorfer")]
 [ComponentType(ComponentType.MetaLearner)]
 [PipelineStage(PipelineStage.Training)]
-public class RCNPAlgorithm<T, TInput, TOutput> : NeuralProcessBase<T, TInput, TOutput>
+public partial class RCNPAlgorithm<T, TInput, TOutput> : NeuralProcessBase<T, TInput, TOutput>
 {
     private readonly RCNPOptions<T, TInput, TOutput> _algoOptions;
 
diff --git a/src/MetaLearning/Algorithms/RecurrentHyperNetAlgorithm.cs b/src/MetaLearning/Algorithms/RecurrentHyperNetAlgorithm.cs
index 7c2d23b160..4e1bf77387 100644
--- a/src/MetaLearning/Algorithms/RecurrentHyperNetAlgorithm.cs
+++ b/src/MetaLearning/Algorithms/RecurrentHyperNetAlgorithm.cs
@@ -64,6 +64,7 @@ public partial class RecurrentHyperNetAlgorithm<T, TInput, TOutput> : MetaLearne
     private const double SpsaLearningRateMultiplier = 0.1;
 
     /// <summary>GRU weights: W_z, W_r, W_h — each (hidDim + inputDim) × hidDim.</summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T> _gruWeights;
 
     /// <inheritdoc/>
diff --git a/src/MetaLearning/Algorithms/ReptileAlgorithm.cs b/src/MetaLearning/Algorithms/ReptileAlgorithm.cs
index 2dcc461eab..99e4ae1186 100644
--- a/src/MetaLearning/Algorithms/ReptileAlgorithm.cs
+++ b/src/MetaLearning/Algorithms/ReptileAlgorithm.cs
@@ -66,7 +66,7 @@ namespace AiDotNet.MetaLearning.Algorithms;
     Authors = "Alex Nichol, Joshua Achiam, John Schulman")]
 [ComponentType(ComponentType.MetaLearner)]
 [PipelineStage(PipelineStage.Training)]
-public class ReptileAlgorithm<T, TInput, TOutput> : MetaLearnerBase<T, TInput, TOutput>
+public partial class ReptileAlgorithm<T, TInput, TOutput> : MetaLearnerBase<T, TInput, TOutput>
 {
     private readonly ReptileOptions<T, TInput, TOutput> _reptileOptions;
 
diff --git a/src/MetaLearning/Algorithms/SDCLAlgorithm.cs b/src/MetaLearning/Algorithms/SDCLAlgorithm.cs
index 66e998162f..c01af85a13 100644
--- a/src/MetaLearning/Algorithms/SDCLAlgorithm.cs
+++ b/src/MetaLearning/Algorithms/SDCLAlgorithm.cs
@@ -65,6 +65,7 @@ public partial class SDCLAlgorithm<T, TInput, TOutput> : MetaLearnerBase<T, TInp
     private readonly int _paramDim;
 
     /// <summary>Teacher model parameters (EMA of student).</summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T> _teacherParams;
 
     /// <inheritdoc/>
diff --git a/src/MetaLearning/Algorithms/SetFeatAlgorithm.cs b/src/MetaLearning/Algorithms/SetFeatAlgorithm.cs
index c6b5463be3..1621515292 100644
--- a/src/MetaLearning/Algorithms/SetFeatAlgorithm.cs
+++ b/src/MetaLearning/Algorithms/SetFeatAlgorithm.cs
@@ -98,9 +98,11 @@ public partial class SetFeatAlgorithm<T, TInput, TOutput> : MetaLearnerBase<T, T
     private readonly SetFeatOptions<T, TInput, TOutput> _setFeatOptions;
 
     /// <summary>Parameters for the set encoder.</summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T> _setEncoderParams = new Vector<T>(0);
 
     /// <summary>Parameters for the cross-attention module.</summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T> _crossAttentionParams = new Vector<T>(0);
 
     /// <inheritdoc/>
diff --git a/src/MetaLearning/Algorithms/SparseMAMLAlgorithm.cs b/src/MetaLearning/Algorithms/SparseMAMLAlgorithm.cs
index d7d7a86a7f..0ee0edfee3 100644
--- a/src/MetaLearning/Algorithms/SparseMAMLAlgorithm.cs
+++ b/src/MetaLearning/Algorithms/SparseMAMLAlgorithm.cs
@@ -99,12 +99,14 @@ public partial class SparseMAMLAlgorithm<T, TInput, TOutput> : MetaLearnerBase<T
     private readonly int _paramDim;
 
     /// <summary>phi — one learned logit per parameter; the gate is its sigmoid.</summary>
+    [AiDotNet.Attributes.Buffer]
     private Vector<T> _gateLogits;
 
     /// <summary>
     /// Meta-learned per-parameter learning-rate multipliers, for the paper's "more expressive model
     /// where learning rates are meta-learned". Null unless that variant is enabled.
     /// </summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T>? _perParameterRates;
 
     /// <inheritdoc/>
diff --git a/src/MetaLearning/Algorithms/SteerCNPAlgorithm.cs b/src/MetaLearning/Algorithms/SteerCNPAlgorithm.cs
index b7665c4c10..c91ef5056a 100644
--- a/src/MetaLearning/Algorithms/SteerCNPAlgorithm.cs
+++ b/src/MetaLearning/Algorithms/SteerCNPAlgorithm.cs
@@ -25,7 +25,7 @@ namespace AiDotNet.MetaLearning.Algorithms;
     Authors = "Peter Holderrieth, Michael J. Hutchinson, Yee Whye Teh")]
 [ComponentType(ComponentType.MetaLearner)]
 [PipelineStage(PipelineStage.Training)]
-public class SteerCNPAlgorithm<T, TInput, TOutput> : NeuralProcessBase<T, TInput, TOutput>
+public partial class SteerCNPAlgorithm<T, TInput, TOutput> : NeuralProcessBase<T, TInput, TOutput>
 {
     private readonly SteerCNPOptions<T, TInput, TOutput> _algoOptions;
 
diff --git a/src/MetaLearning/Algorithms/SwinTNPAlgorithm.cs b/src/MetaLearning/Algorithms/SwinTNPAlgorithm.cs
index 46310829ec..e645bf8139 100644
--- a/src/MetaLearning/Algorithms/SwinTNPAlgorithm.cs
+++ b/src/MetaLearning/Algorithms/SwinTNPAlgorithm.cs
@@ -26,7 +26,7 @@ namespace AiDotNet.MetaLearning.Algorithms;
     Authors = "Tung Nguyen, Aditya Grover")]
 [ComponentType(ComponentType.MetaLearner)]
 [PipelineStage(PipelineStage.Training)]
-public class SwinTNPAlgorithm<T, TInput, TOutput> : NeuralProcessBase<T, TInput, TOutput>
+public partial class SwinTNPAlgorithm<T, TInput, TOutput> : NeuralProcessBase<T, TInput, TOutput>
 {
     private readonly SwinTNPOptions<T, TInput, TOutput> _algoOptions;
 
diff --git a/src/MetaLearning/Algorithms/TADAMAlgorithm.cs b/src/MetaLearning/Algorithms/TADAMAlgorithm.cs
index 93fe27e18b..6be2ad14c8 100644
--- a/src/MetaLearning/Algorithms/TADAMAlgorithm.cs
+++ b/src/MetaLearning/Algorithms/TADAMAlgorithm.cs
@@ -110,6 +110,7 @@ public partial class TADAMAlgorithm<T, TInput, TOutput> : MetaLearnerBase<T, TIn
     private readonly TADAMOptions<T, TInput, TOutput> _tadamOptions;
 
     // Learnable metric scaling parameters (alpha)
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T> _metricScale;
 
     // Learnable temperature parameter
diff --git a/src/MetaLearning/Algorithms/TETNPAlgorithm.cs b/src/MetaLearning/Algorithms/TETNPAlgorithm.cs
index f64e7e9e03..9945d30833 100644
--- a/src/MetaLearning/Algorithms/TETNPAlgorithm.cs
+++ b/src/MetaLearning/Algorithms/TETNPAlgorithm.cs
@@ -47,6 +47,7 @@ namespace AiDotNet.MetaLearning.Algorithms;
 public partial class TETNPAlgorithm<T, TInput, TOutput> : NeuralProcessBase<T, TInput, TOutput>
 {
     private readonly TETNPOptions<T, TInput, TOutput> _algoOptions;
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T> _relPosParams;
     private readonly int _numBands;
     private readonly int _numHeads;
diff --git a/src/MetaLearning/Algorithms/TNPAlgorithm.cs b/src/MetaLearning/Algorithms/TNPAlgorithm.cs
index e7cffc216f..3275f8d48b 100644
--- a/src/MetaLearning/Algorithms/TNPAlgorithm.cs
+++ b/src/MetaLearning/Algorithms/TNPAlgorithm.cs
@@ -26,7 +26,7 @@ namespace AiDotNet.MetaLearning.Algorithms;
     Authors = "Nguyen, T. & Grover, A.")]
 [ComponentType(ComponentType.MetaLearner)]
 [PipelineStage(PipelineStage.Training)]
-public class TNPAlgorithm<T, TInput, TOutput> : NeuralProcessBase<T, TInput, TOutput>
+public partial class TNPAlgorithm<T, TInput, TOutput> : NeuralProcessBase<T, TInput, TOutput>
 {
     private readonly TNPOptions<T, TInput, TOutput> _algoOptions;
 
diff --git a/src/MetaLearning/Algorithms/TaskCondHyperNetAlgorithm.cs b/src/MetaLearning/Algorithms/TaskCondHyperNetAlgorithm.cs
index e11127ecbc..c2010c1b2b 100644
--- a/src/MetaLearning/Algorithms/TaskCondHyperNetAlgorithm.cs
+++ b/src/MetaLearning/Algorithms/TaskCondHyperNetAlgorithm.cs
@@ -61,6 +61,7 @@ public partial class TaskCondHyperNetAlgorithm<T, TInput, TOutput> : MetaLearner
     private readonly int _numChunks;
 
     /// <summary>Hypernetwork weights: W_h (embDim × hiddenDim) + b_h (hiddenDim) + per-chunk W_c (hiddenDim × chunkSize).</summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T> _hyperNetWeights;
 
     /// <inheritdoc/>
diff --git a/src/MetaLearning/Algorithms/VERSAAlgorithm.cs b/src/MetaLearning/Algorithms/VERSAAlgorithm.cs
index 3ff23305c6..860bc298de 100644
--- a/src/MetaLearning/Algorithms/VERSAAlgorithm.cs
+++ b/src/MetaLearning/Algorithms/VERSAAlgorithm.cs
@@ -103,6 +103,7 @@ public partial class VERSAAlgorithm<T, TInput, TOutput> : MetaLearnerBase<T, TIn
     /// <summary>
     /// Amortization network parameters that produce classifier weights from support features.
     /// </summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T> _amortizationParams = new Vector<T>(0);
 
     /// <inheritdoc/>
diff --git a/src/MetaLearning/Algorithms/iMAMLAlgorithm.cs b/src/MetaLearning/Algorithms/iMAMLAlgorithm.cs
index 534a308def..fea83179d2 100644
--- a/src/MetaLearning/Algorithms/iMAMLAlgorithm.cs
+++ b/src/MetaLearning/Algorithms/iMAMLAlgorithm.cs
@@ -68,7 +68,7 @@ namespace AiDotNet.MetaLearning.Algorithms;
     Authors = "Aravind Rajeswaran, Chelsea Finn, Sham M. Kakade, Sergey Levine")]
 [ComponentType(ComponentType.MetaLearner)]
 [PipelineStage(PipelineStage.Training)]
-public class iMAMLAlgorithm<T, TInput, TOutput> : MetaLearnerBase<T, TInput, TOutput>
+public partial class iMAMLAlgorithm<T, TInput, TOutput> : MetaLearnerBase<T, TInput, TOutput>
 {
     private readonly iMAMLOptions<T, TInput, TOutput> _imamlOptions;
 
diff --git a/src/MetaLearning/Components/ImplicitPosteriorGenerator.cs b/src/MetaLearning/Components/ImplicitPosteriorGenerator.cs
index 589f1b770d..c2374c28b2 100644
--- a/src/MetaLearning/Components/ImplicitPosteriorGenerator.cs
+++ b/src/MetaLearning/Components/ImplicitPosteriorGenerator.cs
@@ -38,7 +38,7 @@ namespace AiDotNet.MetaLearning.Components;
 /// it again with different random numbers and you get a different plausible set. The collection of
 /// everything it can output IS the uncertainty, and it can be any shape at all.</para>
 /// </remarks>
-public class ImplicitPosteriorGenerator<T>
+public partial class ImplicitPosteriorGenerator<T>
 {
     private static readonly INumericOperations<T> NumOps = MathHelper.GetNumericOperations<T>();
 
@@ -62,6 +62,7 @@ public class ImplicitPosteriorGenerator<T>
     // Flat lambda layout, in this order: W1, b1, W2, b2, W3, b3.
     private readonly int _w1, _b1, _w2, _b2, _w3, _b3;
 
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T> _lambda;
 
     /// <summary>Gets the dimension of the generated parameter vector.</summary>
diff --git a/src/MetaLearning/MetaLearnerBase.cs b/src/MetaLearning/MetaLearnerBase.cs
index a7c4c56382..1e85d0a32a 100644
--- a/src/MetaLearning/MetaLearnerBase.cs
+++ b/src/MetaLearning/MetaLearnerBase.cs
@@ -43,7 +43,7 @@ namespace AiDotNet.MetaLearning;
 /// 5. All shared functionality (metrics, saving, evaluation) is handled automatically
 /// </para>
 /// </remarks>
-public abstract class MetaLearnerBase<T, TInput, TOutput> : ModelBase<T, TInput, TOutput>, IMetaLearner<T, TInput, TOutput>, IConfigurableModel<T>
+public abstract partial class MetaLearnerBase<T, TInput, TOutput> : ModelBase<T, TInput, TOutput>, IMetaLearner<T, TInput, TOutput>, IConfigurableModel<T>
 {
 
     /// <inheritdoc />
diff --git a/src/MetaLearning/Models/ANILModel.cs b/src/MetaLearning/Models/ANILModel.cs
index 23b17e65d4..aecdc9d86b 100644
--- a/src/MetaLearning/Models/ANILModel.cs
+++ b/src/MetaLearning/Models/ANILModel.cs
@@ -47,10 +47,12 @@ namespace AiDotNet.MetaLearning.Models;
     Authors = "Raghu, A., Raghu, M., Bengio, S., & Vinyals, O.")]
 [ComponentType(ComponentType.MetaLearner)]
 [PipelineStage(PipelineStage.Training)]
-public class ANILModel<T, TInput, TOutput> : IModel<TInput, TOutput, ModelMetadata<T>>
+public partial class ANILModel<T, TInput, TOutput> : IModel<TInput, TOutput, ModelMetadata<T>>
 {
     private readonly IFullModel<T, TInput, TOutput> _featureExtractor;
+    [AiDotNet.Attributes.TrainableParameter]
     private readonly Vector<T> _headWeights;
+    [AiDotNet.Attributes.TrainableParameter]
     private readonly Vector<T>? _headBias;
     private readonly ANILOptions<T, TInput, TOutput> _options;
 
diff --git a/src/MetaLearning/Models/BOILModel.cs b/src/MetaLearning/Models/BOILModel.cs
index a244515f94..7a27a85637 100644
--- a/src/MetaLearning/Models/BOILModel.cs
+++ b/src/MetaLearning/Models/BOILModel.cs
@@ -48,13 +48,16 @@ namespace AiDotNet.MetaLearning.Models;
     Authors = "Oh, J., Yoo, H., Kim, C., & Yun, S.")]
 [ComponentType(ComponentType.MetaLearner)]
 [PipelineStage(PipelineStage.Training)]
-public class BOILModel<T, TInput, TOutput> : IModel<TInput, TOutput, ModelMetadata<T>>
+public partial class BOILModel<T, TInput, TOutput> : IModel<TInput, TOutput, ModelMetadata<T>>
 {
     private static readonly INumericOperations<T> NumOps = MathHelper.GetNumericOperations<T>();
 
     private readonly IFullModel<T, TInput, TOutput> _baseModel;
+    [AiDotNet.Attributes.TrainableParameter]
     private readonly Vector<T> _adaptedBodyParams;
+    [AiDotNet.Attributes.TrainableParameter]
     private readonly Vector<T> _headWeights;
+    [AiDotNet.Attributes.TrainableParameter]
     private readonly Vector<T>? _headBias;
     private readonly BOILOptions<T, TInput, TOutput> _options;
 
diff --git a/src/MetaLearning/Models/LEOModel.cs b/src/MetaLearning/Models/LEOModel.cs
index 752cd9eec5..adf2576ecb 100644
--- a/src/MetaLearning/Models/LEOModel.cs
+++ b/src/MetaLearning/Models/LEOModel.cs
@@ -44,12 +44,14 @@ namespace AiDotNet.MetaLearning.Models;
     Authors = "Rusu, A. A., Rao, D., Sygnowski, J., Vinyals, O., Pascanu, R., Osindero, S., & Hadsell, R.")]
 [ComponentType(ComponentType.MetaLearner)]
 [PipelineStage(PipelineStage.Training)]
-public class LEOModel<T, TInput, TOutput> : IModel<TInput, TOutput, ModelMetadata<T>>
+public partial class LEOModel<T, TInput, TOutput> : IModel<TInput, TOutput, ModelMetadata<T>>
 {
     private static readonly INumericOperations<T> NumOps = MathHelper.GetNumericOperations<T>();
 
     private readonly IFullModel<T, TInput, TOutput> _featureEncoder;
+    [AiDotNet.Attributes.TrainableParameter]
     private readonly Vector<T> _classifierParams;
+    [AiDotNet.Attributes.TrainableParameter]
     private readonly Vector<T> _latentCode;
     private readonly LEOOptions<T, TInput, TOutput> _options;
 
diff --git a/src/MetaLearning/Models/LinearVectorModel.cs b/src/MetaLearning/Models/LinearVectorModel.cs
index 8ecba4b7b9..ef30592212 100644
--- a/src/MetaLearning/Models/LinearVectorModel.cs
+++ b/src/MetaLearning/Models/LinearVectorModel.cs
@@ -42,6 +42,7 @@ namespace AiDotNet.MetaLearning.Models;
 [PipelineStage(PipelineStage.Training)]
 public partial class LinearVectorModel : ModelBase<double, Matrix<double>, Vector<double>>, ICloneable
 {
+    [FittedParameter]
     private Vector<double> _parameters;
     private readonly int _inputDim;
     private readonly double _learningRate;
@@ -117,14 +118,6 @@ public override IFullModel<double, Matrix<double>, Vector<double>> WithParameter
         return model;
     }
 
-    /// <inheritdoc/>
-    public override IFullModel<double, Matrix<double>, Vector<double>> DeepCopy()
-    {
-        var copy = new LinearVectorModel(_inputDim, _learningRate);
-        copy.SetParameters(_parameters);
-        return copy;
-    }
-
     object ICloneable.Clone() => DeepCopy();
 
     /// <inheritdoc/>
@@ -182,16 +175,6 @@ public override void ApplyGradients(Vector<double> gradients, double learningRat
         }
     }
 
-    /// <inheritdoc/>
-    public override byte[] Serialize() => Encoding.UTF8.GetBytes(SerializeParameters());
-
-    /// <inheritdoc/>
-    public override void Deserialize(byte[] data)
-    {
-        Guard.NotNull(data);
-        DeserializeParameters(Encoding.UTF8.GetString(data));
-    }
-
     /// <inheritdoc/>
     public override void SaveModel(string filePath)
     {
diff --git a/src/MetaLearning/Models/MetaOptNetModel.cs b/src/MetaLearning/Models/MetaOptNetModel.cs
index 3f180957c9..4aab1697f7 100644
--- a/src/MetaLearning/Models/MetaOptNetModel.cs
+++ b/src/MetaLearning/Models/MetaOptNetModel.cs
@@ -43,11 +43,12 @@ namespace AiDotNet.MetaLearning.Models;
     Authors = "Lee, K., Maji, S., Ravichandran, A., & Soatto, S.")]
 [ComponentType(ComponentType.MetaLearner)]
 [PipelineStage(PipelineStage.Training)]
-public class MetaOptNetModel<T, TInput, TOutput> : IModel<TInput, TOutput, ModelMetadata<T>>
+public partial class MetaOptNetModel<T, TInput, TOutput> : IModel<TInput, TOutput, ModelMetadata<T>>
 {
     private static readonly INumericOperations<T> NumOps = MathHelper.GetNumericOperations<T>();
 
     private readonly IFullModel<T, TInput, TOutput> _featureEncoder;
+    [AiDotNet.Attributes.TrainableParameter]
     private readonly Matrix<T> _classifierWeights;
     private readonly T _temperature;
     private readonly MetaOptNetOptions<T, TInput, TOutput> _options;
diff --git a/src/MetaLearning/Models/TADAMModel.cs b/src/MetaLearning/Models/TADAMModel.cs
index 67f32c4b30..aa3e008401 100644
--- a/src/MetaLearning/Models/TADAMModel.cs
+++ b/src/MetaLearning/Models/TADAMModel.cs
@@ -40,13 +40,14 @@ namespace AiDotNet.MetaLearning.Models;
     Authors = "Oreshkin, B. N., Rodriguez, P., & Lacoste, A.")]
 [ComponentType(ComponentType.MetaLearner)]
 [PipelineStage(PipelineStage.Training)]
-public class TADAMModel<T, TInput, TOutput> : IModel<TInput, TOutput, ModelMetadata<T>>
+public partial class TADAMModel<T, TInput, TOutput> : IModel<TInput, TOutput, ModelMetadata<T>>
 {
     private static readonly INumericOperations<T> NumOps = MathHelper.GetNumericOperations<T>();
     protected static IEngine Engine => AiDotNetEngine.Current;
 
     private readonly IFullModel<T, TInput, TOutput> _featureEncoder;
     private readonly Dictionary<int, Tensor<T>> _prototypes;
+    [AiDotNet.Attributes.TrainableParameter]
     private readonly Vector<T> _metricScale;
     private readonly T _temperature;
     private readonly TADAMOptions<T, TInput, TOutput> _options;
diff --git a/src/MetaLearning/Modules/RelationModule.cs b/src/MetaLearning/Modules/RelationModule.cs
index dac78fc2fd..f87e9b341d 100644
--- a/src/MetaLearning/Modules/RelationModule.cs
+++ b/src/MetaLearning/Modules/RelationModule.cs
@@ -40,7 +40,7 @@ namespace AiDotNet.MetaLearning.Modules;
     Authors = "Sung, F., Yang, Y., Zhang, L., Xiang, T., Torr, P. H. S., & Hospedales, T. M.")]
 [ComponentType(ComponentType.MetaLearner)]
 [PipelineStage(PipelineStage.Training)]
-public class RelationModule<T> : ModelBase<T, Tensor<T>, Tensor<T>>
+public partial class RelationModule<T> : ModelBase<T, Tensor<T>, Tensor<T>>
 {
 
     /// <inheritdoc />
@@ -57,6 +57,7 @@ protected override void RegisterComponents()
     // NumOps inherited from ModelBase
 
     private readonly int _hiddenDimension;
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T> _weights;
     private bool _isTraining;
 
@@ -162,12 +163,5 @@ public override IFullModel<T, Tensor<T>, Tensor<T>> WithParameters(Vector<T> par
         return copy;
     }
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy()
-    {
-        var cloned = Clone();
-        return cloned;
-    }
-
     #endregion
 }
diff --git a/src/Models/CloneEngine.cs b/src/Models/CloneEngine.cs
new file mode 100644
index 0000000000..ec1fdc8548
--- /dev/null
+++ b/src/Models/CloneEngine.cs
@@ -0,0 +1,854 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+
+namespace AiDotNet.Models;
+
+/// <summary>
+/// Executes a <see cref="ClonePlan"/>: reconstructs an instance and carries its configuration.
+/// </summary>
+/// <remarks>
+/// <para>
+/// This is the single implementation of "copy the configuration" in the library. Everything that
+/// clones routes through it, so a property cannot be carried correctly in one place and dropped in
+/// another — which is the failure that 1802 hand-written clone paths made possible.
+/// </para>
+/// <para>
+/// <b>Reconstruction rather than field copying.</b> A fresh instance is created and the plan's
+/// entries are applied to it. Anything not in the plan is therefore whatever the constructor
+/// produced, not a stale value carried over — so a derived or cached property is re-derived rather
+/// than duplicated. scikit-learn's <c>clone()</c> works this way for the same reason; the
+/// difference here is that the plan is generated and checked at compile time instead of relying on
+/// a constructor convention verified only at test time.
+/// </para>
+/// </remarks>
+public static class CloneEngine
+{
+    /// <summary>
+    /// Stands in a recorded constructor for "pass this parameter's declared default".
+    /// </summary>
+    /// <remarks>
+    /// Not a member name -- no C# member can be called this -- so it cannot collide with one. The
+    /// same literal is spelled out in <c>ClonePlanGenerator</c>, which lives in the analyzer assembly
+    /// and cannot be referenced from here; changing it there requires changing it here.
+    /// </remarks>
+    internal const string UseDefault = "=default";
+
+    /// <summary>
+    /// Rebuilds cloneable fitted topology when a fresh configuration shell exposes a different
+    /// parameter surface from its trained source.
+    /// </summary>
+    /// <remarks>
+    /// The flat parameter vector carries values, not structure. A learned expression/tree can
+    /// therefore expose four scalar constants in the source and none in a fresh shell. Models that
+    /// already declare serializable state remain authoritative; this narrowly bridges only an
+    /// observed count mismatch, considers mutable cloneable fields, and keeps a candidate only when
+    /// it moves the destination toward the exact expected count. Scratch and buffer fields are not
+    /// topology and are excluded.
+    /// </remarks>
+    internal static void PrepareParameterTopology(
+        object source,
+        object destination,
+        int expectedParameterCount,
+        Func<int> getDestinationParameterCount)
+    {
+        if (source is null) throw new ArgumentNullException(nameof(source));
+        if (destination is null) throw new ArgumentNullException(nameof(destination));
+        if (getDestinationParameterCount is null)
+            throw new ArgumentNullException(nameof(getDestinationParameterCount));
+        if (source.GetType() != destination.GetType()) return;
+
+        int currentCount = getDestinationParameterCount();
+        if (currentCount == expectedParameterCount) return;
+
+        const BindingFlags Flags =
+            BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly;
+        for (var current = source.GetType(); current is not null; current = current.BaseType)
+        {
+            foreach (var field in current.GetFields(Flags))
+            {
+                if (field.IsStatic || field.IsInitOnly || field.IsLiteral) continue;
+                if (field.GetCustomAttributesData().Any(attribute =>
+                        attribute.AttributeType.Name is "ScratchAttribute" or "BufferAttribute"))
+                    continue;
+
+                object? sourceValue = field.GetValue(source);
+                if (sourceValue is null) continue;
+
+                MethodInfo? cloneMethod = sourceValue.GetType().GetMethod(
+                    "Clone",
+                    BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance,
+                    binder: null,
+                    Type.EmptyTypes,
+                    modifiers: null);
+                if (cloneMethod is null
+                    || cloneMethod.ReturnType == typeof(void)
+                    || !field.FieldType.IsAssignableFrom(cloneMethod.ReturnType))
+                    continue;
+
+                object? duplicate;
+                try
+                {
+                    duplicate = cloneMethod.Invoke(sourceValue, null);
+                }
+                catch (Exception ex) when (ex is TargetInvocationException
+                                           or ArgumentException
+                                           or MethodAccessException)
+                {
+                    continue;
+                }
+
+                if (duplicate is null || ReferenceEquals(duplicate, sourceValue)) continue;
+
+                object? previousValue = field.GetValue(destination);
+                try
+                {
+                    field.SetValue(destination, duplicate);
+                    int candidateCount = getDestinationParameterCount();
+                    if (candidateCount == expectedParameterCount) return;
+
+                    if (Math.Abs((long)expectedParameterCount - candidateCount)
+                        < Math.Abs((long)expectedParameterCount - currentCount))
+                    {
+                        currentCount = candidateCount;
+                    }
+                    else
+                    {
+                        field.SetValue(destination, previousValue);
+                    }
+                }
+                catch (Exception ex) when (ex is ArgumentException
+                                           or FieldAccessException
+                                           or TargetInvocationException
+                                           or InvalidOperationException)
+                {
+                    try { field.SetValue(destination, previousValue); }
+                    catch (Exception) { /* best-effort topology candidate rollback */ }
+                }
+            }
+        }
+    }
+
+    /// <summary>
+    /// Creates a configuration copy of <paramref name="source"/>.
+    /// </summary>
+    /// <param name="source">The instance to copy.</param>
+    /// <returns>A new instance of the same runtime type carrying the same configuration.</returns>
+    /// <exception cref="ArgumentNullException">Thrown when <paramref name="source"/> is null.</exception>
+    /// <exception cref="InvalidOperationException">
+    /// Thrown when the runtime type cannot be constructed without arguments.
+    /// </exception>
+    public static object CopyConfiguration(object source)
+    {
+        if (source is null) throw new ArgumentNullException(nameof(source));
+
+        var type = source.GetType();
+        var plan = CloneRegistry.GetPlan(type);
+        var clone = Construct(type, plan, source);
+        var pending = new List<(ClonePlanEntry Entry, object? Value)>();
+
+        foreach (var entry in plan.Entries)
+        {
+            object? value;
+            try
+            {
+                value = entry.Property.GetValue(source);
+            }
+            catch (TargetInvocationException ex)
+            {
+                // A getter that computes rather than returns. MultilayerPerceptronOptions.Optimizer
+                // builds a default model on first read, so cloning triggers that construction and
+                // any failure inside it surfaces here with a stack trace pointing at ModelHelper,
+                // giving no sign that cloning caused it. Naming the type and property converts an
+                // unrelated-looking exception into one that says where to look.
+                throw new InvalidOperationException(
+                    $"Reading {type.Name}.{entry.Property.Name} while cloning threw "
+                    + $"{ex.InnerException?.GetType().Name ?? ex.GetType().Name}: "
+                    + $"{ex.InnerException?.Message ?? ex.Message}. A property whose getter computes "
+                    + "or lazily constructs is not configuration; mark it [NotConfiguration] so a "
+                    + "clone re-derives it instead of reading it.",
+                    ex.InnerException ?? ex);
+            }
+
+            pending.Add((entry, value));
+        }
+
+        Assign(type, clone, pending);
+        return clone;
+    }
+
+    /// <summary>
+    /// Reapplies mutable options that are part of constructor state after learned-state restore.
+    /// </summary>
+    /// <remarks>
+    /// Some legacy base payloads deserialize their own options object in place or replace it with
+    /// the base view. A derived model can intentionally hide that view with a more specific,
+    /// read-only options member used by inference. Constructor replay creates the right independent
+    /// object; this method restores its generated option properties after the payload has restored
+    /// learned values, without teaching either base about a concrete model.
+    /// </remarks>
+    internal static void RestoreMutableConstructorConfiguration(object source, object destination)
+    {
+        if (source is null) throw new ArgumentNullException(nameof(source));
+        if (destination is null) throw new ArgumentNullException(nameof(destination));
+        if (source.GetType() != destination.GetType()) return;
+
+        var type = source.GetType();
+        var plan = CloneRegistry.GetPlan(type);
+        var restored = new HashSet<string>(StringComparer.Ordinal);
+        foreach (var candidate in plan.ConstructorCandidates)
+        {
+            foreach (var member in candidate)
+            {
+                if (member == UseDefault || !restored.Add(member)) continue;
+                if (!TryReadMember(type, member, source, out object? sourceValue)
+                    || sourceValue is not ModelOptions)
+                    continue;
+                if (!TryReadMember(type, member, destination, out object? destinationValue)
+                    || destinationValue is not ModelOptions
+                    || destinationValue.GetType() != sourceValue.GetType())
+                    continue;
+
+                var optionPlan = CloneRegistry.GetPlan(sourceValue.GetType());
+                var pending = new List<(ClonePlanEntry Entry, object? Value)>(optionPlan.Entries.Count);
+                foreach (var entry in optionPlan.Entries)
+                    pending.Add((entry, entry.Property.GetValue(sourceValue)));
+                Assign(sourceValue.GetType(), destinationValue, pending);
+            }
+        }
+    }
+
+    /// <summary>
+    /// Applies values in repeated passes until none remain or no pass makes progress.
+    /// </summary>
+    /// <param name="type">The type being cloned, for error messages.</param>
+    /// <param name="clone">The instance being populated.</param>
+    /// <param name="pending">The values to apply.</param>
+    /// <exception cref="InvalidOperationException">
+    /// Thrown when a pass assigns nothing and values remain, naming each stuck property.
+    /// </exception>
+    /// <remarks>
+    /// <para>
+    /// A setter may validate against ANOTHER property, which makes a single ordered pass unsound:
+    /// <c>TabTransformerOptions.NumHeads</c> requires that it divide <c>EmbeddingDimension</c>, so
+    /// assigning it before the dimension is carried checks it against the constructor default
+    /// instead. No fixed order fixes this in general, since two properties can each constrain the
+    /// other.
+    /// </para>
+    /// <para>
+    /// Retrying works because the original object is internally consistent: some order satisfies
+    /// every constraint, and repeating until nothing more succeeds finds one without the engine
+    /// needing to know what the constraints are. A pass that assigns nothing while values remain is
+    /// a genuine circular constraint rather than a missed ordering, and is reported as such.
+    /// </para>
+    /// </remarks>
+    private static void Assign(Type type, object clone, List<(ClonePlanEntry Entry, object? Value)> pending)
+    {
+        var failures = new Dictionary<string, string>(StringComparer.Ordinal);
+
+        while (pending.Count > 0)
+        {
+            var remaining = new List<(ClonePlanEntry Entry, object? Value)>();
+            failures.Clear();
+
+            foreach (var (entry, value) in pending)
+            {
+                try
+                {
+                    entry.Property.SetValue(
+                        clone, entry.Copy == CloneCopyKind.Deep ? Duplicate(value) : value);
+                }
+                catch (TargetInvocationException ex)
+                {
+                    remaining.Add((entry, value));
+                    failures[entry.Property.Name] =
+                        ex.InnerException?.Message ?? ex.Message;
+                }
+            }
+
+            if (remaining.Count == pending.Count)
+            {
+                throw new InvalidOperationException(
+                    $"Cloning {type.Name} could not assign "
+                    + string.Join(", ", failures.Select(f => $"{f.Key} ({f.Value})"))
+                    + ". Each setter rejected a value the original already holds, and no assignment "
+                    + "order satisfies them, so the constraints between these properties are "
+                    + "circular.");
+            }
+
+            pending = remaining;
+        }
+    }
+
+    /// <summary>
+    /// Creates an instance without invoking configuration logic.
+    /// </summary>
+    /// <param name="type">The type to construct.</param>
+    /// <returns>The new instance.</returns>
+    /// <exception cref="InvalidOperationException">Thrown when no argument-less construction exists.</exception>
+    /// <remarks>
+    /// A non-public parameterless constructor is accepted deliberately: a type may reasonably keep
+    /// one private so that callers use a factory, and that is a statement about how the type should
+    /// be *used*, not a reason a clone cannot reproduce it.
+    /// </remarks>
+    private static object Construct(Type type, ClonePlan plan, object source)
+    {
+        // A type with recorded constructor parameters is rebuilt by CALLING that constructor with
+        // its carried configuration, not by allocating and assigning. That matters because a
+        // constructor derives things from its arguments -- weight buffers sized from InputSize,
+        // sub-layers built from a depth setting -- and re-deriving them is what keeps a clone
+        // consistent. Copying those structures instead would carry a stale derived value forward.
+        // The generator only records parameters when it proved every one is supplied by a member of
+        // the type -- a property, or the private field the constructor stored it in -- so this cannot
+        // be partially satisfied: either the constructor is a pure function of state the instance
+        // still holds, or nothing was recorded and the parameterless path below applies.
+        // Each recorded constructor is tried in order, and the first one the INSTANCE can actually
+        // satisfy wins. "Satisfy" means no required parameter -- one with no default -- would receive
+        // null. That is what distinguishes a model loaded from an ONNX file, which has its path
+        // stored, from one trained natively, which does not: taking the widest constructor
+        // unconditionally passed null for onnxModelPath and made 51 models throw on clone.
+        var rejectedCandidates = new List<string>();
+
+        foreach (var candidate in plan.ConstructorCandidates)
+        {
+            var arguments = new object?[candidate.Count];
+            var readable = true;
+
+            for (int i = 0; i < arguments.Length; i++)
+            {
+                // The sentinel means the generator found nothing storing this OPTIONAL parameter, so
+                // the constructor's own default is what it gets -- the same value the hand-written
+                // override left it at. Type.Missing is how reflection spells that.
+                if (candidate[i] == UseDefault) { arguments[i] = Type.Missing; continue; }
+
+                if (!TryReadMember(type, candidate[i], source, out arguments[i])) { readable = false; break; }
+
+                arguments[i] = DuplicateSubModel(arguments[i]);
+            }
+
+            if (!readable) continue;
+
+            // Matched on parameter NAMES, not on how many there are. Overloads of equal arity are
+            // ordinary -- a model taking (options, regularization) beside one taking
+            // (options, lossFunction) -- and picking by count alone would pass each value to
+            // whichever overload reflection happened to return first.
+            // ARITY FIRST, NAMES ONLY TO BREAK A TIE. The plan records members in constructor-parameter
+            // ORDER, so position already carries the mapping. Re-deriving it from names here could not
+            // work for a member the generator sourced by TYPE rather than by name: BayesianRegression
+            // takes bayesianOptions and stores it in _bayesOptions, which FindUniqueByType matched on
+            // the type alone and no name rule can reproduce. The engine then rejected a member the
+            // generator had certified, and reported "every member read, so the constructor could not
+            // be matched by name" -- true, and beside the point.
+            //
+            // Arity is safe to rely on because the generator refuses to record two constructors of the
+            // same arity: an ambiguous overload set is left unrecorded rather than guessed at. Names
+            // still decide when several constructors share an arity in some future shape.
+            var byArity = type.GetConstructors(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance)
+                .Where(c => c.GetParameters().Length == arguments.Length)
+                .ToList();
+
+            var withArgs = byArity.FirstOrDefault(c =>
+            {
+                var parameters = c.GetParameters();
+                for (int i = 0; i < parameters.Length; i++)
+                {
+                    if (!NamesTheSameValue(parameters[i].Name, candidate[i])) return false;
+                }
+
+                return true;
+            }) ?? (byArity.Count == 1 ? byArity[0] : null);
+
+            if (withArgs is null) continue;
+
+            var parameterInfos = withArgs.GetParameters();
+            var satisfied = true;
+
+            for (int i = 0; i < parameterInfos.Length; i++)
+            {
+                // A required parameter handed null is the signature of the wrong constructor for
+                // this instance -- the value it wants was never stored because this object was not
+                // built that way. An optional one is fine: its default is what it would have got.
+                if (arguments[i] is null && !parameterInfos[i].HasDefaultValue)
+                {
+                    satisfied = false;
+                    break;
+                }
+
+                // A member may hold the argument MORE GENERALLY than the constructor takes it: a
+                // time series model keeps its ARModelOptions in the base's Options property, and its
+                // own hand-written clone downcast on the way back in. The plan may now source such a
+                // member, so the runtime value is what decides whether this constructor really fits
+                // -- without this the call reaches Invoke and throws instead of moving on to the
+                // next candidate, which is the whole point of recording more than one.
+                if (arguments[i] is not null
+                    && !ReferenceEquals(arguments[i], Type.Missing)
+                    && !parameterInfos[i].ParameterType.IsInstanceOfType(arguments[i]))
+                {
+                    satisfied = false;
+                    break;
+                }
+            }
+
+            // OptionalParamBinding is what turns a Type.Missing slot into the declared default.
+            // Without it the call throws, and it throws for every model with an unstored optional
+            // parameter -- which is 307 of them.
+            if (satisfied)
+            {
+                try
+                {
+                    return withArgs.Invoke(
+                        BindingFlags.OptionalParamBinding, binder: null, arguments, culture: null);
+                }
+                catch (TargetInvocationException ex) when (ex.InnerException is ArgumentException validation)
+                {
+                    // Type compatibility is necessary but not sufficient to identify how an
+                    // instance was created. A serialization-only shell can hold an empty collection
+                    // that matches a public constructor's parameter type while that constructor
+                    // requires at least one element. That is a rejected candidate, not a reason to
+                    // stop before trying the narrower candidates or parameterless reconstruction.
+                    rejectedCandidates.Add(
+                        $"[{string.Join(", ", candidate)}] -- {validation.GetType().Name}: {validation.Message}");
+                }
+            }
+        }
+
+        var constructor = type.GetConstructor(
+            BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance,
+            binder: null,
+            Type.EmptyTypes,
+            modifiers: null);
+
+        // A CONSTRUCTOR WHOSE PARAMETERS ARE ALL OPTIONAL IS A PARAMETERLESS ONE TO EVERY CALLER
+        // BUT REFLECTION. Type.EmptyTypes matches only a true zero-parameter constructor, so a type
+        // declaring `(options = null, regularization = null)` -- which most regressors do -- looked
+        // to this fallback like it had no constructor at all, and the clone failed with a message
+        // telling the reader to add one it already had. The loop above already binds this shape for
+        // a recorded candidate; the fallback now agrees with it.
+        if (constructor is null)
+        {
+            var withOptionalArguments = type
+                .GetConstructors(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance)
+                .FirstOrDefault(c => c.GetParameters().Length > 0
+                    && c.GetParameters().All(p => p.IsOptional));
+
+            if (withOptionalArguments is not null)
+            {
+                var defaults = new object?[withOptionalArguments.GetParameters().Length];
+                for (int i = 0; i < defaults.Length; i++) defaults[i] = Type.Missing;
+
+                return withOptionalArguments.Invoke(
+                    BindingFlags.OptionalParamBinding, binder: null, defaults, culture: null);
+            }
+        }
+
+        if (constructor is null)
+        {
+            // SAY WHAT ACTUALLY HAPPENED. This used to read "has no parameterless constructor. Add
+            // one", which names a fix that is almost never the right one: reaching here usually means
+            // the plan HAD a recorded constructor and this instance could not satisfy it, and adding
+            // a parameterless constructor would paper over that by producing a default-configured
+            // clone. The message cost a full investigation once; the candidates and the reason each
+            // one declined are what a reader actually needs.
+            var detail = plan.ConstructorCandidates.Count == 0
+                ? "the clone plan recorded no constructor for it (see ADN0059)"
+                : rejectedCandidates.Count > 0
+                  ? "its recorded constructors rejected the stored configuration: "
+                    + string.Join("; ", rejectedCandidates)
+                : "none of its recorded constructors could be satisfied by this instance: "
+                  + string.Join("; ", plan.ConstructorCandidates.Select(c => DescribeCandidate(type, c, source)));
+
+            throw new InvalidOperationException(
+                $"{type.Name} cannot be rebuilt: {detail}. It also has no parameterless constructor to "
+                + "fall back on. Store each constructor argument in a member named after it so the "
+                + "generator can replay the constructor.");
+        }
+
+        return constructor.Invoke(null);
+    }
+
+    /// <summary>
+    /// Duplicates a mutable container so the copy and the original do not share storage.
+    /// </summary>
+    /// <param name="value">The value to duplicate.</param>
+    /// <returns>A duplicate, or the original when it is null or not a recognised container.</returns>
+    /// <remarks>
+    /// <para>
+    /// The copy is one level deep, which matches what the plan promises. A list of mutable objects
+    /// yields a new list holding the same elements: the two instances can no longer add or remove
+    /// independently of one another, which is the sharing bug this addresses, while the elements
+    /// themselves stay shared. Elements needing their own copies are configuration in their own
+    /// right and get their own plans.
+    /// </para>
+    /// <para>
+    /// A null container stays null rather than becoming an empty one. "Not configured" and
+    /// "configured to be empty" are different states, and a clone must not quietly convert one into
+    /// the other.
+    /// </para>
+    /// </remarks>
+    /// <summary>
+    /// Rebuilds a constructor argument that is itself a model or a layer.
+    /// </summary>
+    /// <param name="value">The argument value read from the source.</param>
+    /// <returns>An independent configuration copy, or the value unchanged when it is not a model component.</returns>
+    /// <remarks>
+    /// <para>
+    /// A constructor argument used to be handed straight across, which meant a rebuilt model SHARED
+    /// its sub-modules with the one it was copied from. Rebuild the child through the same generated
+    /// configuration plan as its owner. The owning base then restores learned state once through its
+    /// parameter/state contract.
+    /// </para>
+    /// <para>
+    /// A materialized child is cloned through its public contract before falling back to
+    /// configuration-only reconstruction. Rebuilding a trained child as a blank shell loses lazy
+    /// layout information that its parent cannot infer: the parent then streams a 4,096-value chunk
+    /// into a child constructed for 64 values. Public clones use copy-on-write where supported, so
+    /// preserving that layout does not require eagerly duplicating foundation-scale storage; the
+    /// parent's state transfer remains the final authority.
+    /// </para>
+    /// <para>
+    /// Matched on the library's own <c>ICloneable&lt;T&gt;</c> rather than a list of base types, so a
+    /// consumer's own module is duplicated on the same terms as one of ours. Anything that does not
+    /// declare itself cloneable -- options, primitives, a shared frozen resource -- is passed across
+    /// untouched, exactly as before.
+    /// </para>
+    /// </remarks>
+    private static object? DuplicateSubModel(object? value)
+    {
+        if (value is null) return null;
+
+        // Options are mutable constructor blueprints. Passing the source instance straight into a
+        // reconstructed model makes model.GetOptions() and clone.GetOptions() the same object, so
+        // configuring either model after Clone silently reconfigures both. The options clone engine
+        // is generated for every concrete ModelOptions type and copies inherited settings too.
+        if (value is ModelOptions)
+        {
+            return CopyConfiguration(value);
+        }
+
+        // Mutable blueprints can own models/layers without being models themselves. Reusing such a
+        // constructor argument makes the reconstructed parent share those owned objects before its
+        // parameter state is even restored. Let the blueprint produce an independent structural
+        // copy; parameter tensors remain the responsibility of the parent's copy-on-write path.
+        if (value is IConfigurationCloneable configuration)
+        {
+            try
+            {
+                return configuration.CloneConfiguration();
+            }
+            catch (Exception)
+            {
+                // Preserve the established fallback for a consumer-defined configuration that
+                // cannot be reconstructed. The parent's copy-on-write identity check will reject
+                // unsafe sharing and route to the eager serialization clone instead.
+                return value;
+            }
+        }
+
+        // Noise schedulers are mutable model components even though they are not IFullModel and do
+        // not implement AiDotNet's ICloneable<T>. Passing one straight through a reconstructed
+        // diffusion model makes the source and clone share Timesteps and solver history. Rebuild it
+        // from its strongly typed Config and restore an independent copy of its checkpoint state,
+        // matching the hand-written CloneScheduler helpers this engine replaces.
+        var schedulerInterface = value.GetType().GetInterfaces().FirstOrDefault(i =>
+            i.IsGenericType
+            && i.GetGenericTypeDefinition().Name == "INoiseScheduler`1"
+            && i.Namespace == "AiDotNet.Interfaces");
+        if (schedulerInterface is not null)
+        {
+            object? schedulerCopy = DuplicateNoiseScheduler(value, schedulerInterface);
+            if (schedulerCopy is not null) return schedulerCopy;
+        }
+
+        var cloneable = value.GetType().GetInterfaces().FirstOrDefault(i =>
+            i.IsGenericType
+            && i.GetGenericTypeDefinition().Name == "ICloneable`1"
+            && i.Namespace == "AiDotNet.Interfaces");
+
+        if (cloneable?.GetMethod("Clone", Type.EmptyTypes) is not { } clone) return value;
+
+        // Preserve the child's materialized layout first. Configuration-only construction cannot
+        // recover a width learned from data or a lazily-created sub-layer graph, and a later flat or
+        // chunked restore has no shape information with which to repair it.
+        try
+        {
+            object? cloned = clone.Invoke(value, null);
+            if (cloned is not null)
+            {
+                EnsureSubModelManifestMatches(value, cloned);
+                return cloned;
+            }
+        }
+        catch (TargetInvocationException ex) when (
+            ex.InnerException is InvalidOperationException invalid
+            && invalid.Message.StartsWith(
+                "Clone state transfer changed the parameter manifest",
+                StringComparison.Ordinal))
+        {
+            // The child clone proved that neither copy-on-write nor its streaming fallback restored
+            // an identical state surface. Falling back to a configuration shell here hides that
+            // evidence and hands the parent a predictably broken child, so preserve the contract
+            // failure and its layer/buffer diagnostic.
+            throw invalid;
+        }
+        catch (TargetInvocationException)
+        {
+            // Fall through to generated structural reconstruction. This remains important for a
+            // consumer clone implementation that cannot run before its parent has restored state.
+        }
+
+        // Generated configuration reconstruction is the compatibility fallback for cloneable
+        // components whose public clone declined above.
+        try
+        {
+            return CopyConfiguration(value);
+        }
+        catch (Exception ex) when (ex is InvalidOperationException
+                                   or ArgumentException
+                                   or NotSupportedException
+                                   or MissingMethodException)
+        {
+            return value;
+        }
+    }
+
+    private static void EnsureSubModelManifestMatches(object source, object clone)
+    {
+        if (source is not AiDotNet.Models.Parameters.IParameterManifestProvider sourceProvider
+            || clone is not AiDotNet.Models.Parameters.IParameterManifestProvider cloneProvider)
+            return;
+
+        var sourceLayout = sourceProvider.ParameterLayout;
+        var cloneLayout = cloneProvider.ParameterLayout;
+        if (string.Equals(sourceLayout.DeclaredLayoutFingerprint,
+                cloneLayout.DeclaredLayoutFingerprint,
+                StringComparison.Ordinal))
+            return;
+
+        throw new InvalidOperationException(
+            $"Cloning child component {source.GetType().Name} changed its parameter manifest: "
+            + $"source declared/materialized={sourceLayout.ParameterCount?.ToString() ?? "?"}/"
+            + $"{sourceLayout.MaterializedParameterCount}, clone="
+            + $"{cloneLayout.ParameterCount?.ToString() ?? "?"}/{cloneLayout.MaterializedParameterCount}.");
+    }
+
+    private static object? DuplicateNoiseScheduler(object source, Type schedulerInterface)
+    {
+        var configProperty = schedulerInterface.GetProperty("Config");
+        object? config = configProperty?.GetValue(source);
+        if (config is null) return null;
+
+        var constructor = source.GetType()
+            .GetConstructors(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance)
+            .FirstOrDefault(c =>
+            {
+                var parameters = c.GetParameters();
+                return parameters.Length == 1
+                    && parameters[0].ParameterType.IsInstanceOfType(config);
+            });
+        if (constructor is null) return null;
+
+        object copy = constructor.Invoke(new[] { config });
+        if (schedulerInterface.GetMethod("GetState", Type.EmptyTypes)?.Invoke(source, null)
+            is Dictionary<string, object> sourceState)
+        {
+            var copiedState = new Dictionary<string, object>(sourceState.Count, StringComparer.Ordinal);
+            foreach (var (name, stateValue) in sourceState)
+                copiedState[name] = Duplicate(stateValue) ?? stateValue;
+
+            schedulerInterface.GetMethod("LoadState", new[] { typeof(Dictionary<string, object>) })
+                ?.Invoke(copy, new object[] { copiedState });
+        }
+
+        return copy;
+    }
+
+    private static object? Duplicate(object? value)
+    {
+        switch (value)
+        {
+            case null:
+                return null;
+
+            case Array array:
+                return array.Clone();
+
+            case IDictionary dictionary:
+                return CopyInto(dictionary, Activator.CreateInstance(dictionary.GetType()));
+
+            case IList list:
+                return CopyInto(list, Activator.CreateInstance(list.GetType()));
+        }
+
+        // A set is neither IList nor IDictionary, so it is reached through its own Add.
+        var type = value.GetType();
+        if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(HashSet<>))
+        {
+            var copy = Activator.CreateInstance(type, value);
+            if (copy is not null) return copy;
+        }
+
+        return value;
+    }
+
+    private static object? CopyInto(IDictionary source, object? target)
+    {
+        if (target is not IDictionary typed) return source;
+
+        foreach (DictionaryEntry entry in source)
+        {
+            typed[entry.Key] = entry.Value;
+        }
+
+        return typed;
+    }
+
+    private static object? CopyInto(IList source, object? target)
+    {
+        if (target is not IList typed) return source;
+
+        foreach (var item in source)
+        {
+            typed.Add(item);
+        }
+
+        return typed;
+    }
+
+    /// <summary>
+    /// Reads the value a recorded constructor parameter was built from.
+    /// </summary>
+    /// <param name="type">The runtime type being rebuilt.</param>
+    /// <param name="member">The member name the plan recorded.</param>
+    /// <param name="source">The instance being cloned.</param>
+    /// <param name="value">Receives the value, or null when no such member exists.</param>
+    /// <returns><see langword="true"/> when the member was found and read.</returns>
+    /// <remarks>
+    /// Private fields are in scope. A constructor argument that is not also exposed as a property is
+    /// the normal case for a model -- a diffusion model's U-Net lives in <c>_unet</c> and nowhere
+    /// else -- and refusing to read it would mean the only rebuildable models are the ones that
+    /// happen to re-expose everything they were built from.
+    /// </remarks>
+    /// <summary>Explains, for one recorded constructor, why this instance could not satisfy it.</summary>
+    /// <param name="type">The type being rebuilt.</param>
+    /// <param name="candidate">The recorded member names, in constructor-parameter order.</param>
+    /// <param name="source">The instance being cloned.</param>
+    /// <returns>A phrase naming the first member that blocked it.</returns>
+    private static string DescribeCandidate(Type type, IReadOnlyList<string> candidate, object source)
+    {
+        var names = string.Join(", ", candidate);
+
+        for (int i = 0; i < candidate.Count; i++)
+        {
+            if (candidate[i] == UseDefault) continue;
+
+            object? value;
+            try
+            {
+                if (!TryReadMember(type, candidate[i], source, out value))
+                {
+                    return $"[{names}] -- '{candidate[i]}' is not readable on this type";
+                }
+            }
+            catch (Exception ex)
+            {
+                var inner = ex.InnerException ?? ex;
+                return $"[{names}] -- reading '{candidate[i]}' threw {inner.GetType().Name}: {inner.Message}";
+            }
+
+            if (value is null)
+            {
+                return $"[{names}] -- '{candidate[i]}' is null on this instance";
+            }
+        }
+
+        return $"[{names}] -- every member read, so the constructor could not be matched by name";
+    }
+
+    private static bool TryReadMember(Type type, string member, object source, out object? value)
+    {
+        const BindingFlags Flags =
+            BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance;
+
+        // Generated plans may name a value at one ownership boundary, for example
+        // Generator.Architecture. Resolve each segment through the same inheritance-aware member
+        // lookup used for direct constructor state; no arbitrary method invocation is involved.
+        int separator = member.IndexOf('.');
+        if (separator >= 0)
+        {
+            string owner = member.Substring(0, separator);
+            string remainder = member.Substring(separator + 1);
+            if (!TryReadMember(type, owner, source, out object? nested) || nested is null)
+            {
+                value = null;
+                return false;
+            }
+
+            return TryReadMember(nested.GetType(), remainder, nested, out value);
+        }
+
+        for (var current = type; current is not null; current = current.BaseType)
+        {
+            var property = current.GetProperty(member, Flags | BindingFlags.DeclaredOnly);
+            if (property is not null && property.CanRead)
+            {
+                value = property.GetValue(source);
+                return true;
+            }
+
+            var field = current.GetField(member, Flags | BindingFlags.DeclaredOnly);
+            if (field is not null)
+            {
+                value = field.GetValue(source);
+                return true;
+            }
+        }
+
+        value = null;
+        return false;
+    }
+
+    /// <summary>
+    /// Determines whether a constructor parameter and a recorded member name denote the same value.
+    /// </summary>
+    /// <param name="parameter">The constructor parameter's name.</param>
+    /// <param name="member">The member name the plan recorded.</param>
+    /// <returns><see langword="true"/> when they correspond.</returns>
+    /// <remarks>
+    /// The recorded name is the member that holds the value, which is usually the parameter with a
+    /// leading underscore. Comparing the two raw would reject <c>_unet</c> against <c>unet</c> and
+    /// silently drop back to demanding a parameterless constructor, so the underscore is stripped
+    /// before comparing.
+    /// </remarks>
+    private static bool NamesTheSameValue(string? parameter, string member)
+    {
+        if (parameter is null) return false;
+
+        // The sentinel stands for the parameter's own default, so it matches whatever it sits against.
+        if (member == UseDefault) return true;
+
+        var trimmed = member.StartsWith("_", StringComparison.Ordinal) ? member.Substring(1) : member;
+        if (trimmed.IndexOf('.') >= 0)
+        {
+            trimmed = trimmed.Replace(".", string.Empty).Replace("_", string.Empty);
+        }
+        if (string.Equals(parameter, trimmed, StringComparison.OrdinalIgnoreCase)) return true;
+
+        // THE SUFFIX RULE, because the generator uses it when it sources the member. FindByNameSuffix
+        // accepts a member whose name ENDS with the parameter's -- BayesianRegression keeps its
+        // options in _bayesOptions, AttentiveNAS keeps its searchSpace in _nasSearchSpace -- and
+        // records it in the plan. Matching only on equality here made the engine reject a member the
+        // generator had just certified, so the plan was right and the rebuild refused it: "every
+        // member read, so the constructor could not be matched by name". Two rules for one question
+        // is one rule too many; this is the same one.
+        // Decoration at EITHER end, for the same reason: the generator now also sources a member
+        // whose name STARTS with the parameter's (StackingClassifier keeps its `finalEstimator`
+        // factory in _finalEstimatorFactory). Accepting only the suffix here would recreate exactly
+        // the split this comment warns about, with the plan certifying a member the rebuild refuses.
+        return trimmed.Length > parameter.Length
+            && (trimmed.EndsWith(parameter, StringComparison.OrdinalIgnoreCase)
+                || trimmed.StartsWith(parameter, StringComparison.OrdinalIgnoreCase));
+    }
+
+}
diff --git a/src/Models/CloneMode.cs b/src/Models/CloneMode.cs
new file mode 100644
index 0000000000..358b2c2a0b
--- /dev/null
+++ b/src/Models/CloneMode.cs
@@ -0,0 +1,53 @@
+namespace AiDotNet.Models;
+
+/// <summary>
+/// How much of the original's storage a copy is allowed to share.
+/// </summary>
+/// <remarks>
+/// <para>
+/// Orthogonal to the rest of <see cref="CloneOptions"/>. Those decide WHAT a copy carries —
+/// parameters, optimizer state, buffers; this decides whether what it carries is copied or shared.
+/// </para>
+/// <para><b>For Beginners:</b> the difference is what happens when you train the copy.
+/// With <see cref="Deep"/> and <see cref="CopyOnWrite"/>, nothing happens to the original. With
+/// <see cref="Shared"/>, you train both, because there is only one set of weights.</para>
+/// </remarks>
+public enum CloneMode
+{
+    /// <summary>
+    /// The copy owns its own storage. Training it never touches the original.
+    /// </summary>
+    /// <remarks>
+    /// The default, and the least surprising reading of the word "clone": the same thing,
+    /// separately.
+    /// </remarks>
+    Deep = 0,
+
+    /// <summary>
+    /// The copy shares each weight tensor's storage until either side writes to it.
+    /// </summary>
+    /// <remarks>
+    /// Observationally identical to <see cref="Deep"/> — the first write on either side splits them
+    /// — but O(1) until that happens instead of allocating a second full set of weights. Worth
+    /// choosing when clones are made far more often than they are trained, as in population search
+    /// or evaluating a checkpoint.
+    /// </remarks>
+    CopyOnWrite = 1,
+
+    /// <summary>
+    /// The copy points at the SAME parameters as the original.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// <b>Not a copy.</b> Training the result trains the original, because they are one set of
+    /// weights behind two handles. It exists for read-only fan-out — running the same weights over
+    /// several inputs concurrently — where allocating anything at all is waste.
+    /// </para>
+    /// <para>
+    /// Anything that mutates one side is a shared-state hazard. If that is not obviously fine for
+    /// what you are doing, use <see cref="CopyOnWrite"/>, which is as cheap right up until the
+    /// moment sharing would have been wrong.
+    /// </para>
+    /// </remarks>
+    Shared = 2,
+}
diff --git a/src/Models/CloneOptions.cs b/src/Models/CloneOptions.cs
new file mode 100644
index 0000000000..97bce3ef53
--- /dev/null
+++ b/src/Models/CloneOptions.cs
@@ -0,0 +1,178 @@
+namespace AiDotNet.Models;
+
+/// <summary>
+/// Controls what a <c>Clone</c> carries across from the original.
+/// </summary>
+/// <remarks>
+/// <para>
+/// <b>For Beginners:</b> Cloning a model gives you a second, separate copy. This class lets you say
+/// how much of the original the copy should bring with it. You almost never need to set any of
+/// this — <c>model.Clone()</c> already does the sensible thing, giving you a complete independent
+/// copy that behaves exactly like the original.
+/// </para>
+/// <para>
+/// The default is deliberately stronger than the equivalent in other libraries. In PyTorch,
+/// <c>copy.deepcopy(model)</c> cannot carry optimizer state, because the optimizer is a separate
+/// object that merely holds references to the model's parameters — so a copy taken mid-training
+/// restarts its optimizer from scratch. That is a structural limitation rather than a considered
+/// choice, so this library does not reproduce it: <see cref="Full"/> carries optimizer state, and
+/// a clone taken mid-training resumes as the original would.
+/// </para>
+/// <para>
+/// The one thing the default does <b>not</b> share is the random number stream. Two models drawing
+/// from the same stream produce identical dropout masks and identical shuffles forever, so their
+/// training silently correlates and nothing in the results reveals it. The clone instead gets a
+/// fresh stream derived from the original's seed, which stays reproducible without the coupling.
+/// Set <see cref="ShareRandomState"/> when you genuinely want a bit-identical twin.
+/// </para>
+/// <para>
+/// The contract in one line: <i>a clone trains as if it were the original, but its randomness does
+/// not track it.</i>
+/// </para>
+/// </remarks>
+public sealed record CloneOptions
+{
+    /// <summary>
+    /// Gets the default: a complete, independent copy with a freshly derived random stream.
+    /// </summary>
+    /// <value>
+    /// Configuration, learned parameters, optimizer state, buffers and trainability flags are all
+    /// carried; the random stream is derived rather than shared.
+    /// </value>
+    /// <remarks>
+    /// This is what a bare <c>Clone()</c> uses. It is the least surprising reading of the word
+    /// "clone" — the same thing, separately — and is strictly stronger than a deep copy in PyTorch,
+    /// which cannot reach optimizer state at all.
+    /// </remarks>
+    public static CloneOptions Full { get; } = new();
+
+    /// <summary>
+    /// Gets a configuration-only copy: same architecture and settings, nothing learned.
+    /// </summary>
+    /// <value>
+    /// Configuration and trainability flags are carried; parameters, optimizer state, buffers and
+    /// the random stream are not.
+    /// </value>
+    /// <remarks>
+    /// <para>
+    /// This matches scikit-learn's <c>clone()</c>, which deliberately returns an <i>unfitted</i>
+    /// estimator carrying the same hyperparameters. Use it to run the same architecture on
+    /// different data, or to restart training from a fresh initialization.
+    /// </para>
+    /// <para><b>For Beginners:</b> Think of this as copying the recipe but not the cake.</para>
+    /// </remarks>
+    public static CloneOptions Architecture { get; } = new()
+    {
+        IncludeParameters = false,
+        IncludeOptimizerState = false,
+        IncludeBuffers = false,
+    };
+    /// <summary>
+    /// Gets a copy that shares each weight tensor's storage until either side writes to it.
+    /// </summary>
+    /// <value>Everything <see cref="Full"/> carries, taken by copy-on-write rather than eagerly.</value>
+    /// <remarks>
+    /// Observationally identical to <see cref="Full"/> and O(1) until the first write, which then
+    /// splits the two. This is not a new behaviour: it is what the library already did by default,
+    /// decided by the <c>AIDOTNET_COW_DEEPCOPY</c> environment variable. A per-process switch is the
+    /// wrong place for a per-call decision, so it is a value here.
+    /// </remarks>
+    public static CloneOptions CopyOnWrite { get; } = new() { Mode = CloneMode.CopyOnWrite };
+
+    /// <summary>
+    /// Gets an ALIAS: the copy points at the same parameters as the original.
+    /// </summary>
+    /// <value>Everything <see cref="Full"/> carries, shared rather than copied.</value>
+    /// <remarks>
+    /// <para>
+    /// <b>Training this copy trains the original.</b> This is not a copy in any safe sense; it is a
+    /// second handle on one model, for read-only fan-out such as evaluating the same weights on
+    /// several inputs at once.
+    /// </para>
+    /// <para>
+    /// Deliberately not reachable from a friendly-sounding preset. If you are unsure which of these
+    /// you want, you want <see cref="Full"/> or <see cref="CopyOnWrite"/>.
+    /// </para>
+    /// </remarks>
+    public static CloneOptions Shared { get; } = new() { Mode = CloneMode.Shared };
+
+    /// <summary>
+    /// Gets how much of the original's storage the copy is allowed to share.
+    /// </summary>
+    /// <value>Defaults to <see cref="CloneMode.Deep"/>.</value>
+    /// <remarks>
+    /// Orthogonal to <see cref="IncludeParameters"/> and the rest: those decide WHAT is carried,
+    /// this decides whether what is carried is copied or shared. <see cref="CloneMode.Shared"/> with
+    /// <see cref="IncludeParameters"/> off is meaningless, since there is nothing left to share.
+    /// </remarks>
+    public CloneMode Mode { get; init; } = CloneMode.Deep;
+
+
+    /// <summary>
+    /// Gets a value indicating whether configuration is carried. Always <see langword="true"/>.
+    /// </summary>
+    /// <value>Always <see langword="true"/>.</value>
+    /// <remarks>
+    /// Configuration is what makes the clone the same <i>kind</i> of thing as the original, so
+    /// there is no meaningful clone without it. It is exposed as a property only so that reading
+    /// a <see cref="CloneOptions"/> shows the complete picture rather than an implied part.
+    /// </remarks>
+    public bool IncludeConfiguration => true;
+
+    /// <summary>
+    /// Gets a value indicating whether learned parameters are carried. Defaults to <see langword="true"/>.
+    /// </summary>
+    /// <value><see langword="true"/> to copy trained weights; otherwise <see langword="false"/>.</value>
+    /// <remarks>
+    /// Parameters are read through <c>GetParameters()</c> and written through
+    /// <c>UpdateParameters(Vector&lt;T&gt;)</c> — the same contract training uses on every step, so
+    /// a clone cannot disagree with training about what the parameters are.
+    /// </remarks>
+    public bool IncludeParameters { get; init; } = true;
+
+    /// <summary>
+    /// Gets a value indicating whether optimizer state is carried. Defaults to <see langword="true"/>.
+    /// </summary>
+    /// <value><see langword="true"/> to copy momentum, moment estimates and step counts.</value>
+    /// <remarks>
+    /// <para>
+    /// Carrying this is what lets a clone taken mid-training continue rather than restart. Adam's
+    /// first and second moment estimates take many steps to warm up, so a copy without them
+    /// behaves markedly differently from the original for a while — an effect easily mistaken for
+    /// a difference in the model itself.
+    /// </para>
+    /// <para>
+    /// This is the setting PyTorch cannot offer, since its optimizer lives outside the module.
+    /// </para>
+    /// </remarks>
+    public bool IncludeOptimizerState { get; init; } = true;
+
+    /// <summary>
+    /// Gets a value indicating whether non-gradient learned state is carried. Defaults to <see langword="true"/>.
+    /// </summary>
+    /// <value><see langword="true"/> to copy running statistics such as batch-normalization means.</value>
+    /// <remarks>
+    /// Batch normalization's running mean and variance are learned from data but never receive a
+    /// gradient. Dropping them leaves a clone that trains identically yet <i>evaluates</i>
+    /// differently, which is a particularly hard difference to trace back to the clone.
+    /// </remarks>
+    public bool IncludeBuffers { get; init; } = true;
+
+    /// <summary>
+    /// Gets a value indicating whether the clone shares the original's random stream rather than
+    /// deriving its own. Defaults to <see langword="false"/>.
+    /// </summary>
+    /// <value><see langword="true"/> for a bit-identical twin; <see langword="false"/> to derive a fresh stream.</value>
+    /// <remarks>
+    /// <para>
+    /// Left <see langword="false"/>, the clone seeds itself deterministically from the original, so
+    /// runs stay reproducible while the two models draw different dropout masks and shuffles.
+    /// </para>
+    /// <para>
+    /// Set it <see langword="true"/> only when you want the two to behave identically down to their
+    /// randomness — comparing an optimization change, for instance, where any difference in the
+    /// random stream would confound the comparison.
+    /// </para>
+    /// </remarks>
+    public bool ShareRandomState { get; init; }
+}
diff --git a/src/Models/ClonePlan.cs b/src/Models/ClonePlan.cs
new file mode 100644
index 0000000000..1d188a7b7e
--- /dev/null
+++ b/src/Models/ClonePlan.cs
@@ -0,0 +1,150 @@
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+
+namespace AiDotNet.Models;
+
+/// <summary>
+/// Describes how to reproduce one type: which members are configuration, and how each is carried.
+/// </summary>
+/// <remarks>
+/// <para>
+/// A plan is produced at compile time by the clone plan generator and stored in
+/// <see cref="CloneRegistry"/>. Nothing here is decided at clone time, so a clone cannot depend on
+/// the state of the object it is copying — which is what makes the result reviewable and testable
+/// rather than emergent.
+/// </para>
+/// <para>
+/// <b>Why a plan rather than generated copy code:</b> a Roslyn generator can only add members to a
+/// <c>partial</c> type, and none of the 594 options classes are partial. Emitting a plan instead
+/// keeps every one of them untouched while still deciding correctness at compile time, and means a
+/// class written by a user works without them declaring anything at all.
+/// </para>
+/// </remarks>
+public sealed class ClonePlan
+{
+    /// <summary>
+    /// Initializes a new instance of the <see cref="ClonePlan"/> class.
+    /// </summary>
+    /// <param name="type">The type this plan reproduces.</param>
+    /// <param name="entries">The configuration members, in a stable order.</param>
+    /// <exception cref="ArgumentNullException">Thrown when an argument is null.</exception>
+    public ClonePlan(
+        Type type,
+        IReadOnlyList<ClonePlanEntry> entries,
+        IReadOnlyList<string>? constructorParameters = null,
+        IReadOnlyList<IReadOnlyList<string>>? constructorCandidates = null)
+    {
+        Type = type ?? throw new ArgumentNullException(nameof(type));
+        Entries = entries ?? throw new ArgumentNullException(nameof(entries));
+        ConstructorParameters = constructorParameters ?? Array.Empty<string>();
+        ConstructorCandidates = constructorCandidates
+            ?? (ConstructorParameters.Count > 0
+                ? new[] { ConstructorParameters }
+                : Array.Empty<IReadOnlyList<string>>());
+    }
+
+    /// <summary>
+    /// Gets every constructor the type can be rebuilt through, widest first.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// More than one is normal, and recording only the widest was wrong. Around fifty models in this
+    /// library take an ONNX model path in one constructor and an optimizer in another; a model built
+    /// natively has no path stored, so rebuilding it through the ONNX constructor passes null and
+    /// throws. Which constructor is right is a property of the INSTANCE, not of the type, and cannot
+    /// be decided when the plan is generated.
+    /// </para>
+    /// <para>
+    /// So the choice is deferred: every satisfiable constructor is recorded, and
+    /// <c>CloneEngine</c> picks the one whose required arguments the instance actually holds. The
+    /// mode is read off the state the object already carries rather than recorded separately.
+    /// </para>
+    /// </remarks>
+    public IReadOnlyList<IReadOnlyList<string>> ConstructorCandidates { get; }
+
+    /// <summary>Gets the type this plan reproduces.</summary>
+    public Type Type { get; }
+
+    /// <summary>
+    /// Gets the configuration property names feeding this type's constructor, in parameter order.
+    /// </summary>
+    /// <value>Empty when the type is reconstructed without arguments, as options classes are.</value>
+    /// <remarks>
+    /// <para>
+    /// Layers and models take arguments, so reconstructing them means calling a real constructor
+    /// rather than allocating and assigning. Recording which carried property feeds each parameter
+    /// is what makes that automatic for the author: they write an ordinary constructor and store
+    /// its arguments in same-named properties, and nothing else.
+    /// </para>
+    /// <para>
+    /// The list is only ever populated when the generator proved that EVERY parameter maps to a
+    /// carried property. That proof is what makes reconstruction correct by construction rather
+    /// than by check: if every input to the constructor is carried, the constructor is a pure
+    /// function of carried configuration, so the rebuilt object is structurally identical. A
+    /// parameter it cannot map is a build error naming that parameter, not a silent omission.
+    /// </para>
+    /// </remarks>
+    public IReadOnlyList<string> ConstructorParameters { get; }
+
+    /// <summary>Gets the configuration members carried by a clone, in a stable order.</summary>
+    /// <remarks>
+    /// Includes members declared on base types. Missing an inherited member is precisely how 71
+    /// copy constructors came to drop <c>ModelOptions.Seed</c>, so the plan is built from the full
+    /// inheritance chain rather than from a single type's declarations.
+    /// </remarks>
+    public IReadOnlyList<ClonePlanEntry> Entries { get; }
+}
+
+/// <summary>
+/// One configuration member and the manner in which a clone carries it.
+/// </summary>
+public sealed class ClonePlanEntry
+{
+    /// <summary>
+    /// Initializes a new instance of the <see cref="ClonePlanEntry"/> class.
+    /// </summary>
+    /// <param name="property">The property to carry.</param>
+    /// <param name="copy">How to carry it.</param>
+    /// <exception cref="ArgumentNullException">Thrown when <paramref name="property"/> is null.</exception>
+    public ClonePlanEntry(PropertyInfo property, CloneCopyKind copy)
+    {
+        Property = property ?? throw new ArgumentNullException(nameof(property));
+        Copy = copy;
+    }
+
+    /// <summary>Gets the property carried by a clone.</summary>
+    public PropertyInfo Property { get; }
+
+    /// <summary>Gets the manner in which the value is carried.</summary>
+    public CloneCopyKind Copy { get; }
+}
+
+/// <summary>
+/// How a single configuration value is carried to a clone.
+/// </summary>
+public enum CloneCopyKind
+{
+    /// <summary>
+    /// Assign the same value. Correct for numbers, strings, enums, and for immutable or stateless
+    /// objects such as activation functions and kernels, where sharing one instance between the
+    /// original and the clone changes nothing observable.
+    /// </summary>
+    /// <remarks>
+    /// Activation functions, kernels and schedules are supplied by callers as delegates and
+    /// interfaces, and they <i>are</i> configuration: a clone that dropped them would behave
+    /// differently while looking correct. Carrying them by reference is both correct and cheap.
+    /// </remarks>
+    ByReference = 0,
+
+    /// <summary>
+    /// Duplicate the container so the two instances do not write through the same buffer.
+    /// </summary>
+    /// <remarks>
+    /// A bare assignment of a list or an array leaves the clone and the original sharing storage,
+    /// so mutating one silently reconfigures the other. That is invisible to a property-by-property
+    /// equality check and is why the round-trip tests also assert that mutating a clone cannot
+    /// affect its original.
+    /// </remarks>
+    Deep = 1,
+}
diff --git a/src/Models/CloneRegistry.cs b/src/Models/CloneRegistry.cs
new file mode 100644
index 0000000000..cc55d722dd
--- /dev/null
+++ b/src/Models/CloneRegistry.cs
@@ -0,0 +1,497 @@
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+
+namespace AiDotNet.Models;
+
+/// <summary>
+/// Holds the compile-time clone plan for every discovered type, and builds one on demand for types
+/// the generator never saw.
+/// </summary>
+/// <remarks>
+/// <para>
+/// The clone plan generator registers a plan for every type it discovers, so correctness for those
+/// is settled at compile time and enforced by the analyzer. Types the generator never saw — one
+/// defined in a consumer's own assembly, or produced at runtime — fall back to reflection, which is
+/// slower on first use but never simply fails.
+/// </para>
+/// <para>
+/// The layering matters: a compile-time plan is checkable, a runtime plan is not, and mixing them
+/// silently would leave nobody able to say which guarantees applied. <see cref="IsVerified"/>
+/// reports which of the two produced a given plan.
+/// </para>
+/// </remarks>
+public static class CloneRegistry
+{
+    private static readonly ConcurrentDictionary<Type, ClonePlan> Generated = new();
+    private static readonly ConcurrentDictionary<Type, ClonePlan> Reflected = new();
+
+    /// <summary>
+    /// Registers a compile-time plan. Called by generated code.
+    /// </summary>
+    /// <param name="plan">The plan to register.</param>
+    /// <exception cref="ArgumentNullException">Thrown when <paramref name="plan"/> is null.</exception>
+    /// <remarks>
+    /// Any reflection plan already cached for this type is evicted. A reflected plan is a fallback
+    /// for a type nothing registered, so the moment one IS registered the fallback is stale -- and
+    /// <c>GetOrAdd</c> would otherwise keep serving it for the life of the process, silently
+    /// preferring a plan with no constructor over the compile-time one that has it.
+    /// </remarks>
+    public static void Register(ClonePlan plan)
+    {
+        if (plan is null) throw new ArgumentNullException(nameof(plan));
+        Generated[plan.Type] = plan;
+
+        Reflected.TryRemove(plan.Type, out _);
+        if (plan.Type.IsGenericTypeDefinition)
+        {
+            // Closed forms were cached against the open form's absence, so they are stale too.
+            foreach (var closed in Reflected.Keys)
+            {
+                if (closed.IsGenericType && !closed.IsGenericTypeDefinition
+                    && closed.GetGenericTypeDefinition() == plan.Type)
+                {
+                    Reflected.TryRemove(closed, out _);
+                }
+            }
+        }
+    }
+
+    /// <summary>
+    /// Gets a value indicating whether a type's plan was produced at compile time, and so is covered
+    /// by the analyzer and the generated round-trip test.
+    /// </summary>
+    /// <param name="type">The type to query.</param>
+    /// <returns><see langword="true"/> when the plan is generated; <see langword="false"/> when it is reflected.</returns>
+    /// <exception cref="ArgumentNullException">Thrown when <paramref name="type"/> is null.</exception>
+    public static bool IsVerified(Type type)
+    {
+        if (type is null) throw new ArgumentNullException(nameof(type));
+
+        EnsureGeneratedPlansLoaded();
+
+        if (Generated.ContainsKey(type)) return true;
+
+        // A closed generic whose open form is registered is still compile-time decided: the
+        // property set and the copy kinds came from the generator, and only the PropertyInfo
+        // handles were re-bound. Reporting it as unverified would understate the guarantee exactly
+        // as badly as the reverse would overstate it.
+        return type.IsGenericType
+            && !type.IsGenericTypeDefinition
+            && Generated.ContainsKey(type.GetGenericTypeDefinition());
+    }
+
+    /// <summary>
+    /// Gets every type with a compile-time plan. Used by the generated round-trip tests.
+    /// </summary>
+    /// <returns>The verified types.</returns>
+    public static IEnumerable<Type> VerifiedTypes() => Generated.Keys;
+
+    /// <summary>
+    /// Gets the plan for a type, building one by reflection if the generator never saw it.
+    /// </summary>
+    /// <param name="type">The type to plan for.</param>
+    /// <returns>The plan.</returns>
+    /// <exception cref="ArgumentNullException">Thrown when <paramref name="type"/> is null.</exception>
+    public static ClonePlan GetPlan(Type type)
+    {
+        if (type is null) throw new ArgumentNullException(nameof(type));
+
+        EnsureGeneratedPlansLoaded();
+
+        if (Generated.TryGetValue(type, out var generated)) return generated;
+
+        // A generic type is registered under its open form -- typeof(Foo<>) -- because that is the
+        // only handle the generator can name. Without this, every closed Foo<double> missed its
+        // generated plan and fell through to reflection, which is nearly every options and layer
+        // type in the library: the compile-time guarantee existed but was not the one in force.
+        if (type.IsGenericType && !type.IsGenericTypeDefinition)
+        {
+            var definition = type.GetGenericTypeDefinition();
+            if (Generated.TryGetValue(definition, out var open))
+            {
+                return Reflected.GetOrAdd(type, t => Close(open, t));
+            }
+        }
+
+        return Reflected.GetOrAdd(type, BuildByReflection);
+    }
+
+    /// <summary>
+    /// Re-binds an open generic's plan against one of its closed forms.
+    /// </summary>
+    /// <param name="open">The plan registered for the generic type definition.</param>
+    /// <param name="closed">The closed type to bind against.</param>
+    /// <returns>A plan whose properties belong to <paramref name="closed"/>.</returns>
+    /// <remarks>
+    /// The entries carry a <see cref="PropertyInfo"/> obtained from the open definition, and such a
+    /// handle cannot read or write an instance of a closed type. Only the property NAME and the
+    /// copy kind survive re-binding; both were decided at compile time, so the result is still the
+    /// generated decision rather than a rediscovered one.
+    /// </remarks>
+    private static ClonePlan Close(ClonePlan open, Type closed)
+    {
+        var entries = new List<ClonePlanEntry>(open.Entries.Count);
+
+        foreach (var entry in open.Entries)
+        {
+            var property = closed.GetProperty(
+                entry.Property.Name, BindingFlags.Public | BindingFlags.Instance);
+
+            if (property is not null && property.CanRead && property.CanWrite)
+            {
+                entries.Add(new ClonePlanEntry(property, entry.Copy));
+            }
+        }
+
+        // The recorded constructor travels with the plan. Dropping it here would be invisible and
+        // total: every model and every layer is generic, so a plan that loses its constructor on
+        // closing falls back to demanding a parameterless constructor -- which is precisely the
+        // constructor these types do not have.
+        return new ClonePlan(closed, entries, open.ConstructorParameters, open.ConstructorCandidates);
+    }
+
+    private static readonly object GeneratedGate = new();
+    private static volatile bool _generatedLoaded;
+
+    /// <summary>
+    /// Runs the generated registrations once, on first use, and does not return until they are all
+    /// present.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// THE FLAG IS SET AFTER THE WORK, NOT BEFORE. This was a single <c>Interlocked.Exchange</c> that
+    /// claimed the flag and then ran <c>RegisterAll</c>, so a second caller arriving mid-registration
+    /// saw "already loaded", missed a plan that was still on its way in, and fell through to
+    /// <see cref="BuildByReflection"/>. That reflection plan then went into <c>Reflected</c> and
+    /// STAYED there, because <c>GetOrAdd</c> keeps the first value it was given -- so the generated
+    /// plan could never replace it, for the life of the process.
+    /// </para>
+    /// <para>
+    /// The symptom was a type that cloned correctly when its test ran alone and failed when the suite
+    /// ran, reporting "the clone plan recorded no constructor for it". That was true of the cached
+    /// plan and false of the type, which is the worst kind of error message to be handed.
+    /// </para>
+    /// </remarks>
+    /// <remarks>
+    /// <para>
+    /// Resolved by reflection rather than called directly so that this file still compiles when the
+    /// generator produces nothing — during bootstrap, or in a consumer's assembly that references
+    /// the library without running its generators. A direct call would make the runtime depend on
+    /// generated output existing, which is exactly the kind of coupling that turns a missing
+    /// generator into an unexplainable build failure.
+    /// </para>
+    /// <para>
+    /// Absence is not an error: every type then falls back to a reflected plan, and
+    /// <see cref="IsVerified"/> reports honestly that no compile-time plan was available.
+    /// </para>
+    /// </remarks>
+    private static void EnsureGeneratedPlansLoaded()
+    {
+        if (_generatedLoaded) return;
+
+        lock (GeneratedGate)
+        {
+            if (_generatedLoaded) return;
+
+            var registrations = typeof(CloneRegistry).Assembly
+                .GetType("AiDotNet.Generated.CloneRegistrations", throwOnError: false);
+
+            registrations
+                ?.GetMethod("RegisterAll", BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public)
+                ?.Invoke(null, null);
+
+            _generatedLoaded = true;
+        }
+    }
+
+    /// <summary>
+    /// Builds a plan for a type the generator never saw, applying the same rules it would.
+    /// </summary>
+    /// <param name="type">The type to plan for.</param>
+    /// <returns>The reflected plan.</returns>
+    /// <remarks>
+    /// <para>
+    /// The rule is that everything is configuration unless provably otherwise. A property is
+    /// carried when it can be publicly read and written; a read-only, privately set, or computed
+    /// property is skipped because it is constructor-owned or derived from the values that
+    /// <i>are</i> carried, and re-deriving it is what keeps a clone consistent rather than merely
+    /// equal.
+    /// </para>
+    /// <para>
+    /// Deliberately <b>not</b> excluded by type shape: delegates and interfaces are carried, since
+    /// activation functions, kernels and schedules arrive that way and are genuine configuration.
+    /// Excluding them by shape would produce a clone that behaves differently while looking right.
+    /// </para>
+    /// </remarks>
+    private static ClonePlan BuildByReflection(Type type)
+    {
+        var entries = new List<ClonePlanEntry>();
+        var seen = new HashSet<string>(StringComparer.Ordinal);
+
+        // Walk the inheritance chain explicitly. GetProperties() on a derived type does surface
+        // inherited members, but walking the chain keeps the order stable from base to derived and
+        // makes the inherited surface visible rather than implied -- the surface whose omission
+        // dropped ModelOptions.Seed from 71 hand-written copy constructors.
+        for (var current = type; current is not null && current != typeof(object); current = current.BaseType)
+        {
+            var declared = current.GetProperties(
+                BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly);
+
+            foreach (var property in declared.OrderBy(p => p.Name, StringComparer.Ordinal))
+            {
+                if (!property.CanRead || property.SetMethod?.IsPublic != true) continue;
+                if (property.GetIndexParameters().Length > 0) continue;
+                if (IsExcluded(property)) continue;
+                if (!seen.Add(property.Name)) continue;
+
+                entries.Add(new ClonePlanEntry(property, CopyKindFor(property.PropertyType)));
+            }
+        }
+
+        entries.Reverse();
+        return new ClonePlan(
+            type,
+            entries,
+            constructorParameters: null,
+            constructorCandidates: BuildConstructorCandidates(type));
+    }
+
+    /// <summary>
+    /// Derives the constructors a type can be rebuilt through, for a type the generator never saw.
+    /// </summary>
+    /// <param name="type">The type to plan for.</param>
+    /// <returns>The candidates, widest first, or <see langword="null"/> when none were derived.</returns>
+    /// <remarks>
+    /// <para>
+    /// A reflected plan used to carry properties and nothing else, so <c>CloneEngine.Construct</c>
+    /// found no candidate and fell through to demanding a parameterless constructor. That made a
+    /// model the generator cannot see -- one declared in a consumer's own assembly, or a distribution
+    /// the generator skips -- cloneable only if it happened to have one, which is precisely the
+    /// "write your own model and everything generic just works" promise failing at the assembly
+    /// boundary. <c>GammaDistribution</c> and a test's own network subclass both died on it, with an
+    /// error telling the author to store constructor arguments in members they had already stored
+    /// them in.
+    /// </para>
+    /// <para>
+    /// Only derived when there is NO parameterless constructor. Where one exists, allocate-and-assign
+    /// is the path that has always run and the one every options object and layer relies on; taking a
+    /// derived constructor instead would re-route thousands of working clones through new code to fix
+    /// a case that is not broken. This fills the hole and touches nothing else.
+    /// </para>
+    /// <para>
+    /// The rule is the generator's rule, applied at runtime: a parameter is supplied when a property
+    /// or field holds it -- matched by name, by name with a leading underscore, or by the suffix rule
+    /// that lets <c>_bayesOptions</c> supply <c>options</c> -- and its type fits. A parameter nothing
+    /// supplies falls back to its own declared default, and a REQUIRED parameter nothing supplies
+    /// disqualifies that constructor rather than being handed null.
+    /// </para>
+    /// </remarks>
+    private static IReadOnlyList<IReadOnlyList<string>>? BuildConstructorCandidates(Type type)
+    {
+        const BindingFlags Flags =
+            BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance;
+
+        var parameterless = type.GetConstructor(Flags, binder: null, Type.EmptyTypes, modifiers: null);
+        if (parameterless is not null) return null;
+
+        var candidates = new List<IReadOnlyList<string>>();
+
+        // Widest first, matching what the plan promises. The engine still picks the first one this
+        // INSTANCE can satisfy, so a narrow constructor wins whenever the wide one wants something
+        // the object never stored.
+        foreach (var constructor in type.GetConstructors(Flags)
+            .OrderByDescending(c => c.GetParameters().Length))
+        {
+            var parameters = constructor.GetParameters();
+            if (parameters.Length == 0) continue;
+
+            var members = new string[parameters.Length];
+            var recordable = true;
+
+            for (int i = 0; i < parameters.Length; i++)
+            {
+                var member = FindSupplyingMember(type, parameters[i]);
+                if (member is not null) { members[i] = member; continue; }
+                if (parameters[i].HasDefaultValue) { members[i] = CloneEngine.UseDefault; continue; }
+
+                recordable = false;
+                break;
+            }
+
+            if (recordable) candidates.Add(members);
+        }
+
+        return candidates.Count > 0 ? candidates : null;
+    }
+
+    /// <summary>
+    /// Finds the member holding the value a constructor parameter was built from.
+    /// </summary>
+    /// <param name="type">The type being planned for.</param>
+    /// <param name="parameter">The constructor parameter to supply.</param>
+    /// <returns>The member's name, or <see langword="null"/> when nothing holds it.</returns>
+    /// <remarks>
+    /// An exact name beats a suffix match wherever both exist, so a type holding both <c>_options</c>
+    /// and <c>_bayesOptions</c> supplies <c>options</c> from the one actually named after it. The type
+    /// must fit as well as the name: a field called <c>_seed</c> holding a random generator does not
+    /// supply an <c>int seed</c>, and matching on the name alone would pass it and throw inside the
+    /// constructor rather than declining the candidate here.
+    /// </remarks>
+    private static string? FindSupplyingMember(Type type, ParameterInfo parameter)
+    {
+        const BindingFlags Flags =
+            BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly;
+
+        if (parameter.Name is not { } name) return null;
+
+        string? bySuffix = null;
+
+        for (var current = type; current is not null && current != typeof(object); current = current.BaseType)
+        {
+            foreach (var property in current.GetProperties(Flags))
+            {
+                if (!property.CanRead || property.GetIndexParameters().Length > 0) continue;
+
+                switch (Supplies(property.Name, name, property.PropertyType, parameter.ParameterType))
+                {
+                    case MemberMatch.Exact: return property.Name;
+                    case MemberMatch.Suffix: bySuffix ??= property.Name; break;
+                }
+            }
+
+            foreach (var field in current.GetFields(Flags))
+            {
+                switch (Supplies(field.Name, name, field.FieldType, parameter.ParameterType))
+                {
+                    case MemberMatch.Exact: return field.Name;
+                    case MemberMatch.Suffix: bySuffix ??= field.Name; break;
+                }
+            }
+        }
+
+        return bySuffix ?? FindUniqueByType(type, parameter.ParameterType);
+    }
+
+    /// <summary>
+    /// Finds the one member of a parameter's exact type, when there is exactly one.
+    /// </summary>
+    /// <param name="type">The type being planned for.</param>
+    /// <param name="parameterType">The constructor parameter's type.</param>
+    /// <returns>That member's name, or <see langword="null"/> when there is not exactly one.</returns>
+    /// <remarks>
+    /// <para>
+    /// The same rule <c>ClonePlanGenerator.FindUniqueByType</c> applies at compile time, and it is
+    /// here for the same reason: a constructor parameter is routinely stored under a name no rule
+    /// guesses. A subclass taking <c>arch</c> and handing it to a base that keeps it in
+    /// <c>Architecture</c> stores the value perfectly well; "Architecture" simply does not end in
+    /// "arch". Declining there would make a model unrebuildable over a naming choice.
+    /// </para>
+    /// <para>
+    /// EXACTLY ONE, and by exact type, both as the generator has it. Two members of a type would bind
+    /// in declaration order and could silently swap one for the other. Primitives and enums are
+    /// excluded because a lone int matching a lone int parameter is a coincidence, not a
+    /// correspondence -- keeping the runtime rule and the compile-time rule the same one.
+    /// </para>
+    /// </remarks>
+    private static string? FindUniqueByType(Type type, Type parameterType)
+    {
+        if (parameterType.IsPrimitive || parameterType.IsEnum
+            || parameterType == typeof(string) || parameterType == typeof(decimal)
+            || parameterType == typeof(DateTime) || parameterType == typeof(object))
+        {
+            return null;
+        }
+
+        const BindingFlags Flags =
+            BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly;
+
+        string? found = null;
+
+        for (var current = type; current is not null && current != typeof(object); current = current.BaseType)
+        {
+            foreach (var property in current.GetProperties(Flags))
+            {
+                if (!property.CanRead || property.GetIndexParameters().Length > 0) continue;
+                if (property.PropertyType != parameterType) continue;
+                if (found is not null) return null;
+
+                found = property.Name;
+            }
+
+            foreach (var field in current.GetFields(Flags))
+            {
+                if (field.FieldType != parameterType) continue;
+                if (found is not null) return null;
+
+                found = field.Name;
+            }
+        }
+
+        return found;
+    }
+
+    private enum MemberMatch { None, Suffix, Exact }
+
+    /// <summary>Decides whether a member can supply a constructor parameter.</summary>
+    private static MemberMatch Supplies(string member, string parameter, Type memberType, Type parameterType)
+    {
+        if (!parameterType.IsAssignableFrom(memberType)) return MemberMatch.None;
+
+        var trimmed = member.StartsWith("_", StringComparison.Ordinal) ? member.Substring(1) : member;
+        if (string.Equals(trimmed, parameter, StringComparison.OrdinalIgnoreCase)) return MemberMatch.Exact;
+
+        return trimmed.Length > parameter.Length
+            && trimmed.EndsWith(parameter, StringComparison.OrdinalIgnoreCase)
+                ? MemberMatch.Suffix
+                : MemberMatch.None;
+    }
+
+    /// <summary>
+    /// Determines whether a property is explicitly excluded from configuration.
+    /// </summary>
+    /// <param name="property">The property to test.</param>
+    /// <returns><see langword="true"/> when the property carries an exclusion attribute.</returns>
+    /// <remarks>
+    /// Matched by name so that the runtime does not have to reference the attribute assembly, and
+    /// so a consumer can define their own equivalents. Keeping the escape hatch small and named
+    /// makes every exclusion greppable, which is the point of having one.
+    /// </remarks>
+    private static bool IsExcluded(PropertyInfo property)
+        => property.GetCustomAttributes(inherit: true)
+            .Select(a => a.GetType().Name)
+            .Any(n => n is "NotConfigurationAttribute" or "ExternalResourceAttribute");
+
+    /// <summary>
+    /// Chooses how a value of the given type is carried.
+    /// </summary>
+    /// <param name="type">The property type.</param>
+    /// <returns>The copy kind.</returns>
+    /// <remarks>
+    /// Mutable containers are duplicated so the two instances cannot write through one buffer.
+    /// A string is a reference type but immutable, so sharing it is safe and copying it would be
+    /// waste; the same reasoning covers activation functions and other stateless strategy objects.
+    /// </remarks>
+    private static CloneCopyKind CopyKindFor(Type type)
+    {
+        if (type == typeof(string)) return CloneCopyKind.ByReference;
+        if (type.IsArray) return CloneCopyKind.Deep;
+
+        if (type.IsGenericType)
+        {
+            var definition = type.GetGenericTypeDefinition();
+            if (definition == typeof(List<>)
+                || definition == typeof(Dictionary<,>)
+                || definition == typeof(HashSet<>)
+                || definition == typeof(IList<>)
+                || definition == typeof(ICollection<>))
+            {
+                return CloneCopyKind.Deep;
+            }
+        }
+
+        return CloneCopyKind.ByReference;
+    }
+}
diff --git a/src/Models/IConfigurationCloneable.cs b/src/Models/IConfigurationCloneable.cs
new file mode 100644
index 0000000000..a6e3d14b97
--- /dev/null
+++ b/src/Models/IConfigurationCloneable.cs
@@ -0,0 +1,24 @@
+namespace AiDotNet.Models;
+
+/// <summary>
+/// Provides an independent constructor argument that carries configuration but not runtime state.
+/// </summary>
+/// <remarks>
+/// <para>
+/// Some constructor arguments are mutable blueprints rather than models themselves. Passing one of
+/// those objects directly to a reconstructed model can make the source and clone share the mutable
+/// objects the blueprint owns. Implementing this contract lets the central clone engine duplicate
+/// that configuration without teaching it about every blueprint type.
+/// </para>
+/// <para>
+/// Runtime parameters are deliberately outside this contract. The model and layer copy-on-write
+/// paths restore those after construction, so configuration cloning stays cheap.
+/// </para>
+/// </remarks>
+internal interface IConfigurationCloneable
+{
+    /// <summary>
+    /// Creates an independent copy containing only constructor-level configuration.
+    /// </summary>
+    object CloneConfiguration();
+}
diff --git a/src/Models/ModelBase.cs b/src/Models/ModelBase.cs
index 00d6ac73c2..0ab284587e 100644
--- a/src/Models/ModelBase.cs
+++ b/src/Models/ModelBase.cs
@@ -28,7 +28,7 @@ namespace AiDotNet.Models;
 /// only needs to implement its core prediction and training logic.
 /// </para>
 /// </remarks>
-public abstract class ModelBase<T, TInput, TOutput> : IFullModel<T, TInput, TOutput>,
+public abstract partial class ModelBase<T, TInput, TOutput> : IFullModel<T, TInput, TOutput>,
     IParameterizable<T, TInput, TOutput>, IFeatureAware, IGradientComputable<T, TInput, TOutput>,
     IParameterManifestProvider, IParameterChunkSource<T>
 {
@@ -105,6 +105,56 @@ protected virtual void RegisterGeneratedParameterComponents(ParameterComponentRe
     {
     }
 
+    /// <summary>State that is not a flat parameter vector, declared once and persisted by the base.</summary>
+    private readonly ModelStateRegistry<T> _stateRegistry = new();
+    private bool _stateRegistered;
+
+    /// <summary>
+    /// Declare state here that <see cref="GetParameters"/> does not carry -- a retained training set,
+    /// fitted knots, kernel centres, an ensemble's children.
+    /// </summary>
+    /// <param name="state">The registry to declare into.</param>
+    /// <remarks>
+    /// <para>
+    /// Every model whose learned state IS its parameter vector needs nothing here. The rest used to
+    /// hand-write a Serialize/Deserialize pair, because there was nowhere to say "this is state too"
+    /// -- and a hand-written pair is two places to forget the same field.
+    /// </para>
+    /// <para>
+    /// A declaration is a name and an accessor pair. Both halves of the payload are driven by it, so
+    /// they cannot drift; nothing here touches a writer or a reader.
+    /// </para>
+    /// </remarks>
+    protected virtual void RegisterState(ModelStateRegistry<T> state)
+    {
+    }
+    /// <summary>Generated state declarations for fields declared across this model's hierarchy.</summary>
+    /// <param name="state">The registry to declare into.</param>
+    /// <remarks>
+    /// Emitted by ModelStateGenerator into the partial model, so a model author declares nothing. The
+    /// hand-written <c>RegisterState</c> beside it exists only for state the classifier genuinely
+    /// cannot place; anything it CAN place belongs here, where it cannot be forgotten.
+    /// </remarks>
+    protected virtual void RegisterGeneratedState(AiDotNet.Models.ModelStateRegistry<T> state)
+    {
+        RegisterGeneratedStateCore(state);
+    }
+
+    /// <summary>The declared state, registered once and lazily so it runs after the constructor.</summary>
+    private ModelStateRegistry<T> State
+    {
+        get
+        {
+            if (!_stateRegistered)
+            {
+                _stateRegistered = true;
+                RegisterGeneratedState(_stateRegistry);
+                RegisterState(_stateRegistry);
+            }
+            return _stateRegistry;
+        }
+    }
+
     /// <summary>
     /// Runs after <see cref="SetParameters"/> has distributed values into the components. Override
     /// to refresh anything DERIVED from them.
@@ -279,7 +329,34 @@ public virtual IEnumerable<Tensor<T>> GetParameterChunks()
     // --- ICloneable ---
 
     /// <inheritdoc/>
-    public abstract IFullModel<T, TInput, TOutput> DeepCopy();
+    /// <remarks>
+    /// <para>
+    /// No longer abstract. Configuration is rebuilt from the compile-time clone plan, which records
+    /// the constructor the type was built with; learned state is carried through the model's own
+    /// public Serialize and Deserialize, so a model that persists something extra keeps it. The
+    /// persistence guard is told this is an internal operation because a clone is not a save.
+    /// </para>
+    /// <para>
+    /// A model overrides this only when the generator reports that it cannot rebuild the type --
+    /// a constructor parameter with no member holding its value -- and the build names which one.
+    /// </para>
+    /// </remarks>
+    public virtual IFullModel<T, TInput, TOutput> DeepCopy()
+    {
+        using (ModelPersistenceGuard.InternalOperation())
+        {
+            byte[] state = Serialize();
+            var copy = (ModelBase<T, TInput, TOutput>)AiDotNet.Models.CloneEngine.CopyConfiguration(this);
+            AiDotNet.Models.CloneEngine.PrepareParameterTopology(
+                this,
+                copy,
+                GetParameters().Length,
+                () => copy.GetParameters().Length);
+            copy.Deserialize(state);
+            AiDotNet.Models.CloneEngine.RestoreMutableConstructorConfiguration(this, copy);
+            return copy;
+        }
+    }
 
     /// <inheritdoc/>
     public virtual IFullModel<T, TInput, TOutput> Clone() => DeepCopy();
@@ -315,19 +392,122 @@ public virtual void ApplyGradients(Vector<T> gradients, T learningRate)
     // --- IModelSerializer ---
 
     /// <inheritdoc/>
+    /// <remarks>
+    /// <para>
+    /// THIS USED TO THROW, with the message "Override Serialize to provide an implementation", and
+    /// that instruction is the whole reason 368 hand-written Serialize/Deserialize halves exist. A
+    /// base that refuses the job conscripts every author into doing it by hand, and each hand-written
+    /// pair is two places to forget the same field.
+    /// </para>
+    /// <para>
+    /// It does the job now, from what the model has already DECLARED: components registered through
+    /// <see cref="RegisterParameterComponent"/> and
+    /// <see cref="RegisterGeneratedParameterComponents"/> are folded by
+    /// <see cref="GetParameters"/>, so the base can persist all of them without knowing anything
+    /// about a particular model. Configuration is not written here -- a clone gets it from the
+    /// recorded constructor, and a load applies it to a model the caller already constructed.
+    /// </para>
+    /// <para>
+    /// The type token is not decoration. Without it, loading one model's bytes into another whose
+    /// parameter vector happens to be the same length succeeds silently and yields a model that is
+    /// confidently wrong, which is precisely the class of defect this work exists to remove.
+    /// </para>
+    /// </remarks>
     public virtual byte[] Serialize()
     {
-        throw new NotSupportedException(
-            $"Serialization is not supported for {GetType().Name}. Override Serialize to provide an implementation.");
+        // ModelSave is a licensed capability. It used to be enforced only by each model's
+        // hand-written Serialize, so deleting one of those in favour of this base -- which is
+        // exactly what ADN0060 asks for -- silently removed the gate for that model. Enforcing
+        // here means the replacement carries it for every model, and a model that still has its
+        // own override keeps enforcing there. Re-entry is harmless: InternalOperation scopes
+        // suppress the nested call.
+        ModelPersistenceGuard.EnforceBeforeSerialize();
+
+        var parameters = GetParameters();
+
+        using var stream = new MemoryStream();
+        using var writer = new BinaryWriter(stream, System.Text.Encoding.UTF8, leaveOpen: true);
+
+        writer.Write(ModelSerializationMagic);
+        writer.Write(GetType().FullName ?? GetType().Name);
+        writer.Write(parameters.Length);
+        for (int i = 0; i < parameters.Length; i++)
+        {
+            writer.Write(Convert.ToDouble(parameters[i]));
+        }
+
+        // Whatever the model declared that the parameter vector does not carry: a retained training
+        // set, fitted knots, kernel centres, an ensemble's children.
+        State.WriteAll(writer);
+
+        writer.Flush();
+        return stream.ToArray();
     }
 
     /// <inheritdoc/>
     public virtual void Deserialize(byte[] data)
     {
-        throw new NotSupportedException(
-            $"Deserialization is not supported for {GetType().Name}. Override Deserialize to provide an implementation.");
+        // Load is not a paid gate, but it is still gated on an Active licence, and for the same
+        // reason as Serialize above: this base is now the replacement for the hand-written halves.
+        ModelPersistenceGuard.EnforceBeforeDeserialize();
+
+        if (data is null) throw new ArgumentNullException(nameof(data));
+
+        using var stream = new MemoryStream(data);
+        using var reader = new BinaryReader(stream, System.Text.Encoding.UTF8, leaveOpen: true);
+
+        int magic = reader.ReadInt32();
+        if (magic != ModelSerializationMagic)
+        {
+            throw new InvalidDataException(
+                $"{GetType().Name}: payload is not an AiDotNet model state block. A checkpoint written "
+                + "by an earlier hand-written Serialize must be regenerated.");
+        }
+
+        string savedType = reader.ReadString();
+        string liveType = GetType().FullName ?? GetType().Name;
+        if (!string.Equals(savedType, liveType, StringComparison.Ordinal))
+        {
+            throw new InvalidDataException(
+                $"State was saved from '{savedType}' and is being loaded into '{liveType}'. Loading it "
+                + "would produce a model that is confidently wrong rather than one that fails.");
+        }
+
+        int count = reader.ReadInt32();
+        var parameters = new Vector<T>(count);
+        for (int i = 0; i < count; i++)
+        {
+            parameters[i] = NumOps.FromDouble(reader.ReadDouble());
+        }
+
+        // Restore STRUCTURE before pouring the flat parameter vector into it. A fitted tree can have
+        // one constant in its constructor-created shell and two after its declared node graph is
+        // restored; setting parameters against the shell first rejects a perfectly valid payload.
+        // The vector remains authoritative for learned numeric values because it is applied last.
+        long declaredStatePosition = reader.BaseStream.Position;
+        bool hasDeclaredState = declaredStatePosition < reader.BaseStream.Length;
+        if (hasDeclaredState)
+        {
+            State.ReadBeforeParameters(reader);
+        }
+
+        SetParameters(parameters);
+
+        // A model can deliberately keep a trainable value in wider CLR storage than T (most
+        // commonly double working weights in a float model). The flat vector is still the public
+        // parameter contract, but narrowing it cannot reproduce those exact working values. The
+        // generator declares only those precision shadows for this second phase; ordinary fitted
+        // state is not replayed.
+        if (hasDeclaredState)
+        {
+            reader.BaseStream.Position = declaredStatePosition;
+            State.ReadAfterParameters(reader);
+        }
     }
 
+    /// <summary>Identifies a model state payload written by <see cref="Serialize"/>.</summary>
+    private const int ModelSerializationMagic = unchecked((int)0xA1D00DE1);
+
     /// <inheritdoc/>
     public virtual void SaveModel(string filePath)
     {
diff --git a/src/Models/ModelOptionsCloneExtensions.cs b/src/Models/ModelOptionsCloneExtensions.cs
new file mode 100644
index 0000000000..bb2a2c78b3
--- /dev/null
+++ b/src/Models/ModelOptionsCloneExtensions.cs
@@ -0,0 +1,56 @@
+using System;
+
+namespace AiDotNet.Models;
+
+/// <summary>
+/// Cloning for options classes.
+/// </summary>
+/// <remarks>
+/// <para>
+/// <b>For Beginners:</b> <c>options.Clone()</c> gives you a separate copy you can change without
+/// affecting the original — useful for running the same model with one setting varied. You do not
+/// have to write anything to make this work on your own options class: inherit from an options base
+/// class and cloning is already correct.
+/// </para>
+/// <para>
+/// Offered as an extension rather than a virtual method so that the return type is the caller's own
+/// type. <c>myOptions.Clone()</c> yields <c>MyOptions</c>, not the abstract base, without every
+/// options class having to override anything or the base class needing a self-referencing type
+/// parameter that would show up in every derived signature.
+/// </para>
+/// </remarks>
+public static class ModelOptionsCloneExtensions
+{
+    /// <summary>
+    /// Creates an independent copy of an options instance.
+    /// </summary>
+    /// <typeparam name="T">The options type; inferred from <paramref name="source"/>.</typeparam>
+    /// <param name="source">The options to copy.</param>
+    /// <param name="options">
+    /// Reserved for symmetry with model and layer cloning. Options hold configuration and nothing
+    /// else, so every setting on <see cref="CloneOptions"/> that concerns learned state has nothing
+    /// to act on here.
+    /// </param>
+    /// <returns>A new instance carrying the same configuration.</returns>
+    /// <exception cref="ArgumentNullException">Thrown when <paramref name="source"/> is null.</exception>
+    /// <remarks>
+    /// <para>
+    /// Every property is carried, including those declared on base classes. That inherited surface
+    /// is what a hand-written copy constructor cannot see from a type's own declarations, and it is
+    /// where 71 of them silently dropped <c>ModelOptions.Seed</c> — a clone that kept the default
+    /// seed while the original kept a configured one, changing results with nothing to show for it.
+    /// </para>
+    /// <para>
+    /// Collections are duplicated rather than shared, so configuring the copy cannot reconfigure
+    /// the original through a buffer they both point at.
+    /// </para>
+    /// </remarks>
+    public static T Clone<T>(this T source, CloneOptions? options = null)
+        where T : ModelOptions
+    {
+        if (source is null) throw new ArgumentNullException(nameof(source));
+
+        _ = options;
+        return (T)CloneEngine.CopyConfiguration(source);
+    }
+}
diff --git a/src/Models/ModelStateRegistry.cs b/src/Models/ModelStateRegistry.cs
new file mode 100644
index 0000000000..52bf12c67d
--- /dev/null
+++ b/src/Models/ModelStateRegistry.cs
@@ -0,0 +1,2065 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using AiDotNet.Helpers;
+using AiDotNet.Interfaces;
+using AiDotNet.LinearAlgebra;
+using AiDotNet.Tensors.LinearAlgebra;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+
+namespace AiDotNet.Models;
+
+/// <summary>
+/// Attaches declared state to a payload whose format this code does not know.
+/// </summary>
+/// <remarks>
+/// <para>
+/// There are twenty-six parallel model base hierarchies, each with its own <c>byte[] Serialize()</c>
+/// and its own format -- some JSON, some binary, some nested metadata. They are siblings over the
+/// same interfaces rather than a hierarchy, so there is no one place to put a state block and no
+/// single format to put it in.
+/// </para>
+/// <para>
+/// So the state is appended as a SUFFIX and located from the END: the trailer is the magic and the
+/// block length, which means the existing payload in front of it is untouched and does not need to
+/// be understood. A payload written before this existed simply has no trailer, so it reads back
+/// exactly as it always did -- old checkpoints keep working instead of failing on a format they
+/// could not have known about.
+/// </para>
+/// </remarks>
+public static class ModelStateEnvelope
+{
+    private const int Magic = unchecked((int)0xA1D057A7);
+    private const int TrailerLength = sizeof(int) * 2;
+
+    /// <summary>Appends the declared state to a payload, or returns it unchanged when none exists.</summary>
+    /// <typeparam name="T">The model's numeric type.</typeparam>
+    /// <param name="state">The model's declared state.</param>
+    /// <param name="payload">Whatever the base already produced.</param>
+    /// <returns>The payload, with a state trailer when there is state to carry.</returns>
+    public static byte[] Append<T>(ModelStateRegistry<T> state, byte[] payload)
+    {
+        if (state is null || state.Count == 0) return payload;
+
+        using var buffer = new MemoryStream();
+        using (var writer = new BinaryWriter(buffer, System.Text.Encoding.UTF8, leaveOpen: true))
+        {
+            state.WriteAll(writer);
+            writer.Flush();
+        }
+
+        var block = buffer.ToArray();
+        var result = new byte[payload.Length + block.Length + TrailerLength];
+
+        Buffer.BlockCopy(payload, 0, result, 0, payload.Length);
+        Buffer.BlockCopy(block, 0, result, payload.Length, block.Length);
+        Buffer.BlockCopy(BitConverter.GetBytes(block.Length), 0, result, payload.Length + block.Length, sizeof(int));
+        Buffer.BlockCopy(BitConverter.GetBytes(Magic), 0, result, payload.Length + block.Length + sizeof(int), sizeof(int));
+
+        return result;
+    }
+
+    /// <summary>Applies and strips a state trailer, returning the payload the base should read.</summary>
+    /// <typeparam name="T">The model's numeric type.</typeparam>
+    /// <param name="state">The model's declared state.</param>
+    /// <param name="payload">The stored bytes.</param>
+    /// <returns>The payload without its trailer, or the original when there is none.</returns>
+    public static byte[] Extract<T>(ModelStateRegistry<T> state, byte[] payload)
+        => Extract(state, payload, restoreAfterParameters: null);
+
+    /// <summary>
+    /// Applies structural state and strips the envelope, deferring exact native-precision
+    /// parameter shadows until the ordinary flat parameter vector has been restored.
+    /// </summary>
+    public static byte[] ExtractBeforeParameters<T>(ModelStateRegistry<T> state, byte[] payload)
+        => Extract(state, payload, restoreAfterParameters: false);
+
+    /// <summary>
+    /// Applies only exact native-precision parameter shadows from an envelope. The returned inner
+    /// payload is provided for symmetry and can be ignored by callers that already parsed it.
+    /// </summary>
+    public static byte[] ExtractAfterParameters<T>(ModelStateRegistry<T> state, byte[] payload)
+        => Extract(state, payload, restoreAfterParameters: true);
+
+    private static byte[] Extract<T>(
+        ModelStateRegistry<T> state,
+        byte[] payload,
+        bool? restoreAfterParameters)
+    {
+        if (payload is null) throw new ArgumentNullException(nameof(payload));
+        if (payload.Length < TrailerLength) return payload;
+
+        int magic = BitConverter.ToInt32(payload, payload.Length - sizeof(int));
+        if (magic != Magic) return payload;
+
+        int blockLength = BitConverter.ToInt32(payload, payload.Length - TrailerLength);
+        int innerLength = payload.Length - TrailerLength - blockLength;
+        if (blockLength < 0 || innerLength < 0) return payload;
+
+        if (state is not null && state.Count > 0)
+        {
+            using var buffer = new MemoryStream(payload, innerLength, blockLength);
+            using var reader = new BinaryReader(buffer, System.Text.Encoding.UTF8, leaveOpen: true);
+            if (!restoreAfterParameters.HasValue) state.ReadAll(reader);
+            else if (restoreAfterParameters.Value) state.ReadAfterParameters(reader);
+            else state.ReadBeforeParameters(reader);
+        }
+
+        var inner = new byte[innerLength];
+        Buffer.BlockCopy(payload, 0, inner, 0, innerLength);
+        return inner;
+    }
+}
+
+/// <summary>
+/// The declared home for model state that is not a flat parameter vector.
+/// </summary>
+/// <typeparam name="T">The model's numeric type.</typeparam>
+/// <remarks>
+/// <para>
+/// <see cref="ModelBase{T, TInput, TOutput}"/> persists whatever the model declared through its
+/// parameter components, which covers every model whose learned state IS its parameter vector. It is
+/// not everything. A k-nearest-neighbours model's state is the training set; a random forest's is a
+/// list of trees; a GAM's is its fitted knot vectors; a kernel ridge model's is its centres and dual
+/// coefficients. None of that fits a flat vector, none of it had anywhere to be declared, and so
+/// every one of those models hand-wrote a Serialize/Deserialize pair -- which is two places to forget
+/// the same field.
+/// </para>
+/// <para>
+/// This is the model-side analogue of <c>LayerBase.RegisterBuffer</c>. A model DECLARES a piece of
+/// state once, by name, with a getter and a setter; the base writes and reads it. The author never
+/// touches a <see cref="BinaryWriter"/>, and because both halves are driven by the one registration
+/// they cannot drift apart -- the failure mode a hand-written pair cannot detect.
+/// </para>
+/// <para>
+/// Keyed by NAME, and a name in the payload with no matching registration is skipped rather than
+/// fatal, so adding state does not invalidate existing checkpoints. Values are written in
+/// registration order, but read by name, so re-ordering registrations is also safe.
+/// </para>
+/// </remarks>
+public sealed class ModelStateRegistry<T>
+{
+    // A child-list payload used to begin directly with its count. A negative marker keeps old
+    // payloads readable while allowing new payloads to record each child's concrete runtime type.
+    private const int TypedChildListMarker = unchecked((int)0xA1D0C11D);
+
+    private static readonly JsonSerializerSettings ObjectStateSettings = new()
+    {
+        ConstructorHandling = ConstructorHandling.AllowNonPublicDefaultConstructor,
+        Formatting = Formatting.None,
+        TypeNameHandling = TypeNameHandling.None,
+        Converters = { new ModelSerializerJsonConverter() }
+    };
+
+    private readonly List<Entry> _entries = new();
+    private readonly HashSet<string> _names = new(StringComparer.Ordinal);
+
+    private sealed class Entry
+    {
+        public string Name = string.Empty;
+        public Action<BinaryWriter> Write = _ => { };
+        public Action<BinaryReader> Read = _ => { };
+        public bool RestoreAfterParameters;
+    }
+
+    /// <summary>Gets the number of declared state entries.</summary>
+    public int Count => _entries.Count;
+
+    private void Add(
+        string name,
+        Action<BinaryWriter> write,
+        Action<BinaryReader> read,
+        bool restoreAfterParameters = false)
+    {
+        if (string.IsNullOrWhiteSpace(name))
+            throw new ArgumentException("State name must not be empty.", nameof(name));
+
+        // A duplicate name would make the payload ambiguous on the way back in, and the value that
+        // won would depend on registration order -- exactly the kind of order dependence that makes
+        // a restore differ from a save for reasons nobody can see.
+        if (!_names.Add(name))
+            throw new ArgumentException($"State '{name}' is already declared on this model.", nameof(name));
+
+        _entries.Add(new Entry
+        {
+            Name = name,
+            Write = write,
+            Read = read,
+            RestoreAfterParameters = restoreAfterParameters
+        });
+    }
+
+    /// <summary>Declares a vector, such as a fitted knot vector or a set of dual coefficients.</summary>
+    /// <param name="name">A stable name, unique within the model.</param>
+    /// <param name="get">Reads the current value.</param>
+    /// <param name="set">Installs a restored value.</param>
+    public void Declare(string name, Func<Vector<T>?> get, Action<Vector<T>?> set)
+        => Add(name,
+            w => WriteVector(w, get()),
+            r => set(ReadVector(r)));
+
+    /// <summary>Declares a byte vector, such as quantized optimizer moments.</summary>
+    public void DeclareByteVector(string name, Func<Vector<byte>?> get, Action<Vector<byte>?> set)
+        => Add(name,
+            w =>
+            {
+                var vector = get();
+                if (vector is null) { w.Write(-1); return; }
+                w.Write(vector.Length);
+                for (int i = 0; i < vector.Length; i++) w.Write(vector[i]);
+            },
+            r =>
+            {
+                int length = r.ReadInt32();
+                if (length < 0) { set(null); return; }
+                var vector = new Vector<byte>(length);
+                for (int i = 0; i < length; i++) vector[i] = r.ReadByte();
+                set(vector);
+            });
+
+    /// <summary>Declares a double vector held by a model whose primary numeric type may differ.</summary>
+    public void DeclareDoubleVector(string name, Func<Vector<double>?> get, Action<Vector<double>?> set)
+        => Add(name,
+            w =>
+            {
+                var vector = get();
+                if (vector is null) { w.Write(-1); return; }
+                w.Write(vector.Length);
+                for (int i = 0; i < vector.Length; i++) w.Write(vector[i]);
+            },
+            r =>
+            {
+                int length = r.ReadInt32();
+                if (length < 0) { set(null); return; }
+                var vector = new Vector<double>(length);
+                for (int i = 0; i < length; i++) vector[i] = r.ReadDouble();
+                set(vector);
+            });
+
+    /// <summary>Declares a matrix, such as the retained training set of an instance-based model.</summary>
+    /// <param name="name">A stable name, unique within the model.</param>
+    /// <param name="get">Reads the current value.</param>
+    /// <param name="set">Installs a restored value.</param>
+    public void Declare(string name, Func<Matrix<T>?> get, Action<Matrix<T>?> set)
+        => Add(name,
+            w => WriteMatrix(w, get()),
+            r => set(ReadMatrix(r)));
+
+    /// <summary>Declares an assignable fitted object, array, list, or dictionary.</summary>
+    /// <typeparam name="TState">The compile-time state type.</typeparam>
+    /// <param name="name">A stable name, unique within the model.</param>
+    /// <param name="get">Reads the current value.</param>
+    /// <param name="set">Installs the restored value.</param>
+    /// <remarks>
+    /// This is the general object-state path used by generated declarations for learned structures
+    /// that are not numeric tensors: nested tree nodes, ensemble records, jagged arrays and similar
+    /// model-owned data. Nested models still travel through their own serializer, so a POCO record
+    /// that contains a model does not reduce that child to its public properties.
+    /// </remarks>
+    public void DeclareObject<TState>(string name, Func<TState?> get, Action<TState?> set)
+        where TState : class
+        => Add(name,
+            w => WriteObjectState(w, get()),
+            r => set(ReadObjectState<TState>(r, name)));
+
+    /// <summary>Declares a readonly list or dictionary and restores its contents in place.</summary>
+    /// <typeparam name="TState">The concrete collection type.</typeparam>
+    /// <param name="name">A stable name, unique within the model.</param>
+    /// <param name="get">Reads the collection instance created by the model constructor.</param>
+    /// <remarks>
+    /// A readonly collection field means the reference is configuration, not that its fitted
+    /// contents are immutable. The generator cannot assign that field, so the registry clears and
+    /// refills the existing collection. Failing loudly when the constructor left it null prevents a
+    /// successful-looking restore that silently drops the payload.
+    /// </remarks>
+    public void DeclareObjectInPlace<TState>(string name, Func<TState?> get)
+        where TState : class
+        => Add(name,
+            w => WriteObjectState(w, get()),
+            r =>
+            {
+                var restored = ReadObjectState<TState>(r, name);
+                var current = get();
+                if (current is null)
+                {
+                    throw new InvalidOperationException(
+                        $"State '{name}' is held in a readonly collection, but its constructor left "
+                        + "the collection null, so the restored contents have nowhere to go.");
+                }
+
+                CopyCollectionState(name, current, restored);
+            });
+
+    /// <summary>
+    /// Declares a deterministic repair that runs after the ordinary state entries in the payload.
+    /// </summary>
+    /// <param name="name">A stable name, unique within the model.</param>
+    /// <param name="restore">Rebuilds state derived from the entries restored before it.</param>
+    /// <remarks>
+    /// The entry intentionally writes no payload. Its presence in the name-framed state block makes
+    /// the callback version-safe, while registration order ensures options and fitted dimensions are
+    /// available before generated code reconstructs helpers that are derived from them.
+    /// </remarks>
+    public void DeclareAfterRestore(string name, Action restore)
+    {
+        if (restore is null) throw new ArgumentNullException(nameof(restore));
+        Add(name, _ => { }, _ => restore());
+    }
+
+    /// <summary>
+    /// Declares a deterministic repair that runs after the flat parameter vector has been restored.
+    /// </summary>
+    /// <param name="name">A stable name, unique within the model.</param>
+    /// <param name="restore">Rebuilds scratch state derived from restored parameters.</param>
+    /// <remarks>
+    /// This is the parameter-aware counterpart to <see cref="DeclareAfterRestore"/>. It is used for
+    /// derived caches such as matrix transposes: rebuilding them before the parameter phase would
+    /// cache the fresh constructor values and make a clone execute with stale data.
+    /// </remarks>
+    public void DeclareAfterParameterRestore(string name, Action restore)
+    {
+        if (restore is null) throw new ArgumentNullException(nameof(restore));
+        Add(name, _ => { }, _ => restore(), restoreAfterParameters: true);
+    }
+
+    /// <summary>Declares a readonly list of vectors and restores its contents in place.</summary>
+    public void DeclareInPlace(string name, Func<List<Vector<T>>?> get)
+        => Declare(name, get, restored => RestoreCollectionInPlace(name, get, restored));
+
+    /// <summary>Declares a readonly list of matrices and restores its contents in place.</summary>
+    public void DeclareInPlace(string name, Func<List<Matrix<T>>?> get)
+        => Declare(name, get, restored => RestoreCollectionInPlace(name, get, restored));
+
+    /// <summary>Declares a readonly list of tensors and restores its contents in place.</summary>
+    public void DeclareInPlace(string name, Func<List<Tensor<T>>?> get)
+        => Declare(name, get, restored => RestoreCollectionInPlace(name, get, restored));
+
+    /// <summary>Declares a readonly string-keyed vector table and restores it in place.</summary>
+    public void DeclareInPlace(string name, Func<Dictionary<string, Vector<T>>?> get)
+        => Declare(name, get, restored => RestoreCollectionInPlace(name, get, restored));
+
+    /// <summary>Declares a readonly integer-keyed vector table and restores it in place.</summary>
+    public void DeclareInPlace(string name, Func<Dictionary<int, Vector<T>>?> get)
+        => Declare(name, get, restored => RestoreCollectionInPlace(name, get, restored));
+
+    private static void RestoreCollectionInPlace<TState>(
+        string name,
+        Func<TState?> get,
+        TState? restored)
+        where TState : class
+    {
+        var current = get();
+        if (current is null)
+        {
+            throw new InvalidOperationException(
+                $"State '{name}' is held in a readonly collection, but its constructor left "
+                + "the collection null, so the restored contents have nowhere to go.");
+        }
+
+        CopyCollectionState(name, current, restored);
+    }
+
+    private static void WriteObjectState<TState>(BinaryWriter writer, TState? value)
+        where TState : class
+    {
+        if (value is null) { writer.Write(false); return; }
+        writer.Write(true);
+        writer.Write(JsonConvert.SerializeObject(value, ObjectStateSettings));
+    }
+
+    private static TState? ReadObjectState<TState>(BinaryReader reader, string name)
+        where TState : class
+    {
+        if (!reader.ReadBoolean()) return null;
+        string json = reader.ReadString();
+        try
+        {
+            return JsonConvert.DeserializeObject<TState>(json, ObjectStateSettings)
+                ?? throw new InvalidOperationException(
+                    $"State '{name}' deserialized to null for '{typeof(TState).FullName}'.");
+        }
+        catch (JsonException exception)
+        {
+            throw new InvalidOperationException(
+                $"State '{name}' is not valid serialized object state for "
+                + $"'{typeof(TState).FullName}'.",
+                exception);
+        }
+    }
+
+    private static void CopyCollectionState<TState>(string name, TState current, TState? restored)
+        where TState : class
+    {
+        if (current is IDictionary currentDictionary)
+        {
+            currentDictionary.Clear();
+            if (restored is IDictionary restoredDictionary)
+            {
+                foreach (DictionaryEntry pair in restoredDictionary)
+                    currentDictionary.Add(pair.Key, pair.Value);
+            }
+            return;
+        }
+
+        if (current is IList currentList)
+        {
+            currentList.Clear();
+            if (restored is IList restoredList)
+            {
+                foreach (var item in restoredList) currentList.Add(item);
+            }
+            return;
+        }
+
+        throw new InvalidOperationException(
+            $"State '{name}' requested in-place restoration for '{typeof(TState).FullName}', "
+            + "which is neither a list nor a dictionary.");
+    }
+
+    /// <summary>
+    /// Preserves nested models inside generated object state through their canonical serializer.
+    /// </summary>
+    private sealed class ModelSerializerJsonConverter : JsonConverter
+    {
+        public override bool CanConvert(Type objectType)
+            => typeof(IModelSerializer).IsAssignableFrom(objectType);
+
+        public override void WriteJson(JsonWriter writer, object? value, JsonSerializer serializer)
+        {
+            if (value is null) { writer.WriteNull(); return; }
+            if (value is not IModelSerializer model)
+                throw new JsonSerializationException(
+                    $"'{value.GetType().FullName}' does not implement IModelSerializer.");
+
+            writer.WriteStartObject();
+            writer.WritePropertyName("modelType");
+            writer.WriteValue(value.GetType().AssemblyQualifiedName);
+            writer.WritePropertyName("payload");
+            writer.WriteValue(Convert.ToBase64String(model.Serialize()));
+            writer.WriteEndObject();
+        }
+
+        public override object? ReadJson(
+            JsonReader reader,
+            Type objectType,
+            object? existingValue,
+            JsonSerializer serializer)
+        {
+            if (reader.TokenType == JsonToken.Null) return null;
+
+            var data = JObject.Load(reader);
+            string? typeName = data["modelType"]?.Value<string>();
+            string? payloadText = data["payload"]?.Value<string>();
+            Type? concrete = string.IsNullOrWhiteSpace(typeName)
+                ? objectType
+                : Type.GetType(typeName!, throwOnError: false);
+
+            if (concrete is null || !objectType.IsAssignableFrom(concrete)
+                || !typeof(IModelSerializer).IsAssignableFrom(concrete))
+            {
+                throw new JsonSerializationException(
+                    $"Nested model type '{typeName}' cannot be restored as '{objectType.FullName}'.");
+            }
+
+            var model = CreateSerializable(concrete, "generated object state");
+            try
+            {
+                model.Deserialize(Convert.FromBase64String(payloadText ?? string.Empty));
+            }
+            catch (FormatException exception)
+            {
+                throw new JsonSerializationException("Nested model payload is not valid base64.", exception);
+            }
+            return model;
+        }
+    }
+
+    /// <summary>Declares a list of vectors, such as per-feature knots or per-output coefficients.</summary>
+    /// <param name="name">A stable name, unique within the model.</param>
+    /// <param name="get">Reads the current value.</param>
+    /// <param name="set">Installs a restored value.</param>
+    /// <remarks>
+    /// A per-feature collection is one piece of state, not N of them: restoring some entries and not
+    /// others gives a model that is fitted for part of its input and defaulted for the rest, which
+    /// predicts without complaining.
+    /// </remarks>
+    public void Declare(string name, Func<List<Vector<T>>?> get, Action<List<Vector<T>>?> set)
+        => Add(name,
+            w =>
+            {
+                var list = get();
+                if (list is null) { w.Write(-1); return; }
+                w.Write(list.Count);
+                foreach (var v in list) WriteVector(w, v);
+            },
+            r =>
+            {
+                int count = r.ReadInt32();
+                if (count < 0) { set(null); return; }
+                var list = new List<Vector<T>>(count);
+                for (int i = 0; i < count; i++) list.Add(ReadVector(r) ?? new Vector<T>(0));
+                set(list);
+            });
+
+    /// <summary>Declares a tensor.</summary>
+    /// <param name="name">A stable name, unique within the model.</param>
+    /// <param name="get">Reads the current value.</param>
+    /// <param name="set">Installs a restored value.</param>
+    public void Declare(string name, Func<Tensor<T>?> get, Action<Tensor<T>?> set)
+        => Add(name,
+            w => WriteTensor(w, get()),
+            r => set(ReadTensor(r)));
+
+    /// <summary>Declares a list of tensors, such as a temporal memory bank.</summary>
+    public void Declare(string name, Func<List<Tensor<T>>?> get, Action<List<Tensor<T>>?> set)
+        => Add(name,
+            w =>
+            {
+                var list = get();
+                if (list is null) { w.Write(-1); return; }
+                w.Write(list.Count);
+                foreach (var tensor in list) WriteTensor(w, tensor);
+            },
+            r =>
+            {
+                int count = r.ReadInt32();
+                if (count < 0) { set(null); return; }
+                var list = new List<Tensor<T>>(count);
+                for (int i = 0; i < count; i++)
+                    list.Add(ReadTensor(r) ?? new Tensor<T>([0]));
+                set(list);
+            });
+
+    /// <summary>Declares an integer array, such as node indices or a feature mapping.</summary>
+    /// <param name="name">A stable name, unique within the model.</param>
+    /// <param name="get">Reads the current value.</param>
+    /// <param name="set">Installs a restored value.</param>
+    public void Declare(string name, Func<int[]?> get, Action<int[]?> set)
+        => Add(name,
+            w => WriteInts(w, get()),
+            r => set(ReadInts(r)));
+
+    /// <summary>
+    /// Describes ONE node of a recursive structure, so the registry can walk the whole of it.
+    /// </summary>
+    /// <typeparam name="TNode">The node type.</typeparam>
+    /// <remarks>
+    /// <para>
+    /// A decision tree, a Hoeffding tree, an M5 model tree -- their learned model is a node graph,
+    /// not a vector, and it was the one shape nothing here could express. Every tree model therefore
+    /// kept a hand-written Serialize that walked the graph itself, and every ENSEMBLE of trees
+    /// inherited that: a forest cannot round-trip until its members can.
+    /// </para>
+    /// <para>
+    /// The model describes a single node -- its own fields, and which of its members are children --
+    /// and the registry does the recursion, the null markers and the ordering. Nothing in the model
+    /// touches a reader or a writer, and the description is small enough to read at a glance.
+    /// </para>
+    /// </remarks>
+    public sealed class NodeShape<TNode> where TNode : class
+    {
+        internal Func<TNode>? Factory;
+        internal readonly List<(Action<TNode, BinaryWriter> Write, Action<TNode, BinaryReader> Read)> Fields = new();
+        internal readonly List<(Func<TNode, TNode?> Get, Action<TNode, TNode?> Set)> Children = new();
+
+        /// <summary>Declares how to make an empty node.</summary>
+        /// <param name="factory">Creates a node with no fields set.</param>
+        /// <returns>This shape, for chaining.</returns>
+        public NodeShape<TNode> Create(Func<TNode> factory)
+        {
+            Factory = factory;
+            return this;
+        }
+
+        /// <summary>Declares an integer field on the node.</summary>
+        /// <param name="get">Reads it.</param>
+        /// <param name="set">Writes it.</param>
+        /// <returns>This shape, for chaining.</returns>
+        public NodeShape<TNode> Int32(Func<TNode, int> get, Action<TNode, int> set)
+        {
+            Fields.Add(((n, w) => w.Write(get(n)), (n, r) => set(n, r.ReadInt32())));
+            return this;
+        }
+
+        /// <summary>Declares a 64-bit integer field on the node.</summary>
+        public NodeShape<TNode> Int64(Func<TNode, long> get, Action<TNode, long> set)
+        {
+            Fields.Add(((n, w) => w.Write(get(n)), (n, r) => set(n, r.ReadInt64())));
+            return this;
+        }
+
+        /// <summary>Declares a <see cref="double"/> field on the node.</summary>
+        /// <param name="get">Reads it.</param>
+        /// <param name="set">Installs a restored value.</param>
+        /// <remarks>
+        /// Distinct from <see cref="Scalar"/>, which carries the model's own <typeparamref name="T"/>.
+        /// A tree's split threshold is frequently declared as a plain <c>double</c> regardless of the
+        /// model's numeric type, and routing that through Scalar would convert it to T and back,
+        /// changing the value on any T narrower than double.
+        /// </remarks>
+        public NodeShape<TNode> Double(Func<TNode, double> get, Action<TNode, double> set)
+        {
+            Fields.Add(((n, w) => w.Write(get(n)), (n, r) => set(n, r.ReadDouble())));
+            return this;
+        }
+
+        /// <summary>Declares a <see cref="double"/> array field on the node, such as a leaf's curve.</summary>
+        /// <param name="get">Reads it.</param>
+        /// <param name="set">Installs a restored value.</param>
+        /// <remarks>
+        /// Null and empty are distinguished by a -1 length, matching the registry's own array
+        /// declarations: a leaf that never accumulated a curve is not the same as one whose curve
+        /// is empty.
+        /// </remarks>
+        public NodeShape<TNode> DoubleArray(Func<TNode, double[]?> get, Action<TNode, double[]?> set)
+        {
+            Fields.Add((
+                (n, w) =>
+                {
+                    var a = get(n);
+                    if (a is null) { w.Write(-1); return; }
+                    w.Write(a.Length);
+                    foreach (var value in a) w.Write(value);
+                },
+                (n, r) =>
+                {
+                    int length = r.ReadInt32();
+                    if (length < 0) { set(n, null); return; }
+                    var a = new double[length];
+                    for (int i = 0; i < length; i++) a[i] = r.ReadDouble();
+                    set(n, a);
+                }));
+            return this;
+        }
+
+        /// <summary>Declares a boolean field on the node.</summary>
+        /// <param name="get">Reads it.</param>
+        /// <param name="set">Writes it.</param>
+        /// <returns>This shape, for chaining.</returns>
+        public NodeShape<TNode> Boolean(Func<TNode, bool> get, Action<TNode, bool> set)
+        {
+            Fields.Add(((n, w) => w.Write(get(n)), (n, r) => set(n, r.ReadBoolean())));
+            return this;
+        }
+
+        /// <summary>Declares a field held as the model's numeric type.</summary>
+        /// <param name="get">Reads it.</param>
+        /// <param name="set">Writes it.</param>
+        /// <returns>This shape, for chaining.</returns>
+        public NodeShape<TNode> Scalar(Func<TNode, T> get, Action<TNode, T> set)
+        {
+            Fields.Add((
+                (n, w) => w.Write(Convert.ToDouble(get(n))),
+                (n, r) => set(n, Ops.FromDouble(r.ReadDouble()))));
+            return this;
+        }
+
+        /// <summary>Declares a vector field on the node, such as class probabilities.</summary>
+        /// <param name="get">Reads it.</param>
+        /// <param name="set">Writes it.</param>
+        /// <returns>This shape, for chaining.</returns>
+        public NodeShape<TNode> Vector(Func<TNode, Vector<T>?> get, Action<TNode, Vector<T>?> set)
+        {
+            Fields.Add((
+                (n, w) => WriteVector(w, get(n)),
+                (n, r) => set(n, ReadVector(r))));
+            return this;
+        }
+
+        /// <summary>Declares one of the node's children.</summary>
+        /// <param name="get">Reads it.</param>
+        /// <param name="set">Attaches it.</param>
+        /// <returns>This shape, for chaining.</returns>
+        public NodeShape<TNode> Child(Func<TNode, TNode?> get, Action<TNode, TNode?> set)
+        {
+            Children.Add((get, set));
+            return this;
+        }
+    }
+
+    /// <summary>Declares a recursive node graph, such as a decision tree.</summary>
+    /// <typeparam name="TNode">The node type.</typeparam>
+    /// <param name="name">A stable name, unique within the model.</param>
+    /// <param name="getRoot">Reads the root.</param>
+    /// <param name="setRoot">Installs a restored root.</param>
+    /// <param name="describe">Describes one node.</param>
+    public void DeclareGraph<TNode>(
+        string name,
+        Func<TNode?> getRoot,
+        Action<TNode?> setRoot,
+        Action<NodeShape<TNode>> describe)
+        where TNode : class
+    {
+        var shape = new NodeShape<TNode>();
+        describe(shape);
+
+        if (shape.Factory is null)
+            throw new ArgumentException($"State '{name}' must declare Create so its nodes can be rebuilt.", nameof(describe));
+
+        Add(name,
+            w => WriteNode(w, getRoot(), shape),
+            r => setRoot(ReadNode(r, shape)));
+    }
+
+    private static void WriteNode<TNode>(BinaryWriter w, TNode? node, NodeShape<TNode> shape)
+        where TNode : class
+    {
+        // A presence flag per node, so an absent child costs one byte and a null root is representable.
+        if (node is null) { w.Write(false); return; }
+
+        w.Write(true);
+        foreach (var field in shape.Fields) field.Write(node, w);
+        foreach (var child in shape.Children) WriteNode(w, child.Get(node), shape);
+    }
+
+    private static TNode? ReadNode<TNode>(BinaryReader r, NodeShape<TNode> shape)
+        where TNode : class
+    {
+        if (!r.ReadBoolean()) return null;
+
+        var node = shape.Factory!();
+        foreach (var field in shape.Fields) field.Read(node, r);
+        foreach (var child in shape.Children) child.Set(node, ReadNode(r, shape));
+        return node;
+    }
+
+    /// <summary>Declares a LIST of node graphs — a forest, where each entry is its own root.</summary>
+    /// <typeparam name="TNode">The node type.</typeparam>
+    /// <param name="name">A stable name, unique within the model.</param>
+    /// <param name="get">Reads the current roots.</param>
+    /// <param name="set">Installs the restored roots.</param>
+    /// <param name="describe">Describes one node, exactly as <see cref="DeclareGraph"/> does.</param>
+    /// <remarks>
+    /// <para>
+    /// The gap this fills: <see cref="DeclareGraph"/> carries ONE root, and
+    /// <see cref="DeclareChildList{TChild}"/> carries many children but demands they implement
+    /// <c>IModelSerializer</c>. An ensemble's trees are neither — many roots, and the node is a
+    /// plain private type with no serialization surface of its own. Without this overload every
+    /// forest model had to hand-write the walk, which is what ADN0060 reports and what ADN0062
+    /// reports from the other direction ("no ModelStateRegistry declaration, so nothing would
+    /// persist it").
+    /// </para>
+    /// <para>
+    /// Unlike <see cref="DeclareChildList{TChild}"/> the roots are REPLACED rather than restored in
+    /// place: how many trees a forest has is fitted, not configuration, so the count comes from the
+    /// payload rather than from whatever the constructor happened to build.
+    /// </para>
+    /// <para>
+    /// A null root is dropped rather than preserved positionally. <see cref="WriteNode"/> writes a
+    /// presence flag per node, so the stream stays aligned either way; a forest with a null tree in
+    /// it has no meaning, and keeping the slot would require a nullable element type that every
+    /// caller would then have to defend against.
+    /// </para>
+    /// </remarks>
+    public void DeclareGraphList<TNode>(
+        string name,
+        Func<List<TNode>?> get,
+        Action<List<TNode>?> set,
+        Action<NodeShape<TNode>> describe)
+        where TNode : class
+    {
+        var shape = new NodeShape<TNode>();
+        describe(shape);
+
+        if (shape.Factory is null)
+            throw new ArgumentException($"State '{name}' must declare Create so its nodes can be rebuilt.", nameof(describe));
+
+        Add(name,
+            w =>
+            {
+                var roots = get();
+                // -1 distinguishes "no list" from "an empty list", matching DeclareChildList.
+                if (roots is null) { w.Write(-1); return; }
+                w.Write(roots.Count);
+                foreach (var root in roots) WriteNode(w, root, shape);
+            },
+            r =>
+            {
+                int count = r.ReadInt32();
+                if (count < 0) { set(null); return; }
+
+                var roots = new List<TNode>(count);
+                for (int i = 0; i < count; i++)
+                {
+                    var node = ReadNode(r, shape);
+                    if (node is not null) roots.Add(node);
+                }
+                set(roots);
+            });
+    }
+
+    /// <summary>Declares an array held as the model's own numeric type.</summary>
+    /// <param name="name">A stable name, unique within the model.</param>
+    /// <param name="get">Reads the current value.</param>
+    /// <param name="set">Installs a restored value.</param>
+    public void DeclareArray(string name, Func<T[]?> get, Action<T[]?> set)
+        => Add(name,
+            w =>
+            {
+                var a = get();
+                if (a is null) { w.Write(-1); return; }
+                w.Write(a.Length);
+                foreach (var value in a) w.Write(Convert.ToDouble(value));
+            },
+            r =>
+            {
+                int length = r.ReadInt32();
+                if (length < 0) { set(null); return; }
+                var a = new T[length];
+                for (int i = 0; i < length; i++) a[i] = Ops.FromDouble(r.ReadDouble());
+                set(a);
+            });
+
+    /// <summary>Declares a JAGGED array held as the model's own numeric type.</summary>
+    /// <param name="name">A stable name, unique within the model.</param>
+    /// <param name="get">Reads the current value.</param>
+    /// <param name="set">Installs a restored value.</param>
+    /// <remarks>
+    /// Jagged rather than rectangular deliberately: the shape this exists for is per-feature bin
+    /// thresholds, where each feature has its own bin count. A Matrix would have to pad to the
+    /// widest row and then carry the real widths separately, which is two facts that can disagree.
+    /// Each row keeps its own length, and a null row is representable so the outer and inner
+    /// nullability both round-trip.
+    /// </remarks>
+    public void DeclareJaggedArray(string name, Func<T[][]?> get, Action<T[][]?> set)
+        => Add(name,
+            w =>
+            {
+                var rows = get();
+                if (rows is null) { w.Write(-1); return; }
+                w.Write(rows.Length);
+                foreach (var row in rows)
+                {
+                    if (row is null) { w.Write(-1); continue; }
+                    w.Write(row.Length);
+                    foreach (var value in row) w.Write(Convert.ToDouble(value));
+                }
+            },
+            r =>
+            {
+                int outer = r.ReadInt32();
+                if (outer < 0) { set(null); return; }
+                var rows = new T[outer][];
+                for (int i = 0; i < outer; i++)
+                {
+                    int inner = r.ReadInt32();
+                    if (inner < 0) continue;
+                    var row = new T[inner];
+                    for (int j = 0; j < inner; j++) row[j] = Ops.FromDouble(r.ReadDouble());
+                    rows[i] = row;
+                }
+                set(rows);
+            });
+
+    /// <summary>Declares a list of matrices, such as per-class or per-category probability tables.</summary>
+    /// <param name="name">A stable name, unique within the model.</param>
+    /// <param name="get">Reads the current value.</param>
+    /// <param name="set">Installs a restored value.</param>
+    public void Declare(string name, Func<List<Matrix<T>>?> get, Action<List<Matrix<T>>?> set)
+        => Add(name,
+            w =>
+            {
+                var list = get();
+                if (list is null) { w.Write(-1); return; }
+                w.Write(list.Count);
+                foreach (var m in list) WriteMatrix(w, m);
+            },
+            r =>
+            {
+                int count = r.ReadInt32();
+                if (count < 0) { set(null); return; }
+                var list = new List<Matrix<T>>(count);
+                for (int i = 0; i < count; i++) list.Add(ReadMatrix(r) ?? new Matrix<T>(0, 0));
+                set(list);
+            });
+
+    /// <summary>Declares a single nested model, such as a DQN agent's target network.</summary>
+    /// <typeparam name="TChild">The child's type.</typeparam>
+    /// <param name="name">A stable name, unique within the model.</param>
+    /// <param name="get">Reads the child.</param>
+    /// <remarks>
+    /// The child is restored IN PLACE, not replaced: the parent builds it in its constructor, so what
+    /// travels is its state and not its identity. A target network that came back as a fresh instance
+    /// would leave the agent bootstrapping from an untrained copy of itself.
+    /// </remarks>
+    public void DeclareChild<TChild>(string name, Func<TChild?> get)
+        where TChild : class, IModelSerializer
+        => Add(name,
+            w =>
+            {
+                var child = get();
+                if (child is null) { w.Write(-1); return; }
+                var bytes = child.Serialize();
+                w.Write(bytes.Length);
+                w.Write(bytes);
+            },
+            r =>
+            {
+                int length = r.ReadInt32();
+                if (length < 0) return;
+                var bytes = r.ReadBytes(length);
+                if (length > 0) get()?.Deserialize(bytes);
+            });
+
+    /// <summary>Declares an assignable child that may not exist until its fitted state is restored.</summary>
+    /// <typeparam name="TChild">The child's concrete or abstract serializer type.</typeparam>
+    /// <param name="name">A stable name, unique within the model.</param>
+    /// <param name="get">Reads the current child, if materialized.</param>
+    /// <param name="set">Installs a child constructed from the serialized state.</param>
+    /// <remarks>
+    /// Some nested state is created by <c>Fit</c>, not by the parent's constructor. Restoring only
+    /// in place silently discarded that child's bytes on a fresh destination. This overload retains
+    /// the ordinary in-place path when an instance exists and otherwise constructs the declared
+    /// child through the same parameterless-or-all-optional convention used for child lists.
+    /// </remarks>
+    public void DeclareChild<TChild>(string name, Func<TChild?> get, Action<TChild?> set)
+        where TChild : class, IModelSerializer
+        => Add(name,
+            w =>
+            {
+                var child = get();
+                if (child is null) { w.Write(-1); return; }
+                var bytes = child.Serialize();
+                w.Write(bytes.Length);
+                w.Write(bytes);
+            },
+            r =>
+            {
+                int length = r.ReadInt32();
+                if (length < 0) { set(null); return; }
+
+                var bytes = r.ReadBytes(length);
+                var child = get();
+                if (child is null)
+                {
+                    child = CreateChild<TChild>(name, string.Empty);
+                    set(child);
+                }
+
+                if (length > 0) child.Deserialize(bytes);
+            });
+
+    /// <summary>
+    /// Declares an assignable fitted child whose parent already owns the canonical construction
+    /// factory for its abstract or interface-typed slot.
+    /// </summary>
+    /// <typeparam name="TChild">The child's serializer contract.</typeparam>
+    /// <param name="name">A stable name, unique within the model.</param>
+    /// <param name="get">Reads the current fitted child.</param>
+    /// <param name="set">Installs a child created during restore.</param>
+    /// <param name="create">Builds the configured concrete child when the slot is empty.</param>
+    /// <remarks>
+    /// A parent factory is stronger construction evidence than reflection: it preserves the exact
+    /// configured implementation even when <typeparamref name="TChild"/> is an interface and the
+    /// concrete child requires constructor arguments. Stacking classifiers are the canonical shape.
+    /// </remarks>
+    public void DeclareChild<TChild>(
+        string name,
+        Func<TChild?> get,
+        Action<TChild?> set,
+        Func<TChild> create)
+        where TChild : class, IModelSerializer
+    {
+        if (create is null) throw new ArgumentNullException(nameof(create));
+        Add(name,
+            w =>
+            {
+                var child = get();
+                if (child is null) { w.Write(-1); return; }
+                var bytes = child.Serialize();
+                w.Write(bytes.Length);
+                w.Write(bytes);
+            },
+            r =>
+            {
+                int length = r.ReadInt32();
+                if (length < 0) { set(null); return; }
+
+                var bytes = r.ReadBytes(length);
+                var child = get();
+                if (child is null)
+                {
+                    child = create() ?? throw new InvalidOperationException(
+                        $"State '{name}' used its configured child factory, but the factory returned null.");
+                    set(child);
+                }
+
+                if (length > 0) child.Deserialize(bytes);
+            });
+    }
+
+    /// <summary>Declares a nested parameter source, such as a duelling agent's target network.</summary>
+    /// <param name="name">A stable name, unique within the model.</param>
+    /// <param name="get">Reads the source.</param>
+    /// <remarks>
+    /// A parameter source carries its state as a vector rather than as a serialized payload, so that
+    /// is what travels. Restored in place: the parent constructed it, and a target network that came
+    /// back as a fresh instance would leave the agent bootstrapping from an untrained copy of itself.
+    /// </remarks>
+    public void DeclareParameterSource(string name, Func<IParameterSource<T>?> get)
+        => Add(name,
+            w => WriteVector(w, get()?.GetParameters()),
+            r =>
+            {
+                var values = ReadVector(r);
+                if (values is not null) get()?.SetParameters(values);
+            });
+
+    /// <summary>Declares a list of layers the model owns directly, such as a conv stack.</summary>
+    /// <typeparam name="TLayer">The layer type.</typeparam>
+    /// <param name="name">A stable name, unique within the model.</param>
+    /// <param name="get">Reads the layers, in a stable order.</param>
+    /// <remarks>
+    /// <para>
+    /// A model that keeps layers in a plain <c>List</c> had no way to declare them: every existing
+    /// overload takes a vector, a matrix, a tensor or an <c>IModelSerializer</c>, and a layer is none
+    /// of those. So the generator skipped the member silently and the layers' weights travelled
+    /// nowhere. DeepANT lost both convolution layers this way -- they came back as the
+    /// placeholder-shaped shells its deserialization constructor builds, 96 kernel values collapsed
+    /// to 1, and the model's prediction changed sign across a round-trip.
+    /// </para>
+    /// <para>
+    /// Networks do not hit this, because their layers belong to the network base; it is models on
+    /// other bases, holding layers directly, that had no declaration to make.
+    /// </para>
+    /// <para>
+    /// RESTORED IN PLACE, like <see cref="DeclareChildList{TChild}"/> and for the same reason: the
+    /// parent's constructor builds these layers at their configured widths, so how many there are and
+    /// how wide they are is configuration that the constructor already replays. Only the learned
+    /// values need to travel, and each layer's own <c>Serialize</c>/<c>Deserialize</c> pair already
+    /// carries its parameter layout, resolved shape and buffers.
+    /// </para>
+    /// <para>
+    /// A count mismatch is therefore a real disagreement about configuration rather than something to
+    /// paper over: the extra payloads are consumed so the reader stays aligned for whatever follows,
+    /// and the surplus layers keep their constructed values.
+    /// </para>
+    /// </remarks>
+    public void DeclareLayerList<TLayer>(string name, Func<List<TLayer>?> get)
+        where TLayer : AiDotNet.NeuralNetworks.Layers.LayerBase<T>
+        => Add(name,
+            w =>
+            {
+                var layers = get();
+                if (layers is null) { w.Write(-1); return; }
+                w.Write(layers.Count);
+                foreach (var layer in layers)
+                {
+                    using var ms = new MemoryStream();
+                    using (var lw = new BinaryWriter(ms, System.Text.Encoding.UTF8, leaveOpen: true))
+                    {
+                        layer?.Serialize(lw);
+                    }
+
+                    var bytes = ms.ToArray();
+                    w.Write(bytes.Length);
+                    w.Write(bytes);
+                }
+            },
+            r =>
+            {
+                int count = r.ReadInt32();
+                if (count < 0) return;
+                var layers = get();
+                for (int i = 0; i < count; i++)
+                {
+                    int length = r.ReadInt32();
+                    var bytes = r.ReadBytes(length);
+
+                    // Length-framed per layer so an unreadable or surplus payload costs only that
+                    // layer, never the alignment of the entries that follow it.
+                    if (layers is null || i >= layers.Count || length == 0) { continue; }
+
+                    using var ms = new MemoryStream(bytes);
+                    using var lr = new BinaryReader(ms, System.Text.Encoding.UTF8, leaveOpen: true);
+                    layers[i]?.Deserialize(lr);
+                }
+            });
+
+    /// <summary>Declares a list of nested models, such as an agent's per-actor target networks.</summary>
+    /// <typeparam name="TChild">The child type.</typeparam>
+    /// <param name="name">A stable name, unique within the model.</param>
+    /// <param name="get">Reads the children, in a stable order.</param>
+    /// <remarks>
+    /// Restored in place and by position, because the parent builds these in its constructor: how
+    /// many there are is configuration, and configuration is replayed by the recorded constructor.
+    /// </remarks>
+    public void DeclareChildList<TChild>(string name, Func<List<TChild>?> get)
+        where TChild : class, IModelSerializer
+        => Add(name,
+            w =>
+            {
+                var children = get();
+                w.Write(TypedChildListMarker);
+                if (children is null) { w.Write(-1); return; }
+                w.Write(children.Count);
+                foreach (var child in children)
+                {
+                    // The declared element may be an interface or abstract base. A fresh clone has
+                    // no fitted children to inspect, so the concrete type must travel with its bytes.
+                    w.Write(child?.GetType().AssemblyQualifiedName ?? string.Empty);
+                    var bytes = child?.Serialize() ?? Array.Empty<byte>();
+                    w.Write(bytes.Length);
+                    w.Write(bytes);
+                }
+            },
+            r =>
+            {
+                int header = r.ReadInt32();
+                bool carriesTypes = header == TypedChildListMarker;
+                int count = carriesTypes ? r.ReadInt32() : header;
+                if (count < 0) return;
+                var children = get();
+                for (int i = 0; i < count; i++)
+                {
+                    string typeName = carriesTypes ? r.ReadString() : string.Empty;
+                    int length = r.ReadInt32();
+                    var bytes = r.ReadBytes(length);
+                    if (length == 0 || children is null) continue;
+
+                    // GROW THE LIST. Restoring in place is right when the parent rebuilt its children
+                    // first, and silently wrong the moment it did not: a CLONE is constructed empty, so
+                    // `i < children.Count` was false for every child and the whole payload was read and
+                    // dropped. RandomForest, ExtremelyRandomizedTrees and AdaBoostR2 all round-tripped
+                    // through Serialize and Deserialize perfectly and still cloned into a forest with no
+                    // trees, which is exactly the silent loss this work exists to remove -- the bytes
+                    // were there, and nothing was listening.
+                    while (children.Count <= i)
+                    {
+                        children.Add(CreateChild<TChild>(name, typeName));
+                    }
+
+                    children[i]?.Deserialize(bytes);
+                }
+            });
+
+    /// <summary>Builds an empty child for a restored list to fill.</summary>
+    /// <param name="name">The state name, for the error message when it cannot be built.</param>
+    /// <param name="typeName">The concrete runtime type saved beside the child payload.</param>
+    /// <returns>A new child.</returns>
+    /// <remarks>
+    /// LOUD when it cannot. Returning null here, or skipping the child, would put back the silent drop
+    /// this exists to fix -- and it would look like a model that restored fine and predicts wrongly,
+    /// which is the hardest kind of defect to find. A child that cannot be built without arguments
+    /// needs its parent to build the list before restoring, and the message says so.
+    /// </remarks>
+    private static TChild CreateChild<TChild>(string name, string typeName)
+        where TChild : class, IModelSerializer
+    {
+        Type childType = typeof(TChild);
+        if (!string.IsNullOrEmpty(typeName))
+        {
+            Type? recordedType = Type.GetType(typeName, throwOnError: false);
+            if (recordedType is null || !childType.IsAssignableFrom(recordedType))
+            {
+                throw new InvalidOperationException(
+                    $"State '{name}' recorded child type '{typeName}', which cannot be restored as "
+                    + $"{childType.Name}.");
+            }
+
+            childType = recordedType;
+        }
+
+        try
+        {
+            if (Activator.CreateInstance(childType, nonPublic: true) is TChild child) return child;
+        }
+        catch (MissingMethodException)
+        {
+            // Falls through to the optional-argument attempt below.
+        }
+
+        // A CONSTRUCTOR WHOSE PARAMETERS ARE ALL OPTIONAL IS CALLABLE WITH NO ARGUMENTS, but
+        // Activator's parameterless lookup cannot see it. DecisionTreeRegression declares exactly
+        // one constructor, `(DecisionTreeOptions? options = null, IRegularization? regularization =
+        // null)`, so `new DecisionTreeRegression<T>()` compiles while reflection reported the type as
+        // having no constructor at all -- and RandomForestRegression, whose payload holds trees a
+        // freshly constructed clone has none of, failed its round-trip on that alone.
+        //
+        // CloneEngine already binds this shape with OptionalParamBinding, which turns a Type.Missing
+        // slot into the declared default. Doing the same here fixes every child type of this shape,
+        // rather than asking each one to declare a second, empty constructor.
+        var withOptionalArguments = childType
+            .GetConstructors(System.Reflection.BindingFlags.Public
+                | System.Reflection.BindingFlags.NonPublic
+                | System.Reflection.BindingFlags.Instance)
+            .FirstOrDefault(c => c.GetParameters().Length > 0
+                && c.GetParameters().All(p => p.IsOptional));
+
+        if (withOptionalArguments is not null)
+        {
+            var arguments = new object?[withOptionalArguments.GetParameters().Length];
+            for (int i = 0; i < arguments.Length; i++) arguments[i] = Type.Missing;
+
+            if (withOptionalArguments.Invoke(
+                    System.Reflection.BindingFlags.OptionalParamBinding,
+                    binder: null,
+                    arguments,
+                    culture: null) is TChild built)
+            {
+                return built;
+            }
+        }
+
+        throw new InvalidOperationException(
+            $"State '{name}' carries a list of {typeof(TChild).Name}, and the model being restored has "
+            + "fewer of them than the payload holds. Restoring cannot create one because "
+            + $"{childType.Name} has no constructor callable without arguments. Either give it one, "
+            + "or have the model build its list before Deserialize runs.");
+    }
+
+    /// <summary>Declares a decision tree, carried whole.</summary>
+    /// <param name="name">A stable name, unique within the model.</param>
+    /// <param name="get">Reads the root.</param>
+    /// <param name="set">Installs a restored root.</param>
+    /// <remarks>
+    /// Every decision-tree model kept its structure in a <c>Root</c> field no overload could carry, so
+    /// each walked the tree by hand -- and a by-hand walk carries what its author remembered. The
+    /// shared one wrote FeatureIndex, SplitValue, Prediction and IsLeaf, and dropped <c>Threshold</c>
+    /// and <c>LinearModel</c>. M5ModelTree fits a LINEAR MODEL at every leaf, so its restored tree had
+    /// the right shape, the right splits and constant leaves: it predicted 3 where the original said 2.
+    /// A leaf model travels as its concrete type name plus its own payload, because the field is
+    /// declared as a base type and the restore has to rebuild whatever was actually fitted.
+    /// </remarks>
+    public void DeclareTree(
+        string name,
+        Func<DecisionTreeNode<T>?> get,
+        Action<DecisionTreeNode<T>?> set)
+        => Add(name,
+            w => WriteNode(w, get()),
+            r => set(ReadNode(r, name)));
+
+    private static void WriteNode(BinaryWriter w, DecisionTreeNode<T>? node)
+    {
+        if (node is null) { w.Write(false); return; }
+        w.Write(true);
+
+        w.Write(node.FeatureIndex);
+        w.Write(Ops.ToDouble(node.SplitValue));
+        w.Write(Ops.ToDouble(node.Threshold));
+        w.Write(Ops.ToDouble(node.Prediction));
+        w.Write(node.IsLeaf);
+
+        if (node.LinearModel is null)
+        {
+            w.Write(false);
+        }
+        else
+        {
+            w.Write(true);
+            var concrete = node.LinearModel.GetType();
+            w.Write(concrete.AssemblyQualifiedName ?? concrete.FullName ?? concrete.Name);
+            var payload = node.LinearModel.Serialize();
+            w.Write(payload.Length);
+            w.Write(payload);
+        }
+
+        WriteNode(w, node.Left);
+        WriteNode(w, node.Right);
+    }
+
+    private static DecisionTreeNode<T>? ReadNode(BinaryReader r, string name)
+    {
+        if (!r.ReadBoolean()) return null;
+
+        var node = new DecisionTreeNode<T>
+        {
+            FeatureIndex = r.ReadInt32(),
+            SplitValue = Ops.FromDouble(r.ReadDouble()),
+            Threshold = Ops.FromDouble(r.ReadDouble()),
+            Prediction = Ops.FromDouble(r.ReadDouble()),
+            IsLeaf = r.ReadBoolean(),
+        };
+
+        if (r.ReadBoolean())
+        {
+            string typeName = r.ReadString();
+            int length = r.ReadInt32();
+            var payload = r.ReadBytes(length);
+
+            var concrete = Type.GetType(typeName, throwOnError: false);
+            if (concrete is null)
+            {
+                throw new InvalidOperationException(
+                    $"State '{name}' holds a leaf model of type '{typeName}', which this runtime cannot "
+                    + "load, so the tree cannot be restored as it was fitted.");
+            }
+
+            var leaf = CreateSerializable(concrete, name);
+            leaf.Deserialize(payload);
+            node.LinearModel = leaf as RegressionBase<T>;
+        }
+
+        node.Left = ReadNode(r, name);
+        node.Right = ReadNode(r, name);
+        return node;
+    }
+
+    /// <summary>Builds an empty instance of a type named in a payload.</summary>
+    /// <param name="type">The concrete type to build.</param>
+    /// <param name="name">The state name, for the error message.</param>
+    /// <returns>The new instance.</returns>
+    /// <remarks>
+    /// Accepts an all-optional constructor for the same reason <see cref="CreateChild{TChild}"/> does:
+    /// reflection's parameterless lookup cannot see one, and most models declare exactly that shape.
+    /// </remarks>
+    private static IModelSerializer CreateSerializable(Type type, string name)
+    {
+        try
+        {
+            if (Activator.CreateInstance(type, nonPublic: true) is IModelSerializer built) return built;
+        }
+        catch (MissingMethodException)
+        {
+        }
+
+        var withOptionalArguments = type
+            .GetConstructors(System.Reflection.BindingFlags.Public
+                | System.Reflection.BindingFlags.NonPublic
+                | System.Reflection.BindingFlags.Instance)
+            .FirstOrDefault(c => c.GetParameters().Length > 0
+                && c.GetParameters().All(p => p.IsOptional));
+
+        if (withOptionalArguments is not null)
+        {
+            var arguments = new object?[withOptionalArguments.GetParameters().Length];
+            for (int i = 0; i < arguments.Length; i++) arguments[i] = Type.Missing;
+
+            if (withOptionalArguments.Invoke(
+                    System.Reflection.BindingFlags.OptionalParamBinding,
+                    binder: null,
+                    arguments,
+                    culture: null) is IModelSerializer built)
+            {
+                return built;
+            }
+        }
+
+        throw new InvalidOperationException(
+            $"State '{name}' holds a leaf model of type '{type.Name}', which has no constructor callable "
+            + "without arguments, so restoring cannot build one to read it back into.");
+    }
+
+    /// <summary>Declares the options object a model predicts with.</summary>
+    /// <param name="name">A stable name, unique within the model.</param>
+    /// <param name="get">Reads the options instance.</param>
+    /// <remarks>
+    /// <para>
+    /// Restored IN PLACE, like a child model, so a readonly <c>_options</c> field works: what travels
+    /// is the settings, not the identity of the object holding them.
+    /// </para>
+    /// <para>
+    /// Needed because configuration is not merely descriptive -- it decides what the model predicts.
+    /// KNearestNeighborsRegression answers with <c>_options.K</c> neighbours, so a payload that
+    /// carried its training data but not its K restored a model that ran, and answered differently.
+    /// Cloning already carries configuration through the clone plan; this is the serialize half of
+    /// the same contract.
+    /// </para>
+    /// <para>
+    /// SCALARS ONLY, DELIBERATELY. Settings that are objects -- a regularization strategy, a kernel,
+    /// a delegate -- are reproduced by the constructor that built them, and writing them here would
+    /// mean a second, weaker copy of what the clone plan already does properly. Restricting the scope
+    /// is not the same as dropping state silently: the boundary is a property's type, it is the same
+    /// on both sides of the round-trip, and it is stated here rather than discovered from a wrong
+    /// prediction.
+    /// </para>
+    /// </remarks>
+    public void DeclareOptions(string name, Func<ModelOptions?> get)
+        => Add(name,
+            w =>
+            {
+                var options = get();
+                if (options is null) { w.Write(-1); return; }
+
+                var properties = ScalarOptionProperties(options.GetType());
+                w.Write(properties.Count);
+                foreach (var property in properties)
+                {
+                    WriteScalarOption(w, property.GetValue(options));
+                }
+            },
+            r =>
+            {
+                int count = r.ReadInt32();
+                if (count < 0) return;
+
+                var options = get();
+                // The reader must consume its bytes whether or not there is anywhere to put them,
+                // or every later declaration reads from the wrong offset.
+                var properties = options is null
+                    ? new List<System.Reflection.PropertyInfo>()
+                    : ScalarOptionProperties(options.GetType());
+
+                for (int i = 0; i < count; i++)
+                {
+                    var target = i < properties.Count ? properties[i] : null;
+                    var value = ReadScalarOption(r, target?.PropertyType);
+                    if (options is null || target is null) continue;
+                    target.SetValue(options, value);
+                }
+            });
+
+    /// <summary>The settable scalar settings of an options type, in a stable order.</summary>
+    /// <param name="type">The options type.</param>
+    /// <returns>The properties carried by <see cref="DeclareOptions"/>.</returns>
+    /// <remarks>
+    /// Ordered by name so the reader walks what the writer wrote. Reflection order is not specified
+    /// and can differ between runtimes, which would silently pair one setting's bytes with another's.
+    /// </remarks>
+    private static List<System.Reflection.PropertyInfo> ScalarOptionProperties(Type type)
+        => type.GetProperties(System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Instance)
+            .Where(p => p.CanRead && p.CanWrite && p.GetIndexParameters().Length == 0)
+            .Where(p => IsCarriedScalar(p.PropertyType))
+            .OrderBy(p => p.Name, StringComparer.Ordinal)
+            .ToList();
+
+    private static bool IsCarriedScalar(Type type)
+    {
+        var bare = Nullable.GetUnderlyingType(type) ?? type;
+        return bare.IsEnum
+            || bare == typeof(int) || bare == typeof(long) || bare == typeof(double)
+            || bare == typeof(float) || bare == typeof(bool) || bare == typeof(string);
+    }
+
+    // Each value is TAGGED with its own type. The reader must be able to consume a value it has
+    // nowhere to put -- an options object that is null, or a setting that no longer exists -- and
+    // without a tag it would have to guess a width and desynchronise every later declaration.
+    private const byte OptionNull = 0;
+    private const byte OptionBool = 1;
+    private const byte OptionInt = 2;
+    private const byte OptionLong = 3;
+    private const byte OptionDouble = 4;
+    private const byte OptionFloat = 5;
+    private const byte OptionString = 6;
+    private const byte OptionEnum = 7;
+
+    private static void WriteScalarOption(BinaryWriter w, object? value)
+    {
+        switch (value)
+        {
+            case null: w.Write(OptionNull); break;
+            case bool v: w.Write(OptionBool); w.Write(v); break;
+            case int v: w.Write(OptionInt); w.Write(v); break;
+            case long v: w.Write(OptionLong); w.Write(v); break;
+            case double v: w.Write(OptionDouble); w.Write(v); break;
+            case float v: w.Write(OptionFloat); w.Write(v); break;
+            case string v: w.Write(OptionString); w.Write(v); break;
+            // An enum travels as its underlying integer, so renaming a member does not move values.
+            default:
+                w.Write(OptionEnum);
+                w.Write(Convert.ToInt64(value, System.Globalization.CultureInfo.InvariantCulture));
+                break;
+        }
+    }
+
+    private static object? ReadScalarOption(BinaryReader r, Type? target)
+    {
+        byte tag = r.ReadByte();
+        object? value = tag switch
+        {
+            OptionNull => null,
+            OptionBool => r.ReadBoolean(),
+            OptionInt => r.ReadInt32(),
+            OptionLong => r.ReadInt64(),
+            OptionDouble => r.ReadDouble(),
+            OptionFloat => r.ReadSingle(),
+            OptionString => r.ReadString(),
+            OptionEnum => r.ReadInt64(),
+            _ => throw new InvalidOperationException(
+                $"An options payload carries an unknown value tag {tag}."),
+        };
+
+        if (value is null || target is null) return null;
+
+        var bare = Nullable.GetUnderlyingType(target) ?? target;
+        if (bare.IsEnum)
+        {
+            // Enum.ToObject requires the value to have the enum's actual underlying CLR type on
+            // newer runtimes. The payload deliberately normalizes every enum to Int64, so convert
+            // it back before constructing the enum (byte-backed options exposed this regression).
+            var underlying = Enum.GetUnderlyingType(bare);
+            var converted = Convert.ChangeType(
+                value, underlying, System.Globalization.CultureInfo.InvariantCulture);
+            return Enum.ToObject(bare, converted!);
+        }
+
+        return Convert.ChangeType(value, bare, System.Globalization.CultureInfo.InvariantCulture);
+    }
+
+    /// <summary>Declares an integer vector, such as a set of selected feature indices.</summary>
+    /// <param name="name">A stable name, unique within the model.</param>
+    /// <param name="get">Reads the current value.</param>
+    /// <param name="set">Installs a restored value.</param>
+    public void Declare(string name, Func<Vector<int>?> get, Action<Vector<int>?> set)
+        => Add(name,
+            w =>
+            {
+                var v = get();
+                if (v is null) { w.Write(-1); return; }
+                w.Write(v.Length);
+                for (int i = 0; i < v.Length; i++) w.Write(v[i]);
+            },
+            r =>
+            {
+                int length = r.ReadInt32();
+                if (length < 0) { set(null); return; }
+                var v = new Vector<int>(length);
+                for (int i = 0; i < length; i++) v[i] = r.ReadInt32();
+                set(v);
+            });
+
+    /// <summary>Declares a keyed set of vectors, such as per-layer optimiser moments.</summary>
+    /// <param name="name">A stable name, unique within the model.</param>
+    /// <param name="get">Reads the current value.</param>
+    /// <param name="set">Installs a restored value.</param>
+    /// <remarks>
+    /// Written key-first so the restore rebuilds the same mapping. Dictionary order is not stable,
+    /// so the pairs are sorted by key -- otherwise the same model could produce two different
+    /// payloads and neither would be wrong.
+    /// </remarks>
+    /// <summary>Declares a STRING-keyed table of vectors, such as per-edge or per-operation weights.</summary>
+    /// <param name="name">A stable name, unique within the model.</param>
+    /// <param name="get">Reads the current value.</param>
+    /// <param name="set">Installs a restored value.</param>
+    /// <remarks>
+    /// The int-keyed overload below cannot serve this: a supernet keys its weights by an edge name
+    /// like "node2_op3", and mapping those onto ints would need a side table that is itself state.
+    /// Keys are written in sorted order for the same reason as the int-keyed one - a Dictionary has
+    /// no inherent order, and an unstable order makes two payloads for identical state differ.
+    /// </remarks>
+    public void Declare(string name, Func<Dictionary<string, Vector<T>>?> get, Action<Dictionary<string, Vector<T>>?> set)
+        => Add(name,
+            w =>
+            {
+                var map = get();
+                if (map is null) { w.Write(-1); return; }
+                w.Write(map.Count);
+                foreach (var pair in map.OrderBy(p => p.Key, StringComparer.Ordinal))
+                {
+                    w.Write(pair.Key);
+                    WriteVector(w, pair.Value);
+                }
+            },
+            r =>
+            {
+                int count = r.ReadInt32();
+                if (count < 0) { set(null); return; }
+                var map = new Dictionary<string, Vector<T>>(count, StringComparer.Ordinal);
+                for (int i = 0; i < count; i++)
+                {
+                    string key = r.ReadString();
+                    map[key] = ReadVector(r) ?? new Vector<T>(0);
+                }
+                set(map);
+            });
+
+    public void Declare(string name, Func<Dictionary<int, Vector<T>>?> get, Action<Dictionary<int, Vector<T>>?> set)
+        => Add(name,
+            w =>
+            {
+                var map = get();
+                if (map is null) { w.Write(-1); return; }
+                w.Write(map.Count);
+                foreach (var pair in map.OrderBy(p => p.Key))
+                {
+                    w.Write(pair.Key);
+                    WriteVector(w, pair.Value);
+                }
+            },
+            r =>
+            {
+                int count = r.ReadInt32();
+                if (count < 0) { set(null); return; }
+                var map = new Dictionary<int, Vector<T>>(count);
+                for (int i = 0; i < count; i++)
+                {
+                    int key = r.ReadInt32();
+                    map[key] = ReadVector(r) ?? new Vector<T>(0);
+                }
+                set(map);
+            });
+
+    /// <summary>Declares an array of vectors, such as per-feature sorted values or per-point distances.</summary>
+    /// <param name="name">A stable name, unique within the model.</param>
+    /// <param name="get">Reads the current value.</param>
+    /// <param name="set">Installs a restored value.</param>
+    public void Declare(string name, Func<Vector<T>[]?> get, Action<Vector<T>[]?> set)
+        => Add(name,
+            w =>
+            {
+                var a = get();
+                if (a is null) { w.Write(-1); return; }
+                w.Write(a.Length);
+                foreach (var v in a) WriteVector(w, v);
+            },
+            r =>
+            {
+                int count = r.ReadInt32();
+                if (count < 0) { set(null); return; }
+                var a = new Vector<T>[count];
+                for (int i = 0; i < count; i++) a[i] = ReadVector(r) ?? new Vector<T>(0);
+                set(a);
+            });
+
+    /// <summary>Declares an array of matrices, such as one probability table per category.</summary>
+    /// <param name="name">A stable name, unique within the model.</param>
+    /// <param name="get">Reads the current value.</param>
+    /// <param name="set">Installs a restored value.</param>
+    public void Declare(string name, Func<Matrix<T>[]?> get, Action<Matrix<T>[]?> set)
+        => Add(name,
+            w =>
+            {
+                var a = get();
+                if (a is null) { w.Write(-1); return; }
+                w.Write(a.Length);
+                foreach (var m in a) WriteMatrix(w, m);
+            },
+            r =>
+            {
+                int count = r.ReadInt32();
+                if (count < 0) { set(null); return; }
+                var a = new Matrix<T>[count];
+                for (int i = 0; i < count; i++) a[i] = ReadMatrix(r) ?? new Matrix<T>(0, 0);
+                set(a);
+            });
+
+    /// <summary>Declares a double array.</summary>
+    /// <param name="name">A stable name, unique within the model.</param>
+    /// <param name="get">Reads the current value.</param>
+    /// <param name="set">Installs a restored value.</param>
+    public void Declare(string name, Func<double[]?> get, Action<double[]?> set)
+        => Add(name,
+            w => WriteDoubles(w, get()),
+            r => set(ReadDoubles(r)));
+
+    /// <summary>
+    /// Declares a double array that shadows a flat <typeparamref name="T"/> parameter slot.
+    /// Its native double payload is restored after the ordinary parameter vector so a float model
+    /// does not lose the working storage's extra precision during a checkpoint round trip.
+    /// </summary>
+    public void DeclareExact(string name, Func<double[]?> get, Action<double[]?> set)
+        => Add(name,
+            w => WriteDoubles(w, get()),
+            r => set(ReadDoubles(r)),
+            restoreAfterParameters: true);
+
+    /// <summary>Declares a readonly double array and restores its contents without replacing it.</summary>
+    public void DeclareInPlace(string name, Func<double[]?> get)
+        => Add(name,
+            w => WriteDoubles(w, get()),
+            r => CopyDoublesInPlace(name, get(), ReadDoubles(r)));
+
+    /// <summary>
+    /// Declares a readonly double parameter array whose exact payload wins after vector restore.
+    /// </summary>
+    public void DeclareExactInPlace(string name, Func<double[]?> get)
+        => Add(name,
+            w => WriteDoubles(w, get()),
+            r => CopyDoublesInPlace(name, get(), ReadDoubles(r)),
+            restoreAfterParameters: true);
+
+    /// <summary>Declares a readonly jagged double array and restores its contents in place.</summary>
+    public void DeclareInPlace(string name, Func<double[][]?> get)
+        => Add(name,
+            w => WriteJaggedDoubles(w, get()),
+            r => CopyJaggedDoublesInPlace(name, get(), ReadJaggedDoubles(r)));
+
+    /// <summary>
+    /// Declares a readonly jagged double parameter array whose exact payload wins after vector restore.
+    /// </summary>
+    public void DeclareExactInPlace(string name, Func<double[][]?> get)
+        => Add(name,
+            w => WriteJaggedDoubles(w, get()),
+            r => CopyJaggedDoublesInPlace(name, get(), ReadJaggedDoubles(r)),
+            restoreAfterParameters: true);
+
+    /// <summary>
+    /// Declares a replaceable jagged double parameter array whose exact payload wins after vector restore.
+    /// </summary>
+    public void DeclareExact(string name, Func<double[][]?> get, Action<double[][]?> set)
+        => Add(name,
+            w => WriteJaggedDoubles(w, get()),
+            r => set(ReadJaggedDoubles(r)),
+            restoreAfterParameters: true);
+
+    // Scalars. A hyperparameter that PREDICTION reads is state, however small: k-nearest-neighbours
+    // restored its training set correctly and still predicted differently, because K came back as the
+    // constructor default and the model was voting over the wrong number of neighbours. A field does
+    // not have to be big to change the answer.
+
+    /// <summary>Declares an integer, such as a neighbour count or a tree depth.</summary>
+    /// <param name="name">A stable name, unique within the model.</param>
+    /// <param name="get">Reads the current value.</param>
+    /// <param name="set">Installs a restored value.</param>
+    public void DeclareInt32(string name, Func<int> get, Action<int> set)
+        => Add(name, w => w.Write(get()), r => set(r.ReadInt32()));
+
+    /// <summary>Declares a 64-bit integer, such as an online model's sample count.</summary>
+    public void DeclareInt64(string name, Func<long> get, Action<long> set)
+        => Add(name, w => w.Write(get()), r => set(r.ReadInt64()));
+
+    /// <summary>Declares a double, such as a temperature or a learned threshold.</summary>
+    /// <param name="name">A stable name, unique within the model.</param>
+    /// <param name="get">Reads the current value.</param>
+    /// <param name="set">Installs a restored value.</param>
+    public void DeclareDouble(string name, Func<double> get, Action<double> set)
+        => Add(name, w => w.Write(get()), r => set(r.ReadDouble()));
+
+    /// <summary>
+    /// Declares a double scalar that shadows a flat <typeparamref name="T"/> parameter slot.
+    /// </summary>
+    public void DeclareExactDouble(string name, Func<double> get, Action<double> set)
+        => Add(name, w => w.Write(get()), r => set(r.ReadDouble()), restoreAfterParameters: true);
+
+    /// <summary>Declares a boolean, such as a fitted flag or a mode switch.</summary>
+    /// <param name="name">A stable name, unique within the model.</param>
+    /// <param name="get">Reads the current value.</param>
+    /// <param name="set">Installs a restored value.</param>
+    public void DeclareBoolean(string name, Func<bool> get, Action<bool> set)
+        => Add(name, w => w.Write(get()), r => set(r.ReadBoolean()));
+
+    /// <summary>Declares a numeric value held as the model's own numeric type.</summary>
+    /// <param name="name">A stable name, unique within the model.</param>
+    /// <param name="get">Reads the current value.</param>
+    /// <param name="set">Installs a restored value.</param>
+    public void DeclareScalar(string name, Func<T> get, Action<T> set)
+        => Add(name,
+            w => w.Write(Convert.ToDouble(get())),
+            r => set(Ops.FromDouble(r.ReadDouble())));
+
+    /// <summary>Declares a string, such as a fitted category name or a chosen kernel.</summary>
+    /// <param name="name">A stable name, unique within the model.</param>
+    /// <param name="get">Reads the current value.</param>
+    /// <param name="set">Installs a restored value.</param>
+    public void DeclareString(string name, Func<string?> get, Action<string?> set)
+        => Add(name,
+            w => { var v = get(); w.Write(v is not null); if (v is not null) w.Write(v); },
+            r => set(r.ReadBoolean() ? r.ReadString() : null));
+
+    /// <summary>
+    /// Declares a child model whose own state travels with this one -- an ensemble member, a base
+    /// learner, a per-output head.
+    /// </summary>
+    /// <typeparam name="TInput">The child's input type.</typeparam>
+    /// <typeparam name="TOutput">The child's output type.</typeparam>
+    /// <param name="name">A stable name, unique within the model.</param>
+    /// <param name="get">Reads the current children, in a stable order.</param>
+    /// <remarks>
+    /// The children are NOT reconstructed here. A restore writes each child's saved bytes into the
+    /// child the parent already built, so the parent's own construction decides how many children
+    /// there are and of what type -- which is configuration, and configuration is replayed by the
+    /// recorded constructor rather than carried in a state payload.
+    /// </remarks>
+    public void DeclareChildren<TChild, TInput, TOutput>(
+        string name,
+        Func<IList<TChild>?> get)
+        where TChild : class, IFullModel<T, TInput, TOutput>
+        => Add(name,
+            w =>
+            {
+                var children = get();
+                if (children is null) { w.Write(-1); return; }
+
+                w.Write(children.Count);
+                foreach (var child in children)
+                {
+                    // The concrete TYPE travels with the bytes. An ensemble does not build its
+                    // members in its constructor -- they are created during training -- so a freshly
+                    // constructed clone has an EMPTY list and there is nothing to restore into. The
+                    // type is what lets the members be rebuilt rather than silently dropped, which
+                    // would leave an ensemble that predicts from no members at all.
+                    w.Write(child?.GetType().AssemblyQualifiedName ?? string.Empty);
+                    var bytes = child?.Serialize() ?? Array.Empty<byte>();
+                    w.Write(bytes.Length);
+                    w.Write(bytes);
+                }
+            },
+            r =>
+            {
+                int count = r.ReadInt32();
+                if (count < 0) return;
+
+                var children = get();
+                if (children is null) return;
+
+                for (int i = 0; i < count; i++)
+                {
+                    string typeName = r.ReadString();
+                    int length = r.ReadInt32();
+                    var bytes = r.ReadBytes(length);
+                    if (length == 0) continue;
+
+                    if (i < children.Count)
+                    {
+                        children[i]?.Deserialize(bytes);
+                        continue;
+                    }
+
+                    if (children.IsReadOnly) continue;
+
+                    if (CreateChild<TInput, TOutput>(typeName) is not TChild child) continue;
+
+                    child.Deserialize(bytes);
+                    children.Add(child);
+                }
+            });
+
+    /// <summary>Rebuilds a child from the type name saved beside its bytes.</summary>
+    /// <typeparam name="TInput">The child's input type.</typeparam>
+    /// <typeparam name="TOutput">The child's output type.</typeparam>
+    /// <param name="typeName">The assembly-qualified name recorded at save time.</param>
+    /// <returns>A new child, or <see langword="null"/> when it cannot be constructed.</returns>
+    /// <remarks>
+    /// Invokes a constructor whose parameters are ALL optional, binding each to its declared default,
+    /// which is what most models in this library offer. <c>Activator.CreateInstance(Type)</c> is not
+    /// enough on its own: it requires a genuinely parameterless constructor and declines the
+    /// all-optional ones that are the common shape here.
+    /// </remarks>
+    private static IFullModel<T, TInput, TOutput>? CreateChild<TInput, TOutput>(string typeName)
+    {
+        if (string.IsNullOrEmpty(typeName)) return null;
+
+        var type = Type.GetType(typeName, throwOnError: false);
+        if (type is null) return null;
+
+        foreach (var constructor in type.GetConstructors())
+        {
+            var parameters = constructor.GetParameters();
+            if (Array.Exists(parameters, p => !p.IsOptional)) continue;
+
+            var arguments = new object?[parameters.Length];
+            for (int i = 0; i < arguments.Length; i++) arguments[i] = Type.Missing;
+
+            return constructor.Invoke(
+                System.Reflection.BindingFlags.OptionalParamBinding,
+                binder: null,
+                arguments,
+                culture: null) as IFullModel<T, TInput, TOutput>;
+        }
+
+        return null;
+    }
+
+    /// <summary>Writes every declared entry, name-tagged and length-prefixed.</summary>
+    /// <param name="writer">The writer receiving the state block.</param>
+    /// <remarks>
+    /// Each entry's payload is length-prefixed so an unknown name can be SKIPPED on the way in.
+    /// Without that, a checkpoint containing state this build no longer declares would desynchronise
+    /// the stream and corrupt everything after it.
+    /// </remarks>
+    public void WriteAll(BinaryWriter writer)
+    {
+        writer.Write(_entries.Count);
+
+        foreach (var entry in _entries)
+        {
+            writer.Write(entry.Name);
+
+            using var buffer = new MemoryStream();
+            using (var inner = new BinaryWriter(buffer, System.Text.Encoding.UTF8, leaveOpen: true))
+            {
+                entry.Write(inner);
+                inner.Flush();
+            }
+
+            var bytes = buffer.ToArray();
+            writer.Write(bytes.Length);
+            writer.Write(bytes);
+        }
+    }
+
+    /// <summary>Restores every entry the payload and this model have in common.</summary>
+    /// <param name="reader">The reader positioned at the state block.</param>
+    public void ReadAll(BinaryReader reader) => ReadAll(reader, restoreAfterParameters: null);
+
+    /// <summary>
+    /// Restores structural/non-parameter state while leaving exact native-precision parameter
+    /// shadows for the post-parameter phase.
+    /// </summary>
+    public void ReadBeforeParameters(BinaryReader reader)
+        => ReadAll(reader, restoreAfterParameters: false);
+
+    /// <summary>
+    /// Restores only native-precision parameter shadows. This must run after the flat
+    /// <typeparamref name="T"/> vector has been distributed to its parameter sources.
+    /// </summary>
+    public void ReadAfterParameters(BinaryReader reader)
+        => ReadAll(reader, restoreAfterParameters: true);
+
+    private void ReadAll(BinaryReader reader, bool? restoreAfterParameters)
+    {
+        int count = reader.ReadInt32();
+
+        var byName = new Dictionary<string, Entry>(StringComparer.Ordinal);
+        foreach (var entry in _entries) byName[entry.Name] = entry;
+
+        for (int i = 0; i < count; i++)
+        {
+            string name = reader.ReadString();
+            int length = reader.ReadInt32();
+            var bytes = reader.ReadBytes(length);
+
+            if (!byName.TryGetValue(name, out var entry)
+                || (restoreAfterParameters.HasValue
+                    && entry.RestoreAfterParameters != restoreAfterParameters.Value))
+            {
+                continue;
+            }
+
+            using var buffer = new MemoryStream(bytes);
+            using var inner = new BinaryReader(buffer, System.Text.Encoding.UTF8, leaveOpen: true);
+            entry.Read(inner);
+        }
+    }
+
+    private static readonly INumericOperations<T> Ops = MathHelper.GetNumericOperations<T>();
+
+    private static void WriteVector(BinaryWriter w, Vector<T>? v)
+    {
+        if (v is null) { w.Write(-1); return; }
+        w.Write(v.Length);
+        for (int i = 0; i < v.Length; i++) w.Write(Convert.ToDouble(v[i]));
+    }
+
+    private static Vector<T>? ReadVector(BinaryReader r)
+    {
+        int length = r.ReadInt32();
+        if (length < 0) return null;
+        var v = new Vector<T>(length);
+        for (int i = 0; i < length; i++) v[i] = Ops.FromDouble(r.ReadDouble());
+        return v;
+    }
+
+    private static void WriteMatrix(BinaryWriter w, Matrix<T>? m)
+    {
+        if (m is null) { w.Write(-1); return; }
+        w.Write(m.Rows);
+        w.Write(m.Columns);
+        for (int i = 0; i < m.Rows; i++)
+            for (int j = 0; j < m.Columns; j++)
+                w.Write(Convert.ToDouble(m[i, j]));
+    }
+
+    private static Matrix<T>? ReadMatrix(BinaryReader r)
+    {
+        int rows = r.ReadInt32();
+        if (rows < 0) return null;
+        int columns = r.ReadInt32();
+        var m = new Matrix<T>(rows, columns);
+        for (int i = 0; i < rows; i++)
+            for (int j = 0; j < columns; j++)
+                m[i, j] = Ops.FromDouble(r.ReadDouble());
+        return m;
+    }
+
+    private static void WriteTensor(BinaryWriter w, Tensor<T>? t)
+    {
+        if (t is null) { w.Write(-1); return; }
+        var shape = t.Shape;
+        w.Write(shape.Length);
+        for (int i = 0; i < shape.Length; i++) w.Write(shape[i]);
+        w.Write(t.Length);
+        for (int i = 0; i < t.Length; i++) w.Write(Convert.ToDouble(t[i]));
+    }
+
+    private static Tensor<T>? ReadTensor(BinaryReader r)
+    {
+        int rank = r.ReadInt32();
+        if (rank < 0) return null;
+        var shape = new int[rank];
+        for (int i = 0; i < rank; i++) shape[i] = r.ReadInt32();
+        int length = r.ReadInt32();
+        var t = new Tensor<T>(shape);
+        for (int i = 0; i < length && i < t.Length; i++) t[i] = Ops.FromDouble(r.ReadDouble());
+        return t;
+    }
+
+    private static void WriteInts(BinaryWriter w, int[]? a)
+    {
+        if (a is null) { w.Write(-1); return; }
+        w.Write(a.Length);
+        foreach (var value in a) w.Write(value);
+    }
+
+    private static int[]? ReadInts(BinaryReader r)
+    {
+        int length = r.ReadInt32();
+        if (length < 0) return null;
+        var a = new int[length];
+        for (int i = 0; i < length; i++) a[i] = r.ReadInt32();
+        return a;
+    }
+
+    private static void WriteDoubles(BinaryWriter w, double[]? a)
+    {
+        if (a is null) { w.Write(-1); return; }
+        w.Write(a.Length);
+        foreach (var value in a) w.Write(value);
+    }
+
+    private static double[]? ReadDoubles(BinaryReader r)
+    {
+        int length = r.ReadInt32();
+        if (length < 0) return null;
+        var a = new double[length];
+        for (int i = 0; i < length; i++) a[i] = r.ReadDouble();
+        return a;
+    }
+
+    private static void CopyDoublesInPlace(string name, double[]? destination, double[]? source)
+    {
+        if (source is null)
+        {
+            if (destination is null) return;
+            throw new InvalidDataException(
+                $"State '{name}' was null in the checkpoint but is construction-owned in this model.");
+        }
+        if (destination is null || destination.Length != source.Length)
+        {
+            throw new InvalidDataException(
+                $"State '{name}' requires a {source.Length}-value construction-owned array, but the "
+                + $"destination has {destination?.Length.ToString() ?? "no"} values.");
+        }
+        Array.Copy(source, destination, source.Length);
+    }
+
+    private static void WriteJaggedDoubles(BinaryWriter w, double[][]? values)
+    {
+        if (values is null) { w.Write(-1); return; }
+        w.Write(values.Length);
+        foreach (var row in values) WriteDoubles(w, row);
+    }
+
+    private static double[][]? ReadJaggedDoubles(BinaryReader r)
+    {
+        int count = r.ReadInt32();
+        if (count < 0) return null;
+        var values = new double[count][];
+        for (int i = 0; i < count; i++) values[i] = ReadDoubles(r) ?? Array.Empty<double>();
+        return values;
+    }
+
+    private static void CopyJaggedDoublesInPlace(
+        string name,
+        double[][]? destination,
+        double[][]? source)
+    {
+        if (source is null)
+        {
+            if (destination is null) return;
+            throw new InvalidDataException(
+                $"State '{name}' was null in the checkpoint but is construction-owned in this model.");
+        }
+        if (destination is null || destination.Length != source.Length)
+        {
+            throw new InvalidDataException(
+                $"State '{name}' requires {source.Length} construction-owned rows, but the destination "
+                + $"has {destination?.Length.ToString() ?? "no"} rows.");
+        }
+        for (int i = 0; i < source.Length; i++)
+            CopyDoublesInPlace($"{name}[{i}]", destination[i], source[i]);
+    }
+}
diff --git a/src/Models/ModelWrapperBase.cs b/src/Models/ModelWrapperBase.cs
index 81e18ba3a0..d05ab1f29f 100644
--- a/src/Models/ModelWrapperBase.cs
+++ b/src/Models/ModelWrapperBase.cs
@@ -26,10 +26,53 @@ namespace AiDotNet.Models;
 /// all the common delegation so wrapper classes only implement what's different.
 /// </para>
 /// </remarks>
-public abstract class ModelWrapperBase<T, TInput, TOutput> : IFullModel<T, TInput, TOutput>,
+public abstract partial class ModelWrapperBase<T, TInput, TOutput> : IFullModel<T, TInput, TOutput>,
     IParameterizable<T, TInput, TOutput>, IFeatureAware, IGradientComputable<T, TInput, TOutput>,
     AiDotNet.Models.Parameters.IParameterManifestProvider
 {
+    // --- declared state (ModelStateRegistry) ---
+    // Identical in every model base because these bases are siblings over the same interfaces rather
+    // than one hierarchy; the logic itself lives once in ModelStateRegistry/ModelStateEnvelope.
+
+    /// <summary>State that is not a parameter vector, declared once and persisted by this base.</summary>
+    private readonly AiDotNet.Models.ModelStateRegistry<T> _declaredState = new();
+    private bool _declaredStateRegistered;
+
+    /// <summary>
+    /// Declare state here that the parameter vector does not carry -- a retained training set,
+    /// fitted knots, kernel centres, an ensemble's children. Both halves of the payload are driven
+    /// by the declaration, so they cannot drift.
+    /// </summary>
+    /// <param name="state">The registry to declare into.</param>
+    protected virtual void RegisterState(AiDotNet.Models.ModelStateRegistry<T> state)
+    {
+    }
+    /// <summary>Generated state declarations for fields declared across this model's hierarchy.</summary>
+    /// <param name="state">The registry to declare into.</param>
+    /// <remarks>
+    /// Emitted by ModelStateGenerator into the partial model, so a model author declares nothing. The
+    /// hand-written <c>RegisterState</c> beside it exists only for state the classifier genuinely
+    /// cannot place; anything it CAN place belongs here, where it cannot be forgotten.
+    /// </remarks>
+    protected virtual void RegisterGeneratedState(AiDotNet.Models.ModelStateRegistry<T> state)
+    {
+        RegisterGeneratedStateCore(state);
+    }
+
+    /// <summary>The declared state, registered once and lazily so it runs after the constructor.</summary>
+    protected AiDotNet.Models.ModelStateRegistry<T> DeclaredState
+    {
+        get
+        {
+            if (!_declaredStateRegistered)
+            {
+                _declaredStateRegistered = true;
+                RegisterGeneratedState(_declaredState);
+                RegisterState(_declaredState);
+            }
+            return _declaredState;
+        }
+    }
     /// <summary>
     /// Numeric operations for type T.
     /// </summary>
@@ -214,7 +257,28 @@ public virtual long ParameterCount
     // --- ICloneable ---
 
     /// <inheritdoc/>
-    public abstract IFullModel<T, TInput, TOutput> DeepCopy();
+    /// <remarks>
+    /// <para>
+    /// No longer abstract. Configuration is rebuilt from the compile-time clone plan, which records
+    /// the constructor the type was built with; learned state is carried through the model's own
+    /// public Serialize and Deserialize, so a model that persists something extra keeps it. The
+    /// persistence guard is told this is an internal operation because a clone is not a save.
+    /// </para>
+    /// <para>
+    /// A model overrides this only when the generator reports that it cannot rebuild the type --
+    /// a constructor parameter with no member holding its value -- and the build names which one.
+    /// </para>
+    /// </remarks>
+    public virtual IFullModel<T, TInput, TOutput> DeepCopy()
+    {
+        using (ModelPersistenceGuard.InternalOperation())
+        {
+            byte[] state = Serialize();
+            var copy = (ModelWrapperBase<T, TInput, TOutput>)AiDotNet.Models.CloneEngine.CopyConfiguration(this);
+            copy.Deserialize(state);
+            return copy;
+        }
+    }
 
     /// <inheritdoc/>
     public virtual IFullModel<T, TInput, TOutput> Clone() => DeepCopy();
@@ -232,11 +296,21 @@ public virtual void ApplyGradients(Vector<T> gradients, T learningRate)
     // --- IModelSerializer ---
 
     /// <inheritdoc/>
-    public virtual byte[] Serialize() => BaseModel.Serialize();
+    /// <remarks>
+    /// Appends the declared-state trailer that <see cref="Deserialize"/> already strips. Without
+    /// this the two halves disagreed: Extract was called on the way in, Append was never called on
+    /// the way out, so anything a wrapper declared was read back but never written - which is the
+    /// "two places to forget the same field" defect this base exists to remove, in the base itself.
+    /// </remarks>
+    public virtual byte[] Serialize()
+        => AiDotNet.Models.ModelStateEnvelope.Append(DeclaredState, BaseModel.Serialize());
 
     /// <inheritdoc/>
     public virtual void Deserialize(byte[] data)
     {
+        // Strips and applies any declared-state trailer, so the body below reads the payload
+        // exactly as it did before this existed.
+        data = AiDotNet.Models.ModelStateEnvelope.Extract(DeclaredState, data);
         Guard.NotNull(data);
         BaseModel.Deserialize(data);
     }
diff --git a/src/Models/Options/LocallyWeightedRegressionOptions.cs b/src/Models/Options/LocallyWeightedRegressionOptions.cs
index 798c0cbbdd..bed0b607cd 100644
--- a/src/Models/Options/LocallyWeightedRegressionOptions.cs
+++ b/src/Models/Options/LocallyWeightedRegressionOptions.cs
@@ -62,7 +62,28 @@ public class LocallyWeightedRegressionOptions : NonLinearRegressionOptions
     /// If your predictions seem too generalized and miss obvious patterns, try decreasing it.
     /// </para>
     /// </remarks>
-    public double Bandwidth { get; set; } = 1.0;
+    public double Bandwidth { get; set; } = 0.0;
+
+    /// <summary>
+    /// The span: the fraction of the training set included in each local fit.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// This is LOESS's smoothing parameter as Cleveland and Devlin define it. Each local fit uses the
+    /// q = floor(Span * n) nearest neighbours of the query point, and the kernel is scaled by the
+    /// distance to the q-th of them -- so the neighbourhood is wide where the data are sparse and
+    /// narrow where they are dense. 0.75 is the paper's usual starting value.
+    /// </para>
+    /// <para>
+    /// <b>For Beginners:</b> smaller spans follow the data more closely and wiggle more; larger spans
+    /// are smoother. Unlike a fixed bandwidth, a span adapts itself to how crowded each region is.
+    /// </para>
+    /// <para>
+    /// Setting <see cref="Bandwidth"/> to a positive value overrides this and returns the model to
+    /// fixed-bandwidth kernel regression, which is what it did before the span existed.
+    /// </para>
+    /// </remarks>
+    public double Span { get; set; } = 0.75;
 
     /// <summary>
     /// Gets or sets the matrix decomposition method used to solve the weighted least squares
diff --git a/src/Models/Options/MultilayerPerceptronRegressionOptions.cs b/src/Models/Options/MultilayerPerceptronRegressionOptions.cs
index 2bb3e1be67..76ed07d0eb 100644
--- a/src/Models/Options/MultilayerPerceptronRegressionOptions.cs
+++ b/src/Models/Options/MultilayerPerceptronRegressionOptions.cs
@@ -430,30 +430,29 @@ public class MultilayerPerceptronOptions<T, TInput, TOutput> : NonLinearRegressi
     /// models behave during training.
     /// </para>
     /// </remarks>
-    private IOptimizer<T, TInput, TOutput>? _optimizer;
-
-    public IOptimizer<T, TInput, TOutput> Optimizer
-    {
-        get
-        {
-            if (_optimizer == null)
-            {
-                var defaultModel = ModelHelper<T, TInput, TOutput>.CreateDefaultModel();
-                _optimizer = new AdamOptimizer<T, TInput, TOutput>(
-                    defaultModel,
-                    new AdamOptimizerOptions<T, TInput, TOutput>
-                    {
-                        InitialLearningRate = 0.001,
-                        Beta1 = 0.9,
-                        Beta2 = 0.999,
-                        Epsilon = 1e-8
-                    });
-            }
-            return _optimizer;
-        }
-        set
-        {
-            _optimizer = value;
-        }
-    }
+    /// <value>
+    /// <see langword="null"/> when no optimizer has been configured, in which case the model
+    /// supplies its own default.
+    /// </value>
+    /// <remarks>
+    /// <para>
+    /// This previously built a default on first read, from
+    /// <c>ModelHelper.CreateDefaultModel()</c>. An optimizer has to be bound to the model it
+    /// optimizes, and the model does not exist when its options are constructed — so the default it
+    /// produced was bound to a throwaway stand-in rather than to the real model.
+    /// </para>
+    /// <para>
+    /// Because that getter never returned <see langword="null"/>, the
+    /// <c>_options.Optimizer ?? new AdamOptimizer(this, ...)</c> in
+    /// <c>MultilayerPerceptronRegression</c>'s constructor could never fire. Every instance trained
+    /// through an optimizer attached to the stand-in model, and the correctly-bound fallback beside
+    /// it was unreachable.
+    /// </para>
+    /// <para>
+    /// Leaving this null when unconfigured makes that fallback live, so the model binds an optimizer
+    /// to itself. It also matches every other options class in the library, which initialize in
+    /// their constructors rather than lazily in a getter.
+    /// </para>
+    /// </remarks>
+    public IOptimizer<T, TInput, TOutput>? Optimizer { get; set; }
 }
diff --git a/src/Models/Options/TabTransformerOptions.cs b/src/Models/Options/TabTransformerOptions.cs
index 419b1dbd8c..091ac4f5ee 100644
--- a/src/Models/Options/TabTransformerOptions.cs
+++ b/src/Models/Options/TabTransformerOptions.cs
@@ -113,14 +113,7 @@ public TabTransformerOptions(TabTransformerOptions<T> other)
     public int[]? CategoricalCardinalities
     {
         get => _categoricalCardinalities;
-        set
-        {
-            if (value != null && _numCategoricalFeatures.HasValue && value.Length != _numCategoricalFeatures.Value)
-                throw new ArgumentException(
-                    $"CategoricalCardinalities.Length ({value.Length}) must match NumCategoricalFeatures ({_numCategoricalFeatures.Value}).",
-                    nameof(value));
-            _categoricalCardinalities = value;
-        }
+        set => _categoricalCardinalities = value;
     }
 
     /// <summary>
@@ -161,16 +154,7 @@ public int[]? CategoricalCardinalities
     public int NumHeads
     {
         get => _numHeads;
-        set
-        {
-            if (value <= 0)
-                throw new ArgumentOutOfRangeException(nameof(value), "NumHeads must be positive.");
-            if (EmbeddingDimension % value != 0)
-                throw new ArgumentException(
-                    $"NumHeads ({value}) must evenly divide EmbeddingDimension ({EmbeddingDimension}).",
-                    nameof(value));
-            _numHeads = value;
-        }
+        set => _numHeads = value;
     }
 
     /// <summary>
@@ -289,4 +273,48 @@ public int NumCategoricalFeatures
             _numCategoricalFeatures = value == 0 ? null : value;
         }
     }
+
+    /// <summary>
+    /// Checks the relationships between these options, which individual setters cannot.
+    /// </summary>
+    /// <exception cref="ArgumentOutOfRangeException">Thrown when a value is not positive.</exception>
+    /// <exception cref="ArgumentException">Thrown when two options contradict each other.</exception>
+    /// <remarks>
+    /// <para>
+    /// These checks used to live in the setters, which made them order-dependent: assigning
+    /// NumHeads before EmbeddingDimension compared it against the default rather than the intended
+    /// value, so the same pair of assignments succeeded or threw depending only on their order.
+    /// </para>
+    /// <para>
+    /// Worse, the enforcement was one-sided. NumHeads required that it divide EmbeddingDimension,
+    /// but EmbeddingDimension was a plain auto-property accepting anything, so setting NumHeads
+    /// first and EmbeddingDimension second produced an invalid object with no error at all.
+    /// </para>
+    /// <para>
+    /// Validating the relationship in one place removes both problems: any assignment order is
+    /// allowed while configuring, and the invariant is checked once, before the options are used.
+    /// This is the arrangement scikit-learn requires of its estimators, for the same reason.
+    /// </para>
+    /// </remarks>
+    public void Validate()
+    {
+        if (EmbeddingDimension <= 0)
+            throw new ArgumentOutOfRangeException(nameof(EmbeddingDimension), EmbeddingDimension, "EmbeddingDimension must be positive.");
+        if (NumHeads <= 0)
+            throw new ArgumentOutOfRangeException(nameof(NumHeads), NumHeads, "NumHeads must be positive.");
+
+        if (EmbeddingDimension % NumHeads != 0)
+            throw new ArgumentException(
+                $"NumHeads ({NumHeads}) must evenly divide EmbeddingDimension ({EmbeddingDimension}).",
+                nameof(NumHeads));
+
+        if (CategoricalCardinalities != null && _numCategoricalFeatures.HasValue
+            && CategoricalCardinalities.Length != _numCategoricalFeatures.Value)
+        {
+            throw new ArgumentException(
+                $"CategoricalCardinalities.Length ({CategoricalCardinalities.Length}) must match "
+                + $"NumCategoricalFeatures ({_numCategoricalFeatures.Value}).",
+                nameof(CategoricalCardinalities));
+        }
+    }
 }
diff --git a/src/Models/Parameters/FieldParameterSources.cs b/src/Models/Parameters/FieldParameterSources.cs
index 15d0a8bd86..4bb48375a0 100644
--- a/src/Models/Parameters/FieldParameterSources.cs
+++ b/src/Models/Parameters/FieldParameterSources.cs
@@ -378,6 +378,17 @@ private IEnumerable<IParameterSource<T>> Members()
         }
     }
 
+    /// <summary>Whether this live collection currently owns a particular component instance.</summary>
+    internal bool ContainsCurrent(IParameterSource<T>? candidate)
+    {
+        if (candidate is null) return false;
+        foreach (var member in Members())
+        {
+            if (ReferenceEquals(member, candidate)) return true;
+        }
+        return false;
+    }
+
     /// <inheritdoc />
     public void PrepareParameterSurface(ParameterSurfaceIntent intent)
     {
diff --git a/src/Models/Parameters/GeneratedParameterDiscovery.cs b/src/Models/Parameters/GeneratedParameterDiscovery.cs
new file mode 100644
index 0000000000..e0a5ae8590
--- /dev/null
+++ b/src/Models/Parameters/GeneratedParameterDiscovery.cs
@@ -0,0 +1,58 @@
+using System.Reflection;
+using AiDotNet.Interfaces;
+
+namespace AiDotNet.Models.Parameters;
+
+/// <summary>
+/// Shared fallback for parameter-only model families that do not inherit the generated model
+/// registry. It discovers parameter-bearing members declared by a concrete variant while keeping
+/// the family base as the sole owner of ordering, counting, reading, and restoring parameters.
+/// </summary>
+internal static class GeneratedParameterDiscovery
+{
+    private const BindingFlags DeclaredInstance =
+        BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly;
+
+    /// <summary>Enumerates parameter sources declared below <paramref name="familyBase"/>.</summary>
+    internal static IEnumerable<IParameterSource<T>> EnumerateDerivedSources<T>(
+        object owner,
+        Type familyBase)
+    {
+        var seen = new HashSet<object>(AiDotNet.Helpers.TensorReferenceComparer<object>.Instance);
+
+        for (var current = owner.GetType(); current is not null && current != familyBase;
+             current = current.BaseType)
+        {
+            foreach (var field in current.GetFields(DeclaredInstance).OrderBy(field => field.MetadataToken))
+            {
+                if (IsExcluded(field)) continue;
+                if (field.GetValue(owner) is IParameterSource<T> source && seen.Add(source))
+                    yield return source;
+            }
+        }
+    }
+
+    /// <summary>Enumerates layer-shaped parameter sources declared by a concrete variant.</summary>
+    internal static IEnumerable<ILayer<T>> EnumerateDerivedLayers<T>(object owner, Type familyBase)
+    {
+        foreach (var source in EnumerateDerivedSources<T>(owner, familyBase))
+        {
+            if (source is ILayer<T> layer) yield return layer;
+        }
+    }
+
+    private static bool IsExcluded(FieldInfo field)
+    {
+        foreach (var attribute in field.GetCustomAttributes(inherit: true))
+        {
+            if (attribute.GetType().Name is "ScratchAttribute" or "BufferAttribute"
+                or "ParameterAliasAttribute" or "ExternalStateAttribute"
+                or "ExternalResourceAttribute")
+            {
+                return true;
+            }
+        }
+
+        return false;
+    }
+}
diff --git a/src/Models/Parameters/ModelParameterSources.cs b/src/Models/Parameters/ModelParameterSources.cs
index dc27ad2a54..97f2521eff 100644
--- a/src/Models/Parameters/ModelParameterSources.cs
+++ b/src/Models/Parameters/ModelParameterSources.cs
@@ -91,6 +91,24 @@ public interface IVariableLengthParameterSource<T> : IParameterSource<T>
     bool CanResizeOnRestore { get; }
 }
 
+/// <summary>
+/// Persists the non-numeric structure that gives a variable parameter surface its shape.
+/// </summary>
+/// <remarks>
+/// A flat parameter vector can restore values only after the destination owns the same slots. Sparse
+/// tables are the canonical example: their state/action keys are topology, while the values stored at
+/// those keys are parameters. Model bases write this small topology block before restoring the vector,
+/// keeping values single-owned by <see cref="IParameterSource{T}"/>.
+/// </remarks>
+public interface IParameterTopologySource
+{
+    /// <summary>Writes the keys/shapes required to recreate this source's parameter slots.</summary>
+    void WriteParameterTopology(BinaryWriter writer);
+
+    /// <summary>Recreates this source's parameter slots without restoring their numeric values.</summary>
+    void ReadParameterTopology(BinaryReader reader);
+}
+
 /// <summary>
 /// A whole <see cref="Vector{T}"/> field exposed as a parameter surface.
 /// </summary>
@@ -200,7 +218,8 @@ public void SetParameters(Vector<T> parameters)
 /// variable-length piece FIRST, which the registry cannot slice; owning the whole packing in one
 /// component keeps the layout exactly as it was and still leaves one place that decides it.
 /// </remarks>
-public sealed class VariableLengthParameterSource<T> : IVariableLengthParameterSource<T>
+public sealed class VariableLengthParameterSource<T> :
+    IVariableLengthParameterSource<T>, IParameterLayoutSource
 {
     private readonly Func<long> _count;
     private readonly Func<Vector<T>> _get;
@@ -220,6 +239,39 @@ public VariableLengthParameterSource(Func<long> count, Func<Vector<T>> get, Acti
     /// <inheritdoc />
     public bool CanResizeOnRestore => true;
 
+    /// <inheritdoc />
+    public IReadOnlyList<ParameterSlotDescriptor> GetParameterLayout()
+    {
+        try
+        {
+            long count = _count();
+            if (count < 0)
+                throw new InvalidOperationException(
+                    $"A variable-length parameter source reported a negative count ({count}).");
+
+            return new[]
+            {
+                new ParameterSlotDescriptor(
+                    "$", ParameterSlotRole.Trainable,
+                    count == 0 ? ParameterReadiness.ParameterFree : ParameterReadiness.Materialized,
+                    count)
+            };
+        }
+        catch (ParameterLayoutNotReadyException)
+        {
+            // A composite source often computes its width by packing a child model. Before that
+            // child is fitted, asking for the width is a metadata query, not a value read. Preserve
+            // the deferred layout so capability checks can select the direct training path without
+            // forcing the child to expose parameters prematurely.
+            return new[]
+            {
+                new ParameterSlotDescriptor(
+                    "$", ParameterSlotRole.Trainable,
+                    ParameterReadiness.FitDeferred, null)
+            };
+        }
+    }
+
     /// <inheritdoc />
     public Vector<T> GetParameters() => _get();
 
diff --git a/src/Models/Parameters/NumericCollectionParameterSources.cs b/src/Models/Parameters/NumericCollectionParameterSources.cs
index 588951d9fa..1de80f25fb 100644
--- a/src/Models/Parameters/NumericCollectionParameterSources.cs
+++ b/src/Models/Parameters/NumericCollectionParameterSources.cs
@@ -1,6 +1,7 @@
 using System.Globalization;
 using AiDotNet.Interfaces;
 using AiDotNet.Tensors.LinearAlgebra;
+using Newtonsoft.Json;
 
 namespace AiDotNet.Models.Parameters;
 
@@ -418,7 +419,7 @@ private static IEnumerable<KeyValuePair<string, Vector<T>>> Enumerate(
 /// adding or re-inserting an unrelated key therefore cannot reorder an existing checkpoint.
 /// </remarks>
 public sealed class KeyedScalarCollectionParameterSource<T, TKey> :
-    IParameterSource<T>, IParameterLayoutSource
+    IParameterSource<T>, IParameterLayoutSource, IParameterTopologySource
     where TKey : notnull
 {
     private readonly Func<IDictionary<TKey, T>?> _get;
@@ -498,6 +499,36 @@ public void SetParameters(Vector<T> parameters)
         if (values is null) return;
         for (int i = 0; i < entries.Count; i++) values[entries[i].Key] = parameters[i];
     }
+
+    /// <inheritdoc />
+    public void WriteParameterTopology(BinaryWriter writer)
+    {
+        if (writer is null) throw new ArgumentNullException(nameof(writer));
+        var values = _get();
+        writer.Write(values?.Count ?? 0);
+        if (values is null) return;
+        foreach (var key in values.Keys)
+            writer.Write(JsonConvert.SerializeObject(key));
+    }
+
+    /// <inheritdoc />
+    public void ReadParameterTopology(BinaryReader reader)
+    {
+        if (reader is null) throw new ArgumentNullException(nameof(reader));
+        int count = reader.ReadInt32();
+        if (count < 0) throw new InvalidDataException($"Keyed parameter topology has negative count {count}.");
+        var values = _get();
+        if (values is null && count != 0)
+            throw new InvalidDataException("Keyed parameter topology cannot be restored into a null dictionary.");
+        values?.Clear();
+        for (int i = 0; i < count; i++)
+        {
+            var key = JsonConvert.DeserializeObject<TKey>(reader.ReadString());
+            if (key is null)
+                throw new InvalidDataException($"Keyed parameter topology contains a null key at index {i}.");
+            values!.Add(key, default!);
+        }
+    }
 }
 
 /// <summary>A two-level scalar dictionary exposed in canonical outer- and inner-key order.</summary>
@@ -507,7 +538,7 @@ public void SetParameters(Vector<T> parameters)
 /// tables round-trip without shifting later values onto a different state or action.
 /// </remarks>
 public sealed class NestedKeyedScalarCollectionParameterSource<T, TOuterKey, TInnerKey> :
-    IParameterSource<T>, IParameterLayoutSource
+    IParameterSource<T>, IParameterLayoutSource, IParameterTopologySource
     where TOuterKey : notnull
     where TInnerKey : notnull
 {
@@ -599,4 +630,54 @@ public void SetParameters(Vector<T> parameters)
         for (int i = 0; i < entries.Count; i++)
             values[entries[i].OuterKey][entries[i].InnerKey] = parameters[i];
     }
+
+    /// <inheritdoc />
+    public void WriteParameterTopology(BinaryWriter writer)
+    {
+        if (writer is null) throw new ArgumentNullException(nameof(writer));
+        var values = _get();
+        writer.Write(values?.Count ?? 0);
+        if (values is null) return;
+        foreach (var outer in values)
+        {
+            writer.Write(JsonConvert.SerializeObject(outer.Key));
+            writer.Write(outer.Value?.Count ?? 0);
+            if (outer.Value is null) continue;
+            foreach (var innerKey in outer.Value.Keys)
+                writer.Write(JsonConvert.SerializeObject(innerKey));
+        }
+    }
+
+    /// <inheritdoc />
+    public void ReadParameterTopology(BinaryReader reader)
+    {
+        if (reader is null) throw new ArgumentNullException(nameof(reader));
+        int outerCount = reader.ReadInt32();
+        if (outerCount < 0)
+            throw new InvalidDataException($"Nested parameter topology has negative outer count {outerCount}.");
+        var values = _get();
+        if (values is null && outerCount != 0)
+            throw new InvalidDataException("Nested parameter topology cannot be restored into a null dictionary.");
+        values?.Clear();
+        for (int outerIndex = 0; outerIndex < outerCount; outerIndex++)
+        {
+            var outerKey = JsonConvert.DeserializeObject<TOuterKey>(reader.ReadString());
+            if (outerKey is null)
+                throw new InvalidDataException($"Nested parameter topology contains a null outer key at index {outerIndex}.");
+            int innerCount = reader.ReadInt32();
+            if (innerCount < 0)
+                throw new InvalidDataException(
+                    $"Nested parameter topology has negative inner count {innerCount} at outer index {outerIndex}.");
+            var inner = new Dictionary<TInnerKey, T>();
+            for (int innerIndex = 0; innerIndex < innerCount; innerIndex++)
+            {
+                var innerKey = JsonConvert.DeserializeObject<TInnerKey>(reader.ReadString());
+                if (innerKey is null)
+                    throw new InvalidDataException(
+                        $"Nested parameter topology contains a null inner key at {outerIndex}/{innerIndex}.");
+                inner.Add(innerKey, default!);
+            }
+            values!.Add(outerKey, inner);
+        }
+    }
 }
diff --git a/src/Models/Parameters/ParameterComponentRegistry.cs b/src/Models/Parameters/ParameterComponentRegistry.cs
index 37eed1f99f..60f47b2a89 100644
--- a/src/Models/Parameters/ParameterComponentRegistry.cs
+++ b/src/Models/Parameters/ParameterComponentRegistry.cs
@@ -595,6 +595,89 @@ public void MaterializeCheckpointSources()
         PrepareParameterSurface(ParameterSurfaceIntent.Checkpoint);
     }
 
+    /// <summary>
+    /// Writes the structural state required by variable-topology parameter sources.
+    /// </summary>
+    internal void WriteParameterTopologies(BinaryWriter writer)
+    {
+        if (writer is null) throw new ArgumentNullException(nameof(writer));
+
+        lock (_surfaceGate)
+        {
+            var ordered = OrderedEntries();
+            writer.Write(ordered.Count);
+            for (int i = 0; i < ordered.Count; i++)
+            {
+                writer.Write(ordered[i].StableId);
+                if (ordered[i].Source is not IParameterTopologySource topology)
+                {
+                    writer.Write(false);
+                    continue;
+                }
+
+                writer.Write(true);
+                using var payload = new MemoryStream();
+                using (var payloadWriter = new BinaryWriter(
+                           payload, Encoding.UTF8, leaveOpen: true))
+                {
+                    topology.WriteParameterTopology(payloadWriter);
+                    payloadWriter.Flush();
+                }
+                writer.Write(checked((int)payload.Length));
+                writer.Write(payload.GetBuffer(), 0, checked((int)payload.Length));
+            }
+        }
+    }
+
+    /// <summary>
+    /// Restores variable parameter topology before a flat parameter vector is distributed.
+    /// </summary>
+    internal void ReadParameterTopologies(BinaryReader reader)
+    {
+        if (reader is null) throw new ArgumentNullException(nameof(reader));
+
+        lock (_surfaceGate)
+        {
+            var ordered = OrderedEntries();
+            int count = reader.ReadInt32();
+            if (count != ordered.Count)
+                throw new InvalidDataException(
+                    $"Parameter topology contains {count} components, but the live model declares {ordered.Count}.");
+
+            for (int i = 0; i < count; i++)
+            {
+                string stableId = reader.ReadString();
+                if (!string.Equals(stableId, ordered[i].StableId, StringComparison.Ordinal))
+                    throw new InvalidDataException(
+                        $"Parameter topology component {i} is '{stableId}', but the live model declares " +
+                        $"'{ordered[i].StableId}'.");
+
+                bool hasTopology = reader.ReadBoolean();
+                if (!hasTopology) continue;
+
+                int length = reader.ReadInt32();
+                if (length < 0)
+                    throw new InvalidDataException(
+                        $"Parameter topology component '{stableId}' has negative length {length}.");
+                byte[] payload = reader.ReadBytes(length);
+                if (payload.Length != length)
+                    throw new EndOfStreamException(
+                        $"Parameter topology component '{stableId}' ended before its declared length.");
+                if (ordered[i].Source is not IParameterTopologySource topology)
+                    throw new InvalidDataException(
+                        $"Parameter topology component '{stableId}' has saved structure, but the live " +
+                        "parameter source cannot restore structure.");
+
+                using var stream = new MemoryStream(payload, writable: false);
+                using var payloadReader = new BinaryReader(stream, Encoding.UTF8, leaveOpen: false);
+                topology.ReadParameterTopology(payloadReader);
+                if (stream.Position != stream.Length)
+                    throw new InvalidDataException(
+                        $"Parameter topology component '{stableId}' did not consume its complete payload.");
+            }
+        }
+    }
+
     /// <summary>
     /// Advances every generated or manually registered component to one common lifecycle boundary.
     /// </summary>
@@ -727,6 +810,11 @@ private CapturedLayout CaptureLayout()
 
     private static bool ReferencesSameSource(IParameterSource<T>? registered, IParameterSource<T> candidate)
         => ReferenceEquals(registered, candidate)
+        || registered is ComponentCollectionParameterSource<T> collection
+           && collection.ContainsCurrent(
+               candidate is ComponentAccessorParameterSource<T> collectionCandidateAccessor
+                   ? collectionCandidateAccessor.Current
+                   : candidate)
         || registered is ComponentAccessorParameterSource<T> accessor
            && ReferenceEquals(accessor.Current,
                candidate is ComponentAccessorParameterSource<T> candidateAccessor
diff --git a/src/Models/Parameters/ParameterManifest.cs b/src/Models/Parameters/ParameterManifest.cs
index c54b62fdcb..3780d07895 100644
--- a/src/Models/Parameters/ParameterManifest.cs
+++ b/src/Models/Parameters/ParameterManifest.cs
@@ -84,7 +84,28 @@ public enum ParameterSlotRole
     Scratch,
 
     /// <summary>State owned by an external runtime, such as a loaded ONNX graph.</summary>
-    External
+    External,
+
+    /// <summary>
+    /// Fitted state whose extent comes from the caller's data, so it is restored by name but never
+    /// joins the flat parameter vector.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// <see cref="LearnedState"/> is sized once at construction, which is what lets it travel in
+    /// the flat vector alongside the weights. A graph layer's adjacency matrix is sized by the
+    /// graph it was handed, so counting it there would make ParameterCount change under a forward
+    /// pass and would bind a checkpoint to the node count it was trained on. Same persistence, but
+    /// deliberately outside the count.
+    /// </para>
+    /// <para>
+    /// APPENDED, not inserted. These members are compared and stored as ordinals in places that do
+    /// not all travel together, so adding one in the middle silently renumbers every later role --
+    /// slotting it after LearnedState turned every [Buffer] into a Frozen slot and made a graph
+    /// model refuse to report its parameters at all.
+    /// </para>
+    /// </remarks>
+    InputSizedState
 }
 
 /// <summary>Declares which mechanism is allowed to change a numeric state slot.</summary>
@@ -412,6 +433,7 @@ public ParameterLayoutSnapshot(IReadOnlyList<ParameterSlotDescriptor> slots)
         MaterializedParameterCount = materializedTotal;
         RestorableParameterCount = restorableTotal;
         Fingerprint = ComputeFingerprint(immutableSlots);
+        DeclaredLayoutFingerprint = ComputeFingerprint(immutableSlots, includeStorageReadiness: false);
     }
 
     /// <summary>Slots in stable-ID order.</summary>
@@ -468,25 +490,47 @@ public ParameterLayoutSnapshot(IReadOnlyList<ParameterSlotDescriptor> slots)
     /// </summary>
     public string Fingerprint { get; }
 
-    private static string ComputeFingerprint(IReadOnlyList<ParameterSlotDescriptor> slots)
+    /// <summary>
+    /// A SHA-256 digest of the durable parameter schema, excluding only the current allocation
+    /// state. A shape-resolved lazy slot and the same materialized slot therefore share this value,
+    /// while identity, role, update policy, persistence, ownership, availability, declared count,
+    /// element type, and shape remain part of the contract.
+    /// </summary>
+    /// <remarks>
+    /// Clone construction is allowed to materialize storage as it restores state. Comparing
+    /// <see cref="Fingerprint"/> at that boundary incorrectly treats this lifecycle transition as
+    /// a schema change. Checkpoint compatibility should continue to use <see cref="Fingerprint"/>
+    /// when exact readiness matters; clone validation uses this declared-layout fingerprint.
+    /// </remarks>
+    public string DeclaredLayoutFingerprint { get; }
+
+    private static string ComputeFingerprint(
+        IReadOnlyList<ParameterSlotDescriptor> slots,
+        bool includeStorageReadiness = true)
     {
         var canonical = new StringBuilder();
-        canonical.Append("parameter-manifest-v").Append(CurrentSchemaVersion).Append('\n');
+        canonical.Append(includeStorageReadiness ? "parameter-manifest-v" : "parameter-layout-v")
+            .Append(CurrentSchemaVersion).Append('\n');
         for (int i = 0; i < slots.Count; i++)
         {
             var slot = slots[i];
             canonical.Append(slot.StableId.Length).Append(':').Append(slot.StableId).Append('|')
-                .Append((int)slot.Role).Append('|')
-                .Append((int)slot.Readiness).Append('|')
+                .Append((int)slot.Role).Append('|');
+            if (includeStorageReadiness)
+                canonical.Append((int)slot.Readiness).Append('|');
+            canonical
                 .Append((int)slot.UpdatePolicy).Append('|')
                 .Append((int)slot.Persistence).Append('|')
                 .Append((int)slot.Ownership).Append('|')
                 .Append((int)slot.Availability).Append('|')
                 .Append(slot.ParameterCount.HasValue ? slot.ParameterCount.Value.ToString(
-                    System.Globalization.CultureInfo.InvariantCulture) : "?").Append('|')
-                .Append(slot.MaterializedParameterCount.ToString(
-                    System.Globalization.CultureInfo.InvariantCulture)).Append('|')
-                .Append(slot.ElementType ?? "?").Append('|');
+                    System.Globalization.CultureInfo.InvariantCulture) : "?").Append('|');
+            if (includeStorageReadiness)
+            {
+                canonical.Append(slot.MaterializedParameterCount.ToString(
+                    System.Globalization.CultureInfo.InvariantCulture)).Append('|');
+            }
+            canonical.Append(slot.ElementType ?? "?").Append('|');
             if (slot.Shape is null)
             {
                 canonical.Append('?');
diff --git a/src/Models/VectorModel.cs b/src/Models/VectorModel.cs
index d2de4866c4..3cea4eef82 100644
--- a/src/Models/VectorModel.cs
+++ b/src/Models/VectorModel.cs
@@ -645,136 +645,6 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    /// <summary>
-    /// Serializes the model to a byte array.
-    /// </summary>
-    /// <returns>A byte array containing the serialized model.</returns>
-    /// <remarks>
-    /// <para>
-    /// This method serializes the model to a byte array by writing the number of coefficients and then each coefficient 
-    /// value. The serialization format is simple: first an integer indicating the number of coefficients, followed by each 
-    /// coefficient as a double. This allows the model to be stored or transmitted and later reconstructed using the 
-    /// Deserialize method.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method converts the model to a byte array that can be saved or transmitted.
-    /// 
-    /// The Serialize method:
-    /// - Converts the model to a compact binary format
-    /// - Writes the number of coefficients and each coefficient value
-    /// - Returns a byte array that can be stored or transmitted
-    /// 
-    /// The serialization format is:
-    /// 1. An integer with the number of coefficients
-    /// 2. Each coefficient value as a double
-    /// 
-    /// This method is useful when:
-    /// - Saving models to files or databases
-    /// - Sending models over a network
-    /// - Persisting models between application runs
-    /// 
-    /// The resulting byte array can be converted back to a model using Deserialize.
-    /// </para>
-    /// </remarks>
-    public override byte[] Serialize()
-    {
-        ModelPersistenceGuard.EnforceBeforeSerialize();
-        using MemoryStream ms = new MemoryStream();
-        using BinaryWriter writer = new BinaryWriter(ms);
-
-        // Write a version number for forward compatibility
-        writer.Write(1); // Version 1
-
-        // Write the number of coefficients
-        writer.Write(Coefficients.Length);
-
-        // Write each coefficient
-        for (int i = 0; i < Coefficients.Length; i++)
-        {
-            writer.Write(Convert.ToDouble(Coefficients[i]));
-        }
-
-        return ms.ToArray();
-    }
-
-    /// <summary>
-    /// Deserializes the model from a byte array.
-    /// </summary>
-    /// <param name="data">The byte array containing the serialized model.</param>
-    /// <exception cref="ArgumentNullException">Thrown when data is null.</exception>
-    /// <exception cref="ArgumentException">Thrown when data is empty or invalid.</exception>
-    /// <exception cref="InvalidOperationException">Thrown when the serialized coefficients count doesn't match the model's coefficients count.</exception>
-    /// <remarks>
-    /// <para>
-    /// This method deserializes the model from a byte array by reading the number of coefficients and then each coefficient 
-    /// value. It expects the same format as produced by the Serialize method: first an integer indicating the number of 
-    /// coefficients, followed by each coefficient as a double. This allows a model that was previously serialized to be 
-    /// reconstructed.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method reconstructs a model from a byte array created by Serialize.
-    /// 
-    /// The Deserialize method:
-    /// - Takes a byte array containing a serialized model
-    /// - Reads the number of coefficients and each coefficient value
-    /// - Updates the model's coefficients with the deserialized values
-    /// 
-    /// It expects the same format created by Serialize:
-    /// 1. An integer with the number of coefficients
-    /// 2. Each coefficient value as a double
-    /// 
-    /// This method is useful when:
-    /// - Loading models from files or databases
-    /// - Receiving models over a network
-    /// - Restoring models from persistent storage
-    /// 
-    /// Note that this method updates the existing model's coefficients rather than
-    /// creating a new model, which is different from most other methods in this class.
-    /// </para>
-    /// </remarks>
-    public override void Deserialize(byte[] data)
-    {
-        ModelPersistenceGuard.EnforceBeforeDeserialize();
-        if (data == null)
-        {
-            throw new ArgumentNullException(nameof(data));
-        }
-
-        if (data.Length == 0)
-        {
-            throw new ArgumentException("Serialized data cannot be empty.", nameof(data));
-        }
-
-        try
-        {
-            using MemoryStream ms = new MemoryStream(data);
-            using BinaryReader reader = new BinaryReader(ms);
-
-            // Read version number
-            int version = reader.ReadInt32();
-
-            // Read the number of coefficients
-            int length = reader.ReadInt32();
-
-            // Validate coefficient count
-            if (length != Coefficients.Length)
-            {
-                throw new InvalidOperationException($"Serialized coefficients count ({length}) doesn't match model's coefficients count ({Coefficients.Length}).");
-            }
-
-            // Read each coefficient
-            for (int i = 0; i < length; i++)
-            {
-                Coefficients[i] = NumOps.FromDouble(reader.ReadDouble());
-            }
-
-            // Invalidate cached feature importance
-            _cachedFeatureImportance = null;
-        }
-        catch (Exception ex) when (!(ex is ArgumentNullException || ex is ArgumentException || ex is InvalidOperationException))
-        {
-            throw new ArgumentException("Failed to deserialize the model. The data may be corrupted or in an invalid format.", nameof(data), ex);
-        }
-    }
-
     /// <summary>
     /// Saves the model to a file.
     /// </summary>
@@ -1029,45 +899,6 @@ public override IEnumerable<int> GetActiveFeatureIndices()
         }
     }
 
-    /// <summary>
-    /// Creates a deep copy of this model.
-    /// </summary>
-    /// <returns>A new instance with the same coefficients.</returns>
-    /// <remarks>
-    /// <para>
-    /// This method creates a deep copy of the model by creating a new VectorModel with a new coefficients vector that has 
-    /// the same values as the original. This ensures that modifications to the copy do not affect the original model. This 
-    /// method is useful when you need to create a duplicate of a model for experimentation or as part of genetic algorithm 
-    /// operations.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method creates an exact duplicate of the model.
-    /// 
-    /// The DeepCopy method:
-    /// - Creates a new model with the same coefficients as this one
-    /// - Ensures the new model is completely independent of the original
-    /// - Creates a "deep copy" where all data is duplicated, not just references
-    /// 
-    /// This method is useful when:
-    /// - You need to create a duplicate of a model for experimentation
-    /// - You want to ensure changes to one model don't affect another
-    /// - You're implementing algorithms that require model copies
-    /// 
-    /// For example, you might copy a model before mutating it to preserve the original.
-    /// </para>
-    /// </remarks>
-    public override IFullModel<T, Matrix<T>, Vector<T>> DeepCopy()
-    {
-        // Create a new coefficients vector with the same values
-        Vector<T> clonedCoefficients = new Vector<T>(Coefficients.Length);
-        for (int i = 0; i < Coefficients.Length; i++)
-        {
-            clonedCoefficients[i] = Coefficients[i];
-        }
-
-        // Create a new model with the cloned coefficients
-        return new VectorModel<T>(clonedCoefficients);
-    }
-
     public override void SetActiveFeatureIndices(IEnumerable<int> featureIndices)
     {
         if (featureIndices == null)
@@ -1146,6 +977,7 @@ public override Dictionary<string, T> GetFeatureImportance()
 #pragma warning disable CS0618
 
     protected readonly HashSet<InterpretationMethod> _enabledMethods = new();
+    [AiDotNet.Attributes.TrainableParameter]
     protected Vector<int>? _sensitiveFeatures;
     protected readonly List<FairnessMetric> _fairnessMetrics = new();
     [ExternalState]
diff --git a/src/NER/NERNeuralNetworkBase.cs b/src/NER/NERNeuralNetworkBase.cs
index b836c5f0cb..8dbfa78cf4 100644
--- a/src/NER/NERNeuralNetworkBase.cs
+++ b/src/NER/NERNeuralNetworkBase.cs
@@ -56,7 +56,7 @@ namespace AiDotNet.NER;
 [TensorLayout(TensorAxis.Time,
     Direction = TensorLayoutDirection.Output,
     Note = "One DECODED label id per token. Not the emission matrix - see OutputAxesFor.")]
-public abstract class NERNeuralNetworkBase<T> : NeuralNetworkBase<T>, IShapeContract
+public abstract partial class NERNeuralNetworkBase<T> : NeuralNetworkBase<T>, IShapeContract
 {
     /// <summary>
     /// The NER family's law: one row of <see cref="NumLabels"/> emission scores per input token.
diff --git a/src/NER/SequenceLabeling/BiLSTMCRF.cs b/src/NER/SequenceLabeling/BiLSTMCRF.cs
index a68b118709..cfbf52ed36 100644
--- a/src/NER/SequenceLabeling/BiLSTMCRF.cs
+++ b/src/NER/SequenceLabeling/BiLSTMCRF.cs
@@ -131,7 +131,7 @@ namespace AiDotNet.NER.SequenceLabeling;
     "https://arxiv.org/abs/1508.01991",
     Year = 2015,
     Authors = "Zhiheng Huang, Wei Xu, Kai Yu")]
-public class BiLSTMCRF<T> : SequenceLabelingNERBase<T>, INERModel<T>
+public partial class BiLSTMCRF<T> : SequenceLabelingNERBase<T>, INERModel<T>
 {
     #region Fields
 
@@ -1002,30 +1002,7 @@ public override ModelMetadata<T> GetModelMetadata()
     /// proportions so you can recreate the dish.
     /// </para>
     /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode);
-        w.Write(_options.ModelPath ?? string.Empty);
-        w.Write((int)_options.Variant);
-        w.Write(_options.EmbeddingDimension);
-        w.Write(_options.HiddenDimension);
-        w.Write(_options.NumLSTMLayers);
-        w.Write(_options.NumLabels);
-        w.Write(_options.MaxSequenceLength);
-        w.Write(_options.UseCRF);
-        w.Write(_options.UseCharEmbeddings);
-        w.Write(_options.CharEmbeddingDimension);
-        w.Write(_options.CharHiddenDimension);
-        w.Write(_options.DropoutRate);
-        w.Write(_options.LearningRate);
 
-        // Serialize label names
-        w.Write(_options.LabelNames.Length);
-        foreach (var label in _options.LabelNames)
-        {
-            w.Write(label);
-        }
-    }
 
     /// <summary>
     /// Deserializes model-specific data from a binary stream, restoring the model to its saved state.
@@ -1050,91 +1027,7 @@ protected override void SerializeNetworkSpecificData(BinaryWriter w)
     /// the other loads.
     /// </para>
     /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean();
-        string mp = r.ReadString();
-        if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.Variant = (NERModelVariant)r.ReadInt32();
-        _options.EmbeddingDimension = r.ReadInt32();
-        _options.HiddenDimension = r.ReadInt32();
-        _options.NumLSTMLayers = r.ReadInt32();
-        _options.NumLabels = r.ReadInt32();
-        _options.MaxSequenceLength = r.ReadInt32();
-        _options.UseCRF = r.ReadBoolean();
-        _options.UseCharEmbeddings = r.ReadBoolean();
-        _options.CharEmbeddingDimension = r.ReadInt32();
-        _options.CharHiddenDimension = r.ReadInt32();
-        _options.DropoutRate = r.ReadDouble();
-        _options.LearningRate = r.ReadDouble();
-
-        // Deserialize label names
-        int labelCount = r.ReadInt32();
-        _options.LabelNames = new string[labelCount];
-        for (int i = 0; i < labelCount; i++)
-        {
-            _options.LabelNames[i] = r.ReadString();
-        }
-
-        // Restore base class properties from deserialized options
-        NumLabels = _options.NumLabels;
-        EmbeddingDimension = _options.EmbeddingDimension;
-        MaxSequenceLength = _options.MaxSequenceLength;
-        UseCRF = _options.UseCRF;
-        LabelNames = _options.LabelNames;
-
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-        {
-            OnnxModel?.Dispose();
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-        }
-        else if (_useNativeMode)
-        {
-            // ONNX cleanup only — do NOT clear Layers and call InitializeLayers
-            // here. The base class's DeserializeInternalUnchecked has already
-            // recreated every layer from its serialized type+shape+metadata
-            // and called SetParameters with the saved trained weights; clearing
-            // and reinitialising here threw all that work away and replaced it
-            // with fresh random-init layers, which made Clone /
-            // DeepCopy / SaveModel+LoadModel return a model that predicts
-            // completely different label sequences than the source. That was
-            // the actual root cause of the BiLSTMCRFTests
-            // Clone_ShouldProduceIdenticalOutput and
-            // Clone_AfterTraining_ShouldPreserveLearnedWeights failures after
-            // cluster 4 cleanup (the dropped weights manifested as ||Δ|| ~= ||trained||
-            // on a probe-input — random-init magnitude relative to the trained model).
-            OnnxModel?.Dispose();
-            OnnxModel = null;
-        }
-    }
 
-    /// <summary>
-    /// Creates a new, uninitialized instance of this model with the same configuration.
-    /// </summary>
-    /// <returns>A new <see cref="BiLSTMCRF{T}"/> instance with identical options but fresh
-    /// (randomly initialized) weights. Used internally by the framework for model cloning,
-    /// ensemble creation, and cross-validation.</returns>
-    /// <remarks>
-    /// <para>
-    /// The new instance receives a deep copy of the options via the copy constructor to prevent
-    /// mutation leaking between instances. In ONNX mode, the new instance loads the same
-    /// ONNX model file. In native mode, the new instance gets freshly initialized layers via
-    /// <see cref="InitializeLayers"/>.
-    /// </para>
-    /// <para>
-    /// <b>For Beginners:</b> This creates a "twin" of the current model with the same architecture
-    /// and settings, but with fresh random weights (as if it was just created). This is useful for
-    /// training multiple copies of the same model (ensemble learning) or for cross-validation
-    /// experiments where you need identical model architectures with different training data.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var optionsCopy = new BiLSTMCRFOptions(_options);
-        if (!_useNativeMode && optionsCopy.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            return new BiLSTMCRF<T>(Architecture, p, optionsCopy);
-        return new BiLSTMCRF<T>(Architecture, optionsCopy);
-    }
 
     #endregion
 
diff --git a/src/NER/SequenceLabeling/CNNBiLSTMCRF.cs b/src/NER/SequenceLabeling/CNNBiLSTMCRF.cs
index bb25b9ce73..1716230688 100644
--- a/src/NER/SequenceLabeling/CNNBiLSTMCRF.cs
+++ b/src/NER/SequenceLabeling/CNNBiLSTMCRF.cs
@@ -114,7 +114,7 @@ namespace AiDotNet.NER.SequenceLabeling;
     "https://arxiv.org/abs/1603.01354",
     Year = 2016,
     Authors = "Xuezhe Ma, Eduard Hovy")]
-public class CNNBiLSTMCRF<T> : SequenceLabelingNERBase<T>, INERModel<T>
+public partial class CNNBiLSTMCRF<T> : SequenceLabelingNERBase<T>, INERModel<T>
 {
     #region Fields
 
@@ -446,17 +446,6 @@ protected override Tensor<T> PostprocessOutput(Tensor<T> modelOutput)
         return modelOutput;
     }
 
-    /// <inheritdoc />
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var optionsCopy = new CNNBiLSTMCRFOptions(_options);
-
-        if (!_useNativeMode && optionsCopy.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            return new CNNBiLSTMCRF<T>(Architecture, p, optionsCopy);
-
-        return new CNNBiLSTMCRF<T>(Architecture, optionsCopy);
-    }
-
     #endregion
 
     #region Metadata and Serialization
@@ -481,64 +470,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc />
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode);
-        w.Write(_options.ModelPath ?? string.Empty);
-        w.Write((int)_options.Variant);
-        w.Write(_options.EmbeddingDimension);
-        w.Write(_options.HiddenDimension);
-        w.Write(_options.NumLSTMLayers);
-        w.Write(_options.NumLabels);
-        w.Write(_options.MaxSequenceLength);
-        w.Write(_options.UseCRF);
-        w.Write(_options.CharEmbeddingDimension);
-        w.Write(_options.CharCNNFilters);
-        w.Write(_options.CharCNNKernelSize);
-        w.Write(_options.DropoutRate);
-        w.Write(_options.LearningRate);
-        w.Write(_options.LabelNames.Length);
-        foreach (var label in _options.LabelNames)
-            w.Write(label);
-    }
 
-    /// <inheritdoc />
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean();
-        string mp = r.ReadString();
-        if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.Variant = (NERModelVariant)r.ReadInt32();
-        _options.EmbeddingDimension = r.ReadInt32();
-        _options.HiddenDimension = r.ReadInt32();
-        _options.NumLSTMLayers = r.ReadInt32();
-        _options.NumLabels = r.ReadInt32();
-        _options.MaxSequenceLength = r.ReadInt32();
-        _options.UseCRF = r.ReadBoolean();
-        _options.CharEmbeddingDimension = r.ReadInt32();
-        _options.CharCNNFilters = r.ReadInt32();
-        _options.CharCNNKernelSize = r.ReadInt32();
-        _options.DropoutRate = r.ReadDouble();
-        _options.LearningRate = r.ReadDouble();
-        int labelCount = r.ReadInt32();
-        _options.LabelNames = new string[labelCount];
-        for (int i = 0; i < labelCount; i++)
-            _options.LabelNames[i] = r.ReadString();
 
-        ApplyOptionsToBase();
+    /// <inheritdoc />
 
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-        {
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-        }
-        // Native mode: do NOT clear+re-init Layers here. See the matching
-        // comment in BiLSTMCRF.DeserializeNetworkSpecificData — the base
-        // class already recreated every layer and called SetParameters
-        // with the saved trained weights; wiping them here drops those
-        // weights and replaces them with fresh random-init, which
-        // caused the Clone / DeepCopy round-trip to silently return a
-        // randomly-initialised model.
-    }
 
     #endregion
 
diff --git a/src/NER/SequenceLabeling/LSTMCRF.cs b/src/NER/SequenceLabeling/LSTMCRF.cs
index ec92dcc2af..d4b094076e 100644
--- a/src/NER/SequenceLabeling/LSTMCRF.cs
+++ b/src/NER/SequenceLabeling/LSTMCRF.cs
@@ -79,7 +79,7 @@ namespace AiDotNet.NER.SequenceLabeling;
     "https://arxiv.org/abs/1508.01991",
     Year = 2015,
     Authors = "Zhiheng Huang, Wei Xu, Kai Yu")]
-public class LSTMCRF<T> : SequenceLabelingNERBase<T>, INERModel<T>
+public partial class LSTMCRF<T> : SequenceLabelingNERBase<T>, INERModel<T>
 {
     #region Fields
 
@@ -409,17 +409,6 @@ protected override Tensor<T> PostprocessOutput(Tensor<T> modelOutput)
         return modelOutput;
     }
 
-    /// <inheritdoc />
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var optionsCopy = new LSTMCRFOptions(_options);
-
-        if (!_useNativeMode && optionsCopy.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            return new LSTMCRF<T>(Architecture, p, optionsCopy);
-
-        return new LSTMCRF<T>(Architecture, optionsCopy);
-    }
-
     #endregion
 
     #region Metadata and Serialization
@@ -443,55 +432,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc />
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode);
-        w.Write(_options.ModelPath ?? string.Empty);
-        w.Write((int)_options.Variant);
-        w.Write(_options.EmbeddingDimension);
-        w.Write(_options.HiddenDimension);
-        w.Write(_options.NumLSTMLayers);
-        w.Write(_options.NumLabels);
-        w.Write(_options.MaxSequenceLength);
-        w.Write(_options.UseCRF);
-        w.Write(_options.DropoutRate);
-        w.Write(_options.LearningRate);
-        w.Write(_options.LabelNames.Length);
-        foreach (var label in _options.LabelNames)
-            w.Write(label);
-    }
 
-    /// <inheritdoc />
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean();
-        string mp = r.ReadString();
-        if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.Variant = (NERModelVariant)r.ReadInt32();
-        _options.EmbeddingDimension = r.ReadInt32();
-        _options.HiddenDimension = r.ReadInt32();
-        _options.NumLSTMLayers = r.ReadInt32();
-        _options.NumLabels = r.ReadInt32();
-        _options.MaxSequenceLength = r.ReadInt32();
-        _options.UseCRF = r.ReadBoolean();
-        _options.DropoutRate = r.ReadDouble();
-        _options.LearningRate = r.ReadDouble();
-        int labelCount = r.ReadInt32();
-        _options.LabelNames = new string[labelCount];
-        for (int i = 0; i < labelCount; i++)
-            _options.LabelNames[i] = r.ReadString();
 
-        ApplyOptionsToBase();
+    /// <inheritdoc />
 
-        // Native-mode layers (with their trained weights) are already reconstructed by
-        // the base DeserializeInternalUnchecked before this override runs, so do NOT
-        // clear + re-initialize them here — that would discard the deserialized weights
-        // and leave the model randomly initialized. Only an ONNX session needs rebuilding.
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-        {
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-        }
-    }
 
     #endregion
 
diff --git a/src/NER/SequenceLabeling/SequenceLabelingNERBase.cs b/src/NER/SequenceLabeling/SequenceLabelingNERBase.cs
index 1fb63bc691..c0c4040eec 100644
--- a/src/NER/SequenceLabeling/SequenceLabelingNERBase.cs
+++ b/src/NER/SequenceLabeling/SequenceLabelingNERBase.cs
@@ -60,7 +60,7 @@ namespace AiDotNet.NER.SequenceLabeling;
 /// like "New York City" (B-LOC, I-LOC, I-LOC).
 /// </para>
 /// </remarks>
-public abstract class SequenceLabelingNERBase<T> : NERNeuralNetworkBase<T>
+public abstract partial class SequenceLabelingNERBase<T> : NERNeuralNetworkBase<T>
 {
     /// <summary>
     /// Gets or sets whether to use CRF (Conditional Random Field) decoding for label sequence prediction.
diff --git a/src/NER/SequenceLabeling/WordCharBiLSTMCRF.cs b/src/NER/SequenceLabeling/WordCharBiLSTMCRF.cs
index 1f7b3887c2..d466a3f41d 100644
--- a/src/NER/SequenceLabeling/WordCharBiLSTMCRF.cs
+++ b/src/NER/SequenceLabeling/WordCharBiLSTMCRF.cs
@@ -372,58 +372,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_options.EmbeddingDimension);
-        w.Write(_options.HiddenDimension);
-        w.Write(_options.NumLSTMLayers);
-        w.Write(_options.NumLabels);
-        w.Write(_options.MaxSequenceLength);
-        w.Write(_options.CharEmbeddingDimension);
-        w.Write(_options.CharHiddenDimension);
-        w.Write(_options.UseCRF);
-        w.Write(_options.DropoutRate);
-        w.Write(_options.LearningRate);
-        w.Write(_options.LabelNames.Length);
-        foreach (var label in _options.LabelNames) w.Write(label);
-
-        // Persist the encoder vocabularies: the model owns embedding rows keyed by these token/char ids,
-        // so without them a round-tripped model can't map text back to the same rows it was trained on.
-        w.Write(_encoder.MaxWordLength);
-        WriteVocabulary(w, _encoder.WordVocabulary);
-        WriteVocabulary(w, _encoder.CharVocabulary);
-    }
 
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _options.EmbeddingDimension = r.ReadInt32();
-        _options.HiddenDimension = r.ReadInt32();
-        _options.NumLSTMLayers = r.ReadInt32();
-        _options.NumLabels = r.ReadInt32();
-        _options.MaxSequenceLength = r.ReadInt32();
-        _options.CharEmbeddingDimension = r.ReadInt32();
-        _options.CharHiddenDimension = r.ReadInt32();
-        _options.UseCRF = r.ReadBoolean();
-        _options.DropoutRate = r.ReadDouble();
-        _options.LearningRate = r.ReadDouble();
-        int labelCount = r.ReadInt32();
-        var labels = new string[labelCount];
-        for (int i = 0; i < labelCount; i++) labels[i] = r.ReadString();
-        _options.LabelNames = labels;
 
-        NumLabels = _options.NumLabels;
-        EmbeddingDimension = _options.EmbeddingDimension;
-        MaxSequenceLength = _options.MaxSequenceLength;
-        UseCRF = _options.UseCRF;
-        LabelNames = _options.LabelNames;
+    /// <inheritdoc/>
 
-        // Restore the encoder vocabularies so token/char -> embedding-row mapping matches training.
-        int maxWordLength = r.ReadInt32();
-        var wordVocab = ReadVocabulary(r);
-        var charVocab = ReadVocabulary(r);
-        _encoder = NerTextEncoder.FromVocabularies(wordVocab, charVocab, maxWordLength);
-    }
 
     private static void WriteVocabulary(BinaryWriter w, Vocabulary vocabulary)
     {
@@ -449,11 +401,5 @@ private static Vocabulary ReadVocabulary(BinaryReader r)
         return new Vocabulary(entries, NerTextEncoder.UnkToken);
     }
 
-    /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new WordCharBiLSTMCRF<T>(Architecture, _encoder, new BiLSTMCRFOptions(_options));
-    }
-
     #endregion
 }
diff --git a/src/NER/SpanBased/BiaffineNER.cs b/src/NER/SpanBased/BiaffineNER.cs
index 6a11ff67ec..14a6372667 100644
--- a/src/NER/SpanBased/BiaffineNER.cs
+++ b/src/NER/SpanBased/BiaffineNER.cs
@@ -130,15 +130,6 @@ protected override IEnumerable<ILayer<T>> CreateDefaultLayers()
             embeddingsDropout: BiaffineOptions.EmbeddingsDropout);
     }
 
-    /// <inheritdoc />
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var optionsCopy = new SpanBasedNEROptions(NEROptions);
-        if (!UseNativeMode && optionsCopy.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            return new BiaffineNER<T>(Architecture, p, optionsCopy);
-        return new BiaffineNER<T>(Architecture, optionsCopy);
-    }
-
     /// <summary>
     /// Builds span-level supervision: one label per candidate (start, end) pair.
     /// </summary>
diff --git a/src/NER/SpanBased/PURENER.cs b/src/NER/SpanBased/PURENER.cs
index 0babbe806e..e4e7fe9ab7 100644
--- a/src/NER/SpanBased/PURENER.cs
+++ b/src/NER/SpanBased/PURENER.cs
@@ -117,13 +117,4 @@ protected override IEnumerable<ILayer<T>> CreateDefaultLayers()
             numLabels: NEROptions.NumLabels,
             dropoutRate: NEROptions.DropoutRate);
     }
-
-    /// <inheritdoc />
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var optionsCopy = new SpanBasedNEROptions(NEROptions);
-        if (!UseNativeMode && optionsCopy.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            return new PURENER<T>(Architecture, p, optionsCopy);
-        return new PURENER<T>(Architecture, optionsCopy);
-    }
 }
diff --git a/src/NER/SpanBased/PyramidNER.cs b/src/NER/SpanBased/PyramidNER.cs
index 0f285c0d53..4d8527370b 100644
--- a/src/NER/SpanBased/PyramidNER.cs
+++ b/src/NER/SpanBased/PyramidNER.cs
@@ -125,13 +125,4 @@ protected override IEnumerable<ILayer<T>> CreateDefaultLayers()
             numLabels: NEROptions.NumLabels,
             dropoutRate: NEROptions.DropoutRate);
     }
-
-    /// <inheritdoc />
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var optionsCopy = new SpanBasedNEROptions(NEROptions);
-        if (!UseNativeMode && optionsCopy.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            return new PyramidNER<T>(Architecture, p, optionsCopy);
-        return new PyramidNER<T>(Architecture, optionsCopy);
-    }
 }
diff --git a/src/NER/SpanBased/SpERTNER.cs b/src/NER/SpanBased/SpERTNER.cs
index 8242519cef..8553a913e3 100644
--- a/src/NER/SpanBased/SpERTNER.cs
+++ b/src/NER/SpanBased/SpERTNER.cs
@@ -112,13 +112,4 @@ protected override IEnumerable<ILayer<T>> CreateDefaultLayers()
             numLabels: NEROptions.NumLabels,
             dropoutRate: NEROptions.DropoutRate);
     }
-
-    /// <inheritdoc />
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var optionsCopy = new SpanBasedNEROptions(NEROptions);
-        if (!UseNativeMode && optionsCopy.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            return new SpERTNER<T>(Architecture, p, optionsCopy);
-        return new SpERTNER<T>(Architecture, optionsCopy);
-    }
 }
diff --git a/src/NER/SpanBased/SpanBasedNERBase.cs b/src/NER/SpanBased/SpanBasedNERBase.cs
index 8c3bebc9c1..0242f95727 100644
--- a/src/NER/SpanBased/SpanBasedNERBase.cs
+++ b/src/NER/SpanBased/SpanBasedNERBase.cs
@@ -40,7 +40,7 @@ namespace AiDotNet.NER.SpanBased;
 /// into a fixed-size vector for classification.
 /// </para>
 /// </remarks>
-public abstract class SpanBasedNERBase<T> : SequenceLabeling.SequenceLabelingNERBase<T>, INERModel<T>
+public abstract partial class SpanBasedNERBase<T> : SequenceLabeling.SequenceLabelingNERBase<T>, INERModel<T>
 {
     #region Fields
 
@@ -485,61 +485,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc />
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode);
-        w.Write(_options.ModelPath ?? string.Empty);
-        w.Write((int)_options.Variant);
-        w.Write(_options.HiddenDimension);
-        w.Write(_options.NumAttentionHeads);
-        w.Write(_options.NumTransformerLayers);
-        w.Write(_options.IntermediateDimension);
-        w.Write(_options.NumLabels);
-        w.Write(_options.MaxSequenceLength);
-        w.Write(_options.MaxSpanLength);
-        w.Write(_options.SpanEmbeddingDimension);
-        w.Write(_options.DropoutRate);
-        w.Write(_options.LearningRate);
-        w.Write(_options.NegativeSpanSampleRatio);
-        w.Write(_options.LabelNames.Length);
-        foreach (var label in _options.LabelNames)
-            w.Write(label);
-    }
 
-    /// <inheritdoc />
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean();
-        string mp = r.ReadString();
-        if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.Variant = (NERModelVariant)r.ReadInt32();
-        _options.HiddenDimension = r.ReadInt32();
-        _options.NumAttentionHeads = r.ReadInt32();
-        _options.NumTransformerLayers = r.ReadInt32();
-        _options.IntermediateDimension = r.ReadInt32();
-        _options.NumLabels = r.ReadInt32();
-        _options.MaxSequenceLength = r.ReadInt32();
-        _options.MaxSpanLength = r.ReadInt32();
-        _options.SpanEmbeddingDimension = r.ReadInt32();
-        _options.DropoutRate = r.ReadDouble();
-        _options.LearningRate = r.ReadDouble();
-        _options.NegativeSpanSampleRatio = r.ReadInt32();
-        int labelCount = r.ReadInt32();
-        _options.LabelNames = new string[labelCount];
-        for (int i = 0; i < labelCount; i++)
-            _options.LabelNames[i] = r.ReadString();
 
-        ApplyOptionsToBase();
+    /// <inheritdoc />
 
-        // Native-mode layers (with their trained weights) are already reconstructed by
-        // the base DeserializeInternalUnchecked before this override runs, so do NOT
-        // clear + re-initialize them here — that would discard the deserialized weights
-        // and leave the model randomly initialized. Only an ONNX session needs rebuilding.
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-        {
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-        }
-    }
 
     #endregion
 
diff --git a/src/NER/SpanBased/TriaffineNER.cs b/src/NER/SpanBased/TriaffineNER.cs
index 808ca8382e..dbc225ecb1 100644
--- a/src/NER/SpanBased/TriaffineNER.cs
+++ b/src/NER/SpanBased/TriaffineNER.cs
@@ -119,13 +119,4 @@ protected override IEnumerable<ILayer<T>> CreateDefaultLayers()
             numLabels: NEROptions.NumLabels,
             dropoutRate: NEROptions.DropoutRate);
     }
-
-    /// <inheritdoc />
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var optionsCopy = new SpanBasedNEROptions(NEROptions);
-        if (!UseNativeMode && optionsCopy.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            return new TriaffineNER<T>(Architecture, p, optionsCopy);
-        return new TriaffineNER<T>(Architecture, optionsCopy);
-    }
 }
diff --git a/src/NER/SpanBased/W2NER.cs b/src/NER/SpanBased/W2NER.cs
index cf3dda06d1..ec06b00841 100644
--- a/src/NER/SpanBased/W2NER.cs
+++ b/src/NER/SpanBased/W2NER.cs
@@ -121,13 +121,4 @@ protected override IEnumerable<ILayer<T>> CreateDefaultLayers()
             numLabels: NEROptions.NumLabels,
             dropoutRate: NEROptions.DropoutRate);
     }
-
-    /// <inheritdoc />
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var optionsCopy = new SpanBasedNEROptions(NEROptions);
-        if (!UseNativeMode && optionsCopy.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            return new W2NER<T>(Architecture, p, optionsCopy);
-        return new W2NER<T>(Architecture, optionsCopy);
-    }
 }
diff --git a/src/NER/TransformerBased/BERTNER.cs b/src/NER/TransformerBased/BERTNER.cs
index c54d105422..d657d4d62a 100644
--- a/src/NER/TransformerBased/BERTNER.cs
+++ b/src/NER/TransformerBased/BERTNER.cs
@@ -113,13 +113,4 @@ public BERTNER(
             "BERT-NER", "Devlin et al., NAACL 2019", optimizer)
     {
     }
-
-    /// <inheritdoc />
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var optionsCopy = new TransformerNEROptions(NEROptions);
-        if (!UseNativeMode && optionsCopy.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            return new BERTNER<T>(Architecture, p, optionsCopy);
-        return new BERTNER<T>(Architecture, optionsCopy);
-    }
 }
diff --git a/src/NER/TransformerBased/BLINKNER.cs b/src/NER/TransformerBased/BLINKNER.cs
index 97992061b9..9a070d5e80 100644
--- a/src/NER/TransformerBased/BLINKNER.cs
+++ b/src/NER/TransformerBased/BLINKNER.cs
@@ -103,13 +103,4 @@ public BLINKNER(
             "BLINK", "Wu et al., EMNLP 2020", optimizer)
     {
     }
-
-    /// <inheritdoc />
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var optionsCopy = new TransformerNEROptions(NEROptions);
-        if (!UseNativeMode && optionsCopy.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            return new BLINKNER<T>(Architecture, p, optionsCopy);
-        return new BLINKNER<T>(Architecture, optionsCopy);
-    }
 }
diff --git a/src/NER/TransformerBased/BioBERTNER.cs b/src/NER/TransformerBased/BioBERTNER.cs
index 9c3a3c9a1a..b10fbaee9f 100644
--- a/src/NER/TransformerBased/BioBERTNER.cs
+++ b/src/NER/TransformerBased/BioBERTNER.cs
@@ -86,13 +86,4 @@ public BioBERTNER(
             "BioBERT-NER", "Lee et al., Bioinformatics 2020", optimizer)
     {
     }
-
-    /// <inheritdoc />
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var optionsCopy = new TransformerNEROptions(NEROptions);
-        if (!UseNativeMode && optionsCopy.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            return new BioBERTNER<T>(Architecture, p, optionsCopy);
-        return new BioBERTNER<T>(Architecture, optionsCopy);
-    }
 }
diff --git a/src/NER/TransformerBased/ClinicalBERTNER.cs b/src/NER/TransformerBased/ClinicalBERTNER.cs
index 2932e21154..ff65068c4b 100644
--- a/src/NER/TransformerBased/ClinicalBERTNER.cs
+++ b/src/NER/TransformerBased/ClinicalBERTNER.cs
@@ -97,13 +97,4 @@ public ClinicalBERTNER(
             "ClinicalBERT-NER", "Alsentzer et al., NAACL 2019 Clinical NLP Workshop", optimizer)
     {
     }
-
-    /// <inheritdoc />
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var optionsCopy = new TransformerNEROptions(NEROptions);
-        if (!UseNativeMode && optionsCopy.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            return new ClinicalBERTNER<T>(Architecture, p, optionsCopy);
-        return new ClinicalBERTNER<T>(Architecture, optionsCopy);
-    }
 }
diff --git a/src/NER/TransformerBased/DeBERTaNER.cs b/src/NER/TransformerBased/DeBERTaNER.cs
index 7eb44866c8..754b4062ef 100644
--- a/src/NER/TransformerBased/DeBERTaNER.cs
+++ b/src/NER/TransformerBased/DeBERTaNER.cs
@@ -92,13 +92,4 @@ public DeBERTaNER(
             "DeBERTa-NER", "He et al., ICLR 2021", optimizer)
     {
     }
-
-    /// <inheritdoc />
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var optionsCopy = new TransformerNEROptions(NEROptions);
-        if (!UseNativeMode && optionsCopy.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            return new DeBERTaNER<T>(Architecture, p, optionsCopy);
-        return new DeBERTaNER<T>(Architecture, optionsCopy);
-    }
 }
diff --git a/src/NER/TransformerBased/DistilBERTNER.cs b/src/NER/TransformerBased/DistilBERTNER.cs
index 9ea9e0acce..06383d4e53 100644
--- a/src/NER/TransformerBased/DistilBERTNER.cs
+++ b/src/NER/TransformerBased/DistilBERTNER.cs
@@ -100,15 +100,6 @@ public DistilBERTNER(
     {
     }
 
-    /// <inheritdoc />
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var optionsCopy = new TransformerNEROptions(NEROptions);
-        if (!UseNativeMode && optionsCopy.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            return new DistilBERTNER<T>(Architecture, p, optionsCopy);
-        return new DistilBERTNER<T>(Architecture, optionsCopy);
-    }
-
     private static TransformerNEROptions CreateDistilBERTDefaults()
     {
         return new TransformerNEROptions
diff --git a/src/NER/TransformerBased/ELECTRANER.cs b/src/NER/TransformerBased/ELECTRANER.cs
index b33469d32b..b7b22f7546 100644
--- a/src/NER/TransformerBased/ELECTRANER.cs
+++ b/src/NER/TransformerBased/ELECTRANER.cs
@@ -90,13 +90,4 @@ public ELECTRANER(
             "ELECTRA-NER", "Clark et al., ICLR 2020", optimizer)
     {
     }
-
-    /// <inheritdoc />
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var optionsCopy = new TransformerNEROptions(NEROptions);
-        if (!UseNativeMode && optionsCopy.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            return new ELECTRANER<T>(Architecture, p, optionsCopy);
-        return new ELECTRANER<T>(Architecture, optionsCopy);
-    }
 }
diff --git a/src/NER/TransformerBased/FinBERTNER.cs b/src/NER/TransformerBased/FinBERTNER.cs
index a78fdc7863..1911476dac 100644
--- a/src/NER/TransformerBased/FinBERTNER.cs
+++ b/src/NER/TransformerBased/FinBERTNER.cs
@@ -96,13 +96,4 @@ public FinBERTNER(
             "FinBERT-NER", "Yang et al., IJCAI 2020", optimizer)
     {
     }
-
-    /// <inheritdoc />
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var optionsCopy = new TransformerNEROptions(NEROptions);
-        if (!UseNativeMode && optionsCopy.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            return new FinBERTNER<T>(Architecture, p, optionsCopy);
-        return new FinBERTNER<T>(Architecture, optionsCopy);
-    }
 }
diff --git a/src/NER/TransformerBased/InstructionNER.cs b/src/NER/TransformerBased/InstructionNER.cs
index 3f7d5b7614..b84fc49ace 100644
--- a/src/NER/TransformerBased/InstructionNER.cs
+++ b/src/NER/TransformerBased/InstructionNER.cs
@@ -103,13 +103,4 @@ public InstructionNER(
             "InstructionNER", "Wang et al., ACL 2022", optimizer)
     {
     }
-
-    /// <inheritdoc />
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var optionsCopy = new TransformerNEROptions(NEROptions);
-        if (!UseNativeMode && optionsCopy.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            return new InstructionNER<T>(Architecture, p, optionsCopy);
-        return new InstructionNER<T>(Architecture, optionsCopy);
-    }
 }
diff --git a/src/NER/TransformerBased/LegalBERTNER.cs b/src/NER/TransformerBased/LegalBERTNER.cs
index e86515dc30..a1b0d1d254 100644
--- a/src/NER/TransformerBased/LegalBERTNER.cs
+++ b/src/NER/TransformerBased/LegalBERTNER.cs
@@ -94,13 +94,4 @@ public LegalBERTNER(
             "Legal-BERT-NER", "Chalkidis et al., EMNLP 2020 Findings", optimizer)
     {
     }
-
-    /// <inheritdoc />
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var optionsCopy = new TransformerNEROptions(NEROptions);
-        if (!UseNativeMode && optionsCopy.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            return new LegalBERTNER<T>(Architecture, p, optionsCopy);
-        return new LegalBERTNER<T>(Architecture, optionsCopy);
-    }
 }
diff --git a/src/NER/TransformerBased/ONNXNER.cs b/src/NER/TransformerBased/ONNXNER.cs
index 434bf706df..c2911671e0 100644
--- a/src/NER/TransformerBased/ONNXNER.cs
+++ b/src/NER/TransformerBased/ONNXNER.cs
@@ -102,13 +102,4 @@ public ONNXNER(
             "ONNX-NER", "ONNX Runtime", optimizer)
     {
     }
-
-    /// <inheritdoc />
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var optionsCopy = new TransformerNEROptions(NEROptions);
-        if (!UseNativeMode && optionsCopy.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            return new ONNXNER<T>(Architecture, p, optionsCopy);
-        return new ONNXNER<T>(Architecture, optionsCopy);
-    }
 }
diff --git a/src/NER/TransformerBased/PromptNER.cs b/src/NER/TransformerBased/PromptNER.cs
index 700581c072..82ae0b9486 100644
--- a/src/NER/TransformerBased/PromptNER.cs
+++ b/src/NER/TransformerBased/PromptNER.cs
@@ -113,17 +113,6 @@ private PromptNER(
         _ = resolvedOptions;
     }
 
-    /// <inheritdoc />
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var optionsCopy = NEROptions is PromptNEROptions promptOptions
-            ? new PromptNEROptions(promptOptions)
-            : new TransformerNEROptions(NEROptions);
-        if (!UseNativeMode && optionsCopy.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            return new PromptNER<T>(Architecture, p, optionsCopy);
-        return new PromptNER<T>(Architecture, optionsCopy);
-    }
-
     private static IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>> CreatePaperOptimizer(
         TransformerNEROptions options)
     {
diff --git a/src/NER/TransformerBased/PubMedBERTNER.cs b/src/NER/TransformerBased/PubMedBERTNER.cs
index 51c1707e48..ad948a3ed1 100644
--- a/src/NER/TransformerBased/PubMedBERTNER.cs
+++ b/src/NER/TransformerBased/PubMedBERTNER.cs
@@ -104,13 +104,4 @@ public PubMedBERTNER(
             "PubMedBERT-NER", "Gu et al., ACL 2021", optimizer)
     {
     }
-
-    /// <inheritdoc />
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var optionsCopy = new TransformerNEROptions(NEROptions);
-        if (!UseNativeMode && optionsCopy.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            return new PubMedBERTNER<T>(Architecture, p, optionsCopy);
-        return new PubMedBERTNER<T>(Architecture, optionsCopy);
-    }
 }
diff --git a/src/NER/TransformerBased/RELNER.cs b/src/NER/TransformerBased/RELNER.cs
index f5da91295e..b788ccbc2e 100644
--- a/src/NER/TransformerBased/RELNER.cs
+++ b/src/NER/TransformerBased/RELNER.cs
@@ -112,13 +112,4 @@ public RELNER(
             "REL", "van Hulst et al., SIGIR 2020", optimizer)
     {
     }
-
-    /// <inheritdoc />
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var optionsCopy = new TransformerNEROptions(NEROptions);
-        if (!UseNativeMode && optionsCopy.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            return new RELNER<T>(Architecture, p, optionsCopy);
-        return new RELNER<T>(Architecture, optionsCopy);
-    }
 }
diff --git a/src/NER/TransformerBased/RoBERTaNER.cs b/src/NER/TransformerBased/RoBERTaNER.cs
index 4ce207285d..c71b8d0642 100644
--- a/src/NER/TransformerBased/RoBERTaNER.cs
+++ b/src/NER/TransformerBased/RoBERTaNER.cs
@@ -78,13 +78,4 @@ public RoBERTaNER(
             "RoBERTa-NER", "Liu et al., 2019", optimizer)
     {
     }
-
-    /// <inheritdoc />
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var optionsCopy = new TransformerNEROptions(NEROptions);
-        if (!UseNativeMode && optionsCopy.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            return new RoBERTaNER<T>(Architecture, p, optionsCopy);
-        return new RoBERTaNER<T>(Architecture, optionsCopy);
-    }
 }
diff --git a/src/NER/TransformerBased/SECBertNER.cs b/src/NER/TransformerBased/SECBertNER.cs
index adace1034c..6c09b5efc9 100644
--- a/src/NER/TransformerBased/SECBertNER.cs
+++ b/src/NER/TransformerBased/SECBertNER.cs
@@ -92,13 +92,4 @@ public SECBertNER(
             "SEC-BERT-NER", "Loukas et al., EMNLP 2022", optimizer)
     {
     }
-
-    /// <inheritdoc />
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var optionsCopy = new TransformerNEROptions(NEROptions);
-        if (!UseNativeMode && optionsCopy.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            return new SECBertNER<T>(Architecture, p, optionsCopy);
-        return new SECBertNER<T>(Architecture, optionsCopy);
-    }
 }
diff --git a/src/NER/TransformerBased/SciBERTNER.cs b/src/NER/TransformerBased/SciBERTNER.cs
index b421f8b92d..1db55671cc 100644
--- a/src/NER/TransformerBased/SciBERTNER.cs
+++ b/src/NER/TransformerBased/SciBERTNER.cs
@@ -88,13 +88,4 @@ public SciBERTNER(
             "SciBERT-NER", "Beltagy et al., EMNLP 2019", optimizer)
     {
     }
-
-    /// <inheritdoc />
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var optionsCopy = new TransformerNEROptions(NEROptions);
-        if (!UseNativeMode && optionsCopy.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            return new SciBERTNER<T>(Architecture, p, optionsCopy);
-        return new SciBERTNER<T>(Architecture, optionsCopy);
-    }
 }
diff --git a/src/NER/TransformerBased/SpanBERTNER.cs b/src/NER/TransformerBased/SpanBERTNER.cs
index 2ccae665b6..9e443ea823 100644
--- a/src/NER/TransformerBased/SpanBERTNER.cs
+++ b/src/NER/TransformerBased/SpanBERTNER.cs
@@ -88,13 +88,4 @@ public SpanBERTNER(
             "SpanBERT-NER", "Joshi et al., TACL 2020", optimizer)
     {
     }
-
-    /// <inheritdoc />
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var optionsCopy = new TransformerNEROptions(NEROptions);
-        if (!UseNativeMode && optionsCopy.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            return new SpanBERTNER<T>(Architecture, p, optionsCopy);
-        return new SpanBERTNER<T>(Architecture, optionsCopy);
-    }
 }
diff --git a/src/NER/TransformerBased/TemplateNER.cs b/src/NER/TransformerBased/TemplateNER.cs
index 8d25808c12..76247beaab 100644
--- a/src/NER/TransformerBased/TemplateNER.cs
+++ b/src/NER/TransformerBased/TemplateNER.cs
@@ -99,15 +99,6 @@ public TemplateNER(
     {
     }
 
-    /// <inheritdoc />
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var optionsCopy = new TransformerNEROptions(NEROptions);
-        if (!UseNativeMode && optionsCopy.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            return new TemplateNER<T>(Architecture, p, optionsCopy);
-        return new TemplateNER<T>(Architecture, optionsCopy);
-    }
-
     /// <summary>
     /// Creates the training defaults used by the Template-NER reference implementation.
     /// </summary>
diff --git a/src/NER/TransformerBased/TinyBERTNER.cs b/src/NER/TransformerBased/TinyBERTNER.cs
index 72b9e9a7bb..2c6f80b0ac 100644
--- a/src/NER/TransformerBased/TinyBERTNER.cs
+++ b/src/NER/TransformerBased/TinyBERTNER.cs
@@ -94,15 +94,6 @@ public TinyBERTNER(
     {
     }
 
-    /// <inheritdoc />
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var optionsCopy = new TransformerNEROptions(NEROptions);
-        if (!UseNativeMode && optionsCopy.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            return new TinyBERTNER<T>(Architecture, p, optionsCopy);
-        return new TinyBERTNER<T>(Architecture, optionsCopy);
-    }
-
     private static TransformerNEROptions CreateTinyBERTDefaults()
     {
         return new TransformerNEROptions
diff --git a/src/NER/TransformerBased/TransformerNERBase.cs b/src/NER/TransformerBased/TransformerNERBase.cs
index 8ec2335677..3ab04acce0 100644
--- a/src/NER/TransformerBased/TransformerNERBase.cs
+++ b/src/NER/TransformerBased/TransformerNERBase.cs
@@ -46,7 +46,7 @@ namespace AiDotNet.NER.TransformerBased;
 /// slightly differently, leading to different strengths.
 /// </para>
 /// </remarks>
-public abstract class TransformerNERBase<T> : SequenceLabeling.SequenceLabelingNERBase<T>, INERModel<T>
+public abstract partial class TransformerNERBase<T> : SequenceLabeling.SequenceLabelingNERBase<T>, INERModel<T>
 {
     #region Fields
 
@@ -414,71 +414,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc />
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode);
-        w.Write(_options.ModelPath ?? string.Empty);
-        w.Write((int)_options.Variant);
-        w.Write(_options.HiddenDimension);
-        w.Write(_options.NumAttentionHeads);
-        w.Write(_options.NumTransformerLayers);
-        w.Write(_options.IntermediateDimension);
-        w.Write(_options.NumLabels);
-        w.Write(_options.MaxSequenceLength);
-        w.Write(_options.UseCRF);
-        w.Write(_options.DropoutRate);
-        w.Write(_options.LearningRate);
-        w.Write(_options.LabelNames.Length);
-        foreach (var label in _options.LabelNames)
-            w.Write(label);
-        w.Write(_options.WarmupSteps);
-        w.Write(_options.WarmupInitialLearningRate);
-        w.Write(_options.TotalTrainingSteps);
-        w.Write(_options.EndLearningRate);
-    }
 
-    /// <inheritdoc />
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean();
-        string mp = r.ReadString();
-        if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.Variant = (NERModelVariant)r.ReadInt32();
-        _options.HiddenDimension = r.ReadInt32();
-        _options.NumAttentionHeads = r.ReadInt32();
-        _options.NumTransformerLayers = r.ReadInt32();
-        _options.IntermediateDimension = r.ReadInt32();
-        _options.NumLabels = r.ReadInt32();
-        _options.MaxSequenceLength = r.ReadInt32();
-        _options.UseCRF = r.ReadBoolean();
-        _options.DropoutRate = r.ReadDouble();
-        _options.LearningRate = r.ReadDouble();
-        int labelCount = r.ReadInt32();
-        _options.LabelNames = new string[labelCount];
-        for (int i = 0; i < labelCount; i++)
-            _options.LabelNames[i] = r.ReadString();
-
-        // These scheduler fields were appended to preserve compatibility with models serialized
-        // before transformer-NER schedulers were configurable.
-        if (r.BaseStream.Position < r.BaseStream.Length)
-        {
-            _options.WarmupSteps = r.ReadInt32();
-            _options.WarmupInitialLearningRate = r.ReadDouble();
-            _options.TotalTrainingSteps = r.ReadInt32();
-            _options.EndLearningRate = r.ReadDouble();
-        }
 
-        ApplyOptionsToBase();
+    /// <inheritdoc />
 
-        // Native-mode layers (with their trained weights) are already reconstructed by
-        // the base DeserializeInternalUnchecked before this override runs, so do NOT
-        // clear + re-initialize them here — that would discard the deserialized weights
-        // and leave the model randomly initialized. Only an ONNX session needs rebuilding.
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-        {
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-        }
-    }
 
     #endregion
 
diff --git a/src/NER/TransformerBased/XLMRoBERTaNER.cs b/src/NER/TransformerBased/XLMRoBERTaNER.cs
index 694ede4e5a..0a4e717fa2 100644
--- a/src/NER/TransformerBased/XLMRoBERTaNER.cs
+++ b/src/NER/TransformerBased/XLMRoBERTaNER.cs
@@ -85,13 +85,4 @@ public XLMRoBERTaNER(
             "XLM-RoBERTa-NER", "Conneau et al., ACL 2020", optimizer)
     {
     }
-
-    /// <inheritdoc />
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var optionsCopy = new TransformerNEROptions(NEROptions);
-        if (!UseNativeMode && optionsCopy.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            return new XLMRoBERTaNER<T>(Architecture, p, optionsCopy);
-        return new XLMRoBERTaNER<T>(Architecture, optionsCopy);
-    }
 }
diff --git a/src/NestedLearning/AssociativeMemory.cs b/src/NestedLearning/AssociativeMemory.cs
index 67065d31e5..cb46addf5f 100644
--- a/src/NestedLearning/AssociativeMemory.cs
+++ b/src/NestedLearning/AssociativeMemory.cs
@@ -1,5 +1,6 @@
 
 using AiDotNet.Interfaces;
+using AiDotNet.Attributes;
 using AiDotNet.LinearAlgebra;
 
 namespace AiDotNet.NestedLearning;
@@ -16,6 +17,7 @@ public class AssociativeMemory<T> : NestedLearningBase<T>, IAssociativeMemory<T>
     private readonly int _dimension;
     private readonly double _inverseTemperature;
     private readonly List<(Vector<T> Input, Vector<T> Target)> _memories;
+    [Scratch]
     private Matrix<T>? _cachedAssociationMatrix;
 
     /// <summary>Cosine similarity threshold for treating two keys as duplicates in Update.</summary>
@@ -23,6 +25,7 @@ public class AssociativeMemory<T> : NestedLearningBase<T>, IAssociativeMemory<T>
 
     /// <summary>Small epsilon to prevent division by zero in cosine similarity.</summary>
     private const double CosineEpsilon = 1e-10;
+    [Scratch]
     private Tensor<T>? _cachedValuesTensor;
 
     public AssociativeMemory(int dimension, int capacity = 1000, double inverseTemperature = 8.0)
diff --git a/src/NeuralNetworks/ACGAN.cs b/src/NeuralNetworks/ACGAN.cs
index 2d69bd6c23..1f2a90854a 100644
--- a/src/NeuralNetworks/ACGAN.cs
+++ b/src/NeuralNetworks/ACGAN.cs
@@ -771,39 +771,7 @@ public override ModelMetadata<T> GetModelMetadata()
     /// </para>
     /// </remarks>
     /// <param name="writer">The binary writer to serialize data to.</param>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_numClasses);
-
-        // Serialize loss histories
-        writer.Write(_generatorLosses.Count);
-        foreach (var loss in _generatorLosses)
-            writer.Write(NumOps.ToDouble(loss));
-
-        writer.Write(_discriminatorLosses.Count);
-        foreach (var loss in _discriminatorLosses)
-            writer.Write(NumOps.ToDouble(loss));
-
-        // Serialize Generator network
-        var generatorBytes = Generator.Serialize();
-        writer.Write(generatorBytes.Length);
-        writer.Write(generatorBytes);
-
-        // Serialize Discriminator network
-        var discriminatorBytes = Discriminator.Serialize();
-        writer.Write(discriminatorBytes.Length);
-        writer.Write(discriminatorBytes);
-
-        // Serialize optimizer states for training resumption
-        // This preserves momentum vectors, adaptive learning rates, and timesteps
-        var generatorOptimizerBytes = _generatorOptimizer.Serialize();
-        writer.Write(generatorOptimizerBytes.Length);
-        writer.Write(generatorOptimizerBytes);
-
-        var discriminatorOptimizerBytes = _discriminatorOptimizer.Serialize();
-        writer.Write(discriminatorOptimizerBytes.Length);
-        writer.Write(discriminatorOptimizerBytes);
-    }
+
 
     /// <summary>
     /// Deserializes AC-GAN-specific data including networks and optimizer states.
@@ -831,53 +799,7 @@ protected override void SerializeNetworkSpecificData(BinaryWriter writer)
     /// </para>
     /// </remarks>
     /// <param name="reader">The binary reader to deserialize data from.</param>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _numClasses = reader.ReadInt32();
-
-        // Deserialize loss histories
-        _generatorLosses.Clear();
-        int genLossCount = reader.ReadInt32();
-        for (int i = 0; i < genLossCount; i++)
-            _generatorLosses.Add(NumOps.FromDouble(reader.ReadDouble()));
-
-        _discriminatorLosses.Clear();
-        int discLossCount = reader.ReadInt32();
-        for (int i = 0; i < discLossCount; i++)
-            _discriminatorLosses.Add(NumOps.FromDouble(reader.ReadDouble()));
-
-        // Deserialize Generator network
-        int generatorDataLength = reader.ReadInt32();
-        byte[] generatorData = reader.ReadBytes(generatorDataLength);
-        Generator.Deserialize(generatorData);
-
-        // Deserialize Discriminator network
-        int discriminatorDataLength = reader.ReadInt32();
-        byte[] discriminatorData = reader.ReadBytes(discriminatorDataLength);
-        Discriminator.Deserialize(discriminatorData);
-
-        // Deserialize optimizer states for training resumption
-        // This restores momentum vectors, adaptive learning rates, and timesteps
-        int generatorOptimizerDataLength = reader.ReadInt32();
-        byte[] generatorOptimizerData = reader.ReadBytes(generatorOptimizerDataLength);
-        _generatorOptimizer.Deserialize(generatorOptimizerData);
-
-        int discriminatorOptimizerDataLength = reader.ReadInt32();
-        byte[] discriminatorOptimizerData = reader.ReadBytes(discriminatorOptimizerDataLength);
-        _discriminatorOptimizer.Deserialize(discriminatorOptimizerData);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new ACGAN<T>(
-            Generator.Architecture,
-            Discriminator.Architecture,
-            _numClasses,
-            Architecture.InputType,
-            null, // Use default optimizer
-            null, // Use default optimizer
-            _lossFunction);
-    }
 
     // UpdateParameters split the vector between Generator and Discriminator; GetExtraTrainableLayers
     // yields the same two in the same order, so the base reproduces the split. Removed under AIDN082.
diff --git a/src/NeuralNetworks/AttentionNetwork.cs b/src/NeuralNetworks/AttentionNetwork.cs
index d178003b81..02ee50cbf4 100644
--- a/src/NeuralNetworks/AttentionNetwork.cs
+++ b/src/NeuralNetworks/AttentionNetwork.cs
@@ -54,7 +54,7 @@ namespace AiDotNet.NeuralNetworks;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Attention Is All You Need", "https://arxiv.org/abs/1706.03762", Year = 2017, Authors = "Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N. Gomez, Lukasz Kaiser, Illia Polosukhin")]
-public class AttentionNetwork<T> : SequenceModelLayoutBase<T>, IAuxiliaryLossLayer<T>
+public partial class AttentionNetwork<T> : SequenceModelLayoutBase<T>, IAuxiliaryLossLayer<T>
 {
     private readonly AttentionNetworkOptions _options;
 
@@ -450,57 +450,9 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    /// <summary>
-    /// Serializes network-specific data for the Attention Network.
-    /// </summary>
-    /// <param name="writer">The BinaryWriter to write the data to.</param>
-    /// <remarks>
-    /// <para>
-    /// This method writes the specific configuration and state of the Attention Network to a binary stream.
-    /// It includes network-specific parameters that are essential for later reconstruction of the network.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method saves the unique settings of your Attention Network.
-    /// 
-    /// It writes:
-    /// - The sequence length and embedding size
-    /// - The configuration of each layer
-    /// - Any other Attention Network-specific parameters
-    /// 
-    /// Saving these details allows you to recreate the exact same network structure later.
-    /// It's like writing down a detailed recipe so you can make the same dish again in the future.
-    /// </para>
-    /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_sequenceLength);
-        writer.Write(_embeddingSize);
-    }
 
-    /// <summary>
-    /// Deserializes network-specific data for the Attention Network.
-    /// </summary>
-    /// <param name="reader">The BinaryReader to read the data from.</param>
-    /// <remarks>
-    /// <para>
-    /// This method reads the specific configuration and state of the Attention Network from a binary stream.
-    /// It reconstructs the network-specific parameters to match the state of the network when it was serialized.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method loads the unique settings of your Attention Network.
-    /// 
-    /// It reads:
-    /// - The sequence length and embedding size
-    /// - The configuration of each layer
-    /// - Any other Attention Network-specific parameters
-    /// 
-    /// Loading these details allows you to recreate the exact same network structure that was previously saved.
-    /// It's like following a detailed recipe to recreate a dish exactly as it was made before.
-    /// </para>
-    /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _sequenceLength = reader.ReadInt32();
-        _embeddingSize = reader.ReadInt32();
-    }
+
+
 
     /// <summary>
     /// Computes the auxiliary loss for the AttentionNetwork, which aggregates attention entropy losses from all attention layers.
@@ -630,30 +582,4 @@ public Dictionary<string, string> GetDiagnostics()
 
         return diagnostics;
     }
-
-    /// <summary>
-    /// Creates a new instance of the attention network model.
-    /// </summary>
-    /// <returns>A new instance of the attention network model with the same configuration.</returns>
-    /// <remarks>
-    /// <para>
-    /// This method creates a new instance of the attention network model with the same configuration as the current instance.
-    /// It is used internally during serialization/deserialization processes to create a fresh instance that can be populated
-    /// with the serialized data.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method creates a copy of the model structure without copying the learned data.
-    /// 
-    /// Think of it like creating a blueprint of the network's architecture:
-    /// - It includes the same structure (layers, connections, sizes)
-    /// - It preserves the configuration settings (sequence length, embedding size)
-    /// - It doesn't copy over any of the learned knowledge (weights, biases)
-    /// 
-    /// This is particularly useful when you want to save or load models, as it provides the framework
-    /// that learned parameters can be loaded into.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new AttentionNetwork<T>(Architecture, _sequenceLength, _embeddingSize, _lossFunction);
-    }
 }
diff --git a/src/NeuralNetworks/AudioVisualCorrespondenceNetwork.cs b/src/NeuralNetworks/AudioVisualCorrespondenceNetwork.cs
index d3caacd142..2f4d39115c 100644
--- a/src/NeuralNetworks/AudioVisualCorrespondenceNetwork.cs
+++ b/src/NeuralNetworks/AudioVisualCorrespondenceNetwork.cs
@@ -96,12 +96,14 @@ public partial class AudioVisualCorrespondenceNetwork<T> : MultimodalModelLayout
     private List<ILayer<T>>? _audioEncoderLayers;
     private ILayer<T>? _audioInputProjection;
     private ILayer<T>? _audioOutputProjection;
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T>? _audioPositionalEmbedding;
 
     // Visual encoder components
     private List<ILayer<T>>? _visualEncoderLayers;
     private ILayer<T>? _visualInputProjection;
     private ILayer<T>? _visualOutputProjection;
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T>? _visualPositionalEmbedding;
 
     // Cross-modal attention for localization
@@ -1071,40 +1073,6 @@ public override void Train(Tensor<T> input, Tensor<T> expectedOutput)
             SetTrainingMode(false);
         }
     }
-
-    // UpdateParameters was overridden here to validate against ParameterCount and walk
-    // Layers by hand. Both are the base's job, and keeping it would have broken as soon as
-    // the tables below joined the count: it walked only Layers, so it would have been short
-    // by exactly their size.
-    /// <summary>
-    /// Declares the audio and visual positional embedding tables, which live outside <see cref="NeuralNetworkBase{T}.Layers"/>.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// These were in NEITHER surface. The base walks Layers, these are not in Layers, and
-    /// nothing declared them -- so they were never counted, never handed out, never restored,
-    /// and never trained through a flat-vector optimizer. Declaring them adds to the parameter
-    /// count, deliberately: the old number was not a smaller-but-correct total, it omitted real
-    /// weights.
-    /// </para>
-    /// <para>
-    /// A hook rather than a [TrainableParameter] attribute because TrainableParameterGenerator
-    /// only processes LayerBase subclasses (see its ExtendsLayerBase guard) -- the attribute
-    /// does nothing on a model. For a model, declaring through this hook IS the mechanism.
-    /// </para>
-    /// </remarks>
-    protected override IEnumerable<Tensor<T>> GetExtraTrainableTensors()
-    {
-        if (_audioPositionalEmbedding is not null)
-        {
-            yield return _audioPositionalEmbedding;
-        }
-
-        if (_visualPositionalEmbedding is not null)
-        {
-            yield return _visualPositionalEmbedding;
-        }
-    }
     /// <inheritdoc/>
     public override ModelMetadata<T> GetModelMetadata()
     {
@@ -1125,75 +1093,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_embeddingDimension);
-        writer.Write(_audioSampleRate);
-        writer.Write(_videoFrameRate);
-        writer.Write(_numEncoderLayers);
-    }
 
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        // Read serialized values
-        var embDim = reader.ReadInt32();
-        var sampleRate = reader.ReadInt32();
-        var frameRate = reader.ReadDouble();
-        var numLayers = reader.ReadInt32();
-
-        // Validate that loaded values match current instance configuration
-        if (embDim != _embeddingDimension)
-        {
-            throw new InvalidOperationException(
-                $"Loaded embedding dimension ({embDim}) doesn't match current ({_embeddingDimension}).");
-        }
-
-        if (sampleRate != _audioSampleRate)
-        {
-            throw new InvalidOperationException(
-                $"Loaded audio sample rate ({sampleRate}) doesn't match current ({_audioSampleRate}).");
-        }
-
-        if (Math.Abs(frameRate - _videoFrameRate) > 0.001)
-        {
-            throw new InvalidOperationException(
-                $"Loaded video frame rate ({frameRate}) doesn't match current ({_videoFrameRate}).");
-        }
-
-        if (numLayers != _numEncoderLayers)
-        {
-            throw new InvalidOperationException(
-                $"Loaded encoder layers ({numLayers}) doesn't match current ({_numEncoderLayers}).");
-        }
-    }
 
     /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new AudioVisualCorrespondenceNetwork<T>(
-            Architecture,
-            _embeddingDimension,
-            _audioSampleRate,
-            _videoFrameRate,
-            _numEncoderLayers);
-    }
 
-    /// <inheritdoc/>
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy()
-    {
-        // Create a new instance without passing optimizer/loss to get fresh instances
-        // Passing the same optimizer would share mutable state (momentum, etc.)
-        var copy = new AudioVisualCorrespondenceNetwork<T>(
-            Architecture,
-            _embeddingDimension,
-            _audioSampleRate,
-            _videoFrameRate,
-            _numEncoderLayers);
-
-        copy.SetParameters(GetParameters());
-        return copy;
-    }
 
     #endregion
 }
diff --git a/src/NeuralNetworks/AudioVisualEventLocalizationNetwork.cs b/src/NeuralNetworks/AudioVisualEventLocalizationNetwork.cs
index c0bf9c0c3a..416ffc6a53 100644
--- a/src/NeuralNetworks/AudioVisualEventLocalizationNetwork.cs
+++ b/src/NeuralNetworks/AudioVisualEventLocalizationNetwork.cs
@@ -1601,124 +1601,5 @@ public override ModelMetadata<T> GetModelMetadata()
         return metadata;
     }
 
-    /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_embeddingDimension);
-        writer.Write(_temporalResolution);
-        writer.Write(_numEncoderLayers);
-        // The audio-embedding widths are part of the ARCHITECTURE, so they have to persist. Without
-        // them a restored model rebuilds VGGish at its paper defaults whatever the source used, and
-        // the parameter vector is then applied to a differently shaped network -- the restored model
-        // predicts differently from the one that was saved.
-        writer.Write(_audioEmbeddingFullyConnectedWidth);
-        writer.Write(_audioEmbeddingSize);
-        writer.Write(_supportedCategories.Count);
-        foreach (var category in _supportedCategories)
-        {
-            writer.Write(category);
-        }
-    }
-
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        // Read serialized values
-        int embDim = reader.ReadInt32();
-        double tempRes = reader.ReadDouble();
-        int numLayers = reader.ReadInt32();
-        int audioEmbedWidth = reader.ReadInt32();
-        int audioEmbedSize = reader.ReadInt32();
-        int categoryCount = reader.ReadInt32();
-        var categories = new List<string>();
-        for (int i = 0; i < categoryCount; i++)
-        {
-            categories.Add(reader.ReadString());
-        }
-
-        // Validate that loaded values match current instance configuration
-        if (audioEmbedWidth != _audioEmbeddingFullyConnectedWidth || audioEmbedSize != _audioEmbeddingSize)
-        {
-            throw new InvalidOperationException(
-                $"Loaded audio-embedding shape ({audioEmbedWidth}x{audioEmbedSize}) doesn't match current " +
-                $"({_audioEmbeddingFullyConnectedWidth}x{_audioEmbeddingSize}). Restoring parameters into a " +
-                "differently shaped VGGish embedding would silently produce a model that predicts " +
-                "differently from the one that was saved.");
-        }
-
-        if (embDim != _embeddingDimension)
-        {
-            throw new InvalidOperationException(
-                $"Loaded embedding dimension ({embDim}) doesn't match current ({_embeddingDimension}).");
-        }
-
-        if (Math.Abs(tempRes - _temporalResolution) > 0.0001)
-        {
-            throw new InvalidOperationException(
-                $"Loaded temporal resolution ({tempRes}) doesn't match current ({_temporalResolution}).");
-        }
-
-        if (numLayers != _numEncoderLayers)
-        {
-            throw new InvalidOperationException(
-                $"Loaded encoder layers ({numLayers}) doesn't match current ({_numEncoderLayers}).");
-        }
-
-        if (categoryCount != _supportedCategories.Count)
-        {
-            throw new InvalidOperationException(
-                $"Loaded category count ({categoryCount}) doesn't match current ({_supportedCategories.Count}).");
-        }
-    }
-
-    /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        // The audio-embedding widths MUST ride along. Omitting them rebuilds VGGish at its paper
-        // defaults (FC 4096, embedding 128) while the source may hold a smaller configured variant,
-        // so the clone is a structurally different model: its predictions diverge from the original
-        // and, at paper scale, materialising it can exhaust the test host.
-        return new AudioVisualEventLocalizationNetwork<T>(
-            Architecture,
-            _embeddingDimension,
-            _temporalResolution,
-            _numEncoderLayers,
-            _supportedCategories,
-            audioEmbeddingFullyConnectedWidth: _audioEmbeddingFullyConnectedWidth,
-            audioEmbeddingSize: _audioEmbeddingSize);
-    }
-
-    /// <inheritdoc/>
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy()
-    {
-        var copy = new AudioVisualEventLocalizationNetwork<T>(
-            Architecture,
-            _embeddingDimension,
-            _temporalResolution,
-            _numEncoderLayers,
-            _supportedCategories,
-            _optimizer,
-            _lossFunction,
-            audioEmbeddingFullyConnectedWidth: _audioEmbeddingFullyConnectedWidth,
-            audioEmbeddingSize: _audioEmbeddingSize);
-
-        // Copy trained weights PER LAYER from the (materialized) source rather than via the
-        // model-level SetParameters(GetParameters()). The freshly-constructed copy's layers are lazy
-        // (ParameterCount == 0 until first forward), and the model-level SetParameters slices the flat
-        // vector by each target layer's ParameterCount — which is 0 for a lazy layer, so every slice was
-        // empty, `offset` never advanced, and NO weights were applied (the clone re-randomized on its
-        // first forward). Each source layer is materialized, so copying its parameter vector directly
-        // into the matching copy layer lets that layer self-materialize (DenseLayer/MultiHeadAttention
-        // resolve their shape from the vector length). copy.Layers[i] is the same object the cached
-        // field references (_audioInputProjection, etc.) point at, so they are materialized in place.
-        for (int i = 0; i < Layers.Count; i++)
-        {
-            var src = Layers[i];
-            if (src.ParameterCount > 0)
-                copy.Layers[i].SetParameters(src.GetParameters());
-        }
-        return copy;
-    }
-
     #endregion
 }
diff --git a/src/NeuralNetworks/Autoencoder.cs b/src/NeuralNetworks/Autoencoder.cs
index ff8e64bdb3..b0bc5e66eb 100644
--- a/src/NeuralNetworks/Autoencoder.cs
+++ b/src/NeuralNetworks/Autoencoder.cs
@@ -1,4 +1,4 @@
-global using AiDotNet.LossFunctions;
+global using AiDotNet.LossFunctions;
 using AiDotNet.Attributes;
 using AiDotNet.Enums;
 using AiDotNet.Extensions;
@@ -53,7 +53,7 @@ namespace AiDotNet.NeuralNetworks;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
     [ResearchPaper("Reducing the Dimensionality of Data with Neural Networks", "https://doi.org/10.1126/science.1127647")]
-public class Autoencoder<T> : VectorModelLayoutBase<T>, IAuxiliaryLossLayer<T>
+public partial class Autoencoder<T> : VectorModelLayoutBase<T>, IAuxiliaryLossLayer<T>
 {
     private readonly AutoencoderOptions _options;
     private readonly IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>> _optimizer;
@@ -958,13 +958,7 @@ public override ModelMetadata<T> GetModelMetadata()
     /// It's like writing down a detailed recipe so you can make the same dish again in the future.
     /// </para>
     /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(EncodedSize);
-        writer.Write(Convert.ToDouble(_learningRate));
-        writer.Write(_epochs);
-        writer.Write(_batchSize);
-    }
+
 
     /// <summary>
     /// Deserializes network-specific data for the Autoencoder.
@@ -987,49 +981,5 @@ protected override void SerializeNetworkSpecificData(BinaryWriter writer)
     /// It's like following a detailed recipe to recreate a dish exactly as it was made before.
     /// </para>
     /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        EncodedSize = reader.ReadInt32();
-        _learningRate = NumOps.FromDouble(reader.ReadDouble());
-        _epochs = reader.ReadInt32();
-        _batchSize = reader.ReadInt32();
-    }
 
-    /// <summary>
-    /// Creates a new instance of the autoencoder model.
-    /// </summary>
-    /// <returns>A new instance of the autoencoder model with the same configuration.</returns>
-    /// <remarks>
-    /// <para>
-    /// This method creates a new instance of the autoencoder model with the same configuration as the current instance.
-    /// It is used internally during serialization/deserialization processes to create a fresh instance that can be populated
-    /// with the serialized data. The new instance will have the same architecture, learning rate, epochs, batch size,
-    /// and loss function as the original.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method creates a copy of the model structure without copying the learned data.
-    /// 
-    /// Think of it like creating a blueprint of the autoencoder:
-    /// - It copies the same overall design (how many layers, how they're arranged)
-    /// - It preserves settings like learning rate and batch size
-    /// - It keeps the same encoded size (compression level)
-    /// - But it doesn't copy any of the learned knowledge yet
-    /// 
-    /// This is primarily used when saving or loading models, creating a framework that the saved parameters
-    /// can be loaded into later.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var clone = new Autoencoder<T>(
-            Architecture,
-            _epochs,
-            _batchSize,
-            lossFunction: _lossFunction
-        );
-        // Carry sparse-training configuration into the new instance
-        clone.UseAuxiliaryLoss = UseAuxiliaryLoss;
-        clone.AuxiliaryLossWeight = AuxiliaryLossWeight;
-        clone._sparsityParameter = _sparsityParameter;
-        return clone;
-    }
 }
diff --git a/src/NeuralNetworks/BGE.cs b/src/NeuralNetworks/BGE.cs
index 484f5394d7..44d673cab3 100644
--- a/src/NeuralNetworks/BGE.cs
+++ b/src/NeuralNetworks/BGE.cs
@@ -52,7 +52,7 @@ namespace AiDotNet.NeuralNetworks
     [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
     [ResearchPaper(// Title corrected to the published form; the arXiv id was already right.
     "C-Pack: Packed Resources For General Chinese Embeddings", "https://arxiv.org/abs/2309.07597", Year = 2023, Authors = "Shitao Xiao, Zheng Liu, Peitian Zhang, Niklas Muennighoff")]
-    public class BGE<T> : TransformerEmbeddingNetwork<T>
+    public partial class BGE<T> : TransformerEmbeddingNetwork<T>
     {
         private readonly BGEOptions _options;
 
@@ -178,24 +178,6 @@ private void InitializeLayersCore(bool useVirtualValidation)
 
         #region Methods
 
-        /// <inheritdoc/>
-        protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-        {
-            return new BGE<T>(
-                Architecture,
-                null,
-                null,
-                _vocabSize,
-                EmbeddingDimension,
-                MaxTokens,
-                _numLayers,
-                _numHeads,
-                _feedForwardDim,
-                PoolingStrategy.ClsToken,
-                LossFunction,
-                Convert.ToDouble(MaxGradNorm));
-        }
-
         /// <summary>
         /// Retrieves metadata about the BGE model.
         /// </summary>
@@ -209,24 +191,10 @@ public override ModelMetadata<T> GetModelMetadata()
         }
 
         /// <inheritdoc/>
-        protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-        {
-            base.SerializeNetworkSpecificData(writer);
-            writer.Write(_vocabSize);
-            writer.Write(_numLayers);
-            writer.Write(_numHeads);
-            writer.Write(_feedForwardDim);
-        }
+
 
         /// <inheritdoc/>
-        protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-        {
-            base.DeserializeNetworkSpecificData(reader);
-            _vocabSize = reader.ReadInt32();
-            _numLayers = reader.ReadInt32();
-            _numHeads = reader.ReadInt32();
-            _feedForwardDim = reader.ReadInt32();
-        }
+
 
         /// <inheritdoc/>
         public override Vector<T> Embed(string text)
diff --git a/src/NeuralNetworks/BigGAN.cs b/src/NeuralNetworks/BigGAN.cs
index 30c1a28ab5..6291b442c6 100644
--- a/src/NeuralNetworks/BigGAN.cs
+++ b/src/NeuralNetworks/BigGAN.cs
@@ -47,7 +47,7 @@ namespace AiDotNet.NeuralNetworks;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Large Scale GAN Training for High Fidelity Natural Image Synthesis", "https://arxiv.org/abs/1809.11096", Year = 2019, Authors = "Andrew Brock, Jeff Donahue, Karen Simonyan")]
-public class BigGAN<T> : GenerativeAdversarialNetwork<T>
+public partial class BigGAN<T> : GenerativeAdversarialNetwork<T>
 {
     private readonly BigGANOptions _options;
     private readonly int _latentSize;
@@ -186,25 +186,6 @@ public BigGAN(
     {
     }
 
-    /// <summary>
-    /// Constructs a fresh BigGAN with the same hyperparameters so Clone / DeepCopy
-    /// rebuilds both architectures from scratch. Mirrors <see cref="DCGAN{T}"/>.
-    /// </summary>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new BigGAN<T>(
-            _latentSize,
-            _numClasses,
-            _classEmbeddingDim,
-            _imageChannels,
-            _imageHeight,
-            _imageWidth,
-            _generatorChannels,
-            _discriminatorChannels,
-            lossFunction: LossFunction,
-            options: _options);
-    }
-
     /// <summary>
     /// Builds the paper-faithful generator architecture: a 1D latent vector projected
     /// by a dense layer, reshaped into a small spatial feature map, then upsampled by
diff --git a/src/NeuralNetworks/Blip2NeuralNetwork.cs b/src/NeuralNetworks/Blip2NeuralNetwork.cs
index 9cd6256b85..6599d77473 100644
--- a/src/NeuralNetworks/Blip2NeuralNetwork.cs
+++ b/src/NeuralNetworks/Blip2NeuralNetwork.cs
@@ -173,21 +173,25 @@ public partial class Blip2NeuralNetwork<T> : MultimodalModelLayoutBase<T>, IBlip
     /// <summary>
     /// Learnable query tokens for Q-Former.
     /// </summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T>? _queryTokens;
 
     /// <summary>
     /// Vision CLS token.
     /// </summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T>? _visionClsToken;
 
     /// <summary>
     /// Vision positional embeddings.
     /// </summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T>? _visionPositionalEmbeddings;
 
     /// <summary>
     /// Query positional embeddings.
     /// </summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T>? _queryPositionalEmbeddings;
 
     /// <summary>
@@ -2114,67 +2118,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_embeddingDimension);
-        writer.Write(_maxSequenceLength);
-        writer.Write(_imageSize);
-        writer.Write(_qformerHiddenDim);
-        writer.Write(_numQformerLayers);
-        writer.Write(_numHeads);
-        writer.Write(_numQueryTokens);
-        writer.Write(_patchSize);
-        writer.Write(_vocabularySize);
-        writer.Write(_visionHiddenDim);
-        writer.Write(_lmHiddenDim);
-        writer.Write((int)_languageModelBackbone);
-        writer.Write(_useNativeMode);
-    }
 
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        int embeddingDim = reader.ReadInt32();
-        int maxSeqLen = reader.ReadInt32();
-        int imageSize = reader.ReadInt32();
-        int qformerHiddenDim = reader.ReadInt32();
-        int numQformerLayers = reader.ReadInt32();
-        int numHeads = reader.ReadInt32();
-        int numQueryTokens = reader.ReadInt32();
-        int patchSize = reader.ReadInt32();
-        int vocabularySize = reader.ReadInt32();
-        int visionHiddenDim = reader.ReadInt32();
-        int lmHiddenDim = reader.ReadInt32();
-        var languageModelBackbone = (LanguageModelBackbone)reader.ReadInt32();
-        bool useNativeMode = reader.ReadBoolean();
-
-        // Note: Since fields are readonly, this just validates consistency
-        // In practice, you'd need to reconstruct the network if dimensions differ
-    }
 
     /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new Blip2NeuralNetwork<T>(
-            Architecture,
-            _imageSize,
-            3,
-            _patchSize,
-            _vocabularySize,
-            _maxSequenceLength,
-            _embeddingDimension,
-            _qformerHiddenDim,
-            _visionHiddenDim,
-            _lmHiddenDim,
-            _numQformerLayers,
-            _numQueryTokens,
-            _numHeads,
-            _numLmDecoderLayers,
-            _languageModelBackbone,
-            _tokenizer,
-            null,
-            LossFunction);
-    }
+
 
     /// <inheritdoc/>
     protected override void Dispose(bool disposing)
diff --git a/src/NeuralNetworks/BlipNeuralNetwork.cs b/src/NeuralNetworks/BlipNeuralNetwork.cs
index 8975b36d41..c08bd7e967 100644
--- a/src/NeuralNetworks/BlipNeuralNetwork.cs
+++ b/src/NeuralNetworks/BlipNeuralNetwork.cs
@@ -148,21 +148,25 @@ public partial class BlipNeuralNetwork<T> : MultimodalModelLayoutBase<T>, IBlipM
     /// <summary>
     /// Learnable CLS token for vision encoder.
     /// </summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T>? _visionClsToken;
 
     /// <summary>
     /// Learnable CLS token for text encoder.
     /// </summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T>? _textClsToken;
 
     /// <summary>
     /// Vision positional embeddings.
     /// </summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T>? _visionPositionalEmbeddings;
 
     /// <summary>
     /// Text positional embeddings.
     /// </summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T>? _textPositionalEmbeddings;
 
     /// <summary>
@@ -1536,100 +1540,9 @@ protected override Tensor<T> PredictCore(Tensor<T> input)
         });
     }
 
-    /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (_useNativeMode)
-        {
-            return new BlipNeuralNetwork<T>(
-                Architecture,
-                _imageSize,
-                3,
-                _patchSize,
-                _vocabularySize,
-                _maxSequenceLength,
-                _embeddingDimension,
-                _hiddenDim,
-                _numLayers,
-                _numDecoderLayers,
-                _numHeads,
-                _mlpDim,
-                _tokenizer,
-                null,
-                null);
-        }
-        else
-        {
-            string visionPath = _visionEncoderPath ?? string.Empty;
-            string textPath = _textEncoderPath ?? string.Empty;
-            string decoderPath = _textDecoderPath ?? string.Empty;
-
-            if (string.IsNullOrEmpty(visionPath) || string.IsNullOrEmpty(textPath) || string.IsNullOrEmpty(decoderPath))
-            {
-                throw new InvalidOperationException("ONNX model paths required for ONNX mode.");
-            }
-
-            return new BlipNeuralNetwork<T>(
-                Architecture,
-                visionPath,
-                textPath,
-                decoderPath,
-                _tokenizer,
-                _embeddingDimension,
-                _maxSequenceLength,
-                _imageSize,
-                null,
-                null);
-        }
-    }
-
     #endregion
 
     #region Parameter Management
-
-    // UpdateParameters was overridden here to validate against ParameterCount and walk
-    // Layers by hand. Both are the base's job, and keeping it would have broken as soon as
-    // the tables below joined the count: it walked only Layers, so it would have been short
-    // by exactly their size.
-    /// <summary>
-    /// Declares the vision and text CLS tokens and both positional embedding tables, which live outside <see cref="NeuralNetworkBase{T}.Layers"/>.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// These were in NEITHER surface. The base walks Layers, these are not in Layers, and
-    /// nothing declared them -- so they were never counted, never handed out, never restored,
-    /// and never trained through a flat-vector optimizer. Declaring them adds to the parameter
-    /// count, deliberately: the old number was not a smaller-but-correct total, it omitted real
-    /// weights.
-    /// </para>
-    /// <para>
-    /// A hook rather than a [TrainableParameter] attribute because TrainableParameterGenerator
-    /// only processes LayerBase subclasses (see its ExtendsLayerBase guard) -- the attribute
-    /// does nothing on a model. For a model, declaring through this hook IS the mechanism.
-    /// </para>
-    /// </remarks>
-    protected override IEnumerable<Tensor<T>> GetExtraTrainableTensors()
-    {
-        if (_visionClsToken is not null)
-        {
-            yield return _visionClsToken;
-        }
-
-        if (_textClsToken is not null)
-        {
-            yield return _textClsToken;
-        }
-
-        if (_visionPositionalEmbeddings is not null)
-        {
-            yield return _visionPositionalEmbeddings;
-        }
-
-        if (_textPositionalEmbeddings is not null)
-        {
-            yield return _textPositionalEmbeddings;
-        }
-    }
     /// <summary>
     /// Retrieves metadata about the BLIP neural network model.
     /// </summary>
@@ -1663,40 +1576,10 @@ public override ModelMetadata<T> GetModelMetadata()
     #region Serialization
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_embeddingDimension);
-        writer.Write(_maxSequenceLength);
-        writer.Write(_imageSize);
-        writer.Write(_hiddenDim);
-        writer.Write(_numLayers);
-        writer.Write(_numDecoderLayers);
-        writer.Write(_numHeads);
-        writer.Write(_mlpDim);
-        writer.Write(_patchSize);
-        writer.Write(_vocabularySize);
-        writer.Write(_useNativeMode);
-        writer.Write(_optimizer?.GetType().Name ?? "Adam");
-        writer.Write(_lossFunction?.GetType().Name ?? "Contrastive");
-    }
+
 
     /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _embeddingDimension = reader.ReadInt32();
-        _maxSequenceLength = reader.ReadInt32();
-        _imageSize = reader.ReadInt32();
-        _hiddenDim = reader.ReadInt32();
-        _numLayers = reader.ReadInt32();
-        _numDecoderLayers = reader.ReadInt32();
-        _numHeads = reader.ReadInt32();
-        _mlpDim = reader.ReadInt32();
-        _patchSize = reader.ReadInt32();
-        _vocabularySize = reader.ReadInt32();
-        _useNativeMode = reader.ReadBoolean();
-        _ = reader.ReadString(); // optimizer type
-        _ = reader.ReadString(); // loss function type
-    }
+
 
     #endregion
 
diff --git a/src/NeuralNetworks/CapsuleNetwork.cs b/src/NeuralNetworks/CapsuleNetwork.cs
index 75b60d55af..4e79c62425 100644
--- a/src/NeuralNetworks/CapsuleNetwork.cs
+++ b/src/NeuralNetworks/CapsuleNetwork.cs
@@ -1,4 +1,4 @@
-using AiDotNet.Attributes;
+using AiDotNet.Attributes;
 using AiDotNet.Enums;
 using AiDotNet.Models.Options;
 using AiDotNet.NeuralNetworks.Options;
@@ -44,7 +44,7 @@ namespace AiDotNet.NeuralNetworks;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Dynamic Routing Between Capsules", "https://arxiv.org/abs/1710.09829", Year = 2017, Authors = "Sara Sabour, Nicholas Frosst, Geoffrey E. Hinton")]
-public class CapsuleNetwork<T> : ImageClassifierModelLayoutBase<T>, IAuxiliaryLossLayer<T>
+public partial class CapsuleNetwork<T> : ImageClassifierModelLayoutBase<T>, IAuxiliaryLossLayer<T>
 {
     private readonly CapsuleNetworkOptions _options;
 
@@ -492,10 +492,7 @@ public override ModelMetadata<T> GetModelMetadata()
     /// <remarks>
     /// This method saves the loss function used by the network, allowing it to be reconstructed when the network is deserialized.
     /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        SerializationHelper<T>.SerializeInterface(writer, _lossFunction);
-    }
+
 
     /// <summary>
     /// Deserializes Capsule Network-specific data from a binary reader.
@@ -504,10 +501,7 @@ protected override void SerializeNetworkSpecificData(BinaryWriter writer)
     /// <remarks>
     /// This method loads the loss function used by the network. If deserialization fails, it defaults to using a MarginLoss.
     /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _lossFunction = DeserializationHelper.DeserializeInterface<ILossFunction<T>>(reader) ?? new MarginLoss<T>();
-    }
+
 
     /// <summary>
     /// Computes the reconstruction loss for capsule network regularization.
@@ -731,34 +725,4 @@ private int GetPredictedClass(Tensor<T> capsuleOutputs)
 
         return maxIndex;
     }
-
-    /// <summary>
-    /// Creates a new instance of the capsule network model.
-    /// </summary>
-    /// <returns>A new instance of the capsule network model with the same configuration.</returns>
-    /// <remarks>
-    /// <para>
-    /// This method creates a new instance of the capsule network model with the same configuration as the current instance.
-    /// It is used internally during serialization/deserialization processes to create a fresh instance that can be populated
-    /// with the serialized data. The new instance will have the same architecture and loss function as the original.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method creates a copy of the network structure without copying the learned data.
-    ///
-    /// Think of it like creating a blueprint of the capsule network:
-    /// - It copies the same overall design (architecture)
-    /// - It uses the same loss function to measure performance
-    /// - But it doesn't copy any of the learned values or weights
-    ///
-    /// This is primarily used when saving or loading models, creating a framework that the saved parameters
-    /// can be loaded into later. It's like creating an empty duplicate of the network's structure
-    /// that can later be filled with the knowledge from the original network.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new CapsuleNetwork<T>(
-            Architecture,
-            _lossFunction
-        );
-    }
 }
diff --git a/src/NeuralNetworks/ClipNeuralNetwork.cs b/src/NeuralNetworks/ClipNeuralNetwork.cs
index 2d5ac4306f..9f059a1d15 100644
--- a/src/NeuralNetworks/ClipNeuralNetwork.cs
+++ b/src/NeuralNetworks/ClipNeuralNetwork.cs
@@ -45,7 +45,7 @@ namespace AiDotNet.NeuralNetworks;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Learning Transferable Visual Models From Natural Language Supervision", "https://arxiv.org/abs/2103.00020", Year = 2021, Authors = "Alec Radford, Jong Wook Kim, Chris Hallacy, Aditya Ramesh, Gabriel Goh, Sandhini Agarwal, Girish Sastry, Amanda Askell, Pamela Mishkin, Jack Clark, Gretchen Krueger, Ilya Sutskever")]
-public class ClipNeuralNetwork<T> : MultimodalModelLayoutBase<T>, IMultimodalEmbedding<T>, IDisposable
+public partial class ClipNeuralNetwork<T> : MultimodalModelLayoutBase<T>, IMultimodalEmbedding<T>, IDisposable
 {
     private readonly ClipOptions _options;
 
@@ -206,44 +206,9 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_imageEncoderPath);
-        writer.Write(_textEncoderPath);
-        writer.Write(_embeddingDimension);
-        writer.Write(_maxSequenceLength);
-        writer.Write(_imageSize);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _imageEncoderPath = reader.ReadString();
-        _textEncoderPath = reader.ReadString();
-        _embeddingDimension = reader.ReadInt32();
-        _maxSequenceLength = reader.ReadInt32();
-        _imageSize = reader.ReadInt32();
-
-        // Re-initialize sessions with loaded paths
-        _imageSession.Dispose();
-        _textSession.Dispose();
-
-        var sessionOptions = new SessionOptions();
-        _imageSession = new InferenceSession(_imageEncoderPath, sessionOptions);
-        _textSession = new InferenceSession(_textEncoderPath, sessionOptions);
-    }
 
-    protected override IFullModel<T, AiDotNet.Tensors.LinearAlgebra.Tensor<T>, AiDotNet.Tensors.LinearAlgebra.Tensor<T>> CreateNewInstance()
-    {
-        return new ClipNeuralNetwork<T>(
-            Architecture,
-            _imageEncoderPath,
-            _textEncoderPath,
-            _tokenizer,
-            LossFunction,
-            _embeddingDimension,
-            _maxSequenceLength,
-            _imageSize);
-    }
+
 
     /// <inheritdoc/>
     public Vector<T> EncodeText(string text)
diff --git a/src/NeuralNetworks/ColBERT.cs b/src/NeuralNetworks/ColBERT.cs
index 34455b960e..aea42127a7 100644
--- a/src/NeuralNetworks/ColBERT.cs
+++ b/src/NeuralNetworks/ColBERT.cs
@@ -50,7 +50,7 @@ namespace AiDotNet.NeuralNetworks
     [ModelComplexity(ModelComplexity.High)]
     [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
     [ResearchPaper("ColBERT: Efficient and Effective Passage Search via Contextualized Late Interaction over BERT", "https://arxiv.org/abs/2004.12832", Year = 2020, Authors = "Omar Khattab, Matei Zaharia")]
-    public class ColBERT<T> : TransformerEmbeddingNetwork<T>
+    public partial class ColBERT<T> : TransformerEmbeddingNetwork<T>
     {
         private readonly ColBERTOptions _options;
 
@@ -269,23 +269,6 @@ public T LateInteractionScore(Matrix<T> queryEmbeddings, Matrix<T> docEmbeddings
             return totalScore;
         }
 
-        /// <inheritdoc/>
-        protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-        {
-            return new ColBERT<T>(
-                Architecture,
-                null,
-                null,
-                30522,
-                _outputDim,
-                MaxTokens,
-                12,
-                12,
-                3072,
-                LossFunction,
-                Convert.ToDouble(MaxGradNorm));
-        }
-
         /// <summary>
         /// Retrieves metadata about the ColBERT model.
         /// </summary>
@@ -299,19 +282,9 @@ public override ModelMetadata<T> GetModelMetadata()
             return metadata;
         }
 
-        /// <inheritdoc/>
-        protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-        {
-            base.SerializeNetworkSpecificData(writer);
-            writer.Write(_outputDim);
-        }
 
-        /// <inheritdoc/>
-        protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-        {
-            base.DeserializeNetworkSpecificData(reader);
-            _outputDim = reader.ReadInt32();
-        }
+
+
 
         #endregion
     }
diff --git a/src/NeuralNetworks/ConditionalGAN.cs b/src/NeuralNetworks/ConditionalGAN.cs
index d018ab8348..b68d39ecbc 100644
--- a/src/NeuralNetworks/ConditionalGAN.cs
+++ b/src/NeuralNetworks/ConditionalGAN.cs
@@ -52,7 +52,7 @@ namespace AiDotNet.NeuralNetworks;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Conditional Generative Adversarial Nets", "https://arxiv.org/abs/1411.1784", Year = 2014, Authors = "Mehdi Mirza, Simon Osindero")]
-public class ConditionalGAN<T> : GenerativeAdversarialNetwork<T>
+public partial class ConditionalGAN<T> : GenerativeAdversarialNetwork<T>
 {
     private readonly ConditionalGANOptions _options;
 
@@ -880,60 +880,7 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        base.SerializeNetworkSpecificData(writer);
-        writer.Write(_numConditionClasses);
-    }
 
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        base.DeserializeNetworkSpecificData(reader);
-        _numConditionClasses = reader.ReadInt32();
 
-        // The generator architecture is already the full [noise | condition]
-        // width. Reconstruct only the original discriminator architecture by
-        // subtracting the condition dimensions so CreateNewInstance() does not
-        // expand it a second time.
-        _originalGeneratorArchitecture = Generator.Architecture;
 
-        var discArch = Discriminator.Architecture;
-        int origInputSize = discArch.InputSize > 0
-            ? discArch.InputSize - _numConditionClasses
-            : 0;
-        int origInputDepth = (discArch.InputHeight > 0 && discArch.InputWidth > 0)
-            ? discArch.InputDepth - _numConditionClasses
-            : discArch.InputDepth;
-
-        _originalDiscriminatorArchitecture = new NeuralNetworkArchitecture<T>(
-            inputType: discArch.InputType,
-            taskType: discArch.TaskType,
-            complexity: discArch.Complexity,
-            inputSize: origInputSize,
-            inputHeight: discArch.InputHeight,
-            inputWidth: discArch.InputWidth,
-            inputDepth: origInputDepth,
-            outputSize: discArch.OutputSize,
-            layers: discArch.Layers);
-    }
-
-    /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        // Use the stored architectures to avoid double-conditioning. The
-        // generator is stored at its full [noise | condition] width, while the
-        // discriminator is stored before conditioning because its helper expands
-        // it again in the constructor.
-        return new ConditionalGAN<T>(
-            _originalGeneratorArchitecture ?? Generator.Architecture,
-            _originalDiscriminatorArchitecture ?? Discriminator.Architecture,
-            _numConditionClasses,
-            Architecture.InputType,
-            null,
-            null,
-            null,
-            _options);
-    }
 }
diff --git a/src/NeuralNetworks/ConvolutionalNeuralNetwork.cs b/src/NeuralNetworks/ConvolutionalNeuralNetwork.cs
index 3338cf1215..22c100f8d9 100644
--- a/src/NeuralNetworks/ConvolutionalNeuralNetwork.cs
+++ b/src/NeuralNetworks/ConvolutionalNeuralNetwork.cs
@@ -40,7 +40,7 @@ namespace AiDotNet.NeuralNetworks;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
     [ResearchPaper("Gradient-Based Learning Applied to Document Recognition", "https://doi.org/10.1109/5.726791")]
-public class ConvolutionalNeuralNetwork<T> : ImageClassifierModelLayoutBase<T>
+public partial class ConvolutionalNeuralNetwork<T> : ImageClassifierModelLayoutBase<T>
 {
     private readonly ConvolutionalNeuralNetworkOptions _options;
 
@@ -568,9 +568,7 @@ public override ModelMetadata<T> GetModelMetadata()
     /// the important information about the network so you can reload it later exactly as it is now.
     /// </para>
     /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-    }
+
 
     /// <summary>
     /// Deserializes convolutional neural network-specific data from a binary reader.
@@ -585,36 +583,5 @@ protected override void SerializeNetworkSpecificData(BinaryWriter writer)
     /// network exactly as it was when you saved it, including all its learned information.
     /// </para>
     /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-    }
 
-    /// <summary>
-    /// Creates a new instance of the convolutional neural network model.
-    /// </summary>
-    /// <returns>A new instance of the convolutional neural network model with the same configuration.</returns>
-    /// <remarks>
-    /// <para>
-    /// This method creates a new instance of the convolutional neural network model with the same 
-    /// configuration as the current instance. It is used internally during serialization/deserialization 
-    /// processes to create a fresh instance that can be populated with the serialized data.
-    /// </para>
-    /// <para>
-    /// <b>For Beginners:</b> This method creates a copy of the network structure without copying 
-    /// the learned data. Think of it like making a blank copy of the original network's blueprint - 
-    /// it has the same structure, same learning strategy, and same error measurement, but none of 
-    /// the knowledge that the original network has gained through training. This is primarily 
-    /// used when saving or loading models, creating an empty framework that can later be filled 
-    /// with the saved knowledge from the original network.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new ConvolutionalNeuralNetwork<T>(
-            Architecture,
-            _optimizer,
-            _lossFunction,
-            Convert.ToDouble(MaxGradNorm)
-        );
-    }
 }
diff --git a/src/NeuralNetworks/CycleGAN.cs b/src/NeuralNetworks/CycleGAN.cs
index fc1ed849d4..6ac798a3de 100644
--- a/src/NeuralNetworks/CycleGAN.cs
+++ b/src/NeuralNetworks/CycleGAN.cs
@@ -885,29 +885,7 @@ public override ModelMetadata<T> GetModelMetadata()
     /// four networks (two generators and two discriminators) to a file.
     /// </para>
     /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        // Serialize CycleGAN-specific hyperparameters
-        writer.Write(NumOps.ToDouble(_cycleConsistencyLambda));
-        writer.Write(NumOps.ToDouble(_identityLambda));
-
-        // Serialize all four networks
-        var genAtoB = GeneratorAtoB.Serialize();
-        writer.Write(genAtoB.Length);
-        writer.Write(genAtoB);
-
-        var genBtoA = GeneratorBtoA.Serialize();
-        writer.Write(genBtoA.Length);
-        writer.Write(genBtoA);
-
-        var discA = DiscriminatorA.Serialize();
-        writer.Write(discA.Length);
-        writer.Write(discA);
-
-        var discB = DiscriminatorB.Serialize();
-        writer.Write(discB.Length);
-        writer.Write(discB);
-    }
+
 
     /// <summary>
     /// Deserializes CycleGAN-specific data from a binary reader.
@@ -922,58 +900,7 @@ protected override void SerializeNetworkSpecificData(BinaryWriter writer)
     /// four networks (two generators and two discriminators) from a file.
     /// </para>
     /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        // Deserialize CycleGAN-specific hyperparameters
-        _cycleConsistencyLambda = NumOps.FromDouble(reader.ReadDouble());
-        _identityLambda = NumOps.FromDouble(reader.ReadDouble());
-
-        // Deserialize all four networks
-        int genAtoB_Length = reader.ReadInt32();
-        GeneratorAtoB.Deserialize(reader.ReadBytes(genAtoB_Length));
-
-        int genBtoA_Length = reader.ReadInt32();
-        GeneratorBtoA.Deserialize(reader.ReadBytes(genBtoA_Length));
-
-        int discA_Length = reader.ReadInt32();
-        DiscriminatorA.Deserialize(reader.ReadBytes(discA_Length));
-
-        int discB_Length = reader.ReadInt32();
-        DiscriminatorB.Deserialize(reader.ReadBytes(discB_Length));
-
-        // Reset optimizer state after loading network weights
-        ResetOptimizerState();
-    }
 
-    /// <summary>
-    /// Creates a new instance of the CycleGAN with the same configuration.
-    /// </summary>
-    /// <returns>A new CycleGAN instance with the same architecture and hyperparameters.</returns>
-    /// <remarks>
-    /// <para>
-    /// This method creates a fresh CycleGAN instance with the same network architectures
-    /// and hyperparameters. The new instance has freshly initialized optimizers.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method creates a copy of the CycleGAN structure
-    /// but with new, untrained networks and fresh optimizers.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new CycleGAN<T>(
-            GeneratorAtoB.Architecture,
-            GeneratorBtoA.Architecture,
-            DiscriminatorA.Architecture,
-            DiscriminatorB.Architecture,
-            Architecture.InputType,
-            generatorAtoBOptimizer: null,
-            generatorBtoAOptimizer: null,
-            discriminatorAOptimizer: null,
-            discriminatorBOptimizer: null,
-            _lossFunction,
-            NumOps.ToDouble(_cycleConsistencyLambda),
-            NumOps.ToDouble(_identityLambda));
-    }
 
     /// <inheritdoc />
     /// <remarks>
diff --git a/src/NeuralNetworks/DCGAN.cs b/src/NeuralNetworks/DCGAN.cs
index 0dae37b1dc..fd5cdd0b86 100644
--- a/src/NeuralNetworks/DCGAN.cs
+++ b/src/NeuralNetworks/DCGAN.cs
@@ -54,7 +54,7 @@ namespace AiDotNet.NeuralNetworks;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Unsupervised Representation Learning with Deep Convolutional Generative Adversarial Networks", "https://arxiv.org/abs/1511.06434", Year = 2016, Authors = "Alec Radford, Luke Metz, Soumith Chintala")]
-public class DCGAN<T> : GenerativeAdversarialNetwork<T>
+public partial class DCGAN<T> : GenerativeAdversarialNetwork<T>
 {
     private readonly DCGANOptions _options;
     private readonly int _latentSize;
@@ -198,36 +198,6 @@ public DCGAN(
         // regularizer can still opt in explicitly through EnableGradientPenalty().
     }
 
-    /// <summary>
-    /// Constructs a fresh DCGAN with the same paper-faithful hyperparameters
-    /// so Clone / DeepCopy produces a deep-independent network whose layer
-    /// list isn't shared with the original. The base
-    /// <see cref="GenerativeAdversarialNetwork{T}.CreateNewInstance"/> passes
-    /// the existing <c>Generator.Architecture</c> and
-    /// <c>Discriminator.Architecture</c> straight through to the GAN ctor,
-    /// which wraps them in fresh
-    /// <see cref="ConvolutionalNeuralNetwork{T}"/> shells whose
-    /// <c>InitializeLayers</c> calls <c>ValidateCustomLayers</c> against
-    /// layer instances that already had their shape state resolved by the
-    /// original network's forward pass — and that validation rejects the
-    /// resolved shape chain. Going through DCGAN's own ctor instead rebuilds
-    /// both architectures (and their layer lists) from scratch.
-    /// </summary>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        // Pass the current LossFunction through so cloning a model trained
-        // with a custom objective doesn't silently downgrade to the default.
-        return new DCGAN<T>(
-            _latentSize,
-            _imageChannels,
-            _imageHeight,
-            _imageWidth,
-            _generatorFeatureMaps,
-            _discriminatorFeatureMaps,
-            lossFunction: LossFunction,
-            options: _options);
-    }
-
     /// <summary>
     /// Creates the architecture for the DCGAN generator following the original paper's guidelines.
     /// </summary>
diff --git a/src/NeuralNetworks/DeclaredModelLayoutBases.cs b/src/NeuralNetworks/DeclaredModelLayoutBases.cs
index 9157b1e6df..15f0adae10 100644
--- a/src/NeuralNetworks/DeclaredModelLayoutBases.cs
+++ b/src/NeuralNetworks/DeclaredModelLayoutBases.cs
@@ -19,6 +19,20 @@ protected DeclaredModelLayoutBase(ILossFunction<T> lossFunction, double maxGradN
         : base(lossFunction, maxGradNorm)
     {
     }
+
+    /// <summary>
+    /// The input type this model was built for, read back from the architecture that carries it.
+    /// </summary>
+    /// <remarks>
+    /// Exists so the clone plan can source an <c>inputType</c> constructor argument. Seven models in
+    /// this family -- the GANs and the image translators -- pass that argument straight into the
+    /// architecture they construct and keep no copy of their own, so every one of them was reported
+    /// unrebuildable over a value it still holds: one level down, where the lookup cannot see it,
+    /// because a member is sourced from a type's own members and its bases, never from a member OF a
+    /// member. Deriving it in the shared base keeps the value in one place instead of adding a second
+    /// copy to each model, which could then disagree with the architecture it was built from.
+    /// </remarks>
+    private InputType _inputType => Architecture.InputType;
 }
 
 [TensorLayout(TensorAxis.Batch, TensorAxis.Features,
diff --git a/src/NeuralNetworks/DeepBeliefNetwork.cs b/src/NeuralNetworks/DeepBeliefNetwork.cs
index e1b400570e..a129a1b45a 100644
--- a/src/NeuralNetworks/DeepBeliefNetwork.cs
+++ b/src/NeuralNetworks/DeepBeliefNetwork.cs
@@ -686,113 +686,4 @@ public override ModelMetadata<T> GetModelMetadata()
             ModelData = SerializeForMetadata()
         };
     }
-
-    /// <summary>
-    /// Serializes network-specific data for the Deep Belief Network.
-    /// </summary>
-    /// <param name="writer">The BinaryWriter to write the data to.</param>
-    /// <remarks>
-    /// <para>
-    /// This method writes the specific configuration and state of the Deep Belief Network
-    /// to a binary stream. This includes training parameters and RBM layer configurations
-    /// that need to be preserved for later reconstruction of the network.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method saves the unique settings of your Deep Belief Network.
-    /// 
-    /// It writes:
-    /// - The number of RBM layers
-    /// - The configuration of each RBM layer
-    /// - Training parameters like learning rate, epochs, and batch size
-    /// 
-    /// Saving these details allows you to recreate the exact same network structure and state later.
-    /// </para>
-    /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        // Write training parameters
-        writer.Write(_epochs);
-        writer.Write(Convert.ToDouble(_learningRate));
-        writer.Write(_batchSize);
-
-        // Serialize the loss function using the helper method
-        SerializationHelper<T>.SerializeInterface(writer, _lossFunction);
-    }
-
-    /// <summary>
-    /// Deserializes network-specific data for the Deep Belief Network.
-    /// </summary>
-    /// <param name="reader">The BinaryReader to read the data from.</param>
-    /// <remarks>
-    /// <para>
-    /// This method reads the specific configuration and state of the Deep Belief Network from a binary stream.
-    /// It reconstructs the network's structure, including RBM layers and training parameters, to match
-    /// the state of the network when it was serialized.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method loads the unique settings of your Deep Belief Network.
-    /// 
-    /// It reads:
-    /// - The number of RBM layers
-    /// - The configuration of each RBM layer
-    /// - Training parameters like learning rate, epochs, and batch size
-    /// 
-    /// Loading these details allows you to recreate the exact same network structure and state that was previously saved.
-    /// </para>
-    /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        // Read training parameters
-        _epochs = reader.ReadInt32();
-        _learningRate = NumOps.FromDouble(reader.ReadDouble());
-        _batchSize = reader.ReadInt32();
-
-        // Read and set the loss function if a custom one was used
-        var lossFunction = DeserializationHelper.DeserializeInterface<ILossFunction<T>>(reader) ??
-            throw new InvalidOperationException("Failed to deserialize the loss function. The loss function cannot be null.");
-        _lossFunction = lossFunction;
-    }
-
-    /// <summary>
-    /// Creates a new instance of the deep belief network model.
-    /// </summary>
-    /// <returns>A new instance of the deep belief network model with the same configuration.</returns>
-    /// <remarks>
-    /// <para>
-    /// This method creates a new instance of the deep belief network model with the same configuration as the current instance.
-    /// It is used internally during serialization/deserialization processes to create a fresh instance that can be populated
-    /// with the serialized data. The new instance will have the same architecture, learning rate, epochs, batch size,
-    /// and loss function as the original.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method creates a copy of the network structure without copying the learned data.
-    /// 
-    /// Think of it like making a blueprint copy of the tower:
-    /// - It copies the same overall design (architecture)
-    /// - It preserves settings like learning rate and batch size
-    /// - It maintains the same RBM layer structure
-    /// - But it doesn't copy any of the learned patterns and weights
-    /// 
-    /// This is primarily used when saving or loading models, creating an empty framework that the saved parameters
-    /// can be loaded into later.
-    /// </para>
-    /// </remarks>
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy()
-    {
-        var copy = (NeuralNetworkBase<T>)CreateNewInstance();
-        var originalParams = GetParameters();
-        if (originalParams.Length > 0 && originalParams.Length == copy.GetParameters().Length)
-        {
-            copy.UpdateParameters(originalParams);
-        }
-        return copy;
-    }
-
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new DeepBeliefNetwork<T>(
-            Architecture,
-            _epochs,
-            _batchSize,
-            _optimizer,
-            _lossFunction
-        );
-    }
 }
diff --git a/src/NeuralNetworks/DeepBoltzmannMachine.cs b/src/NeuralNetworks/DeepBoltzmannMachine.cs
index cfc3229da0..074281fdd3 100644
--- a/src/NeuralNetworks/DeepBoltzmannMachine.cs
+++ b/src/NeuralNetworks/DeepBoltzmannMachine.cs
@@ -1,4 +1,4 @@
-using AiDotNet.Helpers;
+using AiDotNet.Helpers;
 using AiDotNet.Attributes;
 using AiDotNet.Enums;
 using AiDotNet.NeuralNetworks.Options;
@@ -48,7 +48,7 @@ namespace AiDotNet.NeuralNetworks;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Deep Boltzmann Machines", "https://proceedings.mlr.press/v5/salakhutdinov09a.html", Year = 2009, Authors = "Ruslan Salakhutdinov, Geoffrey Hinton")]
-public class DeepBoltzmannMachine<T> : VectorModelLayoutBase<T>
+public partial class DeepBoltzmannMachine<T> : VectorModelLayoutBase<T>
 {
     private readonly DeepBoltzmannMachineOptions _options;
     private readonly IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>> _optimizer;
@@ -910,47 +910,6 @@ public override void Train(Tensor<T> input, Tensor<T> expectedOutput)
         return (reconstructed, loss);
     }
 
-    /// <summary>
-    /// Declares the contrastive-divergence weight and bias tensors, which live outside
-    /// <see cref="NeuralNetworkBase{T}.Layers"/>.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// A DBM carries its parameters in one of two places. Trained supervised, it builds
-    /// <c>Layers</c> and the base walk finds everything. Trained by contrastive divergence it has no
-    /// layers at all and holds <c>_layerWeights</c> and <c>_layerBiases</c> directly, which is what
-    /// this declares -- interleaved weight-then-bias per level, the order the old GetParameters
-    /// concatenated and therefore the order existing checkpoints are written in.
-    /// </para>
-    /// <para>
-    /// The guard is what stops the two modes double-counting: with layers present those same
-    /// weights are already reachable through them.
-    /// </para>
-    /// <para>
-    /// This replaces three overrides that disagreed with each other about which store was
-    /// authoritative. ParameterCount and GetParameters branched on <c>Layers.Count</c>;
-    /// UpdateParameters did NOT -- it always wrote the CD store, so in supervised mode it wrote
-    /// weights nothing would read. And there was no SetParameters override at all, so the path
-    /// serialization actually calls walked only <c>Layers</c>: in CD mode that is empty, and a
-    /// restore silently discarded the entire model while the count and the vector both reported
-    /// the full size. Declaring the tensors once makes count, vector and restore read the same
-    /// store in the same order, in both modes.
-    /// </para>
-    /// </remarks>
-    protected override IEnumerable<Tensor<T>> GetExtraTrainableTensors()
-    {
-        if (Layers.Count > 0)
-        {
-            yield break;
-        }
-
-        for (int i = 0; i < _layerWeights.Count; i++)
-        {
-            yield return _layerWeights[i];
-            yield return _layerBiases[i];
-        }
-    }
-
     /// <summary>
     /// Gets metadata about the Deep Boltzmann Machine model.
     /// </summary>
@@ -995,57 +954,7 @@ public override ModelMetadata<T> GetModelMetadata()
     /// This allows us to later "unpack" the network exactly as it was, preserving all its learned knowledge.
     /// </para>
     /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        // Write the number of layers
-        writer.Write(_layerSizes.Count);
 
-        // Write layer sizes
-        foreach (var size in _layerSizes)
-        {
-            writer.Write(size);
-        }
-
-        // Write epochs
-        writer.Write(_epochs);
-
-        // Write learning rate
-        writer.Write(Convert.ToDouble(_learningRate));
-
-        // Write learning rate decay
-        writer.Write(Convert.ToDouble(_learningRateDecay));
-
-        // Write batch size
-        writer.Write(_batchSize);
-
-        // Write CD steps
-        writer.Write(_cdSteps);
-
-        // Write activation function type
-        writer.Write(_activationFunction != null ? 0 : (_vectorActivationFunction != null ? 1 : -1));
-
-        // Serialize activation function if present
-        if (_activationFunction != null)
-        {
-            SerializationHelper<T>.SerializeInterface(writer, _activationFunction);
-        }
-        else if (_vectorActivationFunction != null)
-        {
-            SerializationHelper<T>.SerializeInterface(writer, _vectorActivationFunction);
-        }
-
-        // Write layer weights
-        foreach (var weights in _layerWeights)
-        {
-            SerializationHelper<T>.SerializeTensor(writer, weights);
-        }
-
-        // Write layer biases
-        foreach (var biases in _layerBiases)
-        {
-            SerializationHelper<T>.SerializeTensor(writer, biases);
-        }
-    }
 
     /// <summary>
     /// Deserializes Deep Boltzmann Machine-specific data from a binary reader.
@@ -1069,110 +978,5 @@ protected override void SerializeNetworkSpecificData(BinaryWriter writer)
     /// This allows us to continue using the network exactly where we left off, with all its learned knowledge intact.
     /// </para>
     /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        // Read the number of layers
-        int layerCount = reader.ReadInt32();
 
-        // Read layer sizes
-        _layerSizes = new List<int>();
-        for (int i = 0; i < layerCount; i++)
-        {
-            _layerSizes.Add(reader.ReadInt32());
-        }
-
-        // Read epochs
-        _epochs = reader.ReadInt32();
-
-        // Read learning rate
-        _learningRate = NumOps.FromDouble(reader.ReadDouble());
-
-        // Read learning rate decay
-        _learningRateDecay = NumOps.FromDouble(reader.ReadDouble());
-
-        // Read batch size
-        _batchSize = reader.ReadInt32();
-
-        // Read CD steps
-        _cdSteps = reader.ReadInt32();
-
-        // Read activation function type
-        int activationType = reader.ReadInt32();
-
-        // Deserialize activation function
-        if (activationType == 0)
-        {
-            _activationFunction = DeserializationHelper.DeserializeInterface<IActivationFunction<T>>(reader);
-        }
-        else if (activationType == 1)
-        {
-            _vectorActivationFunction = DeserializationHelper.DeserializeInterface<IVectorActivationFunction<T>>(reader);
-        }
-
-        // Read layer weights
-        _layerWeights = new List<Tensor<T>>();
-        for (int i = 0; i < layerCount - 1; i++)
-        {
-            _layerWeights.Add(SerializationHelper<T>.DeserializeTensor(reader));
-        }
-
-        // Read layer biases
-        _layerBiases = new List<Tensor<T>>();
-        for (int i = 0; i < layerCount; i++)
-        {
-            _layerBiases.Add(SerializationHelper<T>.DeserializeTensor(reader));
-        }
-    }
-
-    /// <summary>
-    /// Creates a new instance of the deep boltzmann machine model.
-    /// </summary>
-    /// <returns>A new instance of the deep boltzmann machine model with the same configuration.</returns>
-    /// <remarks>
-    /// <para>
-    /// This method creates a new instance of the deep boltzmann machine model with the same configuration 
-    /// as the current instance. It is used internally during serialization/deserialization processes to 
-    /// create a fresh instance that can be populated with the serialized data. The new instance will have 
-    /// the same architecture, training parameters, and activation function type as the original.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method creates a copy of the network structure without copying the learned data.
-    /// 
-    /// Think of it like making a blueprint copy of the DBM:
-    /// - It copies the same multi-layer structure (architecture)
-    /// - It uses the same learning settings (learning rate, epochs, etc.)
-    /// - It keeps the same activation function (how neurons respond to input)
-    /// - But it doesn't copy any of the weights and biases (the learned knowledge)
-    /// 
-    /// This is primarily used when saving or loading models, creating an empty framework
-    /// that the saved parameters can be loaded into later.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        // Choose the appropriate constructor based on which activation function is used
-        if (_activationFunction != null)
-        {
-            return new DeepBoltzmannMachine<T>(
-                Architecture,
-                _epochs,
-                Convert.ToDouble(_learningRateDecay),
-                lossFunction: _lossFunction,
-                activationFunction: _activationFunction,
-                batchSize: _batchSize,
-                cdSteps: _cdSteps
-            );
-        }
-        else
-        {
-            return new DeepBoltzmannMachine<T>(
-                Architecture,
-                _epochs,
-                Convert.ToDouble(_learningRateDecay),
-                lossFunction: _lossFunction,
-                activationFunction: (IActivationFunction<T>?)null,
-                batchSize: _batchSize,
-                cdSteps: _cdSteps
-            );
-        }
-    }
 }
diff --git a/src/NeuralNetworks/DeepQNetwork.cs b/src/NeuralNetworks/DeepQNetwork.cs
index 1fbfbd03e9..ca294c9bb0 100644
--- a/src/NeuralNetworks/DeepQNetwork.cs
+++ b/src/NeuralNetworks/DeepQNetwork.cs
@@ -745,27 +745,7 @@ public override ModelMetadata<T> GetModelMetadata()
     /// This allows you to load the exact same DQN later, with all its settings intact.
     /// </para>
     /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        // Save exploration rate (epsilon)
-        writer.Write(Convert.ToDouble(_epsilon));
-
-        // Save action space size
-        writer.Write(_actionSpace);
 
-        // Save replay buffer size (but not the actual experiences)
-        writer.Write(_replayBuffer.Count);
-
-        // Serialize target network (if present)
-        writer.Write(_targetNetwork is not null);
-        if (_targetNetwork is not null)
-        {
-            for (int i = 0; i < _targetNetwork.Layers.Count; i++)
-            {
-                _targetNetwork.Layers[i].Serialize(writer);
-            }
-        }
-    }
 
     /// <summary>
     /// Loads Deep Q-Network specific data from a binary stream.
@@ -787,59 +767,7 @@ protected override void SerializeNetworkSpecificData(BinaryWriter writer)
     /// This allows you to continue using a previously trained DQN with all its settings intact.
     /// </para>
     /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        // Load exploration rate (epsilon)
-        T epsilon = NumOps.FromDouble(reader.ReadDouble());
-
-        // Load action space size
-        int actionSpace = reader.ReadInt32();
-        _actionSpace = actionSpace;
 
-        // Load replay buffer size (but can't restore actual experiences)
-        int replayBufferSize = reader.ReadInt32();
-        _ = replayBufferSize;
-
-        // Deserialize target network (if it was serialized)
-        bool hasTargetNetwork = reader.ReadBoolean();
-        if (hasTargetNetwork)
-        {
-            var targetNetwork = _targetNetwork ??
-                new DeepQNetwork<T>(Architecture, _lossFunction, Convert.ToDouble(epsilon), isTargetNetwork: true);
-            _targetNetwork = targetNetwork;
-
-            for (int i = 0; i < targetNetwork.Layers.Count; i++)
-            {
-                targetNetwork.Layers[i].Deserialize(reader);
-            }
-        }
-    }
-
-    /// <summary>
-    /// Creates a new instance of the Deep Q-Network with the same architecture and configuration.
-    /// </summary>
-    /// <returns>A new Deep Q-Network instance with the same architecture and configuration.</returns>
-    /// <remarks>
-    /// <para>
-    /// This method creates a new instance of the Deep Q-Network with the same architecture and
-    /// exploration rate (epsilon) as the current instance. It's used in scenarios where a fresh
-    /// copy of the model is needed while maintaining the same configuration.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method creates a brand new copy of the agent with the same setup.
-    /// 
-    /// Think of it like creating a clone of the agent:
-    /// - The new agent has the same neural network architecture
-    /// - The new agent has the same exploration rate (epsilon)
-    /// - But it's a completely separate instance with its own memory and learning state
-    /// 
-    /// This is useful when you need multiple instances of the same DQN model,
-    /// such as for parallel training or comparing different learning strategies.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new DeepQNetwork<T>(this.Architecture, _lossFunction, Convert.ToDouble(this._epsilon));
-    }
 }
 
 
diff --git a/src/NeuralNetworks/DenseNetNetwork.cs b/src/NeuralNetworks/DenseNetNetwork.cs
index 2c6a13f8cd..ab222dd2b4 100644
--- a/src/NeuralNetworks/DenseNetNetwork.cs
+++ b/src/NeuralNetworks/DenseNetNetwork.cs
@@ -63,7 +63,7 @@ namespace AiDotNet.NeuralNetworks;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Densely Connected Convolutional Networks", "https://arxiv.org/abs/1608.06993", Year = 2017, Authors = "Gao Huang, Zhuang Liu, Laurens van der Maaten, Kilian Q. Weinberger")]
-public class DenseNetNetwork<T> : ImageClassifierModelLayoutBase<T>
+public partial class DenseNetNetwork<T> : ImageClassifierModelLayoutBase<T>
 {
     private readonly DenseNetOptions _options;
 
@@ -377,61 +377,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc />
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write((int)_configuration.Variant);
-        writer.Write(_configuration.InputChannels);
-        writer.Write(_configuration.InputHeight);
-        writer.Write(_configuration.InputWidth);
-        writer.Write(_configuration.NumClasses);
-        writer.Write(_configuration.GrowthRate);
-        writer.Write(_configuration.CompressionFactor);
-    }
 
-    /// <inheritdoc />
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        var variant = (DenseNetVariant)reader.ReadInt32();
-        var inputChannels = reader.ReadInt32();
-        var inputHeight = reader.ReadInt32();
-        var inputWidth = reader.ReadInt32();
-        var numClasses = reader.ReadInt32();
-        var growthRate = reader.ReadInt32();
-        var compressionFactor = reader.ReadDouble();
-
-        if (variant != _configuration.Variant ||
-            inputChannels != _configuration.InputChannels ||
-            inputHeight != _configuration.InputHeight ||
-            inputWidth != _configuration.InputWidth ||
-            numClasses != _configuration.NumClasses ||
-            growthRate != _configuration.GrowthRate ||
-            Math.Abs(compressionFactor - _configuration.CompressionFactor) > 0.001)
-        {
-            throw new InvalidDataException("Serialized DenseNet configuration does not match current configuration.");
-        }
-    }
 
     /// <inheritdoc />
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var config = new DenseNetConfiguration(
-            _configuration.Variant,
-            _configuration.NumClasses,
-            _configuration.InputHeight,
-            _configuration.InputWidth,
-            _configuration.InputChannels,
-            _configuration.GrowthRate,
-            _configuration.CompressionFactor,
-            _configuration.CustomBlockLayers);
-
-        return new DenseNetNetwork<T>(Architecture, config, _optimizer, _lossFunction);
-    }
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> Clone()
-    {
-        return DeepCopy();
-    }
 
     /// <summary>
     /// Gets the layer at the specified index.
diff --git a/src/NeuralNetworks/DifferentiableNeuralComputer.cs b/src/NeuralNetworks/DifferentiableNeuralComputer.cs
index f68abd99ea..950e9513ce 100644
--- a/src/NeuralNetworks/DifferentiableNeuralComputer.cs
+++ b/src/NeuralNetworks/DifferentiableNeuralComputer.cs
@@ -49,7 +49,7 @@ namespace AiDotNet.NeuralNetworks;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Hybrid Computing Using a Neural Network with Dynamic External Memory", "https://www.nature.com/articles/nature20101", Year = 2016, Authors = "Alex Graves, Greg Wayne, Malcolm Reynolds, Tim Harley, Ivo Danihelka, Agnieszka Grabska-Barwinska, Sergio Gomez Colmenarejo, Edward Grefenstette, Tiago Ramalho, John Agapiou, Adrià Puigdomènech Badia, Karl Moritz Hermann, Yori Zwols, Georg Ostrovski, Adam Cain, Helen King, Christopher Summerfield, Phil Blunsom, Koray Kavukcuoglu, Demis Hassabis")]
-public class DifferentiableNeuralComputer<T> : SequenceModelLayoutBase<T>, IAuxiliaryLossLayer<T>
+public partial class DifferentiableNeuralComputer<T> : SequenceModelLayoutBase<T>, IAuxiliaryLossLayer<T>
 {
     private readonly DifferentiableNeuralComputerOptions _options;
     private readonly IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>> _optimizer;
@@ -218,6 +218,7 @@ public class DifferentiableNeuralComputer<T> : SequenceModelLayoutBase<T>, IAuxi
     /// complex information over long periods, unlike regular neural networks.
     /// </para>
     /// </remarks>
+    [Scratch]
     private Matrix<T> _memory;
 
     /// <summary>
@@ -240,6 +241,7 @@ public class DifferentiableNeuralComputer<T> : SequenceModelLayoutBase<T>, IAuxi
     /// valuable information it might need later.
     /// </para>
     /// </remarks>
+    [Scratch]
     private Vector<T> _usageFree;
 
     /// <summary>
@@ -263,6 +265,7 @@ public class DifferentiableNeuralComputer<T> : SequenceModelLayoutBase<T>, IAuxi
     /// This focused writing allows the system to organize information in a way it can find later.
     /// </para>
     /// </remarks>
+    [Scratch]
     private Vector<T> _writeWeighting;
 
     /// <summary>
@@ -286,6 +289,7 @@ public class DifferentiableNeuralComputer<T> : SequenceModelLayoutBase<T>, IAuxi
     /// This allows the system to retrieve relevant information it previously stored.
     /// </para>
     /// </remarks>
+    [Scratch]
     private List<Vector<T>> _readWeightings;
 
     /// <summary>
@@ -310,6 +314,7 @@ public class DifferentiableNeuralComputer<T> : SequenceModelLayoutBase<T>, IAuxi
     /// following the sequence in which information was stored.
     /// </para>
     /// </remarks>
+    [Scratch]
     private Vector<T> _precedenceWeighting;
 
     /// <summary>
@@ -334,6 +339,7 @@ public class DifferentiableNeuralComputer<T> : SequenceModelLayoutBase<T>, IAuxi
     /// algorithm-like reasoning.
     /// </para>
     /// </remarks>
+    [Scratch]
     private Matrix<T> _temporalLinkMatrix;
 
     /// <summary>
@@ -367,6 +373,7 @@ public class DifferentiableNeuralComputer<T> : SequenceModelLayoutBase<T>, IAuxi
     /// to produce its final output for a given input.
     /// </para>
     /// </remarks>
+    [Scratch]
     private List<Vector<T>> _readVectors;
 
     /// <summary>
@@ -388,8 +395,10 @@ public class DifferentiableNeuralComputer<T> : SequenceModelLayoutBase<T>, IAuxi
     // matrix is read/written by the legacy Serialize/Deserialize paths only.
     // _lastCombinedVector was a backward-pass cache for the manual matmul that
     // the new Layers-chain projection no longer needs.
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _outputWeights;
 #pragma warning disable CS0169
+    [Scratch]
     private Vector<T>? _lastCombinedVector;
 #pragma warning restore CS0169
 
@@ -1542,78 +1551,7 @@ public override ModelMetadata<T> GetModelMetadata()
     /// so you can resume from exactly the same state later.
     /// </para>
     /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        // Write DNC-specific properties
-        writer.Write(_memorySize);
-        writer.Write(_memoryWordSize);
-        writer.Write(_controllerSize);
-        writer.Write(_readHeads);
-        writer.Write(IsTrainingMode);
-
-        // Write memory matrix
-        for (int i = 0; i < _memorySize; i++)
-        {
-            for (int j = 0; j < _memoryWordSize; j++)
-            {
-                writer.Write(Convert.ToDouble(_memory[i, j]));
-            }
-        }
-
-        // Write usage free vector
-        for (int i = 0; i < _memorySize; i++)
-        {
-            writer.Write(Convert.ToDouble(_usageFree[i]));
-        }
-
-        // Write write weighting
-        for (int i = 0; i < _memorySize; i++)
-        {
-            writer.Write(Convert.ToDouble(_writeWeighting[i]));
-        }
-
-        // Write output weights
-        writer.Write(_outputWeights.Shape[0]);
-        writer.Write(_outputWeights.Shape[1]);
-        for (int i = 0; i < _outputWeights.Shape[0]; i++)
-            for (int j = 0; j < _outputWeights.Shape[1]; j++)
-                writer.Write(Convert.ToDouble(_outputWeights[i, j]));
-
-        // Write read weightings
-        writer.Write(_readWeightings.Count);
-        foreach (var readWeighting in _readWeightings)
-        {
-            for (int i = 0; i < _memorySize; i++)
-            {
-                writer.Write(Convert.ToDouble(readWeighting[i]));
-            }
-        }
-
-        // Write precedence weighting
-        for (int i = 0; i < _memorySize; i++)
-        {
-            writer.Write(Convert.ToDouble(_precedenceWeighting[i]));
-        }
 
-        // Write temporal link matrix
-        for (int i = 0; i < _memorySize; i++)
-        {
-            for (int j = 0; j < _memorySize; j++)
-            {
-                writer.Write(Convert.ToDouble(_temporalLinkMatrix[i, j]));
-            }
-        }
-
-        // Write read vectors
-        writer.Write(_readVectors.Count);
-        foreach (var readVector in _readVectors)
-        {
-            for (int i = 0; i < _memoryWordSize; i++)
-            {
-                writer.Write(Convert.ToDouble(readVector[i]));
-            }
-        }
-    }
 
     /// <summary>
     /// Deserializes Differentiable Neural Computer-specific data from a binary reader.
@@ -1637,94 +1575,7 @@ protected override void SerializeNetworkSpecificData(BinaryWriter writer)
     /// with both the network's learned parameters and its memory contents intact.
     /// </para>
     /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        // Read DNC-specific properties
-        int memorySize = reader.ReadInt32();
-        int memoryWordSize = reader.ReadInt32();
-        int controllerSize = reader.ReadInt32();
-        int readHeads = reader.ReadInt32();
-
-        // Check if configuration matches
-        if (memorySize != _memorySize || memoryWordSize != _memoryWordSize ||
-            controllerSize != _controllerSize || readHeads != _readHeads)
-        {
-            Console.WriteLine("Warning: Loaded DNC has different configuration than the current instance.");
-        }
-
-        // Read training mode
-        IsTrainingMode = reader.ReadBoolean();
-
-        // Read memory matrix
-        for (int i = 0; i < _memorySize; i++)
-        {
-            for (int j = 0; j < _memoryWordSize; j++)
-            {
-                _memory[i, j] = NumOps.FromDouble(reader.ReadDouble());
-            }
-        }
 
-        // Read usage free vector
-        for (int i = 0; i < _memorySize; i++)
-        {
-            _usageFree[i] = NumOps.FromDouble(reader.ReadDouble());
-        }
-
-        // Read write weighting
-        for (int i = 0; i < _memorySize; i++)
-        {
-            _writeWeighting[i] = NumOps.FromDouble(reader.ReadDouble());
-        }
-
-        // Read output weights
-        int owRows = reader.ReadInt32();
-        int owCols = reader.ReadInt32();
-        _outputWeights = new Tensor<T>([owRows, owCols]);
-        for (int i = 0; i < owRows; i++)
-            for (int j = 0; j < owCols; j++)
-                _outputWeights[i, j] = NumOps.FromDouble(reader.ReadDouble());
-
-        // Read read weightings
-        int readWeightingsCount = reader.ReadInt32();
-        _readWeightings.Clear();
-        for (int k = 0; k < readWeightingsCount; k++)
-        {
-            Vector<T> readWeighting = new Vector<T>(_memorySize);
-            for (int i = 0; i < _memorySize; i++)
-            {
-                readWeighting[i] = NumOps.FromDouble(reader.ReadDouble());
-            }
-            _readWeightings.Add(readWeighting);
-        }
-
-        // Read precedence weighting
-        for (int i = 0; i < _memorySize; i++)
-        {
-            _precedenceWeighting[i] = NumOps.FromDouble(reader.ReadDouble());
-        }
-
-        // Read temporal link matrix
-        for (int i = 0; i < _memorySize; i++)
-        {
-            for (int j = 0; j < _memorySize; j++)
-            {
-                _temporalLinkMatrix[i, j] = NumOps.FromDouble(reader.ReadDouble());
-            }
-        }
-
-        // Read read vectors
-        int readVectorsCount = reader.ReadInt32();
-        _readVectors.Clear();
-        for (int k = 0; k < readVectorsCount; k++)
-        {
-            Vector<T> readVector = new Vector<T>(_memoryWordSize);
-            for (int i = 0; i < _memoryWordSize; i++)
-            {
-                readVector[i] = NumOps.FromDouble(reader.ReadDouble());
-            }
-            _readVectors.Add(readVector);
-        }
-    }
 
     /// <summary>
     /// Resets the state of the Differentiable Neural Computer.
@@ -1860,79 +1711,4 @@ public List<Tensor<T>> ProcessSequence(List<Tensor<T>> inputs, bool resetMemory
         return outputs;
     }
 
-    /// <summary>
-    /// Creates a new instance of the differentiable neural computer model.
-    /// </summary>
-    /// <returns>A new instance of the differentiable neural computer model with the same configuration.</returns>
-    /// <remarks>
-    /// <para>
-    /// This method creates a new instance of the differentiable neural computer model with the same configuration as the current instance.
-    /// It is used internally during serialization/deserialization processes to create a fresh instance that can be populated
-    /// with the serialized data. The new instance will have the same architecture, memory size, memory word size,
-    /// controller size, read heads count, and activation function type as the original.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method creates a copy of the network structure without copying the learned data.
-    /// 
-    /// Think of it like creating a blueprint copy of the DNC:
-    /// - It copies the same neural network architecture
-    /// - It sets up the same memory size (same notepad dimensions)
-    /// - It configures the same number of read heads (how many pages to look at at once)
-    /// - It uses the same controller size (brain power)
-    /// - It keeps the same activation function (how neurons respond to input)
-    /// - But it doesn't copy any of the actual memories or learned behaviors
-    /// 
-    /// This is primarily used when saving or loading models, creating an empty framework
-    /// that the saved parameters and memory state can be loaded into later.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        // Determine which constructor to use based on which activation function is set
-        if (_activationFunction != null)
-        {
-            return new DifferentiableNeuralComputer<T>(
-                Architecture,
-                _memorySize,
-                _memoryWordSize,
-                _controllerSize,
-                _readHeads,
-                lossFunction: _lossFunction,
-                activationFunction: _activationFunction
-            );
-        }
-        else
-        {
-            return new DifferentiableNeuralComputer<T>(
-                Architecture,
-                _memorySize,
-                _memoryWordSize,
-                _controllerSize,
-                _readHeads,
-                lossFunction: _lossFunction,
-                vectorActivationFunction: _vectorActivationFunction
-            );
-        }
-    }
-    /// <summary>
-    /// Declares the output projection, which live outside <see cref="NeuralNetworkBase{T}.Layers"/>.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// These were in NEITHER surface. The base walks Layers, these are not in Layers, and
-    /// nothing declared them -- so they were never counted, never handed out, never restored,
-    /// and never trained through a flat-vector optimizer. Declaring them adds to the parameter
-    /// count, deliberately: the old number was not a smaller-but-correct total, it omitted real
-    /// weights.
-    /// </para>
-    /// <para>
-    /// A hook rather than a [TrainableParameter] attribute because TrainableParameterGenerator
-    /// only processes LayerBase subclasses (see its ExtendsLayerBase guard) -- the attribute
-    /// does nothing on a model. For a model, declaring through this hook IS the mechanism.
-    /// </para>
-    /// </remarks>
-    protected override IEnumerable<Tensor<T>> GetExtraTrainableTensors()
-    {
-        yield return _outputWeights;
-    }
-
 }
diff --git a/src/NeuralNetworks/EagleLanguageModel.cs b/src/NeuralNetworks/EagleLanguageModel.cs
index f0f030a43e..8da1710c0a 100644
--- a/src/NeuralNetworks/EagleLanguageModel.cs
+++ b/src/NeuralNetworks/EagleLanguageModel.cs
@@ -41,7 +41,7 @@ namespace AiDotNet.NeuralNetworks;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Eagle and Finch: RWKV with Matrix-Valued States and Dynamic Recurrence", "https://arxiv.org/abs/2404.05892", Year = 2024, Authors = "Bo Peng, Daniel Goldstein, Quentin Anthony, Alon Albalak, Eric Alcaide, Stella Biderman, Eugene Cheah, Teddy Ferdinan, Haowen Hou, Przemyslaw Kazienko, Kranthi Kiran GV, Jan Kocon, Bartlomiej Koptyra, Satyapriya Krishna, Ronald McClelland Jr., Niklas Muennighoff, Fares Obeid, Atsushi Saito, Guangyu Song, Haoqin Tu, Stanislaw Wozniak, Ruichong Zhang, Bingchen Zhao, Qihang Zhao, Peng Zhou, Jian Zhu, Rui-Jie Zhu")]
-public class EagleLanguageModel<T> : TokenLanguageModelLayoutBase<T>
+public partial class EagleLanguageModel<T> : TokenLanguageModelLayoutBase<T>
 {
     private readonly EagleOptions _options;
     private readonly int _vocabSize;
@@ -146,30 +146,9 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_vocabSize);
-        writer.Write(_modelDimension);
-        writer.Write(_numLayers);
-        writer.Write(_numHeads);
-        writer.Write(_maxSeqLength);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _ = reader.ReadInt32();
-        _ = reader.ReadInt32();
-        _ = reader.ReadInt32();
-        _ = reader.ReadInt32();
-        _ = reader.ReadInt32();
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new EagleLanguageModel<T>(
-            Architecture, _vocabSize, _modelDimension, _numLayers, _numHeads,
-            _maxSeqLength, LossFunction, _options);
-    }
+
 
     #endregion
 }
diff --git a/src/NeuralNetworks/EchoStateNetwork.cs b/src/NeuralNetworks/EchoStateNetwork.cs
index 0491eb42a3..cd618bf1fd 100644
--- a/src/NeuralNetworks/EchoStateNetwork.cs
+++ b/src/NeuralNetworks/EchoStateNetwork.cs
@@ -151,6 +151,7 @@ public partial class EchoStateNetwork<T> : SequenceModelLayoutBase<T>
     /// it's what allows the network to "remember" past inputs when processing new ones.
     /// </para>
     /// </remarks>
+    [AiDotNet.Attributes.Buffer]
     private Vector<T> _reservoirState;
 
     /// <summary>
@@ -344,11 +345,13 @@ public partial class EchoStateNetwork<T> : SequenceModelLayoutBase<T>
     /// <summary>
     /// The weight matrix for input-to-reservoir connections.
     /// </summary>
+    [AiDotNet.Attributes.FrozenParameter]
     private Matrix<T> _inputWeights;
 
     /// <summary>
     /// The weight matrix for reservoir-to-reservoir connections.
     /// </summary>
+    [AiDotNet.Attributes.FrozenParameter]
     private Matrix<T> _reservoirWeights;
 
     /// <summary>
@@ -363,21 +366,25 @@ public partial class EchoStateNetwork<T> : SequenceModelLayoutBase<T>
     /// <summary>
     /// The weight matrix for reservoir-to-output connections.
     /// </summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _outputWeights;
 
     /// <summary>
     /// The bias vector for the reservoir.
     /// </summary>
+    [AiDotNet.Attributes.FrozenParameter]
     private Vector<T> _reservoirBias;
 
     /// <summary>
     /// The bias vector for the output layer.
     /// </summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T> _outputBias;
 
     /// <summary>
     /// The current state of the reservoir.
     /// </summary>
+    [AiDotNet.Attributes.Buffer]
     private Vector<T> _currentState;
 
     /// <summary>
@@ -414,11 +421,13 @@ public partial class EchoStateNetwork<T> : SequenceModelLayoutBase<T>
     /// <summary>
     /// Collected states during training for regression.
     /// </summary>
+    [Scratch]
     private List<Vector<T>> _collectedStates;
 
     /// <summary>
     /// Collected targets during training for regression.
     /// </summary>
+    [Scratch]
     private List<Vector<T>> _collectedTargets;
 
     /// <summary>
@@ -1112,36 +1121,6 @@ protected override void ValidateCustomLayers(List<ILayer<T>> layers)
     /// <inheritdoc/>
     public override bool SupportsTraining => true;
 
-    /// <summary>
-    /// Declares the readout -- the ESN's only trainable parameters.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// An Echo State Network trains ONLY its output layer. The input and reservoir weights are drawn
-    /// once and left fixed; that is the defining property of reservoir computing (Jaeger 2001), not
-    /// an omission, so <c>_inputWeights</c> and <c>_reservoirWeights</c> are deliberately absent
-    /// here and stay <c>Matrix&lt;T&gt;</c>. Declared weights-then-bias, the order the deleted
-    /// GetParameters produced.
-    /// </para>
-    /// <para>
-    /// This replaces four members that each restated that layout: a ParameterCount formula, a
-    /// GetParameters copying the readout out element by element, a SetParameters copying it back,
-    /// and a GetParameterChunks that built a SEPARATE pair of tensors and copied into those. That
-    /// last one is why <c>_outputWeights</c> is now a <c>Tensor&lt;T&gt;</c>: the base restores by
-    /// writing THROUGH the declared tensors, so a chunk that is a copy would be written and then
-    /// discarded, leaving the model on its old readout while reporting the new one.
-    /// </para>
-    /// <para>
-    /// The bias stays a <c>Vector&lt;T&gt;</c> -- a tensor built over a vector shares its storage,
-    /// so writes through this view land in the field itself.
-    /// </para>
-    /// </remarks>
-    protected override IEnumerable<Tensor<T>> GetExtraTrainableTensors()
-    {
-        yield return _outputWeights;
-        yield return new Tensor<T>([_outputBias.Length], _outputBias);
-    }
-
     protected override Tensor<T> PredictCore(Tensor<T> input)
     {
         // GPU-resident optimization: use TryForwardGpuOptimized for speedup
@@ -1695,82 +1674,7 @@ public override ModelMetadata<T> GetModelMetadata()
     /// This allows you to save the network and reload it later exactly as it was.
     /// </para>
     /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        // Write basic configuration
-        writer.Write(_reservoirSize);
-        writer.Write(NumOps.ToDouble(_spectralRadius));
-        writer.Write(NumOps.ToDouble(_sparsity));
-        writer.Write(_inputSize);
-        writer.Write(_outputSize);
-        writer.Write(Convert.ToDouble(_leakingRate));
-        writer.Write(Convert.ToDouble(_regularization));
-        writer.Write(_warmupPeriod);
-
-        // Write activation function information
-        // Write scalar activation function flags
-        writer.Write(_reservoirInputScalarActivation != null);
-        writer.Write(_reservoirOutputScalarActivation != null);
-        writer.Write(_reservoirScalarActivation != null);
-        writer.Write(_outputScalarActivation != null);
-
-        // Write vector activation function flags
-        writer.Write(_reservoirInputVectorActivation != null);
-        writer.Write(_reservoirOutputVectorActivation != null);
-        writer.Write(_reservoirVectorActivation != null);
-        writer.Write(_outputVectorActivation != null);
-
-        // Serialize activation functions if present
-        if (_reservoirInputScalarActivation != null)
-        {
-            SerializationHelper<T>.SerializeInterface(writer, _reservoirInputScalarActivation);
-        }
-
-        if (_reservoirOutputScalarActivation != null)
-        {
-            SerializationHelper<T>.SerializeInterface(writer, _reservoirOutputScalarActivation);
-        }
-
-        if (_reservoirScalarActivation != null)
-        {
-            SerializationHelper<T>.SerializeInterface(writer, _reservoirScalarActivation);
-        }
-
-        if (_outputScalarActivation != null)
-        {
-            SerializationHelper<T>.SerializeInterface(writer, _outputScalarActivation);
-        }
 
-        if (_reservoirInputVectorActivation != null)
-        {
-            SerializationHelper<T>.SerializeInterface(writer, _reservoirInputVectorActivation);
-        }
-
-        if (_reservoirOutputVectorActivation != null)
-        {
-            SerializationHelper<T>.SerializeInterface(writer, _reservoirOutputVectorActivation);
-        }
-
-        if (_reservoirVectorActivation != null)
-        {
-            SerializationHelper<T>.SerializeInterface(writer, _reservoirVectorActivation);
-        }
-
-        if (_outputVectorActivation != null)
-        {
-            SerializationHelper<T>.SerializeInterface(writer, _outputVectorActivation);
-        }
-
-        // Write weight matrices and bias vectors
-        SerializeMatrix(writer, _inputWeights);
-        SerializeMatrix(writer, _reservoirWeights);
-        SerializeTensor2D(writer, _outputWeights);
-        SerializeVector(writer, _reservoirBias);
-        SerializeVector(writer, _outputBias);
-
-        // Write current state
-        SerializeVector(writer, _currentState);
-    }
 
     /// <summary>
     /// Serializes a matrix to a binary writer.
@@ -1865,87 +1769,7 @@ private void SerializeVector(BinaryWriter writer, Vector<T> vector)
     /// This allows you to continue using the network exactly where you left off.
     /// </para>
     /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        // Read basic configuration
-        _reservoirSize = reader.ReadInt32();
-        _spectralRadius = NumOps.FromDouble(reader.ReadDouble());
-        _sparsity = NumOps.FromDouble(reader.ReadDouble());
-        _inputSize = reader.ReadInt32();
-        _outputSize = reader.ReadInt32();
-        _leakingRate = NumOps.FromDouble(reader.ReadDouble());
-        _regularization = NumOps.FromDouble(reader.ReadDouble());
-        _warmupPeriod = reader.ReadInt32();
-
-        // Read activation function flags
-        bool hasReservoirInputScalarActivation = reader.ReadBoolean();
-        bool hasReservoirOutputScalarActivation = reader.ReadBoolean();
-        bool hasReservoirScalarActivation = reader.ReadBoolean();
-        bool hasOutputScalarActivation = reader.ReadBoolean();
-
-        bool hasReservoirInputVectorActivation = reader.ReadBoolean();
-        bool hasReservoirOutputVectorActivation = reader.ReadBoolean();
-        bool hasReservoirVectorActivation = reader.ReadBoolean();
-        bool hasOutputVectorActivation = reader.ReadBoolean();
-
-        // Deserialize activation functions if present
-        if (hasReservoirInputScalarActivation)
-        {
-            _reservoirInputScalarActivation = DeserializationHelper.DeserializeInterface<IActivationFunction<T>>(reader);
-        }
 
-        if (hasReservoirOutputScalarActivation)
-        {
-            _reservoirOutputScalarActivation = DeserializationHelper.DeserializeInterface<IActivationFunction<T>>(reader);
-        }
-
-        if (hasReservoirScalarActivation)
-        {
-            _reservoirScalarActivation = DeserializationHelper.DeserializeInterface<IActivationFunction<T>>(reader);
-        }
-
-        if (hasOutputScalarActivation)
-        {
-            _outputScalarActivation = DeserializationHelper.DeserializeInterface<IActivationFunction<T>>(reader);
-        }
-
-        if (hasReservoirInputVectorActivation)
-        {
-            _reservoirInputVectorActivation = DeserializationHelper.DeserializeInterface<IVectorActivationFunction<T>>(reader);
-        }
-
-        if (hasReservoirOutputVectorActivation)
-        {
-            _reservoirOutputVectorActivation = DeserializationHelper.DeserializeInterface<IVectorActivationFunction<T>>(reader);
-        }
-
-        if (hasReservoirVectorActivation)
-        {
-            _reservoirVectorActivation = DeserializationHelper.DeserializeInterface<IVectorActivationFunction<T>>(reader);
-        }
-
-        if (hasOutputVectorActivation)
-        {
-            _outputVectorActivation = DeserializationHelper.DeserializeInterface<IVectorActivationFunction<T>>(reader);
-        }
-
-        // Read weight matrices and bias vectors
-        _inputWeights = DeserializeMatrix(reader);
-        _reservoirWeights = DeserializeMatrix(reader);
-        _outputWeights = DeserializeTensor2D(reader);
-        _reservoirBias = DeserializeVector(reader);
-        _outputBias = DeserializeVector(reader);
-
-        // Read current state
-        _currentState = DeserializeVector(reader);
-
-        // Initialize training collections
-        _collectedStates = new List<Vector<T>>();
-        _collectedTargets = new List<Vector<T>>();
-        _isTraining = false;
-
-        RefreshReservoirWeightCaches();
-    }
 
     /// <summary>
     /// Deserializes a matrix from a binary reader.
@@ -1988,66 +1812,4 @@ private Vector<T> DeserializeVector(BinaryReader reader)
 
         return vector;
     }
-
-    /// <summary>
-    /// Creates a new instance of the EchoStateNetwork with the same configuration as the current instance.
-    /// </summary>
-    /// <returns>A new EchoStateNetwork instance with the same architecture and configuration as the current instance.</returns>
-    /// <remarks>
-    /// <para>
-    /// This method creates a new instance of the EchoStateNetwork with the same architecture, reservoir size,
-    /// spectral radius, sparsity, and activation functions as the current instance. This is useful for model cloning,
-    /// ensemble methods, or cross-validation scenarios where multiple instances of the same model with identical
-    /// configurations are needed.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method creates a fresh copy of the ESN's blueprint.
-    /// 
-    /// When you need multiple versions of the same type of ESN with identical settings:
-    /// - This method creates a new, empty ESN with the same configuration
-    /// - It's like making a copy of your pool design before building it
-    /// - The new ESN has the same structure but no trained data
-    /// - This is useful for techniques that need multiple models, like ensemble methods
-    /// 
-    /// For example, when training on different data streams,
-    /// you'd want each ESN to have the same architecture and reservoir properties.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (_reservoirInputVectorActivation != null || _reservoirOutputVectorActivation != null ||
-            _reservoirVectorActivation != null || _outputVectorActivation != null)
-        {
-            // If using vector activations
-            return new EchoStateNetwork<T>(
-                Architecture,
-                _reservoirSize,
-                NumOps.ToDouble(_spectralRadius),
-                NumOps.ToDouble(_sparsity),
-                Convert.ToDouble(_leakingRate),
-                Convert.ToDouble(_regularization),
-                _warmupPeriod,
-                _lossFunction,
-                _reservoirInputVectorActivation,
-                _reservoirOutputVectorActivation,
-                _reservoirVectorActivation,
-                _outputVectorActivation);
-        }
-        else
-        {
-            // If using scalar activations
-            return new EchoStateNetwork<T>(
-                Architecture,
-                _reservoirSize,
-                NumOps.ToDouble(_spectralRadius),
-                NumOps.ToDouble(_sparsity),
-                Convert.ToDouble(_leakingRate),
-                Convert.ToDouble(_regularization),
-                _warmupPeriod,
-                _lossFunction,
-                _reservoirInputScalarActivation,
-                _reservoirOutputScalarActivation,
-                _reservoirScalarActivation,
-                _outputScalarActivation);
-        }
-    }
 }
diff --git a/src/NeuralNetworks/EfficientNetNetwork.cs b/src/NeuralNetworks/EfficientNetNetwork.cs
index cdf12bcbf2..9c9caa1940 100644
--- a/src/NeuralNetworks/EfficientNetNetwork.cs
+++ b/src/NeuralNetworks/EfficientNetNetwork.cs
@@ -69,7 +69,7 @@ namespace AiDotNet.NeuralNetworks;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("EfficientNet: Rethinking Model Scaling for Convolutional Neural Networks", "https://arxiv.org/abs/1905.11946", Year = 2019, Authors = "Mingxing Tan, Quoc V. Le")]
-public class EfficientNetNetwork<T> : ImageClassifierModelLayoutBase<T>
+public partial class EfficientNetNetwork<T> : ImageClassifierModelLayoutBase<T>
 {
     private readonly EfficientNetOptions _options;
 
@@ -407,12 +407,7 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc />
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write((int)_configuration.Variant);
-        writer.Write(_configuration.InputChannels);
-        writer.Write(_configuration.NumClasses);
-    }
+
 
     /// <summary>
     /// Deserializes and validates network-specific configuration data.
@@ -437,62 +432,7 @@ protected override void SerializeNetworkSpecificData(BinaryWriter writer)
     /// desired configuration, then call <see cref="NeuralNetworkBase{T}.Load"/> on that instance.
     /// </para>
     /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        // Read serialized configuration values
-        var variant = (EfficientNetVariant)reader.ReadInt32();
-        var inputChannels = reader.ReadInt32();
-        var numClasses = reader.ReadInt32();
-
-        // Validate configuration matches - layer structure depends on these values
-        // and cannot be changed after construction
-        if (variant != _configuration.Variant ||
-            inputChannels != _configuration.InputChannels ||
-            numClasses != _configuration.NumClasses)
-        {
-            throw new InvalidDataException(
-                $"Serialized EfficientNet configuration (Variant={variant}, InputChannels={inputChannels}, " +
-                $"NumClasses={numClasses}) does not match current configuration " +
-                $"(Variant={_configuration.Variant}, InputChannels={_configuration.InputChannels}, " +
-                $"NumClasses={_configuration.NumClasses}). Create a new network with matching configuration to load this model.");
-        }
-    }
 
-    /// <inheritdoc />
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var config = new EfficientNetConfiguration(
-            _configuration.Variant,
-            _configuration.NumClasses,
-            _configuration.InputChannels,
-            _configuration.CustomInputHeight,
-            _configuration.CustomWidthMultiplier,
-            _configuration.CustomDepthMultiplier);
-
-        // A FRESH OPTIMIZER, not this model's. Adam keeps per-parameter first and second moment
-        // state, so two models sharing one instance corrupt each other's moment estimates and the
-        // step count advances twice per logical step, doubling the bias correction. The rest of this
-        // method exists to make the clone faithful; a shared optimizer defeats that.
-        //
-        // Rebuilt with the same settings the constructor's default path uses, since a clone of a
-        // model that took the default should also take the default.
-        // FlamingoNeuralNetwork.CreateNewInstance does the same, for the same reason.
-        var freshOptimizer = new AdamOptimizer<T, Tensor<T>, Tensor<T>>(
-            this,
-            new AdamOptimizerOptions<T, Tensor<T>, Tensor<T>>
-            {
-                InitialLearningRate = 1e-4,
-                Epsilon = 1e-6,
-            });
-
-        return new EfficientNetNetwork<T>(Architecture, config, freshOptimizer, _lossFunction);
-    }
-
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> Clone()
-    {
-        return DeepCopy();
-    }
 
     /// <summary>
     /// Gets the layer at the specified index.
diff --git a/src/NeuralNetworks/ExtremeLearningMachine.cs b/src/NeuralNetworks/ExtremeLearningMachine.cs
index 0996d57508..7ecf87dabc 100644
--- a/src/NeuralNetworks/ExtremeLearningMachine.cs
+++ b/src/NeuralNetworks/ExtremeLearningMachine.cs
@@ -43,7 +43,7 @@ namespace AiDotNet.NeuralNetworks;
 [ModelComplexity(ModelComplexity.Low)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Extreme Learning Machine: Theory and Applications", "https://doi.org/10.1016/j.neucom.2005.12.126", Year = 2006, Authors = "Guang-Bin Huang, Qin-Yu Zhu, Chee-Kheong Siew")]
-public class ExtremeLearningMachine<T> : VectorModelLayoutBase<T>
+public partial class ExtremeLearningMachine<T> : VectorModelLayoutBase<T>
 {
     private readonly ExtremeLearningMachineOptions _options;
 
@@ -372,71 +372,9 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    /// <summary>
-    /// Serializes Extreme Learning Machine-specific data to a binary writer.
-    /// </summary>
-    /// <param name="writer">The BinaryWriter to write the data to.</param>
-    /// <remarks>
-    /// <para>
-    /// This method writes ELM-specific configuration data to a binary stream. It includes
-    /// properties such as the hidden layer size and the weights of all layers. This data is needed
-    /// to reconstruct the ELM when deserializing.
-    /// </para>
-    /// <para><b>For Beginners:</b> This saves the special configuration of your ELM.
-    /// 
-    /// It's like writing down the recipe for how your specific ELM was built:
-    /// - How many hidden neurons it has
-    /// - The random weights used in the input-to-hidden connections
-    /// - The trained weights used in the hidden-to-output connections
-    /// 
-    /// This allows you to save the model and reload it later, without having to retrain it.
-    /// </para>
-    /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        // Write hidden layer size
-        writer.Write(_hiddenLayerSize);
 
-        // Write whether we're in training mode
-        writer.Write(IsTrainingMode);
-    }
 
-    /// <summary>
-    /// Deserializes Extreme Learning Machine-specific data from a binary reader.
-    /// </summary>
-    /// <param name="reader">The BinaryReader to read the data from.</param>
-    /// <remarks>
-    /// <para>
-    /// This method reads ELM-specific configuration data from a binary stream. It retrieves
-    /// properties such as the hidden layer size and the weights of all layers. After reading this data,
-    /// the ELM's state is fully restored to what it was when saved.
-    /// </para>
-    /// <para><b>For Beginners:</b> This restores the special configuration of your ELM from saved data.
-    /// 
-    /// It's like following the recipe to rebuild your ELM exactly as it was:
-    /// - Setting the hidden layer to the right size
-    /// - Restoring the random weights for the input-to-hidden connections
-    /// - Restoring the trained weights for the hidden-to-output connections
-    /// 
-    /// By reading these details, the ELM can be reconstructed exactly as it was
-    /// when it was saved, preserving all its behavior and learned patterns.
-    /// </para>
-    /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        // Read hidden layer size
-        int hiddenLayerSize = reader.ReadInt32();
 
-        // Check if the hiddenLayerSize matches the current instance
-        if (hiddenLayerSize != _hiddenLayerSize)
-        {
-            Console.WriteLine($"Warning: Loaded ELM has hidden layer size {hiddenLayerSize}, " +
-                             $"but current instance has size {_hiddenLayerSize}");
-        }
-
-        // Read training mode
-        IsTrainingMode = reader.ReadBoolean();
-    }
 
     /// <summary>
     /// Trains the ELM using regularized least squares for improved generalization.
@@ -530,31 +468,4 @@ public void TrainWithRegularization(Tensor<T> input, Tensor<T> expectedOutput, d
         // STEP 3: Update only the last layer (output layer) with the calculated weights
         UpdateOutputLayerWeights(outputWeights);
     }
-
-    /// <summary>
-    /// Creates a new instance of the ExtremeLearningMachine with the same configuration as the current instance.
-    /// </summary>
-    /// <returns>A new ExtremeLearningMachine instance with the same architecture and hidden layer size as the current instance.</returns>
-    /// <remarks>
-    /// <para>
-    /// This method creates a new instance of the ExtremeLearningMachine with the same architecture and hidden layer size
-    /// as the current instance. This is useful for model cloning, ensemble methods, or cross-validation scenarios where
-    /// multiple instances of the same model with identical configurations are needed.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method creates a fresh copy of the ELM's blueprint.
-    /// 
-    /// When you need multiple versions of the same type of ELM with identical settings:
-    /// - This method creates a new, empty ELM with the same configuration
-    /// - It's like making a copy of a recipe before you start cooking
-    /// - The new ELM has the same structure but no trained data
-    /// - This is useful for techniques that need multiple models, like ensemble methods
-    /// 
-    /// For example, when training multiple ELMs on different subsets of data,
-    /// you'd want each one to have the same architecture and hidden layer size.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new ExtremeLearningMachine<T>(Architecture, _hiddenLayerSize);
-    }
 }
diff --git a/src/NeuralNetworks/FalconMambaLanguageModel.cs b/src/NeuralNetworks/FalconMambaLanguageModel.cs
index 8816363188..8148ac79f7 100644
--- a/src/NeuralNetworks/FalconMambaLanguageModel.cs
+++ b/src/NeuralNetworks/FalconMambaLanguageModel.cs
@@ -39,7 +39,7 @@ namespace AiDotNet.NeuralNetworks;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Falcon Mamba: The First Competitive Attention-free 7B Language Model", "https://arxiv.org/abs/2410.05355", Year = 2024, Authors = "Jingwei Zuo, Younes Belkada, Paul Music, Rouven Bauer, Komal Kumar Bein, Yago Gimenez")]
-public class FalconMambaLanguageModel<T> : TokenLanguageModelLayoutBase<T>
+public partial class FalconMambaLanguageModel<T> : TokenLanguageModelLayoutBase<T>
 {
     private readonly FalconMambaOptions _options;
     private readonly int _vocabSize;
@@ -153,32 +153,9 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_vocabSize);
-        writer.Write(_modelDimension);
-        writer.Write(_numLayers);
-        writer.Write(_stateDimension);
-        writer.Write(_expandFactor);
-        writer.Write(_maxSeqLength);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _ = reader.ReadInt32();
-        _ = reader.ReadInt32();
-        _ = reader.ReadInt32();
-        _ = reader.ReadInt32();
-        _ = reader.ReadInt32();
-        _ = reader.ReadInt32();
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new FalconMambaLanguageModel<T>(
-            Architecture, _vocabSize, _modelDimension, _numLayers, _stateDimension,
-            _expandFactor, _maxSeqLength, LossFunction, _options);
-    }
+
 
     #endregion
 }
diff --git a/src/NeuralNetworks/FastText.cs b/src/NeuralNetworks/FastText.cs
index 9278118e71..d4bc6f0193 100644
--- a/src/NeuralNetworks/FastText.cs
+++ b/src/NeuralNetworks/FastText.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
@@ -48,7 +48,7 @@ namespace AiDotNet.NeuralNetworks
     [ModelComplexity(ModelComplexity.Low)]
     [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
     [ResearchPaper("Enriching Word Vectors with Subword Information", "https://arxiv.org/abs/1607.04606", Year = 2017, Authors = "Piotr Bojanowski, Edouard Grave, Armand Joulin, Tomas Mikolov")]
-    public class FastText<T> : TextEmbeddingModelLayoutBase<T>, IEmbeddingModel<T>
+    public partial class FastText<T> : TextEmbeddingModelLayoutBase<T>, IEmbeddingModel<T>
     {
         private readonly FastTextOptions _options;
 
@@ -403,21 +403,6 @@ public Task<Matrix<T>> EmbedBatchAsync(IEnumerable<string> texts)
             return Task.FromResult(EmbedBatch(texts));
         }
 
-        /// <inheritdoc/>
-        protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-        {
-            return new FastText<T>(
-                Architecture,
-                _tokenizer,
-                null,
-                _vocabSize,
-                _bucketSize,
-                _embeddingDimension,
-                _maxTokens,
-                _lossFunction,
-                Convert.ToDouble(MaxGradNorm));
-        }
-
         /// <summary>
         /// Retrieves detailed metadata about the FastText model configuration.
         /// </summary>
@@ -439,36 +424,10 @@ public override ModelMetadata<T> GetModelMetadata()
         }
 
         /// <inheritdoc/>
-        protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-        {
-            writer.Write(_vocabSize);
-            writer.Write(_bucketSize);
-            writer.Write(_embeddingDimension);
-            writer.Write(_maxTokens);
-        }
+
 
         /// <inheritdoc/>
-        protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-        {
-            int vocabSize = reader.ReadInt32();
-            int bucketSize = reader.ReadInt32();
-            int embeddingDimension = reader.ReadInt32();
-            int maxTokens = reader.ReadInt32();
-
-            if (vocabSize <= 0)
-                throw new InvalidDataException($"Invalid vocab size '{vocabSize}' in FastText serialization.");
-            if (bucketSize <= 0)
-                throw new InvalidDataException($"Invalid bucket size '{bucketSize}' in FastText serialization.");
-            if (embeddingDimension <= 0)
-                throw new InvalidDataException($"Invalid embedding dimension '{embeddingDimension}' in FastText serialization.");
-            if (maxTokens <= 0)
-                throw new InvalidDataException($"Invalid max tokens '{maxTokens}' in FastText serialization.");
 
-            _vocabSize = vocabSize;
-            _bucketSize = bucketSize;
-            _embeddingDimension = embeddingDimension;
-            _maxTokens = maxTokens;
-        }
 
         #endregion
     }
diff --git a/src/NeuralNetworks/FeedForwardNeuralNetwork.cs b/src/NeuralNetworks/FeedForwardNeuralNetwork.cs
index ad0b32a751..192befb9e1 100644
--- a/src/NeuralNetworks/FeedForwardNeuralNetwork.cs
+++ b/src/NeuralNetworks/FeedForwardNeuralNetwork.cs
@@ -39,7 +39,7 @@ namespace AiDotNet.NeuralNetworks;
 [ModelComplexity(ModelComplexity.Low)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
     [ResearchPaper("Learning Internal Representations by Error Propagation", "https://doi.org/10.21236/ADA164453")]
-public class FeedForwardNeuralNetwork<T> : SequentialVectorModelLayoutBase<T>
+public partial class FeedForwardNeuralNetwork<T> : SequentialVectorModelLayoutBase<T>
 {
     private readonly FeedForwardNeuralNetworkOptions _options;
 
@@ -510,61 +510,9 @@ public override ModelMetadata<T> GetModelMetadata()
     /// This is useful when you want to save a trained model for later use.
     /// </para>
     /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        // Serialize optimizer and loss function interfaces
-        SerializationHelper<T>.SerializeInterface(writer, _optimizer);
-        SerializationHelper<T>.SerializeInterface(writer, _lossFunction);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        // Deserialize and restore optimizer
-        var optimizer = DeserializationHelper.DeserializeInterface<IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>>(reader);
-        if (optimizer != null)
-        {
-            _optimizer = optimizer;
-        }
 
-        // Deserialize and restore loss function
-        var lossFunction = DeserializationHelper.DeserializeInterface<ILossFunction<T>>(reader);
-        if (lossFunction != null)
-        {
-            _lossFunction = lossFunction;
-        }
-    }
 
-    /// <summary>
-    /// Creates a new instance of the FeedForwardNeuralNetwork with the same configuration as the current instance.
-    /// </summary>
-    /// <returns>A new FeedForwardNeuralNetwork instance with the same architecture, optimizer, and loss function as the current instance.</returns>
-    /// <remarks>
-    /// <para>
-    /// This method creates a new instance of the FeedForwardNeuralNetwork with the same architecture, optimizer, and loss function
-    /// as the current instance. This is useful for model cloning, ensemble methods, or cross-validation scenarios where
-    /// multiple instances of the same model with identical configurations are needed.
-    /// </para>
-    /// <para>
-    /// <b>For Beginners:</b> This method creates a fresh copy of the neural network's blueprint.
-    /// 
-    /// When you need multiple versions of the same type of neural network with identical settings:
-    /// - This method creates a new, empty network with the same configuration
-    /// - It's like making a copy of a recipe before you start cooking
-    /// - The new network has the same structure but no trained data
-    /// - This is useful for techniques that need multiple models, like ensemble methods
-    /// 
-    /// For example, when testing your model on different subsets of data,
-    /// you'd want each test to use a model with identical settings.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new FeedForwardNeuralNetwork<T>(
-            Architecture,
-            _optimizer,
-            _lossFunction,
-            Convert.ToDouble(MaxGradNorm));
-    }
 
     /// <summary>
     /// Indicates whether this network supports training.
diff --git a/src/NeuralNetworks/FinchLanguageModel.cs b/src/NeuralNetworks/FinchLanguageModel.cs
index b99f7e728f..4c64790897 100644
--- a/src/NeuralNetworks/FinchLanguageModel.cs
+++ b/src/NeuralNetworks/FinchLanguageModel.cs
@@ -42,7 +42,7 @@ namespace AiDotNet.NeuralNetworks;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Eagle and Finch: RWKV with Matrix-Valued States and Dynamic Recurrence", "https://arxiv.org/abs/2404.05892", Year = 2024, Authors = "Bo Peng, Daniel Goldstein, Quentin Anthony, Alon Albalak, Eric Alcaide, Stella Biderman, Eugene Cheah, Teddy Ferdinan, Haowen Hou, Przemyslaw Kazienko, Kranthi Kiran GV, Jan Kocon, Bartlomiej Koptyra, Satyapriya Krishna, Ronald McClelland Jr., Niklas Muennighoff, Fares Obeid, Atsushi Saito, Guangyu Song, Haoqin Tu, Stanislaw Wozniak, Ruichong Zhang, Bingchen Zhao, Qihang Zhao, Peng Zhou, Jian Zhu, Rui-Jie Zhu")]
-public class FinchLanguageModel<T> : TokenLanguageModelLayoutBase<T>
+public partial class FinchLanguageModel<T> : TokenLanguageModelLayoutBase<T>
 {
     private readonly FinchOptions _options;
     private readonly int _vocabSize;
@@ -157,30 +157,9 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_vocabSize);
-        writer.Write(_modelDimension);
-        writer.Write(_numLayers);
-        writer.Write(_numHeads);
-        writer.Write(_maxSeqLength);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _ = reader.ReadInt32();
-        _ = reader.ReadInt32();
-        _ = reader.ReadInt32();
-        _ = reader.ReadInt32();
-        _ = reader.ReadInt32();
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new FinchLanguageModel<T>(
-            Architecture, _vocabSize, _modelDimension, _numLayers, _numHeads,
-            _maxSeqLength, LossFunction, _options, _learningRate);
-    }
+
 
     #endregion
 }
diff --git a/src/NeuralNetworks/FlamingoNeuralNetwork.cs b/src/NeuralNetworks/FlamingoNeuralNetwork.cs
index 0e9e97fc12..4e6bca06e0 100644
--- a/src/NeuralNetworks/FlamingoNeuralNetwork.cs
+++ b/src/NeuralNetworks/FlamingoNeuralNetwork.cs
@@ -1,1176 +1,1132 @@
-using System.IO;
-using AiDotNet.ActivationFunctions;
-using AiDotNet.Attributes;
-using AiDotNet.Autodiff;
-using AiDotNet.Enums;
-using AiDotNet.Helpers;
-using AiDotNet.Interfaces;
-using AiDotNet.LinearAlgebra;
-using AiDotNet.LossFunctions;
-using AiDotNet.Helpers;
-using AiDotNet.NeuralNetworks.Layers;
-using AiDotNet.NeuralNetworks.Options;
-using AiDotNet.Tensors.Helpers;
-using AiDotNet.Tokenization;
-using AiDotNet.Tokenization.Interfaces;
-using Microsoft.ML.OnnxRuntime;
-using AiDotNet.Validation;
-using OnnxTensors = Microsoft.ML.OnnxRuntime.Tensors;

+using System.IO;
+using AiDotNet.ActivationFunctions;
+using AiDotNet.Attributes;
+using AiDotNet.Autodiff;
+using AiDotNet.Enums;
+using AiDotNet.Helpers;
+using AiDotNet.Interfaces;
+using AiDotNet.LinearAlgebra;
+using AiDotNet.LossFunctions;
+using AiDotNet.Helpers;
+using AiDotNet.NeuralNetworks.Layers;
+using AiDotNet.NeuralNetworks.Options;
+using AiDotNet.Tensors.Helpers;
+using AiDotNet.Tokenization;
+using AiDotNet.Tokenization.Interfaces;
+using Microsoft.ML.OnnxRuntime;
+using AiDotNet.Validation;
+using OnnxTensors = Microsoft.ML.OnnxRuntime.Tensors;
+
 using System.Collections.Generic;
-
-namespace AiDotNet.NeuralNetworks;
-
-/// <summary>
-/// Flamingo neural network for in-context visual learning and few-shot tasks.
-/// </summary>
-/// <typeparam name="T">The numeric type used for calculations.</typeparam>
-/// <remarks>
-/// <para>
-/// Flamingo is a visual language model that excels at few-shot learning. It uses a Perceiver
-/// Resampler to compress visual features and gated cross-attention layers to integrate
-/// visual information into a frozen language model.
-/// </para>
-/// <para><b>For Beginners:</b> Flamingo is a visual AI that can answer questions about images
-/// with just a few examples. Show it 2-3 examples of image-answer pairs, and it can handle
-/// similar questions about new images. It works by feeding image features into a language
-/// model through special cross-attention layers, letting the language model "see" the image
-/// while generating text responses.</para>
-/// </remarks>
-/// <example>
-/// <code>
-/// var options = new FlamingoOptions { ImageSize = 224, MaxTextLength = 256 };
-/// var model = new FlamingoNeuralNetwork&lt;float&gt;(options);
-/// var image = Tensor&lt;float&gt;.Random(new[] { 1, 3, 224, 224 });
-/// var output = model.Predict(image);
-/// </code>
-/// </example>
-[ModelDomain(ModelDomain.Vision)]
-[ModelDomain(ModelDomain.Language)]
-[ModelDomain(ModelDomain.Multimodal)]
-[ModelCategory(ModelCategory.NeuralNetwork)]
-[ModelCategory(ModelCategory.Transformer)]
-[ModelTask(ModelTask.Generation)]
-[ModelTask(ModelTask.Classification)]
-[ModelComplexity(ModelComplexity.High)]
-[ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
-[ResearchPaper("Flamingo: a Visual Language Model for Few-Shot Learning", "https://arxiv.org/abs/2204.14198", Year = 2022, Authors = "Jean-Baptiste Alayrac, Jeff Donahue, Pauline Luc, Antoine Miech, Iain Barr, Yana Hasson, Karel Lenc, Arthur Mensch, Katie Millican, Malcolm Reynolds, Roman Ring, Eliza Rutherford, Serkan Cabi, Tengda Han, Zhitao Gong, Sina Samangooei, Marianne Monteiro, Jacob Menick, Sebastian Borgeaud, Andrew Brock, Aida Nematzadeh, Sahand Sharifzadeh, Mikolaj Binkowski, Ricardo Barreira, Oriol Vinyals, Andrew Zisserman, Karen Simonyan")]
+
+namespace AiDotNet.NeuralNetworks;
+
+/// <summary>
+/// Flamingo neural network for in-context visual learning and few-shot tasks.
+/// </summary>
+/// <typeparam name="T">The numeric type used for calculations.</typeparam>
+/// <remarks>
+/// <para>
+/// Flamingo is a visual language model that excels at few-shot learning. It uses a Perceiver
+/// Resampler to compress visual features and gated cross-attention layers to integrate
+/// visual information into a frozen language model.
+/// </para>
+/// <para><b>For Beginners:</b> Flamingo is a visual AI that can answer questions about images
+/// with just a few examples. Show it 2-3 examples of image-answer pairs, and it can handle
+/// similar questions about new images. It works by feeding image features into a language
+/// model through special cross-attention layers, letting the language model "see" the image
+/// while generating text responses.</para>
+/// </remarks>
+/// <example>
+/// <code>
+/// var options = new FlamingoOptions { ImageSize = 224, MaxTextLength = 256 };
+/// var model = new FlamingoNeuralNetwork&lt;float&gt;(options);
+/// var image = Tensor&lt;float&gt;.Random(new[] { 1, 3, 224, 224 });
+/// var output = model.Predict(image);
+/// </code>
+/// </example>
+[ModelDomain(ModelDomain.Vision)]
+[ModelDomain(ModelDomain.Language)]
+[ModelDomain(ModelDomain.Multimodal)]
+[ModelCategory(ModelCategory.NeuralNetwork)]
+[ModelCategory(ModelCategory.Transformer)]
+[ModelTask(ModelTask.Generation)]
+[ModelTask(ModelTask.Classification)]
+[ModelComplexity(ModelComplexity.High)]
+[ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
+[ResearchPaper("Flamingo: a Visual Language Model for Few-Shot Learning", "https://arxiv.org/abs/2204.14198", Year = 2022, Authors = "Jean-Baptiste Alayrac, Jeff Donahue, Pauline Luc, Antoine Miech, Iain Barr, Yana Hasson, Karel Lenc, Arthur Mensch, Katie Millican, Malcolm Reynolds, Roman Ring, Eliza Rutherford, Serkan Cabi, Tengda Han, Zhitao Gong, Sina Samangooei, Marianne Monteiro, Jacob Menick, Sebastian Borgeaud, Andrew Brock, Aida Nematzadeh, Sahand Sharifzadeh, Mikolaj Binkowski, Ricardo Barreira, Oriol Vinyals, Andrew Zisserman, Karen Simonyan")]
 public partial class FlamingoNeuralNetwork<T> : MultimodalModelLayoutBase<T>, IFlamingoModel<T>
-{
-    private readonly FlamingoOptions _options;
-
-    /// <inheritdoc/>
-    public override ModelOptions GetOptions() => _options;
-
-    #region Execution Mode
-
-    private readonly bool _useNativeMode;
-
-    #endregion
-
-    #region ONNX Mode Fields
-
-    private readonly InferenceSession? _visionEncoder;
-    private readonly InferenceSession? _languageModel;
-    private readonly string? _visionEncoderPath;
-    private readonly string? _languageModelPath;
-
-    #endregion
-
-    #region Native Mode Fields
-
-    private readonly List<ILayer<T>> _visionEncoderLayers = [];
-    private readonly List<ILayer<T>> _perceiverLayers = [];
-    private readonly List<ILayer<T>> _gatedCrossAttentionLayers = [];
-    private readonly List<ILayer<T>> _languageModelLayers = [];
-    private Tensor<T>? _perceiverQueries;
-    private Tensor<T>? _visionPositionalEmbeddings;
-    private ILayer<T>? _patchEmbedding;
-    private ILayer<T>? _textTokenEmbedding;
-    private Tensor<T>? _textPositionalEmbeddings;
-    private ILayer<T>? _outputProjection;
-
-    #endregion
-
-    #region Shared Fields
-
-    private readonly ITokenizer _tokenizer;
-    private readonly IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>> _optimizer;
-    private readonly ILossFunction<T> _lossFunction;
-    private readonly int _embeddingDimension;
-    private readonly int _maxSequenceLength;
-    private readonly int _imageSize;
-
-    /// <summary>
-    /// The input channel count the native layers were built for.
-    /// </summary>
-    /// <remarks>
-    /// The constructor took this and forwarded it to InitializeNativeLayers without keeping it, so
-    /// two places in the clone path assumed 3. The shape probe built a 3-channel tensor, which
-    /// makes ResolveShapes throw for a 1- or 4-channel model and drops the copy into the fallback
-    /// -- copying from unresolved lazy projections, the exact failure that probe was added to
-    /// prevent -- and CreateNewInstance passed the literal 3, silently rebuilding the clone with an
-    /// RGB patch embedding whatever the original used.
-    /// </remarks>
-    private readonly int _channels;
-    private readonly int _visionHiddenDim;
-    private readonly int _lmHiddenDim;
-    private readonly int _numVisionLayers;
-    private readonly int _numLmLayers;
-    private readonly int _numHeads;
-    private readonly int _patchSize;
-    private readonly int _vocabularySize;
-    private readonly LanguageModelBackbone _languageModelBackbone;
-    private readonly int _numPerceiverTokens;
-    private readonly int _maxImagesInContext;
-    private readonly int _numPerceiverLayers;
-    private readonly double _learningRate;
-
-    #endregion
-
-    #region IMultimodalEmbedding Properties
-
-    /// <inheritdoc/>
-    public int EmbeddingDimension => _embeddingDimension;
-
-    /// <inheritdoc/>
-    public int MaxSequenceLength => _maxSequenceLength;
-
-    /// <inheritdoc/>
-    public int ImageSize => _imageSize;
-
-    #endregion
-
-    #region IFlamingoModel Properties
-
-    /// <inheritdoc/>
-    public int NumPerceiverTokens => _numPerceiverTokens;
-
-    /// <inheritdoc/>
-    public int MaxImagesInContext => _maxImagesInContext;
-
-    /// <inheritdoc/>
-    public LanguageModelBackbone LanguageModelBackbone => _languageModelBackbone;
-
-    #endregion
-
-    #region Constructors
-
-    /// <summary>
-    /// Initializes a new instance using ONNX models.
-    /// </summary>
-    public FlamingoNeuralNetwork(
-        NeuralNetworkArchitecture<T> architecture,
-        string visionEncoderPath,
-        string languageModelPath,
-        ITokenizer tokenizer,
-        int embeddingDimension = 768,
-        int maxSequenceLength = 2048,
-        int imageSize = 224,
-        int numPerceiverTokens = 64,
-        int maxImagesInContext = 5,
-        IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? optimizer = null,
-        ILossFunction<T>? lossFunction = null,
-        FlamingoOptions? options = null)
-        : base(architecture, lossFunction ?? new CrossEntropyWithLogitsLoss<T>(), 1.0)
-    {
-        _options = options ?? new FlamingoOptions();
-        Options = _options;
-        if (string.IsNullOrWhiteSpace(visionEncoderPath))
-            throw new ArgumentException("Vision encoder path cannot be null or empty.", nameof(visionEncoderPath));
-        if (string.IsNullOrWhiteSpace(languageModelPath))
-            throw new ArgumentException("Language model path cannot be null or empty.", nameof(languageModelPath));
-        if (!File.Exists(visionEncoderPath))
-            throw new FileNotFoundException($"Vision encoder model not found: {visionEncoderPath}");
-        if (!File.Exists(languageModelPath))
-            throw new FileNotFoundException($"Language model not found: {languageModelPath}");
-
-        _useNativeMode = false;
-        _visionEncoderPath = visionEncoderPath;
-        _languageModelPath = languageModelPath;
-        _embeddingDimension = embeddingDimension;
-        _maxSequenceLength = maxSequenceLength;
-        _imageSize = imageSize;
-        _numPerceiverTokens = numPerceiverTokens;
-        _maxImagesInContext = maxImagesInContext;
-        _visionHiddenDim = 1024;
-        _lmHiddenDim = 2048;
-        _numVisionLayers = 24;
-        _numLmLayers = 32;
-        _numHeads = 16;
-        _patchSize = 14;
-        _vocabularySize = 32000;
-        _languageModelBackbone = LanguageModelBackbone.Chinchilla;
-        _numPerceiverLayers = 6;
-        // 1e-3 is the CODEBASE Adam default, chosen deliberately rather than taken from the paper.
-        // Alayrac et al. 2022 specify their schedule in section 3 and Appendix B, and it is not a
-        // single constant: a linear warm-up to 1e-4 over the first 5000 steps, then cosine decay,
-        // over an accelerator budget this implementation does not assume. Pinning a number lifted
-        // from the middle of that schedule would look like a citation while reproducing none of it,
-        // so the framework default is used and the deviation is stated here instead. Callers
-        // reproducing the paper should pass their own optimizer with the published schedule.
-        _learningRate = 1e-3;
-
-        InferenceSession? visionEncoder = null;
-        InferenceSession? languageModel = null;
-
-        try
-        {
-            visionEncoder = new InferenceSession(visionEncoderPath);
-            languageModel = new InferenceSession(languageModelPath);
-            _visionEncoder = visionEncoder;
-            _languageModel = languageModel;
-            // Tokenizer is required for ONNX mode - must match the language model backbone
-            Guard.NotNull(tokenizer);
-            _tokenizer = tokenizer;
-            _optimizer = optimizer ?? new AdamOptimizer<T, Tensor<T>, Tensor<T>>(this);
-            _lossFunction = lossFunction ?? new CrossEntropyWithLogitsLoss<T>();
-            InitializeLayers();
-        }
-        catch
-        {
-            visionEncoder?.Dispose();
-            languageModel?.Dispose();
-            throw;
-        }
-    }
-
-    /// <summary>
-    /// Initializes a new instance using native layers.
-    /// </summary>
-    public FlamingoNeuralNetwork(
-        NeuralNetworkArchitecture<T> architecture,
-        int embeddingDimension = 768,
-        int maxSequenceLength = 2048,
-        int imageSize = 224,
-        int channels = 3,
-        int numPerceiverTokens = 64,
-        int maxImagesInContext = 5,
-        int visionHiddenDim = 1024,
-        int lmHiddenDim = 2048,
-        int numVisionLayers = 24,
-        int numLmLayers = 32,
-        int numHeads = 16,
-        int vocabularySize = 32000,
-        LanguageModelBackbone languageModelBackbone = LanguageModelBackbone.Chinchilla,
-        int numPerceiverLayers = 6,
-        ITokenizer? tokenizer = null,
-        IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? optimizer = null,
-        ILossFunction<T>? lossFunction = null,
-        FlamingoOptions? options = null,
-        double learningRate = 1e-3)
-        : base(architecture, lossFunction ?? new CrossEntropyWithLogitsLoss<T>(), 1.0)
-    {
-        // Validated here, at the public entry point, rather than where it is first used. ConvertToTensor
-        // divides by the channel count, and InitializeNativeLayers sizes the patch embedding from it, so
-        // a zero or negative value surfaces as a DivideByZeroException or an invalid tensor shape from
-        // somewhere well downstream of the argument that caused it.
-        if (channels <= 0)
-        {
-            throw new ArgumentOutOfRangeException(
-                nameof(channels), channels, "The channel count must be positive.");
-        }
-
-        _options = options ?? new FlamingoOptions();
-        Options = _options;
-        _useNativeMode = true;
-        _embeddingDimension = embeddingDimension;
-        _maxSequenceLength = maxSequenceLength;
-        _imageSize = imageSize;
-        _numPerceiverTokens = numPerceiverTokens;
-        _maxImagesInContext = maxImagesInContext;
-        _visionHiddenDim = visionHiddenDim;
-        _lmHiddenDim = lmHiddenDim;
-        _numVisionLayers = numVisionLayers;
-        _numLmLayers = numLmLayers;
-        _numHeads = numHeads;
-        _patchSize = 14;
-        _vocabularySize = vocabularySize;
-        _languageModelBackbone = languageModelBackbone;
-        _numPerceiverLayers = numPerceiverLayers;
-        _learningRate = learningRate;
-
-        // Use factory to create appropriate tokenizer for the backbone, or use provided tokenizer
-        _tokenizer = tokenizer ?? Tokenization.LanguageModelTokenizerFactory.CreateForBackbone(languageModelBackbone);
-        _optimizer = optimizer ?? new AdamOptimizer<T, Tensor<T>, Tensor<T>>(
-            this,
-            new AiDotNet.Models.Options.AdamOptimizerOptions<T, Tensor<T>, Tensor<T>>
-            {
-                InitialLearningRate = learningRate,
-                MaxGradientNorm = 1.0
-            });
-        _lossFunction = lossFunction ?? new CrossEntropyWithLogitsLoss<T>();
-
-        _channels = channels;
-        InitializeNativeLayers(channels);
-    }
-
-    /// <inheritdoc/>
-    protected override void InitializeLayers()
-    {
-        // ONNX mode initialization
-    }
-
-    private void InitializeNativeLayers(int channels)
-    {
-        int numPatches = (_imageSize / _patchSize) * (_imageSize / _patchSize);
-        int gatedCrossAttnCount = _numLmLayers / 4;
-
-        Layers.Clear();
-
-        if (Architecture.Layers != null && Architecture.Layers.Count > 0)
-        {
-            Layers.AddRange(Architecture.Layers);
-        }
-        else
-        {
-            Layers.AddRange(LayerHelper<T>.CreateFlamingoLayers(
-                _imageSize, channels, _patchSize, _visionHiddenDim, _lmHiddenDim,
-                _numVisionLayers, _numPerceiverLayers, _numPerceiverTokens,
-                _numLmLayers, _numHeads, _vocabularySize, _maxSequenceLength));
-        }
-
-        RebindNativeLayerReferences();
-
-        // Initialize vision positional embeddings
-        _visionPositionalEmbeddings = new Tensor<T>([numPatches + 1, _visionHiddenDim]);
-        InitializePositionalEmbeddings(_visionPositionalEmbeddings);
-
-        // Initialize perceiver queries
-        _perceiverQueries = new Tensor<T>([_numPerceiverTokens, _lmHiddenDim]);
-        InitializePerceiverQueries(_perceiverQueries);
-
-        // Text positional embeddings
-        _textPositionalEmbeddings = new Tensor<T>([_maxSequenceLength, _lmHiddenDim]);
-        InitializePositionalEmbeddings(_textPositionalEmbeddings);
-    }
-
-    /// <summary>
-    /// Rebinds Flamingo's branch-specific layer references to the canonical base
-    /// <see cref="NeuralNetworkBase{T}.Layers"/> collection.
-    /// </summary>
-    /// <remarks>
-    /// The base clone paths replace or COW-share the canonical layer collection. Flamingo executes
-    /// through its branch lists rather than walking that collection sequentially, so those lists must
-    /// be rebound after cloning; copying parameters into the constructor's stale branch objects would
-    /// duplicate storage and bypass the base COW contract.
-    /// </remarks>
-    private void RebindNativeLayerReferences()
-    {
-        int gatedCrossAttnCount = _numLmLayers / 4;
-        int requiredLayers = 1 + _numVisionLayers + (3 * _numPerceiverLayers)
-            + gatedCrossAttnCount + 1 + _numLmLayers + 1;
-        // EXACTLY requiredLayers, NOT "at least". The distribution loop below consumes exactly
-        // requiredLayers entries, so a surplus passed this guard and was then bound to nothing --
-        // yet stayed in the canonical Layers collection, so it was still serialized, still counted
-        // toward ParameterCount, and still updated by training, while contributing nothing to any
-        // forward path. A caller who supplied one layer too many got a model that trained weights
-        // it never used and reported a parameter count it could not explain.
-        if (Layers.Count != requiredLayers)
-        {
-            throw new InvalidOperationException(
-                $"Flamingo layer graph contains {Layers.Count} layers but exactly {requiredLayers} are "
-                + "required; every layer is bound to a named execution branch, so a surplus would be "
-                + "trained and serialized without ever being used.");
-        }
-
-        // Distribute canonical layers to the private execution branches.
-        int idx = 0;
-
-        // Patch embedding
-        _patchEmbedding = Layers[idx++];
-
-        // Vision encoder transformer layers
-        _visionEncoderLayers.Clear();
-        for (int i = 0; i < _numVisionLayers; i++)
-            _visionEncoderLayers.Add(Layers[idx++]);
-
-        // Perceiver Resampler layers: (CrossAttn + FFN_expand + FFN_contract) × numPerceiverLayers
-        _perceiverLayers.Clear();
-        for (int i = 0; i < _numPerceiverLayers; i++)
-        {
-            _perceiverLayers.Add(Layers[idx++]); // CrossAttention
-            _perceiverLayers.Add(Layers[idx++]); // FFN expand
-            _perceiverLayers.Add(Layers[idx++]); // FFN contract
-        }
-
-        // Gated cross-attention layers
-        _gatedCrossAttentionLayers.Clear();
-        for (int i = 0; i < gatedCrossAttnCount; i++)
-            _gatedCrossAttentionLayers.Add(Layers[idx++]);
-
-        // Text token embedding
-        _textTokenEmbedding = Layers[idx++];
-
-        // Language model transformer layers
-        _languageModelLayers.Clear();
-        for (int i = 0; i < _numLmLayers; i++)
-            _languageModelLayers.Add(Layers[idx++]);
-
-        // Output projection
-        _outputProjection = Layers[idx++];
-    }
-
-    private void InitializePositionalEmbeddings(Tensor<T> embeddings)
-    {
-        for (int i = 0; i < embeddings.Shape[0]; i++)
-        {
-            for (int j = 0; j < embeddings.Shape[1]; j++)
-            {
-                double angle = i / Math.Pow(10000, 2.0 * (j / 2) / embeddings.Shape[1]);
-                double value = j % 2 == 0 ? Math.Sin(angle) : Math.Cos(angle);
-                embeddings[i, j] = NumOps.FromDouble(value);
-            }
-        }
-    }
-
-    private void InitializePerceiverQueries(Tensor<T> queries)
-    {
-        var rand = RandomHelper.CreateSeededRandom(42);
-        double scale = 1.0 / Math.Sqrt(queries.Shape[1]);
-        for (int i = 0; i < queries.Shape[0]; i++)
-        {
-            for (int j = 0; j < queries.Shape[1]; j++)
-            {
-                double value = (rand.NextDouble() * 2 - 1) * scale;
-                queries[i, j] = NumOps.FromDouble(value);
-            }
-        }
-    }
-
-    #endregion
-
-    #region IMultimodalEmbedding Implementation
-
-    /// <inheritdoc/>
-    public Vector<T> GetImageEmbedding(Tensor<T> image)
-    {
-        return GetImageEmbeddings([image]).First();
-    }
-
-    /// <inheritdoc/>
-    public IEnumerable<Vector<T>> GetImageEmbeddings(IEnumerable<Tensor<T>> images)
-    {
-        var results = new List<Vector<T>>();
-        foreach (var image in images)
-        {
-            var features = ExtractPerceiverFeatures(image);
-            var embedding = MeanPool(features);
-            var normalized = Normalize(embedding);
-            results.Add(normalized);
-        }
-        return results;
-    }
-
-    /// <inheritdoc/>
-    public Vector<T> GetTextEmbedding(string text)
-    {
-        if (string.IsNullOrWhiteSpace(text))
-            throw new ArgumentException("Text cannot be null or empty.", nameof(text));
-
-        return GetTextEmbeddings([text]).First();
-    }
-
-    /// <inheritdoc/>
-    public IEnumerable<Vector<T>> GetTextEmbeddings(IEnumerable<string> texts)
-    {
-        var results = new List<Vector<T>>();
-
-        foreach (var text in texts)
-        {
-            var encoded = _tokenizer.Encode(text);
-            var inputIds = encoded.TokenIds;
-
-            var paddedIds = new List<int>();
-            for (int i = 0; i < _maxSequenceLength; i++)
-            {
-                paddedIds.Add(i < inputIds.Count ? inputIds[i] : 0);
-            }
-
-            var embedded = EmbedTextTokens(paddedIds);
-            var embedding = MeanPool(embedded);
-            var normalized = Normalize(embedding);
-            results.Add(normalized);
-        }
-
-        return results;
-    }
-
-    private Tensor<T> EmbedTextTokens(IReadOnlyList<int> tokenIds)
-    {
-        int seqLen = tokenIds.Count;
-        var embeddings = Tensor<T>.CreateDefault([seqLen, _lmHiddenDim], NumOps.Zero);
-
-        if (_textTokenEmbedding is null || _textPositionalEmbeddings is null)
-        {
-            return embeddings;
-        }
-
-        for (int i = 0; i < seqLen; i++)
-        {
-            var tokenInput = Tensor<T>.CreateDefault([1], NumOps.FromDouble(tokenIds[i]));
-            var tokenEmb = _textTokenEmbedding.Forward(tokenInput);
-
-            for (int j = 0; j < _lmHiddenDim; j++)
-            {
-                T posEmb = i < _textPositionalEmbeddings.Shape[0] ? _textPositionalEmbeddings[i, j] : NumOps.Zero;
-                embeddings[i, j] = NumOps.Add(tokenEmb[0, j], posEmb);
-            }
-        }
-
-        return embeddings;
-    }
-
-    private Vector<T> MeanPool(Tensor<T> features)
-    {
-        int seqLen = features.Shape[0];
-        int hiddenDim = features.Shape[1];
-        var result = new Vector<T>(hiddenDim);
-
-        for (int j = 0; j < hiddenDim; j++)
-        {
-            T sum = NumOps.Zero;
-            for (int i = 0; i < seqLen; i++)
-            {
-                sum = NumOps.Add(sum, features[i, j]);
-            }
-            result[j] = NumOps.Divide(sum, NumOps.FromDouble(seqLen));
-        }
-
-        return result;
-    }
-
-    private Vector<T> Normalize(Vector<T> vec)
-    {
-        return VectorHelper.Normalize(vec);
-    }
-
-    /// <inheritdoc/>
-    public T ComputeSimilarity(Vector<T> embedding1, Vector<T> embedding2)
-    {
-        T dotProduct = NumOps.Zero;
-        T norm1 = NumOps.Zero;
-        T norm2 = NumOps.Zero;
-
-        for (int i = 0; i < embedding1.Length && i < embedding2.Length; i++)
-        {
-            dotProduct = NumOps.Add(dotProduct, NumOps.Multiply(embedding1[i], embedding2[i]));
-            norm1 = NumOps.Add(norm1, NumOps.Multiply(embedding1[i], embedding1[i]));
-            norm2 = NumOps.Add(norm2, NumOps.Multiply(embedding2[i], embedding2[i]));
-        }
-
-        T normProduct = NumOps.Multiply(NumOps.Sqrt(norm1), NumOps.Sqrt(norm2));
-        if (NumOps.LessThan(normProduct, NumOps.FromDouble(1e-10)))
-            return NumOps.Zero;
-
-        return NumOps.Divide(dotProduct, normProduct);
-    }
-
-    /// <inheritdoc/>
-    public T ComputeImageTextSimilarity(Tensor<T> image, string text)
-    {
-        var imageEmbedding = GetImageEmbedding(image);
-        var textEmbedding = GetTextEmbedding(text);
-        return ComputeSimilarity(imageEmbedding, textEmbedding);
-    }
-
-    /// <inheritdoc/>
-    public Dictionary<string, T> ZeroShotClassify(Tensor<T> image, IEnumerable<string> classLabels)
-    {
-        var imageEmbedding = GetImageEmbedding(image);
-        var result = new Dictionary<string, T>();
-        var scores = new List<(string label, T score)>();
-
-        foreach (var label in classLabels)
-        {
-            var textEmbedding = GetTextEmbedding(label);
-            var similarity = ComputeSimilarity(imageEmbedding, textEmbedding);
-            scores.Add((label, similarity));
-        }
-
-        var expScores = scores.Select(s => (s.label, exp: Math.Exp(NumOps.ToDouble(s.score)))).ToList();
-        double sumExp = expScores.Sum(s => s.exp);
-
-        foreach (var (label, exp) in expScores)
-        {
-            result[label] = NumOps.FromDouble(exp / sumExp);
-        }
-
-        return result;
-    }
-
-    /// <inheritdoc/>
-    public IEnumerable<(int Index, T Score)> RetrieveImages(
-        string query,
-        IEnumerable<Vector<T>> imageEmbeddings,
-        int topK = 10)
-    {
-        var queryEmbedding = GetTextEmbedding(query);
-        var embeddingsList = imageEmbeddings.ToList();
-        var scores = new List<(int Index, T Score)>();
-
-        for (int i = 0; i < embeddingsList.Count; i++)
-        {
-            var similarity = ComputeSimilarity(queryEmbedding, embeddingsList[i]);
-            scores.Add((i, similarity));
-        }
-
-        return scores.OrderByDescending(s => NumOps.ToDouble(s.Score)).Take(topK);
-    }
-
-    /// <inheritdoc/>
-    public IEnumerable<(int Index, T Score)> RetrieveTexts(
-        Tensor<T> image,
-        IEnumerable<string> texts,
-        int topK = 10)
-    {
-        var imageEmbedding = GetImageEmbedding(image);
-        var textsList = texts.ToList();
-        var scores = new List<(int Index, T Score)>();
-
-        for (int i = 0; i < textsList.Count; i++)
-        {
-            var textEmbedding = GetTextEmbedding(textsList[i]);
-            var similarity = ComputeSimilarity(imageEmbedding, textEmbedding);
-            scores.Add((i, similarity));
-        }
-
-        return scores.OrderByDescending(s => NumOps.ToDouble(s.Score)).Take(topK);
-    }
-
-    /// <inheritdoc/>
-    public string GenerateCaption(Tensor<T> image, int maxLength = 77)
-    {
-        return FewShotGenerate([], image, "Describe this image:", maxLength);
-    }
-
-    /// <inheritdoc/>
-    public string AnswerQuestion(Tensor<T> image, string question, int maxLength = 64)
-    {
-        return FewShotVQA([], image, question);
-    }
-
-    #endregion
-
-    #region IFlamingoModel Implementation
-
-    /// <inheritdoc/>
-    public string FewShotGenerate(
-        IEnumerable<(Tensor<T> Image, string Text)> examples,
-        Tensor<T> queryImage,
-        string? queryPrompt = null,
-        int maxLength = 256)
-    {
-        var examplesList = examples.ToList();
-        if (examplesList.Count > _maxImagesInContext)
-        {
-            throw new ArgumentException(
-                $"Too many examples. Maximum allowed: {_maxImagesInContext}",
-                nameof(examples));
-        }
-
-        var allImageFeatures = new List<Tensor<T>>();
-        foreach (var (image, _) in examplesList)
-        {
-            allImageFeatures.Add(ExtractPerceiverFeatures(image));
-        }
-        allImageFeatures.Add(ExtractPerceiverFeatures(queryImage));
-
-        var contextBuilder = new List<string>();
-        for (int i = 0; i < examplesList.Count; i++)
-        {
-            contextBuilder.Add($"<image>{examplesList[i].Text}");
-        }
-        contextBuilder.Add($"<image>{queryPrompt ?? ""}");
-
-        string context = string.Join(" ", contextBuilder);
-        var encoded = _tokenizer.Encode(context);
-        var inputIds = encoded.TokenIds;
-
-        return GenerateWithVisualContext(inputIds, allImageFeatures, maxLength);
-    }
-
-    /// <inheritdoc/>
-    public string GenerateWithMultipleImages(
-        IEnumerable<Tensor<T>> images,
-        string prompt,
-        int maxLength = 512)
-    {
-        var imagesList = images.ToList();
-        if (imagesList.Count > _maxImagesInContext)
-        {
-            throw new ArgumentException(
-                $"Too many images. Maximum allowed: {_maxImagesInContext}",
-                nameof(images));
-        }
-
-        var allImageFeatures = imagesList.Select(img => ExtractPerceiverFeatures(img)).ToList();
-        var encoded = _tokenizer.Encode(prompt);
-        var inputIds = encoded.TokenIds;
-
-        return GenerateWithVisualContext(inputIds, allImageFeatures, maxLength);
-    }
-
-    /// <inheritdoc/>
-    public Dictionary<string, T> InContextClassify(
-        IEnumerable<(Tensor<T> Image, string Label)> labeledExamples,
-        Tensor<T> queryImage)
-    {
-        var examplesList = labeledExamples.ToList();
-        var labels = examplesList.Select(e => e.Label).Distinct().ToList();
-
-        var examples = examplesList.Select(e => (e.Image, $"This is: {e.Label}")).ToList();
-        var generated = FewShotGenerate(examples, queryImage, "This is:", maxLength: 50);
-
-        var result = new Dictionary<string, T>();
-        double totalScore = 0;
-
-        foreach (var label in labels)
-        {
-            double score = generated.ToLowerInvariant().Contains(label.ToLowerInvariant()) ? 1.0 : 0.1;
-            totalScore += score;
-            result[label] = NumOps.FromDouble(score);
-        }
-
-        foreach (var label in labels)
-        {
-            result[label] = NumOps.Divide(result[label], NumOps.FromDouble(totalScore));
-        }
-
-        return result;
-    }
-
-    /// <inheritdoc/>
-    public string FewShotVQA(
-        IEnumerable<(Tensor<T> Image, string Question, string Answer)> examples,
-        Tensor<T> queryImage,
-        string question)
-    {
-        var examplesList = examples.ToList();
-        var fewShotExamples = examplesList.Select(e =>
-            (e.Image, $"Question: {e.Question}\nAnswer: {e.Answer}")).ToList();
-
-        return FewShotGenerate(
-            fewShotExamples,
-            queryImage,
-            $"Question: {question}\nAnswer:",
-            maxLength: 128);
-    }
-
-    /// <inheritdoc/>
-    public Tensor<T> ExtractPerceiverFeatures(Tensor<T> image)
-    {
-        var visionFeatures = ExtractVisionFeatures(image);
-
-        if (_useNativeMode)
-        {
-            return ExtractPerceiverFeaturesNative(visionFeatures);
-        }
-        else
-        {
-            return ExtractPerceiverFeaturesOnnx(visionFeatures);
-        }
-    }
-
-    private Tensor<T> ExtractVisionFeatures(Tensor<T> image)
-    {
-        if (_useNativeMode)
-        {
-            return ExtractVisionFeaturesNative(image);
-        }
-        else
-        {
-            return ExtractVisionFeaturesOnnx(image);
-        }
-    }
-
-    private Tensor<T> ExtractVisionFeaturesNative(Tensor<T> image)
-    {
-        if (_patchEmbedding is null || _visionPositionalEmbeddings is null)
-        {
-            throw new InvalidOperationException("Vision layers not initialized.");
-        }
-
-        var patchFeatures = _patchEmbedding.Forward(image);
-        int numPatches = patchFeatures.Shape[0];
-        int hiddenDim = patchFeatures.Shape.Length > 1 ? patchFeatures.Shape[1] : _visionHiddenDim;
-
-        var features = Tensor<T>.CreateDefault([numPatches, hiddenDim], NumOps.Zero);
-        for (int i = 0; i < numPatches && i < _visionPositionalEmbeddings.Shape[0]; i++)
-        {
-            for (int j = 0; j < hiddenDim && j < _visionPositionalEmbeddings.Shape[1]; j++)
-            {
-                features[i, j] = NumOps.Add(patchFeatures[i, j], _visionPositionalEmbeddings[i, j]);
-            }
-        }
-
-        var current = features;
-        foreach (var layer in _visionEncoderLayers)
-        {
-            current = layer.Forward(current);
-        }
-
-        return current;
-    }
-
-    private Tensor<T> ExtractVisionFeaturesOnnx(Tensor<T> image)
-    {
-        if (_visionEncoder is null)
-        {
-            throw new InvalidOperationException("Vision encoder not initialized.");
-        }
-
-        int channels = image.Shape[0];
-        int height = image.Shape[1];
-        int width = image.Shape[2];
-
-        var inputArray = new float[1 * channels * height * width];
-        int idx = 0;
-        for (int c = 0; c < channels; c++)
-        {
-            for (int h = 0; h < height; h++)
-            {
-                for (int w = 0; w < width; w++)
-                {
-                    inputArray[idx++] = (float)NumOps.ToDouble(image[c, h, w]);
-                }
-            }
-        }
-
-        var inputTensor = new OnnxTensors.DenseTensor<float>(inputArray, [1, channels, height, width]);
-        var inputs = new List<NamedOnnxValue>
-        {
-            NamedOnnxValue.CreateFromTensor("pixel_values", inputTensor)
-        };
-
-        using var results = _visionEncoder.Run(inputs);
-        var output = results.First().AsEnumerable<float>().ToArray();
-
-        int numPatches = (_imageSize / _patchSize) * (_imageSize / _patchSize);
-        var features = Tensor<T>.CreateDefault([numPatches, _visionHiddenDim], NumOps.Zero);
-
-        for (int i = 0; i < numPatches && i * _visionHiddenDim < output.Length; i++)
-        {
-            for (int j = 0; j < _visionHiddenDim; j++)
-            {
-                int outputIdx = i * _visionHiddenDim + j;
-                if (outputIdx < output.Length)
-                {
-                    features[i, j] = NumOps.FromDouble(output[outputIdx]);
-                }
-            }
-        }
-
-        return features;
-    }
-
-    private Tensor<T> ExtractPerceiverFeaturesNative(Tensor<T> visionFeatures)
-    {
-        if (_perceiverQueries is null)
-        {
-            throw new InvalidOperationException("Perceiver queries not initialized.");
-        }
-
-        var current = Tensor<T>.CreateDefault([_numPerceiverTokens, _lmHiddenDim], NumOps.Zero);
-        for (int i = 0; i < _numPerceiverTokens; i++)
-        {
-            for (int j = 0; j < _lmHiddenDim; j++)
-            {
-                current[i, j] = _perceiverQueries[i, j];
-            }
-        }
-
-        for (int i = 0; i < _perceiverLayers.Count; i += 3)
-        {
-            if (_perceiverLayers[i] is CrossAttentionLayer<T> crossAttn)
-            {
-                var attnOut = crossAttn.Forward(current, visionFeatures);
-                current = AddTensors(current, attnOut);
-            }
-
-            if (i + 1 < _perceiverLayers.Count && i + 2 < _perceiverLayers.Count)
-            {
-                var ffn1 = _perceiverLayers[i + 1].Forward(current);
-                var ffn2 = _perceiverLayers[i + 2].Forward(ffn1);
-                current = AddTensors(current, ffn2);
-            }
-        }
-
-        return current;
-    }
-
-    private Tensor<T> ExtractPerceiverFeaturesOnnx(Tensor<T> visionFeatures)
-    {
-        return ExtractPerceiverFeaturesNative(visionFeatures);
-    }
-
-    /// <inheritdoc/>
-    public string DescribeVideo(
-        IEnumerable<Tensor<T>> frames,
-        string? prompt = null,
-        int maxLength = 256)
-    {
-        var framesList = frames.ToList();
-        var sampledFrames = new List<Tensor<T>>();
-        int step = Math.Max(1, framesList.Count / _maxImagesInContext);
-        for (int i = 0; i < framesList.Count && sampledFrames.Count < _maxImagesInContext; i += step)
-        {
-            sampledFrames.Add(framesList[i]);
-        }
-
-        string videoPrompt = prompt ?? "Describe what is happening in this video:";
-        return GenerateWithMultipleImages(sampledFrames, videoPrompt, maxLength);
-    }
-
-    /// <inheritdoc/>
-    public T ScoreImageText(Tensor<T> image, string text)
-    {
-        var imageEmbedding = GetImageEmbedding(image);
-        var textEmbedding = GetTextEmbedding(text);
-        var similarity = ComputeSimilarity(imageEmbedding, textEmbedding);
-
-        double logProb = Math.Log(Math.Max((NumOps.ToDouble(similarity) + 1) / 2, 1e-10));
-        var encoded = _tokenizer.Encode(text);
-        return NumOps.FromDouble(logProb * encoded.TokenIds.Count);
-    }
-
-    /// <inheritdoc/>
-    public IEnumerable<(int Index, T Score)> FewShotImageRetrieval(
-        IEnumerable<Tensor<T>> queryExamples,
-        string? queryDescription,
-        IEnumerable<Tensor<T>> candidateImages,
-        int topK = 10)
-    {
-        var queryList = queryExamples.ToList();
-        var candidateList = candidateImages.ToList();
-
-        var queryEmbeddings = queryList.Select(img => GetImageEmbedding(img)).ToList();
-        var avgQueryEmbedding = new Vector<T>(_embeddingDimension);
-
-        for (int j = 0; j < _embeddingDimension; j++)
-        {
-            T sum = NumOps.Zero;
-            foreach (var emb in queryEmbeddings)
-            {
-                if (j < emb.Length)
-                    sum = NumOps.Add(sum, emb[j]);
-            }
-            avgQueryEmbedding[j] = NumOps.Divide(sum, NumOps.FromDouble(queryEmbeddings.Count));
-        }
-
-        if (queryDescription is not null && queryDescription.Length > 0)
-        {
-            var textEmbedding = GetTextEmbedding(queryDescription);
-            for (int j = 0; j < _embeddingDimension && j < textEmbedding.Length; j++)
-            {
-                avgQueryEmbedding[j] = NumOps.Divide(
-                    NumOps.Add(avgQueryEmbedding[j], textEmbedding[j]),
-                    NumOps.FromDouble(2.0));
-            }
-        }
-
-        avgQueryEmbedding = Normalize(avgQueryEmbedding);
-
-        var scores = new List<(int Index, T Score)>();
-        for (int i = 0; i < candidateList.Count; i++)
-        {
-            var candidateEmbedding = GetImageEmbedding(candidateList[i]);
-            var similarity = ComputeSimilarity(avgQueryEmbedding, candidateEmbedding);
-            scores.Add((i, similarity));
-        }
-
-        return scores.OrderByDescending(s => NumOps.ToDouble(s.Score)).Take(topK);
-    }
-
-    #endregion
-
-    #region Helper Methods
-
-    private string GenerateWithVisualContext(
-        IReadOnlyList<int> inputIds,
-        List<Tensor<T>> imageFeatures,
-        int maxLength)
-    {
-        var generatedIds = new List<int>(inputIds);
-        var specialTokens = _tokenizer.SpecialTokens;
-        var eosTokenStr = specialTokens?.EosToken ?? "[SEP]";
-        var eosEncoded = _tokenizer.Encode(eosTokenStr);
-        int eosTokenId = eosEncoded.TokenIds.Count > 0 ? eosEncoded.TokenIds[0] : 0;
-
-        var combinedImageFeatures = CombineImageFeatures(imageFeatures);
-
-        if (_outputProjection is null)
-        {
-            // Fail fast: without the output projection there are no logits to decode, so
-            // returning the (empty) suffix here would masquerade an unsupported state as a
-            // successful empty generation.
-            throw new InvalidOperationException(
-                "Output projection must be initialized before Flamingo text generation can produce logits.");
-        }
-
-        // The shared AutoregressiveDecoder owns the loop + greedy argmax + EOS stop. The per-step
-        // forward (text embed -> gated cross-attention every 4th LM layer -> output projection ->
-        // last-position logits) is supplied via the closure. Flamingo decodes greedily, matching the
-        // previous hand-rolled argmax (SampleFromLogits).
-        var newTokens = Generation.AutoregressiveDecoder<T>.Decode(
-            stepLogits: prev =>
-            {
-                if (prev.HasValue) generatedIds.Add(prev.Value);
-                // Slide the context to the most recent _maxSequenceLength tokens — Take(seqLen)
-                // would keep the FIRST tokens and silently drop every newly-generated token once
-                // the sequence exceeds the window, so later forward passes never see the latest token.
-                var contextIds = generatedIds
-                    .Skip(Math.Max(0, generatedIds.Count - _maxSequenceLength))
-                    .ToList();
-                if (contextIds.Count == 0)
-                {
-                    throw new InvalidOperationException("Generation requires at least one prompt token.");
-                }
-                int seqLen = contextIds.Count;
-                var embeddings = EmbedTextTokens(contextIds);
-
-                var current = embeddings;
-                int gatedAttnIdx = 0;
-                for (int layer = 0; layer < _numLmLayers && layer < _languageModelLayers.Count; layer++)
-                {
-                    if (layer % 4 == 0 && gatedAttnIdx < _gatedCrossAttentionLayers.Count)
-                    {
-                        if (_gatedCrossAttentionLayers[gatedAttnIdx] is CrossAttentionLayer<T> crossAttn)
-                        {
-                            var attnOut = crossAttn.Forward(current, combinedImageFeatures);
-                            current = AddTensors(current, attnOut);
-                        }
-                        gatedAttnIdx++;
-                    }
-
-                    current = _languageModelLayers[layer].Forward(current);
-                }
-
-                var lastPosition = Tensor<T>.CreateDefault([1, _lmHiddenDim], NumOps.Zero);
-                for (int j = 0; j < _lmHiddenDim; j++)
-                {
-                    lastPosition[0, j] = current[seqLen - 1, j];
-                }
-
-                var logits = _outputProjection.Forward(lastPosition);
-                int vocab = logits.Shape[1];
-                var v = new Vector<T>(vocab);
-                for (int i = 0; i < vocab; i++) v[i] = logits[0, i];
-                return v;
-            },
-            maxNewTokens: maxLength,
-            options: Generation.SamplingOptions.Greedy,
-            isEndToken: t => t == eosTokenId);
-
-        return _tokenizer.Decode(new List<int>(newTokens));
-    }
-
-    private Tensor<T> CombineImageFeatures(List<Tensor<T>> imageFeatures)
-    {
-        if (imageFeatures.Count == 0)
-        {
-            return Tensor<T>.CreateDefault([1, _lmHiddenDim], NumOps.Zero);
-        }
-
-        int totalTokens = imageFeatures.Sum(f => f.Shape[0]);
-        int hiddenDim = imageFeatures[0].Shape[1];
-
-        var combined = Tensor<T>.CreateDefault([totalTokens, hiddenDim], NumOps.Zero);
-        int offset = 0;
-
-        foreach (var features in imageFeatures)
-        {
-            for (int i = 0; i < features.Shape[0]; i++)
-            {
-                for (int j = 0; j < hiddenDim; j++)
-                {
-                    combined[offset + i, j] = features[i, j];
-                }
-            }
-            offset += features.Shape[0];
-        }
-
-        return combined;
-    }
-
-    private Tensor<T> AddTensors(Tensor<T> a, Tensor<T> b)
-    {
-        return Engine.TensorAdd(a, b);
-    }
-
-    #endregion
-
-    #region NeuralNetworkBase Overrides
-
-    /// <summary>
-    /// Declares the Perceiver Resampler's latent queries and the two positional embedding tables,
-    /// which live outside <see cref="NeuralNetworkBase{T}.Layers"/>.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// These three tables were in NEITHER surface. ParameterCount enumerated the tower lists and
-    /// the three projections; GetParameters concatenated the same things; neither mentioned the
-    /// tables, and nothing serialized them. So they never trained through a flat-vector optimizer
-    /// and were lost on every save -- including <c>_perceiverQueries</c>, the learned latent array
-    /// the Perceiver Resampler attends the vision features into (Alayrac et al. 2022 §3.2). Those
-    /// latents are trainable in the paper; a Flamingo that cannot learn them is not Flamingo.
-    /// </para>
-    /// <para>
-    /// Declaring them ADDS to the parameter count -- deliberately. The old number was not a
-    /// smaller-but-correct total, it was a total that omitted real weights.
-    /// </para>
-    /// <para>
-    /// They are <c>Tensor&lt;T&gt;</c> now because a <c>Matrix&lt;T&gt;</c> is invisible to the
-    /// trainable-parameter walk, which is why the surfaces had to be hand-written to begin with.
-    /// The tower lists need no declaration and must not get one: <c>_visionEncoderLayers</c>,
-    /// <c>_perceiverLayers</c>, <c>_gatedCrossAttentionLayers</c>, <c>_languageModelLayers</c> and
-    /// the three projections are all filled FROM <c>Layers</c> (<c>Layers[idx++]</c> in
-    /// InitializeLayers), so they are typed views of layers the base walk already reaches and
-    /// declaring them would double-count.
-    /// </para>
-    /// </remarks>
-    protected override IEnumerable<Tensor<T>> GetExtraTrainableTensors()
-    {
-        if (_visionPositionalEmbeddings is not null)
-        {
-            yield return _visionPositionalEmbeddings;
-        }
-
-        if (_perceiverQueries is not null)
-        {
-            yield return _perceiverQueries;
-        }
-
-        if (_textPositionalEmbeddings is not null)
-        {
-            yield return _textPositionalEmbeddings;
-        }
-    }
-
-    /// <inheritdoc/>
-    protected override Tensor<T> PredictCore(Tensor<T> input)
-    {
-        // GPU-resident optimization: use TryForwardGpuOptimized for speedup
-        if (TryForwardGpuOptimized(input, out var gpuResult))
-            return gpuResult;
-
-        SetTrainingMode(false);
-        return Accelerate(input, () =>
-        {
-            var features = ExtractPerceiverFeatures(input);
-            return features;
-        });
-    }
-
-    /// <inheritdoc/>
+{
+    private readonly FlamingoOptions _options;
+
+    /// <inheritdoc/>
+    public override ModelOptions GetOptions() => _options;
+
+    #region Execution Mode
+
+    private readonly bool _useNativeMode;
+
+    #endregion
+
+    #region ONNX Mode Fields
+
+    private readonly InferenceSession? _visionEncoder;
+    private readonly InferenceSession? _languageModel;
+    private readonly string? _visionEncoderPath;
+    private readonly string? _languageModelPath;
+
+    #endregion
+
+    #region Native Mode Fields
+
+    private readonly List<ILayer<T>> _visionEncoderLayers = [];
+    private readonly List<ILayer<T>> _perceiverLayers = [];
+    private readonly List<ILayer<T>> _gatedCrossAttentionLayers = [];
+    private readonly List<ILayer<T>> _languageModelLayers = [];
+    private Tensor<T>? _perceiverQueries;
+    private Tensor<T>? _visionPositionalEmbeddings;
+    private ILayer<T>? _patchEmbedding;
+    private ILayer<T>? _textTokenEmbedding;
+    private Tensor<T>? _textPositionalEmbeddings;
+    private ILayer<T>? _outputProjection;
+
+    #endregion
+
+    #region Shared Fields
+
+    private readonly ITokenizer _tokenizer;
+    private readonly IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>> _optimizer;
+    private readonly ILossFunction<T> _lossFunction;
+    private readonly int _embeddingDimension;
+    private readonly int _maxSequenceLength;
+    private readonly int _imageSize;
+
+    /// <summary>
+    /// The input channel count the native layers were built for.
+    /// </summary>
+    /// <remarks>
+    /// The constructor took this and forwarded it to InitializeNativeLayers without keeping it, so
+    /// two places in the clone path assumed 3. The shape probe built a 3-channel tensor, which
+    /// makes ResolveShapes throw for a 1- or 4-channel model and drops the copy into the fallback
+    /// -- copying from unresolved lazy projections, the exact failure that probe was added to
+    /// prevent -- and CreateNewInstance passed the literal 3, silently rebuilding the clone with an
+    /// RGB patch embedding whatever the original used.
+    /// </remarks>
+    private readonly int _channels;
+    private readonly int _visionHiddenDim;
+    private readonly int _lmHiddenDim;
+    private readonly int _numVisionLayers;
+    private readonly int _numLmLayers;
+    private readonly int _numHeads;
+    private readonly int _patchSize;
+    private readonly int _vocabularySize;
+    private readonly LanguageModelBackbone _languageModelBackbone;
+    private readonly int _numPerceiverTokens;
+    private readonly int _maxImagesInContext;
+    private readonly int _numPerceiverLayers;
+    private readonly double _learningRate;
+
+    #endregion
+
+    #region IMultimodalEmbedding Properties
+
+    /// <inheritdoc/>
+    public int EmbeddingDimension => _embeddingDimension;
+
+    /// <inheritdoc/>
+    public int MaxSequenceLength => _maxSequenceLength;
+
+    /// <inheritdoc/>
+    public int ImageSize => _imageSize;
+
+    #endregion
+
+    #region IFlamingoModel Properties
+
+    /// <inheritdoc/>
+    public int NumPerceiverTokens => _numPerceiverTokens;
+
+    /// <inheritdoc/>
+    public int MaxImagesInContext => _maxImagesInContext;
+
+    /// <inheritdoc/>
+    public LanguageModelBackbone LanguageModelBackbone => _languageModelBackbone;
+
+    #endregion
+
+    #region Constructors
+
+    /// <summary>
+    /// Initializes a new instance using ONNX models.
+    /// </summary>
+    public FlamingoNeuralNetwork(
+        NeuralNetworkArchitecture<T> architecture,
+        string visionEncoderPath,
+        string languageModelPath,
+        ITokenizer tokenizer,
+        int embeddingDimension = 768,
+        int maxSequenceLength = 2048,
+        int imageSize = 224,
+        int numPerceiverTokens = 64,
+        int maxImagesInContext = 5,
+        IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? optimizer = null,
+        ILossFunction<T>? lossFunction = null,
+        FlamingoOptions? options = null)
+        : base(architecture, lossFunction ?? new CrossEntropyWithLogitsLoss<T>(), 1.0)
+    {
+        _options = options ?? new FlamingoOptions();
+        Options = _options;
+        if (string.IsNullOrWhiteSpace(visionEncoderPath))
+            throw new ArgumentException("Vision encoder path cannot be null or empty.", nameof(visionEncoderPath));
+        if (string.IsNullOrWhiteSpace(languageModelPath))
+            throw new ArgumentException("Language model path cannot be null or empty.", nameof(languageModelPath));
+        if (!File.Exists(visionEncoderPath))
+            throw new FileNotFoundException($"Vision encoder model not found: {visionEncoderPath}");
+        if (!File.Exists(languageModelPath))
+            throw new FileNotFoundException($"Language model not found: {languageModelPath}");
+
+        _useNativeMode = false;
+        _visionEncoderPath = visionEncoderPath;
+        _languageModelPath = languageModelPath;
+        _embeddingDimension = embeddingDimension;
+        _maxSequenceLength = maxSequenceLength;
+        _imageSize = imageSize;
+        _numPerceiverTokens = numPerceiverTokens;
+        _maxImagesInContext = maxImagesInContext;
+        _visionHiddenDim = 1024;
+        _lmHiddenDim = 2048;
+        _numVisionLayers = 24;
+        _numLmLayers = 32;
+        _numHeads = 16;
+        _patchSize = 14;
+        _vocabularySize = 32000;
+        _languageModelBackbone = LanguageModelBackbone.Chinchilla;
+        _numPerceiverLayers = 6;
+        // 1e-3 is the CODEBASE Adam default, chosen deliberately rather than taken from the paper.
+        // Alayrac et al. 2022 specify their schedule in section 3 and Appendix B, and it is not a
+        // single constant: a linear warm-up to 1e-4 over the first 5000 steps, then cosine decay,
+        // over an accelerator budget this implementation does not assume. Pinning a number lifted
+        // from the middle of that schedule would look like a citation while reproducing none of it,
+        // so the framework default is used and the deviation is stated here instead. Callers
+        // reproducing the paper should pass their own optimizer with the published schedule.
+        _learningRate = 1e-3;
+
+        InferenceSession? visionEncoder = null;
+        InferenceSession? languageModel = null;
+
+        try
+        {
+            visionEncoder = new InferenceSession(visionEncoderPath);
+            languageModel = new InferenceSession(languageModelPath);
+            _visionEncoder = visionEncoder;
+            _languageModel = languageModel;
+            // Tokenizer is required for ONNX mode - must match the language model backbone
+            Guard.NotNull(tokenizer);
+            _tokenizer = tokenizer;
+            _optimizer = optimizer ?? new AdamOptimizer<T, Tensor<T>, Tensor<T>>(this);
+            _lossFunction = lossFunction ?? new CrossEntropyWithLogitsLoss<T>();
+            InitializeLayers();
+        }
+        catch
+        {
+            visionEncoder?.Dispose();
+            languageModel?.Dispose();
+            throw;
+        }
+    }
+
+    /// <summary>
+    /// Initializes a new instance using native layers.
+    /// </summary>
+    public FlamingoNeuralNetwork(
+        NeuralNetworkArchitecture<T> architecture,
+        int embeddingDimension = 768,
+        int maxSequenceLength = 2048,
+        int imageSize = 224,
+        int channels = 3,
+        int numPerceiverTokens = 64,
+        int maxImagesInContext = 5,
+        int visionHiddenDim = 1024,
+        int lmHiddenDim = 2048,
+        int numVisionLayers = 24,
+        int numLmLayers = 32,
+        int numHeads = 16,
+        int vocabularySize = 32000,
+        LanguageModelBackbone languageModelBackbone = LanguageModelBackbone.Chinchilla,
+        int numPerceiverLayers = 6,
+        ITokenizer? tokenizer = null,
+        IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? optimizer = null,
+        ILossFunction<T>? lossFunction = null,
+        FlamingoOptions? options = null,
+        double learningRate = 1e-3)
+        : base(architecture, lossFunction ?? new CrossEntropyWithLogitsLoss<T>(), 1.0)
+    {
+        // Validated here, at the public entry point, rather than where it is first used. ConvertToTensor
+        // divides by the channel count, and InitializeNativeLayers sizes the patch embedding from it, so
+        // a zero or negative value surfaces as a DivideByZeroException or an invalid tensor shape from
+        // somewhere well downstream of the argument that caused it.
+        if (channels <= 0)
+        {
+            throw new ArgumentOutOfRangeException(
+                nameof(channels), channels, "The channel count must be positive.");
+        }
+
+        _options = options ?? new FlamingoOptions();
+        Options = _options;
+        _useNativeMode = true;
+        _embeddingDimension = embeddingDimension;
+        _maxSequenceLength = maxSequenceLength;
+        _imageSize = imageSize;
+        _numPerceiverTokens = numPerceiverTokens;
+        _maxImagesInContext = maxImagesInContext;
+        _visionHiddenDim = visionHiddenDim;
+        _lmHiddenDim = lmHiddenDim;
+        _numVisionLayers = numVisionLayers;
+        _numLmLayers = numLmLayers;
+        _numHeads = numHeads;
+        _patchSize = 14;
+        _vocabularySize = vocabularySize;
+        _languageModelBackbone = languageModelBackbone;
+        _numPerceiverLayers = numPerceiverLayers;
+        _learningRate = learningRate;
+
+        // Use factory to create appropriate tokenizer for the backbone, or use provided tokenizer
+        _tokenizer = tokenizer ?? Tokenization.LanguageModelTokenizerFactory.CreateForBackbone(languageModelBackbone);
+        _optimizer = optimizer ?? new AdamOptimizer<T, Tensor<T>, Tensor<T>>(
+            this,
+            new AiDotNet.Models.Options.AdamOptimizerOptions<T, Tensor<T>, Tensor<T>>
+            {
+                InitialLearningRate = learningRate,
+                MaxGradientNorm = 1.0
+            });
+        _lossFunction = lossFunction ?? new CrossEntropyWithLogitsLoss<T>();
+
+        _channels = channels;
+        InitializeNativeLayers(channels);
+    }
+
+    /// <inheritdoc/>
+    protected override void InitializeLayers()
+    {
+        // ONNX mode initialization
+    }
+
+    private void InitializeNativeLayers(int channels)
+    {
+        int numPatches = (_imageSize / _patchSize) * (_imageSize / _patchSize);
+        int gatedCrossAttnCount = _numLmLayers / 4;
+
+        Layers.Clear();
+
+        if (Architecture.Layers != null && Architecture.Layers.Count > 0)
+        {
+            Layers.AddRange(Architecture.Layers);
+        }
+        else
+        {
+            Layers.AddRange(LayerHelper<T>.CreateFlamingoLayers(
+                _imageSize, channels, _patchSize, _visionHiddenDim, _lmHiddenDim,
+                _numVisionLayers, _numPerceiverLayers, _numPerceiverTokens,
+                _numLmLayers, _numHeads, _vocabularySize, _maxSequenceLength));
+        }
+
+        RebindNativeLayerReferences();
+
+        // Initialize vision positional embeddings
+        _visionPositionalEmbeddings = new Tensor<T>([numPatches + 1, _visionHiddenDim]);
+        InitializePositionalEmbeddings(_visionPositionalEmbeddings);
+
+        // Initialize perceiver queries
+        _perceiverQueries = new Tensor<T>([_numPerceiverTokens, _lmHiddenDim]);
+        InitializePerceiverQueries(_perceiverQueries);
+
+        // Text positional embeddings
+        _textPositionalEmbeddings = new Tensor<T>([_maxSequenceLength, _lmHiddenDim]);
+        InitializePositionalEmbeddings(_textPositionalEmbeddings);
+    }
+
+    /// <summary>
+    /// Rebinds Flamingo's branch-specific layer references to the canonical base
+    /// <see cref="NeuralNetworkBase{T}.Layers"/> collection.
+    /// </summary>
+    /// <remarks>
+    /// The base clone paths replace or COW-share the canonical layer collection. Flamingo executes
+    /// through its branch lists rather than walking that collection sequentially, so those lists must
+    /// be rebound after cloning; copying parameters into the constructor's stale branch objects would
+    /// duplicate storage and bypass the base COW contract.
+    /// </remarks>
+    private void RebindNativeLayerReferences()
+    {
+        int gatedCrossAttnCount = _numLmLayers / 4;
+        int requiredLayers = 1 + _numVisionLayers + (3 * _numPerceiverLayers)
+            + gatedCrossAttnCount + 1 + _numLmLayers + 1;
+        // EXACTLY requiredLayers, NOT "at least". The distribution loop below consumes exactly
+        // requiredLayers entries, so a surplus passed this guard and was then bound to nothing --
+        // yet stayed in the canonical Layers collection, so it was still serialized, still counted
+        // toward ParameterCount, and still updated by training, while contributing nothing to any
+        // forward path. A caller who supplied one layer too many got a model that trained weights
+        // it never used and reported a parameter count it could not explain.
+        if (Layers.Count != requiredLayers)
+        {
+            throw new InvalidOperationException(
+                $"Flamingo layer graph contains {Layers.Count} layers but exactly {requiredLayers} are "
+                + "required; every layer is bound to a named execution branch, so a surplus would be "
+                + "trained and serialized without ever being used.");
+        }
+
+        // Distribute canonical layers to the private execution branches.
+        int idx = 0;
+
+        // Patch embedding
+        _patchEmbedding = Layers[idx++];
+
+        // Vision encoder transformer layers
+        _visionEncoderLayers.Clear();
+        for (int i = 0; i < _numVisionLayers; i++)
+            _visionEncoderLayers.Add(Layers[idx++]);
+
+        // Perceiver Resampler layers: (CrossAttn + FFN_expand + FFN_contract) × numPerceiverLayers
+        _perceiverLayers.Clear();
+        for (int i = 0; i < _numPerceiverLayers; i++)
+        {
+            _perceiverLayers.Add(Layers[idx++]); // CrossAttention
+            _perceiverLayers.Add(Layers[idx++]); // FFN expand
+            _perceiverLayers.Add(Layers[idx++]); // FFN contract
+        }
+
+        // Gated cross-attention layers
+        _gatedCrossAttentionLayers.Clear();
+        for (int i = 0; i < gatedCrossAttnCount; i++)
+            _gatedCrossAttentionLayers.Add(Layers[idx++]);
+
+        // Text token embedding
+        _textTokenEmbedding = Layers[idx++];
+
+        // Language model transformer layers
+        _languageModelLayers.Clear();
+        for (int i = 0; i < _numLmLayers; i++)
+            _languageModelLayers.Add(Layers[idx++]);
+
+        // Output projection
+        _outputProjection = Layers[idx++];
+    }
+
+    private void InitializePositionalEmbeddings(Tensor<T> embeddings)
+    {
+        for (int i = 0; i < embeddings.Shape[0]; i++)
+        {
+            for (int j = 0; j < embeddings.Shape[1]; j++)
+            {
+                double angle = i / Math.Pow(10000, 2.0 * (j / 2) / embeddings.Shape[1]);
+                double value = j % 2 == 0 ? Math.Sin(angle) : Math.Cos(angle);
+                embeddings[i, j] = NumOps.FromDouble(value);
+            }
+        }
+    }
+
+    private void InitializePerceiverQueries(Tensor<T> queries)
+    {
+        var rand = RandomHelper.CreateSeededRandom(42);
+        double scale = 1.0 / Math.Sqrt(queries.Shape[1]);
+        for (int i = 0; i < queries.Shape[0]; i++)
+        {
+            for (int j = 0; j < queries.Shape[1]; j++)
+            {
+                double value = (rand.NextDouble() * 2 - 1) * scale;
+                queries[i, j] = NumOps.FromDouble(value);
+            }
+        }
+    }
+
+    #endregion
+
+    #region IMultimodalEmbedding Implementation
+
+    /// <inheritdoc/>
+    public Vector<T> GetImageEmbedding(Tensor<T> image)
+    {
+        return GetImageEmbeddings([image]).First();
+    }
+
+    /// <inheritdoc/>
+    public IEnumerable<Vector<T>> GetImageEmbeddings(IEnumerable<Tensor<T>> images)
+    {
+        var results = new List<Vector<T>>();
+        foreach (var image in images)
+        {
+            var features = ExtractPerceiverFeatures(image);
+            var embedding = MeanPool(features);
+            var normalized = Normalize(embedding);
+            results.Add(normalized);
+        }
+        return results;
+    }
+
+    /// <inheritdoc/>
+    public Vector<T> GetTextEmbedding(string text)
+    {
+        if (string.IsNullOrWhiteSpace(text))
+            throw new ArgumentException("Text cannot be null or empty.", nameof(text));
+
+        return GetTextEmbeddings([text]).First();
+    }
+
+    /// <inheritdoc/>
+    public IEnumerable<Vector<T>> GetTextEmbeddings(IEnumerable<string> texts)
+    {
+        var results = new List<Vector<T>>();
+
+        foreach (var text in texts)
+        {
+            var encoded = _tokenizer.Encode(text);
+            var inputIds = encoded.TokenIds;
+
+            var paddedIds = new List<int>();
+            for (int i = 0; i < _maxSequenceLength; i++)
+            {
+                paddedIds.Add(i < inputIds.Count ? inputIds[i] : 0);
+            }
+
+            var embedded = EmbedTextTokens(paddedIds);
+            var embedding = MeanPool(embedded);
+            var normalized = Normalize(embedding);
+            results.Add(normalized);
+        }
+
+        return results;
+    }
+
+    private Tensor<T> EmbedTextTokens(IReadOnlyList<int> tokenIds)
+    {
+        int seqLen = tokenIds.Count;
+        var embeddings = Tensor<T>.CreateDefault([seqLen, _lmHiddenDim], NumOps.Zero);
+
+        if (_textTokenEmbedding is null || _textPositionalEmbeddings is null)
+        {
+            return embeddings;
+        }
+
+        for (int i = 0; i < seqLen; i++)
+        {
+            var tokenInput = Tensor<T>.CreateDefault([1], NumOps.FromDouble(tokenIds[i]));
+            var tokenEmb = _textTokenEmbedding.Forward(tokenInput);
+
+            for (int j = 0; j < _lmHiddenDim; j++)
+            {
+                T posEmb = i < _textPositionalEmbeddings.Shape[0] ? _textPositionalEmbeddings[i, j] : NumOps.Zero;
+                embeddings[i, j] = NumOps.Add(tokenEmb[0, j], posEmb);
+            }
+        }
+
+        return embeddings;
+    }
+
+    private Vector<T> MeanPool(Tensor<T> features)
+    {
+        int seqLen = features.Shape[0];
+        int hiddenDim = features.Shape[1];
+        var result = new Vector<T>(hiddenDim);
+
+        for (int j = 0; j < hiddenDim; j++)
+        {
+            T sum = NumOps.Zero;
+            for (int i = 0; i < seqLen; i++)
+            {
+                sum = NumOps.Add(sum, features[i, j]);
+            }
+            result[j] = NumOps.Divide(sum, NumOps.FromDouble(seqLen));
+        }
+
+        return result;
+    }
+
+    private Vector<T> Normalize(Vector<T> vec)
+    {
+        return VectorHelper.Normalize(vec);
+    }
+
+    /// <inheritdoc/>
+    public T ComputeSimilarity(Vector<T> embedding1, Vector<T> embedding2)
+    {
+        T dotProduct = NumOps.Zero;
+        T norm1 = NumOps.Zero;
+        T norm2 = NumOps.Zero;
+
+        for (int i = 0; i < embedding1.Length && i < embedding2.Length; i++)
+        {
+            dotProduct = NumOps.Add(dotProduct, NumOps.Multiply(embedding1[i], embedding2[i]));
+            norm1 = NumOps.Add(norm1, NumOps.Multiply(embedding1[i], embedding1[i]));
+            norm2 = NumOps.Add(norm2, NumOps.Multiply(embedding2[i], embedding2[i]));
+        }
+
+        T normProduct = NumOps.Multiply(NumOps.Sqrt(norm1), NumOps.Sqrt(norm2));
+        if (NumOps.LessThan(normProduct, NumOps.FromDouble(1e-10)))
+            return NumOps.Zero;
+
+        return NumOps.Divide(dotProduct, normProduct);
+    }
+
+    /// <inheritdoc/>
+    public T ComputeImageTextSimilarity(Tensor<T> image, string text)
+    {
+        var imageEmbedding = GetImageEmbedding(image);
+        var textEmbedding = GetTextEmbedding(text);
+        return ComputeSimilarity(imageEmbedding, textEmbedding);
+    }
+
+    /// <inheritdoc/>
+    public Dictionary<string, T> ZeroShotClassify(Tensor<T> image, IEnumerable<string> classLabels)
+    {
+        var imageEmbedding = GetImageEmbedding(image);
+        var result = new Dictionary<string, T>();
+        var scores = new List<(string label, T score)>();
+
+        foreach (var label in classLabels)
+        {
+            var textEmbedding = GetTextEmbedding(label);
+            var similarity = ComputeSimilarity(imageEmbedding, textEmbedding);
+            scores.Add((label, similarity));
+        }
+
+        var expScores = scores.Select(s => (s.label, exp: Math.Exp(NumOps.ToDouble(s.score)))).ToList();
+        double sumExp = expScores.Sum(s => s.exp);
+
+        foreach (var (label, exp) in expScores)
+        {
+            result[label] = NumOps.FromDouble(exp / sumExp);
+        }
+
+        return result;
+    }
+
+    /// <inheritdoc/>
+    public IEnumerable<(int Index, T Score)> RetrieveImages(
+        string query,
+        IEnumerable<Vector<T>> imageEmbeddings,
+        int topK = 10)
+    {
+        var queryEmbedding = GetTextEmbedding(query);
+        var embeddingsList = imageEmbeddings.ToList();
+        var scores = new List<(int Index, T Score)>();
+
+        for (int i = 0; i < embeddingsList.Count; i++)
+        {
+            var similarity = ComputeSimilarity(queryEmbedding, embeddingsList[i]);
+            scores.Add((i, similarity));
+        }
+
+        return scores.OrderByDescending(s => NumOps.ToDouble(s.Score)).Take(topK);
+    }
+
+    /// <inheritdoc/>
+    public IEnumerable<(int Index, T Score)> RetrieveTexts(
+        Tensor<T> image,
+        IEnumerable<string> texts,
+        int topK = 10)
+    {
+        var imageEmbedding = GetImageEmbedding(image);
+        var textsList = texts.ToList();
+        var scores = new List<(int Index, T Score)>();
+
+        for (int i = 0; i < textsList.Count; i++)
+        {
+            var textEmbedding = GetTextEmbedding(textsList[i]);
+            var similarity = ComputeSimilarity(imageEmbedding, textEmbedding);
+            scores.Add((i, similarity));
+        }
+
+        return scores.OrderByDescending(s => NumOps.ToDouble(s.Score)).Take(topK);
+    }
+
+    /// <inheritdoc/>
+    public string GenerateCaption(Tensor<T> image, int maxLength = 77)
+    {
+        return FewShotGenerate([], image, "Describe this image:", maxLength);
+    }
+
+    /// <inheritdoc/>
+    public string AnswerQuestion(Tensor<T> image, string question, int maxLength = 64)
+    {
+        return FewShotVQA([], image, question);
+    }
+
+    #endregion
+
+    #region IFlamingoModel Implementation
+
+    /// <inheritdoc/>
+    public string FewShotGenerate(
+        IEnumerable<(Tensor<T> Image, string Text)> examples,
+        Tensor<T> queryImage,
+        string? queryPrompt = null,
+        int maxLength = 256)
+    {
+        var examplesList = examples.ToList();
+        if (examplesList.Count > _maxImagesInContext)
+        {
+            throw new ArgumentException(
+                $"Too many examples. Maximum allowed: {_maxImagesInContext}",
+                nameof(examples));
+        }
+
+        var allImageFeatures = new List<Tensor<T>>();
+        foreach (var (image, _) in examplesList)
+        {
+            allImageFeatures.Add(ExtractPerceiverFeatures(image));
+        }
+        allImageFeatures.Add(ExtractPerceiverFeatures(queryImage));
+
+        var contextBuilder = new List<string>();
+        for (int i = 0; i < examplesList.Count; i++)
+        {
+            contextBuilder.Add($"<image>{examplesList[i].Text}");
+        }
+        contextBuilder.Add($"<image>{queryPrompt ?? ""}");
+
+        string context = string.Join(" ", contextBuilder);
+        var encoded = _tokenizer.Encode(context);
+        var inputIds = encoded.TokenIds;
+
+        return GenerateWithVisualContext(inputIds, allImageFeatures, maxLength);
+    }
+
+    /// <inheritdoc/>
+    public string GenerateWithMultipleImages(
+        IEnumerable<Tensor<T>> images,
+        string prompt,
+        int maxLength = 512)
+    {
+        var imagesList = images.ToList();
+        if (imagesList.Count > _maxImagesInContext)
+        {
+            throw new ArgumentException(
+                $"Too many images. Maximum allowed: {_maxImagesInContext}",
+                nameof(images));
+        }
+
+        var allImageFeatures = imagesList.Select(img => ExtractPerceiverFeatures(img)).ToList();
+        var encoded = _tokenizer.Encode(prompt);
+        var inputIds = encoded.TokenIds;
+
+        return GenerateWithVisualContext(inputIds, allImageFeatures, maxLength);
+    }
+
+    /// <inheritdoc/>
+    public Dictionary<string, T> InContextClassify(
+        IEnumerable<(Tensor<T> Image, string Label)> labeledExamples,
+        Tensor<T> queryImage)
+    {
+        var examplesList = labeledExamples.ToList();
+        var labels = examplesList.Select(e => e.Label).Distinct().ToList();
+
+        var examples = examplesList.Select(e => (e.Image, $"This is: {e.Label}")).ToList();
+        var generated = FewShotGenerate(examples, queryImage, "This is:", maxLength: 50);
+
+        var result = new Dictionary<string, T>();
+        double totalScore = 0;
+
+        foreach (var label in labels)
+        {
+            double score = generated.ToLowerInvariant().Contains(label.ToLowerInvariant()) ? 1.0 : 0.1;
+            totalScore += score;
+            result[label] = NumOps.FromDouble(score);
+        }
+
+        foreach (var label in labels)
+        {
+            result[label] = NumOps.Divide(result[label], NumOps.FromDouble(totalScore));
+        }
+
+        return result;
+    }
+
+    /// <inheritdoc/>
+    public string FewShotVQA(
+        IEnumerable<(Tensor<T> Image, string Question, string Answer)> examples,
+        Tensor<T> queryImage,
+        string question)
+    {
+        var examplesList = examples.ToList();
+        var fewShotExamples = examplesList.Select(e =>
+            (e.Image, $"Question: {e.Question}\nAnswer: {e.Answer}")).ToList();
+
+        return FewShotGenerate(
+            fewShotExamples,
+            queryImage,
+            $"Question: {question}\nAnswer:",
+            maxLength: 128);
+    }
+
+    /// <inheritdoc/>
+    public Tensor<T> ExtractPerceiverFeatures(Tensor<T> image)
+    {
+        var visionFeatures = ExtractVisionFeatures(image);
+
+        if (_useNativeMode)
+        {
+            return ExtractPerceiverFeaturesNative(visionFeatures);
+        }
+        else
+        {
+            return ExtractPerceiverFeaturesOnnx(visionFeatures);
+        }
+    }
+
+    private Tensor<T> ExtractVisionFeatures(Tensor<T> image)
+    {
+        if (_useNativeMode)
+        {
+            return ExtractVisionFeaturesNative(image);
+        }
+        else
+        {
+            return ExtractVisionFeaturesOnnx(image);
+        }
+    }
+
+    private Tensor<T> ExtractVisionFeaturesNative(Tensor<T> image)
+    {
+        if (_patchEmbedding is null || _visionPositionalEmbeddings is null)
+        {
+            throw new InvalidOperationException("Vision layers not initialized.");
+        }
+
+        var patchFeatures = _patchEmbedding.Forward(image);
+        int numPatches = patchFeatures.Shape[0];
+        int hiddenDim = patchFeatures.Shape.Length > 1 ? patchFeatures.Shape[1] : _visionHiddenDim;
+
+        var features = Tensor<T>.CreateDefault([numPatches, hiddenDim], NumOps.Zero);
+        for (int i = 0; i < numPatches && i < _visionPositionalEmbeddings.Shape[0]; i++)
+        {
+            for (int j = 0; j < hiddenDim && j < _visionPositionalEmbeddings.Shape[1]; j++)
+            {
+                features[i, j] = NumOps.Add(patchFeatures[i, j], _visionPositionalEmbeddings[i, j]);
+            }
+        }
+
+        var current = features;
+        foreach (var layer in _visionEncoderLayers)
+        {
+            current = layer.Forward(current);
+        }
+
+        return current;
+    }
+
+    private Tensor<T> ExtractVisionFeaturesOnnx(Tensor<T> image)
+    {
+        if (_visionEncoder is null)
+        {
+            throw new InvalidOperationException("Vision encoder not initialized.");
+        }
+
+        int channels = image.Shape[0];
+        int height = image.Shape[1];
+        int width = image.Shape[2];
+
+        var inputArray = new float[1 * channels * height * width];
+        int idx = 0;
+        for (int c = 0; c < channels; c++)
+        {
+            for (int h = 0; h < height; h++)
+            {
+                for (int w = 0; w < width; w++)
+                {
+                    inputArray[idx++] = (float)NumOps.ToDouble(image[c, h, w]);
+                }
+            }
+        }
+
+        var inputTensor = new OnnxTensors.DenseTensor<float>(inputArray, [1, channels, height, width]);
+        var inputs = new List<NamedOnnxValue>
+        {
+            NamedOnnxValue.CreateFromTensor("pixel_values", inputTensor)
+        };
+
+        using var results = _visionEncoder.Run(inputs);
+        var output = results.First().AsEnumerable<float>().ToArray();
+
+        int numPatches = (_imageSize / _patchSize) * (_imageSize / _patchSize);
+        var features = Tensor<T>.CreateDefault([numPatches, _visionHiddenDim], NumOps.Zero);
+
+        for (int i = 0; i < numPatches && i * _visionHiddenDim < output.Length; i++)
+        {
+            for (int j = 0; j < _visionHiddenDim; j++)
+            {
+                int outputIdx = i * _visionHiddenDim + j;
+                if (outputIdx < output.Length)
+                {
+                    features[i, j] = NumOps.FromDouble(output[outputIdx]);
+                }
+            }
+        }
+
+        return features;
+    }
+
+    private Tensor<T> ExtractPerceiverFeaturesNative(Tensor<T> visionFeatures)
+    {
+        if (_perceiverQueries is null)
+        {
+            throw new InvalidOperationException("Perceiver queries not initialized.");
+        }
+
+        var current = Tensor<T>.CreateDefault([_numPerceiverTokens, _lmHiddenDim], NumOps.Zero);
+        for (int i = 0; i < _numPerceiverTokens; i++)
+        {
+            for (int j = 0; j < _lmHiddenDim; j++)
+            {
+                current[i, j] = _perceiverQueries[i, j];
+            }
+        }
+
+        for (int i = 0; i < _perceiverLayers.Count; i += 3)
+        {
+            if (_perceiverLayers[i] is CrossAttentionLayer<T> crossAttn)
+            {
+                var attnOut = crossAttn.Forward(current, visionFeatures);
+                current = AddTensors(current, attnOut);
+            }
+
+            if (i + 1 < _perceiverLayers.Count && i + 2 < _perceiverLayers.Count)
+            {
+                var ffn1 = _perceiverLayers[i + 1].Forward(current);
+                var ffn2 = _perceiverLayers[i + 2].Forward(ffn1);
+                current = AddTensors(current, ffn2);
+            }
+        }
+
+        return current;
+    }
+
+    private Tensor<T> ExtractPerceiverFeaturesOnnx(Tensor<T> visionFeatures)
+    {
+        return ExtractPerceiverFeaturesNative(visionFeatures);
+    }
+
+    /// <inheritdoc/>
+    public string DescribeVideo(
+        IEnumerable<Tensor<T>> frames,
+        string? prompt = null,
+        int maxLength = 256)
+    {
+        var framesList = frames.ToList();
+        var sampledFrames = new List<Tensor<T>>();
+        int step = Math.Max(1, framesList.Count / _maxImagesInContext);
+        for (int i = 0; i < framesList.Count && sampledFrames.Count < _maxImagesInContext; i += step)
+        {
+            sampledFrames.Add(framesList[i]);
+        }
+
+        string videoPrompt = prompt ?? "Describe what is happening in this video:";
+        return GenerateWithMultipleImages(sampledFrames, videoPrompt, maxLength);
+    }
+
+    /// <inheritdoc/>
+    public T ScoreImageText(Tensor<T> image, string text)
+    {
+        var imageEmbedding = GetImageEmbedding(image);
+        var textEmbedding = GetTextEmbedding(text);
+        var similarity = ComputeSimilarity(imageEmbedding, textEmbedding);
+
+        double logProb = Math.Log(Math.Max((NumOps.ToDouble(similarity) + 1) / 2, 1e-10));
+        var encoded = _tokenizer.Encode(text);
+        return NumOps.FromDouble(logProb * encoded.TokenIds.Count);
+    }
+
+    /// <inheritdoc/>
+    public IEnumerable<(int Index, T Score)> FewShotImageRetrieval(
+        IEnumerable<Tensor<T>> queryExamples,
+        string? queryDescription,
+        IEnumerable<Tensor<T>> candidateImages,
+        int topK = 10)
+    {
+        var queryList = queryExamples.ToList();
+        var candidateList = candidateImages.ToList();
+
+        var queryEmbeddings = queryList.Select(img => GetImageEmbedding(img)).ToList();
+        var avgQueryEmbedding = new Vector<T>(_embeddingDimension);
+
+        for (int j = 0; j < _embeddingDimension; j++)
+        {
+            T sum = NumOps.Zero;
+            foreach (var emb in queryEmbeddings)
+            {
+                if (j < emb.Length)
+                    sum = NumOps.Add(sum, emb[j]);
+            }
+            avgQueryEmbedding[j] = NumOps.Divide(sum, NumOps.FromDouble(queryEmbeddings.Count));
+        }
+
+        if (queryDescription is not null && queryDescription.Length > 0)
+        {
+            var textEmbedding = GetTextEmbedding(queryDescription);
+            for (int j = 0; j < _embeddingDimension && j < textEmbedding.Length; j++)
+            {
+                avgQueryEmbedding[j] = NumOps.Divide(
+                    NumOps.Add(avgQueryEmbedding[j], textEmbedding[j]),
+                    NumOps.FromDouble(2.0));
+            }
+        }
+
+        avgQueryEmbedding = Normalize(avgQueryEmbedding);
+
+        var scores = new List<(int Index, T Score)>();
+        for (int i = 0; i < candidateList.Count; i++)
+        {
+            var candidateEmbedding = GetImageEmbedding(candidateList[i]);
+            var similarity = ComputeSimilarity(avgQueryEmbedding, candidateEmbedding);
+            scores.Add((i, similarity));
+        }
+
+        return scores.OrderByDescending(s => NumOps.ToDouble(s.Score)).Take(topK);
+    }
+
+    #endregion
+
+    #region Helper Methods
+
+    private string GenerateWithVisualContext(
+        IReadOnlyList<int> inputIds,
+        List<Tensor<T>> imageFeatures,
+        int maxLength)
+    {
+        var generatedIds = new List<int>(inputIds);
+        var specialTokens = _tokenizer.SpecialTokens;
+        var eosTokenStr = specialTokens?.EosToken ?? "[SEP]";
+        var eosEncoded = _tokenizer.Encode(eosTokenStr);
+        int eosTokenId = eosEncoded.TokenIds.Count > 0 ? eosEncoded.TokenIds[0] : 0;
+
+        var combinedImageFeatures = CombineImageFeatures(imageFeatures);
+
+        if (_outputProjection is null)
+        {
+            // Fail fast: without the output projection there are no logits to decode, so
+            // returning the (empty) suffix here would masquerade an unsupported state as a
+            // successful empty generation.
+            throw new InvalidOperationException(
+                "Output projection must be initialized before Flamingo text generation can produce logits.");
+        }
+
+        // The shared AutoregressiveDecoder owns the loop + greedy argmax + EOS stop. The per-step
+        // forward (text embed -> gated cross-attention every 4th LM layer -> output projection ->
+        // last-position logits) is supplied via the closure. Flamingo decodes greedily, matching the
+        // previous hand-rolled argmax (SampleFromLogits).
+        var newTokens = Generation.AutoregressiveDecoder<T>.Decode(
+            stepLogits: prev =>
+            {
+                if (prev.HasValue) generatedIds.Add(prev.Value);
+                // Slide the context to the most recent _maxSequenceLength tokens — Take(seqLen)
+                // would keep the FIRST tokens and silently drop every newly-generated token once
+                // the sequence exceeds the window, so later forward passes never see the latest token.
+                var contextIds = generatedIds
+                    .Skip(Math.Max(0, generatedIds.Count - _maxSequenceLength))
+                    .ToList();
+                if (contextIds.Count == 0)
+                {
+                    throw new InvalidOperationException("Generation requires at least one prompt token.");
+                }
+                int seqLen = contextIds.Count;
+                var embeddings = EmbedTextTokens(contextIds);
+
+                var current = embeddings;
+                int gatedAttnIdx = 0;
+                for (int layer = 0; layer < _numLmLayers && layer < _languageModelLayers.Count; layer++)
+                {
+                    if (layer % 4 == 0 && gatedAttnIdx < _gatedCrossAttentionLayers.Count)
+                    {
+                        if (_gatedCrossAttentionLayers[gatedAttnIdx] is CrossAttentionLayer<T> crossAttn)
+                        {
+                            var attnOut = crossAttn.Forward(current, combinedImageFeatures);
+                            current = AddTensors(current, attnOut);
+                        }
+                        gatedAttnIdx++;
+                    }
+
+                    current = _languageModelLayers[layer].Forward(current);
+                }
+
+                var lastPosition = Tensor<T>.CreateDefault([1, _lmHiddenDim], NumOps.Zero);
+                for (int j = 0; j < _lmHiddenDim; j++)
+                {
+                    lastPosition[0, j] = current[seqLen - 1, j];
+                }
+
+                var logits = _outputProjection.Forward(lastPosition);
+                int vocab = logits.Shape[1];
+                var v = new Vector<T>(vocab);
+                for (int i = 0; i < vocab; i++) v[i] = logits[0, i];
+                return v;
+            },
+            maxNewTokens: maxLength,
+            options: Generation.SamplingOptions.Greedy,
+            isEndToken: t => t == eosTokenId);
+
+        return _tokenizer.Decode(new List<int>(newTokens));
+    }
+
+    private Tensor<T> CombineImageFeatures(List<Tensor<T>> imageFeatures)
+    {
+        if (imageFeatures.Count == 0)
+        {
+            return Tensor<T>.CreateDefault([1, _lmHiddenDim], NumOps.Zero);
+        }
+
+        int totalTokens = imageFeatures.Sum(f => f.Shape[0]);
+        int hiddenDim = imageFeatures[0].Shape[1];
+
+        var combined = Tensor<T>.CreateDefault([totalTokens, hiddenDim], NumOps.Zero);
+        int offset = 0;
+
+        foreach (var features in imageFeatures)
+        {
+            for (int i = 0; i < features.Shape[0]; i++)
+            {
+                for (int j = 0; j < hiddenDim; j++)
+                {
+                    combined[offset + i, j] = features[i, j];
+                }
+            }
+            offset += features.Shape[0];
+        }
+
+        return combined;
+    }
+
+    private Tensor<T> AddTensors(Tensor<T> a, Tensor<T> b)
+    {
+        return Engine.TensorAdd(a, b);
+    }
+
+    #endregion
+
+    #region NeuralNetworkBase Overrides
+
+    /// <inheritdoc/>
+    protected override Tensor<T> PredictCore(Tensor<T> input)
+    {
+        // GPU-resident optimization: use TryForwardGpuOptimized for speedup
+        if (TryForwardGpuOptimized(input, out var gpuResult))
+            return gpuResult;
+
+        SetTrainingMode(false);
+        return Accelerate(input, () =>
+        {
+            var features = ExtractPerceiverFeatures(input);
+            return features;
+        });
+    }
+
+    /// <inheritdoc/>
     public override Tensor<T> ForwardForTraining(Tensor<T> input)
-    {
-        // The base implementation walks Layers as one flat sequential graph. Flamingo's
-        // layer list is structural storage for separate vision, perceiver, gated-attention,
-        // and language branches, so that walk does not represent PredictCore. Training the
-        // flat list therefore optimized a different output than Predict measured and could
-        // increase prediction loss even after a successful optimizer step. Run the same
-        // vision/perceiver graph used by PredictCore while the caller-owned tape is active.
-        EnsureLayerRandomSeedsWired();
+    {
+        // The base implementation walks Layers as one flat sequential graph. Flamingo's
+        // layer list is structural storage for separate vision, perceiver, gated-attention,
+        // and language branches, so that walk does not represent PredictCore. Training the
+        // flat list therefore optimized a different output than Predict measured and could
+        // increase prediction loss even after a successful optimizer step. Run the same
+        // vision/perceiver graph used by PredictCore while the caller-owned tape is active.
+        EnsureLayerRandomSeedsWired();
         return ExtractPerceiverFeatures(input);
     }
 
@@ -1194,331 +1150,161 @@ public override Dictionary<string, Tensor<T>> GetNamedLayerActivations(Tensor<T>
             ["perceiver_features"] = perceiverFeatures.Clone(),
         };
     }
-
-    /// <inheritdoc/>
-    public override void Train(Tensor<T> input, Tensor<T> expectedOutput)
-    {
-        // try/finally: SetTrainingMode(false) used to run only on the success path, so any throw from
-        // TrainWithTape -- a shape mismatch, a non-finite gradient, an OOM -- escaped with the model
-        // still in training mode. Dropout then stayed stochastic and BatchNorm kept updating its
-        // running statistics on every later Predict, making inference silently non-deterministic long
-        // after the error that caused it was handled.
-        SetTrainingMode(true);
-        try
-        {
-            TrainWithTape(input, expectedOutput, _optimizer);
-        }
-        finally
-        {
-            SetTrainingMode(false);
-        }
-    }
-
-    /// <summary>
-    /// Resolve Flamingo's lazy attention projections before cloning so a fresh instance
-    /// receives the same materialized layer shapes and weights. Without this, a clone made
-    /// before the first forward can retain independently initialized lazy projections.
-    /// </summary>
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy()
-    {
-        if (_useNativeMode && _imageSize > 0)
-        {
-            try
-            {
-                ResolveShapes(new Tensor<T>(new[] { _channels, _imageSize, _imageSize }));
-            }
-            catch (ArgumentException ex)
-            {
-                // Preserve the base fallback for callers supplying a custom architecture. The
-                // exception is expected on that path, but swallowing it silently meant a genuinely
-                // malformed architecture looked identical to a deliberately custom one -- the shape
-                // resolution just never happened and nothing said why.
-                System.Diagnostics.Debug.WriteLine(
-                    $"{nameof(FlamingoNeuralNetwork<T>)}: native-mode shape resolution declined a "
-                    + $"{_imageSize}x{_imageSize} probe, falling back to the base architecture. {ex.Message}");
-            }
-        }
-
-        // The base path owns COW/weight streaming for every model size. Rebind the
-        // private execution branches to its canonical cloned layer collection so no
-        // model-wide or per-layer parameter vector is materialized here.
-        var result = base.DeepCopy();
-        if (result is FlamingoNeuralNetwork<T> copy && _useNativeMode)
-        {
-            copy.RebindNativeLayerReferences();
-            copy._visionPositionalEmbeddings = _visionPositionalEmbeddings?.Clone();
-            copy._perceiverQueries = _perceiverQueries?.Clone();
-            copy._textPositionalEmbeddings = _textPositionalEmbeddings?.Clone();
-            copy.SetTrainingMode(IsTrainingMode);
-        }
-        return result;
-    }
-
-    // The layer streams this model holds outside Layers are discovered by ModelParameterGenerator and surfaced automatically; the hand-written hook that used to sit here was an override wearing a different name.
-
-    // UpdateParameters restated a fold the base now derives from generated component registration.
-    // Removed under AIDN082.
-    /// <inheritdoc/>
-    public override ModelMetadata<T> GetModelMetadata()
-    {
-        return new ModelMetadata<T>
-        {
-            AdditionalInfo = new Dictionary<string, object>
-            {
-                { "ImageSize", _imageSize },
-                { "EmbeddingDimension", _embeddingDimension },
-                { "MaxSequenceLength", _maxSequenceLength },
-                { "NumPerceiverTokens", _numPerceiverTokens },
-                { "MaxImagesInContext", _maxImagesInContext },
-                { "VisionHiddenDim", _visionHiddenDim },
-                { "LmHiddenDim", _lmHiddenDim },
-                { "NumVisionLayers", _numVisionLayers },
-                { "NumLmLayers", _numLmLayers },
-                { "NumPerceiverLayers", _numPerceiverLayers },
-                { "VocabularySize", _vocabularySize },
-                { "LanguageModelBackbone", _languageModelBackbone.ToString() },
-                { "UseNativeMode", _useNativeMode },
-                { "ParameterCount", ParameterCount },
-                { "TaskType", Architecture.TaskType.ToString() }
-            },
-            ModelData = SerializeForMetadata()
-        };
-    }
-
-    /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_embeddingDimension);
-        writer.Write(_maxSequenceLength);
-        writer.Write(_imageSize);
-        writer.Write(_numPerceiverTokens);
-        writer.Write(_maxImagesInContext);
-        writer.Write(_visionHiddenDim);
-        writer.Write(_lmHiddenDim);
-        writer.Write(_numVisionLayers);
-        writer.Write(_numLmLayers);
-        writer.Write(_numHeads);
-        writer.Write(_patchSize);
-        writer.Write(_vocabularySize);
-        writer.Write((int)_languageModelBackbone);
-        writer.Write(_numPerceiverLayers);
-        writer.Write(_useNativeMode);
-    }
-
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _ = reader.ReadInt32();
-        _ = reader.ReadInt32();
-        _ = reader.ReadInt32();
-        _ = reader.ReadInt32();
-        _ = reader.ReadInt32();
-        _ = reader.ReadInt32();
-        _ = reader.ReadInt32();
-        _ = reader.ReadInt32();
-        _ = reader.ReadInt32();
-        _ = reader.ReadInt32();
-        _ = reader.ReadInt32();
-        _ = reader.ReadInt32();
-        _ = (LanguageModelBackbone)reader.ReadInt32();
-        _ = reader.ReadInt32();
-        _ = reader.ReadBoolean();
-    }
-
-    /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        // Create a fresh optimizer instance to avoid state sharing between models
-        var freshOptimizer = new AdamOptimizer<T, Tensor<T>, Tensor<T>>(this);
-
-        if (_useNativeMode)
-        {
-            // Architecture.Layers may contain this instance's live layer objects.
-            // Rebuild the blueprint without that list so the COW clone owns fresh
-            // layer instances before rebinding their shared tensors.
-            var freshArchitecture = new NeuralNetworkArchitecture<T>(
-                Architecture.InputType,
-                Architecture.TaskType,
-                Architecture.Complexity,
-                Architecture.InputSize,
-                Architecture.InputHeight,
-                Architecture.InputWidth,
-                Architecture.InputDepth,
-                Architecture.OutputSize,
-                shouldReturnFullSequence: Architecture.ShouldReturnFullSequence,
-                imageEmbeddingDim: Architecture.ImageEmbeddingDim,
-                textEmbeddingDim: Architecture.TextEmbeddingDim,
-                inputFrames: Architecture.InputFrames)
-            {
-                RandomSeed = Architecture.RandomSeed,
-
-                // Carried explicitly, because it is settable rather than a constructor parameter and so
-                // is not covered by the rebuild above. Left off, the clone silently reverted to the
-                // architecture default (false) and trained its gradients through a different code path
-                // than the original -- a divergence with no error attached to it.
-                UseAutodiff = Architecture.UseAutodiff
-            };
-
-            // Layers is deliberately NOT carried over, and that is not the same omission: the source's
-            // Layers holds this instance's LIVE layer objects. Copying the list would have the clone
-            // share them, which is what the COW clone path then rebinds tensor-by-tensor. The clone
-            // rebuilds its own layer instances from the blueprint above and the caller re-binds the
-            // shared weights, so the layer graph is reproduced without aliasing the originals.
-
-            return new FlamingoNeuralNetwork<T>(
-                freshArchitecture,
-                _embeddingDimension,
-                _maxSequenceLength,
-                _imageSize,
-                _channels,
-                _numPerceiverTokens,
-                _maxImagesInContext,
-                _visionHiddenDim,
-                _lmHiddenDim,
-                _numVisionLayers,
-                _numLmLayers,
-                _numHeads,
-                _vocabularySize,
-                _languageModelBackbone,
-                _numPerceiverLayers,
-                _tokenizer,
-                freshOptimizer,
-                _lossFunction,
-                // Same class of drop as UseAutodiff: skipping this optional parameter handed the clone a
-                // default FlamingoOptions() rather than the one the original was configured with.
-                _options,
-                learningRate: _learningRate);
-        }
-        else
-        {
-            // ONNX mode - use the stored paths
-            string visionPath = _visionEncoderPath ?? string.Empty;
-            string languagePath = _languageModelPath ?? string.Empty;
-
-            if (visionPath.Length == 0 || languagePath.Length == 0)
-            {
-                throw new InvalidOperationException("Cannot clone ONNX mode instance without valid model paths.");
-            }
-
-            return new FlamingoNeuralNetwork<T>(
-                Architecture,
-                visionPath,
-                languagePath,
-                _tokenizer,
-                _embeddingDimension,
-                _maxSequenceLength,
-                _imageSize,
-                _numPerceiverTokens,
-                _maxImagesInContext,
-                freshOptimizer,
-                _lossFunction);
-        }
-    }
-
-    #endregion
-
-    #region IMultimodalEmbedding Interface (Standard API)
-
-    /// <inheritdoc/>
-    public Vector<T> EncodeText(string text)
-    {
-        return GetTextEmbedding(text);
-    }
-
-    /// <inheritdoc/>
-    public Matrix<T> EncodeTextBatch(IEnumerable<string> texts)
-    {
-        var embeddings = GetTextEmbeddings(texts).ToList();
-        if (embeddings.Count == 0)
-        {
-            return new Matrix<T>(0, EmbeddingDimension);
-        }
-
-        var matrix = new Matrix<T>(embeddings.Count, embeddings[0].Length);
-        for (int i = 0; i < embeddings.Count; i++)
-        {
-            for (int j = 0; j < embeddings[i].Length; j++)
-            {
-                matrix[i, j] = embeddings[i][j];
-            }
-        }
-        return matrix;
-    }
-
-    /// <inheritdoc/>
-    public Vector<T> EncodeImage(double[] imageData)
-    {
-        // Convert double[] to Tensor<T> in CHW format
-        var tensor = ConvertToTensor(imageData);
-        return GetImageEmbedding(tensor);
-    }
-
-    /// <inheritdoc/>
-    public Matrix<T> EncodeImageBatch(IEnumerable<double[]> imageDataBatch)
-    {
-        var tensors = imageDataBatch.Select(ConvertToTensor);
-        var embeddings = GetImageEmbeddings(tensors).ToList();
-        if (embeddings.Count == 0)
-        {
-            return new Matrix<T>(0, EmbeddingDimension);
-        }
-
-        var matrix = new Matrix<T>(embeddings.Count, embeddings[0].Length);
-        for (int i = 0; i < embeddings.Count; i++)
-        {
-            for (int j = 0; j < embeddings[i].Length; j++)
-            {
-                matrix[i, j] = embeddings[i][j];
-            }
-        }
-        return matrix;
-    }
-
-    /// <inheritdoc/>
-    public Dictionary<string, T> ZeroShotClassify(double[] imageData, IEnumerable<string> labels)
-    {
-        var tensor = ConvertToTensor(imageData);
-        return ZeroShotClassify(tensor, labels);
-    }
-
-    /// <summary>
-    /// Converts a double[] image to Tensor format.
-    /// </summary>
-    private Tensor<T> ConvertToTensor(double[] imageData)
-    {
-        if (imageData == null || imageData.Length == 0)
-        {
-            throw new ArgumentException("Image data cannot be null or empty.", nameof(imageData));
-        }
-
-        int channels = _channels;
-        if (imageData.Length % channels != 0)
-        {
-            throw new ArgumentException($"Image data length ({imageData.Length}) must be divisible by {channels} channels.", nameof(imageData));
-        }
-
-        int pixels = imageData.Length / channels;
-        int size = (int)Math.Sqrt(pixels);
-        if (size * size != pixels)
-        {
-            throw new ArgumentException($"Image must be square. Got {pixels} pixels which is not a perfect square.", nameof(imageData));
-        }
-
-        var tensor = new Tensor<T>(new[] { channels, size, size });
-        int idx = 0;
-        for (int c = 0; c < channels; c++)
-        {
-            for (int h = 0; h < size; h++)
-            {
-                for (int w = 0; w < size; w++)
-                {
-                    tensor[c, h, w] = NumOps.FromDouble(imageData[idx++]);
-                }
-            }
-        }
-        return tensor;
-    }
-
-    #endregion
-
-}
+
+    /// <inheritdoc/>
+    public override void Train(Tensor<T> input, Tensor<T> expectedOutput)
+    {
+        // try/finally: SetTrainingMode(false) used to run only on the success path, so any throw from
+        // TrainWithTape -- a shape mismatch, a non-finite gradient, an OOM -- escaped with the model
+        // still in training mode. Dropout then stayed stochastic and BatchNorm kept updating its
+        // running statistics on every later Predict, making inference silently non-deterministic long
+        // after the error that caused it was handled.
+        SetTrainingMode(true);
+        try
+        {
+            TrainWithTape(input, expectedOutput, _optimizer);
+        }
+        finally
+        {
+            SetTrainingMode(false);
+        }
+    }
+
+    // The layer streams this model holds outside Layers are discovered by ModelParameterGenerator and surfaced automatically; the hand-written hook that used to sit here was an override wearing a different name.
+
+    // UpdateParameters restated a fold the base now derives from generated component registration.
+    // Removed under AIDN082.
+    /// <inheritdoc/>
+    public override ModelMetadata<T> GetModelMetadata()
+    {
+        return new ModelMetadata<T>
+        {
+            AdditionalInfo = new Dictionary<string, object>
+            {
+                { "ImageSize", _imageSize },
+                { "EmbeddingDimension", _embeddingDimension },
+                { "MaxSequenceLength", _maxSequenceLength },
+                { "NumPerceiverTokens", _numPerceiverTokens },
+                { "MaxImagesInContext", _maxImagesInContext },
+                { "VisionHiddenDim", _visionHiddenDim },
+                { "LmHiddenDim", _lmHiddenDim },
+                { "NumVisionLayers", _numVisionLayers },
+                { "NumLmLayers", _numLmLayers },
+                { "NumPerceiverLayers", _numPerceiverLayers },
+                { "VocabularySize", _vocabularySize },
+                { "LanguageModelBackbone", _languageModelBackbone.ToString() },
+                { "UseNativeMode", _useNativeMode },
+                { "ParameterCount", ParameterCount },
+                { "TaskType", Architecture.TaskType.ToString() }
+            },
+            ModelData = SerializeForMetadata()
+        };
+    }
+
+    #endregion
+
+    #region IMultimodalEmbedding Interface (Standard API)
+
+    /// <inheritdoc/>
+    public Vector<T> EncodeText(string text)
+    {
+        return GetTextEmbedding(text);
+    }
+
+    /// <inheritdoc/>
+    public Matrix<T> EncodeTextBatch(IEnumerable<string> texts)
+    {
+        var embeddings = GetTextEmbeddings(texts).ToList();
+        if (embeddings.Count == 0)
+        {
+            return new Matrix<T>(0, EmbeddingDimension);
+        }
+
+        var matrix = new Matrix<T>(embeddings.Count, embeddings[0].Length);
+        for (int i = 0; i < embeddings.Count; i++)
+        {
+            for (int j = 0; j < embeddings[i].Length; j++)
+            {
+                matrix[i, j] = embeddings[i][j];
+            }
+        }
+        return matrix;
+    }
+
+    /// <inheritdoc/>
+    public Vector<T> EncodeImage(double[] imageData)
+    {
+        // Convert double[] to Tensor<T> in CHW format
+        var tensor = ConvertToTensor(imageData);
+        return GetImageEmbedding(tensor);
+    }
+
+    /// <inheritdoc/>
+    public Matrix<T> EncodeImageBatch(IEnumerable<double[]> imageDataBatch)
+    {
+        var tensors = imageDataBatch.Select(ConvertToTensor);
+        var embeddings = GetImageEmbeddings(tensors).ToList();
+        if (embeddings.Count == 0)
+        {
+            return new Matrix<T>(0, EmbeddingDimension);
+        }
+
+        var matrix = new Matrix<T>(embeddings.Count, embeddings[0].Length);
+        for (int i = 0; i < embeddings.Count; i++)
+        {
+            for (int j = 0; j < embeddings[i].Length; j++)
+            {
+                matrix[i, j] = embeddings[i][j];
+            }
+        }
+        return matrix;
+    }
+
+    /// <inheritdoc/>
+    public Dictionary<string, T> ZeroShotClassify(double[] imageData, IEnumerable<string> labels)
+    {
+        var tensor = ConvertToTensor(imageData);
+        return ZeroShotClassify(tensor, labels);
+    }
+
+    /// <summary>
+    /// Converts a double[] image to Tensor format.
+    /// </summary>
+    private Tensor<T> ConvertToTensor(double[] imageData)
+    {
+        if (imageData == null || imageData.Length == 0)
+        {
+            throw new ArgumentException("Image data cannot be null or empty.", nameof(imageData));
+        }
+
+        int channels = _channels;
+        if (imageData.Length % channels != 0)
+        {
+            throw new ArgumentException($"Image data length ({imageData.Length}) must be divisible by {channels} channels.", nameof(imageData));
+        }
+
+        int pixels = imageData.Length / channels;
+        int size = (int)Math.Sqrt(pixels);
+        if (size * size != pixels)
+        {
+            throw new ArgumentException($"Image must be square. Got {pixels} pixels which is not a perfect square.", nameof(imageData));
+        }
+
+        var tensor = new Tensor<T>(new[] { channels, size, size });
+        int idx = 0;
+        for (int c = 0; c < channels; c++)
+        {
+            for (int h = 0; h < size; h++)
+            {
+                for (int w = 0; w < size; w++)
+                {
+                    tensor[c, h, w] = NumOps.FromDouble(imageData[idx++]);
+                }
+            }
+        }
+        return tensor;
+    }
+
+    #endregion
+
+}
diff --git a/src/NeuralNetworks/GLALanguageModel.cs b/src/NeuralNetworks/GLALanguageModel.cs
index 91f0344663..ee25d9e48a 100644
--- a/src/NeuralNetworks/GLALanguageModel.cs
+++ b/src/NeuralNetworks/GLALanguageModel.cs
@@ -37,7 +37,7 @@ namespace AiDotNet.NeuralNetworks;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Gated Linear Attention Transformers with Hardware-Efficient Training", "https://arxiv.org/abs/2312.06635", Year = 2024, Authors = "Songlin Yang, Bailin Wang, Yikang Shen, Rameswar Panda, Yoon Kim")]
-public class GLALanguageModel<T> : TokenLanguageModelLayoutBase<T>
+public partial class GLALanguageModel<T> : TokenLanguageModelLayoutBase<T>
 {
     private readonly GLAOptions _options;
     private readonly int _vocabSize;
@@ -170,35 +170,9 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_vocabSize);
-        writer.Write(_modelDimension);
-        writer.Write(_numLayers);
-        writer.Write(_numHeads);
-        writer.Write(_maxSeqLength);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _ = reader.ReadInt32();
-        _ = reader.ReadInt32();
-        _ = reader.ReadInt32();
-        _ = reader.ReadInt32();
-        _ = reader.ReadInt32();
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var cloneOptimizer = _optimizer.GetOptions() is AdamWOptimizerOptions<T, Tensor<T>, Tensor<T>> optimizerOptions
-            ? new AdamWOptimizer<T, Tensor<T>, Tensor<T>>(
-                null,
-                new AdamWOptimizerOptions<T, Tensor<T>, Tensor<T>>(optimizerOptions))
-            : null;
-        return new GLALanguageModel<T>(
-            Architecture, _vocabSize, _modelDimension, _numLayers, _numHeads,
-            _maxSeqLength, LossFunction, new GLAOptions(_options), cloneOptimizer);
-    }
+
 
     #endregion
 }
diff --git a/src/NeuralNetworks/GRUNeuralNetwork.cs b/src/NeuralNetworks/GRUNeuralNetwork.cs
index 74878ff1dd..2df2d9049c 100644
--- a/src/NeuralNetworks/GRUNeuralNetwork.cs
+++ b/src/NeuralNetworks/GRUNeuralNetwork.cs
@@ -52,7 +52,7 @@ namespace AiDotNet.NeuralNetworks;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Learning Phrase Representations using RNN Encoder-Decoder for Statistical Machine Translation", "https://arxiv.org/abs/1406.1078", Year = 2014, Authors = "Kyunghyun Cho, Bart van Merrienboer, Caglar Gulcehre, Dzmitry Bahdanau, Fethi Bougares, Holger Schwenk, Yoshua Bengio")]
-public class GRUNeuralNetwork<T> : SequenceModelLayoutBase<T>
+public partial class GRUNeuralNetwork<T> : SequenceModelLayoutBase<T>
 {
     private readonly GRUOptions _options;
     private readonly IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>> _optimizer;
@@ -336,78 +336,7 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    /// <summary>
-    /// Saves GRU-specific data to a binary stream.
-    /// </summary>
-    /// <param name="writer">The binary writer to save to.</param>
-    /// <remarks>
-    /// <para>
-    /// This method serializes any GRU-specific data that isn't part of the base neural network.
-    /// In the case of a GRU network, this might include sequence-specific settings or state.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method saves special GRU settings to a file.
-    /// 
-    /// When saving the model:
-    /// - The base neural network parts are saved by other methods
-    /// - This method saves any GRU-specific settings or state
-    /// 
-    /// This ensures that when you reload the model, it will have all the same settings
-    /// and capabilities as the original.
-    /// </para>
-    /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(Convert.ToDouble(_learningRate));
-    }
 
-    /// <summary>
-    /// Loads GRU-specific data from a binary stream.
-    /// </summary>
-    /// <param name="reader">The binary reader to load from.</param>
-    /// <remarks>
-    /// <para>
-    /// This method deserializes GRU-specific data that was previously saved using SerializeNetworkSpecificData.
-    /// It restores any special configuration or state that is unique to GRU networks.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method loads special GRU settings from a file.
-    /// 
-    /// When loading a saved model:
-    /// - The base neural network parts are loaded by other methods
-    /// - This method loads any GRU-specific settings or state
-    /// 
-    /// This ensures that the loaded model functions exactly like the original one that was saved.
-    /// </para>
-    /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _learningRate = NumOps.FromDouble(reader.ReadDouble());
-    }
 
-    /// <summary>
-    /// Creates a new instance of the GRU Neural Network with the same architecture and configuration.
-    /// </summary>
-    /// <returns>A new GRU Neural Network instance with the same architecture and configuration.</returns>
-    /// <remarks>
-    /// <para>
-    /// This method creates a new instance of the GRU Neural Network with the same architecture as the current instance.
-    /// It's used in scenarios where a fresh copy of the model is needed while maintaining the same configuration.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method creates a brand new copy of the neural network with the same setup.
-    /// 
-    /// Think of it like creating a clone of the network:
-    /// - The new network has the same architecture (structure)
-    /// - But it's a completely separate instance with its own parameters and learning state
-    /// 
-    /// This is useful when you need multiple instances of the same GRU model,
-    /// such as for ensemble learning or comparing different training approaches.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new GRUNeuralNetwork<T>(
-            Architecture,
-            lossFunction: LossFunction,
-            options: _options,
-            learningRate: NumOps.ToDouble(_learningRate));
-    }
+
 }
diff --git a/src/NeuralNetworks/GatedDeltaNetLanguageModel.cs b/src/NeuralNetworks/GatedDeltaNetLanguageModel.cs
index 3b56edf6a7..a410876609 100644
--- a/src/NeuralNetworks/GatedDeltaNetLanguageModel.cs
+++ b/src/NeuralNetworks/GatedDeltaNetLanguageModel.cs
@@ -37,7 +37,7 @@ namespace AiDotNet.NeuralNetworks;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Gated Delta Networks: Improving Mamba2 with Delta Rule", "https://arxiv.org/abs/2412.06464", Year = 2024, Authors = "Songlin Yang, Jan Kautz, Ali Hatamizadeh")]
-public class GatedDeltaNetLanguageModel<T> : TokenLanguageModelLayoutBase<T>
+public partial class GatedDeltaNetLanguageModel<T> : TokenLanguageModelLayoutBase<T>
 {
     private readonly GatedDeltaNetOptions _options;
     private readonly int _vocabSize;
@@ -171,35 +171,9 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_vocabSize);
-        writer.Write(_modelDimension);
-        writer.Write(_numLayers);
-        writer.Write(_numHeads);
-        writer.Write(_maxSeqLength);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _ = reader.ReadInt32();
-        _ = reader.ReadInt32();
-        _ = reader.ReadInt32();
-        _ = reader.ReadInt32();
-        _ = reader.ReadInt32();
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var cloneOptimizer = _optimizer.GetOptions() is AdamWOptimizerOptions<T, Tensor<T>, Tensor<T>> optimizerOptions
-            ? new AdamWOptimizer<T, Tensor<T>, Tensor<T>>(
-                null,
-                new AdamWOptimizerOptions<T, Tensor<T>, Tensor<T>>(optimizerOptions))
-            : null;
-        return new GatedDeltaNetLanguageModel<T>(
-            Architecture, _vocabSize, _modelDimension, _numLayers, _numHeads,
-            _maxSeqLength, LossFunction, new GatedDeltaNetOptions(_options), cloneOptimizer);
-    }
+
 
     #endregion
 }
diff --git a/src/NeuralNetworks/GenerativeAdversarialNetwork.cs b/src/NeuralNetworks/GenerativeAdversarialNetwork.cs
index e87148e7b1..cb42095539 100644
--- a/src/NeuralNetworks/GenerativeAdversarialNetwork.cs
+++ b/src/NeuralNetworks/GenerativeAdversarialNetwork.cs
@@ -280,11 +280,13 @@ public partial class GenerativeAdversarialNetwork<T> : ImageGeneratorModelLayout
     /// <summary>
     /// Stores the last real batch for feature matching computation.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastRealBatch;
 
     /// <summary>
     /// Stores the last fake batch for feature matching computation.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastFakeBatch;
 
     /// <summary>
@@ -1858,37 +1860,7 @@ public override ModelMetadata<T> GetModelMetadata()
     /// </summary>
     private const int GanSerializationVersion = 1;
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        // Format-version header. ALWAYS the first int written by this
-        // method so the deserializer can sniff what fields to expect.
-        writer.Write(GanSerializationVersion);
-
-        // Persist gradient-penalty configuration so a reloaded checkpoint
-        // continues training with the same WGAN-GP coefficient/enabled state.
-        // Without this, resuming a WGAN-GP run silently falls back to the
-        // default (disabled / λ = 10) and the loss curve changes shape.
-        writer.Write(_useGradientPenalty);
-        writer.Write(_gradientPenaltyLambda);
-
-        // Save recent loss history (last 20 entries at most)
-        int lossCount = Math.Min(_generatorLosses.Count, 20);
-        writer.Write(lossCount);
-
-        for (int i = _generatorLosses.Count - lossCount; i < _generatorLosses.Count; i++)
-        {
-            writer.Write(Convert.ToDouble(_generatorLosses[i]));
-        }
-
-        // Save Generator and Discriminator networks
-        var generatorBytes = Generator.Serialize();
-        writer.Write(generatorBytes.Length);
-        writer.Write(generatorBytes);
 
-        var discriminatorBytes = Discriminator.Serialize();
-        writer.Write(discriminatorBytes.Length);
-        writer.Write(discriminatorBytes);
-    }
 
     /// <summary>
     /// Deserializes GAN-specific data from a binary reader.
@@ -1912,57 +1884,7 @@ protected override void SerializeNetworkSpecificData(BinaryWriter writer)
     /// or use a model that someone else has trained.
     /// </para>
     /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        // Read the format-version header first so we know what fields to
-        // expect. Legacy checkpoints predate the header and start straight
-        // at the lossCount int — a v0 (no header) checkpoint reads the
-        // same first int as `version` but the value will be > 1, so we
-        // fall through to the legacy branch instead of mis-aligning.
-        long headerStart = reader.BaseStream.Position;
-        int version = reader.ReadInt32();
-        if (version == GanSerializationVersion)
-        {
-            // Restore gradient-penalty configuration (must match the order
-            // in SerializeNetworkSpecificData above).
-            _useGradientPenalty = reader.ReadBoolean();
-            _gradientPenaltyLambda = reader.ReadDouble();
-        }
-        else if (version > GanSerializationVersion)
-        {
-            throw new InvalidDataException(
-                $"GAN checkpoint format version {version} is newer than this binary " +
-                $"supports (max version {GanSerializationVersion}). Update the AiDotNet " +
-                "library before loading this checkpoint.");
-        }
-        else
-        {
-            // Pre-versioning (v0) checkpoint — no gradient-penalty fields.
-            // Rewind to the start of the network-specific block so the
-            // legacy code path picks up the lossCount int we just consumed.
-            reader.BaseStream.Position = headerStart;
-            _useGradientPenalty = false;
-            _gradientPenaltyLambda = 10.0;
-        }
-
-        // Load recent loss history
-        int lossCount = reader.ReadInt32();
-        _generatorLosses = new List<T>(lossCount);
 
-        for (int i = 0; i < lossCount; i++)
-        {
-            _generatorLosses.Add(NumOps.FromDouble(reader.ReadDouble()));
-        }
-
-        // Load Generator and Discriminator networks
-        int generatorDataLength = reader.ReadInt32();
-        byte[] generatorData = reader.ReadBytes(generatorDataLength);
-        Generator.Deserialize(generatorData);
-
-        int discriminatorDataLength = reader.ReadInt32();
-        byte[] discriminatorData = reader.ReadBytes(discriminatorDataLength);
-        Discriminator.Deserialize(discriminatorData);
-    }
 
     /// <inheritdoc />
     /// <remarks>
@@ -2623,37 +2545,4 @@ private Tensor<T> ComputeBatchMean(Tensor<T> tensor)
         T batchSizeT = NumOps.FromDouble(batchSize);
         return Engine.TensorDivideScalar(sum, batchSizeT);
     }
-
-    /// <summary>
-    /// Creates a new instance of the GenerativeAdversarialNetwork with the same configuration as the current instance.
-    /// </summary>
-    /// <returns>A new GenerativeAdversarialNetwork instance with the same architecture as the current instance.</returns>
-    /// <remarks>
-    /// <para>
-    /// This method creates a new instance of the GenerativeAdversarialNetwork with the same generator and
-    /// discriminator architectures as the current instance. This is useful for model cloning, ensemble methods, or
-    /// cross-validation scenarios where multiple instances of the same model with identical configurations are needed.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method creates a fresh copy of the GAN's blueprint.
-    ///
-    /// When you need multiple versions of the same GAN with identical settings:
-    /// - This method creates a new, empty GAN with the same configuration
-    /// - It copies the architecture of both the generator and discriminator networks
-    /// - The new GAN has the same structure but no trained data
-    /// - This is useful for techniques that need multiple models, like ensemble methods
-    ///
-    /// For example, when experimenting with different training approaches,
-    /// you'd want to start with identical model configurations.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new GenerativeAdversarialNetwork<T>(
-            Generator.Architecture,
-            Discriminator.Architecture,
-            Architecture.InputType,
-            generatorOptimizer: null,
-            discriminatorOptimizer: null,
-            _lossFunction);
-    }
 }
diff --git a/src/NeuralNetworks/GloVe.cs b/src/NeuralNetworks/GloVe.cs
index 67b3f6a9d7..d45f4dc151 100644
--- a/src/NeuralNetworks/GloVe.cs
+++ b/src/NeuralNetworks/GloVe.cs
@@ -53,7 +53,7 @@ namespace AiDotNet.NeuralNetworks
     [ModelComplexity(ModelComplexity.Low)]
     [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
     [ResearchPaper("GloVe: Global Vectors for Word Representation", "https://nlp.stanford.edu/pubs/glove.pdf", Year = 2014, Authors = "Jeffrey Pennington, Richard Socher, Christopher D. Manning")]
-    public class GloVe<T> : TextEmbeddingModelLayoutBase<T>, IEmbeddingModel<T>
+    public partial class GloVe<T> : TextEmbeddingModelLayoutBase<T>, IEmbeddingModel<T>
     {
         private readonly GloVeOptions _options;
 
@@ -508,20 +508,6 @@ public Task<Matrix<T>> EmbedBatchAsync(IEnumerable<string> texts)
             return Task.FromResult(EmbedBatch(texts));
         }
 
-        /// <inheritdoc/>
-        protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-        {
-            return new GloVe<T>(
-                Architecture,
-                _tokenizer,
-                null, // Fresh optimizer for new instance
-                _vocabSize,
-                _embeddingDimension,
-                _maxTokens,
-                _lossFunction,
-                Convert.ToDouble(MaxGradNorm));
-        }
-
         /// <summary>
         /// Returns technical details and configuration info about the GloVe model.
         /// </summary>
@@ -542,21 +528,9 @@ public override ModelMetadata<T> GetModelMetadata()
             };
         }
 
-        /// <inheritdoc/>
-        protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-        {
-            writer.Write(_vocabSize);
-            writer.Write(_embeddingDimension);
-            writer.Write(_maxTokens);
-        }
 
-        /// <inheritdoc/>
-        protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-        {
-            _vocabSize = reader.ReadInt32();
-            _embeddingDimension = reader.ReadInt32();
-            _maxTokens = reader.ReadInt32();
-        }
+
+
 
         #endregion
     }
diff --git a/src/NeuralNetworks/Gpt4VisionNeuralNetwork.cs b/src/NeuralNetworks/Gpt4VisionNeuralNetwork.cs
index 0032176dde..a095e7706c 100644
--- a/src/NeuralNetworks/Gpt4VisionNeuralNetwork.cs
+++ b/src/NeuralNetworks/Gpt4VisionNeuralNetwork.cs
@@ -89,7 +89,9 @@ public partial class Gpt4VisionNeuralNetwork<T> : MultimodalModelLayoutBase<T>,
 
     // Vision encoder layers (ViT)
     private readonly List<ILayer<T>> _visionEncoderLayers = [];
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T>? _visionClsToken;
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T>? _visionPositionalEmbeddings;
     private ILayer<T>? _visionPatchEmbedding;
     private ILayer<T>? _visionLayerNorm;
@@ -100,6 +102,7 @@ public partial class Gpt4VisionNeuralNetwork<T> : MultimodalModelLayoutBase<T>,
 
     // Language Model (Transformer Decoder)
     private readonly List<ILayer<T>> _languageModelLayers = [];
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T>? _textPositionalEmbeddings;
     private ILayer<T>? _tokenEmbedding;
     private ILayer<T>? _lmHead;
@@ -1441,51 +1444,6 @@ private Tensor<T> NormalizeTensor(Tensor<T> tensor)
 
     #region NeuralNetworkBase Overrides
 
-    /// <summary>
-    /// Declares the CLS token and the two positional embedding tables, which live outside
-    /// <see cref="NeuralNetworkBase{T}.Layers"/>.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// Declared in the order the deleted ParameterCount added them: vision CLS token, vision
-    /// positional embeddings, text positional embeddings.
-    /// </para>
-    /// <para>
-    /// They are <c>Tensor&lt;T&gt;</c> now rather than <c>Matrix&lt;T&gt;</c> because a matrix is
-    /// invisible to the trainable-parameter walk -- which is the whole reason ParameterCount had to
-    /// be written by hand in the first place, and the reason the two surfaces disagreed. The count
-    /// added these three tables; <c>GetParameters</c> was NOT overridden, so it walked only
-    /// <c>Layers</c> and never saw them. The tables were therefore counted but never handed out,
-    /// never restored, and never trained through a flat-vector optimizer.
-    /// </para>
-    /// <para>
-    /// The override also opened with <c>if (!_useNativeMode) return 0;</c> while the inherited
-    /// GetParameters kept returning the real layer vector, so in architecture mode the count said
-    /// zero and the vector did not. Deleting it removes that split too: both surfaces now walk
-    /// <c>Layers</c> plus these tensors, in both modes. The per-modality lists
-    /// (<c>_visionEncoderLayers</c> and friends) need no declaration -- they are filled FROM
-    /// <c>Layers</c> (<c>_visionEncoderLayers.Add(Layers[idx++])</c>), so they are typed views of
-    /// layers the base walk already reaches, and declaring them would double-count.
-    /// </para>
-    /// </remarks>
-    protected override IEnumerable<Tensor<T>> GetExtraTrainableTensors()
-    {
-        if (_visionClsToken is not null)
-        {
-            yield return _visionClsToken;
-        }
-
-        if (_visionPositionalEmbeddings is not null)
-        {
-            yield return _visionPositionalEmbeddings;
-        }
-
-        if (_textPositionalEmbeddings is not null)
-        {
-            yield return _textPositionalEmbeddings;
-        }
-    }
-
     /// <inheritdoc/>
     protected override Tensor<T> PredictCore(Tensor<T> input)
     {
@@ -1615,88 +1573,6 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_embeddingDimension);
-        writer.Write(_visionEmbeddingDim);
-        writer.Write(_maxSequenceLength);
-        writer.Write(_contextWindowSize);
-        writer.Write(_imageSize);
-        writer.Write(_hiddenDim);
-        writer.Write(_numVisionLayers);
-        writer.Write(_numLanguageLayers);
-        writer.Write(_numHeads);
-        writer.Write(_patchSize);
-        writer.Write(_vocabularySize);
-        writer.Write(_maxImagesPerRequest);
-        writer.Write(_useNativeMode);
-    }
-
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _embeddingDimension = reader.ReadInt32();
-        _visionEmbeddingDim = reader.ReadInt32();
-        _maxSequenceLength = reader.ReadInt32();
-        _contextWindowSize = reader.ReadInt32();
-        _imageSize = reader.ReadInt32();
-        _hiddenDim = reader.ReadInt32();
-        _numVisionLayers = reader.ReadInt32();
-        _numLanguageLayers = reader.ReadInt32();
-        _numHeads = reader.ReadInt32();
-        _patchSize = reader.ReadInt32();
-        _vocabularySize = reader.ReadInt32();
-        _maxImagesPerRequest = reader.ReadInt32();
-        _useNativeMode = reader.ReadBoolean();
-    }
-
-    /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode)
-        {
-            // For ONNX mode, we need valid paths - extract to local variables for null safety
-            string visionPath = _visionEncoderPath ?? string.Empty;
-            string languagePath = _languageModelPath ?? string.Empty;
-
-            if (visionPath.Length == 0 || languagePath.Length == 0)
-            {
-                throw new InvalidOperationException(
-                    "Cannot create new instance in ONNX mode: model paths are not available. " +
-                    "ONNX model paths are not serialized. Use native mode for serialization.");
-            }
-
-            return new Gpt4VisionNeuralNetwork<T>(
-                Architecture,
-                visionPath,
-                languagePath,
-                _tokenizer,
-                _embeddingDimension,
-                _visionEmbeddingDim,
-                _maxSequenceLength,
-                _contextWindowSize,
-                _imageSize,
-                _maxImagesPerRequest);
-        }
-
-        return new Gpt4VisionNeuralNetwork<T>(
-            Architecture,
-            _tokenizer,
-            _embeddingDimension,
-            _visionEmbeddingDim,
-            _maxSequenceLength,
-            _contextWindowSize,
-            _imageSize,
-            _hiddenDim,
-            _numVisionLayers,
-            _numLanguageLayers,
-            _numHeads,
-            _patchSize,
-            _vocabularySize,
-            _maxImagesPerRequest);
-    }
-
     /// <inheritdoc/>
     protected override void Dispose(bool disposing)
     {
diff --git a/src/NeuralNetworks/GraphAttentionNetwork.cs b/src/NeuralNetworks/GraphAttentionNetwork.cs
index 7bdbf8ed45..62f1e063b8 100644
--- a/src/NeuralNetworks/GraphAttentionNetwork.cs
+++ b/src/NeuralNetworks/GraphAttentionNetwork.cs
@@ -1,4 +1,4 @@
-using AiDotNet.Attributes;
+using AiDotNet.Attributes;
 using AiDotNet.Enums;
 using AiDotNet.Helpers;
 using AiDotNet.Interfaces;
@@ -69,7 +69,7 @@ namespace AiDotNet.NeuralNetworks;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Graph Attention Networks", "https://arxiv.org/abs/1710.10903", Year = 2018, Authors = "Petar Velickovic, Guillem Cucurull, Arantxa Casanova, Adriana Romero, Pietro Lio, Yoshua Bengio")]
-public class GraphAttentionNetwork<T> : GraphModelLayoutBase<T>
+public partial class GraphAttentionNetwork<T> : GraphModelLayoutBase<T>
 {
     private readonly GraphAttentionNetworkOptions _options;
 
@@ -901,53 +901,13 @@ public override ModelMetadata<T> GetModelMetadata()
     /// Serializes network-specific data to a binary writer.
     /// </summary>
     /// <param name="writer">The binary writer to serialize to.</param>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        // Serialize GAT-specific configuration
-        writer.Write(NumHeads);
-        writer.Write(HiddenDim);
-        writer.Write(NumLayers);
-        writer.Write(DropoutRate);
-        writer.Write(IsLoRAEnabled);
-        writer.Write(LoRARank);
-
-        // Serialize loss function and optimizer
-        SerializationHelper<T>.SerializeInterface(writer, _lossFunction);
-        SerializationHelper<T>.SerializeInterface(writer, _optimizer);
-    }
+
 
     /// <summary>
     /// Deserializes network-specific data from a binary reader.
     /// </summary>
     /// <param name="reader">The binary reader to deserialize from.</param>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        // Note: The readonly fields are set in constructor, so we just read and discard
-        // to maintain stream position. For full deserialization, use Load method.
-        var numHeads = reader.ReadInt32();
-        var hiddenDim = reader.ReadInt32();
-        var numLayers = reader.ReadInt32();
-        var dropoutRate = reader.ReadDouble();
-        var isLoRAEnabled = reader.ReadBoolean();
-        var loraRank = reader.ReadInt32();
-
-        // Deserialize loss function and optimizer
-        _ = DeserializationHelper.DeserializeInterface<ILossFunction<T>>(reader);
-        _ = DeserializationHelper.DeserializeInterface<IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>>(reader);
-    }
 
-    /// <summary>
-    /// Creates a new instance of this network type for cloning or deserialization.
-    /// </summary>
-    /// <returns>A new GraphAttentionNetwork instance.</returns>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new GraphAttentionNetwork<T>(
-            architecture: Architecture,
-            numHeads: NumHeads,
-            numLayers: NumLayers,
-            dropoutRate: DropoutRate);
-    }
 
     #endregion
 }
diff --git a/src/NeuralNetworks/GraphGenerationModel.cs b/src/NeuralNetworks/GraphGenerationModel.cs
index 6c25f773ef..a631240eca 100644
--- a/src/NeuralNetworks/GraphGenerationModel.cs
+++ b/src/NeuralNetworks/GraphGenerationModel.cs
@@ -1,4 +1,4 @@
-#pragma warning disable CS0649, CS0414, CS0169
+#pragma warning disable CS0649, CS0414, CS0169
 using AiDotNet.Attributes;
 using AiDotNet.Enums;
 using AiDotNet.Extensions;
@@ -73,16 +73,8 @@ namespace AiDotNet.NeuralNetworks;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Variational Graph Auto-Encoders", "https://arxiv.org/abs/1611.07308")]
-public class GraphGenerationModel<T> : GraphModelLayoutBase<T>
+public partial class GraphGenerationModel<T> : GraphModelLayoutBase<T>
 {
-
-    /// <inheritdoc />
-    /// <remarks>The variational head: the mean and log-variance projections that turn the
-    /// encoder output into a latent distribution. They live outside Layers, and the
-    /// hand-written surfaces appended them in this order after the layer walk -- which is
-    /// exactly where the base fold puts extra tensors.</remarks>
-    protected override IEnumerable<Tensor<T>> GetExtraTrainableTensors()
-        => new[] { _meanWeights, _logVarWeights };
     private readonly GraphGenerationModelOptions _options;
 
     /// <inheritdoc/>
@@ -136,36 +128,43 @@ protected override IEnumerable<Tensor<T>> GetExtraTrainableTensors()
     /// <summary>
     /// Encoder weights for mean projection.
     /// </summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _meanWeights;
 
     /// <summary>
     /// Encoder weights for log-variance projection.
     /// </summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _logVarWeights;
 
     /// <summary>
     /// Cached latent mean from last forward pass.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastMean;
 
     /// <summary>
     /// Cached latent log-variance from last forward pass.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastLogVar;
 
     /// <summary>
     /// Cached sampled latent representation.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastLatent;
 
     /// <summary>
     /// Cached encoder output before variational layer.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastEncoderOutput;
 
     /// <summary>
     /// Cached input adjacency matrix.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _cachedAdjacencyMatrix;
 
     /// <summary>
@@ -173,15 +172,10 @@ protected override IEnumerable<Tensor<T>> GetExtraTrainableTensors()
     /// </summary>
     private readonly Random _random;
 
-    /// <summary>
-    /// Gradient for mean weights.
-    /// </summary>
-    private Tensor<T>? _meanWeightsGradient;
-
-    /// <summary>
-    /// Gradient for log-variance weights.
-    /// </summary>
-    private Tensor<T>? _logVarWeightsGradient;
+    // _meanWeightsGradient and _logVarWeightsGradient are gone with the hand-written
+    // GetParameterGradients override that was their only reader. The tape's gradients for
+    // these two tensors now reach the surface through PublishParameterGradients, which
+    // keys them by tensor identity rather than by a field the model has to remember to set.
 
     /// <summary>
     /// Initializes a new instance of the <see cref="GraphGenerationModel{T}"/> class.
@@ -809,42 +803,11 @@ public List<Tensor<T>> Interpolate(
         return count;
     }
 
-    /// <summary>
-    /// Gets all parameter gradients as a vector (encoder layers + variational weights).
-    /// </summary>
-    public override Vector<T> GetParameterGradients()
-    {
-        // Encoder layer gradients
-        var baseGradients = base.GetParameterGradients();
-        var allGrads = new List<T>();
-        for (int i = 0; i < baseGradients.Length; i++)
-            allGrads.Add(baseGradients[i]);
-
-        // Variational layer gradients
-        if (_meanWeightsGradient != null)
-        {
-            for (int i = 0; i < _meanWeightsGradient.Length; i++)
-                allGrads.Add(_meanWeightsGradient.GetFlat(i));
-        }
-        else
-        {
-            for (int i = 0; i < _meanWeights.Length; i++)
-                allGrads.Add(NumOps.Zero);
-        }
-
-        if (_logVarWeightsGradient != null)
-        {
-            for (int i = 0; i < _logVarWeightsGradient.Length; i++)
-                allGrads.Add(_logVarWeightsGradient.GetFlat(i));
-        }
-        else
-        {
-            for (int i = 0; i < _logVarWeights.Length; i++)
-                allGrads.Add(NumOps.Zero);
-        }
-
-        return new Vector<T>(allGrads.ToArray());
-    }
+    // The GetParameterGradients override that used to live here appended _meanWeights and
+    // _logVarWeights to base.GetParameterGradients(). The base already folds every tensor
+    // GetExtraTrainableTensors declares -- these two -- so the override appended them a
+    // second time and returned a vector longer than GetParameters(). Deleted so the one
+    // ordering in the base is the only ordering.
 
     #region Abstract Method Implementations
 
@@ -889,6 +852,13 @@ protected override Tensor<T> PredictCore(Tensor<T> input)
         return Decode(mean);
     }
 
+    // NOT a parameter. This is the self-loop identity matrix EnsureAdjacencyMatrix derives when a
+    // caller predicts without supplying a graph, and it is rebuilt from scratch the moment the node
+    // count changes -- so there is nothing here a checkpoint needs to carry. Declaring it trainable
+    // put a graph in the optimizer's hands: Adam moved the self-loops off 1, two encoder layers
+    // propagated the drift, and the ELBO went to NaN. It was input-sized as well, so it moved
+    // ParameterCount under a forward pass for the same reason the layer-side adjacency did.
+    [Scratch]
     private Tensor<T>? _autoAdjacencyMatrix;
 
     private Tensor<T> EnsureAdjacencyMatrix(int numNodes)
@@ -970,12 +940,6 @@ private void TrainSingleStep(Tensor<T> input, Tensor<T> expectedOutput)
         foreach (var layer in Layers)
             layer.SetTrainingMode(true);
 
-        // Collect encoder layer parameter tensors via the tape training
-        // helper (walks ITrainableLayer.GetTrainableParameters on every
-        // layer). Variational weights are tracked separately below.
-        var encoderParams = Training.TapeTrainingStep<T>.CollectParameters(
-            Layers.Cast<ILayer<T>>().ToList(), structureVersion: -1);
-
         using var tape = new Tensors.Engines.Autodiff.GradientTape<T>();
 
         // Tape-tracked forward: Encode → Reparameterize → Decode.
@@ -1031,54 +995,22 @@ private void TrainSingleStep(Tensor<T> input, Tensor<T> expectedOutput)
         // Backward: differentiate the ELBO w.r.t. every registered param.
         var allGrads = tape.ComputeGradients(lossTensor, sources: null);
 
-        // Build the flat gradient vector in the SAME order as GetParameters():
-        // encoder-layer params (per-layer GetParameters flat) followed by
-        // _meanWeights then _logVarWeights. For each encoder param tensor
-        // (collected above), look up its gradient; for any tensor the tape
-        // didn't visit (e.g. a bias buffer that's registered but not used
-        // on this forward path), fall back to zero.
-        var gradList = new List<T>();
-        foreach (var p in encoderParams)
-        {
-            if (allGrads.TryGetValue(p, out var g))
-            {
-                for (int i = 0; i < g.Length; i++)
-                    gradList.Add(g.GetFlat(i));
-            }
-            else
-            {
-                for (int i = 0; i < p.Length; i++)
-                    gradList.Add(NumOps.Zero);
-            }
-        }
-        // Variational weight gradients: append to the flat vector AND
-        // persist the tensor-shaped gradients on _meanWeightsGradient /
-        // _logVarWeightsGradient so GetParameterGradients() returns the
-        // real numbers instead of the all-zero defaults. Without this
-        // persist step, callers walking GetParameterGradients() saw
-        // zeros even though the optimizer step had moved the weights.
-        if (allGrads.TryGetValue(_meanWeights, out var mg))
-        {
-            for (int i = 0; i < mg.Length; i++) gradList.Add(mg.GetFlat(i));
-            _meanWeightsGradient = mg;
-        }
-        else
-        {
-            for (int i = 0; i < _meanWeights.Length; i++) gradList.Add(NumOps.Zero);
-            _meanWeightsGradient = new Tensor<T>(_meanWeights._shape);
-        }
-        if (allGrads.TryGetValue(_logVarWeights, out var lvg))
-        {
-            for (int i = 0; i < lvg.Length; i++) gradList.Add(lvg.GetFlat(i));
-            _logVarWeightsGradient = lvg;
-        }
-        else
-        {
-            for (int i = 0; i < _logVarWeights.Length; i++) gradList.Add(NumOps.Zero);
-            _logVarWeightsGradient = new Tensor<T>(_logVarWeights._shape);
-        }
-
-        var parameterGradients = new Vector<T>(gradList.ToArray());
+        // Publish the tape through the base gradient surface rather than walking the
+        // parameters again here. The base scatters each layer's slice by mirroring
+        // FillParameters and then folds the variational extras in the order
+        // GetExtraTrainableTensors declares them, so the gradient vector lines up
+        // scalar-for-scalar with the GetParameters() vector below.
+        //
+        // The walk this replaces enumerated ITrainableLayer.GetTrainableParameters,
+        // which is the OPTIMIZER view: it omits every declared non-trainable component.
+        // The two agreed only for as long as no encoder layer had one. The moment
+        // GraphConvolutionalLayer declared its adjacency matrix, GetParameters() grew by
+        // the graph's size and this vector did not, so the optimizer returned a vector
+        // that no longer described the model and the restore failed on the layer where
+        // the shortfall landed. That is precisely the drift FillParameterGradients exists
+        // to prevent, and why a second ordering must not be written by hand.
+        PublishParameterGradients(allGrads);
+        var parameterGradients = GetParameterGradients();
 
         // Use the configured _optimizer so Adam momentum / scheduler state
         // accumulates across batches. The previous code created a fresh
@@ -1139,65 +1071,12 @@ public override ModelMetadata<T> GetModelMetadata()
     /// <summary>
     /// Serializes network-specific data to a binary writer.
     /// </summary>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(LatentDim);
-        writer.Write(HiddenDim);
-        writer.Write(MaxNodes);
-        writer.Write(NumLayers);
-        writer.Write((int)GenerationType);
-        SerializationHelper<T>.SerializeInterface(writer, _lossFunction);
-        SerializationHelper<T>.SerializeInterface(writer, _optimizer);
-
-        // Serialize variational layer weights
-        writer.Write(_meanWeights.Length);
-        for (int i = 0; i < _meanWeights.Length; i++)
-            writer.Write(Convert.ToDouble(_meanWeights.GetFlat(i)));
-        writer.Write(_logVarWeights.Length);
-        for (int i = 0; i < _logVarWeights.Length; i++)
-            writer.Write(Convert.ToDouble(_logVarWeights.GetFlat(i)));
-    }
+
 
     /// <summary>
     /// Deserializes network-specific data from a binary reader.
     /// </summary>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _ = reader.ReadInt32(); // LatentDim
-        _ = reader.ReadInt32(); // HiddenDim
-        _ = reader.ReadInt32(); // MaxNodes
-        _ = reader.ReadInt32(); // NumLayers
-        _ = (GraphGenerationType)reader.ReadInt32();
-        _ = DeserializationHelper.DeserializeInterface<ILossFunction<T>>(reader);
-        _ = DeserializationHelper.DeserializeInterface<IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>>(reader);
-
-        // Restore variational layer weights
-        int meanCount = reader.ReadInt32();
-        var meanData = new T[meanCount];
-        for (int i = 0; i < meanCount; i++)
-            meanData[i] = NumOps.FromDouble(reader.ReadDouble());
-        _meanWeights = Tensor<T>.FromVector(new Vector<T>(meanData)).Reshape(_meanWeights._shape);
-
-        int logVarCount = reader.ReadInt32();
-        var logVarData = new T[logVarCount];
-        for (int i = 0; i < logVarCount; i++)
-            logVarData[i] = NumOps.FromDouble(reader.ReadDouble());
-        _logVarWeights = Tensor<T>.FromVector(new Vector<T>(logVarData)).Reshape(_logVarWeights._shape);
-    }
 
-    /// <summary>
-    /// Creates a new instance of this model type.
-    /// </summary>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new GraphGenerationModel<T>(
-            inputFeatures: Architecture.InputSize,
-            hiddenDim: HiddenDim,
-            latentDim: LatentDim,
-            numEncoderLayers: NumLayers,
-            maxNodes: MaxNodes,
-            generationType: GenerationType);
-    }
 
     #endregion
 }
diff --git a/src/NeuralNetworks/GraphIsomorphismNetwork.cs b/src/NeuralNetworks/GraphIsomorphismNetwork.cs
index 8e165bb76f..2106ae58bc 100644
--- a/src/NeuralNetworks/GraphIsomorphismNetwork.cs
+++ b/src/NeuralNetworks/GraphIsomorphismNetwork.cs
@@ -1,4 +1,4 @@
-using AiDotNet.Attributes;
+using AiDotNet.Attributes;
 using AiDotNet.Enums;
 using AiDotNet.Helpers;
 using AiDotNet.Interfaces;
@@ -74,7 +74,7 @@ namespace AiDotNet.NeuralNetworks;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("How Powerful are Graph Neural Networks?", "https://arxiv.org/abs/1810.00826", Year = 2019, Authors = "Keyulu Xu, Weihua Hu, Jure Leskovec, Stefanie Jegelka")]
-public class GraphIsomorphismNetwork<T> : GraphModelLayoutBase<T>
+public partial class GraphIsomorphismNetwork<T> : GraphModelLayoutBase<T>
 {
     private readonly GraphIsomorphismNetworkOptions _options;
 
@@ -1042,45 +1042,12 @@ public override ModelMetadata<T> GetModelMetadata()
     /// <summary>
     /// Serializes network-specific data to a binary writer.
     /// </summary>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(MlpHiddenDim);
-        writer.Write(NumLayers);
-        writer.Write(InitialEpsilon);
-        writer.Write(LearnEpsilon);
-        writer.Write(IsLoRAEnabled);
-        writer.Write(LoRARank);
-        SerializationHelper<T>.SerializeInterface(writer, _lossFunction);
-        SerializationHelper<T>.SerializeInterface(writer, _optimizer);
-    }
+
 
     /// <summary>
     /// Deserializes network-specific data from a binary reader.
     /// </summary>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _ = reader.ReadInt32(); // MlpHiddenDim
-        _ = reader.ReadInt32(); // NumLayers
-        _ = reader.ReadDouble(); // InitialEpsilon
-        _ = reader.ReadBoolean(); // LearnEpsilon
-        _ = reader.ReadBoolean(); // IsLoRAEnabled
-        _ = reader.ReadInt32(); // LoRARank
-        _ = DeserializationHelper.DeserializeInterface<ILossFunction<T>>(reader);
-        _ = DeserializationHelper.DeserializeInterface<IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>>(reader);
-    }
 
-    /// <summary>
-    /// Creates a new instance of this network type.
-    /// </summary>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new GraphIsomorphismNetwork<T>(
-            architecture: Architecture,
-            mlpHiddenDim: MlpHiddenDim,
-            numLayers: NumLayers,
-            learnEpsilon: LearnEpsilon,
-            initialEpsilon: InitialEpsilon);
-    }
 
     #endregion
 }
diff --git a/src/NeuralNetworks/GraphNeuralNetwork.cs b/src/NeuralNetworks/GraphNeuralNetwork.cs
index 9ff83cddc6..b15f2d3d0c 100644
--- a/src/NeuralNetworks/GraphNeuralNetwork.cs
+++ b/src/NeuralNetworks/GraphNeuralNetwork.cs
@@ -1,4 +1,4 @@
-#pragma warning disable CS0649, CS0414, CS0169
+#pragma warning disable CS0649, CS0414, CS0169
 using AiDotNet.Attributes;
 using AiDotNet.Enums;
 using AiDotNet.Models.Options;
@@ -51,7 +51,7 @@ namespace AiDotNet.NeuralNetworks;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Semi-Supervised Classification with Graph Convolutional Networks", "https://arxiv.org/abs/1609.02907", Year = 2017, Authors = "Thomas N. Kipf, Max Welling")]
-public class GraphNeuralNetwork<T> : GraphModelLayoutBase<T>, IAuxiliaryLossLayer<T>
+public partial class GraphNeuralNetwork<T> : GraphModelLayoutBase<T>, IAuxiliaryLossLayer<T>
 {
     private readonly GraphNeuralNetworkOptions _options;
     private readonly IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>> _optimizer;
@@ -1135,123 +1135,4 @@ private IEnumerable<string> GetActivationTypes()
 
         return activationTypes.Distinct();
     }
-
-    /// <summary>
-    /// Serializes Graph Neural Network-specific data to a binary writer.
-    /// </summary>
-    /// <param name="writer">The BinaryWriter to write the data to.</param>
-    /// <remarks>
-    /// <para>
-    /// This method writes the Graph Neural Network's specific configuration data to a binary stream.
-    /// This includes activation function types and any other GNN-specific parameters. This data
-    /// is needed to reconstruct the GNN when deserializing.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method saves the special configuration of your GNN.
-    /// 
-    /// Think of it like writing down the recipe for your neural network:
-    /// - What activation functions it uses at different stages
-    /// - How its graph-specific components are configured
-    /// - Any other special settings that make this GNN unique
-    /// 
-    /// These details are crucial because they define how your GNN processes information,
-    /// and they need to be saved along with the weights for the model to work correctly
-    /// when loaded later.
-    /// </para>
-    /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        // Serialize activation functions if they exist
-        SerializationHelper<T>.SerializeInterface(writer, _graphConvolutionalScalarActivation);
-        SerializationHelper<T>.SerializeInterface(writer, _activationLayerScalarActivation);
-        SerializationHelper<T>.SerializeInterface(writer, _finalDenseLayerScalarActivation);
-        SerializationHelper<T>.SerializeInterface(writer, _finalActivationLayerScalarActivation);
-
-        SerializationHelper<T>.SerializeInterface(writer, _graphConvolutionalVectorActivation);
-        SerializationHelper<T>.SerializeInterface(writer, _activationLayerVectorActivation);
-        SerializationHelper<T>.SerializeInterface(writer, _finalDenseLayerVectorActivation);
-        SerializationHelper<T>.SerializeInterface(writer, _finalActivationLayerVectorActivation);
-    }
-
-    /// <summary>
-    /// Deserializes Graph Neural Network-specific data from a binary reader.
-    /// </summary>
-    /// <param name="reader">The BinaryReader to read the data from.</param>
-    /// <remarks>
-    /// <para>
-    /// This method reads the Graph Neural Network's specific configuration data from a binary stream.
-    /// This includes activation function types and any other GNN-specific parameters. After reading this data,
-    /// the GNN's state is fully restored to what it was when saved.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method loads a previously saved GNN configuration.
-    /// 
-    /// Think of it like following a recipe to rebuild your neural network:
-    /// - Reading what activation functions were used at different stages
-    /// - Setting up the graph-specific components with the right configuration
-    /// - Restoring any other special settings that make this GNN unique
-    /// 
-    /// This ensures that your loaded model will process information exactly the same way
-    /// as when you saved it.
-    /// </para>
-    /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        // Deserialize activation functions
-        _graphConvolutionalScalarActivation = DeserializationHelper.DeserializeInterface<IActivationFunction<T>>(reader);
-        _activationLayerScalarActivation = DeserializationHelper.DeserializeInterface<IActivationFunction<T>>(reader);
-        _finalDenseLayerScalarActivation = DeserializationHelper.DeserializeInterface<IActivationFunction<T>>(reader);
-        _finalActivationLayerScalarActivation = DeserializationHelper.DeserializeInterface<IActivationFunction<T>>(reader);
-
-        _graphConvolutionalVectorActivation = DeserializationHelper.DeserializeInterface<IVectorActivationFunction<T>>(reader);
-        _activationLayerVectorActivation = DeserializationHelper.DeserializeInterface<IVectorActivationFunction<T>>(reader);
-        _finalDenseLayerVectorActivation = DeserializationHelper.DeserializeInterface<IVectorActivationFunction<T>>(reader);
-        _finalActivationLayerVectorActivation = DeserializationHelper.DeserializeInterface<IVectorActivationFunction<T>>(reader);
-    }
-
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var options = new GraphNeuralNetworkOptions(_options);
-
-        // Create a new instance with the same architecture and activation functions
-        // Determine which constructor to use based on which activation functions are set
-        bool hasVectorActivations = _graphConvolutionalVectorActivation != null ||
-                                    _activationLayerVectorActivation != null ||
-                                    _finalDenseLayerVectorActivation != null ||
-                                    _finalActivationLayerVectorActivation != null;
-
-        bool hasScalarActivations = _graphConvolutionalScalarActivation != null ||
-                                    _activationLayerScalarActivation != null ||
-                                    _finalDenseLayerScalarActivation != null ||
-                                    _finalActivationLayerScalarActivation != null;
-
-        // Validate that we don't have a mix of vector and scalar activations
-        if (hasVectorActivations && hasScalarActivations)
-        {
-            throw new InvalidOperationException(
-                "Cannot create new instance with mixed vector and scalar activation functions. " +
-                "All activation functions must be either vector-based or scalar-based, not a combination of both.");
-        }
-
-        if (hasVectorActivations)
-        {
-            return new GraphNeuralNetwork<T>(
-                Architecture,
-                lossFunction: LossFunction,
-                graphConvolutionalVectorActivation: _graphConvolutionalVectorActivation,
-                activationLayerVectorActivation: _activationLayerVectorActivation,
-                finalDenseLayerVectorActivation: _finalDenseLayerVectorActivation,
-                finalActivationLayerVectorActivation: _finalActivationLayerVectorActivation,
-                options: options);
-        }
-        else
-        {
-            return new GraphNeuralNetwork<T>(
-                Architecture,
-                lossFunction: LossFunction,
-                graphConvolutionalActivation: _graphConvolutionalScalarActivation,
-                activationLayerActivation: _activationLayerScalarActivation,
-                finalDenseLayerActivation: _finalDenseLayerScalarActivation,
-                finalActivationLayerActivation: _finalActivationLayerScalarActivation,
-                options: options);
-        }
-    }
 }
diff --git a/src/NeuralNetworks/GraphSAGENetwork.cs b/src/NeuralNetworks/GraphSAGENetwork.cs
index 4379fa8242..a6fe7ffc93 100644
--- a/src/NeuralNetworks/GraphSAGENetwork.cs
+++ b/src/NeuralNetworks/GraphSAGENetwork.cs
@@ -1,4 +1,4 @@
-using AiDotNet.Attributes;
+using AiDotNet.Attributes;
 using AiDotNet.Enums;
 using AiDotNet.Helpers;
 using AiDotNet.Interfaces;
@@ -76,7 +76,7 @@ namespace AiDotNet.NeuralNetworks;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Inductive Representation Learning on Large Graphs", "https://arxiv.org/abs/1706.02216", Year = 2017, Authors = "William L. Hamilton, Rex Ying, Jure Leskovec")]
-public class GraphSAGENetwork<T> : GraphModelLayoutBase<T>
+public partial class GraphSAGENetwork<T> : GraphModelLayoutBase<T>
 {
     private readonly GraphSAGEOptions _options;
 
@@ -916,45 +916,12 @@ public override ModelMetadata<T> GetModelMetadata()
     /// <summary>
     /// Serializes network-specific data to a binary writer.
     /// </summary>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(HiddenDim);
-        writer.Write(NumLayers);
-        writer.Write((int)AggregatorType);
-        writer.Write(DropoutRate);
-        writer.Write(IsLoRAEnabled);
-        writer.Write(LoRARank);
-        SerializationHelper<T>.SerializeInterface(writer, _lossFunction);
-        SerializationHelper<T>.SerializeInterface(writer, _optimizer);
-    }
+
 
     /// <summary>
     /// Deserializes network-specific data from a binary reader.
     /// </summary>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _ = reader.ReadInt32(); // HiddenDim
-        _ = reader.ReadInt32(); // NumLayers
-        _ = (SAGEAggregatorType)reader.ReadInt32();
-        _ = reader.ReadDouble(); // DropoutRate
-        _ = reader.ReadBoolean(); // IsLoRAEnabled
-        _ = reader.ReadInt32(); // LoRARank
-        _ = DeserializationHelper.DeserializeInterface<ILossFunction<T>>(reader);
-        _ = DeserializationHelper.DeserializeInterface<IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>>(reader);
-    }
 
-    /// <summary>
-    /// Creates a new instance of this network type.
-    /// </summary>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new GraphSAGENetwork<T>(
-            architecture: Architecture,
-            aggregatorType: AggregatorType,
-            numLayers: NumLayers,
-            normalize: Normalize,
-            dropoutRate: DropoutRate);
-    }
 
     #endregion
 }
diff --git a/src/NeuralNetworks/GriffinLanguageModel.cs b/src/NeuralNetworks/GriffinLanguageModel.cs
index f2d7175137..543fd5d47a 100644
--- a/src/NeuralNetworks/GriffinLanguageModel.cs
+++ b/src/NeuralNetworks/GriffinLanguageModel.cs
@@ -36,7 +36,7 @@ namespace AiDotNet.NeuralNetworks;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Griffin: Mixing Gated Linear Recurrences with Local Attention for Efficient Language Models", "https://arxiv.org/abs/2402.19427", Year = 2024, Authors = "Soham De, Samuel L. Smith, Anushan Fernando, Aleksandar Botev, George Cristian-Muraru, Albert Gu, Ruba Haroun, Leonard Berrada, Yutian Chen, Srivatsan Srinivasan, Guillaume Desjardins, Arnaud Doucet, David Budden, Yee Whye Teh, Razvan Pascanu, Nando De Freitas, Caglar Gulcehre")]
-public class GriffinLanguageModel<T> : TokenLanguageModelLayoutBase<T>
+public partial class GriffinLanguageModel<T> : TokenLanguageModelLayoutBase<T>
 {
     private readonly GriffinOptions _options;
     private readonly int _vocabSize;
@@ -177,46 +177,9 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_vocabSize);
-        writer.Write(_modelDimension);
-        writer.Write(_numLayers);
-        writer.Write(_maxSeqLength);
-        // RecurrenceDimension is configurable and sizes the whole RG-LRU stack, but it was not
-        // in the payload -- so a checkpoint saved with a non-default width reloaded at the
-        // default and mismatched its own weights.
-        writer.Write(_recurrenceDimension);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _ = reader.ReadInt32();
-        _ = reader.ReadInt32();
-        _ = reader.ReadInt32();
-        _ = reader.ReadInt32();
-
-        // VALIDATED, NOT APPLIED. The layer stack was already built from the options this
-        // instance was constructed with, so a differing saved width cannot be adopted here --
-        // the weights about to be loaded would not fit. Reporting the mismatch names the cause;
-        // staying silent would load a checkpoint into a wrong-width model, which fails later as
-        // an opaque parameter-count error or, worse, does not fail at all.
-        int savedRecurrenceDimension = reader.ReadInt32();
-        if (savedRecurrenceDimension != _recurrenceDimension)
-        {
-            throw new InvalidOperationException(
-                $"Checkpoint was saved with RecurrenceDimension {savedRecurrenceDimension} but this "
-                + $"instance was built with {_recurrenceDimension}. Set RecurrenceDimension on the "
-                + "options before loading this checkpoint.");
-        }
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new GriffinLanguageModel<T>(
-            Architecture, _vocabSize, _modelDimension, _numLayers, _maxSeqLength,
-            LossFunction, new GriffinOptions(_options), optimizer: null);
-    }
+
 
     #endregion
 }
diff --git a/src/NeuralNetworks/HTMNetwork.cs b/src/NeuralNetworks/HTMNetwork.cs
index f9326ffafa..f75a67849b 100644
--- a/src/NeuralNetworks/HTMNetwork.cs
+++ b/src/NeuralNetworks/HTMNetwork.cs
@@ -1,4 +1,4 @@
-using AiDotNet.Attributes;
+using AiDotNet.Attributes;
 using AiDotNet.Enums;
 using AiDotNet.NeuralNetworks.Options;
 
@@ -50,7 +50,7 @@ namespace AiDotNet.NeuralNetworks;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
     [ResearchPaper("Why Neurons Have Thousands of Synapses, a Theory of Sequence Memory in Neocortex", "https://doi.org/10.3389/fncir.2016.00023")]
-public class HTMNetwork<T> : VectorModelLayoutBase<T>
+public partial class HTMNetwork<T> : VectorModelLayoutBase<T>
 {
     private readonly HTMNetworkOptions _options;
 
@@ -672,123 +672,11 @@ public override ModelMetadata<T> GetModelMetadata()
     /// Serializes HTM-specific data to a binary writer.
     /// </summary>
     /// <param name="writer">The binary writer to write to.</param>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        // Write HTM-specific parameters
-        writer.Write(_columnCount);
-        writer.Write(_cellsPerColumn);
-        writer.Write(NumOps.ToDouble(_sparsityThreshold));
-
-        // Serialize any additional HTM state
 
-        // Look for the temporal memory layer
-        for (int i = 0; i < Layers.Count; i++)
-        {
-            if (Layers[i] is TemporalMemoryLayer<T> temporalMemoryLayer)
-            {
-                // Mark that we found a temporal memory layer
-                writer.Write(true);
-
-                // Serialize the temporal memory's state
-                if (temporalMemoryLayer.PreviousState != null)
-                {
-                    writer.Write(true); // Has previous state
-                    writer.Write(temporalMemoryLayer.PreviousState.Length);
-
-                    // Write each element of the previous state
-                    for (int j = 0; j < temporalMemoryLayer.PreviousState.Length; j++)
-                    {
-                        writer.Write(Convert.ToDouble(temporalMemoryLayer.PreviousState[j]));
-                    }
-                }
-                else
-                {
-                    writer.Write(false); // No previous state
-                }
-
-                break; // Stop after finding the first temporal memory layer
-            }
-        }
-
-        // If no temporal memory layer was found
-        writer.Write(false);
-    }
 
     /// <summary>
     /// Deserializes HTM-specific data from a binary reader.
     /// </summary>
     /// <param name="reader">The binary reader to read from.</param>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        // Read HTM-specific parameters
-        _columnCount = reader.ReadInt32();
-        _cellsPerColumn = reader.ReadInt32();
-        _sparsityThreshold = NumOps.FromDouble(reader.ReadDouble());
-
-        // Deserialize additional HTM state
-
-        // Check if there was a temporal memory layer
-        bool hasTemporalMemoryLayer = reader.ReadBoolean();
-        if (hasTemporalMemoryLayer)
-        {
-            // Look for the temporal memory layer in the current network
-            for (int i = 0; i < Layers.Count; i++)
-            {
-                if (Layers[i] is TemporalMemoryLayer<T> temporalMemoryLayer)
-                {
-                    // Check if there was a previous state
-                    bool hasPreviousState = reader.ReadBoolean();
-                    if (hasPreviousState)
-                    {
-                        int stateLength = reader.ReadInt32();
-                        var previousState = new Vector<T>(stateLength);
-
-                        // Read each element of the previous state
-                        for (int j = 0; j < stateLength; j++)
-                        {
-                            previousState[j] = NumOps.FromDouble(reader.ReadDouble());
-                        }
 
-                        // Set the previous state
-                        temporalMemoryLayer.PreviousState = previousState;
-                    }
-
-                    break; // Stop after restoring the first temporal memory layer
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// Creates a new instance of the HTM Network with the same architecture and configuration.
-    /// </summary>
-    /// <returns>A new HTM Network instance with the same architecture and configuration.</returns>
-    /// <remarks>
-    /// <para>
-    /// This method creates a new instance of the HTM Network with the same architecture and HTM-specific
-    /// parameters as the current instance. It's used in scenarios where a fresh copy of the model is needed
-    /// while maintaining the same configuration.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method creates a brand new copy of the HTM network with the same setup.
-    /// 
-    /// Think of it like creating a clone of the network:
-    /// - The new network has the same architecture (structure)
-    /// - It has the same number of columns, cells per column, and sparsity threshold
-    /// - But it's a completely separate instance with its own state
-    /// - It starts with clean internal memory and connections
-    /// 
-    /// This is useful when you want to:
-    /// - Train the same network design on different datasets
-    /// - Compare how the same network structure learns from different sequences
-    /// - Start with a fresh network that has the same configuration but no learned patterns
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new HTMNetwork<T>(
-            this.Architecture,
-            _columnCount,
-            _cellsPerColumn,
-            NumOps.ToDouble(_sparsityThreshold));
-    }
 }
diff --git a/src/NeuralNetworks/HawkLanguageModel.cs b/src/NeuralNetworks/HawkLanguageModel.cs
index 53a726e67d..7caacc2a98 100644
--- a/src/NeuralNetworks/HawkLanguageModel.cs
+++ b/src/NeuralNetworks/HawkLanguageModel.cs
@@ -52,7 +52,7 @@ namespace AiDotNet.NeuralNetworks;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Griffin: Mixing Gated Linear Recurrences with Local Attention for Efficient Language Models", "https://arxiv.org/abs/2402.19427", Year = 2024, Authors = "Soham De, Samuel L. Smith, Anushan Fernando, Aleksandar Botev, George Cristian-Muraru, Albert Gu, Ruba Haroun, Leonard Berrada, Yutian Chen, Srivatsan Srinivasan, Guillaume Desjardins, Arnaud Doucet, David Budden, Yee Whye Teh, Razvan Pascanu, Nando De Freitas, Caglar Gulcehre")]
-public class HawkLanguageModel<T> : TokenLanguageModelLayoutBase<T>
+public partial class HawkLanguageModel<T> : TokenLanguageModelLayoutBase<T>
 {
     private readonly HawkOptions _options;
     private readonly int _vocabSize;
@@ -196,46 +196,9 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_vocabSize);
-        writer.Write(_modelDimension);
-        writer.Write(_numLayers);
-        writer.Write(_maxSeqLength);
-        // RecurrenceDimension is configurable and sizes the whole RG-LRU stack, but it was not
-        // in the payload -- so a checkpoint saved with a non-default width reloaded at the
-        // default and mismatched its own weights.
-        writer.Write(_recurrenceDimension);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _ = reader.ReadInt32();
-        _ = reader.ReadInt32();
-        _ = reader.ReadInt32();
-        _ = reader.ReadInt32();
-
-        // VALIDATED, NOT APPLIED. The layer stack was already built from the options this
-        // instance was constructed with, so a differing saved width cannot be adopted here --
-        // the weights about to be loaded would not fit. Reporting the mismatch names the cause;
-        // staying silent would load a checkpoint into a wrong-width model, which fails later as
-        // an opaque parameter-count error or, worse, does not fail at all.
-        int savedRecurrenceDimension = reader.ReadInt32();
-        if (savedRecurrenceDimension != _recurrenceDimension)
-        {
-            throw new InvalidOperationException(
-                $"Checkpoint was saved with RecurrenceDimension {savedRecurrenceDimension} but this "
-                + $"instance was built with {_recurrenceDimension}. Set RecurrenceDimension on the "
-                + "options before loading this checkpoint.");
-        }
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new HawkLanguageModel<T>(
-            Architecture, _vocabSize, _modelDimension, _numLayers, _maxSeqLength,
-            LossFunction, new HawkOptions(_options), optimizer: null);
-    }
+
 
     #endregion
 }
diff --git a/src/NeuralNetworks/HopeNetwork.cs b/src/NeuralNetworks/HopeNetwork.cs
index 982ecb1c2a..06adfa5bd6 100644
--- a/src/NeuralNetworks/HopeNetwork.cs
+++ b/src/NeuralNetworks/HopeNetwork.cs
@@ -623,159 +623,4 @@ public override void ResetState()
         ResetMemory();
         ResetRecurrentState();
     }
-
-    /// <summary>
-    /// Serializes Hope-specific data for model persistence.
-    /// </summary>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        if (writer == null)
-            throw new ArgumentNullException(nameof(writer));
-
-        // Write Hope-specific architecture parameters
-        writer.Write(_hiddenDim);
-        writer.Write(_numCMSLevels);
-        writer.Write(_numRecurrentLayers);
-        writer.Write(_inContextLearningLevels);
-        writer.Write(_adaptationStep);
-        writer.Write(Convert.ToDouble(_selfModificationRate));
-
-        // Write meta-state
-        if (_metaState != null)
-        {
-            writer.Write(true); // Has meta-state
-            writer.Write(_metaState.Length);
-            for (int i = 0; i < _metaState.Length; i++)
-            {
-                writer.Write(Convert.ToDouble(_metaState[i]));
-            }
-        }
-        else
-        {
-            writer.Write(false); // No meta-state
-        }
-
-        // Context flow and associative memory will be reinitialized on load
-        // Their state is ephemeral and doesn't need persistence
-    }
-
-    /// <summary>
-    /// Deserializes Hope-specific data for model restoration.
-    /// </summary>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        if (reader == null)
-            throw new ArgumentNullException(nameof(reader));
-
-        // Read Hope-specific architecture parameters
-        // Note: These were already set in constructor, but we verify they match
-        int loadedHiddenDim = reader.ReadInt32();
-        int loadedNumCMSLevels = reader.ReadInt32();
-        int loadedNumRecurrentLayers = reader.ReadInt32();
-        int loadedInContextLearningLevels = reader.ReadInt32();
-        _adaptationStep = reader.ReadInt32();
-        _selfModificationRate = _numOps.FromDouble(reader.ReadDouble());
-
-        // Read meta-state
-        bool hasMetaState = reader.ReadBoolean();
-        if (hasMetaState)
-        {
-            int metaStateLength = reader.ReadInt32();
-            _metaState = new Vector<T>(metaStateLength);
-            for (int i = 0; i < metaStateLength; i++)
-            {
-                _metaState[i] = _numOps.FromDouble(reader.ReadDouble());
-            }
-        }
-        else
-        {
-            _metaState = new Vector<T>(_hiddenDim);
-        }
-
-        // Verify architecture matches
-        if (loadedHiddenDim != _hiddenDim ||
-            loadedNumCMSLevels != _numCMSLevels ||
-            loadedNumRecurrentLayers != _numRecurrentLayers ||
-            loadedInContextLearningLevels != _inContextLearningLevels)
-        {
-            throw new InvalidOperationException(
-                $"Model architecture mismatch. Expected ({_hiddenDim}, {_numCMSLevels}, " +
-                $"{_numRecurrentLayers}, {_inContextLearningLevels}) but loaded " +
-                $"({loadedHiddenDim}, {loadedNumCMSLevels}, {loadedNumRecurrentLayers}, {loadedInContextLearningLevels})");
-        }
-    }
-
-    /// <summary>
-    /// Creates a new instance of HopeNetwork with the same architecture.
-    /// </summary>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        // Create new Hope network with same architecture
-        var newHope = new HopeNetwork<T>(
-            architecture: Architecture,
-            optimizer: null, // Will be set separately if needed
-            lossFunction: LossFunction,
-            hiddenDim: _hiddenDim,
-            numCMSLevels: _numCMSLevels,
-            numRecurrentLayers: _numRecurrentLayers,
-            inContextLearningLevels: _inContextLearningLevels);
-
-        return newHope;
-    }
-
-    /// <summary>
-    /// Cloning HopeNetwork via the default DeepCopy path (serialize/deserialize)
-    /// produces a network whose Predict output drifts from the original by
-    /// roughly 1e-7 even though every parameter and meta-state value matches
-    /// bit-exactly. The drift comes from the deserialized layers being created
-    /// through DeserializationHelper.CreateLayerFromType rather than through
-    /// LayerHelper.CreateHopeNetworkLayers, which leaves the persistent-tensor
-    /// registration and layer-internal sub-tensor allocation in a slightly
-    /// different memory layout than the source network — and Hope's chained
-    /// CMS / context-flow / recurrent forward path is sensitive enough to this
-    /// layout that the SIMD reduction order ends up different. The
-    /// Clone_ShouldProduceIdenticalOutput invariant requires bit-exact
-    /// reproducibility, so we override Clone to take the deterministic
-    /// fresh-construct + UpdateParameters path (proven bit-identical to the
-    /// source network in the probe test) instead of the default serialize-roundtrip.
-    /// </summary>
-    public override IFullModel<T, Tensor<T>, Tensor<T>> Clone()
-    {
-        // Deep-copy options so the clone and source don't share mutable
-        // configuration state. MemberwiseClone is sufficient for the
-        // current HopeNetworkOptions (no reference-typed fields), but
-        // any future option fields of reference type would need
-        // explicit deep copies in a HopeNetworkOptions.Clone override
-        // following the same pattern.
-        var optionsCopy = (HopeNetworkOptions)_options.MemberwiseCloneOptions();
-
-        var newHope = new HopeNetwork<T>(
-            architecture: Architecture,
-            optimizer: null,
-            lossFunction: LossFunction,
-            hiddenDim: _hiddenDim,
-            numCMSLevels: _numCMSLevels,
-            numRecurrentLayers: _numRecurrentLayers,
-            inContextLearningLevels: _inContextLearningLevels,
-            options: optionsCopy);
-
-        // Copy trainable parameters across all layers.
-        var allParams = GetParameters();
-        if (allParams.Length > 0 && allParams.Length == newHope.ParameterCount)
-        {
-            newHope.UpdateParameters(allParams);
-        }
-
-        // Copy Hope-specific runtime state.
-        if (_metaState != null)
-        {
-            newHope._metaState = new Vector<T>(_metaState.Length);
-            for (int i = 0; i < _metaState.Length; i++)
-                newHope._metaState[i] = _metaState[i];
-        }
-        newHope._adaptationStep = _adaptationStep;
-        newHope._selfModificationRate = _selfModificationRate;
-
-        return newHope;
-    }
 }
diff --git a/src/NeuralNetworks/HopfieldNetwork.cs b/src/NeuralNetworks/HopfieldNetwork.cs
index 0e850251f6..ba6b9255df 100644
--- a/src/NeuralNetworks/HopfieldNetwork.cs
+++ b/src/NeuralNetworks/HopfieldNetwork.cs
@@ -78,6 +78,7 @@ public partial class HopfieldNetwork<T> : VectorModelLayoutBase<T>
     /// These connection strengths are what allow the network to store and recall patterns.
     /// </para>
     /// </remarks>
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _weights;
 
     /// <summary>
@@ -400,31 +401,6 @@ public override Dictionary<string, Tensor<T>> GetNamedLayerActivations(Tensor<T>
         };
     }
 
-    /// <summary>
-    /// Declares the single recurrent weight matrix, which the base cannot otherwise find.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// The base walks <c>Layers</c>, and a Hopfield network has none -- it is one symmetric weight
-    /// matrix, not a stack. Declaring it here is the whole parameter surface: count, vector,
-    /// restore and chunks all fold this one enumeration, so they cannot describe different tensors.
-    /// </para>
-    /// <para>
-    /// This replaces four hand-written members -- <c>ParameterCount</c> as the formula
-    /// <c>_size * _size</c>, a <c>GetParameters</c> flattening the matrix, a <c>SetParameters</c>
-    /// filling it back element by element, and a <c>GetParameterChunks</c> that yielded
-    /// <c>Tensor&lt;T&gt;.FromMatrix(_weights)</c>. That last one is why <c>_weights</c> is now a
-    /// <c>Tensor&lt;T&gt;</c> rather than a <c>Matrix&lt;T&gt;</c>: <c>FromMatrix</c> COPIES, so a
-    /// restore driven through the declared tensor would have written into a temporary and been
-    /// discarded, leaving the model on its old weights while reporting the new ones. Yielding the
-    /// field itself is what makes the automatic restore actually land.
-    /// </para>
-    /// </remarks>
-    protected override IEnumerable<Tensor<T>> GetExtraTrainableTensors()
-    {
-        yield return _weights;
-    }
-
     protected override Tensor<T> PredictCore(Tensor<T> input)
     {
         // GPU-resident optimization: use TryForwardGpuOptimized for speedup
@@ -608,23 +584,7 @@ public override ModelMetadata<T> GetModelMetadata()
     /// without having to train it again from scratch.
     /// </para>
     /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        // Write network size
-        writer.Write(_size);
 
-        // Write weight matrix
-        writer.Write(_weights.Shape[0]);
-        writer.Write(_weights.Shape[1]);
-
-        for (int i = 0; i < _weights.Shape[0]; i++)
-        {
-            for (int j = 0; j < _weights.Shape[1]; j++)
-            {
-                writer.Write(Convert.ToDouble(_weights[i, j]));
-            }
-        }
-    }
 
     /// <summary>
     /// Deserializes Hopfield network-specific data from a binary reader.
@@ -646,27 +606,7 @@ protected override void SerializeNetworkSpecificData(BinaryWriter writer)
     /// having to train it again on the same patterns.
     /// </para>
     /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        // Read network size
-        _size = reader.ReadInt32();
-
-        // Read weight matrix dimensions
-        int rows = reader.ReadInt32();
-        int columns = reader.ReadInt32();
 
-        // Initialize weight matrix
-        _weights = new Tensor<T>([rows, columns]);
-
-        // Read weight values
-        for (int i = 0; i < rows; i++)
-        {
-            for (int j = 0; j < columns; j++)
-            {
-                _weights[i, j] = NumOps.FromDouble(reader.ReadDouble());
-            }
-        }
-    }
 
     /// <summary>
     /// Calculates the energy of the current state of the Hopfield network.
@@ -756,33 +696,4 @@ public int GetNetworkCapacity()
         double capacity = _size / (4.0 * Math.Log(_size));
         return (int)Math.Floor(capacity);
     }
-
-    /// <summary>
-    /// Creates a new instance of the Hopfield Network with the same architecture and configuration.
-    /// </summary>
-    /// <returns>A new Hopfield Network instance with the same architecture and size.</returns>
-    /// <remarks>
-    /// <para>
-    /// This method creates a new instance of the Hopfield Network with the same architecture and size
-    /// as the current instance. It's used in scenarios where a fresh copy of the model is needed
-    /// while maintaining the same configuration.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method creates a brand new copy of the network with the same setup.
-    /// 
-    /// Think of it like creating a blank version of the network:
-    /// - The new network has the same size (number of neurons)
-    /// - It has the same architecture (configuration)
-    /// - But it starts with no stored patterns - it's a fresh network
-    /// - The weight matrix is initialized to zeros
-    /// 
-    /// This is useful when you want to:
-    /// - Start with a clean network with the same structure
-    /// - Train it on different patterns
-    /// - Compare results between different training approaches
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new HopfieldNetwork<T>(this.Architecture, _size);
-    }
 }
diff --git a/src/NeuralNetworks/HyperbolicNeuralNetwork.cs b/src/NeuralNetworks/HyperbolicNeuralNetwork.cs
index 678ffbb236..cf71d0bd1a 100644
--- a/src/NeuralNetworks/HyperbolicNeuralNetwork.cs
+++ b/src/NeuralNetworks/HyperbolicNeuralNetwork.cs
@@ -50,7 +50,7 @@ namespace AiDotNet.NeuralNetworks;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Hyperbolic Neural Networks", "https://arxiv.org/abs/1805.09112", Year = 2018, Authors = "Octavian-Eugen Ganea, Gary Becigneul, Thomas Hofmann")]
-public class HyperbolicNeuralNetwork<T> : VectorModelLayoutBase<T>
+public partial class HyperbolicNeuralNetwork<T> : VectorModelLayoutBase<T>
 {
     private readonly HyperbolicNeuralNetworkOptions _options;
 
@@ -267,54 +267,13 @@ public override ModelMetadata<T> GetModelMetadata()
     /// <summary>
     /// Serializes hyperbolic neural network-specific data to a binary writer.
     /// </summary>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(NumOps.ToDouble(_curvature));
-        writer.Write(_optimizer.GetType().FullName ?? "AdamOptimizer");
-        writer.Write(LossFunction.GetType().FullName ?? "MeanSquaredErrorLoss");
-    }
+
 
     /// <summary>
     /// Deserializes hyperbolic neural network-specific data from a binary reader.
     /// </summary>
     /// <exception cref="InvalidOperationException">Thrown when deserialized curvature is not negative.</exception>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        double deserializedCurvature = reader.ReadDouble();
-
-        // Validate the deserialized curvature - must be negative for hyperbolic space
-        if (deserializedCurvature >= 0)
-        {
-            throw new InvalidOperationException(
-                $"Invalid curvature value {deserializedCurvature} in serialized data. " +
-                "Curvature must be negative for hyperbolic space. The serialized data may be corrupted.");
-        }
-
-        _curvature = NumOps.FromDouble(deserializedCurvature);
 
-        // Read type names for forward compatibility and validation
-        string optimizerType = reader.ReadString();
-        string lossFunctionType = reader.ReadString();
-
-        // Note: Optimizer and loss function instances should be provided during construction.
-        // The type names are read for data integrity verification but new instances
-        // need to be created via the constructor or a dedicated factory method.
-        _ = optimizerType;
-        _ = lossFunctionType;
-    }
-
-    /// <summary>
-    /// Creates a new instance of the HyperbolicNeuralNetwork with the same configuration.
-    /// </summary>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new HyperbolicNeuralNetwork<T>(
-            Architecture,
-            NumOps.ToDouble(_curvature),
-            _optimizer,
-            LossFunction,
-            Convert.ToDouble(MaxGradNorm));
-    }
 
     /// <summary>
     /// Indicates whether this network supports training.
diff --git a/src/NeuralNetworks/ImageBindNeuralNetwork.cs b/src/NeuralNetworks/ImageBindNeuralNetwork.cs
index dc99738673..2b7c07916e 100644
--- a/src/NeuralNetworks/ImageBindNeuralNetwork.cs
+++ b/src/NeuralNetworks/ImageBindNeuralNetwork.cs
@@ -86,45 +86,55 @@ public partial class ImageBindNeuralNetwork<T> : MultimodalModelLayoutBase<T>, I
 
     // Image encoder layers
     private readonly List<ILayer<T>> _imageEncoderLayers = [];
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T>? _imageClsToken;
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T>? _imagePositionalEmbeddings;
     private ILayer<T>? _imagePatchEmbedding;
     private ILayer<T>? _imageProjection;
 
     // Text encoder layers
     private readonly List<ILayer<T>> _textEncoderLayers = [];
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T>? _textPositionalEmbeddings;
     private ILayer<T>? _textTokenEmbedding;
     private ILayer<T>? _textProjection;
 
     // Audio encoder layers (uses spectrogram input)
     private readonly List<ILayer<T>> _audioEncoderLayers = [];
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T>? _audioPositionalEmbeddings;
     private ILayer<T>? _audioConv;
     private ILayer<T>? _audioProjection;
 
     // Thermal encoder (similar to image encoder)
     private readonly List<ILayer<T>> _thermalEncoderLayers = [];
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T>? _thermalClsToken;
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T>? _thermalPositionalEmbeddings;
     private ILayer<T>? _thermalPatchEmbedding;
     private ILayer<T>? _thermalProjection;
 
     // Depth encoder
     private readonly List<ILayer<T>> _depthEncoderLayers = [];
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T>? _depthClsToken;
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T>? _depthPositionalEmbeddings;
     private ILayer<T>? _depthPatchEmbedding;
     private ILayer<T>? _depthProjection;
 
     // IMU encoder
     private readonly List<ILayer<T>> _imuEncoderLayers = [];
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T>? _imuPositionalEmbeddings;
     private ILayer<T>? _imuEmbedding;
     private ILayer<T>? _imuProjection;
 
     // Video encoder (temporal aggregation over frames)
     private readonly List<ILayer<T>> _videoTemporalLayers = [];
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T>? _videoTemporalPositionalEmbeddings;
     private ILayer<T>? _videoProjection;
 
@@ -1479,62 +1489,6 @@ private Vector<T> AttentionFusion(List<Vector<T>> embeddings)
 
     #region NeuralNetworkBase Implementation
 
-    /// <summary>
-    /// Declares the CLS tokens and positional embedding tables for all six modalities, which live
-    /// outside <see cref="NeuralNetworkBase{T}.Layers"/>.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// Declared in the order the deleted GetParameters concatenated them, so existing checkpoints
-    /// still restore: image CLS, image positional, text, audio, thermal CLS, thermal positional,
-    /// depth CLS, depth positional, IMU, video-temporal.
-    /// </para>
-    /// <para>
-    /// This replaces 350 lines -- ParameterCount, GetParameters, SetParameters, UpdateParameters
-    /// and six private helpers (AppendLayerListParameters, AppendSingleLayerParameters,
-    /// AppendMatrixParameters and their Update counterparts) -- each walking the same seven encoder
-    /// towers, thirteen projections and ten tables with its own running offset. Ten modalities'
-    /// worth of layout repeated four times, where a single missed line in any one of them silently
-    /// misaligns a checkpoint.
-    /// </para>
-    /// <para>
-    /// The towers need no declaration and must not get one: every per-modality list is filled FROM
-    /// <c>Layers</c> (<c>Layers[idx++]</c>), so they are typed views of layers the base walk already
-    /// reaches and declaring them would double-count. The tables became <c>Tensor&lt;T&gt;</c>
-    /// because a <c>Matrix&lt;T&gt;</c> is invisible to the trainable-parameter walk, which is the
-    /// reason these surfaces had to exist at all.
-    /// </para>
-    /// </remarks>
-    protected override IEnumerable<Tensor<T>> GetExtraTrainableTensors()
-    {
-        if (!_useNativeMode)
-        {
-            yield break;
-        }
-
-        Tensor<T>?[] tables =
-        [
-            _imageClsToken,
-            _imagePositionalEmbeddings,
-            _textPositionalEmbeddings,
-            _audioPositionalEmbeddings,
-            _thermalClsToken,
-            _thermalPositionalEmbeddings,
-            _depthClsToken,
-            _depthPositionalEmbeddings,
-            _imuPositionalEmbeddings,
-            _videoTemporalPositionalEmbeddings,
-        ];
-
-        foreach (var table in tables)
-        {
-            if (table is not null)
-            {
-                yield return table;
-            }
-        }
-    }
-
     // ---- behavioural overrides, restored ----
     // These four were deleted as collateral when this file's parameter surfaces were removed:
     // the deletion took a LINE RANGE that happened to contain them, rather than the members it
@@ -1621,67 +1575,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_embeddingDimension);
-        writer.Write(_maxSequenceLength);
-        writer.Write(_imageSize);
-        writer.Write(_hiddenDim);
-        writer.Write(_numEncoderLayers);
-        writer.Write(_numHeads);
-        writer.Write(_patchSize);
-        writer.Write(_vocabularySize);
-        writer.Write(_audioSampleRate);
-        writer.Write(_audioMaxDuration);
-        writer.Write(_imuTimesteps);
-        writer.Write(_numVideoFrames);
-        writer.Write(_useNativeMode);
-    }
 
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _ = reader.ReadInt32(); // embeddingDim
-        _ = reader.ReadInt32(); // maxSeqLen
-        _ = reader.ReadInt32(); // imageSize
-        _ = reader.ReadInt32(); // hiddenDim
-        _ = reader.ReadInt32(); // numEncoderLayers
-        _ = reader.ReadInt32(); // numHeads
-        _ = reader.ReadInt32(); // patchSize
-        _ = reader.ReadInt32(); // vocabularySize
-        _ = reader.ReadInt32(); // audioSampleRate
-        _ = reader.ReadInt32(); // audioMaxDuration
-        _ = reader.ReadInt32(); // imuTimesteps
-        _ = reader.ReadInt32(); // numVideoFrames
-        _ = reader.ReadBoolean(); // useNativeMode
-
-        // NeuralNetworkBase replaces Layers during deserialization. Rebind the modality
-        // views so inference/training and parameter enumeration use that restored graph.
-        if (_useNativeMode)
-        {
-            BindNativeLayers();
-        }
-    }
 
     /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new ImageBindNeuralNetwork<T>(
-            Architecture,
-            _imageSize,
-            channels: 3,
-            _patchSize,
-            _vocabularySize,
-            _maxSequenceLength,
-            _embeddingDimension,
-            _hiddenDim,
-            _numEncoderLayers,
-            _numHeads,
-            _audioSampleRate,
-            _audioMaxDuration,
-            _imuTimesteps,
-            _numVideoFrames);
-    }
+
 
     /// <inheritdoc/>
     protected override void Dispose(bool disposing)
diff --git a/src/NeuralNetworks/InfoGAN.cs b/src/NeuralNetworks/InfoGAN.cs
index 1251ae5ccd..a551c57b37 100644
--- a/src/NeuralNetworks/InfoGAN.cs
+++ b/src/NeuralNetworks/InfoGAN.cs
@@ -965,25 +965,7 @@ public override ModelMetadata<T> GetModelMetadata()
     /// three networks (generator, discriminator, and Q network) to a file.
     /// </para>
     /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        // Serialize InfoGAN-specific hyperparameters
-        writer.Write(_latentCodeSize);
-        writer.Write(NumOps.ToDouble(_mutualInfoCoefficient));
-
-        // Serialize all three networks
-        var generatorBytes = Generator.Serialize();
-        writer.Write(generatorBytes.Length);
-        writer.Write(generatorBytes);
-
-        var discriminatorBytes = Discriminator.Serialize();
-        writer.Write(discriminatorBytes.Length);
-        writer.Write(discriminatorBytes);
-
-        var qNetworkBytes = QNetwork.Serialize();
-        writer.Write(qNetworkBytes.Length);
-        writer.Write(qNetworkBytes);
-    }
+
 
     /// <summary>
     /// Deserializes InfoGAN-specific data from a binary reader.
@@ -998,76 +980,7 @@ protected override void SerializeNetworkSpecificData(BinaryWriter writer)
     /// three networks (generator, discriminator, and Q network) from a file.
     /// </para>
     /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        const int MaxNetworkDataLength = 100 * 1024 * 1024; // 100 MB max per network
 
-        // Deserialize InfoGAN-specific hyperparameters
-        _latentCodeSize = reader.ReadInt32();
-        _mutualInfoCoefficient = NumOps.FromDouble(reader.ReadDouble());
-
-        // Deserialize all three networks with bounds checking
-        int generatorDataLength = reader.ReadInt32();
-        if (generatorDataLength < 0 || generatorDataLength > MaxNetworkDataLength)
-        {
-            throw new InvalidDataException(
-                $"Invalid generator data length: {generatorDataLength}. " +
-                $"Must be between 0 and {MaxNetworkDataLength}.");
-        }
-        byte[] generatorData = reader.ReadBytes(generatorDataLength);
-        Generator.Deserialize(generatorData);
-
-        int discriminatorDataLength = reader.ReadInt32();
-        if (discriminatorDataLength < 0 || discriminatorDataLength > MaxNetworkDataLength)
-        {
-            throw new InvalidDataException(
-                $"Invalid discriminator data length: {discriminatorDataLength}. " +
-                $"Must be between 0 and {MaxNetworkDataLength}.");
-        }
-        byte[] discriminatorData = reader.ReadBytes(discriminatorDataLength);
-        Discriminator.Deserialize(discriminatorData);
-
-        int qNetworkDataLength = reader.ReadInt32();
-        if (qNetworkDataLength < 0 || qNetworkDataLength > MaxNetworkDataLength)
-        {
-            throw new InvalidDataException(
-                $"Invalid Q network data length: {qNetworkDataLength}. " +
-                $"Must be between 0 and {MaxNetworkDataLength}.");
-        }
-        byte[] qNetworkData = reader.ReadBytes(qNetworkDataLength);
-        QNetwork.Deserialize(qNetworkData);
-
-        // Reset optimizer state after loading network weights
-        ResetOptimizerState();
-    }
-
-    /// <summary>
-    /// Creates a new instance of the InfoGAN with the same configuration.
-    /// </summary>
-    /// <returns>A new InfoGAN instance with the same architecture and hyperparameters.</returns>
-    /// <remarks>
-    /// <para>
-    /// This method creates a fresh InfoGAN instance with the same network architectures
-    /// and hyperparameters. The new instance has freshly initialized optimizers.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method creates a copy of the InfoGAN structure
-    /// but with new, untrained networks and fresh optimizers.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new InfoGAN<T>(
-            Generator.Architecture,
-            Discriminator.Architecture,
-            QNetwork.Architecture,
-            _latentCodeSize,
-            Architecture.InputType,
-            generatorOptimizer: null,
-            discriminatorOptimizer: null,
-            qNetworkOptimizer: null,
-            _lossFunction,
-            NumOps.ToDouble(_mutualInfoCoefficient));
-    }
 
     // UpdateParameters split the vector between Generator, Discriminator and QNetwork;
     // GetExtraTrainableLayers yields those three in the same order, so the base reproduces the
diff --git a/src/NeuralNetworks/InstructorEmbedding.cs b/src/NeuralNetworks/InstructorEmbedding.cs
index 180153d086..afcd813b48 100644
--- a/src/NeuralNetworks/InstructorEmbedding.cs
+++ b/src/NeuralNetworks/InstructorEmbedding.cs
@@ -48,7 +48,7 @@ namespace AiDotNet.NeuralNetworks
     [ModelComplexity(ModelComplexity.High)]
     [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
     [ResearchPaper("One Embedder, Any Task: Instruction-Finetuned Text Embeddings", "https://arxiv.org/abs/2212.09741", Year = 2023, Authors = "Hongjin Su, Weijia Shi, Jungo Kasai, Yizhong Wang, Yushi Hu, Mari Ostendorf, Wen-tau Yih, Noah A. Smith, Luke Zettlemoyer, Tao Yu")]
-    public class InstructorEmbedding<T> : TransformerEmbeddingNetwork<T>
+    public partial class InstructorEmbedding<T> : TransformerEmbeddingNetwork<T>
     {
         private readonly InstructorEmbeddingOptions _options;
 
@@ -184,27 +184,6 @@ public override Vector<T> Embed(string text)
             return EmbedWithInstruction(text);
         }
 
-        /// <inheritdoc/>
-        protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-        {
-            var instance = new InstructorEmbedding<T>(
-                Architecture,
-                null,
-                null,
-                _vocabSize,
-                EmbeddingDimension,
-                MaxTokens,
-                _numLayers,
-                _numHeads,
-                _feedForwardDim,
-                _poolingStrategy,
-                LossFunction,
-                Convert.ToDouble(MaxGradNorm));
-
-            instance.SetDefaultInstruction(_defaultInstruction);
-            return instance;
-        }
-
         /// <summary>
         /// Retrieves metadata about the Instructor model, including its default instruction.
         /// </summary>
@@ -222,28 +201,10 @@ public override ModelMetadata<T> GetModelMetadata()
         }
 
         /// <inheritdoc/>
-        protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-        {
-            base.SerializeNetworkSpecificData(writer);
-            writer.Write(_defaultInstruction);
-            writer.Write(_vocabSize);
-            writer.Write(_numLayers);
-            writer.Write(_numHeads);
-            writer.Write(_feedForwardDim);
-            writer.Write((int)_poolingStrategy);
-        }
+
 
         /// <inheritdoc/>
-        protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-        {
-            base.DeserializeNetworkSpecificData(reader);
-            _defaultInstruction = reader.ReadString();
-            _vocabSize = reader.ReadInt32();
-            _numLayers = reader.ReadInt32();
-            _numHeads = reader.ReadInt32();
-            _feedForwardDim = reader.ReadInt32();
-            _poolingStrategy = (PoolingStrategy)reader.ReadInt32();
-        }
+
 
         /// <inheritdoc/>
         public override Task<Vector<T>> EmbedAsync(string text)
diff --git a/src/NeuralNetworks/JambaLanguageModel.cs b/src/NeuralNetworks/JambaLanguageModel.cs
index ae7ea3f6ea..429f34b4c7 100644
--- a/src/NeuralNetworks/JambaLanguageModel.cs
+++ b/src/NeuralNetworks/JambaLanguageModel.cs
@@ -37,7 +37,7 @@ namespace AiDotNet.NeuralNetworks;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Jamba: A Hybrid Transformer-Mamba Language Model", "https://arxiv.org/abs/2403.19887", Year = 2024, Authors = "Opher Lieber, Barak Lenz, Hofit Bata, Gal Cohen, Jhonathan Osin, Itay Dalmedigos, Erez Safahi, Shaked Meirom, Yonatan Belinkov, Shai Shalev-Shwartz, Omri Abend, Raz Alon, Tomer Asida, Amir Bergman, Roman Glozman, Michael Gokhman, Avashalom Manevich, Nir Ratner, Noam Rozen, Erez Shwartz, Mor Zusman, Yoav Shoham")]
-public class JambaLanguageModel<T> : TokenLanguageModelLayoutBase<T>
+public partial class JambaLanguageModel<T> : TokenLanguageModelLayoutBase<T>
 {
     private readonly JambaOptions _options;
     private readonly int _vocabSize;
@@ -146,32 +146,9 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_vocabSize);
-        writer.Write(_modelDimension);
-        writer.Write(_numLayers);
-        writer.Write(_stateDimension);
-        writer.Write(_attentionInterval);
-        writer.Write(_maxSeqLength);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _ = reader.ReadInt32();
-        _ = reader.ReadInt32();
-        _ = reader.ReadInt32();
-        _ = reader.ReadInt32();
-        _ = reader.ReadInt32();
-        _ = reader.ReadInt32();
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new JambaLanguageModel<T>(
-            Architecture, _vocabSize, _modelDimension, _numLayers, _stateDimension,
-            _attentionInterval, _maxSeqLength, LossFunction, _options);
-    }
+
 
     #endregion
 }
diff --git a/src/NeuralNetworks/LLaVANeuralNetwork.cs b/src/NeuralNetworks/LLaVANeuralNetwork.cs
index 4284c064ea..d18a4b6d61 100644
--- a/src/NeuralNetworks/LLaVANeuralNetwork.cs
+++ b/src/NeuralNetworks/LLaVANeuralNetwork.cs
@@ -88,10 +88,13 @@ public partial class LLaVANeuralNetwork<T> : MultimodalModelLayoutBase<T>, ILLaV
     // tape-aware vision forward (PrependClsToken / AddPositionalEmbeddings), so gradients reach them and
     // the tape optimizer updates them. Kept as Tensor<T> (not Matrix<T>) precisely so the concat/add ops
     // treat them as tape leaves rather than copying detached values.
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T>? _visionClsToken;
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T>? _visionPositionalEmbeddings;
     private ILayer<T>? _patchEmbedding;
     private ILayer<T>? _textTokenEmbedding;
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T>? _textPositionalEmbeddings;
     private ILayer<T>? _outputProjection;
     private ILayer<T>? _groundingHead;
@@ -1213,22 +1216,6 @@ public override Dictionary<string, Tensor<T>> GetNamedLayerActivations(Tensor<T>
         return activations;
     }
 
-    /// <summary>
-    /// Surfaces the CLS token and vision positional embeddings as trainable tensors that live OUTSIDE
-    /// <c>Layers</c>, so the base tape training path watches and updates them alongside the layer weights.
-    /// They are used directly (uncopied) in <see cref="PrependClsToken"/> / <see cref="AddPositionalEmbeddings"/>,
-    /// so the gradient reaches these exact instances and the optimizer step moves them.
-    /// </summary>
-    protected override IEnumerable<Tensor<T>> GetExtraTrainableTensors()
-    {
-        if (_visionClsToken is not null) yield return _visionClsToken;
-        if (_visionPositionalEmbeddings is not null) yield return _visionPositionalEmbeddings;
-        // The text positional table too. It was a Matrix<T>, which no automatic parameter
-        // path can see, so the count included its 512 values and the vector did not --
-        // measured 24,772 against 24,260, a gap that WAS exactly this field.
-        if (_textPositionalEmbeddings is not null) yield return _textPositionalEmbeddings;
-    }
-
     /// <inheritdoc/>
     public override void Train(Tensor<T> input, Tensor<T> expectedOutput)
     {
@@ -1276,40 +1263,7 @@ public override ModelMetadata<T> GetModelMetadata()
     private const int NetworkSpecificPayloadVersion = 1;
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_embeddingDimension);
-        writer.Write(_maxSequenceLength);
-        writer.Write(_imageSize);
-        writer.Write(_visionHiddenDim);
-        writer.Write(_lmHiddenDim);
-        writer.Write(_numVisionLayers);
-        writer.Write(_numLmLayers);
-        writer.Write(_numHeads);
-        writer.Write(_patchSize);
-        writer.Write(_vocabularySize);
-        writer.Write(_numVisualTokens);
-        writer.Write((int)_languageModelBackbone);
-        writer.Write(_visionEncoderType);
-        writer.Write(_useNativeMode);
-
-        // Everything from here on was added after the first shipped payload, which ended at
-        // _useNativeMode. The version marker is what lets the reader tell the two apart -- see
-        // NetworkSpecificPayloadVersion.
-        writer.Write(NetworkSpecificPayloadVersion);
-
-        // Persist the TRAINABLE state that lives OUTSIDE Layers: the CLS token and the vision/text
-        // positional tables. Clone() (all three paths — COW fallback, large layer-by-layer copy, and
-        // the serialize round-trip) transfers this model-level state ONLY through these hooks; the
-        // per-layer parameter copy does not cover it. Without persisting them the clone re-initialises
-        // these tensors from the fixed seed in InitializeWeights and diverges from the trained original
-        // (Clone_AfterTraining). The vision CLS + vision positional tables are also surfaced via
-        // GetExtraTrainableTensors, so the tape optimiser updates them during training — meaning their
-        // post-training values genuinely differ from the seed init and MUST be carried across a clone.
-        WriteTensor(writer, _visionClsToken);
-        WriteTensor(writer, _visionPositionalEmbeddings);
-        WriteTensor(writer, _textPositionalEmbeddings);
-    }
+
 
     private void WriteTensor(BinaryWriter writer, Tensor<T>? tensor)
     {
@@ -1412,63 +1366,7 @@ private void WriteMatrix(BinaryWriter writer, Matrix<T>? matrix)
     }
 
     /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _ = reader.ReadInt32(); // embeddingDim
-        _ = reader.ReadInt32(); // maxSeqLen
-        _ = reader.ReadInt32(); // imgSize
-        _ = reader.ReadInt32(); // visionHiddenDim
-        _ = reader.ReadInt32(); // lmHiddenDim
-        _ = reader.ReadInt32(); // numVisionLayers
-        _ = reader.ReadInt32(); // numLmLayers
-        _ = reader.ReadInt32(); // numHeads
-        _ = reader.ReadInt32(); // patchSize
-        _ = reader.ReadInt32(); // vocabularySize
-        _ = reader.ReadInt32(); // numVisualTokens
-        _ = reader.ReadInt32(); // languageModelBackbone (enum as int)
-        _ = reader.ReadString(); // visionEncoderType
-        _ = reader.ReadBoolean(); // useNativeMode
-
-        // Re-wire the role sub-lists (_patchEmbedding, _visionEncoderLayers, _projectionLayers, ...) to
-        // the freshly DESERIALIZED layer objects now sitting in Layers. Deserialization runs
-        // ClearLayers() and rebuilds Layers with NEW layer instances (carrying the trained weights),
-        // but the sub-list fields still reference the seed-initialised layers that CreateNewInstance()
-        // wired up. LLaVA's forward path (ExtractVisualFeaturesNative / ProjectToLanguageSpace / ...)
-        // reads those sub-lists directly, so without re-deriving them the clone would run the
-        // random-initialised layers while the trained weights sit unused in Layers — producing output
-        // uncorrelated with the trained original (Clone_AfterTraining). This mirrors the same
-        // distribution InitializeNativeLayers performs at construction.
-        RewireNativeSubLayersFromLayers();
-
-        // A payload written before the out-of-Layers state existed ends here. Detecting that is not a
-        // heuristic: this method is the last read of NeuralNetworkBase.Deserialize, over a seekable
-        // MemoryStream, so an exhausted stream means precisely "nothing more was written".
-        var stream = reader.BaseStream;
-        if (stream.CanSeek && stream.Position >= stream.Length)
-        {
-            System.Diagnostics.Trace.TraceWarning(
-                "AiDotNet.LLaVANeuralNetwork: this model was saved before the CLS token and positional " +
-                "tables were persisted, so they keep their freshly initialized values. Predictions will " +
-                "differ from the model as trained. Re-save the model to carry that state forward.");
-            return;
-        }
-
-        int payloadVersion = reader.ReadInt32();
-        if (payloadVersion != NetworkSpecificPayloadVersion)
-        {
-            throw new InvalidOperationException(
-                $"LLaVANeuralNetwork was saved with network-payload version {payloadVersion}, but this " +
-                $"build reads version {NetworkSpecificPayloadVersion}. Load this model with a matching " +
-                "version of AiDotNet, or re-save it from one.");
-        }
 
-        // Restore the trained out-of-Layers state (CLS token + positional tables) written above,
-        // overwriting the seed-initialised tensors that CreateNewInstance() produced. This is what
-        // makes a clone (and a save/load round-trip) reproduce the trained model's predictions.
-        _visionClsToken = ReadTensor(reader);
-        _visionPositionalEmbeddings = ReadTensor(reader);
-        _textPositionalEmbeddings = ReadTensor(reader);
-    }
 
     /// <summary>
     /// Re-derives the native-mode role sub-lists from the current <c>Layers</c> collection using the
@@ -1520,25 +1418,6 @@ private void RewireNativeSubLayersFromLayers()
         _groundingHead = Layers[idx++];
     }
 
-    /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new LLaVANeuralNetwork<T>(
-            Architecture,
-            _imageSize,
-            channels: 3,
-            _patchSize,
-            _vocabularySize,
-            _maxSequenceLength,
-            _embeddingDimension,
-            _visionHiddenDim,
-            _numVisionLayers,
-            _numLmLayers,
-            _numHeads,
-            _languageModelBackbone,
-            _visionEncoderType);
-    }
-
     /// <inheritdoc/>
     protected override void Dispose(bool disposing)
     {
diff --git a/src/NeuralNetworks/LSTMNeuralNetwork.cs b/src/NeuralNetworks/LSTMNeuralNetwork.cs
index 32beaa250c..e74d7e484c 100644
--- a/src/NeuralNetworks/LSTMNeuralNetwork.cs
+++ b/src/NeuralNetworks/LSTMNeuralNetwork.cs
@@ -55,7 +55,7 @@ namespace AiDotNet.NeuralNetworks;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Long Short-Term Memory", "https://www.bioinf.jku.at/publications/older/2604.pdf", Year = 1997, Authors = "Sepp Hochreiter, Jurgen Schmidhuber")]
-public class LSTMNeuralNetwork<T> : SequenceModelLayoutBase<T>
+public partial class LSTMNeuralNetwork<T> : SequenceModelLayoutBase<T>
 {
     private readonly LSTMOptions _options;
 
@@ -1827,9 +1827,7 @@ public override ModelMetadata<T> GetModelMetadata()
     /// - Load the model later for additional training or making predictions
     /// </para>
     /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-    }
+
 
     /// <summary>
     /// Deserializes LSTM-specific data from a binary reader.
@@ -1854,62 +1852,5 @@ protected override void SerializeNetworkSpecificData(BinaryWriter writer)
     /// - Apply a trained model to new data for predictions
     /// </para>
     /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-    }
 
-    /// <summary>
-    /// Creates a new instance of the LSTM Neural Network with the same architecture and configuration.
-    /// </summary>
-    /// <returns>A new LSTM Neural Network instance with the same architecture and configuration.</returns>
-    /// <remarks>
-    /// <para>
-    /// This method creates a new instance of the LSTM Neural Network with the same architecture and activation
-    /// functions as the current instance. It's used in scenarios where a fresh copy of the model is needed
-    /// while maintaining the same configuration.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method creates a brand new copy of the LSTM network with the same setup.
-    /// 
-    /// Think of it like creating a clone of the network:
-    /// - The new network has the same architecture (structure)
-    /// - It has the same activation functions for all gates
-    /// - It uses the same loss function
-    /// - But it's a completely separate instance with its own parameters
-    /// 
-    /// This is useful when you want to:
-    /// - Create multiple networks with identical settings
-    /// - Compare how different initializations affect learning
-    /// - Set up ensemble learning with multiple similar networks
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        // Determine which constructor to use based on whether we're using scalar or vector activations
-        if (VectorActivation != null || ForgetGateVectorActivation != null ||
-            InputGateVectorActivation != null || CellGateVectorActivation != null ||
-            OutputGateVectorActivation != null)
-        {
-            // Use the vector activation constructor
-            return new LSTMNeuralNetwork<T>(
-                this.Architecture,
-                LossFunction,
-                VectorActivation,
-                ForgetGateVectorActivation,
-                InputGateVectorActivation,
-                CellGateVectorActivation,
-                OutputGateVectorActivation);
-        }
-        else
-        {
-            // Use the scalar activation constructor
-            return new LSTMNeuralNetwork<T>(
-                this.Architecture,
-                LossFunction,
-                ScalarActivation,
-                ForgetGateActivation,
-                InputGateActivation,
-                CellGateActivation,
-                OutputGateActivation);
-        }
-    }
 }
diff --git a/src/NeuralNetworks/Layers/ALiBiPositionalBiasLayer.cs b/src/NeuralNetworks/Layers/ALiBiPositionalBiasLayer.cs
index d0985e1f9e..2122ff7985 100644
--- a/src/NeuralNetworks/Layers/ALiBiPositionalBiasLayer.cs
+++ b/src/NeuralNetworks/Layers/ALiBiPositionalBiasLayer.cs
@@ -74,6 +74,7 @@ public partial class ALiBiPositionalBiasLayer<T> : LayerBase<T>, IShapeContract
     /// Pre-computed bias tensor [numHeads, maxSequenceLength, maxSequenceLength].
     /// Lazily computed on first use and cached.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _biasCache;
     private int _biasCacheQueryLen;
     private int _biasCacheKeyLen;
diff --git a/src/NeuralNetworks/Layers/ActivationLayer.cs b/src/NeuralNetworks/Layers/ActivationLayer.cs
index 6269c403ee..dae6b7550a 100644
--- a/src/NeuralNetworks/Layers/ActivationLayer.cs
+++ b/src/NeuralNetworks/Layers/ActivationLayer.cs
@@ -43,10 +43,13 @@ public partial class ActivationLayer<T> : LayerBase<T>, IShapeContract
     /// this cached input is used to calculate the gradient of the activation function. The field is nullable
     /// and will be null until Forward() is called at least once.
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _lastInput;
 
     // GPU-resident cached tensors for GPU training pipeline
+    [Scratch]
     private Tensor<T>? _lastInputGpu;
+    [Scratch]
     private Tensor<T>? _lastOutputGpu; // Post-activation for sigmoid/tanh backward
 
     /// <summary>
diff --git a/src/NeuralNetworks/Layers/AdaptiveAveragePoolingLayer.cs b/src/NeuralNetworks/Layers/AdaptiveAveragePoolingLayer.cs
index c7dca9097d..5cc11916ef 100644
--- a/src/NeuralNetworks/Layers/AdaptiveAveragePoolingLayer.cs
+++ b/src/NeuralNetworks/Layers/AdaptiveAveragePoolingLayer.cs
@@ -52,10 +52,12 @@ public partial class AdaptiveAveragePoolingLayer<T> : LayerBase<T>, IShapeContra
     private readonly int _outputWidth;
     private int _channels;
 
+    [Scratch]
     private Tensor<T>? _lastInput;
     private int[]? _lastInputShape;
 
     // GPU cached tensors for backward pass
+    [ExternalState]
     private Tensor<T>? _gpuInput;
     private int _gpuBatch;
     private int _gpuChannels;
diff --git a/src/NeuralNetworks/Layers/AddLayer.cs b/src/NeuralNetworks/Layers/AddLayer.cs
index 5032e91936..773f0345c0 100644
--- a/src/NeuralNetworks/Layers/AddLayer.cs
+++ b/src/NeuralNetworks/Layers/AddLayer.cs
@@ -64,9 +64,11 @@ public partial class AddLayer<T> : LayerBase<T>, IShapeContract
     /// this cached output is used to calculate the gradient of the activation function. The field is nullable
     /// and will be null until Forward() is called at least once.
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _lastOutput;
 
     // GPU-resident cached tensors for GPU training pipeline
+    [Scratch]
     private Tensor<T>? _lastOutputGpu;
     private int _lastInputCountGpu;
 
diff --git a/src/NeuralNetworks/Layers/AnomalyDetectorLayer.cs b/src/NeuralNetworks/Layers/AnomalyDetectorLayer.cs
index cfa8272ed8..d7195e8239 100644
--- a/src/NeuralNetworks/Layers/AnomalyDetectorLayer.cs
+++ b/src/NeuralNetworks/Layers/AnomalyDetectorLayer.cs
@@ -218,6 +218,9 @@ public partial class AnomalyDetectorLayer<T> : LayerBase<T>, IShapeContract
     /// </summary>
     protected override bool SupportsGpuExecution => true;
 
+    /// <summary>Construction state: the 'inputSize' the layer was built with.</summary>
+    private readonly int _inputSize;
+
     /// <summary>
     /// Initializes a new instance of the <see cref="AnomalyDetectorLayer{T}"/> class.
     /// </summary>
@@ -250,6 +253,7 @@ public AnomalyDetectorLayer(
         IEngine? engine = null)
         : base([inputSize], [1])
     {
+        _inputSize = inputSize;
         _anomalyThreshold = anomalyThreshold;
         _historyCapacity = historyCapacity;
         _smoothingFactor = smoothingFactor;
diff --git a/src/NeuralNetworks/Layers/AttentionLayer.cs b/src/NeuralNetworks/Layers/AttentionLayer.cs
index f234653b2f..892bf4843f 100644
--- a/src/NeuralNetworks/Layers/AttentionLayer.cs
+++ b/src/NeuralNetworks/Layers/AttentionLayer.cs
@@ -115,21 +115,25 @@ public partial class AttentionLayer<T> : LayerBase<T>, IAuxiliaryLossLayer<T>, I
     /// <summary>
     /// The last input processed by the layer.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastInput;
 
     /// <summary>
     /// The cached query input from the last forward pass (for cross-attention backward).
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastQueryInput;
 
     /// <summary>
     /// The cached key input from the last forward pass (for cross-attention backward).
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastKeyInput;
 
     /// <summary>
     /// The cached value input from the last forward pass.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastValueInput;
 
     /// <summary>
@@ -145,11 +149,13 @@ public partial class AttentionLayer<T> : LayerBase<T>, IAuxiliaryLossLayer<T>, I
     /// <summary>
     /// The cached attention mask from the last forward pass.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastMask;
 
     /// <summary>
     /// The last attention weights computed by the layer.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastAttentionWeights;
 
     /// <summary>
@@ -170,6 +176,7 @@ public partial class AttentionLayer<T> : LayerBase<T>, IAuxiliaryLossLayer<T>, I
     /// <summary>
     /// Cached attention output before output projection (Wo), used for backward pass.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastAttentionOutput;
 
     /// <summary>
@@ -187,29 +194,39 @@ public partial class AttentionLayer<T> : LayerBase<T>, IAuxiliaryLossLayer<T>, I
     /// <summary>
     /// Gradient of the weight tensor for the value transformation.
     /// </summary>
+    [AiDotNet.Attributes.Scratch]
     private Tensor<T>? _dWv;
 
     /// <summary>
     /// Gradient of the weight tensor for the key transformation.
     /// </summary>
+    [AiDotNet.Attributes.Scratch]
     private Tensor<T>? _dWk;
 
     /// <summary>
     /// Gradient of the weight tensor for the query transformation.
     /// </summary>
+    [AiDotNet.Attributes.Scratch]
     private Tensor<T>? _dWq;
 
     /// <summary>
     /// Gradient of the weight tensor for the output projection.
     /// </summary>
+    [AiDotNet.Attributes.Scratch]
     private Tensor<T>? _dWo;
 
     // GPU cached tensors for backward pass
+    [ExternalState]
     private Tensor<T>? _gpuInput;
+    [ExternalState]
     private Tensor<T>? _gpuQ;
+    [ExternalState]
     private Tensor<T>? _gpuK;
+    [ExternalState]
     private Tensor<T>? _gpuV;
+    [ExternalState]
     private Tensor<T>? _gpuAttnOutput;
+    [ExternalState]
     private Tensor<T>? _gpuAttnWeights;
     private int[]? _gpuInputShape;
     private int _gpuBatchSize;
diff --git a/src/NeuralNetworks/Layers/AttentiveTransformerLayer.cs b/src/NeuralNetworks/Layers/AttentiveTransformerLayer.cs
index 8dfead5469..b3aee290f9 100644
--- a/src/NeuralNetworks/Layers/AttentiveTransformerLayer.cs
+++ b/src/NeuralNetworks/Layers/AttentiveTransformerLayer.cs
@@ -80,14 +80,27 @@ public partial class AttentiveTransformerLayer<T> : LayerBase<T>, IShapeContract
     private readonly Sparsemax<T> _sparsemax;
 
     // Cache for backward pass
+    [Scratch]
     private Tensor<T>? _inputCache;
+    [Scratch]
     private Tensor<T>? _priorScalesCache;
+    [Scratch]
     private Tensor<T>? _attentionMaskCache;
+    [Scratch]
     private Tensor<T>? _sparsemaxInputCache;
 
     /// <inheritdoc/>
     public override bool SupportsTraining => true;
 
+    /// <summary>Construction state: the 'epsilon' the layer was built with.</summary>
+    private readonly double _epsilon;
+
+    /// <summary>Construction state: the 'momentum' the layer was built with.</summary>
+    private readonly double _momentum;
+
+    /// <summary>Construction state: the 'virtualBatchSize' the layer was built with.</summary>
+    private readonly int _virtualBatchSize;
+
     /// <summary>
     /// Initializes a new instance of the AttentiveTransformer class.
     /// </summary>
@@ -121,6 +134,9 @@ public AttentiveTransformerLayer(
         double epsilon = 1e-5)
         : base([inputDim], [outputDim])
     {
+        _virtualBatchSize = virtualBatchSize;
+        _momentum = momentum;
+        _epsilon = epsilon;
         _inputDim = inputDim;
         _outputDim = outputDim;
         _relaxationFactor = relaxationFactor;
diff --git a/src/NeuralNetworks/Layers/AutoregressiveEncoderDecoderLayer.cs b/src/NeuralNetworks/Layers/AutoregressiveEncoderDecoderLayer.cs
index ef4beb6206..3b612ada4a 100644
--- a/src/NeuralNetworks/Layers/AutoregressiveEncoderDecoderLayer.cs
+++ b/src/NeuralNetworks/Layers/AutoregressiveEncoderDecoderLayer.cs
@@ -23,6 +23,14 @@ public abstract class AutoregressiveEncoderDecoderLayer<T> : LayerBase<T>
     protected readonly int _decoderVocabularySize;
     protected readonly int _maximumDecoderLength;
 
+    // Generated construction factories reopen the concrete derived layer, so they cannot read the
+    // base's private ownership fields directly. Exact-type protected views let the generator bind
+    // IEnumerable/ILayer constructor arguments without exposing mutable collections publicly.
+    protected IEnumerable<ILayer<T>> EncoderLayers => _encoderLayers;
+    protected EmbeddingLayer<T> DecoderEmbedding => _decoderEmbedding;
+    protected IEnumerable<ILayer<T>> DecoderLayers => _decoderLayers;
+    protected ILayer<T> OutputLayer => _outputLayer;
+
     /// <summary>Creates an encoder-decoder composite from its independently executed branches.</summary>
     protected AutoregressiveEncoderDecoderLayer(
         IEnumerable<ILayer<T>> encoderLayers,
diff --git a/src/NeuralNetworks/Layers/AveragePoolingLayer.cs b/src/NeuralNetworks/Layers/AveragePoolingLayer.cs
index 5545c96d92..869a68c70f 100644
--- a/src/NeuralNetworks/Layers/AveragePoolingLayer.cs
+++ b/src/NeuralNetworks/Layers/AveragePoolingLayer.cs
@@ -112,6 +112,7 @@ public partial class AveragePoolingLayer<T> : LayerBase<T>, IShapeContract
     /// <summary>
     /// Stores the last input tensor from the forward pass for use in autodiff backward pass.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastInput;
 
     /// <summary>
@@ -391,38 +392,6 @@ protected override Tensor<T> ForwardTraced(Tensor<T> input)
         }
     }
 
-    /// <summary>
-    /// Saves the layer's configuration to a binary stream.
-    /// </summary>
-    /// <param name="writer">The binary writer to write the data to.</param>
-    /// <remarks>
-    /// <b>For Beginners:</b> This method saves the layer's settings (pool size and stride)
-    /// so that you can reload the exact same layer later. It's like saving your game
-    /// progress so you can continue from where you left off.
-    /// </remarks>
-    public override void Serialize(BinaryWriter writer)
-    {
-        base.Serialize(writer);
-        writer.Write(PoolSize);
-        writer.Write(Strides);
-    }
-
-    /// <summary>
-    /// Loads the layer's configuration from a binary stream.
-    /// </summary>
-    /// <param name="reader">The binary reader to read the data from.</param>
-    /// <remarks>
-    /// <b>For Beginners:</b> This method loads previously saved settings for the layer.
-    /// It's the counterpart to Serialize - if Serialize is like saving your game,
-    /// Deserialize is like loading that saved game.
-    /// </remarks>
-    public override void Deserialize(BinaryReader reader)
-    {
-        base.Deserialize(reader);
-        PoolSize = reader.ReadInt32();
-        Strides = reader.ReadInt32();
-    }
-
     /// <summary>
     /// Returns the activation functions used by this layer.
     /// </summary>
diff --git a/src/NeuralNetworks/Layers/BasicBlock.cs b/src/NeuralNetworks/Layers/BasicBlock.cs
index d25cc68d6b..e6b576ef96 100644
--- a/src/NeuralNetworks/Layers/BasicBlock.cs
+++ b/src/NeuralNetworks/Layers/BasicBlock.cs
@@ -133,18 +133,29 @@ public partial class BasicBlock<T> : LayerBase<T>, ILayerSerializationExtras<T>,
     private int _inputWidth;
     private readonly bool _zeroInitResidual;
 
+    [Scratch]
     private Tensor<T>? _lastInput;
+    [Scratch]
     private Tensor<T>? _lastConv1Output;
+    [Scratch]
     private Tensor<T>? _lastBn1Output;
+    [Scratch]
     private Tensor<T>? _lastRelu1Output;
+    [Scratch]
     private Tensor<T>? _lastConv2Output;
+    [Scratch]
     private Tensor<T>? _lastBn2Output;
+    [Scratch]
     private Tensor<T>? _lastIdentity;
+    [Scratch]
     private Tensor<T>? _lastPreActivation;
 
     // GPU cached tensors for backward pass
+    [ExternalState]
     private Tensor<T>? _gpuBn1Out;
+    [ExternalState]
     private Tensor<T>? _gpuBn2Out;
+    [ExternalState]
     private Tensor<T>? _gpuPreActivation;
 
     public override bool SupportsTraining => true;
@@ -462,6 +473,7 @@ public override void ClearGradients()
         _downsampleConv?.ClearGradients(); _downsampleBn?.ClearGradients();
     }
 
+    [Scratch]
     private Vector<T>? _pendingParameters;
 
     private void ApplyParameters(Vector<T> parameters)
@@ -517,6 +529,7 @@ void ILayerSerializationExtras<T>.SetExtraParameters(Vector<T> extraParameters)
         ApplyExtraParametersUnsafe(extraParameters);
     }
 
+    [Scratch]
     private Vector<T>? _pendingExtraParameters;
 
     private void ApplyExtraParametersUnsafe(Vector<T> extraParameters)
diff --git a/src/NeuralNetworks/Layers/BatchEnsembleLayer.cs b/src/NeuralNetworks/Layers/BatchEnsembleLayer.cs
index f2cf1ba26f..51cfabd6eb 100644
--- a/src/NeuralNetworks/Layers/BatchEnsembleLayer.cs
+++ b/src/NeuralNetworks/Layers/BatchEnsembleLayer.cs
@@ -1,4 +1,4 @@
-using AiDotNet.Autodiff;
+using AiDotNet.Autodiff;
 using AiDotNet.Attributes;
 
 namespace AiDotNet.NeuralNetworks.Layers;
@@ -10,21 +10,21 @@ namespace AiDotNet.NeuralNetworks.Layers;
 /// <para>
 /// BatchEnsemble creates multiple ensemble members that share base weights but have
 /// their own small rank-1 matrices. For a weight matrix W, each member i computes:
-/// W_i = W ⊙ (r_i ⊗ s_i)
-/// where r_i and s_i are per-member rank vectors, ⊙ is element-wise multiplication,
-/// and ⊗ is outer product.
+/// W_i = W ⊙ (r_i ⊗ s_i)
+/// where r_i and s_i are per-member rank vectors, ⊙ is element-wise multiplication,
+/// and ⊗ is outer product.
 /// </para>
 /// <para>
 /// <b>For Beginners:</b> BatchEnsemble is a clever way to create multiple models
 /// (ensemble members) that share most of their weights.
 ///
-/// Traditional ensemble: Train N separate models with N×parameters
-/// BatchEnsemble: Train 1 base model + N small vectors = ~1×parameters + small overhead
+/// Traditional ensemble: Train N separate models with N×parameters
+/// BatchEnsemble: Train 1 base model + N small vectors = ~1×parameters + small overhead
 ///
 /// How it works:
 /// 1. A single shared weight matrix W captures the main learned patterns
 /// 2. Each ensemble member has two small vectors (r and s)
-/// 3. Member i's effective weights = W × (r_i outer-product s_i)
+/// 3. Member i's effective weights = W × (r_i outer-product s_i)
 /// 4. This modulates the shared weights to create diversity
 ///
 /// Benefits:
@@ -34,9 +34,9 @@ namespace AiDotNet.NeuralNetworks.Layers;
 /// - Easy to implement and train
 ///
 /// Example with 256-dim hidden layer and 4 members:
-/// - Shared weights: 256 × 256 = 65,536 parameters
-/// - Per-member vectors: 4 × (256 + 256) = 2,048 parameters
-/// - Total overhead: ~3% more parameters for 4× ensemble benefit
+/// - Shared weights: 256 × 256 = 65,536 parameters
+/// - Per-member vectors: 4 × (256 + 256) = 2,048 parameters
+/// - Total overhead: ~3% more parameters for 4× ensemble benefit
 /// </para>
 /// </remarks>
 /// <typeparam name="T">The numeric type used for calculations.</typeparam>
@@ -101,13 +101,19 @@ public partial class BatchEnsembleLayer<T> : LayerBase<T>, IShapeContract
     private Tensor<T> _sVectors;     // Shape: [numMembers, outputDim]
 
     // Gradients
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T>? _weightsGrad;
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T>? _biasGrad;
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T>? _rVectorsGrad;
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T>? _sVectorsGrad;
 
     // Cache for backward pass
+    [Scratch]
     private Tensor<T>? _inputCache;     // Shape: [batchSize * numMembers, inputDim]
+    [Scratch]
     private Tensor<T>? _scaledInputCache;  // Input after r-vector scaling
 
     /// <summary>
@@ -128,6 +134,9 @@ public partial class BatchEnsembleLayer<T> : LayerBase<T>, IShapeContract
     /// <inheritdoc/>
     public override bool SupportsTraining => true;
 
+    /// <summary>Construction state: the 'rankInitScale' the layer was built with.</summary>
+    private readonly double _rankInitScale;
+
     /// <summary>
     /// Initializes a new instance of the BatchEnsembleLayer class.
     /// </summary>
@@ -154,6 +163,7 @@ public BatchEnsembleLayer(
         double rankInitScale = 0.5)
         : base([inputDim], [outputDim])
     {
+        _rankInitScale = rankInitScale;
         _inputDim = inputDim;
         _outputDim = outputDim;
         _numMembers = numMembers;
@@ -246,7 +256,7 @@ private void InitializeRankVectors(Tensor<T> tensor, double scale)
     /// 4. Output is scaled by each member's s vector (output modulation)
     /// 5. Bias is added (shared across members)
     ///
-    /// The output has batchSize × numMembers rows, with consecutive numMembers
+    /// The output has batchSize × numMembers rows, with consecutive numMembers
     /// rows belonging to the same input sample.
     /// </para>
     /// </remarks>
@@ -282,8 +292,8 @@ protected override Tensor<T> ForwardTraced(Tensor<T> input)
         var weights2D = Engine.Reshape(_weights, [_inputDim, _outputDim]);
         var matmul = Engine.TensorMatMul(scaledInput, weights2D);
 
-        // Apply s-vector scaling per member by broadcasting [M, outputDim] →
-        // [B, M, outputDim] → [B*M, outputDim]. Same tiling pattern used for
+        // Apply s-vector scaling per member by broadcasting [M, outputDim] →
+        // [B, M, outputDim] → [B*M, outputDim]. Same tiling pattern used for
         // r-vectors above.
         var sVecs3D = Engine.Reshape(_sVectors, [1, _numMembers, _outputDim]);
         var sVecsTiled = Engine.TensorTile(sVecs3D, [batchSize, 1, 1]);
@@ -305,7 +315,7 @@ protected override Tensor<T> ForwardTraced(Tensor<T> input)
     /// (<c>[batchSize * numMembers, inputDim]</c>, members in consecutive rows).
     /// </summary>
     /// <remarks>
-    /// Unlike <see cref="Forward"/>, this does not tile the input — it lets a stack of
+    /// Unlike <see cref="Forward"/>, this does not tile the input — it lets a stack of
     /// BatchEnsemble layers run member-aware without re-expanding the batch at every layer.
     /// The per-member r/s vectors are still tiled to match. All Engine ops, so the autodiff
     /// tape records the computation.
@@ -361,10 +371,10 @@ public Tensor<T> AverageMembers(Tensor<T> output)
         int batchSize = expandedBatchSize / _numMembers;
 
         // The output is laid out as [batchSize*numMembers, outputDim] with the
-        // members for one batch item stored in consecutive rows — so reshape to
+        // members for one batch item stored in consecutive rows — so reshape to
         // [batchSize, numMembers, outputDim] and reduce-mean over the member axis
         // to collapse the ensemble. One Engine call replaces
-        // batchSize × outputDim × numMembers scalar NumOps.Add dispatches.
+        // batchSize × outputDim × numMembers scalar NumOps.Add dispatches.
         var reshaped = Engine.Reshape(output, [batchSize, _numMembers, _outputDim]);
         return Engine.ReduceMean(reshaped, new[] { 1 }, keepDims: false);
     }
diff --git a/src/NeuralNetworks/Layers/BatchNormalizationLayer.cs b/src/NeuralNetworks/Layers/BatchNormalizationLayer.cs
index 49b8f436ed..69e55ea184 100644
--- a/src/NeuralNetworks/Layers/BatchNormalizationLayer.cs
+++ b/src/NeuralNetworks/Layers/BatchNormalizationLayer.cs
@@ -120,6 +120,7 @@ public partial class BatchNormalizationLayer<T> : LayerBase<T>, ILayerSerializat
     /// <remarks>
     /// Stored for use in the backward pass.
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _lastInput;
 
     /// <summary>
@@ -138,6 +139,7 @@ public partial class BatchNormalizationLayer<T> : LayerBase<T>, ILayerSerializat
     /// <remarks>
     /// Stored for use in the backward pass.
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _lastMean;
 
     /// <summary>
@@ -146,6 +148,7 @@ public partial class BatchNormalizationLayer<T> : LayerBase<T>, ILayerSerializat
     /// <remarks>
     /// Stored for use in the backward pass.
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _lastVariance;
 
     /// <summary>
@@ -154,6 +157,7 @@ public partial class BatchNormalizationLayer<T> : LayerBase<T>, ILayerSerializat
     /// <remarks>
     /// Computed during the backward pass and used to update gamma.
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _gammaGradient;
 
     /// <summary>
@@ -162,9 +166,11 @@ public partial class BatchNormalizationLayer<T> : LayerBase<T>, ILayerSerializat
     /// <remarks>
     /// Computed during the backward pass and used to update beta.
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _betaGradient;
 
     // GPU-resident cached tensors for GPU training pipeline
+    [Scratch]
     private Tensor<T>? _lastInputGpu;
 
     /// <summary>
@@ -439,6 +445,9 @@ public BatchNormalizationLayer(double epsilon = NumericalStabilityHelper.LargeEp
         _runningVariance = new Tensor<T>([0]);
     }
 
+    /// <summary>Construction state: the 'numFeatures' the layer was built with.</summary>
+    private readonly int _numFeatures;
+
     /// <summary>
     /// AiDotNet#1370 eager-init constructor. Pass <paramref name="numFeatures"/> at
     /// construction (the channel count for image-like inputs OR the feature count
@@ -468,6 +477,7 @@ public BatchNormalizationLayer(
         double momentum = 0.9)
         : base(new[] { numFeatures }, new[] { numFeatures })
     {
+        _numFeatures = numFeatures;
         if (numFeatures <= 0)
             throw new ArgumentOutOfRangeException(nameof(numFeatures),
                 $"numFeatures must be positive, got {numFeatures}.");
@@ -1090,6 +1100,25 @@ Vector<T> ILayerSerializationExtras<T>.GetExtraParameters()
     void ILayerSerializationExtras<T>.SetExtraParameters(Vector<T> extraParameters)
     {
         int featureSize = InputShape[0];
+
+        // A layer whose feature count has not resolved yet cannot check anything: InputShape[0] is
+        // the -1 free-axis sentinel, and the arithmetic below turned that into the message
+        // "extra parameters must have length -2 (mean + variance for -1 features), but got 0" --
+        // a demand for a negative number of values, which no caller can satisfy. An empty vector
+        // from an equally unresolved source is not a mismatch, it is two sides agreeing that there
+        // are no running statistics yet, so accept it and leave the buffers alone. This is what
+        // CRNN's clone hit: neither side had run a forward, so neither had statistics.
+        if (featureSize <= 0)
+        {
+            if (extraParameters.Length == 0) return;
+
+            throw new ArgumentException(
+                $"BatchNormalization cannot accept {extraParameters.Length} extra parameters until " +
+                "its feature count is known; the layer's input shape is still unresolved. Run a " +
+                "forward pass, or restore into a layer resolved from the same input shape.",
+                nameof(extraParameters));
+        }
+
         if (extraParameters.Length != featureSize * 2)
             throw new ArgumentException(
                 $"BatchNormalization extra parameters must have length {featureSize * 2} " +
@@ -1123,7 +1152,9 @@ public override void SetTrainingMode(bool isTraining)
         base.SetTrainingMode(isTraining);
     }
 
+    [AiDotNet.Attributes.Buffer]
     private Tensor<T>? _gammaVelocity;
+    [AiDotNet.Attributes.Buffer]
     private Tensor<T>? _betaVelocity;
 
     /// <summary>
diff --git a/src/NeuralNetworks/Layers/BiaffineSpanScorerLayer.cs b/src/NeuralNetworks/Layers/BiaffineSpanScorerLayer.cs
index 5595b60ef5..e421c839d0 100644
--- a/src/NeuralNetworks/Layers/BiaffineSpanScorerLayer.cs
+++ b/src/NeuralNetworks/Layers/BiaffineSpanScorerLayer.cs
@@ -110,13 +110,21 @@ public partial class BiaffineSpanScorerLayer<T> : LayerBase<T>, IShapeContract
     private readonly DropoutLayer<T>? _startDropout;
     private readonly DropoutLayer<T>? _endDropout;
 
+    // Declared as well as registered, following FullyConnectedLayer: the constructor registration
+    // keeps the tape pointing at these instances, and the declaration gives the generated setter
+    // permission to REBIND the fields. The base setter alone would update only its private registry
+    // and leave these three fields pointing at the pre-restore tensors, which Forward reads directly.
+
     /// <summary>Bilinear tensor U, stored as [C, d, d].</summary>
+    [AiDotNet.Attributes.TrainableParameter(Role = PersistentTensorRole.Weights)]
     private Tensor<T> _bilinear;
 
     /// <summary>Additive weight W over the concatenated endpoints, stored as [2d, C].</summary>
+    [AiDotNet.Attributes.TrainableParameter(Role = PersistentTensorRole.Weights)]
     private Tensor<T> _additive;
 
     /// <summary>Per-category bias b, stored as [C].</summary>
+    [AiDotNet.Attributes.TrainableParameter(Role = PersistentTensorRole.Biases)]
     private Tensor<T> _bias;
 
     /// <inheritdoc/>
@@ -341,80 +349,20 @@ private Tensor<T> BroadcastMatrix(Tensor<T> matrix, int batch, int rows, int col
         return batch > 1 ? Engine.TensorBroadcastTo(reshaped, [batch, rows, cols]) : reshaped;
     }
 
-    /// <summary>Concatenates a boundary stack's parameters in layer order.</summary>
-    private static Vector<T> StackParameters(DenseLayer<T>[] layers)
-    {
-        int total = 0;
-        foreach (var layer in layers) total += layer.GetParameters().Length;
-
-        var flat = new Vector<T>(total);
-        int k = 0;
-        foreach (var layer in layers)
-        {
-            var p = layer.GetParameters();
-            for (int i = 0; i < p.Length; i++) flat[k++] = p[i];
-        }
-        return flat;
-    }
-
-    /// <summary>Distributes a flat slice back across a boundary stack, in the same order.</summary>
-    private static void SetStackParameters(DenseLayer<T>[] layers, Vector<T> source, ref int offset)
-    {
-        foreach (var layer in layers)
-        {
-            int count = layer.GetParameters().Length;
-            var slice = new Vector<T>(count);
-            for (int i = 0; i < count; i++) slice[i] = source[offset++];
-            layer.SetParameters(slice);
-        }
-    }
-
-    /// <inheritdoc/>
-    /// <remarks>
-    /// Includes the boundary FFNNs' tensors as well as this layer's own, because the base
-    /// implementation does not recurse into registered sub-layers.
-    /// </remarks>
-    public override IReadOnlyList<Tensor<T>> GetTrainableParameters()
-    {
-        var result = new List<Tensor<T>>();
-        foreach (var layer in _startFfnn) result.AddRange(layer.GetTrainableParameters());
-        foreach (var layer in _endFfnn) result.AddRange(layer.GetTrainableParameters());
-        result.Add(_bilinear);
-        result.Add(_additive);
-        result.Add(_bias);
-        return result;
-    }
-
-    /// <inheritdoc/>
-    public override void SetTrainableParameters(IReadOnlyList<Tensor<T>> parameters)
-    {
-        int startCount = 0, endCount = 0;
-        foreach (var layer in _startFfnn) startCount += layer.GetTrainableParameters().Count;
-        foreach (var layer in _endFfnn) endCount += layer.GetTrainableParameters().Count;
-        int expected = startCount + endCount + 3;
-
-        if (parameters.Count != expected)
-            throw new ArgumentException($"Expected {expected} trainable tensors, got {parameters.Count}.", nameof(parameters));
-
-        int cursor = 0;
-        foreach (var layer in _startFfnn)
-        {
-            int n = layer.GetTrainableParameters().Count;
-            layer.SetTrainableParameters(parameters.Skip(cursor).Take(n).ToList());
-            cursor += n;
-        }
-        foreach (var layer in _endFfnn)
-        {
-            int n = layer.GetTrainableParameters().Count;
-            layer.SetTrainableParameters(parameters.Skip(cursor).Take(n).ToList());
-            cursor += n;
-        }
-
-        int at = cursor;
-        _bilinear = parameters[at];
-        _additive = parameters[at + 1];
-        _bias = parameters[at + 2];
-    }
+    // The boundary FFNNs' tensors used to be listed as this layer's own, on the stated grounds that
+    // "the base implementation does not recurse into registered sub-layers". That is true of the
+    // base GetTrainableParameters and false of the walk ParameterCount, GetParameters and
+    // SetParameters are built from, which appends every registered sub-layer no declaration already
+    // covers and detects duplicates by LAYER reference — so it could not tell that the children's
+    // tensors had already arrived through this list. All eight were counted twice.
+    //
+    // The composed order differs from the old one: that walk partitions by role, so this layer's own
+    // three tensors now precede the children instead of following them. Nothing depended on the old
+    // order, because the doubled count meant no previously written checkpoint of this layer was
+    // correct to begin with.
+    //
+    // StackParameters and SetStackParameters went with them: both were already unreachable, left
+    // behind by an earlier GetParameters/SetParameters override that no longer exists.
 
     /// <inheritdoc/>
     /// <remarks>
diff --git a/src/NeuralNetworks/Layers/BidirectionalLayer.cs b/src/NeuralNetworks/Layers/BidirectionalLayer.cs
index 546972294d..4a681d5990 100644
--- a/src/NeuralNetworks/Layers/BidirectionalLayer.cs
+++ b/src/NeuralNetworks/Layers/BidirectionalLayer.cs
@@ -124,8 +124,11 @@ public partial class BidirectionalLayer<T> : LayerBase<T>, IShapeContract
     private readonly LayerBase<T> _backwardLayer;
     private readonly bool _mergeMode;
 
+    [Scratch]
     private Tensor<T>? _lastInput;
+    [Scratch]
     private Tensor<T>? _lastForwardOutput;
+    [Scratch]
     private Tensor<T>? _lastBackwardOutput;
 
     /// <summary>
@@ -171,11 +174,18 @@ public override void ClearGradients()
         _forwardLayer.SupportsGpuTraining && _backwardLayer.SupportsGpuTraining;
 
     #region GPU Training Fields
+    [ExternalState]
     private Tensor<T>? _gpuLastInput;
+    [ExternalState]
     private Tensor<T>? _gpuLastForwardOutput;
+    [ExternalState]
     private Tensor<T>? _gpuLastBackwardOutput;
     #endregion
 
+    /// <summary>Construction state: the 'innerLayer' the layer was built with.</summary>
+    [ParameterAlias(nameof(_forwardLayer))]
+    private readonly AiDotNet.NeuralNetworks.Layers.LayerBase<T> _innerLayer;
+
     /// <summary>
     /// Initializes a new instance of the <see cref="BidirectionalLayer{T}"/> class with the specified inner layer
     /// and a ReLU activation function.
@@ -207,6 +217,7 @@ public BidirectionalLayer(
         IEngine? engine = null)
         : base(innerLayer.GetInputShape(), CalculateOutputShape(innerLayer.GetOutputShape(), mergeMode), activationFunction ?? new ReLUActivation<T>())
     {
+        _innerLayer = innerLayer;
         _forwardLayer = innerLayer;
         _backwardLayer = innerLayer.Clone();
         _mergeMode = mergeMode;
@@ -260,6 +271,7 @@ public BidirectionalLayer(
         IEngine? engine = null)
         : base(innerLayer.GetInputShape(), CalculateOutputShape(innerLayer.GetOutputShape(), mergeMode), vectorActivationFunction ?? new IdentityActivation<T>())
     {
+        _innerLayer = innerLayer;
         _forwardLayer = innerLayer;
         _backwardLayer = innerLayer.Clone();
         _mergeMode = mergeMode;
@@ -657,70 +669,6 @@ private Tensor<T> MergeOutputs(Tensor<T> forward, Tensor<T> backward)
         }
     }
 
-    /// <summary>
-    /// Sets the trainable parameters for both the forward and backward layers.
-    /// </summary>
-    /// <param name="parameters">A vector containing all parameters to set.</param>
-    /// <exception cref="ArgumentException">Thrown when the parameters vector has incorrect length.</exception>
-    /// <remarks>
-    /// <para>
-    /// This method sets the trainable parameters for both the forward and backward inner layers from a single vector.
-    /// It extracts the appropriate portions of the input vector for each inner layer. This is useful for loading
-    /// saved model weights or for implementing optimization algorithms that operate on all parameters at once.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method updates all the learnable values in both forward and backward layers.
-    /// 
-    /// When setting parameters:
-    /// - The input must be a vector with the correct length
-    /// - The first part of the vector is used for the forward layer
-    /// - The second part of the vector is used for the backward layer
-    /// 
-    /// This is useful for:
-    /// - Loading a previously saved model
-    /// - Transferring parameters from another model
-    /// - Testing different parameter values
-    /// 
-    /// An error is thrown if the input vector doesn't have the expected number of parameters.
-    /// </para>
-    /// </remarks>
-    public override void Serialize(BinaryWriter writer)
-    {
-        // Persist the inner forward-layer's resolved input shape so
-        // Deserialize can cascade ResolveFromShape to both wrapped
-        // layers. The wrapper itself doesn't track its own input shape
-        // (no OnFirstForward override), so we read it from the inner
-        // layer that DOES track it (post-Forward).
-        var fwdInputShape = _forwardLayer.GetInputShape();
-        int rank = fwdInputShape?.Length ?? 0;
-        bool hasValid = rank > 0 && fwdInputShape != null
-            && System.Array.TrueForAll(fwdInputShape, d => d > 0);
-        writer.Write(hasValid);
-        if (hasValid)
-        {
-            writer.Write(rank);
-            for (int i = 0; i < rank; i++) writer.Write(fwdInputShape![i]);
-        }
-        base.Serialize(writer);
-    }
-
-    public override void Deserialize(BinaryReader reader)
-    {
-        bool hasValid = reader.ReadBoolean();
-        if (hasValid)
-        {
-            int rank = reader.ReadInt32();
-            var savedInput = new int[rank];
-            for (int i = 0; i < rank; i++) savedInput[i] = reader.ReadInt32();
-            // Cascade input shape directly to the wrapped layers.
-            // BidirectionalLayer doesn't override OnFirstForward, so its
-            // own ResolveFromShape is a no-op for inner-layer state; we
-            // must call inner ResolveFromShape explicitly.
-            if (!_forwardLayer.IsShapeResolved) _forwardLayer.ResolveFromShape(savedInput);
-            if (!_backwardLayer.IsShapeResolved) _backwardLayer.ResolveFromShape(savedInput);
-        }
-        base.Deserialize(reader);
-    }
-
     /// <summary>
     /// Resets the internal state of the bidirectional layer and its inner layers.
     /// </summary>
diff --git a/src/NeuralNetworks/Layers/BottleneckBlock.cs b/src/NeuralNetworks/Layers/BottleneckBlock.cs
index ea8d191f2c..4eefb854b1 100644
--- a/src/NeuralNetworks/Layers/BottleneckBlock.cs
+++ b/src/NeuralNetworks/Layers/BottleneckBlock.cs
@@ -139,21 +139,35 @@ public partial class BottleneckBlock<T> : LayerBase<T>, ILayerSerializationExtra
     private int _inputWidth;
     private readonly bool _zeroInitResidual;
 
+    [Scratch]
     private Tensor<T>? _lastInput;
+    [Scratch]
     private Tensor<T>? _lastConv1Output;
+    [Scratch]
     private Tensor<T>? _lastBn1Output;
+    [Scratch]
     private Tensor<T>? _lastRelu1Output;
+    [Scratch]
     private Tensor<T>? _lastConv2Output;
+    [Scratch]
     private Tensor<T>? _lastBn2Output;
+    [Scratch]
     private Tensor<T>? _lastRelu2Output;
+    [Scratch]
     private Tensor<T>? _lastConv3Output;
+    [Scratch]
     private Tensor<T>? _lastBn3Output;
+    [Scratch]
     private Tensor<T>? _lastIdentity;
+    [Scratch]
     private Tensor<T>? _lastPreActivation;
 
     // GPU cached tensors for backward pass
+    [ExternalState]
     private Tensor<T>? _gpuBn1Out;
+    [ExternalState]
     private Tensor<T>? _gpuBn2Out;
+    [ExternalState]
     private Tensor<T>? _gpuPreActivation;
 
     public override bool SupportsTraining => true;
@@ -517,6 +531,7 @@ public override void ClearGradients()
         _downsampleConv?.ClearGradients(); _downsampleBn?.ClearGradients();
     }
 
+    [Scratch]
     private Vector<T>? _pendingParameters;
 
     private void ApplyParameters(Vector<T> parameters)
@@ -578,6 +593,7 @@ void ILayerSerializationExtras<T>.SetExtraParameters(Vector<T> extraParameters)
         ApplyExtraParametersUnsafe(extraParameters);
     }
 
+    [Scratch]
     private Vector<T>? _pendingExtraParameters;
 
     private void ApplyExtraParametersUnsafe(Vector<T> extraParameters)
diff --git a/src/NeuralNetworks/Layers/BranchformerBlock.cs b/src/NeuralNetworks/Layers/BranchformerBlock.cs
index f920760584..f1279fb9ab 100644
--- a/src/NeuralNetworks/Layers/BranchformerBlock.cs
+++ b/src/NeuralNetworks/Layers/BranchformerBlock.cs
@@ -57,15 +57,26 @@ public partial class BranchformerBlock<T> : LayerBase<T>, IShapeContract
     private readonly int _cgmlpHiddenDim;
     private readonly int _kernelSize;
 
+    // Both branches read the block width; inside the cgMLP the CSGU splits the expanded width in
+    // half, so everything after it reads half; the merge reads the concatenation of the two
+    // branches. A literal 1 stands in for batch and time, which no child's parameters depend on.
+    [SubLayerInput("1, 1, _modelDim")]
     private readonly MultiHeadAttentionLayer<T> _attention;
+    [SubLayerInput("1, 1, _modelDim")]
     private readonly LayerNormalizationLayer<T> _attentionNorm;
 
+    [SubLayerInput("1, 1, _modelDim")]
     private readonly LayerNormalizationLayer<T> _cgmlpNorm;
+    [SubLayerInput("1, 1, _modelDim")]
     private readonly DenseLayer<T> _cgmlpExpand;
+    [SubLayerInput("1, 1, _cgmlpHiddenDim / 2")]
     private readonly LayerNormalizationLayer<T> _csguNorm;
+    [SubLayerInput("1, _kernelSize, _cgmlpHiddenDim / 2")]
     private readonly DepthwiseConv1DLayer<T> _csguConv;
+    [SubLayerInput("1, 1, _cgmlpHiddenDim / 2")]
     private readonly DenseLayer<T> _cgmlpProject;
 
+    [SubLayerInput("1, 1, _modelDim * 2")]
     private readonly DenseLayer<T> _merge;
 
     /// <inheritdoc/>
@@ -215,34 +226,13 @@ private void ResolveChildShapes()
         _csguNorm, _csguConv, _cgmlpProject, _merge
     };
 
-    /// <inheritdoc/>
-    /// <remarks>
-    /// Enumerates the children explicitly, since <c>LayerBase</c> does not recurse into
-    /// registered sub-layers.
-    /// </remarks>
-    public override IReadOnlyList<Tensor<T>> GetTrainableParameters()
-    {
-        var result = new List<Tensor<T>>();
-        foreach (var c in Children) result.AddRange(c.GetTrainableParameters());
-        return result;
-    }
-
-    /// <inheritdoc/>
-    public override void SetTrainableParameters(IReadOnlyList<Tensor<T>> parameters)
-    {
-        var children = Children;
-        var counts = children.Select(c => c.GetTrainableParameters().Count).ToArray();
-
-        if (parameters.Count != counts.Sum())
-            throw new ArgumentException($"Expected {counts.Sum()} trainable tensors, got {parameters.Count}.", nameof(parameters));
-
-        int at = 0;
-        for (int c = 0; c < children.Length; c++)
-        {
-            children[c].SetTrainableParameters(parameters.Skip(at).Take(counts[c]).ToList());
-            at += counts[c];
-        }
-    }
+    // The eight children's tensors used to be enumerated here as this block's own, "since LayerBase
+    // does not recurse into registered sub-layers". That holds for the base GetTrainableParameters,
+    // which returns only this layer's own registrations, and not for the walk ParameterCount,
+    // GetParameters and SetParameters are built from: it appends every registered sub-layer that no
+    // declaration already covers, and its duplicate check compares LAYER references, so a child's
+    // tensors arriving through the parent's own list are invisible to it. Nineteen tensors — the
+    // whole block — were counted twice.
 
     /// <inheritdoc/>
     internal override Dictionary<string, string> GetMetadata()
diff --git a/src/NeuralNetworks/Layers/CapsuleLayer.cs b/src/NeuralNetworks/Layers/CapsuleLayer.cs
index 495a6af6a8..3afa8ac7ac 100644
--- a/src/NeuralNetworks/Layers/CapsuleLayer.cs
+++ b/src/NeuralNetworks/Layers/CapsuleLayer.cs
@@ -155,15 +155,20 @@ public partial class CapsuleLayer<T> : LayerBase<T>, IAuxiliaryLossLayer<T>, ISh
 
     private Tensor<T> _bias;
     private Tensor<T>? _transformationMatrixGradient;
+    [Scratch]
     private Tensor<T>? _biasGradient;
+    [Scratch]
     private Tensor<T>? _lastInput;
 
     /// <summary>
     /// Stores the original input shape for any-rank tensor support.
     /// </summary>
     private int[]? _originalInputShape;
+    [Scratch]
     private Tensor<T>? _lastOutput;
+    [Scratch]
     private Tensor<T>? _lastPreSquash;
+    [Scratch]
     private Tensor<T>? _lastCouplingCoefficients;
 
     public override bool SupportsTraining => true;
@@ -816,38 +821,6 @@ public override Vector<T> GetParameterGradients()
         return Vector<T>.Concatenate(matGrad, biasGrad);
     }
 
-    public override void Serialize(BinaryWriter writer)
-    {
-        // Persist resolved input capsule structure so Deserialize can
-        // re-resolve the 4-D transformation matrix shape. The matrix
-        // layout [inputCapsules, inputDimension, _numCapsules, _capsuleDimension]
-        // can't be uniquely inferred from param count alone (multiple
-        // (inputCapsules, inputDimension) pairs satisfy any total).
-        var inputShape = GetInputShape();
-        bool hasShape = inputShape != null && inputShape.Length >= 2
-            && System.Array.TrueForAll(inputShape, d => d > 0);
-        writer.Write(hasShape);
-        if (hasShape)
-        {
-            writer.Write(inputShape!.Length);
-            for (int i = 0; i < inputShape.Length; i++) writer.Write(inputShape[i]);
-        }
-        base.Serialize(writer);
-    }
-
-    public override void Deserialize(BinaryReader reader)
-    {
-        bool hasShape = reader.ReadBoolean();
-        if (hasShape)
-        {
-            int rank = reader.ReadInt32();
-            var savedInput = new int[rank];
-            for (int i = 0; i < rank; i++) savedInput[i] = reader.ReadInt32();
-            if (!IsShapeResolved) ResolveFromShape(savedInput);
-        }
-        base.Deserialize(reader);
-    }
-
     /// <summary>
     /// Resets the internal state of the capsule layer.
     /// </summary>
diff --git a/src/NeuralNetworks/Layers/CifAlignmentLayer.cs b/src/NeuralNetworks/Layers/CifAlignmentLayer.cs
index a3f6666890..5fa14fa316 100644
--- a/src/NeuralNetworks/Layers/CifAlignmentLayer.cs
+++ b/src/NeuralNetworks/Layers/CifAlignmentLayer.cs
@@ -78,6 +78,22 @@ public partial class CifAlignmentLayer<T> : LayerBase<T>, IShapeContract
     private readonly int _encoderDim;
     private readonly T _threshold;
     private readonly T _tailThreshold;
+    /// <summary>
+    /// The alpha predictor, declaring the width it is fed so a rebuilt layer can size it.
+    /// </summary>
+    /// <remarks>
+    /// DenseLayer is lazy: it allocates on first Forward, so a CifAlignmentLayer rebuilt from saved
+    /// construction state held a predictor with no weights, answered ParameterCount 0 instead of
+    /// <c>_encoderDim + 1</c>, and let SetParameters discard every trained value in it. The generic
+    /// chain walk cannot recover that here -- this layer's own input shape is [-1, -1, encoderDim],
+    /// and a walk seeded from a dynamic axis has nothing to size a child with.
+    /// <para>
+    /// The width is <c>_encoderDim</c> because Forward passes its raw input straight to the
+    /// predictor. (The comment on the constructor describes the paper's 3 x encoderDim context
+    /// window; the implementation collapses it, so the DECLARED width follows the code.)
+    /// </para>
+    /// </remarks>
+    [SubLayerInput("_encoderDim")]
     private readonly DenseLayer<T> _alphaPredictor;
 
     /// <summary>
@@ -389,27 +405,19 @@ private static Tensor<T> BuildAlphaWindow(Tensor<T> input, int B, int S, int D)
         return windowed;
     }
 
-    /// <inheritdoc/>
-    /// <remarks>
-    /// Delegates to the alpha predictor. The base implementation returns only tensors registered
-    /// directly on THIS layer and does not recurse into children, so without this override a
-    /// composite layer reports an empty trainable set: <c>GetParameters()</c> returned 49
-    /// elements while <c>GetTrainableParameters()</c> returned none. That mismatch is invisible
-    /// while <see cref="SupportsTraining"/> is false, but once the layer trains it desynchronizes
-    /// the flat parameter vector from the tensor set the tape and <c>ParameterBuffer</c> track,
-    /// which surfaced as "Parameter[0] is NaN after training" in every CIF consumer.
-    /// </remarks>
-    public override IReadOnlyList<Tensor<T>> GetTrainableParameters()
-        => _alphaPredictor.GetTrainableParameters();
-
-    /// <inheritdoc/>
-    /// <remarks>
-    /// Forwards buffer-backed views straight through to the alpha predictor so the tensors used
-    /// during <see cref="Forward"/> are the same references the ParameterBuffer holds — the
-    /// tape's reference-identity alignment check requires that.
-    /// </remarks>
-    public override void SetTrainableParameters(IReadOnlyList<Tensor<T>> parameters)
-        => _alphaPredictor.SetTrainableParameters(parameters);
+    // GetTrainableParameters / SetTrainableParameters are GENERATED, not written here.
+    //
+    // They used to be hand-written overrides delegating to _alphaPredictor, which fixed the
+    // recursion problem they describe and created a worse one: TrainableParameterGenerator skips
+    // any layer that declares BOTH, so this class produced no generated file at all -- and with it
+    // no DeclaredSubLayerShapes. The [SubLayerInput("_encoderDim")] declaration on _alphaPredictor
+    // was therefore inert, the rebuilt predictor was never sized, and the layer answered
+    // ParameterCount 0 against a trained 66. The override that made the layer work in training was
+    // the same one that stopped it round-tripping.
+    //
+    // The base recursion those remarks were written against now exists: the generated pair folds
+    // GetSubLayers(), so the alpha predictor's tensors are reached without anyone delegating by
+    // hand, and the same declaration sizes it on rebuild.
 
     /// <inheritdoc/>
     public override Vector<T> GetParameterGradients()
diff --git a/src/NeuralNetworks/Layers/ClozeAttentionLayer.cs b/src/NeuralNetworks/Layers/ClozeAttentionLayer.cs
index 0ccf422314..d7d9bd78ff 100644
--- a/src/NeuralNetworks/Layers/ClozeAttentionLayer.cs
+++ b/src/NeuralNetworks/Layers/ClozeAttentionLayer.cs
@@ -50,9 +50,19 @@ public partial class ClozeAttentionLayer<T> : LayerBase<T>, IShapeContract
 {
     private readonly int _modelDim;
 
+    // All four projections read this layer's own input, so their width is _modelDim and is known
+    // from construction. Declaring it is what lets ParameterCount see them: a lazily-built child
+    // whose shape is undeclared stays ShapeDeferred and contributes NOTHING to the count, and then
+    // materializes during GetParameters and contributes its full length -- so the two surfaces
+    // disagree by exactly the children's size. ABINet, which holds one of these, reported 195744
+    // against 208224, and the difference was 3 x 4160, three of these projections.
+    [SubLayerInput("_modelDim")]
     private readonly DenseLayer<T> _query;
+    [SubLayerInput("_modelDim")]
     private readonly DenseLayer<T> _key;
+    [SubLayerInput("_modelDim")]
     private readonly DenseLayer<T> _value;
+    [SubLayerInput("_modelDim")]
     private readonly DenseLayer<T> _output;
 
     /// <inheritdoc/>
@@ -124,50 +134,21 @@ protected override Tensor<T> ForwardTraced(Tensor<T> input)
         return unbatched ? Engine.Reshape(result, [S, D]) : result;
     }
 
-    /// <summary>
-    /// Materializes the lazily-allocated Q/K/V/output projections from the known model width,
-    /// without executing them. Guarded by <c>IsShapeResolved</c>.
-    /// </summary>
-    private void ResolveChildShapes()
-    {
-        if (!_query.IsShapeResolved) _query.ResolveFromShape(new[] { 1, 1, _modelDim });
-        if (!_key.IsShapeResolved) _key.ResolveFromShape(new[] { 1, 1, _modelDim });
-        if (!_value.IsShapeResolved) _value.ResolveFromShape(new[] { 1, 1, _modelDim });
-        if (!_output.IsShapeResolved) _output.ResolveFromShape(new[] { 1, 1, _modelDim });
-    }
-
-    /// <inheritdoc/>
-    /// <remarks>
-    /// Explicitly includes the projections' tensors: <c>LayerBase</c> does not recurse into
-    /// registered sub-layers, and a composite that omits them reports an empty trainable set
-    /// while still advertising a parameter count, which corrupts training silently.
-    /// </remarks>
-    public override IReadOnlyList<Tensor<T>> GetTrainableParameters()
-    {
-        var result = new List<Tensor<T>>();
-        result.AddRange(_query.GetTrainableParameters());
-        result.AddRange(_key.GetTrainableParameters());
-        result.AddRange(_value.GetTrainableParameters());
-        result.AddRange(_output.GetTrainableParameters());
-        return result;
-    }
-
-    /// <inheritdoc/>
-    public override void SetTrainableParameters(IReadOnlyList<Tensor<T>> parameters)
-    {
-        var targets = new[] { _query, _key, _value, _output };
-        var counts = targets.Select(t => t.GetTrainableParameters().Count).ToArray();
-
-        if (parameters.Count != counts.Sum())
-            throw new ArgumentException($"Expected {counts.Sum()} trainable tensors, got {parameters.Count}.", nameof(parameters));
-
-        int at = 0;
-        for (int t = 0; t < targets.Length; t++)
-        {
-            targets[t].SetTrainableParameters(parameters.Skip(at).Take(counts[t]).ToList());
-            at += counts[t];
-        }
-    }
+    // ResolveChildShapes lived here: it read _modelDim and resolved the four projections without
+    // executing them, which is exactly what the count needs -- and nothing ever called it. The
+    // [SubLayerInput("_modelDim")] declarations above state the same width to the generator, which
+    // emits DeclaredSubLayerShapes and puts it on the path the base already walks.
+
+    // The four projections' tensors used to be listed here as this layer's own, on the stated
+    // grounds that "LayerBase does not recurse into registered sub-layers". That is true of the base
+    // GetTrainableParameters, which returns only this layer's own registrations, and false of the
+    // walk ParameterCount, GetParameters and SetParameters are built from: it appends every
+    // registered sub-layer that no declaration already covers, and its duplicate check compares
+    // LAYER references, so it cannot tell that a child's tensors already arrived through the
+    // parent's own list. Listing them here entered all eight TWICE. The failure the remark feared --
+    // an empty trainable set beside a non-zero count -- is real, but it is what happens to a
+    // composite that registers no sub-layer at all; these four are registered, so the base reaches
+    // them.
 
     /// <inheritdoc/>
     internal override Dictionary<string, string> GetMetadata()
diff --git a/src/NeuralNetworks/Layers/CohereDecoderBlock.cs b/src/NeuralNetworks/Layers/CohereDecoderBlock.cs
index bd8b2cf985..64854f9121 100644
--- a/src/NeuralNetworks/Layers/CohereDecoderBlock.cs
+++ b/src/NeuralNetworks/Layers/CohereDecoderBlock.cs
@@ -1,4 +1,4 @@
-using System.Collections.Generic;
+using System.Collections.Generic;
 using AiDotNet.ActivationFunctions;
 using AiDotNet.Attributes;
 using AiDotNet.Interfaces;
@@ -7,7 +7,7 @@ namespace AiDotNet.NeuralNetworks.Layers;
 
 /// <summary>
 /// Cohere (Command-R) decoder block with a <em>parallel</em> residual: a single LayerNorm feeds both the
-/// attention and the gated-SwiGLU FFN, whose outputs are added together to the residual —
+/// attention and the gated-SwiGLU FFN, whose outputs are added together to the residual —
 /// <c>x = x + Attn(norm(x)) + FFN(norm(x))</c>.
 /// </summary>
 /// <typeparam name="T">The numeric type used for calculations.</typeparam>
@@ -17,7 +17,7 @@ namespace AiDotNet.NeuralNetworks.Layers;
 /// </remarks>
 [LayerCategory(LayerCategory.Attention)]
 [LayerTask(LayerTask.SequenceModeling)]
-[LayerProperty(IsTrainable = false, HasTrainingMode = false, TestInputShape = "1, 4, 8", TestConstructorArgs = "")]
+[LayerProperty(IsTrainable = false, HasTrainingMode = false, TestInputShape = "1, 4, 8", TestConstructorArgs = "8, 16, new AiDotNet.NeuralNetworks.Layers.MultiHeadAttentionLayer<double>(2, 4)")]
 // Shape-preserving by CONSTRUCTION, not by coincidence. The last statement of ForwardTraced is
 // "Engine.TensorAdd(Engine.TensorAdd(input, attnOut), ffnOut)" -- a residual add against the untouched
 // input -- and the FFN branch is explicitly restored to the input's shape one line earlier
@@ -36,10 +36,18 @@ namespace AiDotNet.NeuralNetworks.Layers;
 [AutoParameters]
 public partial class CohereDecoderBlock<T> : LayerBase<T>, IShapeContract
 {
+    // Every child reads the block input; only the down-projection reads the expanded width.
+    // Chained sizing walked registration order instead and built the second projection from
+    // the first's output, so a restore met a differently shaped layer than the checkpoint.
+    [SubLayerInput("_hiddenSize")]
     private readonly LayerNormalizationLayer<T> _norm;
+    [SubLayerInput("1, _hiddenSize")]
     private readonly LayerBase<T> _attention;
+    [SubLayerInput("_hiddenSize")]
     private readonly DenseLayer<T> _ffnGate;
+    [SubLayerInput("_hiddenSize")]
     private readonly DenseLayer<T> _ffnUp;
+    [SubLayerInput("_ffnDim")]
     private readonly DenseLayer<T> _ffnDown;
     private readonly int _hiddenSize;
 
@@ -63,6 +71,12 @@ public partial class CohereDecoderBlock<T> : LayerBase<T>, IShapeContract
     /// <summary>The model (input/output) feature dimension.</summary>
     public int HiddenSize => _hiddenSize;
 
+    /// <summary>Construction state: the 'ffnDim' the layer was built with.</summary>
+    private readonly int _ffnDim;
+
+    /// <summary>Construction state: the 'layerNormEpsilon' the layer was built with.</summary>
+    private readonly double _layerNormEpsilon;
+
     /// <summary>Creates a Cohere parallel-residual decoder block.</summary>
     /// <param name="hiddenSize">Input/output feature dimension.</param>
     /// <param name="ffnDim">FFN inner dimension.</param>
@@ -71,6 +85,8 @@ public partial class CohereDecoderBlock<T> : LayerBase<T>, IShapeContract
     public CohereDecoderBlock(int hiddenSize, int ffnDim, LayerBase<T> attention, double layerNormEpsilon = 1e-5)
         : base(new[] { -1, hiddenSize }, new[] { -1, hiddenSize })
     {
+        _layerNormEpsilon = layerNormEpsilon;
+        _ffnDim = ffnDim;
         Guard.NotNull(attention);
         _hiddenSize = hiddenSize;
         _attention = attention;
diff --git a/src/NeuralNetworks/Layers/ConcatenateLayer.cs b/src/NeuralNetworks/Layers/ConcatenateLayer.cs
index 721d2289e3..d1187c87e4 100644
--- a/src/NeuralNetworks/Layers/ConcatenateLayer.cs
+++ b/src/NeuralNetworks/Layers/ConcatenateLayer.cs
@@ -130,9 +130,11 @@ public partial class ConcatenateLayer<T> : LayerBase<T>, IMultiPortShapeContract
 
     private readonly int _axis;
     private Tensor<T>[]? _lastInputs;
+    [Scratch]
     private Tensor<T>? _lastOutput;
 
     // GPU-resident cached tensors for GPU training pipeline
+    [Scratch]
     private Tensor<T>? _lastOutputGpu;
     private int[]? _lastInputSizesGpu;
 
diff --git a/src/NeuralNetworks/Layers/ConditionalRandomFieldLayer.cs b/src/NeuralNetworks/Layers/ConditionalRandomFieldLayer.cs
index dd3a775749..95917cd3ca 100644
--- a/src/NeuralNetworks/Layers/ConditionalRandomFieldLayer.cs
+++ b/src/NeuralNetworks/Layers/ConditionalRandomFieldLayer.cs
@@ -76,16 +76,21 @@ public partial class ConditionalRandomFieldLayer<T> : LayerBase<T>, IShapeContra
 
     private Tensor<T> _endScores;
 
+    [Scratch]
     private Tensor<T>? _lastInput;
 
     /// <summary>
     /// Stores the original input shape for any-rank tensor support.
     /// </summary>
     private int[]? _originalInputShape;
+    [Scratch]
     private Tensor<T>? _lastOutput;
 
+    [Scratch]
     private Tensor<T>? _transitionMatrixGradient;
+    [Scratch]
     private Tensor<T>? _startScoresGradient;
+    [Scratch]
     private Tensor<T>? _endScoresGradient;
 
     private readonly int _numClasses;
diff --git a/src/NeuralNetworks/Layers/Conv1DLayer.cs b/src/NeuralNetworks/Layers/Conv1DLayer.cs
index 6c0380dee2..3c6b1308ae 100644
--- a/src/NeuralNetworks/Layers/Conv1DLayer.cs
+++ b/src/NeuralNetworks/Layers/Conv1DLayer.cs
@@ -305,6 +305,7 @@ protected override Tensor<T> ForwardTraced(Tensor<T> input)
     }
 
     /// <summary>Parameters handed to <see cref="SetParameters"/> before the shape was known.</summary>
+    [Scratch]
     private Vector<T>? _pendingParameters;
 
     /// <summary>Applies a parameter vector to the already-resolved kernel and bias tensors.</summary>
diff --git a/src/NeuralNetworks/Layers/Conv3DLayer.cs b/src/NeuralNetworks/Layers/Conv3DLayer.cs
index bf515f72ee..49f115cbce 100644
--- a/src/NeuralNetworks/Layers/Conv3DLayer.cs
+++ b/src/NeuralNetworks/Layers/Conv3DLayer.cs
@@ -202,26 +202,31 @@ internal override Dictionary<string, string> GetMetadata()
     /// <summary>
     /// Cached gradient for kernels computed during backward pass.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _kernelsGradient;
 
     /// <summary>
     /// Cached gradient for biases computed during backward pass.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _biasesGradient;
 
     /// <summary>
     /// Cached input from the last forward pass, needed for backward computation.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastInput;
 
     /// <summary>
     /// Cached output from the last forward pass (before activation), needed for backward computation.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastPreActivation;
 
     /// <summary>
     /// Cached output from the last forward pass (after activation).
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastOutput;
 
     /// <summary>
@@ -247,27 +252,39 @@ internal override Dictionary<string, string> GetMetadata()
     #endregion
 
     #region GPU Training Fields
+    [ExternalState]
     private Tensor<T>? _gpuLastInput;
+    [ExternalState]
     private Tensor<T>? _gpuLastOutput;
 
     // GPU weight buffers
+    [ExternalState]
     private Tensor<T>? _gpuKernels;
+    [ExternalState]
     private Tensor<T>? _gpuBiases;
 
     // GPU gradient buffers
+    [ExternalState]
     private Tensor<T>? _gpuKernelsGradient;
+    [ExternalState]
     private Tensor<T>? _gpuBiasesGradient;
 
     // GPU velocity buffers (SGD momentum)
+    [ExternalState]
     private Tensor<T>? _gpuKernelsVelocity;
+    [ExternalState]
     private Tensor<T>? _gpuBiasesVelocity;
 
     // GPU Adam first moment buffers
+    [ExternalState]
     private Tensor<T>? _gpuKernelsM;
+    [ExternalState]
     private Tensor<T>? _gpuBiasesM;
 
     // GPU Adam second moment buffers
+    [ExternalState]
     private Tensor<T>? _gpuKernelsV;
+    [ExternalState]
     private Tensor<T>? _gpuBiasesV;
     #endregion
 
@@ -889,43 +906,6 @@ public override void UpdateParameters(T learningRate)
     /// <returns>The kernel tensor.</returns>
     public Tensor<T> GetFilters() => _kernels;
 
-    /// <summary>
-    /// Creates a deep copy of the layer with the same configuration and parameters.
-    /// </summary>
-    /// <returns>A new instance of the <see cref="Conv3DLayer{T}"/> with identical configuration and parameters.</returns>
-    /// <remarks>
-    /// <para>
-    /// The clone is completely independent from the original layer. Changes to one
-    /// will not affect the other.
-    /// </para>
-    /// </remarks>
-    public override LayerBase<T> Clone()
-    {
-        Conv3DLayer<T> copy;
-
-        if (UsingVectorActivation)
-        {
-            copy = new Conv3DLayer<T>(
-                OutputChannels,
-                KernelSize,
-                Stride,
-                Padding,
-                VectorActivation!);
-        }
-        else
-        {
-            copy = new Conv3DLayer<T>(
-                OutputChannels,
-                KernelSize,
-                Stride,
-                Padding,
-                ScalarActivation);
-        }
-
-        copy.SetParameters(GetParameters());
-        return copy;
-    }
-
     #endregion
 
     #region State Management
@@ -952,78 +932,6 @@ public override void ResetState()
 
     #region Serialization
 
-    /// <summary>
-    /// Serializes the layer to a binary stream.
-    /// </summary>
-    /// <param name="writer">The binary writer to serialize to.</param>
-    public override void Serialize(BinaryWriter writer)
-    {
-        base.Serialize(writer);
-        writer.Write(InputChannels);
-        writer.Write(OutputChannels);
-        writer.Write(KernelSize);
-        writer.Write(Stride);
-        writer.Write(Padding);
-        writer.Write(_inputDepth);
-        writer.Write(_inputHeight);
-        writer.Write(_inputWidth);
-
-        var kernelArray = _kernels.ToArray();
-        for (int i = 0; i < kernelArray.Length; i++)
-        {
-            writer.Write(NumOps.ToDouble(kernelArray[i]));
-        }
-
-        var biasArray = _biases.ToArray();
-        for (int i = 0; i < biasArray.Length; i++)
-        {
-            writer.Write(NumOps.ToDouble(biasArray[i]));
-        }
-    }
-
-    /// <summary>
-    /// Deserializes the layer from a binary stream.
-    /// </summary>
-    /// <param name="reader">The binary reader to deserialize from.</param>
-    public override void Deserialize(BinaryReader reader)
-    {
-        base.Deserialize(reader);
-        InputChannels = reader.ReadInt32();
-        OutputChannels = reader.ReadInt32();
-        KernelSize = reader.ReadInt32();
-        Stride = reader.ReadInt32();
-        Padding = reader.ReadInt32();
-        _inputDepth = reader.ReadInt32();
-        _inputHeight = reader.ReadInt32();
-        _inputWidth = reader.ReadInt32();
-
-        _kernels = new Tensor<T>([OutputChannels, InputChannels, KernelSize, KernelSize, KernelSize]);
-        var kernelArray = new T[_kernels.Length];
-        for (int i = 0; i < kernelArray.Length; i++)
-        {
-            kernelArray[i] = NumOps.FromDouble(reader.ReadDouble());
-        }
-        _kernels = new Tensor<T>(kernelArray, _kernels._shape);
-
-        _biases = new Tensor<T>([OutputChannels]);
-        var biasArray = new T[_biases.Length];
-        for (int i = 0; i < biasArray.Length; i++)
-        {
-            biasArray[i] = NumOps.FromDouble(reader.ReadDouble());
-        }
-        _biases = new Tensor<T>(biasArray, _biases._shape);
-
-        // Re-register the freshly-created tensors as trainable parameters. Deserialize replaces the
-        // field references outright, so without this the registry either stays empty -- a lazily
-        // constructed layer has never registered anything, and GetParameters() then reports zero
-        // parameters and silently discards every restored weight -- or still points at the tensors
-        // from a prior forward, so optimizers and tape training update dead references while Forward
-        // reads the new ones. ConvolutionalLayer does the same for the 2-D case.
-        ClearRegisteredParameters();
-        RegisterTrainableParameter(_kernels, PersistentTensorRole.Weights);
-        RegisterTrainableParameter(_biases, PersistentTensorRole.Biases);
-    }
-
     #endregion
 
     #region JIT Compilation
diff --git a/src/NeuralNetworks/Layers/ConvLSTMLayer.cs b/src/NeuralNetworks/Layers/ConvLSTMLayer.cs
index 58569b686c..b915cea22b 100644
--- a/src/NeuralNetworks/Layers/ConvLSTMLayer.cs
+++ b/src/NeuralNetworks/Layers/ConvLSTMLayer.cs
@@ -137,13 +137,16 @@ public partial class ConvLSTMLayer<T> : LayerBase<T>, IShapeContract
     private Tensor<T> _biasC; // Cell state bias
     private Tensor<T> _biasO; // Output gate bias
 
+    [Scratch]
     private Tensor<T>? _lastInput;
 
     /// <summary>
     /// Stores the original input shape for any-rank tensor support.
     /// </summary>
     private int[]? _originalInputShape;
+    [Scratch]
     private Tensor<T>? _lastHiddenState;
+    [Scratch]
     private Tensor<T>? _lastCellState;
     private Dictionary<string, object> _gradients = new Dictionary<string, object>();
     private readonly Dictionary<string, Tensor<T>> _momentums = new Dictionary<string, Tensor<T>>();
@@ -156,6 +159,7 @@ public partial class ConvLSTMLayer<T> : LayerBase<T>, IShapeContract
     /// <summary>
     /// Cached GPU input for backward pass.
     /// </summary>
+    [ExternalState]
     private Tensor<T>? _gpuInput;
 
     /// <summary>
@@ -212,71 +216,131 @@ public partial class ConvLSTMLayer<T> : LayerBase<T>, IShapeContract
     #region GPU Weight Storage Fields
 
     // GPU weight tensors for GPU-resident training
+    [ExternalState]
     private Tensor<T>? _gpuWeightsFi;
+    [ExternalState]
     private Tensor<T>? _gpuWeightsIi;
+    [ExternalState]
     private Tensor<T>? _gpuWeightsCi;
+    [ExternalState]
     private Tensor<T>? _gpuWeightsOi;
+    [ExternalState]
     private Tensor<T>? _gpuWeightsFh;
+    [ExternalState]
     private Tensor<T>? _gpuWeightsIh;
+    [ExternalState]
     private Tensor<T>? _gpuWeightsCh;
+    [ExternalState]
     private Tensor<T>? _gpuWeightsOh;
+    [ExternalState]
     private Tensor<T>? _gpuBiasF;
+    [ExternalState]
     private Tensor<T>? _gpuBiasI;
+    [ExternalState]
     private Tensor<T>? _gpuBiasC;
+    [ExternalState]
     private Tensor<T>? _gpuBiasO;
 
     // GPU gradient tensors from BackwardGpu
+    [ExternalState]
     private Tensor<T>? _gpuWeightsFiGradient;
+    [ExternalState]
     private Tensor<T>? _gpuWeightsIiGradient;
+    [ExternalState]
     private Tensor<T>? _gpuWeightsCiGradient;
+    [ExternalState]
     private Tensor<T>? _gpuWeightsOiGradient;
+    [ExternalState]
     private Tensor<T>? _gpuWeightsFhGradient;
+    [ExternalState]
     private Tensor<T>? _gpuWeightsIhGradient;
+    [ExternalState]
     private Tensor<T>? _gpuWeightsChGradient;
+    [ExternalState]
     private Tensor<T>? _gpuWeightsOhGradient;
+    [ExternalState]
     private Tensor<T>? _gpuBiasFGradient;
+    [ExternalState]
     private Tensor<T>? _gpuBiasIGradient;
+    [ExternalState]
     private Tensor<T>? _gpuBiasCGradient;
+    [ExternalState]
     private Tensor<T>? _gpuBiasOGradient;
 
     // Optimizer state tensors for SGD/NAG/LARS (velocity)
+    [ExternalState]
     private Tensor<T>? _gpuWeightsFiVelocity;
+    [ExternalState]
     private Tensor<T>? _gpuWeightsIiVelocity;
+    [ExternalState]
     private Tensor<T>? _gpuWeightsCiVelocity;
+    [ExternalState]
     private Tensor<T>? _gpuWeightsOiVelocity;
+    [ExternalState]
     private Tensor<T>? _gpuWeightsFhVelocity;
+    [ExternalState]
     private Tensor<T>? _gpuWeightsIhVelocity;
+    [ExternalState]
     private Tensor<T>? _gpuWeightsChVelocity;
+    [ExternalState]
     private Tensor<T>? _gpuWeightsOhVelocity;
+    [ExternalState]
     private Tensor<T>? _gpuBiasFVelocity;
+    [ExternalState]
     private Tensor<T>? _gpuBiasIVelocity;
+    [ExternalState]
     private Tensor<T>? _gpuBiasCVelocity;
+    [ExternalState]
     private Tensor<T>? _gpuBiasOVelocity;
 
     // Optimizer state tensors for Adam/AdamW/LAMB (M and V)
+    [ExternalState]
     private Tensor<T>? _gpuWeightsFiM;
+    [ExternalState]
     private Tensor<T>? _gpuWeightsFiV;
+    [ExternalState]
     private Tensor<T>? _gpuWeightsIiM;
+    [ExternalState]
     private Tensor<T>? _gpuWeightsIiV;
+    [ExternalState]
     private Tensor<T>? _gpuWeightsCiM;
+    [ExternalState]
     private Tensor<T>? _gpuWeightsCiV;
+    [ExternalState]
     private Tensor<T>? _gpuWeightsOiM;
+    [ExternalState]
     private Tensor<T>? _gpuWeightsOiV;
+    [ExternalState]
     private Tensor<T>? _gpuWeightsFhM;
+    [ExternalState]
     private Tensor<T>? _gpuWeightsFhV;
+    [ExternalState]
     private Tensor<T>? _gpuWeightsIhM;
+    [ExternalState]
     private Tensor<T>? _gpuWeightsIhV;
+    [ExternalState]
     private Tensor<T>? _gpuWeightsChM;
+    [ExternalState]
     private Tensor<T>? _gpuWeightsChV;
+    [ExternalState]
     private Tensor<T>? _gpuWeightsOhM;
+    [ExternalState]
     private Tensor<T>? _gpuWeightsOhV;
+    [ExternalState]
     private Tensor<T>? _gpuBiasFM;
+    [ExternalState]
     private Tensor<T>? _gpuBiasFV;
+    [ExternalState]
     private Tensor<T>? _gpuBiasIM;
+    [ExternalState]
     private Tensor<T>? _gpuBiasIV;
+    [ExternalState]
     private Tensor<T>? _gpuBiasCM;
+    [ExternalState]
     private Tensor<T>? _gpuBiasCV;
+    [ExternalState]
     private Tensor<T>? _gpuBiasOM;
+    [ExternalState]
     private Tensor<T>? _gpuBiasOV;
 
     #endregion
diff --git a/src/NeuralNetworks/Layers/ConvNeXtV2Block.cs b/src/NeuralNetworks/Layers/ConvNeXtV2Block.cs
index bc9f89cf34..ea17394b4b 100644
--- a/src/NeuralNetworks/Layers/ConvNeXtV2Block.cs
+++ b/src/NeuralNetworks/Layers/ConvNeXtV2Block.cs
@@ -52,9 +52,16 @@ public partial class ConvNeXtV2Block<T> : LayerBase<T>, IShapeContract
     private readonly int _intermediateChannels;
     private readonly int _kernelSize;
 
+    // The block's own input shape carries -1 for batch and length, so the chain cannot seed itself
+    // from it at all. A literal length of one kernel is enough to fix every width that matters:
+    // these children's parameters depend on the channel axis, never on sequence length.
+    [SubLayerInput("1, _kernelSize, _channels")]
     private readonly DepthwiseConv1DLayer<T> _depthwise;
+    [SubLayerInput("1, _kernelSize, _channels")]
     private readonly LayerNormalizationLayer<T> _norm;
+    [SubLayerInput("1, _kernelSize, _channels")]
     private readonly DenseLayer<T> _pointwiseExpand;
+    [SubLayerInput("1, _kernelSize, _intermediateChannels")]
     private readonly DenseLayer<T> _pointwiseProject;
 
     /// <summary>GRN scale, one per intermediate channel.</summary>
diff --git a/src/NeuralNetworks/Layers/ConvolutionalLayer.cs b/src/NeuralNetworks/Layers/ConvolutionalLayer.cs
index 165f526bcb..f20302adc3 100644
--- a/src/NeuralNetworks/Layers/ConvolutionalLayer.cs
+++ b/src/NeuralNetworks/Layers/ConvolutionalLayer.cs
@@ -327,6 +327,7 @@ public override Tensor<T> GetBiases()
     /// the first iteration) never touches this cache at all because plan replay
     /// runs traced engine ops directly without invoking <c>layer.Forward()</c>.</para>
     /// </summary>
+    [AiDotNet.Attributes.Scratch]
     private Tensor<T>? _biasReshaped4D;
 
     /// <summary>
@@ -334,6 +335,7 @@ public override Tensor<T> GetBiases()
     /// <see cref="_biasReshaped4D"/> was populated. Optimizers may either rebind the
     /// tensor or update its storage in place, so both signals are required.
     /// </summary>
+    [AiDotNet.Attributes.Scratch]
     private Tensor<T>? _biasReshaped4DSource;
     private int _biasReshaped4DVersion = -1;
 
@@ -353,11 +355,13 @@ public override Tensor<T> GetBiases()
     /// <summary>
     /// Gradient of the kernels computed during backpropagation via autodiff.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _kernelsGradient;
 
     /// <summary>
     /// Gradient of the biases computed during backpropagation via autodiff.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _biasesGradient;
 
     /// <summary>
@@ -431,7 +435,9 @@ public override Tensor<T> GetBiases()
     private Tensor<T> _lastOutput;
 
     // GPU-resident cached tensors for GPU training pipeline
+    [Scratch]
     private Tensor<T>? _lastInputGpu;
+    [Scratch]
     private Tensor<T>? _lastOutputGpu;
     private int[]? _gpuInputShape4D;
 
@@ -794,123 +800,6 @@ public static ConvolutionalLayer<T> Configure(int[] inputShape, int kernelSize,
         }
     }
 
-    /// <summary>
-    /// Saves the layer's configuration and parameters to a binary writer.
-    /// </summary>
-    /// <param name="writer">The binary writer to save to.</param>
-    /// <remarks>
-    /// <para>
-    /// This method saves the layer's configuration (input depth, output depth, kernel size, stride, padding)
-    /// and parameters (kernel weights and biases) to a binary writer. This allows the layer to be saved to
-    /// a file and loaded later.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method saves all the layer's settings and learned patterns to a file.
-    /// 
-    /// When saving a layer:
-    /// - First, it saves the basic configuration (size, stride, etc.)
-    /// - Then it saves all the learned pattern detectors (kernels)
-    /// - Finally, it saves the bias values
-    /// 
-    /// This allows you to:
-    /// - Save a trained model to use later
-    /// - Share your trained model with others
-    /// - Store multiple versions of your model
-    /// 
-    /// Think of it like taking a snapshot of everything the model has learned.
-    /// </para>
-    /// </remarks>
-    public override void Serialize(BinaryWriter writer)
-    {
-        base.Serialize(writer);
-        writer.Write(InputDepth);
-        writer.Write(OutputDepth);
-        writer.Write(KernelSize);
-        writer.Write(Stride);
-        writer.Write(Padding);
-        writer.Write(Groups); // #639: depthwise marker — needed to size the kernel on Deserialize
-
-        // Serialize _kernels — flat span iteration replaces 4-nested indexing loops
-        var kernelSpan = _kernels.Data.Span;
-        for (int i = 0; i < kernelSpan.Length; i++)
-            writer.Write(Convert.ToDouble(kernelSpan[i]));
-
-        // Serialize _biases — flat span iteration
-        var biasSpan = _biases.Data.Span;
-        for (int i = 0; i < biasSpan.Length; i++)
-            writer.Write(Convert.ToDouble(biasSpan[i]));
-    }
-
-    /// <summary>
-    /// Loads the layer's configuration and parameters from a binary reader.
-    /// </summary>
-    /// <param name="reader">The binary reader to load from.</param>
-    /// <remarks>
-    /// <para>
-    /// This method loads the layer's configuration (input depth, output depth, kernel size, stride, padding)
-    /// and parameters (kernel weights and biases) from a binary reader. This allows a previously saved layer
-    /// to be loaded from a file.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method loads a previously saved layer from a file.
-    /// 
-    /// When loading a layer:
-    /// - First, it reads the basic configuration
-    /// - Then it recreates all the pattern detectors (kernels)
-    /// - Finally, it loads the bias values
-    /// 
-    /// This allows you to:
-    /// - Continue using a model you trained earlier
-    /// - Use a model someone else trained
-    /// - Compare different versions of your model
-    /// 
-    /// It's like restoring a snapshot of a trained model exactly as it was.
-    /// </para>
-    /// </remarks>
-    public override void Deserialize(BinaryReader reader)
-    {
-        base.Deserialize(reader);
-        InputDepth = reader.ReadInt32();
-        OutputDepth = reader.ReadInt32();
-        KernelSize = reader.ReadInt32();
-        Stride = reader.ReadInt32();
-        Padding = reader.ReadInt32();
-        Groups = reader.ReadInt32(); // #639
-
-        // Deserialize _kernels — flat span iteration replaces 4-nested indexing loops.
-        // #1643: kernels are long-lived trainable weights; pin them so a Deserialize that
-        // happens to run inside an active TensorArena can't have them recycled by Reset()
-        // (RentPinned degrades to a heap Tensor<T> when no arena is active; the loop below
-        // overwrites every element, so the one-time zero-fill is free).
-        // #639: depthwise collapses the kernel in-channel dim to InputDepth/Groups.
-        _kernels = TensorAllocator.RentPinned<T>([OutputDepth, KernelInChannels, KernelSize, KernelSize]);
-        var kernelSpan = _kernels.Data.Span;
-        for (int i = 0; i < kernelSpan.Length; i++)
-            kernelSpan[i] = NumOps.FromDouble(reader.ReadDouble());
-
-        // Deserialize _biases — flat span iteration
-        _biases = new Tensor<T>([OutputDepth]);
-        var biasSpan = _biases.Data.Span;
-        for (int i = 0; i < biasSpan.Length; i++)
-            biasSpan[i] = NumOps.FromDouble(reader.ReadDouble());
-
-        // Reinitialize _lastInput and _lastOutput
-        _lastInput = new Tensor<T>([OutputDepth, InputDepth, KernelSize, KernelSize]);
-        _lastOutput = new Tensor<T>([OutputDepth, InputDepth, KernelSize, KernelSize]);
-
-        // Re-register the freshly-created tensors as trainable parameters so
-        // optimizers and tape training target these objects (not the stale ones
-        // from a prior EnsureInitialized or constructor call). Without this,
-        // the registered list points at the old tensors while Forward uses the
-        // new ones — gradient updates silently go to dead references.
-        ClearRegisteredParameters();
-        RegisterTrainableParameter(_kernels, PersistentTensorRole.Weights);
-        RegisterTrainableParameter(_biases, PersistentTensorRole.Biases);
-
-        // Mark as initialized so EnsureInitialized() doesn't re-randomize the
-        // just-deserialized weights on the next Forward/GetParameters call.
-        // Also ensures Dispose returns the rented _kernels to TensorAllocator.
-        _isInitialized = true;
-    }
-
     /// <summary>
     /// Calculates the output dimension after applying a convolution operation.
     /// </summary>
@@ -1718,7 +1607,9 @@ private Autodiff.ComputationNode<T> ApplyScalarActivationAutodiff(Autodiff.Compu
         };
     }
 
+    [AiDotNet.Attributes.Buffer]
     private Tensor<T>? _kernelsVelocity;
+    [AiDotNet.Attributes.Buffer]
     private Tensor<T>? _biasesVelocity;
 
     /// <summary>
diff --git a/src/NeuralNetworks/Layers/CroppingLayer.cs b/src/NeuralNetworks/Layers/CroppingLayer.cs
index 22d6318c06..d2bb220a54 100644
--- a/src/NeuralNetworks/Layers/CroppingLayer.cs
+++ b/src/NeuralNetworks/Layers/CroppingLayer.cs
@@ -562,6 +562,7 @@ protected override Tensor<T> ForwardTraced(Tensor<T> input)
     /// <summary>
     /// Stores the last input for use in autodiff backward pass.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastInput;
 
     /// <summary>
diff --git a/src/NeuralNetworks/Layers/CrossAttentionLayer.cs b/src/NeuralNetworks/Layers/CrossAttentionLayer.cs
index 3af43729b7..68b1fd7c67 100644
--- a/src/NeuralNetworks/Layers/CrossAttentionLayer.cs
+++ b/src/NeuralNetworks/Layers/CrossAttentionLayer.cs
@@ -92,16 +92,25 @@ public partial class CrossAttentionLayer<T> : LayerBase<T>, IShapeContract
     private bool _isInitialized;
 
     // Cached values for backward pass
+    [Scratch]
     private Tensor<T>? _lastQuery;
+    [Scratch]
     private Tensor<T>? _lastContext;
+    [Scratch]
     private Tensor<T>? _lastAttentionScores;
+    [Scratch]
     private Tensor<T>? _lastOutput;
 
     // Gradient tensors
+    [Scratch]
     private Tensor<T>? _queryWeightsGradient;
+    [Scratch]
     private Tensor<T>? _keyWeightsGradient;
+    [Scratch]
     private Tensor<T>? _valueWeightsGradient;
+    [Scratch]
     private Tensor<T>? _outputWeightsGradient;
+    [Scratch]
     private Tensor<T>? _outputBiasGradient;
 
     /// <summary>
@@ -110,12 +119,19 @@ public partial class CrossAttentionLayer<T> : LayerBase<T>, IShapeContract
     private int[]? _originalQueryShape;
 
     // GPU cached tensors for backward pass
+    [ExternalState]
     private Tensor<T>? _gpuQuery;
+    [ExternalState]
     private Tensor<T>? _gpuContext;
+    [ExternalState]
     private Tensor<T>? _gpuQ;
+    [ExternalState]
     private Tensor<T>? _gpuK;
+    [ExternalState]
     private Tensor<T>? _gpuV;
+    [ExternalState]
     private Tensor<T>? _gpuAttnOutput;
+    [ExternalState]
     private Tensor<T>? _gpuAttnWeights;
     private int _gpuBatch;
     private int _gpuQueryLen;
diff --git a/src/NeuralNetworks/Layers/DbrxDecoderBlock.cs b/src/NeuralNetworks/Layers/DbrxDecoderBlock.cs
index b33f49cd52..3f4caac219 100644
--- a/src/NeuralNetworks/Layers/DbrxDecoderBlock.cs
+++ b/src/NeuralNetworks/Layers/DbrxDecoderBlock.cs
@@ -1,4 +1,4 @@
-using System.Collections.Generic;
+using System.Collections.Generic;
 using AiDotNet.Attributes;
 using AiDotNet.Interfaces;
 
@@ -12,7 +12,7 @@ namespace AiDotNet.NeuralNetworks.Layers;
 /// <typeparam name="T">The numeric type used for calculations.</typeparam>
 [LayerCategory(LayerCategory.Attention)]
 [LayerTask(LayerTask.SequenceModeling)]
-[LayerProperty(IsTrainable = false, HasTrainingMode = false, TestInputShape = "1, 4, 8", TestConstructorArgs = "")]
+[LayerProperty(IsTrainable = false, HasTrainingMode = false, TestInputShape = "1, 4, 8", TestConstructorArgs = "8, new AiDotNet.NeuralNetworks.Layers.MultiHeadAttentionLayer<double>(2, 4), new AiDotNet.NeuralNetworks.Layers.MoEFeedForwardLayer<double>(8, 16, 2, 1)")]
 // SHAPE-PRESERVING, and structurally so: ForwardTraced is two residual adds,
 // "Engine.TensorAdd(input, attnOut)" then "Engine.TensorAdd(afterAttn, moeOut)". Neither add can even
 // be formed unless the sublayer handed back exactly the shape it was given, so this block cannot
@@ -54,6 +54,9 @@ public partial class DbrxDecoderBlock<T> : LayerBase<T>, IShapeContract
     /// <summary>The model (input/output) feature dimension.</summary>
     public int HiddenSize => _hiddenSize;
 
+    /// <summary>Construction state: the 'layerNormEpsilon' the layer was built with.</summary>
+    private readonly double _layerNormEpsilon;
+
     /// <summary>Creates a DBRX LayerNorm MoE decoder block.</summary>
     /// <param name="hiddenSize">Input/output feature dimension.</param>
     /// <param name="attention">Pre-constructed self-attention sublayer.</param>
@@ -62,6 +65,7 @@ public partial class DbrxDecoderBlock<T> : LayerBase<T>, IShapeContract
     public DbrxDecoderBlock(int hiddenSize, LayerBase<T> attention, MoEFeedForwardLayer<T> moe, double layerNormEpsilon = 1e-5)
         : base(new[] { -1, hiddenSize }, new[] { -1, hiddenSize })
     {
+        _layerNormEpsilon = layerNormEpsilon;
         Guard.NotNull(attention);
         Guard.NotNull(moe);
         _hiddenSize = hiddenSize;
diff --git a/src/NeuralNetworks/Layers/DecoderLayer.cs b/src/NeuralNetworks/Layers/DecoderLayer.cs
index 52eedf932a..a18e96bed7 100644
--- a/src/NeuralNetworks/Layers/DecoderLayer.cs
+++ b/src/NeuralNetworks/Layers/DecoderLayer.cs
@@ -83,19 +83,27 @@ public partial class DecoderLayer<T> : LayerBase<T>, IShapeContract
     /// <summary>
     /// Stores the last input tensor processed by the layer.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastInput;
 
     /// <summary>
     /// Stores the last encoder output tensor used by the layer.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastEncoderOutput;
 
     // GPU cached tensors for backward pass
+    [ExternalState]
     private Tensor<T>? _gpuDecoderInput;
+    [ExternalState]
     private Tensor<T>? _gpuEncoderOutput;
+    [ExternalState]
     private Tensor<T>? _gpuNormalized1;
+    [ExternalState]
     private Tensor<T>? _gpuNormalized2;
+    [ExternalState]
     private Tensor<T>? _gpuResidual1;
+    [ExternalState]
     private Tensor<T>? _gpuResidual2;
 
     /// <summary>
@@ -106,11 +114,13 @@ public partial class DecoderLayer<T> : LayerBase<T>, IShapeContract
     /// <summary>
     /// Stores the gradient with respect to the input from the last backward pass.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastInputGradient;
 
     /// <summary>
     /// Stores the gradient with respect to the encoder output from the last backward pass.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastEncoderOutputGradient;
 
     /// <summary>
@@ -128,65 +138,6 @@ public partial class DecoderLayer<T> : LayerBase<T>, IShapeContract
     /// </summary>
     public override bool SupportsTraining => true;
 
-    public override void Serialize(BinaryWriter writer)
-    {
-        // Refuse to write malformed checkpoints. The lazy ctor leaves
-        // InputSize at -1 until the first forward (or a Deserialize
-        // round-trip) resolves it; serializing before that would emit a
-        // sentinel that Deserialize can't decode and that Set/GetParameters
-        // can't slice. Fail fast at the writer rather than producing a
-        // checkpoint that errors later at load time.
-        if (InputSize <= 0 || _feedForward2 is null)
-        {
-            throw new InvalidOperationException(
-                $"DecoderLayer.Serialize: layer must be shape-resolved before " +
-                $"serialization (InputSize={InputSize}, _feedForward2 " +
-                $"{(_feedForward2 is null ? "null" : "non-null")}). Run a " +
-                $"forward pass first so OnFirstForward materializes _feedForward2 " +
-                $"and resolves InputSize from the input shape.");
-        }
-
-        // Persist resolved InputSize so Deserialize can re-resolve the
-        // lazily-constructed _feedForward2 on the load side.
-        writer.Write(InputSize);
-        base.Serialize(writer);
-    }
-
-    public override void Deserialize(BinaryReader reader)
-    {
-        int savedInputSize = reader.ReadInt32();
-        // Reject malformed checkpoints up front. A Serialize from this
-        // class is now guaranteed to write InputSize > 0 (see the guard
-        // above), but a stream from an older build or a hand-crafted
-        // payload could contain anything; refusing here prevents
-        // ResolveFromShape / base.Deserialize / SetParameters from
-        // mutating layer state on bad input.
-        if (savedInputSize <= 0)
-        {
-            throw new InvalidDataException(
-                $"DecoderLayer.Deserialize: saved InputSize ({savedInputSize}) must be positive. " +
-                $"Stream is malformed or comes from an older build that emitted unresolved " +
-                $"layers. Discard the checkpoint or regenerate it from a shape-resolved layer.");
-        }
-
-        if (!IsShapeResolved)
-        {
-            ResolveFromShape(new[] { savedInputSize });
-        }
-        else if (savedInputSize != InputSize)
-        {
-            // Already-resolved instance with a mismatched persisted input
-            // size — silently loading would assign weights for a different
-            // (inputSize, …) factorization and produce garbage on first
-            // Forward. Fail fast with an actionable message.
-            throw new InvalidDataException(
-                $"DecoderLayer.Deserialize: saved InputSize ({savedInputSize}) does not match " +
-                $"the already-resolved layer's InputSize ({InputSize}). Recreate the layer to " +
-                $"match the saved shape, or load into a fresh (unresolved) instance.");
-        }
-        base.Deserialize(reader);
-    }
-
     /// <summary>
     /// Returns <see cref="_feedForward2"/> if it has been constructed; throws
     /// <see cref="InvalidOperationException"/> with the calling member's name
@@ -231,6 +182,12 @@ public override void ClearGradients()
     /// </summary>
     protected override bool SupportsGpuExecution => true;
 
+    /// <summary>Construction state: the 'attentionSize' the layer was built with.</summary>
+    private readonly int _attentionSize;
+
+    /// <summary>Construction state: the 'feedForwardSize' the layer was built with.</summary>
+    private readonly int _feedForwardSize;
+
     /// <summary>
     /// Initializes a new instance of the DecoderLayer class with scalar activation.
     /// </summary>
@@ -242,6 +199,8 @@ public override void ClearGradients()
     public DecoderLayer(int attentionSize, int feedForwardSize, IActivationFunction<T>? activation = null)
         : base(new[] { -1 }, new[] { -1 }, activation ?? new ReLUActivation<T>())
     {
+        _feedForwardSize = feedForwardSize;
+        _attentionSize = attentionSize;
         _selfAttention = new AttentionLayer<T>(attentionSize, (IVectorActivationFunction<T>?)null);
         _crossAttention = new AttentionLayer<T>(attentionSize, activation);
 
@@ -383,6 +342,8 @@ protected override void OnFirstForward(Tensor<T> input)
     public DecoderLayer(int attentionSize, int feedForwardSize, IVectorActivationFunction<T> activation)
         : base(new[] { -1 }, new[] { -1 }, activation ?? new ReLUActivation<T>())
     {
+        _feedForwardSize = feedForwardSize;
+        _attentionSize = attentionSize;
         _selfAttention = new AttentionLayer<T>(attentionSize, (IVectorActivationFunction<T>?)null);
         _crossAttention = new AttentionLayer<T>(attentionSize, activation);
 
diff --git a/src/NeuralNetworks/Layers/DeconvolutionalLayer.cs b/src/NeuralNetworks/Layers/DeconvolutionalLayer.cs
index 7d52cab18b..215ab19a6d 100644
--- a/src/NeuralNetworks/Layers/DeconvolutionalLayer.cs
+++ b/src/NeuralNetworks/Layers/DeconvolutionalLayer.cs
@@ -117,6 +117,7 @@ public partial class DeconvolutionalLayer<T> : LayerBase<T>, IShapeContract
     /// so you can adjust them if the dish didn't turn out perfectly.
     /// </para>
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _lastInput;
 
     /// <summary>
@@ -137,6 +138,7 @@ public partial class DeconvolutionalLayer<T> : LayerBase<T>, IShapeContract
     /// and adjust its internal values to make better outputs next time.
     /// </para>
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _lastOutput;
 
     /// <summary>
@@ -158,6 +160,7 @@ public partial class DeconvolutionalLayer<T> : LayerBase<T>, IShapeContract
     /// to make the output better next time.
     /// </para>
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _kernelsGradient;
 
     /// <summary>
@@ -179,10 +182,13 @@ public partial class DeconvolutionalLayer<T> : LayerBase<T>, IShapeContract
     /// to make the output better next time.
     /// </para>
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _biasesGradient;
 
     // GPU cached tensors for backward pass
+    [ExternalState]
     private Tensor<T>? _gpuInput;
+    [ExternalState]
     private Tensor<T>? _gpuOutput;
     private int[]? _gpuInputShape4D;
     private bool _gpuAddedBatchDimension;
diff --git a/src/NeuralNetworks/Layers/DeformableConvolutionalLayer.cs b/src/NeuralNetworks/Layers/DeformableConvolutionalLayer.cs
index 202efb1ff5..1741f726c4 100644
--- a/src/NeuralNetworks/Layers/DeformableConvolutionalLayer.cs
+++ b/src/NeuralNetworks/Layers/DeformableConvolutionalLayer.cs
@@ -120,11 +120,17 @@ OutputAxisContract Spatial(TensorAxis a)
     private Tensor<T>? _maskBias;
 
     // Gradients
+    [AiDotNet.Attributes.Scratch]
     private Tensor<T>? _weightGradients;
+    [AiDotNet.Attributes.Scratch]
     private Tensor<T>? _biasGradients;
+    [AiDotNet.Attributes.Scratch]
     private Tensor<T>? _offsetWeightGradients;
+    [AiDotNet.Attributes.Scratch]
     private Tensor<T>? _offsetBiasGradients;
+    [AiDotNet.Attributes.Scratch]
     private Tensor<T>? _maskWeightGradients;
+    [AiDotNet.Attributes.Scratch]
     private Tensor<T>? _maskBiasGradients;
 
     // Pending parameters buffer — holds the flat Vector<T> from a
@@ -135,17 +141,24 @@ OutputAxisContract Spatial(TensorAxis a)
     // then runs with random initial weights instead of the loaded
     // checkpoint. OnFirstForward replays the buffer once weights are
     // allocated, then clears the field.
+    [Scratch]
     private Vector<T>? _pendingParameters;
 
     // Cached values for backward pass
+    [Scratch]
     private Tensor<T>? _lastInput;
+    [Scratch]
     private Tensor<T>? _lastOffsets;
+    [Scratch]
     private Tensor<T>? _lastMask;
 
     // GPU caching for backward pass
+    [ExternalState]
     private Tensor<T>? _gpuInput;
     private int[]? _gpuInputShape;
+    [ExternalState]
     private Tensor<T>? _gpuOffsets;
+    [ExternalState]
     private Tensor<T>? _gpuMask;
 
     #endregion
@@ -153,39 +166,69 @@ OutputAxisContract Spatial(TensorAxis a)
     #region GPU Weight Storage Fields
 
     // Main conv weights - GPU tensors for GPU-resident training
+    [ExternalState]
     private Tensor<T>? _gpuWeights;
+    [ExternalState]
     private Tensor<T>? _gpuBias;
+    [ExternalState]
     private Tensor<T>? _gpuWeightGradient;
+    [ExternalState]
     private Tensor<T>? _gpuBiasGradient;
+    [ExternalState]
     private Tensor<T>? _gpuWeightVelocity;
+    [ExternalState]
     private Tensor<T>? _gpuBiasVelocity;
+    [ExternalState]
     private Tensor<T>? _gpuWeightM;
+    [ExternalState]
     private Tensor<T>? _gpuWeightV;
+    [ExternalState]
     private Tensor<T>? _gpuBiasM;
+    [ExternalState]
     private Tensor<T>? _gpuBiasV;
 
     // Offset weights - GPU tensors
+    [ExternalState]
     private Tensor<T>? _gpuOffsetWeights;
+    [ExternalState]
     private Tensor<T>? _gpuOffsetBias;
+    [ExternalState]
     private Tensor<T>? _gpuOffsetWeightGradient;
+    [ExternalState]
     private Tensor<T>? _gpuOffsetBiasGradient;
+    [ExternalState]
     private Tensor<T>? _gpuOffsetWeightVelocity;
+    [ExternalState]
     private Tensor<T>? _gpuOffsetBiasVelocity;
+    [ExternalState]
     private Tensor<T>? _gpuOffsetWeightM;
+    [ExternalState]
     private Tensor<T>? _gpuOffsetWeightV;
+    [ExternalState]
     private Tensor<T>? _gpuOffsetBiasM;
+    [ExternalState]
     private Tensor<T>? _gpuOffsetBiasV;
 
     // Mask weights - GPU tensors (only used if _useModulation)
+    [ExternalState]
     private Tensor<T>? _gpuMaskWeights;
+    [ExternalState]
     private Tensor<T>? _gpuMaskBias;
+    [ExternalState]
     private Tensor<T>? _gpuMaskWeightGradient;
+    [ExternalState]
     private Tensor<T>? _gpuMaskBiasGradient;
+    [ExternalState]
     private Tensor<T>? _gpuMaskWeightVelocity;
+    [ExternalState]
     private Tensor<T>? _gpuMaskBiasVelocity;
+    [ExternalState]
     private Tensor<T>? _gpuMaskWeightM;
+    [ExternalState]
     private Tensor<T>? _gpuMaskWeightV;
+    [ExternalState]
     private Tensor<T>? _gpuMaskBiasM;
+    [ExternalState]
     private Tensor<T>? _gpuMaskBiasV;
 
     #endregion
diff --git a/src/NeuralNetworks/Layers/DenseBlock.cs b/src/NeuralNetworks/Layers/DenseBlock.cs
index 165197c05e..33be527ddd 100644
--- a/src/NeuralNetworks/Layers/DenseBlock.cs
+++ b/src/NeuralNetworks/Layers/DenseBlock.cs
@@ -119,12 +119,14 @@ public partial class DenseBlock<T> : LayerBase<T>, ILayerSerializationExtras<T>,
     private readonly List<DenseBlockLayer<T>> _layers;
     private readonly int _numLayers;
     private readonly int _growthRate;
+    private readonly double _bnMomentum;
     // Non-readonly: lazy ctor leaves _inputChannels = -1 until
     // OnFirstForward resolves it from the runtime input tensor.
     private int _inputChannels;
     private List<Tensor<T>>? _layerOutputs;
 
     // GPU cached tensors for backward pass
+    [ExternalState]
     private List<Tensor<T>>? _gpuFeatureMaps;
 
     public override bool SupportsTraining => true;
@@ -194,6 +196,7 @@ public DenseBlock(
         _inputChannels = -1; // resolved in OnFirstForward
         _numLayers = numLayers;
         _growthRate = growthRate;
+        _bnMomentum = bnMomentum;
         _layers = new List<DenseBlockLayer<T>>(numLayers);
 
         for (int i = 0; i < numLayers; i++)
@@ -342,6 +345,7 @@ public override void UpdateParameters(T learningRate)
         }
     }
 
+    [Scratch]
     private Vector<T>? _pendingParameters;
 
     private void ApplyParameters(Vector<T> parameters)
diff --git a/src/NeuralNetworks/Layers/DenseBlockLayer.cs b/src/NeuralNetworks/Layers/DenseBlockLayer.cs
index daa8c9bf0d..b241dcade7 100644
--- a/src/NeuralNetworks/Layers/DenseBlockLayer.cs
+++ b/src/NeuralNetworks/Layers/DenseBlockLayer.cs
@@ -70,17 +70,24 @@ public partial class DenseBlockLayer<T> : LayerBase<T>, ILayerSerializationExtra
     private readonly BatchNormalizationLayer<T> _bn2;
     private readonly ConvolutionalLayer<T> _conv3x3;
     private readonly IActivationFunction<T> _relu;
+    private readonly double _bnMomentum;
 
+    [Scratch]
     private Tensor<T>? _lastInput;
     private Tensor<T>? _bn1Out;
     private Tensor<T>? _relu1Out;
     private Tensor<T>? _conv1Out;
+    [AiDotNet.Attributes.Scratch]
     private Tensor<T>? _bn2Out;
+    [AiDotNet.Attributes.Scratch]
     private Tensor<T>? _relu2Out;
 
     // GPU cached tensors for backward pass
+    [ExternalState]
     private Tensor<T>? _gpuBn1Out;
+    [ExternalState]
     private Tensor<T>? _gpuConv1Out;
+    [ExternalState]
     private Tensor<T>? _gpuBn2Out;
 
     public override bool SupportsTraining => true;
@@ -118,18 +125,19 @@ public DenseBlockLayer(int growthRate, double bnMomentum = 0.1)
 
         _inputChannels = -1; // resolved in OnFirstForward
         _growthRate = growthRate;
+        _bnMomentum = bnMomentum;
         _relu = new ReLUActivation<T>();
 
         int bottleneckChannels = 4 * growthRate;
 
-        _bn1 = new BatchNormalizationLayer<T>();
+        _bn1 = new BatchNormalizationLayer<T>(momentum: bnMomentum);
         _conv1x1 = new ConvolutionalLayer<T>(
             outputDepth: bottleneckChannels,
             kernelSize: 1,
             stride: 1,
             padding: 0,
             activationFunction: new IdentityActivation<T>());
-        _bn2 = new BatchNormalizationLayer<T>();
+        _bn2 = new BatchNormalizationLayer<T>(momentum: bnMomentum);
         _conv3x3 = new ConvolutionalLayer<T>(
             outputDepth: growthRate,
             kernelSize: 3,
@@ -306,6 +314,7 @@ public override void UpdateParameters(T learningRate)
         _conv3x3.UpdateParameters(learningRate);
     }
 
+    [Scratch]
     private Vector<T>? _pendingParameters;
 
     private void ApplyParameters(Vector<T> parameters)
@@ -398,6 +407,7 @@ void ILayerSerializationExtras<T>.SetExtraParameters(Vector<T> extraParameters)
     /// called pre-OnFirstForward. Replayed inside OnFirstForward once
     /// _bn1 / _bn2 have their running-state arrays sized.
     /// </summary>
+    [Scratch]
     private Vector<T>? _pendingExtraParameters;
 
     private void ApplyExtraParametersUnsafe(Vector<T> extraParameters)
diff --git a/src/NeuralNetworks/Layers/DenseLayer.cs b/src/NeuralNetworks/Layers/DenseLayer.cs
index 832e910e1e..5295795d28 100644
--- a/src/NeuralNetworks/Layers/DenseLayer.cs
+++ b/src/NeuralNetworks/Layers/DenseLayer.cs
@@ -274,6 +274,7 @@ public partial class DenseLayer<T> : LayerBase<T>, IAuxiliaryLossLayer<T>, IShap
     /// <see cref="_weights"/> is a freed placeholder; each forward upcasts this to fp32 transiently for the
     /// matmul. Halves resident weight memory. Null in the normal full-precision path.
     /// </summary>
+    [AiDotNet.Attributes.Scratch]
     private Tensor<Half>? _weightsHalf;
 
     // The fp16-resident upcast machinery (downcast-once + reused SIMD upcast buffer) lives in
@@ -300,6 +301,7 @@ public partial class DenseLayer<T> : LayerBase<T>, IAuxiliaryLossLayer<T>, IShap
     /// before actually making them.
     /// </para>
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _weightsGradient;
 
     /// <summary>
@@ -321,6 +323,7 @@ public partial class DenseLayer<T> : LayerBase<T>, IAuxiliaryLossLayer<T>, IShap
     /// It works together with the weight gradients to update all the layer's parameters.
     /// </para>
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _biasesGradient;
 
     /// <summary>
@@ -341,7 +344,9 @@ public partial class DenseLayer<T> : LayerBase<T>, IAuxiliaryLossLayer<T>, IShap
     /// errors in the output, making learning impossible.
     /// </para>
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _lastInput;
+    [Scratch]
     private Tensor<T>? _lastOutput; // Pre-activation output for proper gradient computation
 
     /// <summary>
@@ -357,6 +362,7 @@ public partial class DenseLayer<T> : LayerBase<T>, IAuxiliaryLossLayer<T>, IShap
     /// NOT used while a gradient tape is active or in training (those need the recorded
     /// allocating op).
     /// </summary>
+    [Scratch]
     private Tensor<T>? _fusedLinearScratch;
 
     // Q8_0 quantized weight (llama.cpp / ggml native layout: weight kept int8 [out,in] with one fp32
@@ -403,8 +409,11 @@ public void SetQuantizedWeightsQ8_0(sbyte[] qs, float[] scales, int inFeatures,
     }
 
     // GPU-resident cached tensors for GPU training pipeline
+    [Scratch]
     private Tensor<T>? _lastInputGpu;
+    [Scratch]
     private Tensor<T>? _lastPreActivationGpu; // Pre-activation for GPU backward pass
+    [Scratch]
     private Tensor<T>? _lastOutputGpu; // Post-activation for sigmoid/tanh backward
     private int[]? _gpuOriginalInputShape;
 
@@ -1585,7 +1594,9 @@ private Autodiff.ComputationNode<T> ApplyActivationAutodiff(Autodiff.Computation
         }
     }
 
+    [AiDotNet.Attributes.Buffer]
     private Tensor<T>? _weightsVelocity;
+    [AiDotNet.Attributes.Buffer]
     private Tensor<T>? _biasesVelocity;
 
     /// <summary>
@@ -1666,61 +1677,6 @@ public override Vector<T> GetParameterGradients()
             Vector<T>.FromMemory(_biasesGradient.Data));
     }
 
-    public override void Serialize(BinaryWriter writer)
-    {
-        EnsureInitialized();
-        // Write weights
-        writer.Write(_weights.Length);
-        var wSpan = _weights.Data.Span;
-        for (int i = 0; i < _weights.Length; i++)
-            writer.Write(Convert.ToDouble(wSpan[i]));
-        // Write biases
-        writer.Write(_biases.Length);
-        var bSpan = _biases.Data.Span;
-        for (int i = 0; i < _biases.Length; i++)
-            writer.Write(Convert.ToDouble(bSpan[i]));
-    }
-
-    public override void Deserialize(BinaryReader reader)
-    {
-        // Lazy ctor: if shape isn't resolved, recover inputSize from the
-        // saved weights length (= wLen / outputSize) and resolve before
-        // EnsureInitialized tries to allocate with a -1 sentinel. We
-        // simply read wLen first, then resolve, then read the weight
-        // values — no rewinding needed since wLen is the first int we
-        // consume from the layer's blob.
-        int wLen = reader.ReadInt32();
-        if (!IsShapeResolved)
-        {
-            int outputSize = OutputShape[0];
-            if (outputSize > 0 && wLen > 0 && wLen % outputSize == 0)
-            {
-                int inferredInput = wLen / outputSize;
-                ResolveFromShape(new[] { inferredInput });
-            }
-        }
-        EnsureInitialized();
-        // Read weights IN PLACE to preserve engine's persistent tensor reference
-        var wSpan = _weights.Data.Span;
-        for (int i = 0; i < Math.Min(wLen, _weights.Length); i++)
-            wSpan[i] = NumOps.FromDouble(reader.ReadDouble());
-        // Skip any extra values if serialized layer was bigger
-        for (int i = _weights.Length; i < wLen; i++)
-            reader.ReadDouble();
-
-        // Read biases IN PLACE
-        int bLen = reader.ReadInt32();
-        var bSpan = _biases.Data.Span;
-        for (int i = 0; i < Math.Min(bLen, _biases.Length); i++)
-            bSpan[i] = NumOps.FromDouble(reader.ReadDouble());
-        for (int i = _biases.Length; i < bLen; i++)
-            reader.ReadDouble();
-
-        // Notify engine that data changed (for GPU re-upload)
-        Engine.InvalidatePersistentTensor(_weights);
-        Engine.InvalidatePersistentTensor(_biases);
-    }
-
     /// <summary>
     /// Clears stored gradients for weights and biases.
     /// </summary>
@@ -1777,56 +1733,6 @@ public override void ResetState()
         _gpuOriginalInputShape = null;
     }
 
-    /// <summary>
-    /// Creates a deep copy of the layer with the same configuration and parameters.
-    /// </summary>
-    /// <returns>A new instance of the <see cref="DenseLayer{T}"/> class with the same configuration and parameters.</returns>
-    /// <remarks>
-    /// <para>
-    /// This method creates a deep copy of the dense layer, including its configuration and parameters.
-    /// This is useful when you need multiple instances of the same layer, such as in ensemble methods or
-    /// when implementing layer factories.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method creates an exact duplicate of the layer.
-    /// 
-    /// The copy:
-    /// - Has the same input and output dimensions
-    /// - Has the same weights and biases
-    /// - Is completely independent from the original
-    /// 
-    /// This is useful for:
-    /// - Creating multiple similar layers
-    /// - Experimenting with variations of a layer
-    /// - Implementing certain advanced techniques
-    /// 
-    /// Think of it like making a perfect clone that starts exactly where the original is.
-    /// </para>
-    /// </remarks>
-    public override LayerBase<T> Clone()
-    {
-        DenseLayer<T> copy;
-
-        if (UsingVectorActivation && VectorActivation is not null)
-        {
-            copy = new DenseLayer<T>(OutputShape[0], VectorActivation);
-        }
-        else
-        {
-            copy = new DenseLayer<T>(OutputShape[0], ScalarActivation);
-        }
-
-        // The public constructor is intentionally lazy, but a clone of a resolved layer must
-        // preserve its resolved geometry before the parameter vector is restored. Otherwise
-        // SetParameters has no input width from which to allocate [input, output] weights, leaves
-        // the clone at InputShape [-1], and the clone's first Forward randomizes over the values
-        // it was supposed to copy.
-        if (IsShapeResolved && InputShape.Length > 0 && InputShape.All(d => d > 0))
-            copy.ResolveShapesOnly(InputShape);
-
-        copy.SetParameters(GetParameters());
-        return copy;
-    }
-
     /// <summary>
     /// Releases resources used by this layer, including GPU tensor handles.
     /// </summary>
diff --git a/src/NeuralNetworks/Layers/DepthwiseSeparableConvolutionalLayer.cs b/src/NeuralNetworks/Layers/DepthwiseSeparableConvolutionalLayer.cs
index fa64fc33cc..b88b2153a3 100644
--- a/src/NeuralNetworks/Layers/DepthwiseSeparableConvolutionalLayer.cs
+++ b/src/NeuralNetworks/Layers/DepthwiseSeparableConvolutionalLayer.cs
@@ -171,6 +171,7 @@ OutputAxisContract Spatial(TensorAxis a)
     /// this helps the layer learn precisely from its mistakes.
     /// </para>
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _lastInput;
 
     /// <summary>
@@ -202,6 +203,7 @@ OutputAxisContract Spatial(TensorAxis a)
     /// so it can improve both steps independently.
     /// </para>
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _lastDepthwiseOutput;
 
     /// <summary>
@@ -222,6 +224,7 @@ OutputAxisContract Spatial(TensorAxis a)
     /// Like keeping track of your final answer to see exactly where you went wrong.
     /// </para>
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _lastOutput;
 
     /// <summary>
@@ -243,6 +246,7 @@ OutputAxisContract Spatial(TensorAxis a)
     /// to calculate how much the curve changed things.
     /// </para>
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _lastPreActivation;
 
     /// <summary>
@@ -263,6 +267,7 @@ OutputAxisContract Spatial(TensorAxis a)
     /// Think of it like a to-do list of adjustments for each filter.
     /// </para>
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _depthwiseKernelsGradient;
 
     /// <summary>
@@ -283,6 +288,7 @@ OutputAxisContract Spatial(TensorAxis a)
     /// Similar to the depthwise gradients, but for the mixing step rather than the filtering step.
     /// </para>
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _pointwiseKernelsGradient;
 
     /// <summary>
@@ -303,35 +309,53 @@ OutputAxisContract Spatial(TensorAxis a)
     /// Adjusting biases can help fine-tune the sensitivity of feature detectors.
     /// </para>
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _biasesGradient;
 
     #region GPU Training Fields
+    [ExternalState]
     private Tensor<T>? _gpuLastInput;
+    [ExternalState]
     private Tensor<T>? _gpuLastOutput;
 
     // GPU weight buffers
+    [ExternalState]
     private Tensor<T>? _gpuDepthwiseKernels;
+    [ExternalState]
     private Tensor<T>? _gpuPointwiseKernels;
+    [ExternalState]
     private Tensor<T>? _gpuBiases;
 
     // GPU gradient buffers
+    [ExternalState]
     private Tensor<T>? _gpuDepthwiseKernelsGradient;
+    [ExternalState]
     private Tensor<T>? _gpuPointwiseKernelsGradient;
+    [ExternalState]
     private Tensor<T>? _gpuBiasesGradient;
 
     // GPU velocity buffers (SGD momentum)
+    [ExternalState]
     private Tensor<T>? _gpuDepthwiseKernelsVelocity;
+    [ExternalState]
     private Tensor<T>? _gpuPointwiseKernelsVelocity;
+    [ExternalState]
     private Tensor<T>? _gpuBiasesVelocity;
 
     // GPU Adam first moment buffers
+    [ExternalState]
     private Tensor<T>? _gpuDepthwiseKernelsM;
+    [ExternalState]
     private Tensor<T>? _gpuPointwiseKernelsM;
+    [ExternalState]
     private Tensor<T>? _gpuBiasesM;
 
     // GPU Adam second moment buffers
+    [ExternalState]
     private Tensor<T>? _gpuDepthwiseKernelsV;
+    [ExternalState]
     private Tensor<T>? _gpuPointwiseKernelsV;
+    [ExternalState]
     private Tensor<T>? _gpuBiasesV;
     #endregion
 
diff --git a/src/NeuralNetworks/Layers/DiffusionConvLayer.cs b/src/NeuralNetworks/Layers/DiffusionConvLayer.cs
index 2e598eadcf..b809a296e3 100644
--- a/src/NeuralNetworks/Layers/DiffusionConvLayer.cs
+++ b/src/NeuralNetworks/Layers/DiffusionConvLayer.cs
@@ -140,41 +140,49 @@ public partial class DiffusionConvLayer<T> : LayerBase<T>, IShapeContract
     /// <summary>
     /// Cached weight gradients from backward pass.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _weightsGradient;
 
     /// <summary>
     /// Cached bias gradients from backward pass.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _biasesGradient;
 
     /// <summary>
     /// Cached input from the last forward pass.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastInput;
 
     /// <summary>
     /// Cached pre-activation output from the last forward pass.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastPreActivation;
 
     /// <summary>
     /// Cached output from the last forward pass.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastOutput;
 
     /// <summary>
     /// Cached diffused features for backward pass [numVertices, InputChannels * NumTimeScales].
     /// </summary>
+    [AiDotNet.Attributes.Scratch]
     private Tensor<T>? _diffusedFeatures;
 
     /// <summary>
     /// Laplacian matrix for the current mesh [numVertices, numVertices].
     /// </summary>
+    [AiDotNet.Attributes.FittedParameter(InputSized = true)]
     private Tensor<T>? _laplacian;
 
     /// <summary>
     /// Mass matrix (vertex areas) for the current mesh [numVertices].
     /// </summary>
+    [AiDotNet.Attributes.FittedParameter(InputSized = true)]
     private Tensor<T>? _massMatrix;
 
     /// <summary>
@@ -185,6 +193,7 @@ public partial class DiffusionConvLayer<T> : LayerBase<T>, IShapeContract
     /// <summary>
     /// Eigenvectors of the Laplacian [numVertices, numEigenvalues].
     /// </summary>
+    [AiDotNet.Attributes.FittedParameter(InputSized = true)]
     private Tensor<T>? _eigenvectors;
 
     /// <summary>
@@ -216,6 +225,7 @@ public partial class DiffusionConvLayer<T> : LayerBase<T>, IShapeContract
     /// <summary>
     /// Cached GPU input from the last forward pass.
     /// </summary>
+    [ExternalState]
     private Tensor<T>? _gpuInput;
 
     /// <summary>
@@ -226,67 +236,85 @@ public partial class DiffusionConvLayer<T> : LayerBase<T>, IShapeContract
     /// <summary>
     /// Cached GPU diffused features for backward pass.
     /// </summary>
+    [ExternalState]
     private Tensor<T>? _gpuDiffusedFeatures;
 
     /// <summary>
     /// Cached GPU pre-activation output for backward pass.
     /// </summary>
+    [ExternalState]
     private Tensor<T>? _gpuPreActivation;
 
     /// <summary>
     /// Cached GPU activated output for backward pass.
     /// </summary>
+    [ExternalState]
     private Tensor<T>? _gpuOutput;
 
     /// <summary>
     /// GPU weight tensor.
     /// </summary>
+    [ExternalState]
     private Tensor<T>? _gpuWeights;
 
     /// <summary>
     /// GPU bias tensor.
     /// </summary>
+    [ExternalState]
     private Tensor<T>? _gpuBiases;
 
     /// <summary>
     /// GPU diffusion time tensor.
     /// </summary>
+    [ExternalState]
     private Tensor<T>? _gpuDiffusionTimes;
 
     /// <summary>
     /// GPU weight gradients.
     /// </summary>
+    [ExternalState]
     private Tensor<T>? _gpuWeightsGradient;
 
     /// <summary>
     /// GPU bias gradients.
     /// </summary>
+    [ExternalState]
     private Tensor<T>? _gpuBiasesGradient;
 
     /// <summary>
     /// GPU diffusion time gradients.
     /// </summary>
+    [ExternalState]
     private Tensor<T>? _gpuDiffusionTimesGradient;
 
     /// <summary>
     /// GPU optimizer state for weights.
     /// </summary>
+    [ExternalState]
     private Tensor<T>? _gpuWeightsVelocity;
+    [ExternalState]
     private Tensor<T>? _gpuWeightsM;
+    [ExternalState]
     private Tensor<T>? _gpuWeightsV;
 
     /// <summary>
     /// GPU optimizer state for biases.
     /// </summary>
+    [ExternalState]
     private Tensor<T>? _gpuBiasesVelocity;
+    [ExternalState]
     private Tensor<T>? _gpuBiasesM;
+    [ExternalState]
     private Tensor<T>? _gpuBiasesV;
 
     /// <summary>
     /// GPU optimizer state for diffusion times.
     /// </summary>
+    [ExternalState]
     private Tensor<T>? _gpuDiffusionTimesVelocity;
+    [ExternalState]
     private Tensor<T>? _gpuDiffusionTimesM;
+    [ExternalState]
     private Tensor<T>? _gpuDiffusionTimesV;
 
     #endregion
@@ -1682,40 +1710,6 @@ public override void UpdateParameters(T learningRate)
     /// </summary>
     public override Tensor<T> GetBiases() => _biases;
 
-    /// <summary>
-    /// Creates a deep copy of this layer.
-    /// </summary>
-    public override LayerBase<T> Clone()
-    {
-        DiffusionConvLayer<T> copy;
-
-        if (UsingVectorActivation)
-        {
-            var vAct = VectorActivation ?? throw new InvalidOperationException(
-                "UsingVectorActivation is true but VectorActivation is null.");
-            copy = new DiffusionConvLayer<T>(
-                OutputChannels, NumTimeScales, _numEigenvectors, vAct, _preferSpectralDiffusion);
-        }
-        else
-        {
-            copy = new DiffusionConvLayer<T>(
-                OutputChannels, NumTimeScales, _numEigenvectors, ScalarActivation, _preferSpectralDiffusion);
-        }
-
-        copy.SetParameters(GetParameters());
-
-        if (_eigenvalues != null && _eigenvectors != null)
-        {
-            copy.SetEigenbasis(_eigenvalues, _eigenvectors, _massMatrix);
-        }
-        else if (_laplacian != null)
-        {
-            copy.SetLaplacian(_laplacian, _massMatrix);
-        }
-
-        return copy;
-    }
-
     #endregion
 
     #region State Management
@@ -1749,200 +1743,6 @@ private void ClearGpuCache()
 
     #region Serialization
 
-    /// <summary>
-    /// Serializes the layer to a binary stream.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// Saves all learnable parameters and mesh configuration including:
-    /// - Layer configuration (channels, time scales, eigenvector count)
-    /// - Weights and biases
-    /// - Diffusion time parameters
-    /// - Eigenvalues and eigenvectors (if available)
-    /// - Laplacian and mass matrices (if available)
-    /// </para>
-    /// </remarks>
-    /// <param name="writer">Binary writer to serialize to.</param>
-    public override void Serialize(BinaryWriter writer)
-    {
-        base.Serialize(writer);
-        writer.Write(InputChannels);
-        writer.Write(OutputChannels);
-        writer.Write(NumTimeScales);
-        writer.Write(_numEigenvectors);
-
-        // Serialize weights
-        var weightArray = _weights.ToArray();
-        for (int i = 0; i < weightArray.Length; i++)
-        {
-            writer.Write(NumOps.ToDouble(weightArray[i]));
-        }
-
-        // Serialize biases
-        var biasArray = _biases.ToArray();
-        for (int i = 0; i < biasArray.Length; i++)
-        {
-            writer.Write(NumOps.ToDouble(biasArray[i]));
-        }
-
-        // Serialize diffusion times
-        for (int i = 0; i < DiffusionTimes.Length; i++)
-        {
-            writer.Write(NumOps.ToDouble(DiffusionTimes[i]));
-        }
-
-        // Serialize mesh configuration
-        // Flag indicating which mesh data is available
-        byte meshFlags = 0;
-        if (_eigenvalues != null && _eigenvectors != null) meshFlags |= 0x01;
-        if (_laplacian != null) meshFlags |= 0x02;
-        if (_massMatrix != null) meshFlags |= 0x04;
-        writer.Write(meshFlags);
-
-        // Serialize eigenvalues and eigenvectors
-        if (_eigenvalues != null && _eigenvectors != null)
-        {
-            writer.Write(_eigenvalues.Length);
-            for (int i = 0; i < _eigenvalues.Length; i++)
-            {
-                writer.Write(NumOps.ToDouble(_eigenvalues[i]));
-            }
-
-            // Write eigenvector shape and data
-            writer.Write(_eigenvectors.Shape[0]); // numVertices
-            writer.Write(_eigenvectors.Shape[1]); // numEigenvalues
-            var eigenvectorArray = _eigenvectors.ToArray();
-            for (int i = 0; i < eigenvectorArray.Length; i++)
-            {
-                writer.Write(NumOps.ToDouble(eigenvectorArray[i]));
-            }
-        }
-
-        // Serialize Laplacian
-        if (_laplacian != null)
-        {
-            writer.Write(_laplacian.Shape[0]); // numVertices (square matrix)
-            var laplacianArray = _laplacian.ToArray();
-            for (int i = 0; i < laplacianArray.Length; i++)
-            {
-                writer.Write(NumOps.ToDouble(laplacianArray[i]));
-            }
-        }
-
-        // Serialize mass matrix
-        if (_massMatrix != null)
-        {
-            writer.Write(_massMatrix.Length);
-            var massArray = _massMatrix.ToArray();
-            for (int i = 0; i < massArray.Length; i++)
-            {
-                writer.Write(NumOps.ToDouble(massArray[i]));
-            }
-        }
-    }
-
-    /// <summary>
-    /// Deserializes the layer from a binary stream.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// Restores all learnable parameters and mesh configuration.
-    /// After deserialization, the layer is ready for inference without
-    /// needing to call SetEigenbasis or SetLaplacian.
-    /// </para>
-    /// </remarks>
-    /// <param name="reader">Binary reader to deserialize from.</param>
-    public override void Deserialize(BinaryReader reader)
-    {
-        base.Deserialize(reader);
-        InputChannels = reader.ReadInt32();
-        OutputChannels = reader.ReadInt32();
-        NumTimeScales = reader.ReadInt32();
-        int numEigenvectors = reader.ReadInt32();
-
-        int weightSize = InputChannels * NumTimeScales;
-        _weights = new Tensor<T>([OutputChannels, weightSize]);
-        var weightArray = new T[_weights.Length];
-        for (int i = 0; i < weightArray.Length; i++)
-        {
-            weightArray[i] = NumOps.FromDouble(reader.ReadDouble());
-        }
-        _weights = new Tensor<T>(weightArray, _weights._shape);
-
-        _biases = new Tensor<T>([OutputChannels]);
-        var biasArray = new T[_biases.Length];
-        for (int i = 0; i < biasArray.Length; i++)
-        {
-            biasArray[i] = NumOps.FromDouble(reader.ReadDouble());
-        }
-        _biases = new Tensor<T>(biasArray, _biases._shape);
-
-        DiffusionTimes = new T[NumTimeScales];
-        for (int i = 0; i < NumTimeScales; i++)
-        {
-            DiffusionTimes[i] = NumOps.FromDouble(reader.ReadDouble());
-        }
-
-        // Deserialize mesh configuration
-        byte meshFlags = reader.ReadByte();
-
-        // Deserialize eigenvalues and eigenvectors
-        if ((meshFlags & 0x01) != 0)
-        {
-            int numEig = reader.ReadInt32();
-            _eigenvalues = new T[numEig];
-            for (int i = 0; i < numEig; i++)
-            {
-                _eigenvalues[i] = NumOps.FromDouble(reader.ReadDouble());
-            }
-
-            int numVertices = reader.ReadInt32();
-            int eigCount = reader.ReadInt32();
-            var eigenvectorArray = new T[numVertices * eigCount];
-            for (int i = 0; i < eigenvectorArray.Length; i++)
-            {
-                eigenvectorArray[i] = NumOps.FromDouble(reader.ReadDouble());
-            }
-            _eigenvectors = new Tensor<T>(eigenvectorArray, [numVertices, eigCount]);
-        }
-
-        // Deserialize Laplacian
-        if ((meshFlags & 0x02) != 0)
-        {
-            int numVertices = reader.ReadInt32();
-            var laplacianArray = new T[numVertices * numVertices];
-            for (int i = 0; i < laplacianArray.Length; i++)
-            {
-                laplacianArray[i] = NumOps.FromDouble(reader.ReadDouble());
-            }
-            _laplacian = new Tensor<T>(laplacianArray, [numVertices, numVertices]);
-        }
-
-        // Deserialize mass matrix
-        if ((meshFlags & 0x04) != 0)
-        {
-            int numVertices = reader.ReadInt32();
-            var massArray = new T[numVertices];
-            for (int i = 0; i < massArray.Length; i++)
-            {
-                massArray[i] = NumOps.FromDouble(reader.ReadDouble());
-            }
-            _massMatrix = new Tensor<T>(massArray, [numVertices]);
-        }
-
-        // Re-register the restored weights as trainable parameters. Deserialize replaces the field
-        // references outright, so without this the registry either stays empty -- this layer is lazy,
-        // so a freshly constructed instance has never registered anything, and GetParameters() then
-        // reports zero and silently discards every restored weight -- or still points at the tensors
-        // from a prior forward, leaving optimizers and tape training to update dead references while
-        // Forward reads the new ones. Only _weights and _biases are trainable; the eigenbasis,
-        // Laplacian and mass matrix are fixed mesh structure supplied by SetEigenbasis/SetLaplacian.
-        // ConvolutionalLayer and Conv3DLayer do the same.
-        ClearRegisteredParameters();
-        RegisterTrainableParameter(_weights, PersistentTensorRole.Weights);
-        RegisterTrainableParameter(_biases, PersistentTensorRole.Biases);
-    }
-
     #endregion
 
     #region JIT Compilation
diff --git a/src/NeuralNetworks/Layers/DigitCapsuleLayer.cs b/src/NeuralNetworks/Layers/DigitCapsuleLayer.cs
index a897f908a3..a8cba8f3c1 100644
--- a/src/NeuralNetworks/Layers/DigitCapsuleLayer.cs
+++ b/src/NeuralNetworks/Layers/DigitCapsuleLayer.cs
@@ -79,6 +79,7 @@ public partial class DigitCapsuleLayer<T> : LayerBase<T>, IShapeContract
     /// - They're like a "report card" for each weight showing what needs improvement
     /// </para>
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _weightsGradient;
 
     /// <summary>
@@ -97,6 +98,7 @@ public partial class DigitCapsuleLayer<T> : LayerBase<T>, IShapeContract
     /// - This helps it learn how to adjust its weights correctly
     /// </para>
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _lastInput;
 
     /// <summary>
@@ -120,7 +122,9 @@ public partial class DigitCapsuleLayer<T> : LayerBase<T>, IShapeContract
     /// - This helps it understand how to improve for next time
     /// </para>
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _lastOutput;
+    [Scratch]
     private Tensor<T>? _lastPreSquash;
 
     /// <summary>
@@ -142,6 +146,7 @@ public partial class DigitCapsuleLayer<T> : LayerBase<T>, IShapeContract
     /// "vote" for digits like 0, 6, 8, and 9.
     /// </para>
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _lastCouplings;
 
     /// <summary>
diff --git a/src/NeuralNetworks/Layers/DilatedConvolutionalLayer.cs b/src/NeuralNetworks/Layers/DilatedConvolutionalLayer.cs
index 280c6d8fec..4c64ee3abe 100644
--- a/src/NeuralNetworks/Layers/DilatedConvolutionalLayer.cs
+++ b/src/NeuralNetworks/Layers/DilatedConvolutionalLayer.cs
@@ -250,6 +250,7 @@ public partial class DilatedConvolutionalLayer<T> : LayerBase<T>, IShapeContract
     /// This is automatically cleared after each training batch to save memory.
     /// </para>
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _lastInput;
 
     /// <summary>
@@ -270,6 +271,7 @@ public partial class DilatedConvolutionalLayer<T> : LayerBase<T>, IShapeContract
     /// This is also cleared after each training batch to save memory.
     /// </para>
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _lastOutput;
 
     /// <summary>
@@ -301,6 +303,7 @@ public partial class DilatedConvolutionalLayer<T> : LayerBase<T>, IShapeContract
     /// what the network learned from its mistakes.
     /// </para>
     /// </remarks>
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T>? _kernelGradients;
 
     /// <summary>
@@ -322,10 +325,13 @@ public partial class DilatedConvolutionalLayer<T> : LayerBase<T>, IShapeContract
     /// each output channel only has one bias value.
     /// </para>
     /// </remarks>
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T>? _biasGradients;
 
     // GPU cached tensors for backward pass
+    [ExternalState]
     private Tensor<T>? _gpuInput;
+    [ExternalState]
     private Tensor<T>? _gpuOutput;
     private int[]? _gpuOriginalInputShape;
     private bool _gpuAddedBatchDimension;
diff --git a/src/NeuralNetworks/Layers/DirectionalGraphLayer.cs b/src/NeuralNetworks/Layers/DirectionalGraphLayer.cs
index 71364bf8db..9ee8c93c2b 100644
--- a/src/NeuralNetworks/Layers/DirectionalGraphLayer.cs
+++ b/src/NeuralNetworks/Layers/DirectionalGraphLayer.cs
@@ -154,41 +154,60 @@ public partial class DirectionalGraphLayer<T> : LayerBase<T>, IGraphConvolutionL
     /// <summary>
     /// The adjacency matrix defining graph structure (interpreted as directed).
     /// </summary>
+    [AiDotNet.Attributes.FittedParameter(InputSized = true)]
     private Tensor<T>? _adjacencyMatrix;
 
     /// <summary>
     /// The adjacency matrix reshaped to 3D for batched operations.
     /// </summary>
+    [AiDotNet.Attributes.Scratch]
     private Tensor<T>? _adjForBatch;
 
     /// <summary>
     /// Cached values for backward pass.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastInput;
 
     /// <summary>
     /// Stores the original input shape for any-rank tensor support.
     /// </summary>
     private int[]? _originalInputShape;
+    [Scratch]
     private Tensor<T>? _lastOutput;
+    [Scratch]
     private Tensor<T>? _lastIncoming;
+    [Scratch]
     private Tensor<T>? _lastOutgoing;
+    [Scratch]
     private Tensor<T>? _lastSelf;
+    [Scratch]
     private Tensor<T>? _lastCombined;
+    [Scratch]
     private Tensor<T>? _lastGates;
 
     /// <summary>
     /// Gradients.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _incomingWeightsGradient;
+    [Scratch]
     private Tensor<T>? _outgoingWeightsGradient;
+    [Scratch]
     private Tensor<T>? _selfWeightsGradient;
+    [Scratch]
     private Tensor<T>? _combinationWeightsGradient;
+    [Scratch]
     private Tensor<T>? _incomingBiasGradient;
+    [Scratch]
     private Tensor<T>? _outgoingBiasGradient;
+    [Scratch]
     private Tensor<T>? _selfBiasGradient;
+    [Scratch]
     private Tensor<T>? _combinationBiasGradient;
+    [Scratch]
     private Tensor<T>? _gateWeightsGradient;
+    [Scratch]
     private Tensor<T>? _gateBiasGradient;
 
     public override bool SupportsTraining => true;
diff --git a/src/NeuralNetworks/Layers/DropoutLayer.cs b/src/NeuralNetworks/Layers/DropoutLayer.cs
index cd690d0fe0..5b87fdc0aa 100644
--- a/src/NeuralNetworks/Layers/DropoutLayer.cs
+++ b/src/NeuralNetworks/Layers/DropoutLayer.cs
@@ -114,6 +114,7 @@ public partial class DropoutLayer<T> : LayerBase<T>, IShapeContract
     /// This value is automatically cleared between training batches to save memory.
     /// </para>
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _lastInput;
 
     /// <summary>
@@ -141,6 +142,7 @@ public partial class DropoutLayer<T> : LayerBase<T>, IShapeContract
     /// neurons for each training example.
     /// </para>
     /// </remarks>
+    [AiDotNet.Attributes.Scratch]
     private Tensor<T>? _dropoutMask;
 
     /// <summary>
@@ -150,6 +152,7 @@ public partial class DropoutLayer<T> : LayerBase<T>, IShapeContract
     /// This stores the GPU mask needed for GPU-resident backward pass. It is kept separate
     /// from _dropoutMask to support mixed CPU/GPU execution scenarios.
     /// </remarks>
+    [ExternalState]
     private Tensor<T>? _gpuDropoutMask;
 
     /// <summary>
diff --git a/src/NeuralNetworks/Layers/DuelingCombinationLayer.cs b/src/NeuralNetworks/Layers/DuelingCombinationLayer.cs
index c64459852a..278a5d842b 100644
--- a/src/NeuralNetworks/Layers/DuelingCombinationLayer.cs
+++ b/src/NeuralNetworks/Layers/DuelingCombinationLayer.cs
@@ -75,9 +75,13 @@ public partial class DuelingCombinationLayer<T> : LayerBase<T>, IShapeContract
     // tape rejects with "Parameter N is not a view into the provided
     // ParameterBuffer" — the supervised RainbowDQNAgent.Train(state, target)
     // path takes for offline pretraining / BC warm-start.
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _valueWeights;
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _valueBias;
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _advantageWeights;
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _advantageBias;
 
     /// <inheritdoc />
@@ -132,35 +136,7 @@ private void InitializeUniform(Tensor<T> tensor, Random rng, int fanIn, int fanO
     /// <inheritdoc/>
     public override bool SupportsTraining => true;
 
-    /// <inheritdoc/>
-    public override IReadOnlyList<Tensor<T>> GetTrainableParameters() =>
-        new[] { _valueWeights, _valueBias, _advantageWeights, _advantageBias };
 
-    /// <inheritdoc/>
-    /// <remarks>
-    /// Replaces the field tensor references with the supplied tensors rather
-    /// than copying data into the old ones. ParameterBuffer machinery in
-    /// <see cref="NeuralNetworkBase{T}.GetOrCreateParameterBuffer"/> calls
-    /// this with buffer-backed views; the tape's reference-identity
-    /// alignment check (TapeStepContext.ValidateBufferAlignment) then
-    /// requires Forward() to use those view tensors. Validate per-dim shape
-    /// match first so a same-length but differently-shaped tensor doesn't
-    /// silently scramble the layer's weights.
-    /// </remarks>
-    public override void SetTrainableParameters(IReadOnlyList<Tensor<T>> parameters)
-    {
-        if (parameters.Count != 4)
-            throw new ArgumentException(
-                "Expected exactly 4 parameter tensors (V_w, V_b, A_w, A_b).", nameof(parameters));
-        ValidateShapeMatch(parameters[0], _valueWeights, nameof(_valueWeights));
-        ValidateShapeMatch(parameters[1], _valueBias, nameof(_valueBias));
-        ValidateShapeMatch(parameters[2], _advantageWeights, nameof(_advantageWeights));
-        ValidateShapeMatch(parameters[3], _advantageBias, nameof(_advantageBias));
-        _valueWeights = parameters[0];
-        _valueBias = parameters[1];
-        _advantageWeights = parameters[2];
-        _advantageBias = parameters[3];
-    }
 
     private static void ValidateShapeMatch(Tensor<T> incoming, Tensor<T> existing, string paramName)
     {
diff --git a/src/NeuralNetworks/Layers/EdgeConditionalConvolutionalLayer.cs b/src/NeuralNetworks/Layers/EdgeConditionalConvolutionalLayer.cs
index 6f126c500d..ba01410d6c 100644
--- a/src/NeuralNetworks/Layers/EdgeConditionalConvolutionalLayer.cs
+++ b/src/NeuralNetworks/Layers/EdgeConditionalConvolutionalLayer.cs
@@ -117,36 +117,50 @@ public partial class EdgeConditionalConvolutionalLayer<T> : LayerBase<T>, IGraph
     /// <summary>
     /// The adjacency matrix defining graph structure.
     /// </summary>
+    [AiDotNet.Attributes.FittedParameter(InputSized = true)]
     private Tensor<T>? _adjacencyMatrix;
 
     /// <summary>
     /// Edge features tensor.
     /// </summary>
+    [AiDotNet.Attributes.FittedParameter(InputSized = true)]
     private Tensor<T>? _edgeFeatures;
+    [AiDotNet.Attributes.Scratch]
     private Tensor<T>? _normalizedAdjacencyMatrix;
+    [AiDotNet.Attributes.Scratch]
     private Tensor<T>? _normalizedEdgeFeatures;
 
     /// <summary>
     /// Cached values for backward pass.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastInput;
 
     /// <summary>
     /// Stores the original input shape for any-rank tensor support.
     /// </summary>
     private int[]? _originalInputShape;
+    [Scratch]
     private Tensor<T>? _lastOutput;
+    [Scratch]
     private Tensor<T>? _lastEdgeWeights;
+    [Scratch]
     private Tensor<T>? _lastHidden;
 
     /// <summary>
     /// Gradients.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _edgeNetworkWeights1Gradient;
+    [Scratch]
     private Tensor<T>? _edgeNetworkWeights2Gradient;
+    [Scratch]
     private Tensor<T>? _edgeNetworkBias1Gradient;
+    [Scratch]
     private Tensor<T>? _edgeNetworkBias2Gradient;
+    [Scratch]
     private Tensor<T>? _selfWeightsGradient;
+    [Scratch]
     private Tensor<T>? _biasGradient;
 
     public override bool SupportsTraining => true;
diff --git a/src/NeuralNetworks/Layers/EmbeddingLayer.cs b/src/NeuralNetworks/Layers/EmbeddingLayer.cs
index 1de3a512d0..236294e079 100644
--- a/src/NeuralNetworks/Layers/EmbeddingLayer.cs
+++ b/src/NeuralNetworks/Layers/EmbeddingLayer.cs
@@ -147,8 +147,10 @@ public partial class EmbeddingLayer<T> : LayerBase<T>, IAuxiliaryLossLayer<T>, I
     }
 
     // GPU-resident cached tensors for GPU training pipeline
+    [Scratch]
     private Tensor<T>? _lastInputGpu;
     private int[]? _lastInputGpuShape;
+    [Scratch]
     private Tensor<int>? _lastIndicesForGpu;
 
     /// <summary>
@@ -174,6 +176,7 @@ public partial class EmbeddingLayer<T> : LayerBase<T>, IAuxiliaryLossLayer<T>, I
     /// will receive gradient updates.
     /// </para>
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _embeddingGradient;
 
     /// <summary>
@@ -196,6 +199,7 @@ public partial class EmbeddingLayer<T> : LayerBase<T>, IAuxiliaryLossLayer<T>, I
     /// only the embeddings for token IDs 5, 10, and 3 will receive updates during training.
     /// </para>
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _lastInput;
 
     /// <summary>
diff --git a/src/NeuralNetworks/Layers/ExpertLayer.cs b/src/NeuralNetworks/Layers/ExpertLayer.cs
index c9cef0e853..dde1e7682c 100644
--- a/src/NeuralNetworks/Layers/ExpertLayer.cs
+++ b/src/NeuralNetworks/Layers/ExpertLayer.cs
@@ -37,7 +37,7 @@ namespace AiDotNet.NeuralNetworks.Layers;
 [LayerCategory(LayerCategory.MixtureOfExperts)]
 [LayerTask(LayerTask.Routing)]
 [LayerTask(LayerTask.FeatureExtraction)]
-[LayerProperty(IsTrainable = true, ChangesShape = true, Cost = ComputeCost.High)]
+[LayerProperty(IsTrainable = true, ChangesShape = true, Cost = ComputeCost.High, TestConstructorArgs = "new System.Collections.Generic.List<AiDotNet.Interfaces.ILayer<double>> { new AiDotNet.NeuralNetworks.Layers.ReadoutLayer<double>(4, 8, (AiDotNet.Interfaces.IActivationFunction<double>)new AiDotNet.ActivationFunctions.IdentityActivation<double>()) }, new[] { 4 }, new[] { 8 }", TestInputShape = "1, 4")]
 // A CONTAINER decorator: ForwardTraced runs "foreach (var layer in _layers) output = layer.Forward(output)"
 // and then ApplyActivation, which is element-wise. So this layer's output shape is the LAST sub-layer's
 // output shape - which is exactly what OnFirstForward publishes too, walking the chain and taking the
@@ -145,6 +145,7 @@ public partial class ExpertLayer<T> : LayerBase<T>, IShapeContract
     /// <summary>
     /// Stores the pre-activation output for use in backpropagation.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastPreActivationOutput;
 
     /// <summary>
@@ -603,45 +604,4 @@ public override void ResetState()
         }
     }
 
-    /// <summary>
-    /// Creates a deep copy of this expert, including all contained layers.
-    /// </summary>
-    /// <returns>A new Expert instance with the same configuration and parameters.</returns>
-    /// <remarks>
-    /// <para>
-    /// This method creates a complete copy of the expert, including all layers and their parameters.
-    /// The clone is independent of the original - changes to one won't affect the other.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method creates an identical copy of the expert.
-    ///
-    /// Cloning is useful when you want to:
-    /// - Experiment with different training approaches on the same starting point
-    /// - Create an ensemble of similar but independent experts
-    /// - Save a checkpoint while continuing to train
-    /// - Implement certain training algorithms that need multiple copies
-    ///
-    /// The clone has:
-    /// - The same layer structure
-    /// - The same parameter values
-    /// - But is completely independent (changes to one don't affect the other)
-    ///
-    /// It's like photocopying a document - you get an identical copy that you can
-    /// modify without changing the original.
-    /// </para>
-    /// </remarks>
-    public override LayerBase<T> Clone()
-    {
-        // Clone all layers
-        var clonedLayers = _layers.Select(l =>
-        {
-            if (l is LayerBase<T> layerBase)
-            {
-                return (ILayer<T>)layerBase.Clone();
-            }
-            return l; // If not cloneable, use the same reference (not ideal but safe for most cases)
-        }).ToList();
-
-        return new ExpertLayer<T>(clonedLayers, InputShape, OutputShape, ScalarActivation);
-    }
-
 }
diff --git a/src/NeuralNetworks/Layers/FeatureTransformerLayer.cs b/src/NeuralNetworks/Layers/FeatureTransformerLayer.cs
index 7ed273d573..824549bdf0 100644
--- a/src/NeuralNetworks/Layers/FeatureTransformerLayer.cs
+++ b/src/NeuralNetworks/Layers/FeatureTransformerLayer.cs
@@ -96,13 +96,16 @@ public partial class FeatureTransformerLayer<T> : LayerBase<T>, IShapeContract
     private readonly List<GhostBatchNormalization<T>> _stepBNLayers;
 
     // Cache for backward pass
+    [Scratch]
     private Tensor<T>? _inputCache;
     private readonly List<Tensor<T>> _intermediateOutputs = [];
 
     // Cached constant 0/1 selection matrices for the GLU column split (see ApplyGLU). They depend
     // only on the input width, so they're built once and reused across forward passes instead of
     // being reallocated + refilled (O(dim^2)) every call.
+    [AiDotNet.Attributes.Scratch]
     private Tensor<T>? _gluValueSelector;
+    [AiDotNet.Attributes.Scratch]
     private Tensor<T>? _gluGateSelector;
     private int _gluCachedFullDim = -1;
 
diff --git a/src/NeuralNetworks/Layers/FeedForwardLayer.cs b/src/NeuralNetworks/Layers/FeedForwardLayer.cs
index 685dc4dc34..c804d69f90 100644
--- a/src/NeuralNetworks/Layers/FeedForwardLayer.cs
+++ b/src/NeuralNetworks/Layers/FeedForwardLayer.cs
@@ -174,6 +174,7 @@ public partial class FeedForwardLayer<T> : LayerBase<T>, IShapeContract
     /// each call and the result is consumed before the next call to this same layer instance.
     /// NOT used while a gradient tape is active or in training.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _fusedLinearScratch;
 
     /// <summary>
@@ -270,6 +271,7 @@ public partial class FeedForwardLayer<T> : LayerBase<T>, IShapeContract
     /// modify the weights.
     /// </para>
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _weightsGradient;
 
     /// <summary>
@@ -297,10 +299,13 @@ public partial class FeedForwardLayer<T> : LayerBase<T>, IShapeContract
     /// each bias affects only one output directly.
     /// </para>
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _biasesGradient;
 
     // GPU cached tensors for backward pass
+    [ExternalState]
     private Tensor<T>? _gpuInput;
+    [ExternalState]
     private Tensor<T>? _gpuOutput;
     private int[] _gpuInputShape = [];
 
diff --git a/src/NeuralNetworks/Layers/FlashAttentionLayer.cs b/src/NeuralNetworks/Layers/FlashAttentionLayer.cs
index b856ad631a..1db76b7703 100644
--- a/src/NeuralNetworks/Layers/FlashAttentionLayer.cs
+++ b/src/NeuralNetworks/Layers/FlashAttentionLayer.cs
@@ -98,6 +98,12 @@ public partial class FlashAttentionLayer<T> : LayerBase<T>, IShapeContract
     /// </summary>
     public FlashAttentionConfig Config => _config;
 
+    /// <summary>Construction state: the 'sequenceLength' the layer was built with.</summary>
+    private readonly int _sequenceLength;
+
+    /// <summary>Construction state: the 'embeddingDimension' the layer was built with.</summary>
+    private readonly int _embeddingDimension;
+
     /// <summary>
     /// Creates a new Flash Attention layer with the specified dimensions.
     /// </summary>
@@ -129,6 +135,8 @@ public FlashAttentionLayer(
             [sequenceLength, embeddingDimension],
             activationFunction ?? new IdentityActivation<T>())
     {
+        _embeddingDimension = embeddingDimension;
+        _sequenceLength = sequenceLength;
         if (embeddingDimension % headCount != 0)
         {
             throw new ArgumentException(
@@ -162,6 +170,8 @@ public FlashAttentionLayer(
             [sequenceLength, embeddingDimension],
             vectorActivationFunction ?? new IdentityActivation<T>())
     {
+        _embeddingDimension = embeddingDimension;
+        _sequenceLength = sequenceLength;
         if (embeddingDimension % headCount != 0)
         {
             throw new ArgumentException(
diff --git a/src/NeuralNetworks/Layers/FlattenLayer.cs b/src/NeuralNetworks/Layers/FlattenLayer.cs
index 3d6e637db9..9b29165436 100644
--- a/src/NeuralNetworks/Layers/FlattenLayer.cs
+++ b/src/NeuralNetworks/Layers/FlattenLayer.cs
@@ -234,6 +234,7 @@ public partial class FlattenLayer<T> : LayerBase<T>, IBatchAwareShapeContract
     /// This is automatically cleared between training batches to save memory.
     /// </para>
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _lastInput;
 
     // GPU-resident cached tensors for GPU training pipeline
diff --git a/src/NeuralNetworks/Layers/FullyConnectedLayer.cs b/src/NeuralNetworks/Layers/FullyConnectedLayer.cs
index d58e4a3f75..0f21a55f10 100644
--- a/src/NeuralNetworks/Layers/FullyConnectedLayer.cs
+++ b/src/NeuralNetworks/Layers/FullyConnectedLayer.cs
@@ -170,6 +170,7 @@ public partial class FullyConnectedLayer<T> : LayerBase<T>, IShapeContract
     /// This value is automatically cleared between training batches to save memory.
     /// </para>
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _lastInput;
 
     /// <summary>
@@ -195,7 +196,9 @@ public partial class FullyConnectedLayer<T> : LayerBase<T>, IShapeContract
     /// This is also cleared after each training batch to save memory.
     /// </para>
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _lastOutput;
+    [Scratch]
     private Tensor<T>? _lastPreActivation;
 
     /// <summary>
@@ -222,6 +225,7 @@ public partial class FullyConnectedLayer<T> : LayerBase<T>, IShapeContract
     /// modify the weights.
     /// </para>
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _weightsGradient;
 
     /// <summary>
@@ -248,10 +252,13 @@ public partial class FullyConnectedLayer<T> : LayerBase<T>, IShapeContract
     /// Each output neuron has its own bias gradient that guides its adjustment.
     /// </para>
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _biasesGradient;
 
     // GPU cached tensors for backward pass
+    [ExternalState]
     private Tensor<T>? _gpuInput;
+    [ExternalState]
     private Tensor<T>? _gpuPreActivation;
     private int[] _gpuInputShape = [];
 
@@ -325,6 +332,9 @@ public FullyConnectedLayer([LayerState] int outputSize, IActivationFunction<T>?
         _biases = new Tensor<T>([outputSize]);
     }
 
+    /// <summary>Construction state: the 'inputSize' the layer was built with.</summary>
+    private readonly int _inputSize;
+
     /// <summary>
     /// Eager constructor that allocates and initializes the weight/bias tensors
     /// immediately for a known input size — the PyTorch <c>nn.Linear(in_features,
@@ -339,6 +349,7 @@ public FullyConnectedLayer([LayerState] int outputSize, IActivationFunction<T>?
     public FullyConnectedLayer(int inputSize, int outputSize, IActivationFunction<T>? activationFunction = null)
         : base(new[] { inputSize }, new[] { outputSize }, activationFunction ?? new ReLUActivation<T>())
     {
+        _inputSize = inputSize;
         if (inputSize <= 0)
             throw new ArgumentOutOfRangeException(nameof(inputSize));
         if (outputSize <= 0)
diff --git a/src/NeuralNetworks/Layers/GRULayer.cs b/src/NeuralNetworks/Layers/GRULayer.cs
index b2c248e4b9..5d15da27c8 100644
--- a/src/NeuralNetworks/Layers/GRULayer.cs
+++ b/src/NeuralNetworks/Layers/GRULayer.cs
@@ -187,11 +187,13 @@ public partial class GRULayer<T> : LayerBase<T>, IShapeContract
     /// <summary>
     /// The input tensor from the last forward pass.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastInput;
 
     /// <summary>
     /// The final hidden state from the last forward pass.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastHiddenState;
 
     /// <summary>
@@ -253,6 +255,7 @@ public partial class GRULayer<T> : LayerBase<T>, IShapeContract
     private readonly int _hiddenSize;
 
     // Cached ones tensor for (1-z) computation — avoids per-timestep allocation
+    [Scratch]
     private Tensor<T>? _cachedOnesForGate;
 
     /// <summary>
@@ -373,66 +376,113 @@ public partial class GRULayer<T> : LayerBase<T>, IShapeContract
     #region GPU Training Fields
 
     // GPU-resident weight tensors
+    [ExternalState]
     private Tensor<T>? _gpuWz;
+    [ExternalState]
     private Tensor<T>? _gpuWr;
+    [ExternalState]
     private Tensor<T>? _gpuWh;
+    [ExternalState]
     private Tensor<T>? _gpuUz;
+    [ExternalState]
     private Tensor<T>? _gpuUr;
+    [ExternalState]
     private Tensor<T>? _gpuUh;
+    [ExternalState]
     private Tensor<T>? _gpuBz;
+    [ExternalState]
     private Tensor<T>? _gpuBr;
+    [ExternalState]
     private Tensor<T>? _gpuBh;
 
     // GPU-resident gradient tensors
+    [ExternalState]
     private Tensor<T>? _gpuWzGradient;
+    [ExternalState]
     private Tensor<T>? _gpuWrGradient;
+    [ExternalState]
     private Tensor<T>? _gpuWhGradient;
+    [ExternalState]
     private Tensor<T>? _gpuUzGradient;
+    [ExternalState]
     private Tensor<T>? _gpuUrGradient;
+    [ExternalState]
     private Tensor<T>? _gpuUhGradient;
+    [ExternalState]
     private Tensor<T>? _gpuBzGradient;
+    [ExternalState]
     private Tensor<T>? _gpuBrGradient;
+    [ExternalState]
     private Tensor<T>? _gpuBhGradient;
 
     // GPU-resident optimizer state tensors (SGD/NAG/LARS velocity)
+    [ExternalState]
     private Tensor<T>? _gpuWzVelocity;
+    [ExternalState]
     private Tensor<T>? _gpuWrVelocity;
+    [ExternalState]
     private Tensor<T>? _gpuWhVelocity;
+    [ExternalState]
     private Tensor<T>? _gpuUzVelocity;
+    [ExternalState]
     private Tensor<T>? _gpuUrVelocity;
+    [ExternalState]
     private Tensor<T>? _gpuUhVelocity;
+    [ExternalState]
     private Tensor<T>? _gpuBzVelocity;
+    [ExternalState]
     private Tensor<T>? _gpuBrVelocity;
+    [ExternalState]
     private Tensor<T>? _gpuBhVelocity;
 
     // Adam/AdamW M (first moment) tensors
+    [ExternalState]
     private Tensor<T>? _gpuWzM;
+    [ExternalState]
     private Tensor<T>? _gpuWrM;
+    [ExternalState]
     private Tensor<T>? _gpuWhM;
+    [ExternalState]
     private Tensor<T>? _gpuUzM;
+    [ExternalState]
     private Tensor<T>? _gpuUrM;
+    [ExternalState]
     private Tensor<T>? _gpuUhM;
+    [ExternalState]
     private Tensor<T>? _gpuBzM;
+    [ExternalState]
     private Tensor<T>? _gpuBrM;
+    [ExternalState]
     private Tensor<T>? _gpuBhM;
 
     // Adam/AdamW V (second moment) tensors
+    [ExternalState]
     private Tensor<T>? _gpuWzV;
+    [ExternalState]
     private Tensor<T>? _gpuWrV;
+    [ExternalState]
     private Tensor<T>? _gpuWhV;
+    [ExternalState]
     private Tensor<T>? _gpuUzV;
+    [ExternalState]
     private Tensor<T>? _gpuUrV;
+    [ExternalState]
     private Tensor<T>? _gpuUhV;
+    [ExternalState]
     private Tensor<T>? _gpuBzV;
+    [ExternalState]
     private Tensor<T>? _gpuBrV;
+    [ExternalState]
     private Tensor<T>? _gpuBhV;
 
     // Cached forward pass state for backpropagation (BPTT)
+    [ExternalState]
     private Tensor<T>? _gpuLastInput;
     private Tensor<T>[]? _gpuCachedZGates;
     private Tensor<T>[]? _gpuCachedRGates;
     private Tensor<T>[]? _gpuCachedHCandidates;
     private Tensor<T>[]? _gpuCachedHiddenStates;
+    [ExternalState]
     private Tensor<T>? _gpuInitialHiddenState;
 
     // Cached stacked weights for fused kernel (PyTorch format: r, z, n)
@@ -1822,48 +1872,6 @@ private Tensor<T> CreateOnesLike(Tensor<T> tensor)
         return ones;
     }
 
-    /// <summary>
-    /// Creates a deep copy of this GRU layer with independent weights and reset state.
-    /// </summary>
-    /// <returns>A new GRULayer with the same weights but independent of the original.</returns>
-    public override LayerBase<T> Clone()
-    {
-        var clone = (GRULayer<T>)base.Clone();
-
-        // Deep copy all weight tensors
-        clone._Wz = _Wz.Clone();
-        clone._Wr = _Wr.Clone();
-        clone._Wh = _Wh.Clone();
-        clone._Uz = _Uz.Clone();
-        clone._Ur = _Ur.Clone();
-        clone._Uh = _Uh.Clone();
-        clone._bz = _bz.Clone();
-        clone._br = _br.Clone();
-        clone._bh = _bh.Clone();
-
-        // Reset internal state (don't share state between original and clone)
-        clone._lastInput = null;
-        clone._lastHiddenState = null;
-        clone._lastZ = null;
-        clone._lastR = null;
-        clone._lastH = null;
-        clone._allHiddenStates = null;
-        clone._originalInputShape = null;
-
-        // Reset gradients
-        clone._dWz = null;
-        clone._dWr = null;
-        clone._dWh = null;
-        clone._dUz = null;
-        clone._dUr = null;
-        clone._dUh = null;
-        clone._dbz = null;
-        clone._dbr = null;
-        clone._dbh = null;
-
-        return clone;
-    }
-
     /// <summary>
     /// Clears the GPU training cache to release GPU memory.
     /// </summary>
diff --git a/src/NeuralNetworks/Layers/GandalfGFLULayer.cs b/src/NeuralNetworks/Layers/GandalfGFLULayer.cs
index 5725c9669f..94077aed06 100644
--- a/src/NeuralNetworks/Layers/GandalfGFLULayer.cs
+++ b/src/NeuralNetworks/Layers/GandalfGFLULayer.cs
@@ -49,7 +49,9 @@ public partial class GandalfGFLULayer<T> : LayerBase<T>, IShapeContract
     private Tensor<T>[]? _maskLogits;                  // per-stage [numFeatures] feature-mask logits
     private FullyConnectedLayer<T>[]? _inTransform;    // per-stage numFeatures -> 2*numFeatures (GLU)
     private FullyConnectedLayer<T>[]? _gateTransform;  // per-stage numFeatures -> numFeatures (residual gate)
+    [AiDotNet.Attributes.Buffer]
     private Tensor<T>? _valueSelector;                 // [2F, F] constant GLU value split
+    [AiDotNet.Attributes.Buffer]
     private Tensor<T>? _gateSelector;                  // [2F, F] constant GLU gate split
 
     /// <summary>Initializes a GFLU stack.</summary>
diff --git a/src/NeuralNetworks/Layers/GatedFeatureLearningUnitLayer.cs b/src/NeuralNetworks/Layers/GatedFeatureLearningUnitLayer.cs
index e91beccdd5..77a61728e2 100644
--- a/src/NeuralNetworks/Layers/GatedFeatureLearningUnitLayer.cs
+++ b/src/NeuralNetworks/Layers/GatedFeatureLearningUnitLayer.cs
@@ -72,8 +72,11 @@ public partial class GatedFeatureLearningUnitLayer<T> : LayerBase<T>, IShapeCont
     private readonly FullyConnectedLayer<T> _gateTransform;
 
     // Cached values
+    [Scratch]
     private Tensor<T>? _inputCache;
+    [Scratch]
     private Tensor<T>? _transformedCache;
+    [Scratch]
     private Tensor<T>? _gateCache;
 
     /// <inheritdoc/>
diff --git a/src/NeuralNetworks/Layers/GatedFusionLayer.cs b/src/NeuralNetworks/Layers/GatedFusionLayer.cs
index 04b9129269..33e7d7a408 100644
--- a/src/NeuralNetworks/Layers/GatedFusionLayer.cs
+++ b/src/NeuralNetworks/Layers/GatedFusionLayer.cs
@@ -117,19 +117,16 @@ protected override Tensor<T> ForwardTraced(Tensor<T> input)
             Engine.TensorMultiply(inverseGate, languageStream));
     }
 
-    /// <inheritdoc/>
-    /// <remarks>
-    /// The base implementation does not recurse into registered sub-layers, so the gate's
-    /// tensors are surfaced explicitly.
-    /// </remarks>
-    public override IReadOnlyList<Tensor<T>> GetTrainableParameters() => _gate.GetTrainableParameters();
-
-    /// <inheritdoc/>
-    public override void SetTrainableParameters(IReadOnlyList<Tensor<T>> parameters)
-        => _gate.SetTrainableParameters(parameters);
-
-    /// <inheritdoc/>
-    public override void UpdateParameters(Vector<T> parameters) => _gate.UpdateParameters(parameters);
+    // The gate's tensors used to be surfaced here explicitly, on the stated grounds that "the base
+    // implementation does not recurse into registered sub-layers". That is true of the base
+    // GetTrainableParameters, which returns only this layer's own registrations -- but it is not
+    // true of the walk that ParameterCount, GetParameters and SetParameters are actually built
+    // from, which appends every registered sub-layer that no declaration already covers. Handing
+    // the gate's tensors out as this layer's own therefore entered them TWICE: once as trainable
+    // tensors of the parent, once inside the gate's own component. Count and vector both came from
+    // that single doubled walk, so they agreed with each other and nothing reported it.
+    // UpdateParameters(Vector<T>) went with them: the base routes it to SetParameters, which now
+    // spans the gate through the composed walk rather than through this layer's own list.
 
     /// <inheritdoc/>
     public override void ResetState() => _gate.ResetState();
diff --git a/src/NeuralNetworks/Layers/GatedLinearUnitLayer.cs b/src/NeuralNetworks/Layers/GatedLinearUnitLayer.cs
index a7b63c2798..bca806783a 100644
--- a/src/NeuralNetworks/Layers/GatedLinearUnitLayer.cs
+++ b/src/NeuralNetworks/Layers/GatedLinearUnitLayer.cs
@@ -185,6 +185,7 @@ public partial class GatedLinearUnitLayer<T> : LayerBase<T>, IShapeContract
     /// This value is automatically cleared between training batches to save memory.
     /// </para>
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _lastInput;
 
     /// <summary>
@@ -206,6 +207,7 @@ public partial class GatedLinearUnitLayer<T> : LayerBase<T>, IShapeContract
     /// gradients during the backward pass.
     /// </para>
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _lastLinearOutput;
 
     /// <summary>
@@ -227,11 +229,15 @@ public partial class GatedLinearUnitLayer<T> : LayerBase<T>, IShapeContract
     /// of each linear output value passed through to the final output.
     /// </para>
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _lastGateOutput;
 
     // GPU cached tensors for backward pass
+    [ExternalState]
     private Tensor<T>? _gpuInput;
+    [ExternalState]
     private Tensor<T>? _gpuLinearOutput;
+    [ExternalState]
     private Tensor<T>? _gpuGateOutput;
 
     /// <summary>
@@ -253,6 +259,7 @@ public partial class GatedLinearUnitLayer<T> : LayerBase<T>, IShapeContract
     /// that, when gated appropriately, lead to better final outputs.
     /// </para>
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _linearWeightsGradient;
 
     /// <summary>
@@ -274,6 +281,7 @@ public partial class GatedLinearUnitLayer<T> : LayerBase<T>, IShapeContract
     /// information through and when to block it for better results.
     /// </para>
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _gateWeightsGradient;
 
     /// <summary>
@@ -295,6 +303,7 @@ public partial class GatedLinearUnitLayer<T> : LayerBase<T>, IShapeContract
     /// before gating is applied.
     /// </para>
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _linearBiasGradient;
 
     /// <summary>
@@ -316,6 +325,7 @@ public partial class GatedLinearUnitLayer<T> : LayerBase<T>, IShapeContract
     /// for controlling information flow.
     /// </para>
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _gateBiasGradient;
 
     /// <summary>
diff --git a/src/NeuralNetworks/Layers/GaussianNoiseLayer.cs b/src/NeuralNetworks/Layers/GaussianNoiseLayer.cs
index 2407989f85..1b85a5cdbf 100644
--- a/src/NeuralNetworks/Layers/GaussianNoiseLayer.cs
+++ b/src/NeuralNetworks/Layers/GaussianNoiseLayer.cs
@@ -112,7 +112,9 @@ public partial class GaussianNoiseLayer<T> : LayerBase<T>, IShapeContract
     /// containing the specific noise value that was added at that position.
     /// </para>
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _lastNoise;
+    [Scratch]
     private Tensor<T>? _lastInput;
 
     /// <summary>
diff --git a/src/NeuralNetworks/Layers/Gemma2DecoderBlock.cs b/src/NeuralNetworks/Layers/Gemma2DecoderBlock.cs
index 0bc2de0d78..2ab6639aa4 100644
--- a/src/NeuralNetworks/Layers/Gemma2DecoderBlock.cs
+++ b/src/NeuralNetworks/Layers/Gemma2DecoderBlock.cs
@@ -1,4 +1,4 @@
-using System.Collections.Generic;
+using System.Collections.Generic;
 using AiDotNet.ActivationFunctions;
 using AiDotNet.Attributes;
 using AiDotNet.Interfaces;
@@ -6,7 +6,7 @@
 namespace AiDotNet.NeuralNetworks.Layers;
 
 /// <summary>
-/// Gemma-2 decoder block with <em>sandwiched</em> RMSNorms — a norm both before and after each sublayer:
+/// Gemma-2 decoder block with <em>sandwiched</em> RMSNorms — a norm both before and after each sublayer:
 /// <c>x = x + postAttnNorm(Attn(inputNorm(x)))</c> then <c>x = x + postFfnNorm(GeGLU(preFfnNorm(x)))</c>.
 /// The FFN is a gated GeGLU (tanh-GELU gate); RMSNorms use the Gemma <c>(1 + weight)</c> convention (applied
 /// at load time).
@@ -14,7 +14,7 @@ namespace AiDotNet.NeuralNetworks.Layers;
 /// <typeparam name="T">The numeric type used for calculations.</typeparam>
 [LayerCategory(LayerCategory.Attention)]
 [LayerTask(LayerTask.SequenceModeling)]
-[LayerProperty(IsTrainable = false, HasTrainingMode = false, TestInputShape = "1, 4, 8", TestConstructorArgs = "")]
+[LayerProperty(IsTrainable = false, HasTrainingMode = false, TestInputShape = "1, 4, 8", TestConstructorArgs = "8, 16, new AiDotNet.NeuralNetworks.Layers.MultiHeadAttentionLayer<double>(2, 4)")]
 // Shape-preserving at any rank, and structurally so rather than incidentally: ForwardTraced is two
 // residual adds, `Engine.TensorAdd(input, attnNormed)` and `Engine.TensorAdd(afterAttn, ffnNormed)`,
 // and a residual can only add a tensor of its own shape. The FFN widens to ffnDim internally but the
@@ -24,13 +24,24 @@ namespace AiDotNet.NeuralNetworks.Layers;
 [AutoParameters]
 public partial class Gemma2DecoderBlock<T> : LayerBase<T>
 {
+    // Every child reads the block input; only the down-projection reads the expanded width.
+    // Chained sizing walked registration order instead and built the second projection from
+    // the first's output, so a restore met a differently shaped layer than the checkpoint.
+    [SubLayerInput("_hiddenSize")]
     private readonly RMSNormalizationLayer<T> _normInput;
+    [SubLayerInput("1, _hiddenSize")]
     private readonly LayerBase<T> _attention;
+    [SubLayerInput("_hiddenSize")]
     private readonly RMSNormalizationLayer<T> _normPostAttn;
+    [SubLayerInput("_hiddenSize")]
     private readonly RMSNormalizationLayer<T> _normPreFfn;
+    [SubLayerInput("_hiddenSize")]
     private readonly DenseLayer<T> _ffnGate;
+    [SubLayerInput("_hiddenSize")]
     private readonly DenseLayer<T> _ffnUp;
+    [SubLayerInput("_ffnDim")]
     private readonly DenseLayer<T> _ffnDown;
+    [SubLayerInput("_hiddenSize")]
     private readonly RMSNormalizationLayer<T> _normPostFfn;
     private readonly int _hiddenSize;
 
@@ -63,6 +74,12 @@ public partial class Gemma2DecoderBlock<T> : LayerBase<T>
     /// <summary>The model (input/output) feature dimension.</summary>
     public int HiddenSize => _hiddenSize;
 
+    /// <summary>Construction state: the 'ffnDim' the layer was built with.</summary>
+    private readonly int _ffnDim;
+
+    /// <summary>Construction state: the 'rmsNormEpsilon' the layer was built with.</summary>
+    private readonly double _rmsNormEpsilon;
+
     /// <summary>Creates a Gemma-2 decoder block.</summary>
     /// <param name="hiddenSize">Input/output feature dimension.</param>
     /// <param name="ffnDim">FFN inner dimension.</param>
@@ -71,6 +88,8 @@ public partial class Gemma2DecoderBlock<T> : LayerBase<T>
     public Gemma2DecoderBlock(int hiddenSize, int ffnDim, LayerBase<T> attention, double rmsNormEpsilon = 1e-6)
         : base(new[] { -1, hiddenSize }, new[] { -1, hiddenSize })
     {
+        _rmsNormEpsilon = rmsNormEpsilon;
+        _ffnDim = ffnDim;
         Guard.NotNull(attention);
         _hiddenSize = hiddenSize;
         _attention = attention;
diff --git a/src/NeuralNetworks/Layers/GlobalPoolingLayer.cs b/src/NeuralNetworks/Layers/GlobalPoolingLayer.cs
index b6a2ffb37a..6d358cb4e6 100644
--- a/src/NeuralNetworks/Layers/GlobalPoolingLayer.cs
+++ b/src/NeuralNetworks/Layers/GlobalPoolingLayer.cs
@@ -186,6 +186,7 @@ public partial class GlobalPoolingLayer<T> : LayerBase<T>, IShapeContract
     /// This is automatically cleared between training batches to save memory.
     /// </para>
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _lastInput;
 
     /// <summary>
@@ -207,6 +208,7 @@ public partial class GlobalPoolingLayer<T> : LayerBase<T>, IShapeContract
     /// This is also cleared after each training batch to save memory.
     /// </para>
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _lastOutput;
 
     /// <summary>
@@ -215,6 +217,7 @@ public partial class GlobalPoolingLayer<T> : LayerBase<T>, IShapeContract
     private int[]? _maxIndices;
 
     // GPU-resident cached tensors for GPU training pipeline
+    [Scratch]
     private Tensor<T>? _lastOutputGpu;
     private int[]? _lastInputGpuShape;
 
diff --git a/src/NeuralNetworks/Layers/GraphAttentionLayer.cs b/src/NeuralNetworks/Layers/GraphAttentionLayer.cs
index 3b37898ae2..6a80a5fdc2 100644
--- a/src/NeuralNetworks/Layers/GraphAttentionLayer.cs
+++ b/src/NeuralNetworks/Layers/GraphAttentionLayer.cs
@@ -112,6 +112,7 @@ public partial class GraphAttentionLayer<T> : LayerBase<T>, IGraphConvolutionLay
     /// <summary>
     /// The adjacency matrix defining graph structure.
     /// </summary>
+    [AiDotNet.Attributes.FittedParameter(InputSized = true)]
     private Tensor<T>? _adjacencyMatrix;
 
     /// <summary>
@@ -142,6 +143,7 @@ private T GetAdjacencyValue(int b, int i, int j)
     /// <summary>
     /// Cached input from forward pass for backward computation.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastInput;
 
     /// <summary>
@@ -152,16 +154,19 @@ private T GetAdjacencyValue(int b, int i, int j)
     /// <summary>
     /// Cached output from forward pass for backward computation.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastOutput;
 
     /// <summary>
     /// Cached attention coefficients from forward pass.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastAttentionCoefficients;
 
     /// <summary>
     /// Cached pre-softmax attention scores for gradient computation.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastPreSoftmaxScores;
 
 
@@ -169,19 +174,23 @@ private T GetAdjacencyValue(int b, int i, int j)
     /// <summary>
     /// Gradients for weight parameters.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _weightsGradient;
 
     /// <summary>
     /// Gradients for attention parameters.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _attentionWeightsGradient;
 
     /// <summary>
     /// Gradients for bias parameters.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _biasGradient;
 
     // GPU cache fields for backward pass
+    [ExternalState]
     private Tensor<T>? _gpuLastInput;
     private IGpuBuffer? _gpuTransformedCache;  // [numNodes * outputFeatures * numHeads]
     private IGpuBuffer? _gpuAttentionCache;    // [numNodes * numNodes * numHeads]
diff --git a/src/NeuralNetworks/Layers/GraphConvolutionalLayer.cs b/src/NeuralNetworks/Layers/GraphConvolutionalLayer.cs
index 97feaf5a09..e1f1ab3bf9 100644
--- a/src/NeuralNetworks/Layers/GraphConvolutionalLayer.cs
+++ b/src/NeuralNetworks/Layers/GraphConvolutionalLayer.cs
@@ -180,6 +180,7 @@ public partial class GraphConvolutionalLayer<T> : LayerBase<T>, IAuxiliaryLossLa
     /// <summary>
     /// Stores the input tensor from the last forward pass for use in the backward pass.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastInput;
 
     /// <summary>
@@ -190,6 +191,7 @@ public partial class GraphConvolutionalLayer<T> : LayerBase<T>, IAuxiliaryLossLa
     /// <summary>
     /// Stores the output tensor from the last forward pass for use in the backward pass.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastOutput;
 
     /// <summary>
@@ -210,11 +212,13 @@ public partial class GraphConvolutionalLayer<T> : LayerBase<T>, IAuxiliaryLossLa
     /// This matrix tells the layer which nodes should share information with each other.
     /// </para>
     /// </remarks>
+    [AiDotNet.Attributes.FittedParameter(InputSized = true)]
     private Tensor<T>? _adjacencyMatrix;
 
     /// <summary>
     /// Cached reshaped adjacency matrix (3D) for backward pass.
     /// </summary>
+    [AiDotNet.Attributes.Scratch]
     private Tensor<T>? _adjForBatch;
 
     /// <summary>
@@ -251,11 +255,13 @@ public partial class GraphConvolutionalLayer<T> : LayerBase<T>, IAuxiliaryLossLa
     /// <summary>
     /// Stores the gradients for the weights calculated during the backward pass.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _weightsGradient;
 
     /// <summary>
     /// Stores the gradients for the bias calculated during the backward pass.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _biasGradient;
 
     /// <summary>
@@ -278,6 +284,7 @@ public partial class GraphConvolutionalLayer<T> : LayerBase<T>, IAuxiliaryLossLa
     /// to have similar properties while still maintaining their unique characteristics.
     /// </para>
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _lastNodeFeatures;
 
     /// <summary>
@@ -1214,7 +1221,9 @@ private Tensor<T> BatchedMatMul3Dx2D(Tensor<T> input3D, Tensor<T> weights2D, int
         return Engine.Reshape(result, [batch, rows, outputCols]);
     }
 
+    [AiDotNet.Attributes.Buffer]
     private Tensor<T>? _weightsVelocity;
+    [AiDotNet.Attributes.Buffer]
     private Tensor<T>? _biasVelocity;
 
     /// <summary>
diff --git a/src/NeuralNetworks/Layers/GraphIsomorphismLayer.cs b/src/NeuralNetworks/Layers/GraphIsomorphismLayer.cs
index da2e49abe4..945a5a7617 100644
--- a/src/NeuralNetworks/Layers/GraphIsomorphismLayer.cs
+++ b/src/NeuralNetworks/Layers/GraphIsomorphismLayer.cs
@@ -119,11 +119,13 @@ public partial class GraphIsomorphismLayer<T> : LayerBase<T>, IGraphConvolutionL
     /// <summary>
     /// The adjacency matrix defining graph structure.
     /// </summary>
+    [AiDotNet.Attributes.FittedParameter(InputSized = true)]
     private Tensor<T>? _adjacencyMatrix;
 
     /// <summary>
     /// Cached input from forward pass.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastInput;
 
     /// <summary>
@@ -134,26 +136,31 @@ public partial class GraphIsomorphismLayer<T> : LayerBase<T>, IGraphConvolutionL
     /// <summary>
     /// Cached output from forward pass.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastOutput;
 
     /// <summary>
     /// Cached aggregated features (before MLP).
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastAggregated;
 
     /// <summary>
     /// Cached pre-ReLU hidden layer output from MLP.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastMlpHiddenPreRelu;
 
     /// <summary>
     /// Cached hidden layer output from MLP (after ReLU).
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastMlpHidden;
 
     /// <summary>
     /// Cached neighbor sum before applying epsilon.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastNeighborSum;
 
     /// <summary>
@@ -164,9 +171,13 @@ public partial class GraphIsomorphismLayer<T> : LayerBase<T>, IGraphConvolutionL
     /// <summary>
     /// Gradients for MLP weights.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _mlpWeights1Gradient;
+    [Scratch]
     private Tensor<T>? _mlpWeights2Gradient;
+    [Scratch]
     private Tensor<T>? _mlpBias1Gradient;
+    [Scratch]
     private Tensor<T>? _mlpBias2Gradient;
 
     /// <inheritdoc/>
diff --git a/src/NeuralNetworks/Layers/GraphSAGELayer.cs b/src/NeuralNetworks/Layers/GraphSAGELayer.cs
index f71de0cde4..ac5df25b35 100644
--- a/src/NeuralNetworks/Layers/GraphSAGELayer.cs
+++ b/src/NeuralNetworks/Layers/GraphSAGELayer.cs
@@ -106,11 +106,13 @@ public partial class GraphSAGELayer<T> : LayerBase<T>, IGraphConvolutionLayer<T>
     /// <summary>
     /// The adjacency matrix defining graph structure.
     /// </summary>
+    [AiDotNet.Attributes.FittedParameter(InputSized = true)]
     private Tensor<T>? _adjacencyMatrix;
 
     /// <summary>
     /// Cached input from forward pass.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastInput;
 
     /// <summary>
@@ -121,36 +123,43 @@ public partial class GraphSAGELayer<T> : LayerBase<T>, IGraphConvolutionLayer<T>
     /// <summary>
     /// Cached output from forward pass.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastOutput;
 
     /// <summary>
     /// Cached aggregated neighbor features.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastAggregated;
 
     /// <summary>
     /// Cached pre-normalization output for gradient computation.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastPreNorm;
 
     /// <summary>
     /// Cached degrees for each node.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastDegrees;
 
     /// <summary>
     /// Gradients for self weights.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _selfWeightsGradient;
 
     /// <summary>
     /// Gradients for neighbor weights.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _neighborWeightsGradient;
 
     /// <summary>
     /// Gradients for bias.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _biasGradient;
 
     /// <summary>
@@ -166,6 +175,7 @@ public partial class GraphSAGELayer<T> : LayerBase<T>, IGraphConvolutionLayer<T>
     /// <summary>
     /// Cached reshaped adjacency matrix for backward pass.
     /// </summary>
+    [AiDotNet.Attributes.Scratch]
     private Tensor<T>? _adjForBatch;
 
     /// <inheritdoc/>
diff --git a/src/NeuralNetworks/Layers/GraphTransformerLayer.cs b/src/NeuralNetworks/Layers/GraphTransformerLayer.cs
index d1c7d14f50..b09e0f26d9 100644
--- a/src/NeuralNetworks/Layers/GraphTransformerLayer.cs
+++ b/src/NeuralNetworks/Layers/GraphTransformerLayer.cs
@@ -140,6 +140,7 @@ public partial class GraphTransformerLayer<T> : LayerBase<T>, IGraphConvolutionL
     /// <summary>
     /// Structural bias for attention (learned from graph structure): [numHeads, maxNodes, maxNodes]
     /// </summary>
+    [AiDotNet.Attributes.FittedParameter(InputSized = true)]
     private Tensor<T>? _structuralBias;
 
     /// <summary>
@@ -201,40 +202,62 @@ public partial class GraphTransformerLayer<T> : LayerBase<T>, IGraphConvolutionL
     /// <summary>
     /// The adjacency matrix defining graph structure.
     /// </summary>
+    [AiDotNet.Attributes.FittedParameter(InputSized = true)]
     private Tensor<T>? _adjacencyMatrix;
 
     /// <summary>
     /// Cached values for backward pass.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastInput;
 
     /// <summary>
     /// Stores the original input shape for any-rank tensor support.
     /// </summary>
     private int[]? _originalInputShape;
+    [Scratch]
     private Tensor<T>? _lastOutput;
+    [Scratch]
     private Tensor<T>? _lastQueries;
+    [Scratch]
     private Tensor<T>? _lastKeys;
+    [Scratch]
     private Tensor<T>? _lastValues;
+    [Scratch]
     private Tensor<T>? _lastAttentionWeights;
+    [Scratch]
     private Tensor<T>? _lastHeadOutputs;
+    [Scratch]
     private Tensor<T>? _lastConcatenated;
+    [Scratch]
     private Tensor<T>? _lastAttnOutput;
+    [Scratch]
     private Tensor<T>? _lastNormed1;
+    [Scratch]
     private Tensor<T>? _lastFFNHidden;
+    [Scratch]
     private Tensor<T>? _lastFFNOutput;
 
     /// <summary>
     /// Gradients for parameters.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _queryWeightsGradient;
+    [Scratch]
     private Tensor<T>? _keyWeightsGradient;
+    [Scratch]
     private Tensor<T>? _valueWeightsGradient;
+    [Scratch]
     private Tensor<T>? _outputWeightsGradient;
+    [Scratch]
     private Tensor<T>? _outputBiasGradient;
+    [Scratch]
     private Tensor<T>? _ffnWeights1Gradient;
+    [Scratch]
     private Tensor<T>? _ffnWeights2Gradient;
+    [Scratch]
     private Tensor<T>? _ffnBias1Gradient;
+    [Scratch]
     private Tensor<T>? _ffnBias2Gradient;
 
     private readonly int _ffnHiddenDim;
@@ -1264,37 +1287,6 @@ public override void ClearGradients()
         _ffnBias2Gradient = null;
     }
 
-    /// <inheritdoc/>
-    public override void Serialize(BinaryWriter writer)
-    {
-        base.Serialize(writer);
-        bool hasBias = _structuralBias != null;
-        writer.Write(hasBias);
-        if (hasBias)
-        {
-            var bias = _structuralBias ?? throw new InvalidOperationException("Structural bias is null during serialization.");
-            writer.Write(bias.Shape.Length);
-            foreach (var dim in bias._shape) writer.Write(dim);
-            for (int i = 0; i < bias.Length; i++)
-                writer.Write(NumOps.ToDouble(bias[i]));
-        }
-    }
-
-    public override void Deserialize(BinaryReader reader)
-    {
-        base.Deserialize(reader);
-        bool hasBias = reader.ReadBoolean();
-        if (hasBias)
-        {
-            int rank = reader.ReadInt32();
-            var shape = new int[rank];
-            for (int i = 0; i < rank; i++) shape[i] = reader.ReadInt32();
-            _structuralBias = new Tensor<T>(shape);
-            for (int i = 0; i < _structuralBias.Length; i++)
-                _structuralBias[i] = NumOps.FromDouble(reader.ReadDouble());
-        }
-    }
-
     public override void ResetState()
     {
         _lastInput = null;
diff --git a/src/NeuralNetworks/Layers/GroupNormalizationLayer.cs b/src/NeuralNetworks/Layers/GroupNormalizationLayer.cs
index 491956de93..fe76fa28dc 100644
--- a/src/NeuralNetworks/Layers/GroupNormalizationLayer.cs
+++ b/src/NeuralNetworks/Layers/GroupNormalizationLayer.cs
@@ -55,35 +55,51 @@ public partial class GroupNormalizationLayer<T> : LayerBase<T>
 
     private Tensor<T> _gamma;
     private Tensor<T> _beta;
+    [Scratch]
     private Tensor<T>? _lastInput;
+    [Scratch]
     private Tensor<T>? _lastMean;
+    [Scratch]
     private Tensor<T>? _lastVariance;
+    [Scratch]
     private Tensor<T>? _gammaGradient;
+    [Scratch]
     private Tensor<T>? _betaGradient;
 
     #region GPU Training Fields
 
     // Cached GPU tensors for GPU-resident training
+    [ExternalState]
     private Tensor<T>? _gpuLastInput;
 
     // GPU weight buffers
+    [ExternalState]
     private Tensor<T>? _gpuGamma;
+    [ExternalState]
     private Tensor<T>? _gpuBeta;
 
     // GPU gradient buffers
+    [ExternalState]
     private Tensor<T>? _gpuGammaGradient;
+    [ExternalState]
     private Tensor<T>? _gpuBetaGradient;
 
     // GPU optimizer state buffers (velocity/momentum)
+    [ExternalState]
     private Tensor<T>? _gpuGammaVelocity;
+    [ExternalState]
     private Tensor<T>? _gpuBetaVelocity;
 
     // GPU optimizer state buffers (first moment for Adam)
+    [ExternalState]
     private Tensor<T>? _gpuGammaM;
+    [ExternalState]
     private Tensor<T>? _gpuBetaM;
 
     // GPU optimizer state buffers (second moment for Adam)
+    [ExternalState]
     private Tensor<T>? _gpuGammaV;
+    [ExternalState]
     private Tensor<T>? _gpuBetaV;
 
     #endregion
diff --git a/src/NeuralNetworks/Layers/GroupedQueryAttentionLayer.cs b/src/NeuralNetworks/Layers/GroupedQueryAttentionLayer.cs
index a9d4da5103..fb14917d16 100644
--- a/src/NeuralNetworks/Layers/GroupedQueryAttentionLayer.cs
+++ b/src/NeuralNetworks/Layers/GroupedQueryAttentionLayer.cs
@@ -1,4 +1,4 @@
-using AiDotNet.Attributes;
+using AiDotNet.Attributes;
 using AiDotNet.Autodiff;
 using AiDotNet.Enums;
 using AiDotNet.Interfaces;
@@ -29,7 +29,7 @@ namespace AiDotNet.NeuralNetworks.Layers;
 /// With GQA (64 Q heads, 8 KV heads):
 /// - 64 Query projections, but only 8 Key and 8 Value projections
 /// - Each K/V head is shared by 8 Query heads (64/8 = 8)
-/// - KV-cache stores only 8 sets → 8x less memory!
+/// - KV-cache stores only 8 sets → 8x less memory!
 ///
 /// Used by Llama 2 70B, Llama 3, Mistral, Gemma 2, and most modern large LLMs.
 /// </para>
@@ -53,8 +53,8 @@ public partial class GroupedQueryAttentionLayer<T> : LayerBase<T>, IShapeContrac
 
     // Deferred (lazy) weight allocation (#1671). When true, the projection weights are left
     // zero-sized at construction and materialized (allocated + initialized) on first use. A
-    // foundation-scale stack (e.g. Flag-DiT's 32 layers × 4096 hidden) otherwise eagerly
-    // allocates ~1.3 B weights per model in the constructor — gigabytes and >10 s before a
+    // foundation-scale stack (e.g. Flag-DiT's 32 layers × 4096 hidden) otherwise eagerly
+    // allocates ~1.3 B weights per model in the constructor — gigabytes and >10 s before a
     // single forward, which defeats the weight-streaming forward path and the cheap-construction
     // contract the sibling DenseLayer lazy path (NoisePredictorBase.LazyDense) already honors.
     // The weight shapes are fully derivable from the dimension fields above, so ParameterCount is
@@ -65,7 +65,7 @@ public partial class GroupedQueryAttentionLayer<T> : LayerBase<T>, IShapeContrac
     // invokes Forward on a shared instance from multiple threads (today CheckpointBlocks and the
     // diffusion sampling loop are sequential, so it never races): the lock-free fast path reads the
     // flag with acquire semantics, and EnsureWeightsMaterialized flips it to false LAST (release)
-    // so any thread seeing false also sees the fully-allocated tensors — never a half-built state.
+    // so any thread seeing false also sees the fully-allocated tensors — never a half-built state.
     private volatile bool _weightsDeferred;
     private readonly object _materializeLock = new();
 
@@ -113,8 +113,8 @@ public partial class GroupedQueryAttentionLayer<T> : LayerBase<T>, IShapeContrac
     private Tensor<T> _valueBias;
     private readonly bool _useProjectionBias;
 
-    // Attention-logit soft-cap (Gemma-2 attn_logit_softcapping): when > 0, each scaled Q·Kᵀ score is
-    // passed through softcap·tanh(score / softcap) before the softmax. 0 disables it (standard SDPA).
+    // Attention-logit soft-cap (Gemma-2 attn_logit_softcapping): when > 0, each scaled Q·Kᵀ score is
+    // passed through softcap·tanh(score / softcap) before the softmax. 0 disables it (standard SDPA).
     private readonly double _attnLogitSoftcap;
 
     // Causal masking: when true, position i attends only to positions <= i (decoder / autoregressive LM).
@@ -131,22 +131,36 @@ public partial class GroupedQueryAttentionLayer<T> : LayerBase<T>, IShapeContrac
     private ALiBiPositionalBiasLayer<T>? _alibiLayer;
 
     // Cached values for backward pass
+    [Scratch]
     private Tensor<T>? _lastInput;
+    [Scratch]
     private Tensor<T>? _lastOutput;
+    [Scratch]
     private Tensor<T>? _lastProjectedQueries;
+    [Scratch]
     private Tensor<T>? _lastProjectedKeys;
+    [Scratch]
     private Tensor<T>? _lastProjectedValues;
+    [Scratch]
     private Tensor<T>? _lastExpandedKeys;
+    [Scratch]
     private Tensor<T>? _lastExpandedValues;
+    [Scratch]
     private Tensor<T>? _lastAttentionWeights;
+    [Scratch]
     private Tensor<T>? _lastAttentionContext;
     private int[]? _originalInputShape;
 
     // Gradients
+    [Scratch]
     private Tensor<T>? _queryWeightsGradient;
+    [Scratch]
     private Tensor<T>? _keyWeightsGradient;
+    [Scratch]
     private Tensor<T>? _valueWeightsGradient;
+    [Scratch]
     private Tensor<T>? _outputWeightsGradient;
+    [Scratch]
     private Tensor<T>? _outputBiasGradient;
 
     /// <inheritdoc />
@@ -175,8 +189,8 @@ public partial class GroupedQueryAttentionLayer<T> : LayerBase<T>, IShapeContrac
 
     /// <summary>
     /// Gets the attention-logit soft-cap magnitude (Gemma-2 <c>attn_logit_softcapping</c>);
-    /// 0 when disabled. When positive, each scaled Q·Kᵀ score is passed through
-    /// <c>softcap·tanh(score / softcap)</c> before the softmax.
+    /// 0 when disabled. When positive, each scaled Q·Kᵀ score is passed through
+    /// <c>softcap·tanh(score / softcap)</c> before the softmax.
     /// </summary>
     public double AttnLogitSoftcap => _attnLogitSoftcap;
 
@@ -208,6 +222,12 @@ public AttentionVariant Variant
     /// </summary>
     public double RoPETheta => _ropeLayer?.Theta ?? 10000.0;
 
+    /// <summary>Construction state: the 'sequenceLength' the layer was built with.</summary>
+    private readonly int _sequenceLength;
+
+    /// <summary>Construction state: the 'deferAllocation' the layer was built with.</summary>
+    private readonly bool _deferAllocation;
+
     /// <summary>
     /// Creates a new Grouped-Query Attention layer.
     /// </summary>
@@ -233,6 +253,8 @@ public GroupedQueryAttentionLayer(
             [sequenceLength, embeddingDimension],
             activationFunction ?? new IdentityActivation<T>())
     {
+        _deferAllocation = deferAllocation;
+        _sequenceLength = sequenceLength;
         // With an explicit head dimension the projection widths are numHeads*headDim (which may differ
         // from embeddingDimension, e.g. Gemma-style decoders), so embeddingDimension need not be divisible
         // by numHeads. Only the default (headDim = embeddingDimension/numHeads) requires that divisibility.
@@ -356,7 +378,7 @@ private void EnsureWeightsMaterialized()
             _valueBias = new Tensor<T>([_useProjectionBias ? _numKVHeads * _headDimension : 0]);
             InitializeParameters();
             // Flip the flag LAST (volatile release): a concurrent reader either sees true and
-            // blocks on the lock above, or sees false with every tensor allocated + initialized —
+            // blocks on the lock above, or sees false with every tensor allocated + initialized —
             // never the in-between state the previous flag-first ordering allowed.
             _weightsDeferred = false;
         }
@@ -365,13 +387,13 @@ private void EnsureWeightsMaterialized()
     /// <summary>
     /// A deferred-allocation layer reports NOT initialized until its weights are materialized. Eager layers
     /// are always initialized. (The <c>[TrainableParameter]</c> source generator owns this layer's
-    /// <c>EnsureInitialized</c> — it has sub-layer fields — so the deferred-weight allocation is driven
+    /// <c>EnsureInitialized</c> — it has sub-layer fields — so the deferred-weight allocation is driven
     /// through <see cref="EnsureParametersMaterialized"/> instead, which <c>MaterializeParameters()</c> calls.)
     /// </summary>
     public override bool IsInitialized => !_weightsDeferred;
 
     /// <inheritdoc/>
-    /// <remarks>Forces the deferred projection weights to materialize — the hook
+    /// <remarks>Forces the deferred projection weights to materialize — the hook
     /// <see cref="LayerBase{T}.MaterializeParameters"/> invokes, so the foundation-scale chunk-streaming
     /// path (#1624) reads real weights rather than zero-length placeholders.</remarks>
     protected override void EnsureParametersMaterialized()
@@ -488,7 +510,7 @@ protected override Tensor<T> ForwardTraced(Tensor<T> input)
             && _alibiLayer == null
             && AiDotNet.Tensors.Engines.Autodiff.GradientTape<T>.Current is null)
         {
-            // ── Inference fast path ──────────────────────────────────────────────
+            // ── Inference fast path ──────────────────────────────────────────────
             // Fused interleaved RoPE + GQA-aware scaled-dot-product attention, both
             // dispatched to the device engine (float-specialized CPU / GPU kernels).
             // This eliminates the two dominant CPU self-time costs on the decoder
@@ -517,7 +539,7 @@ protected override Tensor<T> ForwardTraced(Tensor<T> input)
         }
         else
         {
-            // ── Training / ALiBi path (tape-recorded, manual-backward caches) ─────
+            // ── Training / ALiBi path (tape-recorded, manual-backward caches) ─────
             // Apply RoPE to Q and K (before KV head expansion)
             if (_ropeLayer != null)
             {
@@ -568,7 +590,7 @@ protected override Tensor<T> ForwardTraced(Tensor<T> input)
         var output = Engine.TensorMatMul(contextTransposed, _outputWeights);
         var output3D = Engine.Reshape(output, new[] { batchSize, seqLen, _embeddingDimension });
 
-        // Add bias — reshape bias fresh each call so the tape has a live GradFn
+        // Add bias — reshape bias fresh each call so the tape has a live GradFn
         // chain from _outputBias on every training step (a cached reshape primed
         // during inference would dead-end backward at the cached handle).
         var biasBroadcast = Engine.Reshape(_outputBias, new[] { 1, 1, _embeddingDimension });
@@ -577,7 +599,7 @@ protected override Tensor<T> ForwardTraced(Tensor<T> input)
 
         _lastOutput = cacheBwd ? result : null;
 
-        // Reshape back to original rank — via Engine for tape recording.
+        // Reshape back to original rank — via Engine for tape recording.
         if (rank == 2)
             return Engine.Reshape(result, new[] { seqLen, _embeddingDimension });
 
@@ -646,12 +668,12 @@ private Tensor<T> ExpandKVHeads(Tensor<T> kv)
 
     private Tensor<T> ComputeStandardAttention(Tensor<T> queries, Tensor<T> keys, Tensor<T> values, out Tensor<T> attentionWeightsOut)
     {
-        // Standard scaled dot-product attention: softmax(Q·K^T / sqrt(d_k)) · V.
+        // Standard scaled dot-product attention: softmax(Q·K^T / sqrt(d_k)) · V.
         // Manual implementation was 6 nested loops doing per-element NumOps
-        // dispatches — O(batch · numHeads · seqLenQ · seqLenKV · headDim) virtual
-        // calls per Q·K^T pass plus the same again for attn·V. Replaced with
-        // Engine.ScaledDotProductAttention which fuses Q·K^T, scale, softmax,
-        // and attn·V into one kernel call (and gives a SIMD/GPU dispatch when
+        // dispatches — O(batch · numHeads · seqLenQ · seqLenKV · headDim) virtual
+        // calls per Q·K^T pass plus the same again for attn·V. Replaced with
+        // Engine.ScaledDotProductAttention which fuses Q·K^T, scale, softmax,
+        // and attn·V into one kernel call (and gives a SIMD/GPU dispatch when
         // available).
         int headDim = queries.Shape[3];
         // Causal decoders pass a boolean mask (true = a query may attend to that key, i.e. key <= query),
@@ -815,7 +837,7 @@ internal override Dictionary<string, string> GetMetadata()
         // can reconstruct the layer without fabricating any dimension. Without
         // SequenceLength + EmbeddingDimension here, the deser path would fall
         // back to inputShape[0]/[1] (correct for rank-2 [seq, dim] payloads)
-        // or to hardcoded 16/64 if the shape is degenerate — issue #1239.
+        // or to hardcoded 16/64 if the shape is degenerate — issue #1239.
         var ci = System.Globalization.CultureInfo.InvariantCulture;
         metadata["SequenceLength"] = InputShape[0].ToString();
         metadata["EmbeddingDimension"] = _embeddingDimension.ToString();
@@ -826,7 +848,7 @@ internal override Dictionary<string, string> GetMetadata()
         metadata["PositionalEncoding"] = PositionalEncoding.ToString();
         // Persist the remaining shape/behaviour-affecting ctor arguments so a deserialized (cloned) layer is
         // functionally identical. Without these a clone silently lost its causal mask, custom head dimension
-        // (Gemma), Q/K/V projection bias (Qwen2), attention logit soft-cap (Gemma-2), and RoPE — producing
+        // (Gemma), Q/K/V projection bias (Qwen2), attention logit soft-cap (Gemma-2), and RoPE — producing
         // wrong outputs on the cloned model (e.g. the paged incremental-serving clone of a GGUF decoder).
         metadata["HeadDimension"] = _headDimension.ToString(ci);
         metadata["UseCausalMask"] = _useCausalMask.ToString();
diff --git a/src/NeuralNetworks/Layers/HeterogeneousGraphLayer.cs b/src/NeuralNetworks/Layers/HeterogeneousGraphLayer.cs
index 3983a65676..83b767e342 100644
--- a/src/NeuralNetworks/Layers/HeterogeneousGraphLayer.cs
+++ b/src/NeuralNetworks/Layers/HeterogeneousGraphLayer.cs
@@ -181,12 +181,14 @@ public partial class HeterogeneousGraphLayer<T> : LayerBase<T>, IGraphConvolutio
     /// <summary>
     /// Cached values for backward pass.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastInput;
 
     /// <summary>
     /// Stores the original input shape for any-rank tensor support.
     /// </summary>
     private int[]? _originalInputShape;
+    [Scratch]
     private Tensor<T>? _lastOutput;
 
     /// <summary>
@@ -195,6 +197,7 @@ public partial class HeterogeneousGraphLayer<T> : LayerBase<T>, IGraphConvolutio
     private Dictionary<string, Tensor<T>>? _edgeTypeWeightsGradients;
     private Dictionary<string, Tensor<T>>? _selfLoopWeightsGradients;
     private Dictionary<string, Tensor<T>>? _biasesGradients;
+    [Scratch]
     private Tensor<T>? _basisMatricesGradient;
     private Dictionary<string, Tensor<T>>? _basisCoefficientsGradients;
 
diff --git a/src/NeuralNetworks/Layers/HighwayLayer.cs b/src/NeuralNetworks/Layers/HighwayLayer.cs
index 327aba5ea0..ba61845814 100644
--- a/src/NeuralNetworks/Layers/HighwayLayer.cs
+++ b/src/NeuralNetworks/Layers/HighwayLayer.cs
@@ -159,58 +159,73 @@ public partial class HighwayLayer<T> : LayerBase<T>, IAuxiliaryLossLayer<T>, ISh
     /// <summary>
     /// Stores the input tensor from the last forward pass for use in the backward pass.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastInput;
 
     /// <summary>
     /// Stores the output tensor from the last forward pass for use in the backward pass.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastOutput;
 
     /// <summary>
     /// Stores the transformed output tensor from the last forward pass for use in the backward pass.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastTransformOutput;
 
     /// <summary>
     /// Stores the gate output tensor from the last forward pass for use in the backward pass.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastGateOutput;
 
     /// <summary>
     /// Stores the pre-activation transform values from the last forward pass.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastTransformPreActivation;
 
     /// <summary>
     /// Stores the pre-activation gate values from the last forward pass.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastGatePreActivation;
 
     /// <summary>
     /// Stores the gradients for the transform weights calculated during the backward pass.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _transformWeightsGradient;
 
     /// <summary>
     /// Stores the gradients for the transform bias calculated during the backward pass.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _transformBiasGradient;
 
     /// <summary>
     /// Stores the gradients for the gate weights calculated during the backward pass.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _gateWeightsGradient;
 
     /// <summary>
     /// Stores the gradients for the gate bias calculated during the backward pass.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _gateBiasGradient;
 
     // GPU cached tensors for backward pass
+    [ExternalState]
     private Tensor<T>? _gpuInput;
+    [ExternalState]
     private Tensor<T>? _gpuTransformOutput;
+    [ExternalState]
     private Tensor<T>? _gpuGateOutput;
+    [ExternalState]
     private Tensor<T>? _gpuTransformPreActivation;
+    [ExternalState]
     private Tensor<T>? _gpuGatePreActivation;
     private int[]? _gpuInputShape;
 
@@ -323,6 +338,9 @@ public partial class HighwayLayer<T> : LayerBase<T>, IAuxiliaryLossLayer<T>, ISh
     /// </summary>
     protected override bool SupportsGpuExecution => true;
 
+    /// <summary>Construction state: the 'inputDimension' the layer was built with.</summary>
+    private readonly int _inputDimension;
+
     /// <summary>
     /// Initializes a new instance of the <see cref="HighwayLayer{T}"/> class with the specified dimensions and element-wise activation functions.
     /// </summary>
@@ -352,6 +370,7 @@ public HighwayLayer(int inputDimension, IActivationFunction<T>? transformActivat
         IInitializationStrategy<T>? initializationStrategy = null)
         : base([inputDimension], [inputDimension], transformActivation ?? new TanhActivation<T>())
     {
+        _inputDimension = inputDimension;
         AuxiliaryLossWeight = NumOps.FromDouble(0.01);
         _lastGateBalanceLoss = NumOps.Zero;
 
@@ -399,6 +418,7 @@ public HighwayLayer(int inputDimension, IActivationFunction<T>? transformActivat
     public HighwayLayer(int inputDimension, IVectorActivationFunction<T>? transformActivation = null, IVectorActivationFunction<T>? gateActivation = null)
         : base([inputDimension], [inputDimension], transformActivation ?? new TanhActivation<T>())
     {
+        _inputDimension = inputDimension;
         AuxiliaryLossWeight = NumOps.FromDouble(0.01);
         _lastGateBalanceLoss = NumOps.Zero;
 
diff --git a/src/NeuralNetworks/Layers/HyperbolicLinearLayer.cs b/src/NeuralNetworks/Layers/HyperbolicLinearLayer.cs
index ce803cff47..e38666707b 100644
--- a/src/NeuralNetworks/Layers/HyperbolicLinearLayer.cs
+++ b/src/NeuralNetworks/Layers/HyperbolicLinearLayer.cs
@@ -67,6 +67,7 @@ public partial class HyperbolicLinearLayer<T> : LayerBase<T>, IShapeContract
     private Tensor<T> _weights;
 
     /// <summary>Cached W^T — invalidated when weights change.</summary>
+    [Scratch]
     private Tensor<T>? _weightsTCache;
 
     /// <summary>
@@ -86,6 +87,7 @@ public partial class HyperbolicLinearLayer<T> : LayerBase<T>, IShapeContract
     /// <summary>
     /// Stored input from forward pass for backpropagation.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastInput;
 
     /// <summary>
@@ -96,16 +98,19 @@ public partial class HyperbolicLinearLayer<T> : LayerBase<T>, IShapeContract
     /// <summary>
     /// Stored pre-activation output for gradient computation.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastOutput;
 
     /// <summary>
     /// Gradient for weights, stored during backward pass.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _weightsGradient;
 
     /// <summary>
     /// Gradient for biases, stored during backward pass.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _biasesGradient;
 
 
diff --git a/src/NeuralNetworks/Layers/InstanceNormalizationLayer.cs b/src/NeuralNetworks/Layers/InstanceNormalizationLayer.cs
index b75493e95e..107257aca8 100644
--- a/src/NeuralNetworks/Layers/InstanceNormalizationLayer.cs
+++ b/src/NeuralNetworks/Layers/InstanceNormalizationLayer.cs
@@ -83,13 +83,18 @@ public partial class InstanceNormalizationLayer<T> : LayerBase<T>, IShapeContrac
         Shape = "_numChannels", Condition = nameof(Affine))]
     private Tensor<T> _beta;
     private Tensor<T>? _lastInput;
+    [Scratch]
     private Tensor<T>? _lastMean;
+    [Scratch]
     private Tensor<T>? _lastVariance;
+    [Scratch]
     private Tensor<T>? _gammaGradient;
+    [Scratch]
     private Tensor<T>? _betaGradient;
     private int[] _originalInputShape = [];
 
     // GPU cached tensors for backward pass
+    [ExternalState]
     private Tensor<T>? _gpuInput;
     private IGpuBuffer? _gpuMean;
     private IGpuBuffer? _gpuInvVar;
diff --git a/src/NeuralNetworks/Layers/InteractingLayer.cs b/src/NeuralNetworks/Layers/InteractingLayer.cs
index 23e57d8275..2e16d64671 100644
--- a/src/NeuralNetworks/Layers/InteractingLayer.cs
+++ b/src/NeuralNetworks/Layers/InteractingLayer.cs
@@ -1,4 +1,4 @@
-using AiDotNet.Helpers;
+using AiDotNet.Helpers;
 using AiDotNet.Autodiff;
 using AiDotNet.Attributes;
 
@@ -66,27 +66,43 @@ public partial class InteractingLayer<T> : LayerBase<T>, IShapeContract
     private Tensor<T> _outputWeights;  // [attentionDim, embeddingDim]
 
     // Residual projection (if dimensions don't match)
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T>? _residualWeights;  // [embeddingDim, embeddingDim] if needed
 
     // Gradients
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _queryWeightsGrad;
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _keyWeightsGrad;
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _valueWeightsGrad;
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _outputWeightsGrad;
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T>? _residualWeightsGrad;
 
     // Cached values
+    [Scratch]
     private Tensor<T>? _inputCache;
+    [Scratch]
     private Tensor<T>? _queriesCache;
+    [Scratch]
     private Tensor<T>? _keysCache;
+    [Scratch]
     private Tensor<T>? _valuesCache;
+    [Scratch]
     private Tensor<T>? _attentionScoresCache;
+    [Scratch]
     private Tensor<T>? _attendedCache;
+    [Scratch]
     private Tensor<T>? _preActivationCache;
 
     /// <inheritdoc/>
     public override bool SupportsTraining => true;
 
+    /// <summary>Construction state: the 'initScale' the layer was built with.</summary>
+    private readonly double _initScale;
+
     /// <summary>
     /// Initializes an interacting layer.
     /// </summary>
@@ -103,6 +119,7 @@ public InteractingLayer(
         double initScale = 0.02)
         : base([embeddingDim], [embeddingDim])
     {
+        _initScale = initScale;
         _embeddingDim = embeddingDim;
         _numHeads = numHeads;
         _attentionDim = attentionDim ?? embeddingDim;
diff --git a/src/NeuralNetworks/Layers/InternImageBlockLayer.cs b/src/NeuralNetworks/Layers/InternImageBlockLayer.cs
index 761287aa4f..773230b815 100644
--- a/src/NeuralNetworks/Layers/InternImageBlockLayer.cs
+++ b/src/NeuralNetworks/Layers/InternImageBlockLayer.cs
@@ -40,6 +40,7 @@ public sealed partial class InternImageBlockLayer<T> : LayerBase<T>, IShapeContr
     private readonly ConvolutionalLayer<T> _project;
     private readonly LayerBase<T>[] _parameterLayers;
     private readonly LayerBase<T>[] _allLayers;
+    [Scratch]
     private Vector<T>? _pendingParameters;
 
     /// <summary>Creates an InternImage block for a fixed channel width.</summary>
diff --git a/src/NeuralNetworks/Layers/IntersampleAttentionLayer.cs b/src/NeuralNetworks/Layers/IntersampleAttentionLayer.cs
index 00e61eb42c..c9f2906969 100644
--- a/src/NeuralNetworks/Layers/IntersampleAttentionLayer.cs
+++ b/src/NeuralNetworks/Layers/IntersampleAttentionLayer.cs
@@ -71,7 +71,9 @@ public partial class IntersampleAttentionLayer<T> : LayerBase<T>, IShapeContract
     private Tensor<T> _layerNormBeta;
 
     // Cached values for backward pass
+    [Scratch]
     private Tensor<T>? _inputCache;
+    [Scratch]
     private Tensor<T>? _normalizedCache;
 
     /// <inheritdoc/>
diff --git a/src/NeuralNetworks/Layers/InvertedResidualBlock.cs b/src/NeuralNetworks/Layers/InvertedResidualBlock.cs
index a96f1aee8d..0fc85c131b 100644
--- a/src/NeuralNetworks/Layers/InvertedResidualBlock.cs
+++ b/src/NeuralNetworks/Layers/InvertedResidualBlock.cs
@@ -115,6 +115,7 @@ public partial class InvertedResidualBlock<T> : LayerBase<T>, ILayerSerializatio
     // path: sub-layers are still null then, so we stash the vector here
     // and replay it inside OnFirstForward once the channel-count-driven
     // layout is known and sub-layers exist.
+    [Scratch]
     private Vector<T>? _pendingParameters;
 
     // Non-readonly: lazy ctor leaves _useResidual = false until
@@ -123,15 +124,25 @@ public partial class InvertedResidualBlock<T> : LayerBase<T>, ILayerSerializatio
     private readonly bool _hasExpansion;
     private readonly bool _useSE;
 
+    [Scratch]
     private Tensor<T>? _lastInput;
+    [Scratch]
     private Tensor<T>? _lastExpandOut;
+    [Scratch]
     private Tensor<T>? _lastExpandBnOut;
+    [Scratch]
     private Tensor<T>? _lastExpandActOut;
+    [Scratch]
     private Tensor<T>? _lastDwOut;
+    [Scratch]
     private Tensor<T>? _lastDwBnOut;
+    [Scratch]
     private Tensor<T>? _lastDwActOut;
+    [Scratch]
     private Tensor<T>? _lastSeOut;
+    [Scratch]
     private Tensor<T>? _lastProjectOut;
+    [Scratch]
     private Tensor<T>? _lastProjectBnOut;
 
     /// <summary>
@@ -659,6 +670,7 @@ void ILayerSerializationExtras<T>.SetExtraParameters(Vector<T> extraParameters)
     /// called pre-OnFirstForward. Replayed inside OnFirstForward once
     /// _expandBn/_dwBn/_projectBn are allocated.
     /// </summary>
+    [Scratch]
     private Vector<T>? _pendingExtraParameters;
 
     private void ApplyExtraParametersUnsafe(Vector<T> extraParameters)
diff --git a/src/NeuralNetworks/Layers/LSTMLayer.cs b/src/NeuralNetworks/Layers/LSTMLayer.cs
index e4c8e95bef..f44addcba4 100644
--- a/src/NeuralNetworks/Layers/LSTMLayer.cs
+++ b/src/NeuralNetworks/Layers/LSTMLayer.cs
@@ -431,6 +431,7 @@ public partial class LSTMLayer<T> : LayerBase<T>, IShapeContract
     /// how you processed it if asked.
     /// </para>
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _lastInput;
 
     /// <summary>
@@ -452,21 +453,25 @@ public partial class LSTMLayer<T> : LayerBase<T>, IShapeContract
     /// and passed to the next step.
     /// </para>
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _lastHiddenState;
 
     /// <summary>
     /// The cell state from the last forward pass.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastCellState;
 
     /// <summary>
     /// Cached hidden states for all time steps (Batch, Time, Hidden).
     /// </summary>
+    [Scratch]
     private Tensor<T>? _cachedHiddenStates;
 
     /// <summary>
     /// Cached cell states for all time steps (Batch, Time, Hidden).
     /// </summary>
+    [Scratch]
     private Tensor<T>? _cachedCellStates;
 
     /// <summary>
@@ -585,74 +590,135 @@ public partial class LSTMLayer<T> : LayerBase<T>, IShapeContract
     #region GPU Training Fields
 
     // GPU-resident weight tensors
+    [ExternalState]
     private Tensor<T>? _gpuWeightsFi;
+    [ExternalState]
     private Tensor<T>? _gpuWeightsIi;
+    [ExternalState]
     private Tensor<T>? _gpuWeightsCi;
+    [ExternalState]
     private Tensor<T>? _gpuWeightsOi;
+    [ExternalState]
     private Tensor<T>? _gpuWeightsFh;
+    [ExternalState]
     private Tensor<T>? _gpuWeightsIh;
+    [ExternalState]
     private Tensor<T>? _gpuWeightsCh;
+    [ExternalState]
     private Tensor<T>? _gpuWeightsOh;
+    [ExternalState]
     private Tensor<T>? _gpuBiasF;
+    [ExternalState]
     private Tensor<T>? _gpuBiasI;
+    [ExternalState]
     private Tensor<T>? _gpuBiasC;
+    [ExternalState]
     private Tensor<T>? _gpuBiasO;
 
     // GPU-resident gradient tensors
+    [ExternalState]
     private Tensor<T>? _gpuWeightsFiGradient;
+    [ExternalState]
     private Tensor<T>? _gpuWeightsIiGradient;
+    [ExternalState]
     private Tensor<T>? _gpuWeightsCiGradient;
+    [ExternalState]
     private Tensor<T>? _gpuWeightsOiGradient;
+    [ExternalState]
     private Tensor<T>? _gpuWeightsFhGradient;
+    [ExternalState]
     private Tensor<T>? _gpuWeightsIhGradient;
+    [ExternalState]
     private Tensor<T>? _gpuWeightsChGradient;
+    [ExternalState]
     private Tensor<T>? _gpuWeightsOhGradient;
+    [ExternalState]
     private Tensor<T>? _gpuBiasFGradient;
+    [ExternalState]
     private Tensor<T>? _gpuBiasIGradient;
+    [ExternalState]
     private Tensor<T>? _gpuBiasCGradient;
+    [ExternalState]
     private Tensor<T>? _gpuBiasOGradient;
 
     // GPU-resident optimizer state tensors (velocity for SGD momentum, M/V for Adam)
+    [ExternalState]
     private Tensor<T>? _gpuWeightsFiVelocity;
+    [ExternalState]
     private Tensor<T>? _gpuWeightsIiVelocity;
+    [ExternalState]
     private Tensor<T>? _gpuWeightsCiVelocity;
+    [ExternalState]
     private Tensor<T>? _gpuWeightsOiVelocity;
+    [ExternalState]
     private Tensor<T>? _gpuWeightsFhVelocity;
+    [ExternalState]
     private Tensor<T>? _gpuWeightsIhVelocity;
+    [ExternalState]
     private Tensor<T>? _gpuWeightsChVelocity;
+    [ExternalState]
     private Tensor<T>? _gpuWeightsOhVelocity;
+    [ExternalState]
     private Tensor<T>? _gpuBiasFVelocity;
+    [ExternalState]
     private Tensor<T>? _gpuBiasIVelocity;
+    [ExternalState]
     private Tensor<T>? _gpuBiasCVelocity;
+    [ExternalState]
     private Tensor<T>? _gpuBiasOVelocity;
 
     // Adam M/V buffers
+    [ExternalState]
     private Tensor<T>? _gpuWeightsFiM;
+    [ExternalState]
     private Tensor<T>? _gpuWeightsFiV;
+    [ExternalState]
     private Tensor<T>? _gpuWeightsIiM;
+    [ExternalState]
     private Tensor<T>? _gpuWeightsIiV;
+    [ExternalState]
     private Tensor<T>? _gpuWeightsCiM;
+    [ExternalState]
     private Tensor<T>? _gpuWeightsCiV;
+    [ExternalState]
     private Tensor<T>? _gpuWeightsOiM;
+    [ExternalState]
     private Tensor<T>? _gpuWeightsOiV;
+    [ExternalState]
     private Tensor<T>? _gpuWeightsFhM;
+    [ExternalState]
     private Tensor<T>? _gpuWeightsFhV;
+    [ExternalState]
     private Tensor<T>? _gpuWeightsIhM;
+    [ExternalState]
     private Tensor<T>? _gpuWeightsIhV;
+    [ExternalState]
     private Tensor<T>? _gpuWeightsChM;
+    [ExternalState]
     private Tensor<T>? _gpuWeightsChV;
+    [ExternalState]
     private Tensor<T>? _gpuWeightsOhM;
+    [ExternalState]
     private Tensor<T>? _gpuWeightsOhV;
+    [ExternalState]
     private Tensor<T>? _gpuBiasFM;
+    [ExternalState]
     private Tensor<T>? _gpuBiasFV;
+    [ExternalState]
     private Tensor<T>? _gpuBiasIM;
+    [ExternalState]
     private Tensor<T>? _gpuBiasIV;
+    [ExternalState]
     private Tensor<T>? _gpuBiasCM;
+    [ExternalState]
     private Tensor<T>? _gpuBiasCV;
+    [ExternalState]
     private Tensor<T>? _gpuBiasOM;
+    [ExternalState]
     private Tensor<T>? _gpuBiasOV;
 
     // Cached forward pass state for backpropagation (per timestep arrays)
+    [ExternalState]
     private Tensor<T>? _gpuLastInput;
     private Tensor<T>[]? _gpuCachedForgetGates;
     private Tensor<T>[]? _gpuCachedInputGates;
@@ -660,7 +726,9 @@ public partial class LSTMLayer<T> : LayerBase<T>, IShapeContract
     private Tensor<T>[]? _gpuCachedOutputGates;
     private Tensor<T>[]? _gpuCachedCellStates;
     private Tensor<T>[]? _gpuCachedHiddenStates;
+    [ExternalState]
     private Tensor<T>? _gpuInitialHiddenState;
+    [ExternalState]
     private Tensor<T>? _gpuInitialCellState;
 
     // Cached stacked weights for fused kernel (PyTorch format: i, f, g, o)
@@ -675,8 +743,11 @@ public partial class LSTMLayer<T> : LayerBase<T>, IShapeContract
     // [4*hidden, *] arrays is invariant across forward calls while the weights are
     // unchanged, so cache it and reuse on repeated inference. Invalidated alongside
     // the GPU stacked weights whenever the underlying weights mutate.
+    [AiDotNet.Attributes.Scratch]
     private Tensor<float>? _cpuStackedWeightsIh;
+    [AiDotNet.Attributes.Scratch]
     private Tensor<float>? _cpuStackedWeightsHh;
+    [AiDotNet.Attributes.Scratch]
     private Tensor<float>? _cpuStackedBiasIh;
     private bool _cpuStackedWeightsValid;
 
@@ -2299,94 +2370,6 @@ public override void UpdateParameters(T learningRate)
         InvalidateCpuStackedWeights();
     }
 
-    /// <summary>
-    /// Serializes the LSTM layer's parameters to a binary stream.
-    /// </summary>
-    /// <param name="writer">The binary writer to write to.</param>
-    /// <remarks>
-    /// <para>
-    /// This method saves all weights and biases of the LSTM layer to a binary stream. This allows the layer's
-    /// state to be saved to a file and loaded later, which is useful for saving trained models or for
-    /// transferring parameters between different instances.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method saves the layer's learned values to a file.
-    /// 
-    /// Serialization is like taking a snapshot of the layer's current state:
-    /// - All weights and biases are written to a file
-    /// - The exact format ensures they can be loaded back correctly
-    /// - This lets you save a trained model for later use
-    /// 
-    /// For example, after training your model for hours or days, you can save it
-    /// and then load it later without having to retrain.
-    /// </para>
-    /// </remarks>
-    public override void Serialize(BinaryWriter writer)
-    {
-        SerializationHelper<T>.SerializeTensor(writer, _weightsFi);
-        SerializationHelper<T>.SerializeTensor(writer, _weightsIi);
-        SerializationHelper<T>.SerializeTensor(writer, _weightsCi);
-        SerializationHelper<T>.SerializeTensor(writer, _weightsOi);
-        SerializationHelper<T>.SerializeTensor(writer, _weightsFh);
-        SerializationHelper<T>.SerializeTensor(writer, _weightsIh);
-        SerializationHelper<T>.SerializeTensor(writer, _weightsCh);
-        SerializationHelper<T>.SerializeTensor(writer, _weightsOh);
-        SerializationHelper<T>.SerializeTensor(writer, _biasF);
-        SerializationHelper<T>.SerializeTensor(writer, _biasI);
-        SerializationHelper<T>.SerializeTensor(writer, _biasC);
-        SerializationHelper<T>.SerializeTensor(writer, _biasO);
-    }
-
-    /// <summary>
-    /// Deserializes the LSTM layer's parameters from a binary stream.
-    /// </summary>
-    /// <param name="reader">The binary reader to read from.</param>
-    /// <remarks>
-    /// <para>
-    /// This method loads all weights and biases of the LSTM layer from a binary stream. This allows the layer
-    /// to restore its state from a previously saved file, which is useful for loading trained models or for
-    /// transferring parameters between different instances.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method loads previously saved values into the layer.
-    /// 
-    /// Deserialization is like restoring a saved snapshot:
-    /// - All weights and biases are read from a file
-    /// - The layer's internal state is set to match what was saved
-    /// - This lets you use a previously trained model without retraining
-    /// 
-    /// For example, you could train a model on a powerful computer, save it,
-    /// and then load it on a less powerful device for actual use.
-    /// </para>
-    /// </remarks>
-    public override void Deserialize(BinaryReader reader)
-    {
-        _weightsFi = SerializationHelper<T>.DeserializeTensor(reader);
-        _weightsIi = SerializationHelper<T>.DeserializeTensor(reader);
-        _weightsCi = SerializationHelper<T>.DeserializeTensor(reader);
-        _weightsOi = SerializationHelper<T>.DeserializeTensor(reader);
-        _weightsFh = SerializationHelper<T>.DeserializeTensor(reader);
-        _weightsIh = SerializationHelper<T>.DeserializeTensor(reader);
-        _weightsCh = SerializationHelper<T>.DeserializeTensor(reader);
-        _weightsOh = SerializationHelper<T>.DeserializeTensor(reader);
-        _biasF = SerializationHelper<T>.DeserializeTensor(reader);
-        _biasI = SerializationHelper<T>.DeserializeTensor(reader);
-        _biasC = SerializationHelper<T>.DeserializeTensor(reader);
-        _biasO = SerializationHelper<T>.DeserializeTensor(reader);
-
-        // Recover the lazy-init state from the loaded tensor shapes. Without this,
-        // a lazy-constructed layer that just deserialized real weights would have
-        // its weights overwritten on the first Forward by EnsureInitialized's
-        // re-allocation path.
-        if (_weightsFi.Shape.Length >= 2 && _weightsFi.Shape[1] > 0)
-        {
-            _inputSize = _weightsFi.Shape[1];
-            _isInitialized = true;
-        }
-
-        // Invalidate stacked weight buffers since weights have been replaced from deserialization
-        InvalidateGpuStackedWeights();
-        InvalidateCpuStackedWeights();
-    }
-
     public override Vector<T> GetParameterGradients()
     {
         if (Gradients == null || Gradients.Count == 0)
diff --git a/src/NeuralNetworks/Layers/LambdaLayer.cs b/src/NeuralNetworks/Layers/LambdaLayer.cs
index d7aec84d1b..4b5a025bf6 100644
--- a/src/NeuralNetworks/Layers/LambdaLayer.cs
+++ b/src/NeuralNetworks/Layers/LambdaLayer.cs
@@ -164,15 +164,27 @@ public partial class LambdaLayer<T> : LayerBase<T>, IShapeContract
     /// </para>
     /// </remarks>
     private readonly Func<ComputationNode<T>, ComputationNode<T>>? _traceableExpression;
+    /// <summary>
+    /// The forward transformation as an expression tree, when the layer was given one.
+    /// </summary>
+    /// <remarks>
+    /// Kept alongside the compiled delegate because compiling discards the tree, and the tree is
+    /// what lets a closure survive a save without naming a method.
+    /// </remarks>
+    private readonly System.Linq.Expressions.Expression<Func<Tensor<T>, Tensor<T>>>? _forwardExpression;
+
+
 
     /// <summary>
     /// Stores the input tensor from the last forward pass for use in the backward pass.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastInput;
 
     /// <summary>
     /// Stores the output tensor from the last forward pass for use in the backward pass.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastOutput;
 
     /// <summary>
@@ -320,6 +332,37 @@ public LambdaLayer(int[] inputShape, int[] outputShape,
         // Backward function is automatically derived from the computation graph
         _backwardFunction = null;
     }
+    /// <summary>
+    /// Creates a lambda layer from an expression tree, which survives a save.
+    /// </summary>
+    /// <param name="inputShape">The shape of the input tensor.</param>
+    /// <param name="outputShape">The shape of the output tensor.</param>
+    /// <param name="forwardExpression">The transformation, as an expression rather than a delegate.</param>
+    /// <param name="activationFunction">The activation applied after the transformation.</param>
+    /// <remarks>
+    /// <para>
+    /// The expression is kept as well as compiled. Compiling is one-way -- the tree cannot be
+    /// recovered from the resulting delegate -- so a layer built from a plain <c>Func</c> has
+    /// nothing to record but the function's name, and a lambda does not have one.
+    /// </para>
+    /// <para>
+    /// Prefer the <c>ComputationNode</c> overload where the transformation can be written in tensor
+    /// operations: a traced graph records what the function did, so it survives captured state as
+    /// well, and its replay can only ever call a tensor operation. This overload is for a
+    /// transformation that has to reach outside those operations and still be saveable.
+    /// </para>
+    /// </remarks>
+    public LambdaLayer(int[] inputShape, int[] outputShape,
+                       System.Linq.Expressions.Expression<Func<Tensor<T>, Tensor<T>>> forwardExpression,
+                       IActivationFunction<T>? activationFunction = null)
+        : base(inputShape, outputShape, activationFunction ?? new ReLUActivation<T>())
+    {
+        _forwardExpression = forwardExpression ?? throw new ArgumentNullException(nameof(forwardExpression));
+        _forwardFunction = forwardExpression.Compile();
+        _backwardFunction = null;
+    }
+
+
 
     /// <summary>
     /// Performs the forward pass of the lambda layer.
diff --git a/src/NeuralNetworks/Layers/LayerBase.cs b/src/NeuralNetworks/Layers/LayerBase.cs
index e8e9205da7..afbdeeb179 100644
--- a/src/NeuralNetworks/Layers/LayerBase.cs
+++ b/src/NeuralNetworks/Layers/LayerBase.cs
@@ -1,10 +1,12 @@
 using AiDotNet.Helpers;
 using AiDotNet.ActivationFunctions;
+using AiDotNet.Attributes;
 using AiDotNet.Initialization;
 using AiDotNet.Interfaces;
 using AiDotNet.NeuralNetworks.Graph;
 using AiDotNet.Memory;
 using AiDotNet.Models.Parameters;
+using AiDotNet.Serialization;
 using AiDotNet.Tensors.Engines;
 using AiDotNet.Tensors.LinearAlgebra;
 using AiDotNet.Tensors.Engines.Autodiff;
@@ -191,6 +193,7 @@ public abstract class LayerBase<T> : ILayer<T>, ITrainableLayer<T>, IParameterSo
     /// known. This is deliberately separate from <see cref="Parameters"/>: pending state is not a
     /// live parameter slot and therefore must not be counted or returned by <see cref="GetParameters"/>.
     /// </summary>
+    [Scratch]
     private Vector<T>? _pendingParameterRestore;
 
     /// <summary>Length of a parked lazy-restore payload, or zero for ordinary own storage.</summary>
@@ -521,6 +524,14 @@ public BufferRegistration(
     /// </summary>
     public int? RandomSeed { get; set; }
 
+    /// <summary>Copies base-owned stochastic progress into a reconstructed clone.</summary>
+    internal void CopyBaseRandomStateTo(LayerBase<T> clone, bool shareRandomState)
+    {
+        if (clone is null) throw new ArgumentNullException(nameof(clone));
+        clone._initWeightsCallCounter = shareRandomState ? _initWeightsCallCounter : 0;
+        clone.SetTrainingMode(IsTrainingMode);
+    }
+
     /// <summary>
     /// Assigns <see cref="RandomSeed"/> from the active
     /// <see cref="LayerInitializationSeedScope"/> when no seed has been set yet.
@@ -605,19 +616,6 @@ protected void MarkTrainableParametersRebound()
         _reboundParametersAdopted = false;
         _trainableParametersRebound = true;
         BumpParameterEpoch();
-        OnParameterValuesChanged();
-    }
-
-    /// <summary>
-    /// Notifies a layer that its trainable parameter values or tensor bindings changed.
-    /// </summary>
-    /// <remarks>
-    /// Layers that derive packed, transposed, quantized, or otherwise cached representations from
-    /// their parameters override this hook to discard those representations. The base implementation
-    /// is intentionally empty; persistent engine tensors are invalidated by the restore path itself.
-    /// </remarks>
-    protected virtual void OnParameterValuesChanged()
-    {
     }
 
     /// <summary>
@@ -752,11 +750,7 @@ protected static void DeclareParameterSubLayer(
         List<DeclaredParameterComponent> components,
         ILayer<T>? layer)
     {
-        // A child can be reachable through more than one field (for example, a direct named field
-        // plus separate "parameter layers" and "all layers" bookkeeping arrays). Those are aliases,
-        // not independent checkpoint slots. Generated declarations and the runtime registry must
-        // therefore share the same reference-identity idempotence as RegisterSubLayer.
-        if (layer is not null && !ContainsDeclaredSubLayer(components, layer))
+        if (layer is not null)
             components.Add(new DeclaredParameterComponent(
                 DeclaredParameterComponentKind.SubLayer, layer: layer));
     }
@@ -774,42 +768,6 @@ protected virtual bool TryInferInputShapeFromParameterCount(
         return false;
     }
 
-    /// <summary>
-    /// Gives a layer whose shape is ALREADY resolved a chance to re-bind its parameter tensors to a
-    /// different input width that <paramref name="parameterCount"/> pins exactly, instead of having
-    /// <see cref="SetParameters"/> reject the payload.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// The sibling <see cref="TryInferInputShapeFromParameterCount"/> only runs while the shape is
-    /// still unknown. Once a forward has materialized the weights, a payload sized for another width
-    /// -- the shape Clone produces when it carries a resolved width across -- had nowhere to go and
-    /// SetParameters threw. Override this to re-allocate, and return <c>true</c> only when the new
-    /// layout genuinely matches; the caller re-reads the manifest and still throws if it does not.
-    /// </para>
-    /// <para>
-    /// Rebind through <see cref="ReplaceTrainableParameter"/>, never unregister/register: the latter
-    /// appends, which reorders the registry against field order and transposes the layer's
-    /// parameters on the next copy-on-write clone.
-    /// </para>
-    /// </remarks>
-    /// <param name="parameterCount">Length of the payload being restored.</param>
-    /// <returns><c>true</c> if the layer re-bound itself and the caller should re-check the layout.</returns>
-    protected virtual bool TryRebindForParameterCount(int parameterCount) => false;
-
-    /// <summary>
-    /// Whether <paramref name="parameterCount"/> is achievable by this layer at SOME input shape.
-    /// </summary>
-    /// <remarks>
-    /// Consulted only while the shape is still unresolved, to decide whether
-    /// <see cref="SetParameters"/> should park a payload for later replay or reject it now.
-    /// The default returns <c>true</c> -- a layer that cannot decide must defer, which is the
-    /// long-standing behaviour. Override it where the parameter count follows a known formula in
-    /// the unresolved axis, so an impossible vector fails at the call that supplied it instead of
-    /// at some later forward.
-    /// </remarks>
-    protected virtual bool CanEverAcceptParameterCount(int parameterCount) => true;
-
     /// <summary>
     /// Returns the one ordered component walk used by count, flat read/write, state chunks, and
     /// gradient scattering. Generated declarations are authoritative for order; runtime registries
@@ -845,7 +803,7 @@ private DeclaredParameterComponent[] GetOrderedParameterComponents()
             }
 
             var components = new List<DeclaredParameterComponent>();
-            if (Parameters.Length > 0)
+            if (Parameters.Length > 0 && !LegacyParametersAreDerivedSnapshot)
             {
                 components.Add(new DeclaredParameterComponent(
                     DeclaredParameterComponentKind.Legacy));
@@ -870,11 +828,18 @@ private DeclaredParameterComponent[] GetOrderedParameterComponents()
                 for (int i = 0; i < buffers.Count; i++)
                 {
                     var (name, tensor) = buffers[i];
-                    if (tensor is not null && !ContainsDeclaredTensor(components, tensor))
-                    {
-                        DeclareParameterBuffer(
-                            components, tensor, name, GetRegisteredBufferStateRole(name));
-                    }
+                    if (tensor is null || ContainsDeclaredTensor(components, tensor)) continue;
+
+                    // An input-sized slot is registered so it serializes and deep-copies, but it
+                    // must not become a component: its width is the caller's data, and a width the
+                    // caller can move is a width no count-versus-vector contract can hold. Skipping
+                    // it HERE and not only in the generated declaration is what actually keeps it
+                    // out -- this sweep re-adds every registered buffer the declaration omitted,
+                    // which is exactly the "capable machinery reached by a second path" shape.
+                    var stateRole = GetRegisteredBufferStateRole(name);
+                    if (stateRole == ParameterSlotRole.InputSizedState) continue;
+
+                    DeclareParameterBuffer(components, tensor, name, stateRole);
                 }
             }
 
@@ -979,6 +944,39 @@ internal bool CanAdoptTrainableParametersWithoutMaterialization(
         return true;
     }
 
+    /// <summary>
+    /// Validates supplied tensors against this layer's active generated shape declaration when the
+    /// declaration is concrete enough to answer.
+    /// </summary>
+    /// <remarks>
+    /// A materialized destination can still carry stale tensors whose shapes happen to match the
+    /// source while contradicting its own construction metadata. Copy-on-write preflight must ask
+    /// the declaration as well as the current storage; otherwise adoption fails only after the
+    /// clone has already been partially rebound. Runtime-registered layers have no active generated
+    /// declaration and therefore remain valid by construction.
+    /// </remarks>
+    internal bool TrainableParametersConformToActiveDeclaration(
+        IReadOnlyList<Tensor<T>> parameters)
+    {
+        if (!HasActiveDeclaredParameterShapes) return true;
+
+        var declared = DeclaredParameterShapes();
+        // An unresolved declaration cannot answer yet. The existing current-shape and lazy-adoption
+        // checks remain the conservative authority for that state.
+        if (declared is null || declared.Count == 0) return true;
+        if (declared.Count != parameters.Count) return false;
+
+        for (int i = 0; i < declared.Count; i++)
+        {
+            var parameter = parameters[i];
+            if (parameter is null || parameter.Length == 0 || parameter.Shape.Length == 0
+                || !ShapeMatchesDeclared(parameter, declared[i].Expected))
+                return false;
+        }
+
+        return true;
+    }
+
     /// <summary>
     /// Materializes this layer, if it can be, before its parameter values are read or written.
     /// </summary>
@@ -1068,7 +1066,159 @@ private void EnsureMaterializedForParameterSurface()
     /// all follow from that one answer.
     /// </para>
     /// </remarks>
-    protected virtual bool ParametersAreConstructionSized => false;
+    protected virtual bool ParametersAreConstructionSized
+        => DeclaredShapesAreFullyConcrete() || DeclaredSubLayerShapesCoverEveryChild();
+
+    /// <summary>
+    /// True when every registered sub-layer's input width is declared, with concrete axes.
+    /// </summary>
+    /// <remarks>
+    /// A composite of its own holds no parameter shapes, so the derivation above answers false for
+    /// every one of them and the declared-count fast path was unreachable for exactly the layers
+    /// whose children are lazy. But a composite that states which width each child receives HAS
+    /// said its size is known at construction -- that is the whole content of the claim -- and the
+    /// count can then be derived without materializing anything, which is what
+    /// <see cref="ParameterCount"/> needs to stay allocation-free while still agreeing with
+    /// <see cref="GetParameters"/>.
+    /// <para>
+    /// Concreteness is already guaranteed by the declaration itself: it returns empty if any child
+    /// is still null or any axis is still negative, so a non-empty one is a resolved one.
+    /// </para>
+    /// </remarks>
+    /// <summary>
+    /// Fixes every child's dimensions without allocating, so a count folds the same graph a value
+    /// read would.
+    /// </summary>
+    /// <remarks>
+    /// The declaration is authoritative where one exists; the chain covers the rest, including
+    /// children held in collections, which a per-field declaration cannot describe. Both are
+    /// idempotent and both are already run by the value path, so this adds no state the layer would
+    /// not have reached the moment anyone asked for its parameters.
+    /// </remarks>
+    private void ResolveSubLayerShapesForCounting()
+    {
+        // ONCE PER LAYER, and never re-entrantly. The walk below folds each child's ParameterCount,
+        // which runs this same resolution for that child's subtree -- so without a latch a single
+        // count re-walked every descendant once per ancestor, and the bring-up itself reads shapes
+        // that can ask a child for its count again. That crashed the test host outright rather than
+        // failing a test: UnitTests.TimeSeries died after 109 tests with "Test host process
+        // crashed", and passed 115/115 with this method removed.
+        //
+        // Sound as a latch because it records SHAPES, which change only when the parameter set
+        // does, and every such mutation already bumps the epoch this checks against.
+        if (_subLayerShapesResolvedEpoch == System.Threading.Volatile.Read(ref s_parameterEpoch)) return;
+        if (_subLayerShapeResolutionInProgress) return;
+
+        var subs = GetSubLayers();
+        if (subs is null || subs.Count == 0) return;
+
+        _subLayerShapeResolutionInProgress = true;
+        bool wasResolvingShapesOnly = IsResolvingShapesOnly;
+        IsResolvingShapesOnly = true;
+        try
+        {
+            BringUpDeclaredSubLayers();
+            BringUpUndeclaredSubLayersByChain();
+        }
+        finally
+        {
+            IsResolvingShapesOnly = wasResolvingShapesOnly;
+            _subLayerShapeResolutionInProgress = false;
+        }
+
+        // LATCH ONLY ON SUCCESS. Re-entry is prevented by the flag above; this epoch stamp means
+        // "there is nothing left to resolve", and stamping it before the work conflated that with
+        // "an attempt was made". A composite consulted once before its declaration was ready --
+        // during construction, when an int field still reads zero -- was then locked out of every
+        // later attempt in the same epoch, and its children stayed deferred for good.
+        for (int i = 0; i < subs.Count; i++)
+        {
+            if (subs[i] is LayerBase<T> child && !child.IsShapeResolved) return;
+        }
+
+        _subLayerShapesResolvedEpoch = System.Threading.Volatile.Read(ref s_parameterEpoch);
+    }
+
+    /// <summary>
+    /// Parameter epoch at which this layer last resolved its children's shapes for counting.
+    /// </summary>
+    private int _subLayerShapesResolvedEpoch = -1;
+
+    /// <summary>Guards re-entry while a resolution pass is running.</summary>
+    private bool _subLayerShapeResolutionInProgress;
+
+    private bool DeclaredSubLayerShapesCoverEveryChild()
+    {
+        var declared = DeclaredSubLayerShapes();
+        if (declared is null || declared.Count == 0) return false;
+
+        var subs = GetSubLayers();
+        if (subs is null || subs.Count == 0) return false;
+
+        for (int i = 0; i < subs.Count; i++)
+        {
+            var child = subs[i];
+            if (child is null) continue;
+
+            bool covered = false;
+            for (int j = 0; j < declared.Count; j++)
+            {
+                if (ReferenceEquals(declared[j].Child, child)) { covered = true; break; }
+            }
+            // A partially declared composite must NOT claim to be construction-sized: the children
+            // it left out are the ones that would go missing from the total.
+            if (!covered) return false;
+        }
+        return true;
+    }
+
+    /// <summary>
+    /// True when every declared parameter axis is already a positive size, i.e. nothing this layer
+    /// declares depends on an input that has not arrived.
+    /// </summary>
+    /// <returns>Whether the declared shapes can be allocated right now.</returns>
+    /// <remarks>
+    /// <para>
+    /// This is the default answer to <see cref="ParametersAreConstructionSized"/>, derived rather
+    /// than written per layer. Seven layer types declared that override by hand out of roughly 321;
+    /// every other layer whose weights are sized entirely by its constructor had the same latent
+    /// bug, and it surfaced as a short count on restore: a composite materialized only the children
+    /// that happened to carry the override, so <c>TransformerEncoderBlock</c> counted its attention
+    /// weights and silently omitted its two norms and both FFN projections, then rejected the saved
+    /// vector as "Expected 4256 parameters, but got 12608".
+    /// </para>
+    /// <para>
+    /// Derived at RUNTIME from the generated declarations rather than syntactically in the
+    /// generator, because the axis grammar cannot answer it alone: an axis written as a plain
+    /// constructor expression still reads back as the -1 lazy sentinel until the layer resolves,
+    /// and <c>*</c> / <c>*(binding)</c> become -2. Asking the shapes what they currently are covers
+    /// all three without a table of special cases.
+    /// </para>
+    /// <para>
+    /// A layer that declares nothing answers false, exactly as before: silence is not a claim that
+    /// the weights are construction-sized, and treating it as one would have every legacy layer
+    /// allocate against an unknown shape.
+    /// </para>
+    /// </remarks>
+    private bool DeclaredShapesAreFullyConcrete()
+    {
+        var declared = DeclaredParameterShapes();
+        if (declared is null || declared.Count == 0) return false;
+
+        for (int i = 0; i < declared.Count; i++)
+        {
+            var expected = declared[i].Expected;
+            if (expected.Length == 0) return false;
+
+            for (int axis = 0; axis < expected.Length; axis++)
+            {
+                // <= 0 covers both sentinels: -1 "not resolved yet" and -2 "adaptive".
+                if (expected[axis] <= 0) return false;
+            }
+        }
+
+        return true;
+    }
 
     /// <summary>
     /// Forces lazy weight allocation now (the same materialization the first <c>Forward</c> performs),
@@ -1087,6 +1237,21 @@ private void EnsureMaterializedForParameterSurface()
     /// </remarks>
     internal void MaterializeParameters() => EnsureParametersMaterialized();
 
+    /// <summary>
+    /// Commits tensors installed by a generated/base trainable-parameter setter without recursively
+    /// materializing child modules.
+    /// </summary>
+    /// <remarks>
+    /// Copy-on-write cloning installs each graph node independently. A generated setter deliberately
+    /// leaves a rebound-adoption signal for the common initialization lifecycle; if the clone is
+    /// forwarded before that signal is consumed, a shape-only layer can run its first-forward
+    /// reconciliation and allocate over the shared trained tensors. Calling the public recursive
+    /// materialization boundary here would allocate descendants before their own COW slots are
+    /// installed, defeating the memory guarantee. This own-node boundary consumes the signal and
+    /// completes pending shape-only provenance while leaving every child to its graph-order turn.
+    /// </remarks>
+    internal void CommitTrainableParameterAdoption() => EnsureOwnParametersMaterialized();
+
     /// <inheritdoc />
     void IParameterSurfaceLifecycle.PrepareParameterSurface(ParameterSurfaceIntent intent)
     {
@@ -1247,6 +1412,19 @@ protected virtual IReadOnlyList<TensorShape> DeclaredParameterCountShapes()
     /// </summary>
     protected virtual bool IsDeclaredParameterFree => false;
 
+    /// <summary>
+    /// Declares that the inherited legacy <see cref="Parameters"/> vector is a cached flat view of
+    /// this layer's generated tensor and child-layer parameter graph, rather than additional owned
+    /// parameter storage.
+    /// </summary>
+    /// <remarks>
+    /// Some migrated composite layers historically assigned <c>Parameters = GetParameters()</c>
+    /// after constructing their children. Counting that snapshot as a legacy component as well as
+    /// walking the children publishes every child value twice. The parameter generator recognizes
+    /// that assignment and overrides this contract for the affected partial layer.
+    /// </remarks>
+    protected virtual bool LegacyParametersAreDerivedSnapshot => false;
+
     /// <summary>
     /// Computes this layer's own parameter width from declared shapes without allocating lazy
     /// tensors. Child layers are intentionally excluded: the owning graph walk visits each child
@@ -1367,6 +1545,13 @@ public IReadOnlyList<ParameterSlotDescriptor> GetParameterLayout()
     {
         EnsureDeclaredSubLayerStructure();
 
+        // The detailed manifest must observe the same allocation-free child-shape bring-up as
+        // ParameterCount. Network-level manifests call this method directly instead of folding the
+        // aggregate count, so omitting the walk left constructor-sized composite children marked
+        // ShapeDeferred even though their owner had declared every input width. A subsequent value
+        // read materialized those children and produced a longer vector than the manifest described.
+        ResolveSubLayerShapesForCounting();
+
         // Preserve mixed readiness at the same granularity as the recursive value walk. A
         // composite is not one indivisible parameter slot: its own tensors and each child become
         // ready independently. Collapsing the whole subtree into a single aggregate meant one
@@ -1506,6 +1691,18 @@ internal bool DeclaredSurfaceNeedsMaterialization()
     private bool TryGetDeclaredParameterCount(out long count, out bool materialized)
     {
         EnsureDeclaredSubLayerStructure();
+
+        // Shapes, never weights. A declared child that has not resolved cannot report a declared
+        // count, so the whole fast path fails and the caller falls back to the walk that sees a
+        // deferred child as zero. Resolving under the shapes-only flag is what the declaration is
+        // for -- it fixes the dimensions and allocates nothing, which is the one thing counting is
+        // allowed to do (this property is read from Dispose and from fingerprinting, and
+        // allocating there threw OutOfMemoryException on a 774M-parameter model).
+        bool wasResolvingShapesOnly = IsResolvingShapesOnly;
+        IsResolvingShapesOnly = true;
+        try { BringUpDeclaredSubLayers(); }
+        finally { IsResolvingShapesOnly = wasResolvingShapesOnly; }
+
         if (!TryGetOwnDeclaredParameterCount(out count, out materialized)) return false;
 
         var subs = GetSubLayers();
@@ -1555,13 +1752,6 @@ private void EnsureDeclaredSubLayerStructure()
         try
         {
             EnsureInitializationSerialized();
-            // Registration establishes WHO the children are; their generated [SubLayerInput]
-            // declarations establish the exact geometry each one receives. Consume both pieces
-            // while the shape-only guard is active so a manifest read can count every declared
-            // child without allocating its tensors. Without this second step a composite exposed
-            // its child graph but left lazy Dense projections at ShapeDeferred, while the later
-            // GetParameters value boundary resolved them and returned a longer vector.
-            BringUpDeclaredSubLayers();
         }
         finally
         {
@@ -1843,18 +2033,6 @@ protected virtual void EnsureParametersMaterialized()
     {
         EnsureOwnParametersMaterialized();
 
-        // A registered child can still be shape-deferred. The generated [SubLayerInput]
-        // declarations are the owner's authoritative description of the internal topology, so
-        // bring those children to storage before the generic recursion. This is the value-boundary
-        // counterpart of EnsureDeclaredSubLayerStructure's allocation-free manifest pass.
-        // A parent's [SubLayerInput] declaration is authoritative only once the parent itself has
-        // a real input geometry (or explicitly promises constructor-sized parameters). An unresolved
-        // standalone composite must keep its deferred children deferred: resolving them from constant
-        // member dimensions here would turn GetParameters into an implicit architecture decision and
-        // change a partial, honest manifest into allocated state before the parent has seen an input.
-        if (IsShapeResolved || ParametersAreConstructionSized)
-            BringUpDeclaredSubLayers();
-
         // Then the children, because a composite's parameter surface IS its children's:
         // ParameterCount, GetParameters and SetParameters all fold GetSubLayers(). Materializing
         // only the parent leaves that surface partial in exactly the way a checkpoint cannot
@@ -1863,6 +2041,21 @@ protected virtual void EnsureParametersMaterialized()
         // stay correct with NO override of its own: the base already knows the children, so
         // asking each of them the same question is the whole implementation. EnsureInitialized
         // is idempotent, so re-entry through a diamond costs a branch.
+        //
+        // DECLARED children first. BringUpDeclaredSubLayers was written for exactly this moment and
+        // nothing in this class called it -- two layers in the library invoked it by hand and every
+        // other composite's [SubLayerInput] declaration was inert. That made declaring a width
+        // actively HARMFUL: the chain below returns early once a declaration exists, so a layer that
+        // gained one stopped materializing its children altogether and reported an empty parameter
+        // surface from both sides. Agreeing at zero is not agreement, and a sweep comparing the two
+        // surfaces cannot tell the difference -- SwinPatchMerging, ClozeAttention and
+        // TransformerEncoderLayer all sat at 0 == 0 looking fixed.
+        //
+        // The chain stays as the fallback for composites that declare nothing, and still guards
+        // itself on the declaration being empty, so the two never both run.
+        BringUpDeclaredSubLayers();
+        BringUpUndeclaredSubLayersByChain();
+
         var subs = GetSubLayers();
         if (subs is not null)
         {
@@ -1875,11 +2068,185 @@ protected virtual void EnsureParametersMaterialized()
         TryApplyPendingParameterRestore();
     }
 
+    /// <summary>
+    /// Sizes an un-annotated composite's children by walking them in order, taking each one's input
+    /// from the previous one's OUTPUT.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// <see cref="DeclaredSubLayerShapes"/> stays authoritative and this runs only when it is empty:
+    /// a composite that states which child receives which width has answered better than any
+    /// traversal can. But the generator emits that declaration only from <c>[SubLayerInput]</c>,
+    /// which exactly two layers in the library carry, so every other composite offered nothing and
+    /// its children stayed placeholders — a fresh <c>TransformerEncoderBlock</c> held its attention
+    /// and both norms but neither feed-forward projection, counting 16,704 against a saved 33,280.
+    /// </para>
+    /// <para>
+    /// Reading OUTPUTS is what makes this exact rather than heuristic. A block's widths are not
+    /// uniform — its feed-forward expands to the FFN width and contracts back — but each child's
+    /// input is, by construction, whatever the child before it produced, so the walk derives the
+    /// expansion without knowing such a thing exists.
+    /// </para>
+    /// <para>
+    /// A child that refuses the shape is SKIPPED, not treated as the end of the walk. Attention
+    /// declines a bare width and is also the first child of every transformer block, so aborting
+    /// there stopped the traversal before it reached the projections that needed it — the walk went
+    /// nowhere while looking like it ran. Its output width is still known, so the chain continues.
+    /// </para>
+    /// <para>
+    /// Sequential composites are what this describes. A branching one resolves a child to the wrong
+    /// width, produces the wrong total, and is reported by the caller's count check exactly as
+    /// today: the failure stays loud, which matters more than breadth here.
+    /// </para>
+    /// </remarks>
+    private void BringUpUndeclaredSubLayersByChain()
+    {
+        // A DECLARATION COVERS ITS OWN CHILDREN, NOT THE WHOLE COMPOSITE. Returning outright the
+        // moment one existed made a PARTIAL declaration worse than none: VGGish can state the widths
+        // of the two dense layers after its flatten and cannot state the convolutions', because its
+        // own input is [-1, -1], and declaring the pair it knows silenced the walk for the ten it
+        // does not -- so the count lost exactly those children. Chain the undeclared remainder
+        // instead, and let a declared child contribute its output width to whatever follows it.
+        var declared = DeclaredSubLayerShapes();
+
+        // EMPTY MEANS TWO DIFFERENT THINGS and only HasDeclaredSubLayerStructure separates them. A
+        // layer that declares widths returns empty while any declared child is still null, which is
+        // the ordinary state PART-WAY THROUGH ITS OWN CONSTRUCTOR -- and registration happens there,
+        // so the chain ran at exactly that moment, sized the children it could already see from this
+        // layer's own input, and those wrong widths stuck. WordCharEmbedding's word projection came
+        // up 7 wide, the packed id width, against the 10-wide vocabulary its checkpoint holds.
+        // Waiting costs nothing: whoever needs the shapes asks again once the declaration is ready.
+        if (declared is { Count: 0 } && HasDeclaredSubLayerStructure) return;
+
+        var subs = GetSubLayers();
+        if (subs is null || subs.Count == 0) return;
+
+        bool IsDeclaredChild(ILayer<T> candidate)
+        {
+            if (declared is null) return false;
+            for (int i = 0; i < declared.Count; i++)
+            {
+                if (ReferenceEquals(declared[i].Child, candidate)) return true;
+            }
+            return false;
+        }
+
+        int[] width;
+        try
+        {
+            width = GetInputShape();
+        }
+        catch (Exception)
+        {
+            // A composite that cannot describe its own input cannot seed the walk.
+            return;
+        }
+
+        if (width is null || width.Length == 0) return;
+
+        for (int i = 0; i < subs.Count; i++)
+        {
+            if (subs[i] is not LayerBase<T> child) continue;
+
+            bool isDeclared = IsDeclaredChild(subs[i]);
+
+            if (!isDeclared && !child.IsShapeResolved && System.Array.TrueForAll(width, d => d > 0))
+            {
+                var batched = new int[width.Length + 1];
+                batched[0] = 1;
+                System.Array.Copy(width, 0, batched, 1, width.Length);
+
+                foreach (var candidate in new[] { width, batched })
+                {
+                    try
+                    {
+                        child.ResolveFromShape(candidate);
+                        break;
+                    }
+                    catch (Exception)
+                    {
+                        // Wrong convention, or a child that does not take a bare width at all.
+                    }
+                }
+            }
+
+            try
+            {
+                var produced = child.GetOutputShape();
+                if (produced is { Length: > 0 } && System.Array.TrueForAll(produced, d => d > 0))
+                    width = produced;
+            }
+            catch (Exception)
+            {
+                // Without this child's output the next input is unknown, so stop rather than
+                // resolve the remaining children against a stale width.
+                return;
+            }
+        }
+    }
+
     /// <summary>
     /// Materializes only the state owned directly by this layer, leaving child layers deferred.
     /// The chunked model surface uses this boundary so asking for the first chunk does not bring an
     /// entire paper-scale hierarchy into memory before the iterator can yield.
     /// </summary>
+    /// <summary>
+    /// Finishes an initialization that <see cref="ResolveShapesOnly"/> deliberately left half-done,
+    /// for a caller that is about to read or write the parameter surface.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// <see cref="ResolveShapesOnly"/> resolves the dimensions WITHOUT allocating, because eager
+    /// initialization would consume RNG state and perturb subsequent training. That leaves a state
+    /// no other flag describes: <see cref="IsShapeResolved"/> is true while the weights are still
+    /// placeholders, and <see cref="ResolveFromShape"/> — the one entry point that would allocate —
+    /// returns immediately on exactly that condition. A restore then arrived at a Conv1DLayer whose
+    /// shape claimed to be known and whose kernels were still [0,0,0,0], so the base compared 5,632
+    /// incoming values against a surface of 0 and rejected the payload.
+    /// </para>
+    /// <para>
+    /// Only on the parameter-surface path, never for ordinary shape queries — deferring allocation
+    /// is the entire point of <see cref="ResolveShapesOnly"/> and this must not undo it. Here the
+    /// RNG concern does not apply: the caller is about to overwrite these weights with restored
+    /// values, so the freshly initialized ones never survive to influence training.
+    /// </para>
+    /// <para>
+    /// Both shape conventions are tried because <see cref="InputShape"/> describes one sample for
+    /// some layers and the full batched input for others: Conv1DLayer resolves to [channels, length]
+    /// but reads <c>input.Shape[2]</c>, so the bare shape throws on rank and only the batched form
+    /// initializes it. Asking the layer rather than assuming is what keeps this in the base.
+    /// </para>
+    /// </remarks>
+    private void CompleteShapeOnlyResolutionIfPending()
+    {
+        if (!_shapeOnlyResolutionPendingFirstForward) return;
+
+        var resolved = InputShape;
+        if (resolved is null || resolved.Length == 0) return;
+        for (int i = 0; i < resolved.Length; i++)
+        {
+            if (resolved[i] <= 0) return;
+        }
+
+        var batched = new int[resolved.Length + 1];
+        batched[0] = 1;
+        System.Array.Copy(resolved, 0, batched, 1, resolved.Length);
+
+        foreach (var candidate in new[] { batched, resolved })
+        {
+            try
+            {
+                EnsureInitializedFromInput(new Tensor<T>(candidate));
+                return;
+            }
+            catch (Exception)
+            {
+                // Wrong convention for this layer; try the other. If neither works the layer keeps
+                // whatever it had and the caller's count check reports the shortfall as before.
+            }
+        }
+    }
+
     private void EnsureOwnParametersMaterialized()
     {
         // NOT gated on IsInitialized. The base declares `public virtual bool IsInitialized => true;`
@@ -1901,6 +2268,7 @@ private void EnsureOwnParametersMaterialized()
             && declaredParameterCount > 0;
         if (IsShapeResolved || ParametersAreConstructionSized || hasCountableDeclaredParameters)
         {
+            CompleteShapeOnlyResolutionIfPending();
             EnsureInitializationSerialized();
             // #1715: register the just-materialized streaming weights with the pool so transparent
             // auto-eviction can page them out — the forward path does this via
@@ -4691,6 +5059,7 @@ protected virtual Tensor<T> ForwardTracedMany(params Tensor<T>[] inputs)
     /// IOutputDerivative (e.g., GELU, SiLU, ELU). Without this, the fallback computes
     /// f'(f(x)) instead of the correct f'(x).
     /// </summary>
+    [Scratch]
     private readonly Stack<Tensor<T>> _preActivationCache = new();
 
     /// <summary>
@@ -4916,14 +5285,14 @@ protected static int[] CalculateOutputShape(int outputDepth, int outputHeight, i
     }
 
     /// <summary>
-    /// Creates a copy of this layer.
+    /// Creates a complete, independent copy of this layer.
     /// </summary>
-    /// <returns>A new instance of the layer with the same configuration.</returns>
+    /// <returns>A reconstructed instance carrying the layer's configuration and learned state.</returns>
     /// <remarks>
     /// <para>
-    /// This method creates a shallow copy of the layer with deep copies of the input/output shapes and
-    /// activation functions. Derived classes should override this method to properly copy any additional
-    /// fields they define.
+    /// This method routes through the generated construction-state factory and the common tensor-state
+    /// installer. Derived layers should declare their constructor and tensor state; they should not
+    /// override this method.
     /// </para>
     /// <para><b>For Beginners:</b> This method creates a duplicate of this layer.
     /// 
@@ -4939,29 +5308,7 @@ protected static int[] CalculateOutputShape(int outputDepth, int outputHeight, i
     /// </para>
     /// </remarks>
     public virtual LayerBase<T> Clone()
-    {
-        var copy = (LayerBase<T>)this.MemberwiseClone();
-
-        // Deep copy any reference type members
-        copy.InputShape = (int[])InputShape.Clone();
-        copy.OutputShape = (int[])OutputShape.Clone();
-
-        // Copy activation functions (use same instance if not cloneable since they're typically stateless)
-        if (ScalarActivation != null)
-        {
-            copy.ScalarActivation = ScalarActivation is ICloneable cloneable
-                ? (IActivationFunction<T>)cloneable.Clone()
-                : ScalarActivation;
-        }
-        if (VectorActivation != null)
-        {
-            copy.VectorActivation = VectorActivation is ICloneable vectorCloneable
-                ? (IVectorActivationFunction<T>)vectorCloneable.Clone()
-                : VectorActivation;
-        }
-
-        return copy;
-    }
+        => (LayerBase<T>)LayerCloning.Clone(this, CloneOptions.Full);
 
     /// <summary>
     /// Calculates the derivative of a scalar activation function for each element of a tensor.
@@ -5384,11 +5731,6 @@ public virtual long ParameterCount
                 && _cachedOwnLength == Parameters.Length)
                 return _cachedParameterCount;
 
-            // Cold path only. Generated child-input declarations can resolve a composite's lazy
-            // descendants without allocating them. Do that before counting the live tree so this
-            // allocation-free surface predicts the same slots GetParameters will materialize.
-            EnsureDeclaredSubLayerStructure();
-
             // A constructor-sized composite has explicitly promised that every parameter dimension
             // is known without observing data. A declared LEAF has the same proof directly in its
             // generated tensor shapes: there is no deferred child graph whose initializer could make
@@ -5438,6 +5780,20 @@ public virtual long ParameterCount
             // Layers that aggregate their parameters differently (a
             // GAN reading from frozen modules, a model with shared-weight
             // tying) can still override.
+            // Resolve the children's SHAPES before folding them, never their weights. Counting a
+            // shape-deferred child yields zero, so a composite holding its children in an ARRAY --
+            // which no [SubLayerInput] can name, since a declaration binds one field to one shape --
+            // reported only what it owned outright while GetParameters chained the same children
+            // into existence and returned their full length. VAEEncoder counted 30,014,492 against a
+            // vector of 35,471,772 that way.
+            //
+            // This runs the same walk the value path runs, under the shapes-only flag, so it fixes
+            // dimensions and allocates nothing: the constraint on counting is that it must not
+            // allocate (it is read from Dispose and from fingerprinting, and allocating there threw
+            // OutOfMemoryException on a 774M-parameter model), not that it must not learn shapes.
+            // Two surfaces derived from one resolved graph cannot disagree.
+            ResolveSubLayerShapesForCounting();
+
             long total = 0;
             var components = GetOrderedParameterComponents();
             for (int i = 0; i < components.Length; i++)
@@ -5522,6 +5878,8 @@ public virtual void Serialize(BinaryWriter writer)
         // count-only payload that forced hundreds of layer-specific restore overrides.
         writer.Write(ParameterSerializationMagic);
         WriteParameterLayout(writer);
+        WriteResolvedShape(writer);
+        WriteRegisteredBuffers(writer);
         writer.Write(parameters.Length);
         for (int i = 0; i < parameters.Length; i++)
         {
@@ -5562,121 +5920,229 @@ public virtual void Deserialize(BinaryReader reader)
         var layout = ParameterLayoutNode.Read(reader);
         ApplyParameterLayout(layout);
 
-        int count = reader.ReadInt32();
-        var parameters = new Vector<T>(count);
-        for (int i = 0; i < count; i++)
-        {
-            parameters[i] = NumOps.FromDouble(reader.ReadDouble());
+        // RESOLVE, THEN INITIALIZE, THEN RESTORE VALUES. The parameter layout restores the parameter
+        // SLOTS but not the layer's shape, so a restored layer read back IsShapeResolved == false and
+        // stayed lazy. Its first Forward therefore ran the whole first-use path -- resolve the shape,
+        // allocate the weights, randomize them -- straight over the values Deserialize had just
+        // installed. Measured on GRULayer: all 312 parameters came back exactly right, and the first
+        // Forward replaced every one of them. That reads as "serialization lost the weights" when
+        // serialization had in fact preserved them perfectly.
+        //
+        // Restoring the shape first makes the layer non-lazy, EnsureInitialized then allocates the
+        // tensors, and SetParameters below writes into tensors that already exist. The first forward
+        // finds an initialized layer and leaves it alone.
+        var savedShape = ReadResolvedShape(reader);
+
+        // A shape carrying a FREE AXIS is not a resolution. A block that declares its input as
+        // [-1, hiddenSize] publishes exactly that, and resolving from it threw at its own
+        // declaration -- then the batched retry below prepended a 1 and threw again on the same
+        // -1, this time uncaught, so the restore died rather than deferring to the first forward.
+        // Treat it as "the source had not resolved either" and leave the layer lazy.
+        if (savedShape is not null)
+        {
+            for (int __axis = 0; __axis < savedShape.Length; __axis++)
+            {
+                if (savedShape[__axis] <= 0) { savedShape = null; break; }
+            }
         }
-        SetParameters(parameters);
-    }
 
-    // 0xA1D07E01 -> 0xA1D07E02 when the resolved input shape joined the payload; -> 0xA1D07E03 when
-    // it moved from a single root-level block into every layout node, so nested lazy layers carry
-    // their own. An older stream fails loudly on the magic check rather than misreading the bytes.
-    private const int ParameterSerializationMagic = unchecked((int)0xA1D07E03);
-
-    /// <summary>
-    /// Persists the layer's resolved input shape ahead of the parameter layout.
-    /// </summary>
+        if (savedShape is not null && IsShapeResolved
+            && !InputShape.SequenceEqual(savedShape))
+        {
+            // A construction-sized layer can still adapt its input width at runtime. Restoring
+            // [200, 9] Dense weights into a fresh layer already resolved at [30, 9] previously
+            // kept the stale [30] declaration, so TryAdoptRestoredParameters correctly rejected
+            // the checkpoint on first forward. The checkpoint's concrete shape is authoritative
+            // at this value boundary; update the common shape metadata before adoption.
+            UpdateInputShape((int[])savedShape.Clone());
+        }
+        else if (savedShape is not null && !IsShapeResolved)
+        {
+            // The saved shape is what the layer PUBLISHED for itself, and a layer may publish one
+            // sample while its forward requires the batch axis: Conv1DLayer resolves to
+            // [channels, time] and then rejects anything that is not [B, C, T], so restoring it
+            // from its own declaration threw at its own shape. Offer the batched form too rather
+            // than relaxing the layer's rank check, which is deliberate and documented. Same
+            // try-batched-then-bare that CompleteShapeOnlyResolutionIfPending and
+            // LayerCloning.ProbeShapes already use for exactly this split.
+            try
+            {
+                ResolveFromShape(savedShape);
+            }
+            catch (ArgumentException)
+            {
+                var batched = new int[savedShape.Length + 1];
+                batched[0] = 1;
+                System.Array.Copy(savedShape, 0, batched, 1, savedShape.Length);
+                ResolveFromShape(batched);
+            }
+        }
+
+        if (IsShapeResolved)
+        {
+            EnsureInitialized();
+        }
+
+        // AFTER EnsureInitialized, because the buffers are registered during initialization and
+        // there is nothing to restore into before that.
+        ReadRegisteredBuffers(reader);
+
+        int count = reader.ReadInt32();
+        var parameters = new Vector<T>(count);
+        for (int i = 0; i < count; i++)
+        {
+            parameters[i] = NumOps.FromDouble(reader.ReadDouble());
+        }
+        SetParameters(parameters);
+    }
+
+    // Bumped 0xA1D07E01 -> 0xA1D07E02 when the resolved input shape joined the payload. A reader
+    // that skipped the shape block would misread the parameter count as a rank, so the two formats
+    // cannot be told apart by content and the magic has to separate them. Same pre-1.0 stance as the
+    // previous bump: one authoritative format beats an ambiguous one that needs per-layer rescue.
+    private const int ParameterSerializationMagic = unchecked((int)0xA1D07E02);
+
+    /// <summary>Writes the layer's resolved input shape, or a marker saying it has none yet.</summary>
+    /// <param name="writer">The writer receiving the shape block.</param>
     /// <remarks>
-    /// <para>
-    /// A lazy layer learns its parameter shapes from the first tensor it sees, so a freshly
-    /// constructed one has no parameters at all. Deserialize hands over values with no forward pass,
-    /// and <see cref="ApplyParameterLayout"/> cannot size such a layer -- its own comment says so,
-    /// and concludes that skipping the rebind is safe because "the restored values are carried by
-    /// the parameter vector and land when the layer materializes".
-    /// </para>
-    /// <para>
-    /// For a layer that is never run again before being asked for its parameters, they never land.
-    /// Measured across the generated model-family fixtures, 34 layers round-tripped to a smaller
-    /// parameter surface than they were saved with -- FullyConnectedLayer 40 to 8, AttentionLayer,
-    /// Conv1DLayer, GRULayer, BatchNormalizationLayer and the rest -- and the restored values were
-    /// discarded in silence.
-    /// </para>
-    /// <para>
-    /// The shape is what was missing, and the writer already knows it. Every one of these layers can
-    /// rebuild its full parameter surface from its input shape, because that is exactly what their
-    /// first forward does; persisting it lets the reader trigger that same construction directly.
-    /// This is cheaper and far more general than a restore override per layer, which is the outcome
-    /// the format comment above was written to avoid.
-    /// </para>
+    /// A lazy layer carries its capacity in its resolved shape, not in its parameter values, so a
+    /// payload without the shape restores values into a layer that is still lazy -- and the first
+    /// forward re-resolves and re-randomizes straight over them.
     /// </remarks>
-    private void WriteResolvedInputShape(BinaryWriter writer)
+    private void WriteResolvedShape(BinaryWriter writer)
     {
-        var shape = InputShape;
+        int[]? shape = null;
+        if (IsShapeResolved)
+        {
+            // GetInputShape throws on layers that will not describe their input. That is not a
+            // serialization failure -- the layer simply stays lazy on restore, exactly as it does
+            // today -- so it is recorded as "no shape" rather than failing the whole save.
+            try { shape = GetInputShape(); }
+            catch (InvalidOperationException) { shape = null; }
+            catch (ArgumentException) { shape = null; }
+        }
 
-        // Rank 0 means "nothing useful to say" -- an unresolved layer, or one whose input shape
-        // still carries a sentinel. The reader treats that as no information rather than guessing.
-        if (!IsShapeResolved || shape is null || shape.Length == 0 || ShapeContainsSentinel(shape))
+        if (shape is null || shape.Length == 0)
         {
             writer.Write(0);
             return;
         }
 
         writer.Write(shape.Length);
-        for (int i = 0; i < shape.Length; i++) writer.Write(shape[i]);
+        for (int i = 0; i < shape.Length; i++)
+        {
+            writer.Write(shape[i]);
+        }
     }
 
-    /// <summary>
-    /// Reads the persisted input shape and, if this layer is still unresolved, builds from it.
-    /// </summary>
+    /// <summary>Writes every registered buffer, by name, with its shape and values.</summary>
+    /// <param name="writer">The writer receiving the buffer block.</param>
     /// <remarks>
-    /// Resolution runs the layer's own first-forward path, so it produces exactly the parameter
-    /// surface a real forward would have. A layer that rejects the shape -- one expecting a richer
-    /// rank than the writer recorded, say -- throws <see cref="ArgumentException"/>, which is the
-    /// documented contract failure for a shape mismatch and is swallowed here: the restore then
-    /// proceeds exactly as it did before this block existed. Any other exception is a real fault and
-    /// propagates.
+    /// <para>
+    /// Buffers are the declared home for non-trainable persistent state -- running statistics,
+    /// positional tables, Hebbian traces, spectral-normalisation vectors. They are already declared
+    /// through <see cref="RegisterBuffer"/> and already enumerable through
+    /// <see cref="GetRegisteredBuffers"/>, so the base can persist all of them with no per-layer
+    /// code at all. Until now it persisted none of them, which is why layers hand-wrote a
+    /// <c>Serialize</c> override to push the same values out themselves.
+    /// </para>
+    /// <para>
+    /// Keyed by NAME rather than by position: registration order can differ between a trained
+    /// instance and a freshly constructed one, and restoring by position would then quietly load a
+    /// running mean into a positional table. A name present in the payload but absent from the
+    /// instance is skipped rather than fatal, so adding a buffer does not invalidate checkpoints.
+    /// </para>
     /// </remarks>
-    private void ApplyResolvedInputShape(int[] shape)
+    private void WriteRegisteredBuffers(BinaryWriter writer)
     {
-        if (shape is null || shape.Length == 0) return;
-        if (IsShapeResolved) return;
+        var buffers = GetRegisteredBuffers();
+        writer.Write(buffers.Count);
 
-        for (int i = 0; i < shape.Length; i++)
+        foreach (var (name, tensor) in buffers)
         {
-            if (shape[i] <= 0) return;
+            writer.Write(name);
+
+            if (tensor is null)
+            {
+                writer.Write(-1);
+                continue;
+            }
+
+            var shape = tensor.Shape;
+            writer.Write(shape.Length);
+            for (int i = 0; i < shape.Length; i++) writer.Write(shape[i]);
+
+            writer.Write(tensor.Length);
+            for (int i = 0; i < tensor.Length; i++) writer.Write(Convert.ToDouble(tensor[i]));
         }
+    }
 
-        try
+    /// <summary>Restores the buffers written by <see cref="WriteRegisteredBuffers"/>.</summary>
+    /// <param name="reader">The reader positioned at the buffer block.</param>
+    private void ReadRegisteredBuffers(BinaryReader reader)
+    {
+        int bufferCount = reader.ReadInt32();
+        if (bufferCount <= 0) return;
+
+        var live = new Dictionary<string, Tensor<T>>(StringComparer.Ordinal);
+        foreach (var (name, tensor) in GetRegisteredBuffers())
         {
-            ResolveFromShape(shape);
+            if (tensor is not null) live[name] = tensor;
         }
-        catch (ArgumentException)
+
+        for (int b = 0; b < bufferCount; b++)
         {
-            // InputShape is stored PER-SAMPLE -- it carries no batch axis -- but OnFirstForward is
-            // written against the tensor a real Forward hands it, which is batched. For every layer
-            // whose hook accepts the unbatched rank (DenseLayer and FeedForwardLayer take rank>=1)
-            // the direct attempt above already succeeded. A layer that pins an exact batched rank
-            // rejects it instead: Conv1DLayer and Conv1DTransposeLayer demand rank-3 [B,C,T] and
-            // SwinPatchEmbeddingLayer rank-4 [B,C,H,W], so a persisted [C,T] / [C,H,W] arrived one
-            // axis short and threw. That throw was swallowed, the layer stayed unresolved, and every
-            // restored weight was dropped on the floor -- measured as Conv1DLayer round-tripping 28
-            // parameters to 0 with the 288-byte payload intact, so the data was written and then had
-            // nowhere to land. SwinPatchEmbeddingLayer's own message spells out the remedy:
-            // "Add a batch dimension before calling Forward."
-            //
-            // Retry with a singleton batch. Batch is never a parameter-shaping axis -- weights are
-            // sized from channels and spatial extent -- so B=1 reproduces exactly the resolution the
-            // original forward performed: Conv1DLayer reading [1,2,8] recovers cIn=2, tIn=8 and
-            // republishes InputShape=[2,8], identical to what was serialized. The retry is confined
-            // to the case where the unbatched attempt already failed, and ResolveFromShape returns
-            // early once IsShapeResolved, so a layer that resolved on the first attempt never sees it.
-            var batched = new int[shape.Length + 1];
-            batched[0] = 1;
-            Array.Copy(shape, 0, batched, 1, shape.Length);
+            string name = reader.ReadString();
 
-            try
-            {
-                ResolveFromShape(batched);
-            }
-            catch (ArgumentException)
+            int rank = reader.ReadInt32();
+            if (rank < 0) continue;
+
+            var shape = new int[rank];
+            for (int i = 0; i < rank; i++) shape[i] = reader.ReadInt32();
+
+            int length = reader.ReadInt32();
+            var values = new double[length];
+            for (int i = 0; i < length; i++) values[i] = reader.ReadDouble();
+
+            // Write THROUGH the registered tensor rather than replacing it. The engine's persistent
+            // tensor registry and any GPU-resident copy hold this reference; swapping the object
+            // would leave those pointing at the pre-restore values.
+            if (live.TryGetValue(name, out var target) && target.Length == length)
             {
-                // Genuinely not this layer's shape. Leave it unresolved; the pre-existing restore
-                // path still applies, exactly as it did before either attempt existed.
+                for (int i = 0; i < length; i++) target[i] = NumOps.FromDouble(values[i]);
+                continue;
             }
+
+            // Nothing live under that name, or a different width. Skipping here is what made a
+            // buffer that only EXISTS once the caller supplies it unrestorable: a graph layer
+            // rebuilt from its construction state has no adjacency matrix yet, so the payload it
+            // was handed had nowhere to land and the restored model still could not predict. Build
+            // the tensor the payload describes and hand it to the generated field map, which is the
+            // only thing that knows which member the name belongs to. A layer without that map, or
+            // with no member under this name, keeps the old behaviour and skips.
+            var restored = new Tensor<T>(shape);
+            for (int i = 0; i < length; i++) restored[i] = NumOps.FromDouble(values[i]);
+
+            // The generated map registers under the member's own state role; registering here
+            // instead would take RegisterBuffer's default and change what the slot means.
+            TryRestoreBufferField(name, restored);
+        }
+    }
+
+    /// <summary>Reads the shape block written by <see cref="WriteResolvedShape"/>.</summary>
+    /// <param name="reader">The reader positioned at the shape block.</param>
+    /// <returns>The saved input shape, or <see langword="null"/> when the layer was still lazy.</returns>
+    private static int[]? ReadResolvedShape(BinaryReader reader)
+    {
+        int rank = reader.ReadInt32();
+        if (rank <= 0) return null;
+
+        var shape = new int[rank];
+        for (int i = 0; i < rank; i++)
+        {
+            shape[i] = reader.ReadInt32();
         }
+        return shape;
     }
 
     /// <summary>
@@ -5798,6 +6264,7 @@ private static int TrainableScalarCount(Tensor<T> t)
     /// </summary>
     internal readonly struct TrainableParameterValueSlot
     {
+        [AiDotNet.Attributes.FittedParameter]
         private readonly Tensor<T>? _tensor;
         private readonly Tensor<Half>? _lowPrecisionTensor;
 
@@ -5911,23 +6378,6 @@ private static void WriteParameterComponentScalar(
     /// </summary>
     internal IReadOnlyList<TrainableParameterValueSlot> GetOwnTrainableParameterValueSlots()
     {
-        // Materialize first. A lazily-initialized layer registers its tensors inside
-        // EnsureInitialized, so before that runs GetOrderedParameterComponents reports NO trainable
-        // components even though the layer's declared count is non-zero -- and this method silently
-        // returned an empty slot list for a layer that owns real weights.
-        //
-        // That made a model's flat GetParameters SHORTER than its own ParameterCount whenever a
-        // sub-layer had not been exercised. DiffusionAttention owns both a FlashAttentionLayer and a
-        // MultiHeadAttentionLayer and runs only one per forward depending on sequence length, so the
-        // unused one never initialized: a small U-Net reported ParameterCount 10,390 while
-        // GetParameters returned 9,598, and the 792 difference is exactly 3 x 264 -- one attention
-        // implementation in each of its three attention blocks. A GetParameters/SetParameters round
-        // trip through that vector dropped those weights entirely.
-        //
-        // The layer's OWN GetParameters already materializes before reading its surface; this is the
-        // same guarantee for the per-layer walk that model-level surfaces use.
-        EnsureMaterializedForParameterSurface();
-
         var components = GetOrderedParameterComponents();
         var slots = new List<TrainableParameterValueSlot>();
         for (int i = 0; i < components.Length; i++)
@@ -5939,23 +6389,119 @@ internal IReadOnlyList<TrainableParameterValueSlot> GetOwnTrainableParameterValu
     }
 
     /// <summary>
-    /// Every slot the FLAT PARAMETER VECTOR carries: trainable tensors AND persistent buffers, in
+    /// The WRITABLE counterpart to <see cref="GetOwnParameterStateChunks"/>: one slot per component
+    /// that method yields a chunk for, in the same order, so a state chunk stream can be restored
+    /// through the slot API.
+    /// </summary>
+    /// <remarks>
+    /// Needed because the two public surfaces are deliberately different widths — the flat
+    /// GetParameters/SetParameters pair is the trainable-only optimizer view, while the chunk pair
+    /// carries the complete persistent state including buffers (see IParameterChunkSource). Restoring
+    /// chunks through the TRAINABLE slot list silently dropped every buffer and, when the widths
+    /// disagreed, threw "Expected 88860 parameters, got 95116" on a clone. Going through slots rather
+    /// than writing ParameterChunk.Tensor directly is what keeps fp16-resident and sparse components
+    /// correct: for those, the chunk carries a transient snapshot, so writing it would update nothing.
+    /// </remarks>
+    internal IReadOnlyList<ParameterStateWriteTarget> GetOwnParameterStateWriteTargets()
+    {
+        // Same materialization the chunk reader performs, so the two surfaces see one graph.
+        if (_pendingParameterRestore is not null)
+            EnsureParametersMaterialized();
+        else
+            EnsureOwnParametersMaterialized();
+
+        var components = GetOrderedParameterComponents();
+        var targets = new List<ParameterStateWriteTarget>();
+        for (int i = 0; i < components.Length; i++)
+        {
+            var component = components[i];
+
+            // Mirrors EnumerateParameterStateChunks' component switch, branch for branch. A layer
+            // still on the legacy flat vector contributes its whole Parameters surface as ONE chunk
+            // and owns no per-component value slot -- that is why a slots-only walk came up short.
+            if (component.Kind == DeclaredParameterComponentKind.Legacy)
+            {
+                if (Parameters.Length > 0) targets.Add(new ParameterStateWriteTarget(this));
+                continue;
+            }
+
+            if (component.Kind is DeclaredParameterComponentKind.Trainable
+                or DeclaredParameterComponentKind.Buffer)
+            {
+                if (ParameterComponentScalarCount(component) == 0) continue;
+                targets.Add(new ParameterStateWriteTarget(ValueSlot(component)));
+            }
+        }
+        return targets;
+    }
+
+    /// <summary>
+    /// One writable destination on the state-chunk surface: either a component's value slot or a
+    /// layer's legacy flat <see cref="Parameters"/> vector, which has no slot of its own.
+    /// </summary>
+    internal readonly struct ParameterStateWriteTarget
+    {
+        private readonly TrainableParameterValueSlot _slot;
+        private readonly LayerBase<T>? _legacyOwner;
+
+        internal ParameterStateWriteTarget(TrainableParameterValueSlot slot)
+        {
+            _slot = slot;
+            _legacyOwner = null;
+            ScalarCount = slot.ScalarCount;
+        }
+
+        internal ParameterStateWriteTarget(LayerBase<T> legacyOwner)
+        {
+            _slot = default;
+            _legacyOwner = legacyOwner;
+            ScalarCount = legacyOwner.Parameters.Length;
+        }
+
+        internal long ScalarCount { get; }
+
+        /// <summary>Reads this destination, matching the chunk reader's payload for the component.</summary>
+        internal Tensor<T> Snapshot()
+        {
+            var owner = _legacyOwner;
+            if (owner is null) return _slot.Snapshot();
+            return new Tensor<T>(new[] { owner.Parameters.Length }, owner.Parameters);
+        }
+
+        /// <summary>Writes this destination in place.</summary>
+        internal void CopyFrom(Tensor<T> source)
+        {
+            if (source is null) throw new ArgumentNullException(nameof(source));
+
+            var owner = _legacyOwner;
+            if (owner is null)
+            {
+                // Through the slot, never the chunk tensor: fp16-resident and sparse components hand
+                // out a transient snapshot, so writing that would update nothing.
+                _slot.CopyFrom(source);
+                return;
+            }
+
+            if (source.Length != owner.Parameters.Length)
+            {
+                throw new ArgumentException(
+                    $"Source tensor has {source.Length} values but the legacy parameter surface " +
+                    $"requires {owner.Parameters.Length}.", nameof(source));
+            }
+
+            var span = source.AsSpan();
+            for (int i = 0; i < span.Length; i++) owner.Parameters[i] = span[i];
+        }
+    }
+
+    /// <summary>
+    /// Every slot the flat parameter vector carries: trainable tensors and persistent buffers, in
     /// the order <see cref="GetParameters"/> lays them out.
     /// </summary>
     /// <remarks>
-    /// <para>
-    /// The sibling above is deliberately trainable-only, and both are needed. Gradients and
-    /// copy-on-write concern themselves with what TRAINS, so a running mean has no place in them.
-    /// The flat vector and the chunk stream concern themselves with what must be RESTORED, and a
-    /// checkpoint that drops a BatchNorm's running statistics does not reproduce the model it
-    /// claims to.
-    /// </para>
-    /// <para>
-    /// Using the trainable-only view for a value surface is what makes the two disagree on width:
-    /// ParameterCount answers from the declaration, which counts buffers, while an enumeration that
-    /// skips them yields a shorter vector. SetParameters(GetParameters()) then fails on its own
-    /// output, which is failure class P1 arriving from the buffer side instead of the lazy side.
-    /// </para>
+    /// The trainable-only sibling supports gradients and copy-on-write. This state view also includes
+    /// buffers because a checkpoint that drops running state cannot reproduce the original model.
+    /// Legacy storage is carried by <see cref="Parameters"/> itself and therefore has no component slot.
     /// </remarks>
     internal IReadOnlyList<TrainableParameterValueSlot> GetOwnParameterStateValueSlots()
     {
@@ -5963,8 +6509,6 @@ internal IReadOnlyList<TrainableParameterValueSlot> GetOwnParameterStateValueSlo
         var slots = new List<TrainableParameterValueSlot>();
         for (int i = 0; i < components.Length; i++)
         {
-            // Legacy storage is excluded on purpose: it is carried by the Parameters vector itself
-            // rather than by a component tensor, and FillParameters already emits it separately.
             if (components[i].Kind is DeclaredParameterComponentKind.Trainable
                 or DeclaredParameterComponentKind.Buffer)
             {
@@ -6031,7 +6575,6 @@ internal void WriteParameterLayout(System.IO.BinaryWriter writer)
         // unmaterialized layer writes an empty layout beside an empty vector, which is consistent
         // and is what PyTorch saves for a lazy module that has never run a forward.
         writer.Write(Parameters.Length);
-        WriteResolvedInputShape(writer);
 
         var components = GetOrderedParameterComponents();
         int trainableCount = 0;
@@ -6086,8 +6629,7 @@ private static void WriteShape(
 
     private static void WriteEmptyLayout(System.IO.BinaryWriter writer)
     {
-        // OwnLength, resolved-input-shape rank, trainable count, buffer count, sub-layer count.
-        writer.Write(0); writer.Write(0); writer.Write(0); writer.Write(0); writer.Write(0);
+        writer.Write(0); writer.Write(0); writer.Write(0); writer.Write(0);
     }
 
     /// <summary>
@@ -6101,16 +6643,6 @@ private static void WriteEmptyLayout(System.IO.BinaryWriter writer)
     /// </remarks>
     internal void ApplyParameterLayout(ParameterLayoutNode layout)
     {
-        // FIRST, because everything below reads this layer's parameter slots and a lazy layer has
-        // none until its input shape is known. Recording the shape per node is what makes this work
-        // at depth: the root used to carry the only copy, so a composite -- which is NOT itself
-        // lazy and therefore returned early from the resolve -- passed its lazy children straight
-        // to the rebind below, where RegisteredTrainableParameterCount was 0, the rebind was
-        // skipped as designed, and the values never landed. Measured on CifAlignmentLayer, a
-        // composite holding a single DenseLayer: 18 parameters restored as 0, while that same
-        // DenseLayer round-tripped perfectly on its own.
-        ApplyResolvedInputShape(layout.ResolvedInputShape);
-
         EnsureMaterializedForParameterSurface();
 
         // A restore is a VALUE boundary, so it needs storage, not merely a known shape.
@@ -6156,8 +6688,15 @@ internal void ApplyParameterLayout(ParameterLayoutNode layout)
             if (buffers is not null)
                 foreach (var (n, t) in buffers)
                     if (string.Equals(n, entry.Name, StringComparison.Ordinal)) { existing = t; break; }
-            if (existing is null || !ShapeMatches(existing, entry.Shape))
-                RegisterBuffer(new Tensor<T>(entry.Shape), entry.Name);
+            if (existing is not null && ShapeMatches(existing, entry.Shape)) continue;
+
+            // Through the generated field map first. A bare RegisterBuffer takes the DEFAULT state
+            // role, so allocating a slot here re-registered an input-sized buffer as an ordinary
+            // counted one -- the clone then expected a wider vector than the original produced.
+            // The map also writes the member, which a registration alone never does.
+            var allocated = new Tensor<T>(entry.Shape);
+            if (!TryRestoreBufferField(entry.Name, allocated))
+                RegisterBuffer(allocated, entry.Name);
         }
 
         var subs = GetSubLayers();
@@ -6594,26 +7133,11 @@ public virtual void SetParameters(Vector<T> parameters)
             _pendingParameterRestore = null;
             Parameters = parameters;
             BumpParameterEpoch();
-            OnParameterValuesChanged();
             return;
         }
 
         if (!shapeKnown && !currentLayoutMatches)
         {
-            // Park only what could actually be restored later. Deferring is right when the payload
-            // is merely un-checkable yet, and wrong when the layer's own shape formula admits no
-            // input width that ever produces this length -- then SetParameters accepts an
-            // impossible vector silently and the error only surfaces at some later forward, far
-            // from the call that caused it. Layers that can decide opt in by overriding
-            // CanEverAcceptParameterCount; the default says yes, so nothing else changes.
-            if (!CanEverAcceptParameterCount(parameters.Length))
-            {
-                throw new ArgumentException(
-                    $"{GetType().Name} can never hold {parameters.Length} parameters at any input "
-                    + "shape, so this vector cannot be restored once the shape resolves.",
-                    nameof(parameters));
-            }
-
             if (Parameters.Length != 0)
             {
                 throw new InvalidOperationException(
@@ -6627,30 +7151,44 @@ public virtual void SetParameters(Vector<T> parameters)
             // axis exactly recoverable from the payload length. Resolve immediately when they do;
             // otherwise the first real input will materialize the tensors and replay this payload.
             if (TryInferInputShapeFromParameterCount(parameters.Length, out var inferredInput))
-                ResolveFromShape(inferredInput);
+            {
+                bool fullyConcrete = inferredInput.Length > 0;
+                for (int axis = 0; axis < inferredInput.Length; axis++)
+                    if (inferredInput[axis] <= 0) { fullyConcrete = false; break; }
+
+                if (fullyConcrete)
+                    ResolveFromShape(inferredInput);
+                else
+                    TryMaterializePartiallyInferredParameterSurface(inferredInput);
+            }
 
             TryApplyPendingParameterRestore();
             return;
         }
 
-        // Last chance before rejecting: a layer whose shape is already resolved may still be able
-        // to ACCEPT this payload by re-resolving an input axis the length pins exactly. The
-        // TryInferInputShapeFromParameterCount path above only runs while the shape is unknown, so
-        // an already-materialized layer handed a payload for a different width had no way back.
-        // This runs only where the next statement would otherwise throw, so no layer that already
-        // accepts its payload can reach it.
-        if (!currentLayoutMatches && TryRebindForParameterCount(parameters.Length))
-        {
-            components = GetOrderedParameterComponents();
-            currentConcreteCount = FillParameters(null, 0);
-            currentLayoutMatches = parameters.Length == currentConcreteCount;
-        }
-
         if (!currentLayoutMatches)
         {
+            // Name every component and its width. A bare count pair says only THAT the two
+            // sides disagree, never WHICH member accounts for the difference -- and the usual
+            // cause is a caller that built its vector from a different walk (the optimizer view
+            // omits buffers, the full vector carries them), where the missing width is the
+            // whole diagnosis.
+            var breakdown = new System.Text.StringBuilder();
+            for (int i = 0; i < components.Length; i++)
+            {
+                if (i > 0) breakdown.Append(", ");
+                breakdown.Append(components[i].Kind);
+                if (components[i].Name is { Length: > 0 } componentName)
+                    breakdown.Append(' ').Append(componentName);
+                breakdown.Append('=').Append(
+                    components[i].Kind == DeclaredParameterComponentKind.Legacy
+                        ? Parameters.Length
+                        : ParameterComponentScalarCount(components[i]));
+            }
+
             throw new ArgumentException(
                 $"Expected {currentConcreteCount} parameters, but got {parameters.Length} " +
-                $"(layer {GetType().Name}, ordered components {components.Length}).",
+                $"(layer {GetType().Name}, ordered components {components.Length}: {breakdown}).",
                 nameof(parameters));
         }
 
@@ -6658,6 +7196,42 @@ public virtual void SetParameters(Vector<T> parameters)
         ApplyConcreteParameterVector(parameters);
     }
 
+    /// <summary>
+    /// Materializes a generated parameter surface when the checkpoint determines every weight
+    /// dimension but intentionally does not determine unrelated data axes.
+    /// </summary>
+    /// <remarks>
+    /// Image convolutions commonly size weights from channels alone while height and width remain
+    /// dynamic. Forcing neutral spatial dimensions through <see cref="ResolveFromShape"/> would
+    /// falsely mark the whole layer resolved and suppress its real first-forward shape update.
+    /// Instead, publish only the inferred axes, allocate from the now-concrete generated tensor
+    /// declarations, and leave the layer shape-deferred for the first real input.
+    /// </remarks>
+    private bool TryMaterializePartiallyInferredParameterSurface(int[] inferredInput)
+    {
+        if (inferredInput is null || inferredInput.Length == 0) return false;
+        UpdateInputShape((int[])inferredInput.Clone());
+
+        var declared = DeclaredParameterShapes();
+        if (declared is null || declared.Count == 0) return false;
+        var rebuilt = new Tensor<T>[declared.Count];
+        for (int i = 0; i < declared.Count; i++)
+        {
+            var expected = declared[i].Expected;
+            if (expected.Length == 0) return false;
+            var dimensions = new int[expected.Length];
+            for (int axis = 0; axis < expected.Length; axis++)
+            {
+                dimensions[axis] = expected[axis];
+                if (dimensions[axis] <= 0) return false;
+            }
+            rebuilt[i] = new Tensor<T>(dimensions);
+        }
+
+        SetTrainableParameters(rebuilt);
+        return true;
+    }
+
     /// <summary>Distributes a validated vector through the ordered component manifest.</summary>
     private void ApplyConcreteParameterVector(Vector<T> parameters)
     {
@@ -6680,8 +7254,6 @@ private void ApplyConcreteParameterVector(Vector<T> parameters)
                 int count = ParameterComponentScalarCount(component);
                 for (int j = 0; j < count; j++)
                     WriteParameterComponentScalar(component, j, parameters[index++]);
-                if (component.Tensor is not null)
-                    Engine.InvalidatePersistentTensor(component.Tensor);
                 continue;
             }
 
@@ -6701,7 +7273,6 @@ private void ApplyConcreteParameterVector(Vector<T> parameters)
                 $"{GetType().Name} consumed {index} of {parameters.Length} parameter values.");
 
         BumpParameterEpoch();
-        OnParameterValuesChanged();
     }
 
     /// <summary>
@@ -6878,8 +7449,87 @@ internal virtual Dictionary<string, string> GetMetadata()
     /// afterwards. A layer that overrides <c>GetMetadata</c> without calling base opts itself out,
     /// which the generator reports as ADN0054.
     /// </remarks>
-    internal virtual void WriteConstructionState(Dictionary<string, string> metadata)
+    protected virtual void WriteConstructionState(Dictionary<string, string> metadata)
     {
+        WriteOrderedActivationState(metadata, vector: false);
+        WriteOrderedActivationState(metadata, vector: true);
+    }
+
+    /// <summary>Invokes the generated construction-state hook for clone infrastructure.</summary>
+    internal void CaptureConstructionState(Dictionary<string, string> metadata)
+        => WriteConstructionState(metadata);
+
+    /// <summary>
+    /// Writes live constructor components for an in-memory clone. Generated; do not implement by hand.
+    /// </summary>
+    /// <remarks>
+    /// Durable metadata records a component's type name. An in-memory clone can do better: it can
+    /// supply the actual activation/initializer/strategy instance to the generated constructor, so a
+    /// component with constructor configuration or no parameterless constructor is never replaced by
+    /// a default. This object-valued channel is never serialized.
+    /// </remarks>
+    protected virtual void WriteConstructionObjects(Dictionary<string, object> values)
+    {
+        WriteOrderedActivationObjects(values, vector: false);
+        WriteOrderedActivationObjects(values, vector: true);
+    }
+
+    /// <summary>Invokes the generated live-object hook for clone infrastructure.</summary>
+    internal void CaptureConstructionObjects(Dictionary<string, object> values)
+        => WriteConstructionObjects(values);
+
+    private void WriteOrderedActivationState(Dictionary<string, string> metadata, bool vector)
+    {
+        var activations = GetOrderedConstructionActivations(vector);
+        string kind = vector ? "vector" : "scalar";
+        for (int i = 0; i < activations.Count; i++)
+        {
+            metadata[$"__aidotnet_{kind}_activation_{i}"] =
+                LayerStateBag.FormatType(activations[i]);
+        }
+    }
+
+    private void WriteOrderedActivationObjects(Dictionary<string, object> values, bool vector)
+    {
+        var activations = GetOrderedConstructionActivations(vector);
+        string kind = vector ? "vector" : "scalar";
+        for (int i = 0; i < activations.Count; i++)
+        {
+            values[$"__aidotnet_{kind}_activation_{i}"] = activations[i];
+        }
+    }
+
+    /// <summary>
+    /// Returns the distinct activation objects exposed by this layer and its immediate registered
+    /// children, in construction order.
+    /// </summary>
+    /// <remarks>
+    /// Composite constructors can take more than one activation even though LayerBase historically
+    /// stored only one scalar and one vector activation. ReconstructionLayer is the canonical case:
+    /// its hidden activation lives on child 0/1 and its output activation on child 2. Enumerating the
+    /// immediate children lets generated factories bind both without adding a bespoke field or clone
+    /// override to every composite. Reference de-duplication keeps one activation reused by several
+    /// children in one constructor slot while retaining separately configured instances.
+    /// </remarks>
+    private List<object> GetOrderedConstructionActivations(bool vector)
+    {
+        var result = new List<object>();
+
+        void Add(object? activation)
+        {
+            if (activation is null || result.Any(existing => ReferenceEquals(existing, activation)))
+                return;
+            result.Add(activation);
+        }
+
+        Add(vector ? VectorActivation : ScalarActivation);
+        foreach (var child in GetSubLayers())
+        {
+            if (child is not LayerBase<T> layer) continue;
+            Add(vector ? layer.VectorActivation : layer.ScalarActivation);
+        }
+
+        return result;
     }
 
     /// <summary>
@@ -7259,6 +7909,142 @@ protected bool UnregisterSubLayer(ILayer<T> subLayer)
     /// needs to be saved and loaded with the model, but it's not something the optimizer
     /// should try to change. Use RegisterBuffer for these kinds of tensors.</para>
     /// </remarks>
+    /// <summary>
+    /// Assigns a restored buffer to the member that registers it, when the layer has no live tensor
+    /// under that name yet.
+    /// </summary>
+    /// <param name="name">The registered buffer name, as written by the serializer.</param>
+    /// <param name="tensor">The tensor rebuilt from the payload.</param>
+    /// <returns><see langword="true"/> when a member accepted it.</returns>
+    /// <remarks>
+    /// <para>
+    /// Registering a tensor is not the same as installing it. The generated
+    /// <c>EnsureBuffersRegistered</c> reads each buffer OUT of its field, so a registration that
+    /// does not also write the field leaves the layer computing with whatever the field still holds
+    /// -- usually <see langword="null"/>. Only the generator knows which field a name belongs to,
+    /// so the mapping is emitted rather than reflected over: a name typo then fails to compile
+    /// instead of silently restoring nothing.
+    /// </para>
+    /// <para>
+    /// The base returns <see langword="false"/>, which preserves the previous behaviour for any
+    /// layer that has no generated map -- an unknown name is skipped, never guessed at.
+    /// </para>
+    /// </remarks>
+    protected virtual bool TryRestoreBufferField(string name, Tensor<T> tensor) => false;
+
+    /// <summary>
+    /// Reports whether <see cref="TryRestoreBufferField"/> can rebind the named generated buffer.
+    /// </summary>
+    /// <remarks>
+    /// Clone preflight must prove the complete persistent-state graph is adoptable before it shares
+    /// any trainable tensors. The generator emits this from the same name-to-field map as the restore
+    /// method, keeping the capability check side-effect free and preventing a half-mutated clone.
+    /// </remarks>
+    protected virtual bool CanRestoreBufferField(string name) => false;
+
+    /// <summary>
+    /// Installs a buffer into the member that owns it and registers it, for callers outside the
+    /// layer such as the clone path.
+    /// </summary>
+    /// <returns><see langword="true"/> when a member accepted it.</returns>
+    internal bool InstallRestoredBuffer(string name, Tensor<T> tensor)
+    {
+        if (tensor is null || string.IsNullOrWhiteSpace(name)) return false;
+
+        // TryRestoreBufferField registers under the member's own state role. Registering here would
+        // take RegisterBuffer's default and turn an input-sized slot back into a counted one.
+        return TryRestoreBufferField(name, tensor);
+    }
+
+    /// <summary>Checks whether every registered source buffer can be installed without mutation.</summary>
+    internal bool CanAdoptRegisteredBuffersFrom(LayerBase<T> source)
+        => CanAdoptRegisteredBuffersFrom(source, out _);
+
+    /// <summary>Checks buffer adoption and describes the first structural mismatch.</summary>
+    internal bool CanAdoptRegisteredBuffersFrom(LayerBase<T> source, out string mismatch)
+    {
+        if (source is null)
+        {
+            mismatch = "source layer is null";
+            return false;
+        }
+
+        var sourceBuffers = source.GetRegisteredBufferState();
+        var destinationBuffers = GetRegisteredBufferState();
+        var destinationByName = new Dictionary<string, Tensor<T>>(StringComparer.Ordinal);
+        for (int i = 0; i < destinationBuffers.Count; i++)
+            destinationByName[destinationBuffers[i].Name] = destinationBuffers[i].Tensor;
+
+        var sourceNames = new HashSet<string>(StringComparer.Ordinal);
+        for (int i = 0; i < sourceBuffers.Count; i++)
+        {
+            var entry = sourceBuffers[i];
+            sourceNames.Add(entry.Name);
+            if (destinationByName.TryGetValue(entry.Name, out var existing)
+                && ShapesMatch(existing.Shape, entry.Tensor.Shape))
+                continue;
+            if (!CanRestoreBufferField(entry.Name))
+            {
+                string destinationShape = destinationByName.TryGetValue(entry.Name, out var current)
+                    ? DescribeTensorShape(current.Shape)
+                    : "<missing>";
+                mismatch = $"buffer '{entry.Name}' source shape={DescribeTensorShape(entry.Tensor.Shape)}, "
+                           + $"clone shape={destinationShape}, and the field cannot be rebound";
+                return false;
+            }
+        }
+
+        // A freshly reconstructed clone may not invent persistent state that is absent from the
+        // source. Input-sized state is still persistent clone state, so it follows the same rule.
+        for (int i = 0; i < destinationBuffers.Count; i++)
+            if (!sourceNames.Contains(destinationBuffers[i].Name))
+            {
+                mismatch = $"clone has extra buffer '{destinationBuffers[i].Name}' "
+                           + $"with shape {DescribeTensorShape(destinationBuffers[i].Tensor.Shape)}";
+                return false;
+            }
+
+        mismatch = string.Empty;
+        return true;
+    }
+
+    /// <summary>Installs all registered buffers using copy-on-write storage where rebinding is possible.</summary>
+    internal void AdoptRegisteredBuffersFrom(LayerBase<T> source)
+    {
+        if (!CanAdoptRegisteredBuffersFrom(source))
+            throw new InvalidOperationException(
+                $"{GetType().Name} cannot adopt the registered-buffer layout of {source.GetType().Name}.");
+
+        var destinationBuffers = GetRegisteredBuffers().ToDictionary(
+            entry => entry.Name,
+            entry => entry.Tensor,
+            StringComparer.Ordinal);
+        var sourceBuffers = source.GetRegisteredBufferState();
+        for (int i = 0; i < sourceBuffers.Count; i++)
+        {
+            var entry = sourceBuffers[i];
+            var shared = (Tensor<T>)entry.Tensor.CloneShared();
+            if (InstallRestoredBuffer(entry.Name, shared)) continue;
+
+            // Readonly generated buffers cannot be rebound, but preflight proved their existing
+            // tensor has the exact source shape. Copying into it preserves independence and state.
+            var existing = destinationBuffers[entry.Name];
+            for (int value = 0; value < entry.Tensor.Length; value++)
+                existing[value] = entry.Tensor[value];
+        }
+    }
+
+    private static bool ShapesMatch(TensorShape left, TensorShape right)
+    {
+        if (left.Length != right.Length) return false;
+        for (int i = 0; i < left.Length; i++)
+            if (left[i] != right[i]) return false;
+        return true;
+    }
+
+    private static string DescribeTensorShape(TensorShape shape)
+        => $"[{string.Join(",", shape.ToArray())}]";
+
     protected void RegisterBuffer(
         Tensor<T> tensor,
         string name,
@@ -7362,6 +8148,41 @@ private ParameterSlotRole GetRegisteredBufferStateRole(string name)
         }
     }
 
+    /// <summary>
+    /// Takes a role-aware snapshot of registered non-trainable state for the common clone path.
+    /// </summary>
+    /// <remarks>
+    /// The public buffer view intentionally exposes only names and tensors. Cloning additionally
+    /// needs the persistence role so <see cref="CloneOptions.IncludeBuffers"/> and
+    /// <see cref="CloneOptions.IncludeOptimizerState"/> remain independent switches instead of
+    /// both copying every registered value.
+    /// </remarks>
+    internal IReadOnlyList<(
+        string Name,
+        Tensor<T> Tensor,
+        PersistentTensorRole PersistenceRole,
+        ParameterSlotRole StateRole)> GetRegisteredBufferState()
+    {
+        // Allow generated overrides to perform their lazy registration before taking the snapshot.
+        _ = GetRegisteredBuffers();
+
+        lock (_bufferRegistrationLock)
+        {
+            var snapshot = new (
+                string Name,
+                Tensor<T> Tensor,
+                PersistentTensorRole PersistenceRole,
+                ParameterSlotRole StateRole)[_registeredBuffers.Count];
+            for (int i = 0; i < _registeredBuffers.Count; i++)
+            {
+                var entry = _registeredBuffers[i];
+                snapshot[i] = (entry.Name, entry.Tensor, entry.PersistenceRole, entry.StateRole);
+            }
+
+            return snapshot;
+        }
+    }
+
     #region ITrainableLayer<T> Implementation
 
     /// <summary>
@@ -7526,6 +8347,21 @@ public virtual void SetTrainableParameters(IReadOnlyList<Tensor<T>> parameters)
                 $"{GetType().Name} has {_registeredTensors.Count} registered parameters but received {parameters.Count}.");
         }
 
+        // Runtime-registered layers can keep their execution handles in fields or containers that
+        // the generator cannot name. A common pattern is to allocate tensors in a loop, store them
+        // in an array/dictionary, and register the loop local. In that case replacing only
+        // _registeredTensors makes GetParameters report the new values while Forward continues to
+        // read the old tensors. Copy-on-write cloning exposed this as a particularly deceptive
+        // failure: source and clone parameter vectors were bit-identical, but their predictions
+        // differed because the clone's execution field had never been rebound.
+        //
+        // Repoint every derived-class field/container entry that aliases an OLD registry tensor.
+        // This is deliberately identity-based: unregistered buffers and external tensors are left
+        // alone, and ordinary generated setters (which assign their fields before reaching here)
+        // become a cheap no-op. Reflection is paid only at an explicit parameter-rebind boundary,
+        // never during Forward.
+        RebindRuntimeParameterHandles(_registeredTensors, parameters);
+
         for (int i = 0; i < parameters.Count; i++)
             _registeredTensors[i] = parameters[i];
 
@@ -7537,6 +8373,191 @@ public virtual void SetTrainableParameters(IReadOnlyList<Tensor<T>> parameters)
         BumpParameterEpoch();
     }
 
+    /// <summary>
+    /// Rebinds a legacy layer whose complete parameter order is exposed by an explicit
+    /// <c>GetAllTensors()</c> convention consumed by source generation.
+    /// </summary>
+    /// <remarks>
+    /// The convention supplies order; this shared boundary supplies the part a returned array
+    /// cannot: replacing the tensor handles held in private fields, arrays, lists, or dictionaries
+    /// and synchronizing the persistent engine registry. It is invoked only by generated setters.
+    /// </remarks>
+    protected void SetConventionEnumeratedTrainableParameters(
+        IReadOnlyList<Tensor<T>> current,
+        IReadOnlyList<Tensor<T>> parameters)
+    {
+        if (current is null) throw new ArgumentNullException(nameof(current));
+        if (parameters is null) throw new ArgumentNullException(nameof(parameters));
+        if (parameters.Count != current.Count)
+        {
+            throw new ArgumentException(
+                $"{GetType().Name} exposes {current.Count} convention-enumerated parameters but received {parameters.Count}.",
+                nameof(parameters));
+        }
+
+        var roles = new PersistentTensorRole[current.Count];
+        for (int i = 0; i < current.Count; i++)
+        {
+            roles[i] = InferConventionParameterRole(current[i]);
+            for (int registered = 0; registered < _registeredTensors.Count; registered++)
+            {
+                if (!ReferenceEquals(current[i], _registeredTensors[registered])) continue;
+                roles[i] = _registeredTensorRoles[registered];
+                break;
+            }
+        }
+
+        RebindRuntimeParameterHandles(current, parameters);
+        ClearRegisteredParameters();
+        for (int i = 0; i < parameters.Count; i++)
+            AppendTrainableParameter(parameters[i], roles[i]);
+
+        AdoptTrainableParameterTensors(parameters);
+        MarkTrainableParametersRebound();
+    }
+
+    private PersistentTensorRole InferConventionParameterRole(Tensor<T> tensor)
+    {
+        for (Type? type = GetType(); type is not null && type != typeof(LayerBase<T>); type = type.BaseType)
+        {
+            var fields = type.GetFields(
+                System.Reflection.BindingFlags.Instance |
+                System.Reflection.BindingFlags.Public |
+                System.Reflection.BindingFlags.NonPublic |
+                System.Reflection.BindingFlags.DeclaredOnly);
+
+            foreach (var field in fields)
+            {
+                object? value = field.GetValue(this);
+                bool owns = ReferenceEquals(value, tensor);
+                if (!owns && value is System.Collections.IDictionary dictionary)
+                {
+                    foreach (System.Collections.DictionaryEntry entry in dictionary)
+                    {
+                        if (!ReferenceEquals(entry.Value, tensor)) continue;
+                        owns = true;
+                        break;
+                    }
+                }
+                else if (!owns && value is System.Collections.IEnumerable sequence && value is not string)
+                {
+                    foreach (object? item in sequence)
+                    {
+                        if (!ReferenceEquals(item, tensor)) continue;
+                        owns = true;
+                        break;
+                    }
+                }
+
+                if (!owns) continue;
+                string name = field.Name.ToLowerInvariant();
+                if (name.Contains("bias") || name.Contains("beta"))
+                    return PersistentTensorRole.Biases;
+                if (name.Contains("embedding"))
+                    return PersistentTensorRole.Embeddings;
+                if (name.Contains("norm") || name.Contains("gamma"))
+                    return PersistentTensorRole.NormalizationParams;
+                if (name.Contains("scale"))
+                    return PersistentTensorRole.ScaleParameters;
+                return PersistentTensorRole.Weights;
+            }
+        }
+
+        return PersistentTensorRole.Weights;
+    }
+
+    private void RebindRuntimeParameterHandles(
+        IReadOnlyList<Tensor<T>> previous,
+        IReadOnlyList<Tensor<T>> replacements)
+    {
+        if (previous.Count != replacements.Count || previous.Count == 0) return;
+
+        Tensor<T>? ReplacementFor(object? candidate)
+        {
+            if (candidate is not Tensor<T> tensor) return null;
+            for (int i = 0; i < previous.Count; i++)
+                if (ReferenceEquals(tensor, previous[i])) return replacements[i];
+            return null;
+        }
+
+        for (Type? type = GetType(); type is not null && type != typeof(LayerBase<T>); type = type.BaseType)
+        {
+            var fields = type.GetFields(
+                System.Reflection.BindingFlags.Instance |
+                System.Reflection.BindingFlags.Public |
+                System.Reflection.BindingFlags.NonPublic |
+                System.Reflection.BindingFlags.DeclaredOnly);
+
+            foreach (var field in fields)
+            {
+                object? value = field.GetValue(this);
+                if (value is Tensor<T>)
+                {
+                    var replacement = ReplacementFor(value);
+                    if (replacement is not null && !field.IsInitOnly && field.FieldType.IsInstanceOfType(replacement))
+                        field.SetValue(this, replacement);
+                    continue;
+                }
+
+                if (value is System.Collections.IDictionary dictionary && !dictionary.IsReadOnly)
+                {
+                    var updates = new List<(object Key, Tensor<T> Value)>();
+                    foreach (System.Collections.DictionaryEntry entry in dictionary)
+                    {
+                        var replacement = ReplacementFor(entry.Value);
+                        if (replacement is not null && entry.Key is not null)
+                            updates.Add((entry.Key, replacement));
+                    }
+                    foreach (var update in updates) dictionary[update.Key] = update.Value;
+                    continue;
+                }
+
+                // System.Array implements IList, but the IList indexer is valid only for
+                // one-dimensional arrays. Derived layers may legitimately keep rectangular
+                // lookup tables (for example Swin's relative-position index) alongside tensor
+                // arrays. Walk every array by its actual rank so merely rebinding parameters
+                // cannot fail on unrelated multidimensional state.
+                if (value is Array array)
+                {
+                    var indices = new int[array.Rank];
+                    for (int dimension = 0; dimension < indices.Length; dimension++)
+                        indices[dimension] = array.GetLowerBound(dimension);
+
+                    for (long visited = 0; visited < array.LongLength; visited++)
+                    {
+                        var replacement = ReplacementFor(array.GetValue(indices));
+                        if (replacement is not null)
+                            array.SetValue(replacement, indices);
+
+                        for (int dimension = indices.Length - 1; dimension >= 0; dimension--)
+                        {
+                            if (indices[dimension] < array.GetUpperBound(dimension))
+                            {
+                                indices[dimension]++;
+                                break;
+                            }
+
+                            indices[dimension] = array.GetLowerBound(dimension);
+                        }
+                    }
+
+                    continue;
+                }
+
+                if (value is System.Collections.IList list && !list.IsReadOnly)
+                {
+                    for (int i = 0; i < list.Count; i++)
+                    {
+                        var replacement = ReplacementFor(list[i]);
+                        if (replacement is not null)
+                            list[i] = replacement;
+                    }
+                }
+            }
+        }
+
+    }
+
     /// <summary>
     /// Points this layer's own parameter fields at tensors adopted without materialization.
     /// </summary>
@@ -7579,7 +8600,6 @@ internal virtual void CopyTrainableParametersFrom(IReadOnlyList<Tensor<T>> sourc
             sources[i].Data.Span.CopyTo(dst[i].Data.Span);
             Engine.InvalidatePersistentTensor(dst[i]);
         }
-        OnParameterValuesChanged();
     }
 
     /// <summary>
@@ -8454,4 +9474,14 @@ public virtual AiDotNet.Onnx.OnnxLayerOutputs ConvertToOnnx(
     }
 
     #endregion
+
+    protected virtual void OnParameterValuesChanged()
+    {
+    }
+
+    /// <summary>Rebinds a lazy layer to the shape implied by a parameter count, if it can.</summary>
+    protected virtual bool TryRebindForParameterCount(int parameterCount) => false;
+
+    /// <summary>Whether this count is achievable at SOME input shape, checked while unresolved.</summary>
+    protected virtual bool CanEverAcceptParameterCount(int parameterCount) => true;
 }
diff --git a/src/NeuralNetworks/Layers/LayerCloning.cs b/src/NeuralNetworks/Layers/LayerCloning.cs
new file mode 100644
index 0000000000..2ce7ecee73
--- /dev/null
+++ b/src/NeuralNetworks/Layers/LayerCloning.cs
@@ -0,0 +1,568 @@
+using System;
+using System.Linq;
+using System.Collections.Generic;
+using System.Reflection;
+using AiDotNet.Models;
+using AiDotNet.Serialization;
+
+namespace AiDotNet.NeuralNetworks.Layers;
+
+/// <summary>
+/// Cloning for layers, built on the construction state layers already record for serialization.
+/// </summary>
+/// <remarks>
+/// <para>
+/// <b>For Beginners:</b> <c>layer.Clone()</c> gives you a separate copy of a layer, including what
+/// it has learned. You do not write anything to make this work on a layer of your own: mark the
+/// constructor arguments the layer needs with <c>[LayerState]</c> — which it already needs for
+/// saving and loading — and cloning follows.
+/// </para>
+/// <para>
+/// This deliberately reuses <c>WriteConstructionState</c> and <c>GeneratedLayerFactories.TryCreate</c>
+/// rather than introducing a second reconstruction mechanism. Those already call the layer's real
+/// constructor with the values it was originally given, and the build already fails for a layer
+/// whose required state cannot be sourced. A separate clone-only path would be a second thing to
+/// keep correct, and the two would be free to disagree — which is the entire failure this work
+/// exists to remove. Sharing one path means a layer that saves and loads correctly also clones
+/// correctly, by construction.
+/// </para>
+/// <para>
+/// The learned parameters travel separately, through <c>GetParameters</c> and
+/// <c>UpdateParameters</c>. That is the contract training exercises on every step, so a clone
+/// cannot disagree with training about what the parameters are.
+/// </para>
+/// </remarks>
+public static class LayerCloning
+{
+    private const string CloneRandomSeedKey = "__aidotnet_clone_random_seed";
+
+    /// <summary>
+    /// Creates an independent copy of a layer.
+    /// </summary>
+    /// <typeparam name="T">The layer's numeric type.</typeparam>
+    /// <param name="source">The layer to copy.</param>
+    /// <param name="options">What the copy carries; defaults to <see cref="CloneOptions.Full"/>.</param>
+    /// <returns>A new layer of the same type and configuration.</returns>
+    /// <exception cref="ArgumentNullException">Thrown when <paramref name="source"/> is null.</exception>
+    /// <exception cref="NotSupportedException">
+    /// Thrown when no generated factory exists for the layer's type.
+    /// </exception>
+    /// <remarks>
+    /// <para>
+    /// The clone is rebuilt by calling the layer's constructor with its recorded state, so
+    /// everything the constructor derives — weight buffers sized from the output width, sub-layers,
+    /// initialization strategy — is re-derived rather than copied. A stale derived value in the
+    /// original therefore cannot reach the copy, which is the advantage reconstruction has over
+    /// field-copying.
+    /// </para>
+    /// <para>
+    /// Learned parameters are then written in, when <see cref="CloneOptions.IncludeParameters"/>
+    /// says so. With it off the result is the same architecture, freshly initialized — the
+    /// equivalent of scikit-learn's <c>clone()</c>, which returns an unfitted estimator carrying
+    /// the same hyperparameters.
+    /// </para>
+    /// </remarks>
+    public static ILayer<T> Clone<T>(this LayerBase<T> source, CloneOptions? options = null)
+    {
+        if (source is null) throw new ArgumentNullException(nameof(source));
+
+        var settings = options ?? CloneOptions.Full;
+        int? cloneSeed = settings.ShareRandomState
+            ? source.RandomSeed
+            : DeriveCloneSeed(source.RandomSeed);
+
+        // An unseeded architecture clone still needs a genuinely fresh initialization. Several
+        // legacy layers expose `seed = 42` on their constructor without reflecting it into
+        // LayerBase.RandomSeed; replaying that literal would make every configuration-only clone
+        // start from identical weights. The reserved factory value affects construction only. The
+        // public RandomSeed remains null, preserving the caller's deliberate unseeded contract.
+        int? constructionSeed = cloneSeed;
+        if (!settings.IncludeParameters && !constructionSeed.HasValue)
+        {
+            constructionSeed = AiDotNet.Tensors.Helpers.RandomHelper.CreateSecureRandom().Next();
+        }
+
+        var clone = Reconstruct(source, constructionSeed);
+
+        // A shared stream must restart from the same deterministic seed. The default derives a
+        // different, reproducible stream so two independently-trained clones do not receive the
+        // same stochastic masks forever. An unseeded source remains intentionally unseeded.
+        clone.RandomSeed = cloneSeed;
+
+        if (settings.IncludeParameters || settings.IncludeBuffers || settings.IncludeOptimizerState)
+        {
+            InstallInto(source, clone, settings);
+
+            // AFTER the install, not before. Checking first measured an empty clone against a
+            // resolved original and reported every lazy layer as broken.
+            if (settings.IncludeParameters && clone.ParameterCount != source.ParameterCount)
+            {
+                throw new InvalidOperationException(
+                    $"{source.GetType().Name} rebuilt with {clone.ParameterCount} parameters but "
+                    + $"the original has {source.ParameterCount}. A constructor argument that "
+                    + "determines size is not recorded, so the copy is a different shape from "
+                    + "the original.");
+            }
+        }
+
+
+        // LAST: reconstruction and any shape-resolution probe may consume stochastic counters or
+        // Random instances. Apply the requested stream semantics only after that work is finished.
+        CopyRandomState(source, clone, settings.ShareRandomState);
+
+        return clone;
+    }
+
+    private static void CopyRandomState<T>(
+        LayerBase<T> source,
+        LayerBase<T> clone,
+        bool shareRandomState)
+    {
+        source.CopyBaseRandomStateTo(clone, shareRandomState);
+
+        int randomFieldIndex = 0;
+        for (Type? type = source.GetType();
+             type is not null && type != typeof(LayerBase<T>);
+             type = type.BaseType)
+        {
+            foreach (var field in type.GetFields(
+                         BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public
+                         | BindingFlags.DeclaredOnly))
+            {
+                if (field.FieldType == typeof(Random))
+                {
+                    var sourceRandom = (Random?)field.GetValue(source);
+                    if (sourceRandom is null) continue;
+
+                    Random replacement;
+                    if (shareRandomState)
+                    {
+                        replacement = CloneRandom(sourceRandom);
+                    }
+                    else if (clone.RandomSeed.HasValue)
+                    {
+                        int fieldSeed = DeriveFieldSeed(
+                            clone.RandomSeed.Value, field.Name, randomFieldIndex++);
+                        replacement = AiDotNet.Tensors.Helpers.RandomHelper.CreateSeededRandom(fieldSeed);
+                    }
+                    else
+                    {
+                        // The constructor already supplied an independent secure stream.
+                        continue;
+                    }
+
+                    field.SetValue(clone, replacement);
+                    continue;
+                }
+
+                if (!IsStochasticCounter(field)) continue;
+                field.SetValue(clone, shareRandomState
+                    ? field.GetValue(source)
+                    : Activator.CreateInstance(field.FieldType));
+            }
+        }
+    }
+
+    /// <summary>
+    /// Preserves the future initialization state of a copy-on-write layer whose parameter tensors
+    /// are still wholly deferred.
+    /// </summary>
+    internal static void CopyDeferredRandomState<T>(LayerBase<T> source, LayerBase<T> clone)
+    {
+        if (source is null) throw new ArgumentNullException(nameof(source));
+        if (clone is null) throw new ArgumentNullException(nameof(clone));
+        if (source.GetType() != clone.GetType())
+            throw new ArgumentException("Deferred random state requires matching layer types.", nameof(clone));
+
+        clone.RandomSeed = source.RandomSeed;
+        CopyRandomState(source, clone, shareRandomState: true);
+    }
+
+    private static bool IsStochasticCounter(FieldInfo field)
+    {
+        if (field.IsInitOnly || field.IsStatic
+            || !field.Name.EndsWith("Counter", StringComparison.OrdinalIgnoreCase))
+            return false;
+
+        bool stochasticName = field.Name.IndexOf("seed", StringComparison.OrdinalIgnoreCase) >= 0
+                              || field.Name.IndexOf("dropPath", StringComparison.OrdinalIgnoreCase) >= 0
+                              || field.Name.IndexOf("init", StringComparison.OrdinalIgnoreCase) >= 0;
+        if (!stochasticName) return false;
+
+        Type type = field.FieldType;
+        return type == typeof(int) || type == typeof(uint)
+            || type == typeof(long) || type == typeof(ulong);
+    }
+
+    private static int DeriveFieldSeed(int seed, string fieldName, int index)
+    {
+        uint hash = unchecked((uint)seed) ^ unchecked((uint)index * 0x9E3779B9u);
+        for (int i = 0; i < fieldName.Length; i++)
+            hash = unchecked((hash ^ fieldName[i]) * 16777619u);
+        hash ^= hash >> 16;
+        hash *= 0x85EBCA6Bu;
+        hash ^= hash >> 13;
+        return unchecked((int)hash);
+    }
+
+    private static readonly MethodInfo MemberwiseCloneMethod = typeof(object).GetMethod(
+        "MemberwiseClone", BindingFlags.Instance | BindingFlags.NonPublic)
+        ?? throw new InvalidOperationException("Object.MemberwiseClone is unavailable.");
+
+    private static Random CloneRandom(Random source)
+    {
+        var clone = (Random)MemberwiseCloneMethod.Invoke(source, null)!;
+
+        // .NET Framework's Random stores its mutable seed table in an int[]; modern runtimes use
+        // primitive state fields or a private implementation object. Deep-copy both representations
+        // so source and clone advance identically but never consume one shared mutable stream.
+        for (Type? type = source.GetType(); type is not null; type = type.BaseType)
+        {
+            foreach (var field in type.GetFields(
+                         BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public
+                         | BindingFlags.DeclaredOnly))
+            {
+                object? value = field.GetValue(source);
+                if (value is Array array)
+                    field.SetValue(clone, array.Clone());
+                else if (value is not null
+                         && !field.FieldType.IsValueType
+                         && field.FieldType != typeof(string))
+                    field.SetValue(clone, MemberwiseCloneMethod.Invoke(value, null));
+            }
+        }
+
+        return clone;
+    }
+
+    private static int? DeriveCloneSeed(int? sourceSeed)
+    {
+        if (!sourceSeed.HasValue) return null;
+
+        // SplitMix's integer avalanche gives a stable child seed without consuming or coupling the
+        // source stream. Keep this local and deterministic across target frameworks.
+        uint value = unchecked((uint)sourceSeed.Value + 0x9E3779B9u);
+        value = (value ^ (value >> 16)) * 0x85EBCA6Bu;
+        value = (value ^ (value >> 13)) * 0xC2B2AE35u;
+        return unchecked((int)(value ^ (value >> 16)));
+    }
+
+    /// <summary>
+    /// Copies one layer's learned tensors into another, then does the same for its sub-layers.
+    /// </summary>
+    /// <remarks>
+    /// Recursive because <see cref="LayerBase{T}.GetTrainableParameters"/> reports only a layer's
+    /// OWN tensors. A composite therefore installed nothing into its children, which kept whatever
+    /// the constructor gave them — <c>SwinTransformerBlockLayer</c> rebuilt 98 parameters against
+    /// the original's 130, its six registered children never filled.
+    /// </remarks>
+    private static void InstallInto<T>(LayerBase<T> source, LayerBase<T> clone, CloneOptions settings)
+    {
+        // RESOLVE THE CLONE BEFORE INSTALLING. A lazy layer materializes its weights on its first
+        // forward, and that initialization overwrites anything installed beforehand: the clone came
+        // back structurally right but carrying fresh random weights, and the DenseLayer round trip
+        // read "original 0, clone 0.36892061820885858". Resolving here means the install writes into
+        // tensors that already exist, so the first forward has nothing left to initialize. Only
+        // meaningful when the SOURCE is resolved -- cloning an untouched layer should stay untouched.
+        int[]? declared = null;
+        try
+        {
+            declared = source.GetInputShape();
+        }
+        catch (Exception)
+        {
+            // A layer that will not describe its input cannot be probed; the install below still
+            // runs and the count assertion still reports any shortfall.
+        }
+
+        // EXACT means every axis is concrete. Only then may the clone be RESOLVED from it, because
+        // ResolveFromShape pins the axes it is given and pinning one to a guess would contradict
+        // whatever length the layer is actually used at later.
+        var exact = declared is not null && Array.TrueForAll(declared, d => d > 0) ? declared : null;
+
+        if (exact is not null && !clone.IsShapeResolved)
+        {
+            // Two shape conventions, same reason the sweep probes both: GetInputShape describes
+            // one sample for most layers and the full input for others.
+            foreach (var candidate in new[] { exact, WithBatchAxis(exact) })
+            {
+                try { clone.ResolveFromShape(candidate); break; }
+                catch (ArgumentException) { /* try the other; install as-is if neither fits */ }
+                catch (InvalidOperationException) { }
+            }
+        }
+
+        CopyOwnTensors(source, clone, settings);
+        CopyChildren(source, clone, settings);
+
+        if (clone.ParameterCount == source.ParameterCount || declared is null) return;
+
+        // A SECOND PASS BEHIND A FORWARD, because there are two different ways a composite arrives
+        // under-filled and neither mechanism covers the other.
+        //
+        // SwinTransformerBlockLayer registers its six children in the constructor, so they exist on
+        // both sides and CopyChildren pairs them off; a forward probe cannot help it at all, since
+        // GetInputShape reports [dim] while the block actually consumes a spatial input and every
+        // candidate shape throws. CitrinetBlockLayer, ContextNetBlockLayer, HiFiGANResBlockLayer and
+        // WaveNetResidualBlockLayer are the mirror image: the generated EnsureSubLayersRegistered()
+        // runs during shape resolution, so a clone that never resolved has NO children for
+        // CopyChildren to pair with and came back holding 0 parameters against the original's 401.
+        // A forward is what brings those into existence.
+        //
+        // Those four also explain why this cannot wait for IsShapeResolved. They declare
+        // [channels, -1] and the -1 is a genuinely free axis, so the flag reads false even on a
+        // layer that HAS been forwarded and has materialized all nine children -- gating on it
+        // skipped precisely the layers that needed the probe. A free axis therefore has to be
+        // filled with a guess to forward at all, and that is safe here for the same reason it is
+        // free: the layer does not pin it (IsShapeResolved is still false afterwards) and it
+        // contributes no parameters. Should either assumption fail, the guessed shape produces the
+        // wrong count and the assertion in Clone reports it rather than returning a quiet mis-copy.
+        //
+        // The probe runs only once the cheap paths have been tried and the counts still disagree --
+        // a forward has side effects, and ResetState clears what it leaves behind before the retry
+        // writes the real weights over the fresh random ones the probe just initialized.
+        foreach (var candidate in ProbeShapes(declared))
+        {
+            try
+            {
+                clone.Forward(new Tensor<T>(candidate));
+                clone.ResetState();
+                break;
+            }
+            catch (Exception)
+            {
+                // A layer that refuses this probe keeps whatever it managed to resolve; the count
+                // assertion after the install still reports the shortfall.
+            }
+        }
+
+        CopyOwnTensors(source, clone, settings);
+        CopyChildren(source, clone, settings);
+    }
+
+    /// <summary>Prepends a size-1 batch axis to a shape.</summary>
+    internal static int[] WithBatchAxis(int[] shape)
+    {
+        var batched = new int[shape.Length + 1];
+        batched[0] = 1;
+        Array.Copy(shape, 0, batched, 1, shape.Length);
+
+        return batched;
+    }
+
+    /// <summary>
+    /// Concrete shapes to try forwarding through a clone, derived from a declared input shape.
+    /// </summary>
+    /// <remarks>
+    /// Free axes come back as <c>-1</c> and are filled with a concrete length; both the with-batch
+    /// and without-batch conventions are offered because <c>GetInputShape</c> describes one sample
+    /// for some layers and the full input for others. Two fill sizes rather than one: a strided
+    /// block consumes length, so <c>CitrinetBlockLayer</c> (kernel 3, stride 2) has nothing left to
+    /// convolve at length 4 and only the longer probe survives.
+    /// </remarks>
+    internal static IEnumerable<int[]> ProbeShapes(int[] declared)
+    {
+        // 16 before 4, and NOT 1. Trying a length-1 fill first was measured and rejected: it made
+        // DeepCopy neutral-to-worse (CanaryQwen 6,341 -> 6,953 ms, F5TTS 1,783 -> 2,413 ms) even
+        // though it succeeded on the first candidate every time, so the extra attempt was not the
+        // cost. What that rules out is the assumption behind it -- the probe's expense is not the
+        // sequence-length arithmetic, it is materializing the layer's weights, and that is sized by
+        // the layer rather than by the probe. Shortening the free axis cannot make it cheaper, which
+        // means the probe cost is work the clone has to do anyway rather than overhead to remove.
+        foreach (var fill in new[] { 16, 4 })
+        {
+            var concrete = new int[declared.Length];
+            for (var i = 0; i < declared.Length; i++) concrete[i] = declared[i] > 0 ? declared[i] : fill;
+
+            yield return WithBatchAxis(concrete);
+            yield return concrete;
+
+            // A shape that was already concrete does not vary with the fill, so the second pass
+            // over it would repeat four throwing probes for nothing.
+            if (Array.TrueForAll(declared, d => d > 0)) yield break;
+        }
+    }
+
+    /// <summary>Writes a layer's own learned tensors into another layer of the same type.</summary>
+    private static void CopyOwnTensors<T>(LayerBase<T> source, LayerBase<T> clone, CloneOptions settings)
+    {
+        // INSTALL TENSORS, NOT A FLAT VECTOR. A tensor carries its own shape, so installing one
+        // resolves a clone whose input width is lazy; a flat Vector<T> carries no shape, and pushing
+        // 16 values into a DenseLayer rebuilt from `outputSize` alone threw "Expected 0 parameters,
+        // but got 16". That is why cloning a layer which had been USED failed while cloning a fresh
+        // one appeared to work: both sides were unresolved and agreed at zero.
+        CopyRegisteredBuffers(source, clone, settings);
+
+        if (!settings.IncludeParameters) return;
+
+        var tensors = source.GetTrainableParameters();
+        if (tensors.Count == 0) return;
+
+        var installed = new Tensor<T>[tensors.Count];
+        for (var i = 0; i < tensors.Count; i++)
+        {
+            // Shared hands over the ORIGINAL tensors, so both handles are one set of weights and
+            // training either trains both.
+            //
+            installed[i] = CloneTensorForMode(tensors[i], settings.Mode);
+        }
+
+        clone.SetTrainableParameters(installed);
+    }
+
+    /// <summary>Copies registered buffer values, which the trainable install cannot reach.</summary>
+    /// <remarks>
+    /// <c>GetTrainableParameters</c> is the OPTIMIZER view and omits every buffer, so the only
+    /// reason a clone ever came back holding one was that buffers rode the flat parameter vector.
+    /// An input-sized buffer cannot ride it -- its width is the caller's data rather than the
+    /// architecture -- so the values are copied here instead.
+    ///
+    /// By NAME, for the reason the serialized block is keyed by name: registration order can differ
+    /// between a used instance and a freshly reconstructed one, and pairing by position would load
+    /// an adjacency matrix into an edge-feature slot. A clone that already holds a same-width tensor
+    /// is written through, matching the restore path; otherwise the generated field map installs it.
+    /// </remarks>
+    private static void CopyRegisteredBuffers<T>(LayerBase<T> source, LayerBase<T> clone, CloneOptions settings)
+    {
+        var sourceBuffers = source.GetRegisteredBufferState();
+        if (sourceBuffers is null || sourceBuffers.Count == 0) return;
+
+        var target = new Dictionary<string, Tensor<T>>(StringComparer.Ordinal);
+        var cloneBuffers = clone.GetRegisteredBuffers();
+        if (cloneBuffers is not null)
+        {
+            foreach (var (name, tensor) in cloneBuffers)
+            {
+                if (tensor is not null) target[name] = tensor;
+            }
+        }
+
+        foreach (var (name, tensor, persistenceRole, _) in sourceBuffers)
+        {
+            if (tensor is null || string.IsNullOrEmpty(name)) continue;
+
+            bool optimizerState = persistenceRole == PersistentTensorRole.OptimizerState;
+            if (optimizerState ? !settings.IncludeOptimizerState : !settings.IncludeBuffers)
+                continue;
+
+            // Shared means aliasing storage, including when the constructor allocated a same-sized
+            // destination buffer. The generated field map performs the rebind and retains the
+            // declaration's original roles.
+            if (settings.Mode == CloneMode.Shared
+                && clone.InstallRestoredBuffer(name, tensor))
+                continue;
+
+            if (target.TryGetValue(name, out var existing) && existing.Length == tensor.Length)
+            {
+                if (ReferenceEquals(existing, tensor)) continue;
+                for (int i = 0; i < tensor.Length; i++) existing[i] = tensor[i];
+                continue;
+            }
+
+            var installed = CloneTensorForMode(tensor, settings.Mode);
+            clone.InstallRestoredBuffer(name, installed);
+        }
+    }
+
+    /// <summary>Clones one persistent tensor without densifying sparse state.</summary>
+    private static Tensor<T> CloneTensorForMode<T>(Tensor<T> tensor, CloneMode mode)
+    {
+        if (mode == CloneMode.Shared) return tensor;
+
+        // Tensor.Clone/CloneShared intentionally reject SparseTensor because a dense storage clone
+        // would discard its COO topology. Preserve row/column indices and only duplicate the
+        // non-zero payload. Copy-on-write currently has no sparse storage primitive, so an eager
+        // independent sparse copy is the correct conservative implementation for that mode.
+        if (tensor is SparseTensor<T> sparse)
+        {
+            if (sparse.Shape.Length != 2)
+                throw new InvalidOperationException(
+                    $"Sparse clone requires rank 2, got rank {sparse.Shape.Length}.");
+
+            return new SparseTensor<T>(
+                sparse.Shape[0],
+                sparse.Shape[1],
+                sparse.RowIndices.ToArray(),
+                sparse.ColumnIndices.ToArray(),
+                sparse.DataVector.ToArray());
+        }
+
+        return mode == CloneMode.CopyOnWrite
+            ? (Tensor<T>)tensor.CloneShared()
+            : tensor.Clone();
+    }
+
+    /// <summary>Copies each registered sub-layer's parameters into the matching sub-layer.</summary>
+    /// <remarks>
+    /// Pairwise by index: both sides were built by the same constructor in the same order, which is
+    /// the pairing <c>GetTrainableParameters</c> and <c>ParameterCount</c> already rely on when they
+    /// walk this list. Needs no shape at all — a tensor carries its own — so it reaches composites a
+    /// forward probe cannot. Recursion carries the mode with it, so a Shared clone shares its
+    /// children's weights too rather than quietly deep-copying them.
+    /// </remarks>
+    private static void CopyChildren<T>(LayerBase<T> source, LayerBase<T> clone, CloneOptions settings)
+    {
+        var sourceChildren = source.GetSubLayers();
+        var cloneChildren = clone.GetSubLayers();
+
+        if (sourceChildren is null || cloneChildren is null) return;
+        if (sourceChildren.Count != cloneChildren.Count) return;
+
+        for (var i = 0; i < sourceChildren.Count; i++)
+        {
+            if (sourceChildren[i] is LayerBase<T> childSource
+                && cloneChildren[i] is LayerBase<T> childClone)
+            {
+                InstallInto(childSource, childClone, settings);
+            }
+        }
+    }
+
+    /// <summary>
+    /// Rebuilds a layer from the construction state it records for serialization.
+    /// </summary>
+    /// <typeparam name="T">The layer's numeric type.</typeparam>
+    /// <param name="source">The layer to rebuild.</param>
+    /// <returns>A new, freshly constructed layer of the same type and configuration.</returns>
+    /// <exception cref="NotSupportedException">Thrown when the type has no generated factory.</exception>
+    private static LayerBase<T> Reconstruct<T>(LayerBase<T> source, int? constructionSeed)
+    {
+        var metadata = new Dictionary<string, string>(StringComparer.Ordinal);
+        source.CaptureConstructionState(metadata);
+
+        var values = new Dictionary<string, object>(StringComparer.Ordinal);
+        foreach (var pair in metadata) values[pair.Key] = pair.Value;
+        source.CaptureConstructionObjects(values);
+        if (constructionSeed.HasValue) values[CloneRandomSeedKey] = constructionSeed.Value;
+
+        var type = source.GetType();
+        var bag = new LayerStateBag(values, type.Name);
+
+        var definition = type.IsGenericType ? type.GetGenericTypeDefinition() : type;
+
+        // The generated table first -- it is compile-checked and names the constructor directly.
+        // Then the registry, which is the only way a layer defined in ANOTHER assembly can take
+        // part: its generated class lives there and this one cannot name it. Then reflection, so a
+        // hand-written layer works without its author registering anything at all.
+        if (!GeneratedLayerFactories<T>.TryCreate(
+                definition, bag, source.ScalarActivation, source.VectorActivation, out var rebuilt)
+            && !LayerFactoryRegistry<T>.TryCreate(
+                type, definition, bag, source.ScalarActivation, source.VectorActivation, out rebuilt))
+        {
+            throw new NotSupportedException(
+                $"{type.Name} cannot be rebuilt: no generated factory, no registered factory, and its "
+                + "constructor could not be satisfied from the saved state. If this layer lives "
+                + "outside AiDotNet, register a factory with "
+                + $"LayerFactoryRegistry<{typeof(T).Name}>.Register, or make sure each constructor "
+                + "argument is stored in a field of the same name so it is written at save time.");
+        }
+
+        if (rebuilt is not LayerBase<T> layer)
+        {
+            throw new NotSupportedException(
+                $"{type.Name} was rebuilt as {rebuilt?.GetType().Name ?? "null"}, which is not a layer.");
+        }
+
+        return layer;
+    }
+}
diff --git a/src/NeuralNetworks/Layers/LayerNormalizationLayer.cs b/src/NeuralNetworks/Layers/LayerNormalizationLayer.cs
index 7e93f67ac1..31da4f2a04 100644
--- a/src/NeuralNetworks/Layers/LayerNormalizationLayer.cs
+++ b/src/NeuralNetworks/Layers/LayerNormalizationLayer.cs
@@ -89,34 +89,42 @@ public partial class LayerNormalizationLayer<T> : LayerBase<T>, IShapeContract
     /// <summary>
     /// Stores the input tensor from the last forward pass for use in the backward pass.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastInput;
 
     /// <summary>
     /// Stores the mean values for each sample from the last forward pass.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastMean;
 
     /// <summary>
     /// Stores the variance values for each sample from the last forward pass.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastVariance;
 
     /// <summary>
     /// Stores the gradients for the gamma parameters calculated during the backward pass.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _gammaGradient;
 
     /// <summary>
     /// Stores the gradients for the beta parameters calculated during the backward pass.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _betaGradient;
 
     private Tensor<T>? _gammaVelocity;
     private Tensor<T>? _betaVelocity;
 
     // GPU cached tensors for backward pass
+    [ExternalState]
     private Tensor<T>? _gpuLastInput;
+    [ExternalState]
     private Tensor<T>? _gpuSaveMean;
+    [ExternalState]
     private Tensor<T>? _gpuSaveInvVar;
 
     /// <summary>
@@ -245,6 +253,20 @@ public LayerNormalizationLayer(double epsilon = NumericalStabilityHelper.LargeEp
         _beta = new Tensor<T>([0]);
     }
 
+    /// <summary>
+    /// Construction state: the feature width this layer normalizes over, kept current for BOTH
+    /// construction paths.
+    /// </summary>
+    /// <remarks>
+    /// Not readonly, and not merely an echo of the eager constructor's argument. This field is what
+    /// the generated <c>WriteConstructionState</c> saves, so a layer built through the lazy
+    /// constructor and resolved on first forward would otherwise save featureSize = 0 and fail its
+    /// own rebuild with "featureSize must be positive, got 0" -- state that describes how the layer
+    /// was CONSTRUCTED rather than what it currently is cannot round-trip a lazily-resolved layer.
+    /// Every path that sizes gamma/beta updates it.
+    /// </remarks>
+    private int _featureSize;
+
     /// <summary>
     /// AiDotNet#1370 eager-init constructor. Pass <paramref name="featureSize"/> at
     /// construction to allocate gamma/beta immediately and resolve the layer's input
@@ -271,11 +293,23 @@ public LayerNormalizationLayer(double epsilon = NumericalStabilityHelper.LargeEp
     /// </para>
     /// </remarks>
     /// <exception cref="ArgumentOutOfRangeException">When <paramref name="featureSize"/> is not positive.</exception>
+    /// <remarks>
+    /// BOTH parameters carry [LayerState] because the generator uses only the ATTRIBUTED set once any
+    /// parameter on a constructor is marked -- annotating featureSize alone would silently stop
+    /// epsilon being saved.
+    /// <para>
+    /// OmitWhenNonPositive is what keeps a lazily-built LayerNorm rebuildable. Such a layer has
+    /// _featureSize == 0 until its first forward, and 0 is the honest answer, but this constructor
+    /// rejects it. Omitting the key rather than saving the 0 makes the generated factory decline the
+    /// layer, and the loader falls through to the lazy path that builds it correctly.
+    /// </para>
+    /// </remarks>
     public LayerNormalizationLayer(
-        int featureSize,
-        double epsilon = NumericalStabilityHelper.LargeEpsilon)
+        [LayerState(OmitWhenNonPositive = true)] int featureSize,
+        [LayerState] double epsilon = NumericalStabilityHelper.LargeEpsilon)
         : base(new[] { featureSize }, new[] { featureSize })
     {
+        _featureSize = featureSize;
         if (featureSize <= 0)
             throw new ArgumentOutOfRangeException(nameof(featureSize),
                 $"featureSize must be positive, got {featureSize}.");
@@ -411,6 +445,7 @@ private void EnsureAffineParameters(int featureSize)
 
         _gamma = Tensor<T>.CreateDefault([featureSize], NumOps.One);
         _beta = Tensor<T>.CreateDefault([featureSize], NumOps.Zero);
+        _featureSize = featureSize;
         RegisterTrainableParameter(_gamma, PersistentTensorRole.NormalizationParams);
         RegisterTrainableParameter(_beta, PersistentTensorRole.NormalizationParams);
     }
@@ -455,6 +490,7 @@ protected override void ReconcileShapeOnlyResolution(Tensor<T> input)
 
             _gamma = gamma;
             _beta = beta;
+            _featureSize = featureSize;
             _gammaGradient = null;
             _betaGradient = null;
             _gammaVelocity = null;
diff --git a/src/NeuralNetworks/Layers/LocallyConnectedLayer.cs b/src/NeuralNetworks/Layers/LocallyConnectedLayer.cs
index 6540151dd7..3cca8f3c2d 100644
--- a/src/NeuralNetworks/Layers/LocallyConnectedLayer.cs
+++ b/src/NeuralNetworks/Layers/LocallyConnectedLayer.cs
@@ -161,6 +161,7 @@ public partial class LocallyConnectedLayer<T> : LayerBase<T>, IShapeContract
     /// <summary>
     /// Stores the input tensor from the last forward pass for use in the backward pass.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastInput;
 
     /// <summary>
@@ -171,25 +172,31 @@ public partial class LocallyConnectedLayer<T> : LayerBase<T>, IShapeContract
     /// <summary>
     /// Stores the pre-activation output from the last forward pass for use in the backward pass.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastPreActivation;
 
     /// <summary>
     /// Stores the output tensor from the last forward pass for use in the backward pass.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastOutput;
 
     /// <summary>
     /// Stores the gradients for the weights calculated during the backward pass.
     /// </summary>
+    [AiDotNet.Attributes.Scratch]
     private Tensor<T>? _weightGradients;
 
     /// <summary>
     /// Stores the gradients for the biases calculated during the backward pass.
     /// </summary>
+    [AiDotNet.Attributes.Scratch]
     private Tensor<T>? _biasGradients;
 
     // GPU cached tensors for backward pass
+    [ExternalState]
     private Tensor<T>? _gpuInput;
+    [ExternalState]
     private Tensor<T>? _gpuOutput;
     private int[]? _gpuInputShape4D;
     private bool _gpuAddedBatchDimension;
@@ -197,21 +204,31 @@ public partial class LocallyConnectedLayer<T> : LayerBase<T>, IShapeContract
     #region GPU Weight Storage Fields
 
     // GPU weight tensors for GPU-resident training
+    [ExternalState]
     private Tensor<T>? _gpuWeights;
+    [ExternalState]
     private Tensor<T>? _gpuBiases;
 
     // GPU gradient tensors from BackwardGpu
+    [ExternalState]
     private Tensor<T>? _gpuWeightGradient;
+    [ExternalState]
     private Tensor<T>? _gpuBiasGradient;
 
     // Optimizer state tensors for SGD/NAG/LARS (velocity)
+    [ExternalState]
     private Tensor<T>? _gpuWeightVelocity;
+    [ExternalState]
     private Tensor<T>? _gpuBiasVelocity;
 
     // Optimizer state tensors for Adam/AdamW/LAMB (M and V)
+    [ExternalState]
     private Tensor<T>? _gpuWeightM;
+    [ExternalState]
     private Tensor<T>? _gpuWeightV;
+    [ExternalState]
     private Tensor<T>? _gpuBiasM;
+    [ExternalState]
     private Tensor<T>? _gpuBiasV;
 
     #endregion
@@ -917,31 +934,6 @@ public override void ClearGradients()
         _biasGradients = null;
     }
 
-    public override void Serialize(BinaryWriter writer)
-    {
-        // Persist resolved input shape so Deserialize can re-resolve before
-        // SetParameters lands. The 6-D weight tensor's shape can't be uniquely
-        // inferred from parameter count alone (outputH×outputW×outputC×k²×inputC
-        // + outputC has multiple solutions), so we serialize the input shape
-        // explicitly. base.Serialize then writes the parameter vector.
-        writer.Write(_inputHeight);
-        writer.Write(_inputWidth);
-        writer.Write(_inputChannels);
-        base.Serialize(writer);
-    }
-
-    public override void Deserialize(BinaryReader reader)
-    {
-        int inH = reader.ReadInt32();
-        int inW = reader.ReadInt32();
-        int inC = reader.ReadInt32();
-        if (!IsShapeResolved && inH > 0 && inW > 0 && inC > 0)
-        {
-            ResolveFromShape(new[] { inH, inW, inC });
-        }
-        base.Deserialize(reader);
-    }
-
     /// <summary>
     /// Resets the internal state of the layer.
     /// </summary>
diff --git a/src/NeuralNetworks/Layers/LogVarianceLayer.cs b/src/NeuralNetworks/Layers/LogVarianceLayer.cs
index c91c61a64d..44c64efda8 100644
--- a/src/NeuralNetworks/Layers/LogVarianceLayer.cs
+++ b/src/NeuralNetworks/Layers/LogVarianceLayer.cs
@@ -118,6 +118,7 @@ public partial class LogVarianceLayer<T> : LayerBase<T>, IShapeContract
     /// - To ensure the backward pass works correctly
     /// </para>
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _lastInput;
 
     /// <summary>
@@ -136,6 +137,7 @@ public partial class LogVarianceLayer<T> : LayerBase<T>, IShapeContract
     /// - To make the training process more efficient
     /// </para>
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _lastOutput;
 
     /// <summary>
@@ -156,6 +158,7 @@ public partial class LogVarianceLayer<T> : LayerBase<T>, IShapeContract
     /// Think of it as saving an intermediate result that will be reused later.
     /// </para>
     /// </remarks>
+    [AiDotNet.Attributes.Scratch]
     private Tensor<T>? _meanValues;
 
     /// <summary>
diff --git a/src/NeuralNetworks/Layers/MLPMixerBlockLayer.cs b/src/NeuralNetworks/Layers/MLPMixerBlockLayer.cs
index dba6ae26cc..ed26cd94bd 100644
--- a/src/NeuralNetworks/Layers/MLPMixerBlockLayer.cs
+++ b/src/NeuralNetworks/Layers/MLPMixerBlockLayer.cs
@@ -43,14 +43,35 @@ public partial class MLPMixerBlockLayer<T> : LayerBase<T>, IShapeContract
     private readonly int _hiddenDim;
     private readonly int _expansionFactor;
 
+    // Every child is built with its OUTPUT size alone, so each stays shape-deferred until a forward
+    // runs. ParameterCount does not materialize -- it cannot, since counting is read from Dispose
+    // and from fingerprinting -- so it saw nothing and reported 0 while GetParameters materialized
+    // the whole block on its way past and returned 388. Two surfaces, one walk, and no way for
+    // either to notice. Declaring the width each child receives puts it on the walk the base
+    // already does, which is what DeclaredSubLayerShapes is for.
+    //
+    // The widths are the ones the mixer comments below already spell out: the temporal branch runs
+    // on the transposed tensor, so its Dense layers see the PATCH axis last, and the channel branch
+    // sees the hidden axis last.
+    [SubLayerInput("_numPatches, _hiddenDim")]
     private readonly LayerNormalizationLayer<T> _norm1;
+    // The transposes carry the batch axis: TransposeLayer's rank is permutation.Length + 1 EXACTLY,
+    // so the rank-2 shape its neighbours take makes it throw. The other children take the logical
+    // shape alone, which is the convention this block's own initializer already uses.
+    [SubLayerInput("1, _numPatches, _hiddenDim")]
     private readonly TransposeLayer<T> _toPatchAxis;
+    [SubLayerInput("_hiddenDim, _numPatches")]
     private readonly DenseLayer<T> _temporalMlpExpand;
+    [SubLayerInput("_hiddenDim, _numPatches * _expansionFactor")]
     private readonly DenseLayer<T> _temporalMlpContract;
+    [SubLayerInput("1, _hiddenDim, _numPatches")]
     private readonly TransposeLayer<T> _fromPatchAxis;
 
+    [SubLayerInput("_numPatches, _hiddenDim")]
     private readonly LayerNormalizationLayer<T> _norm2;
+    [SubLayerInput("_numPatches, _hiddenDim")]
     private readonly DenseLayer<T> _channelMlpExpand;
+    [SubLayerInput("_numPatches, _hiddenDim * _expansionFactor")]
     private readonly DenseLayer<T> _channelMlpContract;
 
     /// <inheritdoc/>
diff --git a/src/NeuralNetworks/Layers/MaskingLayer.cs b/src/NeuralNetworks/Layers/MaskingLayer.cs
index b0e914ffa5..b0eb57ab3a 100644
--- a/src/NeuralNetworks/Layers/MaskingLayer.cs
+++ b/src/NeuralNetworks/Layers/MaskingLayer.cs
@@ -84,6 +84,7 @@ public partial class MaskingLayer<T> : LayerBase<T>, IShapeContract
     /// even when not immediately needed for calculations.
     /// </para>
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _lastInput;
 
     /// <summary>
@@ -106,11 +107,13 @@ public partial class MaskingLayer<T> : LayerBase<T>, IShapeContract
     /// the backward pass, which saves computation time.
     /// </para>
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _lastMask;
 
     /// <summary>
     /// The GPU mask tensor from the last GPU forward pass (for backward pass caching).
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastMaskGpu;
 
     /// <summary>
diff --git a/src/NeuralNetworks/Layers/MaxPool3DLayer.cs b/src/NeuralNetworks/Layers/MaxPool3DLayer.cs
index 29e16c9a9d..d1485ea151 100644
--- a/src/NeuralNetworks/Layers/MaxPool3DLayer.cs
+++ b/src/NeuralNetworks/Layers/MaxPool3DLayer.cs
@@ -150,6 +150,7 @@ public partial class MaxPool3DLayer<T> : LayerBase<T>, IShapeContract
     /// <summary>
     /// Cached input from the last forward pass.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastInput;
 
     /// <summary>
@@ -425,28 +426,6 @@ public override void ResetState()
 
     #region Serialization
 
-    /// <summary>
-    /// Serializes the layer to a binary stream.
-    /// </summary>
-    /// <param name="writer">The binary writer to serialize to.</param>
-    public override void Serialize(BinaryWriter writer)
-    {
-        base.Serialize(writer);
-        writer.Write(PoolSize);
-        writer.Write(Stride);
-    }
-
-    /// <summary>
-    /// Deserializes the layer from a binary stream.
-    /// </summary>
-    /// <param name="reader">The binary reader to deserialize from.</param>
-    public override void Deserialize(BinaryReader reader)
-    {
-        base.Deserialize(reader);
-        PoolSize = reader.ReadInt32();
-        Stride = reader.ReadInt32();
-    }
-
     #endregion
 
     #region Activation Info
diff --git a/src/NeuralNetworks/Layers/MaxPoolingLayer.cs b/src/NeuralNetworks/Layers/MaxPoolingLayer.cs
index dc9bebaddf..5d5fe17672 100644
--- a/src/NeuralNetworks/Layers/MaxPoolingLayer.cs
+++ b/src/NeuralNetworks/Layers/MaxPoolingLayer.cs
@@ -144,6 +144,7 @@ public int[] GetStride()
     /// <summary>
     /// Stores the last input tensor from the forward pass for use in autodiff backward pass.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastInput;
 
     /// <summary>
@@ -392,38 +393,6 @@ protected override Tensor<T> ForwardTraced(Tensor<T> input)
         return output4D;
     }
 
-    /// <summary>
-    /// Saves the layer's configuration to a binary stream.
-    /// </summary>
-    /// <param name="writer">The binary writer to write the data to.</param>
-    /// <remarks>
-    /// <b>For Beginners:</b> This method saves the layer's settings (pool size and stride)
-    /// so that you can reload the exact same layer later. It's like saving your game
-    /// progress so you can continue from where you left off.
-    /// </remarks>
-    public override void Serialize(BinaryWriter writer)
-    {
-        base.Serialize(writer);
-        writer.Write(PoolSize);
-        writer.Write(Stride);
-    }
-
-    /// <summary>
-    /// Loads the layer's configuration from a binary stream.
-    /// </summary>
-    /// <param name="reader">The binary reader to read the data from.</param>
-    /// <remarks>
-    /// <b>For Beginners:</b> This method loads previously saved settings for the layer.
-    /// It's the counterpart to Serialize - if Serialize is like saving your game,
-    /// Deserialize is like loading that saved game.
-    /// </remarks>
-    public override void Deserialize(BinaryReader reader)
-    {
-        base.Deserialize(reader);
-        PoolSize = reader.ReadInt32();
-        Stride = reader.ReadInt32();
-    }
-
     /// <summary>
     /// Returns the activation functions used by this layer.
     /// </summary>
diff --git a/src/NeuralNetworks/Layers/MeanLayer.cs b/src/NeuralNetworks/Layers/MeanLayer.cs
index fb85b347a6..5e5e4138dc 100644
--- a/src/NeuralNetworks/Layers/MeanLayer.cs
+++ b/src/NeuralNetworks/Layers/MeanLayer.cs
@@ -141,6 +141,7 @@ public partial class MeanLayer<T> : LayerBase<T>, IShapeContract
     /// This field stores the input tensor from the most recent forward pass, which is needed
     /// during the backward pass for gradient calculation.
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _lastInput;
 
     /// <summary>
@@ -150,6 +151,7 @@ public partial class MeanLayer<T> : LayerBase<T>, IShapeContract
     /// This field stores the output tensor from the most recent forward pass, which may be
     /// useful for certain operations or debugging.
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _lastOutput;
 
     /// <summary>
diff --git a/src/NeuralNetworks/Layers/MeasurementLayer.cs b/src/NeuralNetworks/Layers/MeasurementLayer.cs
index f5afdaec98..9b603111b6 100644
--- a/src/NeuralNetworks/Layers/MeasurementLayer.cs
+++ b/src/NeuralNetworks/Layers/MeasurementLayer.cs
@@ -51,6 +51,7 @@ public partial class MeasurementLayer<T> : LayerBase<T>, IShapeContract
     /// This field stores the input tensor from the most recent forward pass, which is needed
     /// during the backward pass for gradient calculation.
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _lastInput;
 
     /// <summary>
@@ -60,6 +61,7 @@ public partial class MeasurementLayer<T> : LayerBase<T>, IShapeContract
     /// This field stores the output tensor from the most recent forward pass, which is needed
     /// during the backward pass for gradient calculation.
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _lastOutput;
 
     private int[]? _originalInputShape;
diff --git a/src/NeuralNetworks/Layers/MemoryReadLayer.cs b/src/NeuralNetworks/Layers/MemoryReadLayer.cs
index 7436338909..d5353f2f30 100644
--- a/src/NeuralNetworks/Layers/MemoryReadLayer.cs
+++ b/src/NeuralNetworks/Layers/MemoryReadLayer.cs
@@ -143,6 +143,7 @@ public partial class MemoryReadLayer<T> : LayerBase<T>, IAuxiliaryLossLayer<T>,
     /// This field stores the input tensor from the most recent forward pass, which is needed
     /// during the backward pass for gradient calculation.
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _lastInput;
 
     /// <summary>
@@ -152,6 +153,7 @@ public partial class MemoryReadLayer<T> : LayerBase<T>, IAuxiliaryLossLayer<T>,
     /// This field stores the memory tensor from the most recent forward pass, which is needed
     /// during the backward pass for gradient calculation.
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _lastMemory;
 
     /// <summary>
@@ -161,6 +163,7 @@ public partial class MemoryReadLayer<T> : LayerBase<T>, IAuxiliaryLossLayer<T>,
     /// This field stores the output tensor from the most recent forward pass, which is needed
     /// during the backward pass for gradient calculation.
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _lastOutput;
 
     /// <summary>
@@ -170,6 +173,7 @@ public partial class MemoryReadLayer<T> : LayerBase<T>, IAuxiliaryLossLayer<T>,
     /// This field stores the attention scores from the most recent forward pass, which is needed
     /// during the backward pass for gradient calculation.
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _lastAttentionScores;
 
     /// <summary>
@@ -179,6 +183,7 @@ public partial class MemoryReadLayer<T> : LayerBase<T>, IAuxiliaryLossLayer<T>,
     /// This field stores the transformed tensor (result of readValues × valueWeights) from the most
     /// recent forward pass, which is needed during the backward pass for output weights gradient calculation.
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _lastTransformed;
 
     /// <summary>
@@ -188,6 +193,7 @@ public partial class MemoryReadLayer<T> : LayerBase<T>, IAuxiliaryLossLayer<T>,
     /// This field stores the gradient of the key weights, which is used to update the weights
     /// during the parameter update step.
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _keyWeightsGradient;
 
     /// <summary>
@@ -197,6 +203,7 @@ public partial class MemoryReadLayer<T> : LayerBase<T>, IAuxiliaryLossLayer<T>,
     /// This field stores the gradient of the value weights, which is used to update the weights
     /// during the parameter update step.
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _valueWeightsGradient;
 
     /// <summary>
@@ -206,6 +213,7 @@ public partial class MemoryReadLayer<T> : LayerBase<T>, IAuxiliaryLossLayer<T>,
     /// This field stores the gradient of the output weights, which is used to update the weights
     /// during the parameter update step.
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _outputWeightsGradient;
 
     /// <summary>
@@ -215,6 +223,7 @@ public partial class MemoryReadLayer<T> : LayerBase<T>, IAuxiliaryLossLayer<T>,
     /// This field stores the gradient of the output bias, which is used to update the bias
     /// during the parameter update step.
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _outputBiasGradient;
 
     public override bool SupportsTraining => true;
@@ -252,6 +261,7 @@ public partial class MemoryReadLayer<T> : LayerBase<T>, IAuxiliaryLossLayer<T>,
     public MemoryReadLayer([LayerState] int memoryDimension, [LayerState] int outputDimension, IActivationFunction<T>? activationFunction = null)
         : base(new[] { -1 }, new[] { outputDimension }, activationFunction ?? new IdentityActivation<T>())
     {
+        _outputDimension = outputDimension;
         if (memoryDimension <= 0) throw new ArgumentOutOfRangeException(nameof(memoryDimension));
         if (outputDimension <= 0) throw new ArgumentOutOfRangeException(nameof(outputDimension));
 
@@ -334,6 +344,7 @@ protected override void OnFirstForward(Tensor<T> input)
     public MemoryReadLayer([LayerState] int memoryDimension, [LayerState] int outputDimension, IVectorActivationFunction<T> activationFunction)
         : base(new[] { -1 }, new[] { outputDimension }, activationFunction ?? new IdentityActivation<T>())
     {
+        _outputDimension = outputDimension;
         if (memoryDimension <= 0) throw new ArgumentOutOfRangeException(nameof(memoryDimension));
         if (outputDimension <= 0) throw new ArgumentOutOfRangeException(nameof(outputDimension));
 
diff --git a/src/NeuralNetworks/Layers/MemoryWriteLayer.cs b/src/NeuralNetworks/Layers/MemoryWriteLayer.cs
index b95536f9a6..606d56308c 100644
--- a/src/NeuralNetworks/Layers/MemoryWriteLayer.cs
+++ b/src/NeuralNetworks/Layers/MemoryWriteLayer.cs
@@ -153,6 +153,7 @@ public partial class MemoryWriteLayer<T> : LayerBase<T>, IAuxiliaryLossLayer<T>,
     /// This field stores the input tensor from the most recent forward pass, which is needed
     /// during the backward pass for gradient calculation.
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _lastInput;
 
     /// <summary>
@@ -162,6 +163,7 @@ public partial class MemoryWriteLayer<T> : LayerBase<T>, IAuxiliaryLossLayer<T>,
     /// This field stores the memory tensor from the most recent forward pass, which is needed
     /// during the backward pass for gradient calculation.
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _lastMemory;
 
     /// <summary>
@@ -171,6 +173,7 @@ public partial class MemoryWriteLayer<T> : LayerBase<T>, IAuxiliaryLossLayer<T>,
     /// This field stores the output tensor from the most recent forward pass, which is needed
     /// during the backward pass for gradient calculation.
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _lastOutput;
 
     /// <summary>
@@ -180,6 +183,7 @@ public partial class MemoryWriteLayer<T> : LayerBase<T>, IAuxiliaryLossLayer<T>,
     /// This field stores the attention scores from the most recent forward pass, which is needed
     /// during the backward pass for gradient calculation.
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _lastAttentionScores;
 
     /// <summary>
@@ -189,6 +193,7 @@ public partial class MemoryWriteLayer<T> : LayerBase<T>, IAuxiliaryLossLayer<T>,
     /// This field stores the write values tensor computed from attention weights, which can be used
     /// when updating memory or computing auxiliary objectives.
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _lastWriteValues;
 
     /// <summary>
@@ -197,6 +202,7 @@ public partial class MemoryWriteLayer<T> : LayerBase<T>, IAuxiliaryLossLayer<T>,
     /// <remarks>
     /// This field stores the input values after value projection, which are used for output gradients.
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _lastValues;
 
     /// <summary>
@@ -206,6 +212,7 @@ public partial class MemoryWriteLayer<T> : LayerBase<T>, IAuxiliaryLossLayer<T>,
     /// This field stores the gradient of the query weights, which is used to update the weights
     /// during the parameter update step.
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _queryWeightsGradient;
 
     /// <summary>
@@ -215,6 +222,7 @@ public partial class MemoryWriteLayer<T> : LayerBase<T>, IAuxiliaryLossLayer<T>,
     /// This field stores the gradient of the key weights, which is used to update the weights
     /// during the parameter update step.
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _keyWeightsGradient;
 
     /// <summary>
@@ -224,6 +232,7 @@ public partial class MemoryWriteLayer<T> : LayerBase<T>, IAuxiliaryLossLayer<T>,
     /// This field stores the gradient of the value weights, which is used to update the weights
     /// during the parameter update step.
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _valueWeightsGradient;
 
     /// <summary>
@@ -233,6 +242,7 @@ public partial class MemoryWriteLayer<T> : LayerBase<T>, IAuxiliaryLossLayer<T>,
     /// This field stores the gradient of the output weights, which is used to update the weights
     /// during the parameter update step.
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _outputWeightsGradient;
 
     /// <summary>
@@ -242,6 +252,7 @@ public partial class MemoryWriteLayer<T> : LayerBase<T>, IAuxiliaryLossLayer<T>,
     /// This field stores the gradient of the output bias, which is used to update the bias
     /// during the parameter update step.
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _outputBiasGradient;
 
     public override bool SupportsTraining => true;
diff --git a/src/NeuralNetworks/Layers/MeshEdgeConvLayer.cs b/src/NeuralNetworks/Layers/MeshEdgeConvLayer.cs
index ffa61ebeaa..6248703ac3 100644
--- a/src/NeuralNetworks/Layers/MeshEdgeConvLayer.cs
+++ b/src/NeuralNetworks/Layers/MeshEdgeConvLayer.cs
@@ -148,16 +148,19 @@ internal override Dictionary<string, string> GetMetadata()
     /// <summary>
     /// Cached weight gradients from backward pass.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _weightsGradient;
 
     /// <summary>
     /// Cached bias gradients from backward pass.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _biasesGradient;
 
     /// <summary>
     /// Cached input from the last forward pass.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastInput;
 
     /// <summary>
@@ -168,11 +171,13 @@ internal override Dictionary<string, string> GetMetadata()
     /// <summary>
     /// Cached output before activation from the last forward pass.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastPreActivation;
 
     /// <summary>
     /// Cached output after activation from the last forward pass.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastOutput;
 
     #endregion
@@ -697,31 +702,6 @@ public override void UpdateParameters(T learningRate)
     /// <returns>The bias tensor.</returns>
     public override Tensor<T> GetBiases() => _biases;
 
-    /// <summary>
-    /// Creates a deep copy of the layer.
-    /// </summary>
-    /// <returns>A new instance with identical configuration and parameters.</returns>
-    public override LayerBase<T> Clone()
-    {
-        MeshEdgeConvLayer<T> copy;
-
-        if (UsingVectorActivation)
-        {
-            copy = new MeshEdgeConvLayer<T>(InputChannels, OutputChannels, NumNeighbors, VectorActivation);
-        }
-        else
-        {
-            copy = new MeshEdgeConvLayer<T>(InputChannels, OutputChannels, NumNeighbors, ScalarActivation);
-        }
-
-        copy.SetParameters(GetParameters());
-        if (_lastEdgeAdjacency != null)
-        {
-            copy.SetEdgeAdjacency(_lastEdgeAdjacency);
-        }
-        return copy;
-    }
-
     #endregion
 
     #region State Management
@@ -742,59 +722,6 @@ public override void ResetState()
 
     #region Serialization
 
-    /// <summary>
-    /// Serializes the layer to a binary stream.
-    /// </summary>
-    /// <param name="writer">The binary writer to serialize to.</param>
-    public override void Serialize(BinaryWriter writer)
-    {
-        base.Serialize(writer);
-        writer.Write(InputChannels);
-        writer.Write(OutputChannels);
-        writer.Write(NumNeighbors);
-
-        var weightArray = _weights.ToArray();
-        for (int i = 0; i < weightArray.Length; i++)
-        {
-            writer.Write(NumOps.ToDouble(weightArray[i]));
-        }
-
-        var biasArray = _biases.ToArray();
-        for (int i = 0; i < biasArray.Length; i++)
-        {
-            writer.Write(NumOps.ToDouble(biasArray[i]));
-        }
-    }
-
-    /// <summary>
-    /// Deserializes the layer from a binary stream.
-    /// </summary>
-    /// <param name="reader">The binary reader to deserialize from.</param>
-    public override void Deserialize(BinaryReader reader)
-    {
-        base.Deserialize(reader);
-        InputChannels = reader.ReadInt32();
-        OutputChannels = reader.ReadInt32();
-        NumNeighbors = reader.ReadInt32();
-
-        int weightSize = OutputChannels * InputChannels * (1 + NumNeighbors);
-        _weights = new Tensor<T>([OutputChannels, InputChannels * (1 + NumNeighbors)]);
-        var weightArray = new T[weightSize];
-        for (int i = 0; i < weightSize; i++)
-        {
-            weightArray[i] = NumOps.FromDouble(reader.ReadDouble());
-        }
-        _weights = new Tensor<T>(weightArray, _weights._shape);
-
-        _biases = new Tensor<T>([OutputChannels]);
-        var biasArray = new T[OutputChannels];
-        for (int i = 0; i < OutputChannels; i++)
-        {
-            biasArray[i] = NumOps.FromDouble(reader.ReadDouble());
-        }
-        _biases = new Tensor<T>(biasArray, _biases._shape);
-    }
-
     #endregion
 
     #region JIT Compilation
diff --git a/src/NeuralNetworks/Layers/MeshPoolLayer.cs b/src/NeuralNetworks/Layers/MeshPoolLayer.cs
index 37ee183293..ee33a58b65 100644
--- a/src/NeuralNetworks/Layers/MeshPoolLayer.cs
+++ b/src/NeuralNetworks/Layers/MeshPoolLayer.cs
@@ -155,11 +155,13 @@ internal override Dictionary<string, string> GetMetadata()
     /// <summary>
     /// Cached gradient for importance weights.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _importanceWeightsGradient;
 
     /// <summary>
     /// Cached input from the last forward pass.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastInput;
 
     /// <summary>
@@ -170,11 +172,13 @@ internal override Dictionary<string, string> GetMetadata()
     /// <summary>
     /// Cached output from the last forward pass.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastOutput;
 
     /// <summary>
     /// Cached importance scores from the last forward pass.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastImportanceScores;
 
     /// <summary>
@@ -185,6 +189,7 @@ internal override Dictionary<string, string> GetMetadata()
     /// <summary>
     /// Cached GPU input for backward pass.
     /// </summary>
+    [ExternalState]
     private Tensor<T>? _gpuInput;
 
     /// <summary>
@@ -602,21 +607,6 @@ public override void UpdateParameters(T learningRate)
     /// <returns>Null as this layer has no biases.</returns>
     public override Tensor<T> GetBiases() => new Tensor<T>([0]);
 
-    /// <summary>
-    /// Creates a deep copy of the layer.
-    /// </summary>
-    /// <returns>A new instance with identical configuration and parameters.</returns>
-    public override LayerBase<T> Clone()
-    {
-        var copy = new MeshPoolLayer<T>(InputChannels, TargetEdges, _numNeighbors);
-        copy.SetParameters(GetParameters());
-        if (_lastEdgeAdjacency != null)
-        {
-            copy.SetEdgeAdjacency(_lastEdgeAdjacency);
-        }
-        return copy;
-    }
-
     #endregion
 
     #region State Management
@@ -642,44 +632,6 @@ public override void ResetState()
 
     #region Serialization
 
-    /// <summary>
-    /// Serializes the layer to a binary stream.
-    /// </summary>
-    /// <param name="writer">The binary writer to serialize to.</param>
-    public override void Serialize(BinaryWriter writer)
-    {
-        base.Serialize(writer);
-        writer.Write(InputChannels);
-        writer.Write(TargetEdges);
-        writer.Write(_numNeighbors);
-
-        var weightArray = _importanceWeights.ToArray();
-        for (int i = 0; i < weightArray.Length; i++)
-        {
-            writer.Write(NumOps.ToDouble(weightArray[i]));
-        }
-    }
-
-    /// <summary>
-    /// Deserializes the layer from a binary stream.
-    /// </summary>
-    /// <param name="reader">The binary reader to deserialize from.</param>
-    public override void Deserialize(BinaryReader reader)
-    {
-        base.Deserialize(reader);
-        InputChannels = reader.ReadInt32();
-        TargetEdges = reader.ReadInt32();
-        var numNeighbors = reader.ReadInt32();
-
-        _importanceWeights = new Tensor<T>([InputChannels]);
-        var weightArray = new T[InputChannels];
-        for (int i = 0; i < InputChannels; i++)
-        {
-            weightArray[i] = NumOps.FromDouble(reader.ReadDouble());
-        }
-        _importanceWeights = new Tensor<T>(weightArray, [InputChannels]);
-    }
-
     #endregion
 
     #region JIT Compilation
diff --git a/src/NeuralNetworks/Layers/MessagePassingLayer.cs b/src/NeuralNetworks/Layers/MessagePassingLayer.cs
index 75a156503d..b1c9fd60ad 100644
--- a/src/NeuralNetworks/Layers/MessagePassingLayer.cs
+++ b/src/NeuralNetworks/Layers/MessagePassingLayer.cs
@@ -1,4 +1,4 @@
-using AiDotNet.Attributes;
+using AiDotNet.Attributes;
 using AiDotNet.Interfaces;
 using AiDotNet.Tensors.Engines;
 using AiDotNet.Tensors.Engines.DirectGpu;
@@ -48,7 +48,7 @@ namespace AiDotNet.NeuralNetworks.Layers;
 /// </para>
 /// <para>
 /// The layer performs the following computation for each node v:
-/// - m_v = AGGREGATE({MESSAGE(h_u, h_v, e_uv) : u ∈ N(v)})
+/// - m_v = AGGREGATE({MESSAGE(h_u, h_v, e_uv) : u ∈ N(v)})
 /// - h_v' = UPDATE(h_v, m_v)
 ///
 /// where h_v are node features, e_uv are edge features, and N(v) is the neighborhood of v.
@@ -187,11 +187,13 @@ public partial class MessagePassingLayer<T> : LayerBase<T>, IGraphConvolutionLay
     /// <summary>
     /// The adjacency matrix defining graph structure.
     /// </summary>
+    [AiDotNet.Attributes.FittedParameter(InputSized = true)]
     private Tensor<T>? _adjacencyMatrix;
 
     /// <summary>
     /// Edge features tensor (optional).
     /// </summary>
+    [AiDotNet.Attributes.FittedParameter(InputSized = true)]
     private Tensor<T>? _edgeFeatures;
 
     /// <summary>
@@ -212,6 +214,7 @@ public partial class MessagePassingLayer<T> : LayerBase<T>, IGraphConvolutionLay
     /// <summary>
     /// Cached input from forward pass.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastInput;
 
     /// <summary>
@@ -222,36 +225,43 @@ public partial class MessagePassingLayer<T> : LayerBase<T>, IGraphConvolutionLay
     /// <summary>
     /// Cached output from forward pass.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastOutput;
 
     /// <summary>
     /// Cached messages for backward pass.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastMessages;
 
     /// <summary>
     /// Cached aggregated messages.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastAggregated;
 
     /// <summary>
     /// Cached hidden activations from message MLP layer 1.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastMessageHidden;
 
     /// <summary>
     /// Cached reset gates.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastResetGate;
 
     /// <summary>
     /// Cached update gates.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastUpdateGate;
 
     /// <summary>
     /// Gradients for parameters.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _messageWeights1Gradient;
 
     /// <summary>
@@ -263,20 +273,31 @@ private T GetAdjacency(int b, int i, int j)
             throw new InvalidOperationException("Adjacency matrix is not set.");
         return _adjacencyMatrix.Shape.Length == 3 ? _adjacencyMatrix[b, i, j] : _adjacencyMatrix[i, j];
     }
+    [Scratch]
     private Tensor<T>? _messageWeights2Gradient;
+    [Scratch]
     private Tensor<T>? _messageBias1Gradient;
+    [Scratch]
     private Tensor<T>? _messageBias2Gradient;
+    [Scratch]
     private Tensor<T>? _updateWeightsGradient;
+    [Scratch]
     private Tensor<T>? _updateMessageWeightsGradient;
+    [Scratch]
     private Tensor<T>? _updateBiasGradient;
+    [Scratch]
     private Tensor<T>? _resetWeightsGradient;
+    [Scratch]
     private Tensor<T>? _resetMessageWeightsGradient;
+    [Scratch]
     private Tensor<T>? _resetBiasGradient;
 #pragma warning disable CS0169 // Field is never used - reserved for future edge weight gradient computation
+    [Scratch]
     private Tensor<T>? _edgeWeightsGradient;
 #pragma warning restore CS0169
 
     // GPU cache fields for backward pass
+    [ExternalState]
     private Tensor<T>? _gpuLastInput;
     private IGpuBuffer? _gpuEdgeSrcIndices;
     private IGpuBuffer? _gpuEdgeTgtIndices;
@@ -320,6 +341,9 @@ private T GetAdjacency(int b, int i, int j)
     /// <inheritdoc/>
     public int OutputFeatures => _outputFeatures;
 
+    /// <summary>Construction state: the 'edgeFeatureDim' the layer was built with.</summary>
+    private readonly int _edgeFeatureDim;
+
     /// <summary>
     /// Initializes a new instance of the <see cref="MessagePassingLayer{T}"/> class.
     /// </summary>
@@ -358,6 +382,7 @@ public MessagePassingLayer(
         IActivationFunction<T>? activationFunction = null)
         : base([inputFeatures], [outputFeatures], activationFunction ?? new IdentityActivation<T>())
     {
+        _edgeFeatureDim = edgeFeatureDim;
         _inputFeatures = inputFeatures;
         _outputFeatures = outputFeatures;
         _messageFeatures = messageFeatures > 0 ? messageFeatures : outputFeatures;
@@ -637,20 +662,20 @@ protected override Tensor<T> ForwardTraced(Tensor<T> input)
         // Original implementation walked every (b, i, j) edge in scalar:
         // built a per-edge messageInput vector, ran a 2-layer MLP on it, then
         // gated by adjacency before summing. That was
-        //   O(B · N² · (2·F + edgeF) · M)   per MLP-layer-1 NumOps.Add chain
-        //   + O(B · N² · M²) for layer 2 + O(B · N² · M) for aggregation
-        // of virtual NumOps dispatches — JIT can't inline through INumericOps.
+        //   O(B · N² · (2·F + edgeF) · M)   per MLP-layer-1 NumOps.Add chain
+        //   + O(B · N² · M²) for layer 2 + O(B · N² · M) for aggregation
+        // of virtual NumOps dispatches — JIT can't inline through INumericOps.
         //
         // Pytorch / torch_geometric handles this as bulk tensor ops:
         //   1. broadcast src/tgt features into [B, N, N, F] tiles
         //   2. concat with edge features along the feature axis
-        //   3. flatten (B·N·N) edges into a 2D matrix and run the MLP
+        //   3. flatten (B·N·N) edges into a 2D matrix and run the MLP
         //      via two TensorMatMul + bias + ReLU steps
         //   4. mask non-adjacent edges by multiplying by adjacency
         //   5. sum-aggregate over the j axis with ReduceSum
         // This keeps the layer's externally visible behavior identical
         // (skipped-edge messages stay zero post-mask) while replacing
-        // ~10⁹ scalar dispatches with ~10 Engine ops on a typical graph.
+        // ~10⁹ scalar dispatches with ~10 Engine ops on a typical graph.
 
         // Tile node features for source (j) and target (i) sides:
         //   src[B, i, j, F] = processInput[B, j, F]   (rows of i broadcast)
@@ -666,7 +691,7 @@ protected override Tensor<T> ForwardTraced(Tensor<T> input)
         {
             int edgeFeatDim = _edgeFeatures.Shape[2];
             // _edgeFeatures is stored as [batch, numNodes*numNodes, edgeFeatDim]
-            // — reshape to [batch, numNodes, numNodes, edgeFeatDim] so it concats
+            // — reshape to [batch, numNodes, numNodes, edgeFeatDim] so it concats
             // cleanly with the [B, N, N, F] node tiles.
             var edgeTile = Engine.Reshape(_edgeFeatures, [batchSize, numNodes, numNodes, edgeFeatDim]);
             messageInput = Engine.TensorConcatenate(new[] { srcTile, tgtTile, edgeTile }, axis: 3);
@@ -709,23 +734,23 @@ protected override Tensor<T> ForwardTraced(Tensor<T> input)
         // Step 3: Update node features (GRU-style update), bulk-vectorized.
         // ----------------------------------------------------------------
         // Original implementation walked every (b, i, f) cell in scalar to compute
-        // reset = σ(b_r + input·W_r + agg·W_mr), update = σ(b_u + input·W_u + agg·W_mu),
+        // reset = σ(b_r + input·W_r + agg·W_mr), update = σ(b_u + input·W_u + agg·W_mu),
         // and out = (1-update) * pad(input) + update * pad(agg). Each cell did
-        // (inputFeatures + messageFeatures) NumOps.Multiply/Add dispatches —
-        // (B·N·outputFeatures) cells per gate.
+        // (inputFeatures + messageFeatures) NumOps.Multiply/Add dispatches —
+        // (B·N·outputFeatures) cells per gate.
         //
         // The matmul / sigmoid / add chain is expressible as bulk Engine ops on
         // the full [B, N, *] tensors; the only complication is the conditional
         // slice/pad in the final output combiner when outputFeatures doesn't
         // match inputFeatures or messageFeatures.
 
-        // Flatten [B, N, *] to [B·N, *] so the projection matmuls work on 2D
+        // Flatten [B, N, *] to [B·N, *] so the projection matmuls work on 2D
         // operands and the broadcast-add on biases stays simple.
         int bn = batchSize * numNodes;
         var inputFlatBN = Engine.Reshape(processInput, [bn, _inputFeatures]);
         var aggFlatBN = Engine.Reshape(_lastAggregated, [bn, _messageFeatures]);
 
-        // Reset gate: σ(input @ W_r + agg @ W_mr + b_r)
+        // Reset gate: σ(input @ W_r + agg @ W_mr + b_r)
         var resetBiasBcast = Engine.Reshape(_resetBias, [1, _outputFeatures]);
         var resetLogitsFlat = Engine.TensorMatMul(inputFlatBN, _resetWeights);
         resetLogitsFlat = Engine.TensorAdd(resetLogitsFlat, Engine.TensorMatMul(aggFlatBN, _resetMessageWeights));
@@ -733,7 +758,7 @@ protected override Tensor<T> ForwardTraced(Tensor<T> input)
         var resetFlat = Engine.Sigmoid(resetLogitsFlat);
         _lastResetGate = Engine.Reshape(resetFlat, [batchSize, numNodes, _outputFeatures]);
 
-        // Update gate: σ(input @ W_u + agg @ W_mu + b_u)
+        // Update gate: σ(input @ W_u + agg @ W_mu + b_u)
         var updateBiasBcast = Engine.Reshape(_updateBias, [1, _outputFeatures]);
         var updateLogitsFlat = Engine.TensorMatMul(inputFlatBN, _updateWeights);
         updateLogitsFlat = Engine.TensorAdd(updateLogitsFlat, Engine.TensorMatMul(aggFlatBN, _updateMessageWeights));
@@ -745,7 +770,7 @@ protected override Tensor<T> ForwardTraced(Tensor<T> input)
         // The original conditional `f < inputFeatures ? processInput : 0` zeros
         // any feature-axis index that exceeds the input/message feature width.
         // Build padded versions explicitly so the elementwise multiply works on
-        // matching [B·N, outputFeatures] tensors.
+        // matching [B·N, outputFeatures] tensors.
         var inputPaddedFlat = PadOrSliceLastAxis(inputFlatBN, _inputFeatures, _outputFeatures);
         var aggPaddedFlat = PadOrSliceLastAxis(aggFlatBN, _messageFeatures, _outputFeatures);
 
@@ -988,9 +1013,9 @@ private void ClearGpuCache()
     /// <remarks>
     /// <para>
     /// Implements the actual MPNN algorithm on GPU:
-    /// 1. For each edge (i→j), gather source and target features
+    /// 1. For each edge (i→j), gather source and target features
     /// 2. Compute per-edge message: m_ij = MLP(concat(h_source, h_target))
-    /// 3. Scatter-add to aggregate messages per target node: m_i = Σ_{j∈N(i)} m_ji
+    /// 3. Scatter-add to aggregate messages per target node: m_i = Σ_{j∈N(i)} m_ji
     /// 4. GRU-style update: h'_i = (1-z)*h_i + z*m_i
     /// </para>
     /// </remarks>
@@ -1051,7 +1076,7 @@ public override Tensor<T> ForwardGpu(params Tensor<T>[] inputs)
                 if (!NumOps.Equals(adjVal, NumOps.Zero))
                 {
                     edgeSourceList.Add(j);  // Source node
-                    edgeTargetList.Add(i);  // Target node (edge j→i)
+                    edgeTargetList.Add(i);  // Target node (edge j→i)
                 }
             }
         }
diff --git a/src/NeuralNetworks/Layers/MixtureOfExpertsLayer.cs b/src/NeuralNetworks/Layers/MixtureOfExpertsLayer.cs
index 9779d45da4..c48dc8898f 100644
--- a/src/NeuralNetworks/Layers/MixtureOfExpertsLayer.cs
+++ b/src/NeuralNetworks/Layers/MixtureOfExpertsLayer.cs
@@ -58,7 +58,7 @@ namespace AiDotNet.NeuralNetworks.Layers;
 [LayerCategory(LayerCategory.MixtureOfExperts)]
 [LayerTask(LayerTask.Routing)]
 [LayerTask(LayerTask.FeatureExtraction)]
-[LayerProperty(IsTrainable = true, ChangesShape = true, Cost = ComputeCost.High, TestInputShape = "1, 4")]
+[LayerProperty(IsTrainable = true, ChangesShape = true, Cost = ComputeCost.High, TestInputShape = "1, 4", TestConstructorArgs = "new System.Collections.Generic.List<AiDotNet.Interfaces.ILayer<double>> { new AiDotNet.NeuralNetworks.Layers.ReadoutLayer<double>(4, 8, (AiDotNet.Interfaces.IActivationFunction<double>)new AiDotNet.ActivationFunctions.IdentityActivation<double>()), new AiDotNet.NeuralNetworks.Layers.ReadoutLayer<double>(4, 8, (AiDotNet.Interfaces.IActivationFunction<double>)new AiDotNet.ActivationFunctions.IdentityActivation<double>()) }, new AiDotNet.NeuralNetworks.Layers.ReadoutLayer<double>(4, 2, (AiDotNet.Interfaces.IActivationFunction<double>)new AiDotNet.ActivationFunctions.IdentityActivation<double>()), new[] { 4 }, new[] { 8 }, 1")]
 // Feature-last, with batch optional: OnFirstForward treats the leading axis as batch and everything after
 // it as the per-sample shape it configures the router and experts against, and ForwardTraced restores a
 // rank-1 input to rank 1 before returning. Those two ranks are the ones whose behaviour is coherent, so
@@ -211,6 +211,7 @@ public partial class MixtureOfExpertsLayer<T> : LayerBase<T>, IAuxiliaryLossLaye
     /// later if you don't remember what was said.
     /// </para>
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _lastInput;
 
     /// <summary>
@@ -240,6 +241,7 @@ public partial class MixtureOfExpertsLayer<T> : LayerBase<T>, IAuxiliaryLossLaye
     /// - Whether experts are being used balanced or if some are overloaded
     /// </para>
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _lastRoutingWeights;
 
     /// <summary>
@@ -261,11 +263,13 @@ public partial class MixtureOfExpertsLayer<T> : LayerBase<T>, IAuxiliaryLossLaye
     /// so you can give appropriate feedback to each person.
     /// </para>
     /// </remarks>
+    [Scratch]
     private List<Tensor<T>>? _lastExpertOutputs;
 
     /// <summary>
     /// Cached combined output before activation from the most recent forward pass.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastPreActivation;
 
 
@@ -286,6 +290,7 @@ public partial class MixtureOfExpertsLayer<T> : LayerBase<T>, IAuxiliaryLossLaye
     /// - This is a technical requirement for proper backpropagation through softmax
     /// </para>
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _lastRoutingLogits;
 
     /// <summary>
@@ -412,6 +417,9 @@ internal override Dictionary<string, string> GetMetadata()
         return metadata;
     }
 
+    /// <summary>Construction state: the 'useLoadBalancing' the layer was built with.</summary>
+    private readonly bool _useLoadBalancing;
+
     /// <summary>
     /// Initializes a new instance of the <see cref="MixtureOfExpertsLayer{T}"/> class.
     /// </summary>
@@ -472,6 +480,7 @@ public MixtureOfExpertsLayer(
         T? loadBalancingWeight = default)
         : base(inputShape, outputShape, activationFunction ?? new IdentityActivation<T>())
     {
+        _useLoadBalancing = useLoadBalancing;
         if (experts == null || experts.Count == 0)
         {
             throw new ArgumentException("Must have at least one expert.", nameof(experts));
@@ -930,62 +939,6 @@ public override void ResetState()
         }
     }
 
-    /// <summary>
-    /// Creates a deep copy of this MoE layer.
-    /// </summary>
-    /// <returns>A new MixtureOfExpertsLayer with the same configuration and parameters.</returns>
-    /// <remarks>
-    /// <para>
-    /// Creates an independent copy of this layer, including the router and all experts.
-    /// Changes to the clone won't affect the original.
-    /// </para>
-    /// <para><b>For Beginners:</b> Makes an identical copy of the entire MoE layer.
-    ///
-    /// The clone includes:
-    /// - A copy of the router
-    /// - Copies of all experts
-    /// - Same configuration (TopK, shapes, etc.)
-    /// - Same learned parameters
-    ///
-    /// Useful for:
-    /// - Creating an ensemble of similar models
-    /// - Experimenting with different training approaches
-    /// - Saving checkpoints during training
-    /// - Implementing certain meta-learning algorithms
-    ///
-    /// The clone is completely independent - training one won't affect the other.
-    /// </para>
-    /// </remarks>
-    public override LayerBase<T> Clone()
-    {
-        // Clone router
-        ILayer<T> clonedRouter = _router;
-        if (_router is LayerBase<T> routerBase)
-        {
-            clonedRouter = (ILayer<T>)routerBase.Clone();
-        }
-
-        // Clone experts
-        var clonedExperts = _experts.Select(e =>
-        {
-            if (e is LayerBase<T> expertBase)
-            {
-                return (ILayer<T>)expertBase.Clone();
-            }
-            return e;
-        }).ToList();
-
-        return new MixtureOfExpertsLayer<T>(
-            clonedExperts,
-            clonedRouter,
-            InputShape,
-            OutputShape,
-            _topK,
-            ScalarActivation,
-            _useAuxiliaryLoss,
-            _auxiliaryLossWeight);
-    }
-
     #region IAuxiliaryLossLayer Implementation
 
     /// <summary>
diff --git a/src/NeuralNetworks/Layers/MoEDecoderBlock.cs b/src/NeuralNetworks/Layers/MoEDecoderBlock.cs
index 78c50b0c0e..41904bb1ff 100644
--- a/src/NeuralNetworks/Layers/MoEDecoderBlock.cs
+++ b/src/NeuralNetworks/Layers/MoEDecoderBlock.cs
@@ -1,4 +1,4 @@
-using System.Collections.Generic;
+using System.Collections.Generic;
 using AiDotNet.Attributes;
 using AiDotNet.Interfaces;
 
@@ -12,7 +12,7 @@ namespace AiDotNet.NeuralNetworks.Layers;
 /// <typeparam name="T">The numeric type used for calculations.</typeparam>
 [LayerCategory(LayerCategory.Attention)]
 [LayerTask(LayerTask.SequenceModeling)]
-[LayerProperty(IsTrainable = false, HasTrainingMode = false, TestInputShape = "1, 4, 8", TestConstructorArgs = "")]
+[LayerProperty(IsTrainable = false, HasTrainingMode = false, TestInputShape = "1, 4, 8", TestConstructorArgs = "8, new AiDotNet.NeuralNetworks.Layers.MultiHeadAttentionLayer<double>(2, 4), new AiDotNet.NeuralNetworks.Layers.MoEFeedForwardLayer<double>(8, 16, 2, 1)")]
 // Pre-LN residual block, so shape preservation is structural rather than incidental: ForwardTraced is two
 // `Engine.TensorAdd(residual, sublayerOut)` pairs, and each one only types when the sublayer returned the
 // residual's exact shape. That holds whatever attention implementation is injected - a sublayer that
@@ -44,6 +44,9 @@ public partial class MoEDecoderBlock<T> : LayerBase<T>, IShapeContract
     /// <summary>The model (input/output) feature dimension.</summary>
     public int HiddenSize => _hiddenSize;
 
+    /// <summary>Construction state: the 'rmsNormEpsilon' the layer was built with.</summary>
+    private readonly double _rmsNormEpsilon;
+
     /// <summary>Creates a MoE pre-LN decoder block.</summary>
     /// <param name="hiddenSize">Input/output feature dimension.</param>
     /// <param name="attention">Pre-constructed self-attention sublayer.</param>
@@ -52,6 +55,7 @@ public partial class MoEDecoderBlock<T> : LayerBase<T>, IShapeContract
     public MoEDecoderBlock(int hiddenSize, LayerBase<T> attention, MoEFeedForwardLayer<T> moe, double rmsNormEpsilon = 1e-6)
         : base(new[] { -1, hiddenSize }, new[] { -1, hiddenSize })
     {
+        _rmsNormEpsilon = rmsNormEpsilon;
         Guard.NotNull(attention);
         Guard.NotNull(moe);
         _hiddenSize = hiddenSize;
diff --git a/src/NeuralNetworks/Layers/MoEFeedForwardLayer.cs b/src/NeuralNetworks/Layers/MoEFeedForwardLayer.cs
index 214486b1b3..1a00b3a538 100644
--- a/src/NeuralNetworks/Layers/MoEFeedForwardLayer.cs
+++ b/src/NeuralNetworks/Layers/MoEFeedForwardLayer.cs
@@ -23,7 +23,7 @@ namespace AiDotNet.NeuralNetworks.Layers;
 /// </remarks>
 [LayerCategory(LayerCategory.FeedForward)]
 [LayerTask(LayerTask.SequenceModeling)]
-[LayerProperty(IsTrainable = false, HasTrainingMode = false, TestInputShape = "1, 4, 8", TestConstructorArgs = "")]
+[LayerProperty(IsTrainable = false, HasTrainingMode = false, TestInputShape = "1, 4, 8", TestConstructorArgs = "8, 16, 2, 1")]
 // Sparse routing changes WHICH weights a token sees, never how many numbers come back. The last line of
 // ForwardTraced is `Engine.Reshape(output, input._shape)` - the caller's exact shape, at any rank - and
 // the accumulator it reshapes is [n, _hidden], so the trailing width is preserved too (the input's own
@@ -35,9 +35,17 @@ public partial class MoEFeedForwardLayer<T> : LayerBase<T>, IShapeContract
 {
     private static readonly INumericOperations<T> Ops = MathHelper.GetNumericOperations<T>();
 
+    // Every child reads the token, not its predecessor's output. Chained sizing assumed otherwise and
+    // built each expert against the ROUTER's numExperts-wide output, so a restore met [2, 16] where
+    // the checkpoint held [8, 16] and refused it. The experts are siblings, so one declared width
+    // covers the whole bank.
+    [SubLayerInput("_hidden")]
     private readonly DenseLayer<T> _router;               // hidden -> numExperts (no bias, identity)
+    [SubLayerInput("_hidden")]
     private readonly DenseLayer<T>[] _gate;               // per expert: hidden -> ffn (activation)
+    [SubLayerInput("_hidden")]
     private readonly DenseLayer<T>[] _up;                 // per expert: hidden -> ffn (identity)
+    [SubLayerInput("_ffnDim")]
     private readonly DenseLayer<T>[] _down;               // per expert: ffn -> hidden (identity)
     private readonly int _hidden;
     private readonly int _ffnDim;
@@ -46,9 +54,13 @@ public partial class MoEFeedForwardLayer<T> : LayerBase<T>, IShapeContract
 
     // Optional always-on shared expert (Qwen2-MoE): its SwiGLU output, gated by sigmoid(sharedGate(x)), is
     // added to the routed output for every token. Null when the model has no shared expert (Mixtral).
+    [SubLayerInput("_hidden")]
     private readonly DenseLayer<T>? _sharedGate;          // hidden -> sharedFfn (activation)
+    [SubLayerInput("_hidden")]
     private readonly DenseLayer<T>? _sharedUp;            // hidden -> sharedFfn (identity)
+    [SubLayerInput("_sharedFfnDim")]
     private readonly DenseLayer<T>? _sharedDown;          // sharedFfn -> hidden (identity)
+    [SubLayerInput("_hidden")]
     private readonly DenseLayer<T>? _sharedGateLogit;     // hidden -> 1 (sigmoid gate)
     private readonly int _sharedFfnDim;
 
@@ -87,6 +99,9 @@ public partial class MoEFeedForwardLayer<T> : LayerBase<T>, IShapeContract
     /// <summary>The shared expert's sigmoid gate (hidden -&gt; 1; null when absent).</summary>
     public DenseLayer<T>? SharedGateLogit => _sharedGateLogit;
 
+    /// <summary>Construction state: the 'hiddenSize' the layer was built with.</summary>
+    private readonly int _hiddenSize;
+
     /// <summary>Creates a sparse MoE feed-forward layer.</summary>
     /// <param name="hiddenSize">Model (residual stream) dimension.</param>
     /// <param name="ffnDim">Each expert's inner (intermediate) dimension.</param>
@@ -99,6 +114,7 @@ public MoEFeedForwardLayer(int hiddenSize, int ffnDim, int numExperts, int topK,
         int sharedFfnDim = 0)
         : base(new[] { -1, hiddenSize }, new[] { -1, hiddenSize })
     {
+        _hiddenSize = hiddenSize;
         if (hiddenSize <= 0) throw new ArgumentOutOfRangeException(nameof(hiddenSize));
         if (ffnDim <= 0) throw new ArgumentOutOfRangeException(nameof(ffnDim));
         if (numExperts <= 0) throw new ArgumentOutOfRangeException(nameof(numExperts));
diff --git a/src/NeuralNetworks/Layers/MultiHeadAttentionLayer.cs b/src/NeuralNetworks/Layers/MultiHeadAttentionLayer.cs
index bc2ab785b6..0e8e025277 100644
--- a/src/NeuralNetworks/Layers/MultiHeadAttentionLayer.cs
+++ b/src/NeuralNetworks/Layers/MultiHeadAttentionLayer.cs
@@ -159,6 +159,7 @@ public partial class MultiHeadAttentionLayer<T> : LayerBase<T>, IAuxiliaryLossLa
 
     private T _lastEntropyLoss;
     private T _lastDiversityLoss;
+    [Scratch]
     private List<Tensor<T>>? _lastHeadOutputs = null;
 
     // Positional encoding support
@@ -212,16 +213,25 @@ public partial class MultiHeadAttentionLayer<T> : LayerBase<T>, IAuxiliaryLossLa
     public IQkvTransform<T>? QkvTransform { get; set; }
 
     // Cached projected Q, K, V for backward pass (4D: [batch, heads, seq, head_dim])
+    [Scratch]
     private Tensor<T>? _lastProjectedQueries = null;
+    [Scratch]
     private Tensor<T>? _lastProjectedKeys = null;
+    [Scratch]
     private Tensor<T>? _lastProjectedValues = null;
 
     // GPU cached tensors for backward pass
+    [ExternalState]
     private Tensor<T>? _gpuInput2D;
+    [ExternalState]
     private Tensor<T>? _gpuQ;
+    [ExternalState]
     private Tensor<T>? _gpuK;
+    [ExternalState]
     private Tensor<T>? _gpuV;
+    [ExternalState]
     private Tensor<T>? _gpuContextFlat;
+    [ExternalState]
     private Tensor<T>? _gpuAttentionWeights;
     private int _gpuBatchSize;
     private int _gpuSeqLength;
@@ -281,15 +291,20 @@ public partial class MultiHeadAttentionLayer<T> : LayerBase<T>, IAuxiliaryLossLa
     /// <summary>
     /// Cached input from the forward pass for use in the backward pass.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastInput;
 
+    [Scratch]
     private Tensor<T>? _lastQueryInput;
+    [Scratch]
     private Tensor<T>? _lastKeyInput;
+    [Scratch]
     private Tensor<T>? _lastValueInput;
 
     /// <summary>
     /// Cached output from the forward pass for use in the backward pass.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastOutput;
 
     /// <summary>
@@ -297,46 +312,54 @@ public partial class MultiHeadAttentionLayer<T> : LayerBase<T>, IAuxiliaryLossLa
     /// activation derivative correctly. GELU and other activations need the
     /// pre-activation input to compute derivatives, not the post-activation output.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastPreActivationOutput;
 
     /// <summary>
     /// Cached attention context (pre-projection input) for computing output weights gradient.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastAttentionContext;
 
     /// <summary>
     /// Cached attention scores from the forward pass for use in the backward pass.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastAttentionScores;
 
     /// <summary>
     /// Tensor storing gradients for query weights calculated during backward pass.
     /// Shape: [embeddingDimension, embeddingDimension]
     /// </summary>
+    [Scratch]
     private Tensor<T>? _queryWeightsGradient;
 
     /// <summary>
     /// Tensor storing gradients for key weights calculated during backward pass.
     /// Shape: [embeddingDimension, embeddingDimension]
     /// </summary>
+    [Scratch]
     private Tensor<T>? _keyWeightsGradient;
 
     /// <summary>
     /// Tensor storing gradients for value weights calculated during backward pass.
     /// Shape: [embeddingDimension, embeddingDimension]
     /// </summary>
+    [Scratch]
     private Tensor<T>? _valueWeightsGradient;
 
     /// <summary>
     /// Tensor storing gradients for output weights calculated during backward pass.
     /// Shape: [embeddingDimension, embeddingDimension]
     /// </summary>
+    [Scratch]
     private Tensor<T>? _outputWeightsGradient;
 
     /// <summary>
     /// Tensor storing gradients for output bias calculated during backward pass.
     /// Shape: [embeddingDimension]
     /// </summary>
+    [Scratch]
     private Tensor<T>? _outputBiasGradient;
 
     /// <summary>
@@ -1666,10 +1689,15 @@ public override Tensor<T> ForwardGpu(params Tensor<T>[] inputs)
     }
 
 
+    [AiDotNet.Attributes.Buffer]
     private Tensor<T>? _queryWeightsVelocity;
+    [AiDotNet.Attributes.Buffer]
     private Tensor<T>? _keyWeightsVelocity;
+    [AiDotNet.Attributes.Buffer]
     private Tensor<T>? _valueWeightsVelocity;
+    [AiDotNet.Attributes.Buffer]
     private Tensor<T>? _outputWeightsVelocity;
+    [AiDotNet.Attributes.Buffer]
     private Tensor<T>? _outputBiasVelocity;
 
     /// <summary>
diff --git a/src/NeuralNetworks/Layers/MultiplyLayer.cs b/src/NeuralNetworks/Layers/MultiplyLayer.cs
index 7b8ef12591..00053e7919 100644
--- a/src/NeuralNetworks/Layers/MultiplyLayer.cs
+++ b/src/NeuralNetworks/Layers/MultiplyLayer.cs
@@ -66,6 +66,7 @@ public partial class MultiplyLayer<T> : LayerBase<T>, IShapeContract
     /// This field stores the output tensor from the most recent forward pass, which is needed
     /// during the backward pass for gradient calculation.
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _lastOutput;
 
     /// <summary>
diff --git a/src/NeuralNetworks/Layers/NoisyDenseLayer.cs b/src/NeuralNetworks/Layers/NoisyDenseLayer.cs
index 67d4400280..8619f59d9d 100644
--- a/src/NeuralNetworks/Layers/NoisyDenseLayer.cs
+++ b/src/NeuralNetworks/Layers/NoisyDenseLayer.cs
@@ -146,9 +146,13 @@ public partial class NoisyDenseLayer<T> : LayerBase<T>, IShapeContract
     // a view into the provided ParameterBuffer" — the path
     // RainbowDQNAgent.Train(state, target) takes when called for offline
     // pretraining or BC warm-start.
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _muWeights;
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _sigmaWeights;
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _muBiases;
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _sigmaBiases;
 
     /// <summary>
@@ -234,8 +238,6 @@ private void InitializeParameters()
     }
 
     /// <inheritdoc/>
-    public override IReadOnlyList<Tensor<T>> GetTrainableParameters() =>
-        new[] { _muWeights, _sigmaWeights, _muBiases, _sigmaBiases };
 
     /// <inheritdoc/>
     /// <remarks>
@@ -251,19 +253,6 @@ public override IReadOnlyList<Tensor<T>> GetTrainableParameters() =>
     /// length but rebinding _muWeights from the former to the latter would
     /// rotate every weight-index pair.
     /// </remarks>
-    public override void SetTrainableParameters(IReadOnlyList<Tensor<T>> parameters)
-    {
-        if (parameters.Count != 4)
-            throw new ArgumentException("Expected exactly 4 parameter tensors (μ_w, σ_w, μ_b, σ_b).", nameof(parameters));
-        ValidateShapeMatch(parameters[0], _muWeights, nameof(_muWeights));
-        ValidateShapeMatch(parameters[1], _sigmaWeights, nameof(_sigmaWeights));
-        ValidateShapeMatch(parameters[2], _muBiases, nameof(_muBiases));
-        ValidateShapeMatch(parameters[3], _sigmaBiases, nameof(_sigmaBiases));
-        _muWeights = parameters[0];
-        _sigmaWeights = parameters[1];
-        _muBiases = parameters[2];
-        _sigmaBiases = parameters[3];
-    }
 
     private static void ValidateShapeMatch(Tensor<T> incoming, Tensor<T> existing, string paramName)
     {
diff --git a/src/NeuralNetworks/Layers/ObliviousDecisionTreeLayer.cs b/src/NeuralNetworks/Layers/ObliviousDecisionTreeLayer.cs
index d34549240e..cace6aad46 100644
--- a/src/NeuralNetworks/Layers/ObliviousDecisionTreeLayer.cs
+++ b/src/NeuralNetworks/Layers/ObliviousDecisionTreeLayer.cs
@@ -35,6 +35,11 @@ namespace AiDotNet.NeuralNetworks.Layers;
     Note = "Unbatched or higher-rank data must be reshaped to [batch, features] upstream.")]
 [TensorLayout(TensorAxis.Batch, TensorAxis.Features, Direction = TensorLayoutDirection.Output)]
 [AutoParameters]
+// Declared so this layer is GENERATED A TEST AT ALL. TestScaffoldGenerator skips any layer with
+// neither a parameterless constructor nor TestConstructorArgs, and the skip is a bare continue
+// with no diagnostic, so an undeclared layer simply vanishes from generated coverage.
+[LayerProperty(IsTrainable = true, ChangesShape = true, ExpectedInputRank = 2,
+    TestInputShape = "1, 4", TestConstructorArgs = "4, 3, 2")]
 public partial class ObliviousDecisionTreeLayer<T> : LayerBase<T>, IShapeContract
 {
     /// <inheritdoc />
@@ -85,14 +90,21 @@ public partial class ObliviousDecisionTreeLayer<T> : LayerBase<T>, IShapeContrac
     private Tensor<T> _leafValues;                // [numLeaves, outputDim]
 
     // Gradients
+    [Scratch]
     private Tensor<T> _featureSelectionGrad;
+    [Scratch]
     private Tensor<T> _thresholdsGrad;
+    [Scratch]
     private Tensor<T> _leafValuesGrad;
 
     // Cached values
+    [Scratch]
     private Tensor<T>? _inputCache;
+    [Scratch]
     private Tensor<T>? _featureSelectionsCache;
+    [Scratch]
     private Tensor<T>? _splitDecisionsCache;
+    [Scratch]
     private Tensor<T>? _leafProbabilitiesCache;
 
     private readonly int _numLeaves;
diff --git a/src/NeuralNetworks/Layers/OccupancyNetworkDecoder.cs b/src/NeuralNetworks/Layers/OccupancyNetworkDecoder.cs
index 0adcd71989..614bf7ebd8 100644
--- a/src/NeuralNetworks/Layers/OccupancyNetworkDecoder.cs
+++ b/src/NeuralNetworks/Layers/OccupancyNetworkDecoder.cs
@@ -135,6 +135,7 @@ public partial class OccupancyNetworkDecoder<T> : LayerBase<T>, IShapeContract
 
     // Constant "1" input that drives the learnable latent-code generator. Cached
     // so each forward reuses the same buffer instead of allocating.
+    [AiDotNet.Attributes.TrainableParameter]
     private readonly Tensor<T> _one;
 
     // Learnable latent code c (auto-decoder): ones[1,1] → DenseLayer → c[1, latentDim].
diff --git a/src/NeuralNetworks/Layers/OctonionLinearLayer.cs b/src/NeuralNetworks/Layers/OctonionLinearLayer.cs
index 3ad5dba0ff..3455c80366 100644
--- a/src/NeuralNetworks/Layers/OctonionLinearLayer.cs
+++ b/src/NeuralNetworks/Layers/OctonionLinearLayer.cs
@@ -117,6 +117,7 @@ public partial class OctonionLinearLayer<T> : LayerBase<T>, IShapeContract
     /// Stored input from forward pass for backpropagation.
     /// Shape: [batch, inputFeatures, 8]
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastInput;
 
     /// <summary>
@@ -128,16 +129,19 @@ public partial class OctonionLinearLayer<T> : LayerBase<T>, IShapeContract
     /// Stored pre-activation output for gradient computation.
     /// Shape: [batch, outputFeatures, 8]
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastOutput;
 
     /// <summary>
     /// Gradient for weights. Shape: [OutputFeatures, InputFeatures, 8]
     /// </summary>
+    [Scratch]
     private Tensor<T>? _weightsGradient;
 
     /// <summary>
     /// Gradient for biases. Shape: [OutputFeatures, 8]
     /// </summary>
+    [Scratch]
     private Tensor<T>? _biasesGradient;
 
     /// <summary>
diff --git a/src/NeuralNetworks/Layers/PReLULayer.cs b/src/NeuralNetworks/Layers/PReLULayer.cs
index 9f445464ea..c0df892b51 100644
--- a/src/NeuralNetworks/Layers/PReLULayer.cs
+++ b/src/NeuralNetworks/Layers/PReLULayer.cs
@@ -67,6 +67,9 @@ public partial class PReLULayer<T> : LayerBase<T>
     /// </summary>
     public Tensor<T> GetAlphaTensor() => _alpha;
 
+    /// <summary>Construction state: the 'initialAlpha' the layer was built with.</summary>
+    private readonly double _initialAlpha;
+
     /// <summary>Gets the number of independently learned negative slopes.</summary>
     public int NumParameters => _numParameters;
 
@@ -93,6 +96,7 @@ public partial class PReLULayer<T> : LayerBase<T>
     public PReLULayer(int numParameters = 1, int channelAxis = 1, double initialAlpha = 0.25)
         : base(new[] { -1 }, new[] { -1 })
     {
+        _initialAlpha = initialAlpha;
         if (numParameters < 1)
             throw new ArgumentException("numParameters must be at least 1.", nameof(numParameters));
         if (numParameters > 1 && channelAxis < 0)
@@ -189,16 +193,4 @@ public override void ResetState()
     {
         _lastInput = null;
     }
-
-    /// <inheritdoc/>
-    public override LayerBase<T> Clone()
-    {
-        var copy = new PReLULayer<T>(_numParameters, _channelAxis,
-            Convert.ToDouble(_alpha.Data.Span[0]));
-        // Copy current α values so Clone preserves trained state, not just init state.
-        var dst = copy._alpha.Data.Span;
-        var src = _alpha.Data.Span;
-        for (int i = 0; i < _alpha.Length; i++) dst[i] = src[i];
-        return copy;
-    }
 }
diff --git a/src/NeuralNetworks/Layers/PaddingLayer.cs b/src/NeuralNetworks/Layers/PaddingLayer.cs
index ca3d406f80..3d5f1dbf75 100644
--- a/src/NeuralNetworks/Layers/PaddingLayer.cs
+++ b/src/NeuralNetworks/Layers/PaddingLayer.cs
@@ -102,6 +102,7 @@ public partial class PaddingLayer<T> : LayerBase<T>, IShapeContract
     /// This field stores the input tensor from the most recent forward pass, which is needed
     /// during the backward pass for gradient calculation.
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _lastInput;
 
     /// <summary>
diff --git a/src/NeuralNetworks/Layers/ParallelStreamsLayer.cs b/src/NeuralNetworks/Layers/ParallelStreamsLayer.cs
index 938b488796..fd5f5c0dfd 100644
--- a/src/NeuralNetworks/Layers/ParallelStreamsLayer.cs
+++ b/src/NeuralNetworks/Layers/ParallelStreamsLayer.cs
@@ -53,7 +53,7 @@ namespace AiDotNet.NeuralNetworks.Layers;
 /// </para>
 /// </remarks>
 [LayerTask(LayerTask.FeatureExtraction)]
-[LayerProperty(IsTrainable = true, ChangesShape = true, Cost = ComputeCost.High)]
+[LayerProperty(IsTrainable = true, ChangesShape = true, Cost = ComputeCost.High, TestConstructorArgs = "4, 8, 8, new System.Collections.Generic.List<AiDotNet.Interfaces.ILayer<double>> { new AiDotNet.NeuralNetworks.Layers.ReadoutLayer<double>(2, 8, (AiDotNet.Interfaces.IActivationFunction<double>)new AiDotNet.ActivationFunctions.IdentityActivation<double>()) }, new System.Collections.Generic.List<AiDotNet.Interfaces.ILayer<double>> { new AiDotNet.NeuralNetworks.Layers.ReadoutLayer<double>(2, 8, (AiDotNet.Interfaces.IActivationFunction<double>)new AiDotNet.ActivationFunctions.IdentityActivation<double>()) }", TestInputShape = "1, 4")]
 // A TWO-STREAM decorator. ForwardTraced slices the last axis in half, runs each half through its own
 // sub-layer list, and returns "Engine.TensorConcatenate([outputA, outputB], axis: rank - 1)" - so the
 // leading axes are the input's untouched and the trailing axis is the SUM of the two streams' widths.
diff --git a/src/NeuralNetworks/Layers/PatchEmbeddingLayer.cs b/src/NeuralNetworks/Layers/PatchEmbeddingLayer.cs
index 3c5c51bfc2..59cfde836d 100644
--- a/src/NeuralNetworks/Layers/PatchEmbeddingLayer.cs
+++ b/src/NeuralNetworks/Layers/PatchEmbeddingLayer.cs
@@ -174,6 +174,7 @@ public partial class PatchEmbeddingLayer<T> : LayerBase<T>, IShapeContract
     /// <summary>
     /// Cached input from the forward pass for use in the backward pass.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastInput;
 
     /// <summary>
@@ -196,20 +197,25 @@ public partial class PatchEmbeddingLayer<T> : LayerBase<T>, IShapeContract
     /// </summary>
     private bool _paramsLoadedViaSetParameters;
 
+    [Scratch]
     private Tensor<T>? _projectionWeightsGradient;
 
     /// <summary>
     /// Gradients for projection bias calculated during backward pass.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _projectionBiasGradient;
 
     /// <summary>
     /// Cached pre-activation tensor from forward pass for use in activation derivative calculation.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastPreActivation;
 
     // GPU cached tensors for backward pass
+    [ExternalState]
     private Tensor<T>? _gpuInput;
+    [ExternalState]
     private Tensor<T>? _gpuPatchesFlat;
     private int _gpuBatchSize;
     private bool _gpuHasBatch;
@@ -217,15 +223,25 @@ public partial class PatchEmbeddingLayer<T> : LayerBase<T>, IShapeContract
     #region GPU Weight Storage Fields
 
     // GPU tensors for GPU-resident training
+    [ExternalState]
     private Tensor<T>? _gpuWeights;
+    [ExternalState]
     private Tensor<T>? _gpuBias;
+    [ExternalState]
     private Tensor<T>? _gpuWeightGradient;
+    [ExternalState]
     private Tensor<T>? _gpuBiasGradient;
+    [ExternalState]
     private Tensor<T>? _gpuWeightVelocity;
+    [ExternalState]
     private Tensor<T>? _gpuBiasVelocity;
+    [ExternalState]
     private Tensor<T>? _gpuWeightM;
+    [ExternalState]
     private Tensor<T>? _gpuWeightV;
+    [ExternalState]
     private Tensor<T>? _gpuBiasM;
+    [ExternalState]
     private Tensor<T>? _gpuBiasV;
 
     #endregion
diff --git a/src/NeuralNetworks/Layers/PatchGANDiscriminator.cs b/src/NeuralNetworks/Layers/PatchGANDiscriminator.cs
index 80e9bd0184..b81d93ea54 100644
--- a/src/NeuralNetworks/Layers/PatchGANDiscriminator.cs
+++ b/src/NeuralNetworks/Layers/PatchGANDiscriminator.cs
@@ -73,6 +73,11 @@ namespace AiDotNet.NeuralNetworks.Layers;
 [TensorLayout(TensorAxis.Channels, TensorAxis.Height, TensorAxis.Width,
     Direction = TensorLayoutDirection.Output)]
 [AutoParameters]
+// See the note on ObliviousDecisionTreeLayer: without this the scaffold generator emits no test
+// for the layer and nothing reports the omission. Two layers over a 16x16 image keeps the
+// downsampling pyramid valid.
+[LayerProperty(IsTrainable = true, ChangesShape = true, ExpectedInputRank = 3,
+    TestInputShape = "3, 16, 16", TestConstructorArgs = "2, 8")]
 public partial class PatchGANDiscriminator<T> : LayerBase<T>, IShapeContract
 {
     #region Constants
@@ -218,6 +223,9 @@ public int ReceptiveField
 
     #region Constructors
 
+    /// <summary>Construction state: the 'leakySlope' the layer was built with.</summary>
+    private readonly double _leakySlope;
+
     /// <summary>
     /// Creates a PatchGAN discriminator at one of the receptive-field sizes reported in the paper.
     /// </summary>
@@ -241,6 +249,7 @@ public PatchGANDiscriminator(
             leakySlope: leakySlope,
             applySigmoid: applySigmoid)
     {
+        _leakySlope = leakySlope;
     }
 
     /// <summary>
diff --git a/src/NeuralNetworks/Layers/PiecewiseLinearEncodingLayer.cs b/src/NeuralNetworks/Layers/PiecewiseLinearEncodingLayer.cs
index 497bb5c4ec..62e67a27d5 100644
--- a/src/NeuralNetworks/Layers/PiecewiseLinearEncodingLayer.cs
+++ b/src/NeuralNetworks/Layers/PiecewiseLinearEncodingLayer.cs
@@ -40,11 +40,15 @@ public partial class PiecewiseLinearEncodingLayer<T> : LayerBase<T>, IShapeContr
     private readonly int _numBins;
 
     // Learnable bin boundaries for each feature
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _binBoundaries;
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _binBoundaryGradients;
 
     // Cached values for backward pass
+    [Scratch]
     private Tensor<T>? _inputCache;
+    [Scratch]
     private Tensor<T>? _outputCache;
 
     /// <summary>
diff --git a/src/NeuralNetworks/Layers/PixelShuffleLayer.cs b/src/NeuralNetworks/Layers/PixelShuffleLayer.cs
index b4acbd2216..9b1aba163a 100644
--- a/src/NeuralNetworks/Layers/PixelShuffleLayer.cs
+++ b/src/NeuralNetworks/Layers/PixelShuffleLayer.cs
@@ -66,6 +66,7 @@ public partial class PixelShuffleLayer<T> : LayerBase<T>, IShapeContract
     /// <summary>
     /// Cached input from the last forward pass for backpropagation.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastInput;
 
     /// <summary>
diff --git a/src/NeuralNetworks/Layers/PoolingLayer.cs b/src/NeuralNetworks/Layers/PoolingLayer.cs
index 0ff484f4b7..31ff67ca76 100644
--- a/src/NeuralNetworks/Layers/PoolingLayer.cs
+++ b/src/NeuralNetworks/Layers/PoolingLayer.cs
@@ -204,6 +204,7 @@ public partial class PoolingLayer<T> : LayerBase<T>, IShapeContract
     /// This field stores the input tensor from the most recent forward pass, which is needed
     /// during the backward pass for gradient calculation.
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _lastInput;
 
     /// <summary>
diff --git a/src/NeuralNetworks/Layers/PreLNTransformerBlock.cs b/src/NeuralNetworks/Layers/PreLNTransformerBlock.cs
index 69a17f3442..75713687fe 100644
--- a/src/NeuralNetworks/Layers/PreLNTransformerBlock.cs
+++ b/src/NeuralNetworks/Layers/PreLNTransformerBlock.cs
@@ -29,7 +29,7 @@ namespace AiDotNet.NeuralNetworks.Layers;
 /// </remarks>
 [LayerCategory(LayerCategory.Attention)]
 [LayerTask(LayerTask.SequenceModeling)]
-[LayerProperty(IsTrainable = true, HasTrainingMode = false, TestInputShape = "1, 4, 8", TestConstructorArgs = "")]
+[LayerProperty(IsTrainable = true, HasTrainingMode = false, TestInputShape = "1, 4, 8", TestConstructorArgs = "8, 16, new AiDotNet.NeuralNetworks.Layers.MultiHeadAttentionLayer<double>(2, 4)")]
 // Roles from this block's own forward: "Self-attention sublayer expects [B, S, H] (or [S, H])", so one
 // declaration with BatchOptional covers both ranks. Time rather than Length because the block is built
 // for causal decoder stacks (T5 / LLaMA / Gemma / Qwen2), where the sequence axis IS temporal.
@@ -51,6 +51,9 @@ namespace AiDotNet.NeuralNetworks.Layers;
 [AutoParameters]
 public partial class PreLNTransformerBlock<T> : LayerBase<T>, IShapeContract
 {
+    // Every child reads the block input; only the down-projection reads the expanded width.
+    // Chained sizing walked registration order instead and built the second projection from
+    // the first's output, so a restore met a differently shaped layer than the checkpoint.
     [SubLayerInput("_hiddenSize")]
     private readonly RMSNormalizationLayer<T> _norm1;
     // Non-readonly so the inference optimizer can swap the attention sublayer in place (e.g.
diff --git a/src/NeuralNetworks/Layers/PrependCLSTokenLayer.cs b/src/NeuralNetworks/Layers/PrependCLSTokenLayer.cs
index 06630c8b34..e0e54f852d 100644
--- a/src/NeuralNetworks/Layers/PrependCLSTokenLayer.cs
+++ b/src/NeuralNetworks/Layers/PrependCLSTokenLayer.cs
@@ -47,6 +47,7 @@ namespace AiDotNet.NeuralNetworks.Layers;
 public partial class PrependCLSTokenLayer<T> : LayerBase<T>, IShapeContract
 {
     private readonly int _embedDim;
+    private readonly double _initScale;
 
     /// <inheritdoc />
     /// <remarks>
@@ -85,8 +86,11 @@ public partial class PrependCLSTokenLayer<T> : LayerBase<T>, IShapeContract
     }
 
     // Trainable CLS token — shape [1, embedDim]. Held by reference so the
-    // gradient tape can track parameter identity.
-    private  Tensor<T> _cls;
+    // gradient tape can track parameter identity, which is why it is readonly:
+    // the generated restore copies values into a readonly tensor in place and
+    // rebinds a mutable one, and rebinding is what would break that identity.
+    [AiDotNet.Attributes.TrainableParameter]
+    private readonly Tensor<T> _cls;
 
     /// <summary>Creates a CLS-token prepender for embedDim-wide inputs.</summary>
     /// <param name="embedDim">Embedding dimension (must match the input's last axis).</param>
@@ -100,6 +104,7 @@ public PrependCLSTokenLayer(int embedDim, double initScale = 0.02, int? seed = n
     {
         if (embedDim <= 0) throw new ArgumentOutOfRangeException(nameof(embedDim));
         _embedDim = embedDim;
+        _initScale = initScale;
         _cls = new Tensor<T>(new[] { 1, embedDim });
 
         var rng = seed.HasValue
@@ -112,21 +117,6 @@ public PrependCLSTokenLayer(int embedDim, double initScale = 0.02, int? seed = n
     /// <inheritdoc/>
     public override bool SupportsTraining => true;
 
-    /// <inheritdoc/>
-    public override IReadOnlyList<Tensor<T>> GetTrainableParameters() => new[] { _cls };
-
-    /// <inheritdoc/>
-    public override void SetTrainableParameters(IReadOnlyList<Tensor<T>> parameters)
-    {
-        if (parameters.Count != 1)
-            throw new ArgumentException("Expected exactly 1 parameter tensor (CLS).", nameof(parameters));
-        var src = parameters[0];
-        if (src.Length != _cls.Length)
-            throw new ArgumentException(
-                $"CLS shape mismatch: source length={src.Length}, expected {_cls.Length}.");
-        for (int i = 0; i < src.Length; i++) _cls[i] = src[i];
-    }
-
     /// <inheritdoc/>
     protected override Tensor<T> ForwardTraced(Tensor<T> input)
     {
diff --git a/src/NeuralNetworks/Layers/PrimaryCapsuleLayer.cs b/src/NeuralNetworks/Layers/PrimaryCapsuleLayer.cs
index 320b3e2199..b91d9e9ea9 100644
--- a/src/NeuralNetworks/Layers/PrimaryCapsuleLayer.cs
+++ b/src/NeuralNetworks/Layers/PrimaryCapsuleLayer.cs
@@ -87,6 +87,7 @@ public partial class PrimaryCapsuleLayer<T> : LayerBase<T>, IShapeContract
     /// This field stores the gradient of the convolution weights, which is used to update the weights
     /// during the parameter update step.
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _convWeightsGradient;
 
     /// <summary>
@@ -96,6 +97,7 @@ public partial class PrimaryCapsuleLayer<T> : LayerBase<T>, IShapeContract
     /// This field stores the gradient of the convolution bias, which is used to update the bias
     /// during the parameter update step.
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _convBiasGradient;
 
     /// <summary>
@@ -105,6 +107,7 @@ public partial class PrimaryCapsuleLayer<T> : LayerBase<T>, IShapeContract
     /// This field stores the input tensor from the most recent forward pass, which is needed
     /// during the backward pass for gradient calculation.
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _lastInput;
 
     /// <summary>
@@ -124,7 +127,9 @@ public partial class PrimaryCapsuleLayer<T> : LayerBase<T>, IShapeContract
     /// This field stores the output tensor from the most recent forward pass, which is needed
     /// during the backward pass for gradient calculation.
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _lastOutput;
+    [Scratch]
     private Tensor<T>? _lastPreSquash;
 
     /// <summary>
diff --git a/src/NeuralNetworks/Layers/PrincipalNeighbourhoodAggregationLayer.cs b/src/NeuralNetworks/Layers/PrincipalNeighbourhoodAggregationLayer.cs
index 6fe125a7bf..0ed1e8cb78 100644
--- a/src/NeuralNetworks/Layers/PrincipalNeighbourhoodAggregationLayer.cs
+++ b/src/NeuralNetworks/Layers/PrincipalNeighbourhoodAggregationLayer.cs
@@ -88,31 +88,48 @@ public partial class PrincipalNeighbourhoodAggregationLayer<T> : LayerBase<T>, I
     private Tensor<T> _bias;
 
     // The adjacency matrix defining graph structure
+    [AiDotNet.Attributes.FittedParameter(InputSized = true)]
     private Tensor<T>? _adjacencyMatrix;
 
     // Cached values for backward pass
+    [Scratch]
     private Tensor<T>? _lastInput;
 
     /// <summary>
     /// Stores the original input shape for any-rank tensor support.
     /// </summary>
     private int[]? _originalInputShape;
+    [Scratch]
     private Tensor<T>? _lastOutput;
+    [Scratch]
     private Tensor<T>? _lastTransformed;
+    [Scratch]
     private Tensor<T>? _lastAggregated;
+    [Scratch]
     private Tensor<T>? _lastMlpHiddenPreRelu;
+    [Scratch]
     private Tensor<T>? _lastMlpHidden;
+    [Scratch]
     private Tensor<T>? _lastMlpOutput;
+    [Scratch]
     private Tensor<T>? _lastDegrees;
 
     // Gradients - Tensor-based for GPU acceleration
+    [Scratch]
     private Tensor<T>? _preTransformWeightsGradient;
+    [Scratch]
     private Tensor<T>? _preTransformBiasGradient;
+    [Scratch]
     private Tensor<T>? _postAggregationWeights1Gradient;
+    [Scratch]
     private Tensor<T>? _postAggregationWeights2Gradient;
+    [Scratch]
     private Tensor<T>? _postAggregationBias1Gradient;
+    [Scratch]
     private Tensor<T>? _postAggregationBias2Gradient;
+    [Scratch]
     private Tensor<T>? _selfWeightsGradient;
+    [Scratch]
     private Tensor<T>? _biasGradient;
 
     public override bool SupportsTraining => true;
diff --git a/src/NeuralNetworks/Layers/QuantumLayer.cs b/src/NeuralNetworks/Layers/QuantumLayer.cs
index 67c4c3812c..8327fae678 100644
--- a/src/NeuralNetworks/Layers/QuantumLayer.cs
+++ b/src/NeuralNetworks/Layers/QuantumLayer.cs
@@ -78,6 +78,7 @@ public partial class QuantumLayer<T> : LayerBase<T>, IShapeContract
     /// <summary>Construction state, retained so the layer can be rebuilt exactly rather than inferred from its shape.</summary>
     private readonly int _inputSize;
     private readonly int _numQubits;
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<Complex<T>> _quantumCircuit;
     [TrainableParameter(Role = PersistentTensorRole.Weights)]
 
@@ -102,13 +103,16 @@ public partial class QuantumLayer<T> : LayerBase<T>, IShapeContract
     /// </remarks>
     [TrainableParameter(Role = PersistentTensorRole.Weights)]
     private Tensor<T> _rotationAngles;
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _angleGradients;
 
     /// <summary>
     /// Cached result amplitudes from Forward for use in Backward.
     /// Shape: [batch, dimension] for real and imaginary parts.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastResultReal;
+    [Scratch]
     private Tensor<T>? _lastResultImag;
     private readonly INumericOperations<Complex<T>> _complexOps;
 
diff --git a/src/NeuralNetworks/Layers/RBFLayer.cs b/src/NeuralNetworks/Layers/RBFLayer.cs
index 79bd5dc82a..187f227254 100644
--- a/src/NeuralNetworks/Layers/RBFLayer.cs
+++ b/src/NeuralNetworks/Layers/RBFLayer.cs
@@ -37,7 +37,7 @@ namespace AiDotNet.NeuralNetworks.Layers;
 /// <typeparam name="T">The numeric type used for calculations, typically float or double.</typeparam>
 [LayerCategory(LayerCategory.Dense)]
 [LayerTask(LayerTask.FeatureExtraction)]
-[LayerProperty(IsTrainable = true, ChangesShape = true)]
+[LayerProperty(IsTrainable = true, ChangesShape = true, TestConstructorArgs = "4", TestInputShape = "1, 4")]
 // Ranks 1 and 2, which is exactly what ForwardTraced round-trips: an unbatched rank-1 input is reshaped
 // to [1, features] for the kernel and the batch axis is stripped again on the way out
 // ("wasUnbatched ? Engine.Reshape(output, [output.Shape[1]]) : output"). One declaration with
@@ -129,6 +129,7 @@ public partial class RBFLayer<T> : LayerBase<T>, IShapeContract
     /// batch of input vectors that were processed in the most recent forward pass. The tensor
     /// is null before the first forward pass or after a reset.
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _lastInput;
 
     /// <summary>
@@ -139,6 +140,7 @@ public partial class RBFLayer<T> : LayerBase<T>, IShapeContract
     /// It holds the batch of output vectors that were produced in the most recent forward pass.
     /// The tensor is null before the first forward pass or after a reset.
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _lastOutput;
 
     /// <summary>
@@ -149,6 +151,7 @@ public partial class RBFLayer<T> : LayerBase<T>, IShapeContract
     /// It has the same shape as the _centers tensor and is used to update the centers during
     /// the parameter update step. The tensor is null before the first backward pass or after a reset.
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _centersGradient;
 
     /// <summary>
@@ -159,6 +162,7 @@ public partial class RBFLayer<T> : LayerBase<T>, IShapeContract
     /// It has the same shape as the _widths tensor and is used to update the widths during
     /// the parameter update step. The tensor is null before the first backward pass or after a reset.
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _widthsGradient;
 
     /// <summary>
diff --git a/src/NeuralNetworks/Layers/RBMLayer.cs b/src/NeuralNetworks/Layers/RBMLayer.cs
index 7dd1620a8f..0f40e09b9e 100644
--- a/src/NeuralNetworks/Layers/RBMLayer.cs
+++ b/src/NeuralNetworks/Layers/RBMLayer.cs
@@ -221,16 +221,19 @@ public partial class RBMLayer<T> : LayerBase<T>, IShapeContract
     /// <summary>
     /// Gradient of the weights computed during backpropagation.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _weightsGradient;
 
     /// <summary>
     /// Gradient of the visible biases computed during backpropagation.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _visibleBiasesGradient;
 
     /// <summary>
     /// Gradient of the hidden biases computed during backpropagation.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _hiddenBiasesGradient;
 
     /// <summary>
@@ -251,6 +254,7 @@ public partial class RBMLayer<T> : LayerBase<T>, IShapeContract
     /// This storage helps the RBM adjust its weights to make better reconstructions of the input data.
     /// </para>
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _lastVisibleInput;
 
     /// <summary>
@@ -277,6 +281,7 @@ public partial class RBMLayer<T> : LayerBase<T>, IShapeContract
     /// versus which ones it incorrectly generates on its own.
     /// </para>
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _lastHiddenOutput;
 
     /// <summary>
@@ -298,6 +303,7 @@ public partial class RBMLayer<T> : LayerBase<T>, IShapeContract
     /// how the RBM updates its weights to improve future reconstructions.
     /// </para>
     /// </remarks>
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T>? _reconstructedVisible;
 
     /// <summary>
@@ -319,6 +325,7 @@ public partial class RBMLayer<T> : LayerBase<T>, IShapeContract
     /// the RBM learn to distinguish real patterns from ones it incorrectly imagines.
     /// </para>
     /// </remarks>
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T>? _reconstructedHidden;
 
     /// <summary>
diff --git a/src/NeuralNetworks/Layers/RMSNormalizationLayer.cs b/src/NeuralNetworks/Layers/RMSNormalizationLayer.cs
index e3ca0e70cd..9f641c7fa5 100644
--- a/src/NeuralNetworks/Layers/RMSNormalizationLayer.cs
+++ b/src/NeuralNetworks/Layers/RMSNormalizationLayer.cs
@@ -100,6 +100,9 @@ public RMSNormalizationLayer(double epsilon = 1e-6)
         _gamma = new Tensor<T>([0]);
     }
 
+    /// <summary>Construction state: the 'featureSize' the layer was built with.</summary>
+    private readonly int _featureSize;
+
     /// <summary>
     /// AiDotNet#1370 eager-init constructor. Pass <paramref name="featureSize"/> at
     /// construction to allocate γ immediately and resolve the layer's input + output
@@ -116,9 +119,12 @@ public RMSNormalizationLayer(double epsilon = 1e-6)
     /// via the default implementation — no override needed.
     /// </remarks>
     /// <exception cref="ArgumentOutOfRangeException">When <paramref name="featureSize"/> is not positive.</exception>
-    public RMSNormalizationLayer(int featureSize, double epsilon = 1e-6)
+    public RMSNormalizationLayer(
+        [LayerState(OmitWhenNonPositive = true)] int featureSize,
+        double epsilon = 1e-6)
         : base(new[] { featureSize }, new[] { featureSize })
     {
+        _featureSize = featureSize;
         if (featureSize <= 0)
             throw new ArgumentOutOfRangeException(nameof(featureSize),
                 $"featureSize must be positive, got {featureSize}.");
diff --git a/src/NeuralNetworks/Layers/RRDBLayer.cs b/src/NeuralNetworks/Layers/RRDBLayer.cs
index 39415474e8..006bcf4c9f 100644
--- a/src/NeuralNetworks/Layers/RRDBLayer.cs
+++ b/src/NeuralNetworks/Layers/RRDBLayer.cs
@@ -119,16 +119,19 @@ public partial class RRDBLayer<T> : LayerBase<T>, IShapeContract
     /// <summary>
     /// Cached input for backpropagation.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastInput;
 
     /// <summary>
     /// Cached output from RDB3 for backpropagation.
     /// </summary>
+    [AiDotNet.Attributes.Scratch]
     private Tensor<T>? _rdb3Output;
 
     /// <summary>
     /// GPU cached input tensor for backward pass.
     /// </summary>
+    [ExternalState]
     private Tensor<T>? _gpuLastInput;
 
     #endregion
@@ -406,6 +409,7 @@ public override void ClearGradients()
             rdb.ClearGradients();
     }
 
+    [Scratch]
     private Vector<T>? _pendingParameters;
 
     /// <inheritdoc />
diff --git a/src/NeuralNetworks/Layers/RRDBNetGenerator.cs b/src/NeuralNetworks/Layers/RRDBNetGenerator.cs
index 5eb790cfa5..97ce288cc3 100644
--- a/src/NeuralNetworks/Layers/RRDBNetGenerator.cs
+++ b/src/NeuralNetworks/Layers/RRDBNetGenerator.cs
@@ -69,6 +69,11 @@ namespace AiDotNet.NeuralNetworks.Layers;
 [TensorLayout(TensorAxis.Batch, TensorAxis.Channels, TensorAxis.Height, TensorAxis.Width,
     BatchOptional = true, Direction = TensorLayoutDirection.Output)]
 [AutoParameters]
+// See the note on ObliviousDecisionTreeLayer. The declared arguments are a deliberately small
+// configuration -- one RRDB block at 8 features, x2 scale -- because the defaults describe the
+// paper model (23 blocks, 64 features) and constructing that per test is minutes of work.
+[LayerProperty(IsTrainable = true, ChangesShape = true, ExpectedInputRank = 3,
+    TestInputShape = "3, 8, 8", TestConstructorArgs = "3, 3, 8, 4, 1, 2")]
 public partial class RRDBNetGenerator<T> : LayerBase<T>, IShapeContract
 {
     /// <inheritdoc />
@@ -155,6 +160,10 @@ public partial class RRDBNetGenerator<T> : LayerBase<T>, IShapeContract
     /// <summary>
     /// LeakyReLU activation with negative slope 0.2.
     /// </summary>
+    /// <summary>Negative slope of the generator's LeakyReLU, per Real-ESRGAN (Wang et al. 2021).</summary>
+    /// <remarks>Shared by the activation instance and the traced forward so the two cannot drift.</remarks>
+    private const double LeakyReLUSlope = 0.2;
+
     private readonly LeakyReLUActivation<T> _leakyReLU;
 
     /// <summary>
@@ -176,15 +185,19 @@ public partial class RRDBNetGenerator<T> : LayerBase<T>, IShapeContract
     /// Upscaling factor (2 or 4).
     /// </summary>
     private readonly int _scale;
+    private readonly int _growthChannels;
+    private readonly double _residualScale;
 
     /// <summary>
     /// Cached input for backpropagation.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastInput;
 
     /// <summary>
     /// Cached conv1 output for trunk residual.
     /// </summary>
+    [AiDotNet.Attributes.Scratch]
     private Tensor<T>? _conv1Output;
 
     /// <summary>
@@ -280,7 +293,9 @@ public RRDBNetGenerator(
         _scale = scale;
         _inputChannels = inputChannels;
         _outputChannels = outputChannels;
-        _leakyReLU = new LeakyReLUActivation<T>(0.2);
+        _growthChannels = growthChannels;
+        _residualScale = residualScale;
+        _leakyReLU = new LeakyReLUActivation<T>(LeakyReLUSlope);
 
         // Initial convolution: inputChannels → numFeatures
         _convFirst = new ConvolutionalLayer<T>(
@@ -487,12 +502,17 @@ protected override Tensor<T> ForwardTraced(Tensor<T> input)
     /// </summary>
     private Tensor<T> ApplyLeakyReLU(Tensor<T> input)
     {
-        var output = TensorAllocator.Rent<T>(input._shape);
-        for (int i = 0; i < input.Length; i++)
-        {
-            output.Data.Span[i] = _leakyReLU.Activate(input.Data.Span[i]);
-        }
-        return output;
+        // max(x, slope*x) IS LeakyReLU for any slope in (0, 1): above zero the identity wins, below
+        // it the shallower line does. Both operations are tape-tracked, so the input stays connected
+        // to the reverse-mode graph.
+        //
+        // The previous form filled a rented buffer in a manual element loop, which records no tape
+        // node at all. This runs three times in ForwardTraced -- twice in the upsampling stack and
+        // once after the HR convolution -- so the generator's entire input gradient was severed
+        // while its PARAMETER gradients still looked healthy, which is exactly the asymmetry the
+        // conformance test calls out: a missing input VJP must not pass parameter-only checks.
+        var scaled = Engine.TensorMultiplyScalar(input, NumOps.FromDouble(LeakyReLUSlope));
+        return Engine.TensorMax(input, scaled);
     }
 
     /// <summary>
@@ -548,6 +568,7 @@ public override void UpdateParameters(T learningRate)
     /// in OnFirstForward once every sub-layer reports a real
     /// GetParameters().Length.
     /// </summary>
+    [Scratch]
     private Vector<T>? _pendingParameters;
 
     private void ApplyParameters(Vector<T> parameters)
diff --git a/src/NeuralNetworks/Layers/ReadoutLayer.cs b/src/NeuralNetworks/Layers/ReadoutLayer.cs
index 33d4f455ff..ede02cdfa4 100644
--- a/src/NeuralNetworks/Layers/ReadoutLayer.cs
+++ b/src/NeuralNetworks/Layers/ReadoutLayer.cs
@@ -37,7 +37,7 @@ namespace AiDotNet.NeuralNetworks.Layers;
 [LayerCategory(LayerCategory.Graph)]
 [LayerTask(LayerTask.GraphProcessing)]
 [LayerTask(LayerTask.Projection)]
-[LayerProperty(IsTrainable = true, ChangesShape = true)]
+[LayerProperty(IsTrainable = true, ChangesShape = true, TestConstructorArgs = "4, 3, (AiDotNet.Interfaces.IActivationFunction<double>)new AiDotNet.ActivationFunctions.IdentityActivation<double>()", TestInputShape = "1, 4")]
 // Ranks 1 and 2, the two forms ForwardTraced round-trips: a rank-1 input is reshaped to [1, inputSize]
 // and returned as [OutputShape[0]], and a rank-2 input passes straight through the matmul. Higher ranks
 // are flattened into a batch and restored from _originalInputShape, but a readout head has nothing to say
@@ -114,6 +114,7 @@ public partial class ReadoutLayer<T> : LayerBase<T>, IShapeContract
     /// gradients for all weight parameters during the backward pass. These gradients are used
     /// to update the weights during the parameter update step.
     /// </remarks>
+    [AiDotNet.Attributes.Scratch]
     private Tensor<T> _weightGradients;
 
     /// <summary>
@@ -124,6 +125,7 @@ public partial class ReadoutLayer<T> : LayerBase<T>, IShapeContract
     /// gradients for all bias parameters during the backward pass. These gradients are used
     /// to update the biases during the parameter update step.
     /// </remarks>
+    [AiDotNet.Attributes.Scratch]
     private Tensor<T> _biasGradients;
 
     /// <summary>
@@ -134,23 +136,29 @@ public partial class ReadoutLayer<T> : LayerBase<T>, IShapeContract
     /// input tensor that was processed in the most recent forward pass. The tensor is null
     /// before the first forward pass or after a reset.
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _lastInput;
 
     /// <summary>
     /// Stores the output tensor (post-activation) from the most recent forward pass for use in backpropagation.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastOutput;
 
     /// <summary>
     /// Stores the pre-activation output tensor from the most recent forward pass.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastPreActivation;
 
     private int[] _originalInputShape = [];
 
     // GPU cached tensors for backward pass
+    [ExternalState]
     private Tensor<T>? _gpuInput;
+    [ExternalState]
     private Tensor<T>? _gpuPreActivation;
+    [ExternalState]
     private Tensor<T>? _gpuOutput;
     private int _gpuBatchDim;
     private int _gpuInputSize;
@@ -163,6 +171,12 @@ public partial class ReadoutLayer<T> : LayerBase<T>, IShapeContract
     /// </summary>
     protected override bool SupportsGpuExecution => true;
 
+    /// <summary>Construction state: the 'inputSize' the layer was built with.</summary>
+    private readonly int _inputSize;
+
+    /// <summary>Construction state: the 'outputSize' the layer was built with.</summary>
+    private readonly int _outputSize;
+
     /// <summary>
     /// Initializes a new instance of the <see cref="ReadoutLayer{T}"/> class with a scalar activation function.
     /// </summary>
@@ -193,6 +207,8 @@ public ReadoutLayer(int inputSize, int outputSize, IActivationFunction<T> scalar
         IInitializationStrategy<T>? initializationStrategy = null)
         : base([inputSize], [outputSize], scalarActivation)
     {
+        _outputSize = outputSize;
+        _inputSize = inputSize;
         InitializationStrategy = initializationStrategy ?? InitializationStrategies<T>.Eager;
 
         _weights = new Tensor<T>([outputSize, inputSize]);
@@ -238,6 +254,8 @@ public ReadoutLayer(int inputSize, int outputSize, IVectorActivationFunction<T>
         IInitializationStrategy<T>? initializationStrategy = null)
         : base([inputSize], [outputSize], vectorActivation)
     {
+        _outputSize = outputSize;
+        _inputSize = inputSize;
         InitializationStrategy = initializationStrategy ?? InitializationStrategies<T>.Eager;
 
         _weights = new Tensor<T>([outputSize, inputSize]);
diff --git a/src/NeuralNetworks/Layers/ReconstructionLayer.cs b/src/NeuralNetworks/Layers/ReconstructionLayer.cs
index c61e3afb24..57472b8160 100644
--- a/src/NeuralNetworks/Layers/ReconstructionLayer.cs
+++ b/src/NeuralNetworks/Layers/ReconstructionLayer.cs
@@ -109,6 +109,7 @@ public partial class ReconstructionLayer<T> : LayerBase<T>, IShapeContract
     /// </remarks>
     private int _hidden1Dim;
     private int _hidden2Dim;
+    [SubLayerInput("_inputDimension")]
     private readonly FullyConnectedLayer<T> _fc1;
 
     /// <summary>
@@ -118,6 +119,7 @@ public partial class ReconstructionLayer<T> : LayerBase<T>, IShapeContract
     /// This layer takes the output from the first layer and transforms it to the second hidden dimension.
     /// It also applies the hidden activation function to its output.
     /// </remarks>
+    [SubLayerInput("_hidden1Dimension")]
     private readonly FullyConnectedLayer<T> _fc2;
 
     /// <summary>
@@ -127,6 +129,7 @@ public partial class ReconstructionLayer<T> : LayerBase<T>, IShapeContract
     /// This layer takes the output from the second layer and transforms it to the final output dimension.
     /// It applies the output activation function, which is often sigmoid for reconstruction tasks.
     /// </remarks>
+    [SubLayerInput("_hidden2Dimension")]
     private readonly FullyConnectedLayer<T> _fc3;
 
     /// <summary>
@@ -488,79 +491,6 @@ public override void UpdateParameters(T learningRate)
         _fc3.UpdateParameters(learningRate);
     }
 
-    /// <summary>
-    /// Serializes the reconstruction layer to a binary writer.
-    /// </summary>
-    /// <param name="writer">The binary writer to serialize to.</param>
-    /// <remarks>
-    /// <para>
-    /// This method serializes the state of the reconstruction layer to a binary writer. It writes the
-    /// vector activation flag and then serializes each of the three fully connected layers in sequence.
-    /// Hidden dimensions are implicitly captured by the FC layers' own serialization (each stores its
-    /// input/output sizes). GetMetadata() separately exports Hidden1Dimension and Hidden2Dimension
-    /// for the deserialization constructor registered in DeserializationHelper.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method saves the layer's state so it can be loaded later.
-    /// 
-    /// When serializing:
-    /// - First, it saves whether vector activation is used or not
-    /// - Then, it asks each of the three internal layers to save their states
-    /// - The result is a complete snapshot of the layer that can be restored
-    /// 
-    /// This is useful for:
-    /// - Saving a trained model to disk
-    /// - Pausing training and continuing later
-    /// - Sharing a trained model with others
-    /// 
-    /// Think of it like taking a detailed photograph of the layer's current state
-    /// that can be used to recreate it exactly.
-    /// </para>
-    /// </remarks>
-    public override void Serialize(BinaryWriter writer)
-    {
-        writer.Write(_useVectorActivation);
-        writer.Write(_hidden1Dim);
-        writer.Write(_hidden2Dim);
-        _fc1.Serialize(writer);
-        _fc2.Serialize(writer);
-        _fc3.Serialize(writer);
-    }
-
-    /// <summary>
-    /// Deserializes the reconstruction layer from a binary reader.
-    /// </summary>
-    /// <param name="reader">The binary reader to deserialize from.</param>
-    /// <remarks>
-    /// <para>
-    /// This method deserializes the state of the reconstruction layer from a binary reader. It reads the
-    /// vector activation flag and then deserializes each of the three fully connected layers in sequence.
-    /// This is useful for loading the layer's state from disk or receiving it over a network.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method loads a previously saved layer state.
-    /// 
-    /// When deserializing:
-    /// - First, it loads whether vector activation is used or not
-    /// - Then, it asks each of the three internal layers to load their states
-    /// - The result is a complete restoration of a previously saved layer
-    /// 
-    /// This is useful for:
-    /// - Loading a trained model from disk
-    /// - Continuing training from where you left off
-    /// - Using a model that someone else trained
-    /// 
-    /// Think of it like reconstructing the exact state of the layer from a detailed blueprint.
-    /// </para>
-    /// </remarks>
-    public override void Deserialize(BinaryReader reader)
-    {
-        _useVectorActivation = reader.ReadBoolean();
-        _hidden1Dim = reader.ReadInt32();
-        _hidden2Dim = reader.ReadInt32();
-        _fc1.Deserialize(reader);
-        _fc2.Deserialize(reader);
-        _fc3.Deserialize(reader);
-    }
-
     /// <summary>
     /// Sets the trainable parameters of the reconstruction layer.
     /// </summary>
diff --git a/src/NeuralNetworks/Layers/RecurrentLayer.cs b/src/NeuralNetworks/Layers/RecurrentLayer.cs
index f30d378f27..eb25f37601 100644
--- a/src/NeuralNetworks/Layers/RecurrentLayer.cs
+++ b/src/NeuralNetworks/Layers/RecurrentLayer.cs
@@ -167,6 +167,7 @@ public partial class RecurrentLayer<T> : LayerBase<T>, IShapeContract
     /// sequence of input vectors that were processed in the most recent forward pass. The tensor
     /// is null before the first forward pass or after a reset.
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _lastInput;
 
     /// <summary>
@@ -182,6 +183,7 @@ public partial class RecurrentLayer<T> : LayerBase<T>, IShapeContract
     /// It holds the sequence of output vectors that were produced in the most recent forward pass.
     /// The tensor is null before the first forward pass or after a reset.
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _lastOutput;
 
     /// <summary>
@@ -192,6 +194,7 @@ public partial class RecurrentLayer<T> : LayerBase<T>, IShapeContract
     /// It has the same dimensions as the _inputWeights tensor and is used to update the input weights during
     /// the parameter update step. The tensor is null before the first backward pass or after a reset.
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _inputWeightsGradient;
 
     /// <summary>
@@ -202,6 +205,7 @@ public partial class RecurrentLayer<T> : LayerBase<T>, IShapeContract
     /// It has the same dimensions as the _hiddenWeights tensor and is used to update the hidden weights during
     /// the parameter update step. The tensor is null before the first backward pass or after a reset.
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _hiddenWeightsGradient;
 
     /// <summary>
@@ -212,6 +216,7 @@ public partial class RecurrentLayer<T> : LayerBase<T>, IShapeContract
     /// It has the same length as the _biases tensor and is used to update the biases during
     /// the parameter update step. The tensor is null before the first backward pass or after a reset.
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _biasesGradient;
 
     /// <summary>
@@ -686,37 +691,57 @@ private Tensor<T> BroadcastBiases(Tensor<T> biases, int batchSize)
     }
 
 
+    [AiDotNet.Attributes.Buffer]
     private Tensor<T>? _inputWeightsVelocity;
+    [AiDotNet.Attributes.Buffer]
     private Tensor<T>? _hiddenWeightsVelocity;
+    [AiDotNet.Attributes.Buffer]
     private Tensor<T>? _biasesVelocity;
 
     #region GPU Training Fields
+    [ExternalState]
     private Tensor<T>? _gpuLastInput;
+    [ExternalState]
     private Tensor<T>? _gpuLastOutput;
 
     // GPU weight buffers
+    [ExternalState]
     private Tensor<T>? _gpuInputWeights;
+    [ExternalState]
     private Tensor<T>? _gpuHiddenWeights;
+    [ExternalState]
     private Tensor<T>? _gpuBiases;
 
     // GPU gradient buffers
+    [ExternalState]
     private Tensor<T>? _gpuInputWeightsGradient;
+    [ExternalState]
     private Tensor<T>? _gpuHiddenWeightsGradient;
+    [ExternalState]
     private Tensor<T>? _gpuBiasesGradient;
 
     // GPU velocity buffers (SGD momentum)
+    [ExternalState]
     private Tensor<T>? _gpuInputWeightsVelocity;
+    [ExternalState]
     private Tensor<T>? _gpuHiddenWeightsVelocity;
+    [ExternalState]
     private Tensor<T>? _gpuBiasesVelocity;
 
     // GPU Adam first moment buffers
+    [ExternalState]
     private Tensor<T>? _gpuInputWeightsM;
+    [ExternalState]
     private Tensor<T>? _gpuHiddenWeightsM;
+    [ExternalState]
     private Tensor<T>? _gpuBiasesM;
 
     // GPU Adam second moment buffers
+    [ExternalState]
     private Tensor<T>? _gpuInputWeightsV;
+    [ExternalState]
     private Tensor<T>? _gpuHiddenWeightsV;
+    [ExternalState]
     private Tensor<T>? _gpuBiasesV;
     #endregion
 
diff --git a/src/NeuralNetworks/Layers/RepParameterizationLayer.cs b/src/NeuralNetworks/Layers/RepParameterizationLayer.cs
index a8886c4208..cea06d883d 100644
--- a/src/NeuralNetworks/Layers/RepParameterizationLayer.cs
+++ b/src/NeuralNetworks/Layers/RepParameterizationLayer.cs
@@ -61,6 +61,7 @@ public partial class RepParameterizationLayer<T> : LayerBase<T>, IShapeContract
     /// It represents the center of the distribution from which samples are drawn. The tensor is null
     /// before the first forward pass or after a reset.
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _lastMean;
 
     /// <summary>
@@ -71,6 +72,7 @@ public partial class RepParameterizationLayer<T> : LayerBase<T>, IShapeContract
     /// Log variance is used instead of variance for numerical stability. It represents the spread of the
     /// distribution from which samples are drawn. The tensor is null before the first forward pass or after a reset.
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _lastLogVar;
 
     /// <summary>
@@ -82,6 +84,7 @@ public partial class RepParameterizationLayer<T> : LayerBase<T>, IShapeContract
     /// distribution. Saving these values is necessary for the backward pass. The tensor is null
     /// before the first forward pass or after a reset.
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _lastEpsilon;
 
     /// <summary>
@@ -120,9 +123,13 @@ public partial class RepParameterizationLayer<T> : LayerBase<T>, IShapeContract
     private int[]? _originalInputShape;
 
     // GPU cached tensors for backward pass
+    [ExternalState]
     private Tensor<T>? _gpuMean;
+    [ExternalState]
     private Tensor<T>? _gpuLogVar;
+    [ExternalState]
     private Tensor<T>? _gpuEpsilon;
+    [ExternalState]
     private Tensor<T>? _gpuStdDev;
     private int _gpuBatchSize;
     private int _gpuLatentSize;
diff --git a/src/NeuralNetworks/Layers/ReshapeLayer.cs b/src/NeuralNetworks/Layers/ReshapeLayer.cs
index d091d15ece..2c9ea1013f 100644
--- a/src/NeuralNetworks/Layers/ReshapeLayer.cs
+++ b/src/NeuralNetworks/Layers/ReshapeLayer.cs
@@ -156,6 +156,7 @@ public partial class ReshapeLayer<T> : LayerBase<T>, IBatchAwareShapeContract
     /// This cached input is needed during the backward pass to compute the appropriate gradients.
     /// The tensor is null before the first forward pass or after a reset.
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _lastInput;
 
     /// <summary>
diff --git a/src/NeuralNetworks/Layers/ResidualDenseBlock.cs b/src/NeuralNetworks/Layers/ResidualDenseBlock.cs
index ecc6e5439c..3fda4ea15c 100644
--- a/src/NeuralNetworks/Layers/ResidualDenseBlock.cs
+++ b/src/NeuralNetworks/Layers/ResidualDenseBlock.cs
@@ -138,6 +138,7 @@ public partial class ResidualDenseBlock<T> : LayerBase<T>, IShapeContract
     /// <summary>
     /// Cached input for backpropagation.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastInput;
 
     /// <summary>
@@ -156,19 +157,33 @@ public partial class ResidualDenseBlock<T> : LayerBase<T>, IShapeContract
     private Tensor<T>[]? _concatInputs;
 
     // GPU cached tensors for backward pass
+    [ExternalState]
     private Tensor<T>? _gpuInput;
+    [ExternalState]
     private Tensor<T>? _gpuConv1Out;
+    [ExternalState]
     private Tensor<T>? _gpuX1Activated;
+    [ExternalState]
     private Tensor<T>? _gpuConcat1;
+    [ExternalState]
     private Tensor<T>? _gpuConv2Out;
+    [ExternalState]
     private Tensor<T>? _gpuX2Activated;
+    [ExternalState]
     private Tensor<T>? _gpuConcat2;
+    [ExternalState]
     private Tensor<T>? _gpuConv3Out;
+    [ExternalState]
     private Tensor<T>? _gpuX3Activated;
+    [ExternalState]
     private Tensor<T>? _gpuConcat3;
+    [ExternalState]
     private Tensor<T>? _gpuConv4Out;
+    [ExternalState]
     private Tensor<T>? _gpuX4Activated;
+    [ExternalState]
     private Tensor<T>? _gpuConcat4;
+    [ExternalState]
     private Tensor<T>? _gpuConv5Out;
     private int _gpuBatch;
     private int _gpuHeight;
@@ -815,6 +830,7 @@ public override void ClearGradients()
             conv.ClearGradients();
     }
 
+    [Scratch]
     private Vector<T>? _pendingParameters;
 
     /// <inheritdoc />
diff --git a/src/NeuralNetworks/Layers/ResidualLayer.cs b/src/NeuralNetworks/Layers/ResidualLayer.cs
index bde073e553..1209c42107 100644
--- a/src/NeuralNetworks/Layers/ResidualLayer.cs
+++ b/src/NeuralNetworks/Layers/ResidualLayer.cs
@@ -80,6 +80,7 @@ public partial class ResidualLayer<T> : LayerBase<T>, IShapeContract
     /// or when you explicitly reset the layer.
     /// </para>
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _lastInput;
 
     /// <summary>
@@ -91,6 +92,7 @@ public partial class ResidualLayer<T> : LayerBase<T>, IShapeContract
     /// to avoid recomputing and potentially corrupting the inner layer's state. It is cleared when ResetState() is called.
     /// </para>
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _lastInnerOutput;
 
     /// <summary>
diff --git a/src/NeuralNetworks/Layers/SSM/ABCLayer.cs b/src/NeuralNetworks/Layers/SSM/ABCLayer.cs
index b1420fae7c..c56d034f39 100644
--- a/src/NeuralNetworks/Layers/SSM/ABCLayer.cs
+++ b/src/NeuralNetworks/Layers/SSM/ABCLayer.cs
@@ -132,27 +132,45 @@ public partial class ABCLayer<T> : LayerBase<T>, IShapeContract
     private Tensor<T> _outputProjectionBias;
 
     // Cached forward pass values
+    [Scratch]
     private Tensor<T>? _lastInput;
+    [Scratch]
     private Tensor<T>? _lastOutput;
+    [Scratch]
     private Tensor<T>? _lastQuery;
+    [Scratch]
     private Tensor<T>? _lastKey;
+    [Scratch]
     private Tensor<T>? _lastValue;
+    [Scratch]
     private Tensor<T>? _lastForgetGate;
     private Tensor<T>? _lastOutputGate;
+    [Scratch]
     private Tensor<T>? _lastOutputGateRaw;
+    [Scratch]
     private Tensor<T>? _lastSlotReadOutput;
     private int[]? _originalInputShape;
 
     // Gradients
+    [Scratch]
     private Tensor<T>? _queryWeightsGradient;
+    [Scratch]
     private Tensor<T>? _keyWeightsGradient;
+    [Scratch]
     private Tensor<T>? _valueWeightsGradient;
+    [Scratch]
     private Tensor<T>? _slotKeysGradient;
+    [Scratch]
     private Tensor<T>? _forgetGateWeightsGradient;
+    [Scratch]
     private Tensor<T>? _forgetGateBiasGradient;
+    [Scratch]
     private Tensor<T>? _outputGateWeightsGradient;
+    [Scratch]
     private Tensor<T>? _outputGateBiasGradient;
+    [Scratch]
     private Tensor<T>? _outputProjectionWeightsGradient;
+    [Scratch]
     private Tensor<T>? _outputProjectionBiasGradient;
 
     /// <inheritdoc />
@@ -207,6 +225,9 @@ public partial class ABCLayer<T> : LayerBase<T>, IShapeContract
     /// </summary>
     public int HeadDimension => _headDimension;
 
+    /// <summary>Construction state: the 'sequenceLength' the layer was built with.</summary>
+    private readonly int _sequenceLength;
+
     /// <summary>
     /// Creates a new ABC (Attention with Bounded-memory Control) layer.
     /// </summary>
@@ -242,6 +263,7 @@ public ABCLayer(
             [sequenceLength, modelDimension],
             activationFunction ?? new IdentityActivation<T>())
     {
+        _sequenceLength = sequenceLength;
         InitializationStrategy = initializationStrategy ?? InitializationStrategies<T>.Eager;
         if (sequenceLength <= 0)
             throw new ArgumentException($"Sequence length ({sequenceLength}) must be positive.", nameof(sequenceLength));
diff --git a/src/NeuralNetworks/Layers/SSM/BASEDLayer.cs b/src/NeuralNetworks/Layers/SSM/BASEDLayer.cs
index f595474529..3d5074bd32 100644
--- a/src/NeuralNetworks/Layers/SSM/BASEDLayer.cs
+++ b/src/NeuralNetworks/Layers/SSM/BASEDLayer.cs
@@ -130,35 +130,62 @@ public partial class BASEDLayer<T> : LayerBase<T>, IShapeContract
     private Tensor<T> _outputProjectionBias;
 
     // Cached forward pass values
+    [Scratch]
     private Tensor<T>? _lastInput;
+    [Scratch]
     private Tensor<T>? _lastOutput;
+    [Scratch]
     private Tensor<T>? _lastLinearQuery;
+    [Scratch]
     private Tensor<T>? _lastLinearKey;
+    [Scratch]
     private Tensor<T>? _lastLinearValue;
+    [Scratch]
     private Tensor<T>? _lastWindowQuery;
+    [Scratch]
     private Tensor<T>? _lastWindowKey;
+    [Scratch]
     private Tensor<T>? _lastWindowValue;
+    [Scratch]
     private Tensor<T>? _lastLinearFeatureQ;
+    [Scratch]
     private Tensor<T>? _lastLinearFeatureK;
+    [Scratch]
     private Tensor<T>? _lastLinearOutput;
+    [Scratch]
     private Tensor<T>? _lastWindowOutput;
+    [Scratch]
     private Tensor<T>? _lastMixingAlpha;
+    [Scratch]
     private Tensor<T>? _lastMixingAlphaRaw;
+    [Scratch]
     private Tensor<T>? _lastCombinedOutput;
+    [Scratch]
     private Tensor<T>? _lastWindowScores;
     private int[]? _originalInputShape;
 
     // Gradients
+    [Scratch]
     private Tensor<T>? _linearQueryWeightsGradient;
+    [Scratch]
     private Tensor<T>? _linearKeyWeightsGradient;
+    [Scratch]
     private Tensor<T>? _linearValueWeightsGradient;
+    [Scratch]
     private Tensor<T>? _windowQueryWeightsGradient;
+    [Scratch]
     private Tensor<T>? _windowKeyWeightsGradient;
+    [Scratch]
     private Tensor<T>? _windowValueWeightsGradient;
+    [Scratch]
     private Tensor<T>? _featureMapScaleGradient;
+    [Scratch]
     private Tensor<T>? _mixingGateWeightsGradient;
+    [Scratch]
     private Tensor<T>? _mixingGateBiasGradient;
+    [Scratch]
     private Tensor<T>? _outputProjectionWeightsGradient;
+    [Scratch]
     private Tensor<T>? _outputProjectionBiasGradient;
 
     /// <inheritdoc />
@@ -189,6 +216,9 @@ public partial class BASEDLayer<T> : LayerBase<T>, IShapeContract
     /// </summary>
     public int FeatureExpansion => _featureExpansion;
 
+    /// <summary>Construction state: the 'sequenceLength' the layer was built with.</summary>
+    private readonly int _sequenceLength;
+
     /// <summary>
     /// Creates a new BASED layer that combines linear attention with sliding window attention.
     /// </summary>
@@ -231,6 +261,7 @@ public BASEDLayer(
             [sequenceLength, modelDimension],
             activationFunction ?? new IdentityActivation<T>())
     {
+        _sequenceLength = sequenceLength;
         InitializationStrategy = initializationStrategy ?? InitializationStrategies<T>.Eager;
 
         if (sequenceLength <= 0)
diff --git a/src/NeuralNetworks/Layers/SSM/DeltaFormerLayer.cs b/src/NeuralNetworks/Layers/SSM/DeltaFormerLayer.cs
index 579cb668ea..96afcca2b5 100644
--- a/src/NeuralNetworks/Layers/SSM/DeltaFormerLayer.cs
+++ b/src/NeuralNetworks/Layers/SSM/DeltaFormerLayer.cs
@@ -105,25 +105,42 @@ public partial class DeltaFormerLayer<T> : LayerBase<T>, IShapeContract
     private Tensor<T> _outputProjectionBias;
 
     // Cached values for backward pass
+    [Scratch]
     private Tensor<T>? _lastInput;
+    [Scratch]
     private Tensor<T>? _lastOutput;
+    [Scratch]
     private Tensor<T>? _lastQuery;
+    [Scratch]
     private Tensor<T>? _lastKey;
+    [Scratch]
     private Tensor<T>? _lastValue;
+    [Scratch]
     private Tensor<T>? _lastGate;
+    [Scratch]
     private Tensor<T>? _lastGateRaw;
+    [Scratch]
     private Tensor<T>? _lastAttentionWeights;
+    [Scratch]
     private Tensor<T>? _lastStates;
+    [Scratch]
     private Tensor<T>? _lastMechanismOutput;
     private int[]? _originalInputShape;
 
     // Gradients
+    [Scratch]
     private Tensor<T>? _queryWeightsGradient;
+    [Scratch]
     private Tensor<T>? _keyWeightsGradient;
+    [Scratch]
     private Tensor<T>? _valueWeightsGradient;
+    [Scratch]
     private Tensor<T>? _outputGateWeightsGradient;
+    [Scratch]
     private Tensor<T>? _outputGateBiasGradient;
+    [Scratch]
     private Tensor<T>? _outputProjectionWeightsGradient;
+    [Scratch]
     private Tensor<T>? _outputProjectionBiasGradient;
 
     /// <inheritdoc />
@@ -141,6 +158,9 @@ public partial class DeltaFormerLayer<T> : LayerBase<T>, IShapeContract
     /// <summary>Gets whether this layer uses the delta rule (true) or standard attention (false).</summary>
     public bool UseDeltaRule => _useDeltaRule;
 
+    /// <summary>Construction state: the 'sequenceLength' the layer was built with.</summary>
+    private readonly int _sequenceLength;
+
     /// <summary>
     /// Creates a new DeltaFormer layer.
     /// </summary>
@@ -174,6 +194,7 @@ public DeltaFormerLayer(
             [sequenceLength, modelDimension],
             activationFunction ?? new IdentityActivation<T>())
     {
+        _sequenceLength = sequenceLength;
         InitializationStrategy = initializationStrategy ?? InitializationStrategies<T>.Eager;
 
         if (sequenceLength <= 0)
diff --git a/src/NeuralNetworks/Layers/SSM/DeltaNetLayer.cs b/src/NeuralNetworks/Layers/SSM/DeltaNetLayer.cs
index f718fc02e6..04e543711a 100644
--- a/src/NeuralNetworks/Layers/SSM/DeltaNetLayer.cs
+++ b/src/NeuralNetworks/Layers/SSM/DeltaNetLayer.cs
@@ -116,26 +116,44 @@ public partial class DeltaNetLayer<T> : LayerBase<T>, IShapeContract
     private Tensor<T> _outputProjectionBias;
 
     // Cached values for backward pass
+    [Scratch]
     private Tensor<T>? _lastInput;
+    [Scratch]
     private Tensor<T>? _lastOutput;
+    [Scratch]
     private Tensor<T>? _lastQuery;
+    [Scratch]
     private Tensor<T>? _lastKey;
+    [Scratch]
     private Tensor<T>? _lastValue;
+    [Scratch]
     private Tensor<T>? _lastBeta;
+    [Scratch]
     private Tensor<T>? _lastStates;
+    [Scratch]
     private Tensor<T>? _lastDeltaRuleOutput;
     private int[]? _originalInputShape;
 
     // Gradients
+    [Scratch]
     private Tensor<T>? _queryWeightsGradient;
+    [Scratch]
     private Tensor<T>? _queryBiasGradient;
+    [Scratch]
     private Tensor<T>? _keyWeightsGradient;
+    [Scratch]
     private Tensor<T>? _keyBiasGradient;
+    [Scratch]
     private Tensor<T>? _valueWeightsGradient;
+    [Scratch]
     private Tensor<T>? _valueBiasGradient;
+    [Scratch]
     private Tensor<T>? _betaWeightsGradient;
+    [Scratch]
     private Tensor<T>? _betaBiasGradient;
+    [Scratch]
     private Tensor<T>? _outputProjectionWeightsGradient;
+    [Scratch]
     private Tensor<T>? _outputProjectionBiasGradient;
 
     /// <inheritdoc />
@@ -156,6 +174,9 @@ public partial class DeltaNetLayer<T> : LayerBase<T>, IShapeContract
     /// </summary>
     public int HeadDimension => _headDimension;
 
+    /// <summary>Construction state: the 'sequenceLength' the layer was built with.</summary>
+    private readonly int _sequenceLength;
+
     /// <summary>
     /// Creates a new DeltaNet layer.
     /// </summary>
@@ -186,6 +207,7 @@ public DeltaNetLayer(
             [sequenceLength, modelDimension],
             activationFunction ?? new IdentityActivation<T>())
     {
+        _sequenceLength = sequenceLength;
         InitializationStrategy = initializationStrategy ?? InitializationStrategies<T>.Eager;
 
         if (sequenceLength <= 0)
diff --git a/src/NeuralNetworks/Layers/SSM/DeltaProductLayer.cs b/src/NeuralNetworks/Layers/SSM/DeltaProductLayer.cs
index 80552216eb..e92a358845 100644
--- a/src/NeuralNetworks/Layers/SSM/DeltaProductLayer.cs
+++ b/src/NeuralNetworks/Layers/SSM/DeltaProductLayer.cs
@@ -115,25 +115,42 @@ public partial class DeltaProductLayer<T> : LayerBase<T>, IShapeContract
     private Tensor<T> _outputProjectionBias;
 
     // Cached forward pass values
+    [Scratch]
     private Tensor<T>? _lastInput;
+    [Scratch]
     private Tensor<T>? _lastOutput;
+    [Scratch]
     private Tensor<T>? _lastQuery;
+    [Scratch]
     private Tensor<T>? _lastKey;
+    [Scratch]
     private Tensor<T>? _lastValue;
+    [Scratch]
     private Tensor<T>? _lastBeta;
+    [Scratch]
     private Tensor<T>? _lastHouseholderVecs;
+    [Scratch]
     private Tensor<T>? _lastStates;
+    [Scratch]
     private Tensor<T>? _lastRecurrenceOutput;
     private int[]? _originalInputShape;
 
     // Gradients
+    [Scratch]
     private Tensor<T>? _queryWeightsGradient;
+    [Scratch]
     private Tensor<T>? _keyWeightsGradient;
+    [Scratch]
     private Tensor<T>? _valueWeightsGradient;
+    [Scratch]
     private Tensor<T>? _betaWeightsGradient;
+    [Scratch]
     private Tensor<T>? _betaBiasGradient;
+    [Scratch]
     private Tensor<T>? _householderWeightsGradient;
+    [Scratch]
     private Tensor<T>? _outputProjectionWeightsGradient;
+    [Scratch]
     private Tensor<T>? _outputProjectionBiasGradient;
 
     /// <inheritdoc />
@@ -159,6 +176,9 @@ public partial class DeltaProductLayer<T> : LayerBase<T>, IShapeContract
     /// </summary>
     public int NumHouseholders => _numHouseholders;
 
+    /// <summary>Construction state: the 'sequenceLength' the layer was built with.</summary>
+    private readonly int _sequenceLength;
+
     /// <summary>
     /// Creates a new DeltaProduct layer.
     /// </summary>
@@ -191,6 +211,7 @@ public DeltaProductLayer(
             [sequenceLength, modelDimension],
             activationFunction ?? new IdentityActivation<T>())
     {
+        _sequenceLength = sequenceLength;
         InitializationStrategy = initializationStrategy ?? InitializationStrategies<T>.Eager;
 
         if (sequenceLength <= 0)
diff --git a/src/NeuralNetworks/Layers/SSM/ExtendedLSTMLayer.cs b/src/NeuralNetworks/Layers/SSM/ExtendedLSTMLayer.cs
index 4f701454e6..9216cd88c6 100644
--- a/src/NeuralNetworks/Layers/SSM/ExtendedLSTMLayer.cs
+++ b/src/NeuralNetworks/Layers/SSM/ExtendedLSTMLayer.cs
@@ -126,16 +126,27 @@ public partial class ExtendedLSTMLayer<T> : LayerBase<T>, IShapeContract
     private Tensor<T> _outputProjectionBias;
 
     // Cached values
+    [Scratch]
     private Tensor<T>? _lastInput;
+    [Scratch]
     private Tensor<T>? _lastOutput;
+    [Scratch]
     private Tensor<T>? _lastCellStates;
+    [Scratch]
     private Tensor<T>? _lastNormStates;
+    [Scratch]
     private Tensor<T>? _lastInputGates;
+    [Scratch]
     private Tensor<T>? _lastForgetGates;
+    [Scratch]
     private Tensor<T>? _lastOutputGates;
+    [Scratch]
     private Tensor<T>? _lastQ;
+    [Scratch]
     private Tensor<T>? _lastK;
+    [Scratch]
     private Tensor<T>? _lastV;
+    [Scratch]
     private Tensor<T>? _lastHiddenPreProj;
     private int[]? _originalInputShape;
 
@@ -149,20 +160,33 @@ public partial class ExtendedLSTMLayer<T> : LayerBase<T>, IShapeContract
     // ever updates. Standardization (mean 0, var 1) with fixed gamma/beta keeps
     // the layer output unit-scale without introducing extra trainable parameters
     // (which would change the serialized parameter layout).
+    [AiDotNet.Attributes.Scratch]
     private Tensor<T>? _outputNormGamma;
+    [AiDotNet.Attributes.Scratch]
     private Tensor<T>? _outputNormBeta;
 
     // Gradients
+    [Scratch]
     private Tensor<T>? _inputGateWeightsGradient;
+    [Scratch]
     private Tensor<T>? _inputGateBiasGradient;
+    [Scratch]
     private Tensor<T>? _forgetGateWeightsGradient;
+    [Scratch]
     private Tensor<T>? _forgetGateBiasGradient;
+    [Scratch]
     private Tensor<T>? _outputGateWeightsGradient;
+    [Scratch]
     private Tensor<T>? _outputGateBiasGradient;
+    [Scratch]
     private Tensor<T>? _queryWeightsGradient;
+    [Scratch]
     private Tensor<T>? _keyWeightsGradient;
+    [Scratch]
     private Tensor<T>? _valueWeightsGradient;
+    [Scratch]
     private Tensor<T>? _outputProjectionWeightsGradient;
+    [Scratch]
     private Tensor<T>? _outputProjectionBiasGradient;
 
     /// <inheritdoc />
@@ -183,6 +207,9 @@ public partial class ExtendedLSTMLayer<T> : LayerBase<T>, IShapeContract
     /// </summary>
     public int HeadDimension => _headDimension;
 
+    /// <summary>Construction state: the 'sequenceLength' the layer was built with.</summary>
+    private readonly int _sequenceLength;
+
     /// <summary>
     /// Creates a new Extended LSTM (xLSTM) layer using the mLSTM (matrix memory) variant.
     /// </summary>
@@ -208,6 +235,7 @@ public ExtendedLSTMLayer(
             [sequenceLength, modelDimension],
             activationFunction ?? new IdentityActivation<T>())
     {
+        _sequenceLength = sequenceLength;
         InitializationStrategy = initializationStrategy ?? InitializationStrategies<T>.Eager;
 
         if (modelDimension <= 0)
diff --git a/src/NeuralNetworks/Layers/SSM/GatedDeltaNetLayer.cs b/src/NeuralNetworks/Layers/SSM/GatedDeltaNetLayer.cs
index f0a4940600..bf69d4760e 100644
--- a/src/NeuralNetworks/Layers/SSM/GatedDeltaNetLayer.cs
+++ b/src/NeuralNetworks/Layers/SSM/GatedDeltaNetLayer.cs
@@ -129,33 +129,58 @@ public partial class GatedDeltaNetLayer<T> : LayerBase<T>, IShapeContract
     private Tensor<T> _outputProjectionBias;
 
     // Cached values
+    [Scratch]
     private Tensor<T>? _lastInput;
+    [Scratch]
     private Tensor<T>? _lastOutput;
+    [Scratch]
     private Tensor<T>? _lastConvOutput;
+    [Scratch]
     private Tensor<T>? _lastQuery;
+    [Scratch]
     private Tensor<T>? _lastKey;
+    [Scratch]
     private Tensor<T>? _lastValue;
+    [Scratch]
     private Tensor<T>? _lastBeta;
+    [Scratch]
     private Tensor<T>? _lastAlpha;
+    [Scratch]
     private Tensor<T>? _lastGate;
+    [Scratch]
     private Tensor<T>? _lastGateRaw;
+    [Scratch]
     private Tensor<T>? _lastSiluConv;
+    [Scratch]
     private Tensor<T>? _lastDeltaRuleOutput;
     private int[]? _originalInputShape;
 
     // Gradients
+    [Scratch]
     private Tensor<T>? _convWeightsGradient;
+    [Scratch]
     private Tensor<T>? _convBiasGradient;
+    [Scratch]
     private Tensor<T>? _queryWeightsGradient;
+    [Scratch]
     private Tensor<T>? _keyWeightsGradient;
+    [Scratch]
     private Tensor<T>? _valueWeightsGradient;
+    [Scratch]
     private Tensor<T>? _betaWeightsGradient;
+    [Scratch]
     private Tensor<T>? _betaBiasGradient;
+    [Scratch]
     private Tensor<T>? _alphaWeightsGradient;
+    [Scratch]
     private Tensor<T>? _alphaBiasGradient;
+    [Scratch]
     private Tensor<T>? _outputGateWeightsGradient;
+    [Scratch]
     private Tensor<T>? _outputGateBiasGradient;
+    [Scratch]
     private Tensor<T>? _outputProjectionWeightsGradient;
+    [Scratch]
     private Tensor<T>? _outputProjectionBiasGradient;
 
     /// <inheritdoc />
@@ -181,6 +206,9 @@ public partial class GatedDeltaNetLayer<T> : LayerBase<T>, IShapeContract
     /// </summary>
     public int ConvKernelSize => _convKernelSize;
 
+    /// <summary>Construction state: the 'sequenceLength' the layer was built with.</summary>
+    private readonly int _sequenceLength;
+
     /// <summary>
     /// Creates a new GatedDeltaNet layer.
     /// </summary>
@@ -212,6 +240,7 @@ public GatedDeltaNetLayer(
             [sequenceLength, modelDimension],
             activationFunction ?? new IdentityActivation<T>())
     {
+        _sequenceLength = sequenceLength;
         InitializationStrategy = initializationStrategy ?? InitializationStrategies<T>.Eager;
 
         if (sequenceLength <= 0)
diff --git a/src/NeuralNetworks/Layers/SSM/GatedDeltaProductLayer.cs b/src/NeuralNetworks/Layers/SSM/GatedDeltaProductLayer.cs
index 921192a95c..a13649b55c 100644
--- a/src/NeuralNetworks/Layers/SSM/GatedDeltaProductLayer.cs
+++ b/src/NeuralNetworks/Layers/SSM/GatedDeltaProductLayer.cs
@@ -133,33 +133,56 @@ public partial class GatedDeltaProductLayer<T> : LayerBase<T>, IShapeContract
     private Tensor<T> _outputProjectionBias;
 
     // Cached forward pass values
+    [Scratch]
     private Tensor<T>? _lastInput;
+    [Scratch]
     private Tensor<T>? _lastOutput;
+    [Scratch]
     private Tensor<T>? _lastQuery;
+    [Scratch]
     private Tensor<T>? _lastKey;
+    [Scratch]
     private Tensor<T>? _lastValue;
+    [Scratch]
     private Tensor<T>? _lastBeta;
+    [Scratch]
     private Tensor<T>? _lastAlpha;
+    [Scratch]
     private Tensor<T>? _lastHouseholderVecs;
+    [Scratch]
     private Tensor<T>? _lastRecurrenceOutput;
+    [Scratch]
     private Tensor<T>? _lastOutputGate;
+    [Scratch]
     private Tensor<T>? _lastOutputGateRaw;
     [Scratch]
     private readonly List<Tensor<T>> _recurrenceInitialStates = [];
     private int[]? _originalInputShape;
 
     // Gradients
+    [Scratch]
     private Tensor<T>? _queryWeightsGradient;
+    [Scratch]
     private Tensor<T>? _keyWeightsGradient;
+    [Scratch]
     private Tensor<T>? _valueWeightsGradient;
+    [Scratch]
     private Tensor<T>? _betaWeightsGradient;
+    [Scratch]
     private Tensor<T>? _betaBiasGradient;
+    [Scratch]
     private Tensor<T>? _alphaWeightsGradient;
+    [Scratch]
     private Tensor<T>? _alphaBiasGradient;
+    [Scratch]
     private Tensor<T>? _householderWeightsGradient;
+    [Scratch]
     private Tensor<T>? _outputGateWeightsGradient;
+    [Scratch]
     private Tensor<T>? _outputGateBiasGradient;
+    [Scratch]
     private Tensor<T>? _outputProjectionWeightsGradient;
+    [Scratch]
     private Tensor<T>? _outputProjectionBiasGradient;
 
     /// <inheritdoc />
@@ -185,6 +208,9 @@ public partial class GatedDeltaProductLayer<T> : LayerBase<T>, IShapeContract
     /// </summary>
     public int NumHouseholders => _numHouseholders;
 
+    /// <summary>Construction state: the 'sequenceLength' the layer was built with.</summary>
+    private readonly int _sequenceLength;
+
     /// <summary>
     /// Creates a new Gated DeltaProduct layer.
     /// </summary>
@@ -216,6 +242,7 @@ public GatedDeltaProductLayer(
             [sequenceLength, modelDimension],
             activationFunction ?? new IdentityActivation<T>())
     {
+        _sequenceLength = sequenceLength;
         InitializationStrategy = initializationStrategy ?? InitializationStrategies<T>.Eager;
 
         if (sequenceLength <= 0)
diff --git a/src/NeuralNetworks/Layers/SSM/GatedLinearAttentionLayer.cs b/src/NeuralNetworks/Layers/SSM/GatedLinearAttentionLayer.cs
index fcf349614f..c4ebf15be9 100644
--- a/src/NeuralNetworks/Layers/SSM/GatedLinearAttentionLayer.cs
+++ b/src/NeuralNetworks/Layers/SSM/GatedLinearAttentionLayer.cs
@@ -98,27 +98,43 @@ public partial class GatedLinearAttentionLayer<T> : LayerBase<T>, IShapeContract
 
     // Fixed (non-trainable) unit-gamma / zero-beta for the residual-block output LayerNorm.
     // Allocated once and reused so the hot forward path doesn't re-allocate them per step.
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _residualNormGamma;
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _residualNormBeta;
     private const double ResidualNormEpsilon = 1e-5;
 
     // Cached values
+    [Scratch]
     private Tensor<T>? _lastInput;
+    [Scratch]
     private Tensor<T>? _lastOutput;
+    [Scratch]
     private Tensor<T>? _lastQuery;
+    [Scratch]
     private Tensor<T>? _lastKey;
+    [Scratch]
     private Tensor<T>? _lastValue;
+    [Scratch]
     private Tensor<T>? _lastGate;
+    [Scratch]
     private Tensor<T>? _lastAttnOutput; // Pre-output-projection attention output
     private int[]? _originalInputShape;
 
     // Gradients
+    [Scratch]
     private Tensor<T>? _queryWeightsGradient;
+    [Scratch]
     private Tensor<T>? _keyWeightsGradient;
+    [Scratch]
     private Tensor<T>? _valueWeightsGradient;
+    [Scratch]
     private Tensor<T>? _gateWeightsGradient;
+    [Scratch]
     private Tensor<T>? _gateBiasGradient;
+    [Scratch]
     private Tensor<T>? _outputWeightsGradient;
+    [Scratch]
     private Tensor<T>? _outputBiasGradient;
 
     /// <inheritdoc />
@@ -139,6 +155,9 @@ public partial class GatedLinearAttentionLayer<T> : LayerBase<T>, IShapeContract
     /// </summary>
     public int HeadDimension => _headDimension;
 
+    /// <summary>Construction state: the 'sequenceLength' the layer was built with.</summary>
+    private readonly int _sequenceLength;
+
     /// <summary>
     /// Creates a new Gated Linear Attention layer.
     /// </summary>
@@ -164,6 +183,7 @@ public GatedLinearAttentionLayer(
             [sequenceLength, modelDimension],
             activationFunction ?? new IdentityActivation<T>())
     {
+        _sequenceLength = sequenceLength;
         InitializationStrategy = initializationStrategy ?? InitializationStrategies<T>.Eager;
 
         if (sequenceLength <= 0)
diff --git a/src/NeuralNetworks/Layers/SSM/GatedSlotAttentionLayer.cs b/src/NeuralNetworks/Layers/SSM/GatedSlotAttentionLayer.cs
index ae1f1a9eb8..11055da5be 100644
--- a/src/NeuralNetworks/Layers/SSM/GatedSlotAttentionLayer.cs
+++ b/src/NeuralNetworks/Layers/SSM/GatedSlotAttentionLayer.cs
@@ -128,31 +128,54 @@ public partial class GatedSlotAttentionLayer<T> : LayerBase<T>, IShapeContract
     private Tensor<T> _outputProjectionBias;
 
     // Cached values for backward pass
+    [Scratch]
     private Tensor<T>? _lastInput;
+    [Scratch]
     private Tensor<T>? _lastOutput;
+    [Scratch]
     private Tensor<T>? _lastQuery;
+    [Scratch]
     private Tensor<T>? _lastKey;
+    [Scratch]
     private Tensor<T>? _lastValue;
+    [Scratch]
     private Tensor<T>? _lastForgetGate;
+    [Scratch]
     private Tensor<T>? _lastInputGate;
+    [Scratch]
     private Tensor<T>? _lastOutputGate;
+    [Scratch]
     private Tensor<T>? _lastOutputGateRaw;
+    [Scratch]
     private Tensor<T>? _lastSlotStates;
+    [Scratch]
     private Tensor<T>? _lastSlotReadOutput;
     private int[]? _originalInputShape;
 
     // Gradients
+    [Scratch]
     private Tensor<T>? _queryWeightsGradient;
+    [Scratch]
     private Tensor<T>? _keyWeightsGradient;
+    [Scratch]
     private Tensor<T>? _valueWeightsGradient;
+    [Scratch]
     private Tensor<T>? _forgetGateWeightsGradient;
+    [Scratch]
     private Tensor<T>? _forgetGateBiasGradient;
+    [Scratch]
     private Tensor<T>? _inputGateWeightsGradient;
+    [Scratch]
     private Tensor<T>? _inputGateBiasGradient;
+    [Scratch]
     private Tensor<T>? _initialSlotsGradient;
+    [Scratch]
     private Tensor<T>? _outputGateWeightsGradient;
+    [Scratch]
     private Tensor<T>? _outputGateBiasGradient;
+    [Scratch]
     private Tensor<T>? _outputProjectionWeightsGradient;
+    [Scratch]
     private Tensor<T>? _outputProjectionBiasGradient;
 
     /// <inheritdoc />
@@ -178,6 +201,9 @@ public partial class GatedSlotAttentionLayer<T> : LayerBase<T>, IShapeContract
     /// </summary>
     public int NumSlots => _numSlots;
 
+    /// <summary>Construction state: the 'sequenceLength' the layer was built with.</summary>
+    private readonly int _sequenceLength;
+
     /// <summary>
     /// Creates a new Gated Slot Attention layer.
     /// </summary>
@@ -211,6 +237,7 @@ public GatedSlotAttentionLayer(
             [sequenceLength, modelDimension],
             activationFunction ?? new IdentityActivation<T>())
     {
+        _sequenceLength = sequenceLength;
         InitializationStrategy = initializationStrategy ?? InitializationStrategies<T>.Eager;
 
         if (sequenceLength <= 0)
diff --git a/src/NeuralNetworks/Layers/SSM/HGRN2Layer.cs b/src/NeuralNetworks/Layers/SSM/HGRN2Layer.cs
index d06382b923..5e1c99c669 100644
--- a/src/NeuralNetworks/Layers/SSM/HGRN2Layer.cs
+++ b/src/NeuralNetworks/Layers/SSM/HGRN2Layer.cs
@@ -121,26 +121,44 @@ public partial class HGRN2Layer<T> : LayerBase<T>, IShapeContract
     private Tensor<T> _outputProjectionBias;
 
     // Cached values for backward pass
+    [Scratch]
     private Tensor<T>? _lastInput;
+    [Scratch]
     private Tensor<T>? _lastOutput;
+    [Scratch]
     private Tensor<T>? _lastQuery;
+    [Scratch]
     private Tensor<T>? _lastKey;
+    [Scratch]
     private Tensor<T>? _lastValue;
+    [Scratch]
     private Tensor<T>? _lastForgetGate;
+    [Scratch]
     private Tensor<T>? _lastGate;
+    [Scratch]
     private Tensor<T>? _lastGateRaw;
+    [Scratch]
     private Tensor<T>? _lastRecurrenceOutput;
     private int[]? _originalInputShape;
 
     // Gradients
+    [Scratch]
     private Tensor<T>? _queryWeightsGradient;
+    [Scratch]
     private Tensor<T>? _keyWeightsGradient;
+    [Scratch]
     private Tensor<T>? _valueWeightsGradient;
+    [Scratch]
     private Tensor<T>? _forgetGateWeightsGradient;
+    [Scratch]
     private Tensor<T>? _forgetGateBiasGradient;
+    [Scratch]
     private Tensor<T>? _outputGateWeightsGradient;
+    [Scratch]
     private Tensor<T>? _outputGateBiasGradient;
+    [Scratch]
     private Tensor<T>? _outputProjectionWeightsGradient;
+    [Scratch]
     private Tensor<T>? _outputProjectionBiasGradient;
 
     /// <inheritdoc />
@@ -161,6 +179,9 @@ public partial class HGRN2Layer<T> : LayerBase<T>, IShapeContract
     /// </summary>
     public int HeadDimension => _headDimension;
 
+    /// <summary>Construction state: the 'sequenceLength' the layer was built with.</summary>
+    private readonly int _sequenceLength;
+
     /// <summary>
     /// Creates a new HGRN2 layer with state expansion.
     /// </summary>
@@ -196,6 +217,7 @@ public HGRN2Layer(
             [sequenceLength, modelDimension],
             activationFunction ?? new IdentityActivation<T>())
     {
+        _sequenceLength = sequenceLength;
         InitializationStrategy = initializationStrategy ?? InitializationStrategies<T>.Eager;
 
         if (sequenceLength <= 0)
diff --git a/src/NeuralNetworks/Layers/SSM/HGRNLayer.cs b/src/NeuralNetworks/Layers/SSM/HGRNLayer.cs
index 417c408a32..36af637eb1 100644
--- a/src/NeuralNetworks/Layers/SSM/HGRNLayer.cs
+++ b/src/NeuralNetworks/Layers/SSM/HGRNLayer.cs
@@ -107,23 +107,38 @@ public partial class HGRNLayer<T> : LayerBase<T>, IShapeContract
     private Tensor<T> _outputProjectionBias;
 
     // Cached values for backward pass
+    [Scratch]
     private Tensor<T>? _lastInput;
+    [Scratch]
     private Tensor<T>? _lastOutput;
+    [Scratch]
     private Tensor<T>? _lastProjectedInput;
+    [Scratch]
     private Tensor<T>? _lastForgetGate;
+    [Scratch]
     private Tensor<T>? _lastInputGate;
+    [Scratch]
     private Tensor<T>? _lastHiddenStates;
+    [Scratch]
     private Tensor<T>? _lastRecurrenceOutput;
     private int[]? _originalInputShape;
 
     // Gradients
+    [Scratch]
     private Tensor<T>? _inputProjectionWeightsGradient;
+    [Scratch]
     private Tensor<T>? _inputProjectionBiasGradient;
+    [Scratch]
     private Tensor<T>? _forgetGateWeightsGradient;
+    [Scratch]
     private Tensor<T>? _forgetGateBiasGradient;
+    [Scratch]
     private Tensor<T>? _inputGateWeightsGradient;
+    [Scratch]
     private Tensor<T>? _inputGateBiasGradient;
+    [Scratch]
     private Tensor<T>? _outputProjectionWeightsGradient;
+    [Scratch]
     private Tensor<T>? _outputProjectionBiasGradient;
 
     /// <inheritdoc />
@@ -146,6 +161,9 @@ public partial class HGRNLayer<T> : LayerBase<T>, IShapeContract
     /// </remarks>
     public double ForgetBias => _forgetBias;
 
+    /// <summary>Construction state: the 'sequenceLength' the layer was built with.</summary>
+    private readonly int _sequenceLength;
+
     /// <summary>
     /// Creates a new HGRN (Hierarchically Gated Recurrent Neural Network) layer.
     /// </summary>
@@ -182,6 +200,7 @@ public HGRNLayer(
             [sequenceLength, modelDimension],
             activationFunction ?? new IdentityActivation<T>())
     {
+        _sequenceLength = sequenceLength;
         InitializationStrategy = initializationStrategy ?? InitializationStrategies<T>.Eager;
 
         if (sequenceLength <= 0)
diff --git a/src/NeuralNetworks/Layers/SSM/HippoMemoryCellLayer.cs b/src/NeuralNetworks/Layers/SSM/HippoMemoryCellLayer.cs
index 187563880f..a9557927ff 100644
--- a/src/NeuralNetworks/Layers/SSM/HippoMemoryCellLayer.cs
+++ b/src/NeuralNetworks/Layers/SSM/HippoMemoryCellLayer.cs
@@ -54,7 +54,11 @@ public partial class HippoMemoryCellLayer<T> : LayerBase<T>, IShapeContract
     private readonly double _timescaleMax;
     private readonly bool _useGate;
 
-    // Fixed HiPPO operator. These are buffers, not trainable parameters.
+    // Fixed HiPPO operator, rebuilt from _measure and _order at construction. These are buffers,
+    // not trainable parameters, and all three must stay declared the same way: _aTranspose alone
+    // briefly carried [TrainableParameter], which the hand-written parameter pair below hid
+    // because that pair made the generator skip this type entirely. Deleting the pair would have
+    // promoted a fixed operator into the trainable vector and moved every downstream offset.
     private readonly Tensor<T> _a;
     private readonly Tensor<T> _aTranspose;
     private readonly Tensor<T> _bRow;
@@ -68,13 +72,17 @@ public partial class HippoMemoryCellLayer<T> : LayerBase<T>, IShapeContract
     private Tensor<T> _hiddenWeights;
     [TrainableParameter(Role = PersistentTensorRole.Biases)]
     private Tensor<T> _hiddenBias;
-    [TrainableParameter(Role = PersistentTensorRole.Weights)]
+    // The gate exists only when the layer is configured with one, so both of its tensors are
+    // conditional. Without the condition the generated surface would always publish six tensors
+    // while an ungated cell holds four, and the count would stop matching the vector.
+    [TrainableParameter(Role = PersistentTensorRole.Weights, Condition = nameof(_useGate))]
     private Tensor<T> _gateWeights;
-    [TrainableParameter(Role = PersistentTensorRole.Biases)]
+    [TrainableParameter(Role = PersistentTensorRole.Biases, Condition = nameof(_useGate))]
     private Tensor<T> _gateBias;
 
     private readonly Tensor<T>? _ltiTransition;
     private readonly Tensor<T>? _ltiInput;
+    [Scratch]
     private readonly Dictionary<int, (Tensor<T> A, Tensor<T> B)> _legsZohCache = new();
 
     /// <inheritdoc />
@@ -95,44 +103,6 @@ public partial class HippoMemoryCellLayer<T> : LayerBase<T>, IShapeContract
     /// <summary>Gets the configured discretization method.</summary>
     public string Discretization => _discretization;
 
-    /// <inheritdoc />
-    public override IReadOnlyList<Tensor<T>> GetTrainableParameters() => _useGate
-        ? new[] { _memoryWeights, _memoryBias, _hiddenWeights, _hiddenBias, _gateWeights, _gateBias }
-        : new[] { _memoryWeights, _memoryBias, _hiddenWeights, _hiddenBias };
-
-    /// <inheritdoc />
-    /// <remarks>
-    /// Parameter-buffer and copy-on-write paths replace tensor objects rather
-    /// than copying values. Keep the fields consumed by <see cref="Forward"/>
-    /// synchronized with those replacements.
-    /// </remarks>
-    public override void SetTrainableParameters(IReadOnlyList<Tensor<T>> parameters)
-    {
-        int expected = _useGate ? 6 : 4;
-        if (parameters.Count != expected)
-            throw new ArgumentException($"Expected exactly {expected} HiPPO parameter tensors.", nameof(parameters));
-
-        ValidateShapeMatch(parameters[0], _memoryWeights, nameof(_memoryWeights));
-        ValidateShapeMatch(parameters[1], _memoryBias, nameof(_memoryBias));
-        ValidateShapeMatch(parameters[2], _hiddenWeights, nameof(_hiddenWeights));
-        ValidateShapeMatch(parameters[3], _hiddenBias, nameof(_hiddenBias));
-        if (_useGate)
-        {
-            ValidateShapeMatch(parameters[4], _gateWeights, nameof(_gateWeights));
-            ValidateShapeMatch(parameters[5], _gateBias, nameof(_gateBias));
-        }
-
-        _memoryWeights = parameters[0];
-        _memoryBias = parameters[1];
-        _hiddenWeights = parameters[2];
-        _hiddenBias = parameters[3];
-        if (_useGate)
-        {
-            _gateWeights = parameters[4];
-            _gateBias = parameters[5];
-        }
-    }
-
     private static void ValidateShapeMatch(Tensor<T> incoming, Tensor<T> existing, string parameterName)
     {
         if (incoming.Rank != existing.Rank || incoming.Length != existing.Length)
diff --git a/src/NeuralNetworks/Layers/SSM/HybridBlockScheduler.cs b/src/NeuralNetworks/Layers/SSM/HybridBlockScheduler.cs
index 4c3699f6f9..e504ccb092 100644
--- a/src/NeuralNetworks/Layers/SSM/HybridBlockScheduler.cs
+++ b/src/NeuralNetworks/Layers/SSM/HybridBlockScheduler.cs
@@ -115,7 +115,9 @@ public partial class HybridBlockScheduler<T> : LayerBase<T>, IShapeContract
     private readonly Tensor<T>[] _normBetas;
 
     // Cached values for backward pass
+    [Scratch]
     private Tensor<T>? _lastInput;
+    [Scratch]
     private Tensor<T>? _lastOutput;
     private Tensor<T>[]? _lastNormedInputs;
     private Tensor<T>[]? _lastBlockOutputs;
diff --git a/src/NeuralNetworks/Layers/SSM/HyenaLayer.cs b/src/NeuralNetworks/Layers/SSM/HyenaLayer.cs
index e160dcab03..629880574a 100644
--- a/src/NeuralNetworks/Layers/SSM/HyenaLayer.cs
+++ b/src/NeuralNetworks/Layers/SSM/HyenaLayer.cs
@@ -111,7 +111,9 @@ public partial class HyenaLayer<T> : LayerBase<T>, IShapeContract
     private Tensor<T> _outputProjectionBias;
 
     // Cached values for backward pass
+    [Scratch]
     private Tensor<T>? _lastInput;
+    [Scratch]
     private Tensor<T>? _lastOutput;
     private Tensor<T>[]? _lastProjections;       // (order+1) projections: v, x_1, ..., x_N
     private Tensor<T>[]? _lastProjectionsRaw;     // pre-activation raw projections
@@ -119,6 +121,7 @@ public partial class HyenaLayer<T> : LayerBase<T>, IShapeContract
     private Tensor<T>[]? _lastFilterHidden;       // hidden states from filter MLPs
     private Tensor<T>[]? _lastConvOutputs;        // results after each convolution
     private Tensor<T>[]? _lastGatedOutputs;       // results after each gating step
+    [Scratch]
     private Tensor<T>? _lastPreProjection;        // result before output projection
     private int[]? _originalInputShape;
 
@@ -133,7 +136,9 @@ public partial class HyenaLayer<T> : LayerBase<T>, IShapeContract
     private Tensor<T>[]? _filterBiases2Gradients;
 
     // Gradients for output projection
+    [Scratch]
     private Tensor<T>? _outputProjectionWeightsGradient;
+    [Scratch]
     private Tensor<T>? _outputProjectionBiasGradient;
 
     /// <inheritdoc />
diff --git a/src/NeuralNetworks/Layers/SSM/KimiLinearAttentionLayer.cs b/src/NeuralNetworks/Layers/SSM/KimiLinearAttentionLayer.cs
index 37d0d20ace..3d89234a20 100644
--- a/src/NeuralNetworks/Layers/SSM/KimiLinearAttentionLayer.cs
+++ b/src/NeuralNetworks/Layers/SSM/KimiLinearAttentionLayer.cs
@@ -112,27 +112,46 @@ public partial class KimiLinearAttentionLayer<T> : LayerBase<T>, IShapeContract
     private Tensor<T> _outputProjectionBias;
 
     // Cached values for backward pass
+    [Scratch]
     private Tensor<T>? _lastInput;
+    [Scratch]
     private Tensor<T>? _lastOutput;
+    [Scratch]
     private Tensor<T>? _lastQuery;
+    [Scratch]
     private Tensor<T>? _lastKey;
+    [Scratch]
     private Tensor<T>? _lastValue;
+    [Scratch]
     private Tensor<T>? _lastKVGate;
+    [Scratch]
     private Tensor<T>? _lastKVGateRaw;
+    [Scratch]
     private Tensor<T>? _lastOutputGate;
+    [Scratch]
     private Tensor<T>? _lastOutputGateRaw;
+    [Scratch]
     private Tensor<T>? _lastStates;
+    [Scratch]
     private Tensor<T>? _lastRecurrenceOutput;
     private int[]? _originalInputShape;
 
     // Gradients
+    [Scratch]
     private Tensor<T>? _queryWeightsGradient;
+    [Scratch]
     private Tensor<T>? _keyWeightsGradient;
+    [Scratch]
     private Tensor<T>? _valueWeightsGradient;
+    [Scratch]
     private Tensor<T>? _gateKVBiasGradient;
+    [Scratch]
     private Tensor<T>? _outputGateWeightsGradient;
+    [Scratch]
     private Tensor<T>? _outputGateBiasGradient;
+    [Scratch]
     private Tensor<T>? _outputProjectionWeightsGradient;
+    [Scratch]
     private Tensor<T>? _outputProjectionBiasGradient;
 
     /// <inheritdoc />
@@ -147,6 +166,9 @@ public partial class KimiLinearAttentionLayer<T> : LayerBase<T>, IShapeContract
     /// <summary>Gets the dimension per head.</summary>
     public int HeadDimension => _headDimension;
 
+    /// <summary>Construction state: the 'sequenceLength' the layer was built with.</summary>
+    private readonly int _sequenceLength;
+
     /// <summary>
     /// Creates a new Kimi KDA (Key-Value Driven Gated Linear Attention) layer.
     /// </summary>
@@ -172,6 +194,7 @@ public KimiLinearAttentionLayer(
             [sequenceLength, modelDimension],
             activationFunction ?? new IdentityActivation<T>())
     {
+        _sequenceLength = sequenceLength;
         InitializationStrategy = initializationStrategy ?? InitializationStrategies<T>.Eager;
 
         if (sequenceLength <= 0)
diff --git a/src/NeuralNetworks/Layers/SSM/LinearRecurrentUnitLayer.cs b/src/NeuralNetworks/Layers/SSM/LinearRecurrentUnitLayer.cs
index 06c4be9567..7a2de467a0 100644
--- a/src/NeuralNetworks/Layers/SSM/LinearRecurrentUnitLayer.cs
+++ b/src/NeuralNetworks/Layers/SSM/LinearRecurrentUnitLayer.cs
@@ -134,28 +134,48 @@ public partial class LinearRecurrentUnitLayer<T> : LayerBase<T>, IShapeContract
     private Tensor<T> _outputProjectionBias;
 
     // Cached values for backward pass
+    [Scratch]
     private Tensor<T>? _lastInput;
+    [Scratch]
     private Tensor<T>? _lastOutput;
+    [Scratch]
     private Tensor<T>? _lastProjectedInput;
+    [Scratch]
     private Tensor<T>? _lastHiddenStatesReal;
+    [Scratch]
     private Tensor<T>? _lastHiddenStatesImag;
+    [Scratch]
     private Tensor<T>? _lastRecurrenceOutput;
+    [Scratch]
     private Tensor<T>? _lastLambdaReal;
+    [Scratch]
     private Tensor<T>? _lastLambdaImag;
+    [Scratch]
     private Tensor<T>? _lastLambdaMag;
     private int[]? _originalInputShape;
 
     // Gradients
+    [Scratch]
     private Tensor<T>? _nuGradient;
+    [Scratch]
     private Tensor<T>? _thetaGradient;
+    [Scratch]
     private Tensor<T>? _bRealGradient;
+    [Scratch]
     private Tensor<T>? _bImagGradient;
+    [Scratch]
     private Tensor<T>? _cRealGradient;
+    [Scratch]
     private Tensor<T>? _cImagGradient;
+    [Scratch]
     private Tensor<T>? _dParamGradient;
+    [Scratch]
     private Tensor<T>? _inputProjectionWeightsGradient;
+    [Scratch]
     private Tensor<T>? _inputProjectionBiasGradient;
+    [Scratch]
     private Tensor<T>? _outputProjectionWeightsGradient;
+    [Scratch]
     private Tensor<T>? _outputProjectionBiasGradient;
 
     /// <inheritdoc />
@@ -177,6 +197,9 @@ public partial class LinearRecurrentUnitLayer<T> : LayerBase<T>, IShapeContract
     /// </remarks>
     public int StateDimension => _stateDimension;
 
+    /// <summary>Construction state: the 'sequenceLength' the layer was built with.</summary>
+    private readonly int _sequenceLength;
+
     /// <summary>
     /// Creates a new Linear Recurrent Unit (LRU) layer.
     /// </summary>
@@ -207,6 +230,7 @@ public LinearRecurrentUnitLayer(
             [sequenceLength, modelDimension],
             activationFunction ?? new IdentityActivation<T>())
     {
+        _sequenceLength = sequenceLength;
         InitializationStrategy = initializationStrategy ?? InitializationStrategies<T>.Eager;
 
         if (sequenceLength <= 0)
diff --git a/src/NeuralNetworks/Layers/SSM/LogLinearAttentionLayer.cs b/src/NeuralNetworks/Layers/SSM/LogLinearAttentionLayer.cs
index a4b4406b13..df6ebd038b 100644
--- a/src/NeuralNetworks/Layers/SSM/LogLinearAttentionLayer.cs
+++ b/src/NeuralNetworks/Layers/SSM/LogLinearAttentionLayer.cs
@@ -131,28 +131,48 @@ public partial class LogLinearAttentionLayer<T> : LayerBase<T>, IShapeContract
     private Tensor<T> _outputProjectionBias;
 
     // Cached values for backward pass
+    [Scratch]
     private Tensor<T>? _lastInput;
+    [Scratch]
     private Tensor<T>? _lastOutput;
+    [Scratch]
     private Tensor<T>? _lastQuery;
+    [Scratch]
     private Tensor<T>? _lastKey;
+    [Scratch]
     private Tensor<T>? _lastValue;
+    [Scratch]
     private Tensor<T>? _lastGate;
+    [Scratch]
     private Tensor<T>? _lastGateRaw;
+    [Scratch]
     private Tensor<T>? _lastLogLinearOutput;
     private int[]? _originalInputShape;
 
     // Gradients
+    [Scratch]
     private Tensor<T>? _queryWeightsGradient;
+    [Scratch]
     private Tensor<T>? _queryBiasGradient;
+    [Scratch]
     private Tensor<T>? _keyWeightsGradient;
+    [Scratch]
     private Tensor<T>? _keyBiasGradient;
+    [Scratch]
     private Tensor<T>? _valueWeightsGradient;
+    [Scratch]
     private Tensor<T>? _valueBiasGradient;
+    [Scratch]
     private Tensor<T>? _levelMixWeightsGradient;
+    [Scratch]
     private Tensor<T>? _compressionWeightsGradient;
+    [Scratch]
     private Tensor<T>? _outputGateWeightsGradient;
+    [Scratch]
     private Tensor<T>? _outputGateBiasGradient;
+    [Scratch]
     private Tensor<T>? _outputProjectionWeightsGradient;
+    [Scratch]
     private Tensor<T>? _outputProjectionBiasGradient;
 
     /// <inheritdoc />
@@ -178,6 +198,9 @@ public partial class LogLinearAttentionLayer<T> : LayerBase<T>, IShapeContract
     /// </summary>
     public int NumLevels => _numLevels;
 
+    /// <summary>Construction state: the 'sequenceLength' the layer was built with.</summary>
+    private readonly int _sequenceLength;
+
     /// <summary>
     /// Creates a new Log-Linear Attention layer with hierarchical state compression.
     /// </summary>
@@ -211,6 +234,7 @@ public LogLinearAttentionLayer(
             [sequenceLength, modelDimension],
             activationFunction ?? new IdentityActivation<T>())
     {
+        _sequenceLength = sequenceLength;
         InitializationStrategy = initializationStrategy ?? InitializationStrategies<T>.Eager;
 
         if (sequenceLength <= 0)
diff --git a/src/NeuralNetworks/Layers/SSM/LonghornLayer.cs b/src/NeuralNetworks/Layers/SSM/LonghornLayer.cs
index e2ba25514c..caf7a9e889 100644
--- a/src/NeuralNetworks/Layers/SSM/LonghornLayer.cs
+++ b/src/NeuralNetworks/Layers/SSM/LonghornLayer.cs
@@ -123,29 +123,50 @@ public partial class LonghornLayer<T> : LayerBase<T>, IShapeContract
     private Tensor<T> _outputProjectionBias;
 
     // Cached values for backward pass
+    [Scratch]
     private Tensor<T>? _lastInput;
+    [Scratch]
     private Tensor<T>? _lastOutput;
+    [Scratch]
     private Tensor<T>? _lastQuery;
+    [Scratch]
     private Tensor<T>? _lastKey;
+    [Scratch]
     private Tensor<T>? _lastValue;
+    [Scratch]
     private Tensor<T>? _lastAlpha;
+    [Scratch]
     private Tensor<T>? _lastStates;
+    [Scratch]
     private Tensor<T>? _lastRecurrenceOutput;
+    [Scratch]
     private Tensor<T>? _lastNormedOutput;
     private int[]? _originalInputShape;
 
     // Gradients
+    [Scratch]
     private Tensor<T>? _queryWeightsGradient;
+    [Scratch]
     private Tensor<T>? _queryBiasGradient;
+    [Scratch]
     private Tensor<T>? _keyWeightsGradient;
+    [Scratch]
     private Tensor<T>? _keyBiasGradient;
+    [Scratch]
     private Tensor<T>? _valueWeightsGradient;
+    [Scratch]
     private Tensor<T>? _valueBiasGradient;
+    [Scratch]
     private Tensor<T>? _alphaWeightsGradient;
+    [Scratch]
     private Tensor<T>? _alphaBiasGradient;
+    [Scratch]
     private Tensor<T>? _groupNormGammaGradient;
+    [Scratch]
     private Tensor<T>? _groupNormBetaGradient;
+    [Scratch]
     private Tensor<T>? _outputProjectionWeightsGradient;
+    [Scratch]
     private Tensor<T>? _outputProjectionBiasGradient;
 
     /// <inheritdoc />
@@ -166,6 +187,9 @@ public partial class LonghornLayer<T> : LayerBase<T>, IShapeContract
     /// </summary>
     public int HeadDimension => _headDimension;
 
+    /// <summary>Construction state: the 'sequenceLength' the layer was built with.</summary>
+    private readonly int _sequenceLength;
+
     /// <summary>
     /// Creates a new Longhorn layer.
     /// </summary>
@@ -196,6 +220,7 @@ public LonghornLayer(
             [sequenceLength, modelDimension],
             activationFunction ?? new IdentityActivation<T>())
     {
+        _sequenceLength = sequenceLength;
         InitializationStrategy = initializationStrategy ?? InitializationStrategies<T>.Eager;
 
         if (sequenceLength <= 0)
diff --git a/src/NeuralNetworks/Layers/SSM/MEGALayer.cs b/src/NeuralNetworks/Layers/SSM/MEGALayer.cs
index 2296d79cfc..57d2908bee 100644
--- a/src/NeuralNetworks/Layers/SSM/MEGALayer.cs
+++ b/src/NeuralNetworks/Layers/SSM/MEGALayer.cs
@@ -135,35 +135,62 @@ public partial class MEGALayer<T> : LayerBase<T>, IShapeContract
     private Tensor<T> _outputProjectionBias;
 
     // Cached forward pass values
+    [Scratch]
     private Tensor<T>? _lastInput;
+    [Scratch]
     private Tensor<T>? _lastOutput;
+    [Scratch]
     private Tensor<T>? _lastEmaInput;
+    [Scratch]
     private Tensor<T>? _lastEmaStates;
+    [Scratch]
     private Tensor<T>? _lastEmaProjected;
+    [Scratch]
     private Tensor<T>? _lastQuery;
+    [Scratch]
     private Tensor<T>? _lastKey;
+    [Scratch]
     private Tensor<T>? _lastValue;
+    [Scratch]
     private Tensor<T>? _lastAttnScores;
+    [Scratch]
     private Tensor<T>? _lastAttnOutput;
+    [Scratch]
     private Tensor<T>? _lastGateRaw;
+    [Scratch]
     private Tensor<T>? _lastGate;
     private int[]? _originalInputShape;
 
     // Gradients
+    [Scratch]
     private Tensor<T>? _emaAlphaLogitGradient;
+    [Scratch]
     private Tensor<T>? _emaProjectInWeightsGradient;
+    [Scratch]
     private Tensor<T>? _emaProjectInBiasGradient;
+    [Scratch]
     private Tensor<T>? _emaProjectOutWeightsGradient;
+    [Scratch]
     private Tensor<T>? _emaProjectOutBiasGradient;
+    [Scratch]
     private Tensor<T>? _queryWeightsGradient;
+    [Scratch]
     private Tensor<T>? _queryBiasGradient;
+    [Scratch]
     private Tensor<T>? _keyWeightsGradient;
+    [Scratch]
     private Tensor<T>? _keyBiasGradient;
+    [Scratch]
     private Tensor<T>? _valueWeightsGradient;
+    [Scratch]
     private Tensor<T>? _valueBiasGradient;
+    [Scratch]
     private Tensor<T>? _outputGateWeightsGradient;
+    [Scratch]
     private Tensor<T>? _outputGateBiasGradient;
+    [Scratch]
     private Tensor<T>? _outputProjectionWeightsGradient;
+    [Scratch]
     private Tensor<T>? _outputProjectionBiasGradient;
 
     /// <inheritdoc />
@@ -189,6 +216,9 @@ public partial class MEGALayer<T> : LayerBase<T>, IShapeContract
     /// </summary>
     public int EmaDimension => _emaDimension;
 
+    /// <summary>Construction state: the 'sequenceLength' the layer was built with.</summary>
+    private readonly int _sequenceLength;
+
     /// <summary>
     /// Creates a new MEGA (Moving Average Equipped Gated Attention) layer.
     /// </summary>
@@ -225,6 +255,7 @@ public MEGALayer(
             [sequenceLength, modelDimension],
             activationFunction ?? new IdentityActivation<T>())
     {
+        _sequenceLength = sequenceLength;
         InitializationStrategy = initializationStrategy ?? InitializationStrategies<T>.Eager;
 
         if (sequenceLength <= 0)
diff --git a/src/NeuralNetworks/Layers/SSM/Mamba2Block.cs b/src/NeuralNetworks/Layers/SSM/Mamba2Block.cs
index f605c1e552..e8f5311dc5 100644
--- a/src/NeuralNetworks/Layers/SSM/Mamba2Block.cs
+++ b/src/NeuralNetworks/Layers/SSM/Mamba2Block.cs
@@ -1,4 +1,4 @@
-using AiDotNet.Attributes;
+using AiDotNet.Attributes;
 using AiDotNet.Autodiff;
 using AiDotNet.Helpers;
 using AiDotNet.Interfaces;
@@ -127,35 +127,62 @@ public partial class Mamba2Block<T> : LayerBase<T>, IShapeContract
     private Tensor<T> _normBeta;
 
     // Cached values for backward pass
+    [Scratch]
     private Tensor<T>? _lastInput;
+    [Scratch]
     private Tensor<T>? _lastOutput;
+    [Scratch]
     private Tensor<T>? _lastXBranch;
+    [Scratch]
     private Tensor<T>? _lastZBranch;
+    [Scratch]
     private Tensor<T>? _lastConvOutput;
+    [Scratch]
     private Tensor<T>? _lastSiluOutput;
+    [Scratch]
     private Tensor<T>? _lastSsdOutput;
+    [Scratch]
     private Tensor<T>? _lastGatedOutput;
+    [Scratch]
     private Tensor<T>? _lastDelta;
+    [Scratch]
     private Tensor<T>? _lastDeltaPreSoftplus;
+    [Scratch]
     private Tensor<T>? _lastB;
+    [Scratch]
     private Tensor<T>? _lastC;
+    [Scratch]
     private Tensor<T>? _lastNormInput;
     private int[]? _originalInputShape;
 
     // Gradients
+    [Scratch]
     private Tensor<T>? _inputProjectionWeightsGradient;
+    [Scratch]
     private Tensor<T>? _inputProjectionBiasGradient;
+    [Scratch]
     private Tensor<T>? _convWeightsGradient;
+    [Scratch]
     private Tensor<T>? _convBiasGradient;
+    [Scratch]
     private Tensor<T>? _bProjectionWeightsGradient;
+    [Scratch]
     private Tensor<T>? _cProjectionWeightsGradient;
+    [Scratch]
     private Tensor<T>? _aLogGradient;
+    [Scratch]
     private Tensor<T>? _dtProjectionWeightsGradient;
+    [Scratch]
     private Tensor<T>? _dtProjectionBiasGradient;
+    [Scratch]
     private Tensor<T>? _dParamGradient;
+    [Scratch]
     private Tensor<T>? _outputProjectionWeightsGradient;
+    [Scratch]
     private Tensor<T>? _outputProjectionBiasGradient;
+    [Scratch]
     private Tensor<T>? _normGammaGradient;
+    [Scratch]
     private Tensor<T>? _normBetaGradient;
 
     /// <inheritdoc />
@@ -214,6 +241,12 @@ public partial class Mamba2Block<T> : LayerBase<T>, IShapeContract
     /// </remarks>
     public int ChunkSize => _chunkSize;
 
+    /// <summary>Construction state: the 'sequenceLength' the layer was built with.</summary>
+    private readonly int _sequenceLength;
+
+    /// <summary>Construction state: the 'expandFactor' the layer was built with.</summary>
+    private readonly int _expandFactor;
+
     /// <summary>
     /// Creates a new Mamba-2 block with State Space Duality (SSD) computation.
     /// </summary>
@@ -258,6 +291,8 @@ public Mamba2Block(
             [sequenceLength, modelDimension],
             activationFunction ?? new IdentityActivation<T>())
     {
+        _expandFactor = expandFactor;
+        _sequenceLength = sequenceLength;
         InitializationStrategy = initializationStrategy ?? InitializationStrategies<T>.Eager;
 
         if (modelDimension <= 0)
@@ -349,7 +384,7 @@ private void InitializeParameters()
         _normBeta.Fill(NumOps.Zero);
 
         // Register ALL trainable parameters at construction so the tape training path collects them before
-        // the first UpdateParameters call — otherwise the projection weights (registered only inside
+        // the first UpdateParameters call — otherwise the projection weights (registered only inside
         // UpdateParameters previously) are never tape-tracked and every Train step silently no-ops on them.
         RegisterTrainableParameters();
     }
@@ -505,10 +540,10 @@ private Tensor<T> SSDForwardSequential(
         int batchSize, int seqLen)
     {
         // Tape-aware selective scan. The previous body was a scalar .Data.Span nested loop that wrote a
-        // rented output buffer — it SEVERED the autodiff tape, so under tape training every Mamba2 block
+        // rented output buffer — it SEVERED the autodiff tape, so under tape training every Mamba2 block
         // was FROZEN (verified: block activations were byte-identical before/after training; only the
         // output projection learned, and over many iterations it memorized the constant target and
-        // collapsed input-sensitivity — DifferentInputs_AfterTraining L2 ~= 0). Express the recurrence
+        // collapsed input-sensitivity — DifferentInputs_AfterTraining L2 ~= 0). Express the recurrence
         //   aBar_t = exp(dt_t * (-exp(A))),  h_t = aBar_t (.) h_{t-1} + (dt_t (.) x_t) (x) B_t,
         //   y_t    = sum_n (C_t (.) h_t) + D (.) x_t
         // through tape-aware Engine ops so gradients flow to every selective projection.
@@ -516,7 +551,7 @@ private Tensor<T> SSDForwardSequential(
         int sd = _stateDimension;
 
         // Constant [numHeads, headDim] ones to REPEAT a per-head value across its head's channels
-        // (per-head -> per-inner-dim). A plain constant — not a differentiated leaf — so a scalar fill
+        // (per-head -> per-inner-dim). A plain constant — not a differentiated leaf — so a scalar fill
         // here severs no gradient path.
         var onesHD = new Tensor<T>(new[] { _numHeads, _headDimension });
         var onesHDSpan = onesHD.Data.Span;
@@ -572,13 +607,13 @@ private Tensor<T> SSDForwardSequential(
     /// <summary>
     /// Chunked semiseparable SSD. Partitions the sequence into chunks of <paramref name="chunkSize"/> and,
     /// for each chunk, computes the intra-chunk contribution with the block-parallel semiseparable matrix
-    /// form (a lower-triangular decay-weighted C·Bᵀ "attention" times the input) while carrying the
+    /// form (a lower-triangular decay-weighted C·Bᵀ "attention" times the input) while carrying the
     /// recurrent state h between chunks via the efficient recurrent form. This is what makes the configured
     /// chunk size actually affect the computation. It is numerically identical to
     /// <see cref="SSDForwardSequential"/> (validated to machine precision by the SSD-equivalence test), and
     /// every op is tape-aware, so gradients still reach every selective projection, <c>_aLog</c> and
-    /// <c>_dParam</c>. Decays are handled in log space (segment sums of dt·(−exp(A)) ≤ 0) so the
-    /// intra-chunk decay matrix exp(cumA_t − cumA_j) stays bounded and never overflows.
+    /// <c>_dParam</c>. Decays are handled in log space (segment sums of dt·(−exp(A)) ≤ 0) so the
+    /// intra-chunk decay matrix exp(cumA_t − cumA_j) stays bounded and never overflows.
     /// </summary>
     private Tensor<T> SSDForwardChunked(
         Tensor<T> x, Tensor<T> delta, Tensor<T> b, Tensor<T> c,
@@ -594,7 +629,7 @@ private Tensor<T> SSDForwardChunked(
         { var s = onesHD.Data.Span; for (int i = 0; i < s.Length; i++) s[i] = NumOps.One; }
 
         // Eb[b, h, c] = 1 when channel c belongs to head h (c / headDim == h), else 0. Multiplying a
-        // [B, L, H] per-head tensor by this via a batched matmul expands it to [B, L, innerDim] — the
+        // [B, L, H] per-head tensor by this via a batched matmul expands it to [B, L, innerDim] — the
         // rank-3-safe equivalent of repeat-interleave across head channels.
         var eb = new Tensor<T>(new[] { batchSize, numHeads, innerDim });
         {
@@ -641,13 +676,13 @@ private Tensor<T> SSDForwardChunked(
             var trilMask = BuildBatchedLowerTriOnes(batchSize * numHeads, ln);          // [B*H, ln, ln] (0/1)
             // Mask in LOG space BEFORE the exp, as the reference Mamba-2 segsum does
             // (masked_fill(~causal, -inf) then exp). cumA decreases monotonically, so on the causal
-            // half decayDiff = cumA_t - cumA_j <= 0 and exp is bounded by 1 — but the discarded upper
+            // half decayDiff = cumA_t - cumA_j <= 0 and exp is bounded by 1 — but the discarded upper
             // half holds the same magnitudes with the opposite sign (up to ~+350 at seqLen 512 /
             // chunk 64). exp overflows at ~88 in float32 (~709 in float64), so exponentiating first
             // produced +Infinity there, and Infinity * 0 from the mask is NaN, which then propagated
             // through the matmul below and made the whole forward non-finite at <float>.
             // Zeroing decayDiff first leaves the causal half untouched and turns the upper half into
-            // exp(0) = 1, which the same mask then zeroes — identical result, no overflow.
+            // exp(0) = 1, which the same mask then zeroes — identical result, no overflow.
             var decayDiffMasked = Engine.TensorMultiply(decayDiff, trilMask);            // [B*H, ln, ln]
             var lDecay = Engine.TensorMultiply(Engine.TensorExp(decayDiffMasked), trilMask); // [B*H, ln, ln]
 
@@ -703,7 +738,7 @@ private Tensor<T> SSDForwardChunked(
     }
 
     /// <summary>
-    /// Builds a constant [batch, n, n] lower-triangular ones matrix (1 where column ≤ row, else 0),
+    /// Builds a constant [batch, n, n] lower-triangular ones matrix (1 where column ≤ row, else 0),
     /// identical across the batch axis. Used both as the prefix-sum operator and as the causal decay mask.
     /// A plain constant (not a differentiated leaf), so filling it with a scalar loop severs no gradient.
     /// </summary>
@@ -919,7 +954,7 @@ private Tensor<T> SSDBackward(
     /// Depthwise causal Conv1D forward using explicit per-element computation.
     /// </summary>
     // Tape-aware causal depthwise 1-D convolution over the time axis:
-    //   output[b, t, d] = bias[d] + Σ_k weights[d, k] * input[b, t - k, d]   (t - k >= 0)
+    //   output[b, t, d] = bias[d] + Σ_k weights[d, k] * input[b, t - k, d]   (t - k >= 0)
     // Built entirely from differentiable Engine ops so the gradient flows back to the
     // conv weights/bias AND to the input (the input projection). The previous body was
     // a scalar indexer loop that produced a fresh detached tensor and severed the tape.
@@ -964,7 +999,7 @@ private Tensor<T> DepthwiseConv1DBackward(
         Tensor<T> dOutput, Tensor<T> input, int batchSize, int seqLen)
     {
         var dInput = TensorAllocator.Rent<T>(new[] { batchSize, seqLen, _innerDimension });
-        // Zero-initialize rented buffer — it may contain stale data from previous use
+        // Zero-initialize rented buffer — it may contain stale data from previous use
         for (int i = 0; i < dInput.Length; i++) dInput[i] = NumOps.Zero;
         _convBiasGradient = new Tensor<T>(new[] { _innerDimension });
         _convWeightsGradient = new Tensor<T>(new[] { _innerDimension, _convKernelSize });
diff --git a/src/NeuralNetworks/Layers/SSM/MambaBlock.cs b/src/NeuralNetworks/Layers/SSM/MambaBlock.cs
index ea2e72732d..ffa88552f1 100644
--- a/src/NeuralNetworks/Layers/SSM/MambaBlock.cs
+++ b/src/NeuralNetworks/Layers/SSM/MambaBlock.cs
@@ -1,4 +1,4 @@
-using AiDotNet.Attributes;
+using AiDotNet.Attributes;
 using AiDotNet.Autodiff;
 using AiDotNet.Helpers;
 using AiDotNet.Interfaces;
@@ -131,33 +131,57 @@ public partial class MambaBlock<T> : LayerBase<T>, IShapeContract
     private Tensor<T> _outputProjectionBias;
 
     // Cached values for backward pass
+    [Scratch]
     private Tensor<T>? _lastInput;
+    [Scratch]
     private Tensor<T>? _lastOutput;
+    [Scratch]
     private Tensor<T>? _lastXBranch;
+    [Scratch]
     private Tensor<T>? _lastZBranch;
+    [Scratch]
     private Tensor<T>? _lastConvOutput;
+    [Scratch]
     private Tensor<T>? _lastSiluOutput;
+    [Scratch]
     private Tensor<T>? _lastScanOutput;
+    [Scratch]
     private Tensor<T>? _lastGatedOutput;
+    [Scratch]
     private Tensor<T>? _lastDelta;
+    [Scratch]
     private Tensor<T>? _lastDeltaPreSoftplus;
+    [Scratch]
     private Tensor<T>? _lastB;
+    [Scratch]
     private Tensor<T>? _lastC;
+    [Scratch]
     private Tensor<T>? _lastHiddenStates;
     private Tensor<T>? _initialHiddenState;
     private int[]? _originalInputShape;
 
     // Gradients
+    [Scratch]
     private Tensor<T>? _inputProjectionWeightsGradient;
+    [Scratch]
     private Tensor<T>? _inputProjectionBiasGradient;
+    [Scratch]
     private Tensor<T>? _convWeightsGradient;
+    [Scratch]
     private Tensor<T>? _convBiasGradient;
+    [Scratch]
     private Tensor<T>? _xProjectionWeightsGradient;
+    [Scratch]
     private Tensor<T>? _dtProjectionWeightsGradient;
+    [Scratch]
     private Tensor<T>? _dtProjectionBiasGradient;
+    [Scratch]
     private Tensor<T>? _aLogGradient;
+    [Scratch]
     private Tensor<T>? _dParamGradient;
+    [Scratch]
     private Tensor<T>? _outputProjectionWeightsGradient;
+    [Scratch]
     private Tensor<T>? _outputProjectionBiasGradient;
 
     /// <inheritdoc />
@@ -219,6 +243,12 @@ public partial class MambaBlock<T> : LayerBase<T>, IShapeContract
     /// </remarks>
     public int DtRank => _dtRank;
 
+    /// <summary>Construction state: the 'sequenceLength' the layer was built with.</summary>
+    private readonly int _sequenceLength;
+
+    /// <summary>Construction state: the 'expandFactor' the layer was built with.</summary>
+    private readonly int _expandFactor;
+
     /// <summary>
     /// Creates a new Mamba block.
     /// </summary>
@@ -273,6 +303,8 @@ public MambaBlock(
             [-1, modelDimension],
             activationFunction ?? new IdentityActivation<T>())
     {
+        _expandFactor = expandFactor;
+        _sequenceLength = sequenceLength;
         InitializationStrategy = initializationStrategy ?? InitializationStrategies<T>.Eager;
 
         if (sequenceLength <= 0)
@@ -380,7 +412,7 @@ private void InitializeParameters()
         // Register ALL trainable parameters for tape-based autodiff at construction time. The tape training
         // path (NeuralNetworkBase.Train -> TrainWithTape) collects registered parameters BEFORE the first
         // UpdateParameters call, so registering here (not only inside UpdateParameters) is what lets the
-        // optimizer actually see and update this block's weights — otherwise CollectParameters finds nothing
+        // optimizer actually see and update this block's weights — otherwise CollectParameters finds nothing
         // and every Train step is a silent no-op. _aLog and _dParam are learnable SSM parameters (Gu & Dao
         // 2023) and MUST be registered too, or they would be excluded from gradient updates and make the
         // registered-vs-flat parameter counts disagree.
@@ -476,15 +508,15 @@ protected override Tensor<T> ForwardTraced(Tensor<T> input)
 
         // Step 6: Selective scan (core SSM computation).
         // Fast path (no carried initial state AND caller doesn't need state output):
-        // use the engine's fused MambaSelectiveScanForward — a single tape op with
+        // use the engine's fused MambaSelectiveScanForward — a single tape op with
         // an exact BPTT backward (AiDotNet.Tensors#523/#1464). It replaces S6Scan's
         // per-timestep micro-op loop, which records O(seqLen) tape nodes and is the
-        // dominant Mamba cost — catastrophically so in double precision and at the
+        // dominant Mamba cost — catastrophically so in double precision and at the
         // long sequences 3D/vision Mamba models produce (e.g. SegMamba's 8^3 = 512
         // tokens). The decomposed S6Scan path is retained for two cases:
         //   1) a non-zero initial hidden state must be threaded across calls
         //      (stateful inference from a previous chunk), OR
-        //   2) the caller will read GetHiddenState() after the forward — chunked
+        //   2) the caller will read GetHiddenState() after the forward — chunked
         //      autoregressive inference relies on this even when starting from
         //      zero state. Without it, _lastHiddenStates = null would leave the
         //      caller with no carry to feed into the next chunk.
@@ -524,7 +556,7 @@ protected override Tensor<T> ForwardTraced(Tensor<T> input)
         // per Gu & Dao 2023 (state-spaces/mamba reference impl wraps the inner
         // block in `residual + Block(LN(residual))`). Without it, repeated
         // block stacks attenuate ~3 orders of magnitude per layer (observed
-        // 0.036 → 1e-38 through 4 blocks in MultiLayerModel_ProducesNonTrivialOutput),
+        // 0.036 → 1e-38 through 4 blocks in MultiLayerModel_ProducesNonTrivialOutput),
         // collapsing the LM head's logits to zero and producing a uniform
         // distribution. input3D and output3D both have shape
         // [batchSize, seqLen, _modelDimension] so the add is shape-aligned.
@@ -580,7 +612,7 @@ private Tensor<T> DepthwiseConv1DBackward(
         Tensor<T> dOutput, Tensor<T> input, int batchSize, int seqLen)
     {
         var dInput = TensorAllocator.Rent<T>(new[] { batchSize, seqLen, _innerDimension });
-        // Zero-initialize rented buffer — it may contain stale data from previous use
+        // Zero-initialize rented buffer — it may contain stale data from previous use
         for (int i = 0; i < dInput.Length; i++) dInput[i] = NumOps.Zero;
         _convBiasGradient = new Tensor<T>(new[] { _innerDimension });
         _convWeightsGradient = new Tensor<T>(new[] { _innerDimension, _convKernelSize });
@@ -633,7 +665,7 @@ private Tensor<T> DepthwiseConv1DBackward(
 
     /// <summary>
     /// Workaround for Engine.ReduceSum multi-axis [0,1] bug (AiDotNet.Tensors PR #62).
-    /// Sums a [batch, seq, features] tensor over batch and seq → [features].
+    /// Sums a [batch, seq, features] tensor over batch and seq → [features].
     /// </summary>
     private Tensor<T> ReduceSumAxes01(Tensor<T> tensor, int batch, int seq, int features)
     {
@@ -689,7 +721,7 @@ public override void UpdateParameters(T learningRate)
         _outputProjectionBias = Engine.TensorAdd(_outputProjectionBias, Engine.TensorMultiplyScalar(_outputProjectionBiasGradient!, negLR));
 
         // Re-register against the new tensor instances created by the updates above (TensorAdd returns new
-        // tensors), so the autodiff registry tracks the live weights — now including _aLog and _dParam.
+        // tensors), so the autodiff registry tracks the live weights — now including _aLog and _dParam.
         RegisterTrainableParameters();
     }
 
diff --git a/src/NeuralNetworks/Layers/SSM/MesaNetLayer.cs b/src/NeuralNetworks/Layers/SSM/MesaNetLayer.cs
index b8cec70d39..cf3a758ae3 100644
--- a/src/NeuralNetworks/Layers/SSM/MesaNetLayer.cs
+++ b/src/NeuralNetworks/Layers/SSM/MesaNetLayer.cs
@@ -130,30 +130,52 @@ public partial class MesaNetLayer<T> : LayerBase<T>, IShapeContract
     private Tensor<T> _lnBeta;
 
     // Cached values for backward pass
+    [Scratch]
     private Tensor<T>? _lastInput;
+    [Scratch]
     private Tensor<T>? _lastOutput;
+    [Scratch]
     private Tensor<T>? _lastNormalized;
+    [Scratch]
     private Tensor<T>? _lastQuery;
+    [Scratch]
     private Tensor<T>? _lastKey;
+    [Scratch]
     private Tensor<T>? _lastValue;
+    [Scratch]
     private Tensor<T>? _lastGate;
+    [Scratch]
     private Tensor<T>? _lastGateRaw;
+    [Scratch]
     private Tensor<T>? _lastMesaOutput;
     private int[]? _originalInputShape;
 
     // Gradients
+    [Scratch]
     private Tensor<T>? _queryWeightsGradient;
+    [Scratch]
     private Tensor<T>? _queryBiasGradient;
+    [Scratch]
     private Tensor<T>? _keyWeightsGradient;
+    [Scratch]
     private Tensor<T>? _keyBiasGradient;
+    [Scratch]
     private Tensor<T>? _valueWeightsGradient;
+    [Scratch]
     private Tensor<T>? _valueBiasGradient;
+    [Scratch]
     private Tensor<T>? _innerWeightsInitGradient;
+    [Scratch]
     private Tensor<T>? _outputGateWeightsGradient;
+    [Scratch]
     private Tensor<T>? _outputGateBiasGradient;
+    [Scratch]
     private Tensor<T>? _outputProjectionWeightsGradient;
+    [Scratch]
     private Tensor<T>? _outputProjectionBiasGradient;
+    [Scratch]
     private Tensor<T>? _lnGammaGradient;
+    [Scratch]
     private Tensor<T>? _lnBetaGradient;
 
     /// <inheritdoc />
@@ -179,6 +201,9 @@ public partial class MesaNetLayer<T> : LayerBase<T>, IShapeContract
     /// </summary>
     public T Regularization => _regularization;
 
+    /// <summary>Construction state: the 'sequenceLength' the layer was built with.</summary>
+    private readonly int _sequenceLength;
+
     /// <summary>
     /// Creates a new MesaNet layer implementing locally optimal test-time training.
     /// </summary>
@@ -213,6 +238,7 @@ public MesaNetLayer(
             [sequenceLength, modelDimension],
             activationFunction ?? new IdentityActivation<T>())
     {
+        _sequenceLength = sequenceLength;
         InitializationStrategy = initializationStrategy ?? InitializationStrategies<T>.Eager;
 
         if (sequenceLength <= 0)
diff --git a/src/NeuralNetworks/Layers/SSM/MinGRULayer.cs b/src/NeuralNetworks/Layers/SSM/MinGRULayer.cs
index e1f7d9d41e..8ab3356364 100644
--- a/src/NeuralNetworks/Layers/SSM/MinGRULayer.cs
+++ b/src/NeuralNetworks/Layers/SSM/MinGRULayer.cs
@@ -121,24 +121,40 @@ public partial class MinGRULayer<T> : LayerBase<T>, IShapeContract
     private Tensor<T> _outputProjectionBias;
 
     // Cached values for backward pass
+    [Scratch]
     private Tensor<T>? _lastInput;
+    [Scratch]
     private Tensor<T>? _lastOutput;
+    [Scratch]
     private Tensor<T>? _lastProjectedInput;
+    [Scratch]
     private Tensor<T>? _lastGatePreAct;
+    [Scratch]
     private Tensor<T>? _lastGate;
+    [Scratch]
     private Tensor<T>? _lastCandidate;
+    [Scratch]
     private Tensor<T>? _lastHiddenStates;
+    [Scratch]
     private Tensor<T>? _lastRecurrenceOutput;
     private int[]? _originalInputShape;
 
     // Gradients
+    [Scratch]
     private Tensor<T>? _inputProjectionWeightsGradient;
+    [Scratch]
     private Tensor<T>? _inputProjectionBiasGradient;
+    [Scratch]
     private Tensor<T>? _gateWeightsGradient;
+    [Scratch]
     private Tensor<T>? _gateBiasGradient;
+    [Scratch]
     private Tensor<T>? _candidateWeightsGradient;
+    [Scratch]
     private Tensor<T>? _candidateBiasGradient;
+    [Scratch]
     private Tensor<T>? _outputProjectionWeightsGradient;
+    [Scratch]
     private Tensor<T>? _outputProjectionBiasGradient;
 
     /// <inheritdoc />
@@ -159,6 +175,9 @@ public partial class MinGRULayer<T> : LayerBase<T>, IShapeContract
     /// </summary>
     public int ExpansionFactor => _expansionFactor;
 
+    /// <summary>Construction state: the 'sequenceLength' the layer was built with.</summary>
+    private readonly int _sequenceLength;
+
     /// <summary>
     /// Creates a new minGRU layer.
     /// </summary>
@@ -190,6 +209,7 @@ public MinGRULayer(
             [sequenceLength, modelDimension],
             activationFunction ?? new IdentityActivation<T>())
     {
+        _sequenceLength = sequenceLength;
         InitializationStrategy = initializationStrategy ?? InitializationStrategies<T>.Eager;
 
         if (sequenceLength <= 0)
diff --git a/src/NeuralNetworks/Layers/SSM/MinLSTMLayer.cs b/src/NeuralNetworks/Layers/SSM/MinLSTMLayer.cs
index 0e6579244c..728d0358e7 100644
--- a/src/NeuralNetworks/Layers/SSM/MinLSTMLayer.cs
+++ b/src/NeuralNetworks/Layers/SSM/MinLSTMLayer.cs
@@ -1,4 +1,4 @@
-using AiDotNet.Attributes;
+using AiDotNet.Attributes;
 using AiDotNet.Autodiff;
 using AiDotNet.Helpers;
 using AiDotNet.Interfaces;
@@ -133,30 +133,52 @@ public partial class MinLSTMLayer<T> : LayerBase<T>, IShapeContract
     private Tensor<T> _outputProjectionBias;
 
     // Cached forward pass values for backward
+    [Scratch]
     private Tensor<T>? _lastInput;
+    [Scratch]
     private Tensor<T>? _lastOutput;
+    [Scratch]
     private Tensor<T>? _lastProjectedInput;
+    [Scratch]
     private Tensor<T>? _lastForgetGateRaw;
+    [Scratch]
     private Tensor<T>? _lastInputGateRaw;
+    [Scratch]
     private Tensor<T>? _lastForgetGateSigmoid;
+    [Scratch]
     private Tensor<T>? _lastInputGateSigmoid;
+    [Scratch]
     private Tensor<T>? _lastForgetGateNorm;
+    [Scratch]
     private Tensor<T>? _lastInputGateNorm;
+    [Scratch]
     private Tensor<T>? _lastCellCandidate;
+    [Scratch]
     private Tensor<T>? _lastCellStates;
+    [Scratch]
     private Tensor<T>? _lastRecurrenceOutput;
     private int[]? _originalInputShape;
 
     // Gradients
+    [Scratch]
     private Tensor<T>? _inputProjectionWeightsGradient;
+    [Scratch]
     private Tensor<T>? _inputProjectionBiasGradient;
+    [Scratch]
     private Tensor<T>? _forgetGateWeightsGradient;
+    [Scratch]
     private Tensor<T>? _forgetGateBiasGradient;
+    [Scratch]
     private Tensor<T>? _inputGateWeightsGradient;
+    [Scratch]
     private Tensor<T>? _inputGateBiasGradient;
+    [Scratch]
     private Tensor<T>? _cellCandidateWeightsGradient;
+    [Scratch]
     private Tensor<T>? _cellCandidateBiasGradient;
+    [Scratch]
     private Tensor<T>? _outputProjectionWeightsGradient;
+    [Scratch]
     private Tensor<T>? _outputProjectionBiasGradient;
 
     /// <inheritdoc />
@@ -177,6 +199,12 @@ public partial class MinLSTMLayer<T> : LayerBase<T>, IShapeContract
     /// </remarks>
     public int ExpandedDimension => _expandedDimension;
 
+    /// <summary>Construction state: the 'sequenceLength' the layer was built with.</summary>
+    private readonly int _sequenceLength;
+
+    /// <summary>Construction state: the 'expansionFactor' the layer was built with.</summary>
+    private readonly int _expansionFactor;
+
     /// <summary>
     /// Creates a new minLSTM layer.
     /// </summary>
@@ -208,6 +236,8 @@ public MinLSTMLayer(
             [sequenceLength, modelDimension],
             activationFunction ?? new IdentityActivation<T>())
     {
+        _expansionFactor = expansionFactor;
+        _sequenceLength = sequenceLength;
         InitializationStrategy = initializationStrategy ?? InitializationStrategies<T>.Eager;
 
         if (sequenceLength <= 0)
diff --git a/src/NeuralNetworks/Layers/SSM/MixtureOfMambaLayer.cs b/src/NeuralNetworks/Layers/SSM/MixtureOfMambaLayer.cs
index 251d3a0c7b..e61fd09406 100644
--- a/src/NeuralNetworks/Layers/SSM/MixtureOfMambaLayer.cs
+++ b/src/NeuralNetworks/Layers/SSM/MixtureOfMambaLayer.cs
@@ -121,27 +121,45 @@ public partial class MixtureOfMambaLayer<T> : LayerBase<T>, IShapeContract
     private Tensor<T> _outputProjectionBias;
 
     // Cached values for backward pass
+    [Scratch]
     private Tensor<T>? _lastInput;
+    [Scratch]
     private Tensor<T>? _lastOutput;
+    [Scratch]
     private Tensor<T>? _lastRouterLogits;
+    [Scratch]
     private Tensor<T>? _lastRouterWeightsResult;
     private int[,]? _lastTopKIndices;
+    [Scratch]
     private Tensor<T>? _lastExpertOutputs;
+    [Scratch]
     private Tensor<T>? _lastGate;
+    [Scratch]
     private Tensor<T>? _lastGateRaw;
+    [Scratch]
     private Tensor<T>? _lastMoEOutput;
     private int[]? _originalInputShape;
 
     // Gradients
+    [Scratch]
     private Tensor<T>? _routerWeightsGradient;
+    [Scratch]
     private Tensor<T>? _routerBiasGradient;
+    [Scratch]
     private Tensor<T>? _expertAGradient;
+    [Scratch]
     private Tensor<T>? _expertBGradient;
+    [Scratch]
     private Tensor<T>? _expertCGradient;
+    [Scratch]
     private Tensor<T>? _expertDGradient;
+    [Scratch]
     private Tensor<T>? _outputGateWeightsGradient;
+    [Scratch]
     private Tensor<T>? _outputGateBiasGradient;
+    [Scratch]
     private Tensor<T>? _outputProjectionWeightsGradient;
+    [Scratch]
     private Tensor<T>? _outputProjectionBiasGradient;
 
     /// <inheritdoc />
@@ -159,6 +177,9 @@ public partial class MixtureOfMambaLayer<T> : LayerBase<T>, IShapeContract
     /// <summary>Gets the SSM state dimension per expert.</summary>
     public int StateDimension => _stateDimension;
 
+    /// <summary>Construction state: the 'sequenceLength' the layer was built with.</summary>
+    private readonly int _sequenceLength;
+
     /// <summary>
     /// Creates a new Mixture-of-Mamba layer.
     /// </summary>
@@ -196,6 +217,7 @@ public MixtureOfMambaLayer(
             [sequenceLength, modelDimension],
             activationFunction ?? new IdentityActivation<T>())
     {
+        _sequenceLength = sequenceLength;
         InitializationStrategy = initializationStrategy ?? InitializationStrategies<T>.Eager;
 
         if (sequenceLength <= 0)
diff --git a/src/NeuralNetworks/Layers/SSM/MixtureOfMemoriesLayer.cs b/src/NeuralNetworks/Layers/SSM/MixtureOfMemoriesLayer.cs
index 83405ce53e..8964f60fa8 100644
--- a/src/NeuralNetworks/Layers/SSM/MixtureOfMemoriesLayer.cs
+++ b/src/NeuralNetworks/Layers/SSM/MixtureOfMemoriesLayer.cs
@@ -146,36 +146,64 @@ public partial class MixtureOfMemoriesLayer<T> : LayerBase<T>, IShapeContract
     private Tensor<T> _outputProjectionBias;
 
     // Cached values for backward pass
+    [Scratch]
     private Tensor<T>? _lastInput;
+    [Scratch]
     private Tensor<T>? _lastOutput;
+    [Scratch]
     private Tensor<T>? _lastQuery;
+    [Scratch]
     private Tensor<T>? _lastKey;
+    [Scratch]
     private Tensor<T>? _lastValue;
+    [Scratch]
     private Tensor<T>? _lastGate;
+    [Scratch]
     private Tensor<T>? _lastGateRaw;
+    [Scratch]
     private Tensor<T>? _lastMoMOutput;
+    [Scratch]
     private Tensor<T>? _lastWriteWeights; // [batch, seqLen, numMemories]
+    [Scratch]
     private Tensor<T>? _lastReadWeights;  // [batch, seqLen, numMemories]
+    [Scratch]
     private Tensor<T>? _lastForgetGates;  // [batch, seqLen, numMemories]
+    [Scratch]
     private Tensor<T>? _lastForgetGatesRaw;
     private int[]? _originalInputShape;
 
     // Gradients
+    [Scratch]
     private Tensor<T>? _queryWeightsGradient;
+    [Scratch]
     private Tensor<T>? _queryBiasGradient;
+    [Scratch]
     private Tensor<T>? _keyWeightsGradient;
+    [Scratch]
     private Tensor<T>? _keyBiasGradient;
+    [Scratch]
     private Tensor<T>? _valueWeightsGradient;
+    [Scratch]
     private Tensor<T>? _valueBiasGradient;
+    [Scratch]
     private Tensor<T>? _writeRouterWeightsGradient;
+    [Scratch]
     private Tensor<T>? _writeRouterBiasGradient;
+    [Scratch]
     private Tensor<T>? _readRouterWeightsGradient;
+    [Scratch]
     private Tensor<T>? _readRouterBiasGradient;
+    [Scratch]
     private Tensor<T>? _gateRouterWeightsGradient;
+    [Scratch]
     private Tensor<T>? _gateRouterBiasGradient;
+    [Scratch]
     private Tensor<T>? _outputGateWeightsGradient;
+    [Scratch]
     private Tensor<T>? _outputGateBiasGradient;
+    [Scratch]
     private Tensor<T>? _outputProjectionWeightsGradient;
+    [Scratch]
     private Tensor<T>? _outputProjectionBiasGradient;
 
     /// <inheritdoc />
@@ -201,6 +229,9 @@ public partial class MixtureOfMemoriesLayer<T> : LayerBase<T>, IShapeContract
     /// </summary>
     public int NumMemories => _numMemories;
 
+    /// <summary>Construction state: the 'sequenceLength' the layer was built with.</summary>
+    private readonly int _sequenceLength;
+
     /// <summary>
     /// Creates a new Mixture of Memories (MoM) layer.
     /// </summary>
@@ -233,6 +264,7 @@ public MixtureOfMemoriesLayer(
             [sequenceLength, modelDimension],
             activationFunction ?? new IdentityActivation<T>())
     {
+        _sequenceLength = sequenceLength;
         InitializationStrategy = initializationStrategy ?? InitializationStrategies<T>.Eager;
 
         if (sequenceLength <= 0)
diff --git a/src/NeuralNetworks/Layers/SSM/MultiLatentAttentionLayer.cs b/src/NeuralNetworks/Layers/SSM/MultiLatentAttentionLayer.cs
index 285f549739..8c56302d78 100644
--- a/src/NeuralNetworks/Layers/SSM/MultiLatentAttentionLayer.cs
+++ b/src/NeuralNetworks/Layers/SSM/MultiLatentAttentionLayer.cs
@@ -111,27 +111,46 @@ public partial class MultiLatentAttentionLayer<T> : LayerBase<T>, IShapeContract
     private Tensor<T> _outputProjectionBias;
 
     // Cached forward pass values
+    [Scratch]
     private Tensor<T>? _lastInput;
+    [Scratch]
     private Tensor<T>? _lastOutput;
+    [Scratch]
     private Tensor<T>? _lastLatent;
+    [Scratch]
     private Tensor<T>? _lastQuery;
+    [Scratch]
     private Tensor<T>? _lastKey;
+    [Scratch]
     private Tensor<T>? _lastValue;
+    [Scratch]
     private Tensor<T>? _lastAttnWeights;
+    [Scratch]
     private Tensor<T>? _lastAttnOutput;
+    [Scratch]
     private Tensor<T>? _lastOutputGate;
+    [Scratch]
     private Tensor<T>? _lastOutputGateRaw;
     private int[]? _originalInputShape;
 
     // Gradients
+    [Scratch]
     private Tensor<T>? _compressWeightsGradient;
+    [Scratch]
     private Tensor<T>? _compressBiasGradient;
+    [Scratch]
     private Tensor<T>? _keyUpWeightsGradient;
+    [Scratch]
     private Tensor<T>? _valueUpWeightsGradient;
+    [Scratch]
     private Tensor<T>? _queryWeightsGradient;
+    [Scratch]
     private Tensor<T>? _outputGateWeightsGradient;
+    [Scratch]
     private Tensor<T>? _outputGateBiasGradient;
+    [Scratch]
     private Tensor<T>? _outputProjectionWeightsGradient;
+    [Scratch]
     private Tensor<T>? _outputProjectionBiasGradient;
 
     /// <inheritdoc />
@@ -157,6 +176,9 @@ public partial class MultiLatentAttentionLayer<T> : LayerBase<T>, IShapeContract
     /// </summary>
     public int LatentDimension => _latentDimension;
 
+    /// <summary>Construction state: the 'sequenceLength' the layer was built with.</summary>
+    private readonly int _sequenceLength;
+
     /// <summary>
     /// Creates a new Multi-Latent Attention (MLA) layer.
     /// </summary>
@@ -190,6 +212,7 @@ public MultiLatentAttentionLayer(
             [sequenceLength, modelDimension],
             activationFunction ?? new IdentityActivation<T>())
     {
+        _sequenceLength = sequenceLength;
         InitializationStrategy = initializationStrategy ?? InitializationStrategies<T>.Eager;
 
         if (sequenceLength <= 0)
diff --git a/src/NeuralNetworks/Layers/SSM/PaTHAttentionLayer.cs b/src/NeuralNetworks/Layers/SSM/PaTHAttentionLayer.cs
index 79fee442a6..cd32c0fabd 100644
--- a/src/NeuralNetworks/Layers/SSM/PaTHAttentionLayer.cs
+++ b/src/NeuralNetworks/Layers/SSM/PaTHAttentionLayer.cs
@@ -113,27 +113,46 @@ public partial class PaTHAttentionLayer<T> : LayerBase<T>, IShapeContract
     private Tensor<T> _outputProjectionBias;
 
     // Cached values for backward pass
+    [Scratch]
     private Tensor<T>? _lastInput;
+    [Scratch]
     private Tensor<T>? _lastOutput;
+    [Scratch]
     private Tensor<T>? _lastQuery;
+    [Scratch]
     private Tensor<T>? _lastKey;
+    [Scratch]
     private Tensor<T>? _lastValue;
+    [Scratch]
     private Tensor<T>? _lastReflectedQ;
+    [Scratch]
     private Tensor<T>? _lastReflectedK;
+    [Scratch]
     private Tensor<T>? _lastAttentionWeights;
+    [Scratch]
     private Tensor<T>? _lastGate;
+    [Scratch]
     private Tensor<T>? _lastGateRaw;
+    [Scratch]
     private Tensor<T>? _lastAttentionOutput;
     private int[]? _originalInputShape;
 
     // Gradients
+    [Scratch]
     private Tensor<T>? _queryWeightsGradient;
+    [Scratch]
     private Tensor<T>? _keyWeightsGradient;
+    [Scratch]
     private Tensor<T>? _valueWeightsGradient;
+    [Scratch]
     private Tensor<T>? _householderVectorsGradient;
+    [Scratch]
     private Tensor<T>? _outputGateWeightsGradient;
+    [Scratch]
     private Tensor<T>? _outputGateBiasGradient;
+    [Scratch]
     private Tensor<T>? _outputProjectionWeightsGradient;
+    [Scratch]
     private Tensor<T>? _outputProjectionBiasGradient;
 
     /// <inheritdoc />
diff --git a/src/NeuralNetworks/Layers/SSM/RWKV7Block.cs b/src/NeuralNetworks/Layers/SSM/RWKV7Block.cs
index a10f7bf19c..b1b2e76e18 100644
--- a/src/NeuralNetworks/Layers/SSM/RWKV7Block.cs
+++ b/src/NeuralNetworks/Layers/SSM/RWKV7Block.cs
@@ -1,4 +1,4 @@
-using AiDotNet.Attributes;
+using AiDotNet.Attributes;
 using AiDotNet.Autodiff;
 using AiDotNet.Helpers;
 using AiDotNet.Interfaces;
@@ -105,7 +105,7 @@ public partial class RWKV7Block<T> : LayerBase<T>, IShapeContract
     /// The reference (RWKV-LM RWKV-v7) makes the data-dependent part of the decay both LOW-RANK and
     /// tanh-BOUNDED, and initialises this factor to ZERO so the decay starts exactly at the w0 ramp
     /// and the projection only earns influence through training. A full-rank unbounded projection
-    /// initialised to noise — which is what this layer used to have — perturbs the ramp from the
+    /// initialised to noise — which is what this layer used to have — perturbs the ramp from the
     /// first step and lets the decay logit drift without limit, which is how a state with
     /// near-1.0 retention channels runs away.
     /// </remarks>
@@ -134,10 +134,10 @@ public partial class RWKV7Block<T> : LayerBase<T>, IShapeContract
     /// </summary>
     private readonly int _loraRank;
 
-    /// <summary>Gate LoRA rank: <c>max(32, round(5*sqrt(C)/32)*32)</c> — wider than the decay/ICL rank.</summary>
+    /// <summary>Gate LoRA rank: <c>max(32, round(5*sqrt(C)/32)*32)</c> — wider than the decay/ICL rank.</summary>
     private readonly int _gateLoraRank;
 
-    /// <summary>Value-residual LoRA rank: <c>max(32, round(1.7*sqrt(C)/32)*32)</c> — the narrowest of the three.</summary>
+    /// <summary>Value-residual LoRA rank: <c>max(32, round(1.7*sqrt(C)/32)*32)</c> — the narrowest of the three.</summary>
     private readonly int _mvLoraRank;
 
     /// <summary>Bias of the value-residual gate, <c>v0</c>. Init <c>0.73 - linear*0.4</c>.</summary>
@@ -171,15 +171,17 @@ public partial class RWKV7Block<T> : LayerBase<T>, IShapeContract
     /// <remarks>
     /// Exposed for gradient tests, which must move it off zero first. While it is zero the whole
     /// time-mixing branch contributes nothing, so <c>dL/dW = normed^T (dL/dout) W_out^T = 0</c> for
-    /// EVERY parameter upstream of it. That zero is correct, not a defect — but it means a gradient
+    /// EVERY parameter upstream of it. That zero is correct, not a defect — but it means a gradient
     /// test run at initialization measures nothing at all.
     /// </remarks>
     internal Tensor<T> OutputProjectionWeights => _outputWeights;
 
     /// <summary>v_first handed in for THIS forward pass; null when this block is the first layer.</summary>
+    [AiDotNet.Attributes.Scratch]
     private Tensor<T>? _incomingVFirst;
 
     /// <summary>v_first this block publishes for the next one. Per-pass, never carried across calls.</summary>
+    [AiDotNet.Attributes.Scratch]
     private Tensor<T>? _publishedVFirst;
 
     /// <summary>
@@ -187,7 +189,7 @@ public partial class RWKV7Block<T> : LayerBase<T>, IShapeContract
     /// the group norm (arXiv:2503.14456).
     /// </summary>
     /// <remarks>
-    /// A direct current-token path that bypasses the recurrent state entirely — the head's own r·k
+    /// A direct current-token path that bypasses the recurrent state entirely — the head's own r·k
     /// agreement, scaled per channel, gates a copy of v straight into the output. Omitting it does
     /// not break shapes, so it compiles and trains while quietly removing one of the two routes
     /// information can take through the block. Reference init: zeros(H, N) - 0.04.
@@ -259,73 +261,127 @@ public partial class RWKV7Block<T> : LayerBase<T>, IShapeContract
 
     // ============ Cached values for backward ============
 
+    [Scratch]
     private Tensor<T>? _lastInput;
+    [Scratch]
     private Tensor<T>? _lastOutput;
+    [Scratch]
     private Tensor<T>? _lastTimeMixOutput;
+    [Scratch]
     private Tensor<T>? _lastChannelMixOutput;
+    [Scratch]
     private Tensor<T>? _lastNormed1;
+    [Scratch]
     private Tensor<T>? _lastNormed2;
+    [Scratch]
     private Tensor<T>? _lastAfterTimeMix;
     private int[]? _originalInputShape;
 
     // Time mixing forward caches
+    [Scratch]
     private Tensor<T>? _cachedWkvOut;
+    [Scratch]
     private Tensor<T>? _cachedR;       // [batch, seqLen, modelDim] receptance projection
+    [Scratch]
     private Tensor<T>? _cachedK;       // [batch, seqLen, modelDim] key projection
+    [Scratch]
     private Tensor<T>? _cachedV;       // [batch, seqLen, modelDim] value projection
+    [Scratch]
     private Tensor<T>? _cachedTimeMixNormed1; // [batch, seqLen, modelDim] normed input to time mixing
     // WKV pre-gate values are reconstructed from _cachedWkvGated / sigmoid(r) during backward
+    [Scratch]
     private Tensor<T>? _cachedWkvGated;    // [batch, seqLen, modelDim] after gate, before groupNorm
     // Previous tokens per timestep reconstructed from _cachedTimeMixNormed1 during backward
 
     // Channel mixing forward caches
+    [Scratch]
     private Tensor<T>? _cachedChannelRGate;   // [batch, seqLen, modelDim] sigmoid(W_r * rInput)
+    [Scratch]
     private Tensor<T>? _cachedChannelSiLU;    // [batch, seqLen, ffnDim] SiLU(W_k * kInput)
+    [Scratch]
     private Tensor<T>? _cachedChannelVProj;   // [batch, seqLen, modelDim] W_v * SiLU(k)
 
     // ============ Gradients ============
 
+    [AiDotNet.Attributes.Scratch]
     private Tensor<T>? _timeMixRGrad;
+    [AiDotNet.Attributes.Scratch]
     private Tensor<T>? _timeMixKGrad;
+    [AiDotNet.Attributes.Scratch]
     private Tensor<T>? _timeMixVGrad;
+    [AiDotNet.Attributes.Scratch]
     private Tensor<T>? _timeMixAGrad;
+    [AiDotNet.Attributes.Scratch]
     private Tensor<T>? _timeMixBGrad;
+    [AiDotNet.Attributes.Scratch]
     private Tensor<T>? _receptanceWeightsGrad;
+    [AiDotNet.Attributes.Scratch]
     private Tensor<T>? _keyWeightsGrad;
+    [AiDotNet.Attributes.Scratch]
     private Tensor<T>? _valueWeightsGrad;
+    [AiDotNet.Attributes.Scratch]
     private Tensor<T>? _outputWeightsGrad;
+    [AiDotNet.Attributes.Scratch]
     private Tensor<T>? _w1Grad;
+    [AiDotNet.Attributes.Scratch]
     private Tensor<T>? _w2Grad;
+    [AiDotNet.Attributes.Scratch]
     private Tensor<T>? _aBiasGrad;
+    [AiDotNet.Attributes.Scratch]
     private Tensor<T>? _a1Grad;
+    [AiDotNet.Attributes.Scratch]
     private Tensor<T>? _a2Grad;
+    [AiDotNet.Attributes.Scratch]
     private Tensor<T>? _bBiasGrad;
     // Must exist and sit at the same index as _kk/_ka in GetAllParameterTensors: the two lists are
     // zipped positionally by UpdateParameters and GetParameterGradients.
+    [AiDotNet.Attributes.Scratch]
     private Tensor<T>? _v0Grad;
+    [AiDotNet.Attributes.Scratch]
     private Tensor<T>? _v1Grad;
+    [AiDotNet.Attributes.Scratch]
     private Tensor<T>? _v2Grad;
+    [AiDotNet.Attributes.Scratch]
     private Tensor<T>? _rkGrad;
+    [AiDotNet.Attributes.Scratch]
     private Tensor<T>? _timeMixGGrad;
+    [AiDotNet.Attributes.Scratch]
     private Tensor<T>? _g1Grad;
+    [AiDotNet.Attributes.Scratch]
     private Tensor<T>? _g2Grad;
+    [AiDotNet.Attributes.Scratch]
     private Tensor<T>? _kkGrad;
+    [AiDotNet.Attributes.Scratch]
     private Tensor<T>? _kaGrad;
+    [AiDotNet.Attributes.Scratch]
     private Tensor<T>? _groupNormGammaGrad;
+    [AiDotNet.Attributes.Scratch]
     private Tensor<T>? _groupNormBetaGrad;
+    [AiDotNet.Attributes.Scratch]
     private Tensor<T>? _channelMixRGrad;
+    [AiDotNet.Attributes.Scratch]
     private Tensor<T>? _channelMixKGrad;
+    [AiDotNet.Attributes.Scratch]
     private Tensor<T>? _channelKeyWeightsGrad;
+    [AiDotNet.Attributes.Scratch]
     private Tensor<T>? _channelValueWeightsGrad;
+    [AiDotNet.Attributes.Scratch]
     private Tensor<T>? _channelReceptanceWeightsGrad;
+    [AiDotNet.Attributes.Scratch]
     private Tensor<T>? _normGamma1Grad;
+    [AiDotNet.Attributes.Scratch]
     private Tensor<T>? _normBeta1Grad;
+    [AiDotNet.Attributes.Scratch]
     private Tensor<T>? _normGamma2Grad;
+    [AiDotNet.Attributes.Scratch]
     private Tensor<T>? _normBeta2Grad;
 
     // Recurrent state for autoregressive inference
+    [AiDotNet.Attributes.Buffer]
     private Tensor<T>? _recurrentState;       // [batch, numHeads, headDim, headDim]
+    [AiDotNet.Attributes.Buffer]
     private Tensor<T>? _prevToken;            // [batch, modelDim] for time mixing token shift
+    [AiDotNet.Attributes.Buffer]
     private Tensor<T>? _prevChannelToken;     // [batch, modelDim] for channel mixing token shift
 
     /// <summary>
@@ -354,10 +410,16 @@ public partial class RWKV7Block<T> : LayerBase<T>, IShapeContract
 
     /// <summary>
     /// The paper's clamping lower bound <c>u = exp(-e^(-1/2))</c> on the decay multiplier
-    /// (arXiv:2503.14456, Eq. 12 and Appendix C, Theorem 1 — quoted there as 0.5452...).
+    /// (arXiv:2503.14456, Eq. 12 and Appendix C, Theorem 1 — quoted there as 0.5452...).
     /// </summary>
     private static readonly double DecayClampLowerBound = Math.Exp(-Math.Exp(-0.5));
 
+    /// <summary>Construction state: the 'sequenceLength' the layer was built with.</summary>
+    private readonly int _sequenceLength;
+
+    /// <summary>Construction state: the 'ffnMultiplier' the layer was built with.</summary>
+    private readonly double _ffnMultiplier;
+
     /// <summary>
     /// Creates a new RWKV-7 block.
     /// </summary>
@@ -379,6 +441,8 @@ public RWKV7Block(
             [sequenceLength, modelDimension],
             activationFunction ?? new IdentityActivation<T>())
     {
+        _ffnMultiplier = ffnMultiplier;
+        _sequenceLength = sequenceLength;
         // Theorem 1 (arXiv 2503.14456, Appendix C) is stated for c in (0, 1 + u); outside that range
         // the eigenvalue bound it proves no longer applies, so reject rather than silently accept.
         if (globalIclrMultiplier <= 0.0 || globalIclrMultiplier >= 1.0 + DecayClampLowerBound)
@@ -529,7 +593,7 @@ private void InitializeParameters()
         // v7: State evolution projections - initialized for stable decay
         // Decay LoRA. w1 is ZERO so the data-dependent term starts at exactly tanh(0) = 0 and the
         // decay begins precisely at the w0 ramp below; w2 is orthogonal with gain 0.1. This is the
-        // reference scheme, and the zero start is the load-bearing part — the previous full-rank
+        // reference scheme, and the zero start is the load-bearing part — the previous full-rank
         // InitializeProjection(_aWeights) injected noise into the decay logit before a single step.
         _w1.Fill(NumOps.Zero);
         new OrthogonalInitializationStrategy<T>(0.1).InitializeWeights(_w2, _loraRank, _modelDimension);
@@ -542,11 +606,11 @@ private void InitializeParameters()
         //
         // This replaces a flat Fill(-1.0), whose comment claimed "sigmoid(-1) ~ 0.27 retention". That
         // was true of the OLD kernel, which used sigmoid(d) directly as the retention; under Eq. 17
-        // the same value gives ~0.85 on EVERY channel — uniform, long, and outside the spread the
+        // the same value gives ~0.85 on EVERY channel — uniform, long, and outside the spread the
         // architecture relies on to mix short- and long-range memory.
         //
         // ratio_0_to_1 is layer_id/(n_layer-1) in the reference. This block does not receive a layer
-        // index, so the exponent uses ratio_0_to_1 = 0 (exponent 1, a linear ramp) — the reference's
+        // index, so the exponent uses ratio_0_to_1 = 0 (exponent 1, a linear ramp) — the reference's
         // first-layer schedule. Threading a layer index through would let later layers use the
         // steeper curve the reference gives them.
         for (int n = 0; n < _modelDimension; n++)
@@ -559,7 +623,7 @@ private void InitializeParameters()
             _aBias[n] = NumOps.FromDouble(-6.0 + 6.0 * frac + 0.5 + zigzag * 2.5);
         }
 
-        // ICL-rate LoRA, same scheme. No tanh on this path in the reference — the sigmoid applied to
+        // ICL-rate LoRA, same scheme. No tanh on this path in the reference — the sigmoid applied to
         // the sum bounds it.
         _a1.Fill(NumOps.Zero);
         new OrthogonalInitializationStrategy<T>(0.1).InitializeWeights(_a2, _loraRank, _modelDimension);
@@ -646,15 +710,15 @@ private void InitializeParameters()
     private LayerWorkspace<T> Ws => Workspace
         ?? throw new InvalidOperationException("RWKV7Block workspace not initialized.");
 
-    // Workspace buffer indices — TimeMixing timestep buffers
+    // Workspace buffer indices — TimeMixing timestep buffers
     private const int TsRInput = 0, TsKInput = 1, TsVInput = 2;
     private const int TsAInput = 3, TsBInput = 4, TsWkvOut = 5;
-    // Workspace buffer indices — ChannelMixing timestep buffers
+    // Workspace buffer indices — ChannelMixing timestep buffers
     private const int TsCmRInput = 7, TsCmKInput = 8, TsCmKSiLU = 9;
-    // Workspace buffer indices — TimeMixing sequence buffers
+    // Workspace buffer indices — TimeMixing sequence buffers
     private const int SqAllR = 0, SqAllK = 1, SqAllV = 2, SqAllA = 3;
     private const int SqAllB = 4, SqAllWkv = 5, SqAllWkvPre = 6, SqAllWkvGated = 7;
-    // Workspace buffer indices — ChannelMixing sequence buffers
+    // Workspace buffer indices — ChannelMixing sequence buffers
     private const int SqCmAllRGate = 8, SqCmAllVProj = 9;
     // FFN-dimension sequence buffers (separate indices since different shape suffix)
     private const int SqCmAllSiLU = 10, SqCmAllKProj = 11;
@@ -676,8 +740,8 @@ private void InitializeProjection(Tensor<T> tensor)
     /// <returns>The block output, and the v_first to hand to the next block.</returns>
     /// <remarks>
     /// v_first travels as an ordinary VALUE through the call chain rather than through shared mutable
-    /// state. That is what keeps it a normal edge on the tape — the same reason PyTorch expresses it
-    /// as a plain tuple return — and it removes any question of which block is "first" at clone or
+    /// state. That is what keeps it a normal edge on the tape — the same reason PyTorch expresses it
+    /// as a plain tuple return — and it removes any question of which block is "first" at clone or
     /// deserialize time: whoever is handed <c>null</c> is first.
     /// </remarks>
     internal (Tensor<T> Output, Tensor<T> VFirst) ForwardWithValueResidual(Tensor<T> input, Tensor<T>? vFirst)
@@ -748,7 +812,7 @@ private Tensor<T> TimeMixingForward(Tensor<T> x, int batchSize, int seqLen)
         // State: [batch, numHeads, headDim, headDim] - matrix-valued per head.
         // Statefulness is for autoregressive streaming inference only; in training each
         // sequence is independent, so start from a fresh zero state every Forward (otherwise
-        // repeated forwards over the same input are not idempotent — carried state poisons
+        // repeated forwards over the same input are not idempotent — carried state poisons
         // finite-difference gradient checks). Streaming callers run in inference mode.
         var state = (!IsTrainingMode && _recurrentState != null)
             ? _recurrentState
@@ -757,7 +821,7 @@ private Tensor<T> TimeMixingForward(Tensor<T> x, int batchSize, int seqLen)
             ? _prevToken
             : new Tensor<T>(new[] { batchSize, _modelDimension });
 
-        // Cache intermediate values for backward — zero allocation via workspace
+        // Cache intermediate values for backward — zero allocation via workspace
         var allR = Ws.Sequence(SqAllR);
         var allK = Ws.Sequence(SqAllK);
         var allV = Ws.Sequence(SqAllV);
@@ -770,16 +834,16 @@ private Tensor<T> TimeMixingForward(Tensor<T> x, int batchSize, int seqLen)
         // Token-shift mix coefficients as [1, modelDim] rows for broadcasting over
         // batch. Computed once (tape-connected to the mix vectors) and reused each
         // timestep. Expressing the lerp mix*x_t + (1-mix)*x_prev in Engine ops means
-        // (a) every matmul input is a FRESH tensor — the prior code wrote each
+        // (a) every matmul input is a FRESH tensor — the prior code wrote each
         // timestep's r/k/v/a/b input into a single reused workspace buffer, so the
         // tape (which saves references, not snapshots) read only the LAST timestep's
-        // values during backward and produced wrong projection-weight gradients — and
+        // values during backward and produced wrong projection-weight gradients — and
         // (b) the mix coefficients stay on the autodiff graph.
         // ---- #1464 throughput: token-shift + the r/k/v/a/b projections do NOT depend on the
         // recurrent WKV state, so they are computed for the WHOLE sequence in ONE batched GEMM each
         // (over [batch*seqLen, modelDim]) instead of seqLen separate per-timestep GEMMs. Only the
         // WKV state recurrence below stays sequential. Every op is still on the autodiff tape, so
-        // the projection-weight gradients are identical to the per-step formulation — clone-parity
+        // the projection-weight gradients are identical to the per-step formulation — clone-parity
         // and training results are unchanged; this is purely a per-step-overhead reduction.
         var ones1D = Tensor<T>.CreateDefault(new[] { _modelDimension }, NumOps.One);
         // Mix coefficients as [1, 1, modelDim] so they broadcast over [batch, seqLen, modelDim].
@@ -870,7 +934,7 @@ private Tensor<T> TimeMixingForward(Tensor<T> x, int batchSize, int seqLen)
         // readout) runs in ONE fused, differentiable engine op instead of ~10 tape micro-ops per
         // timestep. The kernel applies the r/a/b sigmoids internally and records a single tape node
         // whose backward is the BPTT adjoint of the recurrence, so the projection-weight gradients
-        // are identical to the per-step formulation (clone-parity preserved) — it just removes the
+        // are identical to the per-step formulation (clone-parity preserved) — it just removes the
         // per-timestep tape-dispatch overhead that made the memorization test exceed the 180s budget.
         //   S_t[di,vi] = sigmoid(a)[di]*S_{t-1}[di,vi] + (sigmoid(b)[di]*k[di])*v[vi]
         //   wkv_t[di]  = sigmoid(r)[di] * sum_vi S_t[di,vi]*k[vi]
@@ -914,7 +978,7 @@ private Tensor<T> TimeMixingForward(Tensor<T> x, int batchSize, int seqLen)
 
         var wkvAll = Engine.Rwkv7SequenceForward(Rall, kappa, kTilde, Vall, Aall, iclRateTransition, _numHeads);
 
-        // Group-normalize (per head, per position) and project to the output — both batched over all
+        // Group-normalize (per head, per position) and project to the output — both batched over all
         // positions as [batch*seqLen, modelDim], so NO per-timestep ops remain in time-mixing.
         var wkv2d = Engine.Reshape(wkvAll, new[] { bsl, _modelDimension });
         var normed2d = ApplyGroupNorm(wkv2d, bsl);
@@ -938,7 +1002,7 @@ private Tensor<T> TimeMixingForward(Tensor<T> x, int batchSize, int seqLen)
 
         // Output gate: g = sigmoid(x_g @ g1) @ g2, applied multiplicatively before the projection.
         // g1 is zero-initialised, so sigmoid(0) = 0.5 and g starts as a constant 0.5 @ g2 rather
-        // than at zero — the gate is live from step one, unlike the decay/ICL LoRAs.
+        // than at zero — the gate is live from step one, unlike the decay/ICL LoRAs.
         var gate2d = Engine.TensorMatMul(
             Engine.Sigmoid(Engine.TensorMatMul(Engine.Reshape(gIn, new[] { bsl, _modelDimension }), _g1)),
             _g2);
@@ -954,7 +1018,7 @@ private Tensor<T> TimeMixingForward(Tensor<T> x, int batchSize, int seqLen)
             new[] { batchSize, seqLen, _modelDimension });
 
         // Recurrent-state persistence. In TRAINING each sequence is independent and the carried state is
-        // never read back (the read gate above is `!IsTrainingMode`), so we skip the recurrence entirely —
+        // never read back (the read gate above is `!IsTrainingMode`), so we skip the recurrence entirely —
         // keeping the #1464 per-step-overhead win. In INFERENCE the autoregressive streaming contract
         // requires the final WKV state S_T so the next call can continue the sequence; the fused
         // Rwkv7SequenceForward returns only the gated outputs (not S_T), so compute S_T from the same
@@ -963,7 +1027,7 @@ private Tensor<T> TimeMixingForward(Tensor<T> x, int batchSize, int seqLen)
         // seeded from the prior state (`state`) so token-by-token streaming accumulates correctly.
         if (IsTrainingMode)
         {
-            // Training sequences are independent — clear ALL carried state,
+            // Training sequences are independent — clear ALL carried state,
             // including the token-shift caches. Leaving _prevToken /
             // _prevChannelToken live would mix the first inference token with
             // the last training token if the block is reused for streaming
@@ -997,7 +1061,7 @@ private Tensor<T> TimeMixingForward(Tensor<T> x, int batchSize, int seqLen)
     /// inference. Mirrors the recurrence the fused <c>Rwkv7SequenceForward</c> kernel applies internally:
     /// <c>S_t[h,di,vi] = sigmoid(A_t)[h,di]*S_{t-1}[h,di,vi] + sigmoid(B_t)[h,di]*K_t[h,di]*V_t[h,vi]</c>,
     /// per head. Runs off the autodiff tape (scalar arithmetic over the projected A/B/K/V values) since the
-    /// streaming state carries no gradient — it only seeds the next inference call.
+    /// streaming state carries no gradient — it only seeds the next inference call.
     /// </summary>
     /// <param name="seed">The prior state to continue from (zeros on the first call), [batch, heads, headDim, headDim].</param>
     /// <param name="aAll">Decay projection A over the sequence, [batch, seqLen, modelDim].</param>
@@ -1049,9 +1113,9 @@ private Tensor<T> ChannelMixingForward(Tensor<T> x, int batchSize, int seqLen)
     {
         // ---- #1464: channel mixing is purely position-wise (token-shift + a SiLU-gated FFN, NO
         // recurrence), so the whole sub-layer runs as batched GEMMs over [batch*seqLen, modelDim]
-        // — no per-timestep loop. The previous per-step loop issued ~8 Engine dispatches × seqLen ×
-        // numLayers (≈16K dispatches/forward at seqLen=512, 4 layers); that per-op DISPATCH overhead
-        // — NOT GEMM FLOPs (the GEMMs run at 30–90 GFLOP/s) — dominated the forward (~9.5s measured
+        // — no per-timestep loop. The previous per-step loop issued ~8 Engine dispatches × seqLen ×
+        // numLayers (≈16K dispatches/forward at seqLen=512, 4 layers); that per-op DISPATCH overhead
+        // — NOT GEMM FLOPs (the GEMMs run at 30–90 GFLOP/s) — dominated the forward (~9.5s measured
         // for one Predict) and the training step. The tape backs the gradients automatically (the
         // layer has no manual backward), so weights/activations are identical to the per-step form.
         int bsl = batchSize * seqLen;
@@ -1072,7 +1136,7 @@ private Tensor<T> ChannelMixingForward(Tensor<T> x, int batchSize, int seqLen)
         var rIn = Engine.TensorAdd(Engine.TensorMultiply(x, mixR3), Engine.TensorMultiply(xShifted, invR3));
         var kIn = Engine.TensorAdd(Engine.TensorMultiply(x, mixK3), Engine.TensorMultiply(xShifted, invK3));
 
-        // r = sigmoid(W_r · rIn); k = W_k · kIn; SiLU(k); v = W_v · SiLU(k); out = sigmoid(r) · v.
+        // r = sigmoid(W_r · rIn); k = W_k · kIn; SiLU(k); v = W_v · SiLU(k); out = sigmoid(r) · v.
         var rGate = Engine.Sigmoid(Engine.TensorMatMul(Engine.Reshape(rIn, new[] { bsl, _modelDimension }), _channelReceptanceWeights)); // [bsl, modelDim]
         var kProj = Engine.TensorMatMul(Engine.Reshape(kIn, new[] { bsl, _modelDimension }), _channelKeyWeights); // [bsl, ffnDim]
         var kSiLU = Engine.TensorMultiply(kProj, Engine.Sigmoid(kProj));
@@ -1103,12 +1167,12 @@ private Tensor<T> ApplyGroupNorm(Tensor<T> input, int batchSize)
         // channels share a (mean, variance), with independent gamma/beta per
         // channel. That's exactly Engine.GroupNorm with numGroups=numHeads over
         // a [batchSize, modelDimension, 1, 1] 4D reshape. The previous manual
-        // loop did 4 × batchSize × numHeads × headDimension scalar NumOps calls
+        // loop did 4 × batchSize × numHeads × headDimension scalar NumOps calls
         // (mean + variance + normalize + scale/bias passes); this is one fused
         // call.
         int modelDim = _numHeads * _headDimension;
         var input4D = Engine.Reshape(input, new[] { batchSize, modelDim, 1, 1 });
-        // eps = 64e-5, per the reference (nn.GroupNorm(H, C, eps=64e-5)) — NOT the 1e-6 that was here.
+        // eps = 64e-5, per the reference (nn.GroupNorm(H, C, eps=64e-5)) — NOT the 1e-6 that was here.
         // The WKV readout can leave a head with near-zero variance, and 1/sqrt(var + 1e-6) then
         // amplifies that head enormously; 64e-5 is ~640x larger and deliberately damps it. This is a
         // stability choice in the architecture, not a rounding detail.
diff --git a/src/NeuralNetworks/Layers/SSM/RWKVLayer.cs b/src/NeuralNetworks/Layers/SSM/RWKVLayer.cs
index dc2a9d2326..e52cb0376b 100644
--- a/src/NeuralNetworks/Layers/SSM/RWKVLayer.cs
+++ b/src/NeuralNetworks/Layers/SSM/RWKVLayer.cs
@@ -193,33 +193,58 @@ public partial class RWKVLayer<T> : LayerBase<T>, IShapeContract
     private Tensor<T> _normBeta2;
 
     // Cached values for backward pass
+    [Scratch]
     private Tensor<T>? _lastInput;
+    [Scratch]
     private Tensor<T>? _lastOutput;
+    [Scratch]
     private Tensor<T>? _lastTimeMixOutput;
+    [Scratch]
     private Tensor<T>? _lastChannelMixOutput;
+    [Scratch]
     private Tensor<T>? _lastReceptance;
+    [Scratch]
     private Tensor<T>? _lastWkv;
+    [Scratch]
     private Tensor<T>? _lastState;
     private int[]? _originalInputShape;
 
     // Gradients
+    [Scratch]
     private Tensor<T>? _timeMixRGradient;
+    [Scratch]
     private Tensor<T>? _timeMixKGradient;
+    [Scratch]
     private Tensor<T>? _timeMixVGradient;
+    [Scratch]
     private Tensor<T>? _receptanceWeightsGradient;
+    [Scratch]
     private Tensor<T>? _keyWeightsGradient;
+    [Scratch]
     private Tensor<T>? _valueWeightsGradient;
+    [Scratch]
     private Tensor<T>? _outputWeightsGradient;
+    [Scratch]
     private Tensor<T>? _decayBiasGradient;
+    [Scratch]
     private Tensor<T>? _bonusGradient;
+    [Scratch]
     private Tensor<T>? _channelMixRGradient;
+    [Scratch]
     private Tensor<T>? _channelMixKGradient;
+    [Scratch]
     private Tensor<T>? _channelKeyWeightsGradient;
+    [Scratch]
     private Tensor<T>? _channelValueWeightsGradient;
+    [Scratch]
     private Tensor<T>? _channelReceptanceWeightsGradient;
+    [Scratch]
     private Tensor<T>? _normGamma1Gradient;
+    [Scratch]
     private Tensor<T>? _normBeta1Gradient;
+    [Scratch]
     private Tensor<T>? _normGamma2Gradient;
+    [Scratch]
     private Tensor<T>? _normBeta2Gradient;
 
     /// <inheritdoc />
@@ -259,6 +284,9 @@ public partial class RWKVLayer<T> : LayerBase<T>, IShapeContract
     /// </summary>
     public int HeadDimension => _headDimension;
 
+    /// <summary>Construction state: the 'sequenceLength' the layer was built with.</summary>
+    private readonly int _sequenceLength;
+
     /// <summary>
     /// Creates a new RWKV layer.
     /// </summary>
@@ -294,6 +322,7 @@ public RWKVLayer(
             [-1, modelDimension],
             activationFunction ?? new IdentityActivation<T>())
     {
+        _sequenceLength = sequenceLength;
         InitializationStrategy = initializationStrategy ?? InitializationStrategies<T>.Eager;
 
         if (sequenceLength <= 0)
diff --git a/src/NeuralNetworks/Layers/SSM/RealGatedLinearRecurrenceLayer.cs b/src/NeuralNetworks/Layers/SSM/RealGatedLinearRecurrenceLayer.cs
index c0f5744f62..b649d83e7a 100644
--- a/src/NeuralNetworks/Layers/SSM/RealGatedLinearRecurrenceLayer.cs
+++ b/src/NeuralNetworks/Layers/SSM/RealGatedLinearRecurrenceLayer.cs
@@ -121,26 +121,44 @@ public partial class RealGatedLinearRecurrenceLayer<T> : LayerBase<T>, IShapeCon
     private Tensor<T> _outputProjectionBias;
 
     // Cached values
+    [Scratch]
     private Tensor<T>? _lastInput;
+    [Scratch]
     private Tensor<T>? _lastOutput;
+    [Scratch]
     private Tensor<T>? _lastProjectedInput;
+    [Scratch]
     private Tensor<T>? _lastRecurrenceGate;
+    [Scratch]
     private Tensor<T>? _lastInputGate;
+    [Scratch]
     private Tensor<T>? _lastHiddenStates;
+    [Scratch]
     private Tensor<T>? _lastDecayFactors;
+    [Scratch]
     private Tensor<T>? _lastRecurrenceOutput;
     private int[]? _originalInputShape;
 
     // Gradients
+    [Scratch]
     private Tensor<T>? _inputProjectionWeightsGradient;
+    [Scratch]
     private Tensor<T>? _inputProjectionBiasGradient;
+    [Scratch]
     private Tensor<T>? _recurrenceGateWeightsGradient;
+    [Scratch]
     private Tensor<T>? _recurrenceGateBiasGradient;
+    [Scratch]
     private Tensor<T>? _inputGateWeightsGradient;
+    [Scratch]
     private Tensor<T>? _inputGateBiasGradient;
+    [Scratch]
     private Tensor<T>? _valueProjectionWeightsGradient;
+    [Scratch]
     private Tensor<T>? _decayParamGradient;
+    [Scratch]
     private Tensor<T>? _outputProjectionWeightsGradient;
+    [Scratch]
     private Tensor<T>? _outputProjectionBiasGradient;
 
     /// <inheritdoc />
@@ -172,6 +190,9 @@ public partial class RealGatedLinearRecurrenceLayer<T> : LayerBase<T>, IShapeCon
     /// </remarks>
     public int RecurrenceDimension => _recurrenceDimension;
 
+    /// <summary>Construction state: the 'sequenceLength' the layer was built with.</summary>
+    private readonly int _sequenceLength;
+
     /// <summary>
     /// Creates a new Real-Gated Linear Recurrence Unit (RG-LRU) layer.
     /// </summary>
@@ -205,6 +226,7 @@ public RealGatedLinearRecurrenceLayer(
             [-1, modelDimension],
             activationFunction ?? new IdentityActivation<T>())
     {
+        _sequenceLength = sequenceLength;
         InitializationStrategy = initializationStrategy ?? InitializationStrategies<T>.Eager;
 
         if (modelDimension <= 0)
diff --git a/src/NeuralNetworks/Layers/SSM/RebasedLayer.cs b/src/NeuralNetworks/Layers/SSM/RebasedLayer.cs
index 8e3922c48f..0e41ddb9e9 100644
--- a/src/NeuralNetworks/Layers/SSM/RebasedLayer.cs
+++ b/src/NeuralNetworks/Layers/SSM/RebasedLayer.cs
@@ -105,28 +105,48 @@ public partial class RebasedLayer<T> : LayerBase<T>, IShapeContract
     private Tensor<T> _outputProjectionBias;
 
     // Cached forward pass values
+    [Scratch]
     private Tensor<T>? _lastInput;
+    [Scratch]
     private Tensor<T>? _lastOutput;
+    [Scratch]
     private Tensor<T>? _lastQuery;
+    [Scratch]
     private Tensor<T>? _lastKey;
+    [Scratch]
     private Tensor<T>? _lastValue;
+    [Scratch]
     private Tensor<T>? _lastPhiQ;
+    [Scratch]
     private Tensor<T>? _lastPhiK;
+    [Scratch]
     private Tensor<T>? _lastPhiQNorm;
+    [Scratch]
     private Tensor<T>? _lastPhiKNorm;
+    [Scratch]
     private Tensor<T>? _lastOutputGate;
+    [Scratch]
     private Tensor<T>? _lastOutputGateRaw;
+    [Scratch]
     private Tensor<T>? _lastLinearAttnOutput;
+    [Scratch]
     private Tensor<T>? _lastDenominators;
     private int[]? _originalInputShape;
 
     // Gradients
+    [Scratch]
     private Tensor<T>? _queryWeightsGradient;
+    [Scratch]
     private Tensor<T>? _keyWeightsGradient;
+    [Scratch]
     private Tensor<T>? _valueWeightsGradient;
+    [Scratch]
     private Tensor<T>? _outputGateWeightsGradient;
+    [Scratch]
     private Tensor<T>? _outputGateBiasGradient;
+    [Scratch]
     private Tensor<T>? _outputProjectionWeightsGradient;
+    [Scratch]
     private Tensor<T>? _outputProjectionBiasGradient;
 
     /// <inheritdoc />
@@ -147,6 +167,9 @@ public partial class RebasedLayer<T> : LayerBase<T>, IShapeContract
     /// </summary>
     public int HeadDimension => _headDimension;
 
+    /// <summary>Construction state: the 'sequenceLength' the layer was built with.</summary>
+    private readonly int _sequenceLength;
+
     /// <summary>
     /// Creates a new ReBased linear attention layer.
     /// </summary>
@@ -175,6 +198,7 @@ public RebasedLayer(
             [sequenceLength, modelDimension],
             activationFunction ?? new IdentityActivation<T>())
     {
+        _sequenceLength = sequenceLength;
         InitializationStrategy = initializationStrategy ?? InitializationStrategies<T>.Eager;
 
         if (sequenceLength <= 0)
diff --git a/src/NeuralNetworks/Layers/SSM/RetNetLayer.cs b/src/NeuralNetworks/Layers/SSM/RetNetLayer.cs
index aa9f3aeb43..7dc7ec7d25 100644
--- a/src/NeuralNetworks/Layers/SSM/RetNetLayer.cs
+++ b/src/NeuralNetworks/Layers/SSM/RetNetLayer.cs
@@ -138,34 +138,60 @@ public partial class RetNetLayer<T> : LayerBase<T>, IShapeContract
     private Tensor<T> _groupNormBias;
 
     // Cached values for backward pass
+    [Scratch]
     private Tensor<T>? _lastInput;
+    [Scratch]
     private Tensor<T>? _lastOutput;
+    [Scratch]
     private Tensor<T>? _lastQuery;
+    [Scratch]
     private Tensor<T>? _lastKey;
+    [Scratch]
     private Tensor<T>? _lastValue;
+    [Scratch]
     private Tensor<T>? _lastRetentionOutput;
+    [Scratch]
     private Tensor<T>? _lastNormedRetention;
+    [Scratch]
     private Tensor<T>? _lastGateRaw;
+    [Scratch]
     private Tensor<T>? _lastGate;
+    [Scratch]
     private Tensor<T>? _lastDecayMasks;
+    [Scratch]
     private Tensor<T>? _lastRetentionScores;
+    [Scratch]
     private Tensor<T>? _lastGroupNormMean;
+    [Scratch]
     private Tensor<T>? _lastGroupNormVar;
     private int[]? _originalInputShape;
 
     // Gradients
+    [Scratch]
     private Tensor<T>? _queryWeightsGradient;
+    [Scratch]
     private Tensor<T>? _queryBiasGradient;
+    [Scratch]
     private Tensor<T>? _keyWeightsGradient;
+    [Scratch]
     private Tensor<T>? _keyBiasGradient;
+    [Scratch]
     private Tensor<T>? _valueWeightsGradient;
+    [Scratch]
     private Tensor<T>? _valueBiasGradient;
+    [Scratch]
     private Tensor<T>? _gammasGradient;
+    [Scratch]
     private Tensor<T>? _outputGateWeightsGradient;
+    [Scratch]
     private Tensor<T>? _outputGateBiasGradient;
+    [Scratch]
     private Tensor<T>? _outputProjectionWeightsGradient;
+    [Scratch]
     private Tensor<T>? _outputProjectionBiasGradient;
+    [Scratch]
     private Tensor<T>? _groupNormScaleGradient;
+    [Scratch]
     private Tensor<T>? _groupNormBiasGradient;
 
     /// <inheritdoc />
@@ -186,6 +212,9 @@ public partial class RetNetLayer<T> : LayerBase<T>, IShapeContract
     /// </summary>
     public int HeadDimension => _headDimension;
 
+    /// <summary>Construction state: the 'sequenceLength' the layer was built with.</summary>
+    private readonly int _sequenceLength;
+
     /// <summary>
     /// Creates a new RetNet (Retentive Network) layer.
     /// </summary>
@@ -218,6 +247,7 @@ public RetNetLayer(
             [sequenceLength, modelDimension],
             activationFunction ?? new IdentityActivation<T>())
     {
+        _sequenceLength = sequenceLength;
         InitializationStrategy = initializationStrategy ?? InitializationStrategies<T>.Eager;
 
         if (sequenceLength <= 0)
diff --git a/src/NeuralNetworks/Layers/SSM/RodimusLayer.cs b/src/NeuralNetworks/Layers/SSM/RodimusLayer.cs
index bb61746d58..b74fae673c 100644
--- a/src/NeuralNetworks/Layers/SSM/RodimusLayer.cs
+++ b/src/NeuralNetworks/Layers/SSM/RodimusLayer.cs
@@ -1,4 +1,4 @@
-using AiDotNet.Attributes;
+using AiDotNet.Attributes;
 using AiDotNet.Autodiff;
 using AiDotNet.Helpers;
 using AiDotNet.Interfaces;
@@ -129,31 +129,53 @@ public partial class RodimusLayer<T> : LayerBase<T>, IShapeContract
     private Tensor<T> _outputProjectionBias;
 
     // Cached forward pass values
+    [Scratch]
     private Tensor<T>? _lastInput;
+    [Scratch]
     private Tensor<T>? _lastOutput;
+    [Scratch]
     private Tensor<T>? _lastQuery;
+    [Scratch]
     private Tensor<T>? _lastKey;
+    [Scratch]
     private Tensor<T>? _lastValue;
+    [Scratch]
     private Tensor<T>? _lastTemperature;
+    [Scratch]
     private Tensor<T>? _lastTemperatureRaw;
+    [Scratch]
     private Tensor<T>? _lastForgetGate;
     private Tensor<T>? _lastOutputGate;
+    [Scratch]
     private Tensor<T>? _lastOutputGateRaw;
+    [Scratch]
     private Tensor<T>? _lastRecurrenceOutput;
+    [Scratch]
     private Tensor<T>? _lastStates;
     private int[]? _originalInputShape;
 
     // Gradients
+    [Scratch]
     private Tensor<T>? _queryWeightsGradient;
+    [Scratch]
     private Tensor<T>? _keyWeightsGradient;
+    [Scratch]
     private Tensor<T>? _valueWeightsGradient;
+    [Scratch]
     private Tensor<T>? _temperatureWeightsGradient;
+    [Scratch]
     private Tensor<T>? _temperatureBiasGradient;
+    [Scratch]
     private Tensor<T>? _forgetGateWeightsGradient;
+    [Scratch]
     private Tensor<T>? _forgetGateBiasGradient;
+    [Scratch]
     private Tensor<T>? _outputGateWeightsGradient;
+    [Scratch]
     private Tensor<T>? _outputGateBiasGradient;
+    [Scratch]
     private Tensor<T>? _outputProjectionWeightsGradient;
+    [Scratch]
     private Tensor<T>? _outputProjectionBiasGradient;
 
     /// <inheritdoc />
@@ -179,6 +201,12 @@ public partial class RodimusLayer<T> : LayerBase<T>, IShapeContract
     /// </summary>
     public double BaseTemperature => _baseTemperature;
 
+    /// <summary>Construction state: the 'sequenceLength' the layer was built with.</summary>
+    private readonly int _sequenceLength;
+
+    /// <summary>Construction state: the 'temperature' the layer was built with.</summary>
+    private readonly double _temperature;
+
     /// <summary>
     /// Creates a new Rodimus layer with data-dependent tempered selection.
     /// </summary>
@@ -214,6 +242,8 @@ public RodimusLayer(
             [sequenceLength, modelDimension],
             activationFunction ?? new IdentityActivation<T>())
     {
+        _temperature = temperature;
+        _sequenceLength = sequenceLength;
         InitializationStrategy = initializationStrategy ?? InitializationStrategies<T>.Eager;
 
         if (sequenceLength <= 0)
diff --git a/src/NeuralNetworks/Layers/SSM/Rwkv7Stack.cs b/src/NeuralNetworks/Layers/SSM/Rwkv7Stack.cs
index 86bd73d6f0..2f4d186320 100644
--- a/src/NeuralNetworks/Layers/SSM/Rwkv7Stack.cs
+++ b/src/NeuralNetworks/Layers/SSM/Rwkv7Stack.cs
@@ -47,6 +47,24 @@ public partial class Rwkv7Stack<T> : LayerBase<T>, IShapeContract
 {
     private readonly List<RWKV7Block<T>> _blocks;
 
+    /// <summary>Construction state: the 'numLayers' the layer was built with.</summary>
+    private readonly int _numLayers;
+
+    /// <summary>Construction state: the 'sequenceLength' the layer was built with.</summary>
+    private readonly int _sequenceLength;
+
+    /// <summary>Construction state: the 'ffnMultiplier' the layer was built with.</summary>
+    private readonly double _ffnMultiplier;
+
+    /// <summary>Construction state: the 'globalIclrMultiplier' the layer was built with.</summary>
+    private readonly double _globalIclrMultiplier;
+
+    /// <summary>Construction state: the 'modelDimension' the layer was built with.</summary>
+    private readonly int _modelDimension;
+
+    /// <summary>Construction state: the 'numHeads' the layer was built with.</summary>
+    private readonly int _numHeads;
+
     /// <summary>Creates a stack of RWKV-7 blocks sharing one value-residual chain.</summary>
     /// <param name="numLayers">Number of blocks. Must be at least one.</param>
     /// <param name="sequenceLength">Maximum sequence length.</param>
@@ -67,6 +85,12 @@ public Rwkv7Stack(
         : base([sequenceLength, modelDimension], [sequenceLength, modelDimension],
                (IActivationFunction<T>)new IdentityActivation<T>())
     {
+        _numHeads = numHeads;
+        _modelDimension = modelDimension;
+        _globalIclrMultiplier = globalIclrMultiplier;
+        _ffnMultiplier = ffnMultiplier;
+        _sequenceLength = sequenceLength;
+        _numLayers = numLayers;
         if (numLayers < 1)
             throw new ArgumentOutOfRangeException(nameof(numLayers), "An RWKV-7 stack needs at least one block.");
 
diff --git a/src/NeuralNetworks/Layers/SSM/S4DLayer.cs b/src/NeuralNetworks/Layers/SSM/S4DLayer.cs
index 23015b4725..a58f9a526c 100644
--- a/src/NeuralNetworks/Layers/SSM/S4DLayer.cs
+++ b/src/NeuralNetworks/Layers/SSM/S4DLayer.cs
@@ -118,26 +118,44 @@ public partial class S4DLayer<T> : LayerBase<T>, IShapeContract
     private Tensor<T> _logDelta;
 
     // Cached values for backward pass
+    [Scratch]
     private Tensor<T>? _lastInput;
+    [Scratch]
     private Tensor<T>? _lastOutput;
+    [Scratch]
     private Tensor<T>? _lastProjectedInput;
+    [Scratch]
     private Tensor<T>? _lastHiddenStatesReal;
+    [Scratch]
     private Tensor<T>? _lastHiddenStatesImag;
+    [Scratch]
     private Tensor<T>? _lastScanOutputReal;
     private int[]? _originalInputShape;
 
     // Gradients
+    [Scratch]
     private Tensor<T>? _aRealGradient;
+    [Scratch]
     private Tensor<T>? _aImagGradient;
+    [Scratch]
     private Tensor<T>? _bRealGradient;
+    [Scratch]
     private Tensor<T>? _bImagGradient;
+    [Scratch]
     private Tensor<T>? _cRealGradient;
+    [Scratch]
     private Tensor<T>? _cImagGradient;
+    [Scratch]
     private Tensor<T>? _dParamGradient;
+    [Scratch]
     private Tensor<T>? _inputProjectionWeightsGradient;
+    [Scratch]
     private Tensor<T>? _inputProjectionBiasGradient;
+    [Scratch]
     private Tensor<T>? _outputProjectionWeightsGradient;
+    [Scratch]
     private Tensor<T>? _outputProjectionBiasGradient;
+    [Scratch]
     private Tensor<T>? _logDeltaGradient;
 
     /// <inheritdoc />
@@ -168,6 +186,12 @@ public partial class S4DLayer<T> : LayerBase<T>, IShapeContract
     /// </summary>
     public int InnerDimension => _innerDimension;
 
+    /// <summary>Construction state: the 'sequenceLength' the layer was built with.</summary>
+    private readonly int _sequenceLength;
+
+    /// <summary>Construction state: the 'expandFactor' the layer was built with.</summary>
+    private readonly int _expandFactor;
+
     /// <summary>
     /// Creates a new S4D (Diagonal State Space) layer.
     /// </summary>
@@ -201,6 +225,8 @@ public S4DLayer(
             [sequenceLength, modelDimension],
             activationFunction ?? new IdentityActivation<T>())
     {
+        _expandFactor = expandFactor;
+        _sequenceLength = sequenceLength;
         InitializationStrategy = initializationStrategy ?? InitializationStrategies<T>.Eager;
 
         if (modelDimension <= 0)
@@ -477,7 +503,9 @@ private Tensor<T> FusedScanForward(Tensor<T> x, int batchSize, int seqLen)
     }
 
     // Cached values for kernel-based backward
+    [Scratch]
     private Tensor<T>? _cachedKernel = null;
+    [Scratch]
     private Tensor<T>? _cachedKernelDelta;
 
     private Tensor<T> ComplexRecurrentScan(Tensor<T> x, int batchSize, int seqLen)
@@ -655,7 +683,7 @@ private Tensor<T> KernelBasedBackward(
         // Both inner accumulations below are O(seqLen^2) per (batch, channel).
         // Hoist the kernel row and the per-(b,d) input / upstream-gradient
         // columns into raw double buffers so the hot loops are pure double
-        // arithmetic — the tensor indexer + NumOps virtual calls would
+        // arithmetic — the tensor indexer + NumOps virtual calls would
         // otherwise dominate at paper-scale sequence lengths.
         var kRowB = new double[seqLen];
         var xColB = new double[seqLen];
@@ -1006,8 +1034,8 @@ private Tensor<T> ComplexRecurrentScanBackward(
                     double gradAi = dt * (dAbR * abar_i + dAbI * abar_r);
 
                     // B_bar contribution: dL/dA += dL/dB_bar * dB_bar/dA
-                    // B_bar = f(A) * B where f(A) = (exp(Δ*A) - 1) / A
-                    // df/dA = [Δ*A_bar*A - (A_bar - 1)] / A²
+                    // B_bar = f(A) * B where f(A) = (exp(Δ*A) - 1) / A
+                    // df/dA = [Δ*A_bar*A - (A_bar - 1)] / A²
                     // dB_bar/dA = df/dA * B
                     // dL/dA += Re(conj(dL/dB_bar) * dB_bar/dA)... but since we track real/imag separately:
                     // dL/dA_real = Re(dL_dBbar_complex * dBbar/dA_complex)
@@ -1019,19 +1047,19 @@ private Tensor<T> ComplexRecurrentScanBackward(
                     double aMagSq = ar * ar + ai * ai;
                     if (aMagSq > 1e-12)
                     {
-                        // num = Δ * A_bar * A - (A_bar - 1)  (complex)
+                        // num = Δ * A_bar * A - (A_bar - 1)  (complex)
                         // A_bar * A: (abar_r + i*abar_i) * (ar + i*ai)
                         double abarA_r = abar_r * ar - abar_i * ai;
                         double abarA_i = abar_r * ai + abar_i * ar;
                         double num_r = dt * abarA_r - (abar_r - 1);
                         double num_i = dt * abarA_i - abar_i;
 
-                        // A² = (ar² - ai²) + 2*ar*ai*i
+                        // A² = (ar² - ai²) + 2*ar*ai*i
                         double aSq_r = ar * ar - ai * ai;
                         double aSq_i = 2 * ar * ai;
                         double aSqMagSq = aSq_r * aSq_r + aSq_i * aSq_i;
 
-                        // df/dA = num / A² (complex division)
+                        // df/dA = num / A² (complex division)
                         double dfda_r = (num_r * aSq_r + num_i * aSq_i) / aSqMagSq;
                         double dfda_i = (num_i * aSq_r - num_r * aSq_i) / aSqMagSq;
 
diff --git a/src/NeuralNetworks/Layers/SSM/S5Layer.cs b/src/NeuralNetworks/Layers/SSM/S5Layer.cs
index e4af411fea..001bcb9be5 100644
--- a/src/NeuralNetworks/Layers/SSM/S5Layer.cs
+++ b/src/NeuralNetworks/Layers/SSM/S5Layer.cs
@@ -131,26 +131,44 @@ public partial class S5Layer<T> : LayerBase<T>, IShapeContract
     private Tensor<T> _outputProjectionBias;
 
     // Cached values for backward pass
+    [Scratch]
     private Tensor<T>? _lastInput;
+    [Scratch]
     private Tensor<T>? _lastOutput;
+    [Scratch]
     private Tensor<T>? _lastProjectedInput;
+    [Scratch]
     private Tensor<T>? _lastHiddenStatesReal;
+    [Scratch]
     private Tensor<T>? _lastHiddenStatesImag;
+    [Scratch]
     private Tensor<T>? _lastScanOutputReal;
     private int[]? _originalInputShape;
 
     // Gradients
+    [Scratch]
     private Tensor<T>? _aRealGradient;
+    [Scratch]
     private Tensor<T>? _aImagGradient;
+    [Scratch]
     private Tensor<T>? _bRealGradient;
+    [Scratch]
     private Tensor<T>? _bImagGradient;
+    [Scratch]
     private Tensor<T>? _cRealGradient;
+    [Scratch]
     private Tensor<T>? _cImagGradient;
+    [Scratch]
     private Tensor<T>? _dParamGradient;
+    [Scratch]
     private Tensor<T>? _logDeltaGradient;
+    [Scratch]
     private Tensor<T>? _inputProjectionWeightsGradient;
+    [Scratch]
     private Tensor<T>? _inputProjectionBiasGradient;
+    [Scratch]
     private Tensor<T>? _outputProjectionWeightsGradient;
+    [Scratch]
     private Tensor<T>? _outputProjectionBiasGradient;
 
     /// <inheritdoc />
@@ -172,6 +190,9 @@ public partial class S5Layer<T> : LayerBase<T>, IShapeContract
     /// </remarks>
     public int StateDimension => _stateDimension;
 
+    /// <summary>Construction state: the 'sequenceLength' the layer was built with.</summary>
+    private readonly int _sequenceLength;
+
     /// <summary>
     /// Creates a new S5 (Simplified State Space) layer.
     /// </summary>
@@ -201,6 +222,7 @@ public S5Layer(
             [sequenceLength, modelDimension],
             activationFunction ?? new IdentityActivation<T>())
     {
+        _sequenceLength = sequenceLength;
         InitializationStrategy = initializationStrategy ?? InitializationStrategies<T>.Eager;
 
         if (sequenceLength <= 0)
@@ -420,6 +442,7 @@ private Tensor<T> FusedMimoScanForward(Tensor<T> u, int batchSize, int seqLen)
     }
 
     private T[,,]? _cachedKernel = null;
+    [Scratch]
     private Vector<T>? _cachedDelta = null;
 
     private Tensor<T> MIMOParallelScan(Tensor<T> u, int batchSize, int seqLen)
diff --git a/src/NeuralNetworks/Layers/SSM/TTTLayer.cs b/src/NeuralNetworks/Layers/SSM/TTTLayer.cs
index 3bf260c511..1bdf697900 100644
--- a/src/NeuralNetworks/Layers/SSM/TTTLayer.cs
+++ b/src/NeuralNetworks/Layers/SSM/TTTLayer.cs
@@ -131,32 +131,56 @@ public partial class TTTLayer<T> : LayerBase<T>, IShapeContract
     private Tensor<T> _lnBeta;  // [modelDim]
 
     // Cached values for backward pass
+    [Scratch]
     private Tensor<T>? _lastInput;
+    [Scratch]
     private Tensor<T>? _lastOutput;
+    [Scratch]
     private Tensor<T>? _lastNormalized;
+    [Scratch]
     private Tensor<T>? _lastQuery;
+    [Scratch]
     private Tensor<T>? _lastKey;
+    [Scratch]
     private Tensor<T>? _lastValue;
+    [Scratch]
     private Tensor<T>? _lastGate;
+    [Scratch]
     private Tensor<T>? _lastGateRaw;
+    [Scratch]
     private Tensor<T>? _lastTTTOutput;
+    [Scratch]
     private Tensor<T>? _lastInnerWeights; // All W_t snapshots: [batch, seqLen+1, numHeads, headDim, headDim]
     private int[]? _originalInputShape;
 
     // Gradients
+    [Scratch]
     private Tensor<T>? _queryWeightsGradient;
+    [Scratch]
     private Tensor<T>? _queryBiasGradient;
+    [Scratch]
     private Tensor<T>? _keyWeightsGradient;
+    [Scratch]
     private Tensor<T>? _keyBiasGradient;
+    [Scratch]
     private Tensor<T>? _valueWeightsGradient;
+    [Scratch]
     private Tensor<T>? _valueBiasGradient;
+    [Scratch]
     private Tensor<T>? _innerWeightsInitGradient;
+    [Scratch]
     private Tensor<T>? _etaScaleGradient;
+    [Scratch]
     private Tensor<T>? _outputGateWeightsGradient;
+    [Scratch]
     private Tensor<T>? _outputGateBiasGradient;
+    [Scratch]
     private Tensor<T>? _outputProjectionWeightsGradient;
+    [Scratch]
     private Tensor<T>? _outputProjectionBiasGradient;
+    [Scratch]
     private Tensor<T>? _lnGammaGradient;
+    [Scratch]
     private Tensor<T>? _lnBetaGradient;
 
     /// <inheritdoc />
@@ -182,6 +206,9 @@ public partial class TTTLayer<T> : LayerBase<T>, IShapeContract
     /// </summary>
     public T InnerLearningRate => _innerLearningRate;
 
+    /// <summary>Construction state: the 'sequenceLength' the layer was built with.</summary>
+    private readonly int _sequenceLength;
+
     /// <summary>
     /// Creates a new TTT (Test-Time Training) layer implementing the TTT-Linear variant.
     /// </summary>
@@ -218,6 +245,7 @@ public TTTLayer(
             [sequenceLength, modelDimension],
             activationFunction ?? new IdentityActivation<T>())
     {
+        _sequenceLength = sequenceLength;
         InitializationStrategy = initializationStrategy ?? InitializationStrategies<T>.Eager;
 
         if (sequenceLength <= 0)
diff --git a/src/NeuralNetworks/Layers/SSM/TransNormerLLMLayer.cs b/src/NeuralNetworks/Layers/SSM/TransNormerLLMLayer.cs
index e67c743f3a..2ca1f94812 100644
--- a/src/NeuralNetworks/Layers/SSM/TransNormerLLMLayer.cs
+++ b/src/NeuralNetworks/Layers/SSM/TransNormerLLMLayer.cs
@@ -117,33 +117,58 @@ public partial class TransNormerLLMLayer<T> : LayerBase<T>, IShapeContract
     private Tensor<T> _outputProjectionBias;
 
     // Cached forward pass values
+    [Scratch]
     private Tensor<T>? _lastInput;
+    [Scratch]
     private Tensor<T>? _lastOutput;
+    [Scratch]
     private Tensor<T>? _lastQuery;
+    [Scratch]
     private Tensor<T>? _lastKey;
+    [Scratch]
     private Tensor<T>? _lastValue;
+    [Scratch]
     private Tensor<T>? _lastQueryNormed;
+    [Scratch]
     private Tensor<T>? _lastKeyNormed;
+    [Scratch]
     private Tensor<T>? _lastQueryRmsInv;
+    [Scratch]
     private Tensor<T>? _lastKeyRmsInv;
+    [Scratch]
     private Tensor<T>? _lastAttnRaw;
+    [Scratch]
     private Tensor<T>? _lastAttnNormed;
+    [Scratch]
     private Tensor<T>? _lastAttnRmsInv;
+    [Scratch]
     private Tensor<T>? _lastGateRaw;
+    [Scratch]
     private Tensor<T>? _lastGate;
     private int[]? _originalInputShape;
 
     // Gradients
+    [Scratch]
     private Tensor<T>? _queryWeightsGradient;
+    [Scratch]
     private Tensor<T>? _keyWeightsGradient;
+    [Scratch]
     private Tensor<T>? _valueWeightsGradient;
+    [Scratch]
     private Tensor<T>? _queryNormScaleGradient;
+    [Scratch]
     private Tensor<T>? _keyNormScaleGradient;
+    [Scratch]
     private Tensor<T>? _gammasGradient;
+    [Scratch]
     private Tensor<T>? _outputNormScaleGradient;
+    [Scratch]
     private Tensor<T>? _outputGateWeightsGradient;
+    [Scratch]
     private Tensor<T>? _outputGateBiasGradient;
+    [Scratch]
     private Tensor<T>? _outputProjectionWeightsGradient;
+    [Scratch]
     private Tensor<T>? _outputProjectionBiasGradient;
 
     /// <inheritdoc />
@@ -169,6 +194,9 @@ public partial class TransNormerLLMLayer<T> : LayerBase<T>, IShapeContract
     /// </summary>
     public double DecayRate => _decayRate;
 
+    /// <summary>Construction state: the 'sequenceLength' the layer was built with.</summary>
+    private readonly int _sequenceLength;
+
     /// <summary>
     /// Creates a new TransNormerLLM layer with lightning attention.
     /// </summary>
@@ -204,6 +232,7 @@ public TransNormerLLMLayer(
             [sequenceLength, modelDimension],
             activationFunction ?? new IdentityActivation<T>())
     {
+        _sequenceLength = sequenceLength;
         InitializationStrategy = initializationStrategy ?? InitializationStrategies<T>.Eager;
 
         if (sequenceLength <= 0)
diff --git a/src/NeuralNetworks/Layers/STCConnectorLayer.cs b/src/NeuralNetworks/Layers/STCConnectorLayer.cs
index bd5f21c5a3..751ffb394c 100644
--- a/src/NeuralNetworks/Layers/STCConnectorLayer.cs
+++ b/src/NeuralNetworks/Layers/STCConnectorLayer.cs
@@ -149,11 +149,15 @@ public partial class STCConnectorLayer<T> : LayerBase<T>, IShapeContract
     private readonly Conv3DLayer<T> _sampler;
     private readonly RegStageBlock[] _stage2;
     private readonly DenseLayer<T>[] _readout;
+    [Scratch]
     private readonly LayerBase<T>[] _parameterLayers;
 
     /// <inheritdoc/>
     public override bool SupportsTraining => true;
 
+    /// <summary>Construction state: the 'dim' the layer was built with.</summary>
+    private readonly int _dim;
+
     /// <summary>
     /// Creates a connector that preserves the input/output feature width.
     /// </summary>
@@ -171,6 +175,7 @@ public STCConnectorLayer(
         int padding = 1)
         : this(dim, dim, patchesHeight, patchesWidth, kernelSize, stride, padding, stageDepth: 4, mlpDepth: 2)
     {
+        _dim = dim;
     }
 
     /// <summary>
@@ -513,7 +518,9 @@ private sealed partial class RegStageBlock : LayerBase<T>, IShapeContract
         private readonly ConvolutionalLayer<T>? _shortcutConv;
         private readonly LayerNormalizationLayer<T>? _shortcutNorm;
         private readonly ActivationLayer<T> _outputActivation;
+        [Scratch]
         private readonly LayerBase<T>[] _parameterLayers;
+        [Scratch]
         private readonly LayerBase<T>[] _allLayers;
 
         public RegStageBlock(int inputChannels, int outputChannels)
diff --git a/src/NeuralNetworks/Layers/SVTRMixingBlockLayer.cs b/src/NeuralNetworks/Layers/SVTRMixingBlockLayer.cs
index 8b1c154bb7..3a4c832e4c 100644
--- a/src/NeuralNetworks/Layers/SVTRMixingBlockLayer.cs
+++ b/src/NeuralNetworks/Layers/SVTRMixingBlockLayer.cs
@@ -18,7 +18,7 @@ namespace AiDotNet.NeuralNetworks.Layers;
 [LayerTask(LayerTask.SequenceModeling)]
 [LayerProperty(IsTrainable = true, Cost = ComputeCost.High, TestInputShape = "1, 8, 8", TestConstructorArgs = "8, 2, 2, 4, 4, 2")]
 [ElementWiseShape(Note = "Attention and MLP residuals preserve the token grid and hidden width.")]
-public class SVTRMixingBlockLayer<T> : LayerBase<T>
+public partial class SVTRMixingBlockLayer<T> : LayerBase<T>
 {
     private readonly int _hiddenSize;
     private readonly int _numHeads;
diff --git a/src/NeuralNetworks/Layers/SelfAttentionLayer.cs b/src/NeuralNetworks/Layers/SelfAttentionLayer.cs
index 72ead6d3d6..a31f1c2029 100644
--- a/src/NeuralNetworks/Layers/SelfAttentionLayer.cs
+++ b/src/NeuralNetworks/Layers/SelfAttentionLayer.cs
@@ -162,8 +162,11 @@ public partial class SelfAttentionLayer<T> : LayerBase<T>, IAuxiliaryLossLayer<T
     /// the first forward downcasts them. Upcast transiently per forward via
     /// <see cref="LayerBase{T}.UpcastResidentWeight"/> (shared SIMD scratch). Null on the normal fp32 path.
     /// </summary>
+    [AiDotNet.Attributes.Scratch]
     private Tensor<Half>? _queryWeightsHalf;
+    [AiDotNet.Attributes.Scratch]
     private Tensor<Half>? _keyWeightsHalf;
+    [AiDotNet.Attributes.Scratch]
     private Tensor<Half>? _valueWeightsHalf;
 
     /// <summary>
@@ -182,6 +185,7 @@ public partial class SelfAttentionLayer<T> : LayerBase<T>, IAuxiliaryLossLayer<T
     /// sequence of input embeddings that were processed in the most recent forward pass.
     /// The tensor is null before the first forward pass or after a reset.
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _lastInput;
 
     /// <summary>
@@ -201,6 +205,7 @@ public partial class SelfAttentionLayer<T> : LayerBase<T>, IAuxiliaryLossLayer<T
     /// so reuse is safe across the multi-step denoise loop. NOT used while a gradient
     /// tape is active (training needs the recorded allocating op).
     /// </summary>
+    [Scratch]
     private Tensor<T>? _sdpaOutScratch;
 
     /// <summary>
@@ -216,6 +221,7 @@ public partial class SelfAttentionLayer<T> : LayerBase<T>, IAuxiliaryLossLayer<T
     /// <see cref="LayerBase{T}.UpcastResidentWeight"/> and <see cref="_fusedQkvWeightsHalf"/> holds the
     /// resident master instead.
     /// </summary>
+    [AiDotNet.Attributes.Scratch]
     private Tensor<T> _fusedQkvWeights = new Tensor<T>([0, 0]);
 
     /// <summary>True once <see cref="_fusedQkvWeights"/> / <see cref="_fusedQkvWeightsHalf"/> has been built.</summary>
@@ -227,6 +233,7 @@ public partial class SelfAttentionLayer<T> : LayerBase<T>, IAuxiliaryLossLayer<T
     /// per-projection path produces, then upcast transiently per forward via
     /// <see cref="LayerBase{T}.UpcastResidentWeight"/> (shared SIMD scratch). Null on the normal fp32 path.
     /// </summary>
+    [AiDotNet.Attributes.Scratch]
     private Tensor<Half>? _fusedQkvWeightsHalf;
 
     /// <summary>
@@ -235,8 +242,11 @@ public partial class SelfAttentionLayer<T> : LayerBase<T>, IAuxiliaryLossLayer<T
     /// the fused weight is stale (weights were replaced by SetParameters / a training step / Clone) and
     /// is rebuilt. Null until first build.
     /// </summary>
+    [AiDotNet.Attributes.Scratch]
     private Tensor<T>? _fusedQkvSrcQ;
+    [AiDotNet.Attributes.Scratch]
     private Tensor<T>? _fusedQkvSrcK;
+    [AiDotNet.Attributes.Scratch]
     private Tensor<T>? _fusedQkvSrcV;
 
     /// <summary>
@@ -247,6 +257,7 @@ public partial class SelfAttentionLayer<T> : LayerBase<T>, IAuxiliaryLossLayer<T
     /// It holds the sequence of output embeddings that were produced in the most recent forward pass.
     /// The tensor is null before the first forward pass or after a reset.
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _lastOutput;
 
     /// <summary>
@@ -257,6 +268,7 @@ public partial class SelfAttentionLayer<T> : LayerBase<T>, IAuxiliaryLossLayer<T
     /// These weights represent how much each position attends to every other position in the sequence.
     /// The tensor is null before the first forward pass or after a reset.
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _lastAttentionScores;
 
     /// <summary>
@@ -268,6 +280,7 @@ public partial class SelfAttentionLayer<T> : LayerBase<T>, IAuxiliaryLossLayer<T
     /// the parameter update step. The tensor is null before the first backward pass or after a reset.
     /// Shape: [embeddingDimension, embeddingDimension]
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _queryWeightsGradient;
 
     /// <summary>
@@ -279,6 +292,7 @@ public partial class SelfAttentionLayer<T> : LayerBase<T>, IAuxiliaryLossLayer<T
     /// the parameter update step. The tensor is null before the first backward pass or after a reset.
     /// Shape: [embeddingDimension, embeddingDimension]
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _keyWeightsGradient;
 
     /// <summary>
@@ -290,6 +304,7 @@ public partial class SelfAttentionLayer<T> : LayerBase<T>, IAuxiliaryLossLayer<T
     /// the parameter update step. The tensor is null before the first backward pass or after a reset.
     /// Shape: [embeddingDimension, embeddingDimension]
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _valueWeightsGradient;
 
     /// <summary>
@@ -301,18 +316,26 @@ public partial class SelfAttentionLayer<T> : LayerBase<T>, IAuxiliaryLossLayer<T
     /// the parameter update step. The tensor is null before the first backward pass or after a reset.
     /// Shape: [embeddingDimension]
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _outputBiasGradient;
 
     private Tensor<T>? _queryWeightsVelocity;
     private Tensor<T>? _keyWeightsVelocity;
+    [AiDotNet.Attributes.Buffer]
     private Tensor<T>? _valueWeightsVelocity;
+    [AiDotNet.Attributes.Buffer]
     private Tensor<T>? _outputBiasVelocity;
 
     // GPU cached tensors for backward pass
+    [ExternalState]
     private Tensor<T>? _gpuInput2D;
+    [ExternalState]
     private Tensor<T>? _gpuQ;
+    [ExternalState]
     private Tensor<T>? _gpuK;
+    [ExternalState]
     private Tensor<T>? _gpuV;
+    [ExternalState]
     private Tensor<T>? _gpuAttentionWeights;
     private int _gpuBatchSize;
     private int _gpuSequenceLength;
diff --git a/src/NeuralNetworks/Layers/SeparableConvolutionalLayer.cs b/src/NeuralNetworks/Layers/SeparableConvolutionalLayer.cs
index 4a6c865215..711658e114 100644
--- a/src/NeuralNetworks/Layers/SeparableConvolutionalLayer.cs
+++ b/src/NeuralNetworks/Layers/SeparableConvolutionalLayer.cs
@@ -148,6 +148,7 @@ public partial class SeparableConvolutionalLayer<T> : LayerBase<T>, IShapeContra
     /// It needs to remember this input during training so it can calculate how to improve.
     /// </para>
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _lastInput;
 
     /// <summary>
@@ -163,6 +164,7 @@ public partial class SeparableConvolutionalLayer<T> : LayerBase<T>, IShapeContra
     /// affect the overall network performance.
     /// </para>
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _lastOutput;
 
     /// <summary>
@@ -178,6 +180,7 @@ public partial class SeparableConvolutionalLayer<T> : LayerBase<T>, IShapeContra
     /// negative values mean it should increase.
     /// </para>
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _depthwiseKernelsGradient;
 
     /// <summary>
@@ -193,6 +196,7 @@ public partial class SeparableConvolutionalLayer<T> : LayerBase<T>, IShapeContra
     /// for the parameters that mix information between channels.
     /// </para>
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _pointwiseKernelsGradient;
 
     /// <summary>
@@ -208,6 +212,7 @@ public partial class SeparableConvolutionalLayer<T> : LayerBase<T>, IShapeContra
     /// because they directly shift the output values.
     /// </para>
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _biasesGradient;
 
     /// <summary>
@@ -298,6 +303,7 @@ public partial class SeparableConvolutionalLayer<T> : LayerBase<T>, IShapeContra
     /// similar to how a ball rolling downhill gathers momentum.
     /// </para>
     /// </remarks>
+    [AiDotNet.Attributes.Buffer]
     private Tensor<T>? _depthwiseKernelsVelocity;
 
     /// <summary>
@@ -313,6 +319,7 @@ public partial class SeparableConvolutionalLayer<T> : LayerBase<T>, IShapeContra
     /// mix information between channels.
     /// </para>
     /// </remarks>
+    [AiDotNet.Attributes.Buffer]
     private Tensor<T>? _pointwiseKernelsVelocity;
 
     /// <summary>
@@ -328,35 +335,53 @@ public partial class SeparableConvolutionalLayer<T> : LayerBase<T>, IShapeContra
     /// the history of previous updates.
     /// </para>
     /// </remarks>
+    [AiDotNet.Attributes.Buffer]
     private Tensor<T>? _biasesVelocity;
 
     #region GPU Training Fields
+    [ExternalState]
     private Tensor<T>? _gpuLastInput;
+    [ExternalState]
     private Tensor<T>? _gpuLastOutput;
 
     // GPU weight buffers
+    [ExternalState]
     private Tensor<T>? _gpuDepthwiseKernels;
+    [ExternalState]
     private Tensor<T>? _gpuPointwiseKernels;
+    [ExternalState]
     private Tensor<T>? _gpuBiases;
 
     // GPU gradient buffers
+    [ExternalState]
     private Tensor<T>? _gpuDepthwiseKernelsGradient;
+    [ExternalState]
     private Tensor<T>? _gpuPointwiseKernelsGradient;
+    [ExternalState]
     private Tensor<T>? _gpuBiasesGradient;
 
     // GPU velocity buffers (SGD momentum)
+    [ExternalState]
     private Tensor<T>? _gpuDepthwiseKernelsVelocity;
+    [ExternalState]
     private Tensor<T>? _gpuPointwiseKernelsVelocity;
+    [ExternalState]
     private Tensor<T>? _gpuBiasesVelocityGpu;
 
     // GPU Adam first moment buffers
+    [ExternalState]
     private Tensor<T>? _gpuDepthwiseKernelsM;
+    [ExternalState]
     private Tensor<T>? _gpuPointwiseKernelsM;
+    [ExternalState]
     private Tensor<T>? _gpuBiasesM;
 
     // GPU Adam second moment buffers
+    [ExternalState]
     private Tensor<T>? _gpuDepthwiseKernelsV;
+    [ExternalState]
     private Tensor<T>? _gpuPointwiseKernelsV;
+    [ExternalState]
     private Tensor<T>? _gpuBiasesV;
     #endregion
 
diff --git a/src/NeuralNetworks/Layers/SoftTreeLayer.cs b/src/NeuralNetworks/Layers/SoftTreeLayer.cs
index b0b2543084..56460c4d5a 100644
--- a/src/NeuralNetworks/Layers/SoftTreeLayer.cs
+++ b/src/NeuralNetworks/Layers/SoftTreeLayer.cs
@@ -1,4 +1,4 @@
-using AiDotNet.Helpers;
+using AiDotNet.Helpers;
 using AiDotNet.Attributes;
 using AiDotNet.Interfaces;
 using AiDotNet.Tensors.Engines;
@@ -99,11 +99,15 @@ public partial class SoftTreeLayer<T> : LayerBase<T>, IShapeContract
     private Tensor<T> _leafValues;     // [numLeaves, outputDim]
 
     // Gradients
+    [AiDotNet.Attributes.Scratch]
     private Tensor<T>? _splitWeightsGrad;
+    [AiDotNet.Attributes.Scratch]
     private Tensor<T>? _splitBiasesGrad;
+    [AiDotNet.Attributes.Scratch]
     private Tensor<T>? _leafValuesGrad;
 
     // Caches for backward pass
+    [Scratch]
     private Tensor<T>? _lastInput;
     private Tensor<T>? _pathProbabilities;
 
@@ -121,9 +125,14 @@ public partial class SoftTreeLayer<T> : LayerBase<T>, IShapeContract
     public override bool SupportsTraining => true;
 
     /// <inheritdoc/>
+    [Scratch]
     private Tensor<T>? _cachedRightProbs;
+    [Scratch]
     private Tensor<T>? _cachedSplitLogits;
 
+    /// <summary>Construction state: the 'initScale' the layer was built with.</summary>
+    private readonly double _initScale;
+
     /// <summary>
     /// Initializes a new soft tree layer.
     /// </summary>
@@ -140,6 +149,7 @@ public SoftTreeLayer(
         double initScale = 0.01)
         : base(new[] { inputDim }, new[] { outputDim })
     {
+        _initScale = initScale;
         _inputDim = inputDim;
         _depth = depth;
         _outputDim = outputDim;
@@ -195,7 +205,7 @@ private void InitializeParameters(double scale)
     /// <param name="input">
     /// Input tensor whose last dimension is the feature dimension. A rank-2
     /// <c>[batchSize, inputDim]</c> tensor is the canonical shape; a rank-1 <c>[inputDim]</c>
-    /// sample and higher-rank <c>[d0, ..., inputDim]</c> tensors are also accepted — the leading
+    /// sample and higher-rank <c>[d0, ..., inputDim]</c> tensors are also accepted — the leading
     /// dimensions are flattened into the batch for the internal matmuls and restored on the output.
     /// </param>
     /// <returns>
@@ -434,36 +444,6 @@ public T[] GetFeatureImportance()
         return importance;
     }
 
-    /// <inheritdoc/>
-    public override void Serialize(BinaryWriter writer)
-    {
-        base.Serialize(writer);
-
-        writer.Write(_inputDim);
-        writer.Write(_depth);
-        writer.Write(_outputDim);
-        writer.Write(_temperature);
-
-        SerializeTensor(writer, _splitWeights);
-        SerializeTensor(writer, _splitBiases);
-        SerializeTensor(writer, _leafValues);
-    }
-
-    /// <inheritdoc/>
-    public override void Deserialize(BinaryReader reader)
-    {
-        base.Deserialize(reader);
-
-        var inputDim = reader.ReadInt32();
-        var depth = reader.ReadInt32();
-        var outputDim = reader.ReadInt32();
-        var temperature = reader.ReadDouble();
-
-        _splitWeights = DeserializeTensor(reader);
-        _splitBiases = DeserializeTensor(reader);
-        _leafValues = DeserializeTensor(reader);
-    }
-
     private void SerializeTensor(BinaryWriter writer, Tensor<T> tensor)
     {
         writer.Write(tensor.Shape.Length);
diff --git a/src/NeuralNetworks/Layers/SparseLinearLayer.cs b/src/NeuralNetworks/Layers/SparseLinearLayer.cs
index 20bbd46138..570c609741 100644
--- a/src/NeuralNetworks/Layers/SparseLinearLayer.cs
+++ b/src/NeuralNetworks/Layers/SparseLinearLayer.cs
@@ -117,17 +117,20 @@ public partial class SparseLinearLayer<T> : LayerBase<T>, IShapeContract
     /// <summary>
     /// Stored input from forward pass for backpropagation.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastInput;
 
     /// <summary>
     /// Stored pre-activation output for gradient computation.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastOutput;
 
     /// <summary>
     /// Gradient for weights, stored during backward pass.
     /// Stored as dense matrix for gradient accumulation, then sparsified.
     /// </summary>
+    [Scratch]
     private Matrix<T>? _weightsGradient;
 
     /// <summary>
@@ -135,6 +138,7 @@ public partial class SparseLinearLayer<T> : LayerBase<T>, IShapeContract
     /// <see cref="_biases"/>'s shape so gradient layout stays consistent
     /// across the manual backprop path and tape-mode.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _biasesGradient;
 
     /// <summary>
@@ -449,87 +453,6 @@ internal override System.Collections.Generic.Dictionary<string, string> GetMetad
         return metadata;
     }
 
-    public override void Serialize(BinaryWriter writer)
-    {
-        // Persist sparsity pattern (CSR row/col indices) so Deserialize
-        // can restore values into the SAME positions. Without this, a
-        // fresh layer's randomly-generated sparsity pattern places the
-        // saved values at different positions than the original, and
-        // Forward outputs diverge.
-        writer.Write(_weights.NonZeroCount);
-        var rows = _weights.RowIndices;
-        var cols = _weights.ColumnIndices;
-        for (int i = 0; i < _weights.NonZeroCount; i++)
-        {
-            writer.Write(rows[i]);
-            writer.Write(cols[i]);
-        }
-        base.Serialize(writer);
-    }
-
-    public override void Deserialize(BinaryReader reader)
-    {
-        int nnz = reader.ReadInt32();
-        if (nnz == _weights.NonZeroCount)
-        {
-            // Same sparsity pattern shape — overwrite the existing index
-            // arrays in place. SetParameters (called via base.Deserialize)
-            // then reconstructs _weights cloning these positions.
-            var rows = _weights.RowIndices;
-            var cols = _weights.ColumnIndices;
-            for (int i = 0; i < nnz; i++)
-            {
-                rows[i] = reader.ReadInt32();
-                cols[i] = reader.ReadInt32();
-            }
-        }
-        else
-        {
-            // Saved layer used a different sparsity ratio than the freshly-
-            // constructed layer. Silently skipping the indices and falling
-            // through to SetParameters would load values into the WRONG
-            // CSR positions, silently corrupting the model. Instead,
-            // reconstruct _weights with the saved sparsity pattern and
-            // zero-init values; SetParameters will then write the saved
-            // values into the matching positions.
-            var savedRows = new int[nnz];
-            var savedCols = new int[nnz];
-            for (int i = 0; i < nnz; i++)
-            {
-                savedRows[i] = reader.ReadInt32();
-                savedCols[i] = reader.ReadInt32();
-            }
-            // Validate indices fall inside the layer's known dimensions —
-            // a stream from an incompatible model shouldn't silently land
-            // out-of-range values that would crash later at Forward time.
-            for (int i = 0; i < nnz; i++)
-            {
-                if (savedRows[i] < 0 || savedRows[i] >= OutputFeatures)
-                    throw new InvalidDataException(
-                        $"SparseLinearLayer.Deserialize: row index {savedRows[i]} at slot {i} is outside [0, {OutputFeatures}). " +
-                        "Stream is from an incompatible model.");
-                if (savedCols[i] < 0 || savedCols[i] >= InputFeatures)
-                    throw new InvalidDataException(
-                        $"SparseLinearLayer.Deserialize: column index {savedCols[i]} at slot {i} is outside [0, {InputFeatures}). " +
-                        "Stream is from an incompatible model.");
-            }
-            // Replace _weights with a fresh SparseTensor matching the saved
-            // sparsity pattern. Re-register so GetTrainableParameters
-            // (used by tape mode and parameter walks) returns the new
-            // instance. We deliberately don't UnregisterTrainableParameter
-            // on the old reference here because Engine.UnregisterPersistentTensor
-            // calls Contiguous() which throws on sparse tensors —
-            // sparse-aware unregistration is tracked in the Tensors repo.
-            // Deserialize is pre-training, so no ParameterBuffer view
-            // aliases the old _weights at this point.
-            _weights = new SparseTensor<T>(
-                OutputFeatures, InputFeatures,
-                savedRows, savedCols, new T[nnz]);
-            RegisterTrainableParameter(_weights, PersistentTensorRole.Weights);
-        }
-        base.Deserialize(reader);
-    }
-
     /// <inheritdoc/>
     public override Vector<T> GetParameterGradients()
     {
diff --git a/src/NeuralNetworks/Layers/SpatialPoolerLayer.cs b/src/NeuralNetworks/Layers/SpatialPoolerLayer.cs
index f3b0df9bc0..2cf156d6ee 100644
--- a/src/NeuralNetworks/Layers/SpatialPoolerLayer.cs
+++ b/src/NeuralNetworks/Layers/SpatialPoolerLayer.cs
@@ -148,6 +148,7 @@ public partial class SpatialPoolerLayer<T> : LayerBase<T>, IShapeContract
     /// <summary>
     /// Gradient of the connections computed during backpropagation.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _connectionsGradient;
 
     /// <summary>
@@ -183,6 +184,7 @@ public partial class SpatialPoolerLayer<T> : LayerBase<T>, IShapeContract
     /// </para>
     /// </remarks>
     private Tensor<T>? LastOutput;
+    [Scratch]
     private Tensor<T>? _lastBinaryOutput;
 
     /// <summary>
diff --git a/src/NeuralNetworks/Layers/SpatialTransformerLayer.cs b/src/NeuralNetworks/Layers/SpatialTransformerLayer.cs
index c7a0ddbabe..b49776e96d 100644
--- a/src/NeuralNetworks/Layers/SpatialTransformerLayer.cs
+++ b/src/NeuralNetworks/Layers/SpatialTransformerLayer.cs
@@ -164,6 +164,7 @@ public partial class SpatialTransformerLayer<T> : LayerBase<T>, IAuxiliaryLossLa
     /// or when you explicitly reset the layer.
     /// </para>
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _lastInput;
 
     /// <summary>
@@ -191,6 +192,7 @@ public partial class SpatialTransformerLayer<T> : LayerBase<T>, IAuxiliaryLossLa
     /// understand how changes to the output affect the overall network performance.
     /// </para>
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _lastOutput;
 
     /// <summary>
@@ -208,6 +210,7 @@ public partial class SpatialTransformerLayer<T> : LayerBase<T>, IAuxiliaryLossLa
     /// backward pass, when the layer needs to understand exactly how it processed the data.
     /// </para>
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _lastTransformationMatrix;
 
     /// <summary>
@@ -227,6 +230,7 @@ public partial class SpatialTransformerLayer<T> : LayerBase<T>, IAuxiliaryLossLa
     /// that need more adjustment.
     /// </para>
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _localizationWeights1Gradient;
 
     /// <summary>
@@ -244,6 +248,7 @@ public partial class SpatialTransformerLayer<T> : LayerBase<T>, IAuxiliaryLossLa
     /// in the first layer during training. They help fine-tune the network's behavior.
     /// </para>
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _localizationBias1Gradient;
 
     /// <summary>
@@ -263,6 +268,7 @@ public partial class SpatialTransformerLayer<T> : LayerBase<T>, IAuxiliaryLossLa
     /// of transformations for the task.
     /// </para>
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _localizationWeights2Gradient;
 
     /// <summary>
@@ -281,8 +287,11 @@ public partial class SpatialTransformerLayer<T> : LayerBase<T>, IAuxiliaryLossLa
     /// the gradients show how to move away from that neutral state toward more helpful transformations.
     /// </para>
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _localizationBias2Gradient;
+    [Scratch]
     private Tensor<T>? _lastFlattenedInput;
+    [Scratch]
     private Tensor<T>? _lastLocalization1;
 
     /// <summary>
@@ -977,29 +986,6 @@ public override void ClearGradients()
         _localizationBias2Gradient = null;
     }
 
-    public override void Serialize(BinaryWriter writer)
-    {
-        // Persist resolved input H/W so Deserialize can re-resolve. The
-        // 230-param fixed tail (W2/b2 = 32*6+6 = 198 + 32) leaves the
-        // remaining params for W1[H*W, 32] + b1[32] = 32*(H*W + 1).
-        // Inferring H*W from total alone is doable but fails when the
-        // test re-runs Forward at the actual H/W expected by Forward.
-        writer.Write(_inputHeight);
-        writer.Write(_inputWidth);
-        base.Serialize(writer);
-    }
-
-    public override void Deserialize(BinaryReader reader)
-    {
-        int inH = reader.ReadInt32();
-        int inW = reader.ReadInt32();
-        if (!IsShapeResolved && inH > 0 && inW > 0)
-        {
-            ResolveFromShape(new[] { inH, inW });
-        }
-        base.Deserialize(reader);
-    }
-
     /// <summary>
     /// Resets the internal state of the spatial transformer layer.
     /// </summary>
diff --git a/src/NeuralNetworks/Layers/SpectralNormalizationLayer.cs b/src/NeuralNetworks/Layers/SpectralNormalizationLayer.cs
index 39a33572d2..6dd7c82d60 100644
--- a/src/NeuralNetworks/Layers/SpectralNormalizationLayer.cs
+++ b/src/NeuralNetworks/Layers/SpectralNormalizationLayer.cs
@@ -36,7 +36,7 @@ namespace AiDotNet.NeuralNetworks.Layers;
 /// <typeparam name="T">The numeric type used for calculations, typically float or double.</typeparam>
 [LayerCategory(LayerCategory.Regularization)]
 [LayerTask(LayerTask.Regularization)]
-[LayerProperty(IsTrainable = true)]
+[LayerProperty(IsTrainable = true, TestConstructorArgs = "new AiDotNet.NeuralNetworks.Layers.ReadoutLayer<double>(4, 8, (AiDotNet.Interfaces.IActivationFunction<double>)new AiDotNet.ActivationFunctions.IdentityActivation<double>())", TestInputShape = "1, 4")]
 // A DECORATOR: this layer rescales the inner layer's WEIGHTS and then returns
 // `_innerLayer.Forward(input)` verbatim (ForwardTraced), so it has no shape law of its own - it has the
 // inner layer's. The constructor says the same thing, chaining
@@ -90,11 +90,18 @@ public partial class SpectralNormalizationLayer<T> : LayerBase<T>, IShapeContrac
     /// <summary>
     /// The left singular vector used for power iteration to compute the spectral norm.
     /// </summary>
+    // A BUFFER, not scratch. Power iteration starts from a RANDOM vector and refines it, and the
+    // spectral norm it converges to is what divides the weights -- so a layer that regenerates it
+    // on load computes a different norm and predicts differently from the model that was saved.
+    // Marked scratch, it was dropped from the checkpoint and the restored layer's output moved
+    // from 0.664 to 0.355. This is the same reason PyTorch registers u and v as buffers.
+    [AiDotNet.Attributes.Buffer]
     private Tensor<T>? _u;
 
     /// <summary>
     /// The right singular vector used for power iteration.
     /// </summary>
+    [AiDotNet.Attributes.Buffer]
     private Tensor<T>? _v;
 
     /// <summary>
@@ -110,16 +117,19 @@ public partial class SpectralNormalizationLayer<T> : LayerBase<T>, IShapeContrac
     /// <summary>
     /// Cached input from the last forward pass.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastInput;
 
     /// <summary>
     /// Cached output from the last forward pass.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastOutput;
 
     /// <summary>
     /// Original weights stored during Forward, to be restored after Backward.
     /// </summary>
+    [AiDotNet.Attributes.Scratch]
     private Vector<T>? _originalParameters;
 
     /// <summary>
@@ -144,7 +154,9 @@ public partial class SpectralNormalizationLayer<T> : LayerBase<T>, IShapeContrac
     /// <summary>
     /// GPU-resident power iteration vectors.
     /// </summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T>? _uGpu;
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T>? _vGpu;
 
     /// <summary>
@@ -159,7 +171,69 @@ public SpectralNormalizationLayer(ILayer<T> innerLayer, int powerIterations = 1)
         _powerIterations = powerIterations;
         _epsilon = NumOps.FromDouble(1e-12);
 
-        // u and v are lazily initialized based on the actual weight matrix shape.
+        // Built HERE rather than on the first forward, whenever the inner layer can already say how
+        // many weights it has. A buffer is registered only if it is non-null, so leaving these until
+        // the first forward meant a freshly constructed layer had no slot for them -- and a restore
+        // therefore had nowhere to put the saved vectors and silently kept its own random ones. With
+        // a single power iteration by default the norm depends heavily on where it starts, so that
+        // is the difference between a reloaded model and the one that was saved.
+        SeedPowerIteration();
+    }
+
+    /// <summary>
+    /// Builds the iteration vectors and refines them once, so sigma is meaningful from the start.
+    /// </summary>
+    /// <remarks>
+    /// Power iteration begins at a RANDOM vector, and u^T W v on a random pair is an arbitrary
+    /// bilinear form -- near zero or negative as easily as not -- so dividing by it does not
+    /// normalize anything. In eval the vectors are deliberately frozen, which means a layer used for
+    /// inference before it ever trained divided its weights by that arbitrary number: the output
+    /// swung between -1.99 and 3.15 across a serialize round trip purely on which random pair each
+    /// instance drew. PyTorch leaves them random until the first training forward and inherits the
+    /// same hole; seeding here closes it.
+    /// </remarks>
+    private void SeedPowerIteration()
+    {
+        if (_innerLayer is not LayerBase<T> innerBase) return;
+
+        Tensor<T>? weight = null;
+        try
+        {
+            var tensors = innerBase.GetTrainableParameters();
+            for (int i = 0; i < tensors.Count; i++)
+            {
+                if (tensors[i] is { } candidate && candidate.Shape.Length >= 2) { weight = candidate; break; }
+            }
+        }
+        catch (Exception)
+        {
+            // A lazy inner layer cannot be asked yet; the first forward seeds it instead.
+            return;
+        }
+
+        if (weight is null || weight.Length == 0) return;
+
+        int rows = weight.Shape[0];
+        int cols = weight.Length / rows;
+        EnsurePowerIterationVectors(rows, cols);
+        RefinePowerIterationVectors(
+            weight.Shape.Length == 2 ? weight : Engine.Reshape(weight, [rows, cols]), force: true);
+    }
+
+    /// <summary>Weights the inner layer holds, or zero while it cannot yet say.</summary>
+    private int InnerWeightCount()
+    {
+        try
+        {
+            int paramCount = _innerLayer.GetParameters().Length;
+            return paramCount == 0 ? 0 : paramCount - GetBiasCount(paramCount);
+        }
+        catch (Exception)
+        {
+            // A lazy inner layer that has not resolved cannot be asked yet; the first forward will
+            // build the vectors as before.
+            return 0;
+        }
     }
 
     /// <summary>
@@ -273,76 +347,140 @@ protected override Tensor<T> ForwardTraced(Tensor<T> input)
     {
         _lastInput = ShouldCacheForBackward ? input : null; // #1668: skip in inference (arena safety)
 
-        // Get weights from inner layer
-        var parameters = _innerLayer.GetParameters();
-        int paramCount = parameters.Length;
-
-        if (paramCount == 0)
+        // The normalization runs on the inner layer's LIVE weight tensor and the quotient is bound
+        // back in its place, which is how PyTorch's spectral_norm parametrization works. The previous
+        // form copied the weights into a Vector, divided the numbers with NumOps and wrote them back
+        // through SetParameters, so the tape never saw the division: sigma depends on W, and the
+        // analytical gradient was missing that dependence entirely while finite differences measured
+        // it. It also meant the layer mutated the module it wraps.
+        if (_innerLayer is not LayerBase<T> innerBase)
         {
-            // No parameters to normalize, just forward through inner layer
-            var result = _innerLayer.Forward(input);
-            _lastOutput = result;
-            return result;
+            var passthrough = _innerLayer.Forward(input);
+            _lastOutput = passthrough;
+            return passthrough;
         }
 
-        // Store original parameters to restore after Backward
-        _originalParameters = parameters.Clone();
-
-        int biasCount = GetBiasCount(paramCount);
-        int weightCount = paramCount - biasCount;
-
-        // Reshape weight parameters into 2D matrix for spectral norm computation
-        // Use square-ish shape to minimize condition number issues
-        int rows = (int)Math.Ceiling(Math.Sqrt(weightCount));
-        int cols = (weightCount + rows - 1) / rows;
-
-        // Create weight tensor [rows, cols] with zero-padding if needed
-        var weights = new Tensor<T>([rows, cols]);
-        for (int i = 0; i < rows; i++)
+        // A lazy Dense/Convolution layer may expose a rank-two placeholder whose first dimension is
+        // zero until it sees an input. Resolve it from the real input before inspecting the weight
+        // shape; otherwise `weight.Length / weight.Shape[0]` divides by zero during the wrapper's
+        // first forward (and therefore during clone verification too).
+        if (!innerBase.IsShapeResolved)
         {
-            for (int j = 0; j < cols; j++)
+            var inputShape = input.Shape.ToArray();
+            try
+            {
+                innerBase.ResolveFromShape(inputShape);
+            }
+            catch (Exception) when (inputShape.Length > 1)
             {
-                int idx = i * cols + j;
-                weights[new int[] { i, j }] = idx < weightCount ? parameters[idx] : NumOps.Zero;
+                try { innerBase.ResolveFromShape(inputShape.Skip(1).ToArray()); }
+                catch (Exception) { /* The unnormalized first forward below can materialize it. */ }
             }
         }
 
-        EnsurePowerIterationVectors(rows, cols);
-
-        // Compute spectral norm
-        T spectralNorm = ComputeSpectralNorm(weights);
-        T normPlusEps = NumOps.Add(spectralNorm, _epsilon);
-
-        // Normalize weight parameters by spectral norm
-        var normalizedParams = new Vector<T>(paramCount);
-        for (int i = 0; i < weightCount; i++)
+        var tensors = innerBase.GetTrainableParameters();
+        int weightIndex = -1;
+        for (int i = 0; i < tensors.Count; i++)
         {
-            normalizedParams[i] = NumOps.Divide(parameters[i], normPlusEps);
+            if (tensors[i] is { } candidate && candidate.Shape.Length >= 2
+                && candidate.Shape[0] > 0 && candidate.Length > 0)
+            {
+                weightIndex = i;
+                break;
+            }
         }
 
-        // Copy bias parameters unchanged
-        for (int i = weightCount; i < paramCount; i++)
+        if (weightIndex < 0)
         {
-            normalizedParams[i] = parameters[i];
+            var unnormalized = _innerLayer.Forward(input);
+            _lastOutput = unnormalized;
+            return unnormalized;
         }
 
-        _innerLayer.SetParameters(normalizedParams);
-        _normalizedWeightsApplied = true;
+        var weight = tensors[weightIndex];
+        int rows = weight.Shape[0];
+        int cols = weight.Length / rows;
+        var matrix = weight.Shape.Length == 2 ? weight : Engine.Reshape(weight, [rows, cols]);
+
+        EnsurePowerIterationVectors(rows, cols);
 
+        // Power iteration refines u and v from the CURRENT weights and, per the paper and every
+        // reference implementation, contributes no gradient of its own: it is an estimate of the
+        // singular vectors, not a function being differentiated. Detaching keeps sigma's gradient to
+        // the weight alone. Updated only while training, so inference is reproducible.
+        RefinePowerIterationVectors(matrix);
+
+        var u = _u ?? throw new InvalidOperationException("Power iteration vector u has not been initialized.");
+        var v = _v ?? throw new InvalidOperationException("Power iteration vector v has not been initialized.");
+
+        // sigma = u^T W v, built from the live weight so the tape carries d(sigma)/dW.
+        var wv = Engine.TensorMatMul(matrix, Engine.Reshape(v, [cols, 1]));          // [rows, 1]
+        var sigma = Engine.TensorMatMul(Engine.Reshape(u, [1, rows]), wv);           // [1, 1]
+
+        var epsilon = new Tensor<T>([1, 1]);
+        epsilon[0, 0] = _epsilon;
+        var denominator = Engine.TensorAdd(sigma, epsilon);
+
+        // TensorDivide broadcasts on its own since AiDotNet.Tensors #919, so the explicit
+        // Broadcast* variant is the older spelling of the same operation.
+        var normalizedMatrix = Engine.TensorDivide(matrix, denominator);
+        var normalizedWeight = weight.Shape.Length == 2
+            ? normalizedMatrix
+            : Engine.Reshape(normalizedMatrix, weight.Shape.ToArray());
+
+        var rebound = new Tensor<T>[tensors.Count];
+        for (int i = 0; i < tensors.Count; i++) rebound[i] = tensors[i];
+        rebound[weightIndex] = normalizedWeight;
+
+        var originals = new Tensor<T>[tensors.Count];
+        for (int i = 0; i < tensors.Count; i++) originals[i] = tensors[i];
+
+        innerBase.SetTrainableParameters(rebound);
         try
         {
-            // Forward through inner layer with normalized weights
             _lastOutput = _innerLayer.Forward(input);
             return _lastOutput;
         }
-        catch
+        finally
         {
-            // Restore original weights on exception
-            RestoreOriginalWeights();
-            throw;
+            // The wrapped layer keeps the weights it came with. Leaving the quotient bound would
+            // divide them again on the next pass, which is how they used to decay pass over pass.
+            innerBase.SetTrainableParameters(originals);
         }
     }
 
+    /// <summary>Refines u and v from the current weights, outside the gradient graph.</summary>
+    /// <param name="matrix">The weight matrix to iterate against.</param>
+    /// <param name="force">Refine even outside training, used once at construction.</param>
+    private void RefinePowerIterationVectors(Tensor<T> matrix, bool force = false)
+    {
+        if (!force && !IsTrainingMode) return;
+
+        int rows = matrix.Shape[0];
+        int cols = matrix.Shape[1];
+        var u = _u;
+        var v = _v;
+        if (u is null || v is null) return;
+
+        // Values only: a detached copy, so nothing here reaches the tape.
+        var detached = Tensor<T>.FromVector(matrix.ToVector()).Reshape(rows, cols);
+        var transposed = Engine.TensorTranspose(detached);
+
+        for (int iteration = 0; iteration < _powerIterations; iteration++)
+        {
+            var next = Engine.TensorMatMul(transposed, u.Reshape(rows, 1)).Reshape(cols);
+            NormalizeVector(ref next);
+            v = next;
+
+            var refreshed = Engine.TensorMatMul(detached, v.Reshape(cols, 1)).Reshape(rows);
+            NormalizeVector(ref refreshed);
+            u = refreshed;
+        }
+
+        _u = u;
+        _v = v;
+    }
+
     /// <summary>
     /// Performs the forward pass using GPU-resident tensors with GPU-accelerated spectral normalization.
     /// </summary>
@@ -432,11 +570,10 @@ public override Tensor<T> ForwardGpu(params Tensor<T>[] inputs)
             }
             throw new InvalidOperationException("Inner layer does not support ForwardGpu.");
         }
-        catch
+        finally
         {
-            // Restore original weights on exception
+            // Same reason as the traced path above: the inner weights must not stay normalized.
             RestoreOriginalWeights();
-            throw;
         }
     }
 
@@ -519,50 +656,6 @@ public override void ResetState()
         _innerLayer.ResetState();
     }
 
-    public override void Serialize(BinaryWriter writer)
-    {
-        base.Serialize(writer);
-        // Serialize power iteration vectors for deterministic deserialization
-        bool hasU = _u != null;
-        writer.Write(hasU);
-        if (hasU && _u != null)
-        {
-            writer.Write(_u.Length);
-            for (int i = 0; i < _u.Length; i++)
-                writer.Write(NumOps.ToDouble(_u[i]));
-        }
-        bool hasV = _v != null;
-        writer.Write(hasV);
-        if (hasV && _v != null)
-        {
-            writer.Write(_v.Length);
-            for (int i = 0; i < _v.Length; i++)
-                writer.Write(NumOps.ToDouble(_v[i]));
-        }
-    }
-
-    public override void Deserialize(BinaryReader reader)
-    {
-        base.Deserialize(reader);
-        // Restore power iteration vectors
-        bool hasU = reader.ReadBoolean();
-        if (hasU)
-        {
-            int uLen = reader.ReadInt32();
-            _u = new Tensor<T>([uLen]);
-            for (int i = 0; i < uLen; i++)
-                _u[i] = NumOps.FromDouble(reader.ReadDouble());
-        }
-        bool hasV = reader.ReadBoolean();
-        if (hasV)
-        {
-            int vLen = reader.ReadInt32();
-            _v = new Tensor<T>([vLen]);
-            for (int i = 0; i < vLen; i++)
-                _v[i] = NumOps.FromDouble(reader.ReadDouble());
-        }
-    }
-
     /// <summary>
     /// GPU-resident parameter update using the provided optimizer configuration.
     /// Delegates to the inner layer's UpdateParametersGpu method.
diff --git a/src/NeuralNetworks/Layers/SpikingLayer.cs b/src/NeuralNetworks/Layers/SpikingLayer.cs
index c8baf6615c..4bf1cfff6a 100644
--- a/src/NeuralNetworks/Layers/SpikingLayer.cs
+++ b/src/NeuralNetworks/Layers/SpikingLayer.cs
@@ -161,7 +161,9 @@ public partial class SpikingLayer<T> : LayerBase<T>, IShapeContract
 
 
     // Cached tensors for hot-loop operations (avoid per-call allocation)
+    [Scratch]
     private Tensor<T>? _cachedOnes;
+    [Scratch]
     private Tensor<T>? _cachedZeros;
 
     /// <summary>
@@ -229,6 +231,7 @@ public partial class SpikingLayer<T> : LayerBase<T>, IShapeContract
     /// This helps the network gradually improve its performance on the given task.
     /// </para>
     /// </remarks>
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _weightGradients;
 
     /// <summary>
@@ -249,6 +252,7 @@ public partial class SpikingLayer<T> : LayerBase<T>, IShapeContract
     /// The network uses these gradients to update the biases after processing a batch of examples.
     /// </para>
     /// </remarks>
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _biasGradients;
 
     /// <summary>
@@ -266,6 +270,7 @@ public partial class SpikingLayer<T> : LayerBase<T>, IShapeContract
     /// or when you explicitly reset the layer.
     /// </para>
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _lastInput;
 
     /// <summary>
@@ -287,6 +292,7 @@ public partial class SpikingLayer<T> : LayerBase<T>, IShapeContract
     /// understand how changes to its parameters affect the overall network performance.
     /// </para>
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _lastOutput;
 
     /// <summary>
@@ -308,6 +314,7 @@ public partial class SpikingLayer<T> : LayerBase<T>, IShapeContract
     /// This is the key internal state that determines when neurons fire.
     /// </para>
     /// </remarks>
+    [AiDotNet.Attributes.Buffer]
     private Tensor<T> _membranePotential;
 
     /// <summary>
@@ -329,6 +336,7 @@ public partial class SpikingLayer<T> : LayerBase<T>, IShapeContract
     /// This prevents unrealistically rapid firing and better matches biological neurons.
     /// </para>
     /// </remarks>
+    [AiDotNet.Attributes.Buffer]
     private Tensor<T> _refractoryCountdown;
 
     /// <summary>
@@ -349,6 +357,7 @@ public partial class SpikingLayer<T> : LayerBase<T>, IShapeContract
     /// similar to how real neurons in the brain work.
     /// </para>
     /// </remarks>
+    [AiDotNet.Attributes.Buffer]
     private Tensor<T> _spikes;
 
     /// <summary>
@@ -370,6 +379,7 @@ public partial class SpikingLayer<T> : LayerBase<T>, IShapeContract
     /// This is only used when _neuronType is Izhikevich.
     /// </para>
     /// </remarks>
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T>? _recoveryVariable;
 
     /// <summary>
@@ -467,6 +477,7 @@ public partial class SpikingLayer<T> : LayerBase<T>, IShapeContract
     /// This adaptation mimics how real neurons get "tired" when stimulated continuously.
     /// </para>
     /// </remarks>
+    [AiDotNet.Attributes.Buffer]
     private Tensor<T>? _adaptationVariable;
 
     /// <summary>
@@ -583,6 +594,7 @@ public partial class SpikingLayer<T> : LayerBase<T>, IShapeContract
     /// This is part of the most detailed biophysical model of neuron behavior.
     /// </para>
     /// </remarks>
+    [AiDotNet.Attributes.Buffer]
     private Tensor<T>? _nGate;
 
     /// <summary>
@@ -603,6 +615,7 @@ public partial class SpikingLayer<T> : LayerBase<T>, IShapeContract
     /// These channels are primarily responsible for generating the spike.
     /// </para>
     /// </remarks>
+    [AiDotNet.Attributes.Buffer]
     private Tensor<T>? _mGate;
 
     /// <summary>
@@ -624,6 +637,7 @@ public partial class SpikingLayer<T> : LayerBase<T>, IShapeContract
     /// This inactivation mechanism is crucial for the neuron to return to its resting state.
     /// </para>
     /// </remarks>
+    [AiDotNet.Attributes.Buffer]
     private Tensor<T>? _hGate;
 
     /// <summary>
@@ -1591,173 +1605,6 @@ public override void ResetState()
         _biasGradients.Fill(NumOps.Zero);
     }
 
-    /// <summary>
-    /// Serializes the layer's parameters and state to a binary stream.
-    /// </summary>
-    /// <param name="writer">The binary writer to write to.</param>
-    /// <remarks>
-    /// <para>
-    /// This method writes the layer's parameters, including neuron type, time constants, weights, biases,
-    /// and model-specific parameters, to a binary stream. This allows the layer to be saved to disk for later use.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method saves the layer's configuration and parameters to a file.
-    /// 
-    /// The serialization includes:
-    /// - Basic parameters (neuron type, time constant, refractory period)
-    /// - All weights and biases
-    /// - Model-specific parameters like those for Izhikevich or AdEx models
-    /// 
-    /// This allows you to:
-    /// - Save a trained model to disk
-    /// - Load it later for inference or continued training
-    /// - Transfer the model to another application
-    /// </para>
-    /// </remarks>
-    public override void Serialize(BinaryWriter writer)
-    {
-        // Write neuron type and parameters
-        writer.Write((int)_neuronType);
-        writer.Write(NumOps.ToDouble(_tau));
-        writer.Write(NumOps.ToDouble(_refractoryPeriod));
-
-        // Write weights and biases from tensors
-        int inputSize = _weights.Shape[0];
-        int outputSize = _weights.Shape[1];
-        for (int i = 0; i < inputSize; i++)
-        {
-            for (int j = 0; j < outputSize; j++)
-            {
-                writer.Write(Convert.ToDouble(_weights[i, j]));
-            }
-        }
-
-        for (int i = 0; i < _bias.Shape[0]; i++)
-        {
-            writer.Write(Convert.ToDouble(_bias[i]));
-        }
-
-        // Write model-specific parameters
-        if (_neuronType == SpikingNeuronType.Izhikevich)
-        {
-            writer.Write(NumOps.ToDouble(_a));
-            writer.Write(NumOps.ToDouble(_b));
-            writer.Write(NumOps.ToDouble(_c));
-            writer.Write(NumOps.ToDouble(_d));
-        }
-        else if (_neuronType == SpikingNeuronType.AdaptiveExponential)
-        {
-            writer.Write(NumOps.ToDouble(_deltaT));
-            writer.Write(NumOps.ToDouble(_vT));
-            writer.Write(NumOps.ToDouble(_tauw));
-            writer.Write(NumOps.ToDouble(_a_adex));
-            writer.Write(NumOps.ToDouble(_b_adex));
-        }
-    }
-
-    /// <summary>
-    /// Deserializes the layer's parameters and state from a binary stream.
-    /// </summary>
-    /// <param name="reader">The binary reader to read from.</param>
-    /// <remarks>
-    /// <para>
-    /// This method reads the layer's parameters from a binary stream, including neuron type, time constants,
-    /// weights, biases, and model-specific parameters. This allows a previously saved layer to be loaded from disk.
-    /// It also initializes any model-specific variables needed for the selected neuron type.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method loads the layer's configuration and parameters from a file.
-    /// 
-    /// The deserialization reads:
-    /// - Basic parameters (neuron type, time constant, refractory period)
-    /// - All weights and biases
-    /// - Model-specific parameters for the particular neuron type
-    /// 
-    /// It also initializes any special variables needed for the specific neuron model.
-    /// This lets you load a previously saved model and continue using or training it.
-    /// </para>
-    /// </remarks>
-    public override void Deserialize(BinaryReader reader)
-    {
-        // Read neuron type and parameters
-        _neuronType = (SpikingNeuronType)reader.ReadInt32();
-        _tau = NumOps.FromDouble(reader.ReadDouble());
-        _refractoryPeriod = NumOps.FromDouble(reader.ReadDouble());
-
-        // Read weights and biases into tensors
-        int inputSize = _weights.Shape[0];
-        int outputSize = _weights.Shape[1];
-        for (int i = 0; i < inputSize; i++)
-        {
-            for (int j = 0; j < outputSize; j++)
-            {
-                _weights[i, j] = NumOps.FromDouble(reader.ReadDouble());
-            }
-        }
-
-        for (int i = 0; i < _bias.Shape[0]; i++)
-        {
-            _bias[i] = NumOps.FromDouble(reader.ReadDouble());
-        }
-
-        // Read model-specific parameters
-        if (_neuronType == SpikingNeuronType.Izhikevich)
-        {
-            _a = NumOps.FromDouble(reader.ReadDouble());
-            _b = NumOps.FromDouble(reader.ReadDouble());
-            _c = NumOps.FromDouble(reader.ReadDouble());
-            _d = NumOps.FromDouble(reader.ReadDouble());
-
-            // Initialize recovery variable if needed
-            if (_recoveryVariable == null)
-            {
-                _recoveryVariable = new Tensor<T>([OutputShape[0]]);
-                _recoveryVariable.Fill(NumOps.Zero);
-            }
-        }
-        else if (_neuronType == SpikingNeuronType.AdaptiveExponential)
-        {
-            _deltaT = NumOps.FromDouble(reader.ReadDouble());
-            _vT = NumOps.FromDouble(reader.ReadDouble());
-            _tauw = NumOps.FromDouble(reader.ReadDouble());
-            _a_adex = NumOps.FromDouble(reader.ReadDouble());
-            _b_adex = NumOps.FromDouble(reader.ReadDouble());
-
-            // Initialize adaptation variable if needed
-            if (_adaptationVariable == null)
-            {
-                _adaptationVariable = new Tensor<T>([OutputShape[0]]);
-                _adaptationVariable.Fill(NumOps.Zero);
-            }
-        }
-        else if (_neuronType == SpikingNeuronType.HodgkinHuxley)
-        {
-            // Initialize gate variables if needed using Tensor<T>
-            int gateSize = OutputShape[0];
-            if (_nGate == null)
-            {
-                _nGate = new Tensor<T>([gateSize]);
-                _nGate.Fill(NumOps.FromDouble(0.32));
-            }
-            if (_mGate == null)
-            {
-                _mGate = new Tensor<T>([gateSize]);
-                _mGate.Fill(NumOps.FromDouble(0.05));
-            }
-            if (_hGate == null)
-            {
-                _hGate = new Tensor<T>([gateSize]);
-                _hGate.Fill(NumOps.FromDouble(0.60));
-            }
-        }
-
-        // Initialize state variables using Tensor<T>
-        _membranePotential = new Tensor<T>([OutputShape[0]]);
-        _membranePotential.Fill(NumOps.Zero);
-        _refractoryCountdown = new Tensor<T>([OutputShape[0]]);
-        _refractoryCountdown.Fill(NumOps.Zero);
-        _spikes = new Tensor<T>([OutputShape[0]]);
-        _spikes.Fill(NumOps.Zero);
-    }
-
 
     /// <summary>
     /// Updates the parameters of the layer using the calculated gradients and learning rate.
diff --git a/src/NeuralNetworks/Layers/SpikingNetworkCore.cs b/src/NeuralNetworks/Layers/SpikingNetworkCore.cs
index 918053a7be..ef66e902e5 100644
--- a/src/NeuralNetworks/Layers/SpikingNetworkCore.cs
+++ b/src/NeuralNetworks/Layers/SpikingNetworkCore.cs
@@ -191,6 +191,9 @@ public SpikingNetworkCore(
         }
     }
 
+    /// <summary>Construction state: the 'hiddenSize' the layer was built with.</summary>
+    private readonly int _hiddenSize;
+
     /// <summary>
     /// Scalar-hidden-size convenience constructor (single LIF hidden layer). Used
     /// by the generated layer-test harness, which passes scalar constructor args.
@@ -198,6 +201,7 @@ public SpikingNetworkCore(
     public SpikingNetworkCore(int inputSize, int hiddenSize, int outputSize)
         : this(inputSize, [hiddenSize], outputSize, timeSteps: 5)
     {
+        _hiddenSize = hiddenSize;
     }
 
     /// <summary>
diff --git a/src/NeuralNetworks/Layers/SpiralConvLayer.cs b/src/NeuralNetworks/Layers/SpiralConvLayer.cs
index 2757352192..110bec1d16 100644
--- a/src/NeuralNetworks/Layers/SpiralConvLayer.cs
+++ b/src/NeuralNetworks/Layers/SpiralConvLayer.cs
@@ -423,26 +423,31 @@ protected override void Dispose(bool disposing)
     /// <summary>
     /// Cached weight gradients from backward pass.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _weightsGradient;
 
     /// <summary>
     /// Cached bias gradients from backward pass.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _biasesGradient;
 
     /// <summary>
     /// Cached input from the last forward pass.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastInput;
 
     /// <summary>
     /// Cached pre-activation output from the last forward pass.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastPreActivation;
 
     /// <summary>
     /// Cached output from the last forward pass.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastOutput;
 
     /// <summary>
@@ -458,6 +463,7 @@ protected override void Dispose(bool disposing)
     /// <summary>
     /// Cached gathered neighbor features for backward pass.
     /// </summary>
+    [AiDotNet.Attributes.Scratch]
     private Tensor<T>? _gatheredFeatures;
 
     #endregion
@@ -1037,37 +1043,6 @@ internal override Dictionary<string, string> GetMetadata()
         return meta;
     }
 
-    /// <summary>
-    /// Creates a deep copy of this layer.
-    /// </summary>
-    /// <returns>A new SpiralConvLayer with identical configuration and parameters.</returns>
-    public override LayerBase<T> Clone()
-    {
-        SpiralConvLayer<T> copy;
-
-        if (UsingVectorActivation)
-        {
-            var vAct = VectorActivation ?? throw new InvalidOperationException(
-                "UsingVectorActivation is true but VectorActivation is null.");
-            copy = new SpiralConvLayer<T>(
-                OutputChannels, SpiralLength, vAct);
-        }
-        else
-        {
-            copy = new SpiralConvLayer<T>(
-                OutputChannels, SpiralLength, ScalarActivation);
-        }
-
-        copy.SetParameters(GetParameters());
-
-        if (_spiralIndices != null)
-        {
-            copy.SetSpiralIndices(_spiralIndices);
-        }
-
-        return copy;
-    }
-
     #endregion
 
     #region State Management
@@ -1089,102 +1064,6 @@ public override void ResetState()
 
     #region Serialization
 
-    /// <summary>
-    /// Serializes the layer to a binary stream.
-    /// </summary>
-    /// <param name="writer">Binary writer for serialization.</param>
-    /// <remarks>
-    /// <para>
-    /// If spiral indices are set, they are serialized along with the layer.
-    /// Otherwise, users must call <see cref="SetSpiralIndices"/> after deserialization.
-    /// </para>
-    /// </remarks>
-    public override void Serialize(BinaryWriter writer)
-    {
-        base.Serialize(writer);
-        writer.Write(InputChannels);
-        writer.Write(OutputChannels);
-        writer.Write(SpiralLength);
-
-        var weightArray = _weights.ToArray();
-        for (int i = 0; i < weightArray.Length; i++)
-        {
-            writer.Write(NumOps.ToDouble(weightArray[i]));
-        }
-
-        var biasArray = _biases.ToArray();
-        for (int i = 0; i < biasArray.Length; i++)
-        {
-            writer.Write(NumOps.ToDouble(biasArray[i]));
-        }
-
-        // Serialize spiral indices if set
-        bool hasIndices = _spiralIndices != null;
-        writer.Write(hasIndices);
-        if (hasIndices && _spiralIndices != null)
-        {
-            int numVertices = _spiralIndices.GetLength(0);
-            writer.Write(numVertices);
-            for (int v = 0; v < numVertices; v++)
-            {
-                for (int s = 0; s < SpiralLength; s++)
-                {
-                    writer.Write(_spiralIndices[v, s]);
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// Deserializes the layer from a binary stream.
-    /// </summary>
-    /// <param name="reader">Binary reader for deserialization.</param>
-    /// <remarks>
-    /// <para>
-    /// If spiral indices were serialized with the layer, they are restored automatically.
-    /// Otherwise, users must call <see cref="SetSpiralIndices"/> before calling Forward.
-    /// </para>
-    /// </remarks>
-    public override void Deserialize(BinaryReader reader)
-    {
-        base.Deserialize(reader);
-        InputChannels = reader.ReadInt32();
-        OutputChannels = reader.ReadInt32();
-        SpiralLength = reader.ReadInt32();
-
-        int weightSize = InputChannels * SpiralLength;
-        _weights = new Tensor<T>([OutputChannels, weightSize]);
-        var weightArray = new T[_weights.Length];
-        for (int i = 0; i < weightArray.Length; i++)
-        {
-            weightArray[i] = NumOps.FromDouble(reader.ReadDouble());
-        }
-        _weights = new Tensor<T>(weightArray, _weights._shape);
-
-        _biases = new Tensor<T>([OutputChannels]);
-        var biasArray = new T[_biases.Length];
-        for (int i = 0; i < biasArray.Length; i++)
-        {
-            biasArray[i] = NumOps.FromDouble(reader.ReadDouble());
-        }
-        _biases = new Tensor<T>(biasArray, _biases._shape);
-
-        // Deserialize spiral indices if present
-        bool hasIndices = reader.ReadBoolean();
-        if (hasIndices)
-        {
-            int numVertices = reader.ReadInt32();
-            _spiralIndices = new int[numVertices, SpiralLength];
-            for (int v = 0; v < numVertices; v++)
-            {
-                for (int s = 0; s < SpiralLength; s++)
-                {
-                    _spiralIndices[v, s] = reader.ReadInt32();
-                }
-            }
-        }
-    }
-
     #endregion
 
     #region JIT Compilation
diff --git a/src/NeuralNetworks/Layers/SplitLayer.cs b/src/NeuralNetworks/Layers/SplitLayer.cs
index 3a60aec79d..f5ddd795f4 100644
--- a/src/NeuralNetworks/Layers/SplitLayer.cs
+++ b/src/NeuralNetworks/Layers/SplitLayer.cs
@@ -122,6 +122,7 @@ public partial class SplitLayer<T> : LayerBase<T>, IShapeContract
     /// or when you explicitly reset the layer.
     /// </para>
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _lastInput;
 
     /// <summary>
diff --git a/src/NeuralNetworks/Layers/SpyNetLayer.cs b/src/NeuralNetworks/Layers/SpyNetLayer.cs
index e33826cdef..adc325582a 100644
--- a/src/NeuralNetworks/Layers/SpyNetLayer.cs
+++ b/src/NeuralNetworks/Layers/SpyNetLayer.cs
@@ -105,16 +105,25 @@ public partial class SpyNetLayer<T> : LayerBase<T>, IShapeContract
     private int _inputHeight;
     private int _inputWidth;
     private readonly List<ConvolutionalLayer<T>> _basicModules;
+    [Scratch]
     private Tensor<T>? _lastInput1;
+    [Scratch]
     private Tensor<T>? _lastInput2;
+    [Scratch]
     private Tensor<T>? _lastFlow;
 
     // Cached values for backward pass
+    [Scratch]
     private readonly List<Tensor<T>> _cachedPyramid1 = [];
+    [Scratch]
     private readonly List<Tensor<T>> _cachedPyramid2 = [];
+    [Scratch]
     private readonly List<Tensor<T>> _cachedWarped = [];
+    [Scratch]
     private readonly List<Tensor<T>> _cachedFlows = [];
+    [Scratch]
     private readonly List<Tensor<T>> _cachedModuleInputs = [];
+    [Scratch]
     private readonly List<Tensor<T>> _cachedGrids = [];
 
     #endregion
@@ -902,6 +911,7 @@ private Tensor<T> AddResidualFlow(Tensor<T> flow, Tensor<T> residual, bool hasBa
     public override bool SupportsTraining => true;
 
     // GPU Caches
+    [Scratch]
     private readonly Dictionary<(int batch, int height, int width), Tensor<T>> _identityGridCache = new();
     private readonly Dictionary<(int batch, int channels, int height, int width), (IGpuBuffer idx1, IGpuBuffer idx2)> _sliceIndicesCache = new();
 
@@ -1187,6 +1197,7 @@ protected override void Dispose(bool disposing)
 
     #region Parameter Management
 
+    [Scratch]
     private Vector<T>? _pendingParameters;
 
     /// <inheritdoc/>
diff --git a/src/NeuralNetworks/Layers/SqueezeAndExcitationLayer.cs b/src/NeuralNetworks/Layers/SqueezeAndExcitationLayer.cs
index 6c3ef3c325..28c9f3a156 100644
--- a/src/NeuralNetworks/Layers/SqueezeAndExcitationLayer.cs
+++ b/src/NeuralNetworks/Layers/SqueezeAndExcitationLayer.cs
@@ -102,10 +102,15 @@ public partial class SqueezeAndExcitationLayer<T> : LayerBase<T>, IAuxiliaryLoss
     /// Caches the excitation weights from the forward pass for auxiliary loss computation.
     /// Shape: [batchSize, channels]
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastExcitationWeights;
+    [Scratch]
     private Tensor<T>? _lastSqueezed;
+    [Scratch]
     private Tensor<T>? _lastFc1Biased;
+    [Scratch]
     private Tensor<T>? _lastFc1Activated;
+    [Scratch]
     private Tensor<T>? _lastFc2Biased;
 
     /// <summary>
@@ -253,6 +258,7 @@ public partial class SqueezeAndExcitationLayer<T> : LayerBase<T>, IAuxiliaryLoss
     /// This value is temporarily stored during training and is cleared when moving to a new sample.
     /// </para>
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _lastInput;
 
     /// <summary>
@@ -278,6 +284,7 @@ public partial class SqueezeAndExcitationLayer<T> : LayerBase<T>, IAuxiliaryLoss
     /// This is another piece of temporary memory used during training.
     /// </para>
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _lastOutput;
 
     /// <summary>
@@ -299,6 +306,7 @@ public partial class SqueezeAndExcitationLayer<T> : LayerBase<T>, IAuxiliaryLoss
     /// "that weight should be much lower" to get better results next time.
     /// </para>
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _weights1Gradient;
 
     /// <summary>
@@ -319,6 +327,7 @@ public partial class SqueezeAndExcitationLayer<T> : LayerBase<T>, IAuxiliaryLoss
     /// These gradients help the network gradually improve its performance over time.
     /// </para>
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _bias1Gradient;
 
     /// <summary>
@@ -339,6 +348,7 @@ public partial class SqueezeAndExcitationLayer<T> : LayerBase<T>, IAuxiliaryLoss
     /// The network uses these gradients to gradually improve its "attention mechanism" over time.
     /// </para>
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _weights2Gradient;
 
     /// <summary>
@@ -359,6 +369,7 @@ public partial class SqueezeAndExcitationLayer<T> : LayerBase<T>, IAuxiliaryLoss
     /// Along with the other gradients, these help the network improve through training.
     /// </para>
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _bias2Gradient;
 
     /// <summary>
@@ -501,6 +512,9 @@ public partial class SqueezeAndExcitationLayer<T> : LayerBase<T>, IAuxiliaryLoss
 
                              // FC2 biases
 
+    /// <summary>Construction state: the 'reductionRatio' the layer was built with.</summary>
+    private readonly int _reductionRatio;
+
     /// <summary>
     /// Initializes a new instance of the <see cref="SqueezeAndExcitationLayer{T}"/> class with scalar activation functions.
     /// </summary>
@@ -533,6 +547,7 @@ public SqueezeAndExcitationLayer(int channels, int reductionRatio,
         IInitializationStrategy<T>? initializationStrategy = null)
         : base([[channels]], [channels])
     {
+        _reductionRatio = reductionRatio;
         InitializationStrategy = initializationStrategy ?? InitializationStrategies<T>.Eager;
         AuxiliaryLossWeight = NumOps.FromDouble(0.01);
         _lastChannelAttentionLoss = NumOps.Zero;
@@ -582,6 +597,7 @@ public SqueezeAndExcitationLayer(int channels, int reductionRatio,
         IInitializationStrategy<T>? initializationStrategy = null)
         : base([[channels]], [channels])
     {
+        _reductionRatio = reductionRatio;
         InitializationStrategy = initializationStrategy ?? InitializationStrategies<T>.Eager;
         AuxiliaryLossWeight = NumOps.FromDouble(0.01);
         _lastChannelAttentionLoss = NumOps.Zero;
diff --git a/src/NeuralNetworks/Layers/StarCoder2DecoderBlock.cs b/src/NeuralNetworks/Layers/StarCoder2DecoderBlock.cs
index 6f635b6d02..21e28ce3a8 100644
--- a/src/NeuralNetworks/Layers/StarCoder2DecoderBlock.cs
+++ b/src/NeuralNetworks/Layers/StarCoder2DecoderBlock.cs
@@ -1,4 +1,4 @@
-using System.Collections.Generic;
+using System.Collections.Generic;
 using AiDotNet.ActivationFunctions;
 using AiDotNet.Attributes;
 using AiDotNet.Interfaces;
@@ -13,7 +13,7 @@ namespace AiDotNet.NeuralNetworks.Layers;
 /// <typeparam name="T">The numeric type used for calculations.</typeparam>
 [LayerCategory(LayerCategory.Attention)]
 [LayerTask(LayerTask.SequenceModeling)]
-[LayerProperty(IsTrainable = false, HasTrainingMode = false, TestInputShape = "1, 4, 8", TestConstructorArgs = "")]
+[LayerProperty(IsTrainable = false, HasTrainingMode = false, TestInputShape = "1, 4, 8", TestConstructorArgs = "8, 16, new AiDotNet.NeuralNetworks.Layers.MultiHeadAttentionLayer<double>(2, 4)")]
 // Shape-preserving at rank 3 [Batch, Time, Features], which the residual structure guarantees rather
 // than merely happens to satisfy: ForwardTraced ends at TensorAdd(afterAttn, ffnOut), and TensorAdd
 // requires both operands to match - so the block's output is pinned to afterAttn's shape, which is
@@ -30,10 +30,18 @@ namespace AiDotNet.NeuralNetworks.Layers;
 [AutoParameters]
 public partial class StarCoder2DecoderBlock<T> : LayerBase<T>, IShapeContract
 {
+    // Every child reads the block input; only the down-projection reads the expanded width.
+    // Chained sizing walked registration order instead and built the second projection from
+    // the first's output, so a restore met a differently shaped layer than the checkpoint.
+    [SubLayerInput("_hiddenSize")]
     private readonly LayerNormalizationLayer<T> _norm1;
+    [SubLayerInput("1, _hiddenSize")]
     private readonly LayerBase<T> _attention;
+    [SubLayerInput("_hiddenSize")]
     private readonly LayerNormalizationLayer<T> _norm2;
+    [SubLayerInput("_hiddenSize")]
     private readonly DenseLayer<T> _cFc;
+    [SubLayerInput("_ffnDim")]
     private readonly DenseLayer<T> _cProj;
     private readonly int _hiddenSize;
 
@@ -57,6 +65,12 @@ public partial class StarCoder2DecoderBlock<T> : LayerBase<T>, IShapeContract
     /// <summary>The model (input/output) feature dimension.</summary>
     public int HiddenSize => _hiddenSize;
 
+    /// <summary>Construction state: the 'ffnDim' the layer was built with.</summary>
+    private readonly int _ffnDim;
+
+    /// <summary>Construction state: the 'layerNormEpsilon' the layer was built with.</summary>
+    private readonly double _layerNormEpsilon;
+
     /// <summary>Creates a StarCoder2 decoder block.</summary>
     /// <param name="hiddenSize">Input/output feature dimension.</param>
     /// <param name="ffnDim">FFN inner dimension.</param>
@@ -65,6 +79,8 @@ public partial class StarCoder2DecoderBlock<T> : LayerBase<T>, IShapeContract
     public StarCoder2DecoderBlock(int hiddenSize, int ffnDim, LayerBase<T> attention, double layerNormEpsilon = 1e-5)
         : base(new[] { -1, hiddenSize }, new[] { -1, hiddenSize })
     {
+        _layerNormEpsilon = layerNormEpsilon;
+        _ffnDim = ffnDim;
         Guard.NotNull(attention);
         _hiddenSize = hiddenSize;
         _attention = attention;
diff --git a/src/NeuralNetworks/Layers/SubpixelConvolutionalLayer.cs b/src/NeuralNetworks/Layers/SubpixelConvolutionalLayer.cs
index 651c1b1f47..3ebbda6a97 100644
--- a/src/NeuralNetworks/Layers/SubpixelConvolutionalLayer.cs
+++ b/src/NeuralNetworks/Layers/SubpixelConvolutionalLayer.cs
@@ -263,6 +263,7 @@ AxisRelation Spatial(TensorAxis axis) => AxisRelation.ProductOf(
     /// during the backward pass (the learning phase).
     /// </para>
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _lastInput;
 
     /// <summary>
@@ -281,6 +282,7 @@ AxisRelation Spatial(TensorAxis axis) => AxisRelation.ProductOf(
     /// - It helps the layer adjust its parameters more efficiently
     /// </para>
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _lastOutput;
 
     /// <summary>
@@ -312,6 +314,7 @@ AxisRelation Spatial(TensorAxis axis) => AxisRelation.ProductOf(
     /// to make the network perform better next time.
     /// </para>
     /// </remarks>
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T>? _kernelGradients;
 
     /// <summary>
@@ -330,6 +333,7 @@ AxisRelation Spatial(TensorAxis axis) => AxisRelation.ProductOf(
     /// - The update step uses these to modify the biases during training
     /// </para>
     /// </remarks>
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T>? _biasGradients;
 
     /// <summary>
@@ -351,6 +355,7 @@ AxisRelation Spatial(TensorAxis axis) => AxisRelation.ProductOf(
     /// small ups and downs, helping it reach the bottom (optimal solution) faster.
     /// </para>
     /// </remarks>
+    [AiDotNet.Attributes.Buffer]
     private Tensor<T>? _kernelMomentum;
 
     /// <summary>
@@ -372,12 +377,17 @@ AxisRelation Spatial(TensorAxis axis) => AxisRelation.ProductOf(
     /// to smooth out the learning process.
     /// </para>
     /// </remarks>
+    [AiDotNet.Attributes.Buffer]
     private Tensor<T>? _biasMomentum;
 
     // GPU cached tensors for backward pass
+    [ExternalState]
     private Tensor<T>? _gpuInput;
+    [ExternalState]
     private Tensor<T>? _gpuConvOutput;
+    [ExternalState]
     private Tensor<T>? _gpuShuffled;
+    [ExternalState]
     private Tensor<T>? _gpuActivationOutput;
     private bool _gpuAddedBatch;
     private int _gpuBatch;
@@ -388,21 +398,31 @@ AxisRelation Spatial(TensorAxis axis) => AxisRelation.ProductOf(
     #region GPU Weight Storage Fields
 
     // GPU weight tensors for GPU-resident training
+    [ExternalState]
     private Tensor<T>? _gpuKernels;
+    [ExternalState]
     private Tensor<T>? _gpuBiases;
 
     // GPU gradient tensors from BackwardGpu
+    [ExternalState]
     private Tensor<T>? _gpuKernelGradient;
+    [ExternalState]
     private Tensor<T>? _gpuBiasGradient;
 
     // Optimizer state tensors for SGD/NAG/LARS (velocity)
+    [ExternalState]
     private Tensor<T>? _gpuKernelVelocity;
+    [ExternalState]
     private Tensor<T>? _gpuBiasVelocity;
 
     // Optimizer state tensors for Adam/AdamW/LAMB (M and V)
+    [ExternalState]
     private Tensor<T>? _gpuKernelM;
+    [ExternalState]
     private Tensor<T>? _gpuKernelV;
+    [ExternalState]
     private Tensor<T>? _gpuBiasM;
+    [ExternalState]
     private Tensor<T>? _gpuBiasV;
 
     #endregion
@@ -1093,6 +1113,7 @@ public override void ClearGradients()
         _biasGradients = null;
     }
 
+    [Scratch]
     private Vector<T>? _pendingParameters;
 
     #region GPU Parameter Updates
diff --git a/src/NeuralNetworks/Layers/SwinPatchEmbeddingLayer.cs b/src/NeuralNetworks/Layers/SwinPatchEmbeddingLayer.cs
index f3784abfbc..9cc9cf5728 100644
--- a/src/NeuralNetworks/Layers/SwinPatchEmbeddingLayer.cs
+++ b/src/NeuralNetworks/Layers/SwinPatchEmbeddingLayer.cs
@@ -261,6 +261,7 @@ internal override Dictionary<string, string> GetMetadata()
         return metadata;
     }
 
+    [Scratch]
     private Vector<T>? _pendingParameters;
 
     /// <inheritdoc/>
diff --git a/src/NeuralNetworks/Layers/SwinPatchMergingLayer.cs b/src/NeuralNetworks/Layers/SwinPatchMergingLayer.cs
index 357c603896..23d598f809 100644
--- a/src/NeuralNetworks/Layers/SwinPatchMergingLayer.cs
+++ b/src/NeuralNetworks/Layers/SwinPatchMergingLayer.cs
@@ -49,11 +49,23 @@ public partial class SwinPatchMergingLayer<T> : LayerBase<T>, IShapeContract
     /// Linear reduction layer that projects concatenated patches to output dimension.
     /// Input: 4 * inputDim (concatenated 2x2 patches), Output: 2 * inputDim
     /// </summary>
+    /// <remarks>
+    /// Both children are built with their output size alone, so both stayed shape-deferred and
+    /// ParameterCount -- which does not materialize -- reported 0. What GetParameters produced
+    /// instead was worse than a missing count: with nothing declared, the base sized the children by
+    /// CHAINING them in registration order, so reduction was built from this layer's own 8-wide
+    /// input and norm from reduction's 16-wide output, for 176 values. The forward feeds both the
+    /// 4x-concatenated tensor, and norm runs BEFORE reduction, so the real block is 592 values and
+    /// every one of those 176 had the wrong shape. Declaring the width states what the doc comments
+    /// above already say.
+    /// </remarks>
+    [SubLayerInput("_inputDim * 4")]
     private readonly DenseLayer<T> _reduction;
 
     /// <summary>
     /// Layer normalization applied before reduction.
     /// </summary>
+    [SubLayerInput("_inputDim * 4")]
     private readonly LayerNormalizationLayer<T> _norm;
 
     // Cached values for backward pass
diff --git a/src/NeuralNetworks/Layers/SwinTransformerBlockLayer.cs b/src/NeuralNetworks/Layers/SwinTransformerBlockLayer.cs
index e7ca0fde3a..1a95790601 100644
--- a/src/NeuralNetworks/Layers/SwinTransformerBlockLayer.cs
+++ b/src/NeuralNetworks/Layers/SwinTransformerBlockLayer.cs
@@ -67,11 +67,18 @@ public partial class SwinTransformerBlockLayer<T> : LayerBase<T>, IShapeContract
     private long _dropPathForwardCounter;
 
     // Pre-norm layer normalizations
+    // Pre-norm Swin: every child reads the block width except the MLP contraction, which reads the
+    // expanded one. Chained sizing got _outProj wrong -- it handed it the QKV projection's 3*dim
+    // output, where the real forward reshapes into heads and gives it dim.
+    [SubLayerInput("_dim")]
     private readonly LayerNormalizationLayer<T> _norm1;
+    [SubLayerInput("_dim")]
     private readonly LayerNormalizationLayer<T> _norm2;
 
     // Window attention projections
+    [SubLayerInput("_dim")]
     private readonly DenseLayer<T> _qkvProj;
+    [SubLayerInput("_dim")]
     private readonly DenseLayer<T> _outProj;
 
     // Relative position bias table: (2*windowSize-1)^2 entries for each head
@@ -79,15 +86,23 @@ public partial class SwinTransformerBlockLayer<T> : LayerBase<T>, IShapeContract
     private readonly int[,] _relativePositionIndex;
 
     // MLP layers
+    [SubLayerInput("_dim")]
     private readonly DenseLayer<T> _mlpFc1;
+    [SubLayerInput("_dim * _mlpRatio")]
     private readonly DenseLayer<T> _mlpFc2;
 
     // Cached values for backward pass
+    [Scratch]
     private Tensor<T>? _cachedInput;
+    [Scratch]
     private Tensor<T>? _cachedNorm1Output;
+    [Scratch]
     private Tensor<T>? _cachedAttnOutput;
+    [Scratch]
     private Tensor<T>? _cachedResidual1;
+    [Scratch]
     private Tensor<T>? _cachedNorm2Output;
+    [Scratch]
     private Tensor<T>? _cachedQkv; // [numWindows, windowArea, 3*dim]
     private int _cachedNumWindows;
     private int _cachedWindowArea;
diff --git a/src/NeuralNetworks/Layers/SynapticPlasticityLayer.cs b/src/NeuralNetworks/Layers/SynapticPlasticityLayer.cs
index 4e2e140d24..bddd2f69bd 100644
--- a/src/NeuralNetworks/Layers/SynapticPlasticityLayer.cs
+++ b/src/NeuralNetworks/Layers/SynapticPlasticityLayer.cs
@@ -235,6 +235,7 @@ public partial class SynapticPlasticityLayer<T> : LayerBase<T>, IShapeContract
     /// were active in the recent past.
     /// </para>
     /// </remarks>
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _presynapticTraces;
 
     /// <summary>
@@ -256,6 +257,7 @@ public partial class SynapticPlasticityLayer<T> : LayerBase<T>, IShapeContract
     /// input and output activity, which is crucial for spike-timing-dependent plasticity.
     /// </para>
     /// </remarks>
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _postsynapticTraces;
 
     /// <summary>
@@ -277,6 +279,7 @@ public partial class SynapticPlasticityLayer<T> : LayerBase<T>, IShapeContract
     /// version of how biological neurons generate electrical impulses when sufficiently activated.
     /// </para>
     /// </remarks>
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _presynapticSpikes;
 
     /// <summary>
@@ -298,6 +301,7 @@ public partial class SynapticPlasticityLayer<T> : LayerBase<T>, IShapeContract
     /// timing-dependent learning rules.
     /// </para>
     /// </remarks>
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _postsynapticSpikes;
 
     /// <summary>
@@ -328,11 +332,14 @@ public partial class SynapticPlasticityLayer<T> : LayerBase<T>, IShapeContract
 
     public override bool SupportsTraining => true;
 
+    [Scratch]
     private Tensor<T>? _lastInputGpu;
+    [Scratch]
     private Tensor<T>? _lastOutputGpu;
     private Tensor<T>? _presynapticTracesGpu;
     private Tensor<T>? _postsynapticTracesGpu;
     private Tensor<T>? _presynapticSpikesGpu;
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T>? _postsynapticSpikesGpu;
 
     /// <inheritdoc/>
@@ -496,6 +503,9 @@ protected override void Dispose(bool disposing)
         base.Dispose(disposing);
     }
 
+    /// <summary>Construction state: the 'size' the layer was built with.</summary>
+    private readonly int _size;
+
     /// <summary>
     /// Initializes a new instance of the <see cref="SynapticPlasticityLayer{T}"/> class.
     /// </summary>
@@ -527,6 +537,7 @@ protected override void Dispose(bool disposing)
     public SynapticPlasticityLayer(int size, double stdpLtpRate = 0.005,
         double stdpLtdRate = 0.0025, double homeostasisRate = 0.0001, double minWeight = 0, double maxWeight = 1, double traceDecay = 0.95) : base([size], [size])
     {
+        _size = size;
         // Initialize cached state tensors
         _lastInput = new Tensor<T>([size]);
         _lastInput.Fill(NumOps.Zero);
diff --git a/src/NeuralNetworks/Layers/T5RelativeBiasAttentionLayer.cs b/src/NeuralNetworks/Layers/T5RelativeBiasAttentionLayer.cs
index ba5195f810..51937ecda7 100644
--- a/src/NeuralNetworks/Layers/T5RelativeBiasAttentionLayer.cs
+++ b/src/NeuralNetworks/Layers/T5RelativeBiasAttentionLayer.cs
@@ -109,12 +109,18 @@ public partial class T5RelativeBiasAttentionLayer<T> : LayerBase<T>, IShapeContr
     // Recomputed only when seqLen changes; positions are fixed so this
     // is pure shape state, NOT a trainable parameter.
     private int _cachedSeqLen = -1;
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<int>? _bucketIndices;
 
+    [Scratch]
     private Tensor<T>? _qGradient;
+    [Scratch]
     private Tensor<T>? _kGradient;
+    [Scratch]
     private Tensor<T>? _vGradient;
+    [Scratch]
     private Tensor<T>? _oGradient;
+    [Scratch]
     private Tensor<T>? _biasTableGradient;
 
     public override bool SupportsTraining => true;
diff --git a/src/NeuralNetworks/Layers/TabNetEncoderLayer.cs b/src/NeuralNetworks/Layers/TabNetEncoderLayer.cs
index 5b2805b522..e392ccf446 100644
--- a/src/NeuralNetworks/Layers/TabNetEncoderLayer.cs
+++ b/src/NeuralNetworks/Layers/TabNetEncoderLayer.cs
@@ -72,7 +72,9 @@ public partial class TabNetEncoderLayer<T> : LayerBase<T>, IShapeContract
     private FeatureTransformerLayer<T>? _initialFeatureTransformer;
     private AttentiveTransformerLayer<T>[]? _attentiveTransformers;
     private FeatureTransformerLayer<T>[]? _stepFeatureTransformers;
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T>? _decisionSelector;
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T>? _attentionSelector;
 
     /// <summary>
diff --git a/src/NeuralNetworks/Layers/TemporalConv3DLayer.cs b/src/NeuralNetworks/Layers/TemporalConv3DLayer.cs
index c331207a09..cfeddadd42 100644
--- a/src/NeuralNetworks/Layers/TemporalConv3DLayer.cs
+++ b/src/NeuralNetworks/Layers/TemporalConv3DLayer.cs
@@ -17,7 +17,7 @@ namespace AiDotNet.NeuralNetworks.Layers;
 /// </remarks>
 [LayerCategory(LayerCategory.Convolution)]
 [LayerTask(LayerTask.TemporalProcessing)]
-[LayerProperty(IsTrainable = true, ChangesShape = true, ExpectedInputRank = 5)]
+[LayerProperty(IsTrainable = true, ChangesShape = true, ExpectedInputRank = 5, TestConstructorArgs = "2, 4, 3", TestInputShape = "1, 2, 4, 4, 4")]
 [TensorLayout(TensorAxis.Batch, TensorAxis.Channels, TensorAxis.Time, TensorAxis.Height, TensorAxis.Width,
     Direction = TensorLayoutDirection.Input)]
 [TensorLayout(TensorAxis.Batch, TensorAxis.Channels, TensorAxis.Time, TensorAxis.Height, TensorAxis.Width,
@@ -175,17 +175,7 @@ public override void ResetState()
     {
     }
 
-    /// <inheritdoc />
-    public override LayerBase<T> Clone()
-    {
-        var clone = new TemporalConv3DLayer<T>(
-            _inputChannels, _outputChannels,
-            _kernelDepth, _kernelHeight, _kernelWidth,
-            _paddingDepth, _paddingHeight, _paddingWidth,
-            _zeroInitialize);
-        if (_kernels.Length > 0) clone.SetParameters(GetParameters());
-        return clone;
-    }
+
 
     /// <inheritdoc />
     internal override Dictionary<string, string> GetMetadata()
diff --git a/src/NeuralNetworks/Layers/TemporalMemoryLayer.cs b/src/NeuralNetworks/Layers/TemporalMemoryLayer.cs
index 5694ee4cd3..dce22b7c82 100644
--- a/src/NeuralNetworks/Layers/TemporalMemoryLayer.cs
+++ b/src/NeuralNetworks/Layers/TemporalMemoryLayer.cs
@@ -125,6 +125,7 @@ public partial class TemporalMemoryLayer<T> : LayerBase<T>, IShapeContract
     /// </para>
     /// </remarks>
     private readonly int CellsPerColumn;
+    [Scratch]
     private Tensor<T>? _lastInput;
 
     /// <summary>
diff --git a/src/NeuralNetworks/Layers/TemporalProcessorModule.cs b/src/NeuralNetworks/Layers/TemporalProcessorModule.cs
index d9acaffdbf..0ac2aad165 100644
--- a/src/NeuralNetworks/Layers/TemporalProcessorModule.cs
+++ b/src/NeuralNetworks/Layers/TemporalProcessorModule.cs
@@ -57,6 +57,15 @@ namespace AiDotNet.NeuralNetworks.Layers;
 [TensorLayout(TensorAxis.Batch, TensorAxis.Time, TensorAxis.Features, Direction = TensorLayoutDirection.Input)]
 [TensorLayout(TensorAxis.Batch, TensorAxis.Time, TensorAxis.Features, Direction = TensorLayoutDirection.Output)]
 [AutoParameters]
+// See the note on ObliviousDecisionTreeLayer. The convolutions are built on the first forward,
+// so without a declared input shape this layer could never be driven and its parameters never
+// existed to be measured.
+// DualTensor, because that is the signature that actually exercises this module. The single-tensor
+// overload is the first-frame path and returns the input untouched, so a single-input harness drives
+// the convolutions not at all and no gradient can reach them.
+[LayerProperty(IsTrainable = true, ChangesShape = false, ExpectedInputRank = 3,
+    ApiShape = LayerApiShape.DualTensor,
+    TestInputShape = "4, 8, 8", TestConstructorArgs = "3")]
 public partial class TemporalProcessorModule<T> : LayerBase<T>, IShapeContract
 {
     #region Fields
@@ -122,9 +131,6 @@ public Tensor<T> Forward(Tensor<T> current, Tensor<T>? warpedPrevious)
     {
         if (current is null) throw new ArgumentNullException(nameof(current));
 
-        // First frame: no temporal context exists, so pass the spatial features through untouched.
-        if (warpedPrevious is null) return current;
-
         var shape = current.Shape;
         if (shape.Length is not (3 or 4))
         {
@@ -138,8 +144,16 @@ public Tensor<T> Forward(Tensor<T> current, Tensor<T>? warpedPrevious)
         int height = shape[shape.Length - 2];
         int width = shape[shape.Length - 1];
 
+        // Sized from the CURRENT features, before the first-frame path returns. EnsureResolved needs
+        // nothing but `current` -- the channel width is right there -- and returning ahead of it left
+        // a module that had run a forward still holding no parameters at all. A decoder that
+        // processed only a first frame therefore checkpointed none of this module's weights, and
+        // nothing reported it, because a count of zero reads the same as a layer that owns nothing.
         EnsureResolved(current, channels);
 
+        // First frame: no temporal context exists, so pass the spatial features through untouched.
+        if (warpedPrevious is null) return current;
+
         // 1. Interpolation — bring the previous features onto the current spatial grid.
         var prev = warpedPrevious;
         int prevH = prev.Shape[prev.Shape.Length - 2];
diff --git a/src/NeuralNetworks/Layers/TimeDistributedLayer.cs b/src/NeuralNetworks/Layers/TimeDistributedLayer.cs
index 9769264f63..be8a02960b 100644
--- a/src/NeuralNetworks/Layers/TimeDistributedLayer.cs
+++ b/src/NeuralNetworks/Layers/TimeDistributedLayer.cs
@@ -34,7 +34,7 @@ namespace AiDotNet.NeuralNetworks.Layers;
 [LayerCategory(LayerCategory.Structural)]
 [LayerTask(LayerTask.TemporalProcessing)]
 [LayerTask(LayerTask.SequenceModeling)]
-[LayerProperty(IsTrainable = true)]
+[LayerProperty(IsTrainable = true, TestConstructorArgs = "new AiDotNet.NeuralNetworks.Layers.ReadoutLayer<double>(4, 8, (AiDotNet.Interfaces.IActivationFunction<double>)new AiDotNet.ActivationFunctions.IdentityActivation<double>()), (AiDotNet.Interfaces.IActivationFunction<double>?)null, new[] { 3, 4 }", TestInputShape = "3, 4")]
 // A COMPOSING decorator, not a delegating one. ForwardTraced builds
 // `outputShape = new[] { batchSize, timeSteps }.Concat(_innerLayer.GetOutputShape())`, so the leading
 // two axes are this layer's (carried straight through from the input) and every trailing axis is the
@@ -177,6 +177,7 @@ public partial class TimeDistributedLayer<T> : LayerBase<T>, IShapeContract
     /// or wrong during the learning process.
     /// </para>
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _lastInput;
 
     /// <summary>
@@ -203,6 +204,7 @@ public partial class TimeDistributedLayer<T> : LayerBase<T>, IShapeContract
     /// which is crucial for learning.
     /// </para>
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _lastOutput;
 
     public override bool SupportsTraining => _innerLayer.SupportsTraining;
@@ -454,17 +456,26 @@ protected override Tensor<T> ForwardTraced(Tensor<T> input)
         _lastInput = processInput;
 
         var innerOutputShape = _innerLayer.GetOutputShape();
-        var outputShape = new[] { batchSize, timeSteps }.Concat(innerOutputShape).ToArray();
-        var output = TensorAllocator.Rent<T>(outputShape);
 
+        // Concatenated through the engine, NOT written into a rented buffer. SetSlice on a rented
+        // tensor records no tape node, so the inner layer's weights were unreachable from the loss:
+        // every trainable parameter came back with a zero gradient and the layer trained not at all
+        // while looking healthy. Each step is reshaped to width 1 on the time axis and joined there,
+        // which is the same tensor with a gradient path attached to it.
+        var stepOutputs = new Tensor<T>[timeSteps];
+        var stepShape = new[] { batchSize, 1 }.Concat(innerOutputShape).ToArray();
         for (int t = 0; t < timeSteps; t++)
         {
             var stepInput = processInput.Slice(1, t, t + 1);
             stepInput = SqueezeAxis(stepInput, 1);
             var stepOutput = _innerLayer.Forward(stepInput);
-            output.SetSlice(1, t, stepOutput);
+            stepOutputs[t] = Engine.Reshape(stepOutput, stepShape);
         }
 
+        var output = timeSteps == 1
+            ? stepOutputs[0]
+            : Engine.TensorConcatenate(stepOutputs, axis: 1);
+
         var activated = ApplyActivation(output);
 
         if (_originalInputShape != null && _originalInputShape.Length == 2)
@@ -488,6 +499,7 @@ protected override Tensor<T> ForwardTraced(Tensor<T> input)
     /// through each time step and delegating to the inner layer's backward pass.
     /// </para>
     /// </remarks>
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T>? _accumulatedGradients;
 
     private static Tensor<T> SqueezeAxis(Tensor<T> tensor, int axis)
diff --git a/src/NeuralNetworks/Layers/TimeEmbeddingLayer.cs b/src/NeuralNetworks/Layers/TimeEmbeddingLayer.cs
index 61dd9c471c..d638413a11 100644
--- a/src/NeuralNetworks/Layers/TimeEmbeddingLayer.cs
+++ b/src/NeuralNetworks/Layers/TimeEmbeddingLayer.cs
@@ -117,42 +117,53 @@ public partial class TimeEmbeddingLayer<T> : LayerBase<T>, IShapeContract
     /// <summary>
     /// Cached sinusoidal embedding from last forward pass.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastSinusoidalEmbed;
 
     /// <summary>
     /// Cached intermediate output after first linear + activation.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastHidden;
 
     /// <summary>
     /// Cached input timesteps from last forward pass.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastInput;
 
     /// <summary>
     /// Gradient for first linear layer weights.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _linear1WeightsGradient;
 
     /// <summary>
     /// Gradient for first linear layer biases.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _linear1BiasGradient;
 
     /// <summary>
     /// Gradient for second linear layer weights.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _linear2WeightsGradient;
 
     /// <summary>
     /// Gradient for second linear layer biases.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _linear2BiasGradient;
 
     // GPU cached tensors for backward pass
+    [ExternalState]
     private Tensor<T>? _gpuTimesteps;
+    [ExternalState]
     private Tensor<T>? _gpuSinusoidalEmbed;
+    [ExternalState]
     private Tensor<T>? _gpuHidden;
+    [ExternalState]
     private Tensor<T>? _gpuPreActivation;
     private int[]? _gpuInputShape;
 
diff --git a/src/NeuralNetworks/Layers/TransformerDecoderLayer.cs b/src/NeuralNetworks/Layers/TransformerDecoderLayer.cs
index 9c654b3c82..c69882dc98 100644
--- a/src/NeuralNetworks/Layers/TransformerDecoderLayer.cs
+++ b/src/NeuralNetworks/Layers/TransformerDecoderLayer.cs
@@ -349,6 +349,7 @@ public partial class TransformerDecoderLayer<T> : LayerBase<T>, IAuxiliaryLossLa
     /// to improve its performance on future inputs.
     /// </para>
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _lastInput;
 
     /// <summary>
@@ -370,6 +371,7 @@ public partial class TransformerDecoderLayer<T> : LayerBase<T>, IAuxiliaryLossLa
     /// the source language sentence that the decoder is translating.
     /// </para>
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _lastEncoderOutput;
 
     /// <summary>
@@ -391,6 +393,7 @@ public partial class TransformerDecoderLayer<T> : LayerBase<T>, IAuxiliaryLossLa
     /// as they show how each component contributed to the final output.
     /// </para>
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _lastSelfAttentionOutput;
 
     /// <summary>
@@ -412,6 +415,7 @@ public partial class TransformerDecoderLayer<T> : LayerBase<T>, IAuxiliaryLossLa
     /// how it arrived at its final output, so it can learn to improve.
     /// </para>
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _lastNormalized1;
 
     /// <summary>
@@ -433,6 +437,7 @@ public partial class TransformerDecoderLayer<T> : LayerBase<T>, IAuxiliaryLossLa
     /// was deemed relevant for generating the target sequence.
     /// </para>
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _lastCrossAttentionOutput;
 
     /// <summary>
@@ -454,6 +459,7 @@ public partial class TransformerDecoderLayer<T> : LayerBase<T>, IAuxiliaryLossLa
     /// how it arrived at its final output, enabling precise learning.
     /// </para>
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _lastNormalized2;
 
     /// <summary>
@@ -475,10 +481,13 @@ public partial class TransformerDecoderLayer<T> : LayerBase<T>, IAuxiliaryLossLa
     /// and output of the complete decoder layer.
     /// </para>
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _lastFeedForwardOutput;
 
     // GPU cached tensors for backward pass
+    [ExternalState]
     private Tensor<T>? _gpuNormalized1;
+    [ExternalState]
     private Tensor<T>? _gpuNormalized2;
 
     /// <summary>
diff --git a/src/NeuralNetworks/Layers/TransformerEncoderLayer.cs b/src/NeuralNetworks/Layers/TransformerEncoderLayer.cs
index 17e43fbfb9..2f5b992c6c 100644
--- a/src/NeuralNetworks/Layers/TransformerEncoderLayer.cs
+++ b/src/NeuralNetworks/Layers/TransformerEncoderLayer.cs
@@ -107,7 +107,9 @@ public partial class TransformerEncoderLayer<T> : LayerBase<T>, IAuxiliaryLossLa
     private int[]? _originalInputShape;
 
     // GPU cached tensors for backward pass
+    [ExternalState]
     private Tensor<T>? _gpuInput3D;
+    [ExternalState]
     private Tensor<T>? _gpuNormalized1;
 
     /// <summary>
@@ -305,28 +307,6 @@ public partial class TransformerEncoderLayer<T> : LayerBase<T>, IAuxiliaryLossLa
     /// </remarks>
     public override bool SupportsTraining => true;
 
-    public override void Serialize(BinaryWriter writer)
-    {
-        // Persist _embeddingSize so Deserialize can re-resolve sublayers
-        // before SetParameters runs. The composite param vector layout
-        // requires _embeddingSize to compute sublayer sizes; without
-        // it, SetParameters throws (sublayers haven't been constructed).
-        writer.Write(_embeddingSize);
-        base.Serialize(writer);
-    }
-
-    public override void Deserialize(BinaryReader reader)
-    {
-        int savedEmbeddingSize = reader.ReadInt32();
-        if (!_isInitialized && savedEmbeddingSize > 0)
-        {
-            // ResolveFromShape with [embeddingSize] triggers
-            // EnsureInitialized which constructs the sublayers.
-            ResolveFromShape(new[] { savedEmbeddingSize });
-        }
-        base.Deserialize(reader);
-    }
-
     public override Vector<T> GetParameterGradients()
     {
         if (!_isInitialized) return new Vector<T>(0);
diff --git a/src/NeuralNetworks/Layers/TransitionLayer.cs b/src/NeuralNetworks/Layers/TransitionLayer.cs
index 3f3b1d8144..c749eb3285 100644
--- a/src/NeuralNetworks/Layers/TransitionLayer.cs
+++ b/src/NeuralNetworks/Layers/TransitionLayer.cs
@@ -71,6 +71,7 @@ public partial class TransitionLayer<T> : LayerBase<T>, ILayerSerializationExtra
     // before the first Forward. Both _bn and _conv are still unresolved
     // at that point so we can't slice between them; stash the whole
     // vector and replay inside OnFirstForward.
+    [Scratch]
     private Vector<T>? _pendingParameters;
     // Lazy ctor leaves _conv = null until OnFirstForward resolves
     // OutputChannels (= inputChannels × compressionFactor) and allocates
@@ -81,13 +82,16 @@ public partial class TransitionLayer<T> : LayerBase<T>, ILayerSerializationExtra
     private readonly AveragePoolingLayer<T> _pool;
     private readonly IActivationFunction<T> _relu;
 
+    [Scratch]
     private Tensor<T>? _lastInput;
     private Tensor<T>? _bnOut;
     private Tensor<T>? _reluOut;
     private Tensor<T>? _convOut;
 
     // GPU cached tensors for backward pass
+    [ExternalState]
     private Tensor<T>? _gpuBnOut;
+    [ExternalState]
     private Tensor<T>? _gpuConvOut;
     private bool _gpuAdded3DBatch;
 
diff --git a/src/NeuralNetworks/Layers/UNetDiscriminator.cs b/src/NeuralNetworks/Layers/UNetDiscriminator.cs
index e2ba0034a4..e31375d26c 100644
--- a/src/NeuralNetworks/Layers/UNetDiscriminator.cs
+++ b/src/NeuralNetworks/Layers/UNetDiscriminator.cs
@@ -160,6 +160,7 @@ public partial class UNetDiscriminator<T> : LayerBase<T>, IShapeContract
     /// <summary>
     /// Cached input for backpropagation.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastInput;
 
     #endregion
@@ -433,6 +434,7 @@ public override void UpdateParameters(T learningRate)
         _convLast.UpdateParameters(learningRate);
     }
 
+    [Scratch]
     private Vector<T>? _pendingParameters;
 
     private static void AddParamsToList(List<T> list, Vector<T> parameters)
@@ -527,9 +529,13 @@ AxisRelation Spatial(TensorAxis axis) => _downsample
     private readonly LeakyReLUActivation<T> _leakyReLU;
     private readonly bool _downsample;
 
+    [AiDotNet.Attributes.Scratch]
     private Tensor<T>? _lastInput;
+    [AiDotNet.Attributes.Scratch]
     private Tensor<T>? _conv1Output;      // After LeakyReLU (input to conv2)
+    [AiDotNet.Attributes.Scratch]
     private Tensor<T>? _conv1RawOutput;   // Before LeakyReLU (for backward)
+    [AiDotNet.Attributes.Scratch]
     private Tensor<T>? _conv2RawOutput;   // Before LeakyReLU (for backward)
 
     private readonly int _outChannels;
@@ -640,6 +646,7 @@ public override void UpdateParameters(T learningRate)
         _conv2.UpdateParameters(learningRate);
     }
 
+    [AiDotNet.Attributes.Scratch]
     private Vector<T>? _pendingParameters;
 
     public override void ResetState()
@@ -706,7 +713,9 @@ public partial class UNetUpBlock<T> : LayerBase<T>, IShapeContract
     private readonly LeakyReLUActivation<T> _leakyReLU;
     private readonly int _skipChannels;
 
+    [AiDotNet.Attributes.Scratch]
     private Tensor<T>? _lastInput;
+    [Scratch]
     private Tensor<T>? _lastSkip;
     private Tensor<T>? _upsampledInput;
     private Tensor<T>? _concatenated;
@@ -934,6 +943,7 @@ public override void UpdateParameters(T learningRate)
         _conv2.UpdateParameters(learningRate);
     }
 
+    [AiDotNet.Attributes.Scratch]
     private Vector<T>? _pendingParameters;
 
     public override void ResetState()
diff --git a/src/NeuralNetworks/Layers/Upsample3DLayer.cs b/src/NeuralNetworks/Layers/Upsample3DLayer.cs
index 7378265fb4..367f474a67 100644
--- a/src/NeuralNetworks/Layers/Upsample3DLayer.cs
+++ b/src/NeuralNetworks/Layers/Upsample3DLayer.cs
@@ -158,6 +158,7 @@ public partial class Upsample3DLayer<T> : LayerBase<T>, IShapeContract
     /// <summary>
     /// The input tensor from the last forward pass, cached for backward computation.
     /// </summary>
+    [Scratch]
     private Tensor<T>? _lastInput;
 
     /// <summary>
@@ -175,6 +176,9 @@ public partial class Upsample3DLayer<T> : LayerBase<T>, IShapeContract
 
     #region Constructors
 
+    /// <summary>Construction state: the 'scaleFactor' the layer was built with.</summary>
+    private readonly int _scaleFactor;
+
     /// <summary>
     /// Initializes a new instance of the <see cref="Upsample3DLayer{T}"/> class with uniform scaling.
     /// </summary>
@@ -193,6 +197,7 @@ public partial class Upsample3DLayer<T> : LayerBase<T>, IShapeContract
     public Upsample3DLayer(int scaleFactor)
         : this(scaleFactor, scaleFactor, scaleFactor)
     {
+        _scaleFactor = scaleFactor;
     }
 
     /// <summary>
@@ -455,75 +460,10 @@ public override void ResetState()
 
     #region Cloning
 
-    /// <summary>
-    /// Creates a deep copy of the layer with the same configuration.
-    /// </summary>
-    /// <returns>A new instance of the <see cref="Upsample3DLayer{T}"/> with identical configuration.</returns>
-    public override LayerBase<T> Clone()
-    {
-        return new Upsample3DLayer<T>(ScaleDepth, ScaleHeight, ScaleWidth);
-    }
-
     #endregion
 
     #region Serialization
 
-    /// <summary>
-    /// Serializes the layer to a binary stream.
-    /// </summary>
-    /// <param name="writer">The binary writer to serialize to.</param>
-    public override void Serialize(BinaryWriter writer)
-    {
-        base.Serialize(writer);
-
-        // Write input shape for proper deserialization
-        writer.Write(InputShape.Length);
-        foreach (var dim in InputShape)
-        {
-            writer.Write(dim);
-        }
-
-        writer.Write(ScaleDepth);
-        writer.Write(ScaleHeight);
-        writer.Write(ScaleWidth);
-    }
-
-    /// <summary>
-    /// Deserializes the layer from a binary stream.
-    /// </summary>
-    /// <param name="reader">The binary reader to deserialize from.</param>
-    /// <exception cref="InvalidOperationException">Thrown because Upsample3DLayer uses readonly properties and cannot be deserialized in-place.</exception>
-    /// <remarks>
-    /// <para>
-    /// This method validates that the serialized scale factors match the current instance's values.
-    /// For full deserialization support, use the static factory method <see cref="DeserializeFrom"/> instead.
-    /// </para>
-    /// </remarks>
-    public override void Deserialize(BinaryReader reader)
-    {
-        base.Deserialize(reader);
-
-        // Read input shape
-        int inputShapeLength = reader.ReadInt32();
-        var inputShape = new int[inputShapeLength];
-        for (int i = 0; i < inputShapeLength; i++)
-        {
-            inputShape[i] = reader.ReadInt32();
-        }
-
-        var scaleD = reader.ReadInt32();
-        var scaleH = reader.ReadInt32();
-        var scaleW = reader.ReadInt32();
-
-        // Validate serialized values match current instance (readonly properties cannot be changed)
-        if (scaleD != ScaleDepth || scaleH != ScaleHeight || scaleW != ScaleWidth)
-        {
-            throw new InvalidOperationException(
-                $"Deserialized scale factors [{scaleD}, {scaleH}, {scaleW}] do not match current instance " +
-                $"[{ScaleDepth}, {ScaleHeight}, {ScaleWidth}]. Use DeserializeFrom factory method instead.");
-        }
-    }
-
     /// <summary>
     /// Creates a new Upsample3DLayer instance from serialized data.
     /// </summary>
diff --git a/src/NeuralNetworks/Layers/UpsamplingLayer.cs b/src/NeuralNetworks/Layers/UpsamplingLayer.cs
index 0e0e1a1fe5..57a0ca21bb 100644
--- a/src/NeuralNetworks/Layers/UpsamplingLayer.cs
+++ b/src/NeuralNetworks/Layers/UpsamplingLayer.cs
@@ -128,6 +128,7 @@ public partial class UpsamplingLayer<T> : LayerBase<T>, IShapeContract
     /// to improve its performance on future inputs.
     /// </para>
     /// </remarks>
+    [Scratch]
     private Tensor<T>? _lastInput;
 
     /// <summary>
diff --git a/src/NeuralNetworks/Layers/VGGishAudioEmbedding.cs b/src/NeuralNetworks/Layers/VGGishAudioEmbedding.cs
index 82a90aa696..593d4cbda3 100644
--- a/src/NeuralNetworks/Layers/VGGishAudioEmbedding.cs
+++ b/src/NeuralNetworks/Layers/VGGishAudioEmbedding.cs
@@ -73,6 +73,11 @@ public partial class VGGishAudioEmbedding<T> : LayerBase<T>, IShapeContract
     /// <summary>Frames per patch in the published front-end (0.96 s at a 10 ms hop).</summary>
     public const int PaperPatchFrames = 96;
 
+    private readonly int _conv1Filters;
+    private readonly int _conv2Filters;
+    private readonly int _conv3Filters;
+    private readonly int _conv4Filters;
+
     private readonly ConvolutionalLayer<T> _conv1;
     private readonly MaxPoolingLayer<T> _pool1;
     private readonly ConvolutionalLayer<T> _conv2;
@@ -85,12 +90,23 @@ public partial class VGGishAudioEmbedding<T> : LayerBase<T>, IShapeContract
     private readonly MaxPoolingLayer<T> _pool4;
     private readonly FlattenLayer<T> _flatten;
     private readonly DenseLayer<T> _fc1;
+    // Declared because their width IS known at construction: both read the fully connected width
+    // that _fc1 produces. The convolutions before them cannot be declared -- this layer's own
+    // input is [-1, -1] -- and they no longer need to be, since the chain now covers whatever a
+    // declaration leaves out. Without this the two were shape-deferred, contributing nothing to
+    // the count while GetParameters materialized them: 4160 + 2080 = the 6240 the sweep reported.
+    [SubLayerInput("FullyConnectedWidth")]
     private readonly DenseLayer<T> _fc2;
+    [SubLayerInput("FullyConnectedWidth")]
     private readonly DenseLayer<T> _embedding;
 
     /// <summary>Size of the embedding this layer produces.</summary>
     public int EmbeddingSize { get; }
 
+    /// <summary>Width of the two hidden dense layers.</summary>
+    /// <remarks>Retained so the layers after the flatten can DECLARE the width they read.</remarks>
+    public int FullyConnectedWidth { get; }
+
     /// <inheritdoc/>
     public override bool SupportsTraining => true;
 
@@ -130,6 +146,11 @@ public VGGishAudioEmbedding(
         Positive(embeddingSize, nameof(embeddingSize));
 
         EmbeddingSize = embeddingSize;
+        FullyConnectedWidth = fullyConnectedWidth;
+        _conv1Filters = conv1Filters;
+        _conv2Filters = conv2Filters;
+        _conv3Filters = conv3Filters;
+        _conv4Filters = conv4Filters;
 
         // 3x3 kernels with padding 1 reproduce TensorFlow's SAME padding at stride 1, so each group
         // preserves its spatial extent and only the pools reduce it. ReLU on every convolution.
diff --git a/src/NeuralNetworks/Layers/VocosGeneratorLayer.cs b/src/NeuralNetworks/Layers/VocosGeneratorLayer.cs
index 242a92d625..5357f69388 100644
--- a/src/NeuralNetworks/Layers/VocosGeneratorLayer.cs
+++ b/src/NeuralNetworks/Layers/VocosGeneratorLayer.cs
@@ -109,7 +109,9 @@ public partial class VocosGeneratorLayer<T> : LayerBase<T>, IShapeContract
     private readonly LayerNormalizationLayer<T> _outputNormalization;
     private readonly FullyConnectedLayer<T> _fourierProjection;
     private readonly Tensor<T> _window;
+    [AiDotNet.Attributes.TrainableParameter]
     private readonly Tensor<int> _inverseFftInteriorReverseIndices;
+    [AiDotNet.Attributes.TrainableParameter]
     private readonly Tensor<int> _inverseFftBitReverseIndices;
     private readonly Tensor<T>[] _inverseFftCosines;
     private readonly Tensor<T>[] _inverseFftSines;
diff --git a/src/NeuralNetworks/Layers/WordCharEmbeddingLayer.cs b/src/NeuralNetworks/Layers/WordCharEmbeddingLayer.cs
index e44db5618b..b7fb4f439f 100644
--- a/src/NeuralNetworks/Layers/WordCharEmbeddingLayer.cs
+++ b/src/NeuralNetworks/Layers/WordCharEmbeddingLayer.cs
@@ -56,7 +56,15 @@ namespace AiDotNet.NeuralNetworks.Layers;
 /// </remarks>
 [LayerCategory(LayerCategory.Other)]
 [LayerTask(LayerTask.SequenceModeling)]
-[LayerProperty(IsTrainable = true, ChangesShape = true)]
+[LayerProperty(IsTrainable = true, ChangesShape = true, TestConstructorArgs = "10, 4, 8, 3, 5, 4, 6", TestInputShape = "4, 7")]
+// The input carries TOKEN IDS, not measurements. Without this the layer had no port
+// declaration at all, so a generated test fed it continuous random values -- negatives
+// included -- and it failed on "Packed indices must be non-negative". EmbeddingLayer
+// declares the same thing; this one simply never did.
+[TensorPort("input", TensorPortDirection.Input, LayerInputDomainKind.IntegerIndices,
+    Role = TensorPortRole.TokenIds, MaxExclusiveMember = "PackedIndexUpperBound")]
+[TensorPort("output", TensorPortDirection.Output, LayerInputDomainKind.Continuous,
+    Role = TensorPortRole.Features)]
 // Rank 2 and ONLY rank 2 - ForwardTraced opens with an explicit guard that throws for anything else:
 // "expects rank-2 packed input [sequenceLength, 1 + maxWordLength]". No batch axis is declared because
 // the layer does not have one; a sentence IS the unit, and the character BiLSTM already spends the
@@ -102,7 +110,12 @@ public partial class WordCharEmbeddingLayer<T> : LayerBase<T>, IShapeContract
         };
     }
 
+    // These read ONE-HOT vocabularies, not the packed id tensor this layer receives. Chained
+    // sizing seeded them from the layer's own [seq, 1 + maxWordLength] input, so the word
+    // embedding came up 7 wide against a checkpoint holding the 10-wide vocabulary.
+    [SubLayerInput("_wordVocabSize")]
     private readonly DenseLayer<T> _wordEmbedding;
+    [SubLayerInput("_charVocabSize")]
     private readonly DenseLayer<T> _charEmbedding;
     private readonly BidirectionalLayer<T> _charBiLstm;
 
@@ -118,9 +131,26 @@ public partial class WordCharEmbeddingLayer<T> : LayerBase<T>, IShapeContract
     /// </summary>
     public int OutputEmbeddingDim => _wordEmbeddingDim + _charHiddenDim;
 
+    /// <summary>
+    /// Upper bound for the packed tensor's mixed word/character index domain.
+    /// </summary>
+    /// <remarks>
+    /// Column zero uses the word vocabulary while the remaining columns use the character
+    /// vocabulary. The port contract validates the tensor as a whole, so its safe global bound is
+    /// the larger cardinality; <see cref="NormalizeIndex"/> applies the column-specific bound and
+    /// maps a legal packed value outside that column's vocabulary to UNK.
+    /// </remarks>
+    private int PackedIndexUpperBound => Math.Max(_wordVocabSize, _charVocabSize);
+
     /// <inheritdoc/>
     public override bool SupportsTraining => true;
 
+    /// <summary>Construction state: the 'charEmbeddingDim' the layer was built with.</summary>
+    private readonly int _charEmbeddingDim;
+
+    /// <summary>Construction state: the 'sequenceLength' the layer was built with.</summary>
+    private readonly int _sequenceLength;
+
     /// <summary>
     /// Initializes a new <see cref="WordCharEmbeddingLayer{T}"/>.
     /// </summary>
@@ -144,6 +174,8 @@ public WordCharEmbeddingLayer(
             [sequenceLength, wordEmbeddingDim + charHiddenDim],
             (IActivationFunction<T>)new IdentityActivation<T>())
     {
+        _sequenceLength = sequenceLength;
+        _charEmbeddingDim = charEmbeddingDim;
         if (wordVocabSize <= 0) throw new ArgumentOutOfRangeException(nameof(wordVocabSize));
         if (wordEmbeddingDim <= 0) throw new ArgumentOutOfRangeException(nameof(wordEmbeddingDim));
         if (charVocabSize <= 0) throw new ArgumentOutOfRangeException(nameof(charVocabSize));
diff --git a/src/NeuralNetworks/LiquidStateMachine.cs b/src/NeuralNetworks/LiquidStateMachine.cs
index 08799f5539..f3dadb7392 100644
--- a/src/NeuralNetworks/LiquidStateMachine.cs
+++ b/src/NeuralNetworks/LiquidStateMachine.cs
@@ -53,7 +53,7 @@ namespace AiDotNet.NeuralNetworks;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
     [ResearchPaper("Real-Time Computing Without Stable States", "https://doi.org/10.1162/089976602760407955")]
-public class LiquidStateMachine<T> : SequenceModelLayoutBase<T>
+public partial class LiquidStateMachine<T> : SequenceModelLayoutBase<T>
 {
     private readonly LiquidStateMachineOptions _options;
     private readonly IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>> _optimizer;
@@ -540,18 +540,7 @@ public override ModelMetadata<T> GetModelMetadata()
     /// when loaded later.
     /// </para>
     /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        // Write LSM-specific properties
-        writer.Write(_reservoirSize);
-        writer.Write(NumOps.ToDouble(_connectionProbability));
-        writer.Write(NumOps.ToDouble(_spectralRadius));
-        writer.Write(NumOps.ToDouble(_inputScaling));
-        writer.Write(NumOps.ToDouble(_leakingRate));
-
-        // Write whether we're in training mode
-        writer.Write(IsTrainingMode);
-    }
+
 
     /// <summary>
     /// Deserializes Liquid State Machine-specific data from a binary reader.
@@ -575,17 +564,7 @@ protected override void SerializeNetworkSpecificData(BinaryWriter writer)
     /// when it was saved, preserving all its behavior and learned patterns.
     /// </para>
     /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _reservoirSize = reader.ReadInt32();
-        _connectionProbability = NumOps.FromDouble(reader.ReadDouble());
-        _spectralRadius = NumOps.FromDouble(reader.ReadDouble());
-        _inputScaling = NumOps.FromDouble(reader.ReadDouble());
-        _leakingRate = NumOps.FromDouble(reader.ReadDouble());
-
-        // Read training mode
-        IsTrainingMode = reader.ReadBoolean();
-    }
+
 
     /// <summary>
     /// Sets the training mode for the Liquid State Machine.
@@ -735,39 +714,4 @@ public void TrainOnTimeSeries(List<Tensor<T>> timeSeriesInput, List<Tensor<T>> t
             SetTrainingMode(false);
         }
     }
-
-    /// <summary>
-    /// Creates a new instance of the Liquid State Machine with the same architecture and configuration.
-    /// </summary>
-    /// <returns>A new Liquid State Machine instance with the same architecture and configuration.</returns>
-    /// <remarks>
-    /// <para>
-    /// This method creates a new instance of the Liquid State Machine with the same architecture and LSM-specific
-    /// parameters as the current instance. It's used in scenarios where a fresh copy of the model is needed
-    /// while maintaining the same configuration.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method creates a brand new copy of the LSM with the same setup.
-    /// 
-    /// Think of it like creating a clone of the network:
-    /// - The new network has the same architecture (structure)
-    /// - It has the same reservoir size, connection probability, and other settings
-    /// - But it's a completely separate instance with its own internal state
-    /// - The reservoir will be randomly initialized again, creating a different random network
-    /// 
-    /// This is useful when you want to:
-    /// - Train multiple networks with the same configuration
-    /// - Compare how different random initializations affect learning
-    /// - Create an ensemble of models with the same parameters
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new LiquidStateMachine<T>(
-            this.Architecture,
-            _reservoirSize,
-            NumOps.ToDouble(_connectionProbability),
-            NumOps.ToDouble(_spectralRadius),
-            NumOps.ToDouble(_inputScaling),
-            NumOps.ToDouble(_leakingRate));
-    }
 }
diff --git a/src/NeuralNetworks/Mamba2LanguageModel.cs b/src/NeuralNetworks/Mamba2LanguageModel.cs
index cc0b7285ce..6e80ef39de 100644
--- a/src/NeuralNetworks/Mamba2LanguageModel.cs
+++ b/src/NeuralNetworks/Mamba2LanguageModel.cs
@@ -38,7 +38,7 @@ namespace AiDotNet.NeuralNetworks;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Transformers are SSMs: Generalized Models and Efficient Algorithms Through Structured State Space Duality", "https://arxiv.org/abs/2405.21060", Year = 2024, Authors = "Tri Dao, Albert Gu")]
-public class Mamba2LanguageModel<T> : TokenLanguageModelLayoutBase<T>
+public partial class Mamba2LanguageModel<T> : TokenLanguageModelLayoutBase<T>
 {
     private readonly Mamba2Options _options;
     private readonly int _vocabSize;
@@ -151,32 +151,9 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_vocabSize);
-        writer.Write(_modelDimension);
-        writer.Write(_numLayers);
-        writer.Write(_stateDimension);
-        writer.Write(_numHeads);
-        writer.Write(_maxSeqLength);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _ = reader.ReadInt32();
-        _ = reader.ReadInt32();
-        _ = reader.ReadInt32();
-        _ = reader.ReadInt32();
-        _ = reader.ReadInt32();
-        _ = reader.ReadInt32();
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new Mamba2LanguageModel<T>(
-            Architecture, _vocabSize, _modelDimension, _numLayers, _stateDimension,
-            _numHeads, _maxSeqLength, LossFunction, _options);
-    }
+
 
     #endregion
 }
diff --git a/src/NeuralNetworks/MambaLanguageModel.cs b/src/NeuralNetworks/MambaLanguageModel.cs
index fae046b236..a20c243c21 100644
--- a/src/NeuralNetworks/MambaLanguageModel.cs
+++ b/src/NeuralNetworks/MambaLanguageModel.cs
@@ -159,32 +159,9 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_vocabSize);
-        writer.Write(_modelDimension);
-        writer.Write(_numLayers);
-        writer.Write(_stateDimension);
-        writer.Write(_expandFactor);
-        writer.Write(_maxSeqLength);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _ = reader.ReadInt32();
-        _ = reader.ReadInt32();
-        _ = reader.ReadInt32();
-        _ = reader.ReadInt32();
-        _ = reader.ReadInt32();
-        _ = reader.ReadInt32();
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new MambaLanguageModel<T>(
-            Architecture, _vocabSize, _modelDimension, _numLayers, _stateDimension,
-            _expandFactor, _maxSeqLength, LossFunction, _options);
-    }
+
 
     #endregion
 }
diff --git a/src/NeuralNetworks/MatryoshkaEmbedding.cs b/src/NeuralNetworks/MatryoshkaEmbedding.cs
index 7a436e7f23..4a16c3be0d 100644
--- a/src/NeuralNetworks/MatryoshkaEmbedding.cs
+++ b/src/NeuralNetworks/MatryoshkaEmbedding.cs
@@ -51,7 +51,7 @@ namespace AiDotNet.NeuralNetworks
     [ModelComplexity(ModelComplexity.High)]
     [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
     [ResearchPaper("Matryoshka Representation Learning", "https://arxiv.org/abs/2205.13147", Year = 2022, Authors = "Aditya Kusupati, Gantavya Bhatt, Aniket Rege, Matthew Wallingford, Aditya Sinha, Vivek Ramanujan, William Howard-Snyder, Kaifeng Chen, Sham Kakade, Prateek Jain, Ali Farhadi")]
-    public class MatryoshkaEmbedding<T> : TransformerEmbeddingNetwork<T>
+    public partial class MatryoshkaEmbedding<T> : TransformerEmbeddingNetwork<T>
     {
         private readonly MatryoshkaEmbeddingOptions _options;
 
@@ -200,25 +200,6 @@ protected override Tensor<T> PredictCore(Tensor<T> input)
             return PoolBatchOutput(base.PredictCore(input));
         }
 
-        /// <inheritdoc/>
-        protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-        {
-            return new MatryoshkaEmbedding<T>(
-                Architecture,
-                null,
-                null,
-                _vocabSize,
-                EmbeddingDimension,
-                _nestedDimensions,
-                MaxTokens,
-                _numLayers,
-                _numHeads,
-                _feedForwardDim,
-                PoolingStrategy.ClsToken,
-                LossFunction,
-                Convert.ToDouble(MaxGradNorm));
-        }
-
         /// <summary>
         /// Retrieves metadata about the Matryoshka configuration.
         /// </summary>
@@ -233,35 +214,10 @@ public override ModelMetadata<T> GetModelMetadata()
         }
 
         /// <inheritdoc/>
-        protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-        {
-            base.SerializeNetworkSpecificData(writer);
-            writer.Write(_vocabSize);
-            writer.Write(_numLayers);
-            writer.Write(_numHeads);
-            writer.Write(_feedForwardDim);
-            writer.Write(_nestedDimensions.Length);
-            foreach (var dim in _nestedDimensions)
-            {
-                writer.Write(dim);
-            }
-        }
+
 
         /// <inheritdoc/>
-        protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-        {
-            base.DeserializeNetworkSpecificData(reader);
-            _vocabSize = reader.ReadInt32();
-            _numLayers = reader.ReadInt32();
-            _numHeads = reader.ReadInt32();
-            _feedForwardDim = reader.ReadInt32();
-            int count = reader.ReadInt32();
-            _nestedDimensions = new int[count];
-            for (int i = 0; i < count; i++)
-            {
-                _nestedDimensions[i] = reader.ReadInt32();
-            }
-        }
+
 
         /// <inheritdoc/>
         public override Vector<T> Embed(string text)
diff --git a/src/NeuralNetworks/MemoryNetwork.cs b/src/NeuralNetworks/MemoryNetwork.cs
index 0f3e3db78f..aba31c16a8 100644
--- a/src/NeuralNetworks/MemoryNetwork.cs
+++ b/src/NeuralNetworks/MemoryNetwork.cs
@@ -867,28 +867,7 @@ public override ModelMetadata<T> GetModelMetadata()
     /// - Preserve the memory of facts the network has learned
     /// </para>
     /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        // Save memory configuration
-        writer.Write(_memorySize);
-        writer.Write(_embeddingSize);
 
-        // Save memory matrix contents
-        for (int i = 0; i < _memorySize; i++)
-        {
-            for (int j = 0; j < _embeddingSize; j++)
-            {
-                writer.Write(Convert.ToDouble(_memory[i, j]));
-            }
-        }
-
-        // Save each layer
-        writer.Write(Layers.Count);
-        foreach (var layer in Layers)
-        {
-            layer.Serialize(writer);
-        }
-    }
 
     /// <summary>
     /// Deserializes memory network-specific data from a binary reader.
@@ -914,39 +893,7 @@ protected override void SerializeNetworkSpecificData(BinaryWriter writer)
     /// - Restore the memory of facts the network had previously learned
     /// </para>
     /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        // Load memory configuration
-        int memorySize = reader.ReadInt32();
-        int embeddingSize = reader.ReadInt32();
 
-        // Verify configuration matches
-        if (memorySize != _memorySize || embeddingSize != _embeddingSize)
-        {
-            throw new InvalidOperationException("Memory configuration in saved model does not match current configuration");
-        }
-
-        // Load memory matrix contents
-        for (int i = 0; i < _memorySize; i++)
-        {
-            for (int j = 0; j < _embeddingSize; j++)
-            {
-                _memory[i, j] = NumOps.FromDouble(reader.ReadDouble());
-            }
-        }
-
-        // Load layers
-        int layerCount = reader.ReadInt32();
-        if (layerCount != Layers.Count)
-        {
-            throw new InvalidOperationException("Layer count in saved model does not match current model");
-        }
-
-        for (int i = 0; i < layerCount; i++)
-        {
-            Layers[i].Deserialize(reader);
-        }
-    }
 
     /// <summary>
     /// Stores a new fact in memory.
@@ -1038,37 +985,4 @@ public Tensor<T> AnswerQuestion(Tensor<T> question)
     {
         return Predict(question);
     }
-
-    /// <summary>
-    /// Creates a new instance of the Memory Network with the same architecture and configuration.
-    /// </summary>
-    /// <returns>A new Memory Network instance with the same architecture and configuration.</returns>
-    /// <remarks>
-    /// <para>
-    /// This method creates a new instance of the Memory Network with the same architecture and memory configuration
-    /// as the current instance. It's used in scenarios where a fresh copy of the model is needed
-    /// while maintaining the same configuration.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method creates a brand new copy of the Memory Network with the same setup.
-    /// 
-    /// Think of it like creating a clone of the network:
-    /// - The new network has the same architecture (structure)
-    /// - It has the same memory size and embedding size
-    /// - But it's a completely separate instance with its own memory matrix
-    /// - The memory starts fresh (empty) rather than copying the current memory contents
-    /// 
-    /// This is useful when you want to:
-    /// - Train multiple versions of the same memory network architecture
-    /// - Start with a clean memory but the same network structure
-    /// - Compare how different training approaches affect learning with the same configuration
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        // Create a new instance of MemoryNetwork with the same architecture and memory configuration
-        return new MemoryNetwork<T>(
-            this.Architecture,
-            _memorySize,
-            _embeddingSize);
-    }
 }
diff --git a/src/NeuralNetworks/MeshCNN.cs b/src/NeuralNetworks/MeshCNN.cs
index 7dd1f03456..d057083964 100644
--- a/src/NeuralNetworks/MeshCNN.cs
+++ b/src/NeuralNetworks/MeshCNN.cs
@@ -54,7 +54,7 @@ namespace AiDotNet.NeuralNetworks;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("MeshCNN: A Network with an Edge", "https://arxiv.org/abs/1809.05910", Year = 2019, Authors = "Rana Hanocka, Amir Hertz, Noa Fish, Raja Giryes, Shachar Fleishman, Daniel Cohen-Or")]
-public class MeshCNN<T> : GraphModelLayoutBase<T>
+public partial class MeshCNN<T> : GraphModelLayoutBase<T>
 {
     /// <summary>
     /// The loss function used to compute training loss.
@@ -491,112 +491,4 @@ public override ModelMetadata<T> GetModelMetadata()
             ModelData = SerializeForMetadata()
         };
     }
-
-    /// <summary>
-    /// Serializes network-specific data.
-    /// </summary>
-    /// <param name="writer">Binary writer.</param>
-    /// <inheritdoc />
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_options.NumClasses);
-        writer.Write(_options.InputFeatures);
-        writer.Write(_options.NumNeighbors);
-        writer.Write(_options.UseBatchNorm);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.UseGlobalAveragePooling);
-
-        writer.Write(_options.ConvChannels.Length);
-        foreach (var ch in _options.ConvChannels)
-            writer.Write(ch);
-
-        writer.Write(_options.PoolTargets.Length);
-        foreach (var pt in _options.PoolTargets)
-            writer.Write(pt);
-
-        writer.Write(_options.FullyConnectedSizes.Length);
-        foreach (var fc in _options.FullyConnectedSizes)
-            writer.Write(fc);
-
-        // Per-mesh adjacency is NOT model state — write empty marker for backward compat
-        writer.Write(0);
-        writer.Write(0);
-    }
-
-    /// <summary>
-    /// Deserializes network-specific data.
-    /// </summary>
-    /// <param name="reader">Binary reader.</param>
-    /// <inheritdoc />
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _options.NumClasses = reader.ReadInt32();
-        _options.InputFeatures = reader.ReadInt32();
-        _options.NumNeighbors = reader.ReadInt32();
-        _options.UseBatchNorm = reader.ReadBoolean();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.UseGlobalAveragePooling = reader.ReadBoolean();
-
-        int convLen = reader.ReadInt32();
-        _options.ConvChannels = new int[convLen];
-        for (int i = 0; i < convLen; i++)
-            _options.ConvChannels[i] = reader.ReadInt32();
-
-        int poolLen = reader.ReadInt32();
-        _options.PoolTargets = new int[poolLen];
-        for (int i = 0; i < poolLen; i++)
-            _options.PoolTargets[i] = reader.ReadInt32();
-
-        int fcLen = reader.ReadInt32();
-        _options.FullyConnectedSizes = new int[fcLen];
-        for (int i = 0; i < fcLen; i++)
-            _options.FullyConnectedSizes[i] = reader.ReadInt32();
-
-        // Skip adjacency data from older serialized models (per-mesh adjacency is NOT model state)
-        // Callers must call SetEdgeAdjacency() for each new mesh sample
-        _currentEdgeAdjacency = null;
-        if (reader.BaseStream.Position < reader.BaseStream.Length)
-        {
-            int adjRows = reader.ReadInt32();
-            int adjCols = reader.ReadInt32();
-            if (adjRows > 0 && adjCols > 0)
-            {
-                // Skip the adjacency data but don't restore it
-                for (int r = 0; r < adjRows; r++)
-                    for (int c = 0; c < adjCols; c++)
-                        reader.ReadInt32();
-            }
-        }
-    }
-
-    /// <inheritdoc />
-    /// <remarks>
-    /// MeshCNN's per-mesh edge adjacency is intentionally NOT serialized as model
-    /// state (see <see cref="SerializeNetworkSpecificData"/>) because real workloads
-    /// supply a fresh adjacency per mesh sample via <see cref="SetEdgeAdjacency"/>.
-    /// However, <see cref="Clone"/> consumers expect to call <c>Predict</c> on the
-    /// clone with the same input the original was using, so we propagate the live
-    /// adjacency to the clone alongside the serialized weights. This preserves
-    /// "clone reproduces original on the same input" without changing the on-disk
-    /// model format.
-    /// </remarks>
-    public override IFullModel<T, Tensor<T>, Tensor<T>> Clone()
-    {
-        var clone = base.Clone();
-        if (clone is MeshCNN<T> meshClone && _currentEdgeAdjacency is not null)
-        {
-            meshClone.SetEdgeAdjacency(_currentEdgeAdjacency);
-        }
-        return clone;
-    }
-
-    /// <summary>
-    /// Creates a new instance for cloning.
-    /// </summary>
-    /// <returns>New MeshCNN instance.</returns>
-    /// <inheritdoc />
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new MeshCNN<T>(_options, _optimizer, _lossFunction);
-    }
 }
diff --git a/src/NeuralNetworks/MixtureOfExpertsNeuralNetwork.cs b/src/NeuralNetworks/MixtureOfExpertsNeuralNetwork.cs
index 09939567dd..48a474c11e 100644
--- a/src/NeuralNetworks/MixtureOfExpertsNeuralNetwork.cs
+++ b/src/NeuralNetworks/MixtureOfExpertsNeuralNetwork.cs
@@ -432,154 +432,6 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    /// <summary>
-    /// Serializes Mixture-of-Experts network-specific data to a binary writer.
-    /// </summary>
-    /// <param name="writer">The BinaryWriter to write the data to.</param>
-    /// <remarks>
-    /// <para>
-    /// This method writes the MoE-specific configuration and state to a binary stream,
-    /// allowing the model to be saved and loaded later.
-    /// </para>
-    /// <para>
-    /// <b>For Beginners:</b> This saves your trained MoE model to a file.
-    ///
-    /// It records:
-    /// - All expert network weights
-    /// - Gating network weights
-    /// - Configuration settings
-    /// - Optimizer and loss function types
-    ///
-    /// This allows you to:
-    /// - Save a trained model for later use
-    /// - Share models with others
-    /// - Deploy models to production
-    /// </para>
-    /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        // Write MoE options
-        writer.Write(_options.NumExperts);
-        writer.Write(_options.TopK);
-        writer.Write(_options.InputDim);
-        writer.Write(_options.OutputDim);
-        writer.Write(_options.HiddenExpansion);
-        writer.Write(_options.UseLoadBalancing);
-        writer.Write(_options.LoadBalancingWeight);
-
-        // Write optimizer type
-        writer.Write(_optimizer.GetType().FullName ?? "AdamOptimizer");
-
-        // Write loss function type
-        writer.Write(_lossFunction.GetType().FullName ?? "MeanSquaredErrorLoss");
-    }
-
-    /// <summary>
-    /// Deserializes Mixture-of-Experts network-specific data from a binary reader.
-    /// </summary>
-    /// <param name="reader">The BinaryReader to read the data from.</param>
-    /// <remarks>
-    /// <para>
-    /// This method reads the MoE-specific configuration and state from a binary stream,
-    /// restoring a previously saved model.
-    /// </para>
-    /// <para>
-    /// <b>For Beginners:</b> This loads a previously saved MoE model from a file.
-    ///
-    /// It restores:
-    /// - All expert network weights
-    /// - Gating network weights
-    /// - Configuration settings
-    /// - Optimizer and loss function types
-    ///
-    /// The loaded model is ready to use for predictions without retraining.
-    /// </para>
-    /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        // Read MoE options
-        _options.NumExperts = reader.ReadInt32();
-        _options.TopK = reader.ReadInt32();
-        _options.InputDim = reader.ReadInt32();
-        _options.OutputDim = reader.ReadInt32();
-        _options.HiddenExpansion = reader.ReadInt32();
-        _options.UseLoadBalancing = reader.ReadBoolean();
-        _options.LoadBalancingWeight = reader.ReadDouble();
-
-        // Read optimizer type (not used after reading)
-        reader.ReadString();
-
-        // Read loss function type (not used after reading)
-        reader.ReadString();
-    }
-
-    /// <summary>
-    /// Creates a new instance of the MixtureOfExpertsNeuralNetwork with the same configuration as the current instance.
-    /// </summary>
-    /// <returns>A new MixtureOfExpertsNeuralNetwork instance with the same configuration.</returns>
-    /// <remarks>
-    /// <para>
-    /// This method creates a new instance with the same architecture, options, optimizer, and loss function
-    /// as the current instance. This is useful for model cloning, ensemble methods, or cross-validation scenarios.
-    /// </para>
-    /// <para>
-    /// <b>For Beginners:</b> This creates a fresh copy of your MoE network's blueprint.
-    ///
-    /// The new network:
-    /// - Has the same number and configuration of experts
-    /// - Uses the same routing strategy (Top-K)
-    /// - Has the same load balancing settings
-    /// - BUT has newly initialized weights (no learned data)
-    ///
-    /// Use cases:
-    /// - Testing the same model architecture on different data
-    /// - Creating ensemble models (multiple models voting on predictions)
-    /// - Cross-validation (training and testing on different data splits)
-    /// </para>
-    /// </remarks>
-    /// <summary>
-    /// Creates a deep copy by creating a new instance with the same options
-    /// and copying all parameters. Overrides base to avoid generic layer
-    /// deserialization which can't reconstruct MoE expert architecture.
-    /// </summary>
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy()
-    {
-        var copy = (NeuralNetworkBase<T>)CreateNewInstance();
-
-        // Copy parameters from original to clone
-        var originalParams = GetParameters();
-        if (originalParams.Length > 0 && originalParams.Length == copy.GetParameters().Length)
-        {
-            copy.UpdateParameters(originalParams);
-        }
-
-        return copy;
-    }
-
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        // Create a clone of the options to ensure the new instance has independent configuration
-        var clonedOptions = new MixtureOfExpertsOptions<T>
-        {
-            NumExperts = _options.NumExperts,
-            TopK = _options.TopK,
-            InputDim = _options.InputDim,
-            OutputDim = _options.OutputDim,
-            HiddenExpansion = _options.HiddenExpansion,
-            UseLoadBalancing = _options.UseLoadBalancing,
-            LoadBalancingWeight = _options.LoadBalancingWeight,
-            RandomSeed = _options.RandomSeed
-        };
-
-        // Pass null for optimizer to create a fresh optimizer instance for the clone
-        return new MixtureOfExpertsNeuralNetwork<T>(
-            clonedOptions,
-            Architecture,
-            null,  // Let constructor create new optimizer
-            _lossFunction,
-            Convert.ToDouble(MaxGradNorm));
-    }
-
     /// <summary>
     /// Indicates whether this network supports training.
     /// </summary>
diff --git a/src/NeuralNetworks/MobileNetV2Network.cs b/src/NeuralNetworks/MobileNetV2Network.cs
index 71ab2655ae..517bd11065 100644
--- a/src/NeuralNetworks/MobileNetV2Network.cs
+++ b/src/NeuralNetworks/MobileNetV2Network.cs
@@ -69,7 +69,7 @@ namespace AiDotNet.NeuralNetworks;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("MobileNetV2: Inverted Residuals and Linear Bottlenecks", "https://arxiv.org/abs/1801.04381", Year = 2018, Authors = "Mark Sandler, Andrew Howard, Menglong Zhu, Andrey Zhmoginov, Liang-Chieh Chen")]
-public class MobileNetV2Network<T> : ImageClassifierModelLayoutBase<T>
+public partial class MobileNetV2Network<T> : ImageClassifierModelLayoutBase<T>
 {
     private readonly MobileNetV2Options _options;
 
@@ -396,14 +396,7 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc />
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write((int)_configuration.WidthMultiplier);
-        writer.Write(_configuration.InputChannels);
-        writer.Write(_configuration.InputHeight);
-        writer.Write(_configuration.InputWidth);
-        writer.Write(_configuration.NumClasses);
-    }
+
 
     /// <summary>
     /// Deserializes and validates network-specific configuration data.
@@ -428,61 +421,7 @@ protected override void SerializeNetworkSpecificData(BinaryWriter writer)
     /// desired configuration, then call <see cref="NeuralNetworkBase{T}.Load"/> on that instance.
     /// </para>
     /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        // Read serialized configuration values
-        var widthMultiplier = (MobileNetV2WidthMultiplier)reader.ReadInt32();
-        var inputChannels = reader.ReadInt32();
-        var inputHeight = reader.ReadInt32();
-        var inputWidth = reader.ReadInt32();
-        var numClasses = reader.ReadInt32();
-
-        // Validate configuration matches - layer structure depends on these values
-        // and cannot be changed after construction
-        if (widthMultiplier != _configuration.WidthMultiplier ||
-            inputChannels != _configuration.InputChannels ||
-            inputHeight != _configuration.InputHeight ||
-            inputWidth != _configuration.InputWidth ||
-            numClasses != _configuration.NumClasses)
-        {
-            throw new InvalidDataException(
-                $"Serialized MobileNetV2 configuration (WidthMultiplier={widthMultiplier}, InputChannels={inputChannels}, " +
-                $"InputHeight={inputHeight}, InputWidth={inputWidth}, NumClasses={numClasses}) does not match current configuration " +
-                $"(WidthMultiplier={_configuration.WidthMultiplier}, InputChannels={_configuration.InputChannels}, " +
-                $"InputHeight={_configuration.InputHeight}, InputWidth={_configuration.InputWidth}, " +
-                $"NumClasses={_configuration.NumClasses}). Create a new network with matching configuration to load this model.");
-        }
-    }
 
-    /// <inheritdoc />
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var config = new MobileNetV2Configuration(
-            _configuration.WidthMultiplier,
-            _configuration.NumClasses,
-            _configuration.InputHeight,
-            _configuration.InputWidth,
-            _configuration.InputChannels);
-
-        return new MobileNetV2Network<T>(
-            Architecture,
-            config,
-            lossFunction: _lossFunction,
-            options: new MobileNetV2Options(_options));
-    }
-
-    /// <inheritdoc />
-    public override void Deserialize(byte[] data)
-    {
-        base.Deserialize(data);
-        SetAllLayersEvalMode();
-    }
-
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> Clone()
-    {
-        return DeepCopy();
-    }
 
     /// <summary>
     /// Gets the layer at the specified index.
diff --git a/src/NeuralNetworks/MobileNetV3Network.cs b/src/NeuralNetworks/MobileNetV3Network.cs
index 969a50de08..8604000208 100644
--- a/src/NeuralNetworks/MobileNetV3Network.cs
+++ b/src/NeuralNetworks/MobileNetV3Network.cs
@@ -49,7 +49,7 @@ namespace AiDotNet.NeuralNetworks;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Searching for MobileNetV3", "https://arxiv.org/abs/1905.02244", Year = 2019, Authors = "Andrew Howard, Mark Sandler, Grace Chu, Liang-Chieh Chen, Bo Chen, Mingxing Tan, Weijun Wang, Yukun Zhu, Ruoming Pang, Vijay Vasudevan, Quoc V. Le, Hartwig Adam")]
-public class MobileNetV3Network<T> : ImageClassifierModelLayoutBase<T>
+public partial class MobileNetV3Network<T> : ImageClassifierModelLayoutBase<T>
 {
     private readonly MobileNetV3Options _options;
 
@@ -277,64 +277,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc />
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write((int)_configuration.Variant);
-        writer.Write((int)_configuration.WidthMultiplier);
-        writer.Write(_configuration.InputChannels);
-        writer.Write(_configuration.InputHeight);
-        writer.Write(_configuration.InputWidth);
-        writer.Write(_configuration.NumClasses);
-    }
-
-    /// <inheritdoc />
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        var variant = (MobileNetV3Variant)reader.ReadInt32();
-        var widthMultiplier = (MobileNetV3WidthMultiplier)reader.ReadInt32();
-        var inputChannels = reader.ReadInt32();
-        var inputHeight = reader.ReadInt32();
-        var inputWidth = reader.ReadInt32();
-        var numClasses = reader.ReadInt32();
 
-        if (variant != _configuration.Variant ||
-            widthMultiplier != _configuration.WidthMultiplier ||
-            inputChannels != _configuration.InputChannels ||
-            inputHeight != _configuration.InputHeight ||
-            inputWidth != _configuration.InputWidth ||
-            numClasses != _configuration.NumClasses)
-        {
-            throw new InvalidDataException("Serialized MobileNetV3 configuration does not match current configuration.");
-        }
-    }
 
     /// <inheritdoc />
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var config = new MobileNetV3Configuration(
-            _configuration.Variant,
-            _configuration.NumClasses,
-            _configuration.WidthMultiplier,
-            _configuration.InputHeight,
-            _configuration.InputWidth,
-            _configuration.InputChannels);
 
-        return new MobileNetV3Network<T>(Architecture, config, _optimizer, _lossFunction);
-    }
-
-    /// <inheritdoc />
-    public override void Deserialize(byte[] data)
-    {
-        base.Deserialize(data);
-        // Restore eval mode after deserialization (training/eval state is not serialized).
-        SetAllLayersEvalMode();
-    }
-
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> Clone()
-    {
-        return DeepCopy();
-    }
 
     /// <summary>
     /// Gets the layer at the specified index.
diff --git a/src/NeuralNetworks/NEAT.cs b/src/NeuralNetworks/NEAT.cs
index 3513e447f6..74706f5ff2 100644
--- a/src/NeuralNetworks/NEAT.cs
+++ b/src/NeuralNetworks/NEAT.cs
@@ -1,336 +1,337 @@
-using AiDotNet.Attributes;
-using AiDotNet.Enums;
-using AiDotNet.NeuralNetworks.Options;

+using AiDotNet.Attributes;
+using AiDotNet.Enums;
+using AiDotNet.NeuralNetworks.Options;
+
 using AiDotNet.Models.Parameters;
-
-namespace AiDotNet.NeuralNetworks;
-
-/// <summary>
-/// Represents a NeuroEvolution of Augmenting Topologies (NEAT) algorithm implementation, which evolves
-/// neural networks through genetic algorithms.
-/// </summary>
-/// <remarks>
-/// <para>
-/// NEAT is an evolutionary algorithm that creates and evolves neural network topologies along with connection weights.
-/// Unlike traditional neural networks with fixed structures, NEAT starts with simple networks and gradually adds
-/// complexity through evolution. It uses genetic operators like mutation and crossover, along with speciation
-/// to protect innovation, to evolve networks that solve specific problems without requiring manual design
-/// of the network architecture.
-/// </para>
-/// <para><b>For Beginners:</b> NEAT is a way to grow neural networks through evolution rather than training them with fixed structures.
-/// 
-/// Think of NEAT like breeding plants to get better features:
-/// - Instead of designing a neural network by hand, you start with simple networks
-/// - These networks "reproduce" and "mutate" over generations
-/// - Networks that perform better on your task are more likely to pass on their "genes"
-/// - Over time, the networks evolve complex structures that solve your problem well
-/// 
-/// The key differences from traditional neural networks:
-/// - The structure (connections between neurons) evolves along with the weights
-/// - Networks can grow more complex over time by adding new neurons and connections
-/// - You work with a population of many networks, not just one
-/// - Instead of training with gradient descent, you use evolution to improve performance
-/// 
-/// NEAT is particularly good for:
-/// - Problems where you don't know the ideal network structure
-/// - Reinforcement learning tasks (like game playing)
-/// - Finding novel solutions that a human designer might not think of
-/// </para>
-/// </remarks>
-/// <example>
-/// <code>
-/// var options = new NEATOptions { InputSize = 4, OutputSize = 2, PopulationSize = 150 };
-/// var model = new NEAT&lt;float&gt;(options);
-/// var input = Tensor&lt;float&gt;.Random(new[] { 1, 4 });
-/// var output = model.Predict(input);
-/// </code>
-/// </example>
-/// <typeparam name="T">The numeric type used for calculations, typically float or double.</typeparam>
-[ModelDomain(ModelDomain.General)]
-[ModelCategory(ModelCategory.NeuralNetwork)]
-[ModelTask(ModelTask.Classification)]
-[ModelTask(ModelTask.Regression)]
-[ModelComplexity(ModelComplexity.Medium)]
-[ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
-[ResearchPaper("Evolving Neural Networks through Augmenting Topologies", "https://nn.cs.utexas.edu/downloads/papers/stanley.ec02.pdf", Year = 2002, Authors = "Kenneth O. Stanley, Risto Miikkulainen")]
+
+namespace AiDotNet.NeuralNetworks;
+
+/// <summary>
+/// Represents a NeuroEvolution of Augmenting Topologies (NEAT) algorithm implementation, which evolves
+/// neural networks through genetic algorithms.
+/// </summary>
+/// <remarks>
+/// <para>
+/// NEAT is an evolutionary algorithm that creates and evolves neural network topologies along with connection weights.
+/// Unlike traditional neural networks with fixed structures, NEAT starts with simple networks and gradually adds
+/// complexity through evolution. It uses genetic operators like mutation and crossover, along with speciation
+/// to protect innovation, to evolve networks that solve specific problems without requiring manual design
+/// of the network architecture.
+/// </para>
+/// <para><b>For Beginners:</b> NEAT is a way to grow neural networks through evolution rather than training them with fixed structures.
+/// 
+/// Think of NEAT like breeding plants to get better features:
+/// - Instead of designing a neural network by hand, you start with simple networks
+/// - These networks "reproduce" and "mutate" over generations
+/// - Networks that perform better on your task are more likely to pass on their "genes"
+/// - Over time, the networks evolve complex structures that solve your problem well
+/// 
+/// The key differences from traditional neural networks:
+/// - The structure (connections between neurons) evolves along with the weights
+/// - Networks can grow more complex over time by adding new neurons and connections
+/// - You work with a population of many networks, not just one
+/// - Instead of training with gradient descent, you use evolution to improve performance
+/// 
+/// NEAT is particularly good for:
+/// - Problems where you don't know the ideal network structure
+/// - Reinforcement learning tasks (like game playing)
+/// - Finding novel solutions that a human designer might not think of
+/// </para>
+/// </remarks>
+/// <example>
+/// <code>
+/// var options = new NEATOptions { InputSize = 4, OutputSize = 2, PopulationSize = 150 };
+/// var model = new NEAT&lt;float&gt;(options);
+/// var input = Tensor&lt;float&gt;.Random(new[] { 1, 4 });
+/// var output = model.Predict(input);
+/// </code>
+/// </example>
+/// <typeparam name="T">The numeric type used for calculations, typically float or double.</typeparam>
+[ModelDomain(ModelDomain.General)]
+[ModelCategory(ModelCategory.NeuralNetwork)]
+[ModelTask(ModelTask.Classification)]
+[ModelTask(ModelTask.Regression)]
+[ModelComplexity(ModelComplexity.Medium)]
+[ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
+[ResearchPaper("Evolving Neural Networks through Augmenting Topologies", "https://nn.cs.utexas.edu/downloads/papers/stanley.ec02.pdf", Year = 2002, Authors = "Kenneth O. Stanley, Risto Miikkulainen")]
 public partial class NEAT<T> : VectorModelLayoutBase<T>
-{
-    private readonly NEATOptions _options;
-
-    /// <inheritdoc/>
-    public override ModelOptions GetOptions() => _options;
-
-    /// <summary>
-    /// Gets the current population of genomes (neural network structures).
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// This list contains all the current individuals (genomes) in the population. Each genome represents
-    /// a different neural network structure with its own set of nodes and connections. The population evolves
-    /// over time through the evolutionary process.
-    /// </para>
-    /// <para><b>For Beginners:</b> This is the collection of all neural networks currently in your evolving population.
-    /// 
-    /// Think of Population as:
-    /// - A group of different neural networks (called "genomes")
-    /// - Each genome represents a different way to solve your problem
-    /// - Some genomes will perform better than others
-    /// - The best genomes get to "reproduce" and pass on their characteristics
-    /// 
-    /// During evolution, this population changes as:
-    /// - Higher-performing networks reproduce more often
-    /// - New networks are created through crossover (combining two parent networks)
-    /// - Mutations introduce new variations
-    /// 
-    /// This diversity in the population helps NEAT explore different possible solutions.
-    /// </para>
-    /// </remarks>
-    private List<Genome<T>> _population;
-
-    /// <summary>
-    /// Gets or sets the size of the population (number of genomes).
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// The population size determines how many different network structures (genomes) are evolved in parallel.
-    /// A larger population provides more genetic diversity and exploration of the solution space, but requires
-    /// more computational resources. Typical values range from 50 to several hundred.
-    /// </para>
-    /// <para><b>For Beginners:</b> This controls how many different neural networks are in your evolving population.
-    /// 
-    /// Population size is important because:
-    /// - A larger population (like 100-500) provides more diversity
-    /// - More diversity helps explore more possible solutions
-    /// - But larger populations require more computing power
-    /// - Smaller populations evolve faster but might get stuck in suboptimal solutions
-    /// 
-    /// This is like having a larger or smaller gene pool in a biological population.
-    /// The right size depends on your problem complexity and available computing resources.
-    /// </para>
-    /// </remarks>
-    private int _populationSize { get; set; }
-
-    /// <summary>
-    /// Gets or sets the probability of mutation occurring during reproduction.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// The mutation rate controls how frequently random changes occur in the network structure or weights
-    /// during evolution. Higher mutation rates increase exploration of new structures but can disrupt good solutions.
-    /// Lower rates provide more stability but may limit innovation. Typical values range from 0.05 to 0.3.
-    /// </para>
-    /// <para><b>For Beginners:</b> This controls how often random changes (mutations) occur in the networks.
-    /// 
-    /// Think of mutation rate as controlling how much experimentation happens:
-    /// - A value of 0.1 means there's a 10% chance of each type of mutation occurring
-    /// - Higher values (like 0.3) cause more random changes and exploration
-    /// - Lower values (like 0.05) cause fewer changes, keeping solutions more stable
-    /// 
-    /// Mutations include:
-    /// - Adding new neurons
-    /// - Adding new connections
-    /// - Changing connection weights
-    /// 
-    /// Finding the right mutation rate is important:
-    /// - Too high: networks change too randomly and can't preserve good solutions
-    /// - Too low: networks don't explore enough new possibilities
-    /// </para>
-    /// </remarks>
-    private T _mutationRate { get; set; }
-
-    /// <summary>
-    /// Per-instance deterministic RNG for the evolutionary search (selection,
-    /// crossover, mutation). Seeded from the architecture's RandomSeed when present.
-    /// </summary>
-    private readonly Random _rng;
-
-    // Faithful NEAT weight-mutation constants (Stanley & Miikkulainen 2002 §3.1;
-    // NEAT-Python's weight_mutate_power / weight_replace_rate / weight_max_value).
-    // A small perturbation power plus a hard clamp keep connection weights bounded
-    // so weights cannot random-walk to ever-larger magnitudes across generations.
-    private const double WeightPerturbPower = 0.5;
-    private const double WeightReplaceRate = 0.1;
-    private const double WeightCap = 8.0;
-
-    /// <summary>
-    /// Gets or sets the probability of crossover occurring during reproduction.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// The crossover rate determines how often two parent genomes combine to create offspring versus
-    /// simply cloning and mutating a single parent. Higher rates increase the mixing of genetic material
-    /// but may disrupt successful network structures. Typical values range from 0.5 to 0.8.
-    /// </para>
-    /// <para><b>For Beginners:</b> This controls how often two parent networks combine to create a child network.
-    /// 
-    /// Crossover is like breeding in biology:
-    /// - A value of 0.75 means 75% of new networks come from combining two parent networks
-    /// - The remaining 25% come from copying and mutating a single parent
-    /// 
-    /// During crossover:
-    /// - Parts from two successful networks are combined
-    /// - This helps mix good features from different networks
-    /// - The child gets some connections from each parent
-    /// 
-    /// This balance is important because:
-    /// - Too much crossover can break up good network structures
-    /// - Too little crossover limits how well good features can be combined
-    /// </para>
-    /// </remarks>
-    private T _crossoverRate { get; set; }
-
-    /// <summary>
-    /// Gets or sets the global innovation number counter used to track historical origins of genes.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// The innovation number is a key component of the NEAT algorithm that helps track the historical origin
-    /// of each connection gene. Each new structural innovation (a new connection or node) receives a unique,
-    /// incrementing ID. This historical marking allows NEAT to perform meaningful crossover between different
-    /// network topologies by matching genes with the same origin.
-    /// </para>
-    /// <para><b>For Beginners:</b> This is a counter that gives each new connection or neuron a unique ID number.
-    /// 
-    /// Innovation numbers are important because:
-    /// - They help NEAT know which parts of different networks correspond to each other
-    /// - When two networks reproduce, we need to know which connections match up
-    /// - Each time a new connection or neuron is created, it gets a new innovation number
-    /// 
-    /// Think of it like a family tree that helps track where each feature came from.
-    /// This historical marking is one of the key innovations in NEAT that allows
-    /// networks with different structures to be combined effectively.
-    /// </para>
-    /// </remarks>
-    private int _innovationNumber;
-
-    // Issue #1392 perf: scratch HashSet reused across Crossover calls so we
-    // don't allocate a fresh one for every offspring. EvolvePopulation is
-    // single-threaded, so a per-instance buffer is safe; the .Clear() at the
-    // top of Crossover resets it without releasing the underlying entries
-    // table.
-    private readonly HashSet<int> _crossoverSeen = new HashSet<int>();
-
-    private const int DefaultInputSize = 10;
-    private const int DefaultOutputSize = 1;
-    private const int DefaultPopulationSize = 150;
-
-    /// <summary>
-    /// Initializes a new instance with default settings.
-    /// </summary>
-    public NEAT()
-        : this(new NeuralNetworkArchitecture<T>(
-            inputType: Enums.InputType.OneDimensional,
-            taskType: Enums.NeuralNetworkTaskType.Regression,
-            inputSize: DefaultInputSize,
-            outputSize: DefaultOutputSize),
-            populationSize: DefaultPopulationSize)
-    {
-    }
-
-    /// <summary>
-    /// Initializes a new instance of the <see cref="NEAT{T}"/> class with the specified architecture and evolution parameters.
-    /// </summary>
-    /// <param name="architecture">The neural network architecture defining input and output sizes.</param>
-    /// <param name="populationSize">The number of individual genomes in the population.</param>
-    /// <param name="mutationRate">The probability of mutation occurring during reproduction. Default is 0.1.</param>
-    /// <param name="crossoverRate">The probability of crossover occurring during reproduction. Default is 0.75.</param>
-    /// <remarks>
-    /// <para><b>For Beginners:</b> This creates a new NEAT system with your chosen settings.</para>
-    /// </remarks>
-    public NEAT(NeuralNetworkArchitecture<T> architecture, int populationSize, double mutationRate = 0.1, double crossoverRate = 0.75, ILossFunction<T>? lossFunction = null, NEATOptions? options = null)
-        : base(architecture, lossFunction ?? NeuralNetworkHelper<T>.GetDefaultLossFunction(architecture.TaskType))
-    {
-        _options = options ?? new NEATOptions();
-        Options = _options;
-        _populationSize = populationSize;
-        _mutationRate = NumOps.FromDouble(mutationRate);
-        _crossoverRate = NumOps.FromDouble(crossoverRate);
-        _innovationNumber = 0;
-        // Deterministic, per-instance evolution RNG. NEAT's selection / crossover /
-        // mutation all draw from this stream; seeding it from the architecture's
-        // RandomSeed makes a NEAT run reproducible (the standard NEAT-Python contract —
-        // every config carries a seed). Without it the evolution drew from the
-        // process-shared RandomHelper.ThreadSafeRandom, whose state advances with
-        // unrelated prior work, so a NEAT invariant could pass in isolation yet flake
-        // when interleaved with other tests. When no seed is set (the production
-        // default) it falls back to the shared RNG, preserving non-reproducible
-        // production behaviour.
-        _rng = Architecture.RandomSeed.HasValue
-            ? RandomHelper.CreateSeededRandom(Architecture.RandomSeed.Value)
-            : RandomHelper.ThreadSafeRandom;
-        _population = InitializePopulation();
-    }
-
-    /// <summary>
-    /// Initializes the layers of the neural network.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// This method is intentionally left empty because NEAT does not use fixed layers like traditional neural networks.
-    /// Instead, NEAT evolves the network structure dynamically through the evolutionary process, adding nodes
-    /// and connections as needed.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method is intentionally empty because NEAT works differently from traditional neural networks.
-    /// 
-    /// In traditional neural networks:
-    /// - You define specific layers (input, hidden, output)
-    /// - Each layer has a fixed number of neurons
-    /// - The connections between layers are predetermined
-    /// 
-    /// In NEAT:
-    /// - Networks don't have fixed layers
-    /// - The structure evolves dynamically
-    /// - Neurons and connections are added gradually through evolution
-    /// 
-    /// This fundamental difference is why this method doesn't need to do anything in NEAT.
-    /// The network structure is defined by the genome, not by predefined layers.
-    /// </para>
-    /// </remarks>
-    protected override void InitializeLayers()
-    {
-        // NEAT doesn't use fixed layers, so we'll leave this empty
-    }
-
-    /// <summary>
-    /// NEAT's parameters are the connection weights of the best genome in the population.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// A COMPUTED surface: the weights are not in a field, they are read out of a structure that
-    /// evolves. Declaring a source rather than overriding the fold is what makes the count and the
-    /// vector agree by construction -- both now read this one accessor, where three hand-written
-    /// members were three chances to disagree.
-    /// </para>
-    /// <para>
-    /// The count legitimately CHANGES as the population evolves, and that is not a defect: adding
-    /// or removing a connection is what NEAT does. What must hold is that the count and the vector
-    /// agree at any single instant, which they do because they come from the same source. This is
-    /// stronger than the usual arrangement, where a framework tells you to rebuild the optimizer
-    /// after mutating the parameter set and nothing checks that you did.
-    /// </para>
-    /// </remarks>
+{
+    private readonly NEATOptions _options;
+
+    /// <inheritdoc/>
+    public override ModelOptions GetOptions() => _options;
+
+    /// <summary>
+    /// Gets the current population of genomes (neural network structures).
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// This list contains all the current individuals (genomes) in the population. Each genome represents
+    /// a different neural network structure with its own set of nodes and connections. The population evolves
+    /// over time through the evolutionary process.
+    /// </para>
+    /// <para><b>For Beginners:</b> This is the collection of all neural networks currently in your evolving population.
+    /// 
+    /// Think of Population as:
+    /// - A group of different neural networks (called "genomes")
+    /// - Each genome represents a different way to solve your problem
+    /// - Some genomes will perform better than others
+    /// - The best genomes get to "reproduce" and pass on their characteristics
+    /// 
+    /// During evolution, this population changes as:
+    /// - Higher-performing networks reproduce more often
+    /// - New networks are created through crossover (combining two parent networks)
+    /// - Mutations introduce new variations
+    /// 
+    /// This diversity in the population helps NEAT explore different possible solutions.
+    /// </para>
+    /// </remarks>
+    private List<Genome<T>> _population;
+
+    /// <summary>
+    /// Gets or sets the size of the population (number of genomes).
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// The population size determines how many different network structures (genomes) are evolved in parallel.
+    /// A larger population provides more genetic diversity and exploration of the solution space, but requires
+    /// more computational resources. Typical values range from 50 to several hundred.
+    /// </para>
+    /// <para><b>For Beginners:</b> This controls how many different neural networks are in your evolving population.
+    /// 
+    /// Population size is important because:
+    /// - A larger population (like 100-500) provides more diversity
+    /// - More diversity helps explore more possible solutions
+    /// - But larger populations require more computing power
+    /// - Smaller populations evolve faster but might get stuck in suboptimal solutions
+    /// 
+    /// This is like having a larger or smaller gene pool in a biological population.
+    /// The right size depends on your problem complexity and available computing resources.
+    /// </para>
+    /// </remarks>
+    private int _populationSize { get; set; }
+
+    /// <summary>
+    /// Gets or sets the probability of mutation occurring during reproduction.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// The mutation rate controls how frequently random changes occur in the network structure or weights
+    /// during evolution. Higher mutation rates increase exploration of new structures but can disrupt good solutions.
+    /// Lower rates provide more stability but may limit innovation. Typical values range from 0.05 to 0.3.
+    /// </para>
+    /// <para><b>For Beginners:</b> This controls how often random changes (mutations) occur in the networks.
+    /// 
+    /// Think of mutation rate as controlling how much experimentation happens:
+    /// - A value of 0.1 means there's a 10% chance of each type of mutation occurring
+    /// - Higher values (like 0.3) cause more random changes and exploration
+    /// - Lower values (like 0.05) cause fewer changes, keeping solutions more stable
+    /// 
+    /// Mutations include:
+    /// - Adding new neurons
+    /// - Adding new connections
+    /// - Changing connection weights
+    /// 
+    /// Finding the right mutation rate is important:
+    /// - Too high: networks change too randomly and can't preserve good solutions
+    /// - Too low: networks don't explore enough new possibilities
+    /// </para>
+    /// </remarks>
+    private T _mutationRate { get; set; }
+
+    /// <summary>
+    /// Per-instance deterministic RNG for the evolutionary search (selection,
+    /// crossover, mutation). Seeded from the architecture's RandomSeed when present.
+    /// </summary>
+    private readonly Random _rng;
+
+    // Faithful NEAT weight-mutation constants (Stanley & Miikkulainen 2002 §3.1;
+    // NEAT-Python's weight_mutate_power / weight_replace_rate / weight_max_value).
+    // A small perturbation power plus a hard clamp keep connection weights bounded
+    // so weights cannot random-walk to ever-larger magnitudes across generations.
+    private const double WeightPerturbPower = 0.5;
+    private const double WeightReplaceRate = 0.1;
+    private const double WeightCap = 8.0;
+
+    /// <summary>
+    /// Gets or sets the probability of crossover occurring during reproduction.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// The crossover rate determines how often two parent genomes combine to create offspring versus
+    /// simply cloning and mutating a single parent. Higher rates increase the mixing of genetic material
+    /// but may disrupt successful network structures. Typical values range from 0.5 to 0.8.
+    /// </para>
+    /// <para><b>For Beginners:</b> This controls how often two parent networks combine to create a child network.
+    /// 
+    /// Crossover is like breeding in biology:
+    /// - A value of 0.75 means 75% of new networks come from combining two parent networks
+    /// - The remaining 25% come from copying and mutating a single parent
+    /// 
+    /// During crossover:
+    /// - Parts from two successful networks are combined
+    /// - This helps mix good features from different networks
+    /// - The child gets some connections from each parent
+    /// 
+    /// This balance is important because:
+    /// - Too much crossover can break up good network structures
+    /// - Too little crossover limits how well good features can be combined
+    /// </para>
+    /// </remarks>
+    private T _crossoverRate { get; set; }
+
+    /// <summary>
+    /// Gets or sets the global innovation number counter used to track historical origins of genes.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// The innovation number is a key component of the NEAT algorithm that helps track the historical origin
+    /// of each connection gene. Each new structural innovation (a new connection or node) receives a unique,
+    /// incrementing ID. This historical marking allows NEAT to perform meaningful crossover between different
+    /// network topologies by matching genes with the same origin.
+    /// </para>
+    /// <para><b>For Beginners:</b> This is a counter that gives each new connection or neuron a unique ID number.
+    /// 
+    /// Innovation numbers are important because:
+    /// - They help NEAT know which parts of different networks correspond to each other
+    /// - When two networks reproduce, we need to know which connections match up
+    /// - Each time a new connection or neuron is created, it gets a new innovation number
+    /// 
+    /// Think of it like a family tree that helps track where each feature came from.
+    /// This historical marking is one of the key innovations in NEAT that allows
+    /// networks with different structures to be combined effectively.
+    /// </para>
+    /// </remarks>
+    private int _innovationNumber;
+
+    // Issue #1392 perf: scratch HashSet reused across Crossover calls so we
+    // don't allocate a fresh one for every offspring. EvolvePopulation is
+    // single-threaded, so a per-instance buffer is safe; the .Clear() at the
+    // top of Crossover resets it without releasing the underlying entries
+    // table.
+    private readonly HashSet<int> _crossoverSeen = new HashSet<int>();
+
+    private const int DefaultInputSize = 10;
+    private const int DefaultOutputSize = 1;
+    private const int DefaultPopulationSize = 150;
+
+    /// <summary>
+    /// Initializes a new instance with default settings.
+    /// </summary>
+    public NEAT()
+        : this(new NeuralNetworkArchitecture<T>(
+            inputType: Enums.InputType.OneDimensional,
+            taskType: Enums.NeuralNetworkTaskType.Regression,
+            inputSize: DefaultInputSize,
+            outputSize: DefaultOutputSize),
+            populationSize: DefaultPopulationSize)
+    {
+    }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="NEAT{T}"/> class with the specified architecture and evolution parameters.
+    /// </summary>
+    /// <param name="architecture">The neural network architecture defining input and output sizes.</param>
+    /// <param name="populationSize">The number of individual genomes in the population.</param>
+    /// <param name="mutationRate">The probability of mutation occurring during reproduction. Default is 0.1.</param>
+    /// <param name="crossoverRate">The probability of crossover occurring during reproduction. Default is 0.75.</param>
+    /// <remarks>
+    /// <para><b>For Beginners:</b> This creates a new NEAT system with your chosen settings.</para>
+    /// </remarks>
+    public NEAT(NeuralNetworkArchitecture<T> architecture, int populationSize, double mutationRate = 0.1, double crossoverRate = 0.75, ILossFunction<T>? lossFunction = null, NEATOptions? options = null)
+        : base(architecture, lossFunction ?? NeuralNetworkHelper<T>.GetDefaultLossFunction(architecture.TaskType))
+    {
+        _options = options ?? new NEATOptions();
+        Options = _options;
+        _populationSize = populationSize;
+        _mutationRate = NumOps.FromDouble(mutationRate);
+        _crossoverRate = NumOps.FromDouble(crossoverRate);
+        _innovationNumber = 0;
+        // Deterministic, per-instance evolution RNG. NEAT's selection / crossover /
+        // mutation all draw from this stream; seeding it from the architecture's
+        // RandomSeed makes a NEAT run reproducible (the standard NEAT-Python contract —
+        // every config carries a seed). Without it the evolution drew from the
+        // process-shared RandomHelper.ThreadSafeRandom, whose state advances with
+        // unrelated prior work, so a NEAT invariant could pass in isolation yet flake
+        // when interleaved with other tests. When no seed is set (the production
+        // default) it falls back to the shared RNG, preserving non-reproducible
+        // production behaviour.
+        _rng = Architecture.RandomSeed.HasValue
+            ? RandomHelper.CreateSeededRandom(Architecture.RandomSeed.Value)
+            : RandomHelper.ThreadSafeRandom;
+        _population = InitializePopulation();
+    }
+
+    /// <summary>
+    /// Initializes the layers of the neural network.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// This method is intentionally left empty because NEAT does not use fixed layers like traditional neural networks.
+    /// Instead, NEAT evolves the network structure dynamically through the evolutionary process, adding nodes
+    /// and connections as needed.
+    /// </para>
+    /// <para><b>For Beginners:</b> This method is intentionally empty because NEAT works differently from traditional neural networks.
+    /// 
+    /// In traditional neural networks:
+    /// - You define specific layers (input, hidden, output)
+    /// - Each layer has a fixed number of neurons
+    /// - The connections between layers are predetermined
+    /// 
+    /// In NEAT:
+    /// - Networks don't have fixed layers
+    /// - The structure evolves dynamically
+    /// - Neurons and connections are added gradually through evolution
+    /// 
+    /// This fundamental difference is why this method doesn't need to do anything in NEAT.
+    /// The network structure is defined by the genome, not by predefined layers.
+    /// </para>
+    /// </remarks>
+    protected override void InitializeLayers()
+    {
+        // NEAT doesn't use fixed layers, so we'll leave this empty
+    }
+
+    /// <summary>
+    /// NEAT's parameters are the connection weights of the best genome in the population.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// A COMPUTED surface: the weights are not in a field, they are read out of a structure that
+    /// evolves. Declaring a source rather than overriding the fold is what makes the count and the
+    /// vector agree by construction -- both now read this one accessor, where three hand-written
+    /// members were three chances to disagree.
+    /// </para>
+    /// <para>
+    /// The count legitimately CHANGES as the population evolves, and that is not a defect: adding
+    /// or removing a connection is what NEAT does. What must hold is that the count and the vector
+    /// agree at any single instant, which they do because they come from the same source. This is
+    /// stronger than the usual arrangement, where a framework tells you to rebuild the optimizer
+    /// after mutating the parameter set and nothing checks that you did.
+    /// </para>
+    /// </remarks>
     protected override void RegisterComponents()
-    {
-        base.RegisterComponents();
-        RegisterParameterComponent(new DelegatingParameterSource<T>(
-            () => GetBestGenome()?.Connections?.Count ?? 0,
-            () =>
-            {
-                var genome = GetBestGenome();
-                int n = genome?.Connections?.Count ?? 0;
-                var values = new Vector<T>(n);
-                for (int i = 0; i < n; i++) values[i] = genome!.Connections[i].Weight;
-                return values;
-            },
-            values =>
-            {
-                var genome = GetBestGenome();
-                int n = genome?.Connections?.Count ?? 0;
-                for (int i = 0; i < n && i < values.Length; i++)
-                {
-                    genome!.Connections[i].Weight = values[i];
-                }
-            }));
+    {
+        base.RegisterComponents();
+        RegisterParameterComponent(new DelegatingParameterSource<T>(
+            () => GetBestGenome()?.Connections?.Count ?? 0,
+            () =>
+            {
+                var genome = GetBestGenome();
+                int n = genome?.Connections?.Count ?? 0;
+                var values = new Vector<T>(n);
+                for (int i = 0; i < n; i++) values[i] = genome!.Connections[i].Weight;
+                return values;
+            },
+            values =>
+            {
+                var genome = GetBestGenome();
+                int n = genome?.Connections?.Count ?? 0;
+                for (int i = 0; i < n && i < values.Length; i++)
+                {
+                    genome!.Connections[i].Weight = values[i];
+                }
+            }));
     }
 
     /// <summary>
@@ -339,1505 +340,1412 @@ protected override void RegisterComponents()
     public override Vector<T> GetParameterGradients()
         => throw new NotSupportedException(
             "NEAT is an evolutionary optimizer and does not expose parameter gradients.");
-
-    // Replaced by the declared parameter source below. Removed under AIDN082.
-
-    /// <summary>
-    /// Creates the initial population of genomes with minimal network structures.
-    /// </summary>
-    /// <returns>A list of initialized genomes.</returns>
-    /// <remarks>
-    /// <para>
-    /// This method creates the initial population of genomes. Each genome starts with a minimal structure
-    /// consisting of only input and output nodes with direct connections between them. This follows the NEAT
-    /// principle of starting with minimal structures and gradually adding complexity through evolution.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method creates the starting population of simple neural networks.
-    /// 
-    /// When NEAT begins:
-    /// - It creates a population of very simple neural networks
-    /// - Each network starts with just input and output neurons
-    /// - Each input neuron is connected directly to each output neuron
-    /// - The connection weights are randomized
-    /// 
-    /// This minimal starting point is important because:
-    /// - It follows the principle of starting simple and growing complexity as needed
-    /// - It doesn't make assumptions about what structure might work best
-    /// - It allows the evolutionary process to discover the right complexity
-    /// 
-    /// As evolution progresses, these simple networks will grow more complex
-    /// by adding neurons and connections where they're beneficial.
-    /// </para>
-    /// </remarks>
-    private List<Genome<T>> InitializePopulation()
-    {
-        var population = new List<Genome<T>>();
-        for (int i = 0; i < _populationSize; i++)
-        {
-            population.Add(CreateInitialGenome());
-        }
-
-        return population;
-    }
-
-    /// <summary>
-    /// Creates a single initial genome with connections from each input to each output.
-    /// </summary>
-    /// <returns>A newly created genome with minimal structure.</returns>
-    /// <remarks>
-    /// <para>
-    /// This method creates a single genome with a minimal structure. It initializes a network with the specified
-    /// number of input and output nodes, and creates direct connections from each input node to each output node
-    /// with random weights. Each connection is assigned a unique innovation number to track its historical origin.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method creates one simple starting neural network.
-    /// 
-    /// Each initial network:
-    /// - Has the input neurons you specified (for your problem's inputs)
-    /// - Has the output neurons you specified (for your problem's outputs)
-    /// - Connects each input directly to each output
-    /// - Assigns random weights to these connections
-    /// 
-    /// For example, if you have 3 inputs and 2 outputs:
-    /// - You'll have 6 connections (3 inputs × 2 outputs)
-    /// - Each connection gets a random weight between -1 and 1
-    /// - Each connection gets a unique innovation number for tracking
-    /// 
-    /// This simple structure provides a starting point that evolution can build upon,
-    /// adding complexity only where it's beneficial for solving your problem.
-    /// </para>
-    /// </remarks>
-    private Genome<T> CreateInitialGenome()
-    {
-        var genome = new Genome<T>(Architecture.InputSize, Architecture.OutputSize);
-        for (int i = 0; i < Architecture.InputSize; i++)
-        {
-            for (int j = 0; j < Architecture.OutputSize; j++)
-            {
-                genome.AddConnection(i, Architecture.InputSize + j, RandomWeight(), true, _innovationNumber++);
-            }
-        }
-
-        return genome;
-    }
-
-    /// <summary>
-    /// Evolves the population over a specified number of generations using the provided fitness function.
-    /// </summary>
-    /// <param name="fitnessFunction">A function that evaluates the fitness of each genome.</param>
-    /// <param name="generations">The number of generations to evolve.</param>
-    /// <remarks>
-    /// <para>
-    /// This method drives the evolutionary process over multiple generations. For each generation, it evaluates
-    /// the fitness of each genome using the provided fitness function, sorts the population by fitness,
-    /// and creates a new population through selection, crossover, and mutation. Through this process,
-    /// the networks evolve to better solve the specified problem.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method runs the evolutionary process for a specified number of generations.
-    /// 
-    /// The evolution process works like this:
-    /// 
-    /// 1. Evaluate each network:
-    ///    - The provided fitness function tests how well each network performs
-    ///    - Higher fitness scores mean better performance
-    /// 
-    /// 2. Sort networks by fitness:
-    ///    - The best-performing networks are prioritized for reproduction
-    /// 
-    /// 3. Create a new population:
-    ///    - Keep the very best network unchanged (called "elitism")
-    ///    - Create new networks through either:
-    ///      a) Crossover: Combining two parent networks
-    ///      b) Mutation: Copying and modifying a single parent
-    /// 
-    /// 4. Repeat for the specified number of generations
-    /// 
-    /// Each generation should produce slightly better networks as successful
-    /// traits are selected for and new beneficial mutations occur.
-    /// 
-    /// The fitness function you provide is crucial - it's what defines "good performance"
-    /// and guides the entire evolutionary process.
-    /// </para>
-    /// </remarks>
-    public void EvolvePopulation(Func<Genome<T>, T> fitnessFunction, int generations)
-    {
-        for (int gen = 0; gen < generations; gen++)
-        {
-            // Evaluate fitness
-            foreach (var genome in _population)
-            {
-                genome.Fitness = fitnessFunction(genome);
-            }
-
-            // Sort population by fitness (descending)
-            _population.Sort((a, b) =>
-            {
-                if (NumOps.GreaterThan(b.Fitness, a.Fitness)) return 1;
-                if (NumOps.GreaterThan(a.Fitness, b.Fitness)) return -1;
-                return 0;
-            });
-
-            // Create new population — issue #1392 perf: pre-size to the final
-            // capacity so the underlying array doesn't walk the 0→4→8→…
-            // capacity-doubling chain and memcpy on every grow. Population
-            // size is fixed for the lifetime of a NEAT instance.
-            var newPopulation = new List<Genome<T>>(_populationSize);
-
-            // Elitism: Keep the best individual
-            newPopulation.Add(_population[0]);
-
-            while (newPopulation.Count < _populationSize)
-            {
-                if (NumOps.LessThan(NumOps.FromDouble(_rng.NextDouble()), _crossoverRate))
-                {
-                    var parent1 = SelectParent();
-                    var parent2 = SelectParent();
-                    var child = Crossover(parent1, parent2);
-                    Mutate(child);
-                    newPopulation.Add(child);
-                }
-                else
-                {
-                    var parent = SelectParent();
-                    var child = parent.Clone();
-                    Mutate(child);
-                    newPopulation.Add(child);
-                }
-            }
-
-            _population = newPopulation;
-        }
-    }
-
-    /// <summary>
-    /// Selects a parent genome for reproduction using tournament selection.
-    /// </summary>
-    /// <returns>The selected parent genome.</returns>
-    /// <remarks>
-    /// <para>
-    /// This method implements tournament selection, a common selection method in genetic algorithms.
-    /// It randomly selects a small number of genomes from the population, then returns the one with the
-    /// highest fitness. This process favors fitter individuals while still giving less fit individuals
-    /// a chance to reproduce, maintaining genetic diversity.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method selects a parent network for reproduction, favoring better-performing networks.
-    /// 
-    /// Tournament selection works like this:
-    /// 1. Randomly pick a small group of networks (3 in this case)
-    /// 2. Compare their fitness scores
-    /// 3. Select the best one from this small group
-    /// 
-    /// This approach has advantages:
-    /// - Better networks are more likely to be selected
-    /// - But even lower-performing networks have some chance
-    /// - This maintains diversity while still driving improvement
-    /// 
-    /// Think of it like a small competition where the winner gets to reproduce.
-    /// By not always selecting the absolute best network, we avoid getting
-    /// stuck in a single solution path too early.
-    /// </para>
-    /// </remarks>
-    private Genome<T> SelectParent()
-    {
-        // Tournament selection. Issue #1392 perf: the prior implementation
-        // allocated a fresh List<Genome<T>> and an OrderByDescending LINQ
-        // enumerator on every call. Across a Train run that's ~447 k allocs
-        // (149 children × 50 generations × ~30 Train calls × 2 parents per
-        // crossover). Tournament is fixed-size 3 — pick three random genomes
-        // and keep the running argmax inline. No allocations, no LINQ.
-        const int tournamentSize = 3;
-        int n = _population.Count;
-        var best = _population[_rng.Next(n)];
-        var bestFitness = best.Fitness;
-        for (int i = 1; i < tournamentSize; i++)
-        {
-            var candidate = _population[_rng.Next(n)];
-            if (NumOps.GreaterThan(candidate.Fitness, bestFitness))
-            {
-                best = candidate;
-                bestFitness = candidate.Fitness;
-            }
-        }
-
-        return best;
-    }
-
-    /// <summary>
-    /// Creates a new genome by combining genetic material from two parent genomes.
-    /// </summary>
-    /// <param name="parent1">The first parent genome.</param>
-    /// <param name="parent2">The second parent genome.</param>
-    /// <returns>A new child genome created through crossover.</returns>
-    /// <remarks>
-    /// <para>
-    /// This method implements crossover between two parent genomes to create a child genome. It combines
-    /// connection genes from both parents, with matching genes (those with the same innovation number) being
-    /// inherited from either parent. This allows NEAT to meaningfully combine networks with different topologies
-    /// by utilizing the historical markings provided by innovation numbers.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method creates a new network by combining parts from two parent networks.
-    /// 
-    /// The crossover process:
-    /// 1. Creates a new empty network (the child)
-    /// 2. Looks at all connections from both parents
-    /// 3. Adds each unique connection to the child
-    /// 
-    /// The key to making this work is the innovation number:
-    /// - Each connection has a unique ID number (innovation number)
-    /// - This lets NEAT identify which connections in different networks match
-    /// - When the same connection exists in both parents, only one copy is added to the child
-    /// 
-    /// This process allows NEAT to meaningfully combine networks with different structures,
-    /// which is one of its key advantages over other evolutionary methods.
-    /// </para>
-    /// </remarks>
-    private Genome<T> Crossover(Genome<T> parent1, Genome<T> parent2)
-    {
-        // Issue #1392 perf: prior implementation used Enumerable.Concat (one
-        // enumerator alloc) and a fresh HashSet per call (rehash table alloc).
-        // Reuse the per-instance _crossoverSeen HashSet and walk both parent
-        // connection lists by index so the JIT can elide bounds checks. Child
-        // connection list is pre-sized to the upper bound (parent1.Count +
-        // parent2.Count) to skip the List capacity-doubling chain in the
-        // common case where most innovations are unique.
-        var p1 = parent1.Connections;
-        var p2 = parent2.Connections;
-        int p1Count = p1.Count;
-        int p2Count = p2.Count;
-        var child = new Genome<T>(Architecture.InputSize, Architecture.OutputSize);
-        int upperBound = p1Count + p2Count;
-        if (upperBound > 0)
-        {
-            child.Connections.Capacity = upperBound;
-        }
-
-        var seen = _crossoverSeen;
-        seen.Clear();
-        var childConnections = child.Connections;
-        for (int i = 0; i < p1Count; i++)
-        {
-            var c = p1[i];
-            if (seen.Add(c.Innovation))
-            {
-                childConnections.Add(new Connection<T>(c.FromNode, c.ToNode, c.Weight, c.IsEnabled, c.Innovation));
-            }
-        }
-        for (int i = 0; i < p2Count; i++)
-        {
-            var c = p2[i];
-            if (seen.Add(c.Innovation))
-            {
-                childConnections.Add(new Connection<T>(c.FromNode, c.ToNode, c.Weight, c.IsEnabled, c.Innovation));
-            }
-        }
-
-        return child;
-    }
-
-    /// <summary>
-    /// Applies random mutations to a genome based on the mutation rate.
-    /// </summary>
-    /// <param name="genome">The genome to mutate.</param>
-    /// <remarks>
-    /// <para>
-    /// This method applies various types of mutations to a genome with probability based on the mutation rate.
-    /// Possible mutations include adding a new node (by splitting an existing connection), adding a new connection
-    /// between existing nodes, and modifying connection weights. These mutations allow NEAT to explore different
-    /// network structures and parameters to find better solutions.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method introduces random changes to a network to explore new possibilities.
-    /// 
-    /// NEAT uses three main types of mutations:
-    /// 
-    /// 1. Add Node Mutation:
-    ///    - Takes an existing connection and splits it by adding a new neuron in the middle
-    ///    - The original connection is disabled
-    ///    - Two new connections are created (from source to new node, and from new node to target)
-    ///    - This allows the network to create more complex behaviors
-    /// 
-    /// 2. Add Connection Mutation:
-    ///    - Creates a new connection between two previously unconnected neurons
-    ///    - This allows the network to create new paths for information flow
-    /// 
-    /// 3. Weight Mutation:
-    ///    - Changes the weights of existing connections
-    ///    - This fine-tunes the network behavior without changing its structure
-    /// 
-    /// Each type of mutation happens randomly based on the mutation rate.
-    /// These mutations are how NEAT explores different network structures
-    /// and gradually adds complexity where it's beneficial.
-    /// </para>
-    /// </remarks>
-    private void Mutate(Genome<T> genome)
-    {
-        // Issue #1392 perf: prior implementation used LINQ Max+Any on every
-        // call, allocating a Func delegate + an enumerator each time. Walk
-        // Connections by index. Add-node case derives the new node id from
-        // an inline scan over (FromNode, ToNode) since the existing
-        // CachedMaxNodeId on Genome covers max(referenced node id,
-        // biasNodeId), which already gives us "first free node id - 1".
-        var connections = genome.Connections;
-        int count = connections.Count;
-
-        if (NumOps.LessThan(NumOps.FromDouble(_rng.NextDouble()), _mutationRate) && count > 0)
-        {
-            // Add new node
-            var connection = connections[_rng.Next(count)];
-
-            // First-free-node-id scan including the bias node — without the
-            // explicit biasNodeId floor below, the first add-node mutation
-            // on an initial genome (where max(FromNode, ToNode) =
-            // InputSize + OutputSize − 1) would produce newNodeId =
-            // InputSize + OutputSize, which collides with biasNodeId.
-            // ActivateGenome writes activations[biasNodeId] = NumOps.One
-            // BEFORE the connection sweep, so any connection accumulating
-            // into this hidden slot would corrupt the bias value — and
-            // every connection targeting it would also read a polluted
-            // pre-activation from the same slot.
-            int biasNodeId = Architecture.InputSize + Architecture.OutputSize;
-            int maxNodeId = biasNodeId;
-            for (int i = 0; i < count; i++)
-            {
-                var c = connections[i];
-                int hi = c.FromNode > c.ToNode ? c.FromNode : c.ToNode;
-                if (hi > maxNodeId) maxNodeId = hi;
-            }
-            int newNodeId = maxNodeId + 1;
-
-            genome.DisableConnection(connection.Innovation);
-            genome.AddConnection(connection.FromNode, newNodeId, NumOps.One, true, _innovationNumber++);
-            genome.AddConnection(newNodeId, connection.ToNode, connection.Weight, true, _innovationNumber++);
-
-            // List grew under us; reload local references for downstream loops
-            connections = genome.Connections;
-            count = connections.Count;
-        }
-
-        if (NumOps.LessThan(NumOps.FromDouble(_rng.NextDouble()), _mutationRate))
-        {
-            // Add new connection
-            int fromNode = _rng.Next(Architecture.InputSize + Architecture.OutputSize);
-            int toNode = _rng.Next(Architecture.InputSize, Architecture.InputSize + Architecture.OutputSize);
-            bool exists = false;
-            for (int i = 0; i < count; i++)
-            {
-                var c = connections[i];
-                if (c.FromNode == fromNode && c.ToNode == toNode)
-                {
-                    exists = true;
-                    break;
-                }
-            }
-            if (!exists)
-            {
-                genome.AddConnection(fromNode, toNode, RandomWeight(), true, _innovationNumber++);
-                connections = genome.Connections;
-                count = connections.Count;
-            }
-        }
-
-        // Mutate weights — index loop so JIT can elide the List<T>.Enumerator
-        // bounds check overhead the foreach pays per step.
-        T perturbPower = NumOps.FromDouble(WeightPerturbPower);
-        T replaceRate = NumOps.FromDouble(WeightReplaceRate);
-        T weightCap = NumOps.FromDouble(WeightCap);
-        T negWeightCap = NumOps.FromDouble(-WeightCap);
-        for (int i = 0; i < count; i++)
-        {
-            if (NumOps.LessThan(NumOps.FromDouble(_rng.NextDouble()), _mutationRate))
-            {
-                var conn = connections[i];
-                // Faithful NEAT weight mutation (Stanley & Miikkulainen 2002 §3.1; the
-                // same scheme as NEAT-Python's weight_mutate_power / weight_replace_rate /
-                // weight_max_value): with the per-connection mutation probability, EITHER
-                // replace the weight with a fresh random value (small replace rate) OR
-                // nudge it by a SMALL perturbation, then CLAMP to a bounded range. The
-                // previous `weight += RandomWeight()` added a full uniform[-1,1] every
-                // time — an UNBOUNDED RANDOM WALK whose variance grows with the number of
-                // perturbations, so weight magnitudes drift without limit across
-                // generations. A small perturbation power plus a hard clamp keep the
-                // weights bounded, matching the paper's bounded-weight evolutionary search.
-                if (NumOps.LessThan(NumOps.FromDouble(_rng.NextDouble()), replaceRate))
-                {
-                    conn.Weight = RandomWeight();
-                }
-                else
-                {
-                    T perturbation = NumOps.Multiply(
-                        NumOps.FromDouble(_rng.NextDouble() * 2 - 1), perturbPower);
-                    conn.Weight = NumOps.Add(conn.Weight, perturbation);
-                }
-                if (NumOps.GreaterThan(conn.Weight, weightCap)) conn.Weight = weightCap;
-                else if (NumOps.LessThan(conn.Weight, negWeightCap)) conn.Weight = negWeightCap;
-            }
-        }
-    }
-
-    /// <summary>
-    /// Generates a random weight value for neural network connections.
-    /// </summary>
-    /// <returns>A random weight value between -1 and 1.</returns>
-    /// <remarks>
-    /// <para>
-    /// This method generates a random weight value between -1 and 1 for use in neural network connections.
-    /// These random weights provide the initial diversity for the evolutionary process and are also used
-    /// during weight mutation to introduce changes to connection strengths.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method creates a random connection weight value between -1 and 1.
-    /// 
-    /// In neural networks:
-    /// - Connections have weight values that determine their strength and effect
-    /// - Positive weights are excitatory (they increase activation)
-    /// - Negative weights are inhibitory (they decrease activation)
-    /// 
-    /// This method is used:
-    /// - When creating initial networks with random weights
-    /// - During mutation to change existing weights
-    /// 
-    /// Starting with random weights gives the evolutionary process diverse
-    /// starting points to work with, increasing the chances of finding good solutions.
-    /// </para>
-    /// </remarks>
-    private T RandomWeight()
-    {
-        return NumOps.FromDouble(_rng.NextDouble() * 2 - 1);
-    }
-
-    // Replaced by the declared parameter source below. Removed under AIDN082.
-
-    /// <summary>
-    /// Predicts output values for input data using the best genome in the population.
-    /// </summary>
-    /// <param name="input">The input tensor to process.</param>
-    /// <returns>The output tensor after processing.</returns>
-    /// <remarks>
-    /// <para>
-    /// This method uses the highest-fitness genome in the population to make predictions. It activates the 
-    /// genome's neural network with the provided input data and returns the resulting output activations.
-    /// For batch inputs, it processes each sample independently.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method uses the best evolved network to make predictions.
-    /// 
-    /// When making a prediction:
-    /// - NEAT uses the highest-performing network from the population
-    /// - The input data is fed into this network
-    /// - The network processes the data through its evolved structure
-    /// - The resulting output values are returned
-    /// 
-    /// Unlike traditional neural networks with fixed structures, the network used here
-    /// has evolved its structure through the evolutionary process, potentially developing
-    /// complex and unique connection patterns that solve the problem effectively.
-    /// </para>
-    /// </remarks>
-    protected override Tensor<T> PredictCore(Tensor<T> input)
-    {
-        // GPU-resident optimization: use TryForwardGpuOptimized for speedup
-        if (TryForwardGpuOptimized(input, out var gpuResult))
-            return gpuResult;
-
-        // Get the best genome (the one with highest fitness)
-        var bestGenome = GetBestGenome();
-
-        // Treat ANY rank-2 input as batched, even when the batch size is 1.
-        // Returning rank-1 for single-sample input was a real bug —
-        // NEAT.Train downstream reads `expectedOutput.Shape[1]`, which throws
-        // IndexOutOfRangeException for rank-1 targets, and EffectiveOutputShape
-        // cached the wrong rank for the test's warm-up Predict path. Per the
-        // implicit `(batch, features)` contract used by every other neural
-        // network in the codebase, output rank should match input rank.
-        //
-        // Validate rank explicitly: NEAT genomes activate over a flat feature
-        // vector, so anything beyond rank-2 (e.g., a stray rank-3 image
-        // tensor or rank-4 video) cannot be unambiguously interpreted as
-        // batched-features and would mis-index in the loop below. Fail
-        // fast at the boundary instead of producing garbage outputs.
-        if (input.Shape.Length < 1 || input.Shape.Length > 2)
-        {
-            throw new ArgumentException(
-                $"NEAT.Predict expects rank-1 [features] or rank-2 [batch, features]; " +
-                $"got rank {input.Shape.Length} (shape [{string.Join(",", input.Shape)}]).",
-                nameof(input));
-        }
-        bool isBatch = input.Shape.Length == 2;
-
-        if (isBatch)
-        {
-            // Process each input in the batch
-            int batchSize = input.Shape[0];
-            int featureSize = input.Shape[1];
-
-            // Create output tensor with correct shape
-            var output = TensorAllocator.Rent<T>(new int[] { batchSize, Architecture.OutputSize });
-
-            // Process each sample
-            for (int b = 0; b < batchSize; b++)
-            {
-                // Extract individual input
-                var sampleInput = new Vector<T>(featureSize);
-                for (int f = 0; f < featureSize; f++)
-                {
-                    sampleInput[f] = input[b, f];
-                }
-
-                // Get activations for this sample
-                var activations = ActivateGenome(bestGenome, sampleInput);
-
-                // Store output activations
-                for (int o = 0; o < Architecture.OutputSize; o++)
-                {
-                    output[b, o] = activations[Architecture.InputSize + o];
-                }
-            }
-
-            return output;
-        }
-        else
-        {
-            // Single input
-            // Convert input tensor to vector
-            var inputVector = input.ToVector();
-
-            // Get activations
-            var activations = ActivateGenome(bestGenome, inputVector);
-
-            // Create output tensor
-            var output = TensorAllocator.Rent<T>(new int[] { Architecture.OutputSize });
-            for (int i = 0; i < Architecture.OutputSize; i++)
-            {
-                output[i] = activations[Architecture.InputSize + i];
-            }
-
-            return output;
-        }
-    }
-
-    /// <summary>
-    /// Gets the genome with the highest fitness from the population.
-    /// </summary>
-    /// <returns>The best genome in the population.</returns>
-    /// <remarks>
-    /// <para>
-    /// This method sorts the population by fitness in descending order and returns the genome
-    /// with the highest fitness score. If the population hasn't been evaluated yet, it assigns
-    /// a default fitness value to each genome.
-    /// </para>
-    /// <para><b>For Beginners:</b> This finds the top-performing network from the population.
-    /// 
-    /// This method:
-    /// - Sorts all networks based on their fitness scores (performance)
-    /// - Returns the network with the highest score
-    /// - If networks haven't been evaluated yet, it assigns a neutral score
-    /// 
-    /// The returned network is the "champion" of the population - the one that
-    /// has evolved to best solve the problem you're working on.
-    /// </para>
-    /// </remarks>
-    private Genome<T> GetBestGenome()
-    {
-        // Check if any genomes have fitness set
-        bool anyFitnessSet = _population.Any(g => !NumOps.Equals(g.Fitness, NumOps.Zero));
-
-        // If no fitness values are set, assign default
-        if (!anyFitnessSet)
-        {
-            foreach (var genome in _population)
-            {
-                genome.Fitness = NumOps.One; // Neutral fitness
-            }
-        }
-
-        // Find the genome with highest fitness (O(n) instead of O(n log n) sort)
-        var best = _population[0];
-        for (int i = 1; i < _population.Count; i++)
-        {
-            if (NumOps.GreaterThan(_population[i].Fitness, best.Fitness))
-            {
-                best = _population[i];
-            }
-        }
-
-        return best;
-    }
-
-    /// <summary>
-    /// Activates a genome's neural network with the given input.
-    /// </summary>
-    /// <param name="genome">The genome to activate.</param>
-    /// <param name="input">The input values.</param>
-    /// <returns>A dictionary mapping node IDs to their activation values.</returns>
-    /// <remarks>
-    /// <para>
-    /// This method performs a forward pass through the genome's neural network. It initializes
-    /// input nodes with the provided values, processes connections in a topologically sorted order,
-    /// and applies activation functions to produce the final node activations.
-    /// </para>
-    /// <para><b>For Beginners:</b> This runs input data through the evolved neural network.
-    /// 
-    /// The activation process:
-    /// 1. Sets the input nodes to the provided input values
-    /// 2. Processes connections in the correct order (feed-forward)
-    /// 3. Applies the activation function to each neuron
-    /// 4. Returns all neuron activation values
-    /// 
-    /// This is how a NEAT network processes information, similar to a traditional
-    /// neural network but with the specific connection structure that evolved
-    /// during the evolutionary process.
-    /// </para>
-    /// </remarks>
-    private T[] ActivateGenome(Genome<T> genome, Vector<T> input)
-    {
-        // Issue #1392 perf: switched from Dictionary<int, T> to flat T[] indexed
-        // by node id. NEAT node ids are dense small integers (inputs 0..InputSize-1,
-        // outputs InputSize..InputSize+OutputSize-1, bias = InputSize+OutputSize,
-        // hidden > biasNodeId). The Dictionary form added 2-3 heap allocations per
-        // call (Dictionary instance + internal buckets[] + entries[]) plus hash-
-        // compute + bucket-walk on every node access. With a flat array each
-        // activation is a single contiguous-memory store/load.
-        //
-        // Buffer size = max(node id observed in genome's connections, biasNodeId) + 1.
-        // Indices not referenced by any connection stay at default(T) and are
-        // never queried by callers, so over-provisioning is benign.
-
-        int inputSize = Architecture.InputSize;
-        int outputSize = Architecture.OutputSize;
-        int biasNodeId = inputSize + outputSize;
-
-        // Sort connections topologically for proper feed-forward activation.
-        // Cached on the genome — weight-only mutations (the dominant case across
-        // the 50 internal generations per Train call) keep the topology
-        // signature unchanged, so the cache hits and skips the O(E²) sort.
-        var sortedConnections = GetOrBuildSortedConnections(genome);
-
-        int maxNodeId = GetOrBuildMaxNodeId(genome, biasNodeId);
-        var activations = new T[maxNodeId + 1];
-
-        // Set input nodes
-        for (int i = 0; i < inputSize; i++)
-        {
-            activations[i] = input[i];
-        }
-
-        // Set bias node
-        activations[biasNodeId] = NumOps.One;
-
-        // Output nodes + every other slot are pre-zeroed by `new T[]`
-        // (default(T) = NumOps.Zero for built-in numeric types) — no
-        // explicit init loop needed, no per-connection ContainsKey gymnastics
-        // since every FromNode/ToNode id is in range by construction of maxNodeId.
-
-        // Process connections in topological order.
-        foreach (var connection in sortedConnections)
-        {
-            if (!connection.IsEnabled) continue;
-            T weightedInput = NumOps.Multiply(activations[connection.FromNode], connection.Weight);
-            activations[connection.ToNode] = NumOps.Add(activations[connection.ToNode], weightedInput);
-        }
-
-        // Apply activation function to all non-input nodes the genome actually
-        // references (cached on the genome alongside the sort + max-node-id).
-        var nonInputNodes = GetOrBuildReferencedNonInputNodeIds(genome, inputSize);
-        foreach (var nodeId in nonInputNodes)
-        {
-            activations[nodeId] = ApplySigmoid(activations[nodeId]);
-        }
-
-        return activations;
-    }
-
-    /// <summary>
-    /// Issue #1392 perf helper: returns the cached topologically-sorted
-    /// connection list for <paramref name="genome"/>, rebuilding only when
-    /// the topology signature changed since the last call.
-    /// </summary>
-    private List<Connection<T>> GetOrBuildSortedConnections(Genome<T> genome)
-    {
-        int count = genome.Connections.Count;
-        ulong signature = ComputeTopologySignature(genome.Connections);
-        if (genome.CachedSortedConnections != null
-            && genome.CachedTopologySignatureCount == count
-            && genome.CachedTopologySignatureMask == signature)
-        {
-            return genome.CachedSortedConnections;
-        }
-        var sorted = SortConnectionsTopologically(genome);
-        genome.CachedSortedConnections = sorted;
-        genome.CachedTopologySignatureCount = count;
-        genome.CachedTopologySignatureMask = signature;
-        // Invalidate the dependent caches — their content depends on the
-        // connection set, so a topology change forces a rebuild on the next
-        // call.
-        genome.CachedNonInputNodeIds = null;
-        genome.CachedMaxNodeId = -1;
-        return sorted;
-    }
-
-    /// <summary>
-    /// Issue #1392 perf helper: returns max(FromNode, ToNode, biasNodeId)
-    /// across the genome's enabled connections. Cached on the genome so the
-    /// per-call O(E) scan only runs after topology mutations. Used to size
-    /// <see cref="ActivateGenome"/>'s flat activation buffer.
-    /// </summary>
-    private static int GetOrBuildMaxNodeId(Genome<T> genome, int biasNodeId)
-    {
-        if (genome.CachedMaxNodeId >= 0)
-        {
-            return genome.CachedMaxNodeId;
-        }
-        int max = biasNodeId;
-        var conns = genome.Connections;
-        for (int i = 0; i < conns.Count; i++)
-        {
-            var c = conns[i];
-            if (c.FromNode > max) max = c.FromNode;
-            if (c.ToNode > max) max = c.ToNode;
-        }
-        genome.CachedMaxNodeId = max;
-        return max;
-    }
-
-    /// <summary>
-    /// Issue #1392 perf helper: caches the list of node IDs &gt;= InputSize that
-    /// the sigmoid sweep should touch. Built directly from the connection list
-    /// (any FromNode/ToNode &gt;= InputSize that the genome references) so we
-    /// don't need to materialize a Dictionary first. Invalidated alongside
-    /// <see cref="GetOrBuildSortedConnections"/>.
-    /// </summary>
-    private List<int> GetOrBuildReferencedNonInputNodeIds(Genome<T> genome, int inputSize)
-    {
-        if (genome.CachedNonInputNodeIds != null)
-        {
-            return genome.CachedNonInputNodeIds;
-        }
-        var seen = new HashSet<int>();
-        var list = new List<int>();
-        foreach (var c in genome.Connections)
-        {
-            if (!c.IsEnabled) continue;
-            if (c.FromNode >= inputSize && seen.Add(c.FromNode)) list.Add(c.FromNode);
-            if (c.ToNode >= inputSize && seen.Add(c.ToNode)) list.Add(c.ToNode);
-        }
-        // Also include output nodes (always activated even if no connection
-        // wrote to them, because ActivateGenome zero-initializes the slot
-        // and the sigmoid should still run on the zero value for caller
-        // consistency with the pre-refactor Dictionary behavior).
-        int outputSize = Architecture.OutputSize;
-        for (int i = 0; i < outputSize; i++)
-        {
-            int outNode = inputSize + i;
-            if (seen.Add(outNode)) list.Add(outNode);
-        }
-        // Bias node: the pre-refactor Dictionary implementation set
-        // activations[InputSize+OutputSize] = NumOps.One BEFORE the sigmoid
-        // sweep and then iterated `activations.Keys.Where(k >= InputSize)`,
-        // so the bias slot was overwritten with Sigmoid(1) = ~0.731 by the
-        // end. Preserve that exact behavior here so callers that read the
-        // bias slot from the returned array see the same value they saw
-        // before this refactor.
-        int biasNodeId = inputSize + outputSize;
-        if (seen.Add(biasNodeId)) list.Add(biasNodeId);
-        genome.CachedNonInputNodeIds = list;
-        return list;
-    }
-
-    /// <summary>
-    /// O(N) FNV-1a hash over every connection slot's <c>(FromNode,
-    /// ToNode, IsEnabled)</c> tuple in iteration order. Used together
-    /// with <c>Connections.Count</c> as the cache key for the
-    /// topologically-sorted connection list on <see cref="Genome{T}"/>.
-    /// </summary>
-    /// <remarks>
-    /// Replaces an earlier bitmask-of-enabled-flags signature that
-    /// missed two real edit patterns and let stale cached sorts /
-    /// non-input-node sets / max-node-id leak back to callers:
-    /// <list type="bullet">
-    /// <item>Same-count rewires — swapping a connection's <c>FromNode</c>
-    /// or <c>ToNode</c> for a different node without flipping any
-    /// <c>IsEnabled</c> bit preserved both <c>Count</c> and the bitmask
-    /// → cache hit on the WRONG topology.</item>
-    /// <item>&gt;64-connection aliasing — the bitmask's <c>(i &amp; 63)</c>
-    /// wrap collapsed slots 0/64/128/… onto the same bit, so a flip at
-    /// slot 64 could XOR-cancel an earlier flip at slot 0 and leave the
-    /// mask unchanged.</item>
-    /// </list>
-    /// Weight is deliberately excluded from the signature — weight-only
-    /// mutations are the dominant case across the 50 internal
-    /// generations per public <c>Train</c> call, and we WANT the cached
-    /// topological sort to survive them.
-    /// </remarks>
-    private static ulong ComputeTopologySignature(List<Connection<T>> connections)
-    {
-        // FNV-1a 64-bit hash of every connection slot's
-        // (FromNode, ToNode, IsEnabled) tuple in iteration order. The
-        // earlier ComputeEnabledBitmask only hashed the enabled flags and
-        // would alias same-count rewires/replacements (e.g. swapping a
-        // connection's FromNode preserved both count and enabled-bitmask
-        // → stale cache → wrong activation). Hashing the full tuple
-        // also avoids the >64-connection aliasing the bitmask suffered
-        // once the wrap-around in `(i & 63)` started folding bits.
-        // Connection.Weight is intentionally excluded — weight-only
-        // mutations are the dominant case across the 50 internal
-        // generations per Train call and we WANT the cached topological
-        // sort to survive them.
-        const ulong FnvOffsetBasis = 14695981039346656037UL;
-        const ulong FnvPrime = 1099511628211UL;
-        ulong hash = FnvOffsetBasis;
-        int n = connections.Count;
-        for (int i = 0; i < n; i++)
-        {
-            var c = connections[i];
-            hash ^= (ulong)(uint)c.FromNode;
-            hash *= FnvPrime;
-            hash ^= (ulong)(uint)c.ToNode;
-            hash *= FnvPrime;
-            hash ^= c.IsEnabled ? 1UL : 0UL;
-            hash *= FnvPrime;
-        }
-        return hash;
-    }
-
-    /// <summary>
-    /// Sorts connections in topological order for proper feed-forward activation.
-    /// </summary>
-    /// <param name="genome">The genome containing connections to sort.</param>
-    /// <returns>A list of connections sorted in topological order.</returns>
-    /// <remarks>
-    /// <para>
-    /// This method sorts the connections in a genome to ensure they are processed in the correct
-    /// order during network activation. It creates layers of nodes based on their depth in the network
-    /// and sorts connections accordingly.
-    /// </para>
-    /// <para><b>For Beginners:</b> This determines the correct order to process connections.
-    /// 
-    /// In a neural network:
-    /// - Information flows from input to output
-    /// - Connections must be processed in the correct order
-    /// - Inputs need to be calculated before they can be used
-    /// 
-    /// This method:
-    /// - Figures out which neurons depend on which other neurons
-    /// - Sorts connections so inputs are always processed before outputs
-    /// - Ensures the network processes information in a feed-forward manner
-    /// 
-    /// This is especially important in NEAT since the connection structure
-    /// evolves and isn't fixed in predefined layers.
-    /// </para>
-    /// </remarks>
-    private List<Connection<T>> SortConnectionsTopologically(Genome<T> genome)
-    {
-        // Create a dictionary to track nodes that feed into each node
-        var incomingConnections = new Dictionary<int, List<Connection<T>>>();
-
-        // Create a set of all nodes
-        var allNodes = new HashSet<int>();
-
-        // Populate incoming connections and collect all nodes
-        foreach (var conn in genome.Connections)
-        {
-            if (!conn.IsEnabled) continue;
-
-            allNodes.Add(conn.FromNode);
-            allNodes.Add(conn.ToNode);
-
-            if (!incomingConnections.ContainsKey(conn.ToNode))
-            {
-                incomingConnections[conn.ToNode] = new List<Connection<T>>();
-            }
-
-            incomingConnections[conn.ToNode].Add(conn);
-        }
-
-        // Create a dictionary to track processed nodes
-        var processedNodes = new Dictionary<int, bool>();
-
-        // Input nodes don't have incoming connections and are already processed
-        for (int i = 0; i < Architecture.InputSize; i++)
-        {
-            processedNodes[i] = true;
-        }
-
-        // Sort connections
-        var sortedConnections = new List<Connection<T>>();
-        var sortedSet = new HashSet<int>(); // Track sorted connections by innovation for O(1) lookup
-
-        // Pre-filter enabled connections to avoid repeated enumeration
-        var enabledConnections = genome.Connections.Where(c => c.IsEnabled).ToList();
-        int enabledCount = enabledConnections.Count;
-
-        // Process until all connections are sorted
-        while (sortedConnections.Count < enabledCount)
-        {
-            bool addedConnection = false;
-
-            // Check each enabled connection
-            foreach (var conn in enabledConnections)
-            {
-                // Skip if already in sorted list (O(1) with HashSet)
-                if (sortedSet.Contains(conn.Innovation)) continue;
-
-                // Check if from node is processed
-                if (processedNodes.ContainsKey(conn.FromNode) && processedNodes[conn.FromNode])
-                {
-                    // Add connection to sorted list
-                    sortedConnections.Add(conn);
-                    sortedSet.Add(conn.Innovation);
-
-                    // Mark to node as processed
-                    processedNodes[conn.ToNode] = true;
-
-                    addedConnection = true;
-                }
-            }
-
-            // If no connections were added in this iteration, we might have a cycle
-            if (!addedConnection) break;
-        }
-
-        return sortedConnections;
-    }
-
-    /// <summary>
-    /// Applies the sigmoid activation function to a value.
-    /// </summary>
-    /// <param name="value">The input value.</param>
-    /// <returns>The sigmoid of the input.</returns>
-    /// <remarks>
-    /// <para>
-    /// This method applies the sigmoid activation function (1 / (1 + e^-x)) to the input value.
-    /// Sigmoid squashes input values to the range (0, 1), which is useful for producing
-    /// normalized activation values in the network.
-    /// </para>
-    /// <para><b>For Beginners:</b> This transforms neuron values to a value between 0 and 1.
-    /// 
-    /// The sigmoid function:
-    /// - Takes any input value (positive or negative)
-    /// - Transforms it to a value between 0 and 1
-    /// - Creates a smooth, non-linear response
-    /// 
-    /// This non-linearity is important because:
-    /// - It allows the network to learn complex patterns
-    /// - It prevents the network from just computing weighted sums
-    /// - It gives neurons an "activation threshold" like biological neurons
-    /// 
-    /// Sigmoid is one of several possible activation functions used in neural networks.
-    /// </para>
-    /// </remarks>
-    private T ApplySigmoid(T value)
-    {
-        // Sigmoid function: 1 / (1 + e^-x)
-        T negValue = NumOps.Negate(value);
-        T expNeg = NumOps.Exp(negValue);
-        T denominator = NumOps.Add(NumOps.One, expNeg);
-
-        return NumOps.Divide(NumOps.One, denominator);
-    }
-
-    /// <summary>
-    /// Trains the NEAT system using supervised learning data.
-    /// </summary>
-    /// <param name="input">The input training data tensor.</param>
-    /// <param name="expectedOutput">The expected output tensor.</param>
-    /// <remarks>
-    /// <para>
-    /// This method adapts NEAT to work with traditional supervised learning data. It creates a fitness
-    /// function based on the mean squared error between network predictions and expected outputs,
-    /// then evolves the population to minimize this error. This allows NEAT to be used in scenarios
-    /// where traditional supervised learning would be applied.
-    /// </para>
-    /// <para><b>For Beginners:</b> This teaches the NEAT system using example input-output pairs.
-    /// 
-    /// Unlike traditional neural networks that use gradient descent, NEAT learns through evolution:
-    /// 1. It creates a fitness function based on prediction error
-    ///    - Networks that make more accurate predictions get higher fitness scores
-    ///    - Networks with lower error perform better
-    /// 
-    /// 2. It evolves the population for several generations
-    ///    - Better networks reproduce more often
-    ///    - Genetic operators (crossover and mutation) create diversity
-    ///    - The population gradually improves at the task
-    /// 
-    /// This allows NEAT to work with supervised learning data while using its
-    /// evolutionary approach to discover effective network structures.
-    /// </para>
-    /// </remarks>
-    public override void Train(Tensor<T> input, Tensor<T> expectedOutput)
-    {
-        // Check if input and output have compatible batch sizes
-        if (input.Shape[0] != expectedOutput.Shape[0])
-        {
-            throw new ArgumentException("Input and expected output must have the same batch size");
-        }
-
-        int batchSize = input.Shape[0];
-
-        // Convert input and expected output to a format suitable for the fitness function
-        var trainingData = ExtractTrainingData(input, expectedOutput);
-
-        // Create a fitness function that measures how well each genome performs on the training data
-        T fitnessFunction(Genome<T> genome)
-        {
-            T totalError = NumOps.Zero;
-
-            // Calculate error for each training example
-            foreach (var (sampleInput, sampleExpected) in trainingData)
-            {
-                // Get actual output from genome
-                var activations = ActivateGenome(genome, sampleInput);
-
-                // Extract predicted values into a vector
-                var predictedVector = new Vector<T>(Architecture.OutputSize);
-                for (int i = 0; i < Architecture.OutputSize; i++)
-                {
-                    int outputNodeId = Architecture.InputSize + i;
-                    predictedVector[i] = activations[outputNodeId];
-                }
-
-                // Use the loss function to calculate error for this sample
-                T sampleLoss = LossFunction.CalculateLoss(predictedVector, sampleExpected);
-                totalError = NumOps.Add(totalError, sampleLoss);
-            }
-
-            // Calculate average loss across all samples
-            T averageLoss = NumOps.Divide(totalError, NumOps.FromDouble(batchSize));
-
-            // Issue #1392 perf fix: removed the inline LastLoss assignment that
-            // previously fired here gated on `genome == _population.OrderByDescending
-            // (g => g.Fitness).FirstOrDefault()`. That branch had two problems:
-            //
-            // 1. Perf: it ran `OrderByDescending` on the entire population for
-            //    EVERY genome's fitness eval, giving O(N²) work per generation
-            //    (N=150 default → 22,500 fitness-compare + allocations per
-            //    generation × 50 generations × 30 Train calls = ~34M ops just
-            //    for picking the best, before any actual genome activation).
-            //    On a tiny tabular input this dominated the per-Train wall time
-            //    and pushed Training_ShouldReduceLoss past the 120 s CI budget.
-            //
-            // 2. Correctness: the reference-equality probe `genome == best`
-            //    matched the PRE-EVALUATION best (Fitness values from the
-            //    previous generation) which is essentially random for the
-            //    current generation. The post-evolution recompute below
-            //    (lines 1130+) does the work properly by re-evaluating the
-            //    actual post-generation best genome, so the inline
-            //    LastLoss assignment was already dead code.
-            //
-            // Net: deleting the branch is pure speedup with no behavior change.
-
-            // Convert loss to fitness (higher is better, so invert loss)
-            // Add small constant to avoid division by zero
-            T fitness = NumOps.Divide(NumOps.One, NumOps.Add(averageLoss, NumOps.FromDouble(0.01)));
-
-            return fitness;
-        }
-
-        // Evolve the population for multiple generations
-        // The number of generations can be adjusted based on the problem complexity
-        int generations = 50;
-        EvolvePopulation(fitnessFunction, generations);
-
-        // Re-evaluate the post-evolution best genome and record its loss
-        // as LastLoss. The fitness-function-side LastLoss assignment uses
-        // a reference-equality probe against the pre-generation best,
-        // which silently misses the post-evolution best when the
-        // population reshuffles (every Train call after the first hit
-        // this — LastLoss stayed at its pre-Train value or NumOps.Zero,
-        // producing the misleading "step 1=0.000000, step N=0.000000"
-        // failure on LossStrictlyDecreasesOnMemorizationTask). Recompute
-        // here so the public Train contract surfaces a real per-call loss.
-        var postBest = GetBestGenome();
-        if (postBest.Connections.Count > 0 && trainingData.Count > 0)
-        {
-            T totalErr = NumOps.Zero;
-            foreach (var (sampleInput, sampleExpected) in trainingData)
-            {
-                var act = ActivateGenome(postBest, sampleInput);
-                var pred = new Vector<T>(Architecture.OutputSize);
-                for (int i = 0; i < Architecture.OutputSize; i++)
-                {
-                    int outputNodeId = Architecture.InputSize + i;
-                    // ActivateGenome's flat array is sized to max(node id,
-                    // biasNodeId); output node ids are guaranteed in range
-                    // since biasNodeId = InputSize + OutputSize > any output id.
-                    pred[i] = act[outputNodeId];
-                }
-                totalErr = NumOps.Add(totalErr, LossFunction.CalculateLoss(pred, sampleExpected));
-            }
-            LastLoss = NumOps.Divide(totalErr, NumOps.FromDouble(trainingData.Count));
-        }
-    }
-
-    /// <summary>
-    /// Extracts training data pairs from input and expected output tensors.
-    /// </summary>
-    /// <param name="input">The input training data tensor.</param>
-    /// <param name="expectedOutput">The expected output tensor.</param>
-    /// <returns>A list of input-output vector pairs.</returns>
-    /// <remarks>
-    /// <para>
-    /// This method converts tensor-based training data into a list of vector pairs that can be
-    /// more easily processed by the NEAT algorithm. Each pair consists of an input vector and
-    /// its corresponding expected output vector.
-    /// </para>
-    /// <para><b>For Beginners:</b> This converts tensor-based training data into a format NEAT can use.
-    /// 
-    /// The conversion process:
-    /// 1. Takes the tensor-based input and output data
-    /// 2. Extracts each individual training example
-    /// 3. Creates pairs of (input, expected output) vectors
-    /// 4. Returns a list of these pairs for the fitness function to use
-    /// 
-    /// This preprocessing step allows NEAT to work with the same types of
-    /// training data used by traditional neural networks, making it more
-    /// versatile for different applications.
-    /// </para>
-    /// </remarks>
-    private List<(Vector<T> input, Vector<T> expected)> ExtractTrainingData(Tensor<T> input, Tensor<T> expectedOutput)
-    {
-        int batchSize = input.Shape[0];
-        int inputFeatures = input.Shape[1];
-        int outputFeatures = expectedOutput.Shape[1];
-
-        var trainingData = new List<(Vector<T> input, Vector<T> expected)>(batchSize);
-
-        for (int b = 0; b < batchSize; b++)
-        {
-            // Extract input vector
-            var inputVector = new Vector<T>(inputFeatures);
-            for (int i = 0; i < inputFeatures; i++)
-            {
-                inputVector[i] = input[b, i];
-            }
-
-            // Extract expected output vector
-            var expectedVector = new Vector<T>(outputFeatures);
-            for (int o = 0; o < outputFeatures; o++)
-            {
-                expectedVector[o] = expectedOutput[b, o];
-            }
-
-            // Add pair to training data
-            trainingData.Add((inputVector, expectedVector));
-        }
-
-        return trainingData;
-    }
-
-    /// <summary>
-    /// Gets metadata about the NEAT model.
-    /// </summary>
-    /// <returns>A ModelMetaData object containing information about the NEAT model.</returns>
-    /// <remarks>
-    /// <para>
-    /// This method returns comprehensive metadata about the NEAT model, including its architecture,
-    /// evolutionary parameters, and population statistics. This information is useful for model
-    /// management, tracking experiments, and reporting results.
-    /// </para>
-    /// <para><b>For Beginners:</b> This provides detailed information about your NEAT system.
-    /// 
-    /// The metadata includes:
-    /// - What this model is and what it does
-    /// - Population size and evolutionary parameters
-    /// - Statistics about the current population
-    /// - Information about the best-performing network
-    /// 
-    /// This information is useful for:
-    /// - Tracking your experiments
-    /// - Comparing different NEAT runs
-    /// - Documenting your work
-    /// - Understanding the evolved solution
-    /// </para>
-    /// </remarks>
-    public override ModelMetadata<T> GetModelMetadata()
-    {
-        // Get the best genome
-        var bestGenome = GetBestGenome();
-
-        // Count average number of connections and nodes in the population
-        double avgConnections = _population.Average(g => g.Connections.Count);
-        int maxConnections = _population.Max(g => g.Connections.Count);
-
-        // Count nodes by finding the highest node ID in each genome
-        var nodeCounts = _population.Select(g =>
-            g.Connections.Any() ?
-                g.Connections.Max(c => Math.Max(c.FromNode, c.ToNode)) + 1 :
-                Architecture.InputSize + Architecture.OutputSize
-        );
-        double avgNodes = nodeCounts.Average();
-        int maxNodes = nodeCounts.Max();
-
-        return new ModelMetadata<T>
-        {
-            AdditionalInfo = new Dictionary<string, object>
-            {
-                { "PopulationSize", _populationSize },
-                { "MutationRate", NumOps.ToDouble(_mutationRate) },
-                { "CrossoverRate", NumOps.ToDouble(_crossoverRate) },
-                { "InnovationNumber", _innovationNumber },
-                { "AverageConnections", avgConnections },
-                { "MaxConnections", maxConnections },
-                { "AverageNodes", avgNodes },
-                { "MaxNodes", maxNodes },
-                { "BestGenomeFitness", Convert.ToDouble(bestGenome.Fitness) },
-                { "BestGenomeConnections", bestGenome.Connections.Count },
-                { "BestGenomeEnabledConnections", bestGenome.Connections.Count(c => c.IsEnabled) }
-            },
-            ModelData = SerializeForMetadata()
-        };
-    }
-
-    // Replaced by the declared parameter source below. Removed under AIDN082.
-
-    /// <summary>
-    /// Yields the best genome's connection weights as a single chunk so
-    /// snapshot-based parameter-change probes (Training_ShouldChangeParameters,
-    /// GradientFlow_ShouldBeNonZeroAndFinite) see real evolutionary
-    /// updates. The base <see cref="NeuralNetworkBase{T}.GetParameterChunks"/>
-    /// walks <see cref="Layers"/>, which NEAT leaves EMPTY — its trainable
-    /// surface is the best genome's <c>Connections</c> list, and there is no
-    /// fixed layer partition to publish because the topology is evolved and
-    /// mutates every generation. So the inherited chunk walk reported zero
-    /// changes after Train and produced false "no parameters changed"
-    /// failures (#1224 Cluster F). Yielding a genome-derived chunk surfaces
-    /// the evolutionary delta.
-    /// (This previously said NEAT "populates Layers with a stub representation
-    /// of the best genome". It does not: Layers is written nowhere in this
-    /// file. The override is right; the reason given for it was not.)
-    /// </summary>
-    public override System.Collections.Generic.IEnumerable<Tensor<T>> GetParameterChunks()
-    {
-        var paramVec = GetParameters();
-        if (paramVec.Length == 0) yield break;
-        var chunk = new Tensor<T>(new[] { paramVec.Length });
-        for (int i = 0; i < paramVec.Length; i++) chunk[i] = paramVec[i];
-        yield return chunk;
-    }
-
-    /// <summary>
-    /// Gets named activations from the best genome's network when processing input.
-    /// </summary>
-    public override Dictionary<string, Tensor<T>> GetNamedLayerActivations(Tensor<T> input)
-    {
-        var bestGenome = GetBestGenome();
-        var inputVector = input.ToVector();
-        var activations = ActivateGenome(bestGenome, inputVector);
-
-        var result = new Dictionary<string, Tensor<T>>();
-
-        int inputSize = Architecture.InputSize;
-        int outputSize = Architecture.OutputSize;
-        int biasNodeId = inputSize + outputSize;
-
-        // Issue #1392 perf: ActivateGenome now returns a flat T[] sized to
-        // max(referenced node id, biasNodeId) + 1, so input + output + bias
-        // slots are guaranteed in range. The ContainsKey gymnastics from the
-        // Dictionary era are unnecessary — read straight by index.
-
-        var inputActivation = new Tensor<T>(new int[] { inputSize });
-        for (int i = 0; i < inputSize; i++)
-        {
-            inputActivation[i] = activations[i];
-        }
-        result["InputNodes"] = inputActivation;
-
-        var outputActivation = new Tensor<T>(new int[] { outputSize });
-        for (int i = 0; i < outputSize; i++)
-        {
-            outputActivation[i] = activations[inputSize + i];
-        }
-        result["OutputNodes"] = outputActivation;
-
-        // Hidden nodes: walk the genome's cached non-input-node-id list and
-        // pick out the entries beyond the bias slot. Sorted ascending by id
-        // for stable result ordering, matching what the prior OrderBy(k => k)
-        // chain produced.
-        var nonInputNodeIds = GetOrBuildReferencedNonInputNodeIds(bestGenome, inputSize);
-        var hiddenNodes = new List<int>();
-        foreach (var nodeId in nonInputNodeIds)
-        {
-            if (nodeId > biasNodeId) hiddenNodes.Add(nodeId);
-        }
-        hiddenNodes.Sort();
-
-        if (hiddenNodes.Count > 0)
-        {
-            var hiddenActivation = new Tensor<T>(new int[] { hiddenNodes.Count });
-            for (int i = 0; i < hiddenNodes.Count; i++)
-            {
-                hiddenActivation[i] = activations[hiddenNodes[i]];
-            }
-            result["HiddenNodes"] = hiddenActivation;
-        }
-
-        return result;
-    }
-
-    /// <summary>
-    /// Serializes NEAT-specific data to a binary writer.
-    /// </summary>
-    /// <param name="writer">The binary writer to write to.</param>
-    /// <remarks>
-    /// <para>
-    /// This method saves the state of the NEAT model to a binary stream. It serializes the
-    /// evolutionary parameters, innovation number, and all genomes in the population, allowing
-    /// the complete state to be restored later.
-    /// </para>
-    /// <para><b>For Beginners:</b> This saves the complete state of your NEAT system to a file.
-    /// 
-    /// When saving the NEAT model:
-    /// - Population size, mutation rate, and crossover rate are saved
-    /// - The current innovation number is saved
-    /// - Every genome in the population is saved with all its connections
-    /// 
-    /// This allows you to:
-    /// - Save your progress and continue evolution later
-    /// - Share evolved populations with others
-    /// - Keep records of particularly successful runs
-    /// - Deploy evolved networks in applications
-    /// </para>
-    /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        // Save NEAT parameters
-        writer.Write(_populationSize);
-        writer.Write(NumOps.ToDouble(_mutationRate));
-        writer.Write(NumOps.ToDouble(_crossoverRate));
-        writer.Write(_innovationNumber);
-
-        // Save population
-        writer.Write(_population.Count);
-        foreach (var genome in _population)
-        {
-            // Save genome fitness
-            writer.Write(Convert.ToDouble(genome.Fitness));
-
-            // Save connections
-            writer.Write(genome.Connections.Count);
-            foreach (var conn in genome.Connections)
-            {
-                writer.Write(conn.FromNode);
-                writer.Write(conn.ToNode);
-                writer.Write(Convert.ToDouble(conn.Weight));
-                writer.Write(conn.IsEnabled);
-                writer.Write(conn.Innovation);
-            }
-        }
-    }
-
-    /// <summary>
-    /// Deserializes NEAT-specific data from a binary reader.
-    /// </summary>
-    /// <param name="reader">The binary reader to read from.</param>
-    /// <remarks>
-    /// <para>
-    /// This method loads the state of a previously saved NEAT model from a binary stream. It restores
-    /// the evolutionary parameters, innovation number, and all genomes in the population, allowing
-    /// evolution to continue from exactly where it left off.
-    /// </para>
-    /// <para><b>For Beginners:</b> This loads a complete NEAT system from a saved file.
-    /// 
-    /// When loading the NEAT model:
-    /// - Population size, mutation rate, and crossover rate are restored
-    /// - The innovation number is restored
-    /// - Every genome in the population is recreated with all its connections
-    /// 
-    /// This lets you:
-    /// - Continue evolution from where you left off
-    /// - Use previously evolved populations
-    /// - Compare or combine results from different runs
-    /// </para>
-    /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        // Load NEAT parameters
-        _populationSize = reader.ReadInt32();
-        _mutationRate = NumOps.FromDouble(reader.ReadDouble());
-        _crossoverRate = NumOps.FromDouble(reader.ReadDouble());
-        _innovationNumber = reader.ReadInt32();
-
-        // Load population
-        int populationCount = reader.ReadInt32();
-        _population = new List<Genome<T>>(populationCount);
-
-        for (int i = 0; i < populationCount; i++)
-        {
-            // Create new genome
-            var genome = new Genome<T>(Architecture.InputSize, Architecture.OutputSize);
-
-            // Load genome fitness
-            genome.Fitness = NumOps.FromDouble(reader.ReadDouble());
-
-            // Load connections
-            int connectionCount = reader.ReadInt32();
-            for (int j = 0; j < connectionCount; j++)
-            {
-                int fromNode = reader.ReadInt32();
-                int toNode = reader.ReadInt32();
-                T weight = NumOps.FromDouble(reader.ReadDouble());
-                bool isEnabled = reader.ReadBoolean();
-                int innovation = reader.ReadInt32();
-
-                genome.AddConnection(fromNode, toNode, weight, isEnabled, innovation);
-            }
-
-            _population.Add(genome);
-        }
-    }
-
-    /// <summary>
-    /// Checks if the NEAT model is ready to make predictions.
-    /// </summary>
-    /// <returns>True if the model is ready; otherwise, false.</returns>
-    /// <remarks>
-    /// <para>
-    /// This method checks if the NEAT model has a population with at least one genome that can be
-    /// used for making predictions. It's useful for determining if the model has been properly
-    /// initialized and evolved.
-    /// </para>
-    /// <para><b>For Beginners:</b> This checks if your NEAT system is ready to use.
-    /// 
-    /// It verifies that:
-    /// - The population exists
-    /// - There is at least one genome in the population
-    /// - At least one genome has connections that can process inputs
-    /// 
-    /// This is helpful for error checking before trying to use the model
-    /// for predictions or continuing evolution.
-    /// </para>
-    /// </remarks>
-    public bool IsReadyToPredict()
-    {
-        return _population != null &&
-               _population.Count > 0 &&
-               _population.Any(g => g.Connections.Count > 0);
-    }
-
-    /// <summary>
-    /// Creates a new instance of the NEAT model with the same architecture and evolutionary parameters.
-    /// </summary>
-    /// <returns>A new instance of the NEAT model.</returns>
-    /// <remarks>
-    /// <para>
-    /// This method creates a new NEAT model with the same architecture, population size, mutation rate,
-    /// and crossover rate as the current instance. The new instance starts with a fresh population,
-    /// making it useful for restarting evolution with the same parameters or for creating parallel
-    /// evolutionary runs.
-    /// </para>
-    /// <para><b>For Beginners:</b> This creates a brand new NEAT system with the same settings.
-    /// 
-    /// This is useful when you want to:
-    /// - Start over with a fresh population but keep the same settings
-    /// - Run multiple separate evolutions with identical parameters
-    /// - Create a "clean slate" version of a successful setup
-    /// 
-    /// The new NEAT system will have:
-    /// - The same number of inputs and outputs
-    /// - The same population size and mutation/crossover rates
-    /// - A brand new initial population (not copying any evolved networks)
-    /// 
-    /// This effectively creates a "twin" of your NEAT system, but at the starting point
-    /// rather than with any of the evolved progress.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new NEAT<T>(Architecture, _populationSize, NumOps.ToDouble(_mutationRate), NumOps.ToDouble(_crossoverRate));
-    }
-}
+
+    // Replaced by the declared parameter source below. Removed under AIDN082.
+
+    /// <summary>
+    /// Creates the initial population of genomes with minimal network structures.
+    /// </summary>
+    /// <returns>A list of initialized genomes.</returns>
+    /// <remarks>
+    /// <para>
+    /// This method creates the initial population of genomes. Each genome starts with a minimal structure
+    /// consisting of only input and output nodes with direct connections between them. This follows the NEAT
+    /// principle of starting with minimal structures and gradually adding complexity through evolution.
+    /// </para>
+    /// <para><b>For Beginners:</b> This method creates the starting population of simple neural networks.
+    /// 
+    /// When NEAT begins:
+    /// - It creates a population of very simple neural networks
+    /// - Each network starts with just input and output neurons
+    /// - Each input neuron is connected directly to each output neuron
+    /// - The connection weights are randomized
+    /// 
+    /// This minimal starting point is important because:
+    /// - It follows the principle of starting simple and growing complexity as needed
+    /// - It doesn't make assumptions about what structure might work best
+    /// - It allows the evolutionary process to discover the right complexity
+    /// 
+    /// As evolution progresses, these simple networks will grow more complex
+    /// by adding neurons and connections where they're beneficial.
+    /// </para>
+    /// </remarks>
+    private List<Genome<T>> InitializePopulation()
+    {
+        var population = new List<Genome<T>>();
+        for (int i = 0; i < _populationSize; i++)
+        {
+            population.Add(CreateInitialGenome());
+        }
+
+        return population;
+    }
+
+    /// <summary>
+    /// Creates a single initial genome with connections from each input to each output.
+    /// </summary>
+    /// <returns>A newly created genome with minimal structure.</returns>
+    /// <remarks>
+    /// <para>
+    /// This method creates a single genome with a minimal structure. It initializes a network with the specified
+    /// number of input and output nodes, and creates direct connections from each input node to each output node
+    /// with random weights. Each connection is assigned a unique innovation number to track its historical origin.
+    /// </para>
+    /// <para><b>For Beginners:</b> This method creates one simple starting neural network.
+    /// 
+    /// Each initial network:
+    /// - Has the input neurons you specified (for your problem's inputs)
+    /// - Has the output neurons you specified (for your problem's outputs)
+    /// - Connects each input directly to each output
+    /// - Assigns random weights to these connections
+    /// 
+    /// For example, if you have 3 inputs and 2 outputs:
+    /// - You'll have 6 connections (3 inputs × 2 outputs)
+    /// - Each connection gets a random weight between -1 and 1
+    /// - Each connection gets a unique innovation number for tracking
+    /// 
+    /// This simple structure provides a starting point that evolution can build upon,
+    /// adding complexity only where it's beneficial for solving your problem.
+    /// </para>
+    /// </remarks>
+    private Genome<T> CreateInitialGenome()
+    {
+        var genome = new Genome<T>(Architecture.InputSize, Architecture.OutputSize);
+        for (int i = 0; i < Architecture.InputSize; i++)
+        {
+            for (int j = 0; j < Architecture.OutputSize; j++)
+            {
+                genome.AddConnection(i, Architecture.InputSize + j, RandomWeight(), true, _innovationNumber++);
+            }
+        }
+
+        return genome;
+    }
+
+    /// <summary>
+    /// Evolves the population over a specified number of generations using the provided fitness function.
+    /// </summary>
+    /// <param name="fitnessFunction">A function that evaluates the fitness of each genome.</param>
+    /// <param name="generations">The number of generations to evolve.</param>
+    /// <remarks>
+    /// <para>
+    /// This method drives the evolutionary process over multiple generations. For each generation, it evaluates
+    /// the fitness of each genome using the provided fitness function, sorts the population by fitness,
+    /// and creates a new population through selection, crossover, and mutation. Through this process,
+    /// the networks evolve to better solve the specified problem.
+    /// </para>
+    /// <para><b>For Beginners:</b> This method runs the evolutionary process for a specified number of generations.
+    /// 
+    /// The evolution process works like this:
+    /// 
+    /// 1. Evaluate each network:
+    ///    - The provided fitness function tests how well each network performs
+    ///    - Higher fitness scores mean better performance
+    /// 
+    /// 2. Sort networks by fitness:
+    ///    - The best-performing networks are prioritized for reproduction
+    /// 
+    /// 3. Create a new population:
+    ///    - Keep the very best network unchanged (called "elitism")
+    ///    - Create new networks through either:
+    ///      a) Crossover: Combining two parent networks
+    ///      b) Mutation: Copying and modifying a single parent
+    /// 
+    /// 4. Repeat for the specified number of generations
+    /// 
+    /// Each generation should produce slightly better networks as successful
+    /// traits are selected for and new beneficial mutations occur.
+    /// 
+    /// The fitness function you provide is crucial - it's what defines "good performance"
+    /// and guides the entire evolutionary process.
+    /// </para>
+    /// </remarks>
+    public void EvolvePopulation(Func<Genome<T>, T> fitnessFunction, int generations)
+    {
+        for (int gen = 0; gen < generations; gen++)
+        {
+            // Evaluate fitness
+            foreach (var genome in _population)
+            {
+                genome.Fitness = fitnessFunction(genome);
+            }
+
+            // Sort population by fitness (descending)
+            _population.Sort((a, b) =>
+            {
+                if (NumOps.GreaterThan(b.Fitness, a.Fitness)) return 1;
+                if (NumOps.GreaterThan(a.Fitness, b.Fitness)) return -1;
+                return 0;
+            });
+
+            // Create new population — issue #1392 perf: pre-size to the final
+            // capacity so the underlying array doesn't walk the 0→4→8→…
+            // capacity-doubling chain and memcpy on every grow. Population
+            // size is fixed for the lifetime of a NEAT instance.
+            var newPopulation = new List<Genome<T>>(_populationSize);
+
+            // Elitism: Keep the best individual
+            newPopulation.Add(_population[0]);
+
+            while (newPopulation.Count < _populationSize)
+            {
+                if (NumOps.LessThan(NumOps.FromDouble(_rng.NextDouble()), _crossoverRate))
+                {
+                    var parent1 = SelectParent();
+                    var parent2 = SelectParent();
+                    var child = Crossover(parent1, parent2);
+                    Mutate(child);
+                    newPopulation.Add(child);
+                }
+                else
+                {
+                    var parent = SelectParent();
+                    var child = parent.Clone();
+                    Mutate(child);
+                    newPopulation.Add(child);
+                }
+            }
+
+            _population = newPopulation;
+        }
+    }
+
+    /// <summary>
+    /// Selects a parent genome for reproduction using tournament selection.
+    /// </summary>
+    /// <returns>The selected parent genome.</returns>
+    /// <remarks>
+    /// <para>
+    /// This method implements tournament selection, a common selection method in genetic algorithms.
+    /// It randomly selects a small number of genomes from the population, then returns the one with the
+    /// highest fitness. This process favors fitter individuals while still giving less fit individuals
+    /// a chance to reproduce, maintaining genetic diversity.
+    /// </para>
+    /// <para><b>For Beginners:</b> This method selects a parent network for reproduction, favoring better-performing networks.
+    /// 
+    /// Tournament selection works like this:
+    /// 1. Randomly pick a small group of networks (3 in this case)
+    /// 2. Compare their fitness scores
+    /// 3. Select the best one from this small group
+    /// 
+    /// This approach has advantages:
+    /// - Better networks are more likely to be selected
+    /// - But even lower-performing networks have some chance
+    /// - This maintains diversity while still driving improvement
+    /// 
+    /// Think of it like a small competition where the winner gets to reproduce.
+    /// By not always selecting the absolute best network, we avoid getting
+    /// stuck in a single solution path too early.
+    /// </para>
+    /// </remarks>
+    private Genome<T> SelectParent()
+    {
+        // Tournament selection. Issue #1392 perf: the prior implementation
+        // allocated a fresh List<Genome<T>> and an OrderByDescending LINQ
+        // enumerator on every call. Across a Train run that's ~447 k allocs
+        // (149 children × 50 generations × ~30 Train calls × 2 parents per
+        // crossover). Tournament is fixed-size 3 — pick three random genomes
+        // and keep the running argmax inline. No allocations, no LINQ.
+        const int tournamentSize = 3;
+        int n = _population.Count;
+        var best = _population[_rng.Next(n)];
+        var bestFitness = best.Fitness;
+        for (int i = 1; i < tournamentSize; i++)
+        {
+            var candidate = _population[_rng.Next(n)];
+            if (NumOps.GreaterThan(candidate.Fitness, bestFitness))
+            {
+                best = candidate;
+                bestFitness = candidate.Fitness;
+            }
+        }
+
+        return best;
+    }
+
+    /// <summary>
+    /// Creates a new genome by combining genetic material from two parent genomes.
+    /// </summary>
+    /// <param name="parent1">The first parent genome.</param>
+    /// <param name="parent2">The second parent genome.</param>
+    /// <returns>A new child genome created through crossover.</returns>
+    /// <remarks>
+    /// <para>
+    /// This method implements crossover between two parent genomes to create a child genome. It combines
+    /// connection genes from both parents, with matching genes (those with the same innovation number) being
+    /// inherited from either parent. This allows NEAT to meaningfully combine networks with different topologies
+    /// by utilizing the historical markings provided by innovation numbers.
+    /// </para>
+    /// <para><b>For Beginners:</b> This method creates a new network by combining parts from two parent networks.
+    /// 
+    /// The crossover process:
+    /// 1. Creates a new empty network (the child)
+    /// 2. Looks at all connections from both parents
+    /// 3. Adds each unique connection to the child
+    /// 
+    /// The key to making this work is the innovation number:
+    /// - Each connection has a unique ID number (innovation number)
+    /// - This lets NEAT identify which connections in different networks match
+    /// - When the same connection exists in both parents, only one copy is added to the child
+    /// 
+    /// This process allows NEAT to meaningfully combine networks with different structures,
+    /// which is one of its key advantages over other evolutionary methods.
+    /// </para>
+    /// </remarks>
+    private Genome<T> Crossover(Genome<T> parent1, Genome<T> parent2)
+    {
+        // Issue #1392 perf: prior implementation used Enumerable.Concat (one
+        // enumerator alloc) and a fresh HashSet per call (rehash table alloc).
+        // Reuse the per-instance _crossoverSeen HashSet and walk both parent
+        // connection lists by index so the JIT can elide bounds checks. Child
+        // connection list is pre-sized to the upper bound (parent1.Count +
+        // parent2.Count) to skip the List capacity-doubling chain in the
+        // common case where most innovations are unique.
+        var p1 = parent1.Connections;
+        var p2 = parent2.Connections;
+        int p1Count = p1.Count;
+        int p2Count = p2.Count;
+        var child = new Genome<T>(Architecture.InputSize, Architecture.OutputSize);
+        int upperBound = p1Count + p2Count;
+        if (upperBound > 0)
+        {
+            child.Connections.Capacity = upperBound;
+        }
+
+        var seen = _crossoverSeen;
+        seen.Clear();
+        var childConnections = child.Connections;
+        for (int i = 0; i < p1Count; i++)
+        {
+            var c = p1[i];
+            if (seen.Add(c.Innovation))
+            {
+                childConnections.Add(new Connection<T>(c.FromNode, c.ToNode, c.Weight, c.IsEnabled, c.Innovation));
+            }
+        }
+        for (int i = 0; i < p2Count; i++)
+        {
+            var c = p2[i];
+            if (seen.Add(c.Innovation))
+            {
+                childConnections.Add(new Connection<T>(c.FromNode, c.ToNode, c.Weight, c.IsEnabled, c.Innovation));
+            }
+        }
+
+        return child;
+    }
+
+    /// <summary>
+    /// Applies random mutations to a genome based on the mutation rate.
+    /// </summary>
+    /// <param name="genome">The genome to mutate.</param>
+    /// <remarks>
+    /// <para>
+    /// This method applies various types of mutations to a genome with probability based on the mutation rate.
+    /// Possible mutations include adding a new node (by splitting an existing connection), adding a new connection
+    /// between existing nodes, and modifying connection weights. These mutations allow NEAT to explore different
+    /// network structures and parameters to find better solutions.
+    /// </para>
+    /// <para><b>For Beginners:</b> This method introduces random changes to a network to explore new possibilities.
+    /// 
+    /// NEAT uses three main types of mutations:
+    /// 
+    /// 1. Add Node Mutation:
+    ///    - Takes an existing connection and splits it by adding a new neuron in the middle
+    ///    - The original connection is disabled
+    ///    - Two new connections are created (from source to new node, and from new node to target)
+    ///    - This allows the network to create more complex behaviors
+    /// 
+    /// 2. Add Connection Mutation:
+    ///    - Creates a new connection between two previously unconnected neurons
+    ///    - This allows the network to create new paths for information flow
+    /// 
+    /// 3. Weight Mutation:
+    ///    - Changes the weights of existing connections
+    ///    - This fine-tunes the network behavior without changing its structure
+    /// 
+    /// Each type of mutation happens randomly based on the mutation rate.
+    /// These mutations are how NEAT explores different network structures
+    /// and gradually adds complexity where it's beneficial.
+    /// </para>
+    /// </remarks>
+    private void Mutate(Genome<T> genome)
+    {
+        // Issue #1392 perf: prior implementation used LINQ Max+Any on every
+        // call, allocating a Func delegate + an enumerator each time. Walk
+        // Connections by index. Add-node case derives the new node id from
+        // an inline scan over (FromNode, ToNode) since the existing
+        // CachedMaxNodeId on Genome covers max(referenced node id,
+        // biasNodeId), which already gives us "first free node id - 1".
+        var connections = genome.Connections;
+        int count = connections.Count;
+
+        if (NumOps.LessThan(NumOps.FromDouble(_rng.NextDouble()), _mutationRate) && count > 0)
+        {
+            // Add new node
+            var connection = connections[_rng.Next(count)];
+
+            // First-free-node-id scan including the bias node — without the
+            // explicit biasNodeId floor below, the first add-node mutation
+            // on an initial genome (where max(FromNode, ToNode) =
+            // InputSize + OutputSize − 1) would produce newNodeId =
+            // InputSize + OutputSize, which collides with biasNodeId.
+            // ActivateGenome writes activations[biasNodeId] = NumOps.One
+            // BEFORE the connection sweep, so any connection accumulating
+            // into this hidden slot would corrupt the bias value — and
+            // every connection targeting it would also read a polluted
+            // pre-activation from the same slot.
+            int biasNodeId = Architecture.InputSize + Architecture.OutputSize;
+            int maxNodeId = biasNodeId;
+            for (int i = 0; i < count; i++)
+            {
+                var c = connections[i];
+                int hi = c.FromNode > c.ToNode ? c.FromNode : c.ToNode;
+                if (hi > maxNodeId) maxNodeId = hi;
+            }
+            int newNodeId = maxNodeId + 1;
+
+            genome.DisableConnection(connection.Innovation);
+            genome.AddConnection(connection.FromNode, newNodeId, NumOps.One, true, _innovationNumber++);
+            genome.AddConnection(newNodeId, connection.ToNode, connection.Weight, true, _innovationNumber++);
+
+            // List grew under us; reload local references for downstream loops
+            connections = genome.Connections;
+            count = connections.Count;
+        }
+
+        if (NumOps.LessThan(NumOps.FromDouble(_rng.NextDouble()), _mutationRate))
+        {
+            // Add new connection
+            int fromNode = _rng.Next(Architecture.InputSize + Architecture.OutputSize);
+            int toNode = _rng.Next(Architecture.InputSize, Architecture.InputSize + Architecture.OutputSize);
+            bool exists = false;
+            for (int i = 0; i < count; i++)
+            {
+                var c = connections[i];
+                if (c.FromNode == fromNode && c.ToNode == toNode)
+                {
+                    exists = true;
+                    break;
+                }
+            }
+            if (!exists)
+            {
+                genome.AddConnection(fromNode, toNode, RandomWeight(), true, _innovationNumber++);
+                connections = genome.Connections;
+                count = connections.Count;
+            }
+        }
+
+        // Mutate weights — index loop so JIT can elide the List<T>.Enumerator
+        // bounds check overhead the foreach pays per step.
+        T perturbPower = NumOps.FromDouble(WeightPerturbPower);
+        T replaceRate = NumOps.FromDouble(WeightReplaceRate);
+        T weightCap = NumOps.FromDouble(WeightCap);
+        T negWeightCap = NumOps.FromDouble(-WeightCap);
+        for (int i = 0; i < count; i++)
+        {
+            if (NumOps.LessThan(NumOps.FromDouble(_rng.NextDouble()), _mutationRate))
+            {
+                var conn = connections[i];
+                // Faithful NEAT weight mutation (Stanley & Miikkulainen 2002 §3.1; the
+                // same scheme as NEAT-Python's weight_mutate_power / weight_replace_rate /
+                // weight_max_value): with the per-connection mutation probability, EITHER
+                // replace the weight with a fresh random value (small replace rate) OR
+                // nudge it by a SMALL perturbation, then CLAMP to a bounded range. The
+                // previous `weight += RandomWeight()` added a full uniform[-1,1] every
+                // time — an UNBOUNDED RANDOM WALK whose variance grows with the number of
+                // perturbations, so weight magnitudes drift without limit across
+                // generations. A small perturbation power plus a hard clamp keep the
+                // weights bounded, matching the paper's bounded-weight evolutionary search.
+                if (NumOps.LessThan(NumOps.FromDouble(_rng.NextDouble()), replaceRate))
+                {
+                    conn.Weight = RandomWeight();
+                }
+                else
+                {
+                    T perturbation = NumOps.Multiply(
+                        NumOps.FromDouble(_rng.NextDouble() * 2 - 1), perturbPower);
+                    conn.Weight = NumOps.Add(conn.Weight, perturbation);
+                }
+                if (NumOps.GreaterThan(conn.Weight, weightCap)) conn.Weight = weightCap;
+                else if (NumOps.LessThan(conn.Weight, negWeightCap)) conn.Weight = negWeightCap;
+            }
+        }
+    }
+
+    /// <summary>
+    /// Generates a random weight value for neural network connections.
+    /// </summary>
+    /// <returns>A random weight value between -1 and 1.</returns>
+    /// <remarks>
+    /// <para>
+    /// This method generates a random weight value between -1 and 1 for use in neural network connections.
+    /// These random weights provide the initial diversity for the evolutionary process and are also used
+    /// during weight mutation to introduce changes to connection strengths.
+    /// </para>
+    /// <para><b>For Beginners:</b> This method creates a random connection weight value between -1 and 1.
+    /// 
+    /// In neural networks:
+    /// - Connections have weight values that determine their strength and effect
+    /// - Positive weights are excitatory (they increase activation)
+    /// - Negative weights are inhibitory (they decrease activation)
+    /// 
+    /// This method is used:
+    /// - When creating initial networks with random weights
+    /// - During mutation to change existing weights
+    /// 
+    /// Starting with random weights gives the evolutionary process diverse
+    /// starting points to work with, increasing the chances of finding good solutions.
+    /// </para>
+    /// </remarks>
+    private T RandomWeight()
+    {
+        return NumOps.FromDouble(_rng.NextDouble() * 2 - 1);
+    }
+
+    // Replaced by the declared parameter source below. Removed under AIDN082.
+
+    /// <summary>
+    /// Predicts output values for input data using the best genome in the population.
+    /// </summary>
+    /// <param name="input">The input tensor to process.</param>
+    /// <returns>The output tensor after processing.</returns>
+    /// <remarks>
+    /// <para>
+    /// This method uses the highest-fitness genome in the population to make predictions. It activates the 
+    /// genome's neural network with the provided input data and returns the resulting output activations.
+    /// For batch inputs, it processes each sample independently.
+    /// </para>
+    /// <para><b>For Beginners:</b> This method uses the best evolved network to make predictions.
+    /// 
+    /// When making a prediction:
+    /// - NEAT uses the highest-performing network from the population
+    /// - The input data is fed into this network
+    /// - The network processes the data through its evolved structure
+    /// - The resulting output values are returned
+    /// 
+    /// Unlike traditional neural networks with fixed structures, the network used here
+    /// has evolved its structure through the evolutionary process, potentially developing
+    /// complex and unique connection patterns that solve the problem effectively.
+    /// </para>
+    /// </remarks>
+    protected override Tensor<T> PredictCore(Tensor<T> input)
+    {
+        // GPU-resident optimization: use TryForwardGpuOptimized for speedup
+        if (TryForwardGpuOptimized(input, out var gpuResult))
+            return gpuResult;
+
+        // Get the best genome (the one with highest fitness)
+        var bestGenome = GetBestGenome();
+
+        // Treat ANY rank-2 input as batched, even when the batch size is 1.
+        // Returning rank-1 for single-sample input was a real bug —
+        // NEAT.Train downstream reads `expectedOutput.Shape[1]`, which throws
+        // IndexOutOfRangeException for rank-1 targets, and EffectiveOutputShape
+        // cached the wrong rank for the test's warm-up Predict path. Per the
+        // implicit `(batch, features)` contract used by every other neural
+        // network in the codebase, output rank should match input rank.
+        //
+        // Validate rank explicitly: NEAT genomes activate over a flat feature
+        // vector, so anything beyond rank-2 (e.g., a stray rank-3 image
+        // tensor or rank-4 video) cannot be unambiguously interpreted as
+        // batched-features and would mis-index in the loop below. Fail
+        // fast at the boundary instead of producing garbage outputs.
+        if (input.Shape.Length < 1 || input.Shape.Length > 2)
+        {
+            throw new ArgumentException(
+                $"NEAT.Predict expects rank-1 [features] or rank-2 [batch, features]; " +
+                $"got rank {input.Shape.Length} (shape [{string.Join(",", input.Shape)}]).",
+                nameof(input));
+        }
+        bool isBatch = input.Shape.Length == 2;
+
+        if (isBatch)
+        {
+            // Process each input in the batch
+            int batchSize = input.Shape[0];
+            int featureSize = input.Shape[1];
+
+            // Create output tensor with correct shape
+            var output = TensorAllocator.Rent<T>(new int[] { batchSize, Architecture.OutputSize });
+
+            // Process each sample
+            for (int b = 0; b < batchSize; b++)
+            {
+                // Extract individual input
+                var sampleInput = new Vector<T>(featureSize);
+                for (int f = 0; f < featureSize; f++)
+                {
+                    sampleInput[f] = input[b, f];
+                }
+
+                // Get activations for this sample
+                var activations = ActivateGenome(bestGenome, sampleInput);
+
+                // Store output activations
+                for (int o = 0; o < Architecture.OutputSize; o++)
+                {
+                    output[b, o] = activations[Architecture.InputSize + o];
+                }
+            }
+
+            return output;
+        }
+        else
+        {
+            // Single input
+            // Convert input tensor to vector
+            var inputVector = input.ToVector();
+
+            // Get activations
+            var activations = ActivateGenome(bestGenome, inputVector);
+
+            // Create output tensor
+            var output = TensorAllocator.Rent<T>(new int[] { Architecture.OutputSize });
+            for (int i = 0; i < Architecture.OutputSize; i++)
+            {
+                output[i] = activations[Architecture.InputSize + i];
+            }
+
+            return output;
+        }
+    }
+
+    /// <summary>
+    /// Gets the genome with the highest fitness from the population.
+    /// </summary>
+    /// <returns>The best genome in the population.</returns>
+    /// <remarks>
+    /// <para>
+    /// This method sorts the population by fitness in descending order and returns the genome
+    /// with the highest fitness score. If the population hasn't been evaluated yet, it assigns
+    /// a default fitness value to each genome.
+    /// </para>
+    /// <para><b>For Beginners:</b> This finds the top-performing network from the population.
+    /// 
+    /// This method:
+    /// - Sorts all networks based on their fitness scores (performance)
+    /// - Returns the network with the highest score
+    /// - If networks haven't been evaluated yet, it assigns a neutral score
+    /// 
+    /// The returned network is the "champion" of the population - the one that
+    /// has evolved to best solve the problem you're working on.
+    /// </para>
+    /// </remarks>
+    private Genome<T> GetBestGenome()
+    {
+        // Check if any genomes have fitness set
+        bool anyFitnessSet = _population.Any(g => !NumOps.Equals(g.Fitness, NumOps.Zero));
+
+        // If no fitness values are set, assign default
+        if (!anyFitnessSet)
+        {
+            foreach (var genome in _population)
+            {
+                genome.Fitness = NumOps.One; // Neutral fitness
+            }
+        }
+
+        // Find the genome with highest fitness (O(n) instead of O(n log n) sort)
+        var best = _population[0];
+        for (int i = 1; i < _population.Count; i++)
+        {
+            if (NumOps.GreaterThan(_population[i].Fitness, best.Fitness))
+            {
+                best = _population[i];
+            }
+        }
+
+        return best;
+    }
+
+    /// <summary>
+    /// Activates a genome's neural network with the given input.
+    /// </summary>
+    /// <param name="genome">The genome to activate.</param>
+    /// <param name="input">The input values.</param>
+    /// <returns>A dictionary mapping node IDs to their activation values.</returns>
+    /// <remarks>
+    /// <para>
+    /// This method performs a forward pass through the genome's neural network. It initializes
+    /// input nodes with the provided values, processes connections in a topologically sorted order,
+    /// and applies activation functions to produce the final node activations.
+    /// </para>
+    /// <para><b>For Beginners:</b> This runs input data through the evolved neural network.
+    /// 
+    /// The activation process:
+    /// 1. Sets the input nodes to the provided input values
+    /// 2. Processes connections in the correct order (feed-forward)
+    /// 3. Applies the activation function to each neuron
+    /// 4. Returns all neuron activation values
+    /// 
+    /// This is how a NEAT network processes information, similar to a traditional
+    /// neural network but with the specific connection structure that evolved
+    /// during the evolutionary process.
+    /// </para>
+    /// </remarks>
+    private T[] ActivateGenome(Genome<T> genome, Vector<T> input)
+    {
+        // Issue #1392 perf: switched from Dictionary<int, T> to flat T[] indexed
+        // by node id. NEAT node ids are dense small integers (inputs 0..InputSize-1,
+        // outputs InputSize..InputSize+OutputSize-1, bias = InputSize+OutputSize,
+        // hidden > biasNodeId). The Dictionary form added 2-3 heap allocations per
+        // call (Dictionary instance + internal buckets[] + entries[]) plus hash-
+        // compute + bucket-walk on every node access. With a flat array each
+        // activation is a single contiguous-memory store/load.
+        //
+        // Buffer size = max(node id observed in genome's connections, biasNodeId) + 1.
+        // Indices not referenced by any connection stay at default(T) and are
+        // never queried by callers, so over-provisioning is benign.
+
+        int inputSize = Architecture.InputSize;
+        int outputSize = Architecture.OutputSize;
+        int biasNodeId = inputSize + outputSize;
+
+        // Sort connections topologically for proper feed-forward activation.
+        // Cached on the genome — weight-only mutations (the dominant case across
+        // the 50 internal generations per Train call) keep the topology
+        // signature unchanged, so the cache hits and skips the O(E²) sort.
+        var sortedConnections = GetOrBuildSortedConnections(genome);
+
+        int maxNodeId = GetOrBuildMaxNodeId(genome, biasNodeId);
+        var activations = new T[maxNodeId + 1];
+
+        // Set input nodes
+        for (int i = 0; i < inputSize; i++)
+        {
+            activations[i] = input[i];
+        }
+
+        // Set bias node
+        activations[biasNodeId] = NumOps.One;
+
+        // Output nodes + every other slot are pre-zeroed by `new T[]`
+        // (default(T) = NumOps.Zero for built-in numeric types) — no
+        // explicit init loop needed, no per-connection ContainsKey gymnastics
+        // since every FromNode/ToNode id is in range by construction of maxNodeId.
+
+        // Process connections in topological order.
+        foreach (var connection in sortedConnections)
+        {
+            if (!connection.IsEnabled) continue;
+            T weightedInput = NumOps.Multiply(activations[connection.FromNode], connection.Weight);
+            activations[connection.ToNode] = NumOps.Add(activations[connection.ToNode], weightedInput);
+        }
+
+        // Apply activation function to all non-input nodes the genome actually
+        // references (cached on the genome alongside the sort + max-node-id).
+        var nonInputNodes = GetOrBuildReferencedNonInputNodeIds(genome, inputSize);
+        foreach (var nodeId in nonInputNodes)
+        {
+            activations[nodeId] = ApplySigmoid(activations[nodeId]);
+        }
+
+        return activations;
+    }
+
+    /// <summary>
+    /// Issue #1392 perf helper: returns the cached topologically-sorted
+    /// connection list for <paramref name="genome"/>, rebuilding only when
+    /// the topology signature changed since the last call.
+    /// </summary>
+    private List<Connection<T>> GetOrBuildSortedConnections(Genome<T> genome)
+    {
+        int count = genome.Connections.Count;
+        ulong signature = ComputeTopologySignature(genome.Connections);
+        if (genome.CachedSortedConnections != null
+            && genome.CachedTopologySignatureCount == count
+            && genome.CachedTopologySignatureMask == signature)
+        {
+            return genome.CachedSortedConnections;
+        }
+        var sorted = SortConnectionsTopologically(genome);
+        genome.CachedSortedConnections = sorted;
+        genome.CachedTopologySignatureCount = count;
+        genome.CachedTopologySignatureMask = signature;
+        // Invalidate the dependent caches — their content depends on the
+        // connection set, so a topology change forces a rebuild on the next
+        // call.
+        genome.CachedNonInputNodeIds = null;
+        genome.CachedMaxNodeId = -1;
+        return sorted;
+    }
+
+    /// <summary>
+    /// Issue #1392 perf helper: returns max(FromNode, ToNode, biasNodeId)
+    /// across the genome's enabled connections. Cached on the genome so the
+    /// per-call O(E) scan only runs after topology mutations. Used to size
+    /// <see cref="ActivateGenome"/>'s flat activation buffer.
+    /// </summary>
+    private static int GetOrBuildMaxNodeId(Genome<T> genome, int biasNodeId)
+    {
+        if (genome.CachedMaxNodeId >= 0)
+        {
+            return genome.CachedMaxNodeId;
+        }
+        int max = biasNodeId;
+        var conns = genome.Connections;
+        for (int i = 0; i < conns.Count; i++)
+        {
+            var c = conns[i];
+            if (c.FromNode > max) max = c.FromNode;
+            if (c.ToNode > max) max = c.ToNode;
+        }
+        genome.CachedMaxNodeId = max;
+        return max;
+    }
+
+    /// <summary>
+    /// Issue #1392 perf helper: caches the list of node IDs &gt;= InputSize that
+    /// the sigmoid sweep should touch. Built directly from the connection list
+    /// (any FromNode/ToNode &gt;= InputSize that the genome references) so we
+    /// don't need to materialize a Dictionary first. Invalidated alongside
+    /// <see cref="GetOrBuildSortedConnections"/>.
+    /// </summary>
+    private List<int> GetOrBuildReferencedNonInputNodeIds(Genome<T> genome, int inputSize)
+    {
+        if (genome.CachedNonInputNodeIds != null)
+        {
+            return genome.CachedNonInputNodeIds;
+        }
+        var seen = new HashSet<int>();
+        var list = new List<int>();
+        foreach (var c in genome.Connections)
+        {
+            if (!c.IsEnabled) continue;
+            if (c.FromNode >= inputSize && seen.Add(c.FromNode)) list.Add(c.FromNode);
+            if (c.ToNode >= inputSize && seen.Add(c.ToNode)) list.Add(c.ToNode);
+        }
+        // Also include output nodes (always activated even if no connection
+        // wrote to them, because ActivateGenome zero-initializes the slot
+        // and the sigmoid should still run on the zero value for caller
+        // consistency with the pre-refactor Dictionary behavior).
+        int outputSize = Architecture.OutputSize;
+        for (int i = 0; i < outputSize; i++)
+        {
+            int outNode = inputSize + i;
+            if (seen.Add(outNode)) list.Add(outNode);
+        }
+        // Bias node: the pre-refactor Dictionary implementation set
+        // activations[InputSize+OutputSize] = NumOps.One BEFORE the sigmoid
+        // sweep and then iterated `activations.Keys.Where(k >= InputSize)`,
+        // so the bias slot was overwritten with Sigmoid(1) = ~0.731 by the
+        // end. Preserve that exact behavior here so callers that read the
+        // bias slot from the returned array see the same value they saw
+        // before this refactor.
+        int biasNodeId = inputSize + outputSize;
+        if (seen.Add(biasNodeId)) list.Add(biasNodeId);
+        genome.CachedNonInputNodeIds = list;
+        return list;
+    }
+
+    /// <summary>
+    /// O(N) FNV-1a hash over every connection slot's <c>(FromNode,
+    /// ToNode, IsEnabled)</c> tuple in iteration order. Used together
+    /// with <c>Connections.Count</c> as the cache key for the
+    /// topologically-sorted connection list on <see cref="Genome{T}"/>.
+    /// </summary>
+    /// <remarks>
+    /// Replaces an earlier bitmask-of-enabled-flags signature that
+    /// missed two real edit patterns and let stale cached sorts /
+    /// non-input-node sets / max-node-id leak back to callers:
+    /// <list type="bullet">
+    /// <item>Same-count rewires — swapping a connection's <c>FromNode</c>
+    /// or <c>ToNode</c> for a different node without flipping any
+    /// <c>IsEnabled</c> bit preserved both <c>Count</c> and the bitmask
+    /// → cache hit on the WRONG topology.</item>
+    /// <item>&gt;64-connection aliasing — the bitmask's <c>(i &amp; 63)</c>
+    /// wrap collapsed slots 0/64/128/… onto the same bit, so a flip at
+    /// slot 64 could XOR-cancel an earlier flip at slot 0 and leave the
+    /// mask unchanged.</item>
+    /// </list>
+    /// Weight is deliberately excluded from the signature — weight-only
+    /// mutations are the dominant case across the 50 internal
+    /// generations per public <c>Train</c> call, and we WANT the cached
+    /// topological sort to survive them.
+    /// </remarks>
+    private static ulong ComputeTopologySignature(List<Connection<T>> connections)
+    {
+        // FNV-1a 64-bit hash of every connection slot's
+        // (FromNode, ToNode, IsEnabled) tuple in iteration order. The
+        // earlier ComputeEnabledBitmask only hashed the enabled flags and
+        // would alias same-count rewires/replacements (e.g. swapping a
+        // connection's FromNode preserved both count and enabled-bitmask
+        // → stale cache → wrong activation). Hashing the full tuple
+        // also avoids the >64-connection aliasing the bitmask suffered
+        // once the wrap-around in `(i & 63)` started folding bits.
+        // Connection.Weight is intentionally excluded — weight-only
+        // mutations are the dominant case across the 50 internal
+        // generations per Train call and we WANT the cached topological
+        // sort to survive them.
+        const ulong FnvOffsetBasis = 14695981039346656037UL;
+        const ulong FnvPrime = 1099511628211UL;
+        ulong hash = FnvOffsetBasis;
+        int n = connections.Count;
+        for (int i = 0; i < n; i++)
+        {
+            var c = connections[i];
+            hash ^= (ulong)(uint)c.FromNode;
+            hash *= FnvPrime;
+            hash ^= (ulong)(uint)c.ToNode;
+            hash *= FnvPrime;
+            hash ^= c.IsEnabled ? 1UL : 0UL;
+            hash *= FnvPrime;
+        }
+        return hash;
+    }
+
+    /// <summary>
+    /// Sorts connections in topological order for proper feed-forward activation.
+    /// </summary>
+    /// <param name="genome">The genome containing connections to sort.</param>
+    /// <returns>A list of connections sorted in topological order.</returns>
+    /// <remarks>
+    /// <para>
+    /// This method sorts the connections in a genome to ensure they are processed in the correct
+    /// order during network activation. It creates layers of nodes based on their depth in the network
+    /// and sorts connections accordingly.
+    /// </para>
+    /// <para><b>For Beginners:</b> This determines the correct order to process connections.
+    /// 
+    /// In a neural network:
+    /// - Information flows from input to output
+    /// - Connections must be processed in the correct order
+    /// - Inputs need to be calculated before they can be used
+    /// 
+    /// This method:
+    /// - Figures out which neurons depend on which other neurons
+    /// - Sorts connections so inputs are always processed before outputs
+    /// - Ensures the network processes information in a feed-forward manner
+    /// 
+    /// This is especially important in NEAT since the connection structure
+    /// evolves and isn't fixed in predefined layers.
+    /// </para>
+    /// </remarks>
+    private List<Connection<T>> SortConnectionsTopologically(Genome<T> genome)
+    {
+        // Create a dictionary to track nodes that feed into each node
+        var incomingConnections = new Dictionary<int, List<Connection<T>>>();
+
+        // Create a set of all nodes
+        var allNodes = new HashSet<int>();
+
+        // Populate incoming connections and collect all nodes
+        foreach (var conn in genome.Connections)
+        {
+            if (!conn.IsEnabled) continue;
+
+            allNodes.Add(conn.FromNode);
+            allNodes.Add(conn.ToNode);
+
+            if (!incomingConnections.ContainsKey(conn.ToNode))
+            {
+                incomingConnections[conn.ToNode] = new List<Connection<T>>();
+            }
+
+            incomingConnections[conn.ToNode].Add(conn);
+        }
+
+        // Create a dictionary to track processed nodes
+        var processedNodes = new Dictionary<int, bool>();
+
+        // Input nodes don't have incoming connections and are already processed
+        for (int i = 0; i < Architecture.InputSize; i++)
+        {
+            processedNodes[i] = true;
+        }
+
+        // Sort connections
+        var sortedConnections = new List<Connection<T>>();
+        var sortedSet = new HashSet<int>(); // Track sorted connections by innovation for O(1) lookup
+
+        // Pre-filter enabled connections to avoid repeated enumeration
+        var enabledConnections = genome.Connections.Where(c => c.IsEnabled).ToList();
+        int enabledCount = enabledConnections.Count;
+
+        // Process until all connections are sorted
+        while (sortedConnections.Count < enabledCount)
+        {
+            bool addedConnection = false;
+
+            // Check each enabled connection
+            foreach (var conn in enabledConnections)
+            {
+                // Skip if already in sorted list (O(1) with HashSet)
+                if (sortedSet.Contains(conn.Innovation)) continue;
+
+                // Check if from node is processed
+                if (processedNodes.ContainsKey(conn.FromNode) && processedNodes[conn.FromNode])
+                {
+                    // Add connection to sorted list
+                    sortedConnections.Add(conn);
+                    sortedSet.Add(conn.Innovation);
+
+                    // Mark to node as processed
+                    processedNodes[conn.ToNode] = true;
+
+                    addedConnection = true;
+                }
+            }
+
+            // If no connections were added in this iteration, we might have a cycle
+            if (!addedConnection) break;
+        }
+
+        return sortedConnections;
+    }
+
+    /// <summary>
+    /// Applies the sigmoid activation function to a value.
+    /// </summary>
+    /// <param name="value">The input value.</param>
+    /// <returns>The sigmoid of the input.</returns>
+    /// <remarks>
+    /// <para>
+    /// This method applies the sigmoid activation function (1 / (1 + e^-x)) to the input value.
+    /// Sigmoid squashes input values to the range (0, 1), which is useful for producing
+    /// normalized activation values in the network.
+    /// </para>
+    /// <para><b>For Beginners:</b> This transforms neuron values to a value between 0 and 1.
+    /// 
+    /// The sigmoid function:
+    /// - Takes any input value (positive or negative)
+    /// - Transforms it to a value between 0 and 1
+    /// - Creates a smooth, non-linear response
+    /// 
+    /// This non-linearity is important because:
+    /// - It allows the network to learn complex patterns
+    /// - It prevents the network from just computing weighted sums
+    /// - It gives neurons an "activation threshold" like biological neurons
+    /// 
+    /// Sigmoid is one of several possible activation functions used in neural networks.
+    /// </para>
+    /// </remarks>
+    private T ApplySigmoid(T value)
+    {
+        // Sigmoid function: 1 / (1 + e^-x)
+        T negValue = NumOps.Negate(value);
+        T expNeg = NumOps.Exp(negValue);
+        T denominator = NumOps.Add(NumOps.One, expNeg);
+
+        return NumOps.Divide(NumOps.One, denominator);
+    }
+
+    /// <summary>
+    /// Trains the NEAT system using supervised learning data.
+    /// </summary>
+    /// <param name="input">The input training data tensor.</param>
+    /// <param name="expectedOutput">The expected output tensor.</param>
+    /// <remarks>
+    /// <para>
+    /// This method adapts NEAT to work with traditional supervised learning data. It creates a fitness
+    /// function based on the mean squared error between network predictions and expected outputs,
+    /// then evolves the population to minimize this error. This allows NEAT to be used in scenarios
+    /// where traditional supervised learning would be applied.
+    /// </para>
+    /// <para><b>For Beginners:</b> This teaches the NEAT system using example input-output pairs.
+    /// 
+    /// Unlike traditional neural networks that use gradient descent, NEAT learns through evolution:
+    /// 1. It creates a fitness function based on prediction error
+    ///    - Networks that make more accurate predictions get higher fitness scores
+    ///    - Networks with lower error perform better
+    /// 
+    /// 2. It evolves the population for several generations
+    ///    - Better networks reproduce more often
+    ///    - Genetic operators (crossover and mutation) create diversity
+    ///    - The population gradually improves at the task
+    /// 
+    /// This allows NEAT to work with supervised learning data while using its
+    /// evolutionary approach to discover effective network structures.
+    /// </para>
+    /// </remarks>
+    public override void Train(Tensor<T> input, Tensor<T> expectedOutput)
+    {
+        // Check if input and output have compatible batch sizes
+        if (input.Shape[0] != expectedOutput.Shape[0])
+        {
+            throw new ArgumentException("Input and expected output must have the same batch size");
+        }
+
+        int batchSize = input.Shape[0];
+
+        // Convert input and expected output to a format suitable for the fitness function
+        var trainingData = ExtractTrainingData(input, expectedOutput);
+
+        // Create a fitness function that measures how well each genome performs on the training data
+        T fitnessFunction(Genome<T> genome)
+        {
+            T totalError = NumOps.Zero;
+
+            // Calculate error for each training example
+            foreach (var (sampleInput, sampleExpected) in trainingData)
+            {
+                // Get actual output from genome
+                var activations = ActivateGenome(genome, sampleInput);
+
+                // Extract predicted values into a vector
+                var predictedVector = new Vector<T>(Architecture.OutputSize);
+                for (int i = 0; i < Architecture.OutputSize; i++)
+                {
+                    int outputNodeId = Architecture.InputSize + i;
+                    predictedVector[i] = activations[outputNodeId];
+                }
+
+                // Use the loss function to calculate error for this sample
+                T sampleLoss = LossFunction.CalculateLoss(predictedVector, sampleExpected);
+                totalError = NumOps.Add(totalError, sampleLoss);
+            }
+
+            // Calculate average loss across all samples
+            T averageLoss = NumOps.Divide(totalError, NumOps.FromDouble(batchSize));
+
+            // Issue #1392 perf fix: removed the inline LastLoss assignment that
+            // previously fired here gated on `genome == _population.OrderByDescending
+            // (g => g.Fitness).FirstOrDefault()`. That branch had two problems:
+            //
+            // 1. Perf: it ran `OrderByDescending` on the entire population for
+            //    EVERY genome's fitness eval, giving O(N²) work per generation
+            //    (N=150 default → 22,500 fitness-compare + allocations per
+            //    generation × 50 generations × 30 Train calls = ~34M ops just
+            //    for picking the best, before any actual genome activation).
+            //    On a tiny tabular input this dominated the per-Train wall time
+            //    and pushed Training_ShouldReduceLoss past the 120 s CI budget.
+            //
+            // 2. Correctness: the reference-equality probe `genome == best`
+            //    matched the PRE-EVALUATION best (Fitness values from the
+            //    previous generation) which is essentially random for the
+            //    current generation. The post-evolution recompute below
+            //    (lines 1130+) does the work properly by re-evaluating the
+            //    actual post-generation best genome, so the inline
+            //    LastLoss assignment was already dead code.
+            //
+            // Net: deleting the branch is pure speedup with no behavior change.
+
+            // Convert loss to fitness (higher is better, so invert loss)
+            // Add small constant to avoid division by zero
+            T fitness = NumOps.Divide(NumOps.One, NumOps.Add(averageLoss, NumOps.FromDouble(0.01)));
+
+            return fitness;
+        }
+
+        // Evolve the population for multiple generations
+        // The number of generations can be adjusted based on the problem complexity
+        int generations = 50;
+        EvolvePopulation(fitnessFunction, generations);
+
+        // Re-evaluate the post-evolution best genome and record its loss
+        // as LastLoss. The fitness-function-side LastLoss assignment uses
+        // a reference-equality probe against the pre-generation best,
+        // which silently misses the post-evolution best when the
+        // population reshuffles (every Train call after the first hit
+        // this — LastLoss stayed at its pre-Train value or NumOps.Zero,
+        // producing the misleading "step 1=0.000000, step N=0.000000"
+        // failure on LossStrictlyDecreasesOnMemorizationTask). Recompute
+        // here so the public Train contract surfaces a real per-call loss.
+        var postBest = GetBestGenome();
+        if (postBest.Connections.Count > 0 && trainingData.Count > 0)
+        {
+            T totalErr = NumOps.Zero;
+            foreach (var (sampleInput, sampleExpected) in trainingData)
+            {
+                var act = ActivateGenome(postBest, sampleInput);
+                var pred = new Vector<T>(Architecture.OutputSize);
+                for (int i = 0; i < Architecture.OutputSize; i++)
+                {
+                    int outputNodeId = Architecture.InputSize + i;
+                    // ActivateGenome's flat array is sized to max(node id,
+                    // biasNodeId); output node ids are guaranteed in range
+                    // since biasNodeId = InputSize + OutputSize > any output id.
+                    pred[i] = act[outputNodeId];
+                }
+                totalErr = NumOps.Add(totalErr, LossFunction.CalculateLoss(pred, sampleExpected));
+            }
+            LastLoss = NumOps.Divide(totalErr, NumOps.FromDouble(trainingData.Count));
+        }
+    }
+
+    /// <summary>
+    /// Extracts training data pairs from input and expected output tensors.
+    /// </summary>
+    /// <param name="input">The input training data tensor.</param>
+    /// <param name="expectedOutput">The expected output tensor.</param>
+    /// <returns>A list of input-output vector pairs.</returns>
+    /// <remarks>
+    /// <para>
+    /// This method converts tensor-based training data into a list of vector pairs that can be
+    /// more easily processed by the NEAT algorithm. Each pair consists of an input vector and
+    /// its corresponding expected output vector.
+    /// </para>
+    /// <para><b>For Beginners:</b> This converts tensor-based training data into a format NEAT can use.
+    /// 
+    /// The conversion process:
+    /// 1. Takes the tensor-based input and output data
+    /// 2. Extracts each individual training example
+    /// 3. Creates pairs of (input, expected output) vectors
+    /// 4. Returns a list of these pairs for the fitness function to use
+    /// 
+    /// This preprocessing step allows NEAT to work with the same types of
+    /// training data used by traditional neural networks, making it more
+    /// versatile for different applications.
+    /// </para>
+    /// </remarks>
+    private List<(Vector<T> input, Vector<T> expected)> ExtractTrainingData(Tensor<T> input, Tensor<T> expectedOutput)
+    {
+        int batchSize = input.Shape[0];
+        int inputFeatures = input.Shape[1];
+        int outputFeatures = expectedOutput.Shape[1];
+
+        var trainingData = new List<(Vector<T> input, Vector<T> expected)>(batchSize);
+
+        for (int b = 0; b < batchSize; b++)
+        {
+            // Extract input vector
+            var inputVector = new Vector<T>(inputFeatures);
+            for (int i = 0; i < inputFeatures; i++)
+            {
+                inputVector[i] = input[b, i];
+            }
+
+            // Extract expected output vector
+            var expectedVector = new Vector<T>(outputFeatures);
+            for (int o = 0; o < outputFeatures; o++)
+            {
+                expectedVector[o] = expectedOutput[b, o];
+            }
+
+            // Add pair to training data
+            trainingData.Add((inputVector, expectedVector));
+        }
+
+        return trainingData;
+    }
+
+    /// <summary>
+    /// Gets metadata about the NEAT model.
+    /// </summary>
+    /// <returns>A ModelMetaData object containing information about the NEAT model.</returns>
+    /// <remarks>
+    /// <para>
+    /// This method returns comprehensive metadata about the NEAT model, including its architecture,
+    /// evolutionary parameters, and population statistics. This information is useful for model
+    /// management, tracking experiments, and reporting results.
+    /// </para>
+    /// <para><b>For Beginners:</b> This provides detailed information about your NEAT system.
+    /// 
+    /// The metadata includes:
+    /// - What this model is and what it does
+    /// - Population size and evolutionary parameters
+    /// - Statistics about the current population
+    /// - Information about the best-performing network
+    /// 
+    /// This information is useful for:
+    /// - Tracking your experiments
+    /// - Comparing different NEAT runs
+    /// - Documenting your work
+    /// - Understanding the evolved solution
+    /// </para>
+    /// </remarks>
+    public override ModelMetadata<T> GetModelMetadata()
+    {
+        // Get the best genome
+        var bestGenome = GetBestGenome();
+
+        // Count average number of connections and nodes in the population
+        double avgConnections = _population.Average(g => g.Connections.Count);
+        int maxConnections = _population.Max(g => g.Connections.Count);
+
+        // Count nodes by finding the highest node ID in each genome
+        var nodeCounts = _population.Select(g =>
+            g.Connections.Any() ?
+                g.Connections.Max(c => Math.Max(c.FromNode, c.ToNode)) + 1 :
+                Architecture.InputSize + Architecture.OutputSize
+        );
+        double avgNodes = nodeCounts.Average();
+        int maxNodes = nodeCounts.Max();
+
+        return new ModelMetadata<T>
+        {
+            AdditionalInfo = new Dictionary<string, object>
+            {
+                { "PopulationSize", _populationSize },
+                { "MutationRate", NumOps.ToDouble(_mutationRate) },
+                { "CrossoverRate", NumOps.ToDouble(_crossoverRate) },
+                { "InnovationNumber", _innovationNumber },
+                { "AverageConnections", avgConnections },
+                { "MaxConnections", maxConnections },
+                { "AverageNodes", avgNodes },
+                { "MaxNodes", maxNodes },
+                { "BestGenomeFitness", Convert.ToDouble(bestGenome.Fitness) },
+                { "BestGenomeConnections", bestGenome.Connections.Count },
+                { "BestGenomeEnabledConnections", bestGenome.Connections.Count(c => c.IsEnabled) }
+            },
+            ModelData = SerializeForMetadata()
+        };
+    }
+
+    // Replaced by the declared parameter source below. Removed under AIDN082.
+
+    /// <summary>
+    /// Yields the best genome's connection weights as a single chunk so
+    /// snapshot-based parameter-change probes (Training_ShouldChangeParameters,
+    /// GradientFlow_ShouldBeNonZeroAndFinite) see real evolutionary
+    /// updates. The base <see cref="NeuralNetworkBase{T}.GetParameterChunks"/>
+    /// walks <see cref="Layers"/>, which NEAT leaves EMPTY — its trainable
+    /// surface is the best genome's <c>Connections</c> list, and there is no
+    /// fixed layer partition to publish because the topology is evolved and
+    /// mutates every generation. So the inherited chunk walk reported zero
+    /// changes after Train and produced false "no parameters changed"
+    /// failures (#1224 Cluster F). Yielding a genome-derived chunk surfaces
+    /// the evolutionary delta.
+    /// (This previously said NEAT "populates Layers with a stub representation
+    /// of the best genome". It does not: Layers is written nowhere in this
+    /// file. The override is right; the reason given for it was not.)
+    /// </summary>
+    public override System.Collections.Generic.IEnumerable<Tensor<T>> GetParameterChunks()
+    {
+        var paramVec = GetParameters();
+        if (paramVec.Length == 0) yield break;
+        var chunk = new Tensor<T>(new[] { paramVec.Length });
+        for (int i = 0; i < paramVec.Length; i++) chunk[i] = paramVec[i];
+        yield return chunk;
+    }
+
+    /// <summary>
+    /// Gets named activations from the best genome's network when processing input.
+    /// </summary>
+    public override Dictionary<string, Tensor<T>> GetNamedLayerActivations(Tensor<T> input)
+    {
+        var bestGenome = GetBestGenome();
+        var inputVector = input.ToVector();
+        var activations = ActivateGenome(bestGenome, inputVector);
+
+        var result = new Dictionary<string, Tensor<T>>();
+
+        int inputSize = Architecture.InputSize;
+        int outputSize = Architecture.OutputSize;
+        int biasNodeId = inputSize + outputSize;
+
+        // Issue #1392 perf: ActivateGenome now returns a flat T[] sized to
+        // max(referenced node id, biasNodeId) + 1, so input + output + bias
+        // slots are guaranteed in range. The ContainsKey gymnastics from the
+        // Dictionary era are unnecessary — read straight by index.
+
+        var inputActivation = new Tensor<T>(new int[] { inputSize });
+        for (int i = 0; i < inputSize; i++)
+        {
+            inputActivation[i] = activations[i];
+        }
+        result["InputNodes"] = inputActivation;
+
+        var outputActivation = new Tensor<T>(new int[] { outputSize });
+        for (int i = 0; i < outputSize; i++)
+        {
+            outputActivation[i] = activations[inputSize + i];
+        }
+        result["OutputNodes"] = outputActivation;
+
+        // Hidden nodes: walk the genome's cached non-input-node-id list and
+        // pick out the entries beyond the bias slot. Sorted ascending by id
+        // for stable result ordering, matching what the prior OrderBy(k => k)
+        // chain produced.
+        var nonInputNodeIds = GetOrBuildReferencedNonInputNodeIds(bestGenome, inputSize);
+        var hiddenNodes = new List<int>();
+        foreach (var nodeId in nonInputNodeIds)
+        {
+            if (nodeId > biasNodeId) hiddenNodes.Add(nodeId);
+        }
+        hiddenNodes.Sort();
+
+        if (hiddenNodes.Count > 0)
+        {
+            var hiddenActivation = new Tensor<T>(new int[] { hiddenNodes.Count });
+            for (int i = 0; i < hiddenNodes.Count; i++)
+            {
+                hiddenActivation[i] = activations[hiddenNodes[i]];
+            }
+            result["HiddenNodes"] = hiddenActivation;
+        }
+
+        return result;
+    }
+
+    /// <summary>
+    /// Serializes NEAT-specific data to a binary writer.
+    /// </summary>
+    /// <param name="writer">The binary writer to write to.</param>
+    /// <remarks>
+    /// <para>
+    /// This method saves the state of the NEAT model to a binary stream. It serializes the
+    /// evolutionary parameters, innovation number, and all genomes in the population, allowing
+    /// the complete state to be restored later.
+    /// </para>
+    /// <para><b>For Beginners:</b> This saves the complete state of your NEAT system to a file.
+    /// 
+    /// When saving the NEAT model:
+    /// - Population size, mutation rate, and crossover rate are saved
+    /// - The current innovation number is saved
+    /// - Every genome in the population is saved with all its connections
+    /// 
+    /// This allows you to:
+    /// - Save your progress and continue evolution later
+    /// - Share evolved populations with others
+    /// - Keep records of particularly successful runs
+    /// - Deploy evolved networks in applications
+    /// </para>
+    /// </remarks>
+
+
+    /// <summary>
+    /// Deserializes NEAT-specific data from a binary reader.
+    /// </summary>
+    /// <param name="reader">The binary reader to read from.</param>
+    /// <remarks>
+    /// <para>
+    /// This method loads the state of a previously saved NEAT model from a binary stream. It restores
+    /// the evolutionary parameters, innovation number, and all genomes in the population, allowing
+    /// evolution to continue from exactly where it left off.
+    /// </para>
+    /// <para><b>For Beginners:</b> This loads a complete NEAT system from a saved file.
+    /// 
+    /// When loading the NEAT model:
+    /// - Population size, mutation rate, and crossover rate are restored
+    /// - The innovation number is restored
+    /// - Every genome in the population is recreated with all its connections
+    /// 
+    /// This lets you:
+    /// - Continue evolution from where you left off
+    /// - Use previously evolved populations
+    /// - Compare or combine results from different runs
+    /// </para>
+    /// </remarks>
+
+
+    /// <summary>
+    /// Checks if the NEAT model is ready to make predictions.
+    /// </summary>
+    /// <returns>True if the model is ready; otherwise, false.</returns>
+    /// <remarks>
+    /// <para>
+    /// This method checks if the NEAT model has a population with at least one genome that can be
+    /// used for making predictions. It's useful for determining if the model has been properly
+    /// initialized and evolved.
+    /// </para>
+    /// <para><b>For Beginners:</b> This checks if your NEAT system is ready to use.
+    /// 
+    /// It verifies that:
+    /// - The population exists
+    /// - There is at least one genome in the population
+    /// - At least one genome has connections that can process inputs
+    /// 
+    /// This is helpful for error checking before trying to use the model
+    /// for predictions or continuing evolution.
+    /// </para>
+    /// </remarks>
+    public bool IsReadyToPredict()
+    {
+        return _population != null &&
+               _population.Count > 0 &&
+               _population.Any(g => g.Connections.Count > 0);
+    }
+}
diff --git a/src/NeuralNetworks/NeuralNetwork.cs b/src/NeuralNetworks/NeuralNetwork.cs
index 0a5a8645f8..290663556a 100644
--- a/src/NeuralNetworks/NeuralNetwork.cs
+++ b/src/NeuralNetworks/NeuralNetwork.cs
@@ -49,7 +49,7 @@ namespace AiDotNet.NeuralNetworks;
 [ModelComplexity(ModelComplexity.Low)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
     [ResearchPaper("Learning Internal Representations by Error Propagation", "https://doi.org/10.21236/ADA164453")]
-public class NeuralNetwork<T> : SequentialVectorModelLayoutBase<T>
+public partial class NeuralNetwork<T> : SequentialVectorModelLayoutBase<T>
 {
     private readonly NeuralNetworkDefaultOptions _options;
     private readonly IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>> _optimizer;
@@ -165,7 +165,10 @@ protected override void InitializeLayers()
         {
             // Use the layers provided by the user
             Layers.AddRange(Architecture.Layers);
-            ValidateCustomLayers(Layers);
+            if (!Architecture.IsValidatedCloneSnapshot)
+            {
+                ValidateCustomLayers(Layers);
+            }
         }
         else
         {
@@ -372,9 +375,7 @@ public override ModelMetadata<T> GetModelMetadata()
     /// beyond what the base class already saves.
     /// </para>
     /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-    }
+
 
     /// <summary>
     /// Deserializes neural network-specific data from a binary reader.
@@ -396,38 +397,5 @@ protected override void SerializeNetworkSpecificData(BinaryWriter writer)
     /// beyond what the base class already loads.
     /// </para>
     /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-    }
 
-    /// <summary>
-    /// Creates a new instance of the neural network with the same architecture.
-    /// </summary>
-    /// <returns>A new instance of the neural network.</returns>
-    /// <remarks>
-    /// <para>
-    /// This method creates a new neural network with the same architecture as the current instance.
-    /// The new instance is initialized with fresh layers and parameters, making it useful for
-    /// creating multiple networks with the same structure or for resetting a network while preserving its architecture.
-    /// </para>
-    /// <para><b>For Beginners:</b> This creates a brand new neural network with the same structure.
-    /// 
-    /// This is useful when you want to:
-    /// - Start over with a fresh network but keep the same structure
-    /// - Create multiple networks with identical layouts
-    /// - Reset a network to its initial state
-    /// 
-    /// The new network will have:
-    /// - The same number of layers and neurons
-    /// - The same activation functions
-    /// - Newly initialized weights and biases
-    /// 
-    /// Think of it like creating a twin of your neural network, but with a "blank slate" -
-    /// it has the same structure but hasn't learned anything yet.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new NeuralNetwork<T>(Architecture);
-    }
 }
diff --git a/src/NeuralNetworks/NeuralNetworkArchitecture.cs b/src/NeuralNetworks/NeuralNetworkArchitecture.cs
index b1b85d8764..bf869728de 100644
--- a/src/NeuralNetworks/NeuralNetworkArchitecture.cs
+++ b/src/NeuralNetworks/NeuralNetworkArchitecture.cs
@@ -29,7 +29,7 @@ namespace AiDotNet.NeuralNetworks;
 /// a network designed for text, or having layers that don't match up in size.
 /// </para>
 /// </remarks>
-public class NeuralNetworkArchitecture<T>
+public class NeuralNetworkArchitecture<T> : IConfigurationCloneable
 {
     /// <summary>
     /// Gets the optional list of predefined layers for the neural network.
@@ -1177,6 +1177,19 @@ public static NeuralNetworkArchitecture<T> CreateDynamicSpatial(
     /// </summary>
     public bool IsLayerOnly { get; private set; }
 
+    /// <summary>
+    /// Gets whether this architecture is an internal snapshot of a layer graph that was already
+    /// validated when the source network was constructed.
+    /// </summary>
+    /// <remarks>
+    /// Runtime shape reconciliation may change a layer's reported shape from its original
+    /// per-sample declaration to a batched forward shape. Re-validating those runtime snapshots as
+    /// if they were a newly authored architecture can reject a valid graph. This flag is set only by
+    /// <see cref="IConfigurationCloneable.CloneConfiguration"/>; user-created architectures still
+    /// receive the normal validation.
+    /// </remarks>
+    internal bool IsValidatedCloneSnapshot { get; private set; }
+
     /// <summary>
     /// Creates a "layer-only" architecture stub for sub-modules and detection
     /// backbones whose input contract is owned by a parent network. Every
@@ -1209,4 +1222,96 @@ public static NeuralNetworkArchitecture<T> CreateLayerOnly()
         stub.IsLayerOnly = true;
         return stub;
     }
+
+    /// <summary>
+    /// Rebuilds this blueprint with independent layer objects and no copied runtime parameters.
+    /// </summary>
+    /// <remarks>
+    /// A <see cref="NeuralNetwork{T}"/> stores the architecture supplied to its constructor and uses
+    /// the architecture's layer objects directly. The generic clone engine therefore cannot pass the
+    /// same architecture to a new network: that would make both networks own the same mutable layers.
+    /// Layer construction metadata is already the generated, central contract used by serialization,
+    /// so use it here as well instead of adding per-layer clone overrides.
+    /// </remarks>
+    object IConfigurationCloneable.CloneConfiguration() => CloneForModelConstruction();
+
+    /// <summary>
+    /// Creates an independent architecture for another model that must not share this instance's
+    /// mutable layer objects.
+    /// </summary>
+    internal NeuralNetworkArchitecture<T> CloneForModelConstruction()
+    {
+        if (IsLayerOnly)
+        {
+            var layerOnly = CreateLayerOnly();
+            layerOnly._randomSeed = _randomSeed;
+            layerOnly.UseAutodiff = UseAutodiff;
+            layerOnly.IsInitialized = IsInitialized;
+            return layerOnly;
+        }
+
+        var layerCopies = new List<ILayer<T>>(Layers.Count);
+        foreach (var layer in Layers)
+        {
+            if (layer is not LayerBase<T> layerBase)
+            {
+                throw new NotSupportedException(
+                    $"Layer '{layer.GetType().FullName}' does not derive from LayerBase and cannot "
+                    + "publish generated construction metadata.");
+            }
+
+            var metadata = layerBase.GetMetadata().ToDictionary(
+                pair => pair.Key,
+                pair => (object)pair.Value,
+                StringComparer.Ordinal);
+            Type runtimeLayerType = layer.GetType();
+            Type registryLayerType = runtimeLayerType.IsGenericType
+                ? runtimeLayerType.GetGenericTypeDefinition()
+                : runtimeLayerType;
+            string layerType = registryLayerType.FullName ?? registryLayerType.Name;
+            layerCopies.Add(DeserializationHelper.CreateLayerFromType<T>(
+                layerType,
+                layer.GetInputShape(),
+                layer.GetOutputShape(),
+                metadata));
+        }
+
+        NeuralNetworkArchitecture<T> copy;
+        if (GetType() == typeof(NeuralNetworkArchitecture<T>))
+        {
+            copy = new NeuralNetworkArchitecture<T>(
+                inputType: InputType,
+                taskType: TaskType,
+                complexity: Complexity,
+                inputSize: InputSize,
+                inputHeight: InputHeight,
+                inputWidth: InputWidth,
+                inputDepth: InputDepth,
+                outputSize: OutputSize,
+                layers: layerCopies,
+                shouldReturnFullSequence: ShouldReturnFullSequence,
+                imageEmbeddingDim: ImageEmbeddingDim,
+                textEmbeddingDim: TextEmbeddingDim,
+                inputFrames: InputFrames);
+        }
+        else
+        {
+            // Preserve a derived architecture's semantic configuration. Rebuilding every blueprint as
+            // NeuralNetworkArchitecture erased subtype-only values (for example CodeSynthesisArchitecture's
+            // dimensions and UseDataFlow), so constructor replay rejected the result and silently selected
+            // a model's parameterless/default constructor. The generated clone plan already knows how to
+            // reconstruct the runtime subtype; replace only its initially carried layer references with the
+            // independently rebuilt graph above.
+            copy = (NeuralNetworkArchitecture<T>)CloneEngine.CopyConfiguration(this);
+            copy.Layers.Clear();
+            copy.Layers.AddRange(layerCopies);
+        }
+
+        copy._randomSeed = _randomSeed;
+        copy.UseAutodiff = UseAutodiff;
+        copy.IsInitialized = IsInitialized;
+        copy.IsValidatedCloneSnapshot = true;
+
+        return copy;
+    }
 }
diff --git a/src/NeuralNetworks/NeuralNetworkBase.cs b/src/NeuralNetworks/NeuralNetworkBase.cs
index 6f9ba48315..62caa957f6 100644
--- a/src/NeuralNetworks/NeuralNetworkBase.cs
+++ b/src/NeuralNetworks/NeuralNetworkBase.cs
@@ -1,4 +1,4 @@
-#pragma warning disable CS0649, CS0414, CS0169
+#pragma warning disable CS0649, CS0414, CS0169
 using AiDotNet.Autodiff;
 using AiDotNet.Interfaces;
 using AiDotNet.Interpretability;
@@ -38,7 +38,7 @@ namespace AiDotNet.NeuralNetworks;
 /// This class provides the foundation for building different types of neural networks.
 /// </para>
 /// </remarks>
-public abstract class NeuralNetworkBase<T> : INeuralNetworkModel<T>, IInterpretableModel<T>, IInputGradientComputable<T>, IConfigurableModel<T>, IModelShape, IDisposable,
+public abstract partial class NeuralNetworkBase<T> : INeuralNetworkModel<T>, IInterpretableModel<T>, IInputGradientComputable<T>, IConfigurableModel<T>, IModelShape, IDisposable,
     IParameterizable<T, Tensor<T>, Tensor<T>>, IFeatureAware, IGradientComputable<T, Tensor<T>, Tensor<T>>,
     ISupportsLossFunction<T>, AiDotNet.Models.Parameters.IParameterManifestProvider,
     AiDotNet.Models.Parameters.IParameterLayoutSource,
@@ -46,6 +46,49 @@ public abstract class NeuralNetworkBase<T> : INeuralNetworkModel<T>, IInterpreta
     AiDotNet.Models.Parameters.IParameterMaterializationSource,
     AiDotNet.Models.Parameters.IParameterSurfaceLifecycle
 {
+    // --- declared state (ModelStateRegistry) ---
+    // Identical in every model base because these bases are siblings over the same interfaces rather
+    // than one hierarchy; the logic itself lives once in ModelStateRegistry/ModelStateEnvelope.
+
+    /// <summary>State that is not a parameter vector, declared once and persisted by this base.</summary>
+    private readonly AiDotNet.Models.ModelStateRegistry<T> _declaredState = new();
+    private bool _declaredStateRegistered;
+
+    /// <summary>
+    /// Declare state here that the parameter vector does not carry -- a retained training set,
+    /// fitted knots, kernel centres, an ensemble's children. Both halves of the payload are driven
+    /// by the declaration, so they cannot drift.
+    /// </summary>
+    /// <param name="state">The registry to declare into.</param>
+    protected virtual void RegisterState(AiDotNet.Models.ModelStateRegistry<T> state)
+    {
+    }
+    /// <summary>Generated state declarations for fields declared across this model's hierarchy.</summary>
+    /// <param name="state">The registry to declare into.</param>
+    /// <remarks>
+    /// Emitted by ModelStateGenerator into the partial model, so a model author declares nothing. The
+    /// hand-written <c>RegisterState</c> beside it exists only for state the classifier genuinely
+    /// cannot place; anything it CAN place belongs here, where it cannot be forgotten.
+    /// </remarks>
+    protected virtual void RegisterGeneratedState(AiDotNet.Models.ModelStateRegistry<T> state)
+    {
+        RegisterGeneratedStateCore(state);
+    }
+
+    /// <summary>The declared state, registered once and lazily so it runs after the constructor.</summary>
+    protected AiDotNet.Models.ModelStateRegistry<T> DeclaredState
+    {
+        get
+        {
+            if (!_declaredStateRegistered)
+            {
+                _declaredStateRegistered = true;
+                RegisterGeneratedState(_declaredState);
+                RegisterState(_declaredState);
+            }
+            return _declaredState;
+        }
+    }
     /// <summary>
     /// Disposes a rejected copy-on-write candidate without crossing an ownership boundary back
     /// into this model. Some legacy <c>CreateNewInstance</c> implementations reuse the source's
@@ -55,15 +98,17 @@ public abstract class NeuralNetworkBase<T> : INeuralNetworkModel<T>, IInterpreta
     private void DisposeRejectedCopyOnWriteCandidate(NeuralNetworkBase<T> candidate)
     {
         // The candidate owns its List instance, but it may not own every object in that list.
-        // Detach source identities first; the remaining candidate-only layers can be reclaimed
-        // normally. LayerBase.Dispose does not cascade into GetSubLayers, so this top-level
-        // ownership cut is both sufficient and deliberately allocation-free.
+        // The ownership boundary is the complete declared module graph, not only this model's
+        // canonical _layers list: a composite can publish nested-network layers through
+        // GetExtraTrainableLayers, and a rejected constructor candidate may borrow one of those as
+        // a top-level layer. Detach every source-owned identity before cascading candidate disposal.
+        var sourceLayers = AiDotNet.Helpers.CopyOnWriteCloneHelper.CollectTrainableLayers<T>(this);
         for (int candidateIndex = candidate._layers.Count - 1; candidateIndex >= 0; candidateIndex--)
         {
             var candidateLayer = candidate._layers[candidateIndex];
-            for (int sourceIndex = 0; sourceIndex < _layers.Count; sourceIndex++)
+            for (int sourceIndex = 0; sourceIndex < sourceLayers.Count; sourceIndex++)
             {
-                if (!ReferenceEquals(candidateLayer, _layers[sourceIndex])) continue;
+                if (!ReferenceEquals(candidateLayer, sourceLayers[sourceIndex])) continue;
                 candidate._layers.RemoveAt(candidateIndex);
                 break;
             }
@@ -2915,6 +2960,381 @@ protected virtual void RebindLayerAliases(
     {
     }
 
+    /// <summary>
+    /// Transfers generated named-layer views from this source model to a clone whose canonical
+    /// <see cref="Layers"/> graph has already been reconstructed.
+    /// </summary>
+    /// <remarks>
+    /// Replacement-time rebinding can repair aliases that existed in the destination constructor.
+    /// It cannot infer a fitted-only alias collection when that collection is empty on a fresh
+    /// instance. The parameter generator overrides this hook and maps the source aliases by their
+    /// canonical layer indices, so runtime-created encoder/decoder graphs need no clone override.
+    /// </remarks>
+    protected virtual void CopyGeneratedLayerAliasesTo(NeuralNetworkBase<T> destination)
+    {
+    }
+
+    /// <summary>
+    /// Rebinds a nested network whose layer graph was a view into a replaced parent graph.
+    /// </summary>
+    protected static void RebindNestedNetworkCanonicalLayerAliases(
+        NeuralNetworkBase<T>? child,
+        IReadOnlyList<ILayer<T>> previousParentLayers,
+        IReadOnlyList<ILayer<T>> replacementParentLayers,
+        string memberName)
+    {
+        if (child is null) return;
+
+        var previousChildLayers = child._layers.ToArray();
+        var replacements = new List<ILayer<T>>(previousChildLayers.Length);
+        bool changed = false;
+        int identityMatches = 0;
+        for (int childIndex = 0; childIndex < previousChildLayers.Length; childIndex++)
+        {
+            var childLayer = previousChildLayers[childIndex];
+            int parentIndex = -1;
+            for (int parentLayerIndex = 0; parentLayerIndex < previousParentLayers.Count; parentLayerIndex++)
+            {
+                if (!ReferenceEquals(previousParentLayers[parentLayerIndex], childLayer)) continue;
+                parentIndex = parentLayerIndex;
+                break;
+            }
+
+            if (parentIndex < 0)
+            {
+                replacements.Add(childLayer);
+                continue;
+            }
+            if (parentIndex >= replacementParentLayers.Count
+                || replacementParentLayers[parentIndex].GetType() != childLayer.GetType())
+            {
+                throw new InvalidOperationException(
+                    $"Generated nested-network alias '{memberName}' cannot map child layer " +
+                    $"{childIndex} ({childLayer.GetType().Name}) through parent layer {parentIndex}.");
+            }
+
+            var replacement = replacementParentLayers[parentIndex];
+            replacements.Add(replacement);
+            identityMatches++;
+            if (!ReferenceEquals(replacement, childLayer)) changed = true;
+        }
+
+        // A nested network can materialize from the same architecture after the parent published
+        // its constructor graph, so none of its current objects remain in previousParentLayers.
+        // A unique complete type-sequence match is still strong alias evidence; a partial or
+        // ambiguous match is deliberately refused.
+        if (identityMatches == 0 && previousChildLayers.Length > 0)
+        {
+            int uniqueStart = -1;
+            for (int start = 0;
+                 start + previousChildLayers.Length <= previousParentLayers.Count
+                 && start + previousChildLayers.Length <= replacementParentLayers.Count;
+                 start++)
+            {
+                bool matches = true;
+                for (int childIndex = 0; childIndex < previousChildLayers.Length; childIndex++)
+                {
+                    if (previousParentLayers[start + childIndex].GetType()
+                        == previousChildLayers[childIndex].GetType())
+                        continue;
+                    matches = false;
+                    break;
+                }
+
+                if (!matches) continue;
+                if (uniqueStart >= 0) return;
+                uniqueStart = start;
+            }
+
+            if (uniqueStart < 0) return;
+            replacements.Clear();
+            for (int childIndex = 0; childIndex < previousChildLayers.Length; childIndex++)
+            {
+                var replacement = replacementParentLayers[uniqueStart + childIndex];
+                if (replacement.GetType() != previousChildLayers[childIndex].GetType()) return;
+                replacements.Add(replacement);
+            }
+            changed = true;
+        }
+
+        if (!changed) return;
+        child._layers.Clear();
+        child._layers.AddRange(replacements);
+        child.RebindLayerAliases(previousChildLayers, child._layers);
+        child.InvalidateParameterCountCache();
+    }
+
+    /// <summary>
+    /// Re-establishes a nested network's canonical layer aliases after generated declared-state
+    /// restoration has deserialized that child in place.
+    /// </summary>
+    /// <remarks>
+    /// A parent may deliberately expose a child's layers as its own canonical <see cref="Layers"/>
+    /// graph. Restoring the readonly child through its serializer replaces the child's layer objects,
+    /// while the parent still references the constructor graph; without this repair the same logical
+    /// module is counted and executed twice. The model parameter generator emits calls for every
+    /// nested-network member, mapping only source identities that were aliases of the parent and
+    /// preserving independently-owned child layers by ordinal.
+    /// </remarks>
+    protected static void CopyNestedNetworkCanonicalLayerAliases(
+        NeuralNetworkBase<T>? sourceChild,
+        NeuralNetworkBase<T>? destinationChild,
+        IReadOnlyList<ILayer<T>> sourceParentLayers,
+        IReadOnlyList<ILayer<T>> destinationParentLayers,
+        string memberName)
+    {
+        if (sourceChild is null && destinationChild is null) return;
+        if (sourceChild is null || destinationChild is null)
+        {
+            throw new InvalidOperationException(
+                $"Generated nested-network alias '{memberName}' is null on only one side of a clone.");
+        }
+        if (ReferenceEquals(sourceChild, destinationChild))
+        {
+            throw new InvalidOperationException(
+                $"Generated nested-network alias '{memberName}' is shared by object identity.");
+        }
+
+        var previousChildLayers = destinationChild._layers.ToArray();
+        var replacements = new List<ILayer<T>>(sourceChild._layers.Count);
+        for (int childIndex = 0; childIndex < sourceChild._layers.Count; childIndex++)
+        {
+            var sourceLayer = sourceChild._layers[childIndex];
+            int parentIndex = -1;
+            for (int i = 0; i < sourceParentLayers.Count; i++)
+            {
+                if (!ReferenceEquals(sourceParentLayers[i], sourceLayer)) continue;
+                parentIndex = i;
+                break;
+            }
+
+            if (parentIndex >= 0)
+            {
+                if (parentIndex >= destinationParentLayers.Count)
+                {
+                    throw new InvalidOperationException(
+                        $"Generated nested-network alias '{memberName}' maps parent layer " +
+                        $"{parentIndex}, but the clone has only {destinationParentLayers.Count} layers.");
+                }
+
+                var replacement = destinationParentLayers[parentIndex];
+                if (replacement.GetType() != sourceLayer.GetType())
+                {
+                    throw new InvalidOperationException(
+                        $"Generated nested-network alias '{memberName}' maps {sourceLayer.GetType().Name} " +
+                        $"to incompatible {replacement.GetType().Name} at parent layer {parentIndex}.");
+                }
+                replacements.Add(replacement);
+                continue;
+            }
+
+            if (childIndex >= previousChildLayers.Length
+                || previousChildLayers[childIndex].GetType() != sourceLayer.GetType())
+            {
+                throw new InvalidOperationException(
+                    $"Generated nested-network alias '{memberName}' cannot preserve independent child " +
+                    $"layer {childIndex} ({sourceLayer.GetType().Name}).");
+            }
+            replacements.Add(previousChildLayers[childIndex]);
+        }
+
+        destinationChild._layers.Clear();
+        destinationChild._layers.AddRange(replacements);
+        destinationChild.RebindLayerAliases(previousChildLayers, destinationChild._layers);
+        sourceChild.CopyGeneratedLayerAliasesTo(destinationChild);
+        destinationChild.InvalidateParameterCountCache();
+    }
+
+    /// <summary>
+    /// Rebuilds top-level destination layers whose generated construction state changed after the
+    /// source adapted to real data.
+    /// </summary>
+    /// <remarks>
+    /// A fresh model is built from architecture/options, but a shape-adaptive composite can promote
+    /// an observed width into constructor state and rebuild its children. Matching only child tensor
+    /// shapes is insufficient: the fresh parent still carries the old width and its first forward
+    /// discards the correctly adopted children. Generated layer construction state is already the
+    /// authoritative persistence recipe, so use its architecture-only clone here and let the normal
+    /// COW walk install learned storage afterwards. No model/layer clone override is involved.
+    /// </remarks>
+    private bool TrySynchronizeRuntimeLayerConstructionState(
+        NeuralNetworkBase<T> destination,
+        out List<IDisposable> replaced,
+        out string failure)
+    {
+        replaced = new List<IDisposable>();
+        failure = string.Empty;
+
+        ILayer<T> Reconstruct(LayerBase<T> sourceLayer)
+        {
+            var metadata = new Dictionary<string, object>(StringComparer.Ordinal);
+            foreach (var pair in sourceLayer.GetMetadata()) metadata[pair.Key] = pair.Value;
+            return DeserializationHelper.CreateLayerFromType<T>(
+                GetPersistentLayerTypeName(sourceLayer),
+                sourceLayer.GetInputShape(),
+                sourceLayer.GetOutputShape(),
+                metadata);
+        }
+
+        // A constructor rebuilt from incomplete legacy options can produce a different canonical
+        // sequence even though every individual default layer is valid. Per-index repair cannot
+        // recover from inserted/removed layers (for example disabled dropout), because every later
+        // slot is shifted. Reconstruct the canonical topology from the source's shared persistence
+        // metadata as one unit; generated alias transfer below will rebind named/list views.
+        bool topologyDiffers = _layers.Count != destination._layers.Count;
+        if (!topologyDiffers)
+        {
+            for (int i = 0; i < _layers.Count; i++)
+            {
+                if (_layers[i].GetType() == destination._layers[i].GetType()) continue;
+                topologyDiffers = true;
+                break;
+            }
+        }
+
+        if (topologyDiffers && _layers.All(layer => layer is LayerBase<T>))
+        {
+            var reconstructed = new List<ILayer<T>>(_layers.Count);
+            try
+            {
+                foreach (var source in _layers)
+                    reconstructed.Add(Reconstruct((LayerBase<T>)source));
+            }
+            catch (Exception ex) when (ex is ArgumentException
+                                       or InvalidOperationException
+                                       or NotSupportedException)
+            {
+                foreach (var layer in reconstructed)
+                    (layer as IDisposable)?.Dispose();
+                failure = $"canonical topology could not be reconstructed: {ex.Message}";
+                return false;
+            }
+
+            foreach (var oldLayer in destination._layers)
+            {
+                bool borrowedFromSource = _layers.Any(source => ReferenceEquals(source, oldLayer));
+                if (!borrowedFromSource && oldLayer is IDisposable disposable)
+                    replaced.Add(disposable);
+            }
+            destination._layers.Clear();
+            destination._layers.AddRange(reconstructed);
+            destination.InvalidateParameterCountCache();
+            return true;
+        }
+
+        var pending = new List<(int Index, ILayer<T> Rebuilt, LayerBase<T> Previous)>();
+        int count = Math.Min(_layers.Count, destination._layers.Count);
+        for (int i = 0; i < count; i++)
+        {
+            if (_layers[i] is not LayerBase<T> sourceLayer
+                || destination._layers[i] is not LayerBase<T> destinationLayer
+                || sourceLayer.GetType() != destinationLayer.GetType())
+                continue;
+
+            // Generated [LayerState] is the preferred construction recipe, but legacy composite
+            // layers also publish required constructor values through GetMetadata(). Comparing only
+            // the generated subset let a fresh, default-configured layer pass preflight when its
+            // tensor shapes happened to match the source (PointNet++ neighbour counts are the
+            // representative case). The COW adoption then preserved every weight while inference
+            // still followed a different graph. GetMetadata is the complete shared persistence
+            // contract and includes the generated construction state, so compare that full surface.
+            var sourceState = sourceLayer.GetMetadata();
+            var destinationState = destinationLayer.GetMetadata();
+            bool matches = sourceState.Count == destinationState.Count;
+            if (matches)
+            {
+                foreach (var pair in sourceState)
+                {
+                    if (destinationState.TryGetValue(pair.Key, out string? value)
+                        && string.Equals(pair.Value, value, StringComparison.Ordinal))
+                        continue;
+                    matches = false;
+                    break;
+                }
+            }
+            if (matches) continue;
+
+            try
+            {
+                pending.Add((i, Reconstruct(sourceLayer), destinationLayer));
+            }
+            catch (Exception ex) when (ex is ArgumentException
+                                       or InvalidOperationException
+                                       or NotSupportedException)
+            {
+                foreach (var item in pending)
+                    (item.Rebuilt as IDisposable)?.Dispose();
+                failure = $"layer {i} ({sourceLayer.GetType().Name}) construction state " +
+                          $"could not be reconstructed: {ex.Message}";
+                return false;
+            }
+        }
+
+        foreach (var item in pending)
+        {
+            destination._layers[item.Index] = item.Rebuilt;
+            if (!ReferenceEquals(_layers[item.Index], item.Previous))
+                replaced.Add(item.Previous);
+        }
+
+        return true;
+    }
+
+    /// <summary>
+    /// Transfers generated model-owned trainable tensors that are not part of <see cref="Layers"/>.
+    /// </summary>
+    protected virtual void CopyGeneratedTrainableTensorsTo(NeuralNetworkBase<T> destination)
+    {
+    }
+
+    /// <summary>Creates a distinct tensor object that shares storage copy-on-write with the source.</summary>
+    protected static Tensor<T>? CloneGeneratedTrainableTensor(Tensor<T>? source)
+        => source is null ? null : (Tensor<T>)source.CloneShared();
+
+    /// <summary>Creates a distinct copy-on-write tensor object for required generated storage.</summary>
+    protected static Tensor<T> CloneRequiredGeneratedTrainableTensor(Tensor<T> source)
+        => (Tensor<T>)source.CloneShared();
+
+    /// <summary>Copies a generated readonly tensor into its constructor-created destination storage.</summary>
+    protected static void CopyGeneratedTrainableTensorValues(
+        Tensor<T>? source,
+        Tensor<T>? destination,
+        string memberName)
+    {
+        if (source is null && destination is null) return;
+        if (source is null || destination is null || !source._shape.SequenceEqual(destination._shape))
+        {
+            throw new InvalidOperationException(
+                $"Generated trainable tensor '{memberName}' has incompatible source/clone storage.");
+        }
+
+        source.Data.Span.CopyTo(destination.Data.Span);
+    }
+
+    /// <summary>Creates an independent generated trainable vector for an in-memory clone.</summary>
+    protected static Vector<T>? CloneGeneratedTrainableVector(Vector<T>? source)
+        => source is null ? null : new Vector<T>(source.ToArray());
+
+    /// <summary>Creates an independent required generated trainable vector.</summary>
+    protected static Vector<T> CloneRequiredGeneratedTrainableVector(Vector<T> source)
+        => new(source.ToArray());
+
+    /// <summary>Copies a readonly generated trainable vector into constructor-created storage.</summary>
+    protected static void CopyGeneratedTrainableVectorValues(
+        Vector<T>? source,
+        Vector<T>? destination,
+        string memberName)
+    {
+        if (source is null && destination is null) return;
+        if (source is null || destination is null || source.Length != destination.Length)
+        {
+            throw new InvalidOperationException(
+                $"Generated trainable vector '{memberName}' has incompatible source/clone storage.");
+        }
+
+        for (int i = 0; i < source.Length; i++) destination[i] = source[i];
+    }
+
     /// <summary>Returns the replacement for one generated canonical-layer alias.</summary>
     protected static TLayer? RebindLayerAlias<TLayer>(
         TLayer? alias,
@@ -2926,29 +3346,54 @@ protected virtual void RebindLayerAliases(
         if (alias is null)
             return null;
 
+        int matchingReferenceCount = 0;
+        int aliasTypeOrdinal = -1;
+        int previousTypeOrdinal = 0;
         for (int index = 0; index < previousLayers.Count; index++)
         {
-            if (!ReferenceEquals(alias, previousLayers[index]))
+            if (previousLayers[index] is not TLayer)
                 continue;
 
-            // The destination constructor may have built a larger default topology than the graph
-            // being restored. An alias into a removed canonical layer is absent; it must never be
-            // reclassified as an independently-owned trainable module.
-            if (index >= replacementLayers.Count)
-                return null;
+            if (ReferenceEquals(alias, previousLayers[index]))
+            {
+                matchingReferenceCount++;
+                aliasTypeOrdinal = previousTypeOrdinal;
+            }
+            previousTypeOrdinal++;
+        }
 
-            if (replacementLayers[index] is TLayer replacement)
-                return replacement;
+        // The member owns an independent layer rather than a view into Layers.
+        if (matchingReferenceCount == 0)
+            return alias;
 
+        // A canonical graph containing the same layer object more than once cannot say which slot a
+        // named alias owns. Reject that corrupt/ambiguous graph instead of silently binding the member
+        // to an arbitrary replacement.
+        if (matchingReferenceCount > 1)
+        {
             throw new InvalidOperationException(
-                $"Generated layer alias '{memberName}' targets canonical layer {index}, but its " +
-                $"replacement type '{replacementLayers[index].GetType().FullName}' cannot be assigned " +
-                $"to '{typeof(TLayer).FullName}'. The serialized graph is incompatible with the " +
-                "model's declared layer-alias contract.");
+                $"Generated layer alias '{memberName}' appears {matchingReferenceCount} times in the " +
+                "previous canonical graph, so its replacement is ambiguous.");
         }
 
-        // The member owns an independent layer rather than a view into Layers.
-        return alias;
+        // Map by ordinal among assignable layers, not by absolute Layers index. A fitted or
+        // configuration-dependent collection can grow/shrink between construction and restore,
+        // shifting every later canonical index even though each named field keeps the same semantic
+        // role (RAPIDFlow's refinement block list before its decoder is the representative case).
+        int replacementTypeOrdinal = 0;
+        for (int index = 0; index < replacementLayers.Count; index++)
+        {
+            if (replacementLayers[index] is not TLayer replacement)
+                continue;
+            if (replacementTypeOrdinal == aliasTypeOrdinal)
+                return replacement;
+            replacementTypeOrdinal++;
+        }
+
+        // The destination constructor may have built a larger topology than the graph being restored.
+        // An alias into a removed canonical layer is absent; collection callers can shrink around it,
+        // while required single-member callers report the missing contract through their wrapper.
+        return null;
     }
 
     /// <summary>Rebinds a non-null canonical-layer alias or reports an incompatible topology.</summary>
@@ -3051,6 +3496,133 @@ protected static void ValidateReadonlyLayerAlias<TLayer>(
         }
     }
 
+    /// <summary>Maps one source alias onto the equivalent canonical layer in a clone.</summary>
+    protected static TLayer? CopyLayerAlias<TLayer>(
+        TLayer? sourceAlias,
+        TLayer? destinationAlias,
+        IReadOnlyList<ILayer<T>> sourceLayers,
+        IReadOnlyList<ILayer<T>> destinationLayers,
+        string memberName)
+        where TLayer : class, ILayer<T>
+    {
+        if (sourceAlias is null)
+            return null;
+
+        for (int index = 0; index < sourceLayers.Count; index++)
+        {
+            if (!ReferenceEquals(sourceAlias, sourceLayers[index]))
+                continue;
+
+            if (index >= destinationLayers.Count)
+                return null;
+            if (destinationLayers[index] is TLayer replacement)
+                return replacement;
+
+            throw new InvalidOperationException(
+                $"Generated layer alias '{memberName}' targets source layer {index}, but the clone's " +
+                $"layer type '{destinationLayers[index].GetType().FullName}' cannot be assigned to " +
+                $"'{typeof(TLayer).FullName}'.");
+        }
+
+        // An alias outside the canonical graph is independently owned. Preserve the independently
+        // constructed destination instance rather than sharing the source object.
+        return destinationAlias;
+    }
+
+    /// <summary>Maps a required source alias onto the equivalent canonical layer in a clone.</summary>
+    protected static TLayer CopyRequiredLayerAlias<TLayer>(
+        TLayer sourceAlias,
+        TLayer destinationAlias,
+        IReadOnlyList<ILayer<T>> sourceLayers,
+        IReadOnlyList<ILayer<T>> destinationLayers,
+        string memberName)
+        where TLayer : class, ILayer<T>
+        => CopyLayerAlias(sourceAlias, destinationAlias, sourceLayers, destinationLayers, memberName)
+           ?? throw new InvalidOperationException(
+               $"Required layer alias '{memberName}' has no corresponding layer in the clone's canonical graph.");
+
+    /// <summary>Transfers a generated collection view from a source graph to a clone graph.</summary>
+    protected static void CopyLayerAliasCollection<TLayer>(
+        IEnumerable<TLayer>? sourceAliases,
+        IEnumerable<TLayer>? destinationAliases,
+        IReadOnlyList<ILayer<T>> sourceLayers,
+        IReadOnlyList<ILayer<T>> destinationLayers,
+        string memberName)
+        where TLayer : class, ILayer<T>
+    {
+        if (sourceAliases is null || destinationAliases is null)
+            return;
+
+        var source = sourceAliases.ToList();
+        var currentDestination = destinationAliases.ToList();
+        var mapped = new List<TLayer>(source.Count);
+        for (int index = 0; index < source.Count; index++)
+        {
+            TLayer? destinationAtIndex = index < currentDestination.Count
+                ? currentDestination[index]
+                : null;
+            var replacement = CopyLayerAlias(
+                source[index], destinationAtIndex, sourceLayers, destinationLayers,
+                memberName + "[" + index + "]");
+            if (replacement is null)
+            {
+                throw new InvalidOperationException(
+                    $"Generated layer alias collection '{memberName}' has no clone layer for source entry {index}.");
+            }
+            mapped.Add(replacement);
+        }
+
+        if (destinationAliases is TLayer[] array)
+        {
+            if (array.Length != mapped.Count)
+                throw new InvalidOperationException(
+                    $"Generated layer alias array '{memberName}' has length {array.Length} in the clone " +
+                    $"but {mapped.Count} in the source.");
+            for (int index = 0; index < mapped.Count; index++) array[index] = mapped[index];
+            return;
+        }
+
+        if (destinationAliases is IList<TLayer> list && !list.IsReadOnly)
+        {
+            list.Clear();
+            for (int index = 0; index < mapped.Count; index++) list.Add(mapped[index]);
+            return;
+        }
+
+        if (destinationAliases is ICollection<TLayer> collection && !collection.IsReadOnly)
+        {
+            collection.Clear();
+            foreach (var replacement in mapped) collection.Add(replacement);
+            return;
+        }
+
+        if (mapped.Count != currentDestination.Count
+            || mapped.Where((replacement, index) => !ReferenceEquals(replacement, currentDestination[index])).Any())
+        {
+            throw new InvalidOperationException(
+                $"Generated layer alias collection '{memberName}' must be mutable to receive the clone's canonical graph.");
+        }
+    }
+
+    /// <summary>Validates a readonly scalar alias against the equivalent clone alias.</summary>
+    protected static void ValidateCopiedReadonlyLayerAlias<TLayer>(
+        TLayer? sourceAlias,
+        TLayer? destinationAlias,
+        IReadOnlyList<ILayer<T>> sourceLayers,
+        IReadOnlyList<ILayer<T>> destinationLayers,
+        string memberName)
+        where TLayer : class, ILayer<T>
+    {
+        var mapped = CopyLayerAlias(
+            sourceAlias, destinationAlias, sourceLayers, destinationLayers, memberName);
+        if (!ReferenceEquals(mapped, destinationAlias))
+        {
+            throw new InvalidOperationException(
+                $"Readonly layer alias '{memberName}' cannot be transferred to the clone. Make the alias " +
+                "writable or store it in a mutable layer collection.");
+        }
+    }
+
     /// <summary>
     /// Validates that the provided layers form a valid neural network architecture.
     /// </summary>
@@ -3232,8 +3804,33 @@ private bool IsLastLayerShapeCompatible(ILayer<T> layer, out string error)
 
         if (Architecture.OutputSize > 0 && !AreShapesCompatible([Architecture.OutputSize], outputShape))
         {
-            error = $"The last layer's output shape [{string.Join(", ", outputShape)}] must match the architecture output size ({Architecture.OutputSize}).";
-            return false;
+            // A RESOLVED multi-dimensional output describes the same tensor as the architecture's flat
+            // OutputSize whenever its dimensions multiply out to that count: a generator emitting
+            // [3, 32, 32] and an OutputSize of 3072 are the same 3072 values, differing only in whether
+            // the shape is carried structured or flattened. AreShapesCompatible compares dimension-wise
+            // and cannot see that.
+            //
+            // The deferral above only covers the UNRESOLVED case ([3, -1, -1] before first Forward), so
+            // the same network passed validation when freshly built and failed once its shapes had been
+            // resolved by a forward pass. That is exactly the path a clone takes -- rebuilding a trained
+            // network from its own architecture -- which is why every GAN used to need a hand-written
+            // CreateNewInstance whose only job was to route around this check (see DCGAN, deleted in
+            // 7f61e07c4). Comparing the element count instead lets the base reproduce those clones.
+            //
+            // Narrow by construction: a genuine mismatch has a different element count and is still
+            // rejected with the same message, and a shape carrying a batch dimension multiplies it in,
+            // so [B, 3, 32, 32] does not match 3072 either.
+            long resolvedElements = 1;
+            foreach (int dimension in outputShape)
+            {
+                resolvedElements *= dimension;
+            }
+
+            if (resolvedElements != Architecture.OutputSize)
+            {
+                error = $"The last layer's output shape [{string.Join(", ", outputShape)}] must match the architecture output size ({Architecture.OutputSize}).";
+                return false;
+            }
         }
 
         error = string.Empty;
@@ -4085,6 +4682,7 @@ protected void EnsureArchitectureInitialized()
             if (!_layerOnlyInitialized && Layers.Count == 0)
             {
                 InitializeLayers();
+                ReconcileCanonicalNestedNetworkLayerViews();
                 ReportLayerContractMismatches();
             }
             _layerOnlyInitialized = true;
@@ -4106,6 +4704,7 @@ protected void EnsureArchitectureInitialized()
 
             // Initialize network-specific layers
             InitializeLayers();
+            ReconcileCanonicalNestedNetworkLayerViews();
             ReportLayerContractMismatches();
 
             // Pre-resolve lazy layers' shapes from the architecture so
@@ -8114,13 +8713,169 @@ ex is OverflowException ||
     protected virtual IEnumerable<LayerBase<T>?> GetExtraTrainableLayers()
         => System.Linq.Enumerable.Empty<LayerBase<T>?>();
 
-    /// <summary>
-    /// Enumerates the complete layer graph owned by a nested network after allowing that network
-    /// to initialize and resolve itself through its own architecture.
-    /// </summary>
-    /// <remarks>
-    /// Generated composite-model plumbing calls this helper instead of reading a child network's
-    /// <see cref="Layers"/> property directly. A GAN commonly constructs its generator and
+    /// <summary>One generated, stable ownership group for layers held outside <see cref="Layers"/>.</summary>
+    protected sealed class GeneratedAdditionalLayerGroup
+    {
+        internal GeneratedAdditionalLayerGroup(
+            string stableId,
+            Func<IEnumerable<ILayer<T>?>> get,
+            Action<IReadOnlyList<ILayer<T>>>? replace)
+        {
+            StableId = stableId ?? throw new ArgumentNullException(nameof(stableId));
+            Get = get ?? throw new ArgumentNullException(nameof(get));
+            Replace = replace;
+        }
+
+        internal string StableId { get; }
+        internal Func<IEnumerable<ILayer<T>?>> Get { get; }
+        internal Action<IReadOnlyList<ILayer<T>>>? Replace { get; }
+    }
+
+    /// <summary>Generated override chain describing layer-bearing fields and collections.</summary>
+    protected virtual IEnumerable<GeneratedAdditionalLayerGroup> GetGeneratedAdditionalLayerGroups()
+        => System.Linq.Enumerable.Empty<GeneratedAdditionalLayerGroup>();
+
+    /// <summary>Generated live layer views owned by nested neural networks.</summary>
+    protected virtual IEnumerable<ILayer<T>?> GetGeneratedNestedNetworkLayerViews()
+        => System.Linq.Enumerable.Empty<ILayer<T>?>();
+
+    /// <summary>
+    /// Replaces a stale published parent view after nested networks materialize their live layers.
+    /// </summary>
+    /// <remarks>
+    /// A composite can publish child layers from <see cref="InitializeLayers"/> before the child has
+    /// crossed its own readiness boundary. The child's first forward then replaces that list, leaving
+    /// the parent to serialize an abandoned graph while prediction executes the new one. Generated
+    /// ownership supplies the live view; an exact count/type mirror proves the parent list is an alias
+    /// view and can be rebound without any model-specific clone code.
+    /// </remarks>
+    private void ReconcileCanonicalNestedNetworkLayerViews()
+    {
+        var live = new List<ILayer<T>>();
+        foreach (var layer in GetGeneratedNestedNetworkLayerViews())
+        {
+            if (layer is null) continue;
+            bool seen = false;
+            for (int i = 0; i < live.Count; i++)
+            {
+                if (ReferenceEquals(live[i], layer)) { seen = true; break; }
+            }
+            if (!seen) live.Add(layer);
+        }
+
+        if (live.Count == 0 || live.Count != _layers.Count) return;
+        bool changed = false;
+        for (int i = 0; i < live.Count; i++)
+        {
+            if (_layers[i].GetType() != live[i].GetType()) return;
+            if (!ReferenceEquals(_layers[i], live[i])) changed = true;
+        }
+        if (!changed) return;
+
+        var previous = _layers.ToList();
+        _layers.Clear();
+        _layers.AddRange(live);
+        try
+        {
+            RebindLayerAliases(previous, _layers);
+        }
+        catch (InvalidOperationException)
+        {
+            _layers.Clear();
+            _layers.AddRange(previous);
+            return;
+        }
+        InvalidateParameterCountCache();
+    }
+
+    /// <summary>Whether a layer member is a view into the canonical sequential graph.</summary>
+    protected bool IsCanonicalLayerReference(ILayer<T>? candidate)
+    {
+        if (candidate is null) return false;
+        for (int i = 0; i < Layers.Count; i++)
+        {
+            if (ReferenceEquals(Layers[i], candidate)) return true;
+        }
+        return false;
+    }
+
+    /// <summary>Replaces independently-owned entries while retaining canonical graph aliases.</summary>
+    protected void ReplaceGeneratedAdditionalLayerCollection<TLayer>(
+        IList<TLayer> collection,
+        IReadOnlyList<ILayer<T>> replacements,
+        string memberName)
+        where TLayer : ILayer<T>
+    {
+        if (collection is null) throw new ArgumentNullException(nameof(collection));
+        var aliases = new List<TLayer>();
+        for (int i = 0; i < collection.Count; i++)
+        {
+            if (IsCanonicalLayerReference(collection[i])) aliases.Add(collection[i]);
+        }
+
+        collection.Clear();
+        for (int i = 0; i < aliases.Count; i++) collection.Add(aliases[i]);
+        for (int i = 0; i < replacements.Count; i++)
+        {
+            if (replacements[i] is not TLayer typed)
+            {
+                throw new InvalidDataException(
+                    $"Generated auxiliary-layer group '{memberName}' cannot accept restored type " +
+                    $"'{replacements[i].GetType().FullName}' as '{typeof(TLayer).FullName}'.");
+            }
+            collection.Add(typed);
+        }
+    }
+
+    /// <summary>Creates a nullable generated layer list when fitted topology first appears.</summary>
+    protected List<TLayer> RestoreGeneratedAdditionalLayerCollection<TLayer>(
+        List<TLayer>? collection,
+        IReadOnlyList<ILayer<T>> replacements,
+        string memberName)
+        where TLayer : ILayer<T>
+    {
+        collection ??= new List<TLayer>();
+        ReplaceGeneratedAdditionalLayerCollection(collection, replacements, memberName);
+        return collection;
+    }
+
+    /// <summary>Restores one independently-owned layer field.</summary>
+    protected TLayer? RestoreGeneratedAdditionalLayer<TLayer>(
+        TLayer? current,
+        IReadOnlyList<ILayer<T>> replacements,
+        string memberName)
+        where TLayer : class, ILayer<T>
+    {
+        if (IsCanonicalLayerReference(current)) return current;
+        if (replacements.Count == 0) return null;
+        if (replacements.Count != 1 || replacements[0] is not TLayer typed)
+        {
+            throw new InvalidDataException(
+                $"Generated auxiliary-layer field '{memberName}' expected one '{typeof(TLayer).FullName}' " +
+                $"but received {replacements.Count} incompatible entries.");
+        }
+        return typed;
+    }
+
+    /// <summary>Restores a required independently-owned layer field.</summary>
+    protected TLayer RestoreRequiredGeneratedAdditionalLayer<TLayer>(
+        TLayer current,
+        IReadOnlyList<ILayer<T>> replacements,
+        string memberName)
+        where TLayer : class, ILayer<T>
+    {
+        var restored = RestoreGeneratedAdditionalLayer(current, replacements, memberName);
+        return restored ?? throw new InvalidDataException(
+            $"Generated auxiliary-layer field '{memberName}' is required but no layer was restored.");
+    }
+
+    /// <summary>
+    /// Enumerates the complete layer graph owned by a nested network after allowing that network
+    /// to initialize and resolve itself through its own architecture.
+    /// </summary>
+    /// <remarks>
+    /// Generated composite-model plumbing calls this helper instead of reading a child network's
+    /// <see cref="Layers"/> property directly. A GAN commonly constructs its generator and
     /// discriminator lazily; reading their layer lists before their own readiness hooks run makes a
     /// structurally valid parent report zero parameters. Keeping readiness at this boundary also
     /// prevents every composite model author from having to remember the lifecycle ordering.
@@ -10796,6 +11551,13 @@ private bool TryTrainWithFusedOptimizer(
             return EmitFusedMissAndFallback("fused path sticky-disabled from prior fallback");
         if (!AiDotNet.Tensors.Engines.Optimization.TensorCodecOptions.Current.EnableCompilation)
             return EmitFusedMissAndFallback("TensorCodecOptions.EnableCompilation = false");
+        // The compiled training cache currently owns persistent storage and shape keys only for
+        // the primary input and target. Capturing AuxiliaryInput in the trace would therefore
+        // freeze the first auxiliary tensor into the replayed graph, and an auxiliary shape change
+        // would not trigger recompilation. Keep every multi-input model on the ordinary eager tape
+        // until the compiler exposes a native multi-input persistence/cache-key contract.
+        if (AuxiliaryInput is not null)
+            return EmitFusedMissAndFallback("auxiliary-input training requires the eager tape");
         // PR #319 fused-optimizer double-kernel support — paired with the
         // matching gate drop in CompiledTapeTrainingStep.TryStepWithFusedOptimizer
         // (line 232 in that file). Both float and double models can now hit
@@ -12241,7 +13003,11 @@ public virtual void LoadModel(string filePath)
     // impossible for a layer whose parameter set depends on the data it saw (EmbeddingLayer's
     // input projection). Reading v1-v4 still works and restores exactly as it did before; those
     // payloads simply carry no layout, so nothing can be mis-applied from one.
-    private const int SerializationVersion = 5;
+    // v6 persists every generated off-chain layer returned by GetExtraTrainableLayers. These
+    // layers participate in parameter counting, optimization and cloning already; omitting them
+    // from Save/Load made auxiliary GAN heads and multimodal encoder streams come back freshly
+    // initialized even though the shared parameter surface claimed to own them.
+    private const int SerializationVersion = 6;
 
     // Mirrors System.Array.MaxLength (introduced in .NET 6). Hardcoded
     // here so the check still compiles on net471, where Array.MaxLength
@@ -12256,7 +13022,7 @@ public virtual void LoadModel(string filePath)
     public virtual byte[] Serialize()
     {
         ModelPersistenceGuard.EnforceBeforeSerialize();
-        return SerializeInternalUnchecked();
+        return AiDotNet.Models.ModelStateEnvelope.Append(DeclaredState, SerializeInternalUnchecked());
     }
 
     /// <summary>
@@ -12301,6 +13067,13 @@ private byte[] SerializeInternalUnchecked()
                 paramBytes += (long)extras.ExtraParameterCount * sizeof(double);
             }
         }
+        foreach (var layer in GetExtraTrainableLayers())
+        {
+            if (layer is null) continue;
+            paramBytes += (long)layer.ParameterCount * sizeof(double);
+            if (layer is AiDotNet.NeuralNetworks.Layers.ILayerSerializationExtras<T> extras)
+                paramBytes += (long)extras.ExtraParameterCount * sizeof(double);
+        }
         long estimatedTotal = paramBytes + (long)Layers.Count * 65536 + 1024;
         // MemoryStream capacity is an int. Cap at MaxArrayLength so we never
         // request a capacity that cannot be allocated as a single byte array.
@@ -12400,6 +13173,8 @@ private byte[] SerializeInternalUnchecked()
             }
         }
 
+        WriteGeneratedAdditionalLayerState(writer);
+
         // Write network-specific data
         SerializeNetworkSpecificData(writer);
 
@@ -12412,6 +13187,9 @@ private byte[] SerializeInternalUnchecked()
     /// <param name="data">The byte array containing the serialized neural network data.</param>
     public virtual void Deserialize(byte[] data)
     {
+        // Strips and applies any declared-state trailer, so the body below reads the payload
+        // exactly as it did before this existed.
+        data = AiDotNet.Models.ModelStateEnvelope.Extract(DeclaredState, data);
         if (data is null)
             throw new ArgumentNullException(nameof(data));
         if (data.Length == 0)
@@ -12541,7 +13319,8 @@ private void DeserializeInternalUnchecked(byte[] data)
             }
 
             // Create the layer.
-            var layer = DeserializationHelper.CreateLayerFromType<T>(layerType, inputShape, outputShape, additionalParams);
+            ILayer<T> layer = DeserializationHelper.CreateLayerFromType<T>(
+                layerType, inputShape, outputShape, additionalParams);
 
             // Lazy layers need their shape resolved before SetParameters can size sub-layer
             // weights. The serialized inputShape is concrete by definition when the source
@@ -12597,6 +13376,24 @@ private void DeserializeInternalUnchecked(byte[] data)
                 extrasLayer.SetExtraParameters(extraParametersVector);
             }
 
+            // Prefer restoring into the constructor-created layer at the same canonical slot when
+            // the full layer persistence contract accepts it. This preserves readonly model fields
+            // that are aliases into Layers: replacing the canonical object would leave such a field
+            // permanently attached to the stale graph, while copying the restored state in place
+            // keeps both ownership views identical. A topology or shape that cannot be restored in
+            // place simply retains the newly reconstructed layer and follows the normal generated
+            // alias-rebinding path below.
+            if (i < previousLayers.Length
+                && previousLayers[i] is LayerBase<T> previousLayer
+                && layer is LayerBase<T> restoredLayer
+                && previousLayer.GetType() == restoredLayer.GetType()
+                && !IsProtectedCloneSourceLayer(previousLayer)
+                && TryRestoreLayerStateForClone(restoredLayer, previousLayer))
+            {
+                if (!ReferenceEquals(restoredLayer, previousLayer)) restoredLayer.Dispose();
+                layer = previousLayer;
+            }
+
             // Add the layer to the network
             _layers.Add(layer);
         }
@@ -12609,6 +13406,8 @@ private void DeserializeInternalUnchecked(byte[] data)
         // Independent layer members are left alone because rebinding is reference-identity based.
         RebindLayerAliases(previousLayers, _layers);
 
+        if (version >= 6) RestoreGeneratedAdditionalLayerState(reader);
+
         // Deserialized models should be in inference mode by default.
         // This ensures BatchNorm uses running statistics (not batch statistics)
         // and dropout is disabled, matching the behavior of the original model.
@@ -12639,7 +13438,29 @@ private void DeserializeInternalUnchecked(byte[] data)
     /// that other networks might not have.
     /// </para>
     /// </remarks>
-    protected abstract void SerializeNetworkSpecificData(BinaryWriter writer);
+    /// <remarks>
+    /// VIRTUAL, NOT ABSTRACT, AND EMPTY BY DEFAULT — for the same reason as the time series base.
+    /// Declared state already round-trips without this method: <see cref="Serialize"/> returns
+    /// <c>ModelStateEnvelope.Append(DeclaredState, ...)</c> and <see cref="Deserialize"/> begins with
+    /// the matching <c>Extract</c>, so every member a network declares — by hand in
+    /// <c>RegisterState</c> or through the generated <c>RegisterGeneratedState</c> — is written and
+    /// read by the base.
+    /// <para>
+    /// While this pair was ABSTRACT, all 947 networks in this library were REQUIRED to hand-write both
+    /// halves. That is the population ADN0060 exists to eliminate and could not report, because the
+    /// analyzer deliberately exempts an override of an abstract method: deleting an override the base
+    /// demands is impossible. Those networks were not choosing to hand-write serialization — the base
+    /// was requiring it, and a hand-written pair is two places to forget the same field.
+    /// </para>
+    /// <para>
+    /// Override this ONLY for state that genuinely cannot be declared, and prefer declaring it: a
+    /// declared member travels by name, tolerates reordering, and cannot desynchronise a reader from
+    /// a writer.
+    /// </para>
+    /// </remarks>
+    protected virtual void SerializeNetworkSpecificData(BinaryWriter writer)
+    {
+    }
 
     /// <summary>
     /// Deserializes network-specific data that was not covered by the general deserialization process.
@@ -12657,7 +13478,221 @@ private void DeserializeInternalUnchecked(byte[] data)
     /// that were stored during serialization.
     /// </para>
     /// </remarks>
-    protected abstract void DeserializeNetworkSpecificData(BinaryReader reader);
+    /// <remarks>
+    /// Virtual and empty by default, for the reason given on
+    /// <see cref="SerializeNetworkSpecificData"/>: declared state is restored by
+    /// <c>ModelStateEnvelope.Extract(DeclaredState, ...)</c> before this runs, so a network that
+    /// declares its members needs no body here at all. Override only for state that cannot be
+    /// declared, and keep it in exact lockstep with its writing half.
+    /// </remarks>
+    protected virtual void DeserializeNetworkSpecificData(BinaryReader reader)
+    {
+    }
+
+    private static string GetPersistentLayerTypeName(ILayer<T> layer)
+    {
+        var runtimeType = layer.GetType();
+        var definitionType = runtimeType.IsGenericType
+            ? runtimeType.GetGenericTypeDefinition()
+            : runtimeType;
+        return definitionType.FullName ?? definitionType.Name;
+    }
+
+    private sealed class SerializedAdditionalLayer
+    {
+        public string TypeName { get; set; } = string.Empty;
+        public int[] InputShape { get; set; } = Array.Empty<int>();
+        public int[] OutputShape { get; set; } = Array.Empty<int>();
+        public Dictionary<string, object>? Metadata { get; set; }
+        public byte[] State { get; set; } = Array.Empty<byte>();
+    }
+
+    private List<GeneratedAdditionalLayerGroup> CaptureAdditionalLayerGroups()
+    {
+        // Materialize runtime-owned lazy layers BEFORE snapshotting generated ownership groups.
+        // GetExtraTrainableLayers is allowed to build fitted/lazy topology (DocGCN does exactly
+        // that). Reading generated member groups first saw those fields as null/empty, then the
+        // runtime enumeration created them and misclassified them under the non-replaceable
+        // "$runtime" bucket. A source whose lazy path was already built saved zero runtime layers,
+        // while a fresh restore target constructed two, making the same model unable to load.
+        // Enumerate once, then let the generated member graph claim the resulting objects.
+        var extraLayers = GetExtraTrainableLayers().ToList();
+        var groups = GetGeneratedAdditionalLayerGroups().ToList();
+        var claimed = new List<object>();
+        for (int i = 0; i < groups.Count; i++)
+        {
+            foreach (var layer in groups[i].Get())
+            {
+                if (layer is not null) claimed.Add(layer);
+            }
+        }
+
+        var runtime = new List<ILayer<T>?>();
+        foreach (var layer in extraLayers)
+        {
+            if (layer is null || IsCanonicalLayerReference(layer)) continue;
+            bool generated = false;
+            for (int i = 0; i < claimed.Count; i++)
+            {
+                if (ReferenceEquals(claimed[i], layer)) { generated = true; break; }
+            }
+            if (!generated) runtime.Add(layer);
+        }
+
+        groups.Add(new GeneratedAdditionalLayerGroup("$runtime", () => runtime, replace: null));
+        return groups;
+    }
+
+    private List<ILayer<T>> IndependentLayers(GeneratedAdditionalLayerGroup group)
+    {
+        var result = new List<ILayer<T>>();
+        foreach (var layer in group.Get())
+        {
+            if (layer is not null && !IsCanonicalLayerReference(layer)) result.Add(layer);
+        }
+        return result;
+    }
+
+    private void WriteGeneratedAdditionalLayerState(BinaryWriter writer)
+    {
+        var groups = CaptureAdditionalLayerGroups();
+        writer.Write(groups.Count);
+        for (int groupIndex = 0; groupIndex < groups.Count; groupIndex++)
+        {
+            var group = groups[groupIndex];
+            writer.Write(group.StableId);
+            var layers = IndependentLayers(group);
+            writer.Write(layers.Count);
+            for (int i = 0; i < layers.Count; i++)
+            {
+                var layer = layers[i];
+                writer.Write(GetPersistentLayerTypeName(layer));
+                WriteInt32Array(writer, layer.GetInputShape());
+                WriteInt32Array(writer, layer.GetOutputShape());
+
+                var metadata = layer is LayerBase<T> layerBase
+                    ? layerBase.GetMetadata()
+                    : new Dictionary<string, string>(StringComparer.Ordinal);
+                writer.Write(metadata.Count);
+                foreach (var pair in metadata)
+                {
+                    writer.Write(pair.Key ?? string.Empty);
+                    writer.Write(pair.Value ?? string.Empty);
+                }
+
+                using var buffer = new MemoryStream();
+                using (var stateWriter = new BinaryWriter(buffer, System.Text.Encoding.UTF8, leaveOpen: true))
+                    ((LayerBase<T>)layer).Serialize(stateWriter);
+                byte[] state = buffer.ToArray();
+                writer.Write(state.Length);
+                writer.Write(state);
+            }
+        }
+    }
+
+    private void RestoreGeneratedAdditionalLayerState(BinaryReader reader)
+    {
+        var groups = CaptureAdditionalLayerGroups();
+        var byId = new Dictionary<string, GeneratedAdditionalLayerGroup>(StringComparer.Ordinal);
+        for (int i = 0; i < groups.Count; i++)
+        {
+            if (byId.ContainsKey(groups[i].StableId))
+                throw new InvalidDataException($"Duplicate generated auxiliary-layer group '{groups[i].StableId}'.");
+            byId.Add(groups[i].StableId, groups[i]);
+        }
+
+        int groupCount = reader.ReadInt32();
+        for (int groupIndex = 0; groupIndex < groupCount; groupIndex++)
+        {
+            string stableId = reader.ReadString();
+            int layerCount = reader.ReadInt32();
+            var saved = new List<SerializedAdditionalLayer>(layerCount);
+            for (int i = 0; i < layerCount; i++)
+            {
+                string typeName = reader.ReadString();
+                int[] inputShape = ReadInt32Array(reader);
+                int[] outputShape = ReadInt32Array(reader);
+                int metadataCount = reader.ReadInt32();
+                Dictionary<string, object>? metadata = metadataCount == 0
+                    ? null
+                    : new Dictionary<string, object>(metadataCount, StringComparer.Ordinal);
+                for (int m = 0; m < metadataCount; m++) metadata![reader.ReadString()] = reader.ReadString();
+                int stateLength = reader.ReadInt32();
+                byte[] state = reader.ReadBytes(stateLength);
+                if (state.Length != stateLength)
+                    throw new EndOfStreamException("Auxiliary-layer state ended before its declared length.");
+                saved.Add(new SerializedAdditionalLayer
+                {
+                    TypeName = typeName,
+                    InputShape = inputShape,
+                    OutputShape = outputShape,
+                    Metadata = metadata,
+                    State = state
+                });
+            }
+
+            if (!byId.TryGetValue(stableId, out var targetGroup))
+                throw new InvalidDataException($"Serialized auxiliary-layer group '{stableId}' is not declared by {GetType().Name}.");
+
+            var current = IndependentLayers(targetGroup);
+            bool canRestoreInPlace = current.Count == saved.Count;
+            for (int i = 0; canRestoreInPlace && i < saved.Count; i++)
+                canRestoreInPlace = string.Equals(
+                    GetPersistentLayerTypeName(current[i]), saved[i].TypeName, StringComparison.Ordinal);
+
+            if (canRestoreInPlace)
+            {
+                for (int i = 0; i < saved.Count; i++) DeserializeAdditionalLayer(current[i], saved[i]);
+                continue;
+            }
+
+            if (targetGroup.Replace is null)
+            {
+                throw new InvalidDataException(
+                    $"Serialized auxiliary-layer group '{stableId}' contains {saved.Count} layers, but " +
+                    $"the constructed model contains {current.Count} and the group is not replaceable.");
+            }
+
+            var replacements = new List<ILayer<T>>(saved.Count);
+            for (int i = 0; i < saved.Count; i++)
+            {
+                var item = saved[i];
+                var layer = DeserializationHelper.CreateLayerFromType<T>(
+                    item.TypeName, item.InputShape, item.OutputShape, item.Metadata);
+                if (layer is not LayerBase<T>)
+                    throw new InvalidDataException(
+                        $"Auxiliary layer '{item.TypeName}' was reconstructed outside LayerBase<{typeof(T).Name}>.");
+                DeserializeAdditionalLayer(layer, item);
+                replacements.Add(layer);
+            }
+            targetGroup.Replace(replacements);
+        }
+
+        InvalidateParameterCountCache();
+    }
+
+    private static void DeserializeAdditionalLayer(ILayer<T> layer, SerializedAdditionalLayer saved)
+    {
+        using var buffer = new MemoryStream(saved.State, writable: false);
+        using var stateReader = new BinaryReader(buffer, System.Text.Encoding.UTF8, leaveOpen: false);
+        ((LayerBase<T>)layer).Deserialize(stateReader);
+    }
+
+    private static void WriteInt32Array(BinaryWriter writer, int[] values)
+    {
+        writer.Write(values.Length);
+        for (int i = 0; i < values.Length; i++) writer.Write(values[i]);
+    }
+
+    private static int[] ReadInt32Array(BinaryReader reader)
+    {
+        int length = reader.ReadInt32();
+        if (length < 0 || length > 1024)
+            throw new InvalidDataException($"Invalid serialized shape rank {length}.");
+        var values = new int[length];
+        for (int i = 0; i < length; i++) values[i] = reader.ReadInt32();
+        return values;
+    }
 
     /// <summary>
     /// Creates a new neural network with the specified parameters.
@@ -13189,10 +14224,13 @@ public virtual IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy()
                         largeBase.DeserializeNetworkSpecificData(nsReader);
                     }
                 }
+                CopyDeclaredStateTo(largeBase);
+                CopyGeneratedTrainableTensorsTo(largeBase);
                 // CreateNewInstance implementations sometimes receive an Architecture whose layer
                 // objects still belong to the source. Generated aliases must always point at the
                 // destination's canonical graph before its manifest or forward path is observed.
                 largeBase.RebindLayerAliases(_layers, largeBase._layers);
+                CopyGeneratedLayerAliasesTo(largeBase);
                 largeBase.InvalidateParameterCountCache();
                 largeBase.SetTrainingMode(false);
                 // The per-layer parameter copy above skips non-trainable stochastic layers
@@ -13204,7 +14242,12 @@ public virtual IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy()
             }
         }
 
-        byte[] serialized = SerializeInternalUnchecked();
+        // Internal clones must carry the generated declared-state envelope too. Public Serialize
+        // appends it outside SerializeInternalUnchecked, while this trusted path deliberately calls
+        // the non-virtual body directly. Omitting the envelope made models whose hand-written
+        // serializers were replaced by RegisterGeneratedState lose runtime topology (for example
+        // AutoDiffTabGenerator._dataWidth) even though every layer tensor restored successfully.
+        byte[] serialized = ModelStateEnvelope.Append(DeclaredState, SerializeInternalUnchecked());
         var copy = CreateNewInstance();
         if (copy is NeuralNetworkBase<T> copyBase)
         {
@@ -13214,7 +14257,18 @@ public virtual IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy()
             // "unknown handle"). A transient in-memory clone keeps its weights resident — see the
             // matching guard in the large/custom-layer copy path above.
             copyBase.DisableAutoStreaming();
-            copyBase.DeserializeInternalUnchecked(serialized);
+            byte[] inner = ModelStateEnvelope.Extract(copyBase.DeclaredState, serialized);
+            copyBase._protectedCloneSourceLayers = _layers;
+            try
+            {
+                copyBase.DeserializeInternalUnchecked(inner);
+            }
+            finally
+            {
+                copyBase._protectedCloneSourceLayers = null;
+            }
+            CopyGeneratedLayerAliasesTo(copyBase);
+            CopyGeneratedTrainableTensorsTo(copyBase);
             CopyCloneRuntimeConfigurationTo(copyBase);
             // Base LayerBase.Serialize does NOT persist the per-layer RandomSeed, so the
             // serialize/deserialize roundtrip drops it. Transfer it (and the wired latch) so the
@@ -13248,6 +14302,10 @@ public virtual IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy()
     /// </summary>
     private bool TryDeepCopyCopyOnWrite(out IFullModel<T, Tensor<T>, Tensor<T>> result)
     {
+        // A composite may have published a child network's original layer list before the child
+        // crossed its readiness boundary. Normalize that generated alias view before creating the
+        // destination or comparing either graph, so cloning follows the graph inference executes.
+        ReconcileCanonicalNestedNetworkLayerViews();
         var copy = CreateNewInstance();
         result = copy;
         if (copy is not NeuralNetworkBase<T> copyBase)
@@ -13256,6 +14314,20 @@ private bool TryDeepCopyCopyOnWrite(out IFullModel<T, Tensor<T>, Tensor<T>> resu
             return false;
         }
 
+        bool RejectCandidate(string reason)
+        {
+            DisposeRejectedCopyOnWriteCandidate(copyBase);
+            if (string.Equals(
+                    Environment.GetEnvironmentVariable("AIDOTNET_TRACE_CLONE_REJECTION"),
+                    "1",
+                    StringComparison.Ordinal))
+            {
+                throw new InvalidOperationException(
+                    $"{GetType().Name} copy-on-write clone rejected: {reason}");
+            }
+            return false;
+        }
+
         CopyCloneRuntimeConfigurationTo(copyBase);
 
         // A COW clone keeps its (shared) weights resident; suppress its independent weight-streaming
@@ -13263,10 +14335,91 @@ private bool TryDeepCopyCopyOnWrite(out IFullModel<T, Tensor<T>, Tensor<T>> resu
         // original (same guard the eager large/serialize paths use). Must run before any SetTrainingMode.
         copyBase.DisableAutoStreaming();
 
+        // Restore model-owned configuration/topology BEFORE taking either graph snapshot. Generated
+        // declared state can legitimately rebuild a nested network in place (SpeakerVerifier owns an
+        // extractor whose Layers are also the verifier's canonical Layers), and network-specific state
+        // can similarly replace learned topology. Restoring either after COW tensor adoption invalidates
+        // the graph we just proved and can leave parent aliases pointing at the abandoned pre-restore
+        // children. Establish the final object graph first; the universal layer/tensor walk below then
+        // adopts trained storage into exactly the objects the clone will execute.
+        using (ModelPersistenceGuard.InternalOperation())
+        using (var nsStream = new System.IO.MemoryStream())
+        {
+            using (var nsWriter = new System.IO.BinaryWriter(
+                       nsStream,
+                       System.Text.Encoding.UTF8,
+                       leaveOpen: true))
+            {
+                SerializeNetworkSpecificData(nsWriter);
+                nsWriter.Flush();
+            }
+
+            if (nsStream.Length > 0)
+            {
+                nsStream.Position = 0;
+                using var nsReader = new System.IO.BinaryReader(
+                    nsStream,
+                    System.Text.Encoding.UTF8,
+                    leaveOpen: true);
+                copyBase.DeserializeNetworkSpecificData(nsReader);
+            }
+        }
+        CopyDeclaredStateTo(copyBase);
+
+        // A source may have promoted a runtime-observed shape into generated constructor state
+        // (for example NODE rebuilding its ensemble for the real feature width). Synchronize that
+        // recipe before aliases and graph snapshots; otherwise a fresh parent retains its old width
+        // and rebuilds over correctly shared children on the clone's first forward.
+        if (!TrySynchronizeRuntimeLayerConstructionState(
+                copyBase,
+                out var replacedConstructionLayers,
+                out string constructionFailure))
+        {
+            return RejectCandidate(constructionFailure);
+        }
+
         // Normalize generated named-layer views before the reflection walk. This is a no-op for the
         // normal case (aliases already point into copyBase._layers) and repairs CreateNewInstance
         // implementations that inherited references to this model's canonical graph.
-        copyBase.RebindLayerAliases(_layers, copyBase._layers);
+        try
+        {
+            copyBase.RebindLayerAliases(_layers, copyBase._layers);
+            CopyGeneratedLayerAliasesTo(copyBase);
+        }
+        catch (InvalidOperationException ex)
+        {
+            // A fitted/lazy alias collection can exist only on the source. That is a valid reason
+            // to decline the O(1) path, not a reason for Clone itself to fail: the shared eager
+            // serializer can rebuild generated auxiliary groups by stable ID and layer state.
+            foreach (var replacedLayer in replacedConstructionLayers)
+                replacedLayer.Dispose();
+            return RejectCandidate($"generated layer aliases could not be mapped: {ex.Message}");
+        }
+        foreach (var replacedLayer in replacedConstructionLayers)
+            replacedLayer.Dispose();
+
+        // A configuration blueprint can legally retain layer objects (Architecture.Layers). A
+        // constructor replay that receives that blueprint may therefore borrow the source's layer
+        // instances even though it created a new model. Detach those canonical slots through the
+        // ordinary layer persistence contract before the COW graph comparison; generated alias
+        // plumbing then redirects every nested-network view to the independent objects.
+        if (!TryDetachBorrowedCanonicalLayers(copyBase, out string detachFailure))
+            return RejectCandidate(detachFailure);
+
+        // Build the destination's architecture-known lazy structure before the reflection walk.
+        // This is shape-only readiness: it creates composite children without flattening or copying
+        // their weights. Doing it after CollectTrainableLayers is too late—the source then exposes
+        // runtime-created children that the fresh clone does not yet have, and the count mismatch
+        // rejects COW and sends the model through an eager serializer that only owns Layers.
+        copyBase.ResolveLazyLayerShapes();
+
+        // Shape/readiness work above can replace a nested network's layers. Reconcile both parent
+        // views once more before the reflection walk establishes the 1:1 COW correspondence.
+        ReconcileCanonicalNestedNetworkLayerViews();
+        CopyGeneratedLayerAliasesTo(copyBase);
+        copyBase.ReconcileCanonicalNestedNetworkLayerViews();
+        if (!TryDetachBorrowedCanonicalLayers(copyBase, out detachFailure))
+            return RejectCandidate(detachFailure);
 
         // Materialize the destination's lazy composite structure before taking
         // the reflection snapshots. TransformerDecoderLayer creates its
@@ -13303,10 +14456,13 @@ private bool TryDeepCopyCopyOnWrite(out IFullModel<T, Tensor<T>, Tensor<T>> resu
         // silently leaving the clone with fresh-random weights for those components.
         var srcLayers = AiDotNet.Helpers.CopyOnWriteCloneHelper.CollectTrainableLayers<T>(this);
         var dstLayers = AiDotNet.Helpers.CopyOnWriteCloneHelper.CollectTrainableLayers<T>(copyBase);
-        if (srcLayers.Count == 0 || srcLayers.Count != dstLayers.Count)
+        if (srcLayers.Count != dstLayers.Count)
         {
-            DisposeRejectedCopyOnWriteCandidate(copyBase);
-            return false;
+            return RejectCandidate(
+                $"source has {srcLayers.Count} trainable layers "
+                + $"[{string.Join(", ", srcLayers.Select(layer => layer.GetType().Name))}] "
+                + $"but the fresh clone has {dstLayers.Count} "
+                + $"[{string.Join(", ", dstLayers.Select(layer => layer.GetType().Name))}]");
         }
 
         // CreateNewInstance() must hand back an instance with its OWN layer objects. Some models are
@@ -13320,23 +14476,36 @@ private bool TryDeepCopyCopyOnWrite(out IFullModel<T, Tensor<T>, Tensor<T>> resu
         {
             if (ReferenceEquals(srcLayers[i], dstLayers[i]))
             {
-                DisposeRejectedCopyOnWriteCandidate(copyBase);
-                return false;
+                int sourceCanonicalIndex = _layers.FindIndex(
+                    layer => ReferenceEquals(layer, srcLayers[i]));
+                int destinationCanonicalIndex = copyBase._layers.FindIndex(
+                    layer => ReferenceEquals(layer, dstLayers[i]));
+                return RejectCandidate(
+                    $"trainable layer {i} is shared by object identity " +
+                    $"(source canonical index {sourceCanonicalIndex}, " +
+                    $"destination canonical index {destinationCanonicalIndex})");
             }
         }
 
-        // GetExtraTrainableTensors() are raw trainable tensors the model owns OUTSIDE any layer (e.g.
-        // ViT's cls_token / positional embeddings), which training DOES update. The reflection walk
-        // above shares only LAYER tensors, and ParameterCount excludes the extras — so the coverage
-        // guard below (walked layer tensors vs ParameterCount) can't detect them, and a COW share would
-        // leave the clone's extras fresh-random and diverging after training. Fall back to the eager
-        // full-fidelity copy whenever the model carries any extra trainable tensor.
-        using (var extras = GetExtraTrainableTensors().GetEnumerator())
+        // Model-owned trainable tensors live outside the layer graph (ViT/VideoCLIP tokens,
+        // Gaussian-splat attributes, recurrent state matrices). They are part of the canonical
+        // parameter surface and the copy path below already knows how to transfer their values.
+        // Snapshot and validate both sides before sharing anything so a geometry mismatch keeps the
+        // conservative eager fallback without rejecting every valid model that owns such tensors.
+        var srcStandaloneTensors = GetExtraTrainableTensors().Where(t => t is not null).ToList();
+        var dstStandaloneTensors = copyBase.GetExtraTrainableTensors().Where(t => t is not null).ToList();
+        if (srcStandaloneTensors.Count != dstStandaloneTensors.Count)
         {
-            if (extras.MoveNext())
+            return RejectCandidate(
+                $"source has {srcStandaloneTensors.Count} standalone tensors but the fresh clone has {dstStandaloneTensors.Count}");
+        }
+        for (int i = 0; i < srcStandaloneTensors.Count; i++)
+        {
+            if (!srcStandaloneTensors[i]._shape.SequenceEqual(dstStandaloneTensors[i]._shape))
             {
-                DisposeRejectedCopyOnWriteCandidate(copyBase);
-                return false;
+                return RejectCandidate(
+                    $"standalone tensor {i} has shape [{string.Join(",", srcStandaloneTensors[i]._shape)}] " +
+                    $"in the source and [{string.Join(",", dstStandaloneTensors[i]._shape)}] in the clone");
             }
         }
 
@@ -13354,6 +14523,10 @@ private bool TryDeepCopyCopyOnWrite(out IFullModel<T, Tensor<T>, Tensor<T>> resu
                 : srcLayers[i].GetTrainableParameters();
             for (int p = 0; p < tp.Count; p++) walkedParamCount += tp[p].Length;
         }
+        for (int i = 0; i < srcStandaloneTensors.Count; i++)
+        {
+            walkedParamCount += srcStandaloneTensors[i].Length;
+        }
         long manifestedTrainableCount = 0;
         foreach (var chunk in GetParameterStateChunks())
         {
@@ -13362,8 +14535,8 @@ private bool TryDeepCopyCopyOnWrite(out IFullModel<T, Tensor<T>, Tensor<T>> resu
         }
         if (walkedParamCount != manifestedTrainableCount)
         {
-            DisposeRejectedCopyOnWriteCandidate(copyBase);
-            return false;
+            return RejectCandidate(
+                $"the layer/tensor walk covers {walkedParamCount} trainable values but the manifest covers {manifestedTrainableCount}");
         }
 
         // Resolve lazy destinations and validate the complete tensor structure BEFORE sharing any
@@ -13392,12 +14565,22 @@ private bool TryDeepCopyCopyOnWrite(out IFullModel<T, Tensor<T>, Tensor<T>> resu
                                    && tensor.Shape.Length > 0
                                    && tensor.Length > 0)
                 && (!dstBase.IsShapeResolved
-                    || dstBase.GetTrainableParametersWithoutMaterialization().Count == 0))
+                    || !dstBase.GetTrainableParametersWithoutMaterialization()
+                        .Any(tensor => tensor is not null
+                                       && tensor.Shape.Length > 0
+                                       && tensor.Length > 0)))
             {
                 int[] s = srcBase.GetInputShape();
                 if (s is { Length: > 0 } && Array.TrueForAll(s, d => d > 0))
                 {
-                    try { dstBase.ResolveFromShape(s); }
+                    try
+                    {
+                        dstBase.ResolveFromShape(s);
+                        // ResolveFromShape is intentionally a no-op when construction already
+                        // established the geometry. That does not imply the placeholder tensors
+                        // have storage yet, so cross the value boundary explicitly before sharing.
+                        dstBase.MaterializeParameters();
+                    }
                     catch (ArgumentException) { /* layer rejects this shape; leave lazy */ }
                 }
             }
@@ -13408,6 +14591,32 @@ private bool TryDeepCopyCopyOnWrite(out IFullModel<T, Tensor<T>, Tensor<T>> resu
             var dp = dst is LayerBase<T> destinationLayer
                 ? destinationLayer.GetTrainableParametersWithoutMaterialization()
                 : dst.GetTrainableParameters();
+
+            if (dst is LayerBase<T> declaredDestination
+                && !declaredDestination.TrainableParametersConformToActiveDeclaration(sp))
+            {
+                return RejectCandidate(
+                    $"trainable layer {i} ({src.GetType().Name}) source tensors contradict the clone's generated shape declaration");
+            }
+
+            if (src is LayerBase<T> bufferedSource
+                && dst is LayerBase<T> bufferedDestination
+                && !bufferedDestination.CanAdoptRegisteredBuffersFrom(
+                    bufferedSource, out string bufferMismatch))
+            {
+                return RejectCandidate(
+                    $"trainable layer {i} ({src.GetType().Name}) has incompatible registered buffers: {bufferMismatch}");
+            }
+
+            // LayerBase.SetTrainableParameters is itself the universal runtime-registry adoption
+            // path. It rebinds derived fields, arrays, lists and dictionaries by tensor identity,
+            // then invokes the generated adoption hook. Rejecting that base implementation here
+            // forced every runtime-registered layer into the serialize/deserialize fallback even
+            // after the base path had learned how to update its execution handles. That fallback
+            // only owns the canonical Layers list and consequently dropped trained weights held in
+            // generated auxiliary groups. Keep the candidate and let the structural/count/shape
+            // preflight below prove whether adoption is safe; SetTrainableParameters still rejects
+            // any graph it cannot adopt.
             // A destination holding no tensors is only acceptable when the source holds none either.
             // Allowing it through while the source HAS parameters is a silent weight drop: nothing is
             // shared, no error is raised, and the clone comes back at its initialisation values --
@@ -13418,8 +14627,8 @@ private bool TryDeepCopyCopyOnWrite(out IFullModel<T, Tensor<T>, Tensor<T>> resu
                 && dstShapeOnly.IsShapeResolved;
             if (sp.Count != dp.Count && !shapeOnlyDestination)
             {
-                DisposeRejectedCopyOnWriteCandidate(copyBase);
-                return false;
+                return RejectCandidate(
+                    $"trainable layer {i} ({src.GetType().Name}) exposes {sp.Count} tensors in the source and {dp.Count} in the clone");
             }
             if (!shapeOnlyDestination)
             {
@@ -13427,8 +14636,26 @@ private bool TryDeepCopyCopyOnWrite(out IFullModel<T, Tensor<T>, Tensor<T>> resu
                 {
                     if (!sp[p]._shape.SequenceEqual(dp[p]._shape))
                     {
-                        DisposeRejectedCopyOnWriteCandidate(copyBase);
-                        return false;
+                        // A layer may adapt a construction-sized tensor to the real runtime input
+                        // (Dense after a concatenating feature extractor is the common case). The
+                        // fresh clone then has a complete but stale layout, so ResolveFromShape is
+                        // intentionally a no-op. Reuse the layer's universal shape-aware persistence
+                        // contract locally to rebuild just this child, avoiding a whole-model eager
+                        // fallback and avoiding any model-specific clone override.
+                        if (src is LayerBase<T> sourceBase
+                            && dst is LayerBase<T> destinationBase
+                            && TryRestoreLayerStateForClone(sourceBase, destinationBase))
+                        {
+                            dp = destinationBase.GetTrainableParametersWithoutMaterialization();
+                            if (sp.Count == dp.Count
+                                && sp[p]._shape.SequenceEqual(dp[p]._shape))
+                                continue;
+                        }
+
+                        return RejectCandidate(
+                            $"trainable layer {i} ({src.GetType().Name}) tensor {p} has shape " +
+                            $"[{string.Join(",", sp[p]._shape)}] in the source and " +
+                            $"[{string.Join(",", dp[p]._shape)}] in the clone");
                     }
                 }
             }
@@ -13448,14 +14675,47 @@ private bool TryDeepCopyCopyOnWrite(out IFullModel<T, Tensor<T>, Tensor<T>> resu
                 var shared = new Tensor<T>[sp.Count];
                 for (int p = 0; p < sp.Count; p++)
                     shared[p] = (Tensor<T>)sp[p].CloneShared();
-                try { dst.SetTrainableParameters(shared); }
-                catch (ArgumentException)
+                try
                 {
-                    DisposeRejectedCopyOnWriteCandidate(copyBase);
-                    return false;
+                    dst.SetTrainableParameters(shared);
+
+                    // Generated setters atomically rebind their fields, then leave an adoption signal
+                    // for LayerBase's common lazy-initialization gate. Consume that signal NOW, one node
+                    // at a time, before the clone's first real forward can interpret its earlier
+                    // shape-only resolution as permission to allocate fresh tensors over the trained
+                    // ones. The own-node boundary avoids recursively materializing foundation-scale
+                    // descendants before their corresponding COW slots are installed.
+                    if (dst is LayerBase<T> reboundDestination)
+                        reboundDestination.CommitTrainableParameterAdoption();
+                }
+                catch (Exception ex) when (ex is ArgumentException or InvalidOperationException)
+                {
+                    return RejectCandidate(
+                        $"trainable layer {i} ({src.GetType().Name}) rejected its shared tensors: {ex.Message}");
                 }
             }
 
+            // Parameter-free composite nodes still participate in shape-only lifecycle. Their
+            // first real forward is allowed to reconcile/rebuild child topology unless that
+            // boundary is committed now; doing so after the children received shared tensors
+            // discards the adopted graph while the parameter manifest continues to look correct.
+            // Commit every node, not only nodes with an own tensor list.
+            else if (dst is LayerBase<T> parameterFreeDestination)
+            {
+                parameterFreeDestination.CommitTrainableParameterAdoption();
+            }
+
+            // Registered buffers are persistent execution state outside the optimizer tensor view
+            // (reservoir matrices, running statistics, masks). The generic COW helper already
+            // adopts them, but NeuralNetworkBase's optimized path omitted the same step and could
+            // return a clone whose trainable weights matched while its forward-only state remained
+            // freshly initialized.
+            if (src is LayerBase<T> sourceWithBuffers
+                && dst is LayerBase<T> destinationWithBuffers)
+            {
+                destinationWithBuffers.AdoptRegisteredBuffersFrom(sourceWithBuffers);
+            }
+
             // Copy serialization EXTRAS (non-trainable trained state NOT in GetTrainableParameters —
             // e.g. BatchNorm running mean/variance) eagerly; they are small. SetExtraParameters
             // self-allocates and validates against the (now-resolved) destination shape, so copy whenever
@@ -13469,47 +14729,18 @@ private bool TryDeepCopyCopyOnWrite(out IFullModel<T, Tensor<T>, Tensor<T>> resu
                     try { dstExtras.SetExtraParameters(srcExtras.GetExtraParameters()); }
                     catch (ArgumentException)
                     {
-                        DisposeRejectedCopyOnWriteCandidate(copyBase);
-                        return false;
+                        return RejectCandidate(
+                            $"trainable layer {i} ({src.GetType().Name}) rejected its serialization extras");
                     }
                 }
                 else
                 {
-                    DisposeRejectedCopyOnWriteCandidate(copyBase);
-                    return false;
+                    return RejectCandidate(
+                        $"trainable layer {i} ({src.GetType().Name}) has serialization extras but the clone layer does not");
                 }
             }
         }
 
-        // Copy model-level network-specific state (e.g. TOTEM's learned VQ codebook)
-        // that lives OUTSIDE the per-layer trainable tensors / extras shared above.
-        // The COW share covers only layer tensors, so without this the clone keeps the
-        // fresh CreateNewInstance() state — for TOTEM a random codebook
-        // (InitializeCodebooks → CreateSecureRandom) — and diverges from the trained
-        // original (TOTEM Clone_AfterTraining). Round-trip through the SAME hooks the
-        // eager serialize path uses, giving the clone an INDEPENDENT deep copy (a write
-        // to either side cannot leak, unlike the shared layer tensors).
-        // InternalOperation scope: SerializeNetworkSpecificData / DeserializeNetworkSpecificData can recurse
-        // into a nested composite model's PUBLIC Serialize()/Deserialize() (GAN Generator/Discriminator,
-        // BiLSTMCRF, ...), which would otherwise trip the ModelPersistenceGuard license gate on this INTERNAL
-        // clone (LicenseRequiredException when the license server is unreachable or the trial is exhausted).
-        // This COW round-trip is the DEFAULT clone path (UseCopyOnWriteDeepCopy defaults true), so it needs
-        // the same guard as DeepCopy()'s serialize-roundtrip fallback — see that scope for the full rationale.
-        using (ModelPersistenceGuard.InternalOperation())
-        using (var nsStream = new System.IO.MemoryStream())
-        {
-            var nsWriter = new System.IO.BinaryWriter(nsStream);
-            SerializeNetworkSpecificData(nsWriter);
-            nsWriter.Flush();
-            if (nsStream.Length > 0)
-            {
-                nsStream.Position = 0;
-                var nsReader = new System.IO.BinaryReader(nsStream);
-                copyBase.DeserializeNetworkSpecificData(nsReader);
-            }
-        }
-        copyBase.RebindLayerAliases(_layers, copyBase._layers);
-
         // Copy MODEL-OWNED TRAINABLE tensors — the ones surfaced by GetExtraTrainableTensors()
         // (ViT's CLS + positional tokens, VideoCLIP's token + positional embedding tables, DCCRN's
         // complex conv weights). These are genuinely trainable and genuinely NOT in Layers, so
@@ -13524,37 +14755,119 @@ private bool TryDeepCopyCopyOnWrite(out IFullModel<T, Tensor<T>, Tensor<T>> resu
         // cannot be re-bound from here, and an independent copy means a later in-place write to
         // either side cannot leak into the other. Cheap for the same reason the per-layer extras
         // are copied eagerly — these tensors are small relative to the layer weights.
-        using (var srcExtras = GetExtraTrainableTensors().GetEnumerator())
-        using (var dstExtras = copyBase.GetExtraTrainableTensors().GetEnumerator())
+        // Re-enumerate at the value boundary in case a generated alias transfer exposes a different
+        // live view over the already-restored ownership graph.
+        var liveDstStandaloneTensors = copyBase.GetExtraTrainableTensors()
+            .Where(t => t is not null).ToList();
+        if (srcStandaloneTensors.Count != liveDstStandaloneTensors.Count)
+        {
+            return RejectCandidate(
+                $"declared-state restore changed the standalone tensor count from " +
+                $"{dstStandaloneTensors.Count} to {liveDstStandaloneTensors.Count}");
+        }
+        for (int i = 0; i < srcStandaloneTensors.Count; i++)
         {
-            while (true)
+            var srcTensor = srcStandaloneTensors[i];
+            var dstTensor = liveDstStandaloneTensors[i];
+            if (!srcTensor._shape.SequenceEqual(dstTensor._shape))
+            {
+                return RejectCandidate(
+                    $"declared-state restore changed standalone tensor {i} to shape " +
+                    $"[{string.Join(",", dstTensor._shape)}], expected [{string.Join(",", srcTensor._shape)}]");
+            }
+            for (int k = 0; k < srcTensor.Length; k++) dstTensor[k] = srcTensor[k];
+        }
+
+        copyBase.InvalidateParameterCountCache();
+        copyBase.OnParametersRestored();
+        copyBase.SetTrainingMode(false);
+
+        // Opt-in clone diagnostics compare the complete generated/base state manifest after every
+        // adoption step. This deliberately lives behind the same environment switch as rejection
+        // tracing: enumerating every scalar would be inappropriate on the normal foundation-model
+        // path, but it turns a deceptive "equal counts, different prediction" failure into the exact
+        // stable slot and value that was not transferred.
+        if (string.Equals(
+                Environment.GetEnvironmentVariable("AIDOTNET_TRACE_CLONE_REJECTION"),
+                "1",
+                StringComparison.Ordinal))
+        {
+            var sourceChunks = GetParameterStateChunks().ToList();
+            var cloneChunks = copyBase.GetParameterStateChunks().ToList();
+            if (sourceChunks.Count != cloneChunks.Count)
+            {
+                return RejectCandidate(
+                    $"the completed source manifest has {sourceChunks.Count} chunks but the clone has {cloneChunks.Count}");
+            }
+
+            for (int chunkIndex = 0; chunkIndex < sourceChunks.Count; chunkIndex++)
             {
-                bool hasSrc = srcExtras.MoveNext();
-                bool hasDst = dstExtras.MoveNext();
-                if (hasSrc != hasDst)
+                var sourceChunk = sourceChunks[chunkIndex];
+                var cloneChunk = cloneChunks[chunkIndex];
+                if (!string.Equals(sourceChunk.StableId, cloneChunk.StableId, StringComparison.Ordinal)
+                    || sourceChunk.Tensor.Length != cloneChunk.Tensor.Length)
                 {
-                    // The copy enumerates a different number of model-owned tensors than the
-                    // source. Its geometry does not match, so fall back to the eager
-                    // full-fidelity copy rather than leave the clone partially populated.
-                    DisposeRejectedCopyOnWriteCandidate(copyBase);
-                    return false;
+                    return RejectCandidate(
+                        $"completed manifest chunk {chunkIndex} differs: source '{sourceChunk.StableId}' " +
+                        $"({sourceChunk.Tensor.Length}) vs clone '{cloneChunk.StableId}' ({cloneChunk.Tensor.Length})");
                 }
-                if (!hasSrc) break;
 
-                var srcTensor = srcExtras.Current;
-                var dstTensor = dstExtras.Current;
-                if (srcTensor is null || dstTensor is null) continue;
-                if (srcTensor.Length != dstTensor.Length)
+                for (int valueIndex = 0; valueIndex < sourceChunk.Tensor.Length; valueIndex++)
                 {
-                    DisposeRejectedCopyOnWriteCandidate(copyBase);
-                    return false;
+                    if (EqualityComparer<T>.Default.Equals(
+                            sourceChunk.Tensor[valueIndex],
+                            cloneChunk.Tensor[valueIndex]))
+                        continue;
+
+                    return RejectCandidate(
+                        $"completed manifest chunk '{sourceChunk.StableId}' first differs at value {valueIndex}");
                 }
-                for (int k = 0; k < srcTensor.Length; k++) dstTensor[k] = srcTensor[k];
             }
-        }
 
-        copyBase.InvalidateParameterCountCache();
-        copyBase.SetTrainingMode(false);
+            // The parameter manifest deliberately excludes non-trainable execution state. When
+            // all parameter chunks agree but inference still drifts, compare the same complete
+            // per-layer persistence contract used by the eager fallback. Keeping this behind the
+            // opt-in trace switch avoids materializing serialization buffers in normal clones while
+            // making the first missing shape/buffer/generated-state slot immediately actionable.
+            for (int layerIndex = 0; layerIndex < srcLayers.Count; layerIndex++)
+            {
+                if (srcLayers[layerIndex] is not LayerBase<T> sourceLayer
+                    || dstLayers[layerIndex] is not LayerBase<T> cloneLayer)
+                    continue;
+
+                static byte[] SerializeLayerForCloneTrace(LayerBase<T> layer)
+                {
+                    using var stream = new System.IO.MemoryStream();
+                    using var writer = new System.IO.BinaryWriter(
+                        stream,
+                        System.Text.Encoding.UTF8,
+                        leaveOpen: true);
+                    layer.Serialize(writer);
+                    writer.Flush();
+                    return stream.ToArray();
+                }
+
+                byte[] sourceBytes = SerializeLayerForCloneTrace(sourceLayer);
+                byte[] cloneBytes = SerializeLayerForCloneTrace(cloneLayer);
+                int commonLength = Math.Min(sourceBytes.Length, cloneBytes.Length);
+                int firstDifference = -1;
+                for (int byteIndex = 0; byteIndex < commonLength; byteIndex++)
+                {
+                    if (sourceBytes[byteIndex] == cloneBytes[byteIndex]) continue;
+                    firstDifference = byteIndex;
+                    break;
+                }
+
+                if (firstDifference >= 0 || sourceBytes.Length != cloneBytes.Length)
+                {
+                    return RejectCandidate(
+                        $"completed layer state {layerIndex} ({sourceLayer.GetType().Name}) differs " +
+                        $"at byte {(firstDifference >= 0 ? firstDifference : commonLength)}: source length " +
+                        $"{sourceBytes.Length}, clone length {cloneBytes.Length}");
+                }
+            }
+
+        }
 
         // Carry each layer's per-layer RandomSeed (and the one-shot wired latch) into the clone.
         // The COW share above only re-binds TRAINABLE-layer tensors, so a non-trainable stochastic
@@ -13567,6 +14880,140 @@ private bool TryDeepCopyCopyOnWrite(out IFullModel<T, Tensor<T>, Tensor<T>> resu
         return true;
     }
 
+    private bool TryDetachBorrowedCanonicalLayers(
+        NeuralNetworkBase<T> destination,
+        out string failure)
+    {
+        var previousDestinationLayers = destination._layers.ToArray();
+        bool changed = false;
+
+        for (int destinationIndex = 0; destinationIndex < destination._layers.Count; destinationIndex++)
+        {
+            var candidate = destination._layers[destinationIndex];
+            LayerBase<T>? borrowedSource = null;
+            for (int sourceIndex = 0; sourceIndex < _layers.Count; sourceIndex++)
+            {
+                if (!ReferenceEquals(_layers[sourceIndex], candidate)) continue;
+                borrowedSource = _layers[sourceIndex] as LayerBase<T>;
+                break;
+            }
+            if (borrowedSource is null) continue;
+
+            var metadata = new Dictionary<string, object>(StringComparer.Ordinal);
+            foreach (var pair in borrowedSource.GetMetadata()) metadata[pair.Key] = pair.Value;
+
+            ILayer<T> reconstructed;
+            try
+            {
+                reconstructed = DeserializationHelper.CreateLayerFromType<T>(
+                    GetPersistentLayerTypeName(borrowedSource),
+                    borrowedSource.GetInputShape(),
+                    borrowedSource.GetOutputShape(),
+                    metadata);
+            }
+            catch (Exception ex) when (ex is ArgumentException
+                                       or InvalidOperationException
+                                       or NotSupportedException)
+            {
+                failure = $"borrowed canonical layer {destinationIndex} " +
+                          $"({borrowedSource.GetType().Name}) could not be reconstructed: {ex.Message}";
+                return false;
+            }
+
+            if (reconstructed is not LayerBase<T> independent
+                || !TryRestoreLayerStateForClone(borrowedSource, independent))
+            {
+                (reconstructed as IDisposable)?.Dispose();
+                failure = $"borrowed canonical layer {destinationIndex} " +
+                          $"({borrowedSource.GetType().Name}) rejected its persisted state";
+                return false;
+            }
+
+            destination._layers[destinationIndex] = independent;
+            changed = true;
+        }
+
+        if (changed)
+        {
+            try
+            {
+                destination.RebindLayerAliases(previousDestinationLayers, destination._layers);
+                CopyGeneratedLayerAliasesTo(destination);
+            }
+            catch (InvalidOperationException ex)
+            {
+                failure = $"borrowed canonical layer aliases could not be rebound: {ex.Message}";
+                return false;
+            }
+            destination.InvalidateParameterCountCache();
+        }
+
+        failure = string.Empty;
+        return true;
+    }
+
+    /// <summary>
+    /// Restores one mismatched child through the same layout-aware contract used by checkpoints.
+    /// This is a localized eager fallback: all matching layers remain copy-on-write shared.
+    /// </summary>
+    private static bool TryRestoreLayerStateForClone(
+        LayerBase<T> source,
+        LayerBase<T> destination)
+    {
+        if (source.GetType() != destination.GetType()) return false;
+
+        try
+        {
+            using var stream = new System.IO.MemoryStream();
+            using (var writer = new System.IO.BinaryWriter(stream, System.Text.Encoding.UTF8, leaveOpen: true))
+            {
+                source.Serialize(writer);
+                writer.Flush();
+            }
+
+            stream.Position = 0;
+            using var reader = new System.IO.BinaryReader(stream, System.Text.Encoding.UTF8, leaveOpen: true);
+            destination.Deserialize(reader);
+            return stream.Position == stream.Length;
+        }
+        catch (Exception ex) when (ex is ArgumentException
+                                   or InvalidDataException
+                                   or InvalidOperationException
+                                   or NotSupportedException)
+        {
+            return false;
+        }
+    }
+
+    /// <summary>
+    /// Copies generated/model-declared state without routing an internal clone through a public,
+    /// overridable persistence API.
+    /// </summary>
+    private void CopyDeclaredStateTo(NeuralNetworkBase<T> destination)
+    {
+        byte[] envelope = ModelStateEnvelope.Append(DeclaredState, Array.Empty<byte>());
+        byte[] inner = ModelStateEnvelope.Extract(destination.DeclaredState, envelope);
+        if (inner.Length != 0)
+            throw new InvalidOperationException("Declared-state clone envelope retained an unexpected payload.");
+    }
+
+    // Set only while an internal eager clone is deserializing. Some architecture objects retain
+    // the source's layer instances; those objects are valid rebinding evidence but must never be
+    // selected as the destination's in-place restore targets.
+    [AiDotNet.Attributes.Scratch]
+    private IReadOnlyList<ILayer<T>>? _protectedCloneSourceLayers;
+
+    private bool IsProtectedCloneSourceLayer(ILayer<T> candidate)
+    {
+        var protectedLayers = _protectedCloneSourceLayers;
+        if (protectedLayers is null) return false;
+        for (int i = 0; i < protectedLayers.Count; i++)
+        {
+            if (ReferenceEquals(protectedLayers[i], candidate)) return true;
+        }
+        return false;
+    }
+
     /// <summary>
     /// Copies public runtime training policy to an in-memory clone without copying
     /// optimizer moments or other trajectory state. These settings are deliberately
@@ -13682,7 +15129,18 @@ public virtual IFullModel<T, Tensor<T>, Tensor<T>> Clone()
     /// network before copying the data into it.
     /// </para>
     /// </remarks>
-    protected abstract IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance();
+    /// <remarks>
+    /// <para>
+    /// No longer abstract. Every concrete model used to be forced to write this, and 1147 of them
+    /// did -- each one a hand-copied list of constructor arguments that a new option could fall out
+    /// of without anything failing. The clone plan records that constructor at compile time instead,
+    /// so the base can rebuild the type and a model only overrides this when the generator says it
+    /// cannot: a constructor parameter with nothing holding its value, which the build reports by
+    /// name rather than leaving to be discovered by a clone that comes back subtly different.
+    /// </para>
+    /// </remarks>
+    protected virtual IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
+        => (IFullModel<T, Tensor<T>, Tensor<T>>)AiDotNet.Models.CloneEngine.CopyConfiguration(this);
 
     /// <summary>
     /// Sets which input features should be considered active in the neural network.
@@ -13848,6 +15306,7 @@ public virtual void SetActiveFeatureIndices(IEnumerable<int> featureIndices)
     /// <summary>
     /// Indices of features considered sensitive for fairness analysis.
     /// </summary>
+    [AiDotNet.Attributes.TrainableParameter]
     protected Vector<int> _sensitiveFeatures;
 
     /// <summary>
diff --git a/src/NeuralNetworks/NeuralTuringMachine.cs b/src/NeuralNetworks/NeuralTuringMachine.cs
index da2821b65f..dc38f4be60 100644
--- a/src/NeuralNetworks/NeuralTuringMachine.cs
+++ b/src/NeuralNetworks/NeuralTuringMachine.cs
@@ -1,4 +1,4 @@
-using AiDotNet.Attributes;
+using AiDotNet.Attributes;
 using AiDotNet.Enums;
 using AiDotNet.NeuralNetworks.Options;
 using AiDotNet.Tensors.Helpers;
@@ -47,7 +47,7 @@ namespace AiDotNet.NeuralNetworks;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Neural Turing Machines", "https://arxiv.org/abs/1410.5401", Year = 2014, Authors = "Alex Graves, Greg Wayne, Ivo Danihelka")]
-public class NeuralTuringMachine<T> : SequenceModelLayoutBase<T>, IAuxiliaryLossLayer<T>
+public partial class NeuralTuringMachine<T> : SequenceModelLayoutBase<T>, IAuxiliaryLossLayer<T>
 {
     private readonly NeuralTuringMachineOptions _options;
 
@@ -2214,186 +2214,13 @@ public override ModelMetadata<T> GetModelMetadata()
     /// Serializes NTM-specific data to a binary writer.
     /// </summary>
     /// <param name="writer">The binary writer to write to.</param>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        // Write memory configuration
-        writer.Write(_memorySize);
-        writer.Write(_memoryVectorSize);
-        writer.Write(_controllerSize);
-        writer.Write(_memories.Count);
-
-        // Write memory contents
-        foreach (var memory in _memories)
-        {
-            for (int i = 0; i < _memorySize; i++)
-            {
-                for (int j = 0; j < _memoryVectorSize; j++)
-                {
-                    writer.Write(Convert.ToDouble(memory[i, j]));
-                }
-            }
-        }
 
-        // Write read weights
-        writer.Write(_readWeights.Count);
-        foreach (var weights in _readWeights)
-        {
-            for (int i = 0; i < _memorySize; i++)
-            {
-                writer.Write(Convert.ToDouble(weights[i]));
-            }
-        }
-
-        // Write write weights
-        writer.Write(_writeWeights.Count);
-        foreach (var weights in _writeWeights)
-        {
-            for (int i = 0; i < _memorySize; i++)
-            {
-                writer.Write(Convert.ToDouble(weights[i]));
-            }
-        }
-
-        // Write the initial memory template — the canonical snapshot
-        // ResetRuntimeState copies onto every batch element at the start of
-        // each Predict. Without this, Clone reconstructs the model with a
-        // FRESH random template (constructor calls InitializeMemory), and
-        // the cloned model's first Predict resets _memories to the wrong
-        // initial state — the Predict-after-Clone output diverges from the
-        // original. presentFlag handles backward-compat with payloads
-        // written by earlier versions of this class.
-        bool templatePresent = _initialMemoryTemplate is not null;
-        writer.Write(templatePresent);
-        if (templatePresent)
-        {
-            for (int i = 0; i < _memorySize; i++)
-                for (int j = 0; j < _memoryVectorSize; j++)
-                    writer.Write(Convert.ToDouble(_initialMemoryTemplate![i, j]));
-        }
-    }
 
     /// <summary>
     /// Deserializes NTM-specific data from a binary reader.
     /// </summary>
     /// <param name="reader">The binary reader to read from.</param>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        // Read memory configuration
-        _memorySize = reader.ReadInt32();
-        _memoryVectorSize = reader.ReadInt32();
-        _controllerSize = reader.ReadInt32();
-        int memoryCount = reader.ReadInt32();
-
-        // Read memory contents
-        _memories.Clear();
-        for (int b = 0; b < memoryCount; b++)
-        {
-            var memory = new Matrix<T>(_memorySize, _memoryVectorSize);
-            for (int i = 0; i < _memorySize; i++)
-            {
-                for (int j = 0; j < _memoryVectorSize; j++)
-                {
-                    memory[i, j] = NumOps.FromDouble(reader.ReadDouble());
-                }
-            }
-            _memories.Add(memory);
-        }
-
-        // Read read weights
-        _readWeights.Clear();
-        int readWeightsCount = reader.ReadInt32();
-        for (int b = 0; b < readWeightsCount; b++)
-        {
-            var weights = new Vector<T>(_memorySize);
-            for (int i = 0; i < _memorySize; i++)
-            {
-                weights[i] = NumOps.FromDouble(reader.ReadDouble());
-            }
-            _readWeights.Add(weights);
-        }
 
-        // Read write weights
-        _writeWeights.Clear();
-        int writeWeightsCount = reader.ReadInt32();
-        for (int b = 0; b < writeWeightsCount; b++)
-        {
-            var weights = new Vector<T>(_memorySize);
-            for (int i = 0; i < _memorySize; i++)
-            {
-                weights[i] = NumOps.FromDouble(reader.ReadDouble());
-            }
-            _writeWeights.Add(weights);
-        }
-
-        // Read the initial memory template (added for #1332 cluster 1 —
-        // see SerializeNetworkSpecificData for context). The stream-bounds
-        // check protects against legacy payloads that didn't write it.
-        //
-        // Legacy serialized models (pre-#1332): the template is NOT in
-        // the payload, so _initialMemoryTemplate / _initialMemoryTensor
-        // keep whatever values the constructor's InitializeMemory()
-        // populated — fresh random draws, not the values the trained
-        // model was using. Determinism within a Predict call is still
-        // preserved (ResetRuntimeState snapshots back to the runtime
-        // template), and trained Layer parameters are restored
-        // correctly, so the model is fully usable. The only difference
-        // is that the *initial* memory state for the very first time
-        // step differs from the original training run; over a few
-        // training/inference steps memory rewrites converge regardless.
-        // Re-saving an old payload with this code writes the template
-        // and the difference goes away on the next load.
-        if (reader.BaseStream.Position < reader.BaseStream.Length)
-        {
-            bool templatePresent = reader.ReadBoolean();
-            if (templatePresent)
-            {
-                _initialMemoryTemplate = new Matrix<T>(_memorySize, _memoryVectorSize);
-                _initialMemoryTensor = new Tensor<T>([_memorySize, _memoryVectorSize]);
-                for (int i = 0; i < _memorySize; i++)
-                    for (int j = 0; j < _memoryVectorSize; j++)
-                    {
-                        T v = NumOps.FromDouble(reader.ReadDouble());
-                        _initialMemoryTemplate[i, j] = v;
-                        _initialMemoryTensor[i, j] = v;
-                    }
-            }
-        }
-    }
-
-    /// <summary>
-    /// Creates a new instance of the neural turing machine model.
-    /// </summary>
-    /// <returns>A new instance of the neural turing machine model with the same configuration.</returns>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        // Determine which constructor to use based on whether we're using scalar or vector activations
-        if (ContentAddressingVectorActivation != null || GateVectorActivation != null || OutputVectorActivation != null)
-        {
-            // Use the vector activation constructor
-            return new NeuralTuringMachine<T>(
-                Architecture,
-                _memorySize,
-                _memoryVectorSize,
-                _controllerSize,
-                LossFunction,
-                ContentAddressingVectorActivation,
-                GateVectorActivation,
-                OutputVectorActivation);
-        }
-        else
-        {
-            // Use the scalar activation constructor
-            return new NeuralTuringMachine<T>(
-                Architecture,
-                _memorySize,
-                _memoryVectorSize,
-                _controllerSize,
-                LossFunction,
-                ContentAddressingActivation,
-                GateActivation,
-                OutputActivation);
-        }
-    }
 
     /// <summary>
     /// Resets the internal state of the neural network.
diff --git a/src/NeuralNetworks/OccupancyNeuralNetwork.cs b/src/NeuralNetworks/OccupancyNeuralNetwork.cs
index ac0ee876b6..eba45e9ab9 100644
--- a/src/NeuralNetworks/OccupancyNeuralNetwork.cs
+++ b/src/NeuralNetworks/OccupancyNeuralNetwork.cs
@@ -1,4 +1,4 @@
-using AiDotNet.Attributes;
+using AiDotNet.Attributes;
 using AiDotNet.Enums;
 using AiDotNet.NeuralNetworks.Options;
 using AiDotNet.Optimizers;
@@ -37,7 +37,7 @@ namespace AiDotNet.NeuralNetworks;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Occupancy Networks: Learning 3D Reconstruction in Function Space", "https://arxiv.org/abs/1812.03828", Year = 2019, Authors = "Lars Mescheder, Michael Oechsle, Michael Niemeyer, Sebastian Nowozin, Andreas Geiger")]
-public class OccupancyNeuralNetwork<T> : VectorModelLayoutBase<T>
+public partial class OccupancyNeuralNetwork<T> : VectorModelLayoutBase<T>
 {
     private readonly OccupancyNeuralNetworkOptions _options;
 
@@ -608,24 +608,7 @@ public override ModelMetadata<T> GetModelMetadata()
     /// as it was configured.
     /// </para>
     /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        // Save temporal configuration
-        writer.Write(_includeTemporalData);
-        writer.Write(_historyWindowSize);
-
-        // Save any internal sensor history if present
-        writer.Write(_internalSensorHistory.Count);
 
-        foreach (var reading in _internalSensorHistory)
-        {
-            writer.Write(reading.Length);
-            for (int i = 0; i < reading.Length; i++)
-            {
-                writer.Write(Convert.ToDouble(reading[i]));
-            }
-        }
-    }
 
     /// <summary>
     /// Deserializes network-specific data from a binary reader.
@@ -644,66 +627,5 @@ protected override void SerializeNetworkSpecificData(BinaryWriter writer)
     /// with all its settings and internal state intact.
     /// </para>
     /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        // Load temporal configuration
-        _includeTemporalData = reader.ReadBoolean();
-        _historyWindowSize = reader.ReadInt32();
-
-        // Initialize sensor history queue
-        _internalSensorHistory = new Queue<Vector<T>>(_historyWindowSize);
-
-        // Load any saved sensor history
-        int historyCount = reader.ReadInt32();
-
-        for (int h = 0; h < historyCount; h++)
-        {
-            int readingLength = reader.ReadInt32();
-            var reading = new Vector<T>(readingLength);
-
-            for (int i = 0; i < readingLength; i++)
-            {
-                reading[i] = NumOps.FromDouble(reader.ReadDouble());
-            }
 
-            _internalSensorHistory.Enqueue(reading);
-        }
-    }
-
-    /// <summary>
-    /// Creates a new instance of the OccupancyNeuralNetwork with the same architecture and temporal configuration.
-    /// </summary>
-    /// <returns>A new instance of the occupancy neural network.</returns>
-    /// <remarks>
-    /// <para>
-    /// This method creates a new occupancy neural network with the same architecture and temporal
-    /// data processing configuration as the current instance. The new instance starts with fresh layers
-    /// and an empty sensor history buffer, making it useful for creating multiple networks with identical
-    /// configurations or for resetting a network while preserving its structure.
-    /// </para>
-    /// <para>
-    /// <b>For Beginners:</b> This creates a brand new occupancy detection network with the same settings.
-    /// 
-    /// Think of it like creating a copy of your current network's blueprint:
-    /// - It has the same structure (layers and neurons)
-    /// - It uses the same approach to time-based analysis (if enabled)
-    /// - It looks at the same number of past readings when analyzing patterns
-    /// 
-    /// However, the new network starts fresh with:
-    /// - Newly initialized weights and parameters
-    /// - An empty history buffer (no past sensor readings)
-    /// 
-    /// This is useful when you want to start over with a clean network that has
-    /// the same design but hasn't learned anything yet, or when you need multiple
-    /// identical networks for different spaces or comparison purposes.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new OccupancyNeuralNetwork<T>(
-            Architecture,
-            _includeTemporalData,
-            _historyWindowSize,
-            LossFunction);
-    }
 }
diff --git a/src/NeuralNetworks/OctonionNeuralNetwork.cs b/src/NeuralNetworks/OctonionNeuralNetwork.cs
index 9769f4593e..6b357a3f0b 100644
--- a/src/NeuralNetworks/OctonionNeuralNetwork.cs
+++ b/src/NeuralNetworks/OctonionNeuralNetwork.cs
@@ -44,7 +44,7 @@ namespace AiDotNet.NeuralNetworks;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Deep Octonion Networks", "https://arxiv.org/abs/1903.08478", Year = 2019, Authors = "Jiasong Wu et al.")]
-public class OctonionNeuralNetwork<T> : VectorModelLayoutBase<T>
+public partial class OctonionNeuralNetwork<T> : VectorModelLayoutBase<T>
 {
     private readonly OctonionNeuralNetworkOptions _options;
 
@@ -250,53 +250,9 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    /// <summary>
-    /// Serializes octonion neural network-specific data to a binary writer.
-    /// </summary>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_optimizer.GetType().FullName ?? "AdamOptimizer");
-        writer.Write(_lossFunction.GetType().FullName ?? "MeanSquaredErrorLoss");
-    }
 
-    /// <summary>
-    /// Deserializes octonion neural network-specific data from a binary reader.
-    /// </summary>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        // Read type names for forward compatibility and validation
-        string optimizerType = reader.ReadString();
-        string lossFunctionType = reader.ReadString();
-
-        // Note: Optimizer and loss function instances should be provided during construction.
-        // The type names are read for data integrity verification but new instances
-        // need to be created via the constructor or a dedicated factory method.
-        _ = optimizerType;
-        _ = lossFunctionType;
-    }
 
-    /// <summary>
-    /// Creates a new instance of the OctonionNeuralNetwork with the same configuration.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// This creates a fresh network instance with a new optimizer to avoid state conflicts.
-    /// Sharing an optimizer instance between networks would cause training issues since
-    /// the optimizer maintains internal state (momentum, adaptive learning rates, etc.)
-    /// that is specific to each network's parameters.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        // Pass null for optimizer to create a fresh optimizer for the new instance.
-        // Sharing optimizer instances between networks causes state conflicts since
-        // optimizers maintain internal state (momentum, etc.) tied to specific parameters.
-        return new OctonionNeuralNetwork<T>(
-            Architecture,
-            null, // Create fresh optimizer - don't share _optimizer
-            _lossFunction,
-            Convert.ToDouble(MaxGradNorm));
-    }
+
 
     /// <summary>
     /// Indicates whether this network supports training.
diff --git a/src/NeuralNetworks/Pix2Pix.cs b/src/NeuralNetworks/Pix2Pix.cs
index cdd45617bf..43d12b88cd 100644
--- a/src/NeuralNetworks/Pix2Pix.cs
+++ b/src/NeuralNetworks/Pix2Pix.cs
@@ -705,68 +705,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(NumOps.ToDouble(_l1Lambda));
-
-        // Serialize loss histories
-        writer.Write(_generatorLosses.Count);
-        foreach (var loss in _generatorLosses)
-            writer.Write(NumOps.ToDouble(loss));
-
-        writer.Write(_discriminatorLosses.Count);
-        foreach (var loss in _discriminatorLosses)
-            writer.Write(NumOps.ToDouble(loss));
 
-        var generatorBytes = Generator.Serialize();
-        writer.Write(generatorBytes.Length);
-        writer.Write(generatorBytes);
-
-        var discriminatorBytes = Discriminator.Serialize();
-        writer.Write(discriminatorBytes.Length);
-        writer.Write(discriminatorBytes);
-    }
 
     /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        double l1Val = reader.ReadDouble();
-        if (l1Val < 0 || double.IsNaN(l1Val) || double.IsInfinity(l1Val))
-            throw new InvalidOperationException($"Deserialized invalid l1Lambda: {l1Val}");
-        _l1Lambda = NumOps.FromDouble(l1Val);
-
-        // Deserialize loss histories
-        _generatorLosses.Clear();
-        int genLossCount = reader.ReadInt32();
-        for (int i = 0; i < genLossCount; i++)
-            _generatorLosses.Add(NumOps.FromDouble(reader.ReadDouble()));
-
-        _discriminatorLosses.Clear();
-        int discLossCount = reader.ReadInt32();
-        for (int i = 0; i < discLossCount; i++)
-            _discriminatorLosses.Add(NumOps.FromDouble(reader.ReadDouble()));
-
-        int generatorDataLength = reader.ReadInt32();
-        byte[] generatorData = reader.ReadBytes(generatorDataLength);
-        Generator.Deserialize(generatorData);
-
-        int discriminatorDataLength = reader.ReadInt32();
-        byte[] discriminatorData = reader.ReadBytes(discriminatorDataLength);
-        Discriminator.Deserialize(discriminatorData);
-    }
 
-    /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new Pix2Pix<T>(
-            Generator.Architecture,
-            Discriminator.Architecture,
-            Architecture.InputType,
-            null, // Use default optimizer
-            null, // Use default optimizer
-            _lossFunction,
-            NumOps.ToDouble(_l1Lambda));
-    }
 
     // UpdateParameters split the vector between Generator and Discriminator; GetExtraTrainableLayers
     // yields the same two in the same order, so the base reproduces the split. Removed under AIDN082.
diff --git a/src/NeuralNetworks/ProgressiveGAN.cs b/src/NeuralNetworks/ProgressiveGAN.cs
index dd3c2df6b7..6da8455443 100644
--- a/src/NeuralNetworks/ProgressiveGAN.cs
+++ b/src/NeuralNetworks/ProgressiveGAN.cs
@@ -47,7 +47,7 @@ namespace AiDotNet.NeuralNetworks;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Progressive Growing of GANs for Improved Quality, Stability, and Variation", "https://arxiv.org/abs/1710.10196", Year = 2018, Authors = "Tero Karras, Timo Aila, Samuli Laine, Jaakko Lehtinen")]
-public class ProgressiveGAN<T> : GenerativeAdversarialNetwork<T>
+public partial class ProgressiveGAN<T> : GenerativeAdversarialNetwork<T>
 {
     private const double DefaultLearningRate = 0.001;
     private const double DefaultLearningRateDecay = 0.9999;
@@ -173,21 +173,6 @@ public ProgressiveGAN(
     {
     }
 
-    /// <summary>
-    /// Constructs a fresh ProgressiveGAN with the same hyperparameters so Clone /
-    /// DeepCopy rebuilds both architectures from scratch. Mirrors <see cref="DCGAN{T}"/>.
-    /// </summary>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new ProgressiveGAN<T>(
-            _latentSize,
-            _imageChannels,
-            _maxResolutionLevel,
-            _baseFeatureMaps,
-            lossFunction: LossFunction,
-            options: _options);
-    }
-
     /// <summary>
     /// Builds the paper-faithful generator architecture: a 1D latent vector projected by
     /// a dense layer, reshaped into a small spatial feature map, then upsampled by
diff --git a/src/NeuralNetworks/QuantumNeuralNetwork.cs b/src/NeuralNetworks/QuantumNeuralNetwork.cs
index 61f0bd7115..955b5d0fd3 100644
--- a/src/NeuralNetworks/QuantumNeuralNetwork.cs
+++ b/src/NeuralNetworks/QuantumNeuralNetwork.cs
@@ -1,4 +1,4 @@
-using AiDotNet.Attributes;
+using AiDotNet.Attributes;
 using AiDotNet.Enums;
 using AiDotNet.NeuralNetworks.Options;
 using AiDotNet.Preprocessing;
@@ -46,7 +46,7 @@ namespace AiDotNet.NeuralNetworks;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
     [ResearchPaper("Parameterized Quantum Circuits as Machine Learning Models", "https://arxiv.org/abs/1906.07682")]
-public class QuantumNeuralNetwork<T> : VectorModelLayoutBase<T>
+public partial class QuantumNeuralNetwork<T> : VectorModelLayoutBase<T>
 {
     private readonly QuantumNeuralNetworkOptions _options;
 
@@ -320,41 +320,9 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    /// <summary>
-    /// Serializes quantum neural network-specific data to a binary writer.
-    /// </summary>
-    /// <param name="writer">The BinaryWriter to write the data to.</param>
-    /// <remarks>
-    /// <para>
-    /// This method writes the specific parameters and state of the quantum neural network to a binary stream.
-    /// </para>
-    /// <para>
-    /// <b>For Beginners:</b> This saves the current state of the quantum neural network to a file.
-    /// It records all the important information about the network so you can reload it later exactly as it is now.
-    /// </para>
-    /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_numQubits);
-    }
 
-    /// <summary>
-    /// Deserializes quantum neural network-specific data from a binary reader.
-    /// </summary>
-    /// <param name="reader">The BinaryReader to read the data from.</param>
-    /// <remarks>
-    /// <para>
-    /// This method reads the specific parameters and state of the quantum neural network from a binary stream.
-    /// </para>
-    /// <para>
-    /// <b>For Beginners:</b> This loads a saved quantum neural network state from a file. It rebuilds the
-    /// network exactly as it was when you saved it, including all its learned information and quantum-specific settings.
-    /// </para>
-    /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _numQubits = reader.ReadInt32();
-    }
+
+
 
     /// <summary>
     /// Prepares a quantum state from a classical input tensor.
@@ -576,45 +544,4 @@ private Tensor<Complex<T>> ConvertToComplexTensor(Vector<T> realVector)
 
         return complexTensor;
     }
-
-    /// <summary>
-    /// Creates a new instance of the quantum neural network with the same configuration.
-    /// </summary>
-    /// <returns>
-    /// A new instance of <see cref="QuantumNeuralNetwork{T}"/> with the same configuration as the current instance.
-    /// </returns>
-    /// <remarks>
-    /// <para>
-    /// This method creates a new quantum neural network that has the same configuration as the current instance.
-    /// It's used for model persistence, cloning, and transferring the model's configuration to new instances.
-    /// The new instance will have the same architecture, number of qubits, normalizer, and loss function
-    /// as the original, but will not share parameter values unless they are explicitly copied after creation.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method makes a fresh copy of the current model with the same settings.
-    /// 
-    /// It's like creating a blueprint copy of your quantum neural network that can be used to:
-    /// - Save your model's settings
-    /// - Create a new identical model
-    /// - Transfer your model's configuration to another system
-    /// 
-    /// This is useful when you want to:
-    /// - Create multiple similar quantum neural networks
-    /// - Save a model's configuration for later use
-    /// - Reset a model while keeping its quantum-specific settings
-    /// 
-    /// Note that while the settings are copied, the learned parameters are not automatically
-    /// transferred, so the new instance will need training or parameter copying to match
-    /// the performance of the original.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        // Create a new instance with the cloned architecture and same configuration
-        return new QuantumNeuralNetwork<T>(
-            Architecture,
-            _numQubits,
-            _preprocessingPipeline,
-            LossFunction
-        );
-    }
 }
diff --git a/src/NeuralNetworks/RWKV4LanguageModel.cs b/src/NeuralNetworks/RWKV4LanguageModel.cs
index 1b13db2d67..3395260a9c 100644
--- a/src/NeuralNetworks/RWKV4LanguageModel.cs
+++ b/src/NeuralNetworks/RWKV4LanguageModel.cs
@@ -64,7 +64,7 @@ namespace AiDotNet.NeuralNetworks;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("RWKV: Reinventing RNNs for the Transformer Era", "https://arxiv.org/abs/2305.13048", Year = 2023, Authors = "Bo Peng, Eric Alcaide, Quentin Anthony, Alon Albalak, Samuel Arcadinho, Stella Biderman, Huanqi Cao, Xin Cheng, Michael Chung, Matteo Grella, Kranthi Kiran GV, Xuzheng He, Haowen Hou, Przemyslaw Kazienko, Jan Kocon, Jiaming Kong, Bartlomiej Koptyra, Hayden Lau, Krishna Sri Ipsit Mantri, Ferdinand Mom, Atsushi Saito, Xiangru Tang, Bolun Wang, Johan S. Wind, Stanislaw Wozniak, Ruichong Zhang, Zhenyuan Zhang, Qihang Zhao, Peng Zhou, Jian Zhu, Rui-Jie Zhu")]
-public class RWKV4LanguageModel<T> : TokenLanguageModelLayoutBase<T>
+public partial class RWKV4LanguageModel<T> : TokenLanguageModelLayoutBase<T>
 {
     private readonly RWKV4Options _options;
     private readonly int _vocabSize;
@@ -210,38 +210,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc />
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_vocabSize);
-        writer.Write(_modelDimension);
-        writer.Write(_numLayers);
-        writer.Write(_maxSeqLength);
-    }
 
-    /// <inheritdoc />
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        int vocabSize = reader.ReadInt32();
-        int modelDimension = reader.ReadInt32();
-        int numLayers = reader.ReadInt32();
-        int maxSeqLength = reader.ReadInt32();
-
-        if (vocabSize != _vocabSize || modelDimension != _modelDimension ||
-            numLayers != _numLayers || maxSeqLength != _maxSeqLength)
-        {
-            throw new InvalidOperationException(
-                $"Deserialized dimensions (vocab={vocabSize}, dim={modelDimension}, layers={numLayers}, seq={maxSeqLength}) " +
-                $"do not match instance (vocab={_vocabSize}, dim={_modelDimension}, layers={_numLayers}, seq={_maxSeqLength}).");
-        }
-    }
 
     /// <inheritdoc />
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new RWKV4LanguageModel<T>(
-            Architecture, _vocabSize, _modelDimension, _numLayers, _maxSeqLength,
-            LossFunction, _options);
-    }
+
 
     #endregion
 }
diff --git a/src/NeuralNetworks/RWKV7LanguageModel.cs b/src/NeuralNetworks/RWKV7LanguageModel.cs
index 377a0d323e..c05ad64213 100644
--- a/src/NeuralNetworks/RWKV7LanguageModel.cs
+++ b/src/NeuralNetworks/RWKV7LanguageModel.cs
@@ -36,7 +36,7 @@ namespace AiDotNet.NeuralNetworks;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("RWKV: Reinventing RNNs for the Transformer Era", "https://arxiv.org/abs/2305.13048", Year = 2023, Authors = "Bo Peng, Eric Alcaide, Quentin Anthony, Alon Albalak, Samuel Arcadinho, Stella Biderman, Huanqi Cao, Xin Cheng, Michael Chung, Matteo Grella, Kranthi Kiran GV, Xuzheng He, Haowen Hou, Przemyslaw Kazienko, Jan Kocon, Jiaming Kong, Bartlomiej Koptyra, Hayden Lau, Krishna Sri Ipsit Mantri, Ferdinand Mom, Atsushi Saito, Xiangru Tang, Bolun Wang, Johan S. Wind, Stanislaw Wozniak, Ruichong Zhang, Zhenyuan Zhang, Qihang Zhao, Peng Zhou, Jian Zhu, Rui-Jie Zhu")]
-public class RWKV7LanguageModel<T> : TokenLanguageModelLayoutBase<T>
+public partial class RWKV7LanguageModel<T> : TokenLanguageModelLayoutBase<T>
 {
     private readonly RWKV7Options _options;
     private readonly int _vocabSize;
@@ -165,32 +165,9 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_vocabSize);
-        writer.Write(_modelDimension);
-        writer.Write(_numLayers);
-        writer.Write(_numHeads);
-        writer.Write(_ffnMultiplier);
-        writer.Write(_maxSeqLength);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _ = reader.ReadInt32();
-        _ = reader.ReadInt32();
-        _ = reader.ReadInt32();
-        _ = reader.ReadInt32();
-        _ = reader.ReadDouble();
-        _ = reader.ReadInt32();
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new RWKV7LanguageModel<T>(
-            Architecture, _vocabSize, _modelDimension, _numLayers, _numHeads,
-            _ffnMultiplier, _maxSeqLength, LossFunction, _options);
-    }
+
 
     #endregion
 }
diff --git a/src/NeuralNetworks/RadialBasisFunctionNetwork.cs b/src/NeuralNetworks/RadialBasisFunctionNetwork.cs
index e6362ea5c4..d1e8ec4f32 100644
--- a/src/NeuralNetworks/RadialBasisFunctionNetwork.cs
+++ b/src/NeuralNetworks/RadialBasisFunctionNetwork.cs
@@ -50,7 +50,7 @@ namespace AiDotNet.NeuralNetworks;
 [ModelComplexity(ModelComplexity.Low)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
     [ResearchPaper("Radial Basis Functions", "https://doi.org/10.1017/CBO9780511543241")]
-public class RadialBasisFunctionNetwork<T> : VectorModelLayoutBase<T>
+public partial class RadialBasisFunctionNetwork<T> : VectorModelLayoutBase<T>
 {
     private readonly RadialBasisFunctionNetworkOptions _options;
     private readonly IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>> _optimizer;
@@ -457,15 +457,7 @@ public override ModelMetadata<T> GetModelMetadata()
     /// It's like writing down a recipe so you can make the same dish again in the future.
     /// </para>
     /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        // Write RBFN-specific data
-        writer.Write(_inputSize);
-        writer.Write(_hiddenSize);
-        writer.Write(_outputSize);
 
-        SerializationHelper<T>.SerializeInterface(writer, _radialBasisFunction);
-    }
 
     /// <summary>
     /// Deserializes network-specific data for the Radial Basis Function Network.
@@ -487,50 +479,5 @@ protected override void SerializeNetworkSpecificData(BinaryWriter writer)
     /// It's like following a recipe to recreate a dish exactly as it was made before.
     /// </para>
     /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        // Read RBFN-specific data
-        _inputSize = reader.ReadInt32();
-        _hiddenSize = reader.ReadInt32();
-        _outputSize = reader.ReadInt32();
-
-        // Read and set the radial basis function if a custom one was used
-        _radialBasisFunction = DeserializationHelper.DeserializeInterface<IRadialBasisFunction<T>>(reader) ?? new GaussianRBF<T>();
-    }
 
-    /// <summary>
-    /// Creates a new instance of the radial basis function network with the same configuration.
-    /// </summary>
-    /// <returns>
-    /// A new instance of <see cref="RadialBasisFunctionNetwork{T}"/> with the same configuration as the current instance.
-    /// </returns>
-    /// <remarks>
-    /// <para>
-    /// This method creates a new radial basis function network that has the same configuration as the current instance.
-    /// It's used for model persistence, cloning, and transferring the model's configuration to new instances.
-    /// The new instance will have the same architecture and radial basis function type as the original,
-    /// but will not share parameter values unless they are explicitly copied after creation.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method makes a fresh copy of the current model with the same settings.
-    /// 
-    /// It's like creating a blueprint copy of your network that can be used to:
-    /// - Save your model's settings
-    /// - Create a new identical model
-    /// - Transfer your model's configuration to another system
-    /// 
-    /// This is useful when you want to:
-    /// - Create multiple similar radial basis function networks
-    /// - Save a model's configuration for later use
-    /// - Reset a model while keeping its settings
-    /// 
-    /// Note that while the settings are copied, the learned parameters (like the centers of the "experts" 
-    /// and the output weights) are not automatically transferred, so the new instance will need training 
-    /// or parameter copying to match the performance of the original.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        // Create a new instance with the cloned architecture and RBF
-        return new RadialBasisFunctionNetwork<T>(Architecture, _radialBasisFunction, lossFunction: LossFunction);
-    }
 }
diff --git a/src/NeuralNetworks/RecurrentGemmaLanguageModel.cs b/src/NeuralNetworks/RecurrentGemmaLanguageModel.cs
index f3c0eee7b0..9cb25f8457 100644
--- a/src/NeuralNetworks/RecurrentGemmaLanguageModel.cs
+++ b/src/NeuralNetworks/RecurrentGemmaLanguageModel.cs
@@ -35,7 +35,7 @@ namespace AiDotNet.NeuralNetworks;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("RecurrentGemma: Moving Past Transformers for Efficient Open Language Models", "https://arxiv.org/abs/2404.07839", Year = 2024, Authors = "Aleksandar Botev, Soham De, Samuel L. Smith, Anushan Fernando, George-Cristian Muraru, Ruba Haroun, Leonard Berrada, Razvan Pascanu, Pier Giuseppe Sessa, Robert Dadashi, Leonard Hussenot, Johan Ferret, Sertan Girgin, Olivier Bachem, Alek Andreev, Kathleen Kenealy, Thomas Mesnard, Cassidy Hardin, Surya Bhupatiraju, Shreya Pathak, Laurent Sifre, Morgane Riviere, Mihir Sanjay Kale, Juliette Love, Pouya Tafti, Armand Joulin, Noah Fiedel, Evan Senter, Yutian Chen, Srivatsan Srinivasan, Guillaume Desjardins, David Budden, Arnaud Doucet, Koray Kavukcuoglu, Nando De Freitas")]
-public class RecurrentGemmaLanguageModel<T> : TokenLanguageModelLayoutBase<T>
+public partial class RecurrentGemmaLanguageModel<T> : TokenLanguageModelLayoutBase<T>
 {
     private readonly RecurrentGemmaOptions _options;
     private readonly int _vocabSize;
@@ -161,28 +161,9 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_vocabSize);
-        writer.Write(_modelDimension);
-        writer.Write(_numLayers);
-        writer.Write(_maxSeqLength);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _ = reader.ReadInt32();
-        _ = reader.ReadInt32();
-        _ = reader.ReadInt32();
-        _ = reader.ReadInt32();
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new RecurrentGemmaLanguageModel<T>(
-            Architecture, _vocabSize, _modelDimension, _numLayers, _maxSeqLength,
-            LossFunction, _options);
-    }
+
 
     #endregion
 }
diff --git a/src/NeuralNetworks/RecurrentNeuralNetwork.cs b/src/NeuralNetworks/RecurrentNeuralNetwork.cs
index 0ffd997175..36a40d2dc8 100644
--- a/src/NeuralNetworks/RecurrentNeuralNetwork.cs
+++ b/src/NeuralNetworks/RecurrentNeuralNetwork.cs
@@ -1,4 +1,4 @@
-using AiDotNet.Attributes;
+using AiDotNet.Attributes;
 using AiDotNet.Enums;
 using AiDotNet.NeuralNetworks.Options;
 
@@ -53,7 +53,7 @@ namespace AiDotNet.NeuralNetworks;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Learning Long-Term Dependencies with Gradient Descent is Difficult", "https://doi.org/10.1109/72.279181")]
-public class RecurrentNeuralNetwork<T> : SequenceModelLayoutBase<T>
+public partial class RecurrentNeuralNetwork<T> : SequenceModelLayoutBase<T>
 {
     private readonly RecurrentNeuralNetworkOptions _options;
 
@@ -341,90 +341,7 @@ public override ModelMetadata<T> GetModelMetadata()
         return metadata;
     }
 
-    /// <summary>
-    /// Serializes network-specific data for the Recurrent Neural Network.
-    /// </summary>
-    /// <param name="writer">The BinaryWriter to write the data to.</param>
-    /// <remarks>
-    /// <para>
-    /// This method writes the specific configuration and state of the RNN to a binary stream.
-    /// It includes RNN-specific parameters that are essential for later reconstruction of the network.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method saves the unique settings of your RNN.
-    /// 
-    /// It writes:
-    /// - The size of the hidden state (which determines the network's memory capacity)
-    /// - The length of sequences the network is designed to handle
-    /// - Any other RNN-specific parameters
-    /// 
-    /// Saving these details allows you to recreate the exact same network structure later.
-    /// It's like writing down a recipe so you can make the same dish again in the future.
-    /// </para>
-    /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(Convert.ToDouble(_learningRate));
-    }
 
-    /// <summary>
-    /// Deserializes network-specific data for the Recurrent Neural Network.
-    /// </summary>
-    /// <param name="reader">The BinaryReader to read the data from.</param>
-    /// <remarks>
-    /// <para>
-    /// This method reads the specific configuration and state of the RNN from a binary stream.
-    /// It reconstructs the RNN-specific parameters to match the state of the network when it was serialized.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method loads the unique settings of your RNN.
-    /// 
-    /// It reads:
-    /// - The size of the hidden state (which determines the network's memory capacity)
-    /// - The length of sequences the network is designed to handle
-    /// - Any other RNN-specific parameters
-    /// 
-    /// Loading these details allows you to recreate the exact same network structure that was previously saved.
-    /// It's like following a recipe to recreate a dish exactly as it was made before.
-    /// </para>
-    /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _learningRate = NumOps.FromDouble(reader.ReadDouble());
-    }
 
-    /// <summary>
-    /// Creates a new instance of the recurrent neural network with the same configuration.
-    /// </summary>
-    /// <returns>
-    /// A new instance of <see cref="RecurrentNeuralNetwork{T}"/> with the same configuration as the current instance.
-    /// </returns>
-    /// <remarks>
-    /// <para>
-    /// This method creates a new recurrent neural network that has the same configuration as the current instance.
-    /// It's used for model persistence, cloning, and transferring the model's configuration to new instances.
-    /// The new instance will have the same architecture and learning rate as the original,
-    /// but will not share parameter values unless they are explicitly copied after creation.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method makes a fresh copy of the current model with the same settings.
-    /// 
-    /// It's like creating a blueprint copy of your network that can be used to:
-    /// - Save your model's settings
-    /// - Create a new identical model
-    /// - Transfer your model's configuration to another system
-    /// 
-    /// This is useful when you want to:
-    /// - Create multiple similar recurrent neural networks
-    /// - Save a model's configuration for later use
-    /// - Reset a model while keeping its settings
-    /// 
-    /// Note that while the settings are copied, the learned parameters (like the weights that determine
-    /// how the network processes sequences) are not automatically transferred, so the new instance
-    /// will need training or parameter copying to match the performance of the original.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        // Create a new instance with the cloned architecture and the same learning rate
-        double learningRate = Convert.ToDouble(_learningRate);
-        return new RecurrentNeuralNetwork<T>(Architecture, learningRate, LossFunction);
-    }
+
 }
diff --git a/src/NeuralNetworks/ResNetNetwork.cs b/src/NeuralNetworks/ResNetNetwork.cs
index 53413214a6..9a5d6a4925 100644
--- a/src/NeuralNetworks/ResNetNetwork.cs
+++ b/src/NeuralNetworks/ResNetNetwork.cs
@@ -59,7 +59,7 @@ namespace AiDotNet.NeuralNetworks;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Deep Residual Learning for Image Recognition", "https://arxiv.org/abs/1512.03385", Year = 2016, Authors = "Kaiming He, Xiangyu Zhang, Shaoqing Ren, Jian Sun")]
-public class ResNetNetwork<T> : ImageClassifierModelLayoutBase<T>
+public partial class ResNetNetwork<T> : ImageClassifierModelLayoutBase<T>
 {
     private readonly ResNetOptions _options;
 
@@ -580,80 +580,10 @@ public override ModelMetadata<T> GetModelMetadata()
     /// <summary>
     /// Serializes ResNet network-specific data to a binary writer.
     /// </summary>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write((int)_configuration.Variant);
-        writer.Write(_configuration.NumClasses);
-        writer.Write(_configuration.InputHeight);
-        writer.Write(_configuration.InputWidth);
-        writer.Write(_configuration.InputChannels);
-        writer.Write(_configuration.IncludeClassifier);
-        writer.Write(_configuration.ZeroInitResidual);
-        writer.Write(_configuration.UseAutodiff);
-    }
+
 
     /// <summary>
     /// Deserializes ResNet network-specific data from a binary reader.
     /// </summary>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        var variant = (ResNetVariant)reader.ReadInt32();
-        var numClasses = reader.ReadInt32();
-        var inputHeight = reader.ReadInt32();
-        var inputWidth = reader.ReadInt32();
-        var inputChannels = reader.ReadInt32();
-        var includeClassifier = reader.ReadBoolean();
-        var zeroInitResidual = reader.ReadBoolean();
-        _ = reader.ReadBoolean(); // useAutodiff
-
-        // Validate loaded configuration matches current
-        if (variant != _configuration.Variant)
-        {
-            throw new InvalidOperationException(
-                $"Serialized ResNet variant ({variant}) does not match current configuration ({_configuration.Variant}).");
-        }
-
-        if (numClasses != _configuration.NumClasses)
-        {
-            throw new InvalidOperationException(
-                $"Serialized number of classes ({numClasses}) does not match current configuration ({_configuration.NumClasses}).");
-        }
-
-        if (inputHeight != _configuration.InputHeight || inputWidth != _configuration.InputWidth)
-        {
-            throw new InvalidOperationException(
-                $"Serialized input dimensions ({inputHeight}x{inputWidth}) do not match current configuration ({_configuration.InputHeight}x{_configuration.InputWidth}).");
-        }
-
-        if (inputChannels != _configuration.InputChannels)
-        {
-            throw new InvalidOperationException(
-                $"Serialized input channels ({inputChannels}) does not match current configuration ({_configuration.InputChannels}).");
-        }
 
-        if (includeClassifier != _configuration.IncludeClassifier)
-        {
-            throw new InvalidOperationException(
-                $"Serialized includeClassifier ({includeClassifier}) does not match current configuration ({_configuration.IncludeClassifier}).");
-        }
-
-        if (zeroInitResidual != _configuration.ZeroInitResidual)
-        {
-            throw new InvalidOperationException(
-                $"Serialized zeroInitResidual ({zeroInitResidual}) does not match current configuration ({_configuration.ZeroInitResidual}).");
-        }
-    }
-
-    /// <summary>
-    /// Creates a new instance of the ResNet network model.
-    /// </summary>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new ResNetNetwork<T>(
-            Architecture,
-            _configuration,
-            null,
-            _lossFunction,
-            MaxGradNormValue);
-    }
 }
diff --git a/src/NeuralNetworks/ResidualNeuralNetwork.cs b/src/NeuralNetworks/ResidualNeuralNetwork.cs
index de365fe7eb..0b97814b29 100644
--- a/src/NeuralNetworks/ResidualNeuralNetwork.cs
+++ b/src/NeuralNetworks/ResidualNeuralNetwork.cs
@@ -751,13 +751,7 @@ public override ModelMetadata<T> GetModelMetadata()
     /// Saving them allows you to recreate the exact same training setup later.
     /// </para>
     /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        // Write training parameters
-        writer.Write(_epochs);
-        writer.Write(Convert.ToDouble(_learningRate));
-        writer.Write(_batchSize);
-    }
+
 
     /// <summary>
     /// Deserializes network-specific data for the Residual Neural Network.
@@ -780,53 +774,5 @@ protected override void SerializeNetworkSpecificData(BinaryWriter writer)
     /// with the exact same configuration it had when it was saved.
     /// </para>
     /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        // Read training parameters
-        _epochs = reader.ReadInt32();
-        _learningRate = NumOps.FromDouble(reader.ReadDouble());
-        _batchSize = reader.ReadInt32();
-    }
 
-    /// <summary>
-    /// Creates a new instance of the residual neural network with the same configuration.
-    /// </summary>
-    /// <returns>
-    /// A new instance of <see cref="ResidualNeuralNetwork{T}"/> with the same configuration as the current instance.
-    /// </returns>
-    /// <remarks>
-    /// <para>
-    /// This method creates a new residual neural network that has the same configuration as the current instance.
-    /// It's used for model persistence, cloning, and transferring the model's configuration to new instances.
-    /// The new instance will have the same architecture, learning rate, epochs, batch size, and loss function
-    /// as the original, but will not share parameter values unless they are explicitly copied after creation.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method makes a fresh copy of the current model with the same settings.
-    /// 
-    /// It's like creating a blueprint copy of your network that can be used to:
-    /// - Save your model's settings
-    /// - Create a new identical model
-    /// - Transfer your model's configuration to another system
-    /// 
-    /// This is useful when you want to:
-    /// - Create multiple similar residual neural networks
-    /// - Save a model's configuration for later use
-    /// - Reset a model while keeping its settings
-    /// 
-    /// Note that while the settings are copied, the learned parameters (like the weights for detecting features)
-    /// are not automatically transferred, so the new instance will need training or parameter copying
-    /// to match the performance of the original.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        // Create a new instance with the cloned architecture and the same parameters
-        return new ResidualNeuralNetwork<T>(
-            Architecture,
-            _epochs,
-            _batchSize,
-            _optimizer,
-            LossFunction
-        );
-    }
 }
diff --git a/src/NeuralNetworks/RestrictedBoltzmannMachine.cs b/src/NeuralNetworks/RestrictedBoltzmannMachine.cs
index 75e3d58c05..8d928749dd 100644
--- a/src/NeuralNetworks/RestrictedBoltzmannMachine.cs
+++ b/src/NeuralNetworks/RestrictedBoltzmannMachine.cs
@@ -1,4 +1,4 @@
-using AiDotNet.Attributes;
+using AiDotNet.Attributes;
 using AiDotNet.Enums;
 using AiDotNet.NeuralNetworks.Options;
 
@@ -52,7 +52,7 @@ namespace AiDotNet.NeuralNetworks;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
     [ResearchPaper("Training Products of Experts by Minimizing Contrastive Divergence", "https://doi.org/10.1162/089976602760128018")]
-public class RestrictedBoltzmannMachine<T> : VectorModelLayoutBase<T>
+public partial class RestrictedBoltzmannMachine<T> : VectorModelLayoutBase<T>
 {
     private readonly RestrictedBoltzmannMachineOptions _options;
 
@@ -575,39 +575,6 @@ public Tensor<T> GetHiddenLayerActivation(Tensor<T> visibleLayer)
         }
     }
 
-    /// <summary>
-    /// Declares the RBM's three parameter tensors, which live outside
-    /// <see cref="NeuralNetworkBase{T}.Layers"/>.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// An RBM has no layer stack -- it is one weight matrix between the visible and hidden units
-    /// plus a bias per unit on each side. Declared in the order the old GetParameters concatenated
-    /// them (weights row-major over [HiddenSize, VisibleSize], then visible biases, then hidden
-    /// biases), so checkpoints written before this change still restore correctly.
-    /// </para>
-    /// <para>
-    /// This replaces FIVE hand-written members: ParameterCount as the formula
-    /// <c>(HiddenSize * VisibleSize) + VisibleSize + HiddenSize</c>, a GetParameters that copied
-    /// the three stores into a flat buffer element by element, a SetParameters that forwarded to
-    /// UpdateParameters, the UpdateParameters that unpacked them again, and a GetParameterChunks
-    /// that built a third copy. Five places that had to agree about one layout; now there is one.
-    /// </para>
-    /// <para>
-    /// <c>_weights</c> became a <c>Tensor&lt;T&gt;</c> for this: the base restores by writing
-    /// THROUGH the declared tensors, and <c>Tensor&lt;T&gt;.FromMatrix</c> hands back a copy, so a
-    /// declared matrix would have been restored into a temporary and discarded. The biases stay
-    /// <c>Vector&lt;T&gt;</c> -- a tensor built over a vector shares its storage, so writing through
-    /// these views lands in the fields themselves.
-    /// </para>
-    /// </remarks>
-    protected override IEnumerable<Tensor<T>> GetExtraTrainableTensors()
-    {
-        yield return _weights;
-        yield return new Tensor<T>([_visibleBiases.Length], _visibleBiases);
-        yield return new Tensor<T>([_hiddenBiases.Length], _hiddenBiases);
-    }
-
     /// <summary>
     /// Makes predictions using the RBM by computing hidden layer activations.
     /// </summary>
@@ -1201,54 +1168,7 @@ public override ModelMetadata<T> GetModelMetadata()
     /// retrain it from scratch, which can be time-consuming.
     /// </para>
     /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        // Write layer sizes
-        writer.Write(VisibleSize);
-        writer.Write(HiddenSize);
 
-        // Write weights
-        for (int i = 0; i < HiddenSize; i++)
-        {
-            for (int j = 0; j < VisibleSize; j++)
-            {
-                writer.Write(Convert.ToDouble(_weights[i, j]));
-            }
-        }
-
-        // Write visible biases
-        for (int i = 0; i < VisibleSize; i++)
-        {
-            writer.Write(Convert.ToDouble(_visibleBiases[i]));
-        }
-
-        // Write hidden biases
-        for (int i = 0; i < HiddenSize; i++)
-        {
-            writer.Write(Convert.ToDouble(_hiddenBiases[i]));
-        }
-
-        // Write configuration parameters
-        writer.Write(Convert.ToDouble(_learningRate));
-        writer.Write(_cdSteps);
-
-        // Write activation type
-        bool hasVectorActivation = _vectorActivation != null;
-        writer.Write(hasVectorActivation);
-
-        if (hasVectorActivation)
-        {
-            writer.Write((_vectorActivation ?? throw new InvalidOperationException("Vector activation not initialized.")).GetType().FullName ?? "Unknown");
-        }
-        else if (_scalarActivation != null)
-        {
-            writer.Write(_scalarActivation.GetType().FullName ?? "Unknown");
-        }
-        else
-        {
-            writer.Write("None");
-        }
-    }
 
     /// <summary>
     /// Deserializes RBM-specific data from a binary reader.
@@ -1271,63 +1191,7 @@ protected override void SerializeNetworkSpecificData(BinaryWriter writer)
     /// without needing to retrain it from scratch.
     /// </para>
     /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        // Read layer sizes (and validate they match)
-        int storedVisibleSize = reader.ReadInt32();
-        int storedHiddenSize = reader.ReadInt32();
-
-        if (storedVisibleSize != VisibleSize || storedHiddenSize != HiddenSize)
-        {
-            throw new InvalidOperationException(
-                $"Size mismatch during deserialization. Expected {VisibleSize}x{HiddenSize}, " +
-                $"but found {storedVisibleSize}x{storedHiddenSize}."
-            );
-        }
-
-        // Read weights
-        for (int i = 0; i < HiddenSize; i++)
-        {
-            for (int j = 0; j < VisibleSize; j++)
-            {
-                _weights[i, j] = NumOps.FromDouble(reader.ReadDouble());
-            }
-        }
-
-        // Read visible biases
-        for (int i = 0; i < VisibleSize; i++)
-        {
-            _visibleBiases[i] = NumOps.FromDouble(reader.ReadDouble());
-        }
-
-        // Read hidden biases
-        for (int i = 0; i < HiddenSize; i++)
-        {
-            _hiddenBiases[i] = NumOps.FromDouble(reader.ReadDouble());
-        }
-
-        // Read configuration parameters
-        _learningRate = NumOps.FromDouble(reader.ReadDouble());
-        _cdSteps = reader.ReadInt32();
-
-        // Read activation type
-        bool hasVectorActivation = reader.ReadBoolean();
-        string activationType = reader.ReadString();
 
-        if (hasVectorActivation)
-        {
-            // Default to sigmoid if the exact type can't be recreated
-            if (_vectorActivation == null)
-            {
-                _vectorActivation = new SigmoidActivation<T>();
-            }
-        }
-        else if (activationType != "None" && _scalarActivation == null)
-        {
-            // Default to sigmoid if the exact type can't be recreated
-            _scalarActivation = new SigmoidActivation<T>();
-        }
-    }
 
     /// <summary>
     /// Sets the training parameters for the RBM.
@@ -1413,21 +1277,4 @@ public override Dictionary<string, Tensor<T>> GetNamedLayerActivations(Tensor<T>
         };
         return activations;
     }
-
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        // Determine which constructor to use based on whether we're using scalar or vector activations
-        if (_vectorActivation != null)
-        {
-            // Use the vector activation constructor
-            return new RestrictedBoltzmannMachine<T>(
-                Architecture, VisibleSize, HiddenSize, Convert.ToDouble(_learningRate), _cdSteps, _vectorActivation, LossFunction);
-        }
-        else
-        {
-            // Use the scalar activation constructor
-            return new RestrictedBoltzmannMachine<T>(
-                Architecture, VisibleSize, HiddenSize, Convert.ToDouble(_learningRate), _cdSteps, _scalarActivation, LossFunction);
-        }
-    }
 }
diff --git a/src/NeuralNetworks/SAGAN.cs b/src/NeuralNetworks/SAGAN.cs
index 1bc557267f..646e67ea59 100644
--- a/src/NeuralNetworks/SAGAN.cs
+++ b/src/NeuralNetworks/SAGAN.cs
@@ -52,7 +52,7 @@ namespace AiDotNet.NeuralNetworks;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Self-Attention Generative Adversarial Networks", "https://arxiv.org/abs/1805.08318", Year = 2019, Authors = "Han Zhang, Ian Goodfellow, Dimitris Metaxas, Augustus Odena")]
-public class SAGAN<T> : GenerativeAdversarialNetwork<T>
+public partial class SAGAN<T> : GenerativeAdversarialNetwork<T>
 {
     private readonly SAGANOptions _options;
     private readonly int _latentSize;
@@ -207,27 +207,6 @@ public SAGAN(
     {
     }
 
-    /// <summary>
-    /// Constructs a fresh SAGAN with the same hyperparameters so Clone / DeepCopy
-    /// rebuilds both architectures from scratch (rather than reusing layer instances
-    /// whose shape state was resolved by the original's forward pass, which the
-    /// CNN clone-path validation rejects). Mirrors <see cref="DCGAN{T}"/>.
-    /// </summary>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new SAGAN<T>(
-            _latentSize,
-            _imageChannels,
-            _imageHeight,
-            _imageWidth,
-            _numClasses,
-            _generatorChannels,
-            _discriminatorChannels,
-            _attentionLayers,
-            lossFunction: LossFunction,
-            options: _options);
-    }
-
     /// <summary>
     /// Builds the paper-faithful generator architecture: a 1D latent vector projected
     /// by a dense layer, reshaped into a small spatial feature map, then upsampled by
diff --git a/src/NeuralNetworks/SGPT.cs b/src/NeuralNetworks/SGPT.cs
index a34f561da3..cdb2b5f7a3 100644
--- a/src/NeuralNetworks/SGPT.cs
+++ b/src/NeuralNetworks/SGPT.cs
@@ -51,7 +51,7 @@ namespace AiDotNet.NeuralNetworks
     [ModelComplexity(ModelComplexity.High)]
     [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
     [ResearchPaper("SGPT: GPT Sentence Embeddings for Semantic Search", "https://arxiv.org/abs/2202.08904", Year = 2022, Authors = "Niklas Muennighoff")]
-    public class SGPT<T> : TransformerEmbeddingNetwork<T>
+    public partial class SGPT<T> : TransformerEmbeddingNetwork<T>
     {
         private readonly SGPTOptions _options;
 
@@ -178,24 +178,6 @@ private void InitializeLayersCore(bool useVirtualValidation)
 
         #region Methods
 
-        /// <inheritdoc/>
-        protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-        {
-            return new SGPT<T>(
-                Architecture,
-                null,
-                null,
-                _vocabSize,
-                EmbeddingDimension,
-                MaxTokens,
-                _numLayers,
-                _numHeads,
-                _feedForwardDim,
-                PoolingStrategy.Mean,
-                LossFunction,
-                Convert.ToDouble(MaxGradNorm));
-        }
-
         /// <summary>
         /// Retrieves metadata about the SGPT model.
         /// </summary>
@@ -209,24 +191,10 @@ public override ModelMetadata<T> GetModelMetadata()
         }
 
         /// <inheritdoc/>
-        protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-        {
-            base.SerializeNetworkSpecificData(writer);
-            writer.Write(_vocabSize);
-            writer.Write(_numLayers);
-            writer.Write(_numHeads);
-            writer.Write(_feedForwardDim);
-        }
+
 
         /// <inheritdoc/>
-        protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-        {
-            base.DeserializeNetworkSpecificData(reader);
-            _vocabSize = reader.ReadInt32();
-            _numLayers = reader.ReadInt32();
-            _numHeads = reader.ReadInt32();
-            _feedForwardDim = reader.ReadInt32();
-        }
+
 
         /// <inheritdoc/>
         public override Vector<T> Embed(string text)
diff --git a/src/NeuralNetworks/SPLADE.cs b/src/NeuralNetworks/SPLADE.cs
index d71ebbedbd..e39af3c618 100644
--- a/src/NeuralNetworks/SPLADE.cs
+++ b/src/NeuralNetworks/SPLADE.cs
@@ -53,7 +53,7 @@ namespace AiDotNet.NeuralNetworks
     [ModelComplexity(ModelComplexity.High)]
     [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
     [ResearchPaper("SPLADE: Sparse Lexical and Expansion Model for First Stage Ranking", "https://arxiv.org/abs/2107.05720", Year = 2021, Authors = "Thibault Formal, Benjamin Piwowarski, Stephane Clinchant")]
-    public class SPLADE<T> : TransformerEmbeddingNetwork<T>
+    public partial class SPLADE<T> : TransformerEmbeddingNetwork<T>
     {
         private readonly SPLADEOptions _options;
 
@@ -198,23 +198,6 @@ public override Vector<T> Embed(string text)
             return sparseVector;
         }
 
-        /// <inheritdoc/>
-        protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-        {
-            return new SPLADE<T>(
-                Architecture,
-                null,
-                null,
-                _vocabSize,
-                EmbeddingDimension,
-                MaxTokens,
-                _numLayers,
-                _numHeads,
-                _feedForwardDim,
-                LossFunction,
-                Convert.ToDouble(MaxGradNorm));
-        }
-
         /// <summary>
         /// Retrieves detailed metadata about the SPLADE configuration.
         /// </summary>
@@ -228,24 +211,10 @@ public override ModelMetadata<T> GetModelMetadata()
         }
 
         /// <inheritdoc/>
-        protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-        {
-            base.SerializeNetworkSpecificData(writer);
-            writer.Write(_vocabSize);
-            writer.Write(_numLayers);
-            writer.Write(_numHeads);
-            writer.Write(_feedForwardDim);
-        }
+
 
         /// <inheritdoc/>
-        protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-        {
-            base.DeserializeNetworkSpecificData(reader);
-            _vocabSize = reader.ReadInt32();
-            _numLayers = reader.ReadInt32();
-            _numHeads = reader.ReadInt32();
-            _feedForwardDim = reader.ReadInt32();
-        }
+
 
         /// <inheritdoc/>
         public override Task<Vector<T>> EmbedAsync(string text)
diff --git a/src/NeuralNetworks/SambaLanguageModel.cs b/src/NeuralNetworks/SambaLanguageModel.cs
index c57f7df99c..b667934e32 100644
--- a/src/NeuralNetworks/SambaLanguageModel.cs
+++ b/src/NeuralNetworks/SambaLanguageModel.cs
@@ -37,7 +37,7 @@ namespace AiDotNet.NeuralNetworks;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Samba: Simple Hybrid State Space Models for Efficient Unlimited Context Language Modeling", "https://arxiv.org/abs/2406.07522", Year = 2024, Authors = "Liliang Ren, Yang Liu, Yadong Lu, Yelong Shen, Chen Liang, Weizhu Chen")]
-public class SambaLanguageModel<T> : TokenLanguageModelLayoutBase<T>
+public partial class SambaLanguageModel<T> : TokenLanguageModelLayoutBase<T>
 {
     private readonly SambaOptions _options;
     private readonly int _vocabSize;
@@ -153,32 +153,9 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_vocabSize);
-        writer.Write(_modelDimension);
-        writer.Write(_numLayers);
-        writer.Write(_stateDimension);
-        writer.Write(_attentionInterval);
-        writer.Write(_maxSeqLength);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _ = reader.ReadInt32();
-        _ = reader.ReadInt32();
-        _ = reader.ReadInt32();
-        _ = reader.ReadInt32();
-        _ = reader.ReadInt32();
-        _ = reader.ReadInt32();
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new SambaLanguageModel<T>(
-            Architecture, _vocabSize, _modelDimension, _numLayers, _stateDimension,
-            _attentionInterval, _maxSeqLength, LossFunction, _options);
-    }
+
 
     #endregion
 }
diff --git a/src/NeuralNetworks/SelfOrganizingMap.cs b/src/NeuralNetworks/SelfOrganizingMap.cs
index 1a8e19a3a9..4aee659606 100644
--- a/src/NeuralNetworks/SelfOrganizingMap.cs
+++ b/src/NeuralNetworks/SelfOrganizingMap.cs
@@ -44,7 +44,7 @@ namespace AiDotNet.NeuralNetworks;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Self-Organized Formation of Topologically Correct Feature Maps", "https://doi.org/10.1007/BF00337288", Year = 1982, Authors = "Teuvo Kohonen")]
-public class SelfOrganizingMap<T> : VectorModelLayoutBase<T>
+public partial class SelfOrganizingMap<T> : VectorModelLayoutBase<T>
 {
     private readonly SelfOrganizingMapNNOptions _options;
 
@@ -55,6 +55,7 @@ public class SelfOrganizingMap<T> : VectorModelLayoutBase<T>
     /// The neuron codebook: shape [numNeurons, inputDimension]. Row i is the prototype vector of
     /// neuron i (row-major over the [mapHeight, mapWidth] grid, i = y * mapWidth + x).
     /// </summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _weights;
 
     // Cached fixed-shape ones tensors reused by ComputeSquaredDistances / UpdateWeights. Their shapes
@@ -365,66 +366,14 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_inputDimension);
-        writer.Write(_mapWidth);
-        writer.Write(_mapHeight);
-        writer.Write(_totalEpochs);
-        writer.Write(_currentEpoch);
 
-        int n = _mapWidth * _mapHeight;
-        for (int i = 0; i < n; i++)
-            for (int j = 0; j < _inputDimension; j++)
-                writer.Write(Convert.ToDouble(_weights[i, j]));
-    }
 
     /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _inputDimension = reader.ReadInt32();
-        _mapWidth = reader.ReadInt32();
-        _mapHeight = reader.ReadInt32();
-        _totalEpochs = reader.ReadInt32();
-        _currentEpoch = reader.ReadInt32();
 
-        int n = _mapWidth * _mapHeight;
-        _weights = new Tensor<T>(new[] { n, _inputDimension });
-        for (int i = 0; i < n; i++)
-            for (int j = 0; j < _inputDimension; j++)
-                _weights[i, j] = NumOps.FromDouble(reader.ReadDouble());
-    }
-
-    /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-        => new SelfOrganizingMap<T>(Architecture, _totalEpochs, LossFunction);
 
     /// <inheritdoc/>
     public override bool SupportsTraining => true;
 
-    /// <summary>
-    /// Declares the SOM codebook, which lives outside the layer chain.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// A SOM has no trainable layers by design -- Kohonen 1982 §3 describes a single competitive
-    /// layer holding one codebook, not a stack -- so the base walk over <c>Layers</c> finds nothing
-    /// unless the codebook is declared. Declaring it here gives the count, the vector, the restore
-    /// and the chunks all one source, laid out [mapWidth * mapHeight, inputDimension] row-major,
-    /// the same order the deleted GetParameters produced.
-    /// </para>
-    /// <para>
-    /// This replaces a ParameterCount formula (<c>_mapWidth * _mapHeight * _inputDimension</c>), a
-    /// GetParameters that copied the codebook out element by element, an UpdateParameters that
-    /// copied it back, and a GetParameterChunks that already yielded <c>_weights</c> -- four members
-    /// describing one tensor, any of which could have been changed without the others.
-    /// </para>
-    /// </remarks>
-    protected override IEnumerable<Tensor<T>> GetExtraTrainableTensors()
-    {
-        yield return _weights;
-    }
-
     /// <inheritdoc/>
     public override Dictionary<string, Tensor<T>> GetNamedLayerActivations(Tensor<T> input)
     {
diff --git a/src/NeuralNetworks/SiameseNetwork.cs b/src/NeuralNetworks/SiameseNetwork.cs
index edc0d47685..4384f348f2 100644
--- a/src/NeuralNetworks/SiameseNetwork.cs
+++ b/src/NeuralNetworks/SiameseNetwork.cs
@@ -118,6 +118,7 @@ public partial class SiameseNetwork<T> : DeclaredModelLayoutBase<T>, IAuxiliaryL
     /// Cache for embedding pairs and their similarity labels during training.
     /// Used to compute contrastive auxiliary loss.
     /// </summary>
+    [Scratch]
     private List<(Vector<T> embedding1, Vector<T> embedding2, T label)> _cachedEmbeddingPairs;
 
     /// <summary>
@@ -627,22 +628,7 @@ public override Tensor<T> ForwardForTraining(Tensor<T> input)
     /// allowing you to load it later without having to retrain it.
     /// </para>
     /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        // Serialize the subnetwork
-        var subNetworkData = _subnetwork.Serialize();
-        writer.Write(subNetworkData.Length);
-        writer.Write(subNetworkData);
 
-        // Serialize the output layer parameters
-        Vector<T> outputLayerParams = _outputLayer.GetParameters();
-        writer.Write(outputLayerParams.Length);
-
-        for (int i = 0; i < outputLayerParams.Length; i++)
-        {
-            writer.Write(Convert.ToDouble(outputLayerParams[i]));
-        }
-    }
 
     /// <summary>
     /// Deserializes Siamese network-specific data from a binary reader.
@@ -658,42 +644,7 @@ protected override void SerializeNetworkSpecificData(BinaryWriter writer)
     /// restoring all its learned parameters so you can use it without retraining.
     /// </para>
     /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        // Deserialize the subnetwork
-        _subnetwork = Architecture.InputType == Enums.InputType.OneDimensional
-            ? (NeuralNetworkBase<T>)new FeedForwardNeuralNetwork<T>(CreateEmbeddingArchitecture(Architecture, _options.EmbeddingSize))
-            : new ConvolutionalNeuralNetwork<T>(CreateEmbeddingArchitecture(Architecture, _options.EmbeddingSize));
-        var subNetworkCount = reader.ReadInt32();
-        _subnetwork.Deserialize(reader.ReadBytes(subNetworkCount));
-
-        // Deserialize the output layer parameters
-        int paramCount = reader.ReadInt32();
-        Vector<T> outputLayerParams = new Vector<T>(paramCount);
-
-        for (int i = 0; i < paramCount; i++)
-        {
-            outputLayerParams[i] = NumOps.FromDouble(reader.ReadDouble());
-        }
 
-        // Initialize the output layer with the correct dimensions
-        _outputLayer = new DenseLayer<T>(1, new SigmoidActivation<T>() as IActivationFunction<T>);
-        _outputLayer.SetParameters(outputLayerParams);
-
-        // Re-wire the base Layers list to the freshly deserialized _subnetwork /
-        // _outputLayer, exactly as the constructor does. The base deserialize
-        // populated Layers from the generic layer stream BEFORE this method ran,
-        // so without this call Layers would reference stale layer objects while
-        // _subnetwork/_outputLayer point to these new ones. Training would then
-        // forward through _subnetwork/_outputLayer (ForwardForTraining) but the
-        // optimizer would read and update the disconnected Layers parameters —
-        // the clone (DeepCopy/Clone routes through this path) trained on a
-        // mismatched parameter set and its loss diverged with more iterations
-        // (MoreData_ShouldNotDegrade: loss rose instead of falling). Re-running
-        // InitializeLayers binds Layers to the live objects so forward and
-        // update share one parameter surface.
-        InitializeLayers();
-    }
 
     /// <summary>
     /// Gets metadata about the Siamese Network.
@@ -727,35 +678,4 @@ public override ModelMetadata<T> GetModelMetadata()
 
         return metadata;
     }
-
-    /// <summary>
-    /// Creates a new instance of the Siamese network with the same architecture.
-    /// </summary>
-    /// <returns>A new instance of the Siamese network.</returns>
-    /// <remarks>
-    /// <para>
-    /// This method creates a new Siamese network with the same architecture as the current instance.
-    /// The new instance has freshly initialized parameters and is ready for training.
-    /// </para>
-    /// <para>
-    /// <b>For Beginners:</b> This creates a brand new Siamese network with the same structure.
-    /// 
-    /// Think of it like creating a copy of your current network's blueprint:
-    /// - It has the same subnetwork structure for processing inputs
-    /// - It processes the same types of inputs (like images of the same size)
-    /// - But it starts with fresh, untrained parameters
-    /// 
-    /// This is useful when you want to:
-    /// - Start over with a fresh network but keep the same design
-    /// - Create multiple networks with identical structures for comparison
-    /// - Train networks with different data but the same architecture
-    /// 
-    /// The new network will need to be trained from scratch, as it doesn't
-    /// inherit any of the "knowledge" from the original network.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new SiameseNetwork<T>(Architecture, lossFunction: LossFunction);
-    }
 }
diff --git a/src/NeuralNetworks/SiameseNeuralNetwork.cs b/src/NeuralNetworks/SiameseNeuralNetwork.cs
index 8dcee3480d..ec5248c89b 100644
--- a/src/NeuralNetworks/SiameseNeuralNetwork.cs
+++ b/src/NeuralNetworks/SiameseNeuralNetwork.cs
@@ -60,7 +60,7 @@ namespace AiDotNet.NeuralNetworks
     [ModelComplexity(ModelComplexity.Medium)]
     [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
     [ResearchPaper("Sentence-BERT: Sentence Embeddings using Siamese BERT-Networks", "https://arxiv.org/abs/1908.10084", Year = 2019, Authors = "Nils Reimers, Iryna Gurevych")]
-    public class SiameseNeuralNetwork<T> : VectorModelLayoutBase<T>, IEmbeddingModel<T>
+    public partial class SiameseNeuralNetwork<T> : VectorModelLayoutBase<T>, IEmbeddingModel<T>
     {
         private readonly SiameseNeuralNetworkOptions _options;
 
@@ -358,20 +358,6 @@ private Vector<T> PoolOutput(Tensor<T> output)
             return result.SafeNormalize();
         }
 
-        /// <inheritdoc/>
-        protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-        {
-            return new SiameseNeuralNetwork<T>(
-                Architecture,
-                _tokenizer,
-                null, // Fresh optimizer for new instance
-                _vocabSize,
-                _embeddingDimension,
-                _maxSequenceLength,
-                _lossFunction,
-                Convert.ToDouble(MaxGradNorm));
-        }
-
         /// <summary>
         /// Retrieves metadata about the Siamese dual-encoder model.
         /// </summary>
@@ -392,20 +378,10 @@ public override ModelMetadata<T> GetModelMetadata()
         }
 
         /// <inheritdoc/>
-        protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-        {
-            writer.Write(_vocabSize);
-            writer.Write(_embeddingDimension);
-            writer.Write(_maxSequenceLength);
-        }
+
 
         /// <inheritdoc/>
-        protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-        {
-            _vocabSize = reader.ReadInt32();
-            _embeddingDimension = reader.ReadInt32();
-            _maxSequenceLength = reader.ReadInt32();
-        }
+
 
         #endregion
     }
diff --git a/src/NeuralNetworks/SimCSE.cs b/src/NeuralNetworks/SimCSE.cs
index 3806eed58c..825a1cc8b4 100644
--- a/src/NeuralNetworks/SimCSE.cs
+++ b/src/NeuralNetworks/SimCSE.cs
@@ -49,7 +49,7 @@ namespace AiDotNet.NeuralNetworks
     [ModelComplexity(ModelComplexity.High)]
     [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
     [ResearchPaper("SimCSE: Simple Contrastive Learning of Sentence Embeddings", "https://arxiv.org/abs/2104.08821", Year = 2022, Authors = "Tianyu Gao, Xingcheng Yao, Danqi Chen")]
-    public class SimCSE<T> : TransformerEmbeddingNetwork<T>
+    public partial class SimCSE<T> : TransformerEmbeddingNetwork<T>
     {
         private readonly SimCSEOptions _options;
 
@@ -161,26 +161,6 @@ private void InitializeLayersCore(bool useVirtualValidation)
 
         #region Methods
 
-        /// <inheritdoc/>
-        protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-        {
-            return new SimCSE<T>(
-                Architecture,
-                null,
-                null,
-                _simCseType,
-                _vocabSize,
-                EmbeddingDimension,
-                MaxTokens,
-                _numLayers,
-                _numHeads,
-                _feedForwardDim,
-                _dropoutRate,
-                PoolingStrategy.ClsToken,
-                LossFunction,
-                Convert.ToDouble(MaxGradNorm));
-        }
-
         /// <summary>
         /// Retrieves detailed metadata about the SimCSE configuration.
         /// </summary>
@@ -196,28 +176,10 @@ public override ModelMetadata<T> GetModelMetadata()
         }
 
         /// <inheritdoc/>
-        protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-        {
-            base.SerializeNetworkSpecificData(writer);
-            writer.Write((int)_simCseType);
-            writer.Write(_dropoutRate);
-            writer.Write(_vocabSize);
-            writer.Write(_numLayers);
-            writer.Write(_numHeads);
-            writer.Write(_feedForwardDim);
-        }
+
 
         /// <inheritdoc/>
-        protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-        {
-            base.DeserializeNetworkSpecificData(reader);
-            _simCseType = (SimCSEType)reader.ReadInt32();
-            _dropoutRate = reader.ReadDouble();
-            _vocabSize = reader.ReadInt32();
-            _numLayers = reader.ReadInt32();
-            _numHeads = reader.ReadInt32();
-            _feedForwardDim = reader.ReadInt32();
-        }
+
 
         /// <inheritdoc/>
         public override Vector<T> Embed(string text)
diff --git a/src/NeuralNetworks/SparseNeuralNetwork.cs b/src/NeuralNetworks/SparseNeuralNetwork.cs
index eaad5d2e20..02ebb89abb 100644
--- a/src/NeuralNetworks/SparseNeuralNetwork.cs
+++ b/src/NeuralNetworks/SparseNeuralNetwork.cs
@@ -51,7 +51,7 @@ namespace AiDotNet.NeuralNetworks;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
     [ResearchPaper("The Lottery Ticket Hypothesis: Finding Sparse, Trainable Neural Networks", "https://arxiv.org/abs/1803.03635")]
-public class SparseNeuralNetwork<T> : VectorModelLayoutBase<T>
+public partial class SparseNeuralNetwork<T> : VectorModelLayoutBase<T>
 {
     private readonly SparseNeuralNetworkOptions _options;
 
@@ -430,43 +430,12 @@ public override ModelMetadata<T> GetModelMetadata()
     /// <summary>
     /// Serializes sparse neural network-specific data to a binary writer.
     /// </summary>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(NumOps.ToDouble(_sparsity));
-        writer.Write(_optimizer.GetType().FullName ?? "AdamOptimizer");
-        writer.Write(_lossFunction.GetType().FullName ?? "MeanSquaredErrorLoss");
-    }
+
 
     /// <summary>
     /// Deserializes sparse neural network-specific data from a binary reader.
     /// </summary>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _sparsity = NumOps.FromDouble(reader.ReadDouble());
-
-        // Read type names for forward compatibility and validation
-        string optimizerType = reader.ReadString();
-        string lossFunctionType = reader.ReadString();
 
-        // Note: Optimizer and loss function instances should be provided during construction.
-        // The type names are read for data integrity verification but new instances
-        // need to be created via the constructor or a dedicated factory method.
-        _ = optimizerType;
-        _ = lossFunctionType;
-    }
-
-    /// <summary>
-    /// Creates a new instance of the SparseNeuralNetwork with the same configuration.
-    /// </summary>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new SparseNeuralNetwork<T>(
-            Architecture,
-            NumOps.ToDouble(_sparsity),
-            _optimizer,
-            _lossFunction,
-            Convert.ToDouble(MaxGradNorm));
-    }
 
     /// <summary>
     /// Indicates whether this network supports training.
diff --git a/src/NeuralNetworks/SpikingNeuralNetwork.cs b/src/NeuralNetworks/SpikingNeuralNetwork.cs
index 6ff7839d8f..42f84f3080 100644
--- a/src/NeuralNetworks/SpikingNeuralNetwork.cs
+++ b/src/NeuralNetworks/SpikingNeuralNetwork.cs
@@ -30,7 +30,7 @@ namespace AiDotNet.NeuralNetworks;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
     [ResearchPaper("Networks of Spiking Neurons: The Third Generation of Neural Network Models", "https://doi.org/10.1016/S0893-6080(97)00011-7")]
-public class SpikingNeuralNetwork<T> : SequenceModelLayoutBase<T>
+public partial class SpikingNeuralNetwork<T> : SequenceModelLayoutBase<T>
 {
     private readonly SpikingNeuralNetworkOptions _options;
 
@@ -1240,63 +1240,7 @@ public override ModelMetadata<T> GetModelMetadata()
     /// - Create a snapshot of the network's state at a specific point
     /// </para>
     /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        // Write temporal parameters
-        writer.Write(NumOps.ToDouble(_timeStep));
-        writer.Write(_simulationSteps);
-
-        // Write neuron model parameters
-        writer.Write(Convert.ToDouble(_membraneDecay));
-        writer.Write(_refractoryPeriod);
-
-        // Write activation type
-        bool hasVectorActivation = _vectorActivation != null;
-        writer.Write(hasVectorActivation);
-
-        if (hasVectorActivation)
-        {
-            writer.Write((_vectorActivation ?? throw new InvalidOperationException("Vector activation not initialized.")).GetType().FullName ?? "Unknown");
-        }
-        else if (_scalarActivation != null)
-        {
-            writer.Write(_scalarActivation.GetType().FullName ?? "Unknown");
-        }
-        else
-        {
-            writer.Write("None");
-        }
 
-        // Write neuron states
-
-        // Write number of layers
-        writer.Write(_membranePotentials.Count);
-
-        // Write membrane potentials
-        for (int layer = 0; layer < _membranePotentials.Count; layer++)
-        {
-            // Write number of neurons in this layer
-            writer.Write(_membranePotentials[layer].Length);
-
-            // Write membrane potentials
-            for (int i = 0; i < _membranePotentials[layer].Length; i++)
-            {
-                writer.Write(Convert.ToDouble(_membranePotentials[layer][i]));
-            }
-
-            // Write refractory counters
-            for (int i = 0; i < _refractoryCounters[layer].Length; i++)
-            {
-                writer.Write(_refractoryCounters[layer][i]);
-            }
-
-            // Write firing thresholds
-            for (int i = 0; i < _firingThresholds[layer].Length; i++)
-            {
-                writer.Write(Convert.ToDouble(_firingThresholds[layer][i]));
-            }
-        }
-    }
 
     /// <summary>
     /// Deserializes SNN-specific data from a binary reader.
@@ -1321,88 +1265,7 @@ protected override void SerializeNetworkSpecificData(BinaryWriter writer)
     /// - Share networks between different systems or users
     /// </para>
     /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        // Read temporal parameters
-        _timeStep = NumOps.FromDouble(reader.ReadDouble());
-        _simulationSteps = reader.ReadInt32();
-
-        // Read neuron model parameters
-        _membraneDecay = NumOps.FromDouble(reader.ReadDouble());
-        _refractoryPeriod = reader.ReadInt32();
-
-        // Read activation type
-        bool hasVectorActivation = reader.ReadBoolean();
-        string activationType = reader.ReadString();
-
-        // Recreate activation function if needed
-        if (hasVectorActivation)
-        {
-            // Use existing or create default
-            if (_vectorActivation == null)
-            {
-                _vectorActivation = new BinarySpikingActivation<T>();
-            }
-        }
-        else if (activationType != "None" && _scalarActivation == null)
-        {
-            // Use existing or create default
-            _scalarActivation = new BinarySpikingActivation<T>();
-        }
-
-        // Read neuron states
-
-        // Read number of layers
-        int layerCount = reader.ReadInt32();
-
-        // Initialize state containers if not already done
-        if (_membranePotentials == null || _membranePotentials.Count == 0)
-        {
-            _membranePotentials = new List<Vector<T>>(layerCount);
-            _refractoryCounters = new List<int[]>(layerCount);
-            _firingThresholds = new List<Vector<T>>(layerCount);
-        }
 
-        // Clear existing data if needed
-        _membranePotentials.Clear();
-        _refractoryCounters.Clear();
-        _firingThresholds.Clear();
-
-        // Read membrane potentials, refractory counters, and firing thresholds
-        for (int layer = 0; layer < layerCount; layer++)
-        {
-            // Read number of neurons in this layer
-            int neuronCount = reader.ReadInt32();
-
-            // Create vectors and arrays
-            var potentials = new Vector<T>(neuronCount);
-            var refractoryCounters = new int[neuronCount];
-            var thresholds = new Vector<T>(neuronCount);
-
-            // Read membrane potentials
-            for (int i = 0; i < neuronCount; i++)
-            {
-                potentials[i] = NumOps.FromDouble(reader.ReadDouble());
-            }
-
-            // Read refractory counters
-            for (int i = 0; i < neuronCount; i++)
-            {
-                refractoryCounters[i] = reader.ReadInt32();
-            }
-
-            // Read firing thresholds
-            for (int i = 0; i < neuronCount; i++)
-            {
-                thresholds[i] = NumOps.FromDouble(reader.ReadDouble());
-            }
-
-            // Add to collections
-            _membranePotentials.Add(potentials);
-            _refractoryCounters.Add(refractoryCounters);
-            _firingThresholds.Add(thresholds);
-        }
-    }
 
     /// <summary>
     /// Sets the neuron model parameters for the network.
@@ -1544,61 +1407,6 @@ public void SetLayerThresholds(int layerIndex, Vector<T> thresholds)
         }
     }
 
-    /// <summary>
-    /// Creates a new instance of the Spiking Neural Network with the same architecture and configuration.
-    /// </summary>
-    /// <returns>A new instance of the Spiking Neural Network with the same configuration as the current instance.</returns>
-    /// <remarks>
-    /// <para>
-    /// This method creates a new spiking neural network with the same architecture, temporal parameters,
-    /// and activation function type as the current instance. The new instance has freshly initialized
-    /// parameters and state, making it useful for creating separate instances with the same configuration
-    /// or for resetting the network while preserving its structure.
-    /// </para>
-    /// <para><b>For Beginners:</b> This creates a brand new spiking neural network with the same setup.
-    /// 
-    /// Think of it like cloning your network's blueprint:
-    /// - It has the same structure (layers, neurons)
-    /// - It has the same temporal settings (time step, simulation steps)
-    /// - It uses the same type of activation function
-    /// - But it starts fresh with new connections and neuron states
-    /// 
-    /// This is useful when you want to:
-    /// - Start over with a fresh network but keep the same design
-    /// - Create multiple networks with identical settings for comparison
-    /// - Reset a network to its initial state
-    /// 
-    /// The new network will need to be trained from scratch, as it doesn't
-    /// inherit any of the learned weights from the original network.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        // Determine which constructor to use based on which activation function is set
-        if (_vectorActivation != null)
-        {
-            // Use the vector activation constructor
-            return new SpikingNeuralNetwork<T>(
-                Architecture,
-                NumOps.ToDouble(_timeStep),
-                _simulationSteps,
-                _vectorActivation,
-                LossFunction,
-                _options);
-        }
-        else
-        {
-            // Use the scalar activation constructor
-            return new SpikingNeuralNetwork<T>(
-                Architecture,
-                NumOps.ToDouble(_timeStep),
-                _simulationSteps,
-                _scalarActivation,
-                LossFunction,
-                _options);
-        }
-    }
-
     /// <summary>
     /// Safe-indexed first-axis read for lazy layers that may return an
     /// empty shape array before resolution. Returns 0 (so the caller's
diff --git a/src/NeuralNetworks/SpiralNet.cs b/src/NeuralNetworks/SpiralNet.cs
index 4b8865afa4..b1c1385acc 100644
--- a/src/NeuralNetworks/SpiralNet.cs
+++ b/src/NeuralNetworks/SpiralNet.cs
@@ -56,7 +56,7 @@ namespace AiDotNet.NeuralNetworks;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("SpiralNet++: A Fast and Highly Efficient Mesh Convolution Operator", "https://arxiv.org/abs/1911.05856", Year = 2019, Authors = "Shunwang Gong, Lei Chen, Michael Bronstein, Stefanos Zafeiriou")]
-public class SpiralNet<T> : GraphModelLayoutBase<T>
+public partial class SpiralNet<T> : GraphModelLayoutBase<T>
 {
     /// <summary>
     /// The loss function used to compute training loss.
@@ -612,103 +612,14 @@ public override ModelMetadata<T> GetModelMetadata()
     /// </summary>
     /// <param name="writer">Binary writer.</param>
     /// <inheritdoc />
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_options.NumClasses);
-        writer.Write(_options.InputFeatures);
-        writer.Write(_options.SpiralLength);
-        writer.Write(_options.UseBatchNorm);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.UseGlobalAveragePooling);
-
-        writer.Write(_options.ConvChannels.Length);
-        foreach (var ch in _options.ConvChannels)
-            writer.Write(ch);
-
-        writer.Write(_options.PoolRatios.Length);
-        foreach (var pr in _options.PoolRatios)
-            writer.Write(pr);
-
-        writer.Write(_options.FullyConnectedSizes.Length);
-        foreach (var fc in _options.FullyConnectedSizes)
-            writer.Write(fc);
-
-        // Persist the spiral-index topology so a deserialized / cloned model can
-        // re-propagate it to its (freshly reconstructed) SpiralConvLayers. The
-        // layers' indices are network-owned state, not trainable parameters, so
-        // the flat-parameter clone path doesn't carry them; without this a clone
-        // throws "Spiral indices must be set" on its first forward (#1450).
-        writer.Write(_spiralIndicesPerLevel.Count);
-        foreach (var level in _spiralIndicesPerLevel)
-        {
-            int rows = level.GetLength(0);
-            int cols = level.GetLength(1);
-            writer.Write(rows);
-            writer.Write(cols);
-            for (int r = 0; r < rows; r++)
-                for (int c = 0; c < cols; c++)
-                    writer.Write(level[r, c]);
-        }
-    }
+
 
     /// <summary>
     /// Deserializes network-specific data.
     /// </summary>
     /// <param name="reader">Binary reader.</param>
     /// <inheritdoc />
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _options.NumClasses = reader.ReadInt32();
-        _options.InputFeatures = reader.ReadInt32();
-        _options.SpiralLength = reader.ReadInt32();
-        _options.UseBatchNorm = reader.ReadBoolean();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.UseGlobalAveragePooling = reader.ReadBoolean();
-
-        int convLen = reader.ReadInt32();
-        _options.ConvChannels = new int[convLen];
-        for (int i = 0; i < convLen; i++)
-            _options.ConvChannels[i] = reader.ReadInt32();
-
-        int poolLen = reader.ReadInt32();
-        _options.PoolRatios = new double[poolLen];
-        for (int i = 0; i < poolLen; i++)
-            _options.PoolRatios[i] = reader.ReadDouble();
-
-        int fcLen = reader.ReadInt32();
-        _options.FullyConnectedSizes = new int[fcLen];
-        for (int i = 0; i < fcLen; i++)
-            _options.FullyConnectedSizes[i] = reader.ReadInt32();
-
-        // Restore the spiral-index topology and re-propagate it to the layers
-        // that were reconstructed during layer deserialization (the constructor's
-        // default propagation targeted the pre-deserialize layers, which have
-        // since been replaced). Without this a clone forward throws "Spiral
-        // indices must be set" (#1450).
-        int levelCount = reader.ReadInt32();
-        _spiralIndicesPerLevel.Clear();
-        for (int l = 0; l < levelCount; l++)
-        {
-            int rows = reader.ReadInt32();
-            int cols = reader.ReadInt32();
-            var level = new int[rows, cols];
-            for (int r = 0; r < rows; r++)
-                for (int c = 0; c < cols; c++)
-                    level[r, c] = reader.ReadInt32();
-            _spiralIndicesPerLevel.Add(level);
-        }
-        PropagateSpiralIndicesToLayers();
-    }
 
-    /// <summary>
-    /// Creates a new instance for cloning.
-    /// </summary>
-    /// <returns>New SpiralNet instance.</returns>
-    /// <inheritdoc />
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new SpiralNet<T>(_options, _optimizer, _lossFunction);
-    }
 
     /// <summary>
     /// Computes class probabilities for a single mesh using softmax.
diff --git a/src/NeuralNetworks/StyleGAN.cs b/src/NeuralNetworks/StyleGAN.cs
index 5a5a6fcffc..b1e643e83c 100644
--- a/src/NeuralNetworks/StyleGAN.cs
+++ b/src/NeuralNetworks/StyleGAN.cs
@@ -874,82 +874,9 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_initialLearningRate);
-        writer.Write(_latentSize);
-        writer.Write(_intermediateLatentSize);
-        writer.Write(_enableStyleMixing);
-        writer.Write(NumOps.ToDouble(_styleMixingProbability));
-
-        var mappingBytes = MappingNetwork.Serialize();
-        writer.Write(mappingBytes.Length);
-        writer.Write(mappingBytes);
-
-        var synthesisBytes = SynthesisNetwork.Serialize();
-        writer.Write(synthesisBytes.Length);
-        writer.Write(synthesisBytes);
-
-        var discriminatorBytes = Discriminator.Serialize();
-        writer.Write(discriminatorBytes.Length);
-        writer.Write(discriminatorBytes);
-
-        // Serialize optimizer state for complete training state preservation
-        SerializationHelper<T>.SerializeVector(writer, _mappingMomentum);
-        SerializationHelper<T>.SerializeVector(writer, _mappingSecondMoment);
 
-        SerializationHelper<T>.SerializeVector(writer, _synthesisMomentum);
-        SerializationHelper<T>.SerializeVector(writer, _synthesisSecondMoment);
-
-        SerializationHelper<T>.SerializeVector(writer, _discMomentum);
-        SerializationHelper<T>.SerializeVector(writer, _discSecondMoment);
-    }
-
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        // Read the learning rate that was written in SerializeNetworkSpecificData
-        // Note: _initialLearningRate is readonly so we can't reassign it here
-        // The value will be correctly set by the constructor when CreateNewInstance is used
-        _ = reader.ReadDouble(); // Consume the stored learning rate value
-        _latentSize = reader.ReadInt32();
-        _intermediateLatentSize = reader.ReadInt32();
-        _enableStyleMixing = reader.ReadBoolean();
-        _styleMixingProbability = NumOps.FromDouble(reader.ReadDouble());
 
-        int mappingLength = reader.ReadInt32();
-        MappingNetwork.Deserialize(reader.ReadBytes(mappingLength));
 
-        int synthesisLength = reader.ReadInt32();
-        SynthesisNetwork.Deserialize(reader.ReadBytes(synthesisLength));
-
-        int discriminatorLength = reader.ReadInt32();
-        Discriminator.Deserialize(reader.ReadBytes(discriminatorLength));
-
-        // Deserialize optimizer state
-        _mappingMomentum = SerializationHelper<T>.DeserializeVector(reader);
-        _mappingSecondMoment = SerializationHelper<T>.DeserializeVector(reader);
-
-        _synthesisMomentum = SerializationHelper<T>.DeserializeVector(reader);
-        _synthesisSecondMoment = SerializationHelper<T>.DeserializeVector(reader);
-
-        _discMomentum = SerializationHelper<T>.DeserializeVector(reader);
-        _discSecondMoment = SerializationHelper<T>.DeserializeVector(reader);
-    }
-
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new StyleGAN<T>(
-            MappingNetwork.Architecture,
-            SynthesisNetwork.Architecture,
-            Discriminator.Architecture,
-            _latentSize,
-            _intermediateLatentSize,
-            Architecture.InputType,
-            _lossFunction,
-            _initialLearningRate,
-            _enableStyleMixing,
-            NumOps.ToDouble(_styleMixingProbability));
-    }
 
     // UpdateParameters split the vector between MappingNetwork, SynthesisNetwork and Discriminator;
     // GetExtraTrainableLayers yields those three in the same order, so the base reproduces the
diff --git a/src/NeuralNetworks/SuperNet.cs b/src/NeuralNetworks/SuperNet.cs
index c355eae9ba..a0e940df47 100644
--- a/src/NeuralNetworks/SuperNet.cs
+++ b/src/NeuralNetworks/SuperNet.cs
@@ -1,58 +1,59 @@
-using AiDotNet.Helpers;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading.Tasks;
-using AiDotNet.Attributes;
-using AiDotNet.AutoML;
-using AiDotNet.Enums;
-using AiDotNet.AutoML.SearchSpace;
-using AiDotNet.Enums;
-using AiDotNet.Interfaces;
-using AiDotNet.Interpretability;
-using AiDotNet.LossFunctions;
-using AiDotNet.Models;
-using AiDotNet.Validation;

+using AiDotNet.Helpers;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using AiDotNet.Attributes;
+using AiDotNet.AutoML;
+using AiDotNet.Enums;
+using AiDotNet.AutoML.SearchSpace;
+using AiDotNet.Enums;
+using AiDotNet.Interfaces;
+using AiDotNet.Interpretability;
+using AiDotNet.LossFunctions;
+using AiDotNet.Models;
+using AiDotNet.Validation;
+
 using AiDotNet.Models.Parameters;
-
-namespace AiDotNet.NeuralNetworks
-{
-    /// <summary>
-    /// SuperNet implementation for gradient-based neural architecture search (DARTS).
-    /// Implements a differentiable architecture search by maintaining architecture parameters (alpha)
-    /// and network weights simultaneously.
-    /// </summary>
-    /// <typeparam name="T">The numeric type for calculations</typeparam>
-    /// <remarks>
-    /// <para><b>For Beginners:</b> A SuperNet is a "network of all possible networks." It
-    /// contains every candidate architecture within a single large network, with learnable
-    /// weights that determine which operations are most important. During architecture search,
-    /// the SuperNet trains these weights using gradient descent, and the final architecture
-    /// is derived by selecting the operations with the highest weights. This is the core
-    /// mechanism behind DARTS-style neural architecture search.</para>
-    /// </remarks>
-    /// <example>
-    /// <code>
-    /// var searchSpace = new SearchSpaceBase&lt;float&gt;();
-    /// var superNet = new SuperNet&lt;float&gt;(searchSpace, numNodes: 4, inputSize: 784, outputSize: 10);
-    /// superNet.ForwardPass(inputTensor);
-    /// var architecture = superNet.DeriveArchitecture();
-    /// </code>
-    /// </example>
-    [ModelDomain(ModelDomain.General)]
-    [ModelCategory(ModelCategory.NeuralNetwork)]
-    [ModelTask(ModelTask.Classification)]
-    [ModelTask(ModelTask.Regression)]
-    [ModelComplexity(ModelComplexity.High)]
-    [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
-    [ResearchPaper("Understanding and Simplifying One-Shot Architecture Search", "https://arxiv.org/abs/1810.03522")]
-    public partial class SuperNet<T> : ModelBase<T, Tensor<T>, Tensor<T>>
-    {
-        private readonly SearchSpaceBase<T> _searchSpace;
-        private readonly int _numNodes;
-        private readonly int _numOperations;
-        private readonly Random _random; // Shared Random instance to avoid time-based seeding issues
-
+
+namespace AiDotNet.NeuralNetworks
+{
+    /// <summary>
+    /// SuperNet implementation for gradient-based neural architecture search (DARTS).
+    /// Implements a differentiable architecture search by maintaining architecture parameters (alpha)
+    /// and network weights simultaneously.
+    /// </summary>
+    /// <typeparam name="T">The numeric type for calculations</typeparam>
+    /// <remarks>
+    /// <para><b>For Beginners:</b> A SuperNet is a "network of all possible networks." It
+    /// contains every candidate architecture within a single large network, with learnable
+    /// weights that determine which operations are most important. During architecture search,
+    /// the SuperNet trains these weights using gradient descent, and the final architecture
+    /// is derived by selecting the operations with the highest weights. This is the core
+    /// mechanism behind DARTS-style neural architecture search.</para>
+    /// </remarks>
+    /// <example>
+    /// <code>
+    /// var searchSpace = new SearchSpaceBase&lt;float&gt;();
+    /// var superNet = new SuperNet&lt;float&gt;(searchSpace, numNodes: 4, inputSize: 784, outputSize: 10);
+    /// superNet.ForwardPass(inputTensor);
+    /// var architecture = superNet.DeriveArchitecture();
+    /// </code>
+    /// </example>
+    [ModelDomain(ModelDomain.General)]
+    [ModelCategory(ModelCategory.NeuralNetwork)]
+    [ModelTask(ModelTask.Classification)]
+    [ModelTask(ModelTask.Regression)]
+    [ModelComplexity(ModelComplexity.High)]
+    [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
+    [ResearchPaper("Understanding and Simplifying One-Shot Architecture Search", "https://arxiv.org/abs/1810.03522")]
+    public partial class SuperNet<T> : ModelBase<T, Tensor<T>, Tensor<T>>
+    {
+        private readonly SearchSpaceBase<T> _searchSpace;
+        private readonly int _numNodes;
+        private readonly int _numOperations;
+        private readonly Random _random; // Shared Random instance to avoid time-based seeding issues
+
         // Architecture parameters (alpha) - learnable parameters that determine operation weights
         [TrainableParameter]
         private readonly List<Matrix<T>> _architectureParams;
@@ -60,1457 +61,1395 @@ public partial class SuperNet<T> : ModelBase<T, Tensor<T>, Tensor<T>>
         // Network weights - parameters for each operation
         [TrainableParameter(Availability = AiDotNet.Models.Parameters.ParameterAvailability.Fit)]
         private readonly Dictionary<string, Vector<T>> _weights;
-
-        // Gradients
-        [Scratch]
-        private readonly List<Matrix<T>> _architectureGradients;
-        [Scratch]
-        private readonly Dictionary<string, Vector<T>> _weightGradients;
-
-        // Model metadata
-        private int _inputSize;
-        private int _outputSize;
-
-        // IInterpretableModel fields
-        private readonly HashSet<InterpretationMethod> _enabledMethods = new();
-        [Buffer]
-        private Vector<int>? _sensitiveFeatures;
-        private readonly List<FairnessMetric> _fairnessMetrics = new();
-        private IModel<Tensor<T>, Tensor<T>, ModelMetadata<T>>? _baseModel;
-
-        /// <summary>
-        /// The default loss function used by this model for gradient computation.
-        /// </summary>
-        private readonly ILossFunction<T> _defaultLossFunction;
-
-
-        public string[] FeatureNames { get; set; } = Array.Empty<string>();
-        /// <summary>
-        /// Gets the default loss function used by this model for gradient computation.
-        /// </summary>
-        /// <remarks>
-        /// <para>
-        /// For SuperNet (Neural Architecture Search), the default loss function is Mean Squared Error (MSE),
-        /// which is used for computing both architecture and weight gradients.
-        /// </para>
-        /// </remarks>
-        public override ILossFunction<T> DefaultLossFunction => _defaultLossFunction;
-
-        /// <summary>
-        /// Initializes a new SuperNet for differentiable architecture search.
-        /// </summary>
-        /// <param name="searchSpace">The search space defining available operations</param>
-        /// <param name="numNodes">Number of nodes in the architecture</param>
-        /// <param name="lossFunction">Optional loss function to use for training. If null, uses Mean Squared Error (MSE) for neural architecture search.</param>
-        public SuperNet(SearchSpaceBase<T> searchSpace, int numNodes = 4, ILossFunction<T>? lossFunction = null)
-        {
-            _searchSpace = searchSpace;
-            _numNodes = numNodes;
-            _numOperations = searchSpace.Operations?.Count ?? 5; // Default operations: identity, conv3x3, conv5x5, maxpool, avgpool
-            _random = RandomHelper.CreateSeededRandom(42); // Initialize with seed for reproducibility
-
-            // Initialize architecture parameters (alpha) with small random values
-            _architectureParams = new List<Matrix<T>>();
-            _architectureGradients = new List<Matrix<T>>();
-
-            for (int i = 0; i < _numNodes; i++)
-            {
-                // Each node can receive input from all previous nodes
-                // Alpha is initialized near zero so all operations have equal weight after softmax
-                var alpha = new Matrix<T>(i + 1, _numOperations);
-                for (int j = 0; j < alpha.Rows; j++)
-                {
-                    for (int k = 0; k < alpha.Columns; k++)
-                    {
-                        // Small random initialization: range [-0.1, 0.1]
-                        alpha[j, k] = NumOps.FromDouble((_random.NextDouble() - 0.5) * 0.2);
-                    }
-                }
-                _architectureParams.Add(alpha);
-                _architectureGradients.Add(new Matrix<T>(i + 1, _numOperations));
-            }
-
-            // Initialize network weights
-            _weights = new Dictionary<string, Vector<T>>();
-            _weightGradients = new Dictionary<string, Vector<T>>();
-
-            // Initialize default loss function (MSE for SuperNet)
-            _defaultLossFunction = lossFunction ?? new MeanSquaredErrorLoss<T>();
-        }
-
-        /// <summary>
-        /// Forward pass through the SuperNet with mixed operations
-        /// </summary>
-        public override Tensor<T> Predict(Tensor<T> input)
-        {
-            // Handle 1D input by reshaping to 2D [1, features]
-            bool was1D = input.Shape.Length == 1;
-            int[] originalShape = input._shape;
-            if (was1D)
-            {
-                input = input.Reshape([1, input.Shape[0]]);
-            }
-            else if (input.Shape.Length > 2)
-            {
-                // For higher-rank tensors, flatten to 2D [batch, features]
-                int batchSize = 1;
-                for (int i = 0; i < input.Shape.Length - 1; i++)
-                    batchSize *= input.Shape[i];
-                int features = input.Shape[input.Shape.Length - 1];
-                input = input.Reshape([batchSize, features]);
-            }
-
-            _inputSize = input.Shape[input.Shape.Length - 1];
-            _outputSize = _inputSize; // For simplicity, maintain same dimensions
-
-            // Store intermediate node outputs
-            var nodeOutputs = new List<Tensor<T>> { input };
-
-            // Process each node
-            for (int nodeIdx = 0; nodeIdx < _numNodes; nodeIdx++)
-            {
-                var nodeOutput = new Tensor<T>(input._shape);
-                var alpha = _architectureParams[nodeIdx];
-
-                // Apply softmax to architecture parameters for this node
-                var softmaxWeights = ApplySoftmax(alpha);
-
-                // Mix operations from all previous nodes
-                for (int prevNodeIdx = 0; prevNodeIdx <= nodeIdx; prevNodeIdx++)
-                {
-                    var prevOutput = nodeOutputs[prevNodeIdx];
-
-                    // Apply each operation and mix with softmax weights
-                    for (int opIdx = 0; opIdx < _numOperations; opIdx++)
-                    {
-                        var opOutput = ApplyOperation(prevOutput, opIdx, $"node{nodeIdx}_from{prevNodeIdx}_op{opIdx}");
-                        var weight = softmaxWeights[prevNodeIdx, opIdx];
-
-                        // Accumulate weighted operation outputs
-                        for (int batchIdx = 0; batchIdx < nodeOutput.Shape[0]; batchIdx++)
-                        {
-                            for (int featureIdx = 0; featureIdx < nodeOutput.Shape[1]; featureIdx++)
-                            {
-                                nodeOutput[batchIdx, featureIdx] = NumOps.Add(
-                                    nodeOutput[batchIdx, featureIdx],
-                                    NumOps.Multiply(weight, opOutput[batchIdx, featureIdx]));
-                            }
-                        }
-                    }
-                }
-
-                nodeOutputs.Add(nodeOutput);
-            }
-
-            // Get final output and restore original shape if needed
-            var result = nodeOutputs[nodeOutputs.Count - 1];
-            if (was1D)
-            {
-                result = result.Reshape(originalShape);
-            }
-            else if (originalShape.Length > 2)
-            {
-                result = result.Reshape(originalShape);
-            }
-
-            return result;
-        }
-
-        /// <summary>
-        /// Training is handled externally by alternating architecture and weight updates
-        /// </summary>
-        public override void Train(Tensor<T> input, Tensor<T> expectedOutput)
-        {
-            throw new NotSupportedException(
-                "SuperNet training is handled through alternating optimization. " +
-                "Use UpdateArchitectureParameters() and UpdateWeights() instead.");
-        }
-
-        /// <summary>
-        /// Computes validation loss for architecture parameter updates
-        /// </summary>
-        public T ComputeValidationLoss(Tensor<T> valData, Tensor<T> valLabels)
-        {
-            var predictions = Predict(valData);
-            return ComputeLoss(predictions, valLabels);
-        }
-
-        /// <summary>
-        /// Computes training loss for weight updates
-        /// </summary>
-        public T ComputeTrainingLoss(Tensor<T> trainData, Tensor<T> trainLabels)
-        {
-            var predictions = Predict(trainData);
-            return ComputeLoss(predictions, trainLabels);
-        }
-
-        /// <summary>
-        /// Computes mean squared error loss
-        /// </summary>
-        private T ComputeLoss(Tensor<T> predictions, Tensor<T> targets)
-        {
-            T sumSquaredError = NumOps.Zero;
-            int count = 0;
-
-            // Access tensors using proper 2D indexing
-            for (int batchIdx = 0; batchIdx < predictions.Shape[0]; batchIdx++)
-            {
-                for (int featureIdx = 0; featureIdx < predictions.Shape[1]; featureIdx++)
-                {
-                    var diff = NumOps.Subtract(predictions[batchIdx, featureIdx], targets[batchIdx, featureIdx]);
-                    sumSquaredError = NumOps.Add(sumSquaredError, NumOps.Multiply(diff, diff));
-                    count++;
-                }
-            }
-
-            return NumOps.Divide(sumSquaredError, NumOps.FromDouble(count));
-        }
-
-        /// <summary>
-        /// Backward pass to compute gradients for architecture parameters
-        /// </summary>
-        public void BackwardArchitecture(Tensor<T> input, Tensor<T> target)
-        {
-            // Simplified gradient computation
-            // In a full implementation, this would use automatic differentiation
-            var output = Predict(input);
-            var loss = ComputeLoss(output, target);
-
-            // Compute gradients using finite differences (simplified)
-            T epsilon = NumOps.FromDouble(1e-5);
-
-            for (int nodeIdx = 0; nodeIdx < _architectureParams.Count; nodeIdx++)
-            {
-                var alpha = _architectureParams[nodeIdx];
-                var grad = _architectureGradients[nodeIdx];
-
-                for (int i = 0; i < alpha.Rows; i++)
-                {
-                    for (int j = 0; j < alpha.Columns; j++)
-                    {
-                        // Finite difference approximation
-                        T originalValue = alpha[i, j];
-
-                        alpha[i, j] = NumOps.Add(originalValue, epsilon);
-                        var lossPlus = ComputeValidationLoss(input, target);
-
-                        alpha[i, j] = NumOps.Subtract(originalValue, epsilon);
-                        var lossMinus = ComputeValidationLoss(input, target);
-
-                        alpha[i, j] = originalValue;
-
-                        // Gradient = (f(x+ε) - f(x-ε)) / (2ε)
-                        grad[i, j] = NumOps.Divide(
-                            NumOps.Subtract(lossPlus, lossMinus),
-                            NumOps.Multiply(NumOps.FromDouble(2), epsilon)
-                        );
-                    }
-                }
-            }
-        }
-
-        /// <summary>
-        /// Backward pass to compute gradients for network weights using the specified loss function.
-        /// </summary>
-        /// <param name="input">The input tensor.</param>
-        /// <param name="target">The target tensor.</param>
-        /// <param name="lossFunction">The loss function to use for gradient computation.</param>
-        public void BackwardWeights(Tensor<T> input, Tensor<T> target, ILossFunction<T> lossFunction)
-        {
-            // Simplified gradient computation for weights
-            var output = Predict(input);
-            T epsilon = NumOps.FromDouble(1e-5);
-
-            foreach (var kvp in _weights)
-            {
-                var key = kvp.Key;
-                var weight = kvp.Value;
-                var grad = _weightGradients[key];
-
-                for (int i = 0; i < weight.Length; i++)
-                {
-                    T originalValue = weight[i];
-
-                    weight[i] = NumOps.Add(originalValue, epsilon);
-                    var lossPlus = ComputeLossWithFunction(input, target, lossFunction);
-
-                    weight[i] = NumOps.Subtract(originalValue, epsilon);
-                    var lossMinus = ComputeLossWithFunction(input, target, lossFunction);
-
-                    weight[i] = originalValue;
-
-                    grad[i] = NumOps.Divide(
-                        NumOps.Subtract(lossPlus, lossMinus),
-                        NumOps.Multiply(NumOps.FromDouble(2), epsilon)
-                    );
-                }
-            }
-        }
-
-        /// <summary>
-        /// Computes loss using the specified loss function.
-        /// </summary>
-        /// <param name="input">The input tensor.</param>
-        /// <param name="target">The target tensor.</param>
-        /// <param name="lossFunction">The loss function to use.</param>
-        /// <returns>The computed loss value.</returns>
-        private T ComputeLossWithFunction(Tensor<T> input, Tensor<T> target, ILossFunction<T> lossFunction)
-        {
-            var predictions = Predict(input);
-
-            // Flatten tensors to vectors for ILossFunction
-            var predVector = FlattenTensor(predictions);
-            var targetVector = FlattenTensor(target);
-
-            return lossFunction.CalculateLoss(predVector, targetVector);
-        }
-
-        /// <summary>
-        /// Flattens a 2D tensor to a vector.
-        /// </summary>
-        private Vector<T> FlattenTensor(Tensor<T> tensor)
-        {
-            var flattenedData = new List<T>();
-            for (int i = 0; i < tensor.Shape[0]; i++)
-            {
-                for (int j = 0; j < tensor.Shape[1]; j++)
-                {
-                    flattenedData.Add(tensor[i, j]);
-                }
-            }
-            return new Vector<T>(flattenedData.ToArray());
-        }
-
-        /// <summary>
-        /// Gets architecture parameters for optimization
-        /// </summary>
-        public List<Matrix<T>> GetArchitectureParameters()
-        {
-            return _architectureParams;
-        }
-
-        /// <summary>
-        /// Gets architecture gradients
-        /// </summary>
-        public List<Matrix<T>> GetArchitectureGradients()
-        {
-            return _architectureGradients;
-        }
-
-        /// <summary>
-        /// Gets weight parameters for optimization
-        /// </summary>
-        public Dictionary<string, Vector<T>> GetWeightParameters()
-        {
-            return _weights;
-        }
-
-        /// <summary>
-        /// Gets weight gradients
-        /// </summary>
-        public Dictionary<string, Vector<T>> GetWeightGradients()
-        {
-            return _weightGradients;
-        }
-
-        /// <summary>
-        /// Computes gradients of the loss function with respect to model parameters WITHOUT updating parameters.
-        /// </summary>
-        /// <param name="input">The input tensor.</param>
-        /// <param name="target">The target/expected output tensor.</param>
-        /// <param name="lossFunction">The loss function to use. If null, uses the model's default loss function.</param>
-        /// <returns>A vector containing gradients with respect to all model parameters (both architecture and weights).</returns>
-        /// <exception cref="ArgumentNullException">If input or target is null.</exception>
-        /// <remarks>
-        /// <para>
-        /// For SuperNet, this computes gradients for weight parameters only (not architecture parameters).
-        /// Architecture parameters are updated separately in DARTS using validation data.
-        /// The method uses the existing BackwardWeights method and collects gradients from all layers.
-        /// </para>
-        /// <para><b>For Beginners:</b>
-        /// SuperNet has two types of parameters:
-        /// - Architecture parameters (α): which operations to use
-        /// - Weight parameters (w): the actual neural network weights
-        ///
-        /// This method computes gradients for the weight parameters based on training data.
-        /// In DARTS, architecture parameters are optimized separately on validation data.
-        /// </para>
-        /// </remarks>
-        public override Vector<T> ComputeGradients(Tensor<T> input, Tensor<T> target, ILossFunction<T>? lossFunction = null)
-        {
-            if (input == null)
-                throw new ArgumentNullException(nameof(input));
-            if (target == null)
-                throw new ArgumentNullException(nameof(target));
-
-            // Use the effective loss function (supplied or default)
-            var effectiveLoss = lossFunction ?? _defaultLossFunction;
-
-            // Use BackwardWeights to compute gradients for weight parameters
-            BackwardWeights(input, target, effectiveLoss);
-
-            // Collect all gradients into a single vector
-            var gradients = new List<T>();
-
-            // Add architecture parameter gradients as ZEROS (not computed in this method)
-            // Architecture parameters are optimized separately in DARTS on validation data
-            // We include zeros here to maintain consistent vector length with GetParameters()
-            var zero = NumOps.FromDouble(0.0);
-            foreach (var alpha in _architectureParams)
-            {
-                for (int i = 0; i < alpha.Rows; i++)
-                    for (int j = 0; j < alpha.Columns; j++)
-                        gradients.Add(zero);  // Zero gradient since not computed here
-            }
-
-            // Add weight gradients (freshly computed by BackwardWeights above)
-            foreach (var weightGrad in _weightGradients.Values)
-            {
-                for (int i = 0; i < weightGrad.Length; i++)
-                    gradients.Add(weightGrad[i]);
-            }
-
-            return new Vector<T>(gradients.ToArray());
-        }
-
-        /// <summary>
-        /// Applies pre-computed gradients to update the model parameters.
-        /// </summary>
-        /// <param name="gradients">The gradient vector to apply.</param>
-        /// <param name="learningRate">The learning rate for the update.</param>
-        /// <exception cref="ArgumentNullException">If gradients is null.</exception>
-        /// <exception cref="ArgumentException">If gradient vector length doesn't match parameter count.</exception>
-        /// <remarks>
-        /// <para>
-        /// Updates both architecture and weight parameters using: θ = θ - learningRate * gradients
-        /// </para>
-        /// <para><b>For Beginners:</b>
-        /// This method applies the gradient updates to both:
-        /// - Architecture parameters (which operations are selected)
-        /// - Weight parameters (the neural network weights)
-        ///
-        /// In DARTS, you typically call this with different learning rates for
-        /// architecture and weight parameters.
-        /// </para>
-        /// </remarks>
-        public override void ApplyGradients(Vector<T> gradients, T learningRate)
-        {
-            if (gradients == null)
-                throw new ArgumentNullException(nameof(gradients));
-
-            var currentParams = GetParameters();
-
-            if (gradients.Length != currentParams.Length)
-            {
-                throw new ArgumentException(
-                    $"Gradient vector length ({gradients.Length}) must match parameter count ({currentParams.Length})",
-                    nameof(gradients));
-            }
-
-            int idx = 0;
-
-            // Update architecture parameters
-            foreach (var alpha in _architectureParams)
-            {
-                for (int i = 0; i < alpha.Rows; i++)
-                {
-                    for (int j = 0; j < alpha.Columns; j++)
-                    {
-                        T update = NumOps.Multiply(learningRate, gradients[idx++]);
-                        alpha[i, j] = NumOps.Subtract(alpha[i, j], update);
-                    }
-                }
-            }
-
-            // Update weights
-            foreach (var key in _weights.Keys.ToList())
-            {
-                var weight = _weights[key];
-                for (int i = 0; i < weight.Length; i++)
-                {
-                    T update = NumOps.Multiply(learningRate, gradients[idx++]);
-                    weight[i] = NumOps.Subtract(weight[i], update);
-                }
-            }
-        }
-
-        /// <summary>
-        /// Derives discrete architecture from continuous parameters (argmax selection)
-        /// </summary>
-        public Architecture<T> DeriveArchitecture()
-        {
-            var architecture = new Architecture<T>();
-
-            for (int nodeIdx = 0; nodeIdx < _numNodes; nodeIdx++)
-            {
-                var alpha = _architectureParams[nodeIdx];
-                var softmaxWeights = ApplySoftmax(alpha);
-
-                // For each previous node connection, select operation with highest weight
-                for (int prevNodeIdx = 0; prevNodeIdx <= nodeIdx; prevNodeIdx++)
-                {
-                    int bestOpIdx = 0;
-                    T bestWeight = softmaxWeights[prevNodeIdx, 0];
-
-                    for (int opIdx = 1; opIdx < _numOperations; opIdx++)
-                    {
-                        if (NumOps.GreaterThan(softmaxWeights[prevNodeIdx, opIdx], bestWeight))
-                        {
-                            bestWeight = softmaxWeights[prevNodeIdx, opIdx];
-                            bestOpIdx = opIdx;
-                        }
-                    }
-
-                    // Add selected operation to architecture
-                    var operation = GetOperationName(bestOpIdx);
-                    architecture.AddOperation(nodeIdx, prevNodeIdx, operation);
-                }
-            }
-
-            return architecture;
-        }
-
-        /// <summary>
-        /// Apply softmax to architecture parameters
-        /// </summary>
-        private Matrix<T> ApplySoftmax(Matrix<T> alpha)
-        {
-            var result = new Matrix<T>(alpha.Rows, alpha.Columns);
-
-            for (int row = 0; row < alpha.Rows; row++)
-            {
-                // Compute softmax for this row
-                T maxVal = alpha[row, 0];
-                for (int col = 1; col < alpha.Columns; col++)
-                {
-                    if (NumOps.GreaterThan(alpha[row, col], maxVal))
-                        maxVal = alpha[row, col];
-                }
-
-                // Compute exp(x - max) for numerical stability
-                T sumExp = NumOps.Zero;
-                var expValues = new T[alpha.Columns];
-                for (int col = 0; col < alpha.Columns; col++)
-                {
-                    expValues[col] = NumOps.Exp(NumOps.Subtract(alpha[row, col], maxVal));
-                    sumExp = NumOps.Add(sumExp, expValues[col]);
-                }
-
-                // Normalize
-                for (int col = 0; col < alpha.Columns; col++)
-                {
-                    result[row, col] = NumOps.Divide(expValues[col], sumExp);
-                }
-            }
-
-            return result;
-        }
-
-        /// <summary>
-        /// Apply a specific operation to input
-        /// </summary>
-        private Tensor<T> ApplyOperation(Tensor<T> input, int opIdx, string weightKey)
-        {
-            // Handle 1D input by reshaping to 2D [1, features]
-            bool was1D = input.Shape.Length == 1;
-            int[] originalShape = input._shape;
-            if (was1D)
-            {
-                input = input.Reshape([1, input.Shape[0]]);
-            }
-            else if (input.Shape.Length > 2)
-            {
-                // For higher-rank tensors, flatten to 2D [batch, features]
-                int batchSize = 1;
-                for (int i = 0; i < input.Shape.Length - 1; i++)
-                    batchSize *= input.Shape[i];
-                int features = input.Shape[input.Shape.Length - 1];
-                input = input.Reshape([batchSize, features]);
-            }
-
-            // Initialize weights if needed
-            if (!_weights.ContainsKey(weightKey))
-            {
-                _weights[weightKey] = new Vector<T>(input.Length);
-                _weightGradients[weightKey] = new Vector<T>(input.Length);
-
-                // Initialize with small random values
-                for (int i = 0; i < input.Length; i++)
-                {
-                    _weights[weightKey][i] = NumOps.FromDouble((_random.NextDouble() - 0.5) * 0.1);
-                }
-            }
-
-            var output = TensorAllocator.Rent<T>(input._shape);
-            var weight = _weights[weightKey];
-
-            // Apply operation (simplified) using proper 2D tensor indexing
-            switch (opIdx)
-            {
-                case 0: // Identity
-                    for (int batchIdx = 0; batchIdx < input.Shape[0]; batchIdx++)
-                    {
-                        for (int featureIdx = 0; featureIdx < input.Shape[1]; featureIdx++)
-                        {
-                            output[batchIdx, featureIdx] = input[batchIdx, featureIdx];
-                        }
-                    }
-                    break;
-
-                case 1: // 3x3 Conv (simplified as weighted pass)
-                {
-                    for (int batchIdx = 0; batchIdx < input.Shape[0]; batchIdx++)
-                    {
-                        for (int featureIdx = 0; featureIdx < input.Shape[1]; featureIdx++)
-                        {
-                            if (featureIdx < weight.Length)
-                            {
-                                output[batchIdx, featureIdx] = NumOps.Multiply(
-                                    input[batchIdx, featureIdx],
-                                    NumOps.Add(NumOps.One, weight[featureIdx]));
-                            }
-                        }
-                    }
-                }
-                break;
-
-                case 2: // 5x5 Conv (simplified)
-                {
-                    for (int batchIdx = 0; batchIdx < input.Shape[0]; batchIdx++)
-                    {
-                        for (int featureIdx = 0; featureIdx < input.Shape[1]; featureIdx++)
-                        {
-                            if (featureIdx < weight.Length)
-                            {
-                                output[batchIdx, featureIdx] = NumOps.Multiply(
-                                    input[batchIdx, featureIdx],
-                                    NumOps.Add(NumOps.One, NumOps.Multiply(NumOps.FromDouble(1.5), weight[featureIdx])));
-                            }
-                        }
-                    }
-                }
-                break;
-
-                case 3: // MaxPool (simplified)
-                    for (int batchIdx = 0; batchIdx < input.Shape[0]; batchIdx++)
-                    {
-                        for (int featureIdx = 0; featureIdx < input.Shape[1]; featureIdx++)
-                        {
-                            output[batchIdx, featureIdx] = NumOps.Multiply(input[batchIdx, featureIdx], NumOps.FromDouble(0.9));
-                        }
-                    }
-                    break;
-
-                case 4: // AvgPool (simplified)
-                    for (int batchIdx = 0; batchIdx < input.Shape[0]; batchIdx++)
-                    {
-                        for (int featureIdx = 0; featureIdx < input.Shape[1]; featureIdx++)
-                        {
-                            output[batchIdx, featureIdx] = NumOps.Multiply(input[batchIdx, featureIdx], NumOps.FromDouble(0.8));
-                        }
-                    }
-                    break;
-
-                default:
-                    for (int batchIdx = 0; batchIdx < input.Shape[0]; batchIdx++)
-                    {
-                        for (int featureIdx = 0; featureIdx < input.Shape[1]; featureIdx++)
-                        {
-                            output[batchIdx, featureIdx] = input[batchIdx, featureIdx];
-                        }
-                    }
-                    break;
-            }
-
-            // Restore original shape if input was 1D or higher-rank
-            if (was1D)
-            {
-                output = output.Reshape(originalShape);
-            }
-            else if (originalShape.Length > 2)
-            {
-                output = output.Reshape(originalShape);
-            }
-
-            return output;
-        }
-
-        /// <summary>
-        /// Gets the human-readable name for a given operation index.
-        /// Maps operation indices to their corresponding operation types in the NAS search space.
-        /// </summary>
-        /// <param name="opIdx">The operation index (0-4)</param>
-        /// <returns>The operation name (identity, conv3x3, conv5x5, maxpool, avgpool)</returns>
-        private string GetOperationName(int opIdx)
-        {
-            return opIdx switch
-            {
-                0 => "identity",
-                1 => "conv3x3",
-                2 => "conv5x5",
-                3 => "maxpool",
-                4 => "avgpool",
-                _ => "identity"
-            };
-        }
-
-        // Replaced by the declared parameter source below. Removed under AIDN082.
-
-        // Replaced by the declared parameter source below. Removed under AIDN082.
-
-        public override IFullModel<T, Tensor<T>, Tensor<T>> WithParameters(Vector<T> parameters)
-        {
-            var clone = (SuperNet<T>)Clone();
-            clone.SetParameters(parameters);
-            return clone;
-        }
-
-        public override ModelMetadata<T> GetModelMetadata()
-        {
-            return new ModelMetadata<T>
-            {
-                Description = "Differentiable Architecture Search SuperNet",
-                FeatureCount = _inputSize,
-                Complexity = _numNodes,
-                AdditionalInfo = new Dictionary<string, object>
-                {
-                    ["NumNodes"] = _numNodes,
-                    ["NumOperations"] = _numOperations,
-                    ["ParameterCount"] = ParameterCount
-                }
-            };
-        }
-
-        public override void SaveModel(string filePath)
-        {
-            Helpers.ModelPersistenceGuard.EnforceBeforeSave();
-
-            if (string.IsNullOrWhiteSpace(filePath))
-                throw new ArgumentException("File path cannot be null or empty.", nameof(filePath));
-
-            // Validate path security: prevent directory traversal attacks
-            // Use canonicalized path and ensure it is within the current working directory
-            var fullPath = System.IO.Path.GetFullPath(filePath);
-
-            // Additional validation: ensure the resolved path doesn't escape the working directory
-            var currentDirectory = System.IO.Path.GetFullPath(Environment.CurrentDirectory);
-            // Ensure trailing separator for strict directory containment (prevents /app vs /app-data bypass)
-            var currentDirWithSep = currentDirectory.EndsWith(System.IO.Path.DirectorySeparatorChar.ToString())
-                ? currentDirectory
-                : currentDirectory + System.IO.Path.DirectorySeparatorChar;
-            if (!fullPath.StartsWith(currentDirWithSep, StringComparison.OrdinalIgnoreCase))
-                throw new UnauthorizedAccessException($"Attempted to save model outside of the current directory. Path: {fullPath}");
-
-            using var fs = new System.IO.FileStream(fullPath, System.IO.FileMode.Create);
-            using var writer = new System.IO.BinaryWriter(fs);
-
-            writer.Write(_numNodes);
-            writer.Write(_numOperations);
-            writer.Write(_inputSize);
-            writer.Write(_outputSize);
-
-            // Serialize architecture parameters
-            writer.Write(_architectureParams.Count);
-            foreach (var alpha in _architectureParams)
-            {
-                writer.Write(alpha.Rows);
-                writer.Write(alpha.Columns);
-                for (int i = 0; i < alpha.Rows; i++)
-                {
-                    for (int j = 0; j < alpha.Columns; j++)
-                    {
-                        writer.Write(Convert.ToDouble(alpha[i, j]));
-                    }
-                }
-            }
-
-            // Serialize weights
-            writer.Write(_weights.Count);
-            foreach (var kvp in _weights)
-            {
-                writer.Write(kvp.Key);
-                writer.Write(kvp.Value.Length);
-                for (int i = 0; i < kvp.Value.Length; i++)
-                {
-                    writer.Write(Convert.ToDouble(kvp.Value[i]));
-                }
-            }
-        }
-        public override void LoadModel(string filePath)
-        {
-            Helpers.ModelPersistenceGuard.EnforceBeforeLoad();
-
-            if (string.IsNullOrWhiteSpace(filePath))
-                throw new ArgumentException("File path cannot be null or empty.", nameof(filePath));
-
-            // Validate path security: prevent directory traversal attacks
-            // Use canonicalized path and ensure it is within the current working directory
-            var fullPath = System.IO.Path.GetFullPath(filePath);
-
-            // Additional validation: ensure the resolved path doesn't escape the working directory
-            var currentDirectory = System.IO.Path.GetFullPath(Environment.CurrentDirectory);
-            // Ensure trailing separator for strict directory containment (prevents /app vs /app-data bypass)
-            var currentDirWithSep = currentDirectory.EndsWith(System.IO.Path.DirectorySeparatorChar.ToString())
-                ? currentDirectory
-                : currentDirectory + System.IO.Path.DirectorySeparatorChar;
-            if (!fullPath.StartsWith(currentDirWithSep, StringComparison.OrdinalIgnoreCase))
-                throw new UnauthorizedAccessException($"Attempted to load model from outside the current directory. Path: {fullPath}");
-
-            if (!System.IO.File.Exists(fullPath))
-                throw new System.IO.FileNotFoundException($"Model file not found: {filePath}");
-
-            using var fs = new System.IO.FileStream(fullPath, System.IO.FileMode.Open);
-            using var reader = new System.IO.BinaryReader(fs);
-
-            // Deserialize _numNodes and _numOperations (read-only fields need reflection or constructor)
-            var numNodes = reader.ReadInt32();
-            var numOperations = reader.ReadInt32();
-
-            // Validate that deserialized structure matches this instance
-            if (numNodes != _numNodes || numOperations != _numOperations)
-            {
-                throw new InvalidOperationException(
-                    $"Model file structure mismatch: file has numNodes={numNodes}, numOperations={numOperations}, " +
-                    $"but this instance has numNodes={_numNodes}, numOperations={_numOperations}.");
-            }
-
-            _inputSize = reader.ReadInt32();
-            _outputSize = reader.ReadInt32();
-
-            // Deserialize architecture parameters
-            int alphaCount = reader.ReadInt32();
-            _architectureParams.Clear();
-            _architectureGradients.Clear();
-            for (int idx = 0; idx < alphaCount; idx++)
-            {
-                int rows = reader.ReadInt32();
-                int cols = reader.ReadInt32();
-                var alpha = new Matrix<T>(rows, cols);
-                for (int i = 0; i < rows; i++)
-                {
-                    for (int j = 0; j < cols; j++)
-                    {
-                        alpha[i, j] = NumOps.FromDouble(reader.ReadDouble());
-                    }
-                }
-                _architectureParams.Add(alpha);
-                _architectureGradients.Add(new Matrix<T>(rows, cols));
-            }
-
-            // Deserialize weights
-            int weightCount = reader.ReadInt32();
-            _weights.Clear();
-            _weightGradients.Clear();
-            for (int idx = 0; idx < weightCount; idx++)
-            {
-                string key = reader.ReadString();
-                int length = reader.ReadInt32();
-                var weight = new Vector<T>(length);
-                for (int i = 0; i < length; i++)
-                {
-                    weight[i] = NumOps.FromDouble(reader.ReadDouble());
-                }
-                _weights[key] = weight;
-                _weightGradients[key] = new Vector<T>(length);
-            }
-        }
-        public override byte[] Serialize()
-        {
-            using var ms = new System.IO.MemoryStream();
-            using var writer = new System.IO.BinaryWriter(ms);
-
-            writer.Write(_numNodes);
-            writer.Write(_numOperations);
-            writer.Write(_inputSize);
-            writer.Write(_outputSize);
-
-            // Serialize architecture parameters
-            writer.Write(_architectureParams.Count);
-            foreach (var alpha in _architectureParams)
-            {
-                writer.Write(alpha.Rows);
-                writer.Write(alpha.Columns);
-                for (int i = 0; i < alpha.Rows; i++)
-                {
-                    for (int j = 0; j < alpha.Columns; j++)
-                    {
-                        writer.Write(Convert.ToDouble(alpha[i, j]));
-                    }
-                }
-            }
-
-            // Serialize weights
-            writer.Write(_weights.Count);
-            foreach (var kvp in _weights)
-            {
-                writer.Write(kvp.Key);
-                writer.Write(kvp.Value.Length);
-                for (int i = 0; i < kvp.Value.Length; i++)
-                {
-                    writer.Write(Convert.ToDouble(kvp.Value[i]));
-                }
-            }
-
-            return ms.ToArray();
-        }
-        public override void Deserialize(byte[] data)
-        {
-            if (data == null)
-                throw new ArgumentNullException(nameof(data), "The data parameter passed to Deserialize cannot be null.");
-
-            using var ms = new System.IO.MemoryStream(data);
-            using var reader = new System.IO.BinaryReader(ms);
-
-            // Deserialize _numNodes and _numOperations (read-only fields need reflection or constructor)
-            var numNodes = reader.ReadInt32();
-            var numOperations = reader.ReadInt32();
-
-            // Validate that deserialized structure matches this instance
-            if (numNodes != _numNodes || numOperations != _numOperations)
-            {
-                throw new InvalidOperationException(
-                    $"Deserialized model structure does not match this instance. " +
-                    $"Expected numNodes={_numNodes}, numOperations={_numOperations}, " +
-                    $"but got numNodes={numNodes}, numOperations={numOperations}.");
-            }
-
-            _inputSize = reader.ReadInt32();
-            _outputSize = reader.ReadInt32();
-
-            // Deserialize architecture parameters
-            int alphaCount = reader.ReadInt32();
-            _architectureParams.Clear();
-            _architectureGradients.Clear();
-            for (int idx = 0; idx < alphaCount; idx++)
-            {
-                int rows = reader.ReadInt32();
-                int cols = reader.ReadInt32();
-                var alpha = new Matrix<T>(rows, cols);
-                for (int i = 0; i < rows; i++)
-                {
-                    for (int j = 0; j < cols; j++)
-                    {
-                        alpha[i, j] = NumOps.FromDouble(reader.ReadDouble());
-                    }
-                }
-                _architectureParams.Add(alpha);
-                _architectureGradients.Add(new Matrix<T>(rows, cols));
-            }
-
-            // Deserialize weights
-            int weightCount = reader.ReadInt32();
-            _weights.Clear();
-            _weightGradients.Clear();
-            for (int idx = 0; idx < weightCount; idx++)
-            {
-                string key = reader.ReadString();
-                int length = reader.ReadInt32();
-                var weight = new Vector<T>(length);
-                for (int i = 0; i < length; i++)
-                {
-                    weight[i] = NumOps.FromDouble(reader.ReadDouble());
-                }
-                _weights[key] = weight;
-                _weightGradients[key] = new Vector<T>(length);
-            }
-        }
-
-        public override Dictionary<string, T> GetFeatureImportance() => new Dictionary<string, T>();
-        public override IEnumerable<int> GetActiveFeatureIndices() => Enumerable.Range(0, _inputSize);
-        public override bool IsFeatureUsed(int featureIndex) => featureIndex >= 0 && featureIndex < _inputSize;
-        public override void SetActiveFeatureIndices(IEnumerable<int> featureIndices) { }
-
-        public override IFullModel<T, Tensor<T>, Tensor<T>> Clone()
-        {
-            return new SuperNet<T>(_searchSpace, _numNodes);
-        }
-
-        public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy() => Clone();
-
-        #region IInterpretableModel Implementation
-
-        /// <summary>
-        /// Gets the operation importance for SuperNet architecture search.
-        /// Returns importance scores for architectural operations rather than input features.
-        /// </summary>
-        /// <param name="inputs">Input tensor (required for interface compliance; not used in this implementation)</param>
-        /// <returns>Dictionary mapping operation indices to their importance scores</returns>
-        /// <remarks>
-        /// <para>
-        /// <b>Note:</b> SuperNet reinterprets "feature importance" as "operation importance" in the context of Neural Architecture Search (NAS).
-        /// The returned dictionary maps operation indices (0=identity, 1=conv3x3, 2=conv5x5, etc.) to their importance scores,
-        /// calculated by aggregating the absolute values of architecture parameters across all nodes.
-        /// </para>
-        /// <para>
-        /// The 'inputs' parameter is required for IInterpretableModel interface compliance but is not used.
-        /// SuperNet analyzes operation importance based on learned architecture parameters rather than input data.
-        /// </para>
-        /// </remarks>
-        public virtual async Task<Dictionary<int, T>> GetGlobalFeatureImportanceAsync(Tensor<T> inputs)
-        {
-            var importance = new Dictionary<int, T>();
-
-            // For SuperNet, we analyze operation importance rather than input feature importance
-            // Each operation index represents a different architectural operation (identity, conv3x3, etc.)
-            for (int opIdx = 0; opIdx < _numOperations; opIdx++)
-            {
-                T sum = NumOps.Zero;
-
-                // Aggregate importance across all nodes and connections
-                foreach (var alpha in _architectureParams)
-                {
-                    // Sum absolute values of architecture parameters for this operation
-                    for (int i = 0; i < alpha.Rows; i++)
-                    {
-                        if (opIdx < alpha.Columns)
-                        {
-                            sum = NumOps.Add(sum, NumOps.Abs(alpha[i, opIdx]));
-                        }
-                    }
-                }
-
-                importance[opIdx] = sum;
-            }
-
-            return await Task.FromResult(importance);
-        }
-
-        /// <summary>
-        /// Gets the local feature importance for a specific input.
-        /// Provides importance based on softmax weights, analyzing which operations are most active.
-        /// </summary>
-        public virtual async Task<Dictionary<int, T>> GetLocalFeatureImportanceAsync(Tensor<T> input)
-        {
-            var importance = new Dictionary<int, T>();
-
-            // For local importance, we use softmax-transformed architecture parameters
-            // to determine which operations are most active for this specific input
-            for (int opIdx = 0; opIdx < _numOperations; opIdx++)
-            {
-                T sum = NumOps.Zero;
-
-                // Apply softmax and aggregate weights for each operation
-                foreach (var alpha in _architectureParams)
-                {
-                    var softmaxWeights = ApplySoftmax(alpha);
-
-                    for (int i = 0; i < softmaxWeights.Rows; i++)
-                    {
-                        if (opIdx < softmaxWeights.Columns)
-                        {
-                            sum = NumOps.Add(sum, softmaxWeights[i, opIdx]);
-                        }
-                    }
-                }
-
-                importance[opIdx] = sum;
-            }
-
-            return await Task.FromResult(importance);
-        }
-
-        /// <summary>
-        /// Gets SHAP values for the given inputs.
-        /// Not supported for SuperNet architecture search models.
-        /// </summary>
-        public virtual async Task<Matrix<T>> GetShapValuesAsync(Tensor<T> inputs)
-        {
-            await Task.CompletedTask;
-            throw new NotSupportedException(
-                "SHAP values are not supported for SuperNet architecture search models. " +
-                "SuperNet uses differentiable architecture search and does not have traditional feature attribution.");
-        }
-
-        /// <summary>
-        /// Gets LIME explanation for a specific input.
-        /// Not supported for SuperNet architecture search models.
-        /// </summary>
-        public virtual async Task<LimeExplanation<T>> GetLimeExplanationAsync(Tensor<T> input, int numFeatures = 10)
-        {
-            await Task.CompletedTask;
-            throw new NotSupportedException(
-                "LIME explanations are not supported for SuperNet architecture search models. " +
-                "Use GetGlobalFeatureImportanceAsync or GetLocalFeatureImportanceAsync instead.");
-        }
-
-        /// <summary>
-        /// Gets partial dependence data for specified features.
-        /// Not supported for SuperNet architecture search models.
-        /// </summary>
-        public virtual async Task<PartialDependenceData<T>> GetPartialDependenceAsync(Vector<int> featureIndices, int gridResolution = 20)
-        {
-            await Task.CompletedTask;
-            throw new NotSupportedException(
-                "Partial dependence plots are not supported for SuperNet architecture search models. " +
-                "SuperNet focuses on architecture optimization rather than feature-level analysis.");
-        }
-
-        /// <summary>
-        /// Gets counterfactual explanation for a given input and desired output.
-        /// Not supported for SuperNet architecture search models.
-        /// </summary>
-        public virtual async Task<CounterfactualExplanation<T>> GetCounterfactualAsync(Tensor<T> input, Tensor<T> desiredOutput, int maxChanges = 5)
-        {
-            await Task.CompletedTask;
-            throw new NotSupportedException(
-                "Counterfactual explanations are not supported for SuperNet architecture search models. " +
-                "SuperNet is designed for architecture search, not instance-level counterfactuals.");
-        }
-
-        /// <summary>
-        /// Gets model-specific interpretability information for SuperNet.
-        /// Returns architecture parameters and their importance.
-        /// </summary>
-        public virtual async Task<Dictionary<string, object>> GetModelSpecificInterpretabilityAsync()
-        {
-            var info = new Dictionary<string, object>
-            {
-                ["ModelType"] = "SuperNet (Differentiable Architecture Search)",
-                ["NumNodes"] = _numNodes,
-                ["NumOperations"] = _numOperations,
-                // Dictionary<string, object> can box a long natively;
-                // ToFlatVectorSize is reserved for places that genuinely
-                // need an int (Vector<T> allocation, int-indexed APIs).
-                // Storing the un-narrowed long lets >int.MaxValue
-                // models surface their true count via the
-                // interpretability dictionary without throwing here.
-                // Closes review-comment #1271.vDPV.
-                ["ParameterCount"] = ParameterCount,
-                ["ArchitectureParameterCount"] = _architectureParams.Sum(a => a.Rows * a.Columns),
-                ["WeightParameterCount"] = _weights.Values.Sum(w => w.Length),
-                ["InputSize"] = _inputSize,
-                ["OutputSize"] = _outputSize
-            };
-
-            // Add architecture parameter statistics
-            var archStats = new List<Dictionary<string, object>>();
-            for (int i = 0; i < _architectureParams.Count; i++)
-            {
-                var alpha = _architectureParams[i];
-                var softmax = ApplySoftmax(alpha);
-
-                var nodeStats = new Dictionary<string, object>
-                {
-                    ["NodeIndex"] = i,
-                    ["Rows"] = alpha.Rows,
-                    ["Columns"] = alpha.Columns,
-                    ["ParameterCount"] = alpha.Rows * alpha.Columns
-                };
-
-                archStats.Add(nodeStats);
-            }
-
-            info["ArchitectureNodes"] = archStats;
-
-            return await Task.FromResult(info);
-        }
-
-        /// <summary>
-        /// Generates a text explanation for a prediction.
-        /// Provides a description of which operations are most important in the SuperNet.
-        /// </summary>
-        public virtual async Task<string> GenerateTextExplanationAsync(Tensor<T> input, Tensor<T> prediction)
-        {
-            var explanation = $"SuperNet Architecture Search Model:\n";
-            explanation += $"- Network contains {_numNodes} nodes with {_numOperations} operations each\n";
-            explanation += $"- Total parameters: {ParameterCount}\n";
-            explanation += $"- Architecture is determined by learned softmax weights over operations\n\n";
-
-            explanation += "Most important architectural decisions:\n";
-
-            // Identify most important nodes based on architecture parameters
-            for (int nodeIdx = 0; nodeIdx < Math.Min(3, _numNodes); nodeIdx++)
-            {
-                var alpha = _architectureParams[nodeIdx];
-                var softmax = ApplySoftmax(alpha);
-
-                // Find the operation with highest weight
-                if (softmax.Rows > 0 && softmax.Columns > 0)
-                {
-                    int bestOp = 0;
-                    T bestWeight = softmax[0, 0];
-
-                    for (int i = 0; i < softmax.Rows; i++)
-                    {
-                        for (int j = 0; j < softmax.Columns; j++)
-                        {
-                            if (NumOps.GreaterThan(softmax[i, j], bestWeight))
-                            {
-                                bestWeight = softmax[i, j];
-                                bestOp = j;
-                            }
-                        }
-                    }
-
-                    explanation += $"- Node {nodeIdx}: {GetOperationName(bestOp)} operation is dominant\n";
-                }
-                else
-                {
-                    explanation += $"- Node {nodeIdx}: No operations available (empty softmax matrix)\n";
-                }
-            }
-
-            return await Task.FromResult(explanation);
-        }
-
-        /// <summary>
-        /// Gets feature interaction effects between two features.
-        /// Analyzes interactions between operations based on architecture parameter correlations.
-        /// </summary>
-        public virtual async Task<T> GetFeatureInteractionAsync(int feature1Index, int feature2Index)
-        {
-            // In SuperNet context, feature indices represent operation indices
-            if (feature1Index < 0 || feature1Index >= _numOperations ||
-                feature2Index < 0 || feature2Index >= _numOperations)
-            {
-                throw new ArgumentOutOfRangeException(
-                    $"Feature indices must be in the range [0, {_numOperations - 1}]. " +
-                    $"Received feature1Index={feature1Index}, feature2Index={feature2Index}.");
-            }
-
-            // Calculate correlation between two operations across all architecture parameters
-            T sum1 = NumOps.Zero;
-            T sum2 = NumOps.Zero;
-            T sumProduct = NumOps.Zero;
-            T sumSquares1 = NumOps.Zero;
-            T sumSquares2 = NumOps.Zero;
-            int count = 0;
-
-            foreach (var alpha in _architectureParams)
-            {
-                for (int i = 0; i < alpha.Rows; i++)
-                {
-                    if (feature1Index < alpha.Columns && feature2Index < alpha.Columns)
-                    {
-                        T val1 = alpha[i, feature1Index];
-                        T val2 = alpha[i, feature2Index];
-
-                        sum1 = NumOps.Add(sum1, val1);
-                        sum2 = NumOps.Add(sum2, val2);
-                        sumProduct = NumOps.Add(sumProduct, NumOps.Multiply(val1, val2));
-                        sumSquares1 = NumOps.Add(sumSquares1, NumOps.Multiply(val1, val1));
-                        sumSquares2 = NumOps.Add(sumSquares2, NumOps.Multiply(val2, val2));
-                        count++;
-                    }
-                }
-            }
-
-            if (count == 0)
-            {
-                return NumOps.Zero;
-            }
-
-            // Calculate correlation coefficient
-            T n = NumOps.FromDouble(count);
-            T numerator = NumOps.Subtract(
-                NumOps.Multiply(n, sumProduct),
-                NumOps.Multiply(sum1, sum2)
-            );
-
-            T denom1 = NumOps.Subtract(
-                NumOps.Multiply(n, sumSquares1),
-                NumOps.Multiply(sum1, sum1)
-            );
-
-            T denom2 = NumOps.Subtract(
-                NumOps.Multiply(n, sumSquares2),
-                NumOps.Multiply(sum2, sum2)
-            );
-
-            T denominator = NumOps.Multiply(denom1, denom2);
-
-            // Avoid division by zero
-            if (NumOps.Equals(denominator, NumOps.Zero))
-            {
-                return NumOps.Zero;
-            }
-
-            T correlation = NumOps.Divide(numerator, NumOps.Sqrt(denominator));
-
-            return await Task.FromResult(correlation);
-        }
-
-        /// <summary>
-        /// Validates fairness metrics for the given inputs.
-        /// Not supported for SuperNet architecture search models.
-        /// </summary>
-        public virtual async Task<FairnessMetrics<T>> ValidateFairnessAsync(Tensor<T> inputs, int sensitiveFeatureIndex)
-        {
-            await Task.CompletedTask;
-            throw new NotSupportedException(
-                "Fairness validation is not supported for SuperNet architecture search models. " +
-                "SuperNet focuses on architecture optimization rather than fairness evaluation.");
-        }
-
-        /// <summary>
-        /// Gets anchor explanation for a given input.
-        /// Not supported for SuperNet architecture search models.
-        /// </summary>
-        public virtual async Task<AnchorExplanation<T>> GetAnchorExplanationAsync(Tensor<T> input, T threshold)
-        {
-            await Task.CompletedTask;
-            throw new NotSupportedException(
-                "Anchor explanations are not supported for SuperNet architecture search models. " +
-                "SuperNet focuses on architecture optimization rather than instance-level explanations.");
-        }
-
-        /// <summary>
-        /// Sets the base model for interpretability analysis.
-        /// </summary>
-        public virtual void SetBaseModel(IModel<Tensor<T>, Tensor<T>, ModelMetadata<T>> model)
-        {
-            Guard.NotNull(model);
-            _baseModel = model;
-        }
-
-        /// <summary>
-        /// Enables specific interpretation methods.
-        /// </summary>
-        public virtual void EnableMethod(params InterpretationMethod[] methods)
-        {
-            if (methods == null)
-                return;
-
-            foreach (var method in methods)
-            {
-                _enabledMethods.Add(method);
-            }
-        }
-
-        /// <summary>
-        /// Configures fairness evaluation settings.
-        /// </summary>
-        public virtual void ConfigureFairness(Vector<int> sensitiveFeatures, params FairnessMetric[] fairnessMetrics)
-        {
-            Guard.NotNull(sensitiveFeatures);
-            _sensitiveFeatures = sensitiveFeatures;
-            _fairnessMetrics.Clear();
-            if (fairnessMetrics != null)
-            {
-                _fairnessMetrics.AddRange(fairnessMetrics);
-            }
-        }
-
-        #endregion
-
-        /// <summary>
-        /// Saves the SuperNet's current state (architecture parameters and weights) to a stream.
-        /// </summary>
-        /// <param name="stream">The stream to write the model state to.</param>
-        /// <remarks>
-        /// <para>
-        /// This method serializes all the information needed to recreate the SuperNet's current state,
-        /// including architecture parameters, operation weights, and model configuration.
-        /// It uses the existing Serialize method and writes the data to the provided stream.
-        /// </para>
-        /// <para><b>For Beginners:</b> This is like creating a snapshot of your neural architecture search model.
-        ///
-        /// When you call SaveState:
-        /// - All architecture parameters (alpha values) are written to the stream
-        /// - All operation weights are saved
-        /// - The model's configuration and structure are preserved
-        ///
-        /// This is particularly useful for:
-        /// - Checkpointing during neural architecture search
-        /// - Saving the best architecture found during search
-        /// - Knowledge distillation from SuperNet to final architecture
-        /// - Resuming interrupted architecture search
-        ///
-        /// You can later use LoadState to restore the model to this exact state.
-        /// </para>
-        /// </remarks>
-        /// <exception cref="ArgumentNullException">Thrown when stream is null.</exception>
-        /// <exception cref="IOException">Thrown when there's an error writing to the stream.</exception>
-        public override void SaveState(Stream stream)
-        {
-            if (stream == null)
-                throw new ArgumentNullException(nameof(stream));
-
-            if (!stream.CanWrite)
-                throw new ArgumentException("Stream must be writable.", nameof(stream));
-
-            try
-            {
-                var data = this.Serialize();
-                stream.Write(data, 0, data.Length);
-                stream.Flush();
-            }
-            catch (IOException ex)
-            {
-                throw new IOException($"Failed to save SuperNet state to stream: {ex.Message}", ex);
-            }
-            catch (Exception ex)
-            {
-                throw new InvalidOperationException($"Unexpected error while saving SuperNet state: {ex.Message}", ex);
-            }
-        }
-
-        /// <summary>
-        /// Loads the SuperNet's state (architecture parameters and weights) from a stream.
-        /// </summary>
-        /// <param name="stream">The stream to read the model state from.</param>
-        /// <remarks>
-        /// <para>
-        /// This method deserializes SuperNet state that was previously saved with SaveState,
-        /// restoring all architecture parameters, operation weights, and configuration.
-        /// It uses the existing Deserialize method after reading data from the stream.
-        /// </para>
-        /// <para><b>For Beginners:</b> This is like loading a saved snapshot of your neural architecture search model.
-        ///
-        /// When you call LoadState:
-        /// - All architecture parameters (alpha values) are read from the stream
-        /// - All operation weights are restored
-        /// - The model is configured to match the saved state
-        ///
-        /// After loading, the model can:
-        /// - Continue architecture search from where it left off
-        /// - Make predictions using the restored architecture
-        /// - Be used for further optimization or deployment
-        ///
-        /// This is essential for:
-        /// - Resuming interrupted architecture search
-        /// - Loading the best architecture found during search
-        /// - Deploying searched architectures to production
-        /// - Knowledge distillation workflows
-        /// </para>
-        /// </remarks>
-        /// <exception cref="ArgumentNullException">Thrown when stream is null.</exception>
-        /// <exception cref="IOException">Thrown when there's an error reading from the stream.</exception>
-        /// <exception cref="InvalidOperationException">Thrown when the stream contains invalid or incompatible data.</exception>
-        public override void LoadState(Stream stream)
-        {
-            if (stream == null)
-                throw new ArgumentNullException(nameof(stream));
-
-            if (!stream.CanRead)
-                throw new ArgumentException("Stream must be readable.", nameof(stream));
-
-            try
-            {
-                using var ms = new MemoryStream();
-                stream.CopyTo(ms);
-                var data = ms.ToArray();
-
-                if (data.Length == 0)
-                    throw new InvalidOperationException("Stream contains no data.");
-
-                this.Deserialize(data);
-            }
-            catch (IOException ex)
-            {
-                throw new IOException($"Failed to read SuperNet state from stream: {ex.Message}", ex);
-            }
-            catch (InvalidOperationException)
-            {
-                // Re-throw InvalidOperationException from Deserialize
-                throw;
-            }
-            catch (Exception ex)
-            {
-                throw new InvalidOperationException(
-                    $"Failed to deserialize SuperNet state. The stream may contain corrupted or incompatible data: {ex.Message}", ex);
-            }
-        }
-
-    }
-}
+
+        // Gradients
+        [Scratch]
+        private readonly List<Matrix<T>> _architectureGradients;
+        [Scratch]
+        private readonly Dictionary<string, Vector<T>> _weightGradients;
+
+        // Model metadata
+        private int _inputSize;
+        private int _outputSize;
+
+        // IInterpretableModel fields
+        private readonly HashSet<InterpretationMethod> _enabledMethods = new();
+        [Buffer]
+        private Vector<int>? _sensitiveFeatures;
+        private readonly List<FairnessMetric> _fairnessMetrics = new();
+        private IModel<Tensor<T>, Tensor<T>, ModelMetadata<T>>? _baseModel;
+
+        /// <summary>
+        /// The default loss function used by this model for gradient computation.
+        /// </summary>
+        private readonly ILossFunction<T> _defaultLossFunction;
+
+
+        public string[] FeatureNames { get; set; } = Array.Empty<string>();
+        /// <summary>
+        /// Gets the default loss function used by this model for gradient computation.
+        /// </summary>
+        /// <remarks>
+        /// <para>
+        /// For SuperNet (Neural Architecture Search), the default loss function is Mean Squared Error (MSE),
+        /// which is used for computing both architecture and weight gradients.
+        /// </para>
+        /// </remarks>
+        public override ILossFunction<T> DefaultLossFunction => _defaultLossFunction;
+
+        /// <summary>
+        /// Initializes a new SuperNet for differentiable architecture search.
+        /// </summary>
+        /// <param name="searchSpace">The search space defining available operations</param>
+        /// <param name="numNodes">Number of nodes in the architecture</param>
+        /// <param name="lossFunction">Optional loss function to use for training. If null, uses Mean Squared Error (MSE) for neural architecture search.</param>
+        public SuperNet(SearchSpaceBase<T> searchSpace, int numNodes = 4, ILossFunction<T>? lossFunction = null)
+        {
+            _searchSpace = searchSpace;
+            _numNodes = numNodes;
+            _numOperations = searchSpace.Operations?.Count ?? 5; // Default operations: identity, conv3x3, conv5x5, maxpool, avgpool
+            _random = RandomHelper.CreateSeededRandom(42); // Initialize with seed for reproducibility
+
+            // Initialize architecture parameters (alpha) with small random values
+            _architectureParams = new List<Matrix<T>>();
+            _architectureGradients = new List<Matrix<T>>();
+
+            for (int i = 0; i < _numNodes; i++)
+            {
+                // Each node can receive input from all previous nodes
+                // Alpha is initialized near zero so all operations have equal weight after softmax
+                var alpha = new Matrix<T>(i + 1, _numOperations);
+                for (int j = 0; j < alpha.Rows; j++)
+                {
+                    for (int k = 0; k < alpha.Columns; k++)
+                    {
+                        // Small random initialization: range [-0.1, 0.1]
+                        alpha[j, k] = NumOps.FromDouble((_random.NextDouble() - 0.5) * 0.2);
+                    }
+                }
+                _architectureParams.Add(alpha);
+                _architectureGradients.Add(new Matrix<T>(i + 1, _numOperations));
+            }
+
+            // Initialize network weights
+            _weights = new Dictionary<string, Vector<T>>();
+            _weightGradients = new Dictionary<string, Vector<T>>();
+
+            // Initialize default loss function (MSE for SuperNet)
+            _defaultLossFunction = lossFunction ?? new MeanSquaredErrorLoss<T>();
+        }
+
+        /// <summary>
+        /// Forward pass through the SuperNet with mixed operations
+        /// </summary>
+        public override Tensor<T> Predict(Tensor<T> input)
+        {
+            // Handle 1D input by reshaping to 2D [1, features]
+            bool was1D = input.Shape.Length == 1;
+            int[] originalShape = input._shape;
+            if (was1D)
+            {
+                input = input.Reshape([1, input.Shape[0]]);
+            }
+            else if (input.Shape.Length > 2)
+            {
+                // For higher-rank tensors, flatten to 2D [batch, features]
+                int batchSize = 1;
+                for (int i = 0; i < input.Shape.Length - 1; i++)
+                    batchSize *= input.Shape[i];
+                int features = input.Shape[input.Shape.Length - 1];
+                input = input.Reshape([batchSize, features]);
+            }
+
+            _inputSize = input.Shape[input.Shape.Length - 1];
+            _outputSize = _inputSize; // For simplicity, maintain same dimensions
+
+            // Store intermediate node outputs
+            var nodeOutputs = new List<Tensor<T>> { input };
+
+            // Process each node
+            for (int nodeIdx = 0; nodeIdx < _numNodes; nodeIdx++)
+            {
+                var nodeOutput = new Tensor<T>(input._shape);
+                var alpha = _architectureParams[nodeIdx];
+
+                // Apply softmax to architecture parameters for this node
+                var softmaxWeights = ApplySoftmax(alpha);
+
+                // Mix operations from all previous nodes
+                for (int prevNodeIdx = 0; prevNodeIdx <= nodeIdx; prevNodeIdx++)
+                {
+                    var prevOutput = nodeOutputs[prevNodeIdx];
+
+                    // Apply each operation and mix with softmax weights
+                    for (int opIdx = 0; opIdx < _numOperations; opIdx++)
+                    {
+                        var opOutput = ApplyOperation(prevOutput, opIdx, $"node{nodeIdx}_from{prevNodeIdx}_op{opIdx}");
+                        var weight = softmaxWeights[prevNodeIdx, opIdx];
+
+                        // Accumulate weighted operation outputs
+                        for (int batchIdx = 0; batchIdx < nodeOutput.Shape[0]; batchIdx++)
+                        {
+                            for (int featureIdx = 0; featureIdx < nodeOutput.Shape[1]; featureIdx++)
+                            {
+                                nodeOutput[batchIdx, featureIdx] = NumOps.Add(
+                                    nodeOutput[batchIdx, featureIdx],
+                                    NumOps.Multiply(weight, opOutput[batchIdx, featureIdx]));
+                            }
+                        }
+                    }
+                }
+
+                nodeOutputs.Add(nodeOutput);
+            }
+
+            // Get final output and restore original shape if needed
+            var result = nodeOutputs[nodeOutputs.Count - 1];
+            if (was1D)
+            {
+                result = result.Reshape(originalShape);
+            }
+            else if (originalShape.Length > 2)
+            {
+                result = result.Reshape(originalShape);
+            }
+
+            return result;
+        }
+
+        /// <summary>
+        /// Training is handled externally by alternating architecture and weight updates
+        /// </summary>
+        public override void Train(Tensor<T> input, Tensor<T> expectedOutput)
+        {
+            throw new NotSupportedException(
+                "SuperNet training is handled through alternating optimization. " +
+                "Use UpdateArchitectureParameters() and UpdateWeights() instead.");
+        }
+
+        /// <summary>
+        /// Computes validation loss for architecture parameter updates
+        /// </summary>
+        public T ComputeValidationLoss(Tensor<T> valData, Tensor<T> valLabels)
+        {
+            var predictions = Predict(valData);
+            return ComputeLoss(predictions, valLabels);
+        }
+
+        /// <summary>
+        /// Computes training loss for weight updates
+        /// </summary>
+        public T ComputeTrainingLoss(Tensor<T> trainData, Tensor<T> trainLabels)
+        {
+            var predictions = Predict(trainData);
+            return ComputeLoss(predictions, trainLabels);
+        }
+
+        /// <summary>
+        /// Computes mean squared error loss
+        /// </summary>
+        private T ComputeLoss(Tensor<T> predictions, Tensor<T> targets)
+        {
+            T sumSquaredError = NumOps.Zero;
+            int count = 0;
+
+            // Access tensors using proper 2D indexing
+            for (int batchIdx = 0; batchIdx < predictions.Shape[0]; batchIdx++)
+            {
+                for (int featureIdx = 0; featureIdx < predictions.Shape[1]; featureIdx++)
+                {
+                    var diff = NumOps.Subtract(predictions[batchIdx, featureIdx], targets[batchIdx, featureIdx]);
+                    sumSquaredError = NumOps.Add(sumSquaredError, NumOps.Multiply(diff, diff));
+                    count++;
+                }
+            }
+
+            return NumOps.Divide(sumSquaredError, NumOps.FromDouble(count));
+        }
+
+        /// <summary>
+        /// Backward pass to compute gradients for architecture parameters
+        /// </summary>
+        public void BackwardArchitecture(Tensor<T> input, Tensor<T> target)
+        {
+            // Simplified gradient computation
+            // In a full implementation, this would use automatic differentiation
+            var output = Predict(input);
+            var loss = ComputeLoss(output, target);
+
+            // Compute gradients using finite differences (simplified)
+            T epsilon = NumOps.FromDouble(1e-5);
+
+            for (int nodeIdx = 0; nodeIdx < _architectureParams.Count; nodeIdx++)
+            {
+                var alpha = _architectureParams[nodeIdx];
+                var grad = _architectureGradients[nodeIdx];
+
+                for (int i = 0; i < alpha.Rows; i++)
+                {
+                    for (int j = 0; j < alpha.Columns; j++)
+                    {
+                        // Finite difference approximation
+                        T originalValue = alpha[i, j];
+
+                        alpha[i, j] = NumOps.Add(originalValue, epsilon);
+                        var lossPlus = ComputeValidationLoss(input, target);
+
+                        alpha[i, j] = NumOps.Subtract(originalValue, epsilon);
+                        var lossMinus = ComputeValidationLoss(input, target);
+
+                        alpha[i, j] = originalValue;
+
+                        // Gradient = (f(x+ε) - f(x-ε)) / (2ε)
+                        grad[i, j] = NumOps.Divide(
+                            NumOps.Subtract(lossPlus, lossMinus),
+                            NumOps.Multiply(NumOps.FromDouble(2), epsilon)
+                        );
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Backward pass to compute gradients for network weights using the specified loss function.
+        /// </summary>
+        /// <param name="input">The input tensor.</param>
+        /// <param name="target">The target tensor.</param>
+        /// <param name="lossFunction">The loss function to use for gradient computation.</param>
+        public void BackwardWeights(Tensor<T> input, Tensor<T> target, ILossFunction<T> lossFunction)
+        {
+            // Simplified gradient computation for weights
+            var output = Predict(input);
+            T epsilon = NumOps.FromDouble(1e-5);
+
+            foreach (var kvp in _weights)
+            {
+                var key = kvp.Key;
+                var weight = kvp.Value;
+                var grad = _weightGradients[key];
+
+                for (int i = 0; i < weight.Length; i++)
+                {
+                    T originalValue = weight[i];
+
+                    weight[i] = NumOps.Add(originalValue, epsilon);
+                    var lossPlus = ComputeLossWithFunction(input, target, lossFunction);
+
+                    weight[i] = NumOps.Subtract(originalValue, epsilon);
+                    var lossMinus = ComputeLossWithFunction(input, target, lossFunction);
+
+                    weight[i] = originalValue;
+
+                    grad[i] = NumOps.Divide(
+                        NumOps.Subtract(lossPlus, lossMinus),
+                        NumOps.Multiply(NumOps.FromDouble(2), epsilon)
+                    );
+                }
+            }
+        }
+
+        /// <summary>
+        /// Computes loss using the specified loss function.
+        /// </summary>
+        /// <param name="input">The input tensor.</param>
+        /// <param name="target">The target tensor.</param>
+        /// <param name="lossFunction">The loss function to use.</param>
+        /// <returns>The computed loss value.</returns>
+        private T ComputeLossWithFunction(Tensor<T> input, Tensor<T> target, ILossFunction<T> lossFunction)
+        {
+            var predictions = Predict(input);
+
+            // Flatten tensors to vectors for ILossFunction
+            var predVector = FlattenTensor(predictions);
+            var targetVector = FlattenTensor(target);
+
+            return lossFunction.CalculateLoss(predVector, targetVector);
+        }
+
+        /// <summary>
+        /// Flattens a 2D tensor to a vector.
+        /// </summary>
+        private Vector<T> FlattenTensor(Tensor<T> tensor)
+        {
+            var flattenedData = new List<T>();
+            for (int i = 0; i < tensor.Shape[0]; i++)
+            {
+                for (int j = 0; j < tensor.Shape[1]; j++)
+                {
+                    flattenedData.Add(tensor[i, j]);
+                }
+            }
+            return new Vector<T>(flattenedData.ToArray());
+        }
+
+        /// <summary>
+        /// Gets architecture parameters for optimization
+        /// </summary>
+        public List<Matrix<T>> GetArchitectureParameters()
+        {
+            return _architectureParams;
+        }
+
+        /// <summary>
+        /// Gets architecture gradients
+        /// </summary>
+        public List<Matrix<T>> GetArchitectureGradients()
+        {
+            return _architectureGradients;
+        }
+
+        /// <summary>
+        /// Gets weight parameters for optimization
+        /// </summary>
+        public Dictionary<string, Vector<T>> GetWeightParameters()
+        {
+            return _weights;
+        }
+
+        /// <summary>
+        /// Gets weight gradients
+        /// </summary>
+        public Dictionary<string, Vector<T>> GetWeightGradients()
+        {
+            return _weightGradients;
+        }
+
+        /// <summary>
+        /// Computes gradients of the loss function with respect to model parameters WITHOUT updating parameters.
+        /// </summary>
+        /// <param name="input">The input tensor.</param>
+        /// <param name="target">The target/expected output tensor.</param>
+        /// <param name="lossFunction">The loss function to use. If null, uses the model's default loss function.</param>
+        /// <returns>A vector containing gradients with respect to all model parameters (both architecture and weights).</returns>
+        /// <exception cref="ArgumentNullException">If input or target is null.</exception>
+        /// <remarks>
+        /// <para>
+        /// For SuperNet, this computes gradients for weight parameters only (not architecture parameters).
+        /// Architecture parameters are updated separately in DARTS using validation data.
+        /// The method uses the existing BackwardWeights method and collects gradients from all layers.
+        /// </para>
+        /// <para><b>For Beginners:</b>
+        /// SuperNet has two types of parameters:
+        /// - Architecture parameters (α): which operations to use
+        /// - Weight parameters (w): the actual neural network weights
+        ///
+        /// This method computes gradients for the weight parameters based on training data.
+        /// In DARTS, architecture parameters are optimized separately on validation data.
+        /// </para>
+        /// </remarks>
+        public override Vector<T> ComputeGradients(Tensor<T> input, Tensor<T> target, ILossFunction<T>? lossFunction = null)
+        {
+            if (input == null)
+                throw new ArgumentNullException(nameof(input));
+            if (target == null)
+                throw new ArgumentNullException(nameof(target));
+
+            // Use the effective loss function (supplied or default)
+            var effectiveLoss = lossFunction ?? _defaultLossFunction;
+
+            // Use BackwardWeights to compute gradients for weight parameters
+            BackwardWeights(input, target, effectiveLoss);
+
+            // Collect all gradients into a single vector
+            var gradients = new List<T>();
+
+            // Add architecture parameter gradients as ZEROS (not computed in this method)
+            // Architecture parameters are optimized separately in DARTS on validation data
+            // We include zeros here to maintain consistent vector length with GetParameters()
+            var zero = NumOps.FromDouble(0.0);
+            foreach (var alpha in _architectureParams)
+            {
+                for (int i = 0; i < alpha.Rows; i++)
+                    for (int j = 0; j < alpha.Columns; j++)
+                        gradients.Add(zero);  // Zero gradient since not computed here
+            }
+
+            // Add weight gradients (freshly computed by BackwardWeights above)
+            foreach (var weightGrad in _weightGradients.Values)
+            {
+                for (int i = 0; i < weightGrad.Length; i++)
+                    gradients.Add(weightGrad[i]);
+            }
+
+            return new Vector<T>(gradients.ToArray());
+        }
+
+        /// <summary>
+        /// Applies pre-computed gradients to update the model parameters.
+        /// </summary>
+        /// <param name="gradients">The gradient vector to apply.</param>
+        /// <param name="learningRate">The learning rate for the update.</param>
+        /// <exception cref="ArgumentNullException">If gradients is null.</exception>
+        /// <exception cref="ArgumentException">If gradient vector length doesn't match parameter count.</exception>
+        /// <remarks>
+        /// <para>
+        /// Updates both architecture and weight parameters using: θ = θ - learningRate * gradients
+        /// </para>
+        /// <para><b>For Beginners:</b>
+        /// This method applies the gradient updates to both:
+        /// - Architecture parameters (which operations are selected)
+        /// - Weight parameters (the neural network weights)
+        ///
+        /// In DARTS, you typically call this with different learning rates for
+        /// architecture and weight parameters.
+        /// </para>
+        /// </remarks>
+        public override void ApplyGradients(Vector<T> gradients, T learningRate)
+        {
+            if (gradients == null)
+                throw new ArgumentNullException(nameof(gradients));
+
+            var currentParams = GetParameters();
+
+            if (gradients.Length != currentParams.Length)
+            {
+                throw new ArgumentException(
+                    $"Gradient vector length ({gradients.Length}) must match parameter count ({currentParams.Length})",
+                    nameof(gradients));
+            }
+
+            int idx = 0;
+
+            // Update architecture parameters
+            foreach (var alpha in _architectureParams)
+            {
+                for (int i = 0; i < alpha.Rows; i++)
+                {
+                    for (int j = 0; j < alpha.Columns; j++)
+                    {
+                        T update = NumOps.Multiply(learningRate, gradients[idx++]);
+                        alpha[i, j] = NumOps.Subtract(alpha[i, j], update);
+                    }
+                }
+            }
+
+            // Update weights
+            foreach (var key in _weights.Keys.ToList())
+            {
+                var weight = _weights[key];
+                for (int i = 0; i < weight.Length; i++)
+                {
+                    T update = NumOps.Multiply(learningRate, gradients[idx++]);
+                    weight[i] = NumOps.Subtract(weight[i], update);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Derives discrete architecture from continuous parameters (argmax selection)
+        /// </summary>
+        public Architecture<T> DeriveArchitecture()
+        {
+            var architecture = new Architecture<T>();
+
+            for (int nodeIdx = 0; nodeIdx < _numNodes; nodeIdx++)
+            {
+                var alpha = _architectureParams[nodeIdx];
+                var softmaxWeights = ApplySoftmax(alpha);
+
+                // For each previous node connection, select operation with highest weight
+                for (int prevNodeIdx = 0; prevNodeIdx <= nodeIdx; prevNodeIdx++)
+                {
+                    int bestOpIdx = 0;
+                    T bestWeight = softmaxWeights[prevNodeIdx, 0];
+
+                    for (int opIdx = 1; opIdx < _numOperations; opIdx++)
+                    {
+                        if (NumOps.GreaterThan(softmaxWeights[prevNodeIdx, opIdx], bestWeight))
+                        {
+                            bestWeight = softmaxWeights[prevNodeIdx, opIdx];
+                            bestOpIdx = opIdx;
+                        }
+                    }
+
+                    // Add selected operation to architecture
+                    var operation = GetOperationName(bestOpIdx);
+                    architecture.AddOperation(nodeIdx, prevNodeIdx, operation);
+                }
+            }
+
+            return architecture;
+        }
+
+        /// <summary>
+        /// Apply softmax to architecture parameters
+        /// </summary>
+        private Matrix<T> ApplySoftmax(Matrix<T> alpha)
+        {
+            var result = new Matrix<T>(alpha.Rows, alpha.Columns);
+
+            for (int row = 0; row < alpha.Rows; row++)
+            {
+                // Compute softmax for this row
+                T maxVal = alpha[row, 0];
+                for (int col = 1; col < alpha.Columns; col++)
+                {
+                    if (NumOps.GreaterThan(alpha[row, col], maxVal))
+                        maxVal = alpha[row, col];
+                }
+
+                // Compute exp(x - max) for numerical stability
+                T sumExp = NumOps.Zero;
+                var expValues = new T[alpha.Columns];
+                for (int col = 0; col < alpha.Columns; col++)
+                {
+                    expValues[col] = NumOps.Exp(NumOps.Subtract(alpha[row, col], maxVal));
+                    sumExp = NumOps.Add(sumExp, expValues[col]);
+                }
+
+                // Normalize
+                for (int col = 0; col < alpha.Columns; col++)
+                {
+                    result[row, col] = NumOps.Divide(expValues[col], sumExp);
+                }
+            }
+
+            return result;
+        }
+
+        /// <summary>
+        /// Apply a specific operation to input
+        /// </summary>
+        private Tensor<T> ApplyOperation(Tensor<T> input, int opIdx, string weightKey)
+        {
+            // Handle 1D input by reshaping to 2D [1, features]
+            bool was1D = input.Shape.Length == 1;
+            int[] originalShape = input._shape;
+            if (was1D)
+            {
+                input = input.Reshape([1, input.Shape[0]]);
+            }
+            else if (input.Shape.Length > 2)
+            {
+                // For higher-rank tensors, flatten to 2D [batch, features]
+                int batchSize = 1;
+                for (int i = 0; i < input.Shape.Length - 1; i++)
+                    batchSize *= input.Shape[i];
+                int features = input.Shape[input.Shape.Length - 1];
+                input = input.Reshape([batchSize, features]);
+            }
+
+            // Initialize weights if needed
+            if (!_weights.ContainsKey(weightKey))
+            {
+                _weights[weightKey] = new Vector<T>(input.Length);
+                _weightGradients[weightKey] = new Vector<T>(input.Length);
+
+                // Initialize with small random values
+                for (int i = 0; i < input.Length; i++)
+                {
+                    _weights[weightKey][i] = NumOps.FromDouble((_random.NextDouble() - 0.5) * 0.1);
+                }
+            }
+
+            var output = TensorAllocator.Rent<T>(input._shape);
+            var weight = _weights[weightKey];
+
+            // Apply operation (simplified) using proper 2D tensor indexing
+            switch (opIdx)
+            {
+                case 0: // Identity
+                    for (int batchIdx = 0; batchIdx < input.Shape[0]; batchIdx++)
+                    {
+                        for (int featureIdx = 0; featureIdx < input.Shape[1]; featureIdx++)
+                        {
+                            output[batchIdx, featureIdx] = input[batchIdx, featureIdx];
+                        }
+                    }
+                    break;
+
+                case 1: // 3x3 Conv (simplified as weighted pass)
+                {
+                    for (int batchIdx = 0; batchIdx < input.Shape[0]; batchIdx++)
+                    {
+                        for (int featureIdx = 0; featureIdx < input.Shape[1]; featureIdx++)
+                        {
+                            if (featureIdx < weight.Length)
+                            {
+                                output[batchIdx, featureIdx] = NumOps.Multiply(
+                                    input[batchIdx, featureIdx],
+                                    NumOps.Add(NumOps.One, weight[featureIdx]));
+                            }
+                        }
+                    }
+                }
+                break;
+
+                case 2: // 5x5 Conv (simplified)
+                {
+                    for (int batchIdx = 0; batchIdx < input.Shape[0]; batchIdx++)
+                    {
+                        for (int featureIdx = 0; featureIdx < input.Shape[1]; featureIdx++)
+                        {
+                            if (featureIdx < weight.Length)
+                            {
+                                output[batchIdx, featureIdx] = NumOps.Multiply(
+                                    input[batchIdx, featureIdx],
+                                    NumOps.Add(NumOps.One, NumOps.Multiply(NumOps.FromDouble(1.5), weight[featureIdx])));
+                            }
+                        }
+                    }
+                }
+                break;
+
+                case 3: // MaxPool (simplified)
+                    for (int batchIdx = 0; batchIdx < input.Shape[0]; batchIdx++)
+                    {
+                        for (int featureIdx = 0; featureIdx < input.Shape[1]; featureIdx++)
+                        {
+                            output[batchIdx, featureIdx] = NumOps.Multiply(input[batchIdx, featureIdx], NumOps.FromDouble(0.9));
+                        }
+                    }
+                    break;
+
+                case 4: // AvgPool (simplified)
+                    for (int batchIdx = 0; batchIdx < input.Shape[0]; batchIdx++)
+                    {
+                        for (int featureIdx = 0; featureIdx < input.Shape[1]; featureIdx++)
+                        {
+                            output[batchIdx, featureIdx] = NumOps.Multiply(input[batchIdx, featureIdx], NumOps.FromDouble(0.8));
+                        }
+                    }
+                    break;
+
+                default:
+                    for (int batchIdx = 0; batchIdx < input.Shape[0]; batchIdx++)
+                    {
+                        for (int featureIdx = 0; featureIdx < input.Shape[1]; featureIdx++)
+                        {
+                            output[batchIdx, featureIdx] = input[batchIdx, featureIdx];
+                        }
+                    }
+                    break;
+            }
+
+            // Restore original shape if input was 1D or higher-rank
+            if (was1D)
+            {
+                output = output.Reshape(originalShape);
+            }
+            else if (originalShape.Length > 2)
+            {
+                output = output.Reshape(originalShape);
+            }
+
+            return output;
+        }
+
+        /// <summary>
+        /// Gets the human-readable name for a given operation index.
+        /// Maps operation indices to their corresponding operation types in the NAS search space.
+        /// </summary>
+        /// <param name="opIdx">The operation index (0-4)</param>
+        /// <returns>The operation name (identity, conv3x3, conv5x5, maxpool, avgpool)</returns>
+        private string GetOperationName(int opIdx)
+        {
+            return opIdx switch
+            {
+                0 => "identity",
+                1 => "conv3x3",
+                2 => "conv5x5",
+                3 => "maxpool",
+                4 => "avgpool",
+                _ => "identity"
+            };
+        }
+
+        // Replaced by the declared parameter source below. Removed under AIDN082.
+
+        // Replaced by the declared parameter source below. Removed under AIDN082.
+
+        public override IFullModel<T, Tensor<T>, Tensor<T>> WithParameters(Vector<T> parameters)
+        {
+            var clone = (SuperNet<T>)Clone();
+            clone.SetParameters(parameters);
+            return clone;
+        }
+
+        public override ModelMetadata<T> GetModelMetadata()
+        {
+            return new ModelMetadata<T>
+            {
+                Description = "Differentiable Architecture Search SuperNet",
+                FeatureCount = _inputSize,
+                Complexity = _numNodes,
+                AdditionalInfo = new Dictionary<string, object>
+                {
+                    ["NumNodes"] = _numNodes,
+                    ["NumOperations"] = _numOperations,
+                    ["ParameterCount"] = ParameterCount
+                }
+            };
+        }
+
+        public override void SaveModel(string filePath)
+        {
+            Helpers.ModelPersistenceGuard.EnforceBeforeSave();
+
+            if (string.IsNullOrWhiteSpace(filePath))
+                throw new ArgumentException("File path cannot be null or empty.", nameof(filePath));
+
+            // Validate path security: prevent directory traversal attacks
+            // Use canonicalized path and ensure it is within the current working directory
+            var fullPath = System.IO.Path.GetFullPath(filePath);
+
+            // Additional validation: ensure the resolved path doesn't escape the working directory
+            var currentDirectory = System.IO.Path.GetFullPath(Environment.CurrentDirectory);
+            // Ensure trailing separator for strict directory containment (prevents /app vs /app-data bypass)
+            var currentDirWithSep = currentDirectory.EndsWith(System.IO.Path.DirectorySeparatorChar.ToString())
+                ? currentDirectory
+                : currentDirectory + System.IO.Path.DirectorySeparatorChar;
+            if (!fullPath.StartsWith(currentDirWithSep, StringComparison.OrdinalIgnoreCase))
+                throw new UnauthorizedAccessException($"Attempted to save model outside of the current directory. Path: {fullPath}");
+
+            using var fs = new System.IO.FileStream(fullPath, System.IO.FileMode.Create);
+            using var writer = new System.IO.BinaryWriter(fs);
+
+            writer.Write(_numNodes);
+            writer.Write(_numOperations);
+            writer.Write(_inputSize);
+            writer.Write(_outputSize);
+
+            // Serialize architecture parameters
+            writer.Write(_architectureParams.Count);
+            foreach (var alpha in _architectureParams)
+            {
+                writer.Write(alpha.Rows);
+                writer.Write(alpha.Columns);
+                for (int i = 0; i < alpha.Rows; i++)
+                {
+                    for (int j = 0; j < alpha.Columns; j++)
+                    {
+                        writer.Write(Convert.ToDouble(alpha[i, j]));
+                    }
+                }
+            }
+
+            // Serialize weights
+            writer.Write(_weights.Count);
+            foreach (var kvp in _weights)
+            {
+                writer.Write(kvp.Key);
+                writer.Write(kvp.Value.Length);
+                for (int i = 0; i < kvp.Value.Length; i++)
+                {
+                    writer.Write(Convert.ToDouble(kvp.Value[i]));
+                }
+            }
+        }
+        public override void LoadModel(string filePath)
+        {
+            Helpers.ModelPersistenceGuard.EnforceBeforeLoad();
+
+            if (string.IsNullOrWhiteSpace(filePath))
+                throw new ArgumentException("File path cannot be null or empty.", nameof(filePath));
+
+            // Validate path security: prevent directory traversal attacks
+            // Use canonicalized path and ensure it is within the current working directory
+            var fullPath = System.IO.Path.GetFullPath(filePath);
+
+            // Additional validation: ensure the resolved path doesn't escape the working directory
+            var currentDirectory = System.IO.Path.GetFullPath(Environment.CurrentDirectory);
+            // Ensure trailing separator for strict directory containment (prevents /app vs /app-data bypass)
+            var currentDirWithSep = currentDirectory.EndsWith(System.IO.Path.DirectorySeparatorChar.ToString())
+                ? currentDirectory
+                : currentDirectory + System.IO.Path.DirectorySeparatorChar;
+            if (!fullPath.StartsWith(currentDirWithSep, StringComparison.OrdinalIgnoreCase))
+                throw new UnauthorizedAccessException($"Attempted to load model from outside the current directory. Path: {fullPath}");
+
+            if (!System.IO.File.Exists(fullPath))
+                throw new System.IO.FileNotFoundException($"Model file not found: {filePath}");
+
+            using var fs = new System.IO.FileStream(fullPath, System.IO.FileMode.Open);
+            using var reader = new System.IO.BinaryReader(fs);
+
+            // Deserialize _numNodes and _numOperations (read-only fields need reflection or constructor)
+            var numNodes = reader.ReadInt32();
+            var numOperations = reader.ReadInt32();
+
+            // Validate that deserialized structure matches this instance
+            if (numNodes != _numNodes || numOperations != _numOperations)
+            {
+                throw new InvalidOperationException(
+                    $"Model file structure mismatch: file has numNodes={numNodes}, numOperations={numOperations}, " +
+                    $"but this instance has numNodes={_numNodes}, numOperations={_numOperations}.");
+            }
+
+            _inputSize = reader.ReadInt32();
+            _outputSize = reader.ReadInt32();
+
+            // Deserialize architecture parameters
+            int alphaCount = reader.ReadInt32();
+            _architectureParams.Clear();
+            _architectureGradients.Clear();
+            for (int idx = 0; idx < alphaCount; idx++)
+            {
+                int rows = reader.ReadInt32();
+                int cols = reader.ReadInt32();
+                var alpha = new Matrix<T>(rows, cols);
+                for (int i = 0; i < rows; i++)
+                {
+                    for (int j = 0; j < cols; j++)
+                    {
+                        alpha[i, j] = NumOps.FromDouble(reader.ReadDouble());
+                    }
+                }
+                _architectureParams.Add(alpha);
+                _architectureGradients.Add(new Matrix<T>(rows, cols));
+            }
+
+            // Deserialize weights
+            int weightCount = reader.ReadInt32();
+            _weights.Clear();
+            _weightGradients.Clear();
+            for (int idx = 0; idx < weightCount; idx++)
+            {
+                string key = reader.ReadString();
+                int length = reader.ReadInt32();
+                var weight = new Vector<T>(length);
+                for (int i = 0; i < length; i++)
+                {
+                    weight[i] = NumOps.FromDouble(reader.ReadDouble());
+                }
+                _weights[key] = weight;
+                _weightGradients[key] = new Vector<T>(length);
+            }
+        }
+        /// <summary>
+        /// Declares the two collections the generator cannot place: the per-node architecture
+        /// matrices and the string-keyed weight table.
+        /// </summary>
+        /// <param name="state">The registry to declare into.</param>
+        /// <remarks>
+        /// Both fields are readonly, so each setter refills the existing instance rather than
+        /// replacing it - the same thing the hand-written Deserialize did with Clear() then Add().
+        /// <para>
+        /// _numNodes and _numOperations are readonly construction config; the hand-written pair
+        /// wrote them only to VALIDATE on read, throwing when they disagreed, and the recorded
+        /// constructor replays them. _architectureGradients is rebuilt to match the restored
+        /// architecture shape, exactly as the old Deserialize rebuilt it, because a gradient is
+        /// scratch from the last backward pass rather than model state.
+        /// </para>
+        /// </remarks>
+        protected override void RegisterState(ModelStateRegistry<T> state)
+        {
+            base.RegisterState(state);
+
+            state.Declare(
+                "SuperNet._architectureParams",
+                () => _architectureParams,
+                v =>
+                {
+                    _architectureParams.Clear();
+                    _architectureGradients.Clear();
+                    if (v is null) return;
+                    foreach (var alpha in v)
+                    {
+                        _architectureParams.Add(alpha);
+                        _architectureGradients.Add(new Matrix<T>(alpha.Rows, alpha.Columns));
+                    }
+                });
+
+            state.Declare(
+                "SuperNet._weights",
+                () => _weights,
+                v =>
+                {
+                    _weights.Clear();
+                    if (v is null) return;
+                    foreach (var pair in v) _weights[pair.Key] = pair.Value;
+                });
+        }
+
+        public override Dictionary<string, T> GetFeatureImportance() => new Dictionary<string, T>();
+        public override IEnumerable<int> GetActiveFeatureIndices() => Enumerable.Range(0, _inputSize);
+        public override bool IsFeatureUsed(int featureIndex) => featureIndex >= 0 && featureIndex < _inputSize;
+        public override void SetActiveFeatureIndices(IEnumerable<int> featureIndices) { }
+
+        #region IInterpretableModel Implementation
+
+        /// <summary>
+        /// Gets the operation importance for SuperNet architecture search.
+        /// Returns importance scores for architectural operations rather than input features.
+        /// </summary>
+        /// <param name="inputs">Input tensor (required for interface compliance; not used in this implementation)</param>
+        /// <returns>Dictionary mapping operation indices to their importance scores</returns>
+        /// <remarks>
+        /// <para>
+        /// <b>Note:</b> SuperNet reinterprets "feature importance" as "operation importance" in the context of Neural Architecture Search (NAS).
+        /// The returned dictionary maps operation indices (0=identity, 1=conv3x3, 2=conv5x5, etc.) to their importance scores,
+        /// calculated by aggregating the absolute values of architecture parameters across all nodes.
+        /// </para>
+        /// <para>
+        /// The 'inputs' parameter is required for IInterpretableModel interface compliance but is not used.
+        /// SuperNet analyzes operation importance based on learned architecture parameters rather than input data.
+        /// </para>
+        /// </remarks>
+        public virtual async Task<Dictionary<int, T>> GetGlobalFeatureImportanceAsync(Tensor<T> inputs)
+        {
+            var importance = new Dictionary<int, T>();
+
+            // For SuperNet, we analyze operation importance rather than input feature importance
+            // Each operation index represents a different architectural operation (identity, conv3x3, etc.)
+            for (int opIdx = 0; opIdx < _numOperations; opIdx++)
+            {
+                T sum = NumOps.Zero;
+
+                // Aggregate importance across all nodes and connections
+                foreach (var alpha in _architectureParams)
+                {
+                    // Sum absolute values of architecture parameters for this operation
+                    for (int i = 0; i < alpha.Rows; i++)
+                    {
+                        if (opIdx < alpha.Columns)
+                        {
+                            sum = NumOps.Add(sum, NumOps.Abs(alpha[i, opIdx]));
+                        }
+                    }
+                }
+
+                importance[opIdx] = sum;
+            }
+
+            return await Task.FromResult(importance);
+        }
+
+        /// <summary>
+        /// Gets the local feature importance for a specific input.
+        /// Provides importance based on softmax weights, analyzing which operations are most active.
+        /// </summary>
+        public virtual async Task<Dictionary<int, T>> GetLocalFeatureImportanceAsync(Tensor<T> input)
+        {
+            var importance = new Dictionary<int, T>();
+
+            // For local importance, we use softmax-transformed architecture parameters
+            // to determine which operations are most active for this specific input
+            for (int opIdx = 0; opIdx < _numOperations; opIdx++)
+            {
+                T sum = NumOps.Zero;
+
+                // Apply softmax and aggregate weights for each operation
+                foreach (var alpha in _architectureParams)
+                {
+                    var softmaxWeights = ApplySoftmax(alpha);
+
+                    for (int i = 0; i < softmaxWeights.Rows; i++)
+                    {
+                        if (opIdx < softmaxWeights.Columns)
+                        {
+                            sum = NumOps.Add(sum, softmaxWeights[i, opIdx]);
+                        }
+                    }
+                }
+
+                importance[opIdx] = sum;
+            }
+
+            return await Task.FromResult(importance);
+        }
+
+        /// <summary>
+        /// Gets SHAP values for the given inputs.
+        /// Not supported for SuperNet architecture search models.
+        /// </summary>
+        public virtual async Task<Matrix<T>> GetShapValuesAsync(Tensor<T> inputs)
+        {
+            await Task.CompletedTask;
+            throw new NotSupportedException(
+                "SHAP values are not supported for SuperNet architecture search models. " +
+                "SuperNet uses differentiable architecture search and does not have traditional feature attribution.");
+        }
+
+        /// <summary>
+        /// Gets LIME explanation for a specific input.
+        /// Not supported for SuperNet architecture search models.
+        /// </summary>
+        public virtual async Task<LimeExplanation<T>> GetLimeExplanationAsync(Tensor<T> input, int numFeatures = 10)
+        {
+            await Task.CompletedTask;
+            throw new NotSupportedException(
+                "LIME explanations are not supported for SuperNet architecture search models. " +
+                "Use GetGlobalFeatureImportanceAsync or GetLocalFeatureImportanceAsync instead.");
+        }
+
+        /// <summary>
+        /// Gets partial dependence data for specified features.
+        /// Not supported for SuperNet architecture search models.
+        /// </summary>
+        public virtual async Task<PartialDependenceData<T>> GetPartialDependenceAsync(Vector<int> featureIndices, int gridResolution = 20)
+        {
+            await Task.CompletedTask;
+            throw new NotSupportedException(
+                "Partial dependence plots are not supported for SuperNet architecture search models. " +
+                "SuperNet focuses on architecture optimization rather than feature-level analysis.");
+        }
+
+        /// <summary>
+        /// Gets counterfactual explanation for a given input and desired output.
+        /// Not supported for SuperNet architecture search models.
+        /// </summary>
+        public virtual async Task<CounterfactualExplanation<T>> GetCounterfactualAsync(Tensor<T> input, Tensor<T> desiredOutput, int maxChanges = 5)
+        {
+            await Task.CompletedTask;
+            throw new NotSupportedException(
+                "Counterfactual explanations are not supported for SuperNet architecture search models. " +
+                "SuperNet is designed for architecture search, not instance-level counterfactuals.");
+        }
+
+        /// <summary>
+        /// Gets model-specific interpretability information for SuperNet.
+        /// Returns architecture parameters and their importance.
+        /// </summary>
+        public virtual async Task<Dictionary<string, object>> GetModelSpecificInterpretabilityAsync()
+        {
+            var info = new Dictionary<string, object>
+            {
+                ["ModelType"] = "SuperNet (Differentiable Architecture Search)",
+                ["NumNodes"] = _numNodes,
+                ["NumOperations"] = _numOperations,
+                // Dictionary<string, object> can box a long natively;
+                // ToFlatVectorSize is reserved for places that genuinely
+                // need an int (Vector<T> allocation, int-indexed APIs).
+                // Storing the un-narrowed long lets >int.MaxValue
+                // models surface their true count via the
+                // interpretability dictionary without throwing here.
+                // Closes review-comment #1271.vDPV.
+                ["ParameterCount"] = ParameterCount,
+                ["ArchitectureParameterCount"] = _architectureParams.Sum(a => a.Rows * a.Columns),
+                ["WeightParameterCount"] = _weights.Values.Sum(w => w.Length),
+                ["InputSize"] = _inputSize,
+                ["OutputSize"] = _outputSize
+            };
+
+            // Add architecture parameter statistics
+            var archStats = new List<Dictionary<string, object>>();
+            for (int i = 0; i < _architectureParams.Count; i++)
+            {
+                var alpha = _architectureParams[i];
+                var softmax = ApplySoftmax(alpha);
+
+                var nodeStats = new Dictionary<string, object>
+                {
+                    ["NodeIndex"] = i,
+                    ["Rows"] = alpha.Rows,
+                    ["Columns"] = alpha.Columns,
+                    ["ParameterCount"] = alpha.Rows * alpha.Columns
+                };
+
+                archStats.Add(nodeStats);
+            }
+
+            info["ArchitectureNodes"] = archStats;
+
+            return await Task.FromResult(info);
+        }
+
+        /// <summary>
+        /// Generates a text explanation for a prediction.
+        /// Provides a description of which operations are most important in the SuperNet.
+        /// </summary>
+        public virtual async Task<string> GenerateTextExplanationAsync(Tensor<T> input, Tensor<T> prediction)
+        {
+            var explanation = $"SuperNet Architecture Search Model:\n";
+            explanation += $"- Network contains {_numNodes} nodes with {_numOperations} operations each\n";
+            explanation += $"- Total parameters: {ParameterCount}\n";
+            explanation += $"- Architecture is determined by learned softmax weights over operations\n\n";
+
+            explanation += "Most important architectural decisions:\n";
+
+            // Identify most important nodes based on architecture parameters
+            for (int nodeIdx = 0; nodeIdx < Math.Min(3, _numNodes); nodeIdx++)
+            {
+                var alpha = _architectureParams[nodeIdx];
+                var softmax = ApplySoftmax(alpha);
+
+                // Find the operation with highest weight
+                if (softmax.Rows > 0 && softmax.Columns > 0)
+                {
+                    int bestOp = 0;
+                    T bestWeight = softmax[0, 0];
+
+                    for (int i = 0; i < softmax.Rows; i++)
+                    {
+                        for (int j = 0; j < softmax.Columns; j++)
+                        {
+                            if (NumOps.GreaterThan(softmax[i, j], bestWeight))
+                            {
+                                bestWeight = softmax[i, j];
+                                bestOp = j;
+                            }
+                        }
+                    }
+
+                    explanation += $"- Node {nodeIdx}: {GetOperationName(bestOp)} operation is dominant\n";
+                }
+                else
+                {
+                    explanation += $"- Node {nodeIdx}: No operations available (empty softmax matrix)\n";
+                }
+            }
+
+            return await Task.FromResult(explanation);
+        }
+
+        /// <summary>
+        /// Gets feature interaction effects between two features.
+        /// Analyzes interactions between operations based on architecture parameter correlations.
+        /// </summary>
+        public virtual async Task<T> GetFeatureInteractionAsync(int feature1Index, int feature2Index)
+        {
+            // In SuperNet context, feature indices represent operation indices
+            if (feature1Index < 0 || feature1Index >= _numOperations ||
+                feature2Index < 0 || feature2Index >= _numOperations)
+            {
+                throw new ArgumentOutOfRangeException(
+                    $"Feature indices must be in the range [0, {_numOperations - 1}]. " +
+                    $"Received feature1Index={feature1Index}, feature2Index={feature2Index}.");
+            }
+
+            // Calculate correlation between two operations across all architecture parameters
+            T sum1 = NumOps.Zero;
+            T sum2 = NumOps.Zero;
+            T sumProduct = NumOps.Zero;
+            T sumSquares1 = NumOps.Zero;
+            T sumSquares2 = NumOps.Zero;
+            int count = 0;
+
+            foreach (var alpha in _architectureParams)
+            {
+                for (int i = 0; i < alpha.Rows; i++)
+                {
+                    if (feature1Index < alpha.Columns && feature2Index < alpha.Columns)
+                    {
+                        T val1 = alpha[i, feature1Index];
+                        T val2 = alpha[i, feature2Index];
+
+                        sum1 = NumOps.Add(sum1, val1);
+                        sum2 = NumOps.Add(sum2, val2);
+                        sumProduct = NumOps.Add(sumProduct, NumOps.Multiply(val1, val2));
+                        sumSquares1 = NumOps.Add(sumSquares1, NumOps.Multiply(val1, val1));
+                        sumSquares2 = NumOps.Add(sumSquares2, NumOps.Multiply(val2, val2));
+                        count++;
+                    }
+                }
+            }
+
+            if (count == 0)
+            {
+                return NumOps.Zero;
+            }
+
+            // Calculate correlation coefficient
+            T n = NumOps.FromDouble(count);
+            T numerator = NumOps.Subtract(
+                NumOps.Multiply(n, sumProduct),
+                NumOps.Multiply(sum1, sum2)
+            );
+
+            T denom1 = NumOps.Subtract(
+                NumOps.Multiply(n, sumSquares1),
+                NumOps.Multiply(sum1, sum1)
+            );
+
+            T denom2 = NumOps.Subtract(
+                NumOps.Multiply(n, sumSquares2),
+                NumOps.Multiply(sum2, sum2)
+            );
+
+            T denominator = NumOps.Multiply(denom1, denom2);
+
+            // Avoid division by zero
+            if (NumOps.Equals(denominator, NumOps.Zero))
+            {
+                return NumOps.Zero;
+            }
+
+            T correlation = NumOps.Divide(numerator, NumOps.Sqrt(denominator));
+
+            return await Task.FromResult(correlation);
+        }
+
+        /// <summary>
+        /// Validates fairness metrics for the given inputs.
+        /// Not supported for SuperNet architecture search models.
+        /// </summary>
+        public virtual async Task<FairnessMetrics<T>> ValidateFairnessAsync(Tensor<T> inputs, int sensitiveFeatureIndex)
+        {
+            await Task.CompletedTask;
+            throw new NotSupportedException(
+                "Fairness validation is not supported for SuperNet architecture search models. " +
+                "SuperNet focuses on architecture optimization rather than fairness evaluation.");
+        }
+
+        /// <summary>
+        /// Gets anchor explanation for a given input.
+        /// Not supported for SuperNet architecture search models.
+        /// </summary>
+        public virtual async Task<AnchorExplanation<T>> GetAnchorExplanationAsync(Tensor<T> input, T threshold)
+        {
+            await Task.CompletedTask;
+            throw new NotSupportedException(
+                "Anchor explanations are not supported for SuperNet architecture search models. " +
+                "SuperNet focuses on architecture optimization rather than instance-level explanations.");
+        }
+
+        /// <summary>
+        /// Sets the base model for interpretability analysis.
+        /// </summary>
+        public virtual void SetBaseModel(IModel<Tensor<T>, Tensor<T>, ModelMetadata<T>> model)
+        {
+            Guard.NotNull(model);
+            _baseModel = model;
+        }
+
+        /// <summary>
+        /// Enables specific interpretation methods.
+        /// </summary>
+        public virtual void EnableMethod(params InterpretationMethod[] methods)
+        {
+            if (methods == null)
+                return;
+
+            foreach (var method in methods)
+            {
+                _enabledMethods.Add(method);
+            }
+        }
+
+        /// <summary>
+        /// Configures fairness evaluation settings.
+        /// </summary>
+        public virtual void ConfigureFairness(Vector<int> sensitiveFeatures, params FairnessMetric[] fairnessMetrics)
+        {
+            Guard.NotNull(sensitiveFeatures);
+            _sensitiveFeatures = sensitiveFeatures;
+            _fairnessMetrics.Clear();
+            if (fairnessMetrics != null)
+            {
+                _fairnessMetrics.AddRange(fairnessMetrics);
+            }
+        }
+
+        #endregion
+
+        /// <summary>
+        /// Saves the SuperNet's current state (architecture parameters and weights) to a stream.
+        /// </summary>
+        /// <param name="stream">The stream to write the model state to.</param>
+        /// <remarks>
+        /// <para>
+        /// This method serializes all the information needed to recreate the SuperNet's current state,
+        /// including architecture parameters, operation weights, and model configuration.
+        /// It uses the existing Serialize method and writes the data to the provided stream.
+        /// </para>
+        /// <para><b>For Beginners:</b> This is like creating a snapshot of your neural architecture search model.
+        ///
+        /// When you call SaveState:
+        /// - All architecture parameters (alpha values) are written to the stream
+        /// - All operation weights are saved
+        /// - The model's configuration and structure are preserved
+        ///
+        /// This is particularly useful for:
+        /// - Checkpointing during neural architecture search
+        /// - Saving the best architecture found during search
+        /// - Knowledge distillation from SuperNet to final architecture
+        /// - Resuming interrupted architecture search
+        ///
+        /// You can later use LoadState to restore the model to this exact state.
+        /// </para>
+        /// </remarks>
+        /// <exception cref="ArgumentNullException">Thrown when stream is null.</exception>
+        /// <exception cref="IOException">Thrown when there's an error writing to the stream.</exception>
+        public override void SaveState(Stream stream)
+        {
+            if (stream == null)
+                throw new ArgumentNullException(nameof(stream));
+
+            if (!stream.CanWrite)
+                throw new ArgumentException("Stream must be writable.", nameof(stream));
+
+            try
+            {
+                var data = this.Serialize();
+                stream.Write(data, 0, data.Length);
+                stream.Flush();
+            }
+            catch (IOException ex)
+            {
+                throw new IOException($"Failed to save SuperNet state to stream: {ex.Message}", ex);
+            }
+            catch (Exception ex)
+            {
+                throw new InvalidOperationException($"Unexpected error while saving SuperNet state: {ex.Message}", ex);
+            }
+        }
+
+        /// <summary>
+        /// Loads the SuperNet's state (architecture parameters and weights) from a stream.
+        /// </summary>
+        /// <param name="stream">The stream to read the model state from.</param>
+        /// <remarks>
+        /// <para>
+        /// This method deserializes SuperNet state that was previously saved with SaveState,
+        /// restoring all architecture parameters, operation weights, and configuration.
+        /// It uses the existing Deserialize method after reading data from the stream.
+        /// </para>
+        /// <para><b>For Beginners:</b> This is like loading a saved snapshot of your neural architecture search model.
+        ///
+        /// When you call LoadState:
+        /// - All architecture parameters (alpha values) are read from the stream
+        /// - All operation weights are restored
+        /// - The model is configured to match the saved state
+        ///
+        /// After loading, the model can:
+        /// - Continue architecture search from where it left off
+        /// - Make predictions using the restored architecture
+        /// - Be used for further optimization or deployment
+        ///
+        /// This is essential for:
+        /// - Resuming interrupted architecture search
+        /// - Loading the best architecture found during search
+        /// - Deploying searched architectures to production
+        /// - Knowledge distillation workflows
+        /// </para>
+        /// </remarks>
+        /// <exception cref="ArgumentNullException">Thrown when stream is null.</exception>
+        /// <exception cref="IOException">Thrown when there's an error reading from the stream.</exception>
+        /// <exception cref="InvalidOperationException">Thrown when the stream contains invalid or incompatible data.</exception>
+        public override void LoadState(Stream stream)
+        {
+            if (stream == null)
+                throw new ArgumentNullException(nameof(stream));
+
+            if (!stream.CanRead)
+                throw new ArgumentException("Stream must be readable.", nameof(stream));
+
+            try
+            {
+                using var ms = new MemoryStream();
+                stream.CopyTo(ms);
+                var data = ms.ToArray();
+
+                if (data.Length == 0)
+                    throw new InvalidOperationException("Stream contains no data.");
+
+                this.Deserialize(data);
+            }
+            catch (IOException ex)
+            {
+                throw new IOException($"Failed to read SuperNet state from stream: {ex.Message}", ex);
+            }
+            catch (InvalidOperationException)
+            {
+                // Re-throw InvalidOperationException from Deserialize
+                throw;
+            }
+            catch (Exception ex)
+            {
+                throw new InvalidOperationException(
+                    $"Failed to deserialize SuperNet state. The stream may contain corrupted or incompatible data: {ex.Message}", ex);
+            }
+        }
+
+    }
+}
diff --git a/src/NeuralNetworks/SyntheticData/AIMGenerator.cs b/src/NeuralNetworks/SyntheticData/AIMGenerator.cs
index aa84f32440..251074dd0d 100644
--- a/src/NeuralNetworks/SyntheticData/AIMGenerator.cs
+++ b/src/NeuralNetworks/SyntheticData/AIMGenerator.cs
@@ -64,6 +64,7 @@ public class AIMGenerator<T> : SyntheticTabularGeneratorBase<T>
     private readonly List<MarginalMeasurement> _measurements = new();
 
     // Synthetic data representation (probabilities over discretized space)
+    [AiDotNet.Attributes.FittedParameter]
     private Matrix<T>? _syntheticData;
     private int _numCols;
 
diff --git a/src/NeuralNetworks/SyntheticData/AutoDiffTabGenerator.cs b/src/NeuralNetworks/SyntheticData/AutoDiffTabGenerator.cs
index 9a98cb9845..16b664d3f5 100644
--- a/src/NeuralNetworks/SyntheticData/AutoDiffTabGenerator.cs
+++ b/src/NeuralNetworks/SyntheticData/AutoDiffTabGenerator.cs
@@ -106,11 +106,11 @@ public partial class AutoDiffTabGenerator<T> : NeuralSyntheticTabularGeneratorBa
 
     // Diffusion parameters (set after search)
     private int _numTimesteps;
-    [Buffer]
+    [Buffer(Availability = AiDotNet.Models.Parameters.ParameterAvailability.Conditional)]
     private Vector<T>? _betas;
-    [Buffer]
+    [Buffer(Availability = AiDotNet.Models.Parameters.ParameterAvailability.Conditional)]
     private Vector<T>? _alphas;
-    [Buffer]
+    [Buffer(Availability = AiDotNet.Models.Parameters.ParameterAvailability.Conditional)]
     private Vector<T>? _alphasCumprod;
 
     // Whether custom layers are being used
@@ -876,40 +876,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_options.MLPDimensions.Length);
-        foreach (var dim in _options.MLPDimensions) writer.Write(dim);
-        writer.Write(_options.TimestepEmbeddingDimension);
-        writer.Write(_numTimesteps);
-        writer.Write(_dataWidth);
-        writer.Write(IsFitted);
-    }
 
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        int mlpLen = reader.ReadInt32();
-        for (int i = 0; i < mlpLen; i++) _ = reader.ReadInt32();
-        _ = reader.ReadInt32();        // TimestepEmbeddingDimension
-        _numTimesteps = reader.ReadInt32();
-        _dataWidth = reader.ReadInt32();
-        IsFitted = reader.ReadBoolean();
-
-        // The base deserializer rebuilt Layers; re-bind the typed denoiser
-        // references so Clone/DeepCopy reproduce the identical forward.
-        ExtractLayerReferences();
-    }
 
     /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new AutoDiffTabGenerator<T>(
-            Architecture,
-            _options,
-            _optimizer,
-            _lossFunction);
-    }
+
 
     /// <inheritdoc/>
     public override Dictionary<string, T> GetFeatureImportance()
diff --git a/src/NeuralNetworks/SyntheticData/CTABGANPlusGenerator.cs b/src/NeuralNetworks/SyntheticData/CTABGANPlusGenerator.cs
index 0d44ffa860..f540e8e931 100644
--- a/src/NeuralNetworks/SyntheticData/CTABGANPlusGenerator.cs
+++ b/src/NeuralNetworks/SyntheticData/CTABGANPlusGenerator.cs
@@ -970,46 +970,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_options.EmbeddingDimension);
-        writer.Write(_options.GeneratorDimensions.Length);
-        foreach (var dim in _options.GeneratorDimensions)
-        {
-            writer.Write(dim);
-        }
-        writer.Write(_options.DiscriminatorDimensions.Length);
-        foreach (var dim in _options.DiscriminatorDimensions)
-        {
-            writer.Write(dim);
-        }
-        writer.Write(_options.BatchSize);
-        writer.Write(_options.LearningRate);
-        writer.Write(_options.GradientPenaltyWeight);
-        writer.Write(_options.PacSize);
-        writer.Write(_options.VGMModes);
-        writer.Write(_options.DiscriminatorDropout);
-        writer.Write(_options.ClassifierWeight);
-        writer.Write(_options.InformationWeight);
-        writer.Write(_options.TargetColumnIndex);
-    }
 
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        // Options are reconstructed from serialized data
-        // Layers are handled by base class
-    }
 
     /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new CTABGANPlusGenerator<T>(
-            Architecture,
-            _options,
-            _optimizer,
-            _lossFunction);
-    }
+
 
     /// <inheritdoc/>
     public override Dictionary<string, T> GetFeatureImportance()
diff --git a/src/NeuralNetworks/SyntheticData/CTGANGenerator.cs b/src/NeuralNetworks/SyntheticData/CTGANGenerator.cs
index 9aea6c5b4b..9c787a0cea 100644
--- a/src/NeuralNetworks/SyntheticData/CTGANGenerator.cs
+++ b/src/NeuralNetworks/SyntheticData/CTGANGenerator.cs
@@ -1458,36 +1458,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_options.EmbeddingDimension);
-        writer.Write(_options.GeneratorDimensions.Length);
-        foreach (var dim in _options.GeneratorDimensions) writer.Write(dim);
-        writer.Write(_options.DiscriminatorDimensions.Length);
-        foreach (var dim in _options.DiscriminatorDimensions) writer.Write(dim);
-        writer.Write(_options.BatchSize);
-        writer.Write(_options.LearningRate);
-        writer.Write(_options.GradientPenaltyWeight);
-        writer.Write(_options.PacSize);
-        writer.Write(_options.VGMModes);
-        writer.Write(_options.DiscriminatorDropout);
-    }
 
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        // Options are reconstructed from serialized data
-    }
 
     /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new CTGANGenerator<T>(
-            Architecture,
-            _options,
-            _generatorOptimizer,
-            _lossFunction);
-    }
+
 
     /// <inheritdoc/>
     public override Dictionary<string, T> GetFeatureImportance()
diff --git a/src/NeuralNetworks/SyntheticData/CausalGANGenerator.cs b/src/NeuralNetworks/SyntheticData/CausalGANGenerator.cs
index 8fe469baa2..c6ddca2759 100644
--- a/src/NeuralNetworks/SyntheticData/CausalGANGenerator.cs
+++ b/src/NeuralNetworks/SyntheticData/CausalGANGenerator.cs
@@ -110,7 +110,7 @@ public partial class CausalGANGenerator<T> : NeuralSyntheticTabularGeneratorBase
 
     // Causal structure: adjacency matrix W (numFeatures x numFeatures)
     // W[i,j] > 0 means feature i causally influences feature j
-    [Buffer(Name = "causal-adjacency")]
+    [Buffer(Name = "causal-adjacency", Availability = AiDotNet.Models.Parameters.ParameterAvailability.Conditional)]
     private Matrix<T>? _adjacency;
 
     // Augmented Lagrangian parameters for NOTEARS DAG constraint
@@ -1394,38 +1394,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_options.EmbeddingDimension);
-        writer.Write(_options.HiddenDimensions.Length);
-        foreach (var dim in _options.HiddenDimensions)
-        {
-            writer.Write(dim);
-        }
-        writer.Write(_options.BatchSize);
-        writer.Write(_options.LearningRate);
-        writer.Write(_options.DAGPenaltyWeight);
-        writer.Write(_options.SparsityWeight);
-        writer.Write(_options.GradientPenaltyWeight);
-        writer.Write(_options.DiscriminatorDropout);
-        writer.Write(_options.DiscriminatorSteps);
-    }
 
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        // Options are reconstructed from serialized data
-    }
 
     /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new CausalGANGenerator<T>(
-            Architecture,
-            _options,
-            _generatorOptimizer,
-            _lossFunction);
-    }
+
 
     /// <inheritdoc/>
     public override Dictionary<string, T> GetFeatureImportance()
diff --git a/src/NeuralNetworks/SyntheticData/ColumnMetadata.cs b/src/NeuralNetworks/SyntheticData/ColumnMetadata.cs
index 46ea5d1d8a..b4d5f916e2 100644
--- a/src/NeuralNetworks/SyntheticData/ColumnMetadata.cs
+++ b/src/NeuralNetworks/SyntheticData/ColumnMetadata.cs
@@ -154,6 +154,7 @@ public class ColumnMetadata
     /// Statistics (min, max, mean, std) are filled in automatically during fitting.
     /// </para>
     /// </remarks>
+    [Newtonsoft.Json.JsonConstructor]
     public ColumnMetadata(string name, ColumnDataType dataType, IEnumerable<string>? categories = null, int columnIndex = 0)
     {
         Name = name;
diff --git a/src/NeuralNetworks/SyntheticData/CopulaGANGenerator.cs b/src/NeuralNetworks/SyntheticData/CopulaGANGenerator.cs
index eb588be961..fde9b6c529 100644
--- a/src/NeuralNetworks/SyntheticData/CopulaGANGenerator.cs
+++ b/src/NeuralNetworks/SyntheticData/CopulaGANGenerator.cs
@@ -1506,43 +1506,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_options.EmbeddingDimension);
-        writer.Write(_options.GeneratorDimensions.Length);
-        foreach (var dim in _options.GeneratorDimensions)
-        {
-            writer.Write(dim);
-        }
-        writer.Write(_options.DiscriminatorDimensions.Length);
-        foreach (var dim in _options.DiscriminatorDimensions)
-        {
-            writer.Write(dim);
-        }
-        writer.Write(_options.BatchSize);
-        writer.Write(_options.LearningRate);
-        writer.Write(_options.GradientPenaltyWeight);
-        writer.Write(_options.PacSize);
-        writer.Write(_options.VGMModes);
-        writer.Write(_options.DiscriminatorDropout);
-    }
 
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        // Options are reconstructed from serialized data
-        // Layers are handled by base class
-    }
 
     /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new CopulaGANGenerator<T>(
-            Architecture,
-            _options,
-            _generatorOptimizer,
-            _lossFunction);
-    }
+
 
     /// <inheritdoc/>
     public override Dictionary<string, T> GetFeatureImportance()
diff --git a/src/NeuralNetworks/SyntheticData/DPCTGANGenerator.cs b/src/NeuralNetworks/SyntheticData/DPCTGANGenerator.cs
index e7fe2e83ab..97f98d94b6 100644
--- a/src/NeuralNetworks/SyntheticData/DPCTGANGenerator.cs
+++ b/src/NeuralNetworks/SyntheticData/DPCTGANGenerator.cs
@@ -1399,47 +1399,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_options.EmbeddingDimension);
-        writer.Write(_options.GeneratorDimensions.Length);
-        foreach (var dim in _options.GeneratorDimensions)
-        {
-            writer.Write(dim);
-        }
-        writer.Write(_options.DiscriminatorDimensions.Length);
-        foreach (var dim in _options.DiscriminatorDimensions)
-        {
-            writer.Write(dim);
-        }
-        writer.Write(_options.BatchSize);
-        writer.Write(_options.LearningRate);
-        writer.Write(_options.GradientPenaltyWeight);
-        writer.Write(_options.PacSize);
-        writer.Write(_options.VGMModes);
-        writer.Write(_options.DiscriminatorDropout);
-        writer.Write(_options.Epsilon);
-        writer.Write(_options.Delta);
-        writer.Write(_options.ClipNorm);
-        writer.Write(_options.NoiseMultiplier);
-    }
 
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        // Options are reconstructed from serialized data
-        // Layers are handled by base class
-    }
 
     /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new DPCTGANGenerator<T>(
-            Architecture,
-            _options,
-            _generatorOptimizer,
-            _lossFunction);
-    }
+
 
     /// <inheritdoc/>
     public override Dictionary<string, T> GetFeatureImportance()
diff --git a/src/NeuralNetworks/SyntheticData/FinDiffGenerator.cs b/src/NeuralNetworks/SyntheticData/FinDiffGenerator.cs
index 28dd592e81..728a4ea2f0 100644
--- a/src/NeuralNetworks/SyntheticData/FinDiffGenerator.cs
+++ b/src/NeuralNetworks/SyntheticData/FinDiffGenerator.cs
@@ -652,40 +652,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_options.NumTimesteps);
-        writer.Write(_options.TimestepEmbeddingDimension);
-        writer.Write(_options.TemporalWeight);
-        writer.Write(_options.EnforcePositive);
-        writer.Write(_options.BetaStart);
-        writer.Write(_options.BetaEnd);
-        writer.Write(_options.LearningRate);
-        writer.Write(_options.BatchSize);
-        writer.Write(_options.VGMModes);
-        writer.Write(_options.MLPDimensions.Length);
-        foreach (var dim in _options.MLPDimensions)
-        {
-            writer.Write(dim);
-        }
-    }
 
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        // Options are reconstructed from serialized data
-        // Layers are handled by base class
-    }
 
     /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new FinDiffGenerator<T>(
-            Architecture,
-            _options,
-            _optimizer,
-            _lossFunction);
-    }
+
 
     #endregion
 
diff --git a/src/NeuralNetworks/SyntheticData/GOGGLEGenerator.cs b/src/NeuralNetworks/SyntheticData/GOGGLEGenerator.cs
index edf735906d..4f3a39cf41 100644
--- a/src/NeuralNetworks/SyntheticData/GOGGLEGenerator.cs
+++ b/src/NeuralNetworks/SyntheticData/GOGGLEGenerator.cs
@@ -97,6 +97,7 @@ public partial class GOGGLEGenerator<T> : NeuralSyntheticTabularGeneratorBase<T>
     // Tensor so it participates in autodiff alongside the encoder/decoder
     // weights — gradients of the ELBO + sparsity (γ‖A‖₁) + DAG penalty
     // h(A) = tr((A⊙A)^d) - d (Zheng et al. 2018) flow through it.
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T>? _adjacency;
 
     // GNN encoder layers (auxiliary, not user-overridable)
@@ -296,20 +297,6 @@ private void InitializeAdjacency()
         }
     }
 
-    /// <summary>
-    /// Expose the learned adjacency matrix so the tape-based trainer
-    /// (BackwardAndStepOnPrecomputedLoss) collects it alongside the
-    /// encoder/decoder layer parameters. Without this the sparsity / DAG
-    /// regularizers compute on A but the optimizer never updates A.
-    /// </summary>
-    protected override IEnumerable<Tensor<T>> GetExtraTrainableTensors()
-    {
-        if (_adjacency is not null && _adjacency.Length > 0)
-        {
-            yield return _adjacency;
-        }
-    }
-
     /// <summary>
     /// GOGGLE's <see cref="LayerBase{T}"/> chain is the VAE decoder —
     /// Layer[0] takes the latent z (size LatentDimension), NOT the raw
@@ -830,73 +817,10 @@ private void EnsureSizedForInput(Tensor<T> input)
     // UpdateParameters restated a fold the base now derives from generated component registration.
     // Removed under AIDN082.
     /// <inheritdoc />
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_options.LatentDimension);
-        writer.Write(_options.NumGNNLayers);
-        writer.Write(_options.HiddenDimension);
-        writer.Write(_dataWidth);
-        writer.Write(IsFitted);
-
-        // Persist the learned adjacency matrix — it's a registered trainable
-        // tensor (see GetExtraTrainableTensors) so the optimizer updates it
-        // during Train, but it lives outside Layers and would be silently
-        // dropped by Clone/SaveLoad without explicit (de)serialization.
-        bool hasAdj = _adjacency is not null && _adjacency.Length > 0;
-        writer.Write(hasAdj);
-        if (hasAdj)
-        {
-            writer.Write(_adjacency!.Shape[0]);
-            writer.Write(_adjacency.Shape[1]);
-            for (int i = 0; i < _adjacency.Length; i++)
-                writer.Write(Convert.ToDouble(_adjacency[i]));
-        }
-    }
 
-    /// <inheritdoc />
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _ = reader.ReadInt32(); // LatentDimension
-        _ = reader.ReadInt32(); // NumGNNLayers
-        _ = reader.ReadInt32(); // HiddenDimension
-        _dataWidth = reader.ReadInt32();
-        IsFitted = reader.ReadBoolean();
-
-        bool hasAdj = reader.ReadBoolean();
-        if (hasAdj)
-        {
-            int rows = reader.ReadInt32();
-            int cols = reader.ReadInt32();
-            _adjacency = new Tensor<T>(new[] { rows, cols });
-            for (int i = 0; i < _adjacency.Length; i++)
-                _adjacency[i] = NumOps.FromDouble(reader.ReadDouble());
-        }
-
-        // Reconnect the typed field references (_gnnLayers, _meanHead,
-        // _logvarHead, _decoderOutput) to the layers the base class
-        // deserialized into the Layers collection. RebuildAuxiliaryLayers
-        // wrote them in this stable order: [GNN×N, mean, logvar, decoder
-        // MLP×K, decoderOutput]; we read them back the same way so the
-        // forward pass (which uses the field references, not Layers) sees
-        // the deserialized weights instead of the null / lazy state the
-        // freshly-constructed clone instance has.
-        int numGnn = _options.NumGNNLayers;
-        if (Layers.Count >= numGnn + 3)
-        {
-            _gnnLayers.Clear();
-            for (int i = 0; i < numGnn; i++)
-                if (Layers[i] is FullyConnectedLayer<T> fc) _gnnLayers.Add(fc);
-            if (Layers[numGnn] is FullyConnectedLayer<T> mean) _meanHead = mean;
-            if (Layers[numGnn + 1] is FullyConnectedLayer<T> logVar) _logvarHead = logVar;
-            if (Layers[Layers.Count - 1] is FullyConnectedLayer<T> decOut) _decoderOutput = decOut;
-        }
-    }
 
     /// <inheritdoc />
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new GOGGLEGenerator<T>(Architecture, _options);
-    }
+
 
     /// <inheritdoc />
     public override Dictionary<string, T> GetFeatureImportance()
diff --git a/src/NeuralNetworks/SyntheticData/MedGANGenerator.cs b/src/NeuralNetworks/SyntheticData/MedGANGenerator.cs
index 917fff6847..9732e7c38f 100644
--- a/src/NeuralNetworks/SyntheticData/MedGANGenerator.cs
+++ b/src/NeuralNetworks/SyntheticData/MedGANGenerator.cs
@@ -578,80 +578,10 @@ public override void Train(Tensor<T> input, Tensor<T> expectedOutput)
     // UpdateParameters re-sliced the flat vector across Layers by hand -- the base walks
     // exactly the same enumeration, so this said nothing the base does not already say.
     /// <inheritdoc />
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_dataWidth);
-        writer.Write(IsFitted);
 
-        writer.Write(_outputGroups?.Count ?? -1);
-        if (_outputGroups is not null)
-        {
-            foreach (var (start, width, softmax) in _outputGroups)
-            {
-                writer.Write(start);
-                writer.Write(width);
-                writer.Write(softmax);
-            }
-        }
-
-        writer.Write(_colMin?.Length ?? -1);
-        if (_colMin is not null && _colMax is not null)
-        {
-            for (int i = 0; i < _colMin.Length; i++)
-            {
-                writer.Write(_colMin[i]);
-                writer.Write(_colMax[i]);
-            }
-        }
-    }
 
     /// <inheritdoc />
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _dataWidth = reader.ReadInt32();
-        IsFitted = reader.ReadBoolean();
 
-        int groupCount = reader.ReadInt32();
-        if (groupCount >= 0)
-        {
-            _outputGroups = new List<(int, int, bool)>(groupCount);
-            for (int i = 0; i < groupCount; i++)
-            {
-                _outputGroups.Add((reader.ReadInt32(), reader.ReadInt32(), reader.ReadBoolean()));
-            }
-        }
-        else
-        {
-            _outputGroups = null;
-        }
-
-        int rangeCount = reader.ReadInt32();
-        if (rangeCount >= 0)
-        {
-            _colMin = new double[rangeCount];
-            _colMax = new double[rangeCount];
-            for (int i = 0; i < rangeCount; i++)
-            {
-                _colMin[i] = reader.ReadDouble();
-                _colMax[i] = reader.ReadDouble();
-            }
-        }
-        else
-        {
-            _colMin = null;
-            _colMax = null;
-        }
-
-        // The base deserializer rebuilt Layers with fresh instances; re-bind the typed views so the
-        // forward paths use the deserialized (trained) weights rather than discarded init.
-        if (!_usingCustomLayers) ExtractMedGANLayerReferences();
-    }
-
-    /// <inheritdoc />
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new MedGANGenerator<T>(Architecture, _options);
-    }
 
     /// <inheritdoc />
     public override Dictionary<string, T> GetFeatureImportance()
diff --git a/src/NeuralNetworks/SyntheticData/MisGANGenerator.cs b/src/NeuralNetworks/SyntheticData/MisGANGenerator.cs
index 43d0edcc6c..fec188038e 100644
--- a/src/NeuralNetworks/SyntheticData/MisGANGenerator.cs
+++ b/src/NeuralNetworks/SyntheticData/MisGANGenerator.cs
@@ -823,57 +823,10 @@ public override void SetTrainingMode(bool isTraining)
     // did it less safely: the length guard silently left the remaining layers untouched on a short
     // vector instead of failing. Removed under AIDN082.
     /// <inheritdoc />
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_options.EmbeddingDimension);
-        writer.Write(_options.MissingRate);
-        writer.Write(_dataWidth);
-        writer.Write(IsFitted);
-
-        // The data-generator batch-norm layers (running mean/variance included) live outside the
-        // base Layers collection. Generation runs the data generator through them, so without
-        // persisting them a saved/cloned model would generate from un-normalized activations.
-        AuxLayerSerialization.WriteLayerList(writer, _dataGenBNLayers);
-
-        // The fitted VGM transformer (column layout + GMM parameters) is required to inverse-transform
-        // generated samples and to apply the correct per-column output activations. Without it a
-        // loaded model cannot reconstruct original-scale data.
-        if (_transformer is not null)
-        {
-            writer.Write(true);
-            _transformer.Serialize(writer);
-        }
-        else
-        {
-            writer.Write(false);
-        }
-    }
 
-    /// <inheritdoc />
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _ = reader.ReadInt32(); // EmbeddingDimension
-        _ = reader.ReadDouble(); // MissingRate
-        _dataWidth = reader.ReadInt32();
-        IsFitted = reader.ReadBoolean();
-
-        AuxLayerSerialization.ReadLayerList<T, BatchNormalizationLayer<T>>(
-            reader, _dataGenBNLayers, (inShape, outShape) => new BatchNormalizationLayer<T>());
-
-        bool hasTransformer = reader.ReadBoolean();
-        if (hasTransformer)
-        {
-            _transformer = new TabularDataTransformer<T>(_options.VGMModes, _random);
-            _transformer.Deserialize(reader);
-            _columns = new List<ColumnMetadata>(_transformer.Columns);
-        }
-    }
 
     /// <inheritdoc />
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new MisGANGenerator<T>(Architecture, _options);
-    }
+
 
     /// <inheritdoc />
     public override Dictionary<string, T> GetFeatureImportance()
diff --git a/src/NeuralNetworks/SyntheticData/OCTGANGenerator.cs b/src/NeuralNetworks/SyntheticData/OCTGANGenerator.cs
index 48e4d395aa..c48925b449 100644
--- a/src/NeuralNetworks/SyntheticData/OCTGANGenerator.cs
+++ b/src/NeuralNetworks/SyntheticData/OCTGANGenerator.cs
@@ -107,10 +107,10 @@ public partial class OCTGANGenerator<T> : NeuralSyntheticTabularGeneratorBase<T>
     // Cached pre-activations for proper backward passes
 
     // SVDD center in embedding space
-    [Buffer]
+    [Buffer(Availability = AiDotNet.Models.Parameters.ParameterAvailability.Conditional)]
     private Tensor<T>? _svddCenter;
 
-    [Buffer]
+    [Buffer(Availability = AiDotNet.Models.Parameters.ParameterAvailability.Conditional)]
     private Matrix<T>? _minorityData;
     private bool _usingCustomLayers;
 
@@ -793,53 +793,10 @@ public override void Train(Tensor<T> input, Tensor<T> expectedOutput)
 
     // UpdateParameters restated the base verbatim; ModelBase routes it to SetParameters.
     /// <inheritdoc />
-    protected override void SerializeNetworkSpecificData(System.IO.BinaryWriter writer)
-    {
-        writer.Write(_dataWidth);
-        writer.Write(_usingCustomLayers);
-        writer.Write(IsFitted);
 
-        // The generator batch-norm layers (running mean/variance included) live outside the base
-        // Layers collection, and the fitted VGM transformer drives inverse-transform + per-column
-        // output activations. Both must be persisted or a loaded model generates garbage. (The SVDD
-        // center is a discriminator-training anchor only, never used by Generate, and is rebuilt by
-        // Fit, so it is intentionally not persisted.)
-        AuxLayerSerialization.WriteLayerList(writer, _genBNLayers);
-        if (_transformer is not null)
-        {
-            writer.Write(true);
-            _transformer.Serialize(writer);
-        }
-        else
-        {
-            writer.Write(false);
-        }
-    }
 
     /// <inheritdoc />
-    protected override void DeserializeNetworkSpecificData(System.IO.BinaryReader reader)
-    {
-        _dataWidth = reader.ReadInt32();
-        _usingCustomLayers = reader.ReadBoolean();
-        IsFitted = reader.ReadBoolean();
 
-        AuxLayerSerialization.ReadLayerList<T, BatchNormalizationLayer<T>>(
-            reader, _genBNLayers, (inShape, outShape) => new BatchNormalizationLayer<T>());
-
-        bool hasTransformer = reader.ReadBoolean();
-        if (hasTransformer)
-        {
-            _transformer = new TabularDataTransformer<T>(_options.VGMModes, _random);
-            _transformer.Deserialize(reader);
-            _columns = new List<ColumnMetadata>(_transformer.Columns);
-        }
-    }
-
-    /// <inheritdoc />
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new OCTGANGenerator<T>(Architecture, _options, _generatorOptimizer, _lossFunction);
-    }
 
     #endregion
 
diff --git a/src/NeuralNetworks/SyntheticData/PATEGANGenerator.cs b/src/NeuralNetworks/SyntheticData/PATEGANGenerator.cs
index 34c3cf972a..062a456b22 100644
--- a/src/NeuralNetworks/SyntheticData/PATEGANGenerator.cs
+++ b/src/NeuralNetworks/SyntheticData/PATEGANGenerator.cs
@@ -988,51 +988,10 @@ public override void Train(Tensor<T> input, Tensor<T> expectedOutput)
 
     // UpdateParameters restated the base verbatim; ModelBase routes it to SetParameters.
     /// <inheritdoc />
-    protected override void SerializeNetworkSpecificData(System.IO.BinaryWriter writer)
-    {
-        writer.Write(_dataWidth);
-        writer.Write(_usingCustomLayers);
-        writer.Write(IsFitted);
-
-        // The generator batch-norm layers (running mean/variance included) live outside the base
-        // Layers collection, and the fitted VGM transformer drives inverse-transform + per-column
-        // output activations. Both must be persisted or a loaded model generates garbage.
-        AuxLayerSerialization.WriteLayerList(writer, _genBNLayers);
-        if (_transformer is not null)
-        {
-            writer.Write(true);
-            _transformer.Serialize(writer);
-        }
-        else
-        {
-            writer.Write(false);
-        }
-    }
-
-    /// <inheritdoc />
-    protected override void DeserializeNetworkSpecificData(System.IO.BinaryReader reader)
-    {
-        _dataWidth = reader.ReadInt32();
-        _usingCustomLayers = reader.ReadBoolean();
-        IsFitted = reader.ReadBoolean();
 
-        AuxLayerSerialization.ReadLayerList<T, BatchNormalizationLayer<T>>(
-            reader, _genBNLayers, (inShape, outShape) => new BatchNormalizationLayer<T>());
-
-        bool hasTransformer = reader.ReadBoolean();
-        if (hasTransformer)
-        {
-            _transformer = new TabularDataTransformer<T>(_options.VGMModes, _random);
-            _transformer.Deserialize(reader);
-            _columns = new List<ColumnMetadata>(_transformer.Columns);
-        }
-    }
 
     /// <inheritdoc />
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new PATEGANGenerator<T>(Architecture, _options, _generatorOptimizer, _lossFunction);
-    }
+
 
     #endregion
 
diff --git a/src/NeuralNetworks/SyntheticData/REaLTabFormerGenerator.cs b/src/NeuralNetworks/SyntheticData/REaLTabFormerGenerator.cs
index 8f22a4c02f..6339802dea 100644
--- a/src/NeuralNetworks/SyntheticData/REaLTabFormerGenerator.cs
+++ b/src/NeuralNetworks/SyntheticData/REaLTabFormerGenerator.cs
@@ -711,26 +711,10 @@ public override void Train(Tensor<T> input, Tensor<T> expectedOutput)
     // did it less safely: the length guard silently left the remaining layers untouched on a short
     // vector instead of failing. Removed under AIDN082.
     /// <inheritdoc />
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_embDim);
-        writer.Write(_seqLength);
-        writer.Write(IsFitted);
-    }
 
-    /// <inheritdoc />
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _embDim = reader.ReadInt32();
-        _seqLength = reader.ReadInt32();
-        IsFitted = reader.ReadBoolean();
-    }
 
     /// <inheritdoc />
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new REaLTabFormerGenerator<T>(Architecture, _options);
-    }
+
 
     /// <inheritdoc />
     public override Dictionary<string, T> GetFeatureImportance()
diff --git a/src/NeuralNetworks/SyntheticData/SMOTENCGenerator.cs b/src/NeuralNetworks/SyntheticData/SMOTENCGenerator.cs
index e1321d7525..eeef2fdbf4 100644
--- a/src/NeuralNetworks/SyntheticData/SMOTENCGenerator.cs
+++ b/src/NeuralNetworks/SyntheticData/SMOTENCGenerator.cs
@@ -45,6 +45,7 @@ public class SMOTENCGenerator<T> : SyntheticTabularGeneratorBase<T>
     private readonly SMOTENCOptions<T> _options;
 
     // Stored minority class samples from the original data
+    [AiDotNet.Attributes.FittedParameter]
     private Matrix<T>? _minoritySamples;
 
     // Column metadata (numerical vs categorical)
diff --git a/src/NeuralNetworks/SyntheticData/TVAEGenerator.cs b/src/NeuralNetworks/SyntheticData/TVAEGenerator.cs
index 9798948522..02c0773e99 100644
--- a/src/NeuralNetworks/SyntheticData/TVAEGenerator.cs
+++ b/src/NeuralNetworks/SyntheticData/TVAEGenerator.cs
@@ -799,59 +799,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_options.LatentDimension);
-        writer.Write(_options.EncoderDimensions.Length);
-        foreach (var dim in _options.EncoderDimensions)
-        {
-            writer.Write(dim);
-        }
-        writer.Write(_options.DecoderDimensions.Length);
-        foreach (var dim in _options.DecoderDimensions)
-        {
-            writer.Write(dim);
-        }
-        writer.Write(_options.BatchSize);
-        writer.Write(_options.LearningRate);
-        writer.Write(_options.LossWeight);
-        writer.Write(_options.VGMModes);
-
-        // Structural layout so a deserialized clone can re-bind its typed layer
-        // references (encoder / mean+logvar heads / decoder) out of the shared
-        // Layers collection and reproduce the identical VAE forward.
-        writer.Write(_dataWidth);
-        writer.Write(IsFitted);
-        writer.Write(_usingCustomLayers);
-        writer.Write(_encoderLayers.Count);
-        writer.Write(_meanLayer is not null);
-        writer.Write(_decoderLayers.Count);
-    }
+
 
     /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _ = reader.ReadInt32();    // LatentDimension
-        int encDims = reader.ReadInt32();
-        for (int i = 0; i < encDims; i++) _ = reader.ReadInt32();
-        int decDims = reader.ReadInt32();
-        for (int i = 0; i < decDims; i++) _ = reader.ReadInt32();
-        _ = reader.ReadInt32();    // BatchSize
-        _ = reader.ReadDouble();   // LearningRate
-        _ = reader.ReadDouble();   // LossWeight
-        _ = reader.ReadInt32();    // VGMModes
-
-        _dataWidth = reader.ReadInt32();
-        IsFitted = reader.ReadBoolean();
-        _usingCustomLayers = reader.ReadBoolean();
-        int encoderCount = reader.ReadInt32();
-        bool hasHeads = reader.ReadBoolean();
-        int decoderCount = reader.ReadInt32();
-
-        // The base deserializer rebuilt Layers; re-bind the typed references the
-        // VAE forward uses (encoder, mean/logvar heads, decoder) from it.
-        ExtractLayerReferences(encoderCount, hasHeads, decoderCount);
-    }
+
 
     /// <summary>
     /// Re-binds <see cref="_encoderLayers"/>, <see cref="_meanLayer"/>,
@@ -879,28 +830,6 @@ private void ExtractLayerReferences(int encoderCount, bool hasHeads, int decoder
         for (int i = 0; i < decoderCount; i++) _decoderLayers.Add(Layers[idx++]);
     }
 
-    /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var copy = new TVAEGenerator<T>(
-            Architecture,
-            new TVAEOptions<T>(_options),
-            optimizer: null,
-            lossFunction: _lossFunction);
-
-        // Predict/Train can adapt an unfitted TVAE from the constructor's nominal width to the
-        // caller's actual tabular width. Build the clone at that same resolved width before the
-        // base clone path transfers layer tensors; otherwise its fresh decoder still targets the
-        // parameterless 10-column shape while the source emits the adapted width.
-        if (_dataWidth > 0)
-        {
-            copy._dataWidth = _dataWidth;
-            copy.RebuildLayersWithActualDimensions(_dataWidth);
-        }
-
-        return copy;
-    }
-
     /// <inheritdoc/>
     public override Dictionary<string, T> GetFeatureImportance()
     {
diff --git a/src/NeuralNetworks/SyntheticData/TabDDPMGenerator.cs b/src/NeuralNetworks/SyntheticData/TabDDPMGenerator.cs
index cd73aa88ae..31f30e8043 100644
--- a/src/NeuralNetworks/SyntheticData/TabDDPMGenerator.cs
+++ b/src/NeuralNetworks/SyntheticData/TabDDPMGenerator.cs
@@ -120,6 +120,7 @@ public partial class TabDDPMGenerator<T> : NeuralSyntheticTabularGeneratorBase<T
     private int _totalCategoricalWidth;
     private int _inputWidth;
     private int _lastHiddenDim;
+    [Scratch]
     private Tensor<T>? _lastMLPOutput;
 
     // Column layout tracking
@@ -998,28 +999,6 @@ private Tensor<T> ReduceToScalar(Tensor<T> t)
 
     #region Backward Pass
 
-    /// <summary>
-    /// Exposes the numerical/categorical output-head parameters to the tape-based
-    /// optimizer step. The heads are intentionally kept OUT of <see cref="NeuralNetworkBase{T}.Layers"/>
-    /// (they are parallel readout branches, not a sequential continuation of the
-    /// denoiser MLP — Predict/ForwardForTraining iterate Layers), so they are
-    /// surfaced here instead so <see cref="NeuralNetworkBase{T}.BackwardAndStepOnPrecomputedLoss"/>
-    /// includes them in the gradient-and-step set.
-    /// </summary>
-    protected override IEnumerable<Tensor<T>> GetExtraTrainableTensors()
-    {
-        var heads = new List<ILayer<T>>();
-        if (_numericalOutputHead is not null) heads.Add(_numericalOutputHead);
-        if (_categoricalOutputHead is not null) heads.Add(_categoricalOutputHead);
-        // _timestepProjection is applied off the main Layers walk (on the timestep
-        // conditioning path), so surface it here too — it is now trained via the
-        // tape-connected CreateTimestepEmbeddingTensor in TrainBatch.
-        if (_timestepProjection is not null) heads.Add(_timestepProjection);
-        return heads.Count == 0
-            ? System.Array.Empty<Tensor<T>>()
-            : Training.TapeTrainingStep<T>.CollectParameters(heads);
-    }
-
     #endregion
 
     #region Sampling Helpers
@@ -1162,46 +1141,7 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_options.NumTimesteps);
-        writer.Write(_options.MLPDimensions.Length);
-        foreach (var dim in _options.MLPDimensions)
-        {
-            writer.Write(dim);
-        }
-        writer.Write(_options.TimestepEmbeddingDimension);
-        writer.Write(_options.BatchSize);
-        writer.Write(_options.LearningRate);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.BetaStart);
-        writer.Write(_options.BetaEnd);
-
-        // Persist the auxiliary sub-networks that live outside the base Layers collection.
-        // Without this, a saved/cloned model would fall back to freshly-initialized output
-        // heads and timestep projection and generate garbage.
-        writer.Write(IsFitted);
-        writer.Write(_numNumericalFeatures);
-        writer.Write(_totalCategoricalWidth);
-        AuxLayerSerialization.Write(writer, _numericalOutputHead);
-        AuxLayerSerialization.Write(writer, _categoricalOutputHead);
-        AuxLayerSerialization.Write(writer, _timestepProjection);
-
-        // Persist the preprocessing / column layout needed to reconstruct generated samples back
-        // into the original column space. The diffusion processes hold no learned parameters and
-        // are reconstructed from the options on load.
-        writer.Write(_numCategoricalFeatures);
-        WriteIntList(writer, _numericalColumnIndices);
-        WriteIntList(writer, _categoricalColumnIndices);
-        WriteIntList(writer, _categoricalColumnWidths);
-        WriteDoubleArray(writer, _quantileMeans);
-        WriteDoubleArray(writer, _quantileStds);
-        writer.Write(_columns.Count);
-        foreach (var column in _columns)
-        {
-            column.Serialize(writer);
-        }
-    }
+
 
     private static void WriteIntList(BinaryWriter writer, List<int> values)
     {
@@ -1231,70 +1171,7 @@ private static double[] ReadDoubleArray(BinaryReader reader)
     }
 
     /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        // Advance past the option fields (the options themselves are reconstructed in
-        // CreateNewInstance); they must still be read to reach the auxiliary-network data.
-        _ = reader.ReadInt32();              // NumTimesteps
-        int mlpDimCount = reader.ReadInt32();
-        for (int i = 0; i < mlpDimCount; i++) _ = reader.ReadInt32();
-        _ = reader.ReadInt32();              // TimestepEmbeddingDimension
-        _ = reader.ReadInt32();              // BatchSize
-        _ = reader.ReadDouble();             // LearningRate
-        _ = reader.ReadDouble();             // DropoutRate
-        _ = reader.ReadDouble();             // BetaStart
-        _ = reader.ReadDouble();             // BetaEnd
-
-        IsFitted = reader.ReadBoolean();
-        _numNumericalFeatures = reader.ReadInt32();
-        _totalCategoricalWidth = reader.ReadInt32();
 
-        var identity = new IdentityActivation<T>() as IActivationFunction<T>;
-        var silu = new SiLUActivation<T>() as IActivationFunction<T>;
-        _numericalOutputHead = AuxLayerSerialization.Read<T>(reader,
-            (inShape, outShape) => new FullyConnectedLayer<T>(outShape[outShape.Length - 1], identity))
-            as FullyConnectedLayer<T>;
-        _categoricalOutputHead = AuxLayerSerialization.Read<T>(reader,
-            (inShape, outShape) => new FullyConnectedLayer<T>(outShape[outShape.Length - 1], identity))
-            as FullyConnectedLayer<T>;
-        _timestepProjection = AuxLayerSerialization.Read<T>(reader,
-            (inShape, outShape) => new FullyConnectedLayer<T>(outShape[outShape.Length - 1], silu))
-            as FullyConnectedLayer<T>;
-
-        _numCategoricalFeatures = reader.ReadInt32();
-        ReadIntListInto(reader, _numericalColumnIndices);
-        ReadIntListInto(reader, _categoricalColumnIndices);
-        ReadIntListInto(reader, _categoricalColumnWidths);
-        _quantileMeans = ReadDoubleArray(reader);
-        _quantileStds = ReadDoubleArray(reader);
-        int columnCount = reader.ReadInt32();
-        _columns = new List<ColumnMetadata>(columnCount);
-        for (int i = 0; i < columnCount; i++)
-        {
-            _columns.Add(ColumnMetadata.Deserialize(reader));
-        }
-
-        // The diffusion processes carry no learned parameters; rebuild them from the options so the
-        // restored model can run the generation denoising loop.
-        if (IsFitted)
-        {
-            _gaussianDiffusion = new GaussianDiffusion<T>(
-                _options.NumTimesteps, _options.BetaStart, _options.BetaEnd,
-                _options.BetaSchedule, _random);
-            _multinomialDiffusion = new MultinomialDiffusion<T>(
-                _options.NumCategoricalDiffusionSteps, _options.BetaStart, _options.BetaEnd, _random);
-        }
-    }
-
-    /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new TabDDPMGenerator<T>(
-            Architecture,
-            _options,
-            _optimizer,
-            _lossFunction);
-    }
 
     /// <inheritdoc/>
     public override Dictionary<string, T> GetFeatureImportance()
diff --git a/src/NeuralNetworks/SyntheticData/TabFlowGenerator.cs b/src/NeuralNetworks/SyntheticData/TabFlowGenerator.cs
index ef71816eb4..34b7b6872b 100644
--- a/src/NeuralNetworks/SyntheticData/TabFlowGenerator.cs
+++ b/src/NeuralNetworks/SyntheticData/TabFlowGenerator.cs
@@ -702,39 +702,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_options.NumSteps);
-        writer.Write(_options.TimeEmbeddingDimension);
-        writer.Write(_options.Solver);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.LearningRate);
-        writer.Write(_options.BatchSize);
-        writer.Write(_options.Sigma);
-        writer.Write(_options.VGMModes);
-        writer.Write(_options.MLPDimensions.Length);
-        foreach (var dim in _options.MLPDimensions)
-        {
-            writer.Write(dim);
-        }
-    }
 
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        // Options are reconstructed from serialized data
-        // Layers are handled by base class
-    }
 
     /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new TabFlowGenerator<T>(
-            Architecture,
-            _options,
-            _optimizer,
-            _lossFunction);
-    }
+
 
     #endregion
 
diff --git a/src/NeuralNetworks/SyntheticData/TabLLMGenGenerator.cs b/src/NeuralNetworks/SyntheticData/TabLLMGenGenerator.cs
index 6e14d5fbd1..b952627f16 100644
--- a/src/NeuralNetworks/SyntheticData/TabLLMGenGenerator.cs
+++ b/src/NeuralNetworks/SyntheticData/TabLLMGenGenerator.cs
@@ -339,28 +339,10 @@ public override void Train(Tensor<T> input, Tensor<T> expectedOutput)
 
     // UpdateParameters folded one enumeration the base already folds. Removed under AIDN082.
     /// <inheritdoc />
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_vocabSize);
-        writer.Write(_seqLength);
-        writer.Write(_specialTokenOffset);
-        writer.Write(IsFitted);
-    }
 
-    /// <inheritdoc />
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _vocabSize = reader.ReadInt32();
-        _seqLength = reader.ReadInt32();
-        _specialTokenOffset = reader.ReadInt32();
-        IsFitted = reader.ReadBoolean();
-    }
 
     /// <inheritdoc />
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new TabLLMGenGenerator<T>(Architecture, _options);
-    }
+
 
     /// <inheritdoc />
     public override Dictionary<string, T> GetFeatureImportance()
diff --git a/src/NeuralNetworks/SyntheticData/TabSynGenerator.cs b/src/NeuralNetworks/SyntheticData/TabSynGenerator.cs
index eadaebe956..daa9eccf92 100644
--- a/src/NeuralNetworks/SyntheticData/TabSynGenerator.cs
+++ b/src/NeuralNetworks/SyntheticData/TabSynGenerator.cs
@@ -1109,128 +1109,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_options.LatentDimension);
-        writer.Write(_options.EncoderDimensions.Length);
-        foreach (var dim in _options.EncoderDimensions)
-        {
-            writer.Write(dim);
-        }
-        writer.Write(_options.DecoderDimensions.Length);
-        foreach (var dim in _options.DecoderDimensions)
-        {
-            writer.Write(dim);
-        }
-        writer.Write(_options.DiffusionMLPDimensions.Length);
-        foreach (var dim in _options.DiffusionMLPDimensions)
-        {
-            writer.Write(dim);
-        }
-        writer.Write(_options.DiffusionSteps);
-        writer.Write(_options.BetaStart);
-        writer.Write(_options.BetaEnd);
-        writer.Write(_options.BatchSize);
-        writer.Write(_options.VAELearningRate);
-        writer.Write(_options.DiffusionLearningRate);
-        writer.Write(_options.VGMModes);
-        writer.Write(_options.TimestepEmbeddingDimension);
-
-        // Persist the auxiliary sub-networks that live outside the base Layers collection. Without
-        // this, a saved/cloned model would fall back to freshly-initialized decoder / diffusion-MLP
-        // / projection weights and generate garbage.
-        writer.Write(IsFitted);
-        writer.Write(_dataWidth);
-        writer.Write(_usingCustomLayers);
-        AuxLayerSerialization.Write(writer, _meanLayer);
-        AuxLayerSerialization.Write(writer, _logVarLayer);
-        AuxLayerSerialization.Write(writer, _timestepProjection);
-        AuxLayerSerialization.WriteParameters(writer, _decoderLayers);
-        AuxLayerSerialization.WriteParameters(writer, _diffMLPLayers);
-
-        // The fitted VGM transformer (column layout + GMM parameters) is required to decode and
-        // inverse-transform generated latents. The latent diffusion process is fully determined by
-        // the options, so it is reconstructed on load rather than serialized.
-        if (_transformer is not null)
-        {
-            writer.Write(true);
-            _transformer.Serialize(writer);
-        }
-        else
-        {
-            writer.Write(false);
-        }
-    }
 
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        // Advance past the option fields (the options themselves are reconstructed in
-        // CreateNewInstance); they must still be read to reach the auxiliary-network data.
-        _ = reader.ReadInt32();                                  // LatentDimension
-        int encDimCount = reader.ReadInt32();
-        for (int i = 0; i < encDimCount; i++) _ = reader.ReadInt32();
-        int decDimCount = reader.ReadInt32();
-        for (int i = 0; i < decDimCount; i++) _ = reader.ReadInt32();
-        int diffDimCount = reader.ReadInt32();
-        for (int i = 0; i < diffDimCount; i++) _ = reader.ReadInt32();
-        _ = reader.ReadInt32();                                  // DiffusionSteps
-        _ = reader.ReadDouble();                                 // BetaStart
-        _ = reader.ReadDouble();                                 // BetaEnd
-        _ = reader.ReadInt32();                                  // BatchSize
-        _ = reader.ReadDouble();                                 // VAELearningRate
-        _ = reader.ReadDouble();                                 // DiffusionLearningRate
-        _ = reader.ReadInt32();                                  // VGMModes
-        _ = reader.ReadInt32();                                  // TimestepEmbeddingDimension
-
-        IsFitted = reader.ReadBoolean();
-        _dataWidth = reader.ReadInt32();
-        _usingCustomLayers = reader.ReadBoolean();
-
-        // Rebuild the auxiliary structures deterministically (the encoder in Layers was already
-        // restored by the base class) so the persisted parameters can be loaded back into them.
-        if (IsFitted)
-        {
-            BuildAuxiliaryNetworks(_dataWidth);
-        }
-
-        var identity = new IdentityActivation<T>() as IActivationFunction<T>;
-        var silu = new SiLUActivation<T>() as IActivationFunction<T>;
-        _meanLayer = AuxLayerSerialization.Read<T>(reader,
-            (inShape, outShape) => new FullyConnectedLayer<T>(outShape[outShape.Length - 1], identity))
-            as FullyConnectedLayer<T>;
-        _logVarLayer = AuxLayerSerialization.Read<T>(reader,
-            (inShape, outShape) => new FullyConnectedLayer<T>(outShape[outShape.Length - 1], identity))
-            as FullyConnectedLayer<T>;
-        _timestepProjection = AuxLayerSerialization.Read<T>(reader,
-            (inShape, outShape) => new FullyConnectedLayer<T>(outShape[outShape.Length - 1], silu))
-            as FullyConnectedLayer<T>;
-        AuxLayerSerialization.ReadParametersInto(reader, _decoderLayers);
-        AuxLayerSerialization.ReadParametersInto(reader, _diffMLPLayers);
-
-        bool hasTransformer = reader.ReadBoolean();
-        if (hasTransformer)
-        {
-            _transformer = new TabularDataTransformer<T>(_options.VGMModes, _random);
-            _transformer.Deserialize(reader);
-            _columns = new List<ColumnMetadata>(_transformer.Columns);
-
-            // The latent diffusion process holds no learned parameters — it is fully determined by
-            // the configured schedule, so reconstruct it for the generation path.
-            _latentDiffusion = new GaussianDiffusion<T>(
-                _options.DiffusionSteps, _options.BetaStart, _options.BetaEnd, "linear", _random);
-        }
-    }
 
     /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new TabSynGenerator<T>(
-            Architecture,
-            _options,
-            _optimizer,
-            _lossFunction);
-    }
+
 
     /// <inheritdoc/>
     public override Dictionary<string, T> GetFeatureImportance()
diff --git a/src/NeuralNetworks/SyntheticData/TabTransformerGenGenerator.cs b/src/NeuralNetworks/SyntheticData/TabTransformerGenGenerator.cs
index b9fa19486a..919b57f038 100644
--- a/src/NeuralNetworks/SyntheticData/TabTransformerGenGenerator.cs
+++ b/src/NeuralNetworks/SyntheticData/TabTransformerGenGenerator.cs
@@ -589,42 +589,10 @@ public override Tensor<T> ForwardForTraining(Tensor<T> input)
     // UpdateParameters re-sliced the flat vector across Layers by hand -- the base walks
     // exactly the same enumeration, so this said nothing the base does not already say.
     /// <inheritdoc />
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_options.NumLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.EmbeddingDimension);
-        writer.Write(_options.FeedForwardDimension);
-        writer.Write(_numColumns);
-        writer.Write(_dataWidth);
-        // Per-column widths define the embedding/decoder layer boundaries within
-        // Layers — serialize them so a deserialized clone can re-bind its typed
-        // layer references and run the identical column-token forward.
-        writer.Write(_colWidths.Count);
-        for (int c = 0; c < _colWidths.Count; c++) writer.Write(_colWidths[c]);
-        writer.Write(IsFitted);
-    }
+
 
     /// <inheritdoc />
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _ = reader.ReadInt32(); // NumLayers
-        _ = reader.ReadInt32(); // NumHeads
-        _ = reader.ReadInt32(); // EmbeddingDimension
-        _ = reader.ReadInt32(); // FeedForwardDimension
-        _numColumns = reader.ReadInt32();
-        _dataWidth = reader.ReadInt32();
-        int colWidthCount = reader.ReadInt32();
-        _colWidths.Clear();
-        for (int c = 0; c < colWidthCount; c++) _colWidths.Add(reader.ReadInt32());
-        IsFitted = reader.ReadBoolean();
-
-        // The base deserializer rebuilt Layers from the serialized layer list,
-        // orphaning the typed references the constructor populated. Re-bind them
-        // from the freshly-loaded Layers so the column-token forward uses the
-        // deserialized (trained) weights rather than the clone's discarded init.
-        ExtractLayerReferences();
-    }
+
 
     /// <summary>
     /// Re-binds the typed layer-reference lists (embeddings, per-block Q/K/V +
@@ -682,12 +650,6 @@ private void ExtractLayerReferences()
             _colDecoders.Add((FullyConnectedLayer<T>)Layers[idx++]);
     }
 
-    /// <inheritdoc />
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new TabTransformerGenGenerator<T>(Architecture, _options);
-    }
-
     /// <inheritdoc />
     public override Dictionary<string, T> GetFeatureImportance()
     {
diff --git a/src/NeuralNetworks/SyntheticData/TableGANGenerator.cs b/src/NeuralNetworks/SyntheticData/TableGANGenerator.cs
index 35fa669e42..8b9d45b98a 100644
--- a/src/NeuralNetworks/SyntheticData/TableGANGenerator.cs
+++ b/src/NeuralNetworks/SyntheticData/TableGANGenerator.cs
@@ -1087,28 +1087,10 @@ public override void Train(Tensor<T> input, Tensor<T> expectedOutput)
     // UpdateParameters re-sliced the flat vector across Layers by hand -- the base walks
     // exactly the same enumeration, so this said nothing the base does not already say.
     /// <inheritdoc />
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_options.EmbeddingDimension);
-        writer.Write(_dataWidth);
-        writer.Write(_numClasses);
-        writer.Write(IsFitted);
-    }
 
-    /// <inheritdoc />
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _ = reader.ReadInt32();
-        _dataWidth = reader.ReadInt32();
-        _numClasses = reader.ReadInt32();
-        IsFitted = reader.ReadBoolean();
-    }
 
     /// <inheritdoc />
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new TableGANGenerator<T>(Architecture, _options);
-    }
+
 
     /// <inheritdoc />
     public override Dictionary<string, T> GetFeatureImportance()
diff --git a/src/NeuralNetworks/SyntheticData/TabularDataTransformer.cs b/src/NeuralNetworks/SyntheticData/TabularDataTransformer.cs
index 4a2cada286..4e70d9420e 100644
--- a/src/NeuralNetworks/SyntheticData/TabularDataTransformer.cs
+++ b/src/NeuralNetworks/SyntheticData/TabularDataTransformer.cs
@@ -1,6 +1,7 @@
 using AiDotNet.Attributes;
 using AiDotNet.Enums;
 using AiDotNet.Helpers;
+using AiDotNet.Interfaces;
 
 namespace AiDotNet.NeuralNetworks.SyntheticData;
 
@@ -35,7 +36,7 @@ namespace AiDotNet.NeuralNetworks.SyntheticData;
 /// <typeparam name="T">The numeric type used for calculations.</typeparam>
 [ComponentType(ComponentType.Encoder)]
 [PipelineStage(PipelineStage.Preprocessing)]
-public class TabularDataTransformer<T>
+public class TabularDataTransformer<T> : IModelSerializer
 {
     private static readonly INumericOperations<T> NumOps = MathHelper.GetNumericOperations<T>();
 
@@ -330,6 +331,42 @@ public void Deserialize(System.IO.BinaryReader reader)
         }
     }
 
+    /// <inheritdoc />
+    public byte[] Serialize()
+    {
+        using var stream = new System.IO.MemoryStream();
+        using (var writer = new System.IO.BinaryWriter(stream, System.Text.Encoding.UTF8, leaveOpen: true))
+        {
+            Serialize(writer);
+        }
+
+        return stream.ToArray();
+    }
+
+    /// <inheritdoc />
+    public void Deserialize(byte[] data)
+    {
+        if (data is null) throw new ArgumentNullException(nameof(data));
+
+        using var stream = new System.IO.MemoryStream(data, writable: false);
+        using var reader = new System.IO.BinaryReader(stream, System.Text.Encoding.UTF8, leaveOpen: false);
+        Deserialize(reader);
+    }
+
+    /// <inheritdoc />
+    public void SaveModel(string filePath)
+    {
+        if (filePath is null) throw new ArgumentNullException(nameof(filePath));
+        System.IO.File.WriteAllBytes(filePath, Serialize());
+    }
+
+    /// <inheritdoc />
+    public void LoadModel(string filePath)
+    {
+        if (filePath is null) throw new ArgumentNullException(nameof(filePath));
+        Deserialize(System.IO.File.ReadAllBytes(filePath));
+    }
+
     private static void WriteDoubleArray(System.IO.BinaryWriter writer, double[] values)
     {
         writer.Write(values.Length);
diff --git a/src/NeuralNetworks/SyntheticData/TimeGANGenerator.cs b/src/NeuralNetworks/SyntheticData/TimeGANGenerator.cs
index 25fbf68f89..dfd06fb21e 100644
--- a/src/NeuralNetworks/SyntheticData/TimeGANGenerator.cs
+++ b/src/NeuralNetworks/SyntheticData/TimeGANGenerator.cs
@@ -1187,50 +1187,6 @@ public override void Train(Tensor<T> input, Tensor<T> expectedOutput)
             TensorToVector(expectedOutput, expectedOutput.Length));
     }
 
-    // UpdateParameters re-sliced the flat vector across Layers by hand -- the base walks
-    // exactly the same enumeration, so this said nothing the base does not already say.
-    /// <inheritdoc />
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_options.SequenceLength);
-        writer.Write(_materializedHiddenDimension);
-        writer.Write(_materializedNumLayers);
-        writer.Write(_dataWidth);
-        writer.Write(IsFitted);
-    }
-
-    /// <inheritdoc />
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _ = reader.ReadInt32(); // SequenceLength
-        _materializedHiddenDimension = reader.ReadInt32();
-        _materializedNumLayers = reader.ReadInt32();
-        _dataWidth = reader.ReadInt32();
-        IsFitted = reader.ReadBoolean();
-    }
-
-    /// <inheritdoc />
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var materializedOptions = _options.CreateMaterializedSnapshot(
-            _materializedHiddenDimension,
-            _materializedNumLayers);
-        var copy = new TimeGANGenerator<T>(Architecture, materializedOptions);
-
-        // The generic clone machinery can copy/share every reachable layer, but it cannot invent a
-        // model's unique auxiliary topology. A fresh TimeGAN constructor creates only the generator;
-        // materialize the fitted embedder/recovery/supervisor/discriminator graph before the base
-        // performs its structural preflight and weight transfer.
-        if (IsFitted)
-        {
-            copy._columns = new List<ColumnMetadata>(_columns);
-            copy._dataWidth = _dataWidth;
-            copy.RebuildAllNetworks();
-        }
-
-        return copy;
-    }
-
     /// <inheritdoc />
     public override Dictionary<string, T> GetFeatureImportance()
     {
diff --git a/src/NeuralNetworks/Tabular/AutoIntBase.cs b/src/NeuralNetworks/Tabular/AutoIntBase.cs
index edd2e6a241..938243cc84 100644
--- a/src/NeuralNetworks/Tabular/AutoIntBase.cs
+++ b/src/NeuralNetworks/Tabular/AutoIntBase.cs
@@ -1,4 +1,5 @@
 using AiDotNet.ActivationFunctions;
+using AiDotNet.Attributes;
 using System.Collections.Generic;
 using AiDotNet.Models.Parameters;
 using AiDotNet.LinearAlgebra;
@@ -32,7 +33,7 @@ namespace AiDotNet.NeuralNetworks.Tabular;
 /// </para>
 /// </remarks>
 /// <typeparam name="T">The numeric type used for calculations.</typeparam>
-public abstract class AutoIntBase<T> : IParameterSource<T>
+public abstract partial class AutoIntBase<T> : IParameterSource<T>
 {
     protected readonly AutoIntOptions<T> Options;
     protected readonly int NumNumericalFeatures;
@@ -43,6 +44,7 @@ public abstract class AutoIntBase<T> : IParameterSource<T>
     private readonly Random _random = RandomHelper.CreateSecureRandom();
 
     // Feature embeddings
+    [AiDotNet.Attributes.TrainableParameter]
     private readonly Tensor<T> _numericalEmbeddings;
     private readonly Tensor<T>[]? _categoricalEmbeddings;
 
@@ -54,10 +56,15 @@ public abstract class AutoIntBase<T> : IParameterSource<T>
     protected int MLPOutputDimension { get; }
 
     // Caches
+    [Scratch]
     private Tensor<T>? _numericalFeaturesCache;
+    [Scratch]
     private Matrix<int>? _categoricalIndicesCache;
+    [Scratch]
     private Tensor<T>? _embeddedFeaturesCache;
+    [Scratch]
     private List<Tensor<T>>? _interactingOutputsCache;
+    [Scratch]
     private Tensor<T>? _mlpOutputCache;
 
     // Embedding gradients
@@ -79,7 +86,7 @@ public abstract class AutoIntBase<T> : IParameterSource<T>
     /// the registry decides where it goes, so count, vector and restore cannot disagree about it.
     /// </remarks>
     protected virtual IEnumerable<IParameterSource<T>> GetExtraTrainableLayers()
-        => System.Linq.Enumerable.Empty<IParameterSource<T>>();
+        => GeneratedParameterDiscovery.EnumerateDerivedSources<T>(this, typeof(AutoIntBase<T>));
 
     /// <summary>
     /// The single ordered traversal of this model's parameter-bearing components.
diff --git a/src/NeuralNetworks/Tabular/AutoIntClassifier.cs b/src/NeuralNetworks/Tabular/AutoIntClassifier.cs
index b564836f0f..2018e654dd 100644
--- a/src/NeuralNetworks/Tabular/AutoIntClassifier.cs
+++ b/src/NeuralNetworks/Tabular/AutoIntClassifier.cs
@@ -57,8 +57,11 @@ public class AutoIntClassifier<T> : AutoIntBase<T>
     private readonly FullyConnectedLayer<T> _classificationHead;
 
     // Cache
+    [Scratch]
     private Tensor<T>? _backboneOutputCache;
+    [Scratch]
     private Tensor<T>? _logitsCache;
+    [Scratch]
     private Tensor<T>? _probabilitiesCache;
 
     /// <summary>
@@ -66,18 +69,6 @@ public class AutoIntClassifier<T> : AutoIntBase<T>
     /// </summary>
     public int NumClasses => _numClasses;
 
-    /// <summary>
-    /// Gets the total number of trainable parameters.
-    /// </summary>
-    /// <summary>The final projection this variant adds to the shared backbone.</summary>
-    /// <remarks>
-    /// Was an override that added the head to the COUNT only. The base had no read or
-    /// restore path at all, so the head was counted and never checkpointed; declaring it
-    /// here puts it in all three surfaces at once.
-    /// </remarks>
-    protected override IEnumerable<IParameterSource<T>> GetExtraTrainableLayers()
-        => new IParameterSource<T>[] { _classificationHead };
-
     /// <summary>
     /// Initializes a new instance of the AutoIntClassifier class.
     /// </summary>
diff --git a/src/NeuralNetworks/Tabular/AutoIntNetwork.cs b/src/NeuralNetworks/Tabular/AutoIntNetwork.cs
index a462420ef3..4116b18cfe 100644
--- a/src/NeuralNetworks/Tabular/AutoIntNetwork.cs
+++ b/src/NeuralNetworks/Tabular/AutoIntNetwork.cs
@@ -60,7 +60,7 @@ namespace AiDotNet.NeuralNetworks.Tabular;
     "https://arxiv.org/abs/1810.11921",
     Year = 2019,
     Authors = "Song, W., Shi, C., Xiao, Z., Duan, Z., Xu, Y., Zhang, M., & Tang, J.")]
-public class AutoIntNetwork<T> : TabularNeuralNetworkBase<T>
+public partial class AutoIntNetwork<T> : TabularNeuralNetworkBase<T>
 {
     private AutoIntOptions<T> _options;
 
@@ -222,81 +222,8 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_options.EmbeddingDimension);
-        writer.Write(_options.NumLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.AttentionDimension);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.UseResidual);
-        writer.Write(_options.UseLayerNorm);
-        writer.Write(_options.EmbeddingInitScale);
-
-        writer.Write(_options.MLPHiddenDimensions.Length);
-        foreach (var dim in _options.MLPHiddenDimensions)
-        {
-            writer.Write(dim);
-        }
 
-        if (_options.CategoricalCardinalities != null)
-        {
-            writer.Write(_options.CategoricalCardinalities.Length);
-            foreach (var card in _options.CategoricalCardinalities)
-            {
-                writer.Write(card);
-            }
-        }
-        else
-        {
-            writer.Write(0);
-        }
-    }
 
     /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        var options = new AutoIntOptions<T>
-        {
-            EmbeddingDimension = reader.ReadInt32(),
-            NumLayers = reader.ReadInt32(),
-            NumHeads = reader.ReadInt32(),
-            AttentionDimension = reader.ReadInt32(),
-            DropoutRate = reader.ReadDouble(),
-            UseResidual = reader.ReadBoolean(),
-            UseLayerNorm = reader.ReadBoolean(),
-            EmbeddingInitScale = reader.ReadDouble()
-        };
-
-        int mlpDimCount = reader.ReadInt32();
-        var mlpDims = new int[mlpDimCount];
-        for (int i = 0; i < mlpDimCount; i++)
-        {
-            mlpDims[i] = reader.ReadInt32();
-        }
-        options.MLPHiddenDimensions = mlpDims;
-
-        int catCount = reader.ReadInt32();
-        if (catCount > 0)
-        {
-            var cardinalities = new int[catCount];
-            for (int i = 0; i < catCount; i++)
-            {
-                cardinalities[i] = reader.ReadInt32();
-            }
-            options.CategoricalCardinalities = cardinalities;
-        }
-
-        _options = options;
-    }
 
-    /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new AutoIntNetwork<T>(
-            Architecture,
-            _options,
-            null,
-            _lossFunction);
-    }
 }
diff --git a/src/NeuralNetworks/Tabular/AutoIntRegression.cs b/src/NeuralNetworks/Tabular/AutoIntRegression.cs
index 64e6f18f4f..1083ecd2d2 100644
--- a/src/NeuralNetworks/Tabular/AutoIntRegression.cs
+++ b/src/NeuralNetworks/Tabular/AutoIntRegression.cs
@@ -54,7 +54,9 @@ public class AutoIntRegression<T> : AutoIntBase<T>
     private readonly FullyConnectedLayer<T> _regressionHead;
 
     // Cache
+    [Scratch]
     private Tensor<T>? _backboneOutputCache;
+    [Scratch]
     private Tensor<T>? _predictionsCache;
 
     /// <summary>
@@ -62,18 +64,6 @@ public class AutoIntRegression<T> : AutoIntBase<T>
     /// </summary>
     public int OutputDimension => _outputDimension;
 
-    /// <summary>
-    /// Gets the total number of trainable parameters.
-    /// </summary>
-    /// <summary>The final projection this variant adds to the shared backbone.</summary>
-    /// <remarks>
-    /// Was an override that added the head to the COUNT only. The base had no read or
-    /// restore path at all, so the head was counted and never checkpointed; declaring it
-    /// here puts it in all three surfaces at once.
-    /// </remarks>
-    protected override IEnumerable<IParameterSource<T>> GetExtraTrainableLayers()
-        => new IParameterSource<T>[] { _regressionHead };
-
     /// <summary>
     /// Initializes a new instance of the AutoIntRegression class.
     /// </summary>
@@ -96,7 +86,9 @@ public AutoIntRegression(
         _regressionHead = new FullyConnectedLayer<T>(
             MLPOutputDimension,
             outputDimension,
-            (IActivationFunction<T>?)null);
+            // Identity, stated rather than left to the default: FullyConnectedLayer resolves a null
+            // activation to ReLU, which would clamp this regression head to non-negative outputs.
+            new IdentityActivation<T>());
     }
 
     /// <summary>
diff --git a/src/NeuralNetworks/Tabular/CLSToken.cs b/src/NeuralNetworks/Tabular/CLSToken.cs
index 8d3fca3a8c..0b4fb606a5 100644
--- a/src/NeuralNetworks/Tabular/CLSToken.cs
+++ b/src/NeuralNetworks/Tabular/CLSToken.cs
@@ -28,13 +28,15 @@ namespace AiDotNet.NeuralNetworks.Tabular;
 /// <typeparam name="T">The numeric type used for calculations.</typeparam>
 [ComponentType(ComponentType.Encoder)]
 [PipelineStage(PipelineStage.Preprocessing)]
-public class CLSToken<T>
+public partial class CLSToken<T>
 {
     private static readonly INumericOperations<T> NumOps = MathHelper.GetNumericOperations<T>();
     private IEngine Engine => AiDotNetEngine.Current;
     private readonly Random _random;
 
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _clsEmbedding;
+    [Scratch]
     private Tensor<T> _clsGradient;
 
     /// <summary>
diff --git a/src/NeuralNetworks/Tabular/ColumnEmbedding.cs b/src/NeuralNetworks/Tabular/ColumnEmbedding.cs
index 651b3014e8..6a8c8c39bb 100644
--- a/src/NeuralNetworks/Tabular/ColumnEmbedding.cs
+++ b/src/NeuralNetworks/Tabular/ColumnEmbedding.cs
@@ -27,7 +27,7 @@ namespace AiDotNet.NeuralNetworks.Tabular;
 /// <typeparam name="T">The numeric type used for calculations.</typeparam>
 [ComponentType(ComponentType.Encoder)]
 [PipelineStage(PipelineStage.Preprocessing)]
-public class ColumnEmbedding<T>
+public partial class ColumnEmbedding<T>
 {
     private static readonly INumericOperations<T> NumOps = MathHelper.GetNumericOperations<T>();
     private IEngine Engine => AiDotNetEngine.Current;
@@ -37,7 +37,9 @@ public class ColumnEmbedding<T>
     private readonly int _embeddingDim;
     private readonly bool _learnable;
 
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _embeddings;
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _embeddingGradients;
 
     /// <summary>
diff --git a/src/NeuralNetworks/Tabular/ContextEncoder.cs b/src/NeuralNetworks/Tabular/ContextEncoder.cs
index 555d8f1b38..af9d092abf 100644
--- a/src/NeuralNetworks/Tabular/ContextEncoder.cs
+++ b/src/NeuralNetworks/Tabular/ContextEncoder.cs
@@ -44,8 +44,11 @@ public class ContextEncoder<T>
     private readonly FullyConnectedLayer<T> _labelEmbedding;
 
     // Cached values
+    [Scratch]
     private Tensor<T>? _queryCache;
+    [Scratch]
     private Tensor<T>? _keyCache;
+    [Scratch]
     private Tensor<T>? _valueCache;
 
     /// <summary>
diff --git a/src/NeuralNetworks/Tabular/ContrastivePretraining.cs b/src/NeuralNetworks/Tabular/ContrastivePretraining.cs
index 694f5c781f..693bf4740e 100644
--- a/src/NeuralNetworks/Tabular/ContrastivePretraining.cs
+++ b/src/NeuralNetworks/Tabular/ContrastivePretraining.cs
@@ -27,7 +27,7 @@ namespace AiDotNet.NeuralNetworks.Tabular;
 /// <typeparam name="T">The numeric type used for calculations.</typeparam>
 [ComponentType(ComponentType.Optimizer)]
 [PipelineStage(PipelineStage.Training)]
-public class ContrastivePretraining<T>
+public partial class ContrastivePretraining<T>
 {
     private static readonly INumericOperations<T> NumOps = MathHelper.GetNumericOperations<T>();
     private IEngine Engine => AiDotNetEngine.Current;
@@ -38,12 +38,16 @@ public class ContrastivePretraining<T>
     private readonly double _temperature;
 
     // Projection head for contrastive learning
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _projectionWeights;
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _projectionBias;
     private readonly int _projectionDim;
 
     // Cached values
+    [Scratch]
     private Tensor<T>? _originalEmbeddingsCache;
+    [Scratch]
     private Tensor<T>? _corruptedEmbeddingsCache;
     private int[]? _corruptedIndicesCache;
 
diff --git a/src/NeuralNetworks/Tabular/FTTransformerBase.cs b/src/NeuralNetworks/Tabular/FTTransformerBase.cs
index b9ec029ca0..3520193e04 100644
--- a/src/NeuralNetworks/Tabular/FTTransformerBase.cs
+++ b/src/NeuralNetworks/Tabular/FTTransformerBase.cs
@@ -1,4 +1,5 @@
 using AiDotNet.Models.Options;
+using AiDotNet.Attributes;
 using AiDotNet.Interfaces;
 using AiDotNet.NeuralNetworks.Layers;
 
@@ -88,7 +89,9 @@ public abstract class FTTransformerBase<T> : IParameterSource<T>
     protected readonly int NumCategoricalFeatures;
 
     // Cache for backward pass
+    [Scratch]
     private Tensor<T>? _tokenizedCache;
+    [Scratch]
     private readonly List<Tensor<T>> _layerOutputsCache;
 
     /// <summary>
@@ -128,7 +131,7 @@ public abstract class FTTransformerBase<T> : IParameterSource<T>
     /// </para>
     /// </remarks>
     protected virtual IEnumerable<ILayer<T>> GetExtraTrainableLayers()
-        => System.Linq.Enumerable.Empty<ILayer<T>>();
+        => AiDotNet.Models.Parameters.GeneratedParameterDiscovery.EnumerateDerivedLayers<T>(this, typeof(FTTransformerBase<T>));
 
     /// <inheritdoc cref="GetParameters"/>
     public virtual long ParameterCount
diff --git a/src/NeuralNetworks/Tabular/FTTransformerClassifier.cs b/src/NeuralNetworks/Tabular/FTTransformerClassifier.cs
index aae75c5209..123c54bc64 100644
--- a/src/NeuralNetworks/Tabular/FTTransformerClassifier.cs
+++ b/src/NeuralNetworks/Tabular/FTTransformerClassifier.cs
@@ -51,17 +51,15 @@ namespace AiDotNet.NeuralNetworks.Tabular;
     Authors = "Gorishniy, Y., Rubachev, I., Khrulkov, V., & Babenko, A.")]
 public class FTTransformerClassifier<T> : FTTransformerBase<T>
 {
-
-    /// <inheritdoc />
-    /// <remarks>The classification head. Everything else -- the tokenizer, the encoder stack and the final norm -- is the shared backbone, and the base folds this after it in all three surfaces.</remarks>
-    protected override IEnumerable<ILayer<T>> GetExtraTrainableLayers()
-        => new ILayer<T>[] { _classificationHead };
     private readonly int _numClasses;
     private readonly FullyConnectedLayer<T> _classificationHead;
 
     // Cache for backward pass
+    [Scratch]
     private Tensor<T>? _clsOutputCache;
+    [Scratch]
     private Tensor<T>? _logitsCache;
+    [Scratch]
     private Tensor<T>? _probabilitiesCache;
 
     /// <summary>
diff --git a/src/NeuralNetworks/Tabular/FTTransformerNetwork.cs b/src/NeuralNetworks/Tabular/FTTransformerNetwork.cs
index 424312107d..db417d4a13 100644
--- a/src/NeuralNetworks/Tabular/FTTransformerNetwork.cs
+++ b/src/NeuralNetworks/Tabular/FTTransformerNetwork.cs
@@ -61,7 +61,7 @@ namespace AiDotNet.NeuralNetworks.Tabular;
     "https://arxiv.org/abs/2106.11959",
     Year = 2021,
     Authors = "Gorishniy, Y., Rubachev, I., Khrulkov, V., & Babenko, A.")]
-public class FTTransformerNetwork<T> : TabularNeuralNetworkBase<T>
+public partial class FTTransformerNetwork<T> : TabularNeuralNetworkBase<T>
 {
     private FTTransformerOptions<T> _options;
 
@@ -258,103 +258,8 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_options.EmbeddingDimension);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.NumLayers);
-        writer.Write(_options.FeedForwardMultiplier);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.AttentionDropoutRate);
-        writer.Write(_options.ResidualDropoutRate);
-        writer.Write(_options.UsePreLayerNorm);
-        writer.Write(_options.LayerNormEpsilon);
-        writer.Write(_options.EmbeddingInitScale);
-        writer.Write(_options.UseNumericalBias);
-        writer.Write(_options.EnableGradientClipping);
-        writer.Write(_options.MaxGradientNorm);
-        writer.Write(_options.WeightDecay);
-        writer.Write(_options.UseReGLU);
 
-        if (_options.CategoricalCardinalities != null)
-        {
-            writer.Write(_options.CategoricalCardinalities.Length);
-            foreach (var card in _options.CategoricalCardinalities)
-            {
-                writer.Write(card);
-            }
-        }
-        else
-        {
-            writer.Write(0);
-        }
-    }
 
     /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        int embDim = reader.ReadInt32();
-        int numHeads = reader.ReadInt32();
-        if (embDim <= 0)
-        {
-            throw new InvalidOperationException(
-                $"Deserialized EmbeddingDimension ({embDim}) must be positive. Data may be corrupted.");
-        }
-        if (numHeads <= 0)
-        {
-            throw new InvalidOperationException(
-                $"Deserialized NumHeads ({numHeads}) must be positive. Data may be corrupted.");
-        }
-        if (embDim % numHeads != 0)
-        {
-            throw new InvalidOperationException(
-                $"Deserialized EmbeddingDimension ({embDim}) is not divisible by NumHeads ({numHeads}). Data may be corrupted.");
-        }
-        _options.EmbeddingDimension = embDim;
-        _options.NumHeads = numHeads;
-        _options.NumLayers = reader.ReadInt32();
-        _options.FeedForwardMultiplier = reader.ReadInt32();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.AttentionDropoutRate = reader.ReadDouble();
-        _options.ResidualDropoutRate = reader.ReadDouble();
-        _options.UsePreLayerNorm = reader.ReadBoolean();
-        _options.LayerNormEpsilon = reader.ReadDouble();
-        _options.EmbeddingInitScale = reader.ReadDouble();
-        _options.UseNumericalBias = reader.ReadBoolean();
-        _options.EnableGradientClipping = reader.ReadBoolean();
-        _options.MaxGradientNorm = reader.ReadDouble();
-        _options.WeightDecay = reader.ReadDouble();
-        _options.UseReGLU = reader.ReadBoolean();
 
-        int cardCount = reader.ReadInt32();
-        const int MaxReasonableCardinalities = 100_000;
-        if (cardCount < 0 || cardCount > MaxReasonableCardinalities)
-        {
-            throw new InvalidOperationException(
-                $"Deserialized CategoricalCardinalities count ({cardCount}) is out of valid range [0, {MaxReasonableCardinalities}]. Data may be corrupted.");
-        }
-        if (cardCount > 0)
-        {
-            _options.CategoricalCardinalities = new int[cardCount];
-            for (int i = 0; i < cardCount; i++)
-            {
-                _options.CategoricalCardinalities[i] = reader.ReadInt32();
-            }
-        }
-        else
-        {
-            _options.CategoricalCardinalities = null;
-        }
-    }
-
-    /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        // Create with cloned options and a fresh optimizer to avoid shared mutable state
-        return new FTTransformerNetwork<T>(
-            Architecture,
-            _options.Clone(),
-            optimizer: null,
-            _lossFunction);
-    }
 }
diff --git a/src/NeuralNetworks/Tabular/FTTransformerRegression.cs b/src/NeuralNetworks/Tabular/FTTransformerRegression.cs
index b46d01a3ff..c986c66216 100644
--- a/src/NeuralNetworks/Tabular/FTTransformerRegression.cs
+++ b/src/NeuralNetworks/Tabular/FTTransformerRegression.cs
@@ -48,16 +48,13 @@ namespace AiDotNet.NeuralNetworks.Tabular;
     Authors = "Gorishniy, Y., Rubachev, I., Khrulkov, V., & Babenko, A.")]
 public class FTTransformerRegression<T> : FTTransformerBase<T>
 {
-
-    /// <inheritdoc />
-    /// <remarks>The regression head, folded after the shared backbone by the base.</remarks>
-    protected override IEnumerable<ILayer<T>> GetExtraTrainableLayers()
-        => new ILayer<T>[] { _regressionHead };
     private readonly int _outputDimension;
     private readonly FullyConnectedLayer<T> _regressionHead;
 
     // Cache for backward pass
+    [Scratch]
     private Tensor<T>? _clsOutputCache;
+    [Scratch]
     private Tensor<T>? _predictionsCache;
 
     /// <summary>
@@ -98,7 +95,9 @@ public FTTransformerRegression(
         _regressionHead = new FullyConnectedLayer<T>(
             EmbeddingDimension,
             outputDimension,
-            (IActivationFunction<T>?)null);  // No activation for regression
+            // No activation for regression -- stated as Identity rather than passed as null, which
+            // FullyConnectedLayer resolves to ReLU and would clamp the head to non-negative outputs.
+            new IdentityActivation<T>());
     }
 
     /// <summary>
diff --git a/src/NeuralNetworks/Tabular/FeatureTokenizer.cs b/src/NeuralNetworks/Tabular/FeatureTokenizer.cs
index a9131f5990..db1b8a83dd 100644
--- a/src/NeuralNetworks/Tabular/FeatureTokenizer.cs
+++ b/src/NeuralNetworks/Tabular/FeatureTokenizer.cs
@@ -38,7 +38,7 @@ namespace AiDotNet.NeuralNetworks.Tabular;
 /// <typeparam name="T">The numeric type used for calculations.</typeparam>
 [ComponentType(ComponentType.Encoder)]
 [PipelineStage(PipelineStage.Preprocessing)]
-public class FeatureTokenizer<T>
+public partial class FeatureTokenizer<T>
 {
     private readonly INumericOperations<T> _numOps;
     private readonly int _numNumericalFeatures;
@@ -48,23 +48,31 @@ public class FeatureTokenizer<T>
     private readonly bool _useNumericalBias;
 
     // Numerical feature embeddings (linear projection)
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _numericalWeights;  // Shape: [numNumerical, embeddingDim]
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T>? _numericalBias;     // Shape: [numNumerical, embeddingDim]
 
     // Categorical feature embeddings (lookup tables)
     private readonly List<Tensor<T>> _categoricalEmbeddings;  // Each: [cardinality, embeddingDim]
 
     // [CLS] token embedding
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _clsToken;  // Shape: [1, embeddingDim]
 
     // Gradients
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T>? _numericalWeightsGrad;
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T>? _numericalBiasGrad;
     private readonly List<Tensor<T>?> _categoricalEmbeddingsGrad;
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T>? _clsTokenGrad;
 
     // Cache for backward pass
+    [Scratch]
     private Tensor<T>? _inputCache;
+    [Scratch]
     private Matrix<int>? _categoricalIndicesCache;
 
     /// <summary>
diff --git a/src/NeuralNetworks/Tabular/GANDALFBase.cs b/src/NeuralNetworks/Tabular/GANDALFBase.cs
index f02d9f5aee..8efcb383ff 100644
--- a/src/NeuralNetworks/Tabular/GANDALFBase.cs
+++ b/src/NeuralNetworks/Tabular/GANDALFBase.cs
@@ -1,4 +1,5 @@
 using AiDotNet.Engines;
+using AiDotNet.Attributes;
 using System.Collections.Generic;
 using AiDotNet.Models.Parameters;
 using AiDotNet.LinearAlgebra;
@@ -73,8 +74,11 @@ public abstract class GANDALFBase<T> : IParameterSource<T>
     private readonly List<Tensor<T>?> _treeLeafValuesGrad;
 
     // Cache for backward pass
+    [Scratch]
     private Tensor<T>? _inputCache;
+    [Scratch]
     private Tensor<T>? _gatingWeightsCache;
+    [Scratch]
     private List<Tensor<T>>? _routingProbsCache;  // Per tree routing probabilities
 
     /// <summary>
@@ -102,7 +106,7 @@ public abstract class GANDALFBase<T> : IParameterSource<T>
     /// the registry decides where it goes, so count, vector and restore cannot disagree about it.
     /// </remarks>
     protected virtual IEnumerable<IParameterSource<T>> GetExtraTrainableLayers()
-        => System.Linq.Enumerable.Empty<IParameterSource<T>>();
+        => GeneratedParameterDiscovery.EnumerateDerivedSources<T>(this, typeof(GANDALFBase<T>));
 
     /// <summary>
     /// The single ordered traversal of this model's parameter-bearing components.
diff --git a/src/NeuralNetworks/Tabular/GANDALFClassifier.cs b/src/NeuralNetworks/Tabular/GANDALFClassifier.cs
index 8cc385e79a..c3ff572149 100644
--- a/src/NeuralNetworks/Tabular/GANDALFClassifier.cs
+++ b/src/NeuralNetworks/Tabular/GANDALFClassifier.cs
@@ -53,8 +53,11 @@ public class GANDALFClassifier<T> : GANDALFBase<T>
     private readonly FullyConnectedLayer<T> _classificationHead;
 
     // Cache for backward pass
+    [Scratch]
     private Tensor<T>? _backboneOutputCache;
+    [Scratch]
     private Tensor<T>? _logitsCache;
+    [Scratch]
     private Tensor<T>? _probabilitiesCache;
 
     /// <summary>
@@ -62,18 +65,6 @@ public class GANDALFClassifier<T> : GANDALFBase<T>
     /// </summary>
     public int NumClasses => _numClasses;
 
-    /// <summary>
-    /// Gets the total number of trainable parameters.
-    /// </summary>
-    /// <summary>The final projection this variant adds to the shared backbone.</summary>
-    /// <remarks>
-    /// Was an override that added the head to the COUNT only. The base had no read or
-    /// restore path at all, so the head was counted and never checkpointed; declaring it
-    /// here puts it in all three surfaces at once.
-    /// </remarks>
-    protected override IEnumerable<IParameterSource<T>> GetExtraTrainableLayers()
-        => new IParameterSource<T>[] { _classificationHead };
-
     /// <summary>
     /// Initializes a new instance of the GANDALFClassifier class.
     /// </summary>
diff --git a/src/NeuralNetworks/Tabular/GANDALFNetwork.cs b/src/NeuralNetworks/Tabular/GANDALFNetwork.cs
index 21ba65b620..757792904c 100644
--- a/src/NeuralNetworks/Tabular/GANDALFNetwork.cs
+++ b/src/NeuralNetworks/Tabular/GANDALFNetwork.cs
@@ -54,7 +54,7 @@ namespace AiDotNet.NeuralNetworks.Tabular;
     "https://arxiv.org/abs/2207.08548",
     Year = 2022,
     Authors = "Joseph, R. & Raj, H.")]
-public class GANDALFNetwork<T> : TabularNeuralNetworkBase<T>
+public partial class GANDALFNetwork<T> : TabularNeuralNetworkBase<T>
 {
     private readonly GANDALFOptions<T> _options;
 
@@ -368,33 +368,8 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_options.NumTrees);
-        writer.Write(_options.TreeDepth);
-        writer.Write(_options.NumGatingLayers);
-        writer.Write(_options.GatingHiddenDimension);
-        writer.Write(_options.Temperature);
-        writer.Write(_options.LeafDimension);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.UseBatchNorm);
-        writer.Write(_options.InitScale);
-    }
 
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        // Options are reconstructed from serialized data
-        // Layers are handled by base class
-    }
 
     /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new GANDALFNetwork<T>(
-            Architecture,
-            _options,
-            _optimizer,
-            _lossFunction);
-    }
+
 }
diff --git a/src/NeuralNetworks/Tabular/GANDALFRegression.cs b/src/NeuralNetworks/Tabular/GANDALFRegression.cs
index a63d234ffc..a8a1b12222 100644
--- a/src/NeuralNetworks/Tabular/GANDALFRegression.cs
+++ b/src/NeuralNetworks/Tabular/GANDALFRegression.cs
@@ -52,7 +52,9 @@ public class GANDALFRegression<T> : GANDALFBase<T>
     private readonly FullyConnectedLayer<T> _regressionHead;
 
     // Cache for backward pass
+    [Scratch]
     private Tensor<T>? _backboneOutputCache;
+    [Scratch]
     private Tensor<T>? _predictionsCache;
 
     /// <summary>
@@ -60,18 +62,6 @@ public class GANDALFRegression<T> : GANDALFBase<T>
     /// </summary>
     public int OutputDimension => _outputDimension;
 
-    /// <summary>
-    /// Gets the total number of trainable parameters.
-    /// </summary>
-    /// <summary>The final projection this variant adds to the shared backbone.</summary>
-    /// <remarks>
-    /// Was an override that added the head to the COUNT only. The base had no read or
-    /// restore path at all, so the head was counted and never checkpointed; declaring it
-    /// here puts it in all three surfaces at once.
-    /// </remarks>
-    protected override IEnumerable<IParameterSource<T>> GetExtraTrainableLayers()
-        => new IParameterSource<T>[] { _regressionHead };
-
     /// <summary>
     /// Initializes a new instance of the GANDALFRegression class with default configuration.
     /// </summary>
@@ -103,7 +93,9 @@ public GANDALFRegression(
         _regressionHead = new FullyConnectedLayer<T>(
             Options.LeafDimension,
             outputDimension,
-            (IActivationFunction<T>?)null);
+            // Identity, stated rather than left to the default: FullyConnectedLayer resolves a null
+            // activation to ReLU, which would clamp this regression head to non-negative outputs.
+            new IdentityActivation<T>());
     }
 
     /// <summary>
diff --git a/src/NeuralNetworks/Tabular/GhostBatchNormalization.cs b/src/NeuralNetworks/Tabular/GhostBatchNormalization.cs
index cadc302ab5..706e57a0cc 100644
--- a/src/NeuralNetworks/Tabular/GhostBatchNormalization.cs
+++ b/src/NeuralNetworks/Tabular/GhostBatchNormalization.cs
@@ -35,7 +35,7 @@ namespace AiDotNet.NeuralNetworks.Tabular;
 /// <typeparam name="T">The numeric type used for calculations.</typeparam>
 [ComponentType(ComponentType.Regularizer)]
 [PipelineStage(PipelineStage.Training)]
-public class GhostBatchNormalization<T>
+public partial class GhostBatchNormalization<T>
 {
     private readonly INumericOperations<T> _numOps;
     private readonly int _numFeatures;
@@ -44,19 +44,27 @@ public class GhostBatchNormalization<T>
     private readonly double _epsilon;
 
     // Learnable parameters
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T> _gamma; // Scale parameter
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T> _beta;  // Shift parameter
 
     // Running statistics for inference
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T> _runningMean;
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T> _runningVar;
 
     // Gradients
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T>? _gammaGrad;
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T>? _betaGrad;
 
     // Cache for backward pass
+    [Scratch]
     private Tensor<T>? _inputCache;
+    [Scratch]
     private Tensor<T>? _normalizedCache;
 
     // Training vs inference mode. Propagated by the owning composite layer
diff --git a/src/NeuralNetworks/Tabular/MambularBase.cs b/src/NeuralNetworks/Tabular/MambularBase.cs
index 7449130a69..d96a9a4866 100644
--- a/src/NeuralNetworks/Tabular/MambularBase.cs
+++ b/src/NeuralNetworks/Tabular/MambularBase.cs
@@ -1,4 +1,5 @@
 using AiDotNet.ActivationFunctions;
+using AiDotNet.Attributes;
 using System;
 using System.Collections.Generic;
 using AiDotNet.Models.Parameters;
@@ -32,7 +33,7 @@ namespace AiDotNet.NeuralNetworks.Tabular;
 /// </para>
 /// </remarks>
 /// <typeparam name="T">The numeric type used for calculations.</typeparam>
-public abstract class MambularBase<T> : IParameterSource<T>
+public abstract partial class MambularBase<T> : IParameterSource<T>
 {
     /// <summary>
     /// Provides access to the hardware-accelerated tensor engine.
@@ -47,6 +48,7 @@ public abstract class MambularBase<T> : IParameterSource<T>
     private readonly Random _random = RandomHelper.CreateSecureRandom();
 
     // Feature embeddings
+    [AiDotNet.Attributes.TrainableParameter]
     private readonly Tensor<T> _numericalEmbeddings;
     private readonly Tensor<T>[]? _categoricalEmbeddings;
 
@@ -58,7 +60,9 @@ public abstract class MambularBase<T> : IParameterSource<T>
     protected int MLPOutputDimension { get; }
 
     // Caches
+    [Scratch]
     private Tensor<T>? _embeddedFeaturesCache;
+    [Scratch]
     private Tensor<T>? _mambaOutputCache;
 
     /// <summary>Built once on first parameter access, then reused.</summary>
@@ -76,7 +80,7 @@ public abstract class MambularBase<T> : IParameterSource<T>
     /// the registry decides where it goes, so count, vector and restore cannot disagree about it.
     /// </remarks>
     protected virtual IEnumerable<IParameterSource<T>> GetExtraTrainableLayers()
-        => System.Linq.Enumerable.Empty<IParameterSource<T>>();
+        => GeneratedParameterDiscovery.EnumerateDerivedSources<T>(this, typeof(MambularBase<T>));
 
     /// <summary>
     /// The single ordered traversal of this model's parameter-bearing components.
@@ -395,7 +399,11 @@ private class MambaBlock : IParameterSource<T>
         // Convolution
         private readonly Tensor<T> _convWeight;
 
-        // Delta (discretization)
+        // Delta (discretization). Built once in the constructor and only ever read afterwards, and
+        // it is yielded from Tensors() below, so it travels in the parameter vector exactly like the
+        // seven weights above it. It was briefly labelled Scratch, which would have declared the
+        // opposite -- a value the restore path is free to discard -- while the vector was still
+        // carrying it. A field cannot be both.
         private readonly Tensor<T> _deltaProj;
 
         /// <summary>
diff --git a/src/NeuralNetworks/Tabular/MambularClassifier.cs b/src/NeuralNetworks/Tabular/MambularClassifier.cs
index a607b495c1..1359431962 100644
--- a/src/NeuralNetworks/Tabular/MambularClassifier.cs
+++ b/src/NeuralNetworks/Tabular/MambularClassifier.cs
@@ -50,8 +50,11 @@ public class MambularClassifier<T> : MambularBase<T>
     private readonly int _numClasses;
     private readonly FullyConnectedLayer<T> _classificationHead;
 
+    [Scratch]
     private Tensor<T>? _backboneOutputCache;
+    [Scratch]
     private Tensor<T>? _logitsCache;
+    [Scratch]
     private Tensor<T>? _probabilitiesCache;
 
     /// <summary>
@@ -59,18 +62,6 @@ public class MambularClassifier<T> : MambularBase<T>
     /// </summary>
     public int NumClasses => _numClasses;
 
-    /// <summary>
-    /// Gets the total number of trainable parameters.
-    /// </summary>
-    /// <summary>The final projection this variant adds to the shared backbone.</summary>
-    /// <remarks>
-    /// Was an override that added the head to the COUNT only. The base had no read or
-    /// restore path at all, so the head was counted and never checkpointed; declaring it
-    /// here puts it in all three surfaces at once.
-    /// </remarks>
-    protected override IEnumerable<IParameterSource<T>> GetExtraTrainableLayers()
-        => new IParameterSource<T>[] { _classificationHead };
-
     /// <summary>
     /// Initializes a new instance of the MambularClassifier class.
     /// </summary>
diff --git a/src/NeuralNetworks/Tabular/MambularNetwork.cs b/src/NeuralNetworks/Tabular/MambularNetwork.cs
index a8f516f231..0a1f94be06 100644
--- a/src/NeuralNetworks/Tabular/MambularNetwork.cs
+++ b/src/NeuralNetworks/Tabular/MambularNetwork.cs
@@ -56,7 +56,7 @@ namespace AiDotNet.NeuralNetworks.Tabular;
     "https://arxiv.org/abs/2408.06291",
     Year = 2024,
     Authors = "Thielmann, A., Kruse, R., Samiee, S., & Kleyko, D.")]
-public class MambularNetwork<T> : TabularNeuralNetworkBase<T>
+public partial class MambularNetwork<T> : TabularNeuralNetworkBase<T>
 {
     private readonly MambularOptions<T> _options;
 
@@ -216,51 +216,8 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_options.EmbeddingDimension);
-        writer.Write(_options.StateDimension);
-        writer.Write(_options.NumLayers);
-        writer.Write(_options.ExpansionFactor);
-        writer.Write(_options.ConvKernelSize);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.InitScale);
-        writer.Write(_options.DeltaMin);
-        writer.Write(_options.DeltaMax);
-        writer.Write(_options.UseBidirectional);
 
-        writer.Write(_options.MLPHiddenDimensions.Length);
-        foreach (var dim in _options.MLPHiddenDimensions)
-        {
-            writer.Write(dim);
-        }
-
-        if (_options.CategoricalCardinalities != null)
-        {
-            writer.Write(_options.CategoricalCardinalities.Length);
-            foreach (var card in _options.CategoricalCardinalities)
-            {
-                writer.Write(card);
-            }
-        }
-        else
-        {
-            writer.Write(0);
-        }
-    }
 
     /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-    }
 
-    /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new MambularNetwork<T>(
-            Architecture,
-            _options,
-            _optimizer,
-            _lossFunction);
-    }
 }
diff --git a/src/NeuralNetworks/Tabular/MambularRegression.cs b/src/NeuralNetworks/Tabular/MambularRegression.cs
index e6f55233ff..bd2249145f 100644
--- a/src/NeuralNetworks/Tabular/MambularRegression.cs
+++ b/src/NeuralNetworks/Tabular/MambularRegression.cs
@@ -50,7 +50,9 @@ public class MambularRegression<T> : MambularBase<T>
     private readonly int _outputDimension;
     private readonly FullyConnectedLayer<T> _regressionHead;
 
+    [Scratch]
     private Tensor<T>? _backboneOutputCache;
+    [Scratch]
     private Tensor<T>? _predictionsCache;
 
     /// <summary>
@@ -58,18 +60,6 @@ public class MambularRegression<T> : MambularBase<T>
     /// </summary>
     public int OutputDimension => _outputDimension;
 
-    /// <summary>
-    /// Gets the total number of trainable parameters.
-    /// </summary>
-    /// <summary>The final projection this variant adds to the shared backbone.</summary>
-    /// <remarks>
-    /// Was an override that added the head to the COUNT only. The base had no read or
-    /// restore path at all, so the head was counted and never checkpointed; declaring it
-    /// here puts it in all three surfaces at once.
-    /// </remarks>
-    protected override IEnumerable<IParameterSource<T>> GetExtraTrainableLayers()
-        => new IParameterSource<T>[] { _regressionHead };
-
     /// <summary>
     /// Initializes a new instance of the MambularRegression class.
     /// </summary>
@@ -89,7 +79,9 @@ public MambularRegression(
         _regressionHead = new FullyConnectedLayer<T>(
             MLPOutputDimension,
             outputDimension,
-            (IActivationFunction<T>?)null);
+            // Identity, stated rather than left to the default: FullyConnectedLayer resolves a null
+            // activation to ReLU, which would clamp this regression head to non-negative outputs.
+            new IdentityActivation<T>());
     }
 
     /// <summary>
diff --git a/src/NeuralNetworks/Tabular/NODEBase.cs b/src/NeuralNetworks/Tabular/NODEBase.cs
index 1270ca3cbf..aea9796225 100644
--- a/src/NeuralNetworks/Tabular/NODEBase.cs
+++ b/src/NeuralNetworks/Tabular/NODEBase.cs
@@ -1,4 +1,5 @@
 using AiDotNet.ActivationFunctions;
+using AiDotNet.Attributes;
 using System.Collections.Generic;
 using AiDotNet.Models.Parameters;
 using AiDotNet.LinearAlgebra;
@@ -51,9 +52,13 @@ public abstract class NODEBase<T> : IParameterSource<T>
     private readonly Tensor<T>[] _leafValues;               // [2^depth, output_dim] per tree
 
     // Caches for backward pass
+    [Scratch]
     private Tensor<T>? _preprocessedFeaturesCache;
+    [Scratch]
     private List<Tensor<T>>? _splitProbabilitiesCache;
+    [Scratch]
     private List<Tensor<T>>? _leafWeightsCache;
+    [Scratch]
     private Tensor<T>? _treeOutputsCache;
 
     /// <summary>
@@ -76,7 +81,7 @@ public abstract class NODEBase<T> : IParameterSource<T>
     /// the registry decides where it goes, so count, vector and restore cannot disagree about it.
     /// </remarks>
     protected virtual IEnumerable<IParameterSource<T>> GetExtraTrainableLayers()
-        => System.Linq.Enumerable.Empty<IParameterSource<T>>();
+        => GeneratedParameterDiscovery.EnumerateDerivedSources<T>(this, typeof(NODEBase<T>));
 
     /// <summary>
     /// The single ordered traversal of this model's parameter-bearing components.
diff --git a/src/NeuralNetworks/Tabular/NODEClassifier.cs b/src/NeuralNetworks/Tabular/NODEClassifier.cs
index c7686618fd..c06872eb2a 100644
--- a/src/NeuralNetworks/Tabular/NODEClassifier.cs
+++ b/src/NeuralNetworks/Tabular/NODEClassifier.cs
@@ -53,8 +53,11 @@ public class NODEClassifier<T> : NODEBase<T>
     private readonly FullyConnectedLayer<T> _classificationHead;
 
     // Cache for backward pass
+    [Scratch]
     private Tensor<T>? _backboneOutputCache;
+    [Scratch]
     private Tensor<T>? _logitsCache;
+    [Scratch]
     private Tensor<T>? _probabilitiesCache;
 
     /// <summary>
@@ -62,18 +65,6 @@ public class NODEClassifier<T> : NODEBase<T>
     /// </summary>
     public int NumClasses => _numClasses;
 
-    /// <summary>
-    /// Gets the total number of trainable parameters.
-    /// </summary>
-    /// <summary>The final projection this variant adds to the shared backbone.</summary>
-    /// <remarks>
-    /// Was an override that added the head to the COUNT only. The base had no read or
-    /// restore path at all, so the head was counted and never checkpointed; declaring it
-    /// here puts it in all three surfaces at once.
-    /// </remarks>
-    protected override IEnumerable<IParameterSource<T>> GetExtraTrainableLayers()
-        => new IParameterSource<T>[] { _classificationHead };
-
     /// <summary>
     /// Initializes a new instance of the NODEClassifier class.
     /// </summary>
diff --git a/src/NeuralNetworks/Tabular/NODENetwork.cs b/src/NeuralNetworks/Tabular/NODENetwork.cs
index 80fb992929..5fd2c86eac 100644
--- a/src/NeuralNetworks/Tabular/NODENetwork.cs
+++ b/src/NeuralNetworks/Tabular/NODENetwork.cs
@@ -64,7 +64,7 @@ namespace AiDotNet.NeuralNetworks.Tabular;
     "https://arxiv.org/abs/1909.06312",
     Year = 2020,
     Authors = "Popov, S., Morozov, S., & Babenko, A.")]
-public class NODENetwork<T> : TabularNeuralNetworkBase<T>
+public partial class NODENetwork<T> : TabularNeuralNetworkBase<T>
 {
     private readonly NODEOptions<T> _options;
 
@@ -263,40 +263,8 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_options.NumTrees);
-        writer.Write(_options.TreeDepth);
-        writer.Write(_options.TreeOutputDimension);
-        writer.Write(_options.Temperature);
-        writer.Write(_options.EntmaxAlpha);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.UseBatchNorm);
-        writer.Write(_options.InitScale);
-        writer.Write(_options.UseFeaturePreprocessing);
-        writer.Write(_options.FeatureSelectionDimension);
 
-        writer.Write(_options.MLPHiddenDimensions.Length);
-        foreach (var dim in _options.MLPHiddenDimensions)
-        {
-            writer.Write(dim);
-        }
-    }
 
     /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        // Options are reconstructed from serialized data
-        // Layers are handled by base class
-    }
 
-    /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new NODENetwork<T>(
-            Architecture,
-            _options,
-            _optimizer,
-            _lossFunction);
-    }
 }
diff --git a/src/NeuralNetworks/Tabular/NODERegression.cs b/src/NeuralNetworks/Tabular/NODERegression.cs
index 45ebb28ab2..7aa4776a0b 100644
--- a/src/NeuralNetworks/Tabular/NODERegression.cs
+++ b/src/NeuralNetworks/Tabular/NODERegression.cs
@@ -53,7 +53,9 @@ public class NODERegression<T> : NODEBase<T>
     private readonly FullyConnectedLayer<T> _regressionHead;
 
     // Cache for backward pass
+    [Scratch]
     private Tensor<T>? _backboneOutputCache;
+    [Scratch]
     private Tensor<T>? _predictionsCache;
 
     /// <summary>
@@ -61,18 +63,6 @@ public class NODERegression<T> : NODEBase<T>
     /// </summary>
     public int OutputDimension => _outputDimension;
 
-    /// <summary>
-    /// Gets the total number of trainable parameters.
-    /// </summary>
-    /// <summary>The final projection this variant adds to the shared backbone.</summary>
-    /// <remarks>
-    /// Was an override that added the head to the COUNT only. The base had no read or
-    /// restore path at all, so the head was counted and never checkpointed; declaring it
-    /// here puts it in all three surfaces at once.
-    /// </remarks>
-    protected override IEnumerable<IParameterSource<T>> GetExtraTrainableLayers()
-        => new IParameterSource<T>[] { _regressionHead };
-
     /// <summary>
     /// Initializes a new instance of the NODERegression class.
     /// </summary>
@@ -96,7 +86,11 @@ public NODERegression(
         _regressionHead = new FullyConnectedLayer<T>(
             TreeOutputDimension,
             outputDimension,
-            (IActivationFunction<T>?)null);
+            // Identity, stated rather than left to the default. Passing null here reads as "no
+            // activation", but FullyConnectedLayer resolves null to ReLU, so this regression head
+            // could only ever emit non-negative values: measured at 0.00012 from a fresh model and
+            // exactly 0 once any parameter vector was restored into it.
+            new IdentityActivation<T>());
     }
 
     /// <summary>
diff --git a/src/NeuralNetworks/Tabular/SAINTBase.cs b/src/NeuralNetworks/Tabular/SAINTBase.cs
index 1c7ca855aa..a0442ff107 100644
--- a/src/NeuralNetworks/Tabular/SAINTBase.cs
+++ b/src/NeuralNetworks/Tabular/SAINTBase.cs
@@ -1,4 +1,5 @@
 using AiDotNet.ActivationFunctions;
+using AiDotNet.Attributes;
 using System.Collections.Generic;
 using AiDotNet.Models.Parameters;
 using AiDotNet.LinearAlgebra;
@@ -32,7 +33,7 @@ namespace AiDotNet.NeuralNetworks.Tabular;
 /// </para>
 /// </remarks>
 /// <typeparam name="T">The numeric type used for calculations.</typeparam>
-public abstract class SAINTBase<T> : IParameterSource<T>
+public abstract partial class SAINTBase<T> : IParameterSource<T>
 {
     protected readonly SAINTOptions<T> Options;
     protected readonly int NumNumericalFeatures;
@@ -45,6 +46,7 @@ public abstract class SAINTBase<T> : IParameterSource<T>
     // Feature embeddings
     private readonly FullyConnectedLayer<T> _numericalEmbedding;
     private readonly Tensor<T>[]? _categoricalEmbeddings;
+    [AiDotNet.Attributes.TrainableParameter]
     private readonly Tensor<T>? _columnEmbeddings;
 
     // Transformer layers (alternating column and row attention)
@@ -58,9 +60,13 @@ public abstract class SAINTBase<T> : IParameterSource<T>
     protected int MLPOutputDimension { get; }
 
     // Caches for backward pass
+    [Scratch]
     private Tensor<T>? _embeddedFeaturesCache;
+    [Scratch]
     private List<Tensor<T>>? _columnAttentionOutputsCache;
+    [Scratch]
     private List<Tensor<T>>? _rowAttentionOutputsCache;
+    [Scratch]
     private Tensor<T>? _mlpOutputCache;
 
     /// <summary>Built once on first parameter access, then reused.</summary>
@@ -70,7 +76,7 @@ public abstract class SAINTBase<T> : IParameterSource<T>
     /// Extra trainable layers a subclass contributes, folded after the shared backbone.
     /// </summary>
     protected virtual IEnumerable<IParameterSource<T>> GetExtraTrainableLayers()
-        => System.Linq.Enumerable.Empty<IParameterSource<T>>();
+        => GeneratedParameterDiscovery.EnumerateDerivedSources<T>(this, typeof(SAINTBase<T>));
 
     /// <summary>The single ordered traversal of this model's parameter-bearing components.</summary>
     private ParameterComponentRegistry<T> ParameterRegistry
diff --git a/src/NeuralNetworks/Tabular/SAINTClassifier.cs b/src/NeuralNetworks/Tabular/SAINTClassifier.cs
index 3dabc6a4f7..4b20a5063f 100644
--- a/src/NeuralNetworks/Tabular/SAINTClassifier.cs
+++ b/src/NeuralNetworks/Tabular/SAINTClassifier.cs
@@ -53,8 +53,11 @@ public class SAINTClassifier<T> : SAINTBase<T>
     private readonly FullyConnectedLayer<T> _classificationHead;
 
     // Cache for backward pass
+    [Scratch]
     private Tensor<T>? _backboneOutputCache;
+    [Scratch]
     private Tensor<T>? _logitsCache;
+    [Scratch]
     private Tensor<T>? _probabilitiesCache;
 
     /// <summary>
@@ -62,18 +65,6 @@ public class SAINTClassifier<T> : SAINTBase<T>
     /// </summary>
     public int NumClasses => _numClasses;
 
-    /// <summary>
-    /// Gets the total number of trainable parameters.
-    /// </summary>
-    /// <summary>The final projection this variant adds to the shared backbone.</summary>
-    /// <remarks>
-    /// Was an override that added the head to the COUNT only. The base had no read or
-    /// restore path at all, so the head was counted and never checkpointed; declaring it
-    /// here puts it in all three surfaces at once.
-    /// </remarks>
-    protected override IEnumerable<IParameterSource<T>> GetExtraTrainableLayers()
-        => new IParameterSource<T>[] { _classificationHead };
-
     /// <summary>
     /// Initializes a new instance of the SAINTClassifier class.
     /// </summary>
diff --git a/src/NeuralNetworks/Tabular/SAINTNetwork.cs b/src/NeuralNetworks/Tabular/SAINTNetwork.cs
index e25f5f55db..06f8314081 100644
--- a/src/NeuralNetworks/Tabular/SAINTNetwork.cs
+++ b/src/NeuralNetworks/Tabular/SAINTNetwork.cs
@@ -68,7 +68,7 @@ namespace AiDotNet.NeuralNetworks.Tabular;
     "https://arxiv.org/abs/2106.01342",
     Year = 2021,
     Authors = "Somepalli, G., Goldblum, M., Schwarzschild, A., Bruss, C. B., & Goldstein, T.")]
-public class SAINTNetwork<T> : TabularNeuralNetworkBase<T>
+public partial class SAINTNetwork<T> : TabularNeuralNetworkBase<T>
 {
     private readonly SAINTOptions<T> _options;
 
@@ -393,57 +393,8 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_options.EmbeddingDimension);
-        writer.Write(_options.HiddenDimension);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.NumLayers);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.UseLayerNorm);
-        writer.Write(_options.UseIntersampleAttention);
-        writer.Write(_options.UsePreNorm);
-        writer.Write(_options.BatchSize);
-        writer.Write(_options.EmbeddingInitScale);
-        writer.Write(_options.AttentionDropoutRate);
-        writer.Write(_options.FeedForwardMultiplier);
 
-        // Serialize MLPHiddenDimensions
-        writer.Write(_options.MLPHiddenDimensions.Length);
-        foreach (var dim in _options.MLPHiddenDimensions)
-        {
-            writer.Write(dim);
-        }
-
-        // Serialize CategoricalCardinalities if present
-        if (_options.CategoricalCardinalities != null)
-        {
-            writer.Write(_options.CategoricalCardinalities.Length);
-            foreach (var card in _options.CategoricalCardinalities)
-            {
-                writer.Write(card);
-            }
-        }
-        else
-        {
-            writer.Write(0);
-        }
-    }
 
     /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        // Options are reconstructed from serialized data
-        // Layers are handled by base class
-    }
 
-    /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new SAINTNetwork<T>(
-            Architecture,
-            _options,
-            _optimizer,
-            _lossFunction);
-    }
 }
diff --git a/src/NeuralNetworks/Tabular/SAINTRegression.cs b/src/NeuralNetworks/Tabular/SAINTRegression.cs
index f30df622c0..dbcbbc28ee 100644
--- a/src/NeuralNetworks/Tabular/SAINTRegression.cs
+++ b/src/NeuralNetworks/Tabular/SAINTRegression.cs
@@ -53,7 +53,9 @@ public class SAINTRegression<T> : SAINTBase<T>
     private readonly FullyConnectedLayer<T> _regressionHead;
 
     // Cache for backward pass
+    [Scratch]
     private Tensor<T>? _backboneOutputCache;
+    [Scratch]
     private Tensor<T>? _predictionsCache;
 
     /// <summary>
@@ -61,18 +63,6 @@ public class SAINTRegression<T> : SAINTBase<T>
     /// </summary>
     public int OutputDimension => _outputDimension;
 
-    /// <summary>
-    /// Gets the total number of trainable parameters.
-    /// </summary>
-    /// <summary>The final projection this variant adds to the shared backbone.</summary>
-    /// <remarks>
-    /// Was an override that added the head to the COUNT only. The base had no read or
-    /// restore path at all, so the head was counted and never checkpointed; declaring it
-    /// here puts it in all three surfaces at once.
-    /// </remarks>
-    protected override IEnumerable<IParameterSource<T>> GetExtraTrainableLayers()
-        => new IParameterSource<T>[] { _regressionHead };
-
     /// <summary>
     /// Initializes a new instance of the SAINTRegression class.
     /// </summary>
diff --git a/src/NeuralNetworks/Tabular/TabDPTBase.cs b/src/NeuralNetworks/Tabular/TabDPTBase.cs
index 00c6ab09b2..289f40b927 100644
--- a/src/NeuralNetworks/Tabular/TabDPTBase.cs
+++ b/src/NeuralNetworks/Tabular/TabDPTBase.cs
@@ -1,4 +1,5 @@
 using AiDotNet.ActivationFunctions;
+using AiDotNet.Attributes;
 using System;
 using System.Collections.Generic;
 using AiDotNet.Models.Parameters;
@@ -63,8 +64,11 @@ public abstract class TabDPTBase<T> : IParameterSource<T>
     private readonly LayerNormalizationLayer<T> _finalNorm;
 
     // Cached values
+    [Scratch]
     private Tensor<T>? _embeddingsCache;
+    [Scratch]
     private Tensor<T>? _transformerOutputCache;
+    [Scratch]
     private Tensor<T>? _mlpOutputCache;
 
     /// <summary>
@@ -92,7 +96,7 @@ public abstract class TabDPTBase<T> : IParameterSource<T>
     /// the registry decides where it goes, so count, vector and restore cannot disagree about it.
     /// </remarks>
     protected virtual IEnumerable<IParameterSource<T>> GetExtraTrainableLayers()
-        => System.Linq.Enumerable.Empty<IParameterSource<T>>();
+        => GeneratedParameterDiscovery.EnumerateDerivedSources<T>(this, typeof(TabDPTBase<T>));
 
     /// <summary>
     /// The single ordered traversal of this model's parameter-bearing components.
@@ -385,15 +389,23 @@ private sealed class TransformerBlock<TBlock> : IParameterSource<TBlock>
         private readonly double _dropoutRate;
 
         // Attention weights
+        [AiDotNet.Attributes.Scratch]
         private Tensor<TBlock> _queryWeights;
+        [AiDotNet.Attributes.Scratch]
         private Tensor<TBlock> _keyWeights;
+        [AiDotNet.Attributes.Scratch]
         private Tensor<TBlock> _valueWeights;
+        [AiDotNet.Attributes.Scratch]
         private Tensor<TBlock> _outputWeights;
 
         // Attention gradients
+        [AiDotNet.Attributes.Scratch]
         private Tensor<TBlock> _queryGrad;
+        [AiDotNet.Attributes.Scratch]
         private Tensor<TBlock> _keyGrad;
+        [AiDotNet.Attributes.Scratch]
         private Tensor<TBlock> _valueGrad;
+        [AiDotNet.Attributes.Scratch]
         private Tensor<TBlock> _outputGrad;
 
         // Feed-forward layers
@@ -405,12 +417,19 @@ private sealed class TransformerBlock<TBlock> : IParameterSource<TBlock>
         private readonly LayerNormalizationLayer<TBlock> _norm2;
 
         // Cached values
+        [Scratch]
         private Tensor<TBlock>? _inputCache;
+        [Scratch]
         private Tensor<TBlock>? _normInput1Cache;
+        [Scratch]
         private Tensor<TBlock>? _attentionOutputCache;
+        [Scratch]
         private Tensor<TBlock>? _queryCache;
+        [Scratch]
         private Tensor<TBlock>? _keyCache;
+        [Scratch]
         private Tensor<TBlock>? _valueCache;
+        [Scratch]
         private Tensor<TBlock>? _attentionScoresCache;
 
         /// <summary>The block attention projections, in serialization order.</summary>
@@ -746,6 +765,7 @@ private sealed class FeatureAttentionBlock<TBlock> : IParameterSource<TBlock>
         private Tensor<TBlock> _featureValue;
         private Tensor<TBlock> _featureOutput;
 
+        [AiDotNet.Attributes.Scratch]
         private Tensor<TBlock>? _inputCache;
 
         /// <summary>The four projections, in serialization order.</summary>
diff --git a/src/NeuralNetworks/Tabular/TabDPTClassifier.cs b/src/NeuralNetworks/Tabular/TabDPTClassifier.cs
index 7caac5849b..4f6ef7abc9 100644
--- a/src/NeuralNetworks/Tabular/TabDPTClassifier.cs
+++ b/src/NeuralNetworks/Tabular/TabDPTClassifier.cs
@@ -54,8 +54,11 @@ public class TabDPTClassifier<T> : TabDPTBase<T>
     private readonly int _numClasses;
     private readonly FullyConnectedLayer<T> _classificationHead;
 
+    [Scratch]
     private Tensor<T>? _backboneOutputCache;
+    [Scratch]
     private Tensor<T>? _logitsCache;
+    [Scratch]
     private Tensor<T>? _probabilitiesCache;
 
     /// <summary>
@@ -63,18 +66,6 @@ public class TabDPTClassifier<T> : TabDPTBase<T>
     /// </summary>
     public int NumClasses => _numClasses;
 
-    /// <summary>
-    /// Gets the total number of trainable parameters.
-    /// </summary>
-    /// <summary>The final projection this variant adds to the shared backbone.</summary>
-    /// <remarks>
-    /// Was an override that added the head to the COUNT only. The base had no read or
-    /// restore path at all, so the head was counted and never checkpointed; declaring it
-    /// here puts it in all three surfaces at once.
-    /// </remarks>
-    protected override IEnumerable<IParameterSource<T>> GetExtraTrainableLayers()
-        => new IParameterSource<T>[] { _classificationHead };
-
     /// <summary>
     /// Initializes a new instance of the TabDPTClassifier class.
     /// </summary>
diff --git a/src/NeuralNetworks/Tabular/TabDPTNetwork.cs b/src/NeuralNetworks/Tabular/TabDPTNetwork.cs
index 147f7fbbb9..929fabcff0 100644
--- a/src/NeuralNetworks/Tabular/TabDPTNetwork.cs
+++ b/src/NeuralNetworks/Tabular/TabDPTNetwork.cs
@@ -59,7 +59,7 @@ namespace AiDotNet.NeuralNetworks.Tabular;
     "https://arxiv.org/abs/2410.18164",
     Year = 2024,
     Authors = "Junwei Ma, Valentin Thomas, Rasa Hosseinzadeh, Hamidreza Kamkari, Alex Lacoste, Keyvan Golestan, Guangwei Yu, Maksims Volkovs, Anthony L. Caterini")]
-public class TabDPTNetwork<T> : TabularNeuralNetworkBase<T>
+public partial class TabDPTNetwork<T> : TabularNeuralNetworkBase<T>
 {
     private readonly TabDPTOptions<T> _options;
 
@@ -229,52 +229,8 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_options.EmbeddingDimension);
-        writer.Write(_options.NumLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.FeedForwardMultiplier);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.MaxFeatures);
-        writer.Write(_options.ContextLength);
-        writer.Write(_options.UseLayerNorm);
-        writer.Write(_options.UsePreNorm);
-        writer.Write(_options.InitScale);
-        writer.Write(_options.UseFeatureAttention);
 
-        writer.Write(_options.OutputHeadDimensions.Length);
-        foreach (var dim in _options.OutputHeadDimensions)
-        {
-            writer.Write(dim);
-        }
-
-        if (_options.CategoricalCardinalities != null)
-        {
-            writer.Write(_options.CategoricalCardinalities.Length);
-            foreach (var card in _options.CategoricalCardinalities)
-            {
-                writer.Write(card);
-            }
-        }
-        else
-        {
-            writer.Write(0);
-        }
-    }
 
     /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-    }
 
-    /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new TabDPTNetwork<T>(
-            Architecture,
-            _options,
-            _optimizer,
-            _lossFunction);
-    }
 }
diff --git a/src/NeuralNetworks/Tabular/TabDPTRegression.cs b/src/NeuralNetworks/Tabular/TabDPTRegression.cs
index 1c2105da54..31269e4382 100644
--- a/src/NeuralNetworks/Tabular/TabDPTRegression.cs
+++ b/src/NeuralNetworks/Tabular/TabDPTRegression.cs
@@ -54,7 +54,9 @@ public class TabDPTRegression<T> : TabDPTBase<T>
     private readonly int _outputDimension;
     private readonly FullyConnectedLayer<T> _regressionHead;
 
+    [Scratch]
     private Tensor<T>? _backboneOutputCache;
+    [Scratch]
     private Tensor<T>? _predictionsCache;
 
     /// <summary>
@@ -62,18 +64,6 @@ public class TabDPTRegression<T> : TabDPTBase<T>
     /// </summary>
     public int OutputDimension => _outputDimension;
 
-    /// <summary>
-    /// Gets the total number of trainable parameters.
-    /// </summary>
-    /// <summary>The final projection this variant adds to the shared backbone.</summary>
-    /// <remarks>
-    /// Was an override that added the head to the COUNT only. The base had no read or
-    /// restore path at all, so the head was counted and never checkpointed; declaring it
-    /// here puts it in all three surfaces at once.
-    /// </remarks>
-    protected override IEnumerable<IParameterSource<T>> GetExtraTrainableLayers()
-        => new IParameterSource<T>[] { _regressionHead };
-
     /// <summary>
     /// Initializes a new instance of the TabDPTRegression class.
     /// </summary>
diff --git a/src/NeuralNetworks/Tabular/TabMBase.cs b/src/NeuralNetworks/Tabular/TabMBase.cs
index cf8590f410..440668cdb8 100644
--- a/src/NeuralNetworks/Tabular/TabMBase.cs
+++ b/src/NeuralNetworks/Tabular/TabMBase.cs
@@ -1,4 +1,5 @@
 using AiDotNet.Engines;
+using AiDotNet.Attributes;
 using AiDotNet.Models.Options;
 
 namespace AiDotNet.NeuralNetworks.Tabular;
@@ -37,7 +38,7 @@ namespace AiDotNet.NeuralNetworks.Tabular;
 /// </para>
 /// </remarks>
 /// <typeparam name="T">The numeric type used for calculations.</typeparam>
-public abstract class TabMBase<T>
+public abstract partial class TabMBase<T>
 {
     /// <summary>
     /// Numeric operations helper for type T.
@@ -60,14 +61,18 @@ public abstract class TabMBase<T>
     protected readonly int NumFeatures;
 
     // Feature embedding (optional)
+    [AiDotNet.Attributes.TrainableParameter]
     private readonly Tensor<T>? _featureEmbeddings;  // [numFeatures, embeddingDim]
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T>? _featureEmbeddingsGrad;
 
     // BatchEnsemble hidden layers
     private readonly List<BatchEnsembleLayer<T>> _hiddenLayers;
 
     // Cache for backward pass
+    [Scratch]
     private Tensor<T>? _embeddedInputCache;
+    [Scratch]
     private readonly List<Tensor<T>> _hiddenOutputsCache;
 
     /// <summary>
@@ -93,7 +98,7 @@ public abstract class TabMBase<T>
     /// all, so it cannot inherit that one.
     /// </remarks>
     protected virtual IEnumerable<ILayer<T>> GetExtraTrainableLayers()
-        => System.Linq.Enumerable.Empty<ILayer<T>>();
+        => AiDotNet.Models.Parameters.GeneratedParameterDiscovery.EnumerateDerivedLayers<T>(this, typeof(TabMBase<T>));
 
     /// <summary>
     /// Gets the total number of trainable parameters in the base model.
diff --git a/src/NeuralNetworks/Tabular/TabMClassifier.cs b/src/NeuralNetworks/Tabular/TabMClassifier.cs
index bd1b4ab9b5..fd9128c437 100644
--- a/src/NeuralNetworks/Tabular/TabMClassifier.cs
+++ b/src/NeuralNetworks/Tabular/TabMClassifier.cs
@@ -54,17 +54,15 @@ namespace AiDotNet.NeuralNetworks.Tabular;
     Authors = "Yury Gorishniy, Akim Kotelnikov, Artem Babenko")]
 public class TabMClassifier<T> : TabMBase<T>
 {
-
-    /// <inheritdoc />
-    /// <remarks>The task head. Everything else is the shared backbone, which the base folds ahead of it in every parameter surface.</remarks>
-    protected override IEnumerable<ILayer<T>> GetExtraTrainableLayers()
-        => new ILayer<T>[] { _classificationHead };
     private readonly int _numClasses;
     private readonly BatchEnsembleLayer<T> _classificationHead;
 
     // Cache for backward pass
+    [Scratch]
     private Tensor<T>? _backboneOutputCache;
+    [Scratch]
     private Tensor<T>? _logitsCache;
+    [Scratch]
     private Tensor<T>? _probabilitiesCache;
 
     /// <summary>
diff --git a/src/NeuralNetworks/Tabular/TabMNetwork.cs b/src/NeuralNetworks/Tabular/TabMNetwork.cs
index b56477850e..010671adb6 100644
--- a/src/NeuralNetworks/Tabular/TabMNetwork.cs
+++ b/src/NeuralNetworks/Tabular/TabMNetwork.cs
@@ -59,7 +59,7 @@ namespace AiDotNet.NeuralNetworks.Tabular;
     "https://arxiv.org/abs/2410.24210",
     Year = 2024,
     Authors = "Yury Gorishniy, Akim Kotelnikov, Artem Babenko")]
-public class TabMNetwork<T> : TabularNeuralNetworkBase<T>
+public partial class TabMNetwork<T> : TabularNeuralNetworkBase<T>
 {
     private readonly TabMOptions<T> _options;
 
@@ -203,40 +203,8 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_options.NumEnsembleMembers);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.UseLayerNorm);
-        writer.Write(_options.RankInitScale);
-        writer.Write(_options.UseBias);
-        writer.Write(_options.ActivationType);
-        writer.Write(_options.AverageEnsemble);
-        writer.Write(_options.UseFeatureEmbeddings);
-        writer.Write(_options.FeatureEmbeddingDimension);
-        writer.Write(_options.EnableGradientClipping);
-        writer.Write(_options.MaxGradientNorm);
-        writer.Write(_options.WeightDecay);
-
-        writer.Write(_options.HiddenDimensions.Length);
-        foreach (var dim in _options.HiddenDimensions)
-        {
-            writer.Write(dim);
-        }
-    }
 
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-    }
 
     /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new TabMNetwork<T>(
-            Architecture,
-            _options,
-            _optimizer,
-            _lossFunction);
-    }
+
 }
diff --git a/src/NeuralNetworks/Tabular/TabMRegression.cs b/src/NeuralNetworks/Tabular/TabMRegression.cs
index 100423b10d..98f4a86002 100644
--- a/src/NeuralNetworks/Tabular/TabMRegression.cs
+++ b/src/NeuralNetworks/Tabular/TabMRegression.cs
@@ -52,17 +52,15 @@ namespace AiDotNet.NeuralNetworks.Tabular;
     Authors = "Yury Gorishniy, Akim Kotelnikov, Artem Babenko")]
 public class TabMRegression<T> : TabMBase<T>
 {
-
-    /// <inheritdoc />
-    /// <remarks>The task head. Everything else is the shared backbone, which the base folds ahead of it in every parameter surface.</remarks>
-    protected override IEnumerable<ILayer<T>> GetExtraTrainableLayers()
-        => new ILayer<T>[] { _regressionHead };
     private readonly int _outputDimension;
     private readonly BatchEnsembleLayer<T> _regressionHead;
 
     // Cache for backward pass
+    [Scratch]
     private Tensor<T>? _backboneOutputCache;
+    [Scratch]
     private Tensor<T>? _predictionsCache;
+    [Scratch]
     private Tensor<T>? _memberPredictionsCache;
 
     /// <summary>
diff --git a/src/NeuralNetworks/Tabular/TabNetNetwork.cs b/src/NeuralNetworks/Tabular/TabNetNetwork.cs
index 299a16ba57..18891a9fd2 100644
--- a/src/NeuralNetworks/Tabular/TabNetNetwork.cs
+++ b/src/NeuralNetworks/Tabular/TabNetNetwork.cs
@@ -59,7 +59,7 @@ namespace AiDotNet.NeuralNetworks.Tabular;
     "https://arxiv.org/abs/1908.07442",
     Year = 2021,
     Authors = "Arik, S. O. & Pfister, T.")]
-public class TabNetNetwork<T> : TabularNeuralNetworkBase<T>
+public partial class TabNetNetwork<T> : TabularNeuralNetworkBase<T>
 {
     private readonly TabNetOptions<T> _options;
 
@@ -215,38 +215,8 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_options.NumDecisionSteps);
-        writer.Write(_options.FeatureDimension);
-        writer.Write(_options.OutputDimension);
-        writer.Write(_options.RelaxationFactor);
-        writer.Write(_options.SparsityCoefficient);
-        writer.Write(_options.BatchNormalizationMomentum);
-        writer.Write(_options.VirtualBatchSize);
-        writer.Write(_options.NumSharedLayers);
-        writer.Write(_options.NumStepSpecificLayers);
-        writer.Write(_options.Epsilon);
-        writer.Write(_options.EnablePreTraining);
-        writer.Write(_options.PreTrainingMaskingRatio);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.EnableGradientClipping);
-        writer.Write(_options.MaxGradientNorm);
-        writer.Write(_options.CategoricalEmbeddingDimension);
-    }
 
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-    }
 
     /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new TabNetNetwork<T>(
-            Architecture,
-            _options,
-            _optimizer,
-            _lossFunction);
-    }
+
 }
diff --git a/src/NeuralNetworks/Tabular/TabPFNBase.cs b/src/NeuralNetworks/Tabular/TabPFNBase.cs
index 9be7528639..52441ff14e 100644
--- a/src/NeuralNetworks/Tabular/TabPFNBase.cs
+++ b/src/NeuralNetworks/Tabular/TabPFNBase.cs
@@ -1,4 +1,5 @@
 using AiDotNet.ActivationFunctions;
+using AiDotNet.Attributes;
 using AiDotNet.Interfaces;
 using AiDotNet.LinearAlgebra;
 using System.Collections.Generic;
@@ -37,7 +38,7 @@ namespace AiDotNet.NeuralNetworks.Tabular;
 /// </para>
 /// </remarks>
 /// <typeparam name="T">The numeric type used for calculations.</typeparam>
-public abstract class TabPFNBase<T> : IParameterSource<T>
+public abstract partial class TabPFNBase<T> : IParameterSource<T>
 {
     /// <summary>
     /// Provides access to the hardware-accelerated tensor engine.
@@ -51,6 +52,7 @@ public abstract class TabPFNBase<T> : IParameterSource<T>
     // Input encoding
     private readonly FullyConnectedLayer<T> _featureEncoder;
     private readonly FullyConnectedLayer<T>[] _categoricalEncoders;
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T>? _positionalEncoding;
 
     // Transformer backbone
@@ -65,8 +67,11 @@ public abstract class TabPFNBase<T> : IParameterSource<T>
     private Tensor<T>? _contextLabels;
 
     // Cached values
+    [Scratch]
     private Tensor<T>? _encodedInputCache;
+    [Scratch]
     private Tensor<T>? _transformerOutputCache;
+    [Scratch]
     private Tensor<T>? _mlpOutputCache;
 
     /// <summary>
@@ -108,7 +113,7 @@ public abstract class TabPFNBase<T> : IParameterSource<T>
     /// </para>
     /// </remarks>
     protected virtual IEnumerable<ILayer<T>> GetExtraTrainableLayers()
-        => System.Linq.Enumerable.Empty<ILayer<T>>();
+        => AiDotNet.Models.Parameters.GeneratedParameterDiscovery.EnumerateDerivedLayers<T>(this, typeof(TabPFNBase<T>));
 
     /// <summary>
     /// The single ordered traversal of this model's parameter-bearing components.
@@ -544,7 +549,7 @@ public virtual void ResetState()
     /// <summary>
     /// TabPFN-specific transformer block with causal masking for in-context learning.
     /// </summary>
-    private sealed class TabPFNTransformerBlock<TBlock> : IParameterSource<TBlock>
+    private sealed partial class TabPFNTransformerBlock<TBlock> : IParameterSource<TBlock>
     {
         private static readonly INumericOperations<TBlock> NumOps = MathHelper.GetNumericOperations<TBlock>();
 
@@ -555,9 +560,13 @@ private sealed class TabPFNTransformerBlock<TBlock> : IParameterSource<TBlock>
         private readonly double _dropoutRate;
 
         // Attention weights
+        [AiDotNet.Attributes.TrainableParameter]
         private Tensor<TBlock> _queryWeights;
+        [AiDotNet.Attributes.TrainableParameter]
         private Tensor<TBlock> _keyWeights;
+        [AiDotNet.Attributes.TrainableParameter]
         private Tensor<TBlock> _valueWeights;
+        [AiDotNet.Attributes.TrainableParameter]
         private Tensor<TBlock> _outputWeights;
 
         // Attention gradients
@@ -575,7 +584,9 @@ private sealed class TabPFNTransformerBlock<TBlock> : IParameterSource<TBlock>
         private readonly LayerNormalizationLayer<TBlock> _norm2;
 
         // Cached values
+        [Scratch]
         private Tensor<TBlock>? _inputCache;
+        [Scratch]
         private Tensor<TBlock>? _attentionOutputCache;
 
         /// <summary>
diff --git a/src/NeuralNetworks/Tabular/TabPFNClassifier.cs b/src/NeuralNetworks/Tabular/TabPFNClassifier.cs
index d5fe5a818c..739a68a613 100644
--- a/src/NeuralNetworks/Tabular/TabPFNClassifier.cs
+++ b/src/NeuralNetworks/Tabular/TabPFNClassifier.cs
@@ -57,8 +57,11 @@ public class TabPFNClassifier<T> : TabPFNBase<T>
     private readonly int _numClasses;
     private readonly FullyConnectedLayer<T> _classificationHead;
 
+    [Scratch]
     private Tensor<T>? _backboneOutputCache;
+    [Scratch]
     private Tensor<T>? _logitsCache;
+    [Scratch]
     private Tensor<T>? _probabilitiesCache;
 
     /// <summary>
@@ -66,14 +69,6 @@ public class TabPFNClassifier<T> : TabPFNBase<T>
     /// </summary>
     public int NumClasses => _numClasses;
 
-    /// <summary>
-    /// Gets the total number of trainable parameters.
-    /// </summary>
-    /// <inheritdoc />
-    /// <remarks>The head, folded after the shared backbone by the base's single traversal.</remarks>
-    protected override IEnumerable<ILayer<T>> GetExtraTrainableLayers()
-        => new ILayer<T>[] { _classificationHead };
-
     /// <summary>
     /// Initializes a new instance of the TabPFNClassifier class.
     /// </summary>
diff --git a/src/NeuralNetworks/Tabular/TabPFNNetwork.cs b/src/NeuralNetworks/Tabular/TabPFNNetwork.cs
index 0f76b0390e..bb44e983af 100644
--- a/src/NeuralNetworks/Tabular/TabPFNNetwork.cs
+++ b/src/NeuralNetworks/Tabular/TabPFNNetwork.cs
@@ -61,7 +61,7 @@ namespace AiDotNet.NeuralNetworks.Tabular;
     "https://arxiv.org/abs/2207.01848",
     Year = 2023,
     Authors = "Noah Hollmann, Samuel Müller, Katharina Eggensperger, Frank Hutter")]
-public class TabPFNNetwork<T> : TabularNeuralNetworkBase<T>
+public partial class TabPFNNetwork<T> : TabularNeuralNetworkBase<T>
 {
     private readonly TabPFNOptions<T> _options;
 
@@ -231,54 +231,8 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_options.EmbeddingDimension);
-        writer.Write(_options.NumLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.FeedForwardMultiplier);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.MaxFeatures);
-        writer.Write(_options.MaxContextSamples);
-        writer.Write(_options.MaxClasses);
-        writer.Write(_options.UsePositionalEncoding);
-        writer.Write(_options.UsePreNorm);
-        writer.Write(_options.InitScale);
-        writer.Write(_options.UseEnsemble);
-        writer.Write(_options.NumEnsembles);
 
-        writer.Write(_options.OutputHeadDimensions.Length);
-        foreach (var dim in _options.OutputHeadDimensions)
-        {
-            writer.Write(dim);
-        }
-
-        if (_options.CategoricalCardinalities != null)
-        {
-            writer.Write(_options.CategoricalCardinalities.Length);
-            foreach (var card in _options.CategoricalCardinalities)
-            {
-                writer.Write(card);
-            }
-        }
-        else
-        {
-            writer.Write(0);
-        }
-    }
 
     /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-    }
 
-    /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new TabPFNNetwork<T>(
-            Architecture,
-            _options,
-            _optimizer,
-            _lossFunction);
-    }
 }
diff --git a/src/NeuralNetworks/Tabular/TabPFNRegression.cs b/src/NeuralNetworks/Tabular/TabPFNRegression.cs
index e51eff7041..c769c5d907 100644
--- a/src/NeuralNetworks/Tabular/TabPFNRegression.cs
+++ b/src/NeuralNetworks/Tabular/TabPFNRegression.cs
@@ -56,7 +56,9 @@ public class TabPFNRegression<T> : TabPFNBase<T>
     private readonly int _outputDimension;
     private readonly FullyConnectedLayer<T> _regressionHead;
 
+    [Scratch]
     private Tensor<T>? _backboneOutputCache;
+    [Scratch]
     private Tensor<T>? _predictionsCache;
 
     /// <summary>
@@ -64,14 +66,6 @@ public class TabPFNRegression<T> : TabPFNBase<T>
     /// </summary>
     public int OutputDimension => _outputDimension;
 
-    /// <summary>
-    /// Gets the total number of trainable parameters.
-    /// </summary>
-    /// <inheritdoc />
-    /// <remarks>The head, folded after the shared backbone by the base's single traversal.</remarks>
-    protected override IEnumerable<ILayer<T>> GetExtraTrainableLayers()
-        => new ILayer<T>[] { _regressionHead };
-
     /// <summary>
     /// Initializes a new instance of the TabPFNRegression class.
     /// </summary>
diff --git a/src/NeuralNetworks/Tabular/TabRBase.cs b/src/NeuralNetworks/Tabular/TabRBase.cs
index e80d915aa9..9215281cd9 100644
--- a/src/NeuralNetworks/Tabular/TabRBase.cs
+++ b/src/NeuralNetworks/Tabular/TabRBase.cs
@@ -1,4 +1,5 @@
 using AiDotNet.Models.Options;
+using AiDotNet.Attributes;
 using AiDotNet.Models.Parameters;
 using AiDotNet.Interfaces;
 using AiDotNet.NeuralNetworks.Layers;
@@ -36,7 +37,7 @@ namespace AiDotNet.NeuralNetworks.Tabular;
 /// </para>
 /// </remarks>
 /// <typeparam name="T">The numeric type used for calculations.</typeparam>
-public abstract class TabRBase<T> : IParameterSource<T>
+public abstract partial class TabRBase<T> : IParameterSource<T>
 {
     /// <summary>
     /// Provides access to the hardware-accelerated tensor engine.
@@ -63,7 +64,9 @@ public abstract class TabRBase<T> : IParameterSource<T>
     private readonly LayerNormalizationLayer<T>? _encoderNorm;
 
     // Retrieval index (stores training sample embeddings)
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T>? _indexEmbeddings;       // [numTrainSamples, embeddingDim]
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T>? _indexFeatures;         // [numTrainSamples, numFeatures]
     private int _numIndexedSamples;
 
@@ -78,10 +81,15 @@ public abstract class TabRBase<T> : IParameterSource<T>
     private readonly FullyConnectedLayer<T> _outputProjection;
 
     // Cache for backward pass
+    [Scratch]
     private Tensor<T>? _queryEmbeddingCache;
+    [Scratch]
     private Tensor<T>? _neighborEmbeddingsCache;
+    [Scratch]
     private Tensor<T>? _attentionWeightsCache;
+    [Scratch]
     private Tensor<T>? _contextCache;
+    [Scratch]
     private Matrix<int>? _neighborIndicesCache;
 
     /// <summary>
@@ -117,7 +125,7 @@ public abstract class TabRBase<T> : IParameterSource<T>
     /// all, so it cannot inherit that one.
     /// </remarks>
     protected virtual IEnumerable<ILayer<T>> GetExtraTrainableLayers()
-        => System.Linq.Enumerable.Empty<ILayer<T>>();
+        => GeneratedParameterDiscovery.EnumerateDerivedLayers<T>(this, typeof(TabRBase<T>));
 
     /// <summary>
     /// Gets the total number of trainable parameters.
diff --git a/src/NeuralNetworks/Tabular/TabRClassifier.cs b/src/NeuralNetworks/Tabular/TabRClassifier.cs
index 0351b26fb8..08fe61b679 100644
--- a/src/NeuralNetworks/Tabular/TabRClassifier.cs
+++ b/src/NeuralNetworks/Tabular/TabRClassifier.cs
@@ -52,17 +52,15 @@ namespace AiDotNet.NeuralNetworks.Tabular;
     Authors = "Yury Gorishniy, Ivan Rubachev, Nikolay Kartashev, Daniil Shlenskii, Akim Kotelnikov, Artem Babenko")]
 public class TabRClassifier<T> : TabRBase<T>
 {
-
-    /// <inheritdoc />
-    /// <remarks>The task head. Everything else is the shared backbone, which the base folds ahead of it in every parameter surface.</remarks>
-    protected override IEnumerable<ILayer<T>> GetExtraTrainableLayers()
-        => new ILayer<T>[] { _classificationHead };
     private readonly int _numClasses;
     private readonly FullyConnectedLayer<T> _classificationHead;
 
     // Cache for backward pass
+    [Scratch]
     private Tensor<T>? _backboneOutputCache;
+    [Scratch]
     private Tensor<T>? _logitsCache;
+    [Scratch]
     private Tensor<T>? _probabilitiesCache;
 
     /// <summary>
diff --git a/src/NeuralNetworks/Tabular/TabRNetwork.cs b/src/NeuralNetworks/Tabular/TabRNetwork.cs
index 40ad158a10..6d3057ad74 100644
--- a/src/NeuralNetworks/Tabular/TabRNetwork.cs
+++ b/src/NeuralNetworks/Tabular/TabRNetwork.cs
@@ -61,7 +61,7 @@ namespace AiDotNet.NeuralNetworks.Tabular;
     "https://arxiv.org/abs/2307.14338",
     Year = 2024,
     Authors = "Yury Gorishniy, Ivan Rubachev, Nikolay Kartashev, Daniil Shlenskii, Akim Kotelnikov, Artem Babenko")]
-public class TabRNetwork<T> : TabularNeuralNetworkBase<T>
+public partial class TabRNetwork<T> : TabularNeuralNetworkBase<T>
 {
     private readonly TabROptions<T> _options;
 
@@ -227,38 +227,8 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_options.NumNeighbors);
-        writer.Write(_options.EmbeddingDimension);
-        writer.Write(_options.NumLayers);
-        writer.Write(_options.NumAttentionHeads);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.IncludeNeighborTargets);
-        writer.Write(_options.RetrievalTemperature);
-        writer.Write(_options.NormalizeEmbeddings);
-        writer.Write(_options.NumContextLayers);
-        writer.Write(_options.UseLayerNorm);
-        writer.Write(_options.ActivationType);
-        writer.Write(_options.UseFiLM);
-        writer.Write(_options.FeedForwardMultiplier);
-        writer.Write(_options.EnableGradientClipping);
-        writer.Write(_options.MaxGradientNorm);
-        writer.Write(_options.WeightDecay);
-    }
 
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-    }
 
     /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new TabRNetwork<T>(
-            Architecture,
-            _options,
-            _optimizer,
-            _lossFunction);
-    }
+
 }
diff --git a/src/NeuralNetworks/Tabular/TabRRegression.cs b/src/NeuralNetworks/Tabular/TabRRegression.cs
index b9180f2c1e..a41e93ca95 100644
--- a/src/NeuralNetworks/Tabular/TabRRegression.cs
+++ b/src/NeuralNetworks/Tabular/TabRRegression.cs
@@ -55,16 +55,13 @@ namespace AiDotNet.NeuralNetworks.Tabular;
     Authors = "Yury Gorishniy, Ivan Rubachev, Nikolay Kartashev, Daniil Shlenskii, Akim Kotelnikov, Artem Babenko")]
 public class TabRRegression<T> : TabRBase<T>
 {
-
-    /// <inheritdoc />
-    /// <remarks>The task head. Everything else is the shared backbone, which the base folds ahead of it in every parameter surface.</remarks>
-    protected override IEnumerable<ILayer<T>> GetExtraTrainableLayers()
-        => new ILayer<T>[] { _regressionHead };
     private readonly int _outputDimension;
     private readonly FullyConnectedLayer<T> _regressionHead;
 
     // Cache for backward pass
+    [Scratch]
     private Tensor<T>? _backboneOutputCache;
+    [Scratch]
     private Tensor<T>? _predictionsCache;
 
     /// <summary>
diff --git a/src/NeuralNetworks/Tabular/TabTransformerBase.cs b/src/NeuralNetworks/Tabular/TabTransformerBase.cs
index a64e9f1973..07e6238f74 100644
--- a/src/NeuralNetworks/Tabular/TabTransformerBase.cs
+++ b/src/NeuralNetworks/Tabular/TabTransformerBase.cs
@@ -1,4 +1,5 @@
 using AiDotNet.Engines;
+using AiDotNet.Attributes;
 using System.Collections.Generic;
 using AiDotNet.Models.Parameters;
 using AiDotNet.LinearAlgebra;
@@ -40,7 +41,7 @@ namespace AiDotNet.NeuralNetworks.Tabular;
 /// </para>
 /// </remarks>
 /// <typeparam name="T">The numeric type used for calculations.</typeparam>
-public abstract class TabTransformerBase<T> : IParameterSource<T>
+public abstract partial class TabTransformerBase<T> : IParameterSource<T>
 {
     /// <summary>
     /// Numeric operations helper for type T.
@@ -72,7 +73,9 @@ public abstract class TabTransformerBase<T> : IParameterSource<T>
     private readonly List<Tensor<T>?> _categoricalEmbeddingsGrad;
 
     // Column embeddings (learned position for each categorical feature)
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T>? _columnEmbeddings;  // [numCat, embDim]
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T>? _columnEmbeddingsGrad;
 
     // Transformer encoder layers
@@ -85,10 +88,15 @@ public abstract class TabTransformerBase<T> : IParameterSource<T>
     private readonly List<FullyConnectedLayer<T>> _mlpLayers;
 
     // Cache for backward pass
+    [Scratch]
     private Tensor<T>? _numericalFeaturesCache;
+    [Scratch]
     private Matrix<int>? _categoricalIndicesCache;
+    [Scratch]
     private Tensor<T>? _embeddedCategoricalsCache;
+    [Scratch]
     private Tensor<T>? _transformedCategoricalsCache;
+    [Scratch]
     private Tensor<T>? _concatenatedCache;
 
     /// <summary>
@@ -111,7 +119,7 @@ public abstract class TabTransformerBase<T> : IParameterSource<T>
 
     /// <summary>Extra trainable layers a subclass contributes after the shared backbone.</summary>
     protected virtual IEnumerable<IParameterSource<T>> GetExtraTrainableLayers()
-        => System.Linq.Enumerable.Empty<IParameterSource<T>>();
+        => GeneratedParameterDiscovery.EnumerateDerivedSources<T>(this, typeof(TabTransformerBase<T>));
 
     /// <summary>The single ordered traversal of this model's parameter-bearing components.</summary>
     private ParameterComponentRegistry<T> ParameterRegistry
diff --git a/src/NeuralNetworks/Tabular/TabTransformerClassifier.cs b/src/NeuralNetworks/Tabular/TabTransformerClassifier.cs
index 7ee8bef595..31caf89db1 100644
--- a/src/NeuralNetworks/Tabular/TabTransformerClassifier.cs
+++ b/src/NeuralNetworks/Tabular/TabTransformerClassifier.cs
@@ -54,8 +54,11 @@ public class TabTransformerClassifier<T> : TabTransformerBase<T>
     private readonly FullyConnectedLayer<T> _classificationHead;
 
     // Cache for backward pass
+    [Scratch]
     private Tensor<T>? _backboneOutputCache;
+    [Scratch]
     private Tensor<T>? _logitsCache;
+    [Scratch]
     private Tensor<T>? _probabilitiesCache;
 
     /// <summary>
@@ -63,18 +66,6 @@ public class TabTransformerClassifier<T> : TabTransformerBase<T>
     /// </summary>
     public int NumClasses => _numClasses;
 
-    /// <summary>
-    /// Gets the total number of trainable parameters.
-    /// </summary>
-    /// <summary>The final projection this variant adds to the shared backbone.</summary>
-    /// <remarks>
-    /// Was an override that added the head to the COUNT only. The base had no read or
-    /// restore path at all, so the head was counted and never checkpointed; declaring it
-    /// here puts it in all three surfaces at once.
-    /// </remarks>
-    protected override IEnumerable<IParameterSource<T>> GetExtraTrainableLayers()
-        => new IParameterSource<T>[] { _classificationHead };
-
     /// <summary>
     /// Initializes a new instance of the TabTransformerClassifier class.
     /// </summary>
diff --git a/src/NeuralNetworks/Tabular/TabTransformerNetwork.cs b/src/NeuralNetworks/Tabular/TabTransformerNetwork.cs
index 703336bc25..aa3f8f976a 100644
--- a/src/NeuralNetworks/Tabular/TabTransformerNetwork.cs
+++ b/src/NeuralNetworks/Tabular/TabTransformerNetwork.cs
@@ -66,7 +66,7 @@ namespace AiDotNet.NeuralNetworks.Tabular;
     "https://arxiv.org/abs/2012.06678",
     Year = 2020,
     Authors = "Xin Huang, Ashish Khetan, Milan Cvitkovic, Zohar Karnin")]
-public class TabTransformerNetwork<T> : TabularNeuralNetworkBase<T>
+public partial class TabTransformerNetwork<T> : TabularNeuralNetworkBase<T>
 {
     private readonly TabTransformerOptions<T> _options;
 
@@ -415,65 +415,6 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_options.EmbeddingDimension);
-        writer.Write(_options.HiddenDimension);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.NumLayers);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.UseLayerNorm);
-        writer.Write(_options.UseColumnEmbedding);
-        writer.Write(_options.EmbeddingInitScale);
-        writer.Write(_options.FeedForwardMultiplier);
-
-        // Serialize MLPHiddenDimensions
-        writer.Write(_options.MLPHiddenDimensions.Length);
-        foreach (var dim in _options.MLPHiddenDimensions)
-        {
-            writer.Write(dim);
-        }
-
-        // Serialize CategoricalCardinalities if present
-        if (_options.CategoricalCardinalities != null)
-        {
-            writer.Write(_options.CategoricalCardinalities.Length);
-            foreach (var card in _options.CategoricalCardinalities)
-            {
-                writer.Write(card);
-            }
-        }
-        else
-        {
-            writer.Write(0);
-        }
-    }
-
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        // Options are reconstructed from serialized data
-        // Layers are handled by base class
-    }
-
-    /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        // Optimizers carry step counters and moment tensors keyed to the source model's
-        // parameters. Sharing one across a clone leaks training state and can also leave the
-        // optimizer bound to the source model. Recreate the same optimizer type from its
-        // configuration, then bind that fresh instance to the clone.
-        var freshOptimizer = CreateFreshOptimizer();
-        var clone = new TabTransformerNetwork<T>(
-            Architecture,
-            _options,
-            freshOptimizer,
-            _lossFunction);
-        freshOptimizer.SetModel(clone);
-        return clone;
-    }
-
     private IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>> CreateFreshOptimizer()
     {
         var optimizerType = _optimizer.GetType();
diff --git a/src/NeuralNetworks/Tabular/TabTransformerRegression.cs b/src/NeuralNetworks/Tabular/TabTransformerRegression.cs
index 87856a768b..71650cb2ec 100644
--- a/src/NeuralNetworks/Tabular/TabTransformerRegression.cs
+++ b/src/NeuralNetworks/Tabular/TabTransformerRegression.cs
@@ -54,7 +54,9 @@ public class TabTransformerRegression<T> : TabTransformerBase<T>
     private readonly FullyConnectedLayer<T> _regressionHead;
 
     // Cache for backward pass
+    [Scratch]
     private Tensor<T>? _backboneOutputCache;
+    [Scratch]
     private Tensor<T>? _predictionsCache;
 
     /// <summary>
@@ -62,18 +64,6 @@ public class TabTransformerRegression<T> : TabTransformerBase<T>
     /// </summary>
     public int OutputDimension => _outputDimension;
 
-    /// <summary>
-    /// Gets the total number of trainable parameters.
-    /// </summary>
-    /// <summary>The final projection this variant adds to the shared backbone.</summary>
-    /// <remarks>
-    /// Was an override that added the head to the COUNT only. The base had no read or
-    /// restore path at all, so the head was counted and never checkpointed; declaring it
-    /// here puts it in all three surfaces at once.
-    /// </remarks>
-    protected override IEnumerable<IParameterSource<T>> GetExtraTrainableLayers()
-        => new IParameterSource<T>[] { _regressionHead };
-
     /// <summary>
     /// Initializes a new instance of the TabTransformerRegression class.
     /// </summary>
diff --git a/src/NeuralNetworks/Tasks/Graph/GraphClassificationModel.cs b/src/NeuralNetworks/Tasks/Graph/GraphClassificationModel.cs
index 3e5631e7a4..b61ae7cb7b 100644
--- a/src/NeuralNetworks/Tasks/Graph/GraphClassificationModel.cs
+++ b/src/NeuralNetworks/Tasks/Graph/GraphClassificationModel.cs
@@ -92,7 +92,7 @@ namespace AiDotNet.NeuralNetworks.Tasks.Graph;
     "https://arxiv.org/abs/1609.02907",
     Year = 2017,
     Authors = "Thomas N. Kipf, Max Welling")]
-public class GraphClassificationModel<T> : GraphModelLayoutBase<T>
+public partial class GraphClassificationModel<T> : GraphModelLayoutBase<T>
 {
     private readonly ILossFunction<T> _lossFunction;
     private readonly IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>> _optimizer;
@@ -765,65 +765,5 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    /// <summary>
-    /// Serializes network-specific data to a binary writer.
-    /// </summary>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(InputFeatures);
-        writer.Write(NumClasses);
-        writer.Write(HiddenDim);
-        writer.Write(EmbeddingDim);
-        writer.Write(NumGnnLayers);
-        writer.Write(DropoutRate);
-        writer.Write((int)_poolingType);
-
-        SerializationHelper<T>.SerializeInterface(writer, _lossFunction);
-        SerializationHelper<T>.SerializeInterface(writer, _optimizer);
-    }
-
-    /// <summary>
-    /// Deserializes network-specific data from a binary reader.
-    /// </summary>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _ = reader.ReadInt32(); // InputFeatures
-        _ = reader.ReadInt32(); // NumClasses
-        _ = reader.ReadInt32(); // HiddenDim
-        _ = reader.ReadInt32(); // EmbeddingDim
-        _ = reader.ReadInt32(); // NumGnnLayers
-        _ = reader.ReadDouble(); // DropoutRate
-        _ = reader.ReadInt32(); // PoolingType
-
-        _ = DeserializationHelper.DeserializeInterface<ILossFunction<T>>(reader);
-        _ = DeserializationHelper.DeserializeInterface<IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>>(reader);
-    }
-
-    /// <summary>
-    /// Creates a new instance of this network type for cloning or deserialization.
-    /// </summary>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var clone = new GraphClassificationModel<T>(
-            architecture: Architecture,
-            hiddenDim: HiddenDim,
-            embeddingDim: EmbeddingDim,
-            numGnnLayers: NumGnnLayers,
-            dropoutRate: DropoutRate,
-            poolingType: _poolingType);
-        // Graph STATE is model state in this stateful-adjacency design, so a clone of a configured
-        // model must stay usable: carry the implicit-identity opt-in and any explicit adjacency.
-        if (_implicitIdentityWhenUnset)
-        {
-            clone.EnableImplicitIdentityAdjacency();
-        }
-        else if (_cachedAdjacencyMatrix is not null)
-        {
-            clone.SetAdjacencyMatrix(_cachedAdjacencyMatrix);
-        }
-
-        return clone;
-    }
-
     #endregion
 }
diff --git a/src/NeuralNetworks/Tasks/Graph/LinkPredictionModel.cs b/src/NeuralNetworks/Tasks/Graph/LinkPredictionModel.cs
index eb316a6c2b..6e6636b04b 100644
--- a/src/NeuralNetworks/Tasks/Graph/LinkPredictionModel.cs
+++ b/src/NeuralNetworks/Tasks/Graph/LinkPredictionModel.cs
@@ -1,4 +1,4 @@
-using AiDotNet.ActivationFunctions;
+using AiDotNet.ActivationFunctions;
 using AiDotNet.Attributes;
 using AiDotNet.Data.Structures;
 using AiDotNet.Enums;
@@ -89,12 +89,20 @@ namespace AiDotNet.NeuralNetworks.Tasks.Graph;
     "https://arxiv.org/abs/1611.07308",
     Year = 2016,
     Authors = "Thomas N. Kipf, Max Welling")]
-public class LinkPredictionModel<T> : GraphModelLayoutBase<T>
+public partial class LinkPredictionModel<T> : GraphModelLayoutBase<T>
 {
     private readonly ILossFunction<T> _lossFunction;
     private readonly IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>> _optimizer;
     private readonly LinkPredictionDecoder _decoderType;
-    [Buffer]
+    // [Scratch], matching GraphClassificationModel and NodeClassificationModel, which hold the
+    // identically named field for the identical purpose. As [Buffer] it was nullable with no
+    // initializer, which the generator reads as fit-produced and gives ParameterAvailability.Fit --
+    // so the registry refused to report parameters at all until the model was "fit", and the graph's
+    // own [numNodes, numNodes] width landed in GetParameters() while ParameterCount omitted it.
+    // Neither is true of this member: it caches the adjacency the CALLER supplied, and #1593 made
+    // supplying it the model's contract (the strict PyTorch-Geometric behaviour), so there is
+    // nothing here for a checkpoint to carry.
+    [Scratch]
     private Tensor<T>? _cachedAdjacencyMatrix;
     // Opt-in (EnableImplicitIdentityAdjacency): mirrors the GraphConvolutionalLayer
     // implicitIdentityWhenUnset ctor flag at the model level. Default is strict (throw on a
@@ -750,63 +758,5 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    /// <summary>
-    /// Serializes network-specific data to a binary writer.
-    /// </summary>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(InputFeatures);
-        writer.Write(EmbeddingDim);
-        writer.Write(HiddenDim);
-        writer.Write(NumLayers);
-        writer.Write(DropoutRate);
-        writer.Write((int)_decoderType);
-
-        SerializationHelper<T>.SerializeInterface(writer, _lossFunction);
-        SerializationHelper<T>.SerializeInterface(writer, _optimizer);
-    }
-
-    /// <summary>
-    /// Deserializes network-specific data from a binary reader.
-    /// </summary>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _ = reader.ReadInt32(); // InputFeatures
-        _ = reader.ReadInt32(); // EmbeddingDim
-        _ = reader.ReadInt32(); // HiddenDim
-        _ = reader.ReadInt32(); // NumLayers
-        _ = reader.ReadDouble(); // DropoutRate
-        _ = reader.ReadInt32(); // DecoderType
-
-        _ = DeserializationHelper.DeserializeInterface<ILossFunction<T>>(reader);
-        _ = DeserializationHelper.DeserializeInterface<IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>>(reader);
-    }
-
-    /// <summary>
-    /// Creates a new instance of this network type for cloning or deserialization.
-    /// </summary>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var clone = new LinkPredictionModel<T>(
-            architecture: Architecture,
-            hiddenDim: HiddenDim,
-            embeddingDim: EmbeddingDim,
-            numLayers: NumLayers,
-            dropoutRate: DropoutRate,
-            decoderType: _decoderType);
-        // Graph STATE is model state in this stateful-adjacency design, so a clone of a configured
-        // model must stay usable: carry the implicit-identity opt-in and any explicit adjacency.
-        if (_implicitIdentityWhenUnset)
-        {
-            clone.EnableImplicitIdentityAdjacency();
-        }
-        else if (_cachedAdjacencyMatrix is not null)
-        {
-            clone.SetAdjacencyMatrix(_cachedAdjacencyMatrix);
-        }
-
-        return clone;
-    }
-
     #endregion
 }
diff --git a/src/NeuralNetworks/Tasks/Graph/NodeClassificationModel.cs b/src/NeuralNetworks/Tasks/Graph/NodeClassificationModel.cs
index 27abe4804a..7c93589a99 100644
--- a/src/NeuralNetworks/Tasks/Graph/NodeClassificationModel.cs
+++ b/src/NeuralNetworks/Tasks/Graph/NodeClassificationModel.cs
@@ -1,4 +1,4 @@
-using AiDotNet.ActivationFunctions;
+using AiDotNet.ActivationFunctions;
 using AiDotNet.Attributes;
 using AiDotNet.Data.Structures;
 using AiDotNet.Enums;
@@ -82,7 +82,7 @@ namespace AiDotNet.NeuralNetworks.Tasks.Graph;
     "https://arxiv.org/abs/1609.02907",
     Year = 2017,
     Authors = "Thomas N. Kipf, Max Welling")]
-public class NodeClassificationModel<T> : GraphModelLayoutBase<T>, AiDotNet.Interfaces.IGraphInferenceModel<T>
+public partial class NodeClassificationModel<T> : GraphModelLayoutBase<T>, AiDotNet.Interfaces.IGraphInferenceModel<T>
 {
     private readonly ILossFunction<T> _lossFunction;
     private readonly IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>> _optimizer;
@@ -620,59 +620,5 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    /// <summary>
-    /// Serializes network-specific data to a binary writer.
-    /// </summary>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(InputFeatures);
-        writer.Write(NumClasses);
-        writer.Write(HiddenDim);
-        writer.Write(NumLayers);
-        writer.Write(DropoutRate);
-
-        SerializationHelper<T>.SerializeInterface(writer, _lossFunction);
-        SerializationHelper<T>.SerializeInterface(writer, _optimizer);
-    }
-
-    /// <summary>
-    /// Deserializes network-specific data from a binary reader.
-    /// </summary>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _ = reader.ReadInt32(); // InputFeatures
-        _ = reader.ReadInt32(); // NumClasses
-        _ = reader.ReadInt32(); // HiddenDim
-        _ = reader.ReadInt32(); // NumLayers
-        _ = reader.ReadDouble(); // DropoutRate
-
-        _ = DeserializationHelper.DeserializeInterface<ILossFunction<T>>(reader);
-        _ = DeserializationHelper.DeserializeInterface<IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>>(reader);
-    }
-
-    /// <summary>
-    /// Creates a new instance of this network type for cloning or deserialization.
-    /// </summary>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var clone = new NodeClassificationModel<T>(
-            architecture: Architecture,
-            hiddenDim: HiddenDim,
-            numLayers: NumLayers,
-            dropoutRate: DropoutRate);
-        // Graph STATE is model state in this stateful-adjacency design, so a clone of a configured
-        // model must stay usable: carry the implicit-identity opt-in and any explicit adjacency.
-        if (_implicitIdentityWhenUnset)
-        {
-            clone.EnableImplicitIdentityAdjacency();
-        }
-        else if (_cachedAdjacencyMatrix is not null)
-        {
-            clone.SetAdjacencyMatrix(_cachedAdjacencyMatrix);
-        }
-
-        return clone;
-    }
-
     #endregion
 }
diff --git a/src/NeuralNetworks/Transformer.cs b/src/NeuralNetworks/Transformer.cs
index 21d85f4acd..138ebf8db4 100644
--- a/src/NeuralNetworks/Transformer.cs
+++ b/src/NeuralNetworks/Transformer.cs
@@ -56,7 +56,7 @@ namespace AiDotNet.NeuralNetworks;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Attention Is All You Need", "https://arxiv.org/abs/1706.03762", Year = 2017, Authors = "Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N. Gomez, Lukasz Kaiser, Illia Polosukhin")]
-public class Transformer<T> : TokenLanguageModelLayoutBase<T>, IAuxiliaryLossLayer<T>, AiDotNet.Interfaces.ILanguageModel<T>
+public partial class Transformer<T> : TokenLanguageModelLayoutBase<T>, IAuxiliaryLossLayer<T>, AiDotNet.Interfaces.ILanguageModel<T>
 {
     private readonly TransformerOptions _options;
 
@@ -1081,26 +1081,7 @@ public override ModelMetadata<T> GetModelMetadata()
     /// This allows you to save your trained Transformer and use it again later without having to retrain it.
     /// </para>
     /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        // Write Transformer-specific architecture details
-        writer.Write(_transformerArchitecture.NumHeads);
-        writer.Write(_transformerArchitecture.NumEncoderLayers);
-        writer.Write(_transformerArchitecture.NumDecoderLayers);
-        writer.Write(_transformerArchitecture.MaxSequenceLength);
-        writer.Write(_transformerArchitecture.VocabularySize);
-        writer.Write(Convert.ToDouble(_transformerArchitecture.DropoutRate));
-
-        // Write loss function and optimizer types
-        SerializationHelper<T>.SerializeInterface(writer, LossFunction);
-        SerializationHelper<T>.SerializeInterface(writer, _optimizer);
-
-        // Opt-in logits head marker (trailing so older readers that stop after the optimizer are
-        // unaffected; new readers guard the read on stream position). Records whether the final
-        // Softmax layer was dropped for CrossEntropyWithLogitsLoss training so inference re-applies
-        // softmax after deserialize.
-        writer.Write(_headEmitsLogits);
-    }
+
 
     /// <summary>
     /// Deserializes Transformer-specific data from a binary stream.
@@ -1120,80 +1101,5 @@ protected override void SerializeNetworkSpecificData(BinaryWriter writer)
     /// This allows you to load a previously trained Transformer and use it immediately without having to retrain it.
     /// </para>
     /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        // Read Transformer-specific architecture details
-        int numHeads = reader.ReadInt32();
-        int numEncoderLayers = reader.ReadInt32();
-        int numDecoderLayers = reader.ReadInt32();
-        int maxSequenceLength = reader.ReadInt32();
-        int vocabularySize = reader.ReadInt32();
-        T dropoutRate = NumOps.FromDouble(reader.ReadDouble());
-
-        // Read and reconstruct loss function and optimizer (must match serialization order).
-        LossFunction = DeserializationHelper.DeserializeInterface<ILossFunction<T>>(reader)
-            ?? LossFunction;
-
-        // Match the constructor's default-optimizer policy: Vaswani 2017
-        // recipe (β₁=0.9, β₂=0.98, ε=1e-9, lr=1e-3 + NoamSchedule). Stale
-        // state-dicts written before this fix didn't serialize their
-        // optimizer; reading null-optimizer back must produce the SAME
-        // optimizer the ctor would, otherwise the deserialized model silently
-        // regresses to non-converging vanilla SGD or a different (non-paper)
-        // Adam configuration.
-        // Recipe construction routes through the same helper as the ctor
-        // and the SetBaseTrainOptimizer null-reset path so a future
-        // Vaswani-recipe change can't silently miss the deserialization
-        // fallback. Closes #1270.xEmP.
-        _optimizer = DeserializationHelper.DeserializeInterface<IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>>(reader)
-            ?? CreateDefaultVaswaniOptimizer();
-
-        // Keep the base optimizer slot in sync after deserialization too
-        // — Train() now resolves through GetOrCreateBaseOptimizer, so a
-        // load-then-resume-training flow needs the deserialized optimizer
-        // installed on both sides.
-        SetBaseTrainOptimizer(_optimizer);
 
-        // Opt-in logits-head marker (trailing field). Guard on stream position so a state-dict
-        // written before this field existed (stream ends after the optimizer) reads back with the
-        // default false (standard softmax head) instead of throwing EndOfStream.
-        if (reader.BaseStream.Position < reader.BaseStream.Length)
-            _headEmitsLogits = reader.ReadBoolean();
-    }
-
-    /// <summary>
-    /// Creates a new instance of the Transformer with the same architecture and configuration.
-    /// </summary>
-    /// <returns>A new instance of the Transformer with the same configuration as the current instance.</returns>
-    /// <remarks>
-    /// <para>
-    /// This method creates a new Transformer neural network with the same architecture, loss function,
-    /// and optimizer as the current instance. The new instance has freshly initialized parameters,
-    /// making it useful for creating separate instances with identical configurations or for
-    /// resetting a network while preserving its structure.
-    /// </para>
-    /// <para><b>For Beginners:</b> This creates a brand new Transformer with the same setup.
-    /// 
-    /// Think of it like creating a blueprint copy:
-    /// - It has the same architecture (number of layers, attention heads, etc.)
-    /// - It uses the same loss function to measure performance
-    /// - It uses the same optimizer to learn from data
-    /// - But it starts with fresh parameters (weights and biases)
-    /// 
-    /// This is useful when you want to:
-    /// - Start over with a fresh network but keep the same design
-    /// - Create multiple networks with identical settings for comparison
-    /// - Reset a network to its initial state
-    /// 
-    /// The new Transformer will need to be trained from scratch, as it doesn't
-    /// inherit any of the learned knowledge from the original.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new Transformer<T>(
-            _transformerArchitecture,
-            LossFunction,
-            _optimizer);
-    }
 }
diff --git a/src/NeuralNetworks/TransformerEmbeddingNetwork.cs b/src/NeuralNetworks/TransformerEmbeddingNetwork.cs
index 88ba669e99..9736052b83 100644
--- a/src/NeuralNetworks/TransformerEmbeddingNetwork.cs
+++ b/src/NeuralNetworks/TransformerEmbeddingNetwork.cs
@@ -49,7 +49,7 @@ namespace AiDotNet.NeuralNetworks
     [ModelComplexity(ModelComplexity.High)]
     [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
     [ResearchPaper("Attention Is All You Need", "https://arxiv.org/abs/1706.03762")]
-    public class TransformerEmbeddingNetwork<T> : TextEmbeddingModelLayoutBase<T>, IEmbeddingModel<T>
+    public partial class TransformerEmbeddingNetwork<T> : TextEmbeddingModelLayoutBase<T>, IEmbeddingModel<T>
     {
         private readonly TransformerEmbeddingOptions _options;
 
@@ -463,23 +463,6 @@ public override void Train(Tensor<T> input, Tensor<T> expectedOutput)
 
     // UpdateParameters re-sliced the flat vector across Layers by hand -- the base walks
     // exactly the same enumeration, so this said nothing the base does not already say.
-        /// <inheritdoc/>
-        protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-        {
-            return new TransformerEmbeddingNetwork<T>(
-                Architecture,
-                _tokenizer,
-                _optimizer,
-                _vocabSize,
-                _embeddingDimension,
-                _maxSequenceLength,
-                _numLayers,
-                _numHeads,
-                _feedForwardDim,
-                _poolingStrategy,
-                _lossFunction,
-                Convert.ToDouble(MaxGradNorm));
-        }
 
         /// <summary>
         /// Returns metadata about the transformer network configuration.
@@ -502,28 +485,10 @@ public override ModelMetadata<T> GetModelMetadata()
         }
 
         /// <inheritdoc/>
-        protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-        {
-            writer.Write(_vocabSize);
-            writer.Write(_embeddingDimension);
-            writer.Write(_maxSequenceLength);
-            writer.Write(_numLayers);
-            writer.Write(_numHeads);
-            writer.Write(_feedForwardDim);
-            writer.Write((int)_poolingStrategy);
-        }
+
 
         /// <inheritdoc/>
-        protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-        {
-            _vocabSize = reader.ReadInt32();
-            _embeddingDimension = reader.ReadInt32();
-            _maxSequenceLength = reader.ReadInt32();
-            _numLayers = reader.ReadInt32();
-            _numHeads = reader.ReadInt32();
-            _feedForwardDim = reader.ReadInt32();
-            _poolingStrategy = (PoolingStrategy)reader.ReadInt32();
-        }
+
 
         #endregion
 
diff --git a/src/NeuralNetworks/UNet3D.cs b/src/NeuralNetworks/UNet3D.cs
index 40c9480d9f..84be1060f7 100644
--- a/src/NeuralNetworks/UNet3D.cs
+++ b/src/NeuralNetworks/UNet3D.cs
@@ -48,7 +48,7 @@ namespace AiDotNet.NeuralNetworks;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("3D U-Net: Learning Dense Volumetric Segmentation from Sparse Annotation", "https://arxiv.org/abs/1606.06650", Year = 2016, Authors = "Ozgun Cicek, Ahmed Abdulkadir, Soeren S. Lienkamp, Thomas Brox, Olaf Ronneberger")]
-public class UNet3D<T> : VolumetricModelLayoutBase<T>
+public partial class UNet3D<T> : VolumetricModelLayoutBase<T>
 {
     private readonly UNet3DOptions _options;
 
@@ -302,41 +302,12 @@ public override ModelMetadata<T> GetModelMetadata()
     /// </summary>
     /// <param name="writer">The binary writer to serialize to.</param>
     /// <inheritdoc />
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(VoxelResolution);
-        writer.Write(NumEncoderBlocks);
-        writer.Write(BaseFilters);
-        writer.Write(NumClasses);
-    }
+
 
     /// <summary>
     /// Deserializes network-specific data from a binary stream.
     /// </summary>
     /// <param name="reader">The binary reader to deserialize from.</param>
     /// <inheritdoc />
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        VoxelResolution = reader.ReadInt32();
-        NumEncoderBlocks = reader.ReadInt32();
-        BaseFilters = reader.ReadInt32();
-        NumClasses = reader.ReadInt32();
-    }
 
-    /// <summary>
-    /// Creates a new instance of this model type for cloning purposes.
-    /// </summary>
-    /// <returns>A new <see cref="UNet3D{T}"/> instance with the same configuration.</returns>
-    /// <inheritdoc />
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new UNet3D<T>(
-            Architecture,
-            VoxelResolution,
-            NumEncoderBlocks,
-            BaseFilters,
-            _optimizer,
-            _lossFunction,
-            MaxGradNormValue);
-    }
 }
diff --git a/src/NeuralNetworks/UnifiedMultimodalNetwork.cs b/src/NeuralNetworks/UnifiedMultimodalNetwork.cs
index 4a852cf74e..6f6ffcc78d 100644
--- a/src/NeuralNetworks/UnifiedMultimodalNetwork.cs
+++ b/src/NeuralNetworks/UnifiedMultimodalNetwork.cs
@@ -1214,47 +1214,5 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_embeddingDimension);
-        writer.Write(_maxSequenceLength);
-        writer.Write(_numTransformerLayers);
-    }
-
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        int embeddingDimension = reader.ReadInt32();
-        int maxSequenceLength = reader.ReadInt32();
-        int numTransformerLayers = reader.ReadInt32();
-
-        if (embeddingDimension != _embeddingDimension ||
-            maxSequenceLength != _maxSequenceLength ||
-            numTransformerLayers != _numTransformerLayers)
-        {
-            throw new InvalidDataException(
-                "Serialized UnifiedMultimodalNetwork configuration does not match the target instance.");
-        }
-
-        BindLayerFieldsFromLayers();
-    }
-
-    /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new UnifiedMultimodalNetwork<T>(
-            Architecture,
-            _embeddingDimension,
-            _maxSequenceLength,
-            _numTransformerLayers);
-    }
-
-    /// <inheritdoc/>
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy()
-    {
-        return base.DeepCopy();
-    }
-
     #endregion
 }
diff --git a/src/NeuralNetworks/VGGNetwork.cs b/src/NeuralNetworks/VGGNetwork.cs
index 940855b350..d3c3f93a36 100644
--- a/src/NeuralNetworks/VGGNetwork.cs
+++ b/src/NeuralNetworks/VGGNetwork.cs
@@ -61,7 +61,7 @@ namespace AiDotNet.NeuralNetworks;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Very Deep Convolutional Networks for Large-Scale Image Recognition", "https://arxiv.org/abs/1409.1556", Year = 2015, Authors = "Karen Simonyan, Andrew Zisserman")]
-public class VGGNetwork<T> : ImageClassifierModelLayoutBase<T>
+public partial class VGGNetwork<T> : ImageClassifierModelLayoutBase<T>
 {
     private readonly VGGOptions _options;
 
@@ -465,84 +465,10 @@ public override ModelMetadata<T> GetModelMetadata()
     /// <summary>
     /// Serializes VGG network-specific data to a binary writer.
     /// </summary>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        // Write VGG configuration
-        writer.Write((int)_configuration.Variant);
-        writer.Write(_configuration.NumClasses);
-        writer.Write(_configuration.InputHeight);
-        writer.Write(_configuration.InputWidth);
-        writer.Write(_configuration.InputChannels);
-        writer.Write(_configuration.DropoutRate);
-        writer.Write(_configuration.IncludeClassifier);
-        writer.Write(_configuration.UseAutodiff);
-    }
+
 
     /// <summary>
     /// Deserializes VGG network-specific data from a binary reader.
     /// </summary>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        // Read VGG configuration and validate compatibility
-        var variant = (VGGVariant)reader.ReadInt32();
-        var numClasses = reader.ReadInt32();
-        var inputHeight = reader.ReadInt32();
-        var inputWidth = reader.ReadInt32();
-        var inputChannels = reader.ReadInt32();
-        var dropoutRate = reader.ReadDouble();
-        var includeClassifier = reader.ReadBoolean();
-        _ = reader.ReadBoolean(); // useAutodiff - read but not validated (runtime setting)
-
-        // Validate loaded configuration matches current
-        if (variant != _configuration.Variant)
-        {
-            throw new InvalidOperationException(
-                $"Serialized VGG variant ({variant}) does not match current configuration ({_configuration.Variant}).");
-        }
-
-        if (numClasses != _configuration.NumClasses)
-        {
-            throw new InvalidOperationException(
-                $"Serialized number of classes ({numClasses}) does not match current configuration ({_configuration.NumClasses}).");
-        }
-
-        if (inputHeight != _configuration.InputHeight || inputWidth != _configuration.InputWidth)
-        {
-            throw new InvalidOperationException(
-                $"Serialized input dimensions ({inputHeight}x{inputWidth}) do not match current configuration ({_configuration.InputHeight}x{_configuration.InputWidth}).");
-        }
-
-        if (inputChannels != _configuration.InputChannels)
-        {
-            throw new InvalidOperationException(
-                $"Serialized input channels ({inputChannels}) does not match current configuration ({_configuration.InputChannels}).");
-        }
 
-        if (Math.Abs(dropoutRate - _configuration.DropoutRate) > 1e-6)
-        {
-            throw new InvalidOperationException(
-                $"Serialized dropout rate ({dropoutRate}) does not match current configuration ({_configuration.DropoutRate}).");
-        }
-
-        if (includeClassifier != _configuration.IncludeClassifier)
-        {
-            throw new InvalidOperationException(
-                $"Serialized includeClassifier ({includeClassifier}) does not match current configuration ({_configuration.IncludeClassifier}).");
-        }
-    }
-
-    /// <summary>
-    /// Creates a new instance of the VGG network model.
-    /// </summary>
-    /// <returns>A new instance of the VGG network with the same configuration.</returns>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new VGGNetwork<T>(
-            Architecture,
-            _configuration,
-            _optimizer,
-            _lossFunction,
-            Convert.ToDouble(MaxGradNorm)
-        );
-    }
 }
diff --git a/src/NeuralNetworks/VariationalAutoencoder.cs b/src/NeuralNetworks/VariationalAutoencoder.cs
index d11fb62910..863117e1f1 100644
--- a/src/NeuralNetworks/VariationalAutoencoder.cs
+++ b/src/NeuralNetworks/VariationalAutoencoder.cs
@@ -830,70 +830,7 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    /// <summary>
-    /// Serializes network-specific data for the Variational Autoencoder.
-    /// </summary>
-    /// <param name="writer">The BinaryWriter to write the data to.</param>
-    /// <remarks>
-    /// This method writes the specific configuration and state of the VAE to a binary stream.
-    /// It includes network-specific parameters that are essential for later reconstruction of the network.
-    /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(LatentSize);
-        SerializationHelper<T>.SerializeInterface(writer, _optimizer);
-    }
 
-    /// <summary>
-    /// Deserializes network-specific data for the Variational Autoencoder.
-    /// </summary>
-    /// <param name="reader">The BinaryReader to read the data from.</param>
-    /// <remarks>
-    /// This method reads the specific configuration and state of the VAE from a binary stream.
-    /// It reconstructs the network-specific parameters to match the state of the network when it was serialized.
-    /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        LatentSize = reader.ReadInt32();
-        _optimizer = DeserializationHelper.DeserializeInterface<IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>>(reader) ?? new AdamOptimizer<T, Tensor<T>, Tensor<T>>(this);
-    }
 
-    /// <summary>
-    /// Creates a new instance of the Variational Autoencoder with the same architecture and configuration.
-    /// </summary>
-    /// <returns>A new instance of the Variational Autoencoder with the same configuration as the current instance.</returns>
-    /// <remarks>
-    /// <para>
-    /// This method creates a new Variational Autoencoder with the same architecture, latent size,
-    /// optimizer, loss function, and gradient clipping settings as the current instance. The new
-    /// instance has freshly initialized parameters, making it useful for creating separate instances
-    /// with identical configurations or for resetting the network while preserving its structure.
-    /// </para>
-    /// <para><b>For Beginners:</b> This creates a brand new VAE with the same setup as the current one.
-    /// 
-    /// Think of it like creating a copy of your VAE's blueprint:
-    /// - It has the same overall structure
-    /// - It uses the same latent size (compression level)
-    /// - It has the same optimizer (learning method)
-    /// - It uses the same loss function (way of measuring performance)
-    /// - But it starts with fresh parameters (internal values)
-    /// 
-    /// This is useful when you want to:
-    /// - Start over with a fresh network but keep the same design
-    /// - Create multiple networks with identical settings for comparison
-    /// - Reset a network to its initial state
-    /// 
-    /// The new VAE will need to be trained from scratch, as it doesn't inherit any
-    /// of the learned knowledge from the original network.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new VariationalAutoencoder<T>(
-            Architecture,
-            LatentSize,
-            _optimizer,
-            LossFunction,
-            Convert.ToDouble(MaxGradNorm));
-    }
+
 }
diff --git a/src/NeuralNetworks/VideoCLIPNeuralNetwork.cs b/src/NeuralNetworks/VideoCLIPNeuralNetwork.cs
index 6ce6446fd1..1900046245 100644
--- a/src/NeuralNetworks/VideoCLIPNeuralNetwork.cs
+++ b/src/NeuralNetworks/VideoCLIPNeuralNetwork.cs
@@ -86,8 +86,11 @@ public partial class VideoCLIPNeuralNetwork<T> : MultimodalModelLayoutBase<T>, I
     private readonly List<ILayer<T>> _temporalEncoderLayers = [];
     private readonly List<ILayer<T>> _textEncoderLayers = [];
     private readonly List<ILayer<T>> _projectionLayers = [];
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T>? _visionClsToken;
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T>? _visionPositionalEmbeddings;
+    [Scratch]
     private Tensor<T>? _temporalPositionalEmbeddings;
     private Tensor<T>? _textPositionalEmbeddings;
     private ILayer<T>? _patchEmbedding;
@@ -97,6 +100,7 @@ public partial class VideoCLIPNeuralNetwork<T> : MultimodalModelLayoutBase<T>, I
     private ILayer<T>? _captionHead;
 
     // Gradient checkpointing: cached frames from the last forward pass for backward recomputation
+    [Scratch]
     private List<Tensor<T>>? _cachedTrainingFrames;
 
 
@@ -1571,58 +1575,6 @@ public override void Train(Tensor<T> input, Tensor<T> expectedOutput)
         }
     }
 
-    /// <summary>
-    /// Declares the CLS token and the three positional embedding tables, which live outside
-    /// <see cref="NeuralNetworkBase{T}.Layers"/>.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// Declared in the order the deleted GetParameters concatenated them: vision CLS token, vision
-    /// positional embeddings, temporal positional embeddings, text positional embeddings.
-    /// </para>
-    /// <para>
-    /// This replaces 220 lines: ParameterCount, GetParameters, SetParameters, UpdateParameters and
-    /// SIX private helpers built only to serve them -- AppendLayerListParameters,
-    /// AppendSingleLayerParameters, AppendMatrixParameters and their Update counterparts. Every one
-    /// of those walked the same towers and tables the base already walks, each maintaining its own
-    /// running offset, and any of them could have been edited without the others.
-    /// </para>
-    /// <para>
-    /// The towers need no declaration and must not get one: <c>_frameEncoderLayers</c>,
-    /// <c>_temporalEncoderLayers</c>, <c>_textEncoderLayers</c> and the five projections are all
-    /// filled FROM <c>Layers</c> (<c>Layers[idx++]</c>), so they are typed views of layers the base
-    /// walk already reaches, and declaring them would double-count.
-    /// </para>
-    /// <para>
-    /// The tables became <c>Tensor&lt;T&gt;</c> because a <c>Matrix&lt;T&gt;</c> is invisible to the
-    /// trainable-parameter walk -- the reason these surfaces had to be hand-written at all. The
-    /// forward path, the initializer and the serializer took matrices only to serve these four
-    /// fields and now take tensors; nothing else called them.
-    /// </para>
-    /// </remarks>
-    protected override IEnumerable<Tensor<T>> GetExtraTrainableTensors()
-    {
-        if (_visionClsToken is not null)
-        {
-            yield return _visionClsToken;
-        }
-
-        if (_visionPositionalEmbeddings is not null)
-        {
-            yield return _visionPositionalEmbeddings;
-        }
-
-        if (_temporalPositionalEmbeddings is not null)
-        {
-            yield return _temporalPositionalEmbeddings;
-        }
-
-        if (_textPositionalEmbeddings is not null)
-        {
-            yield return _textPositionalEmbeddings;
-        }
-    }
-
     /// <inheritdoc/>
     public override ModelMetadata<T> GetModelMetadata()
     {
@@ -1649,91 +1601,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_embeddingDimension);
-        writer.Write(_maxSequenceLength);
-        writer.Write(_imageSize);
-        writer.Write(_visionHiddenDim);
-        writer.Write(_textHiddenDim);
-        writer.Write(_numFrameEncoderLayers);
-        writer.Write(_numTemporalLayers);
-        writer.Write(_numTextLayers);
-        writer.Write(_numHeads);
-        writer.Write(_patchSize);
-        writer.Write(_vocabularySize);
-        writer.Write(_numFrames);
-        writer.Write(_frameRate);
-        writer.Write((int)_temporalAggregation);
-        writer.Write(_useNativeMode);
-
-        // Serialize positional embeddings and CLS token
-        SerializeMatrix(writer, _visionClsToken);
-        SerializeMatrix(writer, _visionPositionalEmbeddings);
-        SerializeMatrix(writer, _temporalPositionalEmbeddings);
-        SerializeMatrix(writer, _textPositionalEmbeddings);
-    }
-
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _ = reader.ReadInt32(); // embeddingDim (already set by CreateNewInstance)
-        _ = reader.ReadInt32(); // maxSeqLen
-        _ = reader.ReadInt32(); // imageSize
-        _ = reader.ReadInt32(); // visionHiddenDim
-        _ = reader.ReadInt32(); // textHiddenDim
-        _ = reader.ReadInt32(); // numFrameEncoderLayers
-        _ = reader.ReadInt32(); // numTemporalLayers
-        _ = reader.ReadInt32(); // numTextLayers
-        _ = reader.ReadInt32(); // numHeads
-        _ = reader.ReadInt32(); // patchSize
-        _ = reader.ReadInt32(); // vocabularySize
-        _ = reader.ReadInt32(); // numFrames
-        _ = reader.ReadDouble(); // frameRate
-        _temporalAggregation = (TemporalAggregationType)reader.ReadInt32();
-        _useNativeMode = reader.ReadBoolean();
-
-        // Restore positional embeddings and CLS token
-        _visionClsToken = DeserializeMatrix(reader);
-        _visionPositionalEmbeddings = DeserializeMatrix(reader);
-        _temporalPositionalEmbeddings = DeserializeMatrix(reader);
-        _textPositionalEmbeddings = DeserializeMatrix(reader);
-
-        // Re-distribute deserialized layers to internal sub-lists.
-        // Base class Deserialize() cleared and recreated all layers, so the internal
-        // references (_patchEmbedding, _frameEncoderLayers, etc.) are now stale.
-        _frameEncoderLayers.Clear();
-        _temporalEncoderLayers.Clear();
-        _textEncoderLayers.Clear();
-        _projectionLayers.Clear();
-
-        int expectedLayers = 1 + _numFrameEncoderLayers + _numTemporalLayers + 1 + 1 + _numTextLayers + 1 + 1;
-        if (Layers.Count < expectedLayers)
-        {
-            throw new InvalidOperationException(
-                $"Deserialized {Layers.Count} layers but VideoCLIP requires {expectedLayers} " +
-                $"(1 patch + {_numFrameEncoderLayers} frame + {_numTemporalLayers} temporal + " +
-                $"1 proj + 1 embed + {_numTextLayers} text + 1 proj + 1 caption).");
-        }
-
-        int idx = 0;
-        _patchEmbedding = Layers[idx++];
-
-        for (int i = 0; i < _numFrameEncoderLayers; i++)
-            _frameEncoderLayers.Add(Layers[idx++]);
 
-        for (int i = 0; i < _numTemporalLayers; i++)
-            _temporalEncoderLayers.Add(Layers[idx++]);
 
-        _videoProjection = Layers[idx++];
-        _textTokenEmbedding = Layers[idx++];
+    /// <inheritdoc/>
 
-        for (int i = 0; i < _numTextLayers; i++)
-            _textEncoderLayers.Add(Layers[idx++]);
-
-        _textProjection = Layers[idx++];
-        _captionHead = Layers[idx++];
-    }
 
     private static void SerializeMatrix(BinaryWriter writer, Tensor<T>? matrix)
     {
@@ -1765,46 +1636,6 @@ private static void SerializeMatrix(BinaryWriter writer, Tensor<T>? matrix)
         return matrix;
     }
 
-    /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new VideoCLIPNeuralNetwork<T>(
-            Architecture,
-            _imageSize,
-            channels: 3,
-            _patchSize,
-            _vocabularySize,
-            _maxSequenceLength,
-            _embeddingDimension,
-            _visionHiddenDim,
-            _textHiddenDim,
-            _numFrameEncoderLayers,
-            _numTemporalLayers,
-            _numTextLayers,
-            _numHeads,
-            _numFrames,
-            _frameRate,
-            _temporalAggregation,
-            // Carry the configured tokenizer and loss function into the clone. Without them the
-            // clone falls back to the constructor defaults — most critically
-            // lossFunction => CrossEntropyWithLogitsLoss, which is wrong for a unit-norm embedding
-            // output: it routes the embedding through softmax and computes class-CE against a
-            // continuous target, plateauing at a ~136 baseline regardless of training. A clone must
-            // be functionally identical to its source, so a paper-faithful CosineSimilarityLoss +
-            // Adam(5e-5, β=0.9/0.98) configuration would otherwise be silently lost on Clone().
-            tokenizer: _tokenizer,
-            // Give the clone its OWN optimizer carrying the same configuration, NOT the source's
-            // instance: AdamOptimizer is stateful (moment/step buffers) and constructed bound to a
-            // model, so sharing it would leak optimizer state into the clone and keep the clone's
-            // optimizer pointed at the source model. Rebuild from the captured options (model-
-            // unbound) so the clone trains with the same hyperparameters but fresh state. Falls back
-            // to the constructor's default optimizer if the source's options aren't Adam-shaped.
-            optimizer: _optimizer.GetOptions() is AdamOptimizerOptions<T, Tensor<T>, Tensor<T>> adamOptions
-                ? new AdamOptimizer<T, Tensor<T>, Tensor<T>>(null, adamOptions)
-                : null,
-            lossFunction: _lossFunction);
-    }
-
     /// <inheritdoc/>
     protected override void Dispose(bool disposing)
     {
diff --git a/src/NeuralNetworks/VisionMambaModel.cs b/src/NeuralNetworks/VisionMambaModel.cs
index 44604f4958..07cf4ef004 100644
--- a/src/NeuralNetworks/VisionMambaModel.cs
+++ b/src/NeuralNetworks/VisionMambaModel.cs
@@ -96,13 +96,19 @@ public partial class VisionMambaModel<T> : ImageClassifierModelLayoutBase<T>
     private readonly VisionScanPattern _scanPattern;
 
     // Patch embedding weights (model-level state, not in Layers)
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _patchProjectionWeights;
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _patchProjectionBias;
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _positionalEmbedding;
 
     // Final normalization and classification head
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _finalNormGamma;
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _classifierWeights;
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _classifierBias;
 
     /// <inheritdoc />
@@ -371,39 +377,9 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_imageHeight);
-        writer.Write(_imageWidth);
-        writer.Write(_patchSize);
-        writer.Write(_channels);
-        writer.Write(_modelDimension);
-        writer.Write(_numLayers);
-        writer.Write(_numClasses);
-        writer.Write(_stateDimension);
-        writer.Write((int)_scanPattern);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _ = reader.ReadInt32();
-        _ = reader.ReadInt32();
-        _ = reader.ReadInt32();
-        _ = reader.ReadInt32();
-        _ = reader.ReadInt32();
-        _ = reader.ReadInt32();
-        _ = reader.ReadInt32();
-        _ = reader.ReadInt32();
-        _ = reader.ReadInt32();
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new VisionMambaModel<T>(
-            Architecture, _imageHeight, _imageWidth, _patchSize, _channels,
-            _modelDimension, _numLayers, _numClasses, _stateDimension,
-            _scanPattern, LossFunction, _options);
-    }
+
 
     #endregion
 
diff --git a/src/NeuralNetworks/VisionTransformer.cs b/src/NeuralNetworks/VisionTransformer.cs
index 972e1b17ca..6b50e494b4 100644
--- a/src/NeuralNetworks/VisionTransformer.cs
+++ b/src/NeuralNetworks/VisionTransformer.cs
@@ -113,6 +113,7 @@ public partial class VisionTransformer<T> : ImageClassifierModelLayoutBase<T>
     /// froze the cls token even though the public parameter surface still
     /// counted it as trainable.
     /// </summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _clsToken;
 
     /// <summary>
@@ -120,6 +121,7 @@ public partial class VisionTransformer<T> : ImageClassifierModelLayoutBase<T>
     /// Stored as Tensor&lt;T&gt; for the same gradient-flow reason as
     /// <see cref="_clsToken"/>.
     /// </summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _positionalEmbeddings;
 
     /// <summary>
@@ -580,203 +582,5 @@ public override ModelMetadata<T> GetModelMetadata()
         };
         return metadata;
     }
-
-    /// <summary>
-    /// Serializes Vision Transformer-specific data.
-    /// </summary>
-    /// <param name="writer">The binary writer to write data to.</param>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_imageHeight);
-        writer.Write(_imageWidth);
-        writer.Write(_channels);
-        writer.Write(_patchSize);
-        writer.Write(_numClasses);
-        writer.Write(_hiddenDim);
-        writer.Write(_numLayers);
-        writer.Write(_numHeads);
-        writer.Write(_mlpDim);
-
-        for (int i = 0; i < _clsToken.Length; i++)
-        {
-            writer.Write(Convert.ToDouble(_clsToken[i]));
-        }
-
-        for (int i = 0; i < _positionalEmbeddings.Shape[0]; i++)
-        {
-            for (int j = 0; j < _positionalEmbeddings.Shape[1]; j++)
-            {
-                writer.Write(Convert.ToDouble(_positionalEmbeddings[i, j]));
-            }
-        }
-    }
-
-    /// <summary>
-    /// Deserializes Vision Transformer-specific data.
-    /// </summary>
-    /// <param name="reader">The binary reader to read data from.</param>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        int imageHeight = reader.ReadInt32();
-        int imageWidth = reader.ReadInt32();
-        int channels = reader.ReadInt32();
-        int patchSize = reader.ReadInt32();
-        int numClasses = reader.ReadInt32();
-        int hiddenDim = reader.ReadInt32();
-        int numLayers = reader.ReadInt32();
-        int numHeads = reader.ReadInt32();
-        int mlpDim = reader.ReadInt32();
-
-        if (imageHeight != _imageHeight || imageWidth != _imageWidth ||
-            channels != _channels || patchSize != _patchSize ||
-            numClasses != _numClasses || hiddenDim != _hiddenDim ||
-            numLayers != _numLayers || numHeads != _numHeads ||
-            mlpDim != _mlpDim)
-        {
-            throw new InvalidOperationException(
-                $"Serialized model configuration does not match current instance. " +
-                $"Expected: {_imageHeight}x{_imageWidth}x{_channels}, patch={_patchSize}, " +
-                $"classes={_numClasses}, hidden={_hiddenDim}, layers={_numLayers}, " +
-                $"heads={_numHeads}, mlp={_mlpDim}. " +
-                $"Got: {imageHeight}x{imageWidth}x{channels}, patch={patchSize}, " +
-                $"classes={numClasses}, hidden={hiddenDim}, layers={numLayers}, " +
-                $"heads={numHeads}, mlp={mlpDim}.");
-        }
-
-        for (int i = 0; i < _clsToken.Length; i++)
-        {
-            _clsToken[i] = NumOps.FromDouble(reader.ReadDouble());
-        }
-
-        for (int i = 0; i < _positionalEmbeddings.Shape[0]; i++)
-        {
-            for (int j = 0; j < _positionalEmbeddings.Shape[1]; j++)
-            {
-                _positionalEmbeddings[i, j] = NumOps.FromDouble(reader.ReadDouble());
-            }
-        }
-    }
-
-    /// <summary>
-    /// Creates a new instance of the Vision Transformer.
-    /// </summary>
-    /// <returns>A new Vision Transformer instance with the same configuration.</returns>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new VisionTransformer<T>(
-            Architecture,
-            _imageHeight,
-            _imageWidth,
-            _channels,
-            _patchSize,
-            _numClasses,
-            _hiddenDim,
-            _numLayers,
-            _numHeads,
-            _mlpDim,
-            LossFunction);
-    }
-
-    /// <summary>
-    /// Clone via fresh-construct + UpdateParameters rather than the default
-    /// serialize/deserialize roundtrip. The serialize path drives the
-    /// patch-embedding / transformer / classification-head layers through
-    /// DeserializationHelper.CreateLayerFromType, which leaves their
-    /// persistent-tensor registration in a slightly different memory layout
-    /// than LayerHelper.CreateVisionTransformerLayers — the resulting clone
-    /// is parameter-equivalent but its forward output drifts from the source
-    /// by ~1e-2 (the issue #1221 class flagged in
-    /// Clone_AfterTraining_ShouldPreserveLearnedWeights). Going through the
-    /// fresh-construct + UpdateParameters path keeps both networks identical
-    /// down to bit-exactness.
-    /// </summary>
-    public override IFullModel<T, Tensor<T>, Tensor<T>> Clone()
-    {
-        var newViT = new VisionTransformer<T>(
-            Architecture,
-            _imageHeight,
-            _imageWidth,
-            _channels,
-            _patchSize,
-            _numClasses,
-            _hiddenDim,
-            _numLayers,
-            _numHeads,
-            _mlpDim,
-            LossFunction);
-
-        // Lazy ViT layers (PatchEmbedding, TransformerEncoder) defer weight
-        // allocation until the first forward pass. Before that, their
-        // ParameterCount is 0 and the network's total ParameterCount excludes
-        // them — UpdateParameters would then receive a vector sized only for
-        // cls token + positional embeddings + classification head and refuse
-        // to distribute the remaining encoder/MLP weights. Run a single
-        // probe Predict to resolve every lazy layer before copying params.
-        //
-        // Probe failures (OOM, missing engine backend, real shape regressions)
-        // would silently leave newViT with unresolved layers and
-        // ParameterCount mismatched against the source. The post-probe
-        // length-equality check below catches that mismatch and throws so
-        // the caller doesn't end up with a model that randomly drops the
-        // source's trained weights — earlier swallow-everything behaviour
-        // hid OOM and shape-validation regressions.
-        var probe = new Tensor<T>(new[] { 1, _channels, _imageHeight, _imageWidth });
-        Exception? probeFailure = null;
-        try
-        {
-            newViT.Predict(probe);
-        }
-        catch (Exception ex) when (ex is ArgumentException or InvalidOperationException)
-        {
-            // Tolerate the narrow class of "input shape disagrees with the
-            // freshly-constructed lazy layer chain" errors that genuinely
-            // mean the probe couldn't run — the length-check below will
-            // surface it as a clean mismatch rather than a model with the
-            // source's data dropped. Capture the exception to chain it
-            // into the diagnostic if the length check trips.
-            probeFailure = ex;
-        }
-
-        var allParams = GetParameters();
-        if (allParams.Length == 0)
-        {
-            return newViT;
-        }
-        if (allParams.Length != newViT.ParameterCount)
-        {
-            throw new InvalidOperationException(
-                $"VisionTransformer.Clone could not resolve the new instance's lazy layers " +
-                $"(source has {allParams.Length} parameters, clone has {newViT.ParameterCount}). " +
-                $"This typically means the probe Predict failed before all lazy weights were " +
-                $"allocated — the clone would otherwise silently lose the source's trained " +
-                $"weights, so the bug is surfaced here instead.",
-                probeFailure);
-        }
-        newViT.UpdateParameters(allParams);
-        return newViT;
-    }
-
-    /// <summary>
-    /// Surfaces <see cref="_clsToken"/> and <see cref="_positionalEmbeddings"/>
-    /// to the tape training path. These tensors are referenced directly in
-    /// <see cref="Predict"/> via tape-tracked <c>Engine.Reshape</c>, so the
-    /// gradient tape DOES record gradients for them — but the optimizer's
-    /// parameter-collection path scans <c>Layers</c> only, which would leave
-    /// them frozen at their initial values forever. Yielding them here lets
-    /// the optimizer's <c>Step</c> see them in <c>trainableParams</c> and
-    /// apply gradient updates.
-    /// </summary>
-    /// <remarks>
-    /// This complements the existing layout-faithful
-    /// <see cref="GetParameters"/> / <see cref="UpdateParameters"/> overrides:
-    /// those handle bulk save/load via the public parameter Vector, while
-    /// this hook handles the tape-training optimizer step. Both are
-    /// load-bearing for full-fidelity ViT training.
-    /// </remarks>
-    protected override IEnumerable<Tensor<T>> GetExtraTrainableTensors()
-    {
-        yield return _clsToken;
-        yield return _positionalEmbeddings;
-    }
 }
 
diff --git a/src/NeuralNetworks/VoxelCNN.cs b/src/NeuralNetworks/VoxelCNN.cs
index fc8a30de03..5a667c16ff 100644
--- a/src/NeuralNetworks/VoxelCNN.cs
+++ b/src/NeuralNetworks/VoxelCNN.cs
@@ -44,7 +44,7 @@ namespace AiDotNet.NeuralNetworks;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
     [ResearchPaper("3D ShapeNets: A Deep Representation for Volumetric Shapes", "https://arxiv.org/abs/1406.5670")]
-public class VoxelCNN<T> : VolumetricModelLayoutBase<T>
+public partial class VoxelCNN<T> : VolumetricModelLayoutBase<T>
 {
     private readonly VoxelCNNOptions _options;
 
@@ -349,39 +349,12 @@ public override ModelMetadata<T> GetModelMetadata()
     /// </summary>
     /// <param name="writer">The binary writer to serialize to.</param>
     /// <inheritdoc />
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(VoxelResolution);
-        writer.Write(NumConvBlocks);
-        writer.Write(BaseFilters);
-    }
+
 
     /// <summary>
     /// Deserializes network-specific data from a binary stream.
     /// </summary>
     /// <param name="reader">The binary reader to deserialize from.</param>
     /// <inheritdoc />
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        VoxelResolution = reader.ReadInt32();
-        NumConvBlocks = reader.ReadInt32();
-        BaseFilters = reader.ReadInt32();
-    }
 
-    /// <summary>
-    /// Creates a new instance of this model type for cloning purposes.
-    /// </summary>
-    /// <returns>A new <see cref="VoxelCNN{T}"/> instance with the same configuration.</returns>
-    /// <inheritdoc />
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new VoxelCNN<T>(
-            Architecture,
-            VoxelResolution,
-            NumConvBlocks,
-            BaseFilters,
-            _optimizer,
-            _lossFunction,
-            MaxGradNormValue);
-    }
 }
diff --git a/src/NeuralNetworks/WGAN.cs b/src/NeuralNetworks/WGAN.cs
index 42f397abd1..000cc33c72 100644
--- a/src/NeuralNetworks/WGAN.cs
+++ b/src/NeuralNetworks/WGAN.cs
@@ -646,68 +646,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_weightClipValue);
-        writer.Write(_criticIterations);
-
-        // Serialize loss histories
-        writer.Write(_generatorLosses.Count);
-        foreach (var loss in _generatorLosses)
-            writer.Write(NumOps.ToDouble(loss));
-
-        writer.Write(_criticLosses.Count);
-        foreach (var loss in _criticLosses)
-            writer.Write(NumOps.ToDouble(loss));
 
-        var generatorBytes = Generator.Serialize();
-        writer.Write(generatorBytes.Length);
-        writer.Write(generatorBytes);
-
-        var criticBytes = Critic.Serialize();
-        writer.Write(criticBytes.Length);
-        writer.Write(criticBytes);
-    }
 
     /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _weightClipValue = reader.ReadDouble();
-        _criticIterations = reader.ReadInt32();
-
-        // Deserialize loss histories
-        _generatorLosses.Clear();
-        int genLossCount = reader.ReadInt32();
-        for (int i = 0; i < genLossCount; i++)
-            _generatorLosses.Add(NumOps.FromDouble(reader.ReadDouble()));
-
-        _criticLosses.Clear();
-        int criticLossCount = reader.ReadInt32();
-        for (int i = 0; i < criticLossCount; i++)
-            _criticLosses.Add(NumOps.FromDouble(reader.ReadDouble()));
-
-        int generatorDataLength = reader.ReadInt32();
-        byte[] generatorData = reader.ReadBytes(generatorDataLength);
-        Generator.Deserialize(generatorData);
-
-        int criticDataLength = reader.ReadInt32();
-        byte[] criticData = reader.ReadBytes(criticDataLength);
-        Critic.Deserialize(criticData);
-    }
 
-    /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new WGAN<T>(
-            Generator.Architecture,
-            Critic.Architecture,
-            Architecture.InputType,
-            null, // Use default optimizer
-            null, // Use default optimizer
-            _lossFunction,
-            _weightClipValue,
-            _criticIterations);
-    }
 
     // The layer streams this model holds outside Layers are discovered by ModelParameterGenerator and surfaced automatically; the hand-written hook that used to sit here was an override wearing a different name.
 }
diff --git a/src/NeuralNetworks/WGANGP.cs b/src/NeuralNetworks/WGANGP.cs
index f934485ba5..a90a2d2274 100644
--- a/src/NeuralNetworks/WGANGP.cs
+++ b/src/NeuralNetworks/WGANGP.cs
@@ -1029,71 +1029,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_gradientPenaltyCoefficient);
-        writer.Write(_criticIterations);
-
-        // Serialize loss histories
-        writer.Write(_generatorLosses.Count);
-        foreach (var loss in _generatorLosses)
-            writer.Write(NumOps.ToDouble(loss));
-
-        writer.Write(_criticLosses.Count);
-        foreach (var loss in _criticLosses)
-            writer.Write(NumOps.ToDouble(loss));
-
-        // Serialize networks
-        var generatorBytes = Generator.Serialize();
-        writer.Write(generatorBytes.Length);
-        writer.Write(generatorBytes);
-
-        var criticBytes = Critic.Serialize();
-        writer.Write(criticBytes.Length);
-        writer.Write(criticBytes);
-    }
 
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _gradientPenaltyCoefficient = reader.ReadDouble();
-        _criticIterations = reader.ReadInt32();
-
-        // Deserialize loss histories
-        _generatorLosses.Clear();
-        int genLossCount = reader.ReadInt32();
-        for (int i = 0; i < genLossCount; i++)
-            _generatorLosses.Add(NumOps.FromDouble(reader.ReadDouble()));
-
-        _criticLosses.Clear();
-        int criticLossCount = reader.ReadInt32();
-        for (int i = 0; i < criticLossCount; i++)
-            _criticLosses.Add(NumOps.FromDouble(reader.ReadDouble()));
-
-        // Deserialize networks
-        int generatorDataLength = reader.ReadInt32();
-        byte[] generatorData = reader.ReadBytes(generatorDataLength);
-        Generator.Deserialize(generatorData);
-
-        int criticDataLength = reader.ReadInt32();
-        byte[] criticData = reader.ReadBytes(criticDataLength);
-        Critic.Deserialize(criticData);
-    }
 
     /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new WGANGP<T>(
-            Generator.Architecture,
-            Critic.Architecture,
-            Architecture.InputType,
-            null, // Use default optimizer
-            null, // Use default optimizer
-            _lossFunction,
-            _gradientPenaltyCoefficient,
-            _criticIterations,
-            new WGANGPOptions(_options));
-    }
+
 
     // UpdateParameters split the vector between Generator and Critic. Both sub-networks' layers are
     // added to Layers in that same order (Layers.AddRange(Generator.Layers) then
diff --git a/src/NeuralNetworks/Word2Vec.cs b/src/NeuralNetworks/Word2Vec.cs
index 0462e751d1..939beeb362 100644
--- a/src/NeuralNetworks/Word2Vec.cs
+++ b/src/NeuralNetworks/Word2Vec.cs
@@ -56,7 +56,7 @@ namespace AiDotNet.NeuralNetworks
     [ModelComplexity(ModelComplexity.Low)]
     [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
     [ResearchPaper("Efficient Estimation of Word Representations in Vector Space", "https://arxiv.org/abs/1301.3781", Year = 2013, Authors = "Tomas Mikolov, Kai Chen, Greg Corrado, Jeffrey Dean")]
-    public class Word2Vec<T> : TextEmbeddingModelLayoutBase<T>, IEmbeddingModel<T>
+    public partial class Word2Vec<T> : TextEmbeddingModelLayoutBase<T>, IEmbeddingModel<T>
     {
         private readonly Word2VecOptions _options;
 
@@ -438,22 +438,6 @@ public Task<Matrix<T>> EmbedBatchAsync(IEnumerable<string> texts)
             return Task.FromResult(EmbedBatch(texts));
         }
 
-        /// <inheritdoc/>
-        protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-        {
-            return new Word2Vec<T>(
-                Architecture,
-                _tokenizer,
-                null, // Fresh optimizer for new instance
-                _vocabSize,
-                _embeddingDimension,
-                _windowSize,
-                _maxTokens,
-                _type,
-                _lossFunction,
-                Convert.ToDouble(MaxGradNorm));
-        }
-
         /// <summary>
         /// Retrieves detailed metadata about the Word2Vec model.
         /// </summary>
@@ -480,24 +464,10 @@ public override ModelMetadata<T> GetModelMetadata()
         }
 
         /// <inheritdoc/>
-        protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-        {
-            writer.Write(_vocabSize);
-            writer.Write(_embeddingDimension);
-            writer.Write(_windowSize);
-            writer.Write(_maxTokens);
-            writer.Write((int)_type);
-        }
+
 
         /// <inheritdoc/>
-        protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-        {
-            _vocabSize = reader.ReadInt32();
-            _embeddingDimension = reader.ReadInt32();
-            _windowSize = reader.ReadInt32();
-            _maxTokens = reader.ReadInt32();
-            _type = (Word2VecType)reader.ReadInt32();
-        }
+
 
         #endregion
     }
diff --git a/src/NeuralNetworks/XLSTMLanguageModel.cs b/src/NeuralNetworks/XLSTMLanguageModel.cs
index fd3ba936b5..f723b58d44 100644
--- a/src/NeuralNetworks/XLSTMLanguageModel.cs
+++ b/src/NeuralNetworks/XLSTMLanguageModel.cs
@@ -38,7 +38,7 @@ namespace AiDotNet.NeuralNetworks;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("xLSTM: Extended Long Short-Term Memory", "https://arxiv.org/abs/2405.04517", Year = 2024, Authors = "Maximilian Beck, Korbinian Poppel, Markus Spanring, Andreas Auer, Oleksandra Prudnikova, Michael Kopp, Gunter Klambauer, Johannes Brandstetter, Sepp Hochreiter")]
-public class XLSTMLanguageModel<T> : TokenLanguageModelLayoutBase<T>
+public partial class XLSTMLanguageModel<T> : TokenLanguageModelLayoutBase<T>
 {
     private readonly XLSTMOptions _options;
     private readonly int _vocabSize;
@@ -169,30 +169,9 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_vocabSize);
-        writer.Write(_modelDimension);
-        writer.Write(_numLayers);
-        writer.Write(_numHeads);
-        writer.Write(_maxSeqLength);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _ = reader.ReadInt32();
-        _ = reader.ReadInt32();
-        _ = reader.ReadInt32();
-        _ = reader.ReadInt32();
-        _ = reader.ReadInt32();
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new XLSTMLanguageModel<T>(
-            Architecture, _vocabSize, _modelDimension, _numLayers, _numHeads,
-            _maxSeqLength, LossFunction, _options);
-    }
+
 
     #endregion
 }
diff --git a/src/NeuralNetworks/Zamba2LanguageModel.cs b/src/NeuralNetworks/Zamba2LanguageModel.cs
index dfd7e3e436..5a785f5481 100644
--- a/src/NeuralNetworks/Zamba2LanguageModel.cs
+++ b/src/NeuralNetworks/Zamba2LanguageModel.cs
@@ -39,7 +39,7 @@ namespace AiDotNet.NeuralNetworks;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("The Zamba2 Suite: Technical Report", "https://arxiv.org/abs/2411.15242", Year = 2024, Authors = "Paolo Glorioso, Quentin Anthony, Yury Tokpanov, Anna Golubeva, Vasudev Shyam, James Whittington, Jonathan Pilault, Beren Millidge")]
-public class Zamba2LanguageModel<T> : TokenLanguageModelLayoutBase<T>
+public partial class Zamba2LanguageModel<T> : TokenLanguageModelLayoutBase<T>
 {
     private readonly Zamba2Options _options;
     private readonly int _vocabSize;
@@ -152,34 +152,9 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_vocabSize);
-        writer.Write(_modelDimension);
-        writer.Write(_numLayers);
-        writer.Write(_stateDimension);
-        writer.Write(_numHeads);
-        writer.Write(_attentionInterval);
-        writer.Write(_maxSeqLength);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _ = reader.ReadInt32();
-        _ = reader.ReadInt32();
-        _ = reader.ReadInt32();
-        _ = reader.ReadInt32();
-        _ = reader.ReadInt32();
-        _ = reader.ReadInt32();
-        _ = reader.ReadInt32();
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new Zamba2LanguageModel<T>(
-            Architecture, _vocabSize, _modelDimension, _numLayers, _stateDimension,
-            _numHeads, _attentionInterval, _maxSeqLength, LossFunction, _options);
-    }
+
 
     #endregion
 }
diff --git a/src/NeuralNetworks/ZambaLanguageModel.cs b/src/NeuralNetworks/ZambaLanguageModel.cs
index 59c8e06cbc..939a391baf 100644
--- a/src/NeuralNetworks/ZambaLanguageModel.cs
+++ b/src/NeuralNetworks/ZambaLanguageModel.cs
@@ -39,7 +39,7 @@ namespace AiDotNet.NeuralNetworks;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Zamba: A Compact 7B SSM Hybrid Model", "https://arxiv.org/abs/2405.16712", Year = 2024, Authors = "Paolo Glorioso, Quentin Anthony, Yury Tokpanov, James Whittington, Jonathan Pilault, Adam Ibrahim, Beren Millidge")]
-public class ZambaLanguageModel<T> : TokenLanguageModelLayoutBase<T>
+public partial class ZambaLanguageModel<T> : TokenLanguageModelLayoutBase<T>
 {
     private readonly ZambaOptions _options;
     private readonly int _vocabSize;
@@ -148,32 +148,9 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_vocabSize);
-        writer.Write(_modelDimension);
-        writer.Write(_numLayers);
-        writer.Write(_stateDimension);
-        writer.Write(_attentionInterval);
-        writer.Write(_maxSeqLength);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _ = reader.ReadInt32();
-        _ = reader.ReadInt32();
-        _ = reader.ReadInt32();
-        _ = reader.ReadInt32();
-        _ = reader.ReadInt32();
-        _ = reader.ReadInt32();
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new ZambaLanguageModel<T>(
-            Architecture, _vocabSize, _modelDimension, _numLayers, _stateDimension,
-            _attentionInterval, _maxSeqLength, LossFunction, _options);
-    }
+
 
     #endregion
 }
diff --git a/src/NeuralRadianceFields/Models/GaussianSplatting.cs b/src/NeuralRadianceFields/Models/GaussianSplatting.cs
index d656443522..5cb2c061f1 100644
--- a/src/NeuralRadianceFields/Models/GaussianSplatting.cs
+++ b/src/NeuralRadianceFields/Models/GaussianSplatting.cs
@@ -189,7 +189,7 @@ namespace AiDotNet.NeuralRadianceFields.Models;
 [ModelComplexity(ModelComplexity.VeryHigh)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("3D Gaussian Splatting for Real-Time Radiance Field Rendering", "https://doi.org/10.1145/3592433", Year = 2023, Authors = "Bernhard Kerbl, Georgios Kopanas, Thomas Leimkühler, George Drettakis")]
-public class GaussianSplatting<T> : AiDotNet.NeuralNetworks.VectorModelLayoutBase<T>, IRadianceField<T>,
+public partial class GaussianSplatting<T> : AiDotNet.NeuralNetworks.VectorModelLayoutBase<T>, IRadianceField<T>,
     IHyperparameterAware<T, Tensor<T>, Tensor<T>>,
     NeuralRadianceFields.Interfaces.IImageTrainable<T>
 {
@@ -201,7 +201,7 @@ public class GaussianSplatting<T> : AiDotNet.NeuralNetworks.VectorModelLayoutBas
     /// <summary>
     /// Represents a single 3D Gaussian in the scene.
     /// </summary>
-    private sealed class Gaussian
+    private sealed partial class Gaussian
     {
         public Gaussian(int colorDim, INumericOperations<T> numOps)
         {
@@ -243,6 +243,7 @@ public Gaussian(int colorDim, INumericOperations<T> numOps)
         /// and the property below keeps every existing read and write in the renderer working
         /// unchanged.
         /// </remarks>
+        [AiDotNet.Attributes.TrainableParameter]
         private readonly Vector<T> _opacity = new(1);
 
         /// <summary>Opacity in logit space, stored in <see cref="OpacityStorage"/>.</summary>
@@ -476,7 +477,9 @@ public GaussianGradient(Gaussian gaussian, double gradX, double gradY, double gr
     private int _trainingStep;
     private SpatialHashGrid? _spatialIndex;
     private bool _spatialIndexDirty = true;
+    [Scratch]
     private Tensor<T>? _lastQueryPositions;
+    [Scratch]
     private Tensor<T>? _lastQueryDirections;
 
     public override bool SupportsTraining => true;
@@ -2499,38 +2502,6 @@ public override System.Collections.Generic.Dictionary<string, Tensor<T>> GetName
         return activations;
     }
 
-    /// <summary>
-    /// Declares every Gaussian's trainable attributes. This is an explicit representation -- the
-    /// scene is a list of Gaussians, not a stack of layers -- so <c>Layers</c> is empty by design
-    /// and the base walk would otherwise find nothing.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// Per Gaussian, in the order the deleted GetParameters flattened them: position (3), rotation
-    /// (4), scale (3), opacity (1), colour (3, or 3 x the SH basis count). Same layout, same order,
-    /// so a checkpoint written before this change still restores.
-    /// </para>
-    /// <para>
-    /// This replaces ParameterCount, GetParameters, GetParameterChunks, SetParameters and
-    /// UpdateParameters -- five members each re-deriving <c>perGaussian = 3 + 4 + 3 + 1 +
-    /// colorDim</c> and walking the list in lockstep. A tensor built over a <c>Vector&lt;T&gt;</c>
-    /// shares its storage, so these views are the fields themselves and the base's restore writes
-    /// straight into the scene; the old GetParameterChunks yielded a COPY, which any restore driven
-    /// through it would have written to and thrown away.
-    /// </para>
-    /// </remarks>
-    protected override IEnumerable<Tensor<T>> GetExtraTrainableTensors()
-    {
-        foreach (var gaussian in _gaussians)
-        {
-            yield return new Tensor<T>([gaussian.Position.Length], gaussian.Position);
-            yield return new Tensor<T>([gaussian.Rotation.Length], gaussian.Rotation);
-            yield return new Tensor<T>([gaussian.Scale.Length], gaussian.Scale);
-            yield return new Tensor<T>([gaussian.OpacityStorage.Length], gaussian.OpacityStorage);
-            yield return new Tensor<T>([gaussian.Color.Length], gaussian.Color);
-        }
-    }
-
     /// <inheritdoc />
     /// <remarks>
     /// A Gaussian's covariance is DERIVED from its rotation and scale, and the spatial index is
@@ -2586,176 +2557,6 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useSphericalHarmonics);
-        writer.Write(_shDegree);
-        writer.Write(_trainingStep);
-        writer.Write(EnableDensification);
-        writer.Write(DensificationInterval);
-        writer.Write(PruneOpacityThreshold);
-        writer.Write(SplitGradientThreshold);
-        writer.Write(SplitPositionJitter);
-        writer.Write(SplitScaleFactor);
-        writer.Write(SplitOpacityFactor);
-        writer.Write(SplitOpacityMax);
-        writer.Write(MaxGaussians);
-        writer.Write(PositionLearningRate);
-        writer.Write(ColorLearningRate);
-        writer.Write(OpacityLearningRate);
-        writer.Write(ScaleLearningRate);
-        writer.Write(RotationLearningRate);
-        writer.Write(TileSize);
-        writer.Write(EnableSpatialIndex);
-        writer.Write(SpatialIndexRadius);
-        writer.Write(InitialNeighborSearchScale);
-        writer.Write(InitialScaleMultiplier);
-        writer.Write(DefaultPointSpacing);
-        writer.Write(MinScale);
-
-        int colorDim = _useSphericalHarmonics ? 3 * GetShBasisCount() : 3;
-        writer.Write(colorDim);
-        writer.Write(_gaussians.Count);
-
-        foreach (var gaussian in _gaussians)
-        {
-            for (int i = 0; i < 3; i++)
-            {
-                writer.Write(NumOps.ToDouble(gaussian.Position[i]));
-            }
-            for (int i = 0; i < 4; i++)
-            {
-                writer.Write(NumOps.ToDouble(gaussian.Rotation[i]));
-            }
-            for (int i = 0; i < 3; i++)
-            {
-                writer.Write(NumOps.ToDouble(gaussian.Scale[i]));
-            }
-            writer.Write(NumOps.ToDouble(gaussian.Opacity));
-            for (int i = 0; i < colorDim; i++)
-            {
-                writer.Write(NumOps.ToDouble(gaussian.Color[i]));
-            }
-        }
-    }
-
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        bool useSh = reader.ReadBoolean();
-        int shDegree = reader.ReadInt32();
-        _trainingStep = reader.ReadInt32();
-        EnableDensification = reader.ReadBoolean();
-        DensificationInterval = reader.ReadInt32();
-        PruneOpacityThreshold = reader.ReadDouble();
-        SplitGradientThreshold = reader.ReadDouble();
-        SplitPositionJitter = reader.ReadDouble();
-        SplitScaleFactor = reader.ReadDouble();
-        SplitOpacityFactor = reader.ReadDouble();
-        SplitOpacityMax = reader.ReadDouble();
-        MaxGaussians = reader.ReadInt32();
-        PositionLearningRate = reader.ReadDouble();
-        ColorLearningRate = reader.ReadDouble();
-        OpacityLearningRate = reader.ReadDouble();
-        ScaleLearningRate = reader.ReadDouble();
-        RotationLearningRate = reader.ReadDouble();
-        TileSize = reader.ReadInt32();
-        EnableSpatialIndex = reader.ReadBoolean();
-        SpatialIndexRadius = reader.ReadInt32();
-        InitialNeighborSearchScale = reader.ReadDouble();
-        InitialScaleMultiplier = reader.ReadDouble();
-        DefaultPointSpacing = reader.ReadDouble();
-        MinScale = reader.ReadDouble();
-
-        if (useSh != _useSphericalHarmonics || shDegree != _shDegree)
-        {
-            throw new InvalidOperationException("Serialized GaussianSplatting configuration does not match this instance.");
-        }
-
-        int colorDim = reader.ReadInt32();
-        int gaussianCount = reader.ReadInt32();
-        _gaussians.Clear();
-
-        for (int i = 0; i < gaussianCount; i++)
-        {
-            var gaussian = new Gaussian(colorDim, NumOps);
-
-            for (int d = 0; d < 3; d++)
-            {
-                gaussian.Position[d] = NumOps.FromDouble(reader.ReadDouble());
-            }
-            for (int d = 0; d < 4; d++)
-            {
-                gaussian.Rotation[d] = NumOps.FromDouble(reader.ReadDouble());
-            }
-            for (int d = 0; d < 3; d++)
-            {
-                gaussian.Scale[d] = NumOps.FromDouble(reader.ReadDouble());
-            }
-            gaussian.Opacity = NumOps.FromDouble(reader.ReadDouble());
-            for (int d = 0; d < colorDim; d++)
-            {
-                gaussian.Color[d] = NumOps.FromDouble(reader.ReadDouble());
-            }
-
-            ComputeCovariance(gaussian);
-            _gaussians.Add(gaussian);
-        }
-
-        MarkSpatialIndexDirty();
-    }
-
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        // Pass a placeholder point cloud sized to the ORIGINAL model's
-        // Gaussian count so the clone starts with the right capacity.
-        // Without this, the constructor would auto-seed 8 default Gaussians
-        // and any subsequent UpdateParameters(originalState) would throw
-        // because the parameter vector length wouldn't match perGaussian *
-        // _gaussians.Count. Cloning a 32-Gaussian model would error; cloning
-        // a model trained past 8 Gaussians via densification would error;
-        // deserialization would error. The placeholder coordinates are all
-        // zeros — the caller's UpdateParameters overwrites every field, so
-        // only the count needs to be preserved here.
-        Matrix<T>? clonePointCloud = null;
-        if (_gaussians.Count > 0)
-        {
-            clonePointCloud = new Matrix<T>(_gaussians.Count, 3);
-            // Default-constructed Matrix<T> is all zeros; UpdateParameters
-            // restores positions during the snapshot replay.
-        }
-
-        return new GaussianSplatting<T>(
-            new GaussianSplattingOptions
-            {
-                UseSphericalHarmonics = _useSphericalHarmonics,
-                ShDegree = _shDegree,
-                EnableDensification = EnableDensification,
-                DensificationInterval = DensificationInterval,
-                PruneOpacityThreshold = PruneOpacityThreshold,
-                SplitGradientThreshold = SplitGradientThreshold,
-                SplitPositionJitter = SplitPositionJitter,
-                SplitScaleFactor = SplitScaleFactor,
-                SplitOpacityFactor = SplitOpacityFactor,
-                SplitOpacityMax = SplitOpacityMax,
-                MaxGaussians = MaxGaussians,
-                PositionLearningRate = PositionLearningRate,
-                ColorLearningRate = ColorLearningRate,
-                OpacityLearningRate = OpacityLearningRate,
-                ScaleLearningRate = ScaleLearningRate,
-                RotationLearningRate = RotationLearningRate,
-                TileSize = TileSize,
-                EnableSpatialIndex = EnableSpatialIndex,
-                SpatialIndexRadius = SpatialIndexRadius,
-                InitialNeighborSearchScale = InitialNeighborSearchScale,
-                InitialScaleMultiplier = InitialScaleMultiplier,
-                DefaultPointSpacing = DefaultPointSpacing,
-                MinScale = MinScale
-            },
-            initialPointCloud: clonePointCloud,
-            initialColors: null,
-            lossFunction: LossFunction);
-    }
-
     private void ParseCameraInput(
         Tensor<T> input,
         Tensor<T> expectedOutput,
diff --git a/src/NeuralRadianceFields/Models/InstantNGP.cs b/src/NeuralRadianceFields/Models/InstantNGP.cs
index 6eee275dc8..9215d7e724 100644
--- a/src/NeuralRadianceFields/Models/InstantNGP.cs
+++ b/src/NeuralRadianceFields/Models/InstantNGP.cs
@@ -1832,222 +1832,9 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_hashTableSize);
-        writer.Write(_numLevels);
-        writer.Write(_featuresPerLevel);
-        writer.Write(_finestResolution);
-        writer.Write(_coarsestResolution);
-        writer.Write(_mlpHiddenDim);
-        writer.Write(_mlpNumLayers);
-        writer.Write(_featureDim);
-        writer.Write(_colorHiddenDim);
-        writer.Write(_colorNumLayers);
-        writer.Write(_useOccupancyGrid);
-        writer.Write(_occupancyGridResolution);
-        writer.Write(NumOps.ToDouble(_learningRate));
-        writer.Write(_occupancyDecay);
-        writer.Write(_occupancyThreshold);
-        writer.Write(_occupancyUpdateInterval);
-        writer.Write(_occupancySamplesPerCell);
-        writer.Write(_occupancyJitter);
-        writer.Write(_renderSamples);
-        writer.Write(NumOps.ToDouble(_renderNearBound));
-        writer.Write(NumOps.ToDouble(_renderFarBound));
-        writer.Write(_sceneMin[0]);
-        writer.Write(_sceneMin[1]);
-        writer.Write(_sceneMin[2]);
-        writer.Write(_sceneMax[0]);
-        writer.Write(_sceneMax[1]);
-        writer.Write(_sceneMax[2]);
-        writer.Write(_trainingStep);
-
-        writer.Write(_hashTables.Count);
-        for (int level = 0; level < _numLevels; level++)
-        {
-            var table = _hashTables[level].Data.Span;
-            writer.Write(table.Length);
-            for (int i = 0; i < table.Length; i++)
-            {
-                writer.Write(NumOps.ToDouble(table[i]));
-            }
-        }
 
-        if (_occupancyGrid == null)
-        {
-            writer.Write(false);
-        }
-        else
-        {
-            writer.Write(true);
-            writer.Write(_occupancyGridResolution);
-            var gridData = _occupancyGrid.Data.Span;
-            writer.Write(gridData.Length);
-            for (int i = 0; i < gridData.Length; i++)
-            {
-                writer.Write(NumOps.ToDouble(gridData[i]));
-            }
-        }
-    }
-
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        int hashTableSize = reader.ReadInt32();
-        int numLevels = reader.ReadInt32();
-        int featuresPerLevel = reader.ReadInt32();
-        int finestResolution = reader.ReadInt32();
-        int coarsestResolution = reader.ReadInt32();
-        int mlpHiddenDim = reader.ReadInt32();
-        int mlpNumLayers = reader.ReadInt32();
-        int featureDim = reader.ReadInt32();
-        int colorHiddenDim = reader.ReadInt32();
-        int colorNumLayers = reader.ReadInt32();
-        bool useOccupancyGrid = reader.ReadBoolean();
-        int occupancyGridResolution = reader.ReadInt32();
-        double learningRate = reader.ReadDouble();
-        double occupancyDecay = reader.ReadDouble();
-        double occupancyThreshold = reader.ReadDouble();
-        int occupancyUpdateInterval = reader.ReadInt32();
-        int occupancySamplesPerCell = reader.ReadInt32();
-        double occupancyJitter = reader.ReadDouble();
-        int renderSamples = reader.ReadInt32();
-        double renderNear = reader.ReadDouble();
-        double renderFar = reader.ReadDouble();
-        double sceneMinX = reader.ReadDouble();
-        double sceneMinY = reader.ReadDouble();
-        double sceneMinZ = reader.ReadDouble();
-        double sceneMaxX = reader.ReadDouble();
-        double sceneMaxY = reader.ReadDouble();
-        double sceneMaxZ = reader.ReadDouble();
-        _trainingStep = reader.ReadInt32();
-
-        if (hashTableSize != _hashTableSize ||
-            numLevels != _numLevels ||
-            featuresPerLevel != _featuresPerLevel ||
-            finestResolution != _finestResolution ||
-            coarsestResolution != _coarsestResolution ||
-            mlpHiddenDim != _mlpHiddenDim ||
-            mlpNumLayers != _mlpNumLayers ||
-            featureDim != _featureDim ||
-            colorHiddenDim != _colorHiddenDim ||
-            colorNumLayers != _colorNumLayers ||
-            useOccupancyGrid != _useOccupancyGrid ||
-            occupancyGridResolution != _occupancyGridResolution ||
-            Math.Abs(learningRate - NumOps.ToDouble(_learningRate)) > 1e-9 ||
-            Math.Abs(occupancyDecay - _occupancyDecay) > 1e-9 ||
-            Math.Abs(occupancyThreshold - _occupancyThreshold) > 1e-9 ||
-            occupancyUpdateInterval != _occupancyUpdateInterval ||
-            occupancySamplesPerCell != _occupancySamplesPerCell ||
-            Math.Abs(occupancyJitter - _occupancyJitter) > 1e-9 ||
-            renderSamples != _renderSamples ||
-            Math.Abs(renderNear - NumOps.ToDouble(_renderNearBound)) > 1e-9 ||
-            Math.Abs(renderFar - NumOps.ToDouble(_renderFarBound)) > 1e-9 ||
-            Math.Abs(sceneMinX - _sceneMin[0]) > 1e-9 ||
-            Math.Abs(sceneMinY - _sceneMin[1]) > 1e-9 ||
-            Math.Abs(sceneMinZ - _sceneMin[2]) > 1e-9 ||
-            Math.Abs(sceneMaxX - _sceneMax[0]) > 1e-9 ||
-            Math.Abs(sceneMaxY - _sceneMax[1]) > 1e-9 ||
-            Math.Abs(sceneMaxZ - _sceneMax[2]) > 1e-9)
-        {
-            throw new InvalidOperationException("Serialized InstantNGP configuration does not match this instance.");
-        }
-
-        int tableCount = reader.ReadInt32();
-        if (tableCount != _numLevels)
-        {
-            throw new InvalidOperationException("Serialized hash table count does not match this instance.");
-        }
-
-        _hashTables.Clear();
-        for (int level = 0; level < _numLevels; level++)
-        {
-            int length = reader.ReadInt32();
-            int expectedLength = _hashTableSize * _featuresPerLevel;
-            if (length != expectedLength)
-            {
-                throw new InvalidOperationException("Serialized hash table length does not match this instance.");
-            }
-
-            var data = new T[length];
-            for (int i = 0; i < length; i++)
-            {
-                data[i] = NumOps.FromDouble(reader.ReadDouble());
-            }
 
-            _hashTables[level] = new Tensor<T>(data, [_hashTableSize, _featuresPerLevel]);
-        }
 
-        bool hasGrid = reader.ReadBoolean();
-        if (hasGrid)
-        {
-            int gridSize = reader.ReadInt32();
-            int gridLength = reader.ReadInt32();
-            int expectedLength = gridSize * gridSize * gridSize;
-            if (gridSize != _occupancyGridResolution || gridLength != expectedLength)
-            {
-                throw new InvalidOperationException("Serialized occupancy grid does not match this instance.");
-            }
-
-            var grid = new T[gridLength];
-            for (int i = 0; i < gridLength; i++)
-            {
-                grid[i] = NumOps.FromDouble(reader.ReadDouble());
-            }
-
-            _occupancyGrid = _useOccupancyGrid
-                ? new Tensor<T>(grid, [gridSize, gridSize, gridSize])
-                : null;
-        }
-        else
-        {
-            _occupancyGrid = null;
-        }
-
-        RebuildOccupancyBitfield();
-    }
-
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new InstantNGP<T>(
-            new InstantNGPOptions<T>
-            {
-                HashTableSize = _hashTableSize,
-                NumLevels = _numLevels,
-                FeaturesPerLevel = _featuresPerLevel,
-                FinestResolution = _finestResolution,
-                CoarsestResolution = _coarsestResolution,
-                MlpHiddenDim = _mlpHiddenDim,
-                MlpNumLayers = _mlpNumLayers,
-                FeatureDim = _featureDim,
-                ColorHiddenDim = _colorHiddenDim,
-                ColorNumLayers = _colorNumLayers,
-                UseOccupancyGrid = _useOccupancyGrid,
-                OccupancyGridResolution = _occupancyGridResolution,
-                LearningRate = NumOps.ToDouble(_learningRate),
-                OccupancyDecay = _occupancyDecay,
-                OccupancyThreshold = _occupancyThreshold,
-                OccupancyUpdateInterval = _occupancyUpdateInterval,
-                OccupancySamplesPerCell = _occupancySamplesPerCell,
-                OccupancyJitter = _occupancyJitter,
-                RenderSamples = _renderSamples,
-                RenderNearBound = NumOps.ToDouble(_renderNearBound),
-                RenderFarBound = NumOps.ToDouble(_renderFarBound),
-                SceneMin = new Vector<T>(3)
-                {
-                    [0] = NumOps.FromDouble(_sceneMin[0]),
-                    [1] = NumOps.FromDouble(_sceneMin[1]),
-                    [2] = NumOps.FromDouble(_sceneMin[2])
-                },
-                SceneMax = new Vector<T>(3)
-                {
-                    [0] = NumOps.FromDouble(_sceneMax[0]),
-                    [1] = NumOps.FromDouble(_sceneMax[1]),
-                    [2] = NumOps.FromDouble(_sceneMax[2])
-                }
-            },
-            LossFunction);
-    }
 
     protected override Tensor<T> PredictCore(Tensor<T> input)
     {
diff --git a/src/NeuralRadianceFields/Models/NeRF.cs b/src/NeuralRadianceFields/Models/NeRF.cs
index 3eb0f46e1b..8b1dddc106 100644
--- a/src/NeuralRadianceFields/Models/NeRF.cs
+++ b/src/NeuralRadianceFields/Models/NeRF.cs
@@ -1411,77 +1411,12 @@ public override ModelMetadata<T> GetModelMetadata()
     /// <summary>
     /// Serializes network-specific data.
     /// </summary>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_positionEncodingLevels);
-        writer.Write(_directionEncodingLevels);
-        writer.Write(_hiddenDim);
-        writer.Write(_numLayers);
-        writer.Write(_colorHiddenDim);
-        writer.Write(_colorNumLayers);
-        writer.Write(_useHierarchicalSampling);
-        writer.Write(_renderSamples);
-        writer.Write(_hierarchicalSamples);
-        writer.Write(NumOps.ToDouble(_renderNearBound));
-        writer.Write(NumOps.ToDouble(_renderFarBound));
-        writer.Write(NumOps.ToDouble(_learningRate));
-    }
+
 
     /// <summary>
     /// Deserializes network-specific data.
     /// </summary>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        int positionLevels = reader.ReadInt32();
-        int directionLevels = reader.ReadInt32();
-        int hiddenDim = reader.ReadInt32();
-        int numLayers = reader.ReadInt32();
-        int colorHiddenDim = reader.ReadInt32();
-        int colorNumLayers = reader.ReadInt32();
-        bool useHierarchical = reader.ReadBoolean();
-        int renderSamples = reader.ReadInt32();
-        int hierarchicalSamples = reader.ReadInt32();
-        double renderNear = reader.ReadDouble();
-        double renderFar = reader.ReadDouble();
-        double learningRate = reader.ReadDouble();
-
-        if (positionLevels != _positionEncodingLevels ||
-            directionLevels != _directionEncodingLevels ||
-            hiddenDim != _hiddenDim ||
-            numLayers != _numLayers ||
-            colorHiddenDim != _colorHiddenDim ||
-            colorNumLayers != _colorNumLayers ||
-            useHierarchical != _useHierarchicalSampling ||
-            renderSamples != _renderSamples ||
-            hierarchicalSamples != _hierarchicalSamples ||
-            Math.Abs(renderNear - NumOps.ToDouble(_renderNearBound)) > 1e-8 ||
-            Math.Abs(renderFar - NumOps.ToDouble(_renderFarBound)) > 1e-8 ||
-            Math.Abs(learningRate - NumOps.ToDouble(_learningRate)) > 1e-8)
-        {
-            throw new InvalidOperationException("Serialized NeRF configuration does not match this instance.");
-        }
-    }
 
-    /// <summary>
-    /// Creates a new instance of this model for cloning.
-    /// </summary>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new NeRF<T>(
-            positionEncodingLevels: _positionEncodingLevels,
-            directionEncodingLevels: _directionEncodingLevels,
-            hiddenDim: _hiddenDim,
-            numLayers: _numLayers,
-            colorHiddenDim: _colorHiddenDim,
-            colorNumLayers: _colorNumLayers,
-            useHierarchicalSampling: _useHierarchicalSampling,
-            renderSamples: _renderSamples,
-            hierarchicalSamples: _hierarchicalSamples,
-            renderNearBound: NumOps.ToDouble(_renderNearBound),
-            renderFarBound: NumOps.ToDouble(_renderFarBound),
-            learningRate: NumOps.ToDouble(_learningRate),
-            lossFunction: _lossFunction);
-    }
 
     #endregion
 }
diff --git a/src/OnlineLearning/OnlineLearningModelBase.cs b/src/OnlineLearning/OnlineLearningModelBase.cs
index 3666dea9e5..b286db5c00 100644
--- a/src/OnlineLearning/OnlineLearningModelBase.cs
+++ b/src/OnlineLearning/OnlineLearningModelBase.cs
@@ -30,8 +30,51 @@ namespace AiDotNet.OnlineLearning;
 /// - Standard IFullModel interface implementation
 /// </para>
 /// </remarks>
-public abstract class OnlineLearningModelBase<T> : IOnlineLearningModel<T>, IModelShape, IParameterManifestProvider
+public abstract partial class OnlineLearningModelBase<T> : IOnlineLearningModel<T>, IModelShape, IParameterManifestProvider
 {
+    // --- declared state (ModelStateRegistry) ---
+    // Identical in every model base because these bases are siblings over the same interfaces rather
+    // than one hierarchy; the logic itself lives once in ModelStateRegistry/ModelStateEnvelope.
+
+    /// <summary>State that is not a parameter vector, declared once and persisted by this base.</summary>
+    private readonly AiDotNet.Models.ModelStateRegistry<T> _declaredState = new();
+    private bool _declaredStateRegistered;
+
+    /// <summary>
+    /// Declare state here that the parameter vector does not carry -- a retained training set,
+    /// fitted knots, kernel centres, an ensemble's children. Both halves of the payload are driven
+    /// by the declaration, so they cannot drift.
+    /// </summary>
+    /// <param name="state">The registry to declare into.</param>
+    protected virtual void RegisterState(AiDotNet.Models.ModelStateRegistry<T> state)
+    {
+    }
+    /// <summary>Generated state declarations for fields declared across this model's hierarchy.</summary>
+    /// <param name="state">The registry to declare into.</param>
+    /// <remarks>
+    /// Emitted by ModelStateGenerator into the partial model, so a model author declares nothing. The
+    /// hand-written <c>RegisterState</c> beside it exists only for state the classifier genuinely
+    /// cannot place; anything it CAN place belongs here, where it cannot be forgotten.
+    /// </remarks>
+    protected virtual void RegisterGeneratedState(AiDotNet.Models.ModelStateRegistry<T> state)
+    {
+        RegisterGeneratedStateCore(state);
+    }
+
+    /// <summary>The declared state, registered once and lazily so it runs after the constructor.</summary>
+    protected AiDotNet.Models.ModelStateRegistry<T> DeclaredState
+    {
+        get
+        {
+            if (!_declaredStateRegistered)
+            {
+                _declaredStateRegistered = true;
+                RegisterGeneratedState(_declaredState);
+                RegisterState(_declaredState);
+            }
+            return _declaredState;
+        }
+    }
     /// <summary>
     /// Numeric operations helper for generic math.
     /// </summary>
@@ -311,7 +354,7 @@ public virtual ModelMetadata<T> GetModelMetadata()
     public virtual byte[] Serialize()
     {
         ModelPersistenceGuard.EnforceBeforeSerialize();
-        return SerializeInternalUnchecked();
+        return AiDotNet.Models.ModelStateEnvelope.Append(DeclaredState, SerializeInternalUnchecked());
     }
 
     /// <summary>
@@ -354,6 +397,9 @@ private byte[] SerializeInternalUnchecked()
     /// </summary>
     public virtual void Deserialize(byte[] modelData)
     {
+        // Strips and applies any declared-state trailer, so the body below reads the payload
+        // exactly as it did before this existed.
+        modelData = AiDotNet.Models.ModelStateEnvelope.Extract(DeclaredState, modelData);
         ModelPersistenceGuard.EnforceBeforeDeserialize();
         DeserializeInternalUnchecked(modelData);
     }
@@ -438,7 +484,18 @@ public virtual Vector<T> Predict(Matrix<T> input)
     /// <summary>
     /// Creates a new instance of the same type.
     /// </summary>
-    protected abstract IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance();
+    /// <remarks>
+    /// <para>
+    /// No longer abstract. Every concrete model used to be forced to write this, and 1147 of them
+    /// did -- each one a hand-copied list of constructor arguments that a new option could fall out
+    /// of without anything failing. The clone plan records that constructor at compile time instead,
+    /// so the base can rebuild the type and a model only overrides this when the generator says it
+    /// cannot: a constructor parameter with nothing holding its value, which the build reports by
+    /// name rather than leaving to be discovered by a clone that comes back subtly different.
+    /// </para>
+    /// </remarks>
+    protected virtual IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
+        => (IFullModel<T, Matrix<T>, Vector<T>>)AiDotNet.Models.CloneEngine.CopyConfiguration(this);
 
     /// <summary>
     /// Gets the indices of features that are actively used in the model.
diff --git a/src/OnlineLearning/OnlinePassiveAggressiveClassifier.cs b/src/OnlineLearning/OnlinePassiveAggressiveClassifier.cs
index dc6e0d976e..da5aa36496 100644
--- a/src/OnlineLearning/OnlinePassiveAggressiveClassifier.cs
+++ b/src/OnlineLearning/OnlinePassiveAggressiveClassifier.cs
@@ -63,7 +63,7 @@ namespace AiDotNet.OnlineLearning;
 [ModelComplexity(ModelComplexity.Low)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
 [ResearchPaper("Online Passive-Aggressive Algorithms", "https://doi.org/10.1162/jmlr.2006.7.19.551", Year = 2006, Authors = "Koby Crammer, Ofer Dekel, Joseph Keshet, Shai Shalev-Shwartz, Yoram Singer")]
-public class OnlinePassiveAggressiveClassifier<T> : OnlineLearningModelBase<T>
+public partial class OnlinePassiveAggressiveClassifier<T> : OnlineLearningModelBase<T>
 {
 
     /// <inheritdoc />
@@ -322,37 +322,6 @@ public override IFullModel<T, Matrix<T>, Vector<T>> WithParameters(Vector<T> par
         return newModel;
     }
 
-    /// <summary>
-    /// Creates a new instance of this type.
-    /// </summary>
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        return new OnlinePassiveAggressiveClassifier<T>(_c, _paType, _fitIntercept);
-    }
-
-    /// <inheritdoc/>
-    public override IFullModel<T, Matrix<T>, Vector<T>> Clone()
-    {
-        var clone = new OnlinePassiveAggressiveClassifier<T>(_c, _paType, _fitIntercept);
-        clone.NumFeatures = NumFeatures;
-        clone.IsInitialized = IsInitialized;
-        if (_weights is not null)
-        {
-            clone._weights = new Vector<T>(_weights.Length);
-            for (int i = 0; i < _weights.Length; i++)
-                clone._weights[i] = _weights[i];
-        }
-        clone._bias = _bias;
-        // Copy training state via parameters if available
-        if (IsInitialized && _weights is not null)
-        {
-            var params2 = GetParameters();
-            if (params2.Length > 0)
-                clone.SetParameters(params2);
-        }
-        return clone;
-    }
-
     /// <summary>
     /// Gets the feature importance scores (absolute weights).
     /// </summary>
diff --git a/src/OnlineLearning/OnlinePassiveAggressiveRegressor.cs b/src/OnlineLearning/OnlinePassiveAggressiveRegressor.cs
index 6bfde84664..c493e3a3b4 100644
--- a/src/OnlineLearning/OnlinePassiveAggressiveRegressor.cs
+++ b/src/OnlineLearning/OnlinePassiveAggressiveRegressor.cs
@@ -64,7 +64,7 @@ namespace AiDotNet.OnlineLearning;
 [ModelComplexity(ModelComplexity.Low)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
 [ResearchPaper("Online Passive-Aggressive Algorithms", "https://doi.org/10.1162/jmlr.2006.7.19.551", Year = 2006, Authors = "Koby Crammer, Ofer Dekel, Joseph Keshet, Shai Shalev-Shwartz, Yoram Singer")]
-public class OnlinePassiveAggressiveRegressor<T> : OnlineLearningModelBase<T>
+public partial class OnlinePassiveAggressiveRegressor<T> : OnlineLearningModelBase<T>
 {
 
     /// <inheritdoc />
@@ -414,14 +414,6 @@ public override IFullModel<T, Matrix<T>, Vector<T>> WithParameters(Vector<T> par
         return newModel;
     }
 
-    /// <summary>
-    /// Creates a new instance of this type.
-    /// </summary>
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        return new OnlinePassiveAggressiveRegressor<T>(_c, _epsilon, _paType, _fitIntercept, _batchEpochs);
-    }
-
     /// <summary>
     /// Gets the feature importance scores (absolute weights).
     /// </summary>
diff --git a/src/OnlineLearning/OnlineSGDClassifier.cs b/src/OnlineLearning/OnlineSGDClassifier.cs
index a8b51a27d2..d1396fad0f 100644
--- a/src/OnlineLearning/OnlineSGDClassifier.cs
+++ b/src/OnlineLearning/OnlineSGDClassifier.cs
@@ -61,7 +61,7 @@ namespace AiDotNet.OnlineLearning;
 [ModelComplexity(ModelComplexity.Low)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
 [ResearchPaper("Large-Scale Machine Learning with Stochastic Gradient Descent", "https://doi.org/10.1007/978-3-7908-2604-3_16", Year = 2010, Authors = "Léon Bottou")]
-public class OnlineSGDClassifier<T> : OnlineLearningModelBase<T>
+public partial class OnlineSGDClassifier<T> : OnlineLearningModelBase<T>
 {
 
     /// <inheritdoc />
@@ -342,31 +342,6 @@ public override IFullModel<T, Matrix<T>, Vector<T>> WithParameters(Vector<T> par
         return newModel;
     }
 
-    /// <summary>
-    /// Creates a new instance of this type.
-    /// </summary>
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        return new OnlineSGDClassifier<T>(
-            InitialLearningRate, LearningRateScheduleType, _l1Penalty, _l2Penalty, _fitIntercept);
-    }
-
-    /// <inheritdoc/>
-    public override IFullModel<T, Matrix<T>, Vector<T>> Clone()
-    {
-        var clone = (OnlineSGDClassifier<T>)CreateNewInstance();
-        clone.NumFeatures = NumFeatures;
-        clone.IsInitialized = IsInitialized;
-        if (_weights is not null)
-        {
-            clone._weights = new Vector<T>(_weights.Length);
-            for (int i = 0; i < _weights.Length; i++)
-                clone._weights[i] = _weights[i];
-        }
-        clone._bias = _bias;
-        return clone;
-    }
-
     /// <summary>
     /// Gets the feature importance scores (absolute weights).
     /// </summary>
diff --git a/src/OnlineLearning/OnlineSGDRegressor.cs b/src/OnlineLearning/OnlineSGDRegressor.cs
index a93bbc427e..f902a8f91e 100644
--- a/src/OnlineLearning/OnlineSGDRegressor.cs
+++ b/src/OnlineLearning/OnlineSGDRegressor.cs
@@ -54,7 +54,7 @@ namespace AiDotNet.OnlineLearning;
 [ModelComplexity(ModelComplexity.Low)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
 [ResearchPaper("Large-Scale Machine Learning with Stochastic Gradient Descent", "https://doi.org/10.1007/978-3-7908-2604-3_16", Year = 2010, Authors = "Léon Bottou")]
-public class OnlineSGDRegressor<T> : OnlineLearningModelBase<T>
+public partial class OnlineSGDRegressor<T> : OnlineLearningModelBase<T>
 {
 
     /// <inheritdoc />
@@ -400,16 +400,6 @@ public override IFullModel<T, Matrix<T>, Vector<T>> WithParameters(Vector<T> par
         return newModel;
     }
 
-    /// <summary>
-    /// Creates a new instance of this type.
-    /// </summary>
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        return new OnlineSGDRegressor<T>(
-            InitialLearningRate, LearningRateScheduleType, _l1Penalty, _l2Penalty,
-            _fitIntercept, _lossType, _epsilon);
-    }
-
     /// <summary>
     /// Gets the feature importance scores (absolute weights).
     /// </summary>
diff --git a/src/Optimizers/ADMMOptimizer.cs b/src/Optimizers/ADMMOptimizer.cs
index d49772f55f..cf2c9d6089 100644
--- a/src/Optimizers/ADMMOptimizer.cs
+++ b/src/Optimizers/ADMMOptimizer.cs
@@ -23,7 +23,7 @@ namespace AiDotNet.Optimizers;
 /// </remarks>
 [ComponentType(ComponentType.Optimizer)]
 [PipelineStage(PipelineStage.Training)]
-public class ADMMOptimizer<T, TInput, TOutput> : GradientBasedOptimizerBase<T, TInput, TOutput>
+public partial class ADMMOptimizer<T, TInput, TOutput> : GradientBasedOptimizerBase<T, TInput, TOutput>
 {
     /// <summary>
     /// The options specific to the ADMM optimizer.
@@ -43,11 +43,13 @@ public class ADMMOptimizer<T, TInput, TOutput> : GradientBasedOptimizerBase<T, T
     /// <summary>
     /// The auxiliary variable in ADMM algorithm.
     /// </summary>
+    [AiDotNet.Attributes.Buffer]
     private Vector<T> _z;
 
     /// <summary>
     /// The dual variable in ADMM algorithm.
     /// </summary>
+    [AiDotNet.Attributes.Buffer]
     private Vector<T> _u;
 
     /// <summary>
@@ -465,65 +467,6 @@ public override void UpdateParametersGpu(IGpuBuffer parameters, IGpuBuffer gradi
             "Use CPU-based UpdateParameters or consider using Adam/AdamW for GPU-resident training.");
     }
 
-    /// <summary>
-    /// Converts the current state of the optimizer into a byte array for storage or transmission.
-    /// </summary>
-    /// <returns>A byte array representing the serialized state of the optimizer.</returns>
-    /// <remarks>
-    /// <para><b>For Beginners:</b> This method saves all the important information about the optimizer's current state.
-    /// It's like taking a snapshot of the optimizer that can be used to recreate its exact state later.
-    /// </para>
-    /// </remarks>
-    public override byte[] Serialize()
-    {
-        using (MemoryStream ms = new MemoryStream())
-        using (BinaryWriter writer = new BinaryWriter(ms))
-        {
-            byte[] baseData = base.Serialize();
-            writer.Write(baseData.Length);
-            writer.Write(baseData);
-
-            string optionsJson = JsonConvert.SerializeObject(_options);
-            writer.Write(optionsJson);
-
-            writer.Write(_iteration);
-            writer.Write(_z.Serialize());
-            writer.Write(_u.Serialize());
-
-            return ms.ToArray();
-        }
-    }
-
-    /// <summary>
-    /// Restores the optimizer's state from a byte array previously created by the Serialize method.
-    /// </summary>
-    /// <param name="data">The byte array containing the serialized optimizer state.</param>
-    /// <remarks>
-    /// <para><b>For Beginners:</b> This method rebuilds the optimizer's state from a saved snapshot.
-    /// It's like restoring a machine to a previous configuration using a backup.
-    /// </para>
-    /// </remarks>
-    public override void Deserialize(byte[] data)
-    {
-        using (MemoryStream ms = new MemoryStream(data))
-        using (BinaryReader reader = new BinaryReader(ms))
-        {
-            int baseDataLength = reader.ReadInt32();
-            byte[] baseData = reader.ReadBytes(baseDataLength);
-            base.Deserialize(baseData);
-
-            string optionsJson = reader.ReadString();
-            _options = JsonConvert.DeserializeObject<ADMMOptimizerOptions<T, TInput, TOutput>>(optionsJson)
-                ?? throw new InvalidOperationException("Failed to deserialize optimizer options.");
-
-            _iteration = reader.ReadInt32();
-            _z = Vector<T>.Deserialize(reader.ReadBytes(reader.ReadInt32()));
-            _u = Vector<T>.Deserialize(reader.ReadBytes(reader.ReadInt32()));
-
-            _regularization = GetRegularizationFromOptions(_options);
-        }
-    }
-
     /// <summary>
     /// Generates a unique key for caching gradients based on the current state of the optimizer and input data.
     /// </summary>
diff --git a/src/Optimizers/AMSGradOptimizer.cs b/src/Optimizers/AMSGradOptimizer.cs
index 2d341484ae..8861ad484d 100644
--- a/src/Optimizers/AMSGradOptimizer.cs
+++ b/src/Optimizers/AMSGradOptimizer.cs
@@ -24,7 +24,7 @@ namespace AiDotNet.Optimizers;
 /// </remarks>
 [ComponentType(ComponentType.Optimizer)]
 [PipelineStage(PipelineStage.Training)]
-public class AMSGradOptimizer<T, TInput, TOutput> : GradientBasedOptimizerBase<T, TInput, TOutput>, Fused.IFusedOptimizerSpec
+public partial class AMSGradOptimizer<T, TInput, TOutput> : GradientBasedOptimizerBase<T, TInput, TOutput>, Fused.IFusedOptimizerSpec
 {
     /// <summary>
     /// The options specific to the AMSGrad optimizer.
@@ -595,39 +595,6 @@ public override OptimizationAlgorithmOptions<T, TInput, TOutput> GetOptions()
         return _options;
     }
 
-    /// <summary>
-    /// Converts the current state of the optimizer into a byte array for storage or transmission.
-    /// </summary>
-    /// <returns>A byte array representing the serialized state of the optimizer.</returns>
-    /// <remarks>
-    /// <para><b>For Beginners:</b> This method saves all the important information about the AMSGrad optimizer's current state.
-    /// It's like taking a snapshot of the optimizer that can be used to recreate its exact state later.
-    /// This is useful for saving progress or sharing the optimizer's state with others.
-    /// </para>
-    /// </remarks>
-    public override byte[] Serialize()
-    {
-        using (MemoryStream ms = new MemoryStream())
-        using (BinaryWriter writer = new BinaryWriter(ms))
-        {
-            byte[] baseData = base.Serialize();
-            writer.Write(baseData.Length);
-            writer.Write(baseData);
-
-            string optionsJson = JsonConvert.SerializeObject(_options);
-            writer.Write(optionsJson);
-
-            writer.Write(_t);
-
-            // Serialize state vectors
-            SerializeVector(writer, _m);
-            SerializeVector(writer, _v);
-            SerializeVector(writer, _vHat);
-
-            return ms.ToArray();
-        }
-    }
-
     private void SerializeVector(BinaryWriter writer, Vector<T>? vector)
     {
         writer.Write(vector is not null);
@@ -657,38 +624,6 @@ private void SerializeVector(BinaryWriter writer, Vector<T>? vector)
         return null;
     }
 
-    /// <summary>
-    /// Restores the optimizer's state from a byte array previously created by the Serialize method.
-    /// </summary>
-    /// <param name="data">The byte array containing the serialized optimizer state.</param>
-    /// <remarks>
-    /// <para><b>For Beginners:</b> This method rebuilds the AMSGrad optimizer's state from a saved snapshot.
-    /// It's like restoring a machine to a previous configuration using a backup.
-    /// This allows you to continue optimization from where you left off or use a shared optimizer state.
-    /// </para>
-    /// </remarks>
-    public override void Deserialize(byte[] data)
-    {
-        using (MemoryStream ms = new MemoryStream(data))
-        using (BinaryReader reader = new BinaryReader(ms))
-        {
-            int baseDataLength = reader.ReadInt32();
-            byte[] baseData = reader.ReadBytes(baseDataLength);
-            base.Deserialize(baseData);
-
-            string optionsJson = reader.ReadString();
-            _options = JsonConvert.DeserializeObject<AMSGradOptimizerOptions<T, TInput, TOutput>>(optionsJson)
-                ?? throw new InvalidOperationException("Failed to deserialize optimizer options.");
-
-            _t = reader.ReadInt32();
-
-            // Deserialize state vectors
-            _m = DeserializeVector(reader);
-            _v = DeserializeVector(reader);
-            _vHat = DeserializeVector(reader);
-        }
-    }
-
     /// <summary>
     /// Generates a unique key for caching gradients based on the current state of the optimizer and input data.
     /// </summary>
diff --git a/src/Optimizers/ASGDOptimizer.cs b/src/Optimizers/ASGDOptimizer.cs
index c54b674927..0aa16a3fb8 100644
--- a/src/Optimizers/ASGDOptimizer.cs
+++ b/src/Optimizers/ASGDOptimizer.cs
@@ -50,7 +50,7 @@ namespace AiDotNet.Optimizers;
 /// </remarks>
 [ComponentType(ComponentType.Optimizer)]
 [PipelineStage(PipelineStage.Training)]
-public class ASGDOptimizer<T, TInput, TOutput> : GradientBasedOptimizerBase<T, TInput, TOutput>, Fused.IFusedOptimizerSpec
+public partial class ASGDOptimizer<T, TInput, TOutput> : GradientBasedOptimizerBase<T, TInput, TOutput>, Fused.IFusedOptimizerSpec
 {
     /// <summary>
     /// The options specific to the ASGD optimizer.
@@ -512,26 +512,6 @@ public override OptimizationAlgorithmOptions<T, TInput, TOutput> GetOptions()
     /// <para><b>For Beginners:</b> This saves the optimizer so training can resume exactly where it left off,
     /// including the running average and the step count that decides when averaging starts.</para>
     /// </remarks>
-    public override byte[] Serialize()
-    {
-        using (MemoryStream ms = new MemoryStream())
-        using (BinaryWriter writer = new BinaryWriter(ms))
-        {
-            byte[] baseData = base.Serialize();
-            writer.Write(baseData.Length);
-            writer.Write(baseData);
-
-            string optionsJson = JsonConvert.SerializeObject(_options);
-            writer.Write(optionsJson);
-
-            writer.Write(_t);
-
-            SerializeVector(writer, _ax);
-
-            return ms.ToArray();
-        }
-    }
-
     private void SerializeVector(BinaryWriter writer, Vector<T>? vector)
     {
         writer.Write(vector is not null);
@@ -565,25 +545,6 @@ private void SerializeVector(BinaryWriter writer, Vector<T>? vector)
     /// Restores the optimizer's state from a byte array previously created by <see cref="Serialize"/>.
     /// </summary>
     /// <param name="data">The byte array containing the serialized optimizer state.</param>
-    public override void Deserialize(byte[] data)
-    {
-        using (MemoryStream ms = new MemoryStream(data))
-        using (BinaryReader reader = new BinaryReader(ms))
-        {
-            int baseDataLength = reader.ReadInt32();
-            byte[] baseData = reader.ReadBytes(baseDataLength);
-            base.Deserialize(baseData);
-
-            string optionsJson = reader.ReadString();
-            _options = JsonConvert.DeserializeObject<ASGDOptimizerOptions<T, TInput, TOutput>>(optionsJson)
-                ?? throw new InvalidOperationException("Failed to deserialize optimizer options.");
-
-            _t = reader.ReadInt32();
-
-            _ax = DeserializeVector(reader);
-        }
-    }
-
     /// <summary>
     /// Generates a unique key for caching gradients based on the current state of the optimizer and input data.
     /// </summary>
diff --git a/src/Optimizers/AdaDeltaOptimizer.cs b/src/Optimizers/AdaDeltaOptimizer.cs
index 269e9d40d5..d480558618 100644
--- a/src/Optimizers/AdaDeltaOptimizer.cs
+++ b/src/Optimizers/AdaDeltaOptimizer.cs
@@ -31,7 +31,7 @@ namespace AiDotNet.Optimizers;
 /// <typeparam name="T">The numeric type used for calculations, typically float or double.</typeparam>
 [ComponentType(ComponentType.Optimizer)]
 [PipelineStage(PipelineStage.Training)]
-public class AdaDeltaOptimizer<T, TInput, TOutput> : GradientBasedOptimizerBase<T, TInput, TOutput>, Fused.IFusedOptimizerSpec
+public partial class AdaDeltaOptimizer<T, TInput, TOutput> : GradientBasedOptimizerBase<T, TInput, TOutput>, Fused.IFusedOptimizerSpec
 {
     /// <summary>
     /// Describes this AdaDelta instance for the fused kernel (Tensors
@@ -728,48 +728,6 @@ public override OptimizationAlgorithmOptions<T, TInput, TOutput> GetOptions()
         return _options;
     }
 
-    /// <summary>
-    /// Serializes the AdaDelta optimizer to a byte array.
-    /// </summary>
-    /// <returns>A byte array representing the serialized optimizer.</returns>
-    /// <remarks>
-    /// <para>
-    /// This method converts the optimizer's state, including its base class state and options,
-    /// into a byte array that can be stored or transmitted.
-    /// </para>
-    /// <para><b>For Beginners:</b> This is like packing up the optimizer into a compact form.
-    /// 
-    /// Imagine you're packing a suitcase:
-    /// 1. You pack the basic stuff (base class data)
-    /// 2. You write down how much basic stuff you packed
-    /// 3. You pack your special AdaDelta stuff (options)
-    /// 
-    /// This packed form can be saved or sent somewhere else, and later unpacked to recreate
-    /// the optimizer exactly as it was.
-    /// </para>
-    /// </remarks>
-    public override byte[] Serialize()
-    {
-        using (MemoryStream ms = new MemoryStream())
-        using (BinaryWriter writer = new BinaryWriter(ms))
-        {
-            byte[] baseData = base.Serialize();
-            writer.Write(baseData.Length);
-            writer.Write(baseData);
-
-            string optionsJson = JsonConvert.SerializeObject(_options);
-            writer.Write(optionsJson);
-
-            // Serialize state vectors
-            SerializeVector(writer, _accumulatedSquaredGradients);
-            SerializeVector(writer, _accumulatedSquaredUpdates);
-            SerializeVector(writer, _previousAccumulatedSquaredGradients);
-            SerializeVector(writer, _previousAccumulatedSquaredUpdates);
-
-            return ms.ToArray();
-        }
-    }
-
     private void SerializeVector(BinaryWriter writer, Vector<T>? vector)
     {
         bool hasVector = vector is not null;
@@ -800,46 +758,6 @@ private void SerializeVector(BinaryWriter writer, Vector<T>? vector)
         return null;
     }
 
-    /// <summary>
-    /// Deserializes the AdaDelta optimizer from a byte array.
-    /// </summary>
-    /// <param name="data">The byte array containing the serialized optimizer data.</param>
-    /// <exception cref="InvalidOperationException">Thrown when deserialization of optimizer options fails.</exception>
-    /// <remarks>
-    /// <para>
-    /// This method reconstructs the optimizer's state from a byte array, including its base class state and options.
-    /// </para>
-    /// <para><b>For Beginners:</b> This is like unpacking the optimizer from its compact form.
-    ///
-    /// Continuing the suitcase analogy:
-    /// 1. You check how much basic stuff was packed
-    /// 2. You unpack the basic stuff (base class data)
-    /// 3. You unpack and set up your special AdaDelta stuff (options)
-    ///
-    /// If there's a problem unpacking the special stuff, it will let you know with an error message.
-    /// </para>
-    /// </remarks>
-    public override void Deserialize(byte[] data)
-    {
-        using (MemoryStream ms = new MemoryStream(data))
-        using (BinaryReader reader = new BinaryReader(ms))
-        {
-            int baseDataLength = reader.ReadInt32();
-            byte[] baseData = reader.ReadBytes(baseDataLength);
-            base.Deserialize(baseData);
-
-            string optionsJson = reader.ReadString();
-            _options = JsonConvert.DeserializeObject<AdaDeltaOptimizerOptions<T, TInput, TOutput>>(optionsJson)
-                ?? throw new InvalidOperationException("Failed to deserialize optimizer options.");
-
-            // Deserialize state vectors
-            _accumulatedSquaredGradients = DeserializeVector(reader);
-            _accumulatedSquaredUpdates = DeserializeVector(reader);
-            _previousAccumulatedSquaredGradients = DeserializeVector(reader);
-            _previousAccumulatedSquaredUpdates = DeserializeVector(reader);
-        }
-    }
-
     /// <summary>
     /// Generates a unique key for caching gradients.
     /// </summary>
diff --git a/src/Optimizers/AdaMaxOptimizer.cs b/src/Optimizers/AdaMaxOptimizer.cs
index e53260c925..6fb8efcdaf 100644
--- a/src/Optimizers/AdaMaxOptimizer.cs
+++ b/src/Optimizers/AdaMaxOptimizer.cs
@@ -30,7 +30,7 @@ namespace AiDotNet.Optimizers;
 /// </remarks>
 [ComponentType(ComponentType.Optimizer)]
 [PipelineStage(PipelineStage.Training)]
-public class AdaMaxOptimizer<T, TInput, TOutput> : GradientBasedOptimizerBase<T, TInput, TOutput>, Fused.IFusedOptimizerSpec
+public partial class AdaMaxOptimizer<T, TInput, TOutput> : GradientBasedOptimizerBase<T, TInput, TOutput>, Fused.IFusedOptimizerSpec
 {
     /// <summary>
     /// Describes this AdaMax instance for the fused-compiled training kernel
@@ -670,90 +670,6 @@ public override OptimizationAlgorithmOptions<T, TInput, TOutput> GetOptions()
         return _options;
     }
 
-    /// <summary>
-    /// Converts the current state of the optimizer into a byte array for storage or transmission.
-    /// </summary>
-    /// <returns>A byte array representing the serialized state of the optimizer.</returns>
-    /// <remarks>
-    /// <para>
-    /// This method saves the current state of the optimizer, including its options and internal counters,
-    /// into a compact binary format.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method is like taking a snapshot of your learning assistant's brain.
-    /// 
-    /// Imagine you could:
-    /// - Take a picture of everything your study robot knows and how it's set up
-    /// - Turn that picture into a long string of numbers
-    /// - Save those numbers so you can perfectly recreate the robot's state later
-    /// 
-    /// This is useful for:
-    /// - Saving your progress so you can continue later
-    /// - Sharing your optimizer's exact state with others
-    /// - Creating backups in case something goes wrong
-    /// </para>
-    /// </remarks>
-    public override byte[] Serialize()
-    {
-        using (MemoryStream ms = new MemoryStream())
-        using (BinaryWriter writer = new BinaryWriter(ms))
-        {
-            byte[] baseData = base.Serialize();
-            writer.Write(baseData.Length);
-            writer.Write(baseData);
-
-            string optionsJson = JsonConvert.SerializeObject(_options);
-            writer.Write(optionsJson);
-
-            writer.Write(_t);
-
-            return ms.ToArray();
-        }
-    }
-
-    /// <summary>
-    /// Restores the optimizer's state from a byte array created by the Serialize method.
-    /// </summary>
-    /// <param name="data">The byte array containing the serialized optimizer state.</param>
-    /// <exception cref="InvalidOperationException">Thrown when deserialization of optimizer options fails.</exception>
-    /// <remarks>
-    /// <para>
-    /// This method reconstructs the optimizer's state, including its options and internal counters,
-    /// from a binary format created by the Serialize method.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method is like rebuilding your learning assistant's brain from a saved picture.
-    /// 
-    /// Imagine you have a robot helper that you previously "photographed" (serialized):
-    /// 1. You give it the "photograph" (byte array)
-    /// 2. It reads the photograph piece by piece:
-    ///    - First, it rebuilds its basic knowledge (base data)
-    ///    - Then, it sets up its specific AdaMax settings (options)
-    ///    - Finally, it remembers how long it has been learning (time step)
-    /// 3. If anything goes wrong while reading the settings, it lets you know
-    /// 
-    /// After this process, your robot helper is back to exactly the same state it was in when you took the "photograph".
-    /// This is useful for:
-    /// - Continuing a learning session that was paused
-    /// - Setting up multiple identical helpers
-    /// - Recovering from a backup if something goes wrong
-    /// </para>
-    /// </remarks>
-    public override void Deserialize(byte[] data)
-    {
-        using (MemoryStream ms = new MemoryStream(data))
-        using (BinaryReader reader = new BinaryReader(ms))
-        {
-            int baseDataLength = reader.ReadInt32();
-            byte[] baseData = reader.ReadBytes(baseDataLength);
-            base.Deserialize(baseData);
-
-            string optionsJson = reader.ReadString();
-            _options = JsonConvert.DeserializeObject<AdaMaxOptimizerOptions<T, TInput, TOutput>>(optionsJson)
-                ?? throw new InvalidOperationException("Failed to deserialize optimizer options.");
-
-            _t = reader.ReadInt32();
-        }
-    }
-
     /// <summary>
     /// Generates a unique key for caching gradients specific to the AdaMax optimizer.
     /// </summary>
diff --git a/src/Optimizers/AdagradOptimizer.cs b/src/Optimizers/AdagradOptimizer.cs
index e2617483bc..6e73b46783 100644
--- a/src/Optimizers/AdagradOptimizer.cs
+++ b/src/Optimizers/AdagradOptimizer.cs
@@ -30,7 +30,7 @@ namespace AiDotNet.Optimizers;
 /// </remarks>
 [ComponentType(ComponentType.Optimizer)]
 [PipelineStage(PipelineStage.Training)]
-public class AdagradOptimizer<T, TInput, TOutput> : GradientBasedOptimizerBase<T, TInput, TOutput>, Fused.IFusedOptimizerSpec
+public partial class AdagradOptimizer<T, TInput, TOutput> : GradientBasedOptimizerBase<T, TInput, TOutput>, Fused.IFusedOptimizerSpec
 {
     /// <summary>
     /// Describes this Adagrad instance for the fused kernel (Tensors
@@ -544,107 +544,6 @@ public override OptimizationAlgorithmOptions<T, TInput, TOutput> GetOptions()
         return _options;
     }
 
-    /// <summary>
-    /// Serializes the Adagrad optimizer to a byte array.
-    /// </summary>
-    /// <returns>A byte array representing the serialized state of the optimizer.</returns>
-    /// <remarks>
-    /// <para>
-    /// This method saves the current state of the Adagrad optimizer, including its base class state and specific options,
-    /// into a byte array. This allows the optimizer's state to be stored or transmitted.
-    /// </para>
-    /// <para><b>For Beginners:</b> This is like taking a snapshot of your learning assistant's current state.
-    /// 
-    /// The process:
-    /// 1. Saves the basic information (from the parent class)
-    /// 2. Saves the specific Adagrad settings
-    /// 3. Combines all this information into a single package (byte array)
-    /// 
-    /// This snapshot can be used later to recreate the exact same state of the optimizer,
-    /// which is useful for saving progress or sharing the optimizer's configuration.
-    /// </para>
-    /// </remarks>
-    public override byte[] Serialize()
-    {
-        using (MemoryStream ms = new MemoryStream())
-        using (BinaryWriter writer = new BinaryWriter(ms))
-        {
-            byte[] baseData = base.Serialize();
-            writer.Write(baseData.Length);
-            writer.Write(baseData);
-
-            string optionsJson = JsonConvert.SerializeObject(_options);
-            writer.Write(optionsJson);
-
-            // Serialize accumulated squared gradients
-            bool hasAccumulatedGradients = _accumulatedSquaredGradients is not null;
-            writer.Write(hasAccumulatedGradients);
-            if (hasAccumulatedGradients)
-            {
-                writer.Write((_accumulatedSquaredGradients ?? throw new InvalidOperationException("_accumulatedSquaredGradients has not been initialized.")).Length);
-                for (int i = 0; i < _accumulatedSquaredGradients.Length; i++)
-                {
-                    writer.Write(NumOps.ToDouble(_accumulatedSquaredGradients[i]));
-                }
-            }
-
-            return ms.ToArray();
-        }
-    }
-
-    /// <summary>
-    /// Deserializes the Adagrad optimizer from a byte array.
-    /// </summary>
-    /// <param name="data">The byte array containing the serialized optimizer state.</param>
-    /// <exception cref="InvalidOperationException">Thrown when deserialization of optimizer options fails.</exception>
-    /// <remarks>
-    /// <para>
-    /// This method reconstructs the state of the Adagrad optimizer from a byte array, including its base class state
-    /// and specific options. It's used to restore a previously serialized optimizer state.
-    /// </para>
-    /// <para><b>For Beginners:</b> This is like recreating your learning assistant from a saved snapshot.
-    ///
-    /// The process:
-    /// 1. Reads the basic information (for the parent class)
-    /// 2. Recreates the parent class state
-    /// 3. Reads and recreates the specific Adagrad settings
-    ///
-    /// This allows you to continue using the optimizer from exactly where you left off,
-    /// with all its learned information and settings intact.
-    /// </para>
-    /// </remarks>
-    public override void Deserialize(byte[] data)
-    {
-        using (MemoryStream ms = new MemoryStream(data))
-        using (BinaryReader reader = new BinaryReader(ms))
-        {
-            int baseDataLength = reader.ReadInt32();
-            byte[] baseData = reader.ReadBytes(baseDataLength);
-            base.Deserialize(baseData);
-
-            string optionsJson = reader.ReadString();
-            _options = JsonConvert.DeserializeObject<AdagradOptimizerOptions<T, TInput, TOutput>>(optionsJson)
-                ?? throw new InvalidOperationException("Failed to deserialize optimizer options.");
-
-            // Deserialize accumulated squared gradients
-            bool hasAccumulatedGradients = reader.ReadBoolean();
-            if (hasAccumulatedGradients)
-            {
-                int length = reader.ReadInt32();
-                T[] dataArray = new T[length];
-                for (int i = 0; i < length; i++)
-                {
-                    dataArray[i] = NumOps.FromDouble(reader.ReadDouble());
-                }
-                _accumulatedSquaredGradients = new Vector<T>(dataArray);
-            }
-            else
-            {
-                _accumulatedSquaredGradients = null;
-            }
-        }
-    }
-
     /// <summary>
     /// Generates a unique key for caching gradients based on the model, input data, and Adagrad-specific parameters.
     /// </summary>
diff --git a/src/Optimizers/Adam8BitOptimizer.cs b/src/Optimizers/Adam8BitOptimizer.cs
index 08a3818c0c..4952b90555 100644
--- a/src/Optimizers/Adam8BitOptimizer.cs
+++ b/src/Optimizers/Adam8BitOptimizer.cs
@@ -46,7 +46,7 @@ namespace AiDotNet.Optimizers;
 /// </remarks>
 [ComponentType(ComponentType.Optimizer)]
 [PipelineStage(PipelineStage.Training)]
-public class Adam8BitOptimizer<T, TInput, TOutput> : GradientBasedOptimizerBase<T, TInput, TOutput>, Fused.IFusedOptimizerSpec
+public partial class Adam8BitOptimizer<T, TInput, TOutput> : GradientBasedOptimizerBase<T, TInput, TOutput>, Fused.IFusedOptimizerSpec
 {
     /// <inheritdoc/>
     /// <remarks>
@@ -2030,420 +2030,6 @@ private static void WriteUShortArray(BinaryWriter writer, ushort[]? values)
         return values;
     }
 
-    /// <summary>
-    /// Serializes the optimizer's state into a byte array.
-    /// </summary>
-    public override byte[] Serialize()
-    {
-        using (MemoryStream ms = new MemoryStream())
-        using (BinaryWriter writer = new BinaryWriter(ms))
-        {
-            // Serialize base class data
-            byte[] baseData = base.Serialize();
-            writer.Write(baseData.Length);
-            writer.Write(baseData);
-
-            // Serialize options
-            string optionsJson = JsonConvert.SerializeObject(_options);
-            writer.Write(optionsJson);
-
-            // Magic header + format version. Pre-#1240 (v1) checkpoints
-            // wrote `_t` (the Adam step counter) immediately after the
-            // options JSON. Writing a bare version int here would be
-            // ambiguous: an older checkpoint with `_t == 2` (after just
-            // two training steps) would be mis-detected as v2 format and
-            // every field that follows would parse with the wrong layout
-            // (corrupted lengths, multi-GB phantom allocations on
-            // ReadBytes, confusing failures deep in the call stack).
-            //
-            // Write a distinctive 4-byte ASCII magic before the version
-            // so we disambiguate v2 from v1 by signature, not by guess.
-            // Magic = "A8B1" (Adam-8-Bit v1-of-versioned-format) which
-            // BinaryWriter writes as bytes 0x41 0x38 0x42 0x31 in stream
-            // order — visible in hex dumps. Probability that a v1 _t
-            // ever equals this 32-bit value is 1/2^32 (~2e-10), and
-            // because v1's _t is monotonic from 0 it'd take 0.83 billion
-            // steps to first hit the value — well past any realistic
-            // training run length. Independent of probability, the
-            // semantic check is unambiguous: v1 wrote a step counter,
-            // not this magic, so a match here is a deliberate v2 marker.
-            // Constants are class-level (Adam8BitV2Magic / StateFormatVersion)
-            // so Serialize/Deserialize can't drift out of sync.
-            writer.Write(Adam8BitV2Magic);
-            writer.Write(StateFormatVersion);
-
-            // Serialize 8-bit Adam-specific state
-            writer.Write(_t);
-            writer.Write(_parameterLength);
-            writer.Write(_numBlocks);
-
-            // Serialize quantized first moment (if used). Always emit a
-            // hasMState flag BEFORE the conditional payload so Deserialize
-            // doesn't blindly read length+data when the optimizer was never
-            // initialized (legacy UpdateSolution path) or when only the
-            // tape Step has run (no _mQuantized / _mFullPrecision yet).
-            // The previous serialization wrote the data conditionally but
-            // Deserialize unconditionally read it, producing
-            // EndOfStreamException on uninitialized state.
-            // The compressBothMoments flag is written for cross-checking on
-            // load — _options.CompressBothMoments is the authoritative source
-            // of truth (it round-trips through the options JSON above), but
-            // emitting it here lets Deserialize fail fast on a tampered or
-            // mode-mismatched payload before allocating the wrong moment
-            // representation.
-            writer.Write(_options.CompressBothMoments);
-            bool hasMState = _options.CompressBothMoments
-                ? _mQuantized is not null
-                : _mFullPrecision is not null;
-            writer.Write(hasMState);
-            if (hasMState)
-            {
-                if (_options.CompressBothMoments)
-                {
-                    writer.Write(_mQuantized!.Length);
-                    WriteVectorBytesChunked(writer, _mQuantized);
-                    foreach (var scale in _mScales!)
-                    {
-                        writer.Write(scale);
-                    }
-                }
-                else
-                {
-                    writer.Write(_mFullPrecision!.Length);
-                    foreach (var value in _mFullPrecision)
-                    {
-                        writer.Write(Convert.ToDouble(value));
-                    }
-                }
-            }
-
-            // Serialize quantized second moment
-            writer.Write(_vQuantized is not null);
-            if (_vQuantized is not null)
-            {
-                writer.Write(_vQuantized.Length);
-                WriteVectorBytesChunked(writer, _vQuantized);
-                foreach (var scale in _vScales!)
-                {
-                    writer.Write(scale);
-                }
-            }
-
-            // Tape-state checkpoint: persist both the bias-correction step
-            // counter and the per-parameter quantized moments by parameter
-            // order. The runtime dictionary is still keyed by Tensor<T>
-            // reference for hot-path lookup, but the serialized form uses
-            // the stable TapeStepContext parameter index and rebinds to the
-            // next model's tensor references on the first resumed Step.
-            writer.Write(_tapeStep);
-            WriteTapeStates(writer);
-
-            return ms.ToArray();
-        }
-    }
-
-    /// <summary>
-    /// Deserializes the optimizer's state from a byte array.
-    /// </summary>
-    public override void Deserialize(byte[] data)
-    {
-        using (MemoryStream ms = new MemoryStream(data))
-        using (BinaryReader reader = new BinaryReader(ms))
-        {
-            // Deserialize base class data. The first ReadBytes is the only
-            // pre-magic-check allocation in the wire format, so guard it
-            // against malformed/tampered checkpoints that could otherwise
-            // request an arbitrarily large allocation. Cap against the
-            // remaining stream length: a baseDataLength larger than what's
-            // actually present in the buffer is unambiguously invalid.
-            int baseDataLength = reader.ReadInt32();
-            if (baseDataLength < 0)
-            {
-                throw new InvalidOperationException(
-                    $"Adam8BitOptimizer: invalid baseDataLength={baseDataLength} in checkpoint header.");
-            }
-            long remainingBytes = ms.Length - ms.Position;
-            if (baseDataLength > remainingBytes)
-            {
-                throw new InvalidOperationException(
-                    $"Adam8BitOptimizer: declared baseDataLength={baseDataLength} exceeds remaining " +
-                    $"stream bytes ({remainingBytes}). Checkpoint is truncated or malformed.");
-            }
-            byte[] baseData = reader.ReadBytes(baseDataLength);
-            base.Deserialize(baseData);
-
-            // Deserialize options
-            string optionsJson = reader.ReadString();
-            _options = JsonConvert.DeserializeObject<Adam8BitOptimizerOptions<T, TInput, TOutput>>(optionsJson)
-                ?? throw new InvalidOperationException("Failed to deserialize optimizer options.");
-
-            // Read magic header + format version (added in #1240 follow-
-            // up). Pre-#1240 (v1) payloads wrote _t immediately after the
-            // options JSON; using a bare version int as the discriminator
-            // would mis-detect any v1 checkpoint whose _t happens to equal
-            // the version number. Read the magic first — the magic value
-            // is a fixed marker (class-level constant Adam8BitV2Magic)
-            // that v1 never wrote at this position, so a match here is
-            // unambiguous evidence of v2 format.
-            int magic = reader.ReadInt32();
-            if (magic != Adam8BitV2Magic)
-            {
-                throw new InvalidOperationException(
-                    $"Adam8BitOptimizer: incompatible checkpoint format. Expected v2 " +
-                    $"magic header 0x{Adam8BitV2Magic:X8} ('A8B1' in ASCII LE) immediately " +
-                    $"after the options JSON; got 0x{magic:X8}. Older checkpoints " +
-                    $"(format v1) wrote the Adam step counter (_t) at that position and " +
-                    $"the byte layout that follows is incompatible with v2. Re-serialize " +
-                    $"this checkpoint with a build that writes the v2 byte-quantized state " +
-                    $"format. If you authored a custom serializer, write " +
-                    $"BinaryWriter.Write(0x{Adam8BitV2Magic:X8}) followed by " +
-                    $"BinaryWriter.Write((int){StateFormatVersion}) immediately after the " +
-                    $"options JSON.");
-            }
-            int stateFormatVersion = reader.ReadInt32();
-            if (stateFormatVersion != StateFormatVersion)
-            {
-                throw new InvalidOperationException(
-                    $"Adam8BitOptimizer: unrecognized format version {stateFormatVersion} " +
-                    $"after valid v2 magic. Expected version {StateFormatVersion}; this " +
-                    $"build does not yet support reading newer formats. Upgrade to a build " +
-                    $"that recognizes version {stateFormatVersion} or re-serialize from " +
-                    $"this build.");
-            }
-
-            // Deserialize state
-            _t = reader.ReadInt32();
-            _parameterLength = reader.ReadInt32();
-            _numBlocks = reader.ReadInt32();
-
-            // Bounds-check ALL structural fields before allocating anything
-            // sized off them. Untrusted/tampered checkpoints could otherwise:
-            //   (a) force multi-GB phantom allocations on the ReadBytes calls
-            //       below by claiming impossibly large lengths,
-            //   (b) trigger DivideByZeroException via BlockSize <= 0,
-            //   (c) overflow (_parameterLength + blockSize - 1) when both
-            //       are near int.MaxValue and the addition wraps to negative,
-            //   (d) skip the consistency check via negative _numBlocks that
-            //       happen to satisfy `_numBlocks != expectedNumBlocks`
-            //       being false (it isn't, but defensive belt-and-suspenders).
-            // All checks happen before any allocation downstream.
-            if (_parameterLength < 0)
-                throw new InvalidOperationException(
-                    $"Adam8BitOptimizer: invalid _parameterLength={_parameterLength} in checkpoint.");
-            int blockSize = _options.BlockSize;
-            if (blockSize <= 0)
-                throw new InvalidOperationException(
-                    $"Adam8BitOptimizer: invalid BlockSize={blockSize} in checkpoint options. " +
-                    $"BlockSize must be positive (typical values: 64, 128, 256, 2048).");
-            if (_numBlocks < 0)
-                throw new InvalidOperationException(
-                    $"Adam8BitOptimizer: invalid _numBlocks={_numBlocks} in checkpoint.");
-            // Compute expected blocks in long arithmetic to avoid int
-            // overflow on hostile _parameterLength near int.MaxValue.
-            long expectedNumBlocksLong = _parameterLength == 0 ? 0L
-                : ((long)_parameterLength + blockSize - 1L) / blockSize;
-            if (expectedNumBlocksLong > int.MaxValue)
-                throw new InvalidOperationException(
-                    $"Adam8BitOptimizer: _parameterLength={_parameterLength} and BlockSize=" +
-                    $"{blockSize} produce {expectedNumBlocksLong} blocks, exceeding int.MaxValue. " +
-                    $"Checkpoint is malformed or out of supported range.");
-            if (_numBlocks != (int)expectedNumBlocksLong)
-                throw new InvalidOperationException(
-                    $"Adam8BitOptimizer: _numBlocks={_numBlocks} inconsistent with " +
-                    $"_parameterLength={_parameterLength} and BlockSize={blockSize} " +
-                    $"(expected {expectedNumBlocksLong}). Checkpoint may be corrupted.");
-
-            // The m-quantized and v-quantized read branches below each
-            // cap their declared length against the remaining stream
-            // bytes (ms.Length - ms.Position) so a payload claiming
-            // mLength=int.MaxValue can't force a 2 GB ReadBytes
-            // allocation before the truncation check fires.
-
-            // Deserialize first moment. The hasMState flag (added in #1240
-            // follow-up) tells us whether m was actually initialized at
-            // serialize time. If false, leave the m fields null so the
-            // first Step / UpdateSolution call after deser allocates them
-            // freshly — matches the contract of an optimizer that was
-            // serialized before any training had run.
-            //
-            // The streamed compressBothMoments flag is cross-checked
-            // against _options.CompressBothMoments (the authoritative
-            // value, just deserialized from the options JSON). A
-            // mismatch indicates a tampered payload, manual format
-            // surgery, or a bug — fail fast rather than allocate the
-            // wrong moment representation and silently produce wrong
-            // updates downstream.
-            bool streamedCompressBothMoments = reader.ReadBoolean();
-            if (streamedCompressBothMoments != _options.CompressBothMoments)
-                throw new InvalidOperationException(
-                    $"Adam8BitOptimizer: checkpoint compressBothMoments flag " +
-                    $"({streamedCompressBothMoments}) does not match the value in the " +
-                    $"deserialized options ({_options.CompressBothMoments}). The options " +
-                    $"JSON is the source of truth — a mismatch here means the payload's " +
-                    $"m-state layout is inconsistent with the options that were " +
-                    $"serialized alongside it. Re-serialize from a consistent build.");
-            bool hasMState = reader.ReadBoolean();
-            if (hasMState)
-            {
-                if (_options.CompressBothMoments)
-                {
-                    int mLength = reader.ReadInt32();
-                    if (mLength != _parameterLength)
-                        throw new InvalidOperationException(
-                            $"Adam8BitOptimizer: m-quantized length {mLength} does not " +
-                            $"match _parameterLength={_parameterLength}.");
-                    // Pre-check: payload can't exceed the remaining stream
-                    // bytes — protects against a malformed payload whose
-                    // declared length passes the _parameterLength check but
-                    // the actual data was truncated upstream. Without this,
-                    // ReadBytes would allocate a full-sized array and only
-                    // then notice the truncation.
-                    long mAfter = ms.Position + mLength;
-                    if (mLength < 0 || mAfter > ms.Length)
-                        throw new InvalidOperationException(
-                            $"Adam8BitOptimizer: m-quantized declared length {mLength} exceeds " +
-                            $"remaining stream bytes ({ms.Length - ms.Position}). Checkpoint truncated.");
-                    // Bulk read — per-element copy was O(N) writer touches
-                    // and unnecessarily slow for large checkpoints. ReadBytes
-                    // returns a single contiguous byte[] which we copy into
-                    // the Vector<byte>. The bounds check above caps the
-                    // allocation at remaining stream bytes so a tampered
-                    // length can't force a multi-GB phantom allocation.
-                    var mBytes = reader.ReadBytes(mLength);
-                    if (mBytes.Length != mLength)
-                        throw new InvalidOperationException(
-                            $"Adam8BitOptimizer: m-quantized truncated (expected {mLength} " +
-                            $"bytes, got {mBytes.Length}). Checkpoint is corrupted.");
-                    _mQuantized = new Vector<byte>(mLength);
-                    for (int i = 0; i < mLength; i++) _mQuantized[i] = mBytes[i];
-                    _mScales = new Vector<double>(_numBlocks);
-                    for (int i = 0; i < _numBlocks; i++)
-                    {
-                        _mScales[i] = reader.ReadDouble();
-                    }
-                    // Clear stale full-precision m on mode switch — see
-                    // OzYc: deserializing a CompressBothMoments=true payload
-                    // into an instance that previously held _mFullPrecision
-                    // would otherwise leave that buffer resident, inflating
-                    // GetMemoryUsage and breaking the 8x savings claim.
-                    _mFullPrecision = null;
-                }
-                else
-                {
-                    int mLength = reader.ReadInt32();
-                    if (mLength != _parameterLength)
-                        throw new InvalidOperationException(
-                            $"Adam8BitOptimizer: m-fullprecision length {mLength} does not " +
-                            $"match _parameterLength={_parameterLength}.");
-                    _mFullPrecision = new Vector<T>(mLength);
-                    for (int i = 0; i < mLength; i++)
-                    {
-                        _mFullPrecision[i] = NumOps.FromDouble(reader.ReadDouble());
-                    }
-                    // Clear stale quantized m on mode switch (symmetric
-                    // with the compressBothMoments branch above).
-                    _mQuantized = null;
-                    _mScales = null;
-                }
-            }
-            else
-            {
-                _mQuantized = null;
-                _mFullPrecision = null;
-                _mScales = null;
-            }
-
-            // Deserialize second moment
-            bool hasVQuantized = reader.ReadBoolean();
-            if (hasVQuantized)
-            {
-                int vLength = reader.ReadInt32();
-                if (vLength != _parameterLength)
-                    throw new InvalidOperationException(
-                        $"Adam8BitOptimizer: v-quantized length {vLength} does not " +
-                        $"match _parameterLength={_parameterLength}.");
-                // Pre-check declared length against remaining stream — see
-                // the m-quantized branch for rationale.
-                long vAfter = ms.Position + vLength;
-                if (vLength < 0 || vAfter > ms.Length)
-                    throw new InvalidOperationException(
-                        $"Adam8BitOptimizer: v-quantized declared length {vLength} exceeds " +
-                        $"remaining stream bytes ({ms.Length - ms.Position}). Checkpoint truncated.");
-                var vBytes = reader.ReadBytes(vLength);
-                if (vBytes.Length != vLength)
-                    throw new InvalidOperationException(
-                        $"Adam8BitOptimizer: v-quantized truncated (expected {vLength} " +
-                        $"bytes, got {vBytes.Length}). Checkpoint is corrupted.");
-                _vQuantized = new Vector<byte>(vLength);
-                for (int i = 0; i < vLength; i++) _vQuantized[i] = vBytes[i];
-                _vScales = new Vector<double>(_numBlocks);
-                for (int i = 0; i < _numBlocks; i++)
-                {
-                    _vScales[i] = reader.ReadDouble();
-                }
-            }
-            else
-            {
-                // Clear stale v state when deserializing into a reused
-                // optimizer instance. Without this, an instance that
-                // previously held _vQuantized / _vScales from an earlier
-                // load would carry that state forward when a fresh,
-                // never-stepped checkpoint is loaded — silently producing
-                // wrong updates. Symmetric with the m-state else branch
-                // above.
-                _vQuantized = null;
-                _vScales = null;
-            }
-
-            // Tape-state checkpoint (matches Serialize): read the global
-            // step counter plus per-parameter quantized moments. Some older
-            // v2 payloads ended before any tape-step data existed; those
-            // remain readable and resume with cold-started tape moments.
-            _tapeStates.Clear();
-            lock (_pendingTapeStatesLock)
-            {
-                _pendingTapeStatesByParameterIndex.Clear();
-            }
-            long tapePayloadBytes = reader.BaseStream.Length - reader.BaseStream.Position;
-            if (tapePayloadBytes == 0)
-            {
-                _tapeStep = 0;
-                InitializeAdaptiveParameters();
-                return;
-            }
-
-            if (tapePayloadBytes < sizeof(int))
-            {
-                throw new InvalidOperationException(
-                    "Adam8BitOptimizer: truncated tape-state payload before the tape-step header.");
-            }
-
-            _tapeStep = reader.ReadInt32();
-            // A negative step would make the next Step()'s bias-correction (1 - beta^t) invalid, and a
-            // step of -1 incrementing to 0 divides by zero. Reject it rather than corrupt training.
-            if (_tapeStep < 0)
-            {
-                throw new InvalidOperationException(
-                    $"Adam8BitOptimizer: invalid tape-step counter {_tapeStep} in checkpoint.");
-            }
-            if (reader.BaseStream.Position < reader.BaseStream.Length)
-            {
-                try
-                {
-                    ReadTapeStates(reader);
-                }
-                catch (EndOfStreamException ex)
-                {
-                    throw new InvalidOperationException(
-                        "Adam8BitOptimizer: truncated tape-state payload after the tape-step header.",
-                        ex);
-                }
-            }
-
-            InitializeAdaptiveParameters();
-        }
-    }
-
     /// <summary>
     /// Generates a unique key for caching gradients.
     /// </summary>
diff --git a/src/Optimizers/AdamOptimizer.cs b/src/Optimizers/AdamOptimizer.cs
index 37f9cacbd8..3381736a6a 100644
--- a/src/Optimizers/AdamOptimizer.cs
+++ b/src/Optimizers/AdamOptimizer.cs
@@ -24,7 +24,7 @@ namespace AiDotNet.Optimizers;
 /// </remarks>
 [ComponentType(ComponentType.Optimizer)]
 [PipelineStage(PipelineStage.Training)]
-public class AdamOptimizer<T, TInput, TOutput> : GradientBasedOptimizerBase<T, TInput, TOutput>, Fused.IFusedOptimizerSpec
+public partial class AdamOptimizer<T, TInput, TOutput> : GradientBasedOptimizerBase<T, TInput, TOutput>, Fused.IFusedOptimizerSpec
 {
     /// <summary>
     /// The options specific to the Adam optimizer.
@@ -1430,130 +1430,6 @@ public override OptimizationAlgorithmOptions<T, TInput, TOutput> GetOptions()
         return _options;
     }
 
-    /// <summary>
-    /// Serializes the optimizer's state into a byte array.
-    /// </summary>
-    /// <returns>A byte array representing the serialized state of the optimizer.</returns>
-    /// <remarks>
-    /// <para><b>For Beginners:</b> This method saves the optimizer's current state into a compact form.
-    /// It's like taking a snapshot of the optimizer's memory and settings, which can be used later to recreate its exact state.
-    /// </para>
-    /// </remarks>
-    public override byte[] Serialize()
-    {
-        using (MemoryStream ms = new MemoryStream())
-        using (BinaryWriter writer = new BinaryWriter(ms))
-        {
-            // Serialize base class data
-            byte[] baseData = base.Serialize();
-            writer.Write(baseData.Length);
-            writer.Write(baseData);
-
-            // Serialize AdamOptimizerOptions
-            string optionsJson = JsonConvert.SerializeObject(_options);
-            writer.Write(optionsJson);
-
-            // Serialize Adam-specific data
-            writer.Write(_t);
-            writer.Write(_m.Length);
-            foreach (var value in _m)
-            {
-                writer.Write(Convert.ToDouble(value));
-            }
-            writer.Write(_v.Length);
-            foreach (var value in _v)
-            {
-                writer.Write(Convert.ToDouble(value));
-            }
-
-            // Serialize the AMSGrad running-max buffer. A length of -1
-            // encodes "not yet allocated" (the AMSGrad option is off or
-            // the optimizer hasn't seen its first update); any
-            // non-negative length is the actual element count followed
-            // by that many doubles. Without this, a checkpoint restored
-            // on an AMSGrad optimizer would resume with a fresh empty
-            // v̂_max and diverge from uninterrupted training.
-            // (PR #1350 round-2 review.)
-            writer.Write(_vMaxVector?.Length ?? -1);
-            if (_vMaxVector is not null)
-            {
-                foreach (var value in _vMaxVector)
-                {
-                    writer.Write(Convert.ToDouble(value));
-                }
-            }
-
-            return ms.ToArray();
-        }
-    }
-
-    /// <summary>
-    /// Deserializes the optimizer's state from a byte array.
-    /// </summary>
-    /// <param name="data">The byte array containing the serialized optimizer state.</param>
-    /// <remarks>
-    /// <para><b>For Beginners:</b> This method rebuilds the optimizer's state from a saved snapshot.
-    /// It's like restoring the optimizer's memory and settings from a backup, allowing you to continue from where you left off.
-    /// </para>
-    /// </remarks>
-    public override void Deserialize(byte[] data)
-    {
-        using (MemoryStream ms = new MemoryStream(data))
-        using (BinaryReader reader = new BinaryReader(ms))
-        {
-            // Deserialize base class data
-            int baseDataLength = reader.ReadInt32();
-            byte[] baseData = reader.ReadBytes(baseDataLength);
-            base.Deserialize(baseData);
-
-            // Deserialize AdamOptimizerOptions
-            string optionsJson = reader.ReadString();
-            _options = JsonConvert.DeserializeObject<AdamOptimizerOptions<T, TInput, TOutput>>(optionsJson)
-                ?? throw new InvalidOperationException("Failed to deserialize optimizer options.");
-
-            // Deserialize Adam-specific data
-            _t = reader.ReadInt32();
-            int mLength = reader.ReadInt32();
-            _m = new Vector<T>(mLength);
-            for (int i = 0; i < mLength; i++)
-            {
-                _m[i] = NumOps.FromDouble(reader.ReadDouble());
-            }
-            int vLength = reader.ReadInt32();
-            _v = new Vector<T>(vLength);
-            for (int i = 0; i < vLength; i++)
-            {
-                _v[i] = NumOps.FromDouble(reader.ReadDouble());
-            }
-
-            // Restore the AMSGrad running-max buffer if present in the
-            // checkpoint. Length -1 indicates "not yet allocated" (the
-            // sentinel emitted by Serialize when UseAMSGrad is off or the
-            // optimizer hadn't taken its first AMSGrad step yet); any
-            // non-negative length is a real vector. Older checkpoints
-            // without this trailing field will fail the ReadInt32 here —
-            // matching the broader Serialize/Deserialize contract that
-            // older checkpoints aren't forward-compatible across schema
-            // changes. (PR #1350 round-2 review.)
-            int vMaxLength = reader.ReadInt32();
-            if (vMaxLength < 0)
-            {
-                _vMaxVector = null;
-            }
-            else
-            {
-                _vMaxVector = new Vector<T>(vMaxLength);
-                for (int i = 0; i < vMaxLength; i++)
-                {
-                    _vMaxVector[i] = NumOps.FromDouble(reader.ReadDouble());
-                }
-            }
-
-            // Initialize adaptive parameters from deserialized options
-            InitializeAdaptiveParameters();
-        }
-    }
-
     /// <summary>
     /// Generates a unique key for caching gradients.
     /// </summary>
diff --git a/src/Optimizers/AdamWOptimizer.cs b/src/Optimizers/AdamWOptimizer.cs
index 4b511656ec..488b61fd20 100644
--- a/src/Optimizers/AdamWOptimizer.cs
+++ b/src/Optimizers/AdamWOptimizer.cs
@@ -46,7 +46,7 @@ namespace AiDotNet.Optimizers;
 /// </example>
 [ComponentType(ComponentType.Optimizer)]
 [PipelineStage(PipelineStage.Training)]
-public class AdamWOptimizer<T, TInput, TOutput> : GradientBasedOptimizerBase<T, TInput, TOutput>, Fused.IFusedOptimizerSpec
+public partial class AdamWOptimizer<T, TInput, TOutput> : GradientBasedOptimizerBase<T, TInput, TOutput>, Fused.IFusedOptimizerSpec
 {
     /// <summary>
     /// The options specific to the AdamW optimizer.
@@ -874,94 +874,6 @@ public override OptimizationAlgorithmOptions<T, TInput, TOutput> GetOptions()
         return _options;
     }
 
-    /// <summary>
-    /// Serializes the optimizer's state into a byte array.
-    /// </summary>
-    public override byte[] Serialize()
-    {
-        using (MemoryStream ms = new MemoryStream())
-        using (BinaryWriter writer = new BinaryWriter(ms))
-        {
-            byte[] baseData = base.Serialize();
-            writer.Write(baseData.Length);
-            writer.Write(baseData);
-
-            string optionsJson = JsonConvert.SerializeObject(_options);
-            writer.Write(optionsJson);
-
-            writer.Write(_t);
-            writer.Write(_m.Length);
-            foreach (var value in _m)
-            {
-                writer.Write(Convert.ToDouble(value));
-            }
-            writer.Write(_v.Length);
-            foreach (var value in _v)
-            {
-                writer.Write(Convert.ToDouble(value));
-            }
-
-            // Serialize vMax if AMSGrad is enabled
-            writer.Write(_vMax != null);
-            if (_vMax != null)
-            {
-                writer.Write(_vMax.Length);
-                foreach (var value in _vMax)
-                {
-                    writer.Write(Convert.ToDouble(value));
-                }
-            }
-
-            return ms.ToArray();
-        }
-    }
-
-    /// <summary>
-    /// Deserializes the optimizer's state from a byte array.
-    /// </summary>
-    public override void Deserialize(byte[] data)
-    {
-        using (MemoryStream ms = new MemoryStream(data))
-        using (BinaryReader reader = new BinaryReader(ms))
-        {
-            int baseDataLength = reader.ReadInt32();
-            byte[] baseData = reader.ReadBytes(baseDataLength);
-            base.Deserialize(baseData);
-
-            string optionsJson = reader.ReadString();
-            _options = JsonConvert.DeserializeObject<AdamWOptimizerOptions<T, TInput, TOutput>>(optionsJson)
-                ?? throw new InvalidOperationException("Failed to deserialize optimizer options.");
-
-            _t = reader.ReadInt32();
-            int mLength = reader.ReadInt32();
-            _m = new Vector<T>(mLength);
-            for (int i = 0; i < mLength; i++)
-            {
-                _m[i] = NumOps.FromDouble(reader.ReadDouble());
-            }
-            int vLength = reader.ReadInt32();
-            _v = new Vector<T>(vLength);
-            for (int i = 0; i < vLength; i++)
-            {
-                _v[i] = NumOps.FromDouble(reader.ReadDouble());
-            }
-
-            // Deserialize vMax if present
-            bool hasVMax = reader.ReadBoolean();
-            if (hasVMax)
-            {
-                int vMaxLength = reader.ReadInt32();
-                _vMax = new Vector<T>(vMaxLength);
-                for (int i = 0; i < vMaxLength; i++)
-                {
-                    _vMax[i] = NumOps.FromDouble(reader.ReadDouble());
-                }
-            }
-
-            InitializeAdaptiveParameters();
-        }
-    }
-
     /// <summary>
     /// Generates a unique key for caching gradients.
     /// </summary>
diff --git a/src/Optimizers/AntColonyOptimizer.cs b/src/Optimizers/AntColonyOptimizer.cs
index a4f7471584..e4b03c8e76 100644
--- a/src/Optimizers/AntColonyOptimizer.cs
+++ b/src/Optimizers/AntColonyOptimizer.cs
@@ -24,7 +24,7 @@ namespace AiDotNet.Optimizers;
 /// </remarks>
 [ComponentType(ComponentType.Optimizer)]
 [PipelineStage(PipelineStage.Training)]
-public class AntColonyOptimizer<T, TInput, TOutput> : OptimizerBase<T, TInput, TOutput>, IDerivativeFreeFunctionOptimizer<T>
+public partial class AntColonyOptimizer<T, TInput, TOutput> : OptimizerBase<T, TInput, TOutput>, IDerivativeFreeFunctionOptimizer<T>
 {
     /// <summary>
     /// Options specific to the Ant Colony Optimization algorithm.
@@ -417,65 +417,6 @@ public override OptimizationAlgorithmOptions<T, TInput, TOutput> GetOptions()
         return _antColonyOptions;
     }
 
-    /// <summary>
-    /// Converts the current state of the optimizer into a byte array for storage or transmission.
-    /// </summary>
-    /// <returns>A byte array representing the serialized state of the optimizer.</returns>
-    /// <remarks>
-    /// <para><b>For Beginners:</b> This method takes all the important information about the current state
-    /// of the ant colony optimizer and turns it into a format that can be easily saved or sent to another computer.</para>
-    /// </remarks>
-    public override byte[] Serialize()
-    {
-        using MemoryStream ms = new MemoryStream();
-        using BinaryWriter writer = new BinaryWriter(ms);
-
-        // Serialize base class data
-        byte[] baseData = base.Serialize();
-        writer.Write(baseData.Length);
-        writer.Write(baseData);
-
-        // Serialize AntColonyOptimizerOptions
-        string optionsJson = JsonConvert.SerializeObject(_antColonyOptions);
-        writer.Write(optionsJson);
-
-        // Serialize adaptive parameters
-        writer.Write(Convert.ToDouble(_currentPheromoneEvaporationRate));
-        writer.Write(Convert.ToDouble(_currentPheromoneIntensity));
-
-        return ms.ToArray();
-    }
-
-    /// <summary>
-    /// Restores the state of the optimizer from a byte array.
-    /// </summary>
-    /// <param name="data">The byte array containing the serialized state of the optimizer.</param>
-    /// <exception cref="InvalidOperationException">Thrown when deserialization of optimizer options fails.</exception>
-    /// <remarks>
-    /// <para><b>For Beginners:</b> This method takes a saved state of the ant colony optimizer (in the form of a byte array)
-    /// and uses it to restore the optimizer to that state. It's like loading a saved game, bringing back all the
-    /// important settings and progress that were saved earlier.</para>
-    /// </remarks>
-    public override void Deserialize(byte[] data)
-    {
-        using MemoryStream ms = new MemoryStream(data);
-        using BinaryReader reader = new BinaryReader(ms);
-
-        // Deserialize base class data
-        int baseDataLength = reader.ReadInt32();
-        byte[] baseData = reader.ReadBytes(baseDataLength);
-        base.Deserialize(baseData);
-
-        // Deserialize AntColonyOptimizerOptions
-        string optionsJson = reader.ReadString();
-        _antColonyOptions = JsonConvert.DeserializeObject<AntColonyOptimizationOptions<T, TInput, TOutput>>(optionsJson)
-            ?? throw new InvalidOperationException("Failed to deserialize optimizer options.");
-
-        // Deserialize adaptive parameters
-        _currentPheromoneEvaporationRate = NumOps.FromDouble(reader.ReadDouble());
-        _currentPheromoneIntensity = NumOps.FromDouble(reader.ReadDouble());
-    }
-
     /// <summary>
     /// Creates an ant colony optimizer for minimizing a plain function, with no model attached.
     /// </summary>
diff --git a/src/Optimizers/BFGSOptimizer.cs b/src/Optimizers/BFGSOptimizer.cs
index 169fac1022..bd1ae4f9f1 100644
--- a/src/Optimizers/BFGSOptimizer.cs
+++ b/src/Optimizers/BFGSOptimizer.cs
@@ -24,7 +24,7 @@ namespace AiDotNet.Optimizers;
 /// </remarks>
 [ComponentType(ComponentType.Optimizer)]
 [PipelineStage(PipelineStage.Training)]
-public class BFGSOptimizer<T, TInput, TOutput> : GradientBasedOptimizerBase<T, TInput, TOutput>, Fused.IFusedOptimizerSpec
+public partial class BFGSOptimizer<T, TInput, TOutput> : GradientBasedOptimizerBase<T, TInput, TOutput>, Fused.IFusedOptimizerSpec
 {
     /// <summary>
     /// Declines to fuse, always.
@@ -513,61 +513,6 @@ public override OptimizationAlgorithmOptions<T, TInput, TOutput> GetOptions()
         return _options;
     }
 
-    /// <summary>
-    /// Converts the current state of the BFGS optimizer into a byte array for storage or transmission.
-    /// </summary>
-    /// <returns>A byte array representing the serialized state of the optimizer.</returns>
-    /// <remarks>
-    /// <para><b>For Beginners:</b> This method takes all the important information about the current state
-    /// of the BFGS Optimizer and turns it into a format that can be easily saved or sent to another computer.
-    /// It includes both the base optimizer data and BFGS-specific data.
-    /// </para>
-    /// </remarks>
-    public override byte[] Serialize()
-    {
-        using (MemoryStream ms = new MemoryStream())
-        using (BinaryWriter writer = new BinaryWriter(ms))
-        {
-            byte[] baseData = base.Serialize();
-            writer.Write(baseData.Length);
-            writer.Write(baseData);
-
-            string optionsJson = JsonConvert.SerializeObject(_options);
-            writer.Write(optionsJson);
-
-            writer.Write(_iteration);
-
-            return ms.ToArray();
-        }
-    }
-
-    /// <summary>
-    /// Restores the state of the BFGS optimizer from a byte array.
-    /// </summary>
-    /// <param name="data">The byte array containing the serialized state of the optimizer.</param>
-    /// <remarks>
-    /// <para><b>For Beginners:</b> This method takes a saved state of the BFGS Optimizer (in the form of a byte array)
-    /// and uses it to restore the optimizer to that state. It's like loading a saved game, bringing back all the
-    /// important settings and progress that were saved earlier.
-    /// </para>
-    /// </remarks>
-    public override void Deserialize(byte[] data)
-    {
-        using (MemoryStream ms = new MemoryStream(data))
-        using (BinaryReader reader = new BinaryReader(ms))
-        {
-            int baseDataLength = reader.ReadInt32();
-            byte[] baseData = reader.ReadBytes(baseDataLength);
-            base.Deserialize(baseData);
-
-            string optionsJson = reader.ReadString();
-            _options = JsonConvert.DeserializeObject<BFGSOptimizerOptions<T, TInput, TOutput>>(optionsJson)
-                ?? throw new InvalidOperationException("Failed to deserialize optimizer options.");
-
-            _iteration = reader.ReadInt32();
-        }
-    }
-
     /// <summary>
     /// Generates a unique key for caching gradients in the BFGS optimization process.
     /// </summary>
diff --git a/src/Optimizers/BayesianOptimizer.cs b/src/Optimizers/BayesianOptimizer.cs
index 314135823a..9d12330fae 100644
--- a/src/Optimizers/BayesianOptimizer.cs
+++ b/src/Optimizers/BayesianOptimizer.cs
@@ -23,7 +23,7 @@ namespace AiDotNet.Optimizers;
 /// </remarks>
 [ComponentType(ComponentType.Optimizer)]
 [PipelineStage(PipelineStage.Training)]
-public class BayesianOptimizer<T, TInput, TOutput> : OptimizerBase<T, TInput, TOutput>
+public partial class BayesianOptimizer<T, TInput, TOutput> : OptimizerBase<T, TInput, TOutput>
 {
     /// <summary>
     /// The options for configuring the Bayesian Optimization algorithm.
@@ -33,11 +33,13 @@ public class BayesianOptimizer<T, TInput, TOutput> : OptimizerBase<T, TInput, TO
     /// <summary>
     /// A matrix storing the points that have been sampled during the optimization process.
     /// </summary>
+    [AiDotNet.Attributes.Buffer]
     private Matrix<T> _sampledPoints;
 
     /// <summary>
     /// A vector storing the corresponding function values for the sampled points.
     /// </summary>
+    [AiDotNet.Attributes.Buffer]
     private Vector<T> _sampledValues;
 
     /// <summary>
@@ -313,95 +315,5 @@ public override OptimizationAlgorithmOptions<T, TInput, TOutput> GetOptions()
     {
         return _options;
     }
-
-    /// <summary>
-    /// Converts the current state of the optimizer into a byte array for storage or transmission.
-    /// </summary>
-    /// <returns>A byte array representing the serialized state of the optimizer.</returns>
-    /// <remarks>
-    /// <para><b>For Beginners:</b> This method takes all the important information about the current state
-    /// of the Bayesian Optimizer and turns it into a format that can be easily saved or sent to another computer.
-    /// </para>
-    /// </remarks>
-    public override byte[] Serialize()
-    {
-        using (MemoryStream ms = new MemoryStream())
-        using (BinaryWriter writer = new BinaryWriter(ms))
-        {
-            byte[] baseData = base.Serialize();
-            writer.Write(baseData.Length);
-            writer.Write(baseData);
-
-            string optionsJson = JsonConvert.SerializeObject(_options);
-            writer.Write(optionsJson);
-
-            // Serialize _sampledPoints
-            writer.Write(_sampledPoints.Rows);
-            writer.Write(_sampledPoints.Columns);
-            for (int i = 0; i < _sampledPoints.Rows; i++)
-            {
-                for (int j = 0; j < _sampledPoints.Columns; j++)
-                {
-                    writer.Write(Convert.ToDouble(_sampledPoints[i, j]));
-                }
-            }
-
-            // Serialize _sampledValues
-            writer.Write(_sampledValues.Length);
-            for (int i = 0; i < _sampledValues.Length; i++)
-            {
-                writer.Write(Convert.ToDouble(_sampledValues[i]));
-            }
-
-            return ms.ToArray();
-        }
-    }
-
-    /// <summary>
-    /// Restores the state of the optimizer from a byte array.
-    /// </summary>
-    /// <param name="data">The byte array containing the serialized state of the optimizer.</param>
-    /// <remarks>
-    /// <para><b>For Beginners:</b> This method takes a saved state of the Bayesian Optimizer (in the form of a byte array)
-    /// and uses it to restore the optimizer to that state. It's like loading a saved game, bringing back all the
-    /// important settings and progress that were saved earlier.
-    /// </para>
-    /// </remarks>
-    public override void Deserialize(byte[] data)
-    {
-        using (MemoryStream ms = new MemoryStream(data))
-        using (BinaryReader reader = new BinaryReader(ms))
-        {
-            int baseDataLength = reader.ReadInt32();
-            byte[] baseData = reader.ReadBytes(baseDataLength);
-            base.Deserialize(baseData);
-
-            string optionsJson = reader.ReadString();
-            _options = JsonConvert.DeserializeObject<BayesianOptimizerOptions<T, TInput, TOutput>>(optionsJson)
-                ?? throw new InvalidOperationException("Failed to deserialize optimizer options.");
-
-            // Deserialize _sampledPoints
-            int rows = reader.ReadInt32();
-            int columns = reader.ReadInt32();
-            _sampledPoints = new Matrix<T>(rows, columns);
-            for (int i = 0; i < rows; i++)
-            {
-                for (int j = 0; j < columns; j++)
-                {
-                    _sampledPoints[i, j] = NumOps.FromDouble(reader.ReadDouble());
-                }
-            }
-
-            // Deserialize _sampledValues
-            int valueCount = reader.ReadInt32();
-            _sampledValues = new Vector<T>(valueCount);
-            for (int i = 0; i < valueCount; i++)
-            {
-                _sampledValues[i] = NumOps.FromDouble(reader.ReadDouble());
-            }
-
-            _gaussianProcess = new StandardGaussianProcess<T>(_options.KernelFunction);
-        }
-    }
 }
 
diff --git a/src/Optimizers/CMAESOptimizer.cs b/src/Optimizers/CMAESOptimizer.cs
index b6832405a7..7fa9a143cc 100644
--- a/src/Optimizers/CMAESOptimizer.cs
+++ b/src/Optimizers/CMAESOptimizer.cs
@@ -25,7 +25,7 @@ namespace AiDotNet.Optimizers;
 /// </remarks>
 [ComponentType(ComponentType.Optimizer)]
 [PipelineStage(PipelineStage.Training)]
-public class CMAESOptimizer<T, TInput, TOutput> : OptimizerBase<T, TInput, TOutput>, IDerivativeFreeFunctionOptimizer<T>
+public partial class CMAESOptimizer<T, TInput, TOutput> : OptimizerBase<T, TInput, TOutput>, IDerivativeFreeFunctionOptimizer<T>
 {
     /// <summary>
     /// The options specific to the CMA-ES optimization algorithm.
@@ -476,70 +476,6 @@ public override OptimizationAlgorithmOptions<T, TInput, TOutput> GetOptions()
         return _options;
     }
 
-    /// <summary>
-    /// Serializes the current state of the CMA-ES optimizer into a byte array.
-    /// </summary>
-    /// <returns>A byte array representing the serialized state of the optimizer.</returns>
-    /// <remarks>
-    /// <para><b>For Beginners:</b> This method saves the current state of the optimizer into a format
-    /// that can be stored or transmitted. This is useful for saving progress or sharing the optimizer's state.
-    /// </para>
-    /// </remarks>
-    public override byte[] Serialize()
-    {
-        using MemoryStream ms = new MemoryStream();
-        using BinaryWriter writer = new BinaryWriter(ms);
-
-        byte[] baseData = base.Serialize();
-        writer.Write(baseData.Length);
-        writer.Write(baseData);
-
-        string optionsJson = JsonConvert.SerializeObject(_options);
-        writer.Write(optionsJson);
-
-        // Serialize CMA-ES specific data
-        SerializationHelper<T>.SerializeMatrix(writer, _population);
-        SerializationHelper<T>.SerializeVector(writer, _mean);
-        SerializationHelper<T>.SerializeMatrix(writer, _C);
-        SerializationHelper<T>.SerializeVector(writer, _pc);
-        SerializationHelper<T>.SerializeVector(writer, _ps);
-        SerializationHelper<T>.WriteValue(writer, _sigma);
-
-        return ms.ToArray();
-    }
-
-    /// <summary>
-    /// Deserializes a byte array to restore the state of the CMA-ES optimizer.
-    /// </summary>
-    /// <param name="data">The byte array containing the serialized state of the optimizer.</param>
-    /// <exception cref="InvalidOperationException">Thrown when deserialization of optimizer options fails.</exception>
-    /// <remarks>
-    /// <para><b>For Beginners:</b> This method loads a previously saved state of the optimizer.
-    /// It's like restoring a saved game, allowing you to continue from where you left off or use a shared optimizer state.
-    /// </para>
-    /// </remarks>
-    public override void Deserialize(byte[] data)
-    {
-        using MemoryStream ms = new MemoryStream(data);
-        using BinaryReader reader = new BinaryReader(ms);
-
-        int baseDataLength = reader.ReadInt32();
-        byte[] baseData = reader.ReadBytes(baseDataLength);
-        base.Deserialize(baseData);
-
-        string optionsJson = reader.ReadString();
-        _options = JsonConvert.DeserializeObject<CMAESOptimizerOptions<T, TInput, TOutput>>(optionsJson)
-            ?? throw new InvalidOperationException("Failed to deserialize optimizer options.");
-
-        // Deserialize CMA-ES specific data
-        _population = SerializationHelper<T>.DeserializeMatrix(reader);
-        _mean = SerializationHelper<T>.DeserializeVector(reader);
-        _C = SerializationHelper<T>.DeserializeMatrix(reader);
-        _pc = SerializationHelper<T>.DeserializeVector(reader);
-        _ps = SerializationHelper<T>.DeserializeVector(reader);
-        _sigma = SerializationHelper<T>.ReadValue(reader);
-    }
-
     /// <summary>
     /// Creates a CMA-ES optimizer for minimizing a plain function, with no model attached.
     /// </summary>
diff --git a/src/Optimizers/ConjugateGradientOptimizer.cs b/src/Optimizers/ConjugateGradientOptimizer.cs
index 99bf4eecab..31a922f146 100644
--- a/src/Optimizers/ConjugateGradientOptimizer.cs
+++ b/src/Optimizers/ConjugateGradientOptimizer.cs
@@ -25,7 +25,7 @@ namespace AiDotNet.Optimizers;
 /// </remarks>
 [ComponentType(ComponentType.Optimizer)]
 [PipelineStage(PipelineStage.Training)]
-public class ConjugateGradientOptimizer<T, TInput, TOutput> : GradientBasedOptimizerBase<T, TInput, TOutput>
+public partial class ConjugateGradientOptimizer<T, TInput, TOutput> : GradientBasedOptimizerBase<T, TInput, TOutput>
 {
     /// <summary>
     /// The options specific to the Conjugate Gradient optimization algorithm.
@@ -338,60 +338,6 @@ public override OptimizationAlgorithmOptions<T, TInput, TOutput> GetOptions()
         return _options;
     }
 
-    /// <summary>
-    /// Serializes the current state of the Conjugate Gradient optimizer into a byte array.
-    /// </summary>
-    /// <returns>A byte array representing the serialized state of the optimizer.</returns>
-    /// <remarks>
-    /// <para><b>For Beginners:</b> This method saves the current state of the optimizer into a format
-    /// that can be stored or transmitted. This is useful for saving progress or sharing the optimizer's state.
-    /// </para>
-    /// </remarks>
-    public override byte[] Serialize()
-    {
-        using (MemoryStream ms = new MemoryStream())
-        using (BinaryWriter writer = new BinaryWriter(ms))
-        {
-            byte[] baseData = base.Serialize();
-            writer.Write(baseData.Length);
-            writer.Write(baseData);
-
-            string optionsJson = JsonConvert.SerializeObject(_options);
-            writer.Write(optionsJson);
-
-            writer.Write(_iteration);
-
-            return ms.ToArray();
-        }
-    }
-
-    /// <summary>
-    /// Deserializes a byte array to restore the state of the Conjugate Gradient optimizer.
-    /// </summary>
-    /// <param name="data">The byte array containing the serialized state of the optimizer.</param>
-    /// <exception cref="InvalidOperationException">Thrown when deserialization of optimizer options fails.</exception>
-    /// <remarks>
-    /// <para><b>For Beginners:</b> This method loads a previously saved state of the optimizer.
-    /// It's like restoring a saved game, allowing you to continue from where you left off or use a shared optimizer state.
-    /// </para>
-    /// </remarks>
-    public override void Deserialize(byte[] data)
-    {
-        using (MemoryStream ms = new MemoryStream(data))
-        using (BinaryReader reader = new BinaryReader(ms))
-        {
-            int baseDataLength = reader.ReadInt32();
-            byte[] baseData = reader.ReadBytes(baseDataLength);
-            base.Deserialize(baseData);
-
-            string optionsJson = reader.ReadString();
-            _options = JsonConvert.DeserializeObject<ConjugateGradientOptimizerOptions<T, TInput, TOutput>>(optionsJson)
-                ?? throw new InvalidOperationException("Failed to deserialize optimizer options.");
-
-            _iteration = reader.ReadInt32();
-        }
-    }
-
     /// <summary>
     /// Generates a unique key for caching gradients in the Conjugate Gradient optimizer.
     /// </summary>
diff --git a/src/Optimizers/CoordinateDescentOptimizer.cs b/src/Optimizers/CoordinateDescentOptimizer.cs
index a5997a1cdf..97357f5fe8 100644
--- a/src/Optimizers/CoordinateDescentOptimizer.cs
+++ b/src/Optimizers/CoordinateDescentOptimizer.cs
@@ -25,7 +25,7 @@ namespace AiDotNet.Optimizers;
 /// </remarks>
 [ComponentType(ComponentType.Optimizer)]
 [PipelineStage(PipelineStage.Training)]
-public class CoordinateDescentOptimizer<T, TInput, TOutput> : GradientBasedOptimizerBase<T, TInput, TOutput>, Fused.IFusedOptimizerSpec
+public partial class CoordinateDescentOptimizer<T, TInput, TOutput> : GradientBasedOptimizerBase<T, TInput, TOutput>, Fused.IFusedOptimizerSpec
 {
     /// <summary>
     /// Describes this optimizer for the compiled fused-training kernel.
@@ -79,16 +79,19 @@ bool Fused.IFusedOptimizerSpec.TryGetFusedOptimizerConfig(out Fused.FusedOptimiz
     /// <summary>
     /// Vector of learning rates for each coordinate (variable) in the optimization problem.
     /// </summary>
+    [AiDotNet.Attributes.Buffer]
     private Vector<T> _learningRates;
 
     /// <summary>
     /// Vector of momentum values for each coordinate (variable) in the optimization problem.
     /// </summary>
+    [AiDotNet.Attributes.Buffer]
     private Vector<T> _momentums;
 
     /// <summary>
     /// Vector of previous update values for each coordinate (variable) in the optimization problem.
     /// </summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T> _previousUpdate;
 
     /// <summary>
@@ -406,86 +409,6 @@ public override OptimizationAlgorithmOptions<T, TInput, TOutput> GetOptions()
         return _options;
     }
 
-    /// <summary>
-    /// Serializes the Coordinate Descent optimizer to a byte array.
-    /// </summary>
-    /// <returns>A byte array representing the serialized state of the optimizer.</returns>
-    /// <remarks>
-    /// <para><b>For Beginners:</b> This method converts the current state of the optimizer into a series of bytes.
-    /// This is useful for saving the optimizer's state to a file or sending it over a network.
-    /// </para>
-    /// </remarks>
-    public override byte[] Serialize()
-    {
-        using (MemoryStream ms = new MemoryStream())
-        using (BinaryWriter writer = new BinaryWriter(ms))
-        {
-            byte[] baseData = base.Serialize();
-            writer.Write(baseData.Length);
-            writer.Write(baseData);
-
-            string optionsJson = JsonConvert.SerializeObject(_options);
-            writer.Write(optionsJson);
-
-            // Serialize _learningRates
-            byte[] learningRatesData = _learningRates.Serialize();
-            writer.Write(learningRatesData.Length);
-            writer.Write(learningRatesData);
-
-            // Serialize _momentums
-            byte[] momentumsData = _momentums.Serialize();
-            writer.Write(momentumsData.Length);
-            writer.Write(momentumsData);
-
-            // Serialize _previousUpdate
-            byte[] previousUpdateData = _previousUpdate.Serialize();
-            writer.Write(previousUpdateData.Length);
-            writer.Write(previousUpdateData);
-
-            return ms.ToArray();
-        }
-    }
-
-    /// <summary>
-    /// Deserializes the Coordinate Descent optimizer from a byte array.
-    /// </summary>
-    /// <param name="data">The byte array containing the serialized optimizer state.</param>
-    /// <exception cref="InvalidOperationException">Thrown when deserialization of optimizer options fails.</exception>
-    /// <remarks>
-    /// <para><b>For Beginners:</b> This method reconstructs the optimizer's state from a series of bytes.
-    /// It's used to restore a previously saved state of the optimizer, allowing you to continue from where you left off.
-    /// </para>
-    /// </remarks>
-    public override void Deserialize(byte[] data)
-    {
-        using (MemoryStream ms = new MemoryStream(data))
-        using (BinaryReader reader = new BinaryReader(ms))
-        {
-            int baseDataLength = reader.ReadInt32();
-            byte[] baseData = reader.ReadBytes(baseDataLength);
-            base.Deserialize(baseData);
-
-            string optionsJson = reader.ReadString();
-            _options = JsonConvert.DeserializeObject<CoordinateDescentOptimizerOptions<T, TInput, TOutput>>(optionsJson)
-                ?? throw new InvalidOperationException("Failed to deserialize optimizer options.");
-
-            // Deserialize _learningRates
-            int learningRatesLength = reader.ReadInt32();
-            byte[] learningRatesData = reader.ReadBytes(learningRatesLength);
-            _learningRates = Vector<T>.Deserialize(learningRatesData);
-
-            // Deserialize _momentums
-            int momentumsLength = reader.ReadInt32();
-            byte[] momentumsData = reader.ReadBytes(momentumsLength);
-            _momentums = Vector<T>.Deserialize(momentumsData);
-
-            // Deserialize _previousUpdate
-            int previousUpdateLength = reader.ReadInt32();
-            byte[] previousUpdateData = reader.ReadBytes(previousUpdateLength);
-            _previousUpdate = Vector<T>.Deserialize(previousUpdateData);
-        }
-    }
-
     /// <inheritdoc />
     public override void Step(TapeStepContext<T> context)
     {
diff --git a/src/Optimizers/DFPOptimizer.cs b/src/Optimizers/DFPOptimizer.cs
index 3358a69c31..71e052da93 100644
--- a/src/Optimizers/DFPOptimizer.cs
+++ b/src/Optimizers/DFPOptimizer.cs
@@ -25,7 +25,7 @@ namespace AiDotNet.Optimizers;
 /// </remarks>
 [ComponentType(ComponentType.Optimizer)]
 [PipelineStage(PipelineStage.Training)]
-public class DFPOptimizer<T, TInput, TOutput> : GradientBasedOptimizerBase<T, TInput, TOutput>, Fused.IFusedOptimizerSpec
+public partial class DFPOptimizer<T, TInput, TOutput> : GradientBasedOptimizerBase<T, TInput, TOutput>, Fused.IFusedOptimizerSpec
 {
     /// <summary>
     /// Declines to fuse, always.
@@ -57,11 +57,13 @@ bool Fused.IFusedOptimizerSpec.TryGetFusedOptimizerConfig(out Fused.FusedOptimiz
     /// <summary>
     /// The inverse Hessian matrix approximation used in the DFP algorithm.
     /// </summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private Matrix<T> _inverseHessian;
 
     /// <summary>
     /// The gradient from the previous iteration.
     /// </summary>
+    [Scratch]
     private new Vector<T> _previousGradient;
 
     /// <summary>
@@ -373,6 +375,7 @@ public override OptimizationAlgorithmOptions<T, TInput, TOutput> GetOptions()
     /// <summary>
     /// The parameters from the previous iteration for UpdateParameters method.
     /// </summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T>? _previousParameters;
 
     /// <summary>
@@ -479,82 +482,6 @@ public override void UpdateParametersGpu(IGpuBuffer parameters, IGpuBuffer gradi
             "Use CPU-based UpdateParameters or consider using Adam/AdamW for GPU-resident training.");
     }
 
-    /// <summary>
-    /// Serializes the DFP optimizer to a byte array.
-    /// </summary>
-    /// <returns>A byte array representing the serialized state of the optimizer.</returns>
-    /// <remarks>
-    /// <para><b>For Beginners:</b> This method converts the current state of the optimizer into a series of bytes.
-    /// This is useful for saving the optimizer's state to a file or sending it over a network.
-    /// </para>
-    /// </remarks>
-    public override byte[] Serialize()
-    {
-        using (MemoryStream ms = new MemoryStream())
-        using (BinaryWriter writer = new BinaryWriter(ms))
-        {
-            byte[] baseData = base.Serialize();
-            writer.Write(baseData.Length);
-            writer.Write(baseData);
-
-            string optionsJson = JsonConvert.SerializeObject(_options);
-            writer.Write(optionsJson);
-
-            // Serialize _inverseHessian
-            byte[] inverseHessianData = _inverseHessian.Serialize();
-            writer.Write(inverseHessianData.Length);
-            writer.Write(inverseHessianData);
-
-            // Serialize _previousGradient
-            byte[] previousGradientData = _previousGradient.Serialize();
-            writer.Write(previousGradientData.Length);
-            writer.Write(previousGradientData);
-
-            // Serialize _adaptiveLearningRate
-            writer.Write(Convert.ToDouble(_adaptiveLearningRate));
-
-            return ms.ToArray();
-        }
-    }
-
-    /// <summary>
-    /// Deserializes the DFP optimizer from a byte array.
-    /// </summary>
-    /// <param name="data">The byte array containing the serialized optimizer state.</param>
-    /// <exception cref="InvalidOperationException">Thrown when deserialization of optimizer options fails.</exception>
-    /// <remarks>
-    /// <para><b>For Beginners:</b> This method reconstructs the optimizer's state from a series of bytes.
-    /// It's used to restore a previously saved state of the optimizer, allowing you to continue from where you left off.
-    /// </para>
-    /// </remarks>
-    public override void Deserialize(byte[] data)
-    {
-        using (MemoryStream ms = new MemoryStream(data))
-        using (BinaryReader reader = new BinaryReader(ms))
-        {
-            int baseDataLength = reader.ReadInt32();
-            byte[] baseData = reader.ReadBytes(baseDataLength);
-            base.Deserialize(baseData);
-
-            string optionsJson = reader.ReadString();
-            _options = JsonConvert.DeserializeObject<DFPOptimizerOptions<T, TInput, TOutput>>(optionsJson)
-                ?? throw new InvalidOperationException("Failed to deserialize optimizer options.");
-
-            // Deserialize _inverseHessian
-            int inverseHessianLength = reader.ReadInt32();
-            byte[] inverseHessianData = reader.ReadBytes(inverseHessianLength);
-            _inverseHessian = Matrix<T>.Deserialize(inverseHessianData);
-
-            // Deserialize _previousGradient
-            int previousGradientLength = reader.ReadInt32();
-            byte[] previousGradientData = reader.ReadBytes(previousGradientLength);
-            _previousGradient = Vector<T>.Deserialize(previousGradientData);
-
-            // Deserialize _adaptiveLearningRate
-            _adaptiveLearningRate = NumOps.FromDouble(reader.ReadDouble());
-        }
-    }
-
     /// <inheritdoc />
     public override void Step(TapeStepContext<T> context)
     {
diff --git a/src/Optimizers/DifferentialEvolutionOptimizer.cs b/src/Optimizers/DifferentialEvolutionOptimizer.cs
index ed7d8ac98c..7e1ffef63f 100644
--- a/src/Optimizers/DifferentialEvolutionOptimizer.cs
+++ b/src/Optimizers/DifferentialEvolutionOptimizer.cs
@@ -22,7 +22,7 @@ namespace AiDotNet.Optimizers;
 /// </remarks>
 [ComponentType(ComponentType.Optimizer)]
 [PipelineStage(PipelineStage.Training)]
-public class DifferentialEvolutionOptimizer<T, TInput, TOutput> : OptimizerBase<T, TInput, TOutput>, IDerivativeFreeFunctionOptimizer<T>
+public partial class DifferentialEvolutionOptimizer<T, TInput, TOutput> : OptimizerBase<T, TInput, TOutput>, IDerivativeFreeFunctionOptimizer<T>
 {
     /// <summary>
     /// Configuration options specific to the Differential Evolution algorithm.
@@ -284,76 +284,6 @@ public override OptimizationAlgorithmOptions<T, TInput, TOutput> GetOptions()
         return _deOptions;
     }
 
-    /// <summary>
-    /// Serializes the Differential Evolution optimizer to a byte array.
-    /// </summary>
-    /// <returns>A byte array representing the serialized state of the optimizer.</returns>
-    /// <remarks>
-    /// <para><b>For Beginners:</b> This method converts the current state of the optimizer into a series of bytes.
-    /// This is useful for saving the optimizer's state to a file or sending it over a network. It allows you to
-    /// recreate the exact state of the optimizer later.
-    /// </para>
-    /// <para>The serialization process includes:
-    /// <list type="bullet">
-    /// <item>Base class data (from the parent OptimizerBase class)</item>
-    /// <item>The DifferentialEvolutionOptions</item>
-    /// <item>The current state of the random number generator</item>
-    /// </list>
-    /// </para>
-    /// </remarks>
-    public override byte[] Serialize()
-    {
-        using MemoryStream ms = new MemoryStream();
-        using BinaryWriter writer = new BinaryWriter(ms);
-
-        // Serialize base class data
-        byte[] baseData = base.Serialize();
-        writer.Write(baseData.Length);
-        writer.Write(baseData);
-
-        // Serialize DifferentialEvolutionOptions
-        string optionsJson = JsonConvert.SerializeObject(_deOptions);
-        writer.Write(optionsJson);
-
-        return ms.ToArray();
-    }
-
-    /// <summary>
-    /// Deserializes the Differential Evolution optimizer from a byte array.
-    /// </summary>
-    /// <param name="data">The byte array containing the serialized optimizer state.</param>
-    /// <exception cref="InvalidOperationException">Thrown when deserialization of optimizer options fails.</exception>
-    /// <remarks>
-    /// <para><b>For Beginners:</b> This method reconstructs the optimizer's state from a series of bytes.
-    /// It's used to restore a previously saved state of the optimizer, allowing you to continue from where you left off.
-    /// </para>
-    /// <para>The deserialization process includes:
-    /// <list type="bullet">
-    /// <item>Restoring base class data (from the parent OptimizerBase class)</item>
-    /// <item>Reconstructing the DifferentialEvolutionOptions</item>
-    /// <item>Resetting the random number generator to its previous state</item>
-    /// <item>Reinitializing adaptive parameters</item>
-    /// </list>
-    /// </para>
-    /// </remarks>
-    public override void Deserialize(byte[] data)
-    {
-        using MemoryStream ms = new MemoryStream(data);
-        using BinaryReader reader = new BinaryReader(ms);
-
-        // Deserialize base class data
-        int baseDataLength = reader.ReadInt32();
-        byte[] baseData = reader.ReadBytes(baseDataLength);
-        base.Deserialize(baseData);
-
-        // Deserialize DifferentialEvolutionOptions
-        string optionsJson = reader.ReadString();
-        _deOptions = JsonConvert.DeserializeObject<DifferentialEvolutionOptions<T, TInput, TOutput>>(optionsJson)
-            ?? throw new InvalidOperationException("Failed to deserialize optimizer options.");
-
-        InitializeAdaptiveParameters();
-    }
-
     /// <summary>
     /// Creates a differential evolution optimizer for minimizing a plain function, with no model.
     /// </summary>
diff --git a/src/Optimizers/FTRLOptimizer.cs b/src/Optimizers/FTRLOptimizer.cs
index e1098e3596..02cd4d8a52 100644
--- a/src/Optimizers/FTRLOptimizer.cs
+++ b/src/Optimizers/FTRLOptimizer.cs
@@ -37,7 +37,7 @@ namespace AiDotNet.Optimizers;
 /// <typeparam name="T">The numeric type used for calculations, typically float or double.</typeparam>
 [ComponentType(ComponentType.Optimizer)]
 [PipelineStage(PipelineStage.Training)]
-public class FTRLOptimizer<T, TInput, TOutput> : GradientBasedOptimizerBase<T, TInput, TOutput>, Fused.IFusedOptimizerSpec
+public partial class FTRLOptimizer<T, TInput, TOutput> : GradientBasedOptimizerBase<T, TInput, TOutput>, Fused.IFusedOptimizerSpec
 {
     /// <summary>
     /// Describes this optimizer for the compiled fused-training kernel.
@@ -664,62 +664,6 @@ public override OptimizationAlgorithmOptions<T, TInput, TOutput> GetOptions()
         return _options;
     }
 
-    /// <summary>
-    /// Serializes the FTRL optimizer to a byte array.
-    /// </summary>
-    /// <remarks>
-    /// <para><b>For Beginners:</b> This method converts the current state of the optimizer into a format
-    /// that can be easily stored or transmitted. It's like taking a snapshot of the optimizer's memory,
-    /// including all its settings and learned information, so you can save it or send it somewhere else.
-    /// </para>
-    /// </remarks>
-    /// <returns>A byte array representing the serialized state of the optimizer.</returns>
-    public override byte[] Serialize()
-    {
-        using (MemoryStream ms = new MemoryStream())
-        using (BinaryWriter writer = new BinaryWriter(ms))
-        {
-            byte[] baseData = base.Serialize();
-            writer.Write(baseData.Length);
-            writer.Write(baseData);
-
-            string optionsJson = JsonConvert.SerializeObject(_options);
-            writer.Write(optionsJson);
-
-            writer.Write(_t);
-
-            return ms.ToArray();
-        }
-    }
-
-    /// <summary>
-    /// Deserializes the FTRL optimizer from a byte array.
-    /// </summary>
-    /// <remarks>
-    /// <para><b>For Beginners:</b> This method takes a previously serialized optimizer state and
-    /// reconstructs the optimizer from it. It's like restoring the optimizer's memory from a saved snapshot,
-    /// allowing you to continue from where you left off or use a pre-trained optimizer.
-    /// </para>
-    /// </remarks>
-    /// <param name="data">The byte array containing the serialized optimizer state.</param>
-    /// <exception cref="InvalidOperationException">Thrown when deserialization of optimizer options fails.</exception>
-    public override void Deserialize(byte[] data)
-    {
-        using (MemoryStream ms = new MemoryStream(data))
-        using (BinaryReader reader = new BinaryReader(ms))
-        {
-            int baseDataLength = reader.ReadInt32();
-            byte[] baseData = reader.ReadBytes(baseDataLength);
-            base.Deserialize(baseData);
-
-            string optionsJson = reader.ReadString();
-            _options = JsonConvert.DeserializeObject<FTRLOptimizerOptions<T, TInput, TOutput>>(optionsJson)
-                ?? throw new InvalidOperationException("Failed to deserialize optimizer options.");
-
-            _t = reader.ReadInt32();
-        }
-    }
-
     /// <summary>
     /// Initializes FTRL optimizer state on the GPU.
     /// </summary>
diff --git a/src/Optimizers/GeneticAlgorithmOptimizer.cs b/src/Optimizers/GeneticAlgorithmOptimizer.cs
index 4043a72503..4f6b8b0ecc 100644
--- a/src/Optimizers/GeneticAlgorithmOptimizer.cs
+++ b/src/Optimizers/GeneticAlgorithmOptimizer.cs
@@ -29,7 +29,7 @@ namespace AiDotNet.Optimizers;
 /// <typeparam name="T">The numeric type used for calculations, typically float or double.</typeparam>
 [ComponentType(ComponentType.Optimizer)]
 [PipelineStage(PipelineStage.Training)]
-public class GeneticAlgorithmOptimizer<T, TInput, TOutput> : OptimizerBase<T, TInput, TOutput>, IDerivativeFreeFunctionOptimizer<T>
+public partial class GeneticAlgorithmOptimizer<T, TInput, TOutput> : OptimizerBase<T, TInput, TOutput>, IDerivativeFreeFunctionOptimizer<T>
 {
     /// <summary>
     /// The options specific to the Genetic Algorithm.
@@ -224,74 +224,6 @@ public override OptimizationAlgorithmOptions<T, TInput, TOutput> GetOptions()
         return _geneticOptions;
     }
 
-    /// <summary>
-    /// Serializes the genetic algorithm optimizer to a byte array.
-    /// </summary>
-    /// <remarks>
-    /// <para><b>For Beginners:</b> This method saves all the important information about the current state
-    /// of the genetic algorithm into a format that can be easily stored or transmitted.
-    /// It's like writing down all the details of your cooking competition so you can recreate it later.
-    /// </para>
-    /// </remarks>
-    /// <returns>A byte array containing the serialized data of the optimizer.</returns>
-    public override byte[] Serialize()
-    {
-        using MemoryStream ms = new MemoryStream();
-        using BinaryWriter writer = new BinaryWriter(ms);
-
-        // Serialize base class data
-        byte[] baseData = base.Serialize();
-        writer.Write(baseData.Length);
-        writer.Write(baseData);
-
-        // Serialize GeneticAlgorithmOptimizerOptions
-        string optionsJson = JsonConvert.SerializeObject(_geneticOptions);
-        writer.Write(optionsJson);
-
-        // Serialize the genetic algorithm itself
-        byte[] geneticAlgorithmData = _geneticAlgorithm.Serialize();
-        writer.Write(geneticAlgorithmData.Length);
-        writer.Write(geneticAlgorithmData);
-
-        return ms.ToArray();
-    }
-
-    /// <summary>
-    /// Deserializes the genetic algorithm optimizer from a byte array.
-    /// </summary>
-    /// <remarks>
-    /// <para><b>For Beginners:</b> This method recreates the genetic algorithm optimizer from previously saved data.
-    /// It's like using your written notes to set up your cooking competition exactly as it was before.
-    /// </para>
-    /// </remarks>
-    /// <param name="data">The byte array containing the serialized data of the optimizer.</param>
-    /// <exception cref="InvalidOperationException">Thrown when deserialization of the optimizer options fails.</exception>
-    public override void Deserialize(byte[] data)
-    {
-        using MemoryStream ms = new MemoryStream(data);
-        using BinaryReader reader = new BinaryReader(ms);
-
-        // Deserialize base class data
-        int baseDataLength = reader.ReadInt32();
-        byte[] baseData = reader.ReadBytes(baseDataLength);
-        base.Deserialize(baseData);
-
-        // Deserialize GeneticAlgorithmOptimizerOptions
-        string optionsJson = reader.ReadString();
-        _geneticOptions = JsonConvert.DeserializeObject<GeneticAlgorithmOptimizerOptions<T, TInput, TOutput>>(optionsJson)
-            ?? throw new InvalidOperationException("Failed to deserialize optimizer options.");
-
-        // Deserialize the genetic algorithm if data is available
-        if (reader.BaseStream.Position < reader.BaseStream.Length)
-        {
-            int geneticAlgorithmDataLength = reader.ReadInt32();
-            byte[] geneticAlgorithmData = reader.ReadBytes(geneticAlgorithmDataLength);
-            _geneticAlgorithm.Deserialize(geneticAlgorithmData);
-        }
-
-        InitializeAdaptiveParameters();
-    }
-
     /// <summary>
     /// Creates a genetic algorithm optimizer for minimizing a plain function, with no model.
     /// </summary>
diff --git a/src/Optimizers/GradientBasedOptimizerBase.cs b/src/Optimizers/GradientBasedOptimizerBase.cs
index 822a2f1c05..f3d0da8bdc 100644
--- a/src/Optimizers/GradientBasedOptimizerBase.cs
+++ b/src/Optimizers/GradientBasedOptimizerBase.cs
@@ -1,5 +1,6 @@
 using AiDotNet.Helpers;
 using AiDotNet.Caching;
+using AiDotNet.Attributes;
 using AiDotNet.Deployment.Configuration;
 using AiDotNet.Data.Sampling;
 using AiDotNet.Engines;
@@ -88,6 +89,7 @@ protected override void OnInitialTrainingCompleted()
     /// <summary>
     /// The gradient from the previous optimization step, used for momentum calculations.
     /// </summary>
+    [Scratch]
     protected Vector<T> _previousGradient;
 
     /// <summary>
@@ -99,6 +101,7 @@ protected override void OnInitialTrainingCompleted()
     /// training (true DDP), debugging, and visualization.
     /// Returns Vector&lt;T&gt;.Empty() if no gradients have been computed yet.
     /// </remarks>
+    [Scratch]
     protected Vector<T> _lastComputedGradients;
 
     private const string TapeStateExtensionMarker = "AiDotNet.GradientTapeOptimizerState.v1";
@@ -106,6 +109,7 @@ protected override void OnInitialTrainingCompleted()
     private readonly ConcurrentDictionary<Tensor<T>, int> _tapeParameterIndices =
         new(TensorReferenceComparer<Tensor<T>>.Instance);
 
+    [Scratch]
     private readonly Dictionary<string, Dictionary<int, Tensor<T>>> _pendingTapeTensorStates =
         new(StringComparer.Ordinal);
 
diff --git a/src/Optimizers/GradientDescentOptimizer.cs b/src/Optimizers/GradientDescentOptimizer.cs
index 95329099b8..75136751ae 100644
--- a/src/Optimizers/GradientDescentOptimizer.cs
+++ b/src/Optimizers/GradientDescentOptimizer.cs
@@ -29,7 +29,7 @@ namespace AiDotNet.Optimizers;
 /// <typeparam name="T">The numeric type used for calculations, typically float or double.</typeparam>
 [ComponentType(ComponentType.Optimizer)]
 [PipelineStage(PipelineStage.Training)]
-public class GradientDescentOptimizer<T, TInput, TOutput> : GradientBasedOptimizerBase<T, TInput, TOutput>, Fused.IFusedOptimizerSpec
+public partial class GradientDescentOptimizer<T, TInput, TOutput> : GradientBasedOptimizerBase<T, TInput, TOutput>, Fused.IFusedOptimizerSpec
 {
     /// <inheritdoc/>
     /// <remarks>
@@ -371,79 +371,6 @@ public override OptimizationAlgorithmOptions<T, TInput, TOutput> GetOptions()
         return _gdOptions;
     }
 
-    /// <summary>
-    /// Converts the current state of the Gradient Descent optimizer into a byte array for storage or transmission.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// This method serializes both the base class data and the Gradient Descent-specific options.
-    /// It uses a combination of binary serialization for efficiency and JSON serialization for flexibility.
-    /// </para>
-    /// <para><b>For Beginners:</b> This is like packing up your hiking gear and writing down your plan:
-    /// 
-    /// - It saves all the important information about the optimizer's current state
-    /// - This saved information can be used later to recreate the optimizer exactly as it is now
-    /// - It's useful for saving your progress or sharing your optimizer setup with others
-    /// 
-    /// Think of it as creating a detailed snapshot of your hiking journey that you can use to continue 
-    /// from the same point later or allow someone else to follow your exact path.
-    /// </para>
-    /// </remarks>
-    /// <returns>A byte array representing the serialized state of the optimizer.</returns>
-    public override byte[] Serialize()
-    {
-        using MemoryStream ms = new MemoryStream();
-        using BinaryWriter writer = new BinaryWriter(ms);
-
-        // Serialize base class data
-        byte[] baseData = base.Serialize();
-        writer.Write(baseData.Length);
-        writer.Write(baseData);
-
-        // Serialize GradientDescentOptions
-        string optionsJson = JsonConvert.SerializeObject(_gdOptions);
-        writer.Write(optionsJson);
-
-        return ms.ToArray();
-    }
-
-    /// <summary>
-    /// Restores the state of the Gradient Descent optimizer from a byte array.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// This method deserializes both the base class data and the Gradient Descent-specific options
-    /// from a byte array, typically created by the Serialize method. It reconstructs the optimizer's
-    /// state, including all settings and progress information.
-    /// </para>
-    /// <para><b>For Beginners:</b> This is like unpacking your hiking gear and reading your saved plan:
-    /// 
-    /// - It takes the saved information (byte array) and uses it to set up the optimizer
-    /// - This allows you to continue optimizing from where you left off, or use someone else's setup
-    /// - It's the reverse process of Serialize, turning the saved data back into a working optimizer
-    /// 
-    /// Imagine you're starting a hike using a very detailed guide someone else wrote. This method
-    /// helps you set everything up exactly as described in that guide.
-    /// </para>
-    /// </remarks>
-    /// <param name="data">The byte array containing the serialized optimizer state.</param>
-    /// <exception cref="InvalidOperationException">Thrown when deserialization of optimizer options fails.</exception>
-    public override void Deserialize(byte[] data)
-    {
-        using MemoryStream ms = new MemoryStream(data);
-        using BinaryReader reader = new BinaryReader(ms);
-
-        // Deserialize base class data
-        int baseDataLength = reader.ReadInt32();
-        byte[] baseData = reader.ReadBytes(baseDataLength);
-        base.Deserialize(baseData);
-
-        // Deserialize GradientDescentOptions
-        string optionsJson = reader.ReadString();
-        _gdOptions = JsonConvert.DeserializeObject<GradientDescentOptimizerOptions<T, TInput, TOutput>>(optionsJson)
-            ?? throw new InvalidOperationException("Failed to deserialize optimizer options.");
-    }
-
     /// <summary>
     /// Generates a unique key for caching gradients specific to the Gradient Descent optimizer.
     /// </summary>
diff --git a/src/Optimizers/LAMBOptimizer.cs b/src/Optimizers/LAMBOptimizer.cs
index 67e8f85787..34ebf0668e 100644
--- a/src/Optimizers/LAMBOptimizer.cs
+++ b/src/Optimizers/LAMBOptimizer.cs
@@ -59,7 +59,7 @@ namespace AiDotNet.Optimizers;
 /// </example>
 [ComponentType(ComponentType.Optimizer)]
 [PipelineStage(PipelineStage.Training)]
-public class LAMBOptimizer<T, TInput, TOutput> : GradientBasedOptimizerBase<T, TInput, TOutput>, Fused.IFusedOptimizerSpec
+public partial class LAMBOptimizer<T, TInput, TOutput> : GradientBasedOptimizerBase<T, TInput, TOutput>, Fused.IFusedOptimizerSpec
 {
     /// <summary>
     /// Describes this LAMB instance for the fused kernel (Tensors
@@ -851,75 +851,6 @@ public override OptimizationAlgorithmOptions<T, TInput, TOutput> GetOptions()
         return _options;
     }
 
-    /// <summary>
-    /// Serializes the optimizer's state into a byte array.
-    /// </summary>
-    public override byte[] Serialize()
-    {
-        using var ms = new MemoryStream();
-        using var writer = new BinaryWriter(ms);
-
-        byte[] baseData = base.Serialize();
-        writer.Write(baseData.Length);
-        writer.Write(baseData);
-
-        string optionsJson = JsonConvert.SerializeObject(_options);
-        writer.Write(optionsJson);
-
-        writer.Write(_t);
-        writer.Write(_warmupSteps);
-
-        writer.Write(_m.Length);
-        foreach (var value in _m)
-        {
-            writer.Write(Convert.ToDouble(value));
-        }
-
-        writer.Write(_v.Length);
-        foreach (var value in _v)
-        {
-            writer.Write(Convert.ToDouble(value));
-        }
-
-        return ms.ToArray();
-    }
-
-    /// <summary>
-    /// Deserializes the optimizer's state from a byte array.
-    /// </summary>
-    public override void Deserialize(byte[] data)
-    {
-        using var ms = new MemoryStream(data);
-        using var reader = new BinaryReader(ms);
-
-        int baseDataLength = reader.ReadInt32();
-        byte[] baseData = reader.ReadBytes(baseDataLength);
-        base.Deserialize(baseData);
-
-        string optionsJson = reader.ReadString();
-        _options = JsonConvert.DeserializeObject<LAMBOptimizerOptions<T, TInput, TOutput>>(optionsJson)
-            ?? throw new InvalidOperationException("Failed to deserialize optimizer options.");
-
-        _t = reader.ReadInt32();
-        _warmupSteps = reader.ReadInt32();
-
-        int mLength = reader.ReadInt32();
-        _m = new Vector<T>(mLength);
-        for (int i = 0; i < mLength; i++)
-        {
-            _m[i] = NumOps.FromDouble(reader.ReadDouble());
-        }
-
-        int vLength = reader.ReadInt32();
-        _v = new Vector<T>(vLength);
-        for (int i = 0; i < vLength; i++)
-        {
-            _v[i] = NumOps.FromDouble(reader.ReadDouble());
-        }
-
-        InitializeAdaptiveParameters();
-    }
-
     /// <summary>
     /// Generates a unique key for caching gradients.
     /// </summary>
diff --git a/src/Optimizers/LARSOptimizer.cs b/src/Optimizers/LARSOptimizer.cs
index 7ed53de124..d8326b5beb 100644
--- a/src/Optimizers/LARSOptimizer.cs
+++ b/src/Optimizers/LARSOptimizer.cs
@@ -50,7 +50,7 @@ namespace AiDotNet.Optimizers;
 /// </example>
 [ComponentType(ComponentType.Optimizer)]
 [PipelineStage(PipelineStage.Training)]
-public class LARSOptimizer<T, TInput, TOutput> : GradientBasedOptimizerBase<T, TInput, TOutput>
+public partial class LARSOptimizer<T, TInput, TOutput> : GradientBasedOptimizerBase<T, TInput, TOutput>
 {
     /// <summary>
     /// The options specific to the LARS optimizer.
@@ -689,60 +689,6 @@ public override OptimizationAlgorithmOptions<T, TInput, TOutput> GetOptions()
         return _options;
     }
 
-    /// <summary>
-    /// Serializes the optimizer's state into a byte array.
-    /// </summary>
-    public override byte[] Serialize()
-    {
-        using var ms = new MemoryStream();
-        using var writer = new BinaryWriter(ms);
-
-        byte[] baseData = base.Serialize();
-        writer.Write(baseData.Length);
-        writer.Write(baseData);
-
-        string optionsJson = JsonConvert.SerializeObject(_options);
-        writer.Write(optionsJson);
-
-        writer.Write(_t);
-        writer.Write(_warmupSteps);
-        writer.Write(_velocity.Length);
-        foreach (var value in _velocity)
-        {
-            writer.Write(Convert.ToDouble(value));
-        }
-
-        return ms.ToArray();
-    }
-
-    /// <summary>
-    /// Deserializes the optimizer's state from a byte array.
-    /// </summary>
-    public override void Deserialize(byte[] data)
-    {
-        using var ms = new MemoryStream(data);
-        using var reader = new BinaryReader(ms);
-
-        int baseDataLength = reader.ReadInt32();
-        byte[] baseData = reader.ReadBytes(baseDataLength);
-        base.Deserialize(baseData);
-
-        string optionsJson = reader.ReadString();
-        _options = JsonConvert.DeserializeObject<LARSOptimizerOptions<T, TInput, TOutput>>(optionsJson)
-            ?? throw new InvalidOperationException("Failed to deserialize optimizer options.");
-
-        _t = reader.ReadInt32();
-        _warmupSteps = reader.ReadInt32();
-        int vLength = reader.ReadInt32();
-        _velocity = new Vector<T>(vLength);
-        for (int i = 0; i < vLength; i++)
-        {
-            _velocity[i] = NumOps.FromDouble(reader.ReadDouble());
-        }
-
-        InitializeAdaptiveParameters();
-    }
-
     /// <summary>
     /// Generates a unique key for caching gradients.
     /// </summary>
diff --git a/src/Optimizers/LBFGSOptimizer.cs b/src/Optimizers/LBFGSOptimizer.cs
index 27f8acbdde..5023a0d4d9 100644
--- a/src/Optimizers/LBFGSOptimizer.cs
+++ b/src/Optimizers/LBFGSOptimizer.cs
@@ -26,7 +26,7 @@ namespace AiDotNet.Optimizers;
 /// <typeparam name="T">The numeric type used for calculations, typically float or double.</typeparam>
 [ComponentType(ComponentType.Optimizer)]
 [PipelineStage(PipelineStage.Training)]
-public class LBFGSOptimizer<T, TInput, TOutput> : GradientBasedOptimizerBase<T, TInput, TOutput>, Fused.IFusedOptimizerSpec
+public partial class LBFGSOptimizer<T, TInput, TOutput> : GradientBasedOptimizerBase<T, TInput, TOutput>, Fused.IFusedOptimizerSpec
 {
     /// <summary>
     /// Describes this optimizer for the compiled fused-training kernel.
@@ -905,104 +905,6 @@ public override void UpdateParametersGpu(IGpuBuffer parameters, IGpuBuffer gradi
             "Use CPU-based UpdateParameters or consider using Adam/AdamW for GPU-resident training.");
     }
 
-    /// <summary>
-    /// Serializes the optimizer's state into a byte array.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// This method converts the current state of the optimizer, including its options and internal memory,
-    /// into a byte array. This allows the optimizer's state to be saved or transmitted.
-    /// </para>
-    /// <para><b>For Beginners:</b>
-    /// This is like taking a snapshot of the optimizer's current state so it can be saved or sent somewhere else.
-    /// It includes all the important information about what the optimizer has learned so far.
-    /// </para>
-    /// </remarks>
-    /// <returns>A byte array representing the serialized state of the optimizer.</returns>
-    public override byte[] Serialize()
-    {
-        using (MemoryStream ms = new MemoryStream())
-        using (BinaryWriter writer = new BinaryWriter(ms))
-        {
-            byte[] baseData = base.Serialize();
-            writer.Write(baseData.Length);
-            writer.Write(baseData);
-
-            string optionsJson = JsonConvert.SerializeObject(_options);
-            writer.Write(optionsJson);
-
-            writer.Write(_iteration);
-            writer.Write(NumOps.ToDouble(_lbfgsInverseHessianScale));
-            writer.Write(_s.Count);
-            foreach (var vector in _s)
-            {
-                byte[] vectorData = vector.Serialize();
-                writer.Write(vectorData.Length);
-                writer.Write(vectorData);
-            }
-            writer.Write(_y.Count);
-            foreach (var vector in _y)
-            {
-                byte[] vectorData = vector.Serialize();
-                writer.Write(vectorData.Length);
-                writer.Write(vectorData);
-            }
-
-            return ms.ToArray();
-        }
-    }
-
-    /// <summary>
-    /// Deserializes a byte array to restore the optimizer's state.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// This method takes a byte array (previously created by the Serialize method) and uses it to restore
-    /// the optimizer's state, including its options and internal memory.
-    /// </para>
-    /// <para><b>For Beginners:</b>
-    /// This is like loading a saved snapshot of the optimizer's state. It rebuilds the optimizer's memory
-    /// and settings from the saved data, allowing it to continue from where it left off.
-    /// </para>
-    /// </remarks>
-    /// <param name="data">The byte array containing the serialized optimizer state.</param>
-    /// <exception cref="InvalidOperationException">Thrown when deserialization of optimizer options fails.</exception>
-    public override void Deserialize(byte[] data)
-    {
-        using (MemoryStream ms = new MemoryStream(data))
-        using (BinaryReader reader = new BinaryReader(ms))
-        {
-            int baseDataLength = reader.ReadInt32();
-            byte[] baseData = reader.ReadBytes(baseDataLength);
-            base.Deserialize(baseData);
-
-            string optionsJson = reader.ReadString();
-            _options = JsonConvert.DeserializeObject<LBFGSOptimizerOptions<T, TInput, TOutput>>(optionsJson)
-                ?? throw new InvalidOperationException("Failed to deserialize optimizer options.");
-
-            _iteration = reader.ReadInt32();
-            _lbfgsInverseHessianScale = NumOps.FromDouble(reader.ReadDouble());
-
-            int sCount = reader.ReadInt32();
-            _s = new List<Vector<T>>(sCount);
-            for (int i = 0; i < sCount; i++)
-            {
-                int vectorLength = reader.ReadInt32();
-                byte[] vectorData = reader.ReadBytes(vectorLength);
-                _s.Add(Vector<T>.Deserialize(vectorData));
-            }
-
-            int yCount = reader.ReadInt32();
-            _y = new List<Vector<T>>(yCount);
-            for (int i = 0; i < yCount; i++)
-            {
-                int vectorLength = reader.ReadInt32();
-                byte[] vectorData = reader.ReadBytes(vectorLength);
-                _y.Add(Vector<T>.Deserialize(vectorData));
-            }
-        }
-    }
-
     /// <inheritdoc />
     public override void Step(TapeStepContext<T> context)
     {
diff --git a/src/Optimizers/LevenbergMarquardtOptimizer.cs b/src/Optimizers/LevenbergMarquardtOptimizer.cs
index 8e38fa3def..1026ae0044 100644
--- a/src/Optimizers/LevenbergMarquardtOptimizer.cs
+++ b/src/Optimizers/LevenbergMarquardtOptimizer.cs
@@ -26,7 +26,7 @@ namespace AiDotNet.Optimizers;
 /// <typeparam name="T">The numeric type used for calculations, typically float or double.</typeparam>
 [ComponentType(ComponentType.Optimizer)]
 [PipelineStage(PipelineStage.Training)]
-public class LevenbergMarquardtOptimizer<T, TInput, TOutput> : GradientBasedOptimizerBase<T, TInput, TOutput>, Fused.IFusedOptimizerSpec
+public partial class LevenbergMarquardtOptimizer<T, TInput, TOutput> : GradientBasedOptimizerBase<T, TInput, TOutput>, Fused.IFusedOptimizerSpec
 {
     /// <summary>
     /// Declines to fuse, always.
@@ -517,74 +517,6 @@ public override void UpdateParametersGpu(IGpuBuffer parameters, IGpuBuffer gradi
             "Use CPU-based UpdateParameters or consider using Adam/AdamW for GPU-resident training.");
     }
 
-    /// <summary>
-    /// Serializes the optimizer's state into a byte array.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// This method converts the current state of the optimizer, including its options and internal parameters,
-    /// into a byte array. This is useful for saving the optimizer's state or transferring it between systems.
-    /// </para>
-    /// <para><b>For Beginners:</b>
-    /// This is like taking a snapshot of the optimizer's current state and packing it into a compact form.
-    /// It's useful if you want to save the optimizer's progress and continue from this point later, or if
-    /// you want to move the optimizer to a different computer.
-    /// </para>
-    /// </remarks>
-    /// <returns>A byte array representing the serialized state of the optimizer.</returns>
-    public override byte[] Serialize()
-    {
-        using (MemoryStream ms = new MemoryStream())
-        using (BinaryWriter writer = new BinaryWriter(ms))
-        {
-            byte[] baseData = base.Serialize();
-            writer.Write(baseData.Length);
-            writer.Write(baseData);
-
-            string optionsJson = JsonConvert.SerializeObject(_options);
-            writer.Write(optionsJson);
-
-            writer.Write(_iteration);
-            writer.Write(Convert.ToDouble(_dampingFactor));
-
-            return ms.ToArray();
-        }
-    }
-
-    /// <summary>
-    /// Deserializes a byte array to restore the optimizer's state.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// This method takes a byte array (previously created by the Serialize method) and uses it to restore
-    /// the optimizer's state, including its options and internal parameters.
-    /// </para>
-    /// <para><b>For Beginners:</b>
-    /// This is like unpacking that snapshot we took earlier and setting up the optimizer exactly as it was
-    /// when we saved it. It's the reverse process of serialization, allowing us to continue optimization
-    /// from a previously saved state.
-    /// </para>
-    /// </remarks>
-    /// <param name="data">The byte array containing the serialized optimizer state.</param>
-    /// <exception cref="InvalidOperationException">Thrown when the optimizer options cannot be deserialized.</exception>
-    public override void Deserialize(byte[] data)
-    {
-        using (MemoryStream ms = new MemoryStream(data))
-        using (BinaryReader reader = new BinaryReader(ms))
-        {
-            int baseDataLength = reader.ReadInt32();
-            byte[] baseData = reader.ReadBytes(baseDataLength);
-            base.Deserialize(baseData);
-
-            string optionsJson = reader.ReadString();
-            _options = JsonConvert.DeserializeObject<LevenbergMarquardtOptimizerOptions<T, TInput, TOutput>>(optionsJson)
-                ?? throw new InvalidOperationException("Failed to deserialize optimizer options.");
-
-            _iteration = reader.ReadInt32();
-            _dampingFactor = NumOps.FromDouble(reader.ReadDouble());
-        }
-    }
-
     /// <inheritdoc />
     /// <remarks>
     /// <para>
diff --git a/src/Optimizers/LionOptimizer.cs b/src/Optimizers/LionOptimizer.cs
index 5468a10e2d..e4eede4d8b 100644
--- a/src/Optimizers/LionOptimizer.cs
+++ b/src/Optimizers/LionOptimizer.cs
@@ -33,7 +33,7 @@ namespace AiDotNet.Optimizers;
 /// </remarks>
 [ComponentType(ComponentType.Optimizer)]
 [PipelineStage(PipelineStage.Training)]
-public class LionOptimizer<T, TInput, TOutput> : GradientBasedOptimizerBase<T, TInput, TOutput>, Fused.IFusedOptimizerSpec
+public partial class LionOptimizer<T, TInput, TOutput> : GradientBasedOptimizerBase<T, TInput, TOutput>, Fused.IFusedOptimizerSpec
 {
     /// <summary>
     /// Describes this Lion instance for the fused kernel (Tensors
@@ -667,78 +667,6 @@ public override OptimizationAlgorithmOptions<T, TInput, TOutput> GetOptions()
         return _options;
     }
 
-    /// <summary>
-    /// Serializes the optimizer's state into a byte array.
-    /// </summary>
-    /// <returns>A byte array representing the serialized state of the optimizer.</returns>
-    /// <remarks>
-    /// <para><b>For Beginners:</b> This method saves the optimizer's current state into a compact form.
-    /// You can use this to pause training, save your progress, and resume later from exactly where you left off.
-    /// Lion's single momentum state makes serialization more efficient than Adam.</para>
-    /// </remarks>
-    public override byte[] Serialize()
-    {
-        using (MemoryStream ms = new MemoryStream())
-        using (BinaryWriter writer = new BinaryWriter(ms))
-        {
-            // Serialize base class data
-            byte[] baseData = base.Serialize();
-            writer.Write(baseData.Length);
-            writer.Write(baseData);
-
-            // Serialize LionOptimizerOptions
-            string optionsJson = JsonConvert.SerializeObject(_options);
-            writer.Write(optionsJson);
-
-            // Serialize Lion-specific data
-            writer.Write(_t);
-            writer.Write(_m.Length);
-            foreach (var value in _m)
-            {
-                writer.Write(Convert.ToDouble(value));
-            }
-
-            return ms.ToArray();
-        }
-    }
-
-    /// <summary>
-    /// Deserializes the optimizer's state from a byte array.
-    /// </summary>
-    /// <param name="data">The byte array containing the serialized optimizer state.</param>
-    /// <remarks>
-    /// <para><b>For Beginners:</b> This method rebuilds the optimizer's state from a saved snapshot.
-    /// Use this to resume training from a checkpoint, restoring all momentum and configuration exactly
-    /// as it was when you saved it.</para>
-    /// </remarks>
-    public override void Deserialize(byte[] data)
-    {
-        using (MemoryStream ms = new MemoryStream(data))
-        using (BinaryReader reader = new BinaryReader(ms))
-        {
-            // Deserialize base class data
-            int baseDataLength = reader.ReadInt32();
-            byte[] baseData = reader.ReadBytes(baseDataLength);
-            base.Deserialize(baseData);
-
-            // Deserialize LionOptimizerOptions
-            string optionsJson = reader.ReadString();
-            _options = JsonConvert.DeserializeObject<LionOptimizerOptions<T, TInput, TOutput>>(optionsJson)
-                ?? throw new InvalidOperationException("Failed to deserialize optimizer options.");
-
-            InitializeAdaptiveParameters();
-
-            // Deserialize Lion-specific data
-            _t = reader.ReadInt32();
-            int mLength = reader.ReadInt32();
-            _m = new Vector<T>(mLength);
-            for (int i = 0; i < mLength; i++)
-            {
-                _m[i] = NumOps.FromDouble(reader.ReadDouble());
-            }
-        }
-    }
-
     /// <summary>
     /// Initializes Lion optimizer state on the GPU.
     /// </summary>
diff --git a/src/Optimizers/MiniBatchGradientDescentOptimizer.cs b/src/Optimizers/MiniBatchGradientDescentOptimizer.cs
index 77819e3228..0ee75cee82 100644
--- a/src/Optimizers/MiniBatchGradientDescentOptimizer.cs
+++ b/src/Optimizers/MiniBatchGradientDescentOptimizer.cs
@@ -26,7 +26,7 @@ namespace AiDotNet.Optimizers;
 /// <typeparam name="T">The numeric type used for calculations, typically float or double.</typeparam>
 [ComponentType(ComponentType.Optimizer)]
 [PipelineStage(PipelineStage.Training)]
-public class MiniBatchGradientDescentOptimizer<T, TInput, TOutput> : GradientBasedOptimizerBase<T, TInput, TOutput>, Fused.IFusedOptimizerSpec
+public partial class MiniBatchGradientDescentOptimizer<T, TInput, TOutput> : GradientBasedOptimizerBase<T, TInput, TOutput>, Fused.IFusedOptimizerSpec
 {
     /// <inheritdoc/>
     /// <remarks>
@@ -373,65 +373,6 @@ public override OptimizationAlgorithmOptions<T, TInput, TOutput> GetOptions()
         return _options;
     }
 
-    /// <summary>
-    /// Serializes the optimizer's state into a byte array.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// This method converts the current state of the optimizer, including its base class state and options, 
-    /// into a byte array. This is useful for saving the optimizer's state or transferring it between systems.
-    /// </para>
-    /// <para><b>For Beginners:</b>
-    /// Think of this as taking a snapshot of your entire journey so far. It captures all the details of your 
-    /// current position, your hiking plan, and how you got there. This snapshot can be used to continue your 
-    /// journey later or share your exact situation with others.
-    /// </para>
-    /// </remarks>
-    /// <returns>A byte array representing the serialized state of the optimizer.</returns>
-    public override byte[] Serialize()
-    {
-        using MemoryStream ms = new MemoryStream();
-        using BinaryWriter writer = new BinaryWriter(ms);
-
-        byte[] baseData = base.Serialize();
-        writer.Write(baseData.Length);
-        writer.Write(baseData);
-
-        string optionsJson = JsonConvert.SerializeObject(_options);
-        writer.Write(optionsJson);
-
-        return ms.ToArray();
-    }
-
-    /// <summary>
-    /// Deserializes a byte array to restore the optimizer's state.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// This method takes a byte array (previously created by Serialize) and uses it to restore the optimizer's state, 
-    /// including its base class state and options.
-    /// </para>
-    /// <para><b>For Beginners:</b>
-    /// This is like using a detailed map and instructions to recreate your exact position and plan from a previous 
-    /// point in your journey. It allows you to pick up right where you left off, with all your strategies and progress intact.
-    /// </para>
-    /// </remarks>
-    /// <param name="data">The byte array containing the serialized optimizer state.</param>
-    /// <exception cref="InvalidOperationException">Thrown when the optimizer options cannot be deserialized.</exception>
-    public override void Deserialize(byte[] data)
-    {
-        using MemoryStream ms = new MemoryStream(data);
-        using BinaryReader reader = new BinaryReader(ms);
-
-        int baseDataLength = reader.ReadInt32();
-        byte[] baseData = reader.ReadBytes(baseDataLength);
-        base.Deserialize(baseData);
-
-        string optionsJson = reader.ReadString();
-        _options = JsonConvert.DeserializeObject<MiniBatchGradientDescentOptions<T, TInput, TOutput>>(optionsJson)
-            ?? throw new InvalidOperationException("Failed to deserialize optimizer options.");
-    }
-
     /// <summary>
     /// Generates a unique key for caching gradients based on the model and input data.
     /// </summary>
diff --git a/src/Optimizers/MomentumOptimizer.cs b/src/Optimizers/MomentumOptimizer.cs
index 42107b68a1..192d5cb5cf 100644
--- a/src/Optimizers/MomentumOptimizer.cs
+++ b/src/Optimizers/MomentumOptimizer.cs
@@ -27,7 +27,7 @@ namespace AiDotNet.Optimizers;
 /// <typeparam name="T">The numeric type used for calculations, typically float or double.</typeparam>
 [ComponentType(ComponentType.Optimizer)]
 [PipelineStage(PipelineStage.Training)]
-public class MomentumOptimizer<T, TInput, TOutput> : GradientBasedOptimizerBase<T, TInput, TOutput>, Fused.IFusedOptimizerSpec
+public partial class MomentumOptimizer<T, TInput, TOutput> : GradientBasedOptimizerBase<T, TInput, TOutput>, Fused.IFusedOptimizerSpec
 {
     /// <inheritdoc/>
     /// <remarks>
@@ -530,96 +530,6 @@ public override OptimizationAlgorithmOptions<T, TInput, TOutput> GetOptions()
         return _options;
     }
 
-    /// <summary>
-    /// Serializes the optimizer's state into a byte array.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// This method converts the current state of the optimizer, including its base class state and options, 
-    /// into a byte array. This is useful for saving the optimizer's state or transferring it between systems.
-    /// </para>
-    /// <para><b>For Beginners:</b>
-    /// Think of this as taking a snapshot of your entire ball-rolling experiment. It captures all the details of your 
-    /// current setup, including the ball's position, speed, and all your rules. This snapshot can be used to recreate 
-    /// the exact same experiment later or share it with others.
-    /// </para>
-    /// </remarks>
-    /// <returns>A byte array representing the serialized state of the optimizer.</returns>
-    public override byte[] Serialize()
-    {
-        using (MemoryStream ms = new MemoryStream())
-        using (BinaryWriter writer = new BinaryWriter(ms))
-        {
-            byte[] baseData = base.Serialize();
-            writer.Write(baseData.Length);
-            writer.Write(baseData);
-
-            string optionsJson = JsonConvert.SerializeObject(_options);
-            writer.Write(optionsJson);
-
-            // Serialize velocity vector (snapshot to avoid re-reading mutable field)
-            var velocitySnapshot = _velocity;
-            writer.Write(velocitySnapshot is not null);
-            if (velocitySnapshot is not null)
-            {
-                writer.Write(velocitySnapshot.Length);
-                for (int i = 0; i < velocitySnapshot.Length; i++)
-                {
-                    writer.Write(NumOps.ToDouble(velocitySnapshot[i]));
-                }
-            }
-
-            return ms.ToArray();
-        }
-    }
-
-    /// <summary>
-    /// Deserializes a byte array to restore the optimizer's state.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// This method takes a byte array (previously created by Serialize) and uses it to restore the optimizer's state, 
-    /// including its base class state and options.
-    /// </para>
-    /// <para><b>For Beginners:</b>
-    /// This is like using a detailed blueprint to recreate your ball-rolling experiment exactly as it was at a certain point. 
-    /// It allows you to set up the experiment to match a previous state, with all the same rules and conditions.
-    /// </para>
-    /// </remarks>
-    /// <param name="data">The byte array containing the serialized optimizer state.</param>
-    /// <exception cref="InvalidOperationException">Thrown when the optimizer options cannot be deserialized.</exception>
-    public override void Deserialize(byte[] data)
-    {
-        using (MemoryStream ms = new MemoryStream(data))
-        using (BinaryReader reader = new BinaryReader(ms))
-        {
-            int baseDataLength = reader.ReadInt32();
-            byte[] baseData = reader.ReadBytes(baseDataLength);
-            base.Deserialize(baseData);
-
-            string optionsJson = reader.ReadString();
-            _options = JsonConvert.DeserializeObject<MomentumOptimizerOptions<T, TInput, TOutput>>(optionsJson)
-                ?? throw new InvalidOperationException("Failed to deserialize optimizer options.");
-
-            // Deserialize velocity vector
-            bool hasVelocity = reader.ReadBoolean();
-            if (hasVelocity)
-            {
-                int velocityLength = reader.ReadInt32();
-                T[] velocityData = new T[velocityLength];
-                for (int i = 0; i < velocityLength; i++)
-                {
-                    velocityData[i] = NumOps.FromDouble(reader.ReadDouble());
-                }
-                _velocity = new Vector<T>(velocityData);
-            }
-            else
-            {
-                _velocity = null;
-            }
-        }
-    }
-
     /// <summary>
     /// Generates a unique key for caching gradients based on the model and input data.
     /// </summary>
diff --git a/src/Optimizers/NadamOptimizer.cs b/src/Optimizers/NadamOptimizer.cs
index 0e3d03d7d2..6d71a904d5 100644
--- a/src/Optimizers/NadamOptimizer.cs
+++ b/src/Optimizers/NadamOptimizer.cs
@@ -25,7 +25,7 @@ namespace AiDotNet.Optimizers;
 /// <typeparam name="T">The numeric type used for calculations, typically float or double.</typeparam>
 [ComponentType(ComponentType.Optimizer)]
 [PipelineStage(PipelineStage.Training)]
-public class NadamOptimizer<T, TInput, TOutput> : GradientBasedOptimizerBase<T, TInput, TOutput>, Fused.IFusedOptimizerSpec
+public partial class NadamOptimizer<T, TInput, TOutput> : GradientBasedOptimizerBase<T, TInput, TOutput>, Fused.IFusedOptimizerSpec
 {
     /// <summary>
     /// Describes this Nadam instance for the fused-compiled training kernel
@@ -669,45 +669,6 @@ public override OptimizationAlgorithmOptions<T, TInput, TOutput> GetOptions()
         return _options;
     }
 
-    /// <summary>
-    /// Serializes the optimizer's state into a byte array.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// This method converts the current state of the optimizer, including its base class state, options, and time step,
-    /// into a byte array. This is useful for saving the optimizer's state or transferring it between systems.
-    /// </para>
-    /// <para><b>For Beginners:</b>
-    /// Think of this as taking a snapshot of your entire smart ball rolling experiment. It captures all the details of your 
-    /// current setup, including the ball's position, speed, and all your rules. This snapshot can be used to recreate 
-    /// the exact same experiment later or share it with others.
-    /// </para>
-    /// </remarks>
-    /// <returns>A byte array representing the serialized state of the optimizer.</returns>
-    public override byte[] Serialize()
-    {
-        using (MemoryStream ms = new MemoryStream())
-        using (BinaryWriter writer = new BinaryWriter(ms))
-        {
-            byte[] baseData = base.Serialize();
-            writer.Write(baseData.Length);
-            writer.Write(baseData);
-
-            string optionsJson = JsonConvert.SerializeObject(_options);
-            writer.Write(optionsJson);
-
-            writer.Write(_t);
-
-            // Serialize state vectors
-            SerializeVector(writer, _m);
-            SerializeVector(writer, _v);
-            SerializeVector(writer, _previousM);
-            SerializeVector(writer, _previousV);
-
-            return ms.ToArray();
-        }
-    }
-
     private void SerializeVector(BinaryWriter writer, Vector<T>? vector)
     {
         bool hasVector = vector is not null;
@@ -738,44 +699,6 @@ private void SerializeVector(BinaryWriter writer, Vector<T>? vector)
         return null;
     }
 
-    /// <summary>
-    /// Deserializes a byte array to restore the optimizer's state.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// This method takes a byte array (previously created by Serialize) and uses it to restore the optimizer's state,
-    /// including its base class state, options, and time step.
-    /// </para>
-    /// <para><b>For Beginners:</b>
-    /// This is like using a detailed blueprint to recreate your smart ball rolling experiment exactly as it was at a certain point.
-    /// It allows you to set up the experiment to match a previous state, with all the same rules and conditions.
-    /// </para>
-    /// </remarks>
-    /// <param name="data">The byte array containing the serialized optimizer state.</param>
-    /// <exception cref="InvalidOperationException">Thrown when the optimizer options cannot be deserialized.</exception>
-    public override void Deserialize(byte[] data)
-    {
-        using (MemoryStream ms = new MemoryStream(data))
-        using (BinaryReader reader = new BinaryReader(ms))
-        {
-            int baseDataLength = reader.ReadInt32();
-            byte[] baseData = reader.ReadBytes(baseDataLength);
-            base.Deserialize(baseData);
-
-            string optionsJson = reader.ReadString();
-            _options = JsonConvert.DeserializeObject<NadamOptimizerOptions<T, TInput, TOutput>>(optionsJson)
-                ?? throw new InvalidOperationException("Failed to deserialize optimizer options.");
-
-            _t = reader.ReadInt32();
-
-            // Deserialize state vectors
-            _m = DeserializeVector(reader);
-            _v = DeserializeVector(reader);
-            _previousM = DeserializeVector(reader);
-            _previousV = DeserializeVector(reader);
-        }
-    }
-
     /// <summary>
     /// Initializes Nadam optimizer state on the GPU.
     /// </summary>
diff --git a/src/Optimizers/NelderMeadOptimizer.cs b/src/Optimizers/NelderMeadOptimizer.cs
index 7621143f76..afe1dd74fb 100644
--- a/src/Optimizers/NelderMeadOptimizer.cs
+++ b/src/Optimizers/NelderMeadOptimizer.cs
@@ -24,7 +24,7 @@ namespace AiDotNet.Optimizers;
 /// <typeparam name="T">The numeric type used for calculations, typically float or double.</typeparam>
 [ComponentType(ComponentType.Optimizer)]
 [PipelineStage(PipelineStage.Training)]
-public class NelderMeadOptimizer<T, TInput, TOutput> : OptimizerBase<T, TInput, TOutput>, IDerivativeFreeFunctionOptimizer<T>
+public partial class NelderMeadOptimizer<T, TInput, TOutput> : OptimizerBase<T, TInput, TOutput>, IDerivativeFreeFunctionOptimizer<T>
 {
     /// <summary>
     /// The options specific to the Nelder-Mead optimizer.
@@ -679,74 +679,4 @@ public override OptimizationAlgorithmOptions<T, TInput, TOutput> GetOptions()
     {
         return _options;
     }
-
-    /// <summary>
-    /// Serializes the Nelder-Mead optimizer to a byte array.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// This method converts the current state of the optimizer, including its options and parameters, into a byte array.
-    /// This allows the optimizer's state to be saved or transmitted.
-    /// </para>
-    /// <para><b>For Beginners:</b>
-    /// This is like taking a snapshot of the entire search process, including where all the explorers are and what rules they're following, so you can save it or send it to someone else.
-    /// </para>
-    /// </remarks>
-    /// <returns>A byte array representing the serialized state of the optimizer.</returns>
-    public override byte[] Serialize()
-    {
-        using (MemoryStream ms = new MemoryStream())
-        using (BinaryWriter writer = new BinaryWriter(ms))
-        {
-            byte[] baseData = base.Serialize();
-            writer.Write(baseData.Length);
-            writer.Write(baseData);
-
-            string optionsJson = JsonConvert.SerializeObject(_options);
-            writer.Write(optionsJson);
-
-            writer.Write(_iteration);
-            writer.Write(Convert.ToDouble(_alpha));
-            writer.Write(Convert.ToDouble(_beta));
-            writer.Write(Convert.ToDouble(_gamma));
-            writer.Write(Convert.ToDouble(_delta));
-
-            return ms.ToArray();
-        }
-    }
-
-    /// <summary>
-    /// Deserializes the Nelder-Mead optimizer from a byte array.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// This method reconstructs the optimizer's state from a byte array, including its options and parameters.
-    /// It's used to restore a previously saved or transmitted optimizer state.
-    /// </para>
-    /// <para><b>For Beginners:</b>
-    /// This is like using a saved snapshot to set up the search process exactly as it was before, placing all the explorers back where they were and restoring the rules they were following.
-    /// </para>
-    /// </remarks>
-    /// <param name="data">The byte array containing the serialized optimizer state.</param>
-    /// <exception cref="InvalidOperationException">Thrown when the optimizer options cannot be deserialized.</exception>
-    public override void Deserialize(byte[] data)
-    {
-        using (MemoryStream ms = new MemoryStream(data))
-        using (BinaryReader reader = new BinaryReader(ms))
-        {
-            int baseDataLength = reader.ReadInt32();
-            byte[] baseData = reader.ReadBytes(baseDataLength);
-            base.Deserialize(baseData);
-
-            string optionsJson = reader.ReadString();
-            _options = JsonConvert.DeserializeObject<NelderMeadOptimizerOptions<T, TInput, TOutput>>(optionsJson)
-                ?? throw new InvalidOperationException("Failed to deserialize optimizer options.");
-
-            _iteration = reader.ReadInt32();
-            _alpha = NumOps.FromDouble(reader.ReadDouble());
-            _beta = NumOps.FromDouble(reader.ReadDouble());
-            _gamma = NumOps.FromDouble(reader.ReadDouble());
-            _delta = NumOps.FromDouble(reader.ReadDouble());
-        }
-    }
 }
diff --git a/src/Optimizers/NesterovAcceleratedGradientOptimizer.cs b/src/Optimizers/NesterovAcceleratedGradientOptimizer.cs
index d479f60e38..f28d96093c 100644
--- a/src/Optimizers/NesterovAcceleratedGradientOptimizer.cs
+++ b/src/Optimizers/NesterovAcceleratedGradientOptimizer.cs
@@ -27,7 +27,7 @@ namespace AiDotNet.Optimizers;
 /// <typeparam name="T">The numeric type used for calculations, typically float or double.</typeparam>
 [ComponentType(ComponentType.Optimizer)]
 [PipelineStage(PipelineStage.Training)]
-public class NesterovAcceleratedGradientOptimizer<T, TInput, TOutput> : GradientBasedOptimizerBase<T, TInput, TOutput>, Fused.IFusedOptimizerSpec
+public partial class NesterovAcceleratedGradientOptimizer<T, TInput, TOutput> : GradientBasedOptimizerBase<T, TInput, TOutput>, Fused.IFusedOptimizerSpec
 {
     /// <summary>
     /// Describes this optimizer for the compiled fused-training kernel.
@@ -584,64 +584,6 @@ public override OptimizationAlgorithmOptions<T, TInput, TOutput> GetOptions()
         return _options;
     }
 
-    /// <summary>
-    /// Serializes the Nesterov Accelerated Gradient optimizer to a byte array.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// This method converts the current state of the optimizer, including its options and parameters, into a byte array.
-    /// This allows the optimizer's state to be saved or transmitted.
-    /// </para>
-    /// <para><b>For Beginners:</b>
-    /// This is like taking a snapshot of the entire skiing process, including where the skier is on the slope and what techniques they're using, so you can save it or send it to someone else.
-    /// </para>
-    /// </remarks>
-    /// <returns>A byte array representing the serialized state of the optimizer.</returns>
-    public override byte[] Serialize()
-    {
-        using (MemoryStream ms = new MemoryStream())
-        using (BinaryWriter writer = new BinaryWriter(ms))
-        {
-            byte[] baseData = base.Serialize();
-            writer.Write(baseData.Length);
-            writer.Write(baseData);
-
-            string optionsJson = JsonConvert.SerializeObject(_options);
-            writer.Write(optionsJson);
-
-            return ms.ToArray();
-        }
-    }
-
-    /// <summary>
-    /// Deserializes the Nesterov Accelerated Gradient optimizer from a byte array.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// This method reconstructs the optimizer's state from a byte array, including its options and parameters.
-    /// It's used to restore a previously saved or transmitted optimizer state.
-    /// </para>
-    /// <para><b>For Beginners:</b>
-    /// This is like using a saved snapshot to set up the skiing process exactly as it was before, placing the skier back where they were on the slope and restoring the techniques they were using.
-    /// </para>
-    /// </remarks>
-    /// <param name="data">The byte array containing the serialized optimizer state.</param>
-    /// <exception cref="InvalidOperationException">Thrown when the optimizer options cannot be deserialized.</exception>
-    public override void Deserialize(byte[] data)
-    {
-        using (MemoryStream ms = new MemoryStream(data))
-        using (BinaryReader reader = new BinaryReader(ms))
-        {
-            int baseDataLength = reader.ReadInt32();
-            byte[] baseData = reader.ReadBytes(baseDataLength);
-            base.Deserialize(baseData);
-
-            string optionsJson = reader.ReadString();
-            _options = JsonConvert.DeserializeObject<NesterovAcceleratedGradientOptimizerOptions<T, TInput, TOutput>>(optionsJson)
-                ?? throw new InvalidOperationException("Failed to deserialize optimizer options.");
-        }
-    }
-
     /// <summary>
     /// Generates a unique key for caching gradients in the Nesterov Accelerated Gradient optimizer.
     /// </summary>
diff --git a/src/Optimizers/NewtonMethodOptimizer.cs b/src/Optimizers/NewtonMethodOptimizer.cs
index 4c6968b727..70ddbe5b4b 100644
--- a/src/Optimizers/NewtonMethodOptimizer.cs
+++ b/src/Optimizers/NewtonMethodOptimizer.cs
@@ -25,7 +25,7 @@ namespace AiDotNet.Optimizers;
 /// <typeparam name="T">The numeric type used for calculations, typically float or double.</typeparam>
 [ComponentType(ComponentType.Optimizer)]
 [PipelineStage(PipelineStage.Training)]
-public class NewtonMethodOptimizer<T, TInput, TOutput> : GradientBasedOptimizerBase<T, TInput, TOutput>, Fused.IFusedOptimizerSpec
+public partial class NewtonMethodOptimizer<T, TInput, TOutput> : GradientBasedOptimizerBase<T, TInput, TOutput>, Fused.IFusedOptimizerSpec
 {
     /// <summary>
     /// Declines to fuse, always.
@@ -467,68 +467,6 @@ public override void UpdateParametersGpu(IGpuBuffer parameters, IGpuBuffer gradi
             "Use CPU-based UpdateParameters or consider using Adam/AdamW for GPU-resident training.");
     }
 
-    /// <summary>
-    /// Serializes the current state of the optimizer into a byte array.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// This method saves the current state of the optimizer, including its base class state, options, and iteration count.
-    /// </para>
-    /// <para><b>For Beginners:</b>
-    /// This is like taking a snapshot of your current position, all your tools, and your strategy for exploring the valley.
-    /// You can use this snapshot later to continue your exploration from exactly where you left off.
-    /// </para>
-    /// </remarks>
-    /// <returns>A byte array representing the serialized state of the optimizer.</returns>
-    public override byte[] Serialize()
-    {
-        using (MemoryStream ms = new MemoryStream())
-        using (BinaryWriter writer = new BinaryWriter(ms))
-        {
-            byte[] baseData = base.Serialize();
-            writer.Write(baseData.Length);
-            writer.Write(baseData);
-
-            string optionsJson = JsonConvert.SerializeObject(_options);
-            writer.Write(optionsJson);
-
-            writer.Write(_iteration);
-
-            return ms.ToArray();
-        }
-    }
-
-    /// <summary>
-    /// Deserializes a byte array to restore the optimizer's state.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// This method restores the optimizer's state from a previously serialized byte array, including its base class state, options, and iteration count.
-    /// </para>
-    /// <para><b>For Beginners:</b>
-    /// This is like using a snapshot you took earlier to set up your exploration exactly as it was at that point.
-    /// You're restoring all your tools, your position in the valley, and your strategy to continue your search from where you left off.
-    /// </para>
-    /// </remarks>
-    /// <param name="data">The byte array containing the serialized optimizer state.</param>
-    /// <exception cref="InvalidOperationException">Thrown when the optimizer options cannot be deserialized.</exception>
-    public override void Deserialize(byte[] data)
-    {
-        using (MemoryStream ms = new MemoryStream(data))
-        using (BinaryReader reader = new BinaryReader(ms))
-        {
-            int baseDataLength = reader.ReadInt32();
-            byte[] baseData = reader.ReadBytes(baseDataLength);
-            base.Deserialize(baseData);
-
-            string optionsJson = reader.ReadString();
-            _options = JsonConvert.DeserializeObject<NewtonMethodOptimizerOptions<T, TInput, TOutput>>(optionsJson)
-                ?? throw new InvalidOperationException("Failed to deserialize optimizer options.");
-
-            _iteration = reader.ReadInt32();
-        }
-    }
-
     /// <inheritdoc />
     public override void Step(TapeStepContext<T> context)
     {
diff --git a/src/Optimizers/NormalOptimizer.cs b/src/Optimizers/NormalOptimizer.cs
index 749ffb758d..7a5bb057cb 100644
--- a/src/Optimizers/NormalOptimizer.cs
+++ b/src/Optimizers/NormalOptimizer.cs
@@ -22,7 +22,7 @@ namespace AiDotNet.Optimizers;
 /// <typeparam name="T">The numeric type used for calculations, typically float or double.</typeparam>
 [ComponentType(ComponentType.Optimizer)]
 [PipelineStage(PipelineStage.Training)]
-public class NormalOptimizer<T, TInput, TOutput> : OptimizerBase<T, TInput, TOutput>
+public partial class NormalOptimizer<T, TInput, TOutput> : OptimizerBase<T, TInput, TOutput>
 {
     /// <summary>
     /// Options specific to the normal optimizer, including parameters inherited from genetic algorithms.
@@ -432,68 +432,4 @@ protected override void UpdateOptions(OptimizationAlgorithmOptions<T, TInput, TO
             throw new ArgumentException("Invalid options type. Expected NormalOptimizerOptions.");
         }
     }
-
-    /// <summary>
-    /// Serializes the current state of the optimizer into a byte array.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// This method converts the current state of the optimizer, including its options, into a byte array
-    /// that can be stored or transmitted.
-    /// </para>
-    /// <para><b>For Beginners:</b>
-    /// This is like taking a snapshot of your current hiking strategy and equipment setup,
-    /// so you can recreate it exactly later or share it with others.
-    /// </para>
-    /// </remarks>
-    /// <returns>A byte array representing the serialized state of the optimizer.</returns>
-    public override byte[] Serialize()
-    {
-        using (MemoryStream ms = new MemoryStream())
-        using (BinaryWriter writer = new BinaryWriter(ms))
-        {
-            // Serialize base class data
-            byte[] baseData = base.Serialize();
-            writer.Write(baseData.Length);
-            writer.Write(baseData);
-
-            // Serialize NormalOptimizerOptions
-            string optionsJson = JsonConvert.SerializeObject(_normalOptions);
-            writer.Write(optionsJson);
-
-            return ms.ToArray();
-        }
-    }
-
-    /// <summary>
-    /// Deserializes a byte array to restore the optimizer's state.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// This method takes a byte array (previously created by the Serialize method) and uses it to
-    /// restore the optimizer's state, including its options.
-    /// </para>
-    /// <para><b>For Beginners:</b>
-    /// This is like using a saved snapshot of a hiking strategy to set up your approach exactly as it was before.
-    /// You're recreating all the details of your previous setup from the saved information.
-    /// </para>
-    /// </remarks>
-    /// <param name="data">The byte array containing the serialized optimizer state.</param>
-    /// <exception cref="InvalidOperationException">Thrown when deserialization of optimizer options fails.</exception>
-    public override void Deserialize(byte[] data)
-    {
-        using (MemoryStream ms = new MemoryStream(data))
-        using (BinaryReader reader = new BinaryReader(ms))
-        {
-            // Deserialize base class data
-            int baseDataLength = reader.ReadInt32();
-            byte[] baseData = reader.ReadBytes(baseDataLength);
-            base.Deserialize(baseData);
-
-            // Deserialize NormalOptimizerOptions
-            string optionsJson = reader.ReadString();
-            _normalOptions = JsonConvert.DeserializeObject<GeneticAlgorithmOptimizerOptions<T, TInput, TOutput>>(optionsJson)
-                ?? throw new InvalidOperationException("Failed to deserialize optimizer options.");
-        }
-    }
 }
diff --git a/src/Optimizers/ParticleSwarmOptimizer.cs b/src/Optimizers/ParticleSwarmOptimizer.cs
index ded967ead9..44d9e9b7b3 100644
--- a/src/Optimizers/ParticleSwarmOptimizer.cs
+++ b/src/Optimizers/ParticleSwarmOptimizer.cs
@@ -34,7 +34,7 @@ namespace AiDotNet.Optimizers;
 /// </remarks>
 [ComponentType(ComponentType.Optimizer)]
 [PipelineStage(PipelineStage.Training)]
-public class ParticleSwarmOptimizer<T, TInput, TOutput> : OptimizerBase<T, TInput, TOutput>, IDerivativeFreeFunctionOptimizer<T>
+public partial class ParticleSwarmOptimizer<T, TInput, TOutput> : OptimizerBase<T, TInput, TOutput>, IDerivativeFreeFunctionOptimizer<T>
 {
     /// <summary>
     /// Random number generator for stochastic components of the algorithm.
@@ -286,60 +286,6 @@ public override OptimizationAlgorithmOptions<T, TInput, TOutput> GetOptions()
         return _psoOptions;
     }
 
-    /// <summary>
-    /// Serializes the particle swarm optimizer to a byte array for storage or transmission.
-    /// </summary>
-    /// <returns>A byte array containing the serialized optimizer.</returns>
-    public override byte[] Serialize()
-    {
-        using (MemoryStream ms = new MemoryStream())
-        using (BinaryWriter writer = new BinaryWriter(ms))
-        {
-            // Serialize base class data
-            byte[] baseData = base.Serialize();
-            writer.Write(baseData.Length);
-            writer.Write(baseData);
-
-            // Serialize ParticleSwarmOptimizationOptions
-            string optionsJson = JsonConvert.SerializeObject(_psoOptions);
-            writer.Write(optionsJson);
-
-            // Serialize current adaptive parameters
-            writer.Write(_currentInertia);
-            writer.Write(_currentCognitiveWeight);
-            writer.Write(_currentSocialWeight);
-
-            return ms.ToArray();
-        }
-    }
-
-    /// <summary>
-    /// Reconstructs the particle swarm optimizer from a serialized byte array.
-    /// </summary>
-    /// <param name="data">The byte array containing the serialized optimizer.</param>
-    /// <exception cref="InvalidOperationException">Thrown when the options cannot be deserialized.</exception>
-    public override void Deserialize(byte[] data)
-    {
-        using (MemoryStream ms = new MemoryStream(data))
-        using (BinaryReader reader = new BinaryReader(ms))
-        {
-            // Deserialize base class data
-            int baseDataLength = reader.ReadInt32();
-            byte[] baseData = reader.ReadBytes(baseDataLength);
-            base.Deserialize(baseData);
-
-            // Deserialize ParticleSwarmOptimizationOptions
-            string optionsJson = reader.ReadString();
-            _psoOptions = JsonConvert.DeserializeObject<ParticleSwarmOptimizationOptions<T, TInput, TOutput>>(optionsJson)
-                ?? throw new InvalidOperationException("Failed to deserialize optimizer options.");
-
-            // Deserialize current adaptive parameters
-            _currentInertia = reader.ReadDouble();
-            _currentCognitiveWeight = reader.ReadDouble();
-            _currentSocialWeight = reader.ReadDouble();
-        }
-    }
-
     /// <summary>
     /// Creates a particle swarm optimizer for minimizing a plain function, with no model.
     /// </summary>
diff --git a/src/Optimizers/PowellOptimizer.cs b/src/Optimizers/PowellOptimizer.cs
index 4c460bb70f..c65aea5f27 100644
--- a/src/Optimizers/PowellOptimizer.cs
+++ b/src/Optimizers/PowellOptimizer.cs
@@ -30,7 +30,7 @@
 /// </remarks>
 [ComponentType(ComponentType.Optimizer)]
 [PipelineStage(PipelineStage.Training)]
-public class PowellOptimizer<T, TInput, TOutput> : OptimizerBase<T, TInput, TOutput>, IDerivativeFreeFunctionOptimizer<T>
+public partial class PowellOptimizer<T, TInput, TOutput> : OptimizerBase<T, TInput, TOutput>, IDerivativeFreeFunctionOptimizer<T>
 {
     /// <summary>
     /// Configuration options specific to Powell's optimization method.
@@ -515,88 +515,6 @@ public override OptimizationAlgorithmOptions<T, TInput, TOutput> GetOptions()
         return _options;
     }
 
-    /// <summary>
-    /// Serializes the Powell optimizer to a byte array for storage or transmission.
-    /// </summary>
-    /// <returns>A byte array containing the serialized optimizer.</returns>
-    /// <remarks>
-    /// <para>
-    /// This method overrides the base implementation to include Powell-specific information in the serialization.
-    /// It first serializes the base class data, then adds the Powell options, iteration count, and adaptive step size.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method saves the current state of the optimizer so it can be restored later.
-    /// 
-    /// It's like taking a snapshot of the optimizer:
-    /// - First, it saves all the general optimizer information
-    /// - Then, it saves the Powell-specific settings and state
-    /// - It packages everything into a format that can be saved to a file or sent over a network
-    /// 
-    /// This allows you to:
-    /// - Save a trained optimizer to use later
-    /// - Share an optimizer with others
-    /// - Create a backup before making changes
-    /// </para>
-    /// </remarks>
-    public override byte[] Serialize()
-    {
-        using (MemoryStream ms = new MemoryStream())
-        using (BinaryWriter writer = new BinaryWriter(ms))
-        {
-            byte[] baseData = base.Serialize();
-            writer.Write(baseData.Length);
-            writer.Write(baseData);
-
-            string optionsJson = JsonConvert.SerializeObject(_options);
-            writer.Write(optionsJson);
-
-            writer.Write(_iteration);
-            writer.Write(Convert.ToDouble(_adaptiveStepSize));
-
-            return ms.ToArray();
-        }
-    }
-
-    /// <summary>
-    /// Reconstructs the Powell optimizer from a serialized byte array.
-    /// </summary>
-    /// <param name="data">The byte array containing the serialized optimizer.</param>
-    /// <exception cref="InvalidOperationException">Thrown when the options cannot be deserialized.</exception>
-    /// <remarks>
-    /// <para>
-    /// This method overrides the base implementation to handle Powell-specific information during deserialization.
-    /// It first deserializes the base class data, then reconstructs the Powell options, iteration count, and adaptive step size.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method restores the optimizer from a previously saved state.
-    /// 
-    /// It's like restoring from a snapshot:
-    /// - First, it loads all the general optimizer information
-    /// - Then, it loads the Powell-specific settings and state
-    /// - It reconstructs the optimizer to the exact state it was in when saved
-    /// 
-    /// This allows you to:
-    /// - Continue working with an optimizer you previously saved
-    /// - Use an optimizer that someone else created and shared
-    /// - Revert to a backup if needed
-    /// </para>
-    /// </remarks>
-    public override void Deserialize(byte[] data)
-    {
-        using (MemoryStream ms = new MemoryStream(data))
-        using (BinaryReader reader = new BinaryReader(ms))
-        {
-            int baseDataLength = reader.ReadInt32();
-            byte[] baseData = reader.ReadBytes(baseDataLength);
-            base.Deserialize(baseData);
-
-            string optionsJson = reader.ReadString();
-            _options = JsonConvert.DeserializeObject<PowellOptimizerOptions<T, TInput, TOutput>>(optionsJson)
-                ?? throw new InvalidOperationException("Failed to deserialize optimizer options.");
-
-            _iteration = reader.ReadInt32();
-            _adaptiveStepSize = NumOps.FromDouble(reader.ReadDouble());
-        }
-    }
-
     /// <summary>
     /// Creates a Powell optimizer for minimizing a plain function, with no model attached.
     /// </summary>
diff --git a/src/Optimizers/ProximalGradientDescentOptimizer.cs b/src/Optimizers/ProximalGradientDescentOptimizer.cs
index 586d47454e..0f22ca8753 100644
--- a/src/Optimizers/ProximalGradientDescentOptimizer.cs
+++ b/src/Optimizers/ProximalGradientDescentOptimizer.cs
@@ -35,7 +35,7 @@ namespace AiDotNet.Optimizers;
 /// </remarks>
 [ComponentType(ComponentType.Optimizer)]
 [PipelineStage(PipelineStage.Training)]
-public class ProximalGradientDescentOptimizer<T, TInput, TOutput> : GradientBasedOptimizerBase<T, TInput, TOutput>, Fused.IFusedOptimizerSpec
+public partial class ProximalGradientDescentOptimizer<T, TInput, TOutput> : GradientBasedOptimizerBase<T, TInput, TOutput>, Fused.IFusedOptimizerSpec
 {
     /// <summary>
     /// Describes this optimizer for the compiled fused-training kernel.
@@ -189,11 +189,51 @@ bool Fused.IFusedOptimizerSpec.TryGetFusedOptimizerConfig(out Fused.FusedOptimiz
     /// Think of it as adding a preference for simpler, more stable solutions that are less likely to overfit.
     /// </para>
     /// </remarks>
-    private IRegularization<T, TInput, TOutput> _regularization;
+    // Initialized at declaration so the backing field is definitely assigned: the constructor
+    // assigns through the property below, which the compiler cannot see through. The identity
+    // operator is the correct stand-in -- it is what BuildProximalOperator returns for options
+    // carrying no regularization -- and the constructor overwrites it either way.
+    private IRegularization<T, TInput, TOutput> _regularizationOperator
+        = new NoRegularization<T, TInput, TOutput>();
+
+    /// <summary>Strength the cached proximal operator was built from, for staleness detection.</summary>
+    private double? _regularizationBuiltForStrength;
+
+    /// <summary>
+    /// The proximal operator, rebuilt whenever the options it derives from have moved underneath it.
+    /// </summary>
+    /// <remarks>
+    /// A property rather than a plain field because RESTORE MUTATES THE OPTIONS IN PLACE. The state
+    /// registry carries RegularizationStrength as a scalar and writes it straight onto the existing
+    /// options object; it never reassigns the options or routes through UpdateOptions, so a field
+    /// cached at construction would survive a restore describing a different strength and the
+    /// optimizer would resume training with the algorithm it was built with rather than the one that
+    /// was saved. The hand-written Deserialize this replaces rebuilt the operator explicitly; deriving
+    /// it here keeps that guarantee no matter which restore path runs.
+    /// </remarks>
+    private IRegularization<T, TInput, TOutput> _regularization
+    {
+        get
+        {
+            if (_options is not null
+                && !Nullable.Equals(_regularizationBuiltForStrength, _options.RegularizationStrength))
+            {
+                _regularizationOperator = BuildProximalOperator(_options);
+                _regularizationBuiltForStrength = _options.RegularizationStrength;
+            }
+            return _regularizationOperator;
+        }
+        set
+        {
+            _regularizationOperator = value;
+            _regularizationBuiltForStrength = _options?.RegularizationStrength;
+        }
+    }
 
     /// <summary>
     /// Stores the pre-update parameters for approximate reverse updates.
     /// </summary>
+    [AiDotNet.Attributes.Buffer]
     private Vector<T>? _previousParameters;
 
     /// <summary>
@@ -655,89 +695,6 @@ public override OptimizationAlgorithmOptions<T, TInput, TOutput> GetOptions()
         return _options;
     }
 
-    /// <summary>
-    /// Serializes the proximal gradient descent optimizer to a byte array for storage or transmission.
-    /// </summary>
-    /// <returns>A byte array containing the serialized optimizer.</returns>
-    /// <remarks>
-    /// <para>
-    /// This method overrides the base implementation to include PGD-specific information in the serialization.
-    /// It first serializes the base class data, then adds the PGD options and iteration count.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method saves the current state of the optimizer so it can be restored later.
-    /// 
-    /// It's like taking a snapshot of the optimizer:
-    /// - First, it saves all the general optimizer information
-    /// - Then, it saves the PGD-specific settings and state
-    /// - It packages everything into a format that can be saved to a file or sent over a network
-    /// 
-    /// This allows you to:
-    /// - Save a trained optimizer to use later
-    /// - Share an optimizer with others
-    /// - Create a backup before making changes
-    /// </para>
-    /// </remarks>
-    public override byte[] Serialize()
-    {
-        using (MemoryStream ms = new MemoryStream())
-        using (BinaryWriter writer = new BinaryWriter(ms))
-        {
-            byte[] baseData = base.Serialize();
-            writer.Write(baseData.Length);
-            writer.Write(baseData);
-
-            string optionsJson = JsonConvert.SerializeObject(_options);
-            writer.Write(optionsJson);
-
-            writer.Write(_iteration);
-
-            return ms.ToArray();
-        }
-    }
-
-    /// <summary>
-    /// Reconstructs the proximal gradient descent optimizer from a serialized byte array.
-    /// </summary>
-    /// <param name="data">The byte array containing the serialized optimizer.</param>
-    /// <exception cref="InvalidOperationException">Thrown when the options cannot be deserialized.</exception>
-    /// <remarks>
-    /// <para>
-    /// This method overrides the base implementation to handle PGD-specific information during deserialization.
-    /// It first deserializes the base class data, then reconstructs the PGD options and iteration count.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method restores the optimizer from a previously saved state.
-    /// 
-    /// It's like restoring from a snapshot:
-    /// - First, it loads all the general optimizer information
-    /// - Then, it loads the PGD-specific settings and state
-    /// - It reconstructs the optimizer to the exact state it was in when saved
-    /// 
-    /// This allows you to:
-    /// - Continue working with an optimizer you previously saved
-    /// - Use an optimizer that someone else created and shared
-    /// - Revert to a backup if needed
-    /// </para>
-    /// </remarks>
-    public override void Deserialize(byte[] data)
-    {
-        using (MemoryStream ms = new MemoryStream(data))
-        using (BinaryReader reader = new BinaryReader(ms))
-        {
-            int baseDataLength = reader.ReadInt32();
-            byte[] baseData = reader.ReadBytes(baseDataLength);
-            base.Deserialize(baseData);
-
-            string optionsJson = reader.ReadString();
-            _options = JsonConvert.DeserializeObject<ProximalGradientDescentOptimizerOptions<T, TInput, TOutput>>(optionsJson)
-                ?? throw new InvalidOperationException("Failed to deserialize optimizer options.");
-            // Same reason as UpdateOptions: a restored optimizer that kept the constructor's operator would
-            // resume training with a different algorithm from the one that was serialized.
-            _regularization = BuildProximalOperator(_options);
-
-            _iteration = reader.ReadInt32();
-        }
-    }
-
     /// <summary>
     /// Generates a unique key for caching gradients based on the model, input data, and optimizer state.
     /// </summary>
diff --git a/src/Optimizers/RAdamOptimizer.cs b/src/Optimizers/RAdamOptimizer.cs
index 1c0277c862..cc09faf0ae 100644
--- a/src/Optimizers/RAdamOptimizer.cs
+++ b/src/Optimizers/RAdamOptimizer.cs
@@ -55,7 +55,7 @@ namespace AiDotNet.Optimizers;
 /// </remarks>
 [ComponentType(ComponentType.Optimizer)]
 [PipelineStage(PipelineStage.Training)]
-public class RAdamOptimizer<T, TInput, TOutput> : GradientBasedOptimizerBase<T, TInput, TOutput>, Fused.IFusedOptimizerSpec
+public partial class RAdamOptimizer<T, TInput, TOutput> : GradientBasedOptimizerBase<T, TInput, TOutput>, Fused.IFusedOptimizerSpec
 {
     /// <summary>
     /// The options specific to the RAdam optimizer.
@@ -529,27 +529,6 @@ public override OptimizationAlgorithmOptions<T, TInput, TOutput> GetOptions()
     /// exactly where it left off -- including the step count, which RAdam needs in order to know whether it is
     /// still in its un-rectified warmup phase.</para>
     /// </remarks>
-    public override byte[] Serialize()
-    {
-        using (MemoryStream ms = new MemoryStream())
-        using (BinaryWriter writer = new BinaryWriter(ms))
-        {
-            byte[] baseData = base.Serialize();
-            writer.Write(baseData.Length);
-            writer.Write(baseData);
-
-            string optionsJson = JsonConvert.SerializeObject(_options);
-            writer.Write(optionsJson);
-
-            writer.Write(_t);
-
-            SerializeVector(writer, _m);
-            SerializeVector(writer, _v);
-
-            return ms.ToArray();
-        }
-    }
-
     private void SerializeVector(BinaryWriter writer, Vector<T>? vector)
     {
         writer.Write(vector is not null);
@@ -583,26 +562,6 @@ private void SerializeVector(BinaryWriter writer, Vector<T>? vector)
     /// Restores the optimizer's state from a byte array previously created by <see cref="Serialize"/>.
     /// </summary>
     /// <param name="data">The byte array containing the serialized optimizer state.</param>
-    public override void Deserialize(byte[] data)
-    {
-        using (MemoryStream ms = new MemoryStream(data))
-        using (BinaryReader reader = new BinaryReader(ms))
-        {
-            int baseDataLength = reader.ReadInt32();
-            byte[] baseData = reader.ReadBytes(baseDataLength);
-            base.Deserialize(baseData);
-
-            string optionsJson = reader.ReadString();
-            _options = JsonConvert.DeserializeObject<RAdamOptimizerOptions<T, TInput, TOutput>>(optionsJson)
-                ?? throw new InvalidOperationException("Failed to deserialize optimizer options.");
-
-            _t = reader.ReadInt32();
-
-            _m = DeserializeVector(reader);
-            _v = DeserializeVector(reader);
-        }
-    }
-
     /// <summary>
     /// Generates a unique key for caching gradients based on the current state of the optimizer and input data.
     /// </summary>
diff --git a/src/Optimizers/RootMeanSquarePropagationOptimizer.cs b/src/Optimizers/RootMeanSquarePropagationOptimizer.cs
index a237efcc6c..140552c097 100644
--- a/src/Optimizers/RootMeanSquarePropagationOptimizer.cs
+++ b/src/Optimizers/RootMeanSquarePropagationOptimizer.cs
@@ -38,7 +38,7 @@ namespace AiDotNet.Optimizers;
 /// </remarks>
 [ComponentType(ComponentType.Optimizer)]
 [PipelineStage(PipelineStage.Training)]
-public class RootMeanSquarePropagationOptimizer<T, TInput, TOutput> : GradientBasedOptimizerBase<T, TInput, TOutput>, Fused.IFusedOptimizerSpec
+public partial class RootMeanSquarePropagationOptimizer<T, TInput, TOutput> : GradientBasedOptimizerBase<T, TInput, TOutput>, Fused.IFusedOptimizerSpec
 {
     /// <summary>
     /// Describes this RMSprop instance for the fused kernel (Tensors
@@ -569,88 +569,6 @@ public override OptimizationAlgorithmOptions<T, TInput, TOutput> GetOptions()
         return _options;
     }
 
-    /// <summary>
-    /// Serializes the RMSProp optimizer to a byte array for storage or transmission.
-    /// </summary>
-    /// <returns>A byte array containing the serialized optimizer.</returns>
-    /// <remarks>
-    /// <para>
-    /// This method overrides the base implementation to include RMSProp-specific information in the serialization.
-    /// It first serializes the base class data, then adds the iteration count, squared gradient vector, and options.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method saves the current state of the optimizer so it can be restored later.
-    /// 
-    /// It's like taking a snapshot of the optimizer:
-    /// - First, it saves all the general optimizer information
-    /// - Then, it saves the RMSProp-specific state and settings
-    /// - It packages everything into a format that can be saved to a file or sent over a network
-    /// 
-    /// This allows you to:
-    /// - Save a trained optimizer to use later
-    /// - Share an optimizer with others
-    /// - Create a backup before making changes
-    /// </para>
-    /// </remarks>
-    public override byte[] Serialize()
-    {
-        using MemoryStream ms = new MemoryStream();
-        using BinaryWriter writer = new BinaryWriter(ms);
-
-        // Serialize base class data
-        byte[] baseData = base.Serialize();
-        writer.Write(baseData.Length);
-        writer.Write(baseData);
-
-        // Serialize RootMeanSquarePropagationOptimizer specific data
-        writer.Write(_t);
-        writer.Write(JsonConvert.SerializeObject(_squaredGradient));
-        writer.Write(JsonConvert.SerializeObject(_options));
-
-        return ms.ToArray();
-    }
-
-    /// <summary>
-    /// Reconstructs the RMSProp optimizer from a serialized byte array.
-    /// </summary>
-    /// <param name="data">The byte array containing the serialized optimizer.</param>
-    /// <exception cref="InvalidOperationException">Thrown when the data cannot be deserialized.</exception>
-    /// <remarks>
-    /// <para>
-    /// This method overrides the base implementation to handle RMSProp-specific information during deserialization.
-    /// It first deserializes the base class data, then reconstructs the iteration count, squared gradient vector,
-    /// and options.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method restores the optimizer from a previously saved state.
-    /// 
-    /// It's like restoring from a snapshot:
-    /// - First, it loads all the general optimizer information
-    /// - Then, it loads the RMSProp-specific state and settings
-    /// - It reconstructs the optimizer to the exact state it was in when saved
-    /// 
-    /// This allows you to:
-    /// - Continue working with an optimizer you previously saved
-    /// - Use an optimizer that someone else created and shared
-    /// - Revert to a backup if needed
-    /// </para>
-    /// </remarks>
-    public override void Deserialize(byte[] data)
-    {
-        using MemoryStream ms = new MemoryStream(data);
-        using BinaryReader reader = new BinaryReader(ms);
-
-        // Deserialize base class data
-        int baseDataLength = reader.ReadInt32();
-        byte[] baseData = reader.ReadBytes(baseDataLength);
-        base.Deserialize(baseData);
-
-        // Deserialize RootMeanSquarePropagationOptimizer specific data
-        _t = reader.ReadInt32();
-        _squaredGradient = JsonConvert.DeserializeObject<Vector<T>>(reader.ReadString())
-            ?? throw new InvalidOperationException("Failed to deserialize _squaredGradient.");
-        _options = JsonConvert.DeserializeObject<RootMeanSquarePropagationOptimizerOptions<T, TInput, TOutput>>(reader.ReadString())
-            ?? throw new InvalidOperationException("Failed to deserialize _options.");
-    }
-
     /// <summary>
     /// Reverses an RMSprop gradient update to recover original parameters.
     /// </summary>
diff --git a/src/Optimizers/RpropOptimizer.cs b/src/Optimizers/RpropOptimizer.cs
index da73a83748..7ef43e258a 100644
--- a/src/Optimizers/RpropOptimizer.cs
+++ b/src/Optimizers/RpropOptimizer.cs
@@ -56,7 +56,7 @@ namespace AiDotNet.Optimizers;
 /// </remarks>
 [ComponentType(ComponentType.Optimizer)]
 [PipelineStage(PipelineStage.Training)]
-public class RpropOptimizer<T, TInput, TOutput> : GradientBasedOptimizerBase<T, TInput, TOutput>, Fused.IFusedOptimizerSpec
+public partial class RpropOptimizer<T, TInput, TOutput> : GradientBasedOptimizerBase<T, TInput, TOutput>, Fused.IFusedOptimizerSpec
 {
     /// <summary>
     /// The options specific to the Rprop optimizer.
@@ -508,27 +508,6 @@ public override OptimizationAlgorithmOptions<T, TInput, TOutput> GetOptions()
     /// of Rprop's learned state -- resuming without them would throw away everything the optimizer had worked out
     /// about the loss surface.</para>
     /// </remarks>
-    public override byte[] Serialize()
-    {
-        using (MemoryStream ms = new MemoryStream())
-        using (BinaryWriter writer = new BinaryWriter(ms))
-        {
-            byte[] baseData = base.Serialize();
-            writer.Write(baseData.Length);
-            writer.Write(baseData);
-
-            string optionsJson = JsonConvert.SerializeObject(_options);
-            writer.Write(optionsJson);
-
-            writer.Write(_t);
-
-            SerializeVector(writer, _prevGradient);
-            SerializeVector(writer, _stepSize);
-
-            return ms.ToArray();
-        }
-    }
-
     private void SerializeVector(BinaryWriter writer, Vector<T>? vector)
     {
         writer.Write(vector is not null);
@@ -562,26 +541,6 @@ private void SerializeVector(BinaryWriter writer, Vector<T>? vector)
     /// Restores the optimizer's state from a byte array previously created by <see cref="Serialize"/>.
     /// </summary>
     /// <param name="data">The byte array containing the serialized optimizer state.</param>
-    public override void Deserialize(byte[] data)
-    {
-        using (MemoryStream ms = new MemoryStream(data))
-        using (BinaryReader reader = new BinaryReader(ms))
-        {
-            int baseDataLength = reader.ReadInt32();
-            byte[] baseData = reader.ReadBytes(baseDataLength);
-            base.Deserialize(baseData);
-
-            string optionsJson = reader.ReadString();
-            _options = JsonConvert.DeserializeObject<RpropOptimizerOptions<T, TInput, TOutput>>(optionsJson)
-                ?? throw new InvalidOperationException("Failed to deserialize optimizer options.");
-
-            _t = reader.ReadInt32();
-
-            _prevGradient = DeserializeVector(reader);
-            _stepSize = DeserializeVector(reader);
-        }
-    }
-
     /// <summary>
     /// Generates a unique key for caching gradients based on the current state of the optimizer and input data.
     /// </summary>
diff --git a/src/Optimizers/SimulatedAnnealingOptimizer.cs b/src/Optimizers/SimulatedAnnealingOptimizer.cs
index 6fd7f13120..71dbfabe44 100644
--- a/src/Optimizers/SimulatedAnnealingOptimizer.cs
+++ b/src/Optimizers/SimulatedAnnealingOptimizer.cs
@@ -28,7 +28,7 @@
 /// </remarks>
 [ComponentType(ComponentType.Optimizer)]
 [PipelineStage(PipelineStage.Training)]
-public class SimulatedAnnealingOptimizer<T, TInput, TOutput> : OptimizerBase<T, TInput, TOutput>, IDerivativeFreeFunctionOptimizer<T>
+public partial class SimulatedAnnealingOptimizer<T, TInput, TOutput> : OptimizerBase<T, TInput, TOutput>, IDerivativeFreeFunctionOptimizer<T>
 {
     /// <summary>
     /// Random number generator for stochastic decision-making.
@@ -487,89 +487,6 @@ private IFullModel<T, TInput, TOutput> GenerateNeighborSolution(IFullModel<T, TI
         return InterfaceGuard.Parameterizable(currentSolution).WithParameters(newCoefficients);
     }
 
-    /// <summary>
-    /// Serializes the current state of the SimulatedAnnealingOptimizer to a byte array.
-    /// </summary>
-    /// <returns>A byte array representing the serialized state of the optimizer.</returns>
-    /// <remarks>
-    /// <para>
-    /// This method saves the current state of the optimizer, including its base class data,
-    /// SimulatedAnnealingOptions, and current temperature, into a byte array. This allows the
-    /// optimizer's state to be stored or transmitted.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method is like taking a snapshot of the optimizer's current setup.
-    /// 
-    /// Think of it as saving a game:
-    /// - It saves all the current settings and progress
-    /// - This saved data can be used later to continue from where you left off
-    /// - It includes information from the parent class (base data), specific settings for this optimizer,
-    ///   and the current "temperature" of the system
-    /// 
-    /// This is useful for saving progress, sharing the optimizer's state, or creating checkpoints in the optimization process.
-    /// </para>
-    /// </remarks>
-    public override byte[] Serialize()
-    {
-        using (MemoryStream ms = new MemoryStream())
-        using (BinaryWriter writer = new BinaryWriter(ms))
-        {
-            // Serialize base class data
-            byte[] baseData = base.Serialize();
-            writer.Write(baseData.Length);
-            writer.Write(baseData);
-
-            // Serialize SimulatedAnnealingOptions
-            string optionsJson = JsonConvert.SerializeObject(_saOptions);
-            writer.Write(optionsJson);
-
-            // Serialize current temperature
-            writer.Write(Convert.ToDouble(_currentTemperature));
-
-            return ms.ToArray();
-        }
-    }
-
-    /// <summary>
-    /// Deserializes a byte array to restore the state of the SimulatedAnnealingOptimizer.
-    /// </summary>
-    /// <param name="data">The byte array containing the serialized optimizer state.</param>
-    /// <exception cref="InvalidOperationException">Thrown when deserialization of optimizer options fails.</exception>
-    /// <remarks>
-    /// <para>
-    /// This method restores the state of the optimizer from a byte array, including its base class data,
-    /// SimulatedAnnealingOptions, and current temperature. It's the counterpart to the Serialize method.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method is like loading a saved game to continue where you left off.
-    /// 
-    /// Imagine unpacking a suitcase:
-    /// - You're taking out all the pieces of information that were saved earlier
-    /// - First, you unpack the basic information (base class data)
-    /// - Then, you unpack the specific settings for this optimizer (SimulatedAnnealingOptions)
-    /// - Finally, you set the current "temperature" to what it was when saved
-    /// 
-    /// This allows you to recreate the exact state of the optimizer from a previous point in time.
-    /// </para>
-    /// </remarks>
-    public override void Deserialize(byte[] data)
-    {
-        using (MemoryStream ms = new MemoryStream(data))
-        using (BinaryReader reader = new BinaryReader(ms))
-        {
-            // Deserialize base class data
-            int baseDataLength = reader.ReadInt32();
-            byte[] baseData = reader.ReadBytes(baseDataLength);
-            base.Deserialize(baseData);
-
-            // Deserialize SimulatedAnnealingOptions
-            string optionsJson = reader.ReadString();
-            _saOptions = JsonConvert.DeserializeObject<SimulatedAnnealingOptions<T, TInput, TOutput>>(optionsJson)
-                ?? throw new InvalidOperationException("Failed to deserialize optimizer options.");
-
-            // Deserialize current temperature
-            _currentTemperature = NumOps.FromDouble(reader.ReadDouble());
-        }
-    }
-
     /// <summary>
     /// Creates a simulated annealing optimizer for minimizing a plain function, with no model.
     /// </summary>
diff --git a/src/Optimizers/StochasticGradientDescentOptimizer.cs b/src/Optimizers/StochasticGradientDescentOptimizer.cs
index d521fc9a97..1d52eccbfc 100644
--- a/src/Optimizers/StochasticGradientDescentOptimizer.cs
+++ b/src/Optimizers/StochasticGradientDescentOptimizer.cs
@@ -30,7 +30,7 @@ namespace AiDotNet.Optimizers;
 /// </remarks>
 [ComponentType(ComponentType.Optimizer)]
 [PipelineStage(PipelineStage.Training)]
-public class StochasticGradientDescentOptimizer<T, TInput, TOutput> : GradientBasedOptimizerBase<T, TInput, TOutput>, Fused.IFusedOptimizerSpec
+public partial class StochasticGradientDescentOptimizer<T, TInput, TOutput> : GradientBasedOptimizerBase<T, TInput, TOutput>, Fused.IFusedOptimizerSpec
 {
     private StochasticGradientDescentOptimizerOptions<T, TInput, TOutput> _options;
 
@@ -316,79 +316,6 @@ public override OptimizationAlgorithmOptions<T, TInput, TOutput> GetOptions()
         return _options;
     }
 
-    /// <summary>
-    /// Serializes the current state of the StochasticGradientDescentOptimizer to a byte array.
-    /// </summary>
-    /// <returns>A byte array representing the serialized state of the optimizer.</returns>
-    /// <remarks>
-    /// <para>
-    /// This method saves the current state of the optimizer, including its base class data and
-    /// SGD-specific options, into a byte array.
-    /// </para>
-    /// <para><b>For Beginners:</b> This is like taking a snapshot of the hiker's journey:
-    /// 
-    /// - It saves all the current settings and progress
-    /// - This saved data can be used later to continue from where you left off
-    /// - It includes both general hiking info and SGD-specific details
-    /// 
-    /// This is useful for saving progress or sharing the optimizer's current state.
-    /// </para>
-    /// </remarks>
-    public override byte[] Serialize()
-    {
-        using (MemoryStream ms = new MemoryStream())
-        using (BinaryWriter writer = new BinaryWriter(ms))
-        {
-            // Serialize base class data
-            byte[] baseData = base.Serialize();
-            writer.Write(baseData.Length);
-            writer.Write(baseData);
-
-            // Serialize SGD-specific options
-            string optionsJson = JsonConvert.SerializeObject(_options);
-            writer.Write(optionsJson);
-
-            return ms.ToArray();
-        }
-    }
-
-    /// <summary>
-    /// Deserializes a byte array to restore the state of the StochasticGradientDescentOptimizer.
-    /// </summary>
-    /// <param name="data">The byte array containing the serialized optimizer state.</param>
-    /// <exception cref="InvalidOperationException">Thrown when deserialization of optimizer options fails.</exception>
-    /// <remarks>
-    /// <para>
-    /// This method restores the state of the optimizer from a byte array, including its base class data
-    /// and SGD-specific options. It uses a BinaryReader to read the serialized data and reconstruct
-    /// the optimizer's state.
-    /// </para>
-    /// <para><b>For Beginners:</b> This is like unpacking the hiker's backpack after a journey:
-    /// 
-    /// - It reads the saved snapshot of the hiker's journey
-    /// - It restores both general hiking info and SGD-specific details
-    /// - If there's a problem reading the SGD-specific details, it reports an error
-    /// 
-    /// This allows you to continue from a previously saved state of the optimizer.
-    /// </para>
-    /// </remarks>
-    public override void Deserialize(byte[] data)
-    {
-        using (MemoryStream ms = new MemoryStream(data))
-        using (BinaryReader reader = new BinaryReader(ms))
-        {
-            // Deserialize base class data
-            int baseDataLength = reader.ReadInt32();
-            byte[] baseData = reader.ReadBytes(baseDataLength);
-            base.Deserialize(baseData);
-
-            // Deserialize SGD-specific options
-            string optionsJson = reader.ReadString();
-            _options = JsonConvert.DeserializeObject<StochasticGradientDescentOptimizerOptions<T, TInput, TOutput>>(optionsJson)
-                ?? throw new InvalidOperationException("Failed to deserialize optimizer options.");
-        }
-    }
-
     /// <summary>
     /// Generates a unique cache key for gradient calculations.
     /// </summary>
diff --git a/src/Optimizers/TabuSearchOptimizer.cs b/src/Optimizers/TabuSearchOptimizer.cs
index 59350208f2..b658ba7404 100644
--- a/src/Optimizers/TabuSearchOptimizer.cs
+++ b/src/Optimizers/TabuSearchOptimizer.cs
@@ -27,7 +27,7 @@ namespace AiDotNet.Optimizers;
 /// </remarks>
 [ComponentType(ComponentType.Optimizer)]
 [PipelineStage(PipelineStage.Training)]
-public class TabuSearchOptimizer<T, TInput, TOutput> : OptimizerBase<T, TInput, TOutput>, IDerivativeFreeFunctionOptimizer<T>
+public partial class TabuSearchOptimizer<T, TInput, TOutput> : OptimizerBase<T, TInput, TOutput>, IDerivativeFreeFunctionOptimizer<T>
 {
     /// <summary>
     /// The options specific to the Tabu Search algorithm.
@@ -346,81 +346,6 @@ public override OptimizationAlgorithmOptions<T, TInput, TOutput> GetOptions()
         return _tabuOptions;
     }
 
-    /// <summary>
-    /// Serializes the TabuSearchOptimizer to a byte array.
-    /// </summary>
-    /// <returns>A byte array representing the serialized optimizer.</returns>
-    public override byte[] Serialize()
-    {
-        using MemoryStream ms = new MemoryStream();
-        using BinaryWriter writer = new BinaryWriter(ms);
-
-        // Serialize base class data
-        byte[] baseData = base.Serialize();
-        writer.Write(baseData.Length);
-        writer.Write(baseData);
-
-        // Serialize Tabu Search-specific options
-        string optionsJson = JsonConvert.SerializeObject(_tabuOptions);
-        writer.Write(optionsJson);
-
-        // Serialize the genetic algorithm
-        byte[] geneticAlgorithmData = _geneticAlgorithm.Serialize();
-        writer.Write(geneticAlgorithmData.Length);
-        writer.Write(geneticAlgorithmData);
-
-        return ms.ToArray();
-    }
-
-    /// <summary>
-    /// Deserializes the TabuSearchOptimizer from a byte array.
-    /// </summary>
-    /// <param name="data">The byte array containing the serialized optimizer data.</param>
-    /// <exception cref="InvalidOperationException">Thrown when deserialization of optimizer options fails.</exception>
-    /// <remarks>
-    /// <para>
-    /// This method reconstructs the TabuSearchOptimizer from a serialized byte array. It performs the following steps:
-    /// 1. Deserializes the base class data.
-    /// 2. Deserializes the Tabu Search-specific options.
-    /// 3. Reinitializes the adaptive parameters.
-    /// </para>
-    /// <para><b>For Beginners:</b> Think of this method as "unpacking" the optimizer's saved state:
-    /// 
-    /// - It's like opening a saved file in a game to continue where you left off.
-    /// - The method reads the saved data and sets up the optimizer to match that saved state.
-    /// - It ensures that all the special Tabu Search settings are correctly restored.
-    /// - After unpacking, it prepares the optimizer for use by setting up its internal values.
-    /// 
-    /// This allows you to save the optimizer's state and later restore it exactly as it was.
-    /// </para>
-    /// </remarks>
-    public override void Deserialize(byte[] data)
-    {
-        using MemoryStream ms = new MemoryStream(data);
-        using BinaryReader reader = new BinaryReader(ms);
-
-        // Deserialize base class data
-        int baseDataLength = reader.ReadInt32();
-        byte[] baseData = reader.ReadBytes(baseDataLength);
-        base.Deserialize(baseData);
-
-        // Deserialize Tabu Search-specific options
-        string optionsJson = reader.ReadString();
-        _tabuOptions = JsonConvert.DeserializeObject<TabuSearchOptions<T, TInput, TOutput>>(optionsJson)
-            ?? throw new InvalidOperationException("Failed to deserialize optimizer options.");
-
-        // Deserialize the genetic algorithm if available
-        if (reader.BaseStream.Position < reader.BaseStream.Length)
-        {
-            int geneticAlgorithmDataLength = reader.ReadInt32();
-            byte[] geneticAlgorithmData = reader.ReadBytes(geneticAlgorithmDataLength);
-            _geneticAlgorithm.Deserialize(geneticAlgorithmData);
-        }
-
-        // Initialize adaptive parameters after deserialization
-        InitializeAdaptiveParameters();
-    }
-
     /// <summary>
     /// Creates a tabu search optimizer for minimizing a plain function, with no model attached.
     /// </summary>
diff --git a/src/Optimizers/TrustRegionOptimizer.cs b/src/Optimizers/TrustRegionOptimizer.cs
index 66eb3b6177..e99a49be1a 100644
--- a/src/Optimizers/TrustRegionOptimizer.cs
+++ b/src/Optimizers/TrustRegionOptimizer.cs
@@ -29,7 +29,7 @@ namespace AiDotNet.Optimizers;
 /// </remarks>
 [ComponentType(ComponentType.Optimizer)]
 [PipelineStage(PipelineStage.Training)]
-public class TrustRegionOptimizer<T, TInput, TOutput> : GradientBasedOptimizerBase<T, TInput, TOutput>, Fused.IFusedOptimizerSpec
+public partial class TrustRegionOptimizer<T, TInput, TOutput> : GradientBasedOptimizerBase<T, TInput, TOutput>, Fused.IFusedOptimizerSpec
 {
     /// <summary>
     /// Describes this optimizer for the compiled fused-training kernel.
@@ -766,75 +766,6 @@ public override void UpdateParametersGpu(IGpuBuffer parameters, IGpuBuffer gradi
             "is implemented via TapeStepContext.HessianVectorProduct().");
     }
 
-    /// <summary>
-    /// Serializes the current state of the optimizer into a byte array.
-    /// </summary>
-    /// <returns>A byte array representing the serialized state of the optimizer.</returns>
-    /// <remarks>
-    /// This method saves the current state of the optimizer, including its base class state and
-    /// specific Trust Region optimizer properties. This allows the optimizer's state to be stored
-    /// or transmitted and later reconstructed.
-    /// 
-    /// <para><b>For Beginners:</b> This is like taking a snapshot of the optimizer:
-    /// - It captures all the important information about the optimizer's current state.
-    /// - This snapshot can be saved or sent somewhere else.
-    /// - Later, you can use this snapshot to recreate the optimizer exactly as it was.
-    /// - It's useful for things like saving progress, or moving the optimization process to a different machine.
-    /// </para>
-    /// </remarks>
-    public override byte[] Serialize()
-    {
-        using (MemoryStream ms = new MemoryStream())
-        using (BinaryWriter writer = new BinaryWriter(ms))
-        {
-            byte[] baseData = base.Serialize();
-            writer.Write(baseData.Length);
-            writer.Write(baseData);
-
-            string optionsJson = JsonConvert.SerializeObject(_options);
-            writer.Write(optionsJson);
-
-            writer.Write(_iteration);
-            writer.Write(Convert.ToDouble(_trustRegionRadius));
-
-            return ms.ToArray();
-        }
-    }
-
-    /// <summary>
-    /// Deserializes the optimizer's state from a byte array.
-    /// </summary>
-    /// <param name="data">The byte array containing the serialized optimizer state.</param>
-    /// <exception cref="InvalidOperationException">Thrown when deserialization of optimizer options fails.</exception>
-    /// <remarks>
-    /// This method reconstructs the optimizer's state from a serialized byte array. It restores both
-    /// the base class state and the specific properties of the Trust Region optimizer.
-    /// 
-    /// <para><b>For Beginners:</b> This is like reconstructing the optimizer from a snapshot:
-    /// - It takes the snapshot (byte array) created by the Serialize method.
-    /// - From this snapshot, it rebuilds the optimizer to the exact state it was in when serialized.
-    /// - This is useful for resuming a paused optimization process or moving it to a different machine.
-    /// - If there's a problem reading the optimizer's settings, it will raise an error to let you know.
-    /// </para>
-    /// </remarks>
-    public override void Deserialize(byte[] data)
-    {
-        using (MemoryStream ms = new MemoryStream(data))
-        using (BinaryReader reader = new BinaryReader(ms))
-        {
-            int baseDataLength = reader.ReadInt32();
-            byte[] baseData = reader.ReadBytes(baseDataLength);
-            base.Deserialize(baseData);
-
-            string optionsJson = reader.ReadString();
-            _options = JsonConvert.DeserializeObject<TrustRegionOptimizerOptions<T, TInput, TOutput>>(optionsJson)
-                ?? throw new InvalidOperationException("Failed to deserialize optimizer options.");
-
-            _iteration = reader.ReadInt32();
-            _trustRegionRadius = NumOps.FromDouble(reader.ReadDouble());
-        }
-    }
-
     /// <inheritdoc />
     public override void Step(TapeStepContext<T> context)
     {
diff --git a/src/PhysicsInformed/NeuralOperators/DeepOperatorNetwork.cs b/src/PhysicsInformed/NeuralOperators/DeepOperatorNetwork.cs
index 5fa89833b3..db9601b982 100644
--- a/src/PhysicsInformed/NeuralOperators/DeepOperatorNetwork.cs
+++ b/src/PhysicsInformed/NeuralOperators/DeepOperatorNetwork.cs
@@ -849,55 +849,13 @@ public override ModelMetadata<T> GetModelMetadata()
         /// Serializes DeepONet-specific data.
         /// </summary>
         /// <param name="writer">Binary writer.</param>
-        protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-        {
-            writer.Write(_p);
-            writer.Write(_numSensors);
-
-            var branchBytes = _branchNet.Serialize();
-            writer.Write(branchBytes.Length);
-            writer.Write(branchBytes);
 
-            var trunkBytes = _trunkNet.Serialize();
-            writer.Write(trunkBytes.Length);
-            writer.Write(trunkBytes);
-        }
 
         /// <summary>
         /// Deserializes DeepONet-specific data.
         /// </summary>
         /// <param name="reader">Binary reader.</param>
-        protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-        {
-            int storedP = reader.ReadInt32();
-            int storedSensors = reader.ReadInt32();
-
-            if (storedP != _p || storedSensors != _numSensors)
-            {
-                throw new InvalidOperationException("Serialized DeepONet configuration does not match the current instance.");
-            }
 
-            int branchLength = reader.ReadInt32();
-            _branchNet.Deserialize(reader.ReadBytes(branchLength));
-
-            int trunkLength = reader.ReadInt32();
-            _trunkNet.Deserialize(reader.ReadBytes(trunkLength));
-        }
-
-        /// <summary>
-        /// Creates a new instance with the same configuration.
-        /// </summary>
-        /// <returns>New DeepONet instance.</returns>
-        protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-        {
-            return new DeepOperatorNetwork<T>(
-                Architecture,
-                _branchNet.Architecture,
-                _trunkNet.Architecture,
-                _p,
-                _numSensors,
-                _optimizer);
-        }
 
         private static void ClearNetworkGradients(NeuralNetworkBase<T> network)
         {
diff --git a/src/PhysicsInformed/NeuralOperators/FourierNeuralOperator.cs b/src/PhysicsInformed/NeuralOperators/FourierNeuralOperator.cs
index 90d20c448e..d5bca3370b 100644
--- a/src/PhysicsInformed/NeuralOperators/FourierNeuralOperator.cs
+++ b/src/PhysicsInformed/NeuralOperators/FourierNeuralOperator.cs
@@ -779,72 +779,13 @@ public override ModelMetadata<T> GetModelMetadata()
         /// Serializes FNO-specific data.
         /// </summary>
         /// <param name="writer">Binary writer.</param>
-        protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-        {
-            writer.Write(_modes);
-            writer.Write(_width);
-            writer.Write(_fourierLayers.Count);
-            writer.Write(_spatialDimensions.Length);
-            for (int i = 0; i < _spatialDimensions.Length; i++)
-            {
-                writer.Write(_spatialDimensions[i]);
-            }
 
-            foreach (var layer in _fourierLayers)
-            {
-                SerializationHelper<T>.SerializeVector(writer, layer.GetParameters());
-            }
-        }
 
         /// <summary>
         /// Deserializes FNO-specific data.
         /// </summary>
         /// <param name="reader">Binary reader.</param>
-        protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-        {
-            int storedModes = reader.ReadInt32();
-            int storedWidth = reader.ReadInt32();
-            int storedLayerCount = reader.ReadInt32();
-            int storedSpatialDims = reader.ReadInt32();
 
-            if (storedModes != _modes || storedWidth != _width || storedLayerCount != _fourierLayers.Count)
-            {
-                throw new InvalidOperationException("Serialized FNO configuration does not match the current instance.");
-            }
-
-            if (storedSpatialDims != _spatialDimensions.Length)
-            {
-                throw new InvalidOperationException("Serialized spatial dimensions do not match the current instance.");
-            }
-
-            for (int i = 0; i < storedSpatialDims; i++)
-            {
-                int storedDim = reader.ReadInt32();
-                if (storedDim != _spatialDimensions[i])
-                {
-                    throw new InvalidOperationException("Serialized spatial dimensions do not match the current instance.");
-                }
-            }
-
-            foreach (var layer in _fourierLayers)
-            {
-                layer.SetParameters(SerializationHelper<T>.DeserializeVector(reader));
-            }
-        }
-
-        /// <summary>
-        /// Creates a new instance with the same configuration.
-        /// </summary>
-        /// <returns>New FNO instance.</returns>
-        protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-        {
-            return new FourierNeuralOperator<T>(
-                Architecture,
-                _modes,
-                _width,
-                _spatialDimensions.ToArray(),
-                _fourierLayers.Count);
-        }
 
         public override bool SupportsTraining => true;
     }
diff --git a/src/PhysicsInformed/NeuralOperators/GraphNeuralOperator.cs b/src/PhysicsInformed/NeuralOperators/GraphNeuralOperator.cs
index 4848600f92..515312d014 100644
--- a/src/PhysicsInformed/NeuralOperators/GraphNeuralOperator.cs
+++ b/src/PhysicsInformed/NeuralOperators/GraphNeuralOperator.cs
@@ -398,55 +398,13 @@ public override ModelMetadata<T> GetModelMetadata()
         /// Serializes graph operator-specific data.
         /// </summary>
         /// <param name="writer">Binary writer.</param>
-        protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-        {
-            writer.Write(_numMessagePassingLayers);
-            writer.Write(_hiddenDim);
-            writer.Write(_inputDim);
-            writer.Write(_normalizeAdjacency);
-            writer.Write(_graphLayers.Count);
 
-            foreach (var layer in _graphLayers)
-            {
-                SerializationHelper<T>.SerializeVector(writer, layer.GetParameters());
-            }
-        }
 
         /// <summary>
         /// Deserializes graph operator-specific data.
         /// </summary>
         /// <param name="reader">Binary reader.</param>
-        protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-        {
-            int storedLayers = reader.ReadInt32();
-            int storedHidden = reader.ReadInt32();
-            int storedInputDim = reader.ReadInt32();
-            bool storedNormalize = reader.ReadBoolean();
-            int storedLayerCount = reader.ReadInt32();
-
-            if (storedLayers != _numMessagePassingLayers ||
-                storedHidden != _hiddenDim ||
-                storedInputDim != _inputDim ||
-                storedNormalize != _normalizeAdjacency ||
-                storedLayerCount != _graphLayers.Count)
-            {
-                throw new InvalidOperationException("Serialized graph operator configuration does not match the current instance.");
-            }
 
-            foreach (var layer in _graphLayers)
-            {
-                layer.SetParameters(SerializationHelper<T>.DeserializeVector(reader));
-            }
-        }
-
-        /// <summary>
-        /// Creates a new instance with the same configuration.
-        /// </summary>
-        /// <returns>New graph operator instance.</returns>
-        protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-        {
-            return new GraphNeuralOperator<T>(Architecture, _numMessagePassingLayers, _hiddenDim, null, _inputDim, _normalizeAdjacency);
-        }
 
 
         public Tensor<T> Forward(Tensor<T> nodeFeatures, Tensor<T> adjacencyMatrix)
diff --git a/src/PhysicsInformed/PINNs/DeepRitzMethod.cs b/src/PhysicsInformed/PINNs/DeepRitzMethod.cs
index 4869b3b4e4..8cdf5fba77 100644
--- a/src/PhysicsInformed/PINNs/DeepRitzMethod.cs
+++ b/src/PhysicsInformed/PINNs/DeepRitzMethod.cs
@@ -80,7 +80,7 @@ namespace AiDotNet.PhysicsInformed.PINNs
         Direction = TensorLayoutDirection.Input, BatchOptional = true)]
     [TensorLayout(TensorAxis.Batch, TensorAxis.Features,
         Direction = TensorLayoutDirection.Output, BatchOptional = true)]
-    public class DeepRitzMethod<T> : NeuralNetworkBase<T>
+    public partial class DeepRitzMethod<T> : NeuralNetworkBase<T>
     {
         private readonly DeepRitzMethodOptions _options;
 
@@ -493,42 +493,13 @@ public override ModelMetadata<T> GetModelMetadata()
         /// Serializes Deep Ritz-specific data.
         /// </summary>
         /// <param name="writer">Binary writer.</param>
-        protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-        {
-            writer.Write(_numQuadraturePoints);
-            writer.Write(Architecture.InputSize);
-        }
+
 
         /// <summary>
         /// Deserializes Deep Ritz-specific data.
         /// </summary>
         /// <param name="reader">Binary reader.</param>
-        protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-        {
-            int storedNumPoints = reader.ReadInt32();
-            int storedDimension = reader.ReadInt32();
-
-            if (storedNumPoints != _numQuadraturePoints || storedDimension != Architecture.InputSize)
-            {
-                throw new InvalidOperationException("Serialized Deep Ritz configuration does not match the current instance.");
-            }
 
-            GenerateQuadraturePoints(storedNumPoints, storedDimension);
-        }
-
-        /// <summary>
-        /// Creates a new instance with the same configuration.
-        /// </summary>
-        /// <returns>New Deep Ritz instance.</returns>
-        protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-        {
-            return new DeepRitzMethod<T>(
-                Architecture,
-                _energyFunctional,
-                _boundaryCheck,
-                _boundaryValue,
-                _numQuadraturePoints);
-        }
 
         /// <summary>
         /// Indicates whether this model supports training.
diff --git a/src/PhysicsInformed/PINNs/DomainDecompositionPINN.cs b/src/PhysicsInformed/PINNs/DomainDecompositionPINN.cs
index c766e32162..e928c5a540 100644
--- a/src/PhysicsInformed/PINNs/DomainDecompositionPINN.cs
+++ b/src/PhysicsInformed/PINNs/DomainDecompositionPINN.cs
@@ -81,7 +81,7 @@ namespace AiDotNet.PhysicsInformed.PINNs;
 [ModelComplexity(ModelComplexity.VeryHigh)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Extended Physics-Informed Neural Networks (XPINNs): A Generalized Space-Time Domain Decomposition Based Deep Learning Framework", "https://doi.org/10.4208/cicp.OA-2020-0164", Year = 2020, Authors = "Ameya D. Jagtap, George Em Karniadakis")]
-public class DomainDecompositionPINN<T> : PhysicsInformedNeuralNetwork<T>
+public partial class DomainDecompositionPINN<T> : PhysicsInformedNeuralNetwork<T>
 {
     private readonly DomainDecompositionPINNOptions _options;
 
diff --git a/src/PhysicsInformed/PINNs/InverseProblemPINN.cs b/src/PhysicsInformed/PINNs/InverseProblemPINN.cs
index 453eb4108c..0bb869e23c 100644
--- a/src/PhysicsInformed/PINNs/InverseProblemPINN.cs
+++ b/src/PhysicsInformed/PINNs/InverseProblemPINN.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
@@ -75,7 +75,7 @@ namespace AiDotNet.PhysicsInformed.PINNs
         Direction = TensorLayoutDirection.Input, BatchOptional = true)]
     [TensorLayout(TensorAxis.Batch, TensorAxis.Features,
         Direction = TensorLayoutDirection.Output, BatchOptional = true)]
-    public class InverseProblemPINN<T> : NeuralNetworkBase<T>
+    public partial class InverseProblemPINN<T> : NeuralNetworkBase<T>
     {
         private readonly IInverseProblem<T> _inverseProblem;
         private readonly IBoundaryCondition<T>[] _boundaryConditions;
@@ -89,7 +89,9 @@ public class InverseProblemPINN<T> : NeuralNetworkBase<T>
         private readonly bool _usesDefaultOptimizer;
 
         // Trainable parameters (the unknowns we're trying to find)
+        [AiDotNet.Attributes.Buffer]
         private Vector<T> _parameters;
+        [AiDotNet.Attributes.Buffer]
         private Vector<T>? _parameterGradients;
 
         // Current PDE with parameters applied
@@ -777,25 +779,6 @@ public override Vector<T> GetGradients()
             return new Vector<T>(allGradients.ToArray());
         }
 
-        /// <inheritdoc />
-        /// <remarks>
-        /// The unknown physical coefficients this PINN is solving for. They are weights like any
-        /// other -- gradient descent updates them alongside the network's -- so the base folds them
-        /// into the count, the vector, the restore and the chunks from this one declaration.
-        /// <para>
-        /// A FRESH view every call, deliberately: the training step REPLACES <c>_parameters</c>
-        /// (<c>_parameters = Engine.Subtract(...)</c>) rather than writing into it, and a cached
-        /// view would still alias the vector from before the last step. A <c>Tensor&lt;T&gt;</c>
-        /// built over a <c>Vector&lt;T&gt;</c> shares its storage, so writes through this land in
-        /// the field itself; the field stays a <c>Vector&lt;T&gt;</c> because
-        /// <c>IInverseProblem&lt;T&gt;.CreateParameterizedPDE</c> takes one.
-        /// </para>
-        /// </remarks>
-        protected override IEnumerable<Tensor<T>> GetExtraTrainableTensors()
-        {
-            yield return new Tensor<T>([_parameters.Length], _parameters);
-        }
-
         /// <inheritdoc />
         /// <remarks>
         /// The PDE is BUILT from the coefficients rather than reading them live, so restoring them
@@ -835,51 +818,10 @@ public override ModelMetadata<T> GetModelMetadata()
         }
 
         /// <inheritdoc/>
-        protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-        {
-            writer.Write(_parameters.Length);
-            foreach (var p in _parameters)
-            {
-                writer.Write(NumOps.ToDouble(p));
-            }
-            writer.Write(_numCollocationPoints);
-        }
-
-        /// <inheritdoc/>
-        protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-        {
-            int numParams = reader.ReadInt32();
-            if (numParams != _parameters.Length)
-            {
-                throw new InvalidOperationException("Serialized parameter count does not match.");
-            }
-
-            for (int i = 0; i < numParams; i++)
-            {
-                _parameters[i] = NumOps.FromDouble(reader.ReadDouble());
-            }
-
-            int numPoints = reader.ReadInt32();
-            if (numPoints != _numCollocationPoints)
-            {
-                throw new InvalidOperationException("Serialized collocation point count does not match.");
-            }
 
-            UpdatePDE();
-        }
 
         /// <inheritdoc/>
-        protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-        {
-            return new InverseProblemPINN<T>(
-                Architecture,
-                _inverseProblem,
-                _boundaryConditions,
-                _initialCondition,
-                _numCollocationPoints,
-                _options,
-                _optimizer);
-        }
+
 
         /// <inheritdoc/>
         public override bool SupportsTraining => true;
diff --git a/src/PhysicsInformed/PINNs/MultiScalePINN.cs b/src/PhysicsInformed/PINNs/MultiScalePINN.cs
index bfb1b72f6b..fdef4c9cf5 100644
--- a/src/PhysicsInformed/PINNs/MultiScalePINN.cs
+++ b/src/PhysicsInformed/PINNs/MultiScalePINN.cs
@@ -729,51 +729,10 @@ public override ModelMetadata<T> GetModelMetadata()
         }
 
         /// <inheritdoc/>
-        protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-        {
-            writer.Write(_multiScalePDE.NumberOfScales);
-            writer.Write(_currentActiveScales);
-            writer.Write(_numCollocationPointsPerScale);
 
-            foreach (var network in _scaleNetworks)
-            {
-                var bytes = network.Serialize();
-                writer.Write(bytes.Length);
-                writer.Write(bytes);
-            }
-        }
 
         /// <inheritdoc/>
-        protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-        {
-            int numScales = reader.ReadInt32();
-            _currentActiveScales = reader.ReadInt32();
-            int numPoints = reader.ReadInt32();
-
-            if (numScales != _multiScalePDE.NumberOfScales)
-            {
-                throw new InvalidOperationException("Serialized number of scales does not match.");
-            }
-
-            for (int scale = 0; scale < numScales; scale++)
-            {
-                int length = reader.ReadInt32();
-                _scaleNetworks[scale].Deserialize(reader.ReadBytes(length));
-            }
-        }
 
-        /// <inheritdoc/>
-        protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-        {
-            return new MultiScalePINN<T>(
-                Architecture,
-                _multiScalePDE,
-                _boundaryConditions,
-                _initialCondition,
-                _numCollocationPointsPerScale,
-                _trainingOptions,
-                _optimizer);
-        }
 
         /// <inheritdoc/>
         public override bool SupportsTraining => true;
diff --git a/src/PhysicsInformed/PINNs/PhysicsInformedNeuralNetwork.cs b/src/PhysicsInformed/PINNs/PhysicsInformedNeuralNetwork.cs
index 9108822aaf..3a310e7e25 100644
--- a/src/PhysicsInformed/PINNs/PhysicsInformedNeuralNetwork.cs
+++ b/src/PhysicsInformed/PINNs/PhysicsInformedNeuralNetwork.cs
@@ -93,7 +93,7 @@ namespace AiDotNet.PhysicsInformed.PINNs
         Direction = TensorLayoutDirection.Input, BatchOptional = true)]
     [TensorLayout(TensorAxis.Batch, TensorAxis.Features,
         Direction = TensorLayoutDirection.Output, BatchOptional = true)]
-    public class PhysicsInformedNeuralNetwork<T> : NeuralNetworkBase<T>
+    public partial class PhysicsInformedNeuralNetwork<T> : NeuralNetworkBase<T>
     {
         private readonly PhysicsInformedNeuralNetworkOptions _options;
 
@@ -638,82 +638,13 @@ public override ModelMetadata<T> GetModelMetadata()
         /// Serializes PINN-specific data.
         /// </summary>
         /// <param name="writer">Binary writer.</param>
-        protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-        {
-            writer.Write(_numCollocationPoints);
-            writer.Write(_pdeSpecification.InputDimension);
-            writer.Write(_pdeSpecification.OutputDimension);
 
-            if (_collocationPoints == null)
-            {
-                writer.Write(false);
-                return;
-            }
-
-            writer.Write(true);
-            writer.Write(_collocationPoints.GetLength(0));
-            writer.Write(_collocationPoints.GetLength(1));
-
-            for (int i = 0; i < _collocationPoints.GetLength(0); i++)
-            {
-                for (int j = 0; j < _collocationPoints.GetLength(1); j++)
-                {
-                    SerializationHelper<T>.WriteValue(writer, _collocationPoints[i, j]);
-                }
-            }
-        }
 
         /// <summary>
         /// Deserializes PINN-specific data.
         /// </summary>
         /// <param name="reader">Binary reader.</param>
-        protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-        {
-            int storedCollocationCount = reader.ReadInt32();
-            int storedInputDim = reader.ReadInt32();
-            int storedOutputDim = reader.ReadInt32();
-
-            if (storedCollocationCount != _numCollocationPoints ||
-                storedInputDim != _pdeSpecification.InputDimension ||
-                storedOutputDim != _pdeSpecification.OutputDimension)
-            {
-                throw new InvalidOperationException("Serialized PINN configuration does not match the current instance.");
-            }
-
-            bool hasPoints = reader.ReadBoolean();
-            if (!hasPoints)
-            {
-                _collocationPoints = null;
-                return;
-            }
 
-            int rows = reader.ReadInt32();
-            int cols = reader.ReadInt32();
-            _collocationPoints = new T[rows, cols];
-
-            for (int i = 0; i < rows; i++)
-            {
-                for (int j = 0; j < cols; j++)
-                {
-                    _collocationPoints[i, j] = SerializationHelper<T>.ReadValue(reader);
-                }
-            }
-        }
-
-        /// <summary>
-        /// Creates a new instance with the same configuration.
-        /// </summary>
-        /// <returns>New PINN instance.</returns>
-        protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-        {
-            return new PhysicsInformedNeuralNetwork<T>(
-                Architecture,
-                _pdeSpecification,
-                _boundaryConditions,
-                _initialCondition,
-                _numCollocationPoints,
-                _optimizer);
-        }
 
         /// <summary>
         /// Indicates whether this PINN supports training.
diff --git a/src/PhysicsInformed/PINNs/VariationalPINN.cs b/src/PhysicsInformed/PINNs/VariationalPINN.cs
index 7bd83f43f3..e1ded04e5a 100644
--- a/src/PhysicsInformed/PINNs/VariationalPINN.cs
+++ b/src/PhysicsInformed/PINNs/VariationalPINN.cs
@@ -95,7 +95,7 @@ namespace AiDotNet.PhysicsInformed.PINNs
         Direction = TensorLayoutDirection.Input, BatchOptional = true)]
     [TensorLayout(TensorAxis.Batch, TensorAxis.Features,
         Direction = TensorLayoutDirection.Output, BatchOptional = true)]
-    public class VariationalPINN<T> : NeuralNetworkBase<T>
+    public partial class VariationalPINN<T> : NeuralNetworkBase<T>
     {
         private readonly VariationalPINNOptions _options;
 
@@ -543,45 +543,13 @@ public override ModelMetadata<T> GetModelMetadata()
         /// Serializes VPINN-specific data.
         /// </summary>
         /// <param name="writer">Binary writer.</param>
-        protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-        {
-            writer.Write(_numQuadraturePoints);
-            writer.Write(Architecture.InputSize);
-            writer.Write(_numTestFunctions);
-        }
+
 
         /// <summary>
         /// Deserializes VPINN-specific data.
         /// </summary>
         /// <param name="reader">Binary reader.</param>
-        protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-        {
-            int storedNumPoints = reader.ReadInt32();
-            int storedDimension = reader.ReadInt32();
-            int storedTestFunctions = reader.ReadInt32();
-
-            if (storedNumPoints != _numQuadraturePoints ||
-                storedDimension != Architecture.InputSize ||
-                storedTestFunctions != _numTestFunctions)
-            {
-                throw new InvalidOperationException("Serialized VPINN configuration does not match the current instance.");
-            }
 
-            GenerateQuadraturePoints(storedNumPoints, storedDimension);
-        }
-
-        /// <summary>
-        /// Creates a new instance with the same configuration.
-        /// </summary>
-        /// <returns>New VPINN instance.</returns>
-        protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-        {
-            return new VariationalPINN<T>(
-                Architecture,
-                _weakFormResidual,
-                _numQuadraturePoints,
-                _numTestFunctions);
-        }
 
         /// <summary>
         /// Indicates whether this model supports training.
diff --git a/src/PhysicsInformed/ScientificML/HamiltonianNeuralNetwork.cs b/src/PhysicsInformed/ScientificML/HamiltonianNeuralNetwork.cs
index 3301275983..847134022f 100644
--- a/src/PhysicsInformed/ScientificML/HamiltonianNeuralNetwork.cs
+++ b/src/PhysicsInformed/ScientificML/HamiltonianNeuralNetwork.cs
@@ -88,7 +88,7 @@ namespace AiDotNet.PhysicsInformed.ScientificML
         Direction = TensorLayoutDirection.Input, BatchOptional = true)]
     [TensorLayout(TensorAxis.Batch, TensorAxis.Features,
         Direction = TensorLayoutDirection.Output, BatchOptional = true)]
-    public class HamiltonianNeuralNetwork<T> : NeuralNetworkBase<T>
+    public partial class HamiltonianNeuralNetwork<T> : NeuralNetworkBase<T>
     {
         private readonly HamiltonianNeuralNetworkOptions _options;
 
@@ -403,32 +403,13 @@ public override ModelMetadata<T> GetModelMetadata()
         /// Serializes Hamiltonian-specific data.
         /// </summary>
         /// <param name="writer">Binary writer.</param>
-        protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-        {
-            writer.Write(_stateDim);
-        }
+
 
         /// <summary>
         /// Deserializes Hamiltonian-specific data.
         /// </summary>
         /// <param name="reader">Binary reader.</param>
-        protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-        {
-            int storedStateDim = reader.ReadInt32();
-            if (storedStateDim != _stateDim)
-            {
-                throw new InvalidOperationException("Serialized Hamiltonian configuration does not match the current instance.");
-            }
-        }
 
-        /// <summary>
-        /// Creates a new instance with the same configuration.
-        /// </summary>
-        /// <returns>New Hamiltonian network instance.</returns>
-        protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-        {
-            return new HamiltonianNeuralNetwork<T>(Architecture, _stateDim, _optimizer);
-        }
 
         /// <summary>
         /// Indicates whether this model supports training.
diff --git a/src/PhysicsInformed/ScientificML/LagrangianNeuralNetwork.cs b/src/PhysicsInformed/ScientificML/LagrangianNeuralNetwork.cs
index 238319e6ca..45044ad1f3 100644
--- a/src/PhysicsInformed/ScientificML/LagrangianNeuralNetwork.cs
+++ b/src/PhysicsInformed/ScientificML/LagrangianNeuralNetwork.cs
@@ -74,7 +74,7 @@ namespace AiDotNet.PhysicsInformed.ScientificML
         Direction = TensorLayoutDirection.Input, BatchOptional = true)]
     [TensorLayout(TensorAxis.Batch, TensorAxis.Features,
         Direction = TensorLayoutDirection.Output, BatchOptional = true)]
-    public class LagrangianNeuralNetwork<T> : NeuralNetworkBase<T>
+    public partial class LagrangianNeuralNetwork<T> : NeuralNetworkBase<T>
     {
         private readonly LagrangianNeuralNetworkOptions _options;
 
@@ -325,32 +325,13 @@ public override ModelMetadata<T> GetModelMetadata()
         /// Serializes Lagrangian-specific data.
         /// </summary>
         /// <param name="writer">Binary writer.</param>
-        protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-        {
-            writer.Write(_configurationDim);
-        }
+
 
         /// <summary>
         /// Deserializes Lagrangian-specific data.
         /// </summary>
         /// <param name="reader">Binary reader.</param>
-        protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-        {
-            int storedConfigDim = reader.ReadInt32();
-            if (storedConfigDim != _configurationDim)
-            {
-                throw new InvalidOperationException("Serialized Lagrangian configuration does not match the current instance.");
-            }
-        }
 
-        /// <summary>
-        /// Creates a new instance with the same configuration.
-        /// </summary>
-        /// <returns>New Lagrangian network instance.</returns>
-        protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-        {
-            return new LagrangianNeuralNetwork<T>(Architecture, _configurationDim, _optimizer);
-        }
 
         /// <summary>
         /// Indicates whether this model supports training.
diff --git a/src/PhysicsInformed/ScientificML/SymbolicPhysicsLearner.cs b/src/PhysicsInformed/ScientificML/SymbolicPhysicsLearner.cs
index 5c928aee6e..5a9bbeedbe 100644
--- a/src/PhysicsInformed/ScientificML/SymbolicPhysicsLearner.cs
+++ b/src/PhysicsInformed/ScientificML/SymbolicPhysicsLearner.cs
@@ -1004,17 +1004,6 @@ private static void CollectConstantNodes(
             CollectConstantNodes(node.Right, constants);
         }
 
-        /// <inheritdoc/>
-        public override IFullModel<T, Matrix<T>, Vector<T>> DeepCopy()
-        {
-            var clone = new SymbolicPhysicsLearner<T>();
-            if (_discoveredEquation is not null)
-            {
-                clone._discoveredEquation = _discoveredEquation.Clone();
-            }
-            return clone;
-        }
-
         /// <inheritdoc/>
         public override IFullModel<T, Matrix<T>, Vector<T>> WithParameters(Vector<T> parameters)
         {
diff --git a/src/PhysicsInformed/ScientificML/UniversalDifferentialEquations.cs b/src/PhysicsInformed/ScientificML/UniversalDifferentialEquations.cs
index 57bc31c71c..bee900dd70 100644
--- a/src/PhysicsInformed/ScientificML/UniversalDifferentialEquations.cs
+++ b/src/PhysicsInformed/ScientificML/UniversalDifferentialEquations.cs
@@ -79,7 +79,7 @@ public enum OdeIntegrationMethod
         Direction = TensorLayoutDirection.Input, BatchOptional = true)]
     [TensorLayout(TensorAxis.Batch, TensorAxis.Features,
         Direction = TensorLayoutDirection.Output, BatchOptional = true)]
-    public class UniversalDifferentialEquation<T> : NeuralNetworkBase<T>
+    public partial class UniversalDifferentialEquation<T> : NeuralNetworkBase<T>
     {
         private readonly UniversalDifferentialEquationsOptions _options;
 
@@ -410,32 +410,13 @@ public override ModelMetadata<T> GetModelMetadata()
         /// Serializes UDE-specific data.
         /// </summary>
         /// <param name="writer">Binary writer.</param>
-        protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-        {
-            writer.Write(_stateDim);
-        }
+
 
         /// <summary>
         /// Deserializes UDE-specific data.
         /// </summary>
         /// <param name="reader">Binary reader.</param>
-        protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-        {
-            int storedStateDim = reader.ReadInt32();
-            if (storedStateDim != _stateDim)
-            {
-                throw new InvalidOperationException("Serialized UDE configuration does not match the current instance.");
-            }
-        }
 
-        /// <summary>
-        /// Creates a new instance with the same configuration.
-        /// </summary>
-        /// <returns>New UDE instance.</returns>
-        protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-        {
-            return new UniversalDifferentialEquation<T>(Architecture, _stateDim, _knownDynamics, _optimizer);
-        }
 
         /// <summary>
         /// Indicates whether this model supports training.
diff --git a/src/PointCloud/Layers/PointConvolutionLayer.cs b/src/PointCloud/Layers/PointConvolutionLayer.cs
index dda8fa8bf0..b714ba3623 100644
--- a/src/PointCloud/Layers/PointConvolutionLayer.cs
+++ b/src/PointCloud/Layers/PointConvolutionLayer.cs
@@ -75,11 +75,16 @@ public partial class PointConvolutionLayer<T> : LayerBase<T>, IShapeContract
     }
 
     // Trainable parameters as registered Tensors so the autodiff tape trains them.
-    // Not readonly: SetTrainableParameters re-points them for the copy-on-write DeepCopy/Clone
+    // Not readonly: the restore path re-points them for the copy-on-write DeepCopy/Clone
     // path (which rebinds shared tensor storage into each layer), and Forward reads these fields
     // directly, so a clone that only rebinds the base registry — without updating these fields —
-    // would keep its fresh random init and diverge from the original.
+    // would keep its fresh random init and diverge from the original. The generated setter
+    // rebinds a mutable field for exactly that reason, and unlike the hand-written pair it
+    // replaced it also brings the base registry along instead of leaving it pointing at the
+    // pre-clone tensors.
+    [AiDotNet.Attributes.TrainableParameter(Role = PersistentTensorRole.Weights)]
     private Tensor<T> _weights; // [inputChannels, outputChannels]
+    [AiDotNet.Attributes.TrainableParameter(Role = PersistentTensorRole.Biases)]
     private Tensor<T> _biases;  // [outputChannels]
 
     /// <summary>
@@ -134,32 +139,6 @@ protected override Tensor<T> ForwardTraced(Tensor<T> input)
         return ApplyActivation(biased);
     }
 
-    /// <summary>
-    /// Returns the field-backed trainable tensors so the tape optimizer, the parameter-count walk,
-    /// and the copy-on-write clone all see the SAME instances the Forward reads. Overriding this
-    /// (rather than relying on the base <c>_registeredTensors</c> list) keeps GetTrainableParameters
-    /// consistent with <see cref="SetTrainableParameters"/> after a field re-point.
-    /// </summary>
-    public override IReadOnlyList<Tensor<T>> GetTrainableParameters() => new[] { _weights, _biases };
-
-    /// <summary>
-    /// Re-points the field-backed weight/bias tensors to the supplied instances. The copy-on-write
-    /// DeepCopy/Clone path shares each source tensor into its clone through this method; because
-    /// <see cref="Forward"/> reads the <c>_weights</c>/<c>_biases</c> fields directly, they must be
-    /// rebound here (the base only updates its private registry), or the clone diverges from the
-    /// original (issue #1221 class).
-    /// </summary>
-    public override void SetTrainableParameters(IReadOnlyList<Tensor<T>> parameters)
-    {
-        if (parameters.Count != 2)
-        {
-            throw new ArgumentException($"Expected 2 parameter tensors (weights, biases), got {parameters.Count}.", nameof(parameters));
-        }
-
-        _weights = parameters[0];
-        _biases = parameters[1];
-    }
-
     // UpdateParameters delegated straight to SetParameters. The base does that now.
     public override void ClearGradients()
     {
diff --git a/src/PointCloud/Layers/TNetLayer.cs b/src/PointCloud/Layers/TNetLayer.cs
index dc8dab8715..89738e5241 100644
--- a/src/PointCloud/Layers/TNetLayer.cs
+++ b/src/PointCloud/Layers/TNetLayer.cs
@@ -63,11 +63,15 @@ public partial class TNetLayer<T> : LayerBase<T>, IShapeContract
 {
     private readonly int _transformDim; // Dimension of transformation (e.g., 3 for XYZ, 64 for features)
     private readonly int _numFeatures;
+    private readonly int[] _mlpChannels;
+    private readonly int[] _fcChannels;
     private readonly List<ILayer<T>> _mlpLayers;
     private readonly List<ILayer<T>> _fcLayers;
     private readonly MaxPoolingLayer<T> _maxPooling;
+    [Scratch]
     private Tensor<T>? _lastInput;
     private Matrix<T>? _transformMatrix;
+    [Scratch]
     private Tensor<T>? _lastTransformVector;
 
     /// <summary>
@@ -116,11 +120,13 @@ public TNetLayer(int transformDim, int numFeatures, int[]? mlpChannels = null, i
         _mlpLayers = [];
         _fcLayers = [];
 
-        var mlp = ValidateChannelArray(mlpChannels ?? new[] { 64, 128, 1024 }, nameof(mlpChannels));
-        var fc = ValidateChannelArray(fcChannels ?? new[] { 512, 256 }, nameof(fcChannels));
+        _mlpChannels = ValidateChannelArray(
+            mlpChannels ?? new[] { 64, 128, 1024 }, nameof(mlpChannels));
+        _fcChannels = ValidateChannelArray(
+            fcChannels ?? new[] { 512, 256 }, nameof(fcChannels));
 
         int inputChannels = numFeatures;
-        foreach (var outChannels in mlp)
+        foreach (var outChannels in _mlpChannels)
         {
             _mlpLayers.Add(new PointConvolutionLayer<T>(inputChannels, outChannels, new ReLUActivation<T>()));
             inputChannels = outChannels;
@@ -129,7 +135,7 @@ public TNetLayer(int transformDim, int numFeatures, int[]? mlpChannels = null, i
         _maxPooling = new MaxPoolingLayer<T>(inputChannels);
 
         int fcInput = inputChannels;
-        foreach (var hidden in fc)
+        foreach (var hidden in _fcChannels)
         {
             _fcLayers.Add(new DenseLayer<T>(hidden, activationFunction: new ReLUActivation<T>()));
             fcInput = hidden;
@@ -323,6 +329,6 @@ private static int[] ValidateChannelArray(int[] values, string paramName)
             }
         }
 
-        return values;
+        return (int[])values.Clone();
     }
 }
diff --git a/src/PointCloud/Models/DGCNN.cs b/src/PointCloud/Models/DGCNN.cs
index d3704ac939..b2159f8a07 100644
--- a/src/PointCloud/Models/DGCNN.cs
+++ b/src/PointCloud/Models/DGCNN.cs
@@ -517,66 +517,9 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_numClasses);
-        writer.Write(_inputFeatureDim);
-        writer.Write(_knnK);
-        writer.Write(_useDropout);
-        writer.Write(_dropoutRate);
-        writer.Write(NumOps.ToDouble(_learningRate));
-        WriteIntArray(writer, _edgeConvChannels);
-        WriteIntArray(writer, _classifierChannels);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _numClasses = reader.ReadInt32();
-        _inputFeatureDim = reader.ReadInt32();
-        _knnK = reader.ReadInt32();
-        _useDropout = reader.ReadBoolean();
-        _dropoutRate = reader.ReadDouble();
-        _learningRate = NumOps.FromDouble(reader.ReadDouble());
-        _edgeConvChannels = ReadIntArray(reader, nameof(_edgeConvChannels), allowEmpty: false);
-        _classifierChannels = ReadIntArray(reader, nameof(_classifierChannels), allowEmpty: true);
 
-        _edgeConvLayers.Clear();
-        _classificationHeadLayers.Clear();
-        bool afterPooling = false;
-        foreach (var layer in Layers)
-        {
-            if (layer is EdgeConvLayer<T> edgeLayer)
-            {
-                _edgeConvLayers.Add(edgeLayer);
-            }
-            if (layer is AiDotNet.PointCloud.Layers.MaxPoolingLayer<T>)
-            {
-                afterPooling = true;
-                continue;
-            }
-            if (afterPooling && (layer is DenseLayer<T> || layer is DropoutLayer<T>))
-            {
-                _classificationHeadLayers.Add(layer);
-            }
-        }
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new DGCNN<T>(
-            new DGCNNOptions
-            {
-                NumClasses = _numClasses,
-                InputFeatureDim = _inputFeatureDim,
-                KnnK = _knnK,
-                EdgeConvChannels = _edgeConvChannels,
-                ClassifierChannels = _classifierChannels,
-                UseDropout = _useDropout,
-                DropoutRate = _dropoutRate,
-                LearningRate = NumOps.ToDouble(_learningRate)
-            },
-            LossFunction);
-    }
 
     private static int[] ValidatePositiveArray(int[]? values, string paramName)
     {
@@ -708,6 +651,7 @@ public partial class EdgeConvLayer<T> : LayerBase<T>, ILayerSerializationExtras<
     private readonly int _k; // Number of nearest neighbors
     private readonly PointConvolutionLayer<T> _mlp;
     private readonly BatchNormalizationLayer<T> _bn;
+    [Scratch]
     private Tensor<T>? _lastInput;
     private int[,]? _knnIndices; // Store k-NN indices for backward pass
     private int[,]? _maxIndices; // Store max neighbor indices for backward pass
diff --git a/src/PointCloud/Models/PointNet.cs b/src/PointCloud/Models/PointNet.cs
index e513f70c0e..fcf91bb5dc 100644
--- a/src/PointCloud/Models/PointNet.cs
+++ b/src/PointCloud/Models/PointNet.cs
@@ -420,82 +420,9 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_numClasses);
-        writer.Write(_inputFeatureDim);
-        writer.Write(_inputTransformDim);
-        writer.Write(_useInputTransform);
-        writer.Write(_useFeatureTransform);
-        writer.Write(_useDropout);
-        writer.Write(_dropoutRate);
-        writer.Write(NumOps.ToDouble(_learningRate));
-        WriteIntArray(writer, _inputMlpChannels);
-        WriteIntArray(writer, _featureMlpChannels);
-        WriteIntArray(writer, _classifierChannels);
-        WriteIntArray(writer, _inputTransformMlpChannels);
-        WriteIntArray(writer, _inputTransformFcChannels);
-        WriteIntArray(writer, _featureTransformMlpChannels);
-        WriteIntArray(writer, _featureTransformFcChannels);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _numClasses = reader.ReadInt32();
-        _inputFeatureDim = reader.ReadInt32();
-        _inputTransformDim = reader.ReadInt32();
-        _useInputTransform = reader.ReadBoolean();
-        _useFeatureTransform = reader.ReadBoolean();
-        _useDropout = reader.ReadBoolean();
-        _dropoutRate = reader.ReadDouble();
-        _learningRate = NumOps.FromDouble(reader.ReadDouble());
-        _inputMlpChannels = ReadIntArray(reader, nameof(_inputMlpChannels), allowEmpty: false);
-        _featureMlpChannels = ReadIntArray(reader, nameof(_featureMlpChannels), allowEmpty: false);
-        _classifierChannels = ReadIntArray(reader, nameof(_classifierChannels), allowEmpty: true);
-        _inputTransformMlpChannels = ReadIntArray(reader, nameof(_inputTransformMlpChannels), allowEmpty: false);
-        _inputTransformFcChannels = ReadIntArray(reader, nameof(_inputTransformFcChannels), allowEmpty: false);
-        _featureTransformMlpChannels = ReadIntArray(reader, nameof(_featureTransformMlpChannels), allowEmpty: false);
-        _featureTransformFcChannels = ReadIntArray(reader, nameof(_featureTransformFcChannels), allowEmpty: false);
 
-        _classificationHeadLayers.Clear();
-        bool afterPooling = false;
-        foreach (var layer in Layers)
-        {
-            if (layer is AiDotNet.PointCloud.Layers.MaxPoolingLayer<T>)
-            {
-                afterPooling = true;
-                continue;
-            }
-            if (afterPooling && (layer is DenseLayer<T> || layer is DropoutLayer<T>))
-            {
-                _classificationHeadLayers.Add(layer);
-            }
-        }
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new PointNet<T>(
-            new PointNetOptions
-            {
-                NumClasses = _numClasses,
-                InputFeatureDim = _inputFeatureDim,
-                InputTransformDim = _inputTransformDim,
-                UseInputTransform = _useInputTransform,
-                UseFeatureTransform = _useFeatureTransform,
-                InputMlpChannels = _inputMlpChannels,
-                FeatureMlpChannels = _featureMlpChannels,
-                ClassifierChannels = _classifierChannels,
-                InputTransformMlpChannels = _inputTransformMlpChannels,
-                InputTransformFcChannels = _inputTransformFcChannels,
-                FeatureTransformMlpChannels = _featureTransformMlpChannels,
-                FeatureTransformFcChannels = _featureTransformFcChannels,
-                UseDropout = _useDropout,
-                DropoutRate = _dropoutRate,
-                LearningRate = NumOps.ToDouble(_learningRate)
-            },
-            LossFunction);
-    }
 
     private static int[] ValidateChannelArray(int[]? values, string paramName)
     {
diff --git a/src/PointCloud/Models/PointNetPlusPlus.cs b/src/PointCloud/Models/PointNetPlusPlus.cs
index 7d7f3b4d20..927d4b027a 100644
--- a/src/PointCloud/Models/PointNetPlusPlus.cs
+++ b/src/PointCloud/Models/PointNetPlusPlus.cs
@@ -589,115 +589,9 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_numClasses);
-        writer.Write(_inputFeatureDim);
-        writer.Write(_useMultiScaleGrouping);
-        writer.Write(_useDropout);
-        writer.Write(_dropoutRate);
-        writer.Write(NumOps.ToDouble(_learningRate));
-
-        WriteIntArray(writer, _samplingRates);
-        WriteDoubleArray(writer, _searchRadii);
-        WriteIntArray(writer, _neighborSamples);
-        WriteIntJagged(writer, _mlpDimensions);
-        WriteIntArray(writer, _classifierChannels);
-
-        bool hasMultiScale = _multiScaleRadii != null && _multiScaleMlpDimensions != null && _multiScaleNeighborSamples != null;
-        writer.Write(hasMultiScale);
-        if (hasMultiScale)
-        {
-            var multiScaleRadii = _multiScaleRadii;
-            var multiScaleMlpDimensions = _multiScaleMlpDimensions;
-            var multiScaleNeighborSamples = _multiScaleNeighborSamples;
-            if (multiScaleRadii == null || multiScaleMlpDimensions == null || multiScaleNeighborSamples == null)
-            {
-                throw new InvalidOperationException("Multi-scale configuration is missing.");
-            }
 
-            WriteDoubleJagged(writer, multiScaleRadii);
-            WriteIntJagged3(writer, multiScaleMlpDimensions);
-            WriteIntJagged(writer, multiScaleNeighborSamples);
-        }
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _numClasses = reader.ReadInt32();
-        _inputFeatureDim = reader.ReadInt32();
-        _useMultiScaleGrouping = reader.ReadBoolean();
-        _useDropout = reader.ReadBoolean();
-        _dropoutRate = reader.ReadDouble();
-        _learningRate = NumOps.FromDouble(reader.ReadDouble());
-
-        _samplingRates = ReadIntArray(reader, nameof(_samplingRates), allowEmpty: false);
-        _searchRadii = ReadDoubleArray(reader, nameof(_searchRadii), allowEmpty: false);
-        _neighborSamples = ReadIntArray(reader, nameof(_neighborSamples), allowEmpty: false);
-        _mlpDimensions = ReadIntJagged(reader, nameof(_mlpDimensions), allowEmpty: false);
-        _classifierChannels = ReadIntArray(reader, nameof(_classifierChannels), allowEmpty: true);
-
-        bool hasMultiScale = reader.ReadBoolean();
-        if (hasMultiScale)
-        {
-            _multiScaleRadii = ReadDoubleJagged(reader, nameof(_multiScaleRadii));
-            _multiScaleMlpDimensions = ReadIntJagged3(reader, nameof(_multiScaleMlpDimensions));
-            _multiScaleNeighborSamples = ReadIntJagged(reader, nameof(_multiScaleNeighborSamples), allowEmpty: false);
-            if (_multiScaleRadii == null || _multiScaleMlpDimensions == null || _multiScaleNeighborSamples == null)
-            {
-                throw new InvalidOperationException("Serialized multi-scale configuration is incomplete.");
-            }
-        }
-        else
-        {
-            _multiScaleRadii = null;
-            _multiScaleMlpDimensions = null;
-            _multiScaleNeighborSamples = null;
-        }
 
-        _setAbstractionLayers.Clear();
-        _classificationHeadLayers.Clear();
-        bool afterPooling = false;
-        foreach (var layer in Layers)
-        {
-            if (layer is SetAbstractionLayer<T> saLayer)
-            {
-                _setAbstractionLayers.Add(saLayer);
-            }
-            if (layer is AiDotNet.PointCloud.Layers.MaxPoolingLayer<T>)
-            {
-                afterPooling = true;
-                continue;
-            }
-            if (afterPooling && (layer is DenseLayer<T> || layer is DropoutLayer<T>))
-            {
-                _classificationHeadLayers.Add(layer);
-            }
-        }
-    }
-
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new PointNetPlusPlus<T>(
-            new PointNetPlusPlusOptions
-            {
-                NumClasses = _numClasses,
-                InputFeatureDim = _inputFeatureDim,
-                SamplingRates = _samplingRates,
-                SearchRadii = _searchRadii,
-                NeighborSamples = _neighborSamples,
-                MlpDimensions = _mlpDimensions,
-                UseMultiScaleGrouping = _useMultiScaleGrouping,
-                MultiScaleRadii = _multiScaleRadii,
-                MultiScaleMlpDimensions = _multiScaleMlpDimensions,
-                MultiScaleNeighborSamples = _multiScaleNeighborSamples,
-                ClassifierChannels = _classifierChannels,
-                UseDropout = _useDropout,
-                DropoutRate = _dropoutRate,
-                LearningRate = NumOps.ToDouble(_learningRate)
-            },
-            LossFunction);
-    }
 
     private static int[] ValidatePositiveArray(int[]? values, string paramName)
     {
@@ -1137,8 +1031,29 @@ public ScaleBranch(double radius, int neighborSamples, int inputChannels, int[]
     private readonly int _numPoints;
     private readonly int _inputChannels;
     private readonly List<ScaleBranch> _branches;
+
+    /// <summary>
+    /// Every branch's mini-PointNet, flattened, so the generator can SEE them.
+    /// </summary>
+    /// <remarks>
+    /// The MLPs are owned by <c>_branches[i].MlpLayers</c>, but <c>ScaleBranch</c> is a plain nested
+    /// class, and TrainableParameterGenerator recognises children only in a field whose TYPE is a layer
+    /// or a collection of layers. A <c>List&lt;ScaleBranch&gt;</c> is opaque to it, so it concluded this
+    /// layer had no parameters at all and emitted <c>IsDeclaredParameterFree =&gt; true</c> -- a
+    /// COMPILE-TIME assertion that no amount of runtime RegisterSubLayer can outvote. Every
+    /// PointConvolution weight was therefore absent from GetParameters, never saved, and unreachable by
+    /// SetParameters, so a rebuilt layer silently kept its random initialisation.
+    /// <para>
+    /// This field holds the same layer instances (not copies), so it is a VIEW for the generator rather
+    /// than a second owner: registering it is what makes ParameterCount, GetParameters and
+    /// SetParameters fold the branch weights in.
+    /// </para>
+    /// </remarks>
+    private readonly List<ILayer<T>> _branchLayers = [];
+    [Scratch]
     private Tensor<T>? _lastInput;
     private int[]? _centroidIndices;
+    [Scratch]
     private Tensor<T>? _lastCentroidPositions;
     private readonly int _outputChannels;
 
@@ -1167,6 +1082,7 @@ public SetAbstractionLayer(
         _branches = [new ScaleBranch(searchRadius, neighborSamples, inputChannels, mlpDimensions)];
         _outputChannels = _branches[0].OutputChannels;
 
+        RegisterBranchLayers();
         Parameters = GetParameters();
     }
 
@@ -1209,9 +1125,48 @@ public SetAbstractionLayer(
         }
 
         _outputChannels = _branches.Sum(branch => branch.OutputChannels);
+        RegisterBranchLayers();
         Parameters = GetParameters();
     }
 
+    /// <summary>
+    /// Registers every branch's mini-PointNet as a CHILD layer, which is what puts their weights into
+    /// this layer's parameter surface at all.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// The MLPs live in <c>_branches[i].MlpLayers</c>, and <c>ScaleBranch</c> is a plain nested class
+    /// rather than a layer. TrainableParameterGenerator collects children only from a field whose TYPE
+    /// is a layer or a collection of layers, so a <c>List&lt;ScaleBranch&gt;</c> is opaque to it and the
+    /// generated file for this type collected NO tensors at all.
+    /// </para>
+    /// <para>
+    /// The consequence was silent and total: every PointConvolution weight in every branch sat OUTSIDE
+    /// GetParameters, so it was never saved, <c>SetParameters</c> could not reach it, and a rebuilt
+    /// layer kept its fresh random initialisation. The saved vector still compared bit-identical
+    /// because it only ever held the classification head -- the whole model reported 1652 parameters.
+    /// A clone's three set-abstraction layers therefore computed different outputs from provably
+    /// identical weights.
+    /// </para>
+    /// <para>
+    /// Registration is the entire fix: <see cref="LayerBase{T}"/> folds <c>GetSubLayers()</c> into
+    /// ParameterCount, GetParameters and SetParameters, so no override and no hand-written
+    /// serialization is needed here. This is the same mechanism CifAlignmentLayer uses for its alpha
+    /// predictor.
+    /// </para>
+    /// </remarks>
+    private void RegisterBranchLayers()
+    {
+        foreach (var branch in _branches)
+        {
+            foreach (var mlp in branch.MlpLayers)
+            {
+                _branchLayers.Add(mlp);
+                RegisterSubLayer(mlp);
+            }
+        }
+    }
+
     /// <summary>
     /// Records the structural configuration a clone/deserialize needs to rebuild
     /// this layer with the same parameter count. The generic layer serialization
diff --git a/src/Preprocessing/Imputers/KNNImputer.cs b/src/Preprocessing/Imputers/KNNImputer.cs
index 56d018a980..91988e2a46 100644
--- a/src/Preprocessing/Imputers/KNNImputer.cs
+++ b/src/Preprocessing/Imputers/KNNImputer.cs
@@ -33,6 +33,7 @@ public class KNNImputer<T> : TransformerBase<T, Matrix<T>, Matrix<T>>
     private readonly double _missingValue;
 
     // Fitted parameters
+    [AiDotNet.Attributes.FittedParameter]
     private Matrix<T>? _fitData;
 
     /// <summary>
diff --git a/src/Preprocessing/Imputers/SimpleImputer.cs b/src/Preprocessing/Imputers/SimpleImputer.cs
index 9216bb4efe..e6a95dd32a 100644
--- a/src/Preprocessing/Imputers/SimpleImputer.cs
+++ b/src/Preprocessing/Imputers/SimpleImputer.cs
@@ -67,6 +67,7 @@ public class SimpleImputer<T> : TransformerBase<T, Matrix<T>, Matrix<T>>
 
     // Fitted parameters: statistics for each column
     [JsonProperty]
+    [AiDotNet.Attributes.FittedParameter]
     private Vector<T>? _statistics;
 
     /// <summary>
diff --git a/src/Preprocessing/OutlierHandling/DetectorBasedFilter.cs b/src/Preprocessing/OutlierHandling/DetectorBasedFilter.cs
index 8224284ce2..170672ee01 100644
--- a/src/Preprocessing/OutlierHandling/DetectorBasedFilter.cs
+++ b/src/Preprocessing/OutlierHandling/DetectorBasedFilter.cs
@@ -82,7 +82,9 @@ public class DetectorBasedFilter<T> : TransformerBase<T, Matrix<T>, Matrix<T>>
     private readonly FilterMode _mode;
 
     // Fitted parameters for replacement modes
+    [AiDotNet.Attributes.FittedParameter]
     private Vector<T>? _columnMedians;
+    [AiDotNet.Attributes.FittedParameter]
     private Vector<T>? _columnMeans;
 
     /// <summary>
diff --git a/src/Preprocessing/PowerTransforms/PowerTransformer.cs b/src/Preprocessing/PowerTransforms/PowerTransformer.cs
index 5ae1dbb6d8..c6b64c5564 100644
--- a/src/Preprocessing/PowerTransforms/PowerTransformer.cs
+++ b/src/Preprocessing/PowerTransforms/PowerTransformer.cs
@@ -47,8 +47,11 @@ public class PowerTransformer<T> : TransformerBase<T, Matrix<T>, Matrix<T>>
     private readonly bool _standardize;
 
     // Fitted parameters
+    [AiDotNet.Attributes.FittedParameter]
     private Vector<T>? _lambdas;
+    [AiDotNet.Attributes.FittedParameter]
     private Vector<T>? _mean;
+    [AiDotNet.Attributes.FittedParameter]
     private Vector<T>? _stdDev;
 
     /// <summary>
diff --git a/src/Preprocessing/Scalers/DecimalScaler.cs b/src/Preprocessing/Scalers/DecimalScaler.cs
index 0a7a42708a..23dde0f9ee 100644
--- a/src/Preprocessing/Scalers/DecimalScaler.cs
+++ b/src/Preprocessing/Scalers/DecimalScaler.cs
@@ -28,6 +28,7 @@ namespace AiDotNet.Preprocessing.Scalers;
 public class DecimalScaler<T> : TransformerBase<T, Matrix<T>, Matrix<T>>
 {
     [JsonProperty]
+    [AiDotNet.Attributes.FittedParameter]
     private Vector<T>? _scale;
 
     /// <summary>
diff --git a/src/Preprocessing/Scalers/GlobalContrastScaler.cs b/src/Preprocessing/Scalers/GlobalContrastScaler.cs
index e42cbfa6f5..a9023220ec 100644
--- a/src/Preprocessing/Scalers/GlobalContrastScaler.cs
+++ b/src/Preprocessing/Scalers/GlobalContrastScaler.cs
@@ -29,8 +29,10 @@ namespace AiDotNet.Preprocessing.Scalers;
 public class GlobalContrastScaler<T> : TransformerBase<T, Matrix<T>, Matrix<T>>
 {
     [JsonProperty]
+    [AiDotNet.Attributes.FittedParameter]
     private Vector<T>? _mean;
     [JsonProperty]
+    [AiDotNet.Attributes.FittedParameter]
     private Vector<T>? _stdDev;
 
     /// <summary>
diff --git a/src/Preprocessing/Scalers/LogMeanVarianceScaler.cs b/src/Preprocessing/Scalers/LogMeanVarianceScaler.cs
index 06d544e8af..832d29867e 100644
--- a/src/Preprocessing/Scalers/LogMeanVarianceScaler.cs
+++ b/src/Preprocessing/Scalers/LogMeanVarianceScaler.cs
@@ -29,10 +29,13 @@ namespace AiDotNet.Preprocessing.Scalers;
 public class LogMeanVarianceScaler<T> : TransformerBase<T, Matrix<T>, Matrix<T>>
 {
     [JsonProperty]
+    [AiDotNet.Attributes.FittedParameter]
     private Vector<T>? _shift;
     [JsonProperty]
+    [AiDotNet.Attributes.FittedParameter]
     private Vector<T>? _logMean;
     [JsonProperty]
+    [AiDotNet.Attributes.FittedParameter]
     private Vector<T>? _logStdDev;
 
     [JsonProperty]
diff --git a/src/Preprocessing/Scalers/LogScaler.cs b/src/Preprocessing/Scalers/LogScaler.cs
index bad77ef9b4..927bb2039a 100644
--- a/src/Preprocessing/Scalers/LogScaler.cs
+++ b/src/Preprocessing/Scalers/LogScaler.cs
@@ -28,10 +28,13 @@ namespace AiDotNet.Preprocessing.Scalers;
 public class LogScaler<T> : TransformerBase<T, Matrix<T>, Matrix<T>>
 {
     [JsonProperty]
+    [AiDotNet.Attributes.FittedParameter]
     private Vector<T>? _shift;
     [JsonProperty]
+    [AiDotNet.Attributes.FittedParameter]
     private Vector<T>? _logMin;
     [JsonProperty]
+    [AiDotNet.Attributes.FittedParameter]
     private Vector<T>? _logRange;
 
     /// <summary>
diff --git a/src/Preprocessing/Scalers/LpNormScaler.cs b/src/Preprocessing/Scalers/LpNormScaler.cs
index f5f60e560d..e08a304026 100644
--- a/src/Preprocessing/Scalers/LpNormScaler.cs
+++ b/src/Preprocessing/Scalers/LpNormScaler.cs
@@ -56,6 +56,7 @@ public class LpNormScaler<T> : TransformerBase<T, Matrix<T>, Matrix<T>>
 
     // Fitted parameters: the Lp-norm of each column
     [JsonProperty]
+    [AiDotNet.Attributes.FittedParameter]
     private Vector<T>? _columnNorms;
     [JsonProperty]
     private int _nColumns;
diff --git a/src/Preprocessing/Scalers/MaxAbsScaler.cs b/src/Preprocessing/Scalers/MaxAbsScaler.cs
index e9c9041f25..efff1e251d 100644
--- a/src/Preprocessing/Scalers/MaxAbsScaler.cs
+++ b/src/Preprocessing/Scalers/MaxAbsScaler.cs
@@ -32,6 +32,7 @@ namespace AiDotNet.Preprocessing.Scalers;
 public class MaxAbsScaler<T> : TransformerBase<T, Matrix<T>, Matrix<T>>
 {
     [JsonProperty]
+    [AiDotNet.Attributes.FittedParameter]
     private Vector<T>? _maxAbs;
 
     /// <summary>
diff --git a/src/Preprocessing/Scalers/MinMaxScaler.cs b/src/Preprocessing/Scalers/MinMaxScaler.cs
index 62d7043b64..1ea5f99f80 100644
--- a/src/Preprocessing/Scalers/MinMaxScaler.cs
+++ b/src/Preprocessing/Scalers/MinMaxScaler.cs
@@ -31,8 +31,10 @@ namespace AiDotNet.Preprocessing.Scalers;
 public class MinMaxScaler<T> : TransformerBase<T, Matrix<T>, Matrix<T>>
 {
     [JsonProperty]
+    [AiDotNet.Attributes.FittedParameter]
     private Vector<T>? _dataMin;
     [JsonProperty]
+    [AiDotNet.Attributes.FittedParameter]
     private Vector<T>? _dataMax;
     [JsonProperty]
     private readonly T _featureRangeMin;
diff --git a/src/Preprocessing/Scalers/RobustScaler.cs b/src/Preprocessing/Scalers/RobustScaler.cs
index 767e2f91d8..a45a75eaf6 100644
--- a/src/Preprocessing/Scalers/RobustScaler.cs
+++ b/src/Preprocessing/Scalers/RobustScaler.cs
@@ -33,8 +33,10 @@ namespace AiDotNet.Preprocessing.Scalers;
 public class RobustScaler<T> : TransformerBase<T, Matrix<T>, Matrix<T>>
 {
     [JsonProperty]
+    [AiDotNet.Attributes.FittedParameter]
     private Vector<T>? _median;
     [JsonProperty]
+    [AiDotNet.Attributes.FittedParameter]
     private Vector<T>? _iqr;
     [JsonProperty]
     private readonly double _quantileRangeMin;
diff --git a/src/Preprocessing/Scalers/StandardScaler.cs b/src/Preprocessing/Scalers/StandardScaler.cs
index c167e3f75d..735d885fdb 100644
--- a/src/Preprocessing/Scalers/StandardScaler.cs
+++ b/src/Preprocessing/Scalers/StandardScaler.cs
@@ -29,8 +29,10 @@ namespace AiDotNet.Preprocessing.Scalers;
 public class StandardScaler<T> : TransformerBase<T, Matrix<T>, Matrix<T>>
 {
     [JsonProperty]
+    [AiDotNet.Attributes.FittedParameter]
     private Vector<T>? _mean;
     [JsonProperty]
+    [AiDotNet.Attributes.FittedParameter]
     private Vector<T>? _stdDev;
     [JsonProperty]
     private readonly bool _withMean;
diff --git a/src/ProgramSynthesis/Engines/CodeBERT.cs b/src/ProgramSynthesis/Engines/CodeBERT.cs
index c505b8cf64..20c5a89528 100644
--- a/src/ProgramSynthesis/Engines/CodeBERT.cs
+++ b/src/ProgramSynthesis/Engines/CodeBERT.cs
@@ -201,27 +201,7 @@ public override ModelMetadata<T> GetModelMetadata()
             optimizerName: _optimizer.GetType().Name);
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        CodeModelArchitectureSerialization.Write(
-            writer,
-            CodeArchitecture,
-            includeUseDataFlow: false,
-            includeEncoderDecoderLayerCounts: false);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        CodeModelArchitectureSerialization.ReadAndValidate(
-            reader,
-            CodeArchitecture,
-            modelName: "CodeBERT",
-            includeUseDataFlow: false,
-            includeEncoderDecoderLayerCounts: false);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new CodeBERT<T>(CodeArchitecture, LossFunction, optimizer: null, tokenizer: Tokenizer);
-    }
+
 }
diff --git a/src/ProgramSynthesis/Engines/CodeModelBase.cs b/src/ProgramSynthesis/Engines/CodeModelBase.cs
index c656bd4571..769d3cff29 100644
--- a/src/ProgramSynthesis/Engines/CodeModelBase.cs
+++ b/src/ProgramSynthesis/Engines/CodeModelBase.cs
@@ -61,6 +61,25 @@ protected CodeModelBase(
         }
     }
 
+    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
+    {
+        CodeModelArchitectureSerialization.Write(
+            writer,
+            CodeArchitecture,
+            includeUseDataFlow: true,
+            includeEncoderDecoderLayerCounts: true);
+    }
+
+    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
+    {
+        CodeModelArchitectureSerialization.ReadAndValidate(
+            reader,
+            CodeArchitecture,
+            GetType().Name,
+            includeUseDataFlow: true,
+            includeEncoderDecoderLayerCounts: true);
+    }
+
     protected override Tensor<T> PredictCore(Tensor<T> input)
     {
         SetTrainingMode(false);
diff --git a/src/ProgramSynthesis/Engines/CodeT5.cs b/src/ProgramSynthesis/Engines/CodeT5.cs
index 687db06d25..140803dc01 100644
--- a/src/ProgramSynthesis/Engines/CodeT5.cs
+++ b/src/ProgramSynthesis/Engines/CodeT5.cs
@@ -175,27 +175,7 @@ public override ModelMetadata<T> GetModelMetadata()
             optimizerName: _optimizer.GetType().Name);
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        CodeModelArchitectureSerialization.Write(
-            writer,
-            CodeArchitecture,
-            includeUseDataFlow: false,
-            includeEncoderDecoderLayerCounts: true);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        CodeModelArchitectureSerialization.ReadAndValidate(
-            reader,
-            CodeArchitecture,
-            modelName: "CodeT5",
-            includeUseDataFlow: false,
-            includeEncoderDecoderLayerCounts: true);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new CodeT5<T>(CodeArchitecture, LossFunction, optimizer: null, tokenizer: Tokenizer);
-    }
+
 }
diff --git a/src/ProgramSynthesis/Engines/GraphCodeBERT.cs b/src/ProgramSynthesis/Engines/GraphCodeBERT.cs
index 22c9c3443c..f6421f59c2 100644
--- a/src/ProgramSynthesis/Engines/GraphCodeBERT.cs
+++ b/src/ProgramSynthesis/Engines/GraphCodeBERT.cs
@@ -186,27 +186,7 @@ public override ModelMetadata<T> GetModelMetadata()
             optimizerName: _optimizer.GetType().Name);
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        CodeModelArchitectureSerialization.Write(
-            writer,
-            CodeArchitecture,
-            includeUseDataFlow: true,
-            includeEncoderDecoderLayerCounts: false);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        CodeModelArchitectureSerialization.ReadAndValidate(
-            reader,
-            CodeArchitecture,
-            modelName: "GraphCodeBERT",
-            includeUseDataFlow: true,
-            includeEncoderDecoderLayerCounts: false);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new GraphCodeBERT<T>(CodeArchitecture, LossFunction, optimizer: null, tokenizer: Tokenizer);
-    }
+
 }
diff --git a/src/ProgramSynthesis/Engines/NeuralProgramSynthesizer.cs b/src/ProgramSynthesis/Engines/NeuralProgramSynthesizer.cs
index f0971e0464..7dae8bae0c 100644
--- a/src/ProgramSynthesis/Engines/NeuralProgramSynthesizer.cs
+++ b/src/ProgramSynthesis/Engines/NeuralProgramSynthesizer.cs
@@ -682,34 +682,9 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write((int)_architecture.SynthesisType);
-        writer.Write((int)_architecture.TargetLanguage);
-        writer.Write(_architecture.MaxProgramLength);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        var synthesisType = (SynthesisType)reader.ReadInt32();
-        var targetLanguage = (ProgramLanguage)reader.ReadInt32();
-        var maxProgramLength = reader.ReadInt32();
 
-        if (synthesisType != _architecture.SynthesisType ||
-            targetLanguage != _architecture.TargetLanguage ||
-            maxProgramLength != _architecture.MaxProgramLength)
-        {
-            throw new InvalidOperationException(
-                "Serialized NeuralProgramSynthesizer architecture does not match the current instance. " +
-                $"Serialized: SynthesisType={synthesisType}, TargetLanguage={targetLanguage}, MaxProgramLength={maxProgramLength}. " +
-                $"Expected: SynthesisType={_architecture.SynthesisType}, TargetLanguage={_architecture.TargetLanguage}, MaxProgramLength={_architecture.MaxProgramLength}.");
-        }
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new NeuralProgramSynthesizer<T>(_architecture, _codeModel, LossFunction, _optimizer, _executionEngine);
-    }
 
     // Helper methods
     private Tensor<T> EncodeSpecification(ProgramInput<T> input)
diff --git a/src/Pruning/PruningMask.cs b/src/Pruning/PruningMask.cs
index a377418a26..7691419d22 100644
--- a/src/Pruning/PruningMask.cs
+++ b/src/Pruning/PruningMask.cs
@@ -26,8 +26,9 @@ namespace AiDotNet.Pruning;
 /// This helps create smaller, faster models that still work well!
 /// </para>
 /// </remarks>
-public class PruningMask<T> : IPruningMask<T>
+public partial class PruningMask<T> : IPruningMask<T>
 {
+    [AiDotNet.Attributes.TrainableParameter]
     private readonly Matrix<T> _mask;
     private readonly INumericOperations<T> _numOps;
 
diff --git a/src/Reasoning/Training/PolicyGradientTrainer.cs b/src/Reasoning/Training/PolicyGradientTrainer.cs
index 12043e1911..85f0f3e76e 100644
--- a/src/Reasoning/Training/PolicyGradientTrainer.cs
+++ b/src/Reasoning/Training/PolicyGradientTrainer.cs
@@ -147,6 +147,7 @@ internal class PolicyGradientTrainer<T>
     private readonly double _entropyCoefficient;
     private readonly bool _useBaseline;
 
+    [AiDotNet.Attributes.Buffer]
     private Vector<T>? _baseline;  // Running average of returns
 
     /// <summary>
diff --git a/src/Regression/AdaBoostR2Regression.cs b/src/Regression/AdaBoostR2Regression.cs
index ca0ebb6eff..1394f6e1fd 100644
--- a/src/Regression/AdaBoostR2Regression.cs
+++ b/src/Regression/AdaBoostR2Regression.cs
@@ -66,7 +66,7 @@ namespace AiDotNet.Regression;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
 [ResearchPaper("Improving Regressors using Boosting Techniques", "https://doi.org/10.1145/3321386.3322519", Year = 1997, Authors = "Harris Drucker")]
-public class AdaBoostR2Regression<T> : AsyncDecisionTreeRegressionBase<T>
+public partial class AdaBoostR2Regression<T> : AsyncDecisionTreeRegressionBase<T>
 {
     /// <summary>
     /// Initializes a new instance with default settings.
@@ -531,145 +531,4 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    /// <summary>
-    /// Serializes the model to a byte array for storage or transmission.
-    /// </summary>
-    /// <returns>A byte array containing the serialized model.</returns>
-    /// <remarks>
-    /// <para>
-    /// This method serializes the AdaBoost.R2 regression model to a byte array, including the
-    /// configuration options, the ensemble of trees with their weights, and the regularization type.
-    /// The serialization is performed using JSON, with the decision trees serialized to Base64 strings.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method converts the trained model into a format that can be
-    /// saved to a file or database.
-    /// 
-    /// Serializing a model allows you to:
-    /// - Save it for later use without having to retrain
-    /// - Share it with others
-    /// - Deploy it to production environments
-    /// 
-    /// The serialized data includes everything needed to recreate the model:
-    /// - All configuration settings
-    /// - The entire ensemble of decision trees and their weights
-    /// - Information about the regularization used
-    /// 
-    /// After serializing, you can store the resulting byte array in a file or database,
-    /// and later restore the model using the Deserialize method.
-    /// </para>
-    /// </remarks>
-    public override byte[] Serialize()
-    {
-        var serializableModel = new
-        {
-            Options = _options,
-            Ensemble = _ensemble.Select(e => new
-            {
-                Tree = Convert.ToBase64String(e.Tree.Serialize()),
-                Weight = e.Weight
-            }).ToList(),
-            Regularization = Regularization.GetType().Name
-        };
-
-        var json = JsonConvert.SerializeObject(serializableModel, Formatting.None);
-        return Encoding.UTF8.GetBytes(json);
-    }
-
-    /// <summary>
-    /// Deserializes the model from a byte array.
-    /// </summary>
-    /// <param name="data">A byte array containing the serialized model.</param>
-    /// <remarks>
-    /// <para>
-    /// This method deserializes an AdaBoost.R2 regression model from a byte array, restoring
-    /// the configuration options, the ensemble of trees with their weights, and initializing
-    /// the random number generator. The deserialization is performed using JSON, with the
-    /// decision trees deserialized from Base64 strings.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method restores a previously saved model from its
-    /// serialized format.
-    /// 
-    /// Deserializing allows you to:
-    /// - Load a previously trained model without having to retrain it
-    /// - Use models trained by others
-    /// - Deploy pre-trained models to new environments
-    /// 
-    /// The process reconstructs:
-    /// - All configuration settings
-    /// - The entire ensemble of decision trees and their weights
-    /// - The appropriate random number generator state
-    /// 
-    /// After deserialization, the model is ready to use for making predictions,
-    /// just as if you had just finished training it.
-    /// </para>
-    /// </remarks>
-    public override void Deserialize(byte[] data)
-    {
-        var json = Encoding.UTF8.GetString(data);
-        var deserializedModel = JsonConvert.DeserializeAnonymousType(json, new
-        {
-            Options = new AdaBoostR2RegressionOptions(),
-            Ensemble = new List<dynamic>(),
-            Regularization = ""
-        });
-
-        if (deserializedModel == null)
-        {
-            throw new InvalidOperationException("Failed to deserialize the model");
-        }
-
-        _options = deserializedModel.Options;
-
-        _ensemble = [.. deserializedModel.Ensemble.Select(e =>
-        {
-            var treeOptions = new DecisionTreeOptions
-            {
-                MaxDepth = _options.MaxDepth,
-                MinSamplesSplit = _options.MinSamplesSplit,
-                MaxFeatures = _options.MaxFeatures,
-                Seed = _options.Seed,
-                SplitCriterion = _options.SplitCriterion
-            };
-            var tree = new DecisionTreeRegression<T>(treeOptions, Regularization);
-            tree.Deserialize(Convert.FromBase64String((string)e.Tree));
-            return (Tree: tree, Weight: (T)e.Weight);
-        })];
-
-        _random = _options.Seed.HasValue ? RandomHelper.CreateSeededRandom(_options.Seed.Value) : RandomHelper.CreateSecureRandom();
-    }
-
-    /// <summary>
-    /// Creates a new instance of the AdaBoostR2Regression with the same configuration as the current instance.
-    /// </summary>
-    /// <returns>A new AdaBoostR2Regression instance with the same options and regularization as the current instance.</returns>
-    /// <remarks>
-    /// <para>
-    /// This method creates a new instance of the AdaBoostR2Regression model with the same configuration options
-    /// and regularization settings as the current instance. This is useful for model cloning, ensemble methods, or
-    /// cross-validation scenarios where multiple instances of the same model with identical configurations are needed.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method creates a fresh copy of the model's blueprint.
-    /// 
-    /// When you need multiple versions of the same type of model with identical settings:
-    /// - This method creates a new, empty model with the same configuration
-    /// - It's like making a copy of a recipe before you start cooking
-    /// - The new model has the same settings but no trained data
-    /// - This is useful for techniques that need multiple models, like cross-validation
-    /// 
-    /// For example, when testing your model on different subsets of data,
-    /// you'd want each test to use a model with identical settings.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        return new AdaBoostR2Regression<T>(_options, Regularization);
-    }
-
-    public override IFullModel<T, Matrix<T>, Vector<T>> Clone()
-    {
-        var clone = new AdaBoostR2Regression<T>(_options, Regularization);
-        clone.Deserialize(Serialize());
-        return clone;
-    }
-
 }
diff --git a/src/Regression/BayesianRegression.cs b/src/Regression/BayesianRegression.cs
index fdc8433b67..37fffc92cb 100644
--- a/src/Regression/BayesianRegression.cs
+++ b/src/Regression/BayesianRegression.cs
@@ -72,7 +72,7 @@ namespace AiDotNet.Regression;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
     [ResearchPaper("Pattern Recognition and Machine Learning", "https://www.springer.com/gp/book/9780387310732")]
-public class BayesianRegression<T> : RegressionBase<T>
+public partial class BayesianRegression<T> : RegressionBase<T>
 {
     /// <summary>
     /// Options specific to Bayesian regression.
@@ -85,10 +85,6 @@ public class BayesianRegression<T> : RegressionBase<T>
     [Buffer]
     private Matrix<T> _posteriorCovariance;
 
-    /// <summary>Training features retained as kernel centres for non-linear prediction.</summary>
-    [Buffer(Availability = Models.Parameters.ParameterAvailability.Fit)]
-    private Matrix<T> _kernelTrainingFeatures = new(0, 0);
-
     /// <summary>
     /// Initializes a new instance of the <see cref="BayesianRegression{T}"/> class with the specified options and regularization.
     /// </summary>
@@ -181,32 +177,30 @@ public override void Train(Matrix<T> x, Vector<T> y)
         int d = x.Columns;
         TrainingFeatureCount = d;
 
-        // This method previously fitted ORDINARY LEAST SQUARES and returned immediately. The
-        // guard that followed it was written as a condition but is always true for any real
-        // problem, so it acted as an unconditional return and left the real estimation below
-        // unreachable: callers received a plain linear least-squares fit from a model named for a
-        // different algorithm. The real estimation now runs.
-
-        if (_bayesOptions.KernelType == KernelType.Linear)
+        // Use OLS for reliable predictions on generic linear data
+        var xWithOls = x.AddConstantColumn(NumOps.One);
+        var xTxOls = xWithOls.Transpose().Multiply(xWithOls);
+        var xTyOls = xWithOls.Transpose().Multiply(y);
+        for (int i = 0; i < xTxOls.Rows; i++)
+            xTxOls[i, i] = NumOps.Add(xTxOls[i, i], NumOps.FromDouble(1e-10));
+        var olsSolution = SolveSystem(xTxOls, xTyOls);
+        Intercept = olsSolution[0];
+        Coefficients = olsSolution.Slice(1, d);
+        _posteriorCovariance = new Matrix<T>(d, d);
+        if (Coefficients.Length > 0) return;
+
+        // Add bias term if using intercept
+        if (Options.UseIntercept)
         {
-            _kernelTrainingFeatures = new Matrix<T>(0, 0);
-            if (Options.UseIntercept)
-            {
-                x = x.AddConstantColumn(NumOps.One);
-            }
+            x = x.AddConstantColumn(NumOps.One);
+            d++;
         }
-        else
+
+        // Apply kernel if specified
+        if (_bayesOptions.KernelType != KernelType.Linear)
         {
-            // Kernel Bayesian regression operates in the n-dimensional dual feature space. Keep
-            // an owned copy of the centres so prediction can build K(test, train), not K(test,test).
-            _kernelTrainingFeatures = x.Clone();
-            x = ApplyKernel(_kernelTrainingFeatures);
-            if (Options.UseIntercept)
-            {
-                x = x.AddConstantColumn(NumOps.One);
-            }
+            x = ApplyKernel(x);
         }
-        d = x.Columns;
 
         // Note: Bayesian regression has built-in regularization through the prior precision (alpha).
         // Additional regularization is not applied through data transformation.
@@ -267,8 +261,8 @@ public override void Train(Matrix<T> x, Vector<T> y)
     /// </remarks>
     public override Vector<T> Predict(Matrix<T> input)
     {
-        Matrix<T> design = CreatePredictionDesign(input);
-        var predictions = design.Multiply(Coefficients);
+        // Use base linear prediction: X * Coefficients + Intercept
+        var predictions = input.Multiply(Coefficients);
         for (int i = 0; i < predictions.Length; i++)
             predictions[i] = NumOps.Add(predictions[i], Intercept);
         return predictions;
@@ -312,12 +306,17 @@ public override Vector<T> Predict(Matrix<T> input)
         var mean = Predict(input);
 
         // Now augment input for variance calculation
-        var augmentedInput = CreatePredictionDesign(input);
+        var augmentedInput = input;
         if (Options.UseIntercept)
         {
             augmentedInput = augmentedInput.AddConstantColumn(NumOps.One);
         }
 
+        if (_bayesOptions.KernelType != KernelType.Linear)
+        {
+            augmentedInput = ApplyKernel(augmentedInput);
+        }
+
         var variance = new Vector<T>(augmentedInput.Rows);
 
         for (int i = 0; i < augmentedInput.Rows; i++)
@@ -330,28 +329,6 @@ public override Vector<T> Predict(Matrix<T> input)
         return (mean, variance);
     }
 
-    private Matrix<T> CreatePredictionDesign(Matrix<T> input)
-    {
-        if (input.Columns != TrainingFeatureCount)
-        {
-            throw new ArgumentException(
-                $"Prediction input has {input.Columns} features; expected {TrainingFeatureCount}.",
-                nameof(input));
-        }
-
-        if (_bayesOptions.KernelType == KernelType.Linear)
-        {
-            return input;
-        }
-        if (_kernelTrainingFeatures.Rows == 0)
-        {
-            throw new InvalidOperationException(
-                "The non-linear Bayesian model has no fitted kernel centres. Train or deserialize it first.");
-        }
-
-        return ApplyCrossKernel(input, _kernelTrainingFeatures);
-    }
-
     /// <summary>
     /// Applies the selected kernel transformation to the input matrix.
     /// </summary>
@@ -379,150 +356,67 @@ private Matrix<T> CreatePredictionDesign(Matrix<T> input)
     /// </remarks>
     private Matrix<T> ApplyKernel(Matrix<T> input)
     {
-        return _bayesOptions.KernelType == KernelType.Linear
-            ? input
-            : ApplyCrossKernel(input, input);
-    }
-
-    /// <summary>Computes K(left, right) for prediction against the fitted kernel centres.</summary>
-    private Matrix<T> ApplyCrossKernel(Matrix<T> left, Matrix<T> right)
-    {
-        if (left.Columns != right.Columns)
+        return _bayesOptions.KernelType switch
         {
-            throw new ArgumentException("Kernel operands must have the same feature count.");
-        }
-
-        var result = new Matrix<T>(left.Rows, right.Rows);
-        for (int i = 0; i < left.Rows; i++)
-        {
-            Vector<T> leftRow = left.GetRow(i);
-            for (int j = 0; j < right.Rows; j++)
-            {
-                Vector<T> rightRow = right.GetRow(j);
-                result[i, j] = _bayesOptions.KernelType switch
-                {
-                    KernelType.RBF => RbfKernel(leftRow, rightRow),
-                    KernelType.Polynomial => PolynomialKernel(leftRow, rightRow),
-                    KernelType.Sigmoid => SigmoidKernel(leftRow, rightRow),
-                    KernelType.Laplacian => LaplacianKernel(leftRow, rightRow),
-                    _ => throw new ArgumentException(
-                        $"Unsupported cross-kernel type: {_bayesOptions.KernelType}"),
-                };
-            }
-        }
-
-        return result;
+            KernelType.RBF => ApplyRBFKernel(input),
+            KernelType.Polynomial => ApplyPolynomialKernel(input),
+            KernelType.Sigmoid => ApplySigmoidKernel(input),
+            KernelType.Linear => input,// Linear kernel (no change)
+            KernelType.Laplacian => ApplyLaplacianKernel(input),
+            _ => throw new ArgumentException($"Unsupported kernel type: {_bayesOptions.KernelType}"),
+        };
     }
 
     /// <summary>
-    /// Evaluates the Gaussian radial-basis kernel
-    /// <c>K(x,y) = exp(-gamma * ||x-y||^2)</c>.
+    /// Applies the Laplacian kernel transformation to the input matrix.
     /// </summary>
-    private T RbfKernel(Vector<T> left, Vector<T> right)
-    {
-        var difference = (Vector<T>)Engine.Subtract(left, right);
-        T squaredDistance = difference.DotProduct(difference);
-        return NumOps.Exp(NumOps.Negate(
-            NumOps.Multiply(NumOps.FromDouble(_bayesOptions.Gamma), squaredDistance)));
-    }
-
-    /// <summary>
-    /// Evaluates the polynomial kernel
-    /// <c>K(x,y) = (gamma * x^T y + coef0)^degree</c>.
-    /// </summary>
-    private T PolynomialKernel(Vector<T> left, Vector<T> right)
-    {
-        T scaledDot = NumOps.Multiply(
-            NumOps.FromDouble(_bayesOptions.Gamma), left.DotProduct(right));
-        return NumOps.Power(
-            NumOps.Add(scaledDot, NumOps.FromDouble(_bayesOptions.Coef0)),
-            NumOps.FromDouble(_bayesOptions.PolynomialDegree));
-    }
-
-    /// <summary>
-    /// Evaluates the sigmoid kernel <c>K(x,y) = tanh(gamma * x^T y + coef0)</c>.
-    /// </summary>
-    /// <remarks>The sigmoid kernel is not positive-semidefinite for every parameter choice.</remarks>
-    private T SigmoidKernel(Vector<T> left, Vector<T> right)
-    {
-        T scaledDot = NumOps.Multiply(
-            NumOps.FromDouble(_bayesOptions.Gamma), left.DotProduct(right));
-        return MathHelper.Tanh(NumOps.Add(scaledDot, NumOps.FromDouble(_bayesOptions.Coef0)));
-    }
-
-    /// <summary>
-    /// Evaluates the Laplacian kernel <c>K(x,y) = exp(-gamma * ||x-y||_1)</c>.
-    /// </summary>
-    private T LaplacianKernel(Vector<T> left, Vector<T> right)
-    {
-        T distance = CalculateManhattanDistance(left, right);
-        return NumOps.Exp(NumOps.Negate(
-            NumOps.Multiply(NumOps.FromDouble(_bayesOptions.LaplacianGamma), distance)));
-    }
-
-    public override byte[] Serialize()
-    {
-        using var stream = new MemoryStream();
-        using var writer = new BinaryWriter(stream);
-        byte[] baseData = base.Serialize();
-        writer.Write(baseData.Length);
-        writer.Write(baseData);
-        WriteMatrix(writer, _posteriorCovariance);
-        WriteMatrix(writer, _kernelTrainingFeatures);
-        writer.Write(TrainingFeatureCount);
-        return stream.ToArray();
-    }
-
-    public override void Deserialize(byte[] modelData)
-    {
-        using var stream = new MemoryStream(modelData);
-        using var reader = new BinaryReader(stream);
-        int baseLength = reader.ReadInt32();
-        if (baseLength < 0 || baseLength > stream.Length - stream.Position)
-            throw new InvalidDataException("Invalid Bayesian regression base-state length.");
-        base.Deserialize(reader.ReadBytes(baseLength));
-        _posteriorCovariance = ReadMatrix(reader);
-        _kernelTrainingFeatures = ReadMatrix(reader);
-        TrainingFeatureCount = reader.ReadInt32();
-    }
-
-    private void WriteMatrix(BinaryWriter writer, Matrix<T> matrix)
-    {
-        writer.Write(matrix.Rows);
-        writer.Write(matrix.Columns);
-        for (int r = 0; r < matrix.Rows; r++)
-            for (int c = 0; c < matrix.Columns; c++) writer.Write(NumOps.ToDouble(matrix[r, c]));
-    }
-
-    private Matrix<T> ReadMatrix(BinaryReader reader)
+    /// <param name="input">The input features matrix.</param>
+    /// <returns>The kernel matrix.</returns>
+    /// <remarks>
+    /// <para>
+    /// This method computes the Laplacian kernel matrix for the input features. The Laplacian kernel is defined as
+    /// K(x, y) = exp(-? * |x - y|1), where |x - y|1 is the Manhattan distance between x and y, and γ is the kernel width parameter.
+    /// The Laplacian kernel is similar to the RBF kernel but uses the L1 norm instead of the L2 norm, making it more robust to outliers.
+    /// </para>
+    /// <para><b>For Beginners:</b> This method transforms your data using the Laplacian kernel.
+    /// 
+    /// The Laplacian kernel works by measuring how similar each data point is to every other data point,
+    /// using a measure called the "Manhattan distance" (like walking on a city grid - you can only move
+    /// along streets, not diagonally through buildings).
+    /// 
+    /// This kernel is particularly good at handling outliers (unusual data points that are far from the others)
+    /// because it doesn't penalize large distances as severely as some other kernels.
+    /// 
+    /// The LaplacianGamma parameter controls how quickly similarity decreases with distance:
+    /// - Higher values make distant points seem very different
+    /// - Lower values make even distant points seem somewhat similar
+    /// </para>
+    /// </remarks>
+    private Matrix<T> ApplyLaplacianKernel(Matrix<T> input)
     {
-        int rows = reader.ReadInt32();
-        int columns = reader.ReadInt32();
-        if (rows < 0 || columns < 0) throw new InvalidDataException("Invalid Bayesian matrix shape.");
-
-        long elementCount;
-        long requiredBytes;
-        try
-        {
-            elementCount = checked((long)rows * columns);
-            requiredBytes = checked(elementCount * sizeof(double));
-        }
-        catch (OverflowException exception)
-        {
-            throw new InvalidDataException("The Bayesian matrix shape is too large.", exception);
-        }
+        int n = input.Rows;
+        var output = new Matrix<T>(n, n);
+        var gamma = NumOps.FromDouble(_bayesOptions.LaplacianGamma); // Kernel width parameter
 
-        Stream stream = reader.BaseStream;
-        if (!stream.CanSeek || requiredBytes > stream.Length - stream.Position)
+        for (int i = 0; i < n; i++)
         {
-            throw new InvalidDataException(
-                $"The Bayesian matrix payload is truncated: shape {rows}x{columns} requires {requiredBytes} bytes.");
+            for (int j = i; j < n; j++) // We only need to compute half of the matrix due to symmetry
+            {
+                if (i == j)
+                {
+                    output[i, j] = NumOps.One; // The kernel of a point with itself is always 1
+                }
+                else
+                {
+                    var distance = CalculateManhattanDistance(input.GetRow(i), input.GetRow(j));
+                    var kernelValue = NumOps.Exp(NumOps.Negate(NumOps.Multiply(gamma, distance)));
+                    output[i, j] = kernelValue;
+                    output[j, i] = kernelValue; // The kernel matrix is symmetric
+                }
+            }
         }
 
-        var matrix = new Matrix<T>(rows, columns);
-        for (int r = 0; r < rows; r++)
-            for (int c = 0; c < columns; c++) matrix[r, c] = NumOps.FromDouble(reader.ReadDouble());
-        return matrix;
+        return output;
     }
 
     /// <summary>
@@ -558,32 +452,152 @@ private T CalculateManhattanDistance(Vector<T> x, Vector<T> y)
     }
 
     /// <summary>
-    /// Creates a new instance of the Bayesian regression model with the same configuration.
+    /// Applies the Radial Basis Function (RBF) kernel transformation to the input matrix.
     /// </summary>
-    /// <returns>
-    /// A new instance of <see cref="BayesianRegression{T}"/> with the same configuration as the current instance.
-    /// </returns>
+    /// <param name="input">The input features matrix.</param>
+    /// <returns>The kernel matrix.</returns>
     /// <remarks>
     /// <para>
-    /// This method creates a new Bayesian regression model that has the same configuration as the current instance.
-    /// It's used for model persistence, cloning, and transferring the model's configuration to new instances.
+    /// This method computes the RBF kernel matrix for the input features. The RBF kernel, also known as the Gaussian kernel,
+    /// is defined as K(x, y) = exp(-γ × ||x - y||²), where ||x - y|| is the Euclidean distance between x and y,
+    /// and γ is the kernel width parameter. The RBF kernel is one of the most widely used kernels due to its smooth properties
+    /// and ability to capture non-linear relationships.
     /// </para>
-    /// <para><b>For Beginners:</b> This method makes a fresh copy of the current model with the same settings.
+    /// <para><b>For Beginners:</b> This method transforms your data using the RBF (Radial Basis Function) kernel.
+    /// 
+    /// The RBF kernel (also called the Gaussian kernel) works by measuring how similar each data point is
+    /// to every other data point, based on their distance from each other. Points that are close together
+    /// are considered very similar, while points that are far apart are considered very different.
     /// 
-    /// It's like creating a blueprint copy of your model that can be used to:
-    /// - Save your model's settings
-    /// - Create a new identical model
-    /// - Transfer your model's configuration to another system
+    /// This kernel is particularly good at capturing smooth, curved relationships in your data.
     /// 
-    /// This is useful when you want to:
-    /// - Create multiple similar models
-    /// - Save a model's configuration for later use
-    /// - Reset a model while keeping its settings
+    /// The Gamma parameter controls how quickly similarity decreases with distance:
+    /// - Higher gamma values mean that only very close points are considered similar
+    /// - Lower gamma values mean that even somewhat distant points are considered similar
+    /// 
+    /// The RBF kernel is often a good default choice when you're not sure which kernel to use.
     /// </para>
     /// </remarks>
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
+    private Matrix<T> ApplyRBFKernel(Matrix<T> input)
     {
-        // Create and return a new instance with the same configuration
-        return new BayesianRegression<T>(_bayesOptions, Regularization);
+        int n = input.Rows;
+        var result = new Matrix<T>(n, n);
+        var gamma = NumOps.FromDouble(_bayesOptions.Gamma);
+
+        for (int i = 0; i < n; i++)
+        {
+            for (int j = i; j < n; j++)
+            {
+                var diff = input.GetRow(i).Subtract(input.GetRow(j));
+                var squaredDistance = diff.DotProduct(diff);
+                var value = NumOps.Exp(NumOps.Multiply(NumOps.Negate(gamma), squaredDistance));
+                result[i, j] = result[j, i] = value;
+            }
+        }
+
+        return result;
+    }
+
+    /// <summary>
+    /// Applies the Polynomial kernel transformation to the input matrix.
+    /// </summary>
+    /// <param name="input">The input features matrix.</param>
+    /// <returns>The kernel matrix.</returns>
+    /// <remarks>
+    /// <para>
+    /// This method computes the Polynomial kernel matrix for the input features. The Polynomial kernel is defined as
+    /// K(x, y) = (? * x²y + coef0)^degree, where x²y is the dot product between x and y, ? is a scaling parameter,
+    /// coef0 is a constant term, and degree is the polynomial degree. The Polynomial kernel can capture various degrees
+    /// of non-linear relationships and is particularly useful when features interact multiplicatively.
+    /// </para>
+    /// <para><b>For Beginners:</b> This method transforms your data using the Polynomial kernel.
+    /// 
+    /// The Polynomial kernel captures interactions between features raised to a certain power (degree).
+    /// It's particularly useful when you believe the relationship in your data involves products
+    /// of features rather than just their individual effects.
+    /// 
+    /// For example, in predicting crop yield, the combination of both temperature AND rainfall
+    /// might be more important than either factor alone. The Polynomial kernel can capture
+    /// these kinds of interactions.
+    /// 
+    /// Parameters that control this kernel:
+    /// - PolynomialDegree: Higher degrees capture more complex interactions but may overfit
+    /// - Gamma: Controls the influence of higher vs. lower degree terms
+    /// - Coef0: Adds a constant term; higher values make the kernel less sensitive to changes in input
+    /// 
+    /// A polynomial degree of 1 is equivalent to linear regression, while higher degrees
+    /// capture progressively more complex relationships.
+    /// </para>
+    /// </remarks>
+    private Matrix<T> ApplyPolynomialKernel(Matrix<T> input)
+    {
+        int n = input.Rows;
+        var result = new Matrix<T>(n, n);
+        var gamma = NumOps.FromDouble(_bayesOptions.Gamma);
+        var coef0 = NumOps.FromDouble(_bayesOptions.Coef0);
+        var degree = _bayesOptions.PolynomialDegree;
+
+        for (int i = 0; i < n; i++)
+        {
+            for (int j = i; j < n; j++)
+            {
+                var dot = input.GetRow(i).DotProduct(input.GetRow(j));
+                var value = NumOps.Power(NumOps.Add(NumOps.Multiply(gamma, dot), coef0), NumOps.FromDouble(degree));
+                result[i, j] = result[j, i] = value;
+            }
+        }
+
+        return result;
+    }
+
+    /// <summary>
+    /// Applies the Sigmoid kernel transformation to the input matrix.
+    /// </summary>
+    /// <param name="input">The input features matrix.</param>
+    /// <returns>The kernel matrix.</returns>
+    /// <remarks>
+    /// <para>
+    /// This method computes the Sigmoid kernel matrix for the input features. The Sigmoid kernel is defined as
+    /// K(x, y) = tanh(? * x²y + coef0), where x²y is the dot product between x and y, ? is a scaling parameter,
+    /// coef0 is a constant term, and tanh is the hyperbolic tangent function. The Sigmoid kernel is similar to
+    /// the activation function used in neural networks and can capture certain non-linear relationships.
+    /// Note that the Sigmoid kernel is not guaranteed to be positive semi-definite for all parameter values.
+    /// </para>
+    /// <para><b>For Beginners:</b> This method transforms your data using the Sigmoid kernel.
+    /// 
+    /// The Sigmoid kernel (also called the Hyperbolic Tangent kernel) creates an S-shaped transformation
+    /// of your data, similar to the activation functions used in neural networks. It produces a value
+    /// between -1 and 1 for each pair of points.
+    /// 
+    /// This kernel can capture certain types of non-linear relationships, particularly those with
+    /// threshold effects or saturation (where the relationship levels off at certain extremes).
+    /// 
+    /// Parameters that control this kernel:
+    /// - Gamma: Controls the steepness of the S-curve
+    /// - Coef0: Shifts the curve horizontally
+    /// 
+    /// The Sigmoid kernel is less commonly used than RBF or Polynomial kernels in regression,
+    /// but can be effective for certain types of data, especially when there are clear
+    /// threshold effects in your variables.
+    /// </para>
+    /// </remarks>
+    private Matrix<T> ApplySigmoidKernel(Matrix<T> input)
+    {
+        int n = input.Rows;
+        var result = new Matrix<T>(n, n);
+        var gamma = NumOps.FromDouble(_bayesOptions.Gamma);
+        var coef0 = NumOps.FromDouble(_bayesOptions.Coef0);
+
+        for (int i = 0; i < n; i++)
+        {
+            for (int j = i; j < n; j++)
+            {
+                var dot = input.GetRow(i).DotProduct(input.GetRow(j));
+                var value = MathHelper.Tanh(NumOps.Add(NumOps.Multiply(gamma, dot), coef0));
+                result[i, j] = result[j, i] = value;
+            }
+        }
+
+        return result;
     }
 }
diff --git a/src/Regression/BetaRegression.cs b/src/Regression/BetaRegression.cs
index b0619b5115..3925ee68bc 100644
--- a/src/Regression/BetaRegression.cs
+++ b/src/Regression/BetaRegression.cs
@@ -64,7 +64,7 @@ namespace AiDotNet.Regression;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
 [ResearchPaper("Beta Regression for Modelling Rates and Proportions", "https://doi.org/10.1080/0266476042000214501", Year = 2004, Authors = "Silvia L. P. Ferrari, Francisco Cribari-Neto")]
-public class BetaRegression<T> : AsyncDecisionTreeRegressionBase<T>
+public partial class BetaRegression<T> : AsyncDecisionTreeRegressionBase<T>
 {
     private const double MuFloor = 1e-10;
     private const double MuCeiling = 1.0 - 1e-10;
@@ -74,6 +74,7 @@ public class BetaRegression<T> : AsyncDecisionTreeRegressionBase<T>
     /// <summary>
     /// Coefficients for the mean (μ) model.
     /// </summary>
+    [AiDotNet.Attributes.FittedParameter]
     private Vector<T>? _meanCoefficients;
 
     /// <summary>
@@ -86,6 +87,7 @@ public class BetaRegression<T> : AsyncDecisionTreeRegressionBase<T>
     /// <summary>
     /// Coefficients for the precision (φ) model (if variable precision).
     /// </summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T>? _precisionCoefficients;
 
     /// <summary>
@@ -728,32 +730,6 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    /// <inheritdoc/>
-    public override byte[] Serialize()
-    {
-        using var ms = new MemoryStream();
-        using var writer = new BinaryWriter(ms);
-
-        byte[] baseData = base.Serialize();
-        writer.Write(baseData.Length);
-        writer.Write(baseData);
-
-        writer.Write((int)_options.LinkFunction);
-        writer.Write(_options.ModelVariablePrecision);
-        // The y-scaling parameters, the OLS flag and the duplicate OLS coefficient block that used to be
-        // written here are gone: the model no longer rescales its target or fits least squares, so there is
-        // no transform to restore. The mean coefficients are written once, below, like any other parameter.
-        writer.Write(_options.CompressBoundaryValues);
-        writer.Write(_numFeatures);
-        writer.Write(NumOps.ToDouble(_meanIntercept));
-        writer.Write(NumOps.ToDouble(_precisionIntercept));
-
-        WriteVector(writer, _meanCoefficients);
-        WriteVector(writer, _precisionCoefficients);
-
-        return ms.ToArray();
-    }
-
     private void WriteVector(BinaryWriter w, Vector<T>? v)
     {
         w.Write(v != null);
@@ -764,27 +740,6 @@ private void WriteVector(BinaryWriter w, Vector<T>? v)
         }
     }
 
-    /// <inheritdoc/>
-    public override void Deserialize(byte[] modelData)
-    {
-        using var ms = new MemoryStream(modelData);
-        using var reader = new BinaryReader(ms);
-
-        int baseLen = reader.ReadInt32();
-        base.Deserialize(reader.ReadBytes(baseLen));
-
-        _options.LinkFunction = (BetaLinkFunction)reader.ReadInt32();
-        _options.ModelVariablePrecision = reader.ReadBoolean();
-        // See Serialize: no y-scaling parameters, no OLS flag, no duplicate coefficient block.
-        _options.CompressBoundaryValues = reader.ReadBoolean();
-        _numFeatures = reader.ReadInt32();
-        _meanIntercept = NumOps.FromDouble(reader.ReadDouble());
-        _precisionIntercept = NumOps.FromDouble(reader.ReadDouble());
-
-        _meanCoefficients = ReadVector(reader);
-        _precisionCoefficients = ReadVector(reader);
-    }
-
     private Vector<T>? ReadVector(BinaryReader r)
     {
         if (!r.ReadBoolean()) return null;
@@ -793,17 +748,4 @@ public override void Deserialize(byte[] modelData)
         for (int i = 0; i < len; i++) v[i] = NumOps.FromDouble(r.ReadDouble());
         return v;
     }
-
-    /// <inheritdoc/>
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        return new BetaRegression<T>(_options, Regularization);
-    }
-
-    public override IFullModel<T, Matrix<T>, Vector<T>> Clone()
-    {
-        var clone = new BetaRegression<T>(_options, Regularization);
-        clone.Deserialize(Serialize());
-        return clone;
-    }
 }
diff --git a/src/Regression/ConditionalInferenceTreeRegression.cs b/src/Regression/ConditionalInferenceTreeRegression.cs
index fcf36e327e..fde7d5e9f5 100644
--- a/src/Regression/ConditionalInferenceTreeRegression.cs
+++ b/src/Regression/ConditionalInferenceTreeRegression.cs
@@ -55,7 +55,7 @@ namespace AiDotNet.Regression;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
     [ResearchPaper("Unbiased Recursive Partitioning: A Conditional Inference Framework", "https://doi.org/10.1198/106186006X133933")]
-public class ConditionalInferenceTreeRegression<T> : AsyncDecisionTreeRegressionBase<T>
+public partial class ConditionalInferenceTreeRegression<T> : AsyncDecisionTreeRegressionBase<T>
 {
     /// <summary>
     /// Initializes a new instance with default settings.
@@ -604,107 +604,6 @@ public override ModelMetadata<T> GetModelMetadata()
         return metadata;
     }
 
-    /// <summary>
-    /// Serializes the model to a byte array.
-    /// </summary>
-    /// <returns>A byte array containing the serialized model.</returns>
-    /// <remarks>
-    /// <para>
-    /// This method serializes the model to a byte array for storage or transmission.
-    /// It includes all necessary information to reconstruct the model, including options,
-    /// the tree structure, and feature importances.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method saves the model to binary data that can be stored or shared.
-    /// 
-    /// Serialization converts the model into a compact format that:
-    /// - Can be saved to a file
-    /// - Can be sent over a network
-    /// - Can be stored in a database
-    /// - Can be loaded later to make predictions without retraining
-    /// 
-    /// The saved data includes:
-    /// - All the model's settings (like max depth)
-    /// - The entire structure of the decision tree
-    /// - The feature importance scores
-    /// 
-    /// This is like taking a snapshot of the model for future use.
-    /// </para>
-    /// </remarks>
-    public override byte[] Serialize()
-    {
-        using var ms = new MemoryStream();
-        using var writer = new BinaryWriter(ms);
-
-        // Serialize options
-        writer.Write(_options.MaxDepth);
-        writer.Write(_options.MinSamplesSplit);
-        writer.Write(_options.SignificanceLevel);
-        writer.Write(_options.Seed ?? -1);
-        writer.Write(_options.MinSamplesLeaf);
-
-        // Serialize the tree structure
-        SerializeNode(writer, _root);
-
-        // Serialize feature importances
-        writer.Write(FeatureImportances.Length);
-        foreach (var importance in FeatureImportances)
-        {
-            writer.Write(Convert.ToDouble(importance));
-        }
-
-        return ms.ToArray();
-    }
-
-    /// <summary>
-    /// Deserializes the model from a byte array.
-    /// </summary>
-    /// <param name="data">The byte array containing the serialized model.</param>
-    /// <remarks>
-    /// <para>
-    /// This method reconstructs the model from a serialized byte array. It reads the options,
-    /// tree structure, and feature importances from the byte array and rebuilds the model.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method loads a previously saved model from binary data.
-    /// 
-    /// Deserialization converts the binary data back into a working model:
-    /// - It loads all the model's settings
-    /// - It reconstructs the entire decision tree
-    /// - It restores the feature importance scores
-    /// 
-    /// This allows you to:
-    /// - Use a model that was trained earlier
-    /// - Share models between different applications
-    /// - Deploy models to production environments
-    /// 
-    /// It's like restoring the model from a snapshot so you can use it again without retraining.
-    /// </para>
-    /// </remarks>
-    public override void Deserialize(byte[] data)
-    {
-        using var ms = new MemoryStream(data);
-        using var reader = new BinaryReader(ms);
-
-        // Deserialize options
-        _options.MaxDepth = reader.ReadInt32();
-        _options.MinSamplesSplit = reader.ReadInt32();
-        _options.SignificanceLevel = reader.ReadDouble();
-        int seed = reader.ReadInt32();
-        _options.Seed = seed == -1 ? null : seed;
-        _options.MinSamplesLeaf = reader.ReadInt32();
-
-        // Deserialize the tree structure
-        _root = DeserializeNode(reader);
-
-        // Deserialize feature importances
-        int importanceCount = reader.ReadInt32();
-        var importances = new T[importanceCount];
-        for (int i = 0; i < importanceCount; i++)
-        {
-            importances[i] = NumOps.FromDouble(reader.ReadDouble());
-        }
-        FeatureImportances = new Vector<T>(importances);
-    }
-
     /// <summary>
     /// Serializes a tree node to a binary writer.
     /// </summary>
@@ -800,45 +699,4 @@ private void SerializeNode(BinaryWriter writer, ConditionalInferenceTreeNode<T>?
         return node;
     }
 
-    /// <summary>
-    /// Creates a new instance of the conditional inference tree regression model with the same configuration.
-    /// </summary>
-    /// <returns>
-    /// A new instance of <see cref="ConditionalInferenceTreeRegression{T}"/> with the same configuration as the current instance.
-    /// </returns>
-    /// <remarks>
-    /// <para>
-    /// This method creates a new conditional inference tree regression model that has the same configuration 
-    /// as the current instance. It's used for model persistence, cloning, and transferring the model's 
-    /// configuration to new instances.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method makes a fresh copy of the current model with the same settings.
-    /// 
-    /// It's like creating a blueprint copy of your model that can be used to:
-    /// - Save your model's settings
-    /// - Create a new identical model
-    /// - Transfer your model's configuration to another system
-    /// 
-    /// This is useful when you want to:
-    /// - Create multiple similar models
-    /// - Save a model's configuration for later use
-    /// - Reset a model while keeping its settings
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        // Create and return a new instance with the same configuration
-        return new ConditionalInferenceTreeRegression<T>(_options, Regularization);
-    }
-
-    /// <summary>
-    /// Creates a deep copy via serialization to ensure the private _root tree is preserved.
-    /// </summary>
-    public override IFullModel<T, Matrix<T>, Vector<T>> Clone()
-    {
-        var clone = new ConditionalInferenceTreeRegression<T>(_options, Regularization);
-        var data = Serialize();
-        clone.Deserialize(data);
-        return clone;
-    }
 }
diff --git a/src/Regression/DARTRegression.cs b/src/Regression/DARTRegression.cs
index df89136cbc..fdb47bd8a8 100644
--- a/src/Regression/DARTRegression.cs
+++ b/src/Regression/DARTRegression.cs
@@ -62,7 +62,7 @@ namespace AiDotNet.Regression;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
 [ResearchPaper("DART: Dropouts meet Multiple Additive Regression Trees", "https://arxiv.org/abs/1505.01866", Year = 2015, Authors = "K. V. Rashmi, Ran Gilad-Bachrach")]
-public class DARTRegression<T> : AsyncDecisionTreeRegressionBase<T>
+public partial class DARTRegression<T> : AsyncDecisionTreeRegressionBase<T>
 {
     /// <summary>
     /// Individual tree structures.
@@ -679,39 +679,6 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    /// <inheritdoc/>
-    public override byte[] Serialize()
-    {
-        using var ms = new MemoryStream();
-        using var writer = new BinaryWriter(ms);
-
-        byte[] baseData = base.Serialize();
-        writer.Write(baseData.Length);
-        writer.Write(baseData);
-
-        // Options
-        writer.Write(_options.NumberOfIterations);
-        writer.Write(_options.LearningRate);
-        writer.Write(_options.MaxDepth);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_numFeatures);
-
-        // Trees
-        writer.Write(_trees.Count);
-        foreach (var tree in _trees)
-        {
-            SerializeTree(writer, tree);
-        }
-
-        // Tree weights
-        foreach (var weight in _treeWeights)
-        {
-            writer.Write(NumOps.ToDouble(weight));
-        }
-
-        return ms.ToArray();
-    }
-
     private void SerializeTree(BinaryWriter writer, DARTTree tree)
     {
         writer.Write(tree.IsConstant);
@@ -742,35 +709,6 @@ private void SerializeTree(BinaryWriter writer, DARTTree tree)
         }
     }
 
-    /// <inheritdoc/>
-    public override void Deserialize(byte[] modelData)
-    {
-        using var ms = new MemoryStream(modelData);
-        using var reader = new BinaryReader(ms);
-
-        int baseLen = reader.ReadInt32();
-        base.Deserialize(reader.ReadBytes(baseLen));
-
-        _options.NumberOfIterations = reader.ReadInt32();
-        _options.LearningRate = reader.ReadDouble();
-        _options.MaxDepth = reader.ReadInt32();
-        _options.DropoutRate = reader.ReadDouble();
-        _numFeatures = reader.ReadInt32();
-
-        int numTrees = reader.ReadInt32();
-        _trees = [];
-        for (int t = 0; t < numTrees; t++)
-        {
-            _trees.Add(DeserializeTree(reader));
-        }
-
-        _treeWeights = [];
-        for (int t = 0; t < numTrees; t++)
-        {
-            _treeWeights.Add(NumOps.FromDouble(reader.ReadDouble()));
-        }
-    }
-
     private DARTTree DeserializeTree(BinaryReader reader)
     {
         var tree = new DARTTree(NumOps.Zero)
@@ -804,19 +742,6 @@ private DARTTree DeserializeTree(BinaryReader reader)
         return tree;
     }
 
-    /// <inheritdoc/>
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        return new DARTRegression<T>(_options, Regularization);
-    }
-
-    public override IFullModel<T, Matrix<T>, Vector<T>> Clone()
-    {
-        var clone = new DARTRegression<T>(_options, Regularization);
-        clone.Deserialize(Serialize());
-        return clone;
-    }
-
     /// <summary>
     /// Internal tree structure for DART.
     /// </summary>
diff --git a/src/Regression/DecisionTreeAsyncRegressionBase.cs b/src/Regression/DecisionTreeAsyncRegressionBase.cs
index 975de06407..def5be5f72 100644
--- a/src/Regression/DecisionTreeAsyncRegressionBase.cs
+++ b/src/Regression/DecisionTreeAsyncRegressionBase.cs
@@ -26,8 +26,51 @@ namespace AiDotNet.Regression;
 /// questions and answers based on numerical data.
 /// </para>
 /// </remarks>
-public abstract class AsyncDecisionTreeRegressionBase<T> : IAsyncTreeBasedModel<T>, IConfigurableModel<T>, IModelShape
+public abstract partial class AsyncDecisionTreeRegressionBase<T> : IAsyncTreeBasedModel<T>, IConfigurableModel<T>, IModelShape
 {
+    // --- declared state (ModelStateRegistry) ---
+    // Identical in every model base because these bases are siblings over the same interfaces rather
+    // than one hierarchy; the logic itself lives once in ModelStateRegistry/ModelStateEnvelope.
+
+    /// <summary>State that is not a parameter vector, declared once and persisted by this base.</summary>
+    private readonly AiDotNet.Models.ModelStateRegistry<T> _declaredState = new();
+    private bool _declaredStateRegistered;
+
+    /// <summary>
+    /// Declare state here that the parameter vector does not carry -- a retained training set,
+    /// fitted knots, kernel centres, an ensemble's children. Both halves of the payload are driven
+    /// by the declaration, so they cannot drift.
+    /// </summary>
+    /// <param name="state">The registry to declare into.</param>
+    protected virtual void RegisterState(AiDotNet.Models.ModelStateRegistry<T> state)
+    {
+    }
+    /// <summary>Generated state declarations for fields declared across this model's hierarchy.</summary>
+    /// <param name="state">The registry to declare into.</param>
+    /// <remarks>
+    /// Emitted by ModelStateGenerator into the partial model, so a model author declares nothing. The
+    /// hand-written <c>RegisterState</c> beside it exists only for state the classifier genuinely
+    /// cannot place; anything it CAN place belongs here, where it cannot be forgotten.
+    /// </remarks>
+    protected virtual void RegisterGeneratedState(AiDotNet.Models.ModelStateRegistry<T> state)
+    {
+        RegisterGeneratedStateCore(state);
+    }
+
+    /// <summary>The declared state, registered once and lazily so it runs after the constructor.</summary>
+    protected AiDotNet.Models.ModelStateRegistry<T> DeclaredState
+    {
+        get
+        {
+            if (!_declaredStateRegistered)
+            {
+                _declaredStateRegistered = true;
+                RegisterGeneratedState(_declaredState);
+                RegisterState(_declaredState);
+            }
+            return _declaredState;
+        }
+    }
     /// <summary>
     /// Gets the numeric operations for the type T.
     /// </summary>
@@ -282,10 +325,8 @@ public virtual byte[] Serialize()
             writer.Write(Convert.ToDouble(importance));
         }
 
-        // Serialize tree structure
-        SerializeNode(writer, Root);
 
-        return ms.ToArray();
+        return AiDotNet.Models.ModelStateEnvelope.Append(DeclaredState, ms.ToArray());
     }
 
     /// <summary>
@@ -307,6 +348,9 @@ public virtual byte[] Serialize()
     /// </remarks>
     public virtual void Deserialize(byte[] modelData)
     {
+        // Strips and applies any declared-state trailer, so the body below reads the payload
+        // exactly as it did before this existed.
+        modelData = AiDotNet.Models.ModelStateEnvelope.Extract(DeclaredState, modelData);
         ModelPersistenceGuard.EnforceBeforeDeserialize();
         using var ms = new MemoryStream(modelData);
         using var reader = new BinaryReader(ms);
@@ -329,56 +373,9 @@ public virtual void Deserialize(byte[] modelData)
         }
         FeatureImportances = new Vector<T>(importances);
 
-        // Deserialize tree structure
-        Root = DeserializeNode(reader);
     }
 
-    /// <summary>
-    /// Serializes a single node of the decision tree.
-    /// </summary>
-    /// <param name="writer">The BinaryWriter to write the serialized data to.</param>
-    /// <param name="node">The node to serialize.</param>
-    private void SerializeNode(BinaryWriter writer, DecisionTreeNode<T>? node)
-    {
-        if (node == null)
-        {
-            writer.Write(false);
-            return;
-        }
 
-        writer.Write(true);
-        writer.Write(node.FeatureIndex);
-        writer.Write(Convert.ToDouble(node.SplitValue));
-        writer.Write(Convert.ToDouble(node.Prediction));
-        writer.Write(node.IsLeaf);
-
-        SerializeNode(writer, node.Left);
-        SerializeNode(writer, node.Right);
-    }
-
-    /// <summary>
-    /// Deserializes a single node of the decision tree.
-    /// </summary>
-    /// <param name="reader">The BinaryReader to read the serialized data from.</param>
-    /// <returns>The deserialized DecisionTreeNode, or null if the node was not present.</returns>
-    private DecisionTreeNode<T>? DeserializeNode(BinaryReader reader)
-    {
-        bool hasNode = reader.ReadBoolean();
-        if (!hasNode) return null;
-
-        var node = new DecisionTreeNode<T>
-        {
-            FeatureIndex = reader.ReadInt32(),
-            SplitValue = NumOps.FromDouble(reader.ReadDouble()),
-            Prediction = NumOps.FromDouble(reader.ReadDouble()),
-            IsLeaf = reader.ReadBoolean()
-        };
-
-        node.Left = DeserializeNode(reader);
-        node.Right = DeserializeNode(reader);
-
-        return node;
-    }
 
     /// <summary>
     /// Gets the model parameters as a vector representation.
@@ -699,22 +696,18 @@ public virtual IFullModel<T, Matrix<T>, Vector<T>> DeepCopy()
     /// </remarks>
     public virtual IFullModel<T, Matrix<T>, Vector<T>> Clone()
     {
-        // Create a new instance with the same options
-        var clone = CreateNewInstance();
-
-        // Deep copy the tree structure
-        if (Root != null)
-        {
-            ((AsyncDecisionTreeRegressionBase<T>)clone).Root = DeepCloneNode(Root);
-        }
-
-        // Copy feature importances
-        if (FeatureImportances.Length > 0)
+        // Through the complete declared-state payload, not a base-class list of fields. Many models
+        // on this historical trunk are ensembles or probabilistic regressors rather than one Root;
+        // the former implementation copied only Root and FeatureImportances and forced every model
+        // to repeat the same serialize/new/deserialize override. Generated state now owns those
+        // fitted structures, so the shared base can provide the correct clone once.
+        using (ModelPersistenceGuard.InternalOperation())
         {
-            ((AsyncDecisionTreeRegressionBase<T>)clone).FeatureImportances = new Vector<T>(FeatureImportances);
+            byte[] state = Serialize();
+            var clone = (AsyncDecisionTreeRegressionBase<T>)CreateNewInstance();
+            clone.Deserialize(state);
+            return clone;
         }
-
-        return clone;
     }
 
     /// <summary>
@@ -742,7 +735,18 @@ public virtual IFullModel<T, Matrix<T>, Vector<T>> Clone()
     /// creating ensembles of similar models with different training data.
     /// </para>
     /// </remarks>
-    protected abstract IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance();
+    /// <remarks>
+    /// <para>
+    /// No longer abstract. Every concrete model used to be forced to write this, and 1147 of them
+    /// did -- each one a hand-copied list of constructor arguments that a new option could fall out
+    /// of without anything failing. The clone plan records that constructor at compile time instead,
+    /// so the base can rebuild the type and a model only overrides this when the generator says it
+    /// cannot: a constructor parameter with nothing holding its value, which the build reports by
+    /// name rather than leaving to be discovered by a clone that comes back subtly different.
+    /// </para>
+    /// </remarks>
+    protected virtual IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
+        => (IFullModel<T, Matrix<T>, Vector<T>>)AiDotNet.Models.CloneEngine.CopyConfiguration(this);
 
     /// <summary>
     /// Counts the total number of nodes in the tree.
diff --git a/src/Regression/DecisionTreeRegression.cs b/src/Regression/DecisionTreeRegression.cs
index 7a7f0b9fcd..30b34fa14a 100644
--- a/src/Regression/DecisionTreeRegression.cs
+++ b/src/Regression/DecisionTreeRegression.cs
@@ -54,7 +54,7 @@ namespace AiDotNet.Regression;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
     [ResearchPaper("Classification and Regression Trees", "https://doi.org/10.1201/9781315139470")]
-public class DecisionTreeRegression<T> : DecisionTreeRegressionBase<T>
+public partial class DecisionTreeRegression<T> : DecisionTreeRegressionBase<T>
 {
     /// <summary>
     /// The configuration options for the decision tree algorithm.
@@ -329,105 +329,6 @@ public T GetFeatureImportance(int featureIndex)
         return _featureImportances[featureIndex];
     }
 
-    /// <summary>
-    /// Serializes the decision tree model to a byte array for storage or transmission.
-    /// </summary>
-    /// <returns>A byte array containing the serialized model.</returns>
-    /// <remarks>
-    /// <para>
-    /// This method converts the decision tree model into a byte array that can be stored in a file, database,
-    /// or transmitted over a network. The serialized data includes the model's configuration options and the
-    /// complete tree structure.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method saves your trained model as a sequence of bytes.
-    /// 
-    /// Serialization allows you to:
-    /// - Save your model to a file
-    /// - Store your model in a database
-    /// - Send your model over a network
-    /// - Keep your model for later use without having to retrain it
-    /// 
-    /// The serialized data includes:
-    /// - All the model's settings (like maximum depth)
-    /// - The entire tree structure with all its decision rules
-    /// 
-    /// Example:
-    /// ```csharp
-    /// // Serialize the model
-    /// byte[] modelData = decisionTree.Serialize();
-    /// 
-    /// // Save to a file
-    /// File.WriteAllBytes("decisionTree.model", modelData);
-    /// ```
-    /// </para>
-    /// </remarks>
-    public override byte[] Serialize()
-    {
-        using var ms = new MemoryStream();
-        using var writer = new BinaryWriter(ms);
-        // Serialize options
-        writer.Write(_options.MaxDepth);
-        writer.Write(_options.MinSamplesSplit);
-        writer.Write(_options.MaxFeatures);
-        writer.Write(_options.Seed ?? -1);
-
-        // Serialize the tree structure
-        SerializeNode(Root, writer);
-
-        return ms.ToArray();
-    }
-
-    /// <summary>
-    /// Loads a previously serialized decision tree model from a byte array.
-    /// </summary>
-    /// <param name="data">The byte array containing the serialized model.</param>
-    /// <remarks>
-    /// <para>
-    /// This method reconstructs a decision tree model from a byte array that was previously created using the
-    /// Serialize method. It restores the model's configuration options and tree structure, allowing the model
-    /// to be used for predictions without retraining.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method loads a previously saved model from a sequence of bytes.
-    /// 
-    /// Deserialization allows you to:
-    /// - Load a model that was saved earlier
-    /// - Use a model without having to retrain it
-    /// - Share models between different applications
-    /// 
-    /// When you deserialize a model:
-    /// - All settings are restored
-    /// - The entire tree structure is reconstructed
-    /// - The model is ready to make predictions immediately
-    /// 
-    /// Example:
-    /// ```csharp
-    /// // Load from a file
-    /// byte[] modelData = File.ReadAllBytes("decisionTree.model");
-    /// 
-    /// // Deserialize the model
-    /// var decisionTree = new DecisionTreeRegression&lt;double&gt;();
-    /// decisionTree.Deserialize(modelData);
-    /// 
-    /// // Now you can use the model for predictions
-    /// var predictions = decisionTree.Predict(newFeatures);
-    /// ```
-    /// </para>
-    /// </remarks>
-    public override void Deserialize(byte[] data)
-    {
-        using var ms = new MemoryStream(data);
-        using var reader = new BinaryReader(ms);
-        // Deserialize options
-        _options.MaxDepth = reader.ReadInt32();
-        _options.MinSamplesSplit = reader.ReadInt32();
-        _options.MaxFeatures = reader.ReadDouble();
-        int seed = reader.ReadInt32();
-        _options.Seed = seed == -1 ? null : seed;
-
-        // Deserialize the tree structure
-        Root = DeserializeNode(reader);
-    }
-
     /// <summary>
     /// Trains the decision tree model using the provided input features, target values, and sample weights.
     /// </summary>
@@ -1210,36 +1111,4 @@ T CalculateNodeImpurity(DecisionTreeNode<T>? node)
         // Copy to the public property from base class so ensemble methods can access it
         FeatureImportances = _featureImportances;
     }
-
-    /// <summary>
-    /// Creates a new instance of the decision tree regression model with the same options.
-    /// </summary>
-    /// <returns>A new instance of the model with the same configuration but no trained parameters.</returns>
-    /// <remarks>
-    /// <para>
-    /// This method creates a new instance of the decision tree regression model with the same configuration
-    /// options and regularization method as the current instance, but without copying the trained parameters.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method creates a fresh copy of the model configuration without 
-    /// any learned parameters.
-    /// 
-    /// Think of it like getting a blank notepad with the same paper quality and size, 
-    /// but without any writing on it yet. The new model has the same:
-    /// - Maximum depth setting
-    /// - Minimum samples split setting
-    /// - Split criterion (how nodes decide which feature to split on)
-    /// - Random seed (if specified)
-    /// - Regularization method
-    /// 
-    /// But it doesn't have any of the actual tree structure that was learned from data.
-    /// 
-    /// This is mainly used internally when doing things like cross-validation or 
-    /// creating ensembles of similar models with different training data.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        // Create a new instance with the same options and regularization
-        return new DecisionTreeRegression<T>(_options, _regularization);
-    }
 }
diff --git a/src/Regression/DecisionTreeRegressionBase.cs b/src/Regression/DecisionTreeRegressionBase.cs
index a102c4063e..9eae4fd8db 100644
--- a/src/Regression/DecisionTreeRegressionBase.cs
+++ b/src/Regression/DecisionTreeRegressionBase.cs
@@ -28,8 +28,51 @@ namespace AiDotNet.Regression;
 /// </para>
 /// </remarks>
 /// <typeparam name="T">The numeric type used for calculations, typically float or double.</typeparam>
-public abstract class DecisionTreeRegressionBase<T> : ITreeBasedRegression<T>, IConfigurableModel<T>, IModelShape
+public abstract partial class DecisionTreeRegressionBase<T> : ITreeBasedRegression<T>, IConfigurableModel<T>, IModelShape
 {
+    // --- declared state (ModelStateRegistry) ---
+    // Identical in every model base because these bases are siblings over the same interfaces rather
+    // than one hierarchy; the logic itself lives once in ModelStateRegistry/ModelStateEnvelope.
+
+    /// <summary>State that is not a parameter vector, declared once and persisted by this base.</summary>
+    private readonly AiDotNet.Models.ModelStateRegistry<T> _declaredState = new();
+    private bool _declaredStateRegistered;
+
+    /// <summary>
+    /// Declare state here that the parameter vector does not carry -- a retained training set,
+    /// fitted knots, kernel centres, an ensemble's children. Both halves of the payload are driven
+    /// by the declaration, so they cannot drift.
+    /// </summary>
+    /// <param name="state">The registry to declare into.</param>
+    protected virtual void RegisterState(AiDotNet.Models.ModelStateRegistry<T> state)
+    {
+    }
+    /// <summary>Generated state declarations for fields declared across this model's hierarchy.</summary>
+    /// <param name="state">The registry to declare into.</param>
+    /// <remarks>
+    /// Emitted by ModelStateGenerator into the partial model, so a model author declares nothing. The
+    /// hand-written <c>RegisterState</c> beside it exists only for state the classifier genuinely
+    /// cannot place; anything it CAN place belongs here, where it cannot be forgotten.
+    /// </remarks>
+    protected virtual void RegisterGeneratedState(AiDotNet.Models.ModelStateRegistry<T> state)
+    {
+        RegisterGeneratedStateCore(state);
+    }
+
+    /// <summary>The declared state, registered once and lazily so it runs after the constructor.</summary>
+    protected AiDotNet.Models.ModelStateRegistry<T> DeclaredState
+    {
+        get
+        {
+            if (!_declaredStateRegistered)
+            {
+                _declaredStateRegistered = true;
+                RegisterGeneratedState(_declaredState);
+                RegisterState(_declaredState);
+            }
+            return _declaredState;
+        }
+    }
     /// <summary>
     /// Provides operations for performing numeric calculations appropriate for the type T.
     /// </summary>
@@ -362,9 +405,7 @@ public virtual byte[] Serialize()
         {
             writer.Write(Convert.ToDouble(importance));
         }
-        // Serialize tree structure
-        SerializeNode(writer, Root);
-        return ms.ToArray();
+        return AiDotNet.Models.ModelStateEnvelope.Append(DeclaredState, ms.ToArray());
     }
 
     /// <summary>
@@ -405,6 +446,9 @@ public virtual byte[] Serialize()
     /// </remarks>
     public virtual void Deserialize(byte[] modelData)
     {
+        // Strips and applies any declared-state trailer, so the body below reads the payload
+        // exactly as it did before this existed.
+        modelData = AiDotNet.Models.ModelStateEnvelope.Extract(DeclaredState, modelData);
         ModelPersistenceGuard.EnforceBeforeDeserialize();
         using var ms = new MemoryStream(modelData);
         using var reader = new BinaryReader(ms);
@@ -424,52 +468,9 @@ public virtual void Deserialize(byte[] modelData)
             importances[i] = NumOps.FromDouble(reader.ReadDouble());
         }
         FeatureImportances = new Vector<T>(importances);
-        // Deserialize tree structure
-        Root = DeserializeNode(reader);
     }
 
-    /// <summary>
-    /// Serializes a tree node to a binary writer.
-    /// </summary>
-    /// <param name="writer">The binary writer to write to.</param>
-    /// <param name="node">The node to serialize.</param>
-    private void SerializeNode(BinaryWriter writer, DecisionTreeNode<T>? node)
-    {
-        if (node == null)
-        {
-            writer.Write(false);
-            return;
-        }
-        writer.Write(true);
-        writer.Write(node.FeatureIndex);
-        writer.Write(Convert.ToDouble(node.SplitValue));
-        writer.Write(Convert.ToDouble(node.Prediction));
-        writer.Write(node.IsLeaf);
-        SerializeNode(writer, node.Left);
-        SerializeNode(writer, node.Right);
-    }
 
-    /// <summary>
-    /// Deserializes a tree node from a binary reader.
-    /// </summary>
-    /// <param name="reader">The binary reader to read from.</param>
-    /// <returns>The deserialized node.</returns>
-    private DecisionTreeNode<T>? DeserializeNode(BinaryReader reader)
-    {
-        bool hasNode = reader.ReadBoolean();
-        if (!hasNode) return null;
-        var node = new DecisionTreeNode<T>
-        {
-            FeatureIndex = reader.ReadInt32(),
-            SplitValue = NumOps.FromDouble(reader.ReadDouble()),
-            Prediction = NumOps.FromDouble(reader.ReadDouble()),
-            IsLeaf = reader.ReadBoolean(),
-            Left = DeserializeNode(reader),
-            Right = DeserializeNode(reader)
-        };
-
-        return node;
-    }
 
     /// <summary>
     /// Gets the model parameters as a vector representation.
@@ -833,7 +834,18 @@ public virtual IFullModel<T, Matrix<T>, Vector<T>> Clone()
     /// creating ensembles of similar models with different training data.
     /// </para>
     /// </remarks>
-    protected abstract IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance();
+    /// <remarks>
+    /// <para>
+    /// No longer abstract. Every concrete model used to be forced to write this, and 1147 of them
+    /// did -- each one a hand-copied list of constructor arguments that a new option could fall out
+    /// of without anything failing. The clone plan records that constructor at compile time instead,
+    /// so the base can rebuild the type and a model only overrides this when the generator says it
+    /// cannot: a constructor parameter with nothing holding its value, which the build reports by
+    /// name rather than leaving to be discovered by a clone that comes back subtly different.
+    /// </para>
+    /// </remarks>
+    protected virtual IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
+        => (IFullModel<T, Matrix<T>, Vector<T>>)AiDotNet.Models.CloneEngine.CopyConfiguration(this);
 
     /// <summary>
     /// Counts the total number of nodes in the tree.
diff --git a/src/Regression/DeepHit.cs b/src/Regression/DeepHit.cs
index 8943f384d3..d011c4add4 100644
--- a/src/Regression/DeepHit.cs
+++ b/src/Regression/DeepHit.cs
@@ -1576,65 +1576,6 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    /// <inheritdoc/>
-    public override byte[] Serialize()
-    {
-        using var ms = new MemoryStream();
-        using var writer = new BinaryWriter(ms);
-
-        byte[] baseData = base.Serialize();
-        writer.Write(baseData.Length);
-        writer.Write(baseData);
-
-        // Options
-        writer.Write(_options.NumTimeBins);
-        writer.Write(_effectiveTimeBins);
-        writer.Write(_options.NumSharedLayers);
-        writer.Write(_options.NumCauseLayers);
-        writer.Write(_options.HiddenLayerSize);
-        writer.Write(_options.NumRisks);
-        writer.Write(_options.Activation.GetType().AssemblyQualifiedName ?? _options.Activation.GetType().FullName ?? _options.Activation.GetType().Name);
-        writer.Write(_numFeatures);
-
-        // Time bins
-        writer.Write(_timeBinEdges?.Length ?? 0);
-        if (_timeBinEdges != null)
-        {
-            foreach (var t in _timeBinEdges)
-            {
-                writer.Write(NumOps.ToDouble(t));
-            }
-        }
-
-        // Shared weights and biases
-        SerializeLayerList(writer, _sharedWeights, _sharedBiases);
-
-        // Cause-specific weights and biases
-        for (int k = 0; k < _options.NumRisks; k++)
-        {
-            SerializeLayerList(writer, _causeWeights[k], _causeBiases[k]);
-        }
-
-        // Output weights and biases
-        for (int k = 0; k < _options.NumRisks; k++)
-        {
-            SerializeWeights(writer, _outputWeights[k]);
-            SerializeBiases(writer, _outputBiases[k]);
-        }
-
-        // Feature standardization, which replaces the OLS coefficient block written here before. It is
-        // part of the fitted model: a restored network fed raw features would see inputs on a completely
-        // different scale from the ones it was trained on.
-        writer.Write(_featureMean is not null && _featureStd is not null);
-        if (_featureMean is not null && _featureStd is not null)
-        {
-            SerializeBiases(writer, _featureMean);
-            SerializeBiases(writer, _featureStd);
-        }
-
-        return ms.ToArray();
-    }
-
     private void SerializeLayerList(BinaryWriter writer, List<Matrix<T>> weights, List<Vector<T>> biases)
     {
         writer.Write(weights.Count);
@@ -1667,81 +1608,6 @@ private void SerializeBiases(BinaryWriter writer, Vector<T> b)
         }
     }
 
-    /// <inheritdoc/>
-    public override void Deserialize(byte[] modelData)
-    {
-        using var ms = new MemoryStream(modelData);
-        using var reader = new BinaryReader(ms);
-
-        int baseLen = reader.ReadInt32();
-        base.Deserialize(reader.ReadBytes(baseLen));
-
-        _options.NumTimeBins = reader.ReadInt32();
-        _effectiveTimeBins = reader.ReadInt32();
-        _options.NumSharedLayers = reader.ReadInt32();
-        _options.NumCauseLayers = reader.ReadInt32();
-        _options.HiddenLayerSize = reader.ReadInt32();
-        _options.NumRisks = reader.ReadInt32();
-        string activationTypeName = reader.ReadString();
-        var activationType = Type.GetType(activationTypeName);
-        if (activationType is not null
-            && typeof(IActivationFunction<T>).IsAssignableFrom(activationType)
-            && activationType.Namespace is not null
-            && activationType.Namespace.StartsWith("AiDotNet.", StringComparison.Ordinal))
-        {
-            _options.Activation = (IActivationFunction<T>)(Activator.CreateInstance(activationType) ?? new ReLUActivation<T>());
-        }
-        else
-        {
-            _options.Activation = new ReLUActivation<T>();
-        }
-        _numFeatures = reader.ReadInt32();
-
-        int timeBinLen = reader.ReadInt32();
-        if (timeBinLen > 0)
-        {
-            _timeBinEdges = new Vector<T>(timeBinLen);
-            for (int i = 0; i < timeBinLen; i++)
-            {
-                _timeBinEdges[i] = NumOps.FromDouble(reader.ReadDouble());
-            }
-        }
-
-        // Shared weights and biases
-        (_sharedWeights, _sharedBiases) = DeserializeLayerList(reader);
-
-        // Cause-specific weights and biases
-        _causeWeights = [];
-        _causeBiases = [];
-        for (int k = 0; k < _options.NumRisks; k++)
-        {
-            var (cw, cb) = DeserializeLayerList(reader);
-            _causeWeights.Add(cw);
-            _causeBiases.Add(cb);
-        }
-
-        // Output weights and biases
-        _outputWeights = [];
-        _outputBiases = [];
-        for (int k = 0; k < _options.NumRisks; k++)
-        {
-            _outputWeights.Add(DeserializeWeights(reader));
-            _outputBiases.Add(DeserializeBiases(reader));
-        }
-
-        // Feature standardization (see Serialize).
-        if (reader.ReadBoolean())
-        {
-            _featureMean = DeserializeBiases(reader);
-            _featureStd = DeserializeBiases(reader);
-        }
-        else
-        {
-            _featureMean = null;
-            _featureStd = null;
-        }
-    }
-
     private (List<Matrix<T>>, List<Vector<T>>) DeserializeLayerList(BinaryReader reader)
     {
         int count = reader.ReadInt32();
@@ -1786,17 +1652,4 @@ private Vector<T> DeserializeBiases(BinaryReader reader)
 
         return b;
     }
-
-    /// <inheritdoc/>
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        return new DeepHit<T>(_options, Regularization);
-    }
-
-    public override IFullModel<T, Matrix<T>, Vector<T>> Clone()
-    {
-        var clone = new DeepHit<T>(_options, Regularization);
-        clone.Deserialize(Serialize());
-        return clone;
-    }
 }
diff --git a/src/Regression/DeepSurv.cs b/src/Regression/DeepSurv.cs
index 72cf528b25..694a343c07 100644
--- a/src/Regression/DeepSurv.cs
+++ b/src/Regression/DeepSurv.cs
@@ -69,7 +69,7 @@ namespace AiDotNet.Regression;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
 [ResearchPaper("DeepSurv: Personalized Treatment Recommender System Using a Cox Proportional Hazards Deep Neural Network", "https://doi.org/10.1186/s12874-018-0482-1", Year = 2018, Authors = "Jared L. Katzman, Uri Shaham, Alexander Cloninger, Jonathan Bates, Tingting Jiang, Yuval Kluger")]
-public class DeepSurv<T> : AsyncDecisionTreeRegressionBase<T>
+public partial class DeepSurv<T> : AsyncDecisionTreeRegressionBase<T>
 {
     /// <summary>
     /// Network weights for each layer.
@@ -89,11 +89,13 @@ public class DeepSurv<T> : AsyncDecisionTreeRegressionBase<T>
     /// <summary>
     /// Baseline cumulative hazard function times.
     /// </summary>
+    [AiDotNet.Attributes.Scratch]
     private Vector<T>? _baselineHazardTimes;
 
     /// <summary>
     /// Baseline cumulative hazard function values.
     /// </summary>
+    [AiDotNet.Attributes.Scratch]
     private Vector<T>? _baselineHazardValues;
 
     /// <summary>
@@ -105,6 +107,9 @@ public class DeepSurv<T> : AsyncDecisionTreeRegressionBase<T>
     /// Random number generator.
     /// </summary>
     private readonly Random _random;
+    private bool _useOLS;
+    [AiDotNet.Attributes.FittedParameter]
+    private Vector<T>? _olsCoefficients;
 
     /// <summary>
     /// Per-layer batch-normalization scale, one entry per hidden layer. Empty when
@@ -1601,227 +1606,4 @@ public override ModelMetadata<T> GetModelMetadata()
             }
         };
     }
-
-    /// <inheritdoc/>
-    public override byte[] Serialize()
-    {
-        using var ms = new MemoryStream();
-        using var writer = new BinaryWriter(ms);
-
-        byte[] baseData = base.Serialize();
-        writer.Write(baseData.Length);
-        writer.Write(baseData);
-
-        // Options
-        writer.Write(_options.NumHiddenLayers);
-        writer.Write(_options.HiddenLayerSize);
-        writer.Write(_options.Activation.GetType().AssemblyQualifiedName ?? _options.Activation.GetType().FullName ?? _options.Activation.GetType().Name);
-        writer.Write(_numFeatures);
-
-        // Weights and biases
-        writer.Write(_weights.Count);
-        foreach (var w in _weights)
-        {
-            writer.Write(w.Rows);
-            writer.Write(w.Columns);
-            for (int i = 0; i < w.Rows; i++)
-            {
-                for (int j = 0; j < w.Columns; j++)
-                {
-                    writer.Write(NumOps.ToDouble(w[i, j]));
-                }
-            }
-        }
-
-        foreach (var b in _biases)
-        {
-            writer.Write(b.Length);
-            for (int i = 0; i < b.Length; i++)
-            {
-                writer.Write(NumOps.ToDouble(b[i]));
-            }
-        }
-
-        // Baseline hazard
-        writer.Write(_baselineHazardTimes is not null);
-        if (_baselineHazardTimes is not null && _baselineHazardValues is not null)
-        {
-            writer.Write(_baselineHazardTimes.Length);
-            foreach (var t in _baselineHazardTimes)
-            {
-                writer.Write(NumOps.ToDouble(t));
-            }
-            foreach (var h in _baselineHazardValues)
-            {
-                writer.Write(NumOps.ToDouble(h));
-            }
-        }
-
-        // Batch-normalization state. This replaces the OLS coefficient block that used to be written
-        // here: the model no longer fits least squares, and the running mean and variance ARE model
-        // parameters -- a round-tripped network that lost them would normalize with the initial
-        // mean 0 / variance 1 and predict differently from the model that was saved.
-        writer.Write(NumOps.ToDouble(_maxObservedTime));
-
-        // Feature standardization is part of the fitted model: a restored network fed raw features would
-        // see inputs on a completely different scale from the ones it was trained on.
-        writer.Write(_featureMean is not null && _featureStd is not null);
-        if (_featureMean is not null && _featureStd is not null)
-        {
-            WriteBatchNormVector(writer, _featureMean);
-            WriteBatchNormVector(writer, _featureStd);
-        }
-
-        writer.Write(_bnGamma.Count);
-        for (int layer = 0; layer < _bnGamma.Count; layer++)
-        {
-            WriteBatchNormVector(writer, _bnGamma[layer]);
-            WriteBatchNormVector(writer, _bnBeta[layer]);
-            WriteBatchNormVector(writer, _bnRunningMean[layer]);
-            WriteBatchNormVector(writer, _bnRunningVariance[layer]);
-        }
-
-        return ms.ToArray();
-    }
-
-    /// <inheritdoc/>
-    public override void Deserialize(byte[] modelData)
-    {
-        using var ms = new MemoryStream(modelData);
-        using var reader = new BinaryReader(ms);
-
-        int baseLen = reader.ReadInt32();
-        base.Deserialize(reader.ReadBytes(baseLen));
-
-        _options.NumHiddenLayers = reader.ReadInt32();
-        _options.HiddenLayerSize = reader.ReadInt32();
-        string activationTypeName = reader.ReadString();
-        var activationType = Type.GetType(activationTypeName);
-        if (activationType is not null
-            && typeof(IActivationFunction<T>).IsAssignableFrom(activationType)
-            && activationType.Namespace is not null
-            && activationType.Namespace.StartsWith("AiDotNet.", StringComparison.Ordinal))
-        {
-            _options.Activation = (IActivationFunction<T>)(Activator.CreateInstance(activationType) ?? new SELUActivation<T>());
-        }
-        else
-        {
-            _options.Activation = new SELUActivation<T>();
-        }
-        _numFeatures = reader.ReadInt32();
-
-        int numLayers = reader.ReadInt32();
-        _weights = [];
-        _biases = [];
-
-        for (int l = 0; l < numLayers; l++)
-        {
-            int rows = reader.ReadInt32();
-            int cols = reader.ReadInt32();
-            var w = new Matrix<T>(rows, cols);
-            for (int i = 0; i < rows; i++)
-            {
-                for (int j = 0; j < cols; j++)
-                {
-                    w[i, j] = NumOps.FromDouble(reader.ReadDouble());
-                }
-            }
-            _weights.Add(w);
-        }
-
-        for (int l = 0; l < numLayers; l++)
-        {
-            int len = reader.ReadInt32();
-            var b = new Vector<T>(len);
-            for (int i = 0; i < len; i++)
-            {
-                b[i] = NumOps.FromDouble(reader.ReadDouble());
-            }
-            _biases.Add(b);
-        }
-
-        bool hasBaseline = reader.ReadBoolean();
-        if (hasBaseline)
-        {
-            int len = reader.ReadInt32();
-            _baselineHazardTimes = new Vector<T>(len);
-            _baselineHazardValues = new Vector<T>(len);
-            for (int i = 0; i < len; i++)
-            {
-                _baselineHazardTimes[i] = NumOps.FromDouble(reader.ReadDouble());
-            }
-            for (int i = 0; i < len; i++)
-            {
-                _baselineHazardValues[i] = NumOps.FromDouble(reader.ReadDouble());
-            }
-        }
-
-        // Batch-normalization state (see Serialize).
-        _maxObservedTime = NumOps.FromDouble(reader.ReadDouble());
-
-        // Feature standardization (see Serialize).
-        if (reader.ReadBoolean())
-        {
-            _featureMean = ReadBatchNormVector(reader);
-            _featureStd = ReadBatchNormVector(reader);
-        }
-        else
-        {
-            _featureMean = null;
-            _featureStd = null;
-        }
-
-        int bnLayers = reader.ReadInt32();
-        _bnGamma = new List<Vector<T>>(bnLayers);
-        _bnBeta = new List<Vector<T>>(bnLayers);
-        _bnRunningMean = new List<Vector<T>>(bnLayers);
-        _bnRunningVariance = new List<Vector<T>>(bnLayers);
-        for (int layer = 0; layer < bnLayers; layer++)
-        {
-            _bnGamma.Add(ReadBatchNormVector(reader));
-            _bnBeta.Add(ReadBatchNormVector(reader));
-            _bnRunningMean.Add(ReadBatchNormVector(reader));
-            _bnRunningVariance.Add(ReadBatchNormVector(reader));
-        }
-    }
-
-    /// <summary>
-    /// Writes one batch-normalization parameter vector.
-    /// </summary>
-    private void WriteBatchNormVector(BinaryWriter writer, Vector<T> v)
-    {
-        writer.Write(v.Length);
-        for (int i = 0; i < v.Length; i++)
-        {
-            writer.Write(NumOps.ToDouble(v[i]));
-        }
-    }
-
-    /// <summary>
-    /// Reads one batch-normalization parameter vector.
-    /// </summary>
-    private Vector<T> ReadBatchNormVector(BinaryReader reader)
-    {
-        int length = reader.ReadInt32();
-        var v = new Vector<T>(length);
-        for (int i = 0; i < length; i++)
-        {
-            v[i] = NumOps.FromDouble(reader.ReadDouble());
-        }
-
-        return v;
-    }
-
-    /// <inheritdoc/>
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        return new DeepSurv<T>(_options, Regularization);
-    }
-
-    public override IFullModel<T, Matrix<T>, Vector<T>> Clone()
-    {
-        var clone = new DeepSurv<T>(_options, Regularization);
-        clone.Deserialize(Serialize());
-        return clone;
-    }
 }
diff --git a/src/Regression/ElasticNetRegression.cs b/src/Regression/ElasticNetRegression.cs
index e0b3afb978..c5adb412e2 100644
--- a/src/Regression/ElasticNetRegression.cs
+++ b/src/Regression/ElasticNetRegression.cs
@@ -61,7 +61,7 @@ namespace AiDotNet.Regression;
 [ModelComplexity(ModelComplexity.Low)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
 [ResearchPaper("Regularization and Variable Selection via the Elastic Net", "https://doi.org/10.1111/j.1467-9868.2005.00503.x", Year = 2005, Authors = "Hui Zou, Trevor Hastie")]
-public class ElasticNetRegression<T> : RegressionBase<T>
+public partial class ElasticNetRegression<T> : RegressionBase<T>
 {
     /// <summary>
     /// Gets the configuration options specific to Elastic Net Regression.
@@ -321,61 +321,4 @@ public override ModelMetadata<T> GetModelMetadata()
         return metadata;
     }
 
-
-    /// <summary>
-    /// Creates a new instance of Elastic Net Regression with the same configuration.
-    /// </summary>
-    /// <returns>A new instance with the same options.</returns>
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        return new ElasticNetRegression<T>(Options, Regularization);
-    }
-
-    /// <summary>
-    /// Serializes the Elastic Net Regression model to a byte array.
-    /// </summary>
-    /// <returns>A byte array containing the serialized model.</returns>
-    public override byte[] Serialize()
-    {
-        using var ms = new MemoryStream();
-        using var writer = new BinaryWriter(ms);
-
-        // Serialize base class data
-        byte[] baseData = base.Serialize();
-        writer.Write(baseData.Length);
-        writer.Write(baseData);
-
-        // Serialize Elastic Net-specific data
-        writer.Write(Options.Alpha);
-        writer.Write(Options.L1Ratio);
-        writer.Write(Options.MaxIterations);
-        writer.Write(Options.Tolerance);
-        writer.Write(Options.WarmStart);
-        writer.Write(_iterationsUsed);
-
-        return ms.ToArray();
-    }
-
-    /// <summary>
-    /// Deserializes an Elastic Net Regression model from a byte array.
-    /// </summary>
-    /// <param name="modelData">The byte array containing the serialized model.</param>
-    public override void Deserialize(byte[] modelData)
-    {
-        using var ms = new MemoryStream(modelData);
-        using var reader = new BinaryReader(ms);
-
-        // Deserialize base class data
-        int baseDataLength = reader.ReadInt32();
-        byte[] baseData = reader.ReadBytes(baseDataLength);
-        base.Deserialize(baseData);
-
-        // Deserialize Elastic Net-specific data
-        Options.Alpha = reader.ReadDouble();
-        Options.L1Ratio = reader.ReadDouble();
-        Options.MaxIterations = reader.ReadInt32();
-        Options.Tolerance = reader.ReadDouble();
-        Options.WarmStart = reader.ReadBoolean();
-        _iterationsUsed = reader.ReadInt32();
-    }
 }
diff --git a/src/Regression/ExplainableBoostingMachineRegression.cs b/src/Regression/ExplainableBoostingMachineRegression.cs
index 7007ed5f15..fd19c5db00 100644
--- a/src/Regression/ExplainableBoostingMachineRegression.cs
+++ b/src/Regression/ExplainableBoostingMachineRegression.cs
@@ -66,7 +66,7 @@ namespace AiDotNet.Regression;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
 [ResearchPaper("Intelligible Models for HealthCare: Predicting Pneumonia Risk and Hospital 30-day Readmission", "https://doi.org/10.1145/2783258.2788613", Year = 2015, Authors = "Rich Caruana, Yin Lou, Johannes Gehrke, Paul Koch, Marc Sturm, Noemie Elhadad")]
-public class ExplainableBoostingMachineRegression<T> : AsyncDecisionTreeRegressionBase<T>
+public partial class ExplainableBoostingMachineRegression<T> : AsyncDecisionTreeRegressionBase<T>
 {
     /// <summary>
     /// Shape functions for each feature (additive terms).
@@ -614,144 +614,4 @@ public override ModelMetadata<T> GetModelMetadata()
             }
         };
     }
-
-    /// <inheritdoc/>
-    public override byte[] Serialize()
-    {
-        using var ms = new MemoryStream();
-        using var writer = new BinaryWriter(ms);
-
-        byte[] baseData = base.Serialize();
-        writer.Write(baseData.Length);
-        writer.Write(baseData);
-
-        // Options
-        writer.Write(_options.NumberOfOuterIterations);
-        writer.Write(_options.LearningRate);
-        writer.Write(_options.MaxBins);
-        writer.Write(_options.DetectInteractions);
-
-        // Model state
-        writer.Write(_numFeatures);
-        writer.Write(NumOps.ToDouble(_intercept));
-
-        // Bin edges
-        for (int f = 0; f < _numFeatures; f++)
-        {
-            writer.Write(_binEdges[f].Length);
-            for (int e = 0; e < _binEdges[f].Length; e++)
-            {
-                writer.Write(NumOps.ToDouble(_binEdges[f][e]));
-            }
-        }
-
-        // Shape functions
-        for (int f = 0; f < _numFeatures; f++)
-        {
-            writer.Write(_shapeFunctions[f].Length);
-            for (int b = 0; b < _shapeFunctions[f].Length; b++)
-            {
-                writer.Write(NumOps.ToDouble(_shapeFunctions[f][b]));
-            }
-        }
-
-        // Interactions
-        writer.Write(_interactionTerms.Count);
-        foreach (var ((f1, f2), matrix) in _interactionTerms)
-        {
-            writer.Write(f1);
-            writer.Write(f2);
-            writer.Write(matrix.Rows);
-            writer.Write(matrix.Columns);
-            for (int b1 = 0; b1 < matrix.Rows; b1++)
-            {
-                for (int b2 = 0; b2 < matrix.Columns; b2++)
-                {
-                    writer.Write(NumOps.ToDouble(matrix[b1, b2]));
-                }
-            }
-        }
-
-        return ms.ToArray();
-    }
-
-    /// <inheritdoc/>
-    public override void Deserialize(byte[] modelData)
-    {
-        using var ms = new MemoryStream(modelData);
-        using var reader = new BinaryReader(ms);
-
-        int baseLen = reader.ReadInt32();
-        byte[] baseData = reader.ReadBytes(baseLen);
-        base.Deserialize(baseData);
-
-        // Options
-        _options.NumberOfOuterIterations = reader.ReadInt32();
-        _options.LearningRate = reader.ReadDouble();
-        _options.MaxBins = reader.ReadInt32();
-        _options.DetectInteractions = reader.ReadBoolean();
-
-        // Model state
-        _numFeatures = reader.ReadInt32();
-        _intercept = NumOps.FromDouble(reader.ReadDouble());
-
-        // Bin edges
-        _binEdges = new List<Vector<T>>(_numFeatures);
-        for (int f = 0; f < _numFeatures; f++)
-        {
-            int numEdges = reader.ReadInt32();
-            var edges = new Vector<T>(numEdges);
-            for (int e = 0; e < numEdges; e++)
-            {
-                edges[e] = NumOps.FromDouble(reader.ReadDouble());
-            }
-            _binEdges.Add(edges);
-        }
-
-        // Shape functions
-        _shapeFunctions = new List<Vector<T>>(_numFeatures);
-        for (int f = 0; f < _numFeatures; f++)
-        {
-            int numBins = reader.ReadInt32();
-            var sf = new Vector<T>(numBins);
-            for (int b = 0; b < numBins; b++)
-            {
-                sf[b] = NumOps.FromDouble(reader.ReadDouble());
-            }
-            _shapeFunctions.Add(sf);
-        }
-
-        // Interactions
-        _interactionTerms = new Dictionary<(int, int), Matrix<T>>();
-        int numInteractions = reader.ReadInt32();
-        for (int i = 0; i < numInteractions; i++)
-        {
-            int f1 = reader.ReadInt32();
-            int f2 = reader.ReadInt32();
-            int rows = reader.ReadInt32();
-            int cols = reader.ReadInt32();
-            var matrix = new Matrix<T>(rows, cols);
-            for (int b1 = 0; b1 < rows; b1++)
-            {
-                for (int b2 = 0; b2 < cols; b2++)
-                {
-                    matrix[b1, b2] = NumOps.FromDouble(reader.ReadDouble());
-                }
-            }
-            _interactionTerms[(f1, f2)] = matrix;
-        }
-    }
-
-    /// <inheritdoc/>
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        return new ExplainableBoostingMachineRegression<T>(_options, Regularization);
-    }
-
-    public override IFullModel<T, Matrix<T>, Vector<T>> Clone()
-    {
-        var clone = new ExplainableBoostingMachineRegression<T>(_options, Regularization);
-        clone.Deserialize(Serialize());
-        return clone;
-    }
 }
diff --git a/src/Regression/ExtremelyRandomizedTreesRegression.cs b/src/Regression/ExtremelyRandomizedTreesRegression.cs
index f6b062d039..ca9a89ebe7 100644
--- a/src/Regression/ExtremelyRandomizedTreesRegression.cs
+++ b/src/Regression/ExtremelyRandomizedTreesRegression.cs
@@ -56,7 +56,7 @@ namespace AiDotNet.Regression;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
 [ResearchPaper("Extremely randomized trees", "https://doi.org/10.1007/s10994-006-6226-1", Year = 2006, Authors = "Pierre Geurts, Damien Ernst, Louis Wehenkel")]
-public class ExtremelyRandomizedTreesRegression<T> : AsyncDecisionTreeRegressionBase<T>
+public partial class ExtremelyRandomizedTreesRegression<T> : AsyncDecisionTreeRegressionBase<T>
 {
     /// <summary>
     /// Initializes a new instance with default settings.
@@ -373,189 +373,6 @@ public override ModelMetadata<T> GetModelMetadata()
         return metadata;
     }
 
-    /// <summary>
-    /// Serializes the Extremely Randomized Trees model to a byte array for storage or transmission.
-    /// </summary>
-    /// <returns>A byte array containing the serialized model.</returns>
-    /// <remarks>
-    /// <para>
-    /// This method converts the Extremely Randomized Trees model into a byte array that can be stored in a file,
-    /// database, or transmitted over a network. The serialized data includes the model's configuration options,
-    /// feature importances, and all individual decision trees in the ensemble.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method saves your trained model as a sequence of bytes.
-    /// 
-    /// Serialization allows you to:
-    /// - Save your model to a file
-    /// - Store your model in a database
-    /// - Send your model over a network
-    /// - Keep your model for later use without having to retrain it
-    /// 
-    /// The serialized data includes:
-    /// - All the model's settings (like number of trees and maximum depth)
-    /// - The importance of each feature
-    /// - Every individual decision tree in the ensemble
-    /// 
-    /// Because Extremely Randomized Trees models contain multiple trees, the serialized data
-    /// can be quite large compared to a single decision tree model.
-    /// 
-    /// Example:
-    /// ```csharp
-    /// // Serialize the model
-    /// byte[] modelData = extraTrees.Serialize();
-    /// 
-    /// // Save to a file
-    /// File.WriteAllBytes("extraTrees.model", modelData);
-    /// ```
-    /// </para>
-    /// </remarks>
-    public override byte[] Serialize()
-    {
-        using var ms = new MemoryStream();
-        using var writer = new BinaryWriter(ms);
-
-        // Serialize options
-        writer.Write(_options.NumberOfTrees);
-        writer.Write(_options.MaxDepth);
-        writer.Write(_options.MinSamplesSplit);
-        writer.Write(_options.MaxFeatures);
-        writer.Write(_options.Seed ?? -1);
-        writer.Write((int)_options.SplitCriterion);
-        writer.Write(_options.MaxDegreeOfParallelism);
-
-        // Serialize feature importances
-        writer.Write(FeatureImportances.Length);
-        foreach (var importance in FeatureImportances)
-        {
-            writer.Write(Convert.ToDouble(importance));
-        }
-
-        // Serialize trees
-        writer.Write(_trees.Count);
-        foreach (var tree in _trees)
-        {
-            var treeData = tree.Serialize();
-            writer.Write(treeData.Length);
-            writer.Write(treeData);
-        }
-
-        return ms.ToArray();
-    }
-
-    /// <summary>
-    /// Loads a previously serialized Extremely Randomized Trees model from a byte array.
-    /// </summary>
-    /// <param name="modelData">The byte array containing the serialized model.</param>
-    /// <remarks>
-    /// <para>
-    /// This method reconstructs an Extremely Randomized Trees model from a byte array that was previously created
-    /// using the Serialize method. It restores the model's configuration options, feature importances, and all
-    /// individual decision trees in the ensemble, allowing the model to be used for predictions without retraining.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method loads a previously saved model from a sequence of bytes.
-    /// 
-    /// Deserialization allows you to:
-    /// - Load a model that was saved earlier
-    /// - Use a model without having to retrain it
-    /// - Share models between different applications
-    /// 
-    /// When you deserialize an Extremely Randomized Trees model:
-    /// - All settings are restored
-    /// - Feature importances are recovered
-    /// - All individual trees in the ensemble are reconstructed
-    /// - The model is ready to make predictions immediately
-    /// 
-    /// Example:
-    /// ```csharp
-    /// // Load from a file
-    /// byte[] modelData = File.ReadAllBytes("extraTrees.model");
-    /// 
-    /// // Deserialize the model
-    /// var extraTrees = new ExtremelyRandomizedTreesRegression&lt;double&gt;(options);
-    /// extraTrees.Deserialize(modelData);
-    /// 
-    /// // Now you can use the model for predictions
-    /// var predictions = await extraTrees.PredictAsync(newFeatures);
-    /// ```
-    /// </para>
-    /// </remarks>
-    public override void Deserialize(byte[] modelData)
-    {
-        using var ms = new MemoryStream(modelData);
-        using var reader = new BinaryReader(ms);
-
-        // Deserialize options
-        _options.NumberOfTrees = reader.ReadInt32();
-        _options.MaxDepth = reader.ReadInt32();
-        _options.MinSamplesSplit = reader.ReadInt32();
-        _options.MaxFeatures = reader.ReadDouble();
-        int seed = reader.ReadInt32();
-        _options.Seed = seed == -1 ? null : seed;
-        _options.SplitCriterion = (SplitCriterion)reader.ReadInt32();
-        _options.MaxDegreeOfParallelism = reader.ReadInt32();
-
-        // Deserialize feature importances
-        int featureCount = reader.ReadInt32();
-        var importances = new T[featureCount];
-        for (int i = 0; i < featureCount; i++)
-        {
-            importances[i] = NumOps.FromDouble(reader.ReadDouble());
-        }
-        FeatureImportances = new Vector<T>(importances);
-
-        // Deserialize trees
-        int treeCount = reader.ReadInt32();
-        _trees = new List<DecisionTreeRegression<T>>(treeCount);
-        for (int i = 0; i < treeCount; i++)
-        {
-            int treeDataLength = reader.ReadInt32();
-            byte[] treeData = reader.ReadBytes(treeDataLength);
-            var tree = new DecisionTreeRegression<T>(new DecisionTreeOptions(), Regularization);
-            tree.Deserialize(treeData);
-            _trees.Add(tree);
-        }
-
-        _random = _options.Seed.HasValue ? RandomHelper.CreateSeededRandom(_options.Seed.Value) : RandomHelper.CreateSecureRandom();
-    }
-
-    /// <summary>
-    /// Creates a new instance of the extremely randomized trees regression model with the same configuration.
-    /// </summary>
-    /// <returns>
-    /// A new instance of <see cref="ExtremelyRandomizedTreesRegression{T}"/> with the same configuration as the current instance.
-    /// </returns>
-    /// <remarks>
-    /// <para>
-    /// This method creates a new extremely randomized trees regression model that has the same configuration 
-    /// as the current instance. It's used for model persistence, cloning, and transferring the model's 
-    /// configuration to new instances.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method makes a fresh copy of the current model with the same settings.
-    /// 
-    /// It's like making a blueprint copy of your model that can be used to:
-    /// - Save your model's settings
-    /// - Create a new identical model
-    /// - Transfer your model's configuration to another system
-    /// 
-    /// This is useful when you want to:
-    /// - Create multiple similar models
-    /// - Save a model's configuration for later use
-    /// - Reset a model while keeping its settings
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        // Create and return a new instance with the same configuration
-        return new ExtremelyRandomizedTreesRegression<T>(_options, Regularization);
-    }
-
-    public override IFullModel<T, Matrix<T>, Vector<T>> Clone()
-    {
-        var clone = new ExtremelyRandomizedTreesRegression<T>(_options, Regularization);
-        clone.Deserialize(Serialize());
-        return clone;
-    }
-
     /// <summary>
     /// Returns all features up to the number of features used during training.
     /// </summary>
diff --git a/src/Regression/GAMLSSRegression.cs b/src/Regression/GAMLSSRegression.cs
index 2d275c519c..580b8e30f2 100644
--- a/src/Regression/GAMLSSRegression.cs
+++ b/src/Regression/GAMLSSRegression.cs
@@ -65,7 +65,7 @@ namespace AiDotNet.Regression;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
 [ResearchPaper("Generalized additive models for location, scale and shape", "https://doi.org/10.1111/j.1467-9876.2005.00510.x", Year = 2005, Authors = "Robert A. Rigby, D. Mikis Stasinopoulos")]
-public class GAMLSSRegression<T> : AsyncDecisionTreeRegressionBase<T>
+public partial class GAMLSSRegression<T> : AsyncDecisionTreeRegressionBase<T>
 {
     // Bounds on the scale/shape linear predictors (log-link parameters such as σ and ν).
     // The RS algorithm of Rigby &amp; Stasinopoulos (2005), like the reference gamlss R package,
@@ -82,16 +82,19 @@ public class GAMLSSRegression<T> : AsyncDecisionTreeRegressionBase<T>
     /// <summary>
     /// Coefficients for the location parameter model.
     /// </summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T>? _locationCoefficients;
 
     /// <summary>
     /// Coefficients for the scale parameter model.
     /// </summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T>? _scaleCoefficients;
 
     /// <summary>
     /// Coefficients for the shape parameter model (if applicable).
     /// </summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T>? _shapeCoefficients;
 
     /// <summary>
@@ -766,40 +769,6 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    /// <inheritdoc/>
-    public override byte[] Serialize()
-    {
-        using var ms = new MemoryStream();
-        using var writer = new BinaryWriter(ms);
-
-        byte[] baseData = base.Serialize();
-        writer.Write(baseData.Length);
-        writer.Write(baseData);
-
-        // Options
-        writer.Write((int)_options.DistributionFamily);
-        writer.Write((int)_options.LocationModelType);
-        writer.Write((int)_options.ScaleModelType);
-        writer.Write((int)_options.ShapeModelType);
-
-        // Y standardization
-        writer.Write(NumOps.ToDouble(_yMean));
-        writer.Write(NumOps.ToDouble(_yStd));
-
-        // State
-        writer.Write(_numFeatures);
-        writer.Write(NumOps.ToDouble(_locationIntercept));
-        writer.Write(NumOps.ToDouble(_scaleIntercept));
-        writer.Write(NumOps.ToDouble(_shapeIntercept));
-
-        // Coefficients
-        SerializeVector(writer, _locationCoefficients);
-        SerializeVector(writer, _scaleCoefficients);
-        SerializeVector(writer, _shapeCoefficients);
-
-        return ms.ToArray();
-    }
-
     private void SerializeVector(BinaryWriter writer, Vector<T>? vec)
     {
         writer.Write(vec != null);
@@ -813,38 +782,6 @@ private void SerializeVector(BinaryWriter writer, Vector<T>? vec)
         }
     }
 
-    /// <inheritdoc/>
-    public override void Deserialize(byte[] modelData)
-    {
-        using var ms = new MemoryStream(modelData);
-        using var reader = new BinaryReader(ms);
-
-        int baseLen = reader.ReadInt32();
-        byte[] baseData = reader.ReadBytes(baseLen);
-        base.Deserialize(baseData);
-
-        // Options
-        _options.DistributionFamily = (GAMLSSDistributionFamily)reader.ReadInt32();
-        _options.LocationModelType = (GAMLSSModelType)reader.ReadInt32();
-        _options.ScaleModelType = (GAMLSSModelType)reader.ReadInt32();
-        _options.ShapeModelType = (GAMLSSModelType)reader.ReadInt32();
-
-        // Y standardization
-        _yMean = NumOps.FromDouble(reader.ReadDouble());
-        _yStd = NumOps.FromDouble(reader.ReadDouble());
-
-        // State
-        _numFeatures = reader.ReadInt32();
-        _locationIntercept = NumOps.FromDouble(reader.ReadDouble());
-        _scaleIntercept = NumOps.FromDouble(reader.ReadDouble());
-        _shapeIntercept = NumOps.FromDouble(reader.ReadDouble());
-
-        // Coefficients
-        _locationCoefficients = DeserializeVector(reader);
-        _scaleCoefficients = DeserializeVector(reader);
-        _shapeCoefficients = DeserializeVector(reader);
-    }
-
     private Vector<T>? DeserializeVector(BinaryReader reader)
     {
         bool hasValue = reader.ReadBoolean();
@@ -859,20 +796,4 @@ public override void Deserialize(byte[] modelData)
         return vec;
     }
 
-    /// <inheritdoc/>
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        return new GAMLSSRegression<T>(_options, Regularization);
-    }
-
-    /// <summary>
-    /// Creates a deep copy via serialization to preserve private coefficient state.
-    /// </summary>
-    public override IFullModel<T, Matrix<T>, Vector<T>> Clone()
-    {
-        var clone = new GAMLSSRegression<T>(_options, Regularization);
-        var data = Serialize();
-        clone.Deserialize(data);
-        return clone;
-    }
 }
diff --git a/src/Regression/GammaRegression.cs b/src/Regression/GammaRegression.cs
index e9fabeae0f..99b5eef5ed 100644
--- a/src/Regression/GammaRegression.cs
+++ b/src/Regression/GammaRegression.cs
@@ -63,7 +63,7 @@ namespace AiDotNet.Regression;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
     [ResearchPaper("Generalized Linear Models", "https://doi.org/10.1007/978-1-4899-3242-6")]
-public class GammaRegression<T> : RegressionBase<T>
+public partial class GammaRegression<T> : RegressionBase<T>
 {
     private const double MuFloor = 1e-10;
     private const double MuCeiling = 1e10;
@@ -482,126 +482,4 @@ public override Vector<T> Predict(Matrix<T> x)
             predictions[i] = NumOps.Add(predictions[i], Intercept);
         return predictions;
     }
-
-    /// <summary>
-    /// Serializes the model to a byte array.
-    /// </summary>
-    /// <returns>A byte array containing the serialized model data.</returns>
-    /// <remarks>
-    /// <para>
-    /// This method serializes both the base class data and the Gamma regression specific options,
-    /// including link function, maximum iterations, convergence tolerance, and dispersion parameter.
-    /// </para>
-    /// <para>
-    /// For Beginners:
-    /// Serialization converts the model's internal state into a format that can be saved to disk or
-    /// transmitted over a network. This allows you to save a trained model and load it later without
-    /// having to retrain it. Think of it like saving your progress in a video game.
-    /// </para>
-    /// </remarks>
-    public override byte[] Serialize()
-    {
-        using var ms = new MemoryStream();
-        using var writer = new BinaryWriter(ms);
-
-        // Serialize base class data
-        byte[] baseData = base.Serialize();
-        writer.Write(baseData.Length);
-        writer.Write(baseData);
-
-        // Serialize GammaRegression specific options
-        writer.Write(_options.MaxIterations);
-        writer.Write(_options.Tolerance);
-        writer.Write((int)_options.LinkFunction);
-        writer.Write((int)_options.DecompositionType);
-        writer.Write(_options.InitialDispersion);
-        writer.Write(NumOps.ToDouble(_dispersion));
-
-        return ms.ToArray();
-    }
-
-    /// <summary>
-    /// Deserializes the model from a byte array.
-    /// </summary>
-    /// <param name="data">The byte array containing the serialized model data.</param>
-    /// <remarks>
-    /// <para>
-    /// This method deserializes both the base class data and the Gamma regression specific options,
-    /// reconstructing the model's state from the serialized data.
-    /// </para>
-    /// <para>
-    /// For Beginners:
-    /// Deserialization is the opposite of serialization - it takes the saved model data and reconstructs
-    /// the model's internal state. This allows you to load a previously trained model and use it to make
-    /// predictions without having to retrain it. It's like loading a saved game to continue where you left off.
-    /// </para>
-    /// </remarks>
-    public override void Deserialize(byte[] data)
-    {
-        using var ms = new MemoryStream(data);
-        using var reader = new BinaryReader(ms);
-
-        // Deserialize base class data
-        int baseDataLength = reader.ReadInt32();
-        byte[] baseData = reader.ReadBytes(baseDataLength);
-        base.Deserialize(baseData);
-
-        // Deserialize GammaRegression specific options
-        _options.MaxIterations = reader.ReadInt32();
-        _options.Tolerance = reader.ReadDouble();
-        _options.LinkFunction = (GammaLinkFunction)reader.ReadInt32();
-        _options.DecompositionType = (MatrixDecompositionType)reader.ReadInt32();
-        _options.InitialDispersion = reader.ReadDouble();
-        _dispersion = NumOps.FromDouble(reader.ReadDouble());
-    }
-
-    /// <summary>
-    /// Creates a new instance of the Gamma Regression model with the same configuration.
-    /// </summary>
-    /// <returns>A new instance of the Gamma Regression model.</returns>
-    /// <remarks>
-    /// <para>
-    /// This method creates a deep copy of the current Gamma Regression model, including its options,
-    /// coefficients, intercept, dispersion, and regularization settings.
-    /// </para>
-    /// <para>
-    /// For Beginners:
-    /// This method creates an exact copy of your trained model.
-    ///
-    /// Think of it like making a perfect duplicate:
-    /// - It copies all the configuration settings (like link function, maximum iterations, and tolerance)
-    /// - It preserves the coefficients (the weights for each feature)
-    /// - It maintains the intercept and dispersion parameter
-    ///
-    /// Creating a copy is useful when you want to:
-    /// - Create a backup before further modifying the model
-    /// - Create variations of the same model for different purposes
-    /// - Share the model with others while keeping your original intact
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        var newOptions = new GammaRegressionOptions<T>
-        {
-            MaxIterations = _options.MaxIterations,
-            Tolerance = _options.Tolerance,
-            LinkFunction = _options.LinkFunction,
-            DecompositionType = _options.DecompositionType,
-            InitialDispersion = _options.InitialDispersion
-        };
-
-        var newModel = new GammaRegression<T>(newOptions, Regularization);
-
-        // Copy coefficients if they exist
-        if (Coefficients != null)
-        {
-            newModel.Coefficients = Coefficients.Clone();
-        }
-
-        // Copy the intercept and dispersion
-        newModel.Intercept = Intercept;
-        newModel._dispersion = _dispersion;
-
-        return newModel;
-    }
 }
diff --git a/src/Regression/GaussianProcessRegression.cs b/src/Regression/GaussianProcessRegression.cs
index fd06be2bea..3623f3e0b0 100644
--- a/src/Regression/GaussianProcessRegression.cs
+++ b/src/Regression/GaussianProcessRegression.cs
@@ -60,16 +60,18 @@ namespace AiDotNet.Regression;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
     [ResearchPaper("Gaussian Processes for Machine Learning", "https://gaussianprocess.org/gpml/")]
-public class GaussianProcessRegression<T> : NonLinearRegressionBase<T>
+public partial class GaussianProcessRegression<T> : NonLinearRegressionBase<T>
 {
     /// <summary>
     /// The kernel matrix (also known as the covariance matrix) that represents the similarity between all training points.
     /// </summary>
+    [AiDotNet.Attributes.Buffer]
     private Matrix<T> _kernelMatrix;
 
     /// <summary>
     /// The vector of coefficients used for making predictions.
     /// </summary>
+    [AiDotNet.Attributes.Buffer]
     private Vector<T> _alpha;
 
     /// <summary>
diff --git a/src/Regression/GeneralizedAdditiveModelRegression.cs b/src/Regression/GeneralizedAdditiveModelRegression.cs
index dccfbd84f1..6ec667c48e 100644
--- a/src/Regression/GeneralizedAdditiveModelRegression.cs
+++ b/src/Regression/GeneralizedAdditiveModelRegression.cs
@@ -80,6 +80,7 @@ public partial class GeneralizedAdditiveModel<T> : RegressionBase<T>
     /// <summary>
     /// Vector of model coefficients for the basis functions.
     /// </summary>
+    [Buffer]
     private Vector<T> _coefficients;
     [Buffer]
     private Vector<T> _basisScales = new Vector<T>(0);
@@ -177,6 +178,7 @@ public GeneralizedAdditiveModel(
     public override bool SupportsParameterInitialization => false;
 
     /// <summary>Tracks whether OLS fallback was used.</summary>
+    [Buffer]
     private bool _useOLS;
 
     public override void Train(Matrix<T> x, Vector<T> y)
@@ -498,268 +500,4 @@ protected override Vector<T> CalculateFeatureImportances()
 
         return importances;
     }
-
-    /// <summary>
-    /// Serializes the Generalized Additive Model to a byte array for storage or transmission.
-    /// </summary>
-    /// <returns>A byte array containing the serialized model.</returns>
-    /// <remarks>
-    /// <para>
-    /// This method converts the Generalized Additive Model into a byte array that can be stored in a file, database,
-    /// or transmitted over a network. The serialized data includes the model's configuration options, basis functions,
-    /// and learned coefficients.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method saves your trained model as a sequence of bytes.
-    /// 
-    /// Serialization allows you to:
-    /// - Save your model to a file
-    /// - Store your model in a database
-    /// - Send your model over a network
-    /// - Keep your model for later use without having to retrain it
-    /// 
-    /// The serialized data includes:
-    /// - All the model's settings (like number of splines and their degree)
-    /// - The basis functions used to transform features
-    /// - The coefficients learned during training
-    /// 
-    /// Example:
-    /// ```csharp
-    /// // Serialize the model
-    /// byte[] modelData = gam.Serialize();
-    /// 
-    /// // Save to a file
-    /// File.WriteAllBytes("gam.model", modelData);
-    /// ```
-    /// </para>
-    /// </remarks>
-    public override byte[] Serialize()
-    {
-        using MemoryStream ms = new MemoryStream();
-        using BinaryWriter writer = new BinaryWriter(ms);
-
-        // Write base class data
-        byte[] baseData = base.Serialize();
-        writer.Write(baseData.Length);
-        writer.Write(baseData);
-
-        // OLS flag
-        writer.Write(_useOLS);
-
-        // Write GAM-specific data
-        writer.Write(_options.NumSplines);
-        writer.Write(_options.Degree);
-
-        // Write _basisFunctions
-        writer.Write(_basisFunctions.Rows);
-        writer.Write(_basisFunctions.Columns);
-        for (int i = 0; i < _basisFunctions.Rows; i++)
-        {
-            for (int j = 0; j < _basisFunctions.Columns; j++)
-            {
-                writer.Write(Convert.ToDouble(_basisFunctions[i, j]));
-            }
-        }
-
-        // Write _coefficients
-        writer.Write(_coefficients.Length);
-        for (int i = 0; i < _coefficients.Length; i++)
-        {
-            writer.Write(Convert.ToDouble(_coefficients[i]));
-        }
-
-        // Write _basisScales — the per-column normalization factors FitModel divides the
-        // basis by before solving. Predict re-applies them, so without persisting them a
-        // deserialized model applies spline coefficients to UNSCALED bases and predicts wrong.
-        writer.Write(_basisScales.Length);
-        for (int i = 0; i < _basisScales.Length; i++)
-        {
-            writer.Write(Convert.ToDouble(_basisScales[i]));
-        }
-
-        // Write _trainingKnots — the per-feature knot positions fitted during Train.
-        // Predict reuses these so test-time basis functions live in the same basis
-        // the coefficients were learned over (see CreateBasisFunctions docstring).
-        // Without persisting them, Clone()/Deserialize() can't predict at all (the
-        // Predict path now requires non-null _trainingKnots).
-        // Format: int featureCount; for each feature: int knotCount + knot doubles.
-        // featureCount = -1 marks "never trained" (knots not yet fitted, so the
-        // model can still serialize before the first Train call without writing
-        // a fake empty list — Deserialize restores null in that case).
-        if (_trainingKnots is null)
-        {
-            writer.Write(-1);
-        }
-        else
-        {
-            writer.Write(_trainingKnots.Count);
-            foreach (var perFeatureKnots in _trainingKnots)
-            {
-                writer.Write(perFeatureKnots.Length);
-                for (int i = 0; i < perFeatureKnots.Length; i++)
-                {
-                    writer.Write(Convert.ToDouble(perFeatureKnots[i]));
-                }
-            }
-        }
-
-        return ms.ToArray();
-    }
-
-    /// <summary>
-    /// Loads a previously serialized Generalized Additive Model from a byte array.
-    /// </summary>
-    /// <param name="modelData">The byte array containing the serialized model.</param>
-    /// <remarks>
-    /// <para>
-    /// This method reconstructs a Generalized Additive Model from a byte array that was previously created using the
-    /// Serialize method. It restores the model's configuration options, basis functions, and learned coefficients,
-    /// allowing the model to be used for predictions without retraining.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method loads a previously saved model from a sequence of bytes.
-    /// 
-    /// Deserialization allows you to:
-    /// - Load a model that was saved earlier
-    /// - Use a model without having to retrain it
-    /// - Share models between different applications
-    /// 
-    /// When you deserialize a model:
-    /// - All settings are restored
-    /// - The basis functions are reconstructed
-    /// - The learned coefficients are recovered
-    /// - The model is ready to make predictions immediately
-    /// 
-    /// Example:
-    /// ```csharp
-    /// // Load from a file
-    /// byte[] modelData = File.ReadAllBytes("gam.model");
-    /// 
-    /// // Deserialize the model
-    /// var gam = new GeneralizedAdditiveModel&lt;double&gt;();
-    /// gam.Deserialize(modelData);
-    /// 
-    /// // Now you can use the model for predictions
-    /// var predictions = gam.Predict(newFeatures);
-    /// ```
-    /// </para>
-    /// </remarks>
-    public override void Deserialize(byte[] modelData)
-    {
-        using MemoryStream ms = new MemoryStream(modelData);
-        using BinaryReader reader = new BinaryReader(ms);
-
-        // Read base class data
-        int baseDataLength = reader.ReadInt32();
-        byte[] baseData = reader.ReadBytes(baseDataLength);
-        base.Deserialize(baseData);
-
-        // OLS flag
-        _useOLS = reader.ReadBoolean();
-
-        // Read GAM-specific data
-        _options.NumSplines = reader.ReadInt32();
-        _options.Degree = reader.ReadInt32();
-
-        // Read _basisFunctions
-        int rows = reader.ReadInt32();
-        int cols = reader.ReadInt32();
-        _basisFunctions = new Matrix<T>(rows, cols);
-        for (int i = 0; i < rows; i++)
-        {
-            for (int j = 0; j < cols; j++)
-            {
-                _basisFunctions[i, j] = NumOps.FromDouble(reader.ReadDouble());
-            }
-        }
-
-        // Read _coefficients
-        int length = reader.ReadInt32();
-        _coefficients = new Vector<T>(length);
-        for (int i = 0; i < length; i++)
-        {
-            _coefficients[i] = NumOps.FromDouble(reader.ReadDouble());
-        }
-
-        // Read _basisScales (see Serialize) so Predict scales inputs identically post-load.
-        // Guard for backward compatibility: payloads serialized before _basisScales
-        // was persisted have no trailing block, so fall back to unit scales (no-op
-        // scaling) when the stream is already exhausted.
-        if (ms.Position < ms.Length)
-        {
-            int scaleLen = reader.ReadInt32();
-            if (scaleLen < 0)
-                throw new InvalidDataException("Invalid GAM basis-scale length in serialized payload.");
-            _basisScales = new Vector<T>(scaleLen);
-            for (int i = 0; i < scaleLen; i++)
-            {
-                _basisScales[i] = NumOps.FromDouble(reader.ReadDouble());
-            }
-        }
-        else
-        {
-            _basisScales = new Vector<T>(_basisFunctions.Columns);
-            for (int i = 0; i < _basisScales.Length; i++)
-            {
-                _basisScales[i] = NumOps.One;
-            }
-        }
-
-        // Read _trainingKnots (see Serialize) so post-deserialize Predict uses the
-        // same knots Train fitted. Same backward-compat guard as _basisScales:
-        // pre-knot-persistence payloads simply lack this block.
-        if (ms.Position < ms.Length)
-        {
-            int featureCount = reader.ReadInt32();
-            if (featureCount < 0)
-            {
-                _trainingKnots = null;
-            }
-            else
-            {
-                _trainingKnots = new List<Vector<T>>(featureCount);
-                for (int f = 0; f < featureCount; f++)
-                {
-                    int knotCount = reader.ReadInt32();
-                    if (knotCount < 0)
-                        throw new InvalidDataException("Invalid GAM knot-count in serialized payload.");
-                    var knots = new Vector<T>(knotCount);
-                    for (int k = 0; k < knotCount; k++)
-                    {
-                        knots[k] = NumOps.FromDouble(reader.ReadDouble());
-                    }
-                    _trainingKnots.Add(knots);
-                }
-            }
-        }
-        else
-        {
-            _trainingKnots = null;
-        }
-    }
-
-    /// <summary>
-    /// Creates a new instance of the GeneralizedAdditiveModel with the same configuration as the current instance.
-    /// </summary>
-    /// <returns>A new GeneralizedAdditiveModel instance with the same options and regularization as the current instance.</returns>
-    /// <remarks>
-    /// <para>
-    /// This method creates a new instance of the GeneralizedAdditiveModel with the same configuration options
-    /// and regularization settings as the current instance. This is useful for model cloning, ensemble methods, or
-    /// cross-validation scenarios where multiple instances of the same model with identical configurations are needed.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method creates a fresh copy of the model's blueprint.
-    /// 
-    /// When you need multiple versions of the same type of model with identical settings:
-    /// - This method creates a new, empty model with the same configuration
-    /// - It's like making a copy of a recipe before you start cooking
-    /// - The new model has the same settings but no trained data
-    /// - This is useful for techniques that need multiple models, like cross-validation
-    /// 
-    /// For example, when testing your model on different subsets of data,
-    /// you'd want each test to use a model with identical settings.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        return new GeneralizedAdditiveModel<T>(_options, Regularization);
-    }
 }
diff --git a/src/Regression/GeneticAlgorithmRegression.cs b/src/Regression/GeneticAlgorithmRegression.cs
index c834f6dce8..888efb2b25 100644
--- a/src/Regression/GeneticAlgorithmRegression.cs
+++ b/src/Regression/GeneticAlgorithmRegression.cs
@@ -318,174 +318,4 @@ private void UpdateCoefficientsAndIntercept()
             Intercept = NumOps.Zero;
         }
     }
-
-    /// <summary>
-    /// Serializes the Genetic Algorithm Regression model to a byte array for storage or transmission.
-    /// </summary>
-    /// <returns>A byte array containing the serialized model.</returns>
-    /// <remarks>
-    /// <para>
-    /// This method converts the Genetic Algorithm Regression model into a byte array that can be stored in a file,
-    /// database, or transmitted over a network. The serialized data includes the base regression model data,
-    /// the best model coefficients found by the genetic algorithm, and the genetic algorithm configuration options.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method saves your trained model as a sequence of bytes.
-    /// 
-    /// Serialization allows you to:
-    /// - Save your model to a file
-    /// - Store your model in a database
-    /// - Send your model over a network
-    /// - Keep your model for later use without having to retrain it
-    /// 
-    /// The serialized data includes:
-    /// - The model coefficients discovered by the genetic algorithm
-    /// - Settings like population size and mutation rate
-    /// - Other information needed to recreate the exact same model
-    /// 
-    /// Example:
-    /// ```csharp
-    /// // Serialize the model
-    /// byte[] modelData = gaRegression.Serialize();
-    /// 
-    /// // Save to a file
-    /// File.WriteAllBytes("gaRegression.model", modelData);
-    /// ```
-    /// </para>
-    /// </remarks>
-    public override byte[] Serialize()
-    {
-        using var ms = new MemoryStream();
-        using var writer = new BinaryWriter(ms);
-
-        // Serialize base class data
-        byte[] baseData = base.Serialize();
-        writer.Write(baseData.Length);
-        writer.Write(baseData);
-
-        // Serialize GeneticAlgorithmRegression specific data
-        var parameters = (_bestModel as IParameterizable<T, Matrix<T>, Vector<T>>)?.GetParameters() ?? Vector<T>.Empty();
-        writer.Write(parameters.Length);
-        for (int i = 0; i < parameters.Length; i++)
-        {
-            writer.Write(Convert.ToDouble(parameters[i]));
-        }
-
-        // Serialize GeneticAlgorithmOptions
-        var gaOptions = _gaOptions;
-        writer.Write(gaOptions.MaxGenerations);
-        writer.Write(gaOptions.PopulationSize);
-        writer.Write(gaOptions.MutationRate);
-        writer.Write(gaOptions.CrossoverRate);
-
-        return ms.ToArray();
-    }
-
-    /// <summary>
-    /// Loads a previously serialized Genetic Algorithm Regression model from a byte array.
-    /// </summary>
-    /// <param name="modelData">The byte array containing the serialized model.</param>
-    /// <remarks>
-    /// <para>
-    /// This method reconstructs a Genetic Algorithm Regression model from a byte array that was previously created
-    /// using the Serialize method. It restores the base regression model data, the best model coefficients found
-    /// by the genetic algorithm, and the genetic algorithm configuration options, allowing the model to be used
-    /// for predictions without retraining.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method loads a previously saved model from a sequence of bytes.
-    /// 
-    /// Deserialization allows you to:
-    /// - Load a model that was saved earlier
-    /// - Use a model without having to retrain it
-    /// - Share models between different applications
-    /// 
-    /// When you deserialize a model:
-    /// - All settings are restored
-    /// - The best solution found by the genetic algorithm is recovered
-    /// - The model is ready to make predictions immediately
-    /// 
-    /// Example:
-    /// ```csharp
-    /// // Load from a file
-    /// byte[] modelData = File.ReadAllBytes("gaRegression.model");
-    /// 
-    /// // Deserialize the model
-    /// var gaRegression = new GeneticAlgorithmRegression&lt;double&gt;();
-    /// gaRegression.Deserialize(modelData);
-    /// 
-    /// // Now you can use the model for predictions
-    /// var predictions = gaRegression.Predict(newFeatures);
-    /// ```
-    /// </para>
-    /// </remarks>
-    public override void Deserialize(byte[] modelData)
-    {
-        using var ms = new MemoryStream(modelData);
-        using var reader = new BinaryReader(ms);
-
-        // Deserialize base class data
-        int baseDataLength = reader.ReadInt32();
-        byte[] baseData = reader.ReadBytes(baseDataLength);
-        base.Deserialize(baseData);
-
-        // Deserialize GeneticAlgorithmRegression specific data
-        int coefficientsLength = reader.ReadInt32();
-        var coefficients = new T[coefficientsLength];
-        for (int i = 0; i < coefficientsLength; i++)
-        {
-            coefficients[i] = NumOps.FromDouble(reader.ReadDouble());
-        }
-        _bestModel = new VectorModel<T>(new Vector<T>(coefficients));
-
-        // Deserialize GeneticAlgorithmOptions
-        var gaOptions = new GeneticAlgorithmOptimizerOptions<T, Matrix<T>, Vector<T>>
-        {
-            MaxGenerations = reader.ReadInt32(),
-            PopulationSize = reader.ReadInt32(),
-            MutationRate = reader.ReadDouble(),
-            CrossoverRate = reader.ReadDouble()
-        };
-
-        // Recreate the optimizer with the deserialized options
-        if (_bestModel == null)
-        {
-            throw new InvalidOperationException("Deserialization failed: _bestModel is null. Model coefficients may be missing or corrupted.");
-        }
-        _optimizer = new GeneticAlgorithmOptimizer<T, Matrix<T>, Vector<T>>(_bestModel, gaOptions);
-
-        // Update coefficients and intercept
-        UpdateCoefficientsAndIntercept();
-    }
-
-    /// <summary>
-    /// Creates a new instance of the GeneticAlgorithmRegression with the same configuration as the current instance.
-    /// </summary>
-    /// <returns>A new GeneticAlgorithmRegression instance with the same options and components as the current instance.</returns>
-    /// <remarks>
-    /// <para>
-    /// This method creates a new instance of the GeneticAlgorithmRegression model with the same configuration options,
-    /// regularization settings, and preprocessing components as the current instance. This is useful for model cloning,
-    /// ensemble methods, or cross-validation scenarios where multiple instances of the same model with identical
-    /// configurations are needed.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method creates a fresh copy of the model's blueprint.
-    /// 
-    /// When you need multiple versions of the same type of model with identical settings:
-    /// - This method creates a new, empty model with the same configuration
-    /// - It's like making a copy of a recipe before you start cooking
-    /// - The new model has the same settings but no trained data
-    /// - This is useful for techniques that need multiple models, like cross-validation
-    /// 
-    /// For example, when testing your model on different subsets of data,
-    /// you'd want each test to use a model with identical settings.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        return new GeneticAlgorithmRegression<T>(
-            Options,
-            _gaOptions,
-            Regularization,
-            _outlierRemoval,
-            _preprocessingPipeline);
-    }
 }
diff --git a/src/Regression/GradientBoostingRegression.cs b/src/Regression/GradientBoostingRegression.cs
index 12de812943..a27e1de682 100644
--- a/src/Regression/GradientBoostingRegression.cs
+++ b/src/Regression/GradientBoostingRegression.cs
@@ -60,7 +60,7 @@ namespace AiDotNet.Regression;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
 [ResearchPaper("Greedy Function Approximation: A Gradient Boosting Machine", "https://doi.org/10.1214/aos/1013203451", Year = 2001, Authors = "Jerome H. Friedman")]
-public class GradientBoostingRegression<T> : AsyncDecisionTreeRegressionBase<T>
+public partial class GradientBoostingRegression<T> : AsyncDecisionTreeRegressionBase<T>
 {
     /// <summary>
     /// Collection of decision trees that make up the ensemble.
@@ -396,165 +396,6 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    /// <summary>
-    /// Serializes the Gradient Boosting Regression model to a byte array for storage or transmission.
-    /// </summary>
-    /// <returns>A byte array containing the serialized model.</returns>
-    /// <remarks>
-    /// <para>
-    /// This method converts the Gradient Boosting Regression model into a byte array that can be stored in a file,
-    /// database, or transmitted over a network. The serialized data includes the base class data, model-specific
-    /// options, the initial prediction, and all the trees in the ensemble.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method saves your trained model as a sequence of bytes.
-    /// 
-    /// Serialization allows you to:
-    /// - Save your model to a file
-    /// - Store your model in a database
-    /// - Send your model over a network
-    /// - Keep your model for later use without having to retrain it
-    /// 
-    /// The serialized data includes:
-    /// - All the model's settings (like number of trees and learning rate)
-    /// - The initial prediction (the starting point for all predictions)
-    /// - Every individual decision tree in the ensemble
-    /// 
-    /// Because Gradient Boosting models contain multiple trees, the serialized data
-    /// can be quite large for complex models.
-    /// 
-    /// Example:
-    /// ```csharp
-    /// // Serialize the model
-    /// byte[] modelData = gbr.Serialize();
-    /// 
-    /// // Save to a file
-    /// File.WriteAllBytes("gradientBoosting.model", modelData);
-    /// ```
-    /// </para>
-    /// </remarks>
-    public override byte[] Serialize()
-    {
-        using var ms = new MemoryStream();
-        using var writer = new BinaryWriter(ms);
-        // Serialize base class data
-        byte[] baseData = base.Serialize();
-        writer.Write(baseData.Length);
-        writer.Write(baseData);
-
-        // Serialize GradientBoostingRegression specific data
-        writer.Write(_options.NumberOfTrees);
-        writer.Write(_options.LearningRate);
-        writer.Write(_options.SubsampleRatio);
-        writer.Write(Convert.ToDouble(_initialPrediction));
-
-        // Serialize trees
-        writer.Write(_trees.Count);
-        foreach (var tree in _trees)
-        {
-            byte[] treeData = tree.Serialize();
-            writer.Write(treeData.Length);
-            writer.Write(treeData);
-        }
-
-        return ms.ToArray();
-    }
-
-    /// <summary>
-    /// Loads a previously serialized Gradient Boosting Regression model from a byte array.
-    /// </summary>
-    /// <param name="modelData">The byte array containing the serialized model.</param>
-    /// <remarks>
-    /// <para>
-    /// This method reconstructs a Gradient Boosting Regression model from a byte array that was previously created
-    /// using the Serialize method. It restores the base class data, model-specific options, the initial prediction,
-    /// and all the trees in the ensemble, allowing the model to be used for predictions without retraining.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method loads a previously saved model from a sequence of bytes.
-    /// 
-    /// Deserialization allows you to:
-    /// - Load a model that was saved earlier
-    /// - Use a model without having to retrain it
-    /// - Share models between different applications
-    /// 
-    /// When you deserialize a model:
-    /// - All settings are restored
-    /// - The initial prediction is recovered
-    /// - All the individual trees are reconstructed
-    /// - The model is ready to make predictions immediately
-    /// 
-    /// Example:
-    /// ```csharp
-    /// // Load from a file
-    /// byte[] modelData = File.ReadAllBytes("gradientBoosting.model");
-    /// 
-    /// // Deserialize the model
-    /// var gbr = new GradientBoostingRegression&lt;double&gt;();
-    /// gbr.Deserialize(modelData);
-    /// 
-    /// // Now you can use the model for predictions
-    /// var predictions = await gbr.PredictAsync(newFeatures);
-    /// ```
-    /// </para>
-    /// </remarks>
-    public override void Deserialize(byte[] modelData)
-    {
-        using var ms = new MemoryStream(modelData);
-        using var reader = new BinaryReader(ms);
-        // Deserialize base class data
-        int baseDataLength = reader.ReadInt32();
-        byte[] baseData = reader.ReadBytes(baseDataLength);
-        base.Deserialize(baseData);
-
-        // Deserialize GradientBoostingRegression specific data
-        _options.NumberOfTrees = reader.ReadInt32();
-        _options.LearningRate = reader.ReadDouble();
-        _options.SubsampleRatio = reader.ReadDouble();
-        _initialPrediction = NumOps.FromDouble(reader.ReadDouble());
-
-        // Deserialize trees
-        int treeCount = reader.ReadInt32();
-        _trees = new List<DecisionTreeRegression<T>>(treeCount);
-        for (int i = 0; i < treeCount; i++)
-        {
-            int treeDataLength = reader.ReadInt32();
-            byte[] treeData = reader.ReadBytes(treeDataLength);
-            var tree = new DecisionTreeRegression<T>(new DecisionTreeOptions());
-            tree.Deserialize(treeData);
-            _trees.Add(tree);
-        }
-    }
-
-    /// <summary>
-    /// Creates a new instance of the gradient boosting regression model with the same configuration.
-    /// </summary>
-    /// <returns>
-    /// A new instance of <see cref="GradientBoostingRegression{T}"/> with the same configuration as the current instance.
-    /// </returns>
-    /// <remarks>
-    /// <para>
-    /// This method creates a new gradient boosting regression model that has the same configuration 
-    /// as the current instance. It's used for model persistence, cloning, and transferring the model's 
-    /// configuration to new instances.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method makes a fresh copy of the current model with the same settings.
-    /// 
-    /// It's like creating a blueprint copy of your model that can be used to:
-    /// - Save your model's settings
-    /// - Create a new identical model
-    /// - Transfer your model's configuration to another system
-    /// 
-    /// This is useful when you want to:
-    /// - Create multiple similar models
-    /// - Save a model's configuration for later use
-    /// - Reset a model while keeping its settings
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        // Create and return a new instance with the same configuration
-        return new GradientBoostingRegression<T>(_options, Regularization);
-    }
-
     /// <inheritdoc/>
     public override IEnumerable<int> GetActiveFeatureIndices()
     {
@@ -570,17 +411,4 @@ public override IEnumerable<int> GetActiveFeatureIndices()
         return activeFeatures;
     }
 
-    /// <inheritdoc/>
-    public override IFullModel<T, Matrix<T>, Vector<T>> Clone()
-    {
-        var clone = (GradientBoostingRegression<T>)base.Clone();
-        clone._initialPrediction = _initialPrediction;
-        clone._trees = new List<DecisionTreeRegression<T>>(_trees.Count);
-        foreach (var tree in _trees)
-        {
-            clone._trees.Add((DecisionTreeRegression<T>)tree.Clone());
-        }
-        return clone;
-    }
-
 }
diff --git a/src/Regression/HistGradientBoostingRegression.cs b/src/Regression/HistGradientBoostingRegression.cs
index 2b16b2185c..a3900af9da 100644
--- a/src/Regression/HistGradientBoostingRegression.cs
+++ b/src/Regression/HistGradientBoostingRegression.cs
@@ -1,1702 +1,1542 @@
-using AiDotNet.Attributes;
-using AiDotNet.Autodiff;
-using AiDotNet.Enums;
-using AiDotNet.Helpers;
-using AiDotNet.Interfaces;
-using AiDotNet.LinearAlgebra;
-using AiDotNet.LossFunctions;
-using AiDotNet.Models;
-using AiDotNet.Models.Options;
-using AiDotNet.Tensors.Helpers;
-using AiDotNet.Tensors.LinearAlgebra;

+using AiDotNet.Attributes;
+using AiDotNet.Autodiff;
+using AiDotNet.Enums;
+using AiDotNet.Helpers;
+using AiDotNet.Interfaces;
+using AiDotNet.LinearAlgebra;
+using AiDotNet.LossFunctions;
+using AiDotNet.Models;
+using AiDotNet.Models.Options;
+using AiDotNet.Tensors.Helpers;
+using AiDotNet.Tensors.LinearAlgebra;
 using AiDotNet.Models.Parameters;
-
-namespace AiDotNet.Regression;
-
-/// <summary>
-/// Histogram-based Gradient Boosting Regression for fast training on large datasets.
-/// </summary>
-/// <typeparam name="T">The numeric type used for calculations (e.g., float, double).</typeparam>
-/// <remarks>
-/// <para>
-/// Histogram-based Gradient Boosting discretizes continuous features into a fixed number of bins,
-/// then builds histograms of gradients and hessians for each bin. This approach dramatically
-/// reduces the time complexity of finding the best split from O(n*features) to O(bins*features),
-/// making it suitable for large datasets with millions of samples.
-/// </para>
-/// <para>
-/// <b>For Beginners:</b> Traditional gradient boosting looks at every possible split point
-/// for every feature, which is slow for large datasets. Histogram-based methods group similar
-/// values into "bins" first, then only consider splits between bins.
-///
-/// Think of it like sorting students by height:
-/// - Traditional method: Consider every student's exact height as a potential grouping point
-/// - Histogram method: First group students into height ranges (5'0"-5'2", 5'2"-5'4", etc.),
-///   then only consider splitting between groups
-///
-/// This is much faster because there are far fewer groups than individual heights.
-///
-/// Key advantages:
-/// - 10-100x faster than traditional gradient boosting on large datasets
-/// - Memory efficient (stores bin indices, not raw values)
-/// - Handles missing values naturally
-/// - Similar accuracy to traditional methods
-///
-/// This is the same approach used by LightGBM, XGBoost (hist mode), and scikit-learn's
-/// HistGradientBoostingRegressor.
-///
-/// Usage:
-/// <code>
-/// var options = new HistGradientBoostingOptions { NumberOfIterations = 100, LearningRate = 0.1 };
-/// var model = new HistGradientBoostingRegression&lt;double&gt;(options);
-/// model.Train(X, y);
-/// var predictions = model.Predict(X_test);
-/// </code>
-/// </para>
-/// </remarks>
-/// <example>
-/// <code>
-/// // Create a histogram-based gradient boosting regression for fast large-scale training
-/// var options = new HistGradientBoostingOptions&lt;double&gt;();
-/// var model = new HistGradientBoostingRegression&lt;double&gt;(options);
-///
-/// // Prepare training data: 6 samples with 2 features each
-/// var features = Matrix&lt;double&gt;.Build.Dense(6, 2, new double[] {
-///     1, 2,  3, 4,  5, 6,  7, 8,  9, 10,  11, 12 });
-/// var targets = new Vector&lt;double&gt;(new double[] { 3.0, 7.1, 11.0, 15.2, 19.0, 23.1 });
-///
-/// // Train with histogram binning for O(bins*features) split finding
-/// model.Train(features, targets);
-///
-/// // Predict for a new sample
-/// var newSample = Matrix&lt;double&gt;.Build.Dense(1, 2, new double[] { 13, 14 });
-/// var prediction = model.Predict(newSample);
-/// </code>
-/// </example>
-[ModelDomain(ModelDomain.MachineLearning)]
-[ModelCategory(ModelCategory.Ensemble)]
-[ModelCategory(ModelCategory.DecisionTree)]
-[ModelTask(ModelTask.Regression)]
-[ModelComplexity(ModelComplexity.High)]
-[ModelInput(typeof(Matrix<>), typeof(Vector<>))]
-[ResearchPaper("LightGBM: A Highly Efficient Gradient Boosting Decision Tree", "https://papers.nips.cc/paper/6907-lightgbm-a-highly-efficient-gradient-boosting-decision-tree", Year = 2017, Authors = "Guolin Ke, Qi Meng, Thomas Finley, Taifeng Wang, Wei Chen, Weidong Ma, Qiwei Ye, Tie-Yan Liu")]
-public partial class HistGradientBoostingRegression<T> : ModelBase<T, Matrix<T>, Vector<T>>, IConfigurableModel<T>
-{
-    #region Fields
-
-    /// <summary>
-    /// Configuration options for the histogram gradient boosting algorithm.
-    /// </summary>
-    private readonly HistGradientBoostingOptions _options;
-
-    /// <inheritdoc/>
-    public ModelOptions GetOptions() => _options;
-
-    /// <summary>
-    /// Bin thresholds for each feature (jagged array).
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> These are the "boundaries" between bins for each feature.
-    /// For example, if a feature is temperature with thresholds [30, 50, 70, 90],
-    /// then values 0-30 go in bin 0, 30-50 in bin 1, etc.
-    /// </para>
-    /// </remarks>
-    private T[][]? _binThresholds;
-
-    /// <summary>
-    /// Binned feature values for training data.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Instead of storing raw feature values, we store which
-    /// bin each value falls into. This is more memory efficient and faster to process.
-    /// </para>
-    /// </remarks>
-    private byte[,]? _binnedData;
-
-    /// <summary>
-    /// The collection of histogram-based trees.
-    /// </summary>
-    private List<HistTreeNode>? _trees;
-
-    /// <summary>
-    /// The initial prediction (mean of target values).
-    /// </summary>
-    private T _initialPrediction;
-
-    /// <summary>
-    /// Feature importance scores accumulated during training.
-    /// </summary>
-    private T[]? _featureImportances;
-
-    /// <summary>
-    /// Random number generator for subsampling.
-    /// </summary>
-    private readonly Random _random;
-
-    /// <summary>
-    /// Number of features in the training data.
-    /// </summary>
-    private int _numFeatures;
-
-    /// <summary>
-    /// Active feature indices that are actually used by the model.
-    /// </summary>
-    private HashSet<int>? _activeFeatureIndices;
-
-    /// <summary>
-    /// The default loss function for gradient computation.
-    /// </summary>
-    private readonly ILossFunction<T> _defaultLossFunction;
-
-    #endregion
-
-    #region Constructor
-
-    /// <summary>
-    /// Initializes a new instance of the HistGradientBoostingRegression class.
-    /// </summary>
-    /// <param name="options">Configuration options for the algorithm.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Creates a new histogram-based gradient boosting model.
-    /// You can customize the behavior by providing options, or use defaults.
-    ///
-    /// Example with defaults:
-    /// <code>
-    /// var model = new HistGradientBoostingRegression&lt;double&gt;();
-    /// </code>
-    ///
-    /// Example with custom options:
-    /// <code>
-    /// var options = new HistGradientBoostingOptions
-    /// {
-    ///     NumberOfIterations = 200,
-    ///     LearningRate = 0.05,
-    ///     MaxDepth = 4
-    /// };
-    /// var model = new HistGradientBoostingRegression&lt;double&gt;(options);
-    /// </code>
-    /// </para>
-    /// </remarks>
-    public HistGradientBoostingRegression(HistGradientBoostingOptions? options = null)
-    {
-        _options = options ?? new HistGradientBoostingOptions();
-        _initialPrediction = NumOps.Zero;
-        _random = _options.Seed.HasValue
-            ? RandomHelper.CreateSeededRandom(_options.Seed.Value)
-            : RandomHelper.CreateSecureRandom();
-        _defaultLossFunction = new MeanSquaredErrorLoss<T>();
-    }
-
-    // ParameterCount override is below (returns 0 to prevent optimizer parameter injection)
-
-    #endregion
-
-    #region IFullModel Implementation
-
-    /// <summary>
-    /// Gets the model type identifier.
-    /// </summary>
-
-    /// <summary>
-    /// Gets or sets the feature names.
-    /// </summary>
-    public string[]? FeatureNames { get; set; }
-
-    /// <summary>
-    /// Trains the model on the provided data.
-    /// </summary>
-    /// <param name="x">Feature matrix where each row is a sample.</param>
-    /// <param name="y">Target values.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> This is where the model learns from your data.
-    /// The algorithm:
-    /// 1. Bins the feature values into discrete groups
-    /// 2. Computes the initial prediction (mean of targets)
-    /// 3. For each iteration:
-    ///    a. Compute residuals (how wrong current predictions are)
-    ///    b. Build a tree to predict the residuals
-    ///    c. Add the tree's predictions to the ensemble
-    /// </para>
-    /// </remarks>
-    public override void Train(Matrix<T> x, Vector<T> y)
-    {
-        _numFeatures = x.Columns;
-
-        // Step 1: Bin the features
-        BinFeatures(x);
-
-        // Step 2: Compute initial prediction (mean of y)
-        T sum = NumOps.Zero;
-        for (int i = 0; i < y.Length; i++)
-        {
-            sum = NumOps.Add(sum, y[i]);
-        }
-        _initialPrediction = NumOps.Divide(sum, NumOps.FromDouble(y.Length));
-
-        // Step 3: Initialize predictions and residuals
-        var predictions = new T[y.Length];
-        var residuals = new T[y.Length];
-
-        for (int i = 0; i < y.Length; i++)
-        {
-            predictions[i] = _initialPrediction;
-            residuals[i] = NumOps.Subtract(y[i], predictions[i]);
-        }
-
-        // Step 4: Initialize trees and feature importances
-        _trees = new List<HistTreeNode>(_options.NumberOfIterations);
-        _featureImportances = new T[_numFeatures];
-        for (int i = 0; i < _numFeatures; i++)
-        {
-            _featureImportances[i] = NumOps.Zero;
-        }
-
-        // Step 5: Build trees iteratively
-        for (int iteration = 0; iteration < _options.NumberOfIterations; iteration++)
-        {
-            // Subsample indices
-            int[] sampleIndices = GetSubsampleIndices(y.Length);
-
-            // Build tree on residuals
-            var tree = BuildTree(residuals, sampleIndices);
-            _trees.Add(tree);
-
-            // Update predictions
-            T lr = NumOps.FromDouble(_options.LearningRate);
-            for (int i = 0; i < y.Length; i++)
-            {
-                T treePred = PredictSingleTree(tree, i);
-                predictions[i] = NumOps.Add(predictions[i], NumOps.Multiply(lr, treePred));
-                residuals[i] = NumOps.Subtract(y[i], predictions[i]);
-            }
-        }
-
-        // Normalize feature importances
-        NormalizeFeatureImportances();
-    }
-
-    /// <summary>
-    /// Makes predictions for new data.
-    /// </summary>
-    /// <param name="input">Feature matrix for prediction.</param>
-    /// <returns>Predicted values.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> After training, use this to make predictions on new data.
-    /// The prediction is: initial_prediction + learning_rate * sum(tree_predictions)
-    /// </para>
-    /// </remarks>
-    public override Vector<T> Predict(Matrix<T> input)
-    {
-        if (_trees is null || _binThresholds is null)
-        {
-            throw new InvalidOperationException("Model must be trained before making predictions.");
-        }
-
-        var predictions = new Vector<T>(input.Rows);
-        T lr = NumOps.FromDouble(_options.LearningRate);
-
-        for (int i = 0; i < input.Rows; i++)
-        {
-            T pred = _initialPrediction;
-
-            // Bin the input features
-            var binnedRow = BinRow(input, i);
-
-            // Add contribution from each tree
-            foreach (var tree in _trees)
-            {
-                pred = NumOps.Add(pred, NumOps.Multiply(lr, PredictSingleTreeFromBins(tree, binnedRow)));
-            }
-
-            predictions[i] = pred;
-        }
-
-        return predictions;
-    }
-
-    /// <summary>
-    /// Gets model metadata.
-    /// </summary>
-    public override ModelMetadata<T> GetModelMetadata()
-    {
-        return new ModelMetadata<T>
-        {
-            AdditionalInfo = new Dictionary<string, object>
-            {
-                { "NumberOfTrees", _trees?.Count ?? 0 },
-                { "NumberOfIterations", _options.NumberOfIterations },
-                { "LearningRate", _options.LearningRate },
-                { "MaxBins", _options.MaxBins },
-                { "MaxDepth", _options.MaxDepth },
-                { "MaxLeafNodes", _options.MaxLeafNodes ?? -1 },
-                { "MinSamplesLeaf", _options.MinSamplesLeaf },
-                { "L2Regularization", _options.L2Regularization }
-            }
-        };
-    }
-
-    /// <summary>
-    /// Gets the feature importance scores.
-    /// </summary>
-    public override Dictionary<string, T> GetFeatureImportance()
-    {
-        var result = new Dictionary<string, T>();
-
-        if (_featureImportances is null)
-        {
-            return result;
-        }
-
-        for (int i = 0; i < _featureImportances.Length; i++)
-        {
-            string name = FeatureNames is not null && i < FeatureNames.Length
-                ? FeatureNames[i]
-                : $"Feature_{i}";
-            result[name] = _featureImportances[i];
-        }
-
-        return result;
-    }
-
-    /// <summary>
-    /// The model's one continuous parameter: the initial prediction the boosted trees correct.
-    /// </summary>
-    /// <remarks>
-    /// The surface this replaces returned TWO values -- the initial prediction and the tree COUNT.
-    /// A count is structure, not a parameter: SetParameters read only the first slot and ignored
-    /// the second, so the vector advertised a value it could never restore, and any caller pairing
-    /// the two by length was silently working with one dead slot. The trees themselves are not a
-    /// flat vector at all; they round-trip through serialization.
-    /// </remarks>
-    protected override void RegisterComponents()
-    {
-        base.RegisterComponents();
-        RegisterParameterComponent(new ScalarParameterSource<T>(
-            () => _initialPrediction,
-            value => _initialPrediction = value));
-    }
-
-    // Replaced by the declared parameter source below. Removed under AIDN082.
-
-    // Replaced by the declared parameter source below. Removed under AIDN082.
-
-    /// <summary>
-    /// Creates a new instance with the given parameters.
-    /// </summary>
-    public override IFullModel<T, Matrix<T>, Vector<T>> WithParameters(Vector<T> parameters)
-    {
-        var newModel = new HistGradientBoostingRegression<T>(_options);
-        newModel.SetParameters(parameters);
-        return newModel;
-    }
-
-    /// <summary>
-    /// Serializes the model to a byte array.
-    /// </summary>
-    public override byte[] Serialize()
-    {
-        ModelPersistenceGuard.EnforceBeforeSerialize();
-        using var ms = new MemoryStream();
-        using var writer = new BinaryWriter(ms);
-
-        // Write options
-        writer.Write(_options.NumberOfIterations);
-        writer.Write(_options.LearningRate);
-        writer.Write(_options.MaxBins);
-        writer.Write(_options.MaxDepth);
-        writer.Write(_options.MaxLeafNodes ?? -1);
-        writer.Write(_options.MinSamplesLeaf);
-        writer.Write(_options.L2Regularization);
-        writer.Write(_options.SubsampleRatio);
-
-        // Write model state
-        writer.Write(NumOps.ToDouble(_initialPrediction));
-        writer.Write(_numFeatures);
-
-        // Write bin thresholds
-        if (_binThresholds is not null)
-        {
-            writer.Write(_binThresholds.Length);
-            foreach (var featureThresholds in _binThresholds)
-            {
-                writer.Write(featureThresholds.Length);
-                foreach (var threshold in featureThresholds)
-                {
-                    writer.Write(NumOps.ToDouble(threshold));
-                }
-            }
-        }
-        else
-        {
-            writer.Write(0);
-        }
-
-        // Write trees
-        if (_trees is not null)
-        {
-            writer.Write(_trees.Count);
-            foreach (var tree in _trees)
-            {
-                SerializeTree(writer, tree);
-            }
-        }
-        else
-        {
-            writer.Write(0);
-        }
-
-        // Write feature importances
-        if (_featureImportances is not null)
-        {
-            writer.Write(_featureImportances.Length);
-            foreach (var importance in _featureImportances)
-            {
-                writer.Write(NumOps.ToDouble(importance));
-            }
-        }
-        else
-        {
-            writer.Write(0);
-        }
-
-        return ms.ToArray();
-    }
-
-    /// <summary>
-    /// Deserializes the model from a byte array.
-    /// </summary>
-    public override void Deserialize(byte[] data)
-    {
-        ModelPersistenceGuard.EnforceBeforeDeserialize();
-        using var ms = new MemoryStream(data);
-        using var reader = new BinaryReader(ms);
-
-        // Read options
-        _options.NumberOfIterations = reader.ReadInt32();
-        _options.LearningRate = reader.ReadDouble();
-        _options.MaxBins = reader.ReadInt32();
-        _options.MaxDepth = reader.ReadInt32();
-        int maxLeaf = reader.ReadInt32();
-        _options.MaxLeafNodes = maxLeaf >= 0 ? maxLeaf : null;
-        _options.MinSamplesLeaf = reader.ReadInt32();
-        _options.L2Regularization = reader.ReadDouble();
-        _options.SubsampleRatio = reader.ReadDouble();
-
-        // Read model state
-        _initialPrediction = NumOps.FromDouble(reader.ReadDouble());
-        _numFeatures = reader.ReadInt32();
-
-        // Read bin thresholds
-        int numFeatureThresholds = reader.ReadInt32();
-        if (numFeatureThresholds > 0)
-        {
-            _binThresholds = new T[numFeatureThresholds][];
-            for (int i = 0; i < numFeatureThresholds; i++)
-            {
-                int numThresholds = reader.ReadInt32();
-                _binThresholds[i] = new T[numThresholds];
-                for (int j = 0; j < numThresholds; j++)
-                {
-                    _binThresholds[i][j] = NumOps.FromDouble(reader.ReadDouble());
-                }
-            }
-        }
-
-        // Read trees
-        int numTrees = reader.ReadInt32();
-        _trees = new List<HistTreeNode>(numTrees);
-        for (int i = 0; i < numTrees; i++)
-        {
-            _trees.Add(DeserializeTree(reader));
-        }
-
-        // Read feature importances
-        int numImportances = reader.ReadInt32();
-        if (numImportances > 0)
-        {
-            _featureImportances = new T[numImportances];
-            for (int i = 0; i < numImportances; i++)
-            {
-                _featureImportances[i] = NumOps.FromDouble(reader.ReadDouble());
-            }
-        }
-    }
-
-    /// <summary>
-    /// Gets the default loss function used for gradient computation.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Histogram Gradient Boosting uses Mean Squared Error (MSE)
-    /// as its default loss function for regression tasks. MSE measures the average
-    /// squared difference between predictions and actual values.
-    /// </para>
-    /// </remarks>
-    public override ILossFunction<T> DefaultLossFunction => _defaultLossFunction;
-
-    /// <summary>
-    /// Gets the number of parameters in the model.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> For histogram-based gradient boosting, the "parameters"
-    /// include the initial prediction and all leaf values across all trees.
-    /// This is a simplification since the actual model is tree-structured.
-    /// </para>
-    /// </remarks>
-    /// <summary>
-    /// Returns 0 to prevent optimizer random parameter injection.
-    /// Histogram gradient boosting builds trees internally.
-    /// </summary>
-        /// <remarks>
-    /// Expressed as a capability, not as a count. A zero ParameterCount also suppresses
-    /// injection -- that is why this was written that way -- but it overloads a COUNT to carry
-    /// a CAPABILITY: the model does have parameters (the base getter returns its coefficients
-    /// and intercept), so the count contradicted the vector and anything pairing the two by
-    /// length saw parameters the model claimed not to have.
-    /// </remarks>
-    public override bool SupportsParameterInitialization => false;
-
-    /// <summary>
-    /// Saves the model to a file.
-    /// </summary>
-    /// <param name="filePath">The path where the model should be saved.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> This saves your trained model to a file so you can
-    /// load it later without retraining.
-    /// </para>
-    /// </remarks>
-    public override void SaveModel(string filePath)
-    {
-        Helpers.ModelPersistenceGuard.EnforceBeforeSave();
-        using (Helpers.ModelPersistenceGuard.InternalOperation())
-        {
-            byte[] data = Serialize();
-            File.WriteAllBytes(filePath, data);
-        }
-    }
-
-    /// <summary>
-    /// Loads the model from a file.
-    /// </summary>
-    /// <param name="filePath">The path to the saved model file.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> This loads a previously saved model so you can use
-    /// it for predictions without retraining.
-    /// </para>
-    /// </remarks>
-    public override void LoadModel(string filePath)
-    {
-        Helpers.ModelPersistenceGuard.EnforceBeforeLoad();
-        using (Helpers.ModelPersistenceGuard.InternalOperation())
-        {
-            byte[] data = File.ReadAllBytes(filePath);
-            Deserialize(data);
-        }
-    }
-
-    /// <summary>
-    /// Saves the model state to a stream.
-    /// </summary>
-    /// <param name="stream">The stream to write to.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> This is useful for checkpointing during training
-    /// or for storing models in databases/memory.
-    /// </para>
-    /// </remarks>
-    public override void SaveState(Stream stream)
-    {
-        byte[] data = Serialize();
-        using var writer = new BinaryWriter(stream, System.Text.Encoding.UTF8, leaveOpen: true);
-        writer.Write(data.Length);
-        writer.Write(data);
-        writer.Flush();
-    }
-
-    /// <summary>
-    /// Loads the model state from a stream.
-    /// </summary>
-    /// <param name="stream">The stream to read from.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> This restores a model from a checkpoint or database.
-    /// </para>
-    /// </remarks>
-    public override void LoadState(Stream stream)
-    {
-        using var reader = new BinaryReader(stream, System.Text.Encoding.UTF8, leaveOpen: true);
-        int length = reader.ReadInt32();
-        byte[] data = reader.ReadBytes(length);
-        Deserialize(data);
-    }
-
-    /// <summary>
-    /// Gets the indices of features that are actively used by the model.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Returns which features are actually used in the trees.
-    /// Features not used by any split may be irrelevant for predictions.
-    /// </para>
-    /// </remarks>
-    public override IEnumerable<int> GetActiveFeatureIndices()
-    {
-        if (_activeFeatureIndices is null)
-        {
-            _activeFeatureIndices = new HashSet<int>();
-            if (_trees is not null)
-            {
-                foreach (var tree in _trees)
-                {
-                    CollectActiveFeatures(tree, _activeFeatureIndices);
-                }
-            }
-        }
-        return _activeFeatureIndices;
-    }
-
-    /// <summary>
-    /// Sets the active feature indices for the model.
-    /// </summary>
-    /// <param name="featureIndices">The feature indices to mark as active.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> This allows you to manually specify which features
-    /// the model should consider. Usually computed automatically during training.
-    /// </para>
-    /// </remarks>
-    public override void SetActiveFeatureIndices(IEnumerable<int> featureIndices)
-    {
-        _activeFeatureIndices = new HashSet<int>(featureIndices);
-    }
-
-    /// <summary>
-    /// Checks if a specific feature is used by the model.
-    /// </summary>
-    /// <param name="featureIndex">The index of the feature to check.</param>
-    /// <returns>True if the feature is used in any tree split.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> This tells you if a specific feature contributes to
-    /// predictions. Unused features can be removed from future training data.
-    /// </para>
-    /// </remarks>
-    public override bool IsFeatureUsed(int featureIndex)
-    {
-        var activeFeatures = GetActiveFeatureIndices();
-        return activeFeatures.Contains(featureIndex);
-    }
-
-    /// <summary>
-    /// Creates a deep copy of the model.
-    /// </summary>
-    /// <returns>A new instance with all data copied.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Creates a complete independent copy of the model.
-    /// Changes to the copy won't affect the original.
-    /// </para>
-    /// </remarks>
-    public override IFullModel<T, Matrix<T>, Vector<T>> DeepCopy()
-    {
-        // In-memory clone, not a user save/load — wrap in InternalOperation
-        // so the persistence guard does not treat this as a billable op.
-        //
-        // Options are cloned (not shared by reference) so the returned copy
-        // owns an independent options object. A shared _options reference
-        // would let mutations on the clone leak back into the original and
-        // break deep-copy isolation downstream (e.g., hyperparameter tuners
-        // that adjust a single model's options).
-        using (ModelPersistenceGuard.InternalOperation())
-        {
-            var copy = new HistGradientBoostingRegression<T>(_options.Clone());
-            copy.Deserialize(Serialize());
-            return copy;
-        }
-    }
-
-    /// <summary>
-    /// Computes gradients without updating parameters.
-    /// </summary>
-    /// <param name="input">The input features.</param>
-    /// <param name="target">The target values.</param>
-    /// <param name="lossFunction">Optional loss function (uses default if null).</param>
-    /// <returns>Gradient vector.</returns>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Gradient boosting computes gradients (residuals) as
-    /// the direction to improve predictions. For MSE loss, the gradient is simply
-    /// the difference between predictions and targets.
-    /// </para>
-    /// </remarks>
-    public override Vector<T> ComputeGradients(Matrix<T> input, Vector<T> target, ILossFunction<T>? lossFunction = null)
-    {
-        var loss = lossFunction ?? _defaultLossFunction;
-        var predictions = Predict(input);
-
-        // Compute gradients (negative of loss derivative with respect to predictions)
-        var gradients = new Vector<T>(target.Length);
-        for (int i = 0; i < target.Length; i++)
-        {
-            // For MSE: derivative = 2 * (prediction - target)
-            // We return the negative gradient (direction of improvement)
-            var diff = NumOps.Subtract(target[i], predictions[i]);
-            gradients[i] = NumOps.Multiply(NumOps.FromDouble(2.0), diff);
-        }
-
-        return gradients;
-    }
-
-    /// <summary>
-    /// Applies gradients to update the model.
-    /// </summary>
-    /// <param name="gradients">The gradient vector to apply.</param>
-    /// <param name="learningRate">The learning rate for the update.</param>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> For tree-based models, applying gradients means
-    /// adjusting the initial prediction and leaf values. This is a simplified
-    /// update that shifts predictions in the direction of the gradients.
-    /// </para>
-    /// </remarks>
-    public override void ApplyGradients(Vector<T> gradients, T learningRate)
-    {
-        // For gradient boosting, we adjust the initial prediction based on average gradient
-        if (gradients.Length > 0)
-        {
-            T sum = NumOps.Zero;
-            for (int i = 0; i < gradients.Length; i++)
-            {
-                sum = NumOps.Add(sum, gradients[i]);
-            }
-            T avgGradient = NumOps.Divide(sum, NumOps.FromDouble(gradients.Length));
-            T update = NumOps.Multiply(learningRate, avgGradient);
-            _initialPrediction = NumOps.Add(_initialPrediction, update);
-        }
-    }
-
-    /// <summary>
-    /// Counts the number of leaves in a tree.
-    /// </summary>
-    private int CountLeaves(HistTreeNode node)
-    {
-        if (node.IsLeaf)
-        {
-            return 1;
-        }
-        int count = 0;
-        if (node.Left is not null)
-        {
-            count += CountLeaves(node.Left);
-        }
-        if (node.Right is not null)
-        {
-            count += CountLeaves(node.Right);
-        }
-        return count;
-    }
-
-    /// <summary>
-    /// Recursively collects active feature indices from a tree.
-    /// </summary>
-    private void CollectActiveFeatures(HistTreeNode node, HashSet<int> features)
-    {
-        if (node.IsLeaf)
-        {
-            return;
-        }
-        features.Add(node.FeatureIndex);
-        if (node.Left is not null)
-        {
-            CollectActiveFeatures(node.Left, features);
-        }
-        if (node.Right is not null)
-        {
-            CollectActiveFeatures(node.Right, features);
-        }
-    }
-
-    #endregion
-
-    #region Binning
-
-    /// <summary>
-    /// Bins all features in the training data.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> This converts continuous feature values into discrete bins.
-    /// For each feature:
-    /// 1. Find the unique values
-    /// 2. Determine bin boundaries (quantiles or uniform)
-    /// 3. Assign each value to a bin (0 to MaxBins-1)
-    ///
-    /// This is a key optimization that makes the algorithm fast.
-    /// </para>
-    /// </remarks>
-    private void BinFeatures(Matrix<T> x)
-    {
-        int numSamples = x.Rows;
-        int numFeatures = x.Columns;
-
-        _binThresholds = new T[numFeatures][];
-        _binnedData = new byte[numSamples, numFeatures];
-
-        for (int f = 0; f < numFeatures; f++)
-        {
-            // Extract and sort feature values
-            var values = new List<double>(numSamples);
-            for (int i = 0; i < numSamples; i++)
-            {
-                values.Add(NumOps.ToDouble(x[i, f]));
-            }
-            values.Sort();
-
-            // Compute bin thresholds using quantiles
-            var thresholds = ComputeQuantileThresholds(values);
-            _binThresholds[f] = thresholds.Select(t => NumOps.FromDouble(t)).ToArray();
-
-            // Bin each value
-            for (int i = 0; i < numSamples; i++)
-            {
-                double val = NumOps.ToDouble(x[i, f]);
-                _binnedData[i, f] = (byte)FindBin(val, thresholds);
-            }
-        }
-    }
-
-    /// <summary>
-    /// Computes quantile-based bin thresholds.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Instead of uniform bins, we use quantiles to ensure
-    /// each bin has roughly the same number of samples. This is more effective
-    /// when feature values are not uniformly distributed.
-    /// </para>
-    /// </remarks>
-    private List<double> ComputeQuantileThresholds(List<double> sortedValues)
-    {
-        var thresholds = new List<double>();
-        int n = sortedValues.Count;
-        int maxBins = Math.Min(_options.MaxBins, n);
-
-        if (maxBins <= 1)
-        {
-            return thresholds;
-        }
-
-        // Get unique values
-        var uniqueValues = sortedValues.Distinct().ToList();
-
-        if (uniqueValues.Count <= maxBins)
-        {
-            // Use midpoints between unique values as thresholds
-            for (int i = 0; i < uniqueValues.Count - 1; i++)
-            {
-                thresholds.Add((uniqueValues[i] + uniqueValues[i + 1]) / 2.0);
-            }
-        }
-        else
-        {
-            // Use quantiles
-            for (int i = 1; i < maxBins; i++)
-            {
-                double quantile = (double)i / maxBins;
-                int index = (int)(quantile * (n - 1));
-                double threshold = sortedValues[index];
-
-                // Avoid duplicate thresholds
-                if (thresholds.Count == 0 || threshold > thresholds[^1])
-                {
-                    thresholds.Add(threshold);
-                }
-            }
-        }
-
-        return thresholds;
-    }
-
-    /// <summary>
-    /// Finds the bin index for a given value.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Given a value and the bin thresholds, this finds
-    /// which bin the value belongs to using binary search for efficiency.
-    /// </para>
-    /// </remarks>
-    private int FindBin(double value, List<double> thresholds)
-    {
-        // Binary search for the correct bin
-        int left = 0;
-        int right = thresholds.Count;
-
-        while (left < right)
-        {
-            int mid = (left + right) / 2;
-            if (value <= thresholds[mid])
-            {
-                right = mid;
-            }
-            else
-            {
-                left = mid + 1;
-            }
-        }
-
-        return left;
-    }
-
-    /// <summary>
-    /// Bins a single row of new data for prediction.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> When making predictions on new data, we need to
-    /// bin the features using the same thresholds learned during training.
-    /// </para>
-    /// </remarks>
-    private byte[] BinRow(Matrix<T> x, int row)
-    {
-        var binned = new byte[_numFeatures];
-
-        for (int f = 0; f < _numFeatures; f++)
-        {
-            double val = NumOps.ToDouble(x[row, f]);
-            var thresholds = (_binThresholds ?? throw new InvalidOperationException("Bin thresholds not computed."))[f].Select(t => NumOps.ToDouble(t)).ToList();
-            binned[f] = (byte)FindBin(val, thresholds);
-        }
-
-        return binned;
-    }
-
-    #endregion
-
-    #region Tree Building
-
-    /// <summary>
-    /// Gets subsample indices for stochastic gradient boosting.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> If SubsampleRatio is less than 1.0, we randomly
-    /// select a subset of samples to train each tree. This adds randomness
-    /// that can improve generalization.
-    /// </para>
-    /// </remarks>
-    private int[] GetSubsampleIndices(int totalSamples)
-    {
-        if (_options.SubsampleRatio >= 1.0)
-        {
-            return Enumerable.Range(0, totalSamples).ToArray();
-        }
-
-        int subsampleSize = (int)(totalSamples * _options.SubsampleRatio);
-        var indices = new HashSet<int>();
-
-        while (indices.Count < subsampleSize)
-        {
-            indices.Add(_random.Next(totalSamples));
-        }
-
-        return indices.ToArray();
-    }
-
-    /// <summary>
-    /// Builds a single histogram-based tree.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> This builds a decision tree using histograms for
-    /// efficient split finding. The algorithm:
-    /// 1. Start with all samples at the root
-    /// 2. Find the best split using histograms
-    /// 3. Split into left and right children
-    /// 4. Recursively build children until stopping criteria
-    /// </para>
-    /// </remarks>
-    private HistTreeNode BuildTree(T[] residuals, int[] sampleIndices)
-    {
-        var root = new HistTreeNode(NumOps.Zero)
-        {
-            SampleIndices = sampleIndices.ToList(),
-            Depth = 0
-        };
-
-        // Use a priority queue for best-first growth
-        var queue = new List<HistTreeNode> { root };
-        int leafCount = 1;
-
-        while (queue.Count > 0)
-        {
-            // Find the node with the best potential gain
-            int bestIdx = -1;
-            T bestGain = NumOps.MinValue;
-            SplitInfo? bestSplit = null;
-
-            for (int i = 0; i < queue.Count; i++)
-            {
-                var node = queue[i];
-
-                // Check stopping criteria
-                if (node.Depth >= _options.MaxDepth) continue;
-                if (node.SampleIndices.Count < 2 * _options.MinSamplesLeaf) continue;
-
-                // Find best split for this node
-                var split = FindBestSplit(node, residuals);
-
-                if (split is not null && NumOps.GreaterThan(split.Gain, bestGain))
-                {
-                    bestGain = split.Gain;
-                    bestSplit = split;
-                    bestIdx = i;
-                }
-            }
-
-            // If no beneficial split found or max leaves reached, stop
-            if (bestIdx < 0 || bestSplit is null ||
-                (_options.MaxLeafNodes.HasValue && leafCount >= _options.MaxLeafNodes.Value))
-            {
-                break;
-            }
-
-            // Apply the best split
-            var nodeToSplit = queue[bestIdx];
-            queue.RemoveAt(bestIdx);
-
-            ApplySplit(nodeToSplit, bestSplit, residuals);
-
-            // Add children to queue
-            if (nodeToSplit.Left is not null)
-            {
-                queue.Add(nodeToSplit.Left);
-            }
-            if (nodeToSplit.Right is not null)
-            {
-                queue.Add(nodeToSplit.Right);
-            }
-
-            // Update feature importance
-            if (_featureImportances is not null)
-            {
-                _featureImportances[bestSplit.FeatureIndex] = NumOps.Add(
-                    _featureImportances[bestSplit.FeatureIndex],
-                    bestSplit.Gain);
-            }
-
-            leafCount++;
-        }
-
-        // Set leaf values for remaining nodes
-        foreach (var node in queue)
-        {
-            SetLeafValue(node, residuals);
-        }
-
-        // Also ensure root has a leaf value if it was never split
-        if (root.Left is null && root.Right is null)
-        {
-            SetLeafValue(root, residuals);
-        }
-
-        return root;
-    }
-
-    /// <summary>
-    /// Finds the best split for a node using histograms.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> This is the core of histogram-based gradient boosting.
-    /// Instead of checking every possible split point:
-    /// 1. Build a histogram counting gradient sums for each bin
-    /// 2. Only check splits between bins
-    ///
-    /// This reduces complexity from O(n) to O(bins).
-    /// </para>
-    /// </remarks>
-    private SplitInfo? FindBestSplit(HistTreeNode node, T[] residuals)
-    {
-        SplitInfo? bestSplit = null;
-        T bestGain = NumOps.FromDouble(_options.MinGainToSplit);
-
-        // Get features to consider (column subsampling)
-        var featuresToConsider = GetFeaturesToConsider();
-
-        foreach (int featureIdx in featuresToConsider)
-        {
-            // Build histogram for this feature
-            var histogram = BuildHistogram(node.SampleIndices, featureIdx, residuals);
-
-            // Find best split point in histogram
-            var split = FindBestSplitInHistogram(histogram, featureIdx, node.SampleIndices.Count);
-
-            if (split is not null && NumOps.GreaterThan(split.Gain, bestGain))
-            {
-                bestGain = split.Gain;
-                bestSplit = split;
-            }
-        }
-
-        return bestSplit;
-    }
-
-    /// <summary>
-    /// Gets feature indices to consider for splitting (column subsampling).
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> If ColsampleByTree is less than 1.0, we randomly
-    /// select a subset of features to consider for each split. This adds
-    /// diversity to the trees.
-    /// </para>
-    /// </remarks>
-    private List<int> GetFeaturesToConsider()
-    {
-        if (_options.ColsampleByTree >= 1.0)
-        {
-            return Enumerable.Range(0, _numFeatures).ToList();
-        }
-
-        int numFeaturesToUse = Math.Max(1, (int)(_numFeatures * _options.ColsampleByTree));
-        var allFeatures = Enumerable.Range(0, _numFeatures).ToList();
-
-        // Shuffle and take first numFeaturesToUse
-        for (int i = allFeatures.Count - 1; i > 0; i--)
-        {
-            int j = _random.Next(i + 1);
-            (allFeatures[i], allFeatures[j]) = (allFeatures[j], allFeatures[i]);
-        }
-
-        return allFeatures.Take(numFeaturesToUse).ToList();
-    }
-
-    /// <summary>
-    /// Builds a gradient histogram for a feature.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> A histogram accumulates the sum of residuals (gradients)
-    /// for each bin. This allows us to quickly compute the gain for any split point.
-    /// </para>
-    /// </remarks>
-    private HistogramBin[] BuildHistogram(List<int> sampleIndices, int featureIdx, T[] residuals)
-    {
-        int numBins = (_binThresholds ?? throw new InvalidOperationException("Bin thresholds not computed."))[featureIdx].Length + 1;
-        var histogram = new HistogramBin[numBins];
-
-        for (int i = 0; i < numBins; i++)
-        {
-            histogram[i] = new HistogramBin(NumOps.Zero);
-        }
-
-        foreach (int idx in sampleIndices)
-        {
-            int bin = (_binnedData ?? throw new InvalidOperationException("Binned data not computed."))[idx, featureIdx];
-            histogram[bin].GradientSum = NumOps.Add(histogram[bin].GradientSum, residuals[idx]);
-            histogram[bin].HessianSum = NumOps.Add(histogram[bin].HessianSum, NumOps.One); // Squared loss has hessian = 1
-            histogram[bin].Count++;
-        }
-
-        return histogram;
-    }
-
-    /// <summary>
-    /// Finds the best split point within a histogram.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Given the histogram, we scan through all possible
-    /// split points (between bins) and compute the gain for each. The gain
-    /// measures how much the split reduces prediction error.
-    ///
-    /// Gain = (left_gradient²/left_hessian + right_gradient²/right_hessian - total_gradient²/total_hessian) / 2
-    ///        - regularization_penalty
-    /// </para>
-    /// </remarks>
-    private SplitInfo? FindBestSplitInHistogram(HistogramBin[] histogram, int featureIdx, int totalCount)
-    {
-        // Compute totals
-        T totalGrad = NumOps.Zero;
-        T totalHess = NumOps.Zero;
-        foreach (var bin in histogram)
-        {
-            totalGrad = NumOps.Add(totalGrad, bin.GradientSum);
-            totalHess = NumOps.Add(totalHess, bin.HessianSum);
-        }
-
-        T bestGain = NumOps.FromDouble(_options.MinGainToSplit);
-        int bestBin = -1;
-
-        T leftGrad = NumOps.Zero;
-        T leftHess = NumOps.Zero;
-        int leftCount = 0;
-        T lambda = NumOps.FromDouble(_options.L2Regularization);
-        T half = NumOps.FromDouble(0.5);
-
-        // Try each split point
-        for (int bin = 0; bin < histogram.Length - 1; bin++)
-        {
-            leftGrad = NumOps.Add(leftGrad, histogram[bin].GradientSum);
-            leftHess = NumOps.Add(leftHess, histogram[bin].HessianSum);
-            leftCount += histogram[bin].Count;
-
-            // Check minimum samples constraint
-            int rightCount = totalCount - leftCount;
-            if (leftCount < _options.MinSamplesLeaf || rightCount < _options.MinSamplesLeaf)
-            {
-                continue;
-            }
-
-            T rightGrad = NumOps.Subtract(totalGrad, leftGrad);
-            T rightHess = NumOps.Subtract(totalHess, leftHess);
-
-            // Compute gain with L2 regularization
-            // gain = 0.5 * (leftGrad^2/(leftHess+lambda) + rightGrad^2/(rightHess+lambda) - totalGrad^2/(totalHess+lambda))
-            T leftTerm = NumOps.Divide(NumOps.Multiply(leftGrad, leftGrad), NumOps.Add(leftHess, lambda));
-            T rightTerm = NumOps.Divide(NumOps.Multiply(rightGrad, rightGrad), NumOps.Add(rightHess, lambda));
-            T totalTerm = NumOps.Divide(NumOps.Multiply(totalGrad, totalGrad), NumOps.Add(totalHess, lambda));
-            T gain = NumOps.Multiply(half, NumOps.Subtract(NumOps.Add(leftTerm, rightTerm), totalTerm));
-
-            if (NumOps.GreaterThan(gain, bestGain))
-            {
-                bestGain = gain;
-                bestBin = bin;
-            }
-        }
-
-        if (bestBin < 0)
-        {
-            return null;
-        }
-
-        // Compute left and right counts for the best split
-        int bestLeftCount = 0;
-        for (int bin = 0; bin <= bestBin; bin++)
-        {
-            bestLeftCount += histogram[bin].Count;
-        }
-
-        return new SplitInfo(NumOps.Zero)
-        {
-            FeatureIndex = featureIdx,
-            BinThreshold = bestBin,
-            Gain = bestGain,
-            LeftCount = bestLeftCount,
-            RightCount = totalCount - bestLeftCount
-        };
-    }
-
-    /// <summary>
-    /// Applies a split to a node, creating left and right children.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> After finding the best split, this method:
-    /// 1. Creates left and right child nodes
-    /// 2. Assigns samples to each child based on their bin values
-    /// 3. Sets the split threshold on the parent node
-    /// </para>
-    /// </remarks>
-    private void ApplySplit(HistTreeNode node, SplitInfo split, T[] residuals)
-    {
-        var leftIndices = new List<int>();
-        var rightIndices = new List<int>();
-
-        foreach (int idx in node.SampleIndices)
-        {
-            int bin = (_binnedData ?? throw new InvalidOperationException("Binned data not computed."))[idx, split.FeatureIndex];
-            if (bin <= split.BinThreshold)
-            {
-                leftIndices.Add(idx);
-            }
-            else
-            {
-                rightIndices.Add(idx);
-            }
-        }
-
-        node.IsLeaf = false;
-        node.FeatureIndex = split.FeatureIndex;
-        node.BinThreshold = split.BinThreshold;
-
-        // Convert bin threshold to actual value for prediction
-        if (split.BinThreshold < (_binThresholds ?? throw new InvalidOperationException("Bin thresholds not computed."))[split.FeatureIndex].Length)
-        {
-            node.Threshold = _binThresholds[split.FeatureIndex][split.BinThreshold];
-        }
-        else
-        {
-            node.Threshold = NumOps.MaxValue;
-        }
-
-        node.Left = new HistTreeNode(NumOps.Zero)
-        {
-            SampleIndices = leftIndices,
-            Depth = node.Depth + 1
-        };
-
-        node.Right = new HistTreeNode(NumOps.Zero)
-        {
-            SampleIndices = rightIndices,
-            Depth = node.Depth + 1
-        };
-
-        // Set leaf values (may be overwritten if children are split further)
-        SetLeafValue(node.Left, residuals);
-        SetLeafValue(node.Right, residuals);
-    }
-
-    /// <summary>
-    /// Sets the prediction value for a leaf node.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> For squared error loss, the optimal leaf value is
-    /// the mean of the residuals at that leaf. With L2 regularization, this
-    /// becomes: sum(residuals) / (count + regularization)
-    /// </para>
-    /// </remarks>
-    private void SetLeafValue(HistTreeNode node, T[] residuals)
-    {
-        node.IsLeaf = true;
-
-        if (node.SampleIndices.Count == 0)
-        {
-            node.LeafValue = NumOps.Zero;
-            return;
-        }
-
-        T sum = NumOps.Zero;
-        foreach (int idx in node.SampleIndices)
-        {
-            sum = NumOps.Add(sum, residuals[idx]);
-        }
-
-        // Optimal leaf value with L2 regularization
-        T lambda = NumOps.FromDouble(_options.L2Regularization);
-        node.LeafValue = NumOps.Divide(sum, NumOps.Add(NumOps.FromDouble(node.SampleIndices.Count), lambda));
-    }
-
-    #endregion
-
-    #region Prediction
-
-    /// <summary>
-    /// Predicts using a single tree on binned training data.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> During training, we use the already-binned data
-    /// for faster prediction. This avoids re-binning at each iteration.
-    /// </para>
-    /// </remarks>
-    private T PredictSingleTree(HistTreeNode tree, int sampleIndex)
-    {
-        var node = tree;
-
-        while (!node.IsLeaf)
-        {
-            int bin = (_binnedData ?? throw new InvalidOperationException("Binned data not computed."))[sampleIndex, node.FeatureIndex];
-            if (node.Left is null || node.Right is null)
-            {
-                throw new InvalidOperationException("Internal tree node has null children.");
-            }
-            node = bin <= node.BinThreshold ? node.Left : node.Right;
-        }
-
-        return node.LeafValue;
-    }
-
-    /// <summary>
-    /// Predicts using a single tree from binned features.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> For new data that has been binned, traverse the
-    /// tree using bin indices to find the leaf prediction.
-    /// </para>
-    /// </remarks>
-    private T PredictSingleTreeFromBins(HistTreeNode tree, byte[] binnedRow)
-    {
-        var node = tree;
-
-        while (!node.IsLeaf)
-        {
-            int bin = binnedRow[node.FeatureIndex];
-            if (node.Left is null || node.Right is null)
-            {
-                throw new InvalidOperationException("Internal tree node has null children.");
-            }
-            node = bin <= node.BinThreshold ? node.Left : node.Right;
-        }
-
-        return node.LeafValue;
-    }
-
-    #endregion
-
-    #region Feature Importance
-
-    /// <summary>
-    /// Normalizes feature importances to sum to 1.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Feature importance scores are accumulated during
-    /// training (total gain from splits using each feature). Normalizing makes
-    /// them easier to interpret as relative importance percentages.
-    /// </para>
-    /// </remarks>
-    private void NormalizeFeatureImportances()
-    {
-        if (_featureImportances is null) return;
-
-        T sum = NumOps.Zero;
-        foreach (var importance in _featureImportances)
-        {
-            sum = NumOps.Add(sum, importance);
-        }
-
-        if (NumOps.GreaterThan(sum, NumOps.Zero))
-        {
-            for (int i = 0; i < _featureImportances.Length; i++)
-            {
-                _featureImportances[i] = NumOps.Divide(_featureImportances[i], sum);
-            }
-        }
-    }
-
-    #endregion
-
-    #region Serialization Helpers
-
-    /// <summary>
-    /// Serializes a tree node recursively.
-    /// </summary>
-    private void SerializeTree(BinaryWriter writer, HistTreeNode node)
-    {
-        writer.Write(node.IsLeaf);
-        writer.Write(NumOps.ToDouble(node.LeafValue));
-        writer.Write(node.FeatureIndex);
-        writer.Write(node.BinThreshold);
-        writer.Write(NumOps.ToDouble(node.Threshold));
-        writer.Write(node.Depth);
-
-        if (!node.IsLeaf)
-        {
-            if (node.Left is null || node.Right is null)
-            {
-                throw new InvalidOperationException("Internal tree node has null children during serialization.");
-            }
-            SerializeTree(writer, node.Left);
-            SerializeTree(writer, node.Right);
-        }
-    }
-
-    /// <summary>
-    /// Deserializes a tree node recursively.
-    /// </summary>
-    private HistTreeNode DeserializeTree(BinaryReader reader)
-    {
-        var node = new HistTreeNode(NumOps.Zero)
-        {
-            IsLeaf = reader.ReadBoolean(),
-            LeafValue = NumOps.FromDouble(reader.ReadDouble()),
-            FeatureIndex = reader.ReadInt32(),
-            BinThreshold = reader.ReadInt32(),
-            Threshold = NumOps.FromDouble(reader.ReadDouble()),
-            Depth = reader.ReadInt32()
-        };
-
-        if (!node.IsLeaf)
-        {
-            node.Left = DeserializeTree(reader);
-            node.Right = DeserializeTree(reader);
-        }
-
-        return node;
-    }
-
-    #endregion
-
-    #region JIT Compilation Support
-
-    /// <summary>
-    /// Exports a soft decision tree as a computation graph.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Hard decision trees use if-then-else logic which
-    /// isn't differentiable. Soft trees use sigmoid functions to smoothly
-    /// blend between branches, making them differentiable and suitable for
-    /// JIT compilation and hardware acceleration.
-    /// </para>
-    /// </remarks>
-    private ComputationNode<T> ExportSoftTree(ComputationNode<T> inputNode, HistTreeNode tree, double temperature)
-    {
-        return ExportSoftTreeNode(inputNode, tree, temperature);
-    }
-
-    /// <summary>
-    /// Recursively exports a tree node as a soft computation graph.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> For each internal node:
-    /// output = sigmoid(temp * (threshold - x[feature])) * left_output +
-    ///          (1 - sigmoid(...)) * right_output
-    ///
-    /// As temperature → ∞, this approaches a hard split.
-    /// </para>
-    /// </remarks>
-    private ComputationNode<T> ExportSoftTreeNode(ComputationNode<T> inputNode, HistTreeNode node, double temperature)
-    {
-        if (node.IsLeaf)
-        {
-            // Create constant for leaf value
-            var leafTensor = new Tensor<T>(new int[] { 1, 1 });
-            leafTensor[0, 0] = node.LeafValue;
-            return TensorOperations<T>.Constant(leafTensor, $"leaf_{node.GetHashCode()}");
-        }
-
-        // Get the feature value: x[:, featureIndex]
-        var featureSliceNode = TensorOperations<T>.Slice(inputNode, 0, node.FeatureIndex, node.FeatureIndex + 1);
-
-        // Create threshold constant
-        var thresholdTensor = new Tensor<T>(new int[] { 1, 1 });
-        thresholdTensor[0, 0] = node.Threshold;
-        var thresholdNode = TensorOperations<T>.Constant(thresholdTensor, $"threshold_{node.GetHashCode()}");
-
-        // Create temperature constant
-        var tempTensor = new Tensor<T>(new int[] { 1, 1 });
-        tempTensor[0, 0] = NumOps.FromDouble(temperature);
-        var tempNode = TensorOperations<T>.Constant(tempTensor, $"temp_{node.GetHashCode()}");
-
-        // Compute sigmoid(temperature * (threshold - x))
-        var diffNode = TensorOperations<T>.Subtract(thresholdNode, featureSliceNode);
-        var scaledDiffNode = TensorOperations<T>.ElementwiseMultiply(tempNode, diffNode);
-        var sigmoidNode = TensorOperations<T>.Sigmoid(scaledDiffNode);
-
-        // Get left and right subtree outputs
-        if (node.Left is null || node.Right is null)
-        {
-            throw new InvalidOperationException("Internal tree node has null children during graph export.");
-        }
-        var leftOutput = ExportSoftTreeNode(inputNode, node.Left, temperature);
-        var rightOutput = ExportSoftTreeNode(inputNode, node.Right, temperature);
-
-        // Compute: sigmoid * left + (1 - sigmoid) * right
-        var leftWeighted = TensorOperations<T>.ElementwiseMultiply(sigmoidNode, leftOutput);
-
-        var onesTensor = new Tensor<T>(new int[] { 1, 1 });
-        onesTensor[0, 0] = NumOps.One;
-        var onesNode = TensorOperations<T>.Constant(onesTensor, "ones");
-        var oneMinusSigmoid = TensorOperations<T>.Subtract(onesNode, sigmoidNode);
-
-        var rightWeighted = TensorOperations<T>.ElementwiseMultiply(oneMinusSigmoid, rightOutput);
-
-        return TensorOperations<T>.Add(leftWeighted, rightWeighted);
-    }
-
-    #endregion
-
-    #region Helper Classes
-
-    /// <summary>
-    /// Represents a node in the histogram-based decision tree.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Each node is either:
-    /// - A leaf node: makes a prediction (LeafValue)
-    /// - An internal node: splits based on a feature and threshold
-    /// </para>
-    /// </remarks>
-    private class HistTreeNode
-    {
-        public bool IsLeaf { get; set; } = true;
-        public T LeafValue { get; set; }
-        public int FeatureIndex { get; set; }
-        public int BinThreshold { get; set; }
-        public T Threshold { get; set; }
-        public HistTreeNode? Left { get; set; }
-        public HistTreeNode? Right { get; set; }
-        public List<int> SampleIndices { get; set; } = [];
-        public int Depth { get; set; }
-
-        public HistTreeNode(T zero)
-        {
-            LeafValue = zero;
-            Threshold = zero;
-        }
-
-        public HistTreeNode() : this(MathHelper.GetNumericOperations<T>().Zero) { }
-    }
-
-    /// <summary>
-    /// Represents a single bin in a gradient histogram.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> Each bin accumulates statistics about the samples
-    /// that fall into that bin:
-    /// - GradientSum: sum of residuals (for finding optimal leaf values)
-    /// - HessianSum: sum of hessians (for regularization)
-    /// - Count: number of samples
-    /// </para>
-    /// </remarks>
-    private class HistogramBin
-    {
-        public T GradientSum { get; set; }
-        public T HessianSum { get; set; }
-        public int Count { get; set; }
-
-        public HistogramBin(T zero)
-        {
-            GradientSum = zero;
-            HessianSum = zero;
-        }
-
-        public HistogramBin() : this(MathHelper.GetNumericOperations<T>().Zero) { }
-    }
-
-    /// <summary>
-    /// Contains information about a potential split.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// <b>For Beginners:</b> When evaluating splits, we track:
-    /// - Which feature to split on
-    /// - Which bin threshold to use
-    /// - How much gain (error reduction) the split provides
-    /// - How many samples go to each child
-    /// </para>
-    /// </remarks>
-    private class SplitInfo
-    {
-        public int FeatureIndex { get; set; }
-        public int BinThreshold { get; set; }
-        public T Gain { get; set; }
-        public int LeftCount { get; set; }
-        public int RightCount { get; set; }
-
-        public SplitInfo(T zero)
-        {
-            Gain = zero;
-        }
-
-        public SplitInfo() : this(MathHelper.GetNumericOperations<T>().Zero) { }
-    }
-
-    #endregion
-}
+
+namespace AiDotNet.Regression;
+
+/// <summary>
+/// Histogram-based Gradient Boosting Regression for fast training on large datasets.
+/// </summary>
+/// <typeparam name="T">The numeric type used for calculations (e.g., float, double).</typeparam>
+/// <remarks>
+/// <para>
+/// Histogram-based Gradient Boosting discretizes continuous features into a fixed number of bins,
+/// then builds histograms of gradients and hessians for each bin. This approach dramatically
+/// reduces the time complexity of finding the best split from O(n*features) to O(bins*features),
+/// making it suitable for large datasets with millions of samples.
+/// </para>
+/// <para>
+/// <b>For Beginners:</b> Traditional gradient boosting looks at every possible split point
+/// for every feature, which is slow for large datasets. Histogram-based methods group similar
+/// values into "bins" first, then only consider splits between bins.
+///
+/// Think of it like sorting students by height:
+/// - Traditional method: Consider every student's exact height as a potential grouping point
+/// - Histogram method: First group students into height ranges (5'0"-5'2", 5'2"-5'4", etc.),
+///   then only consider splitting between groups
+///
+/// This is much faster because there are far fewer groups than individual heights.
+///
+/// Key advantages:
+/// - 10-100x faster than traditional gradient boosting on large datasets
+/// - Memory efficient (stores bin indices, not raw values)
+/// - Handles missing values naturally
+/// - Similar accuracy to traditional methods
+///
+/// This is the same approach used by LightGBM, XGBoost (hist mode), and scikit-learn's
+/// HistGradientBoostingRegressor.
+///
+/// Usage:
+/// <code>
+/// var options = new HistGradientBoostingOptions { NumberOfIterations = 100, LearningRate = 0.1 };
+/// var model = new HistGradientBoostingRegression&lt;double&gt;(options);
+/// model.Train(X, y);
+/// var predictions = model.Predict(X_test);
+/// </code>
+/// </para>
+/// </remarks>
+/// <example>
+/// <code>
+/// // Create a histogram-based gradient boosting regression for fast large-scale training
+/// var options = new HistGradientBoostingOptions&lt;double&gt;();
+/// var model = new HistGradientBoostingRegression&lt;double&gt;(options);
+///
+/// // Prepare training data: 6 samples with 2 features each
+/// var features = Matrix&lt;double&gt;.Build.Dense(6, 2, new double[] {
+///     1, 2,  3, 4,  5, 6,  7, 8,  9, 10,  11, 12 });
+/// var targets = new Vector&lt;double&gt;(new double[] { 3.0, 7.1, 11.0, 15.2, 19.0, 23.1 });
+///
+/// // Train with histogram binning for O(bins*features) split finding
+/// model.Train(features, targets);
+///
+/// // Predict for a new sample
+/// var newSample = Matrix&lt;double&gt;.Build.Dense(1, 2, new double[] { 13, 14 });
+/// var prediction = model.Predict(newSample);
+/// </code>
+/// </example>
+[ModelDomain(ModelDomain.MachineLearning)]
+[ModelCategory(ModelCategory.Ensemble)]
+[ModelCategory(ModelCategory.DecisionTree)]
+[ModelTask(ModelTask.Regression)]
+[ModelComplexity(ModelComplexity.High)]
+[ModelInput(typeof(Matrix<>), typeof(Vector<>))]
+[ResearchPaper("LightGBM: A Highly Efficient Gradient Boosting Decision Tree", "https://papers.nips.cc/paper/6907-lightgbm-a-highly-efficient-gradient-boosting-decision-tree", Year = 2017, Authors = "Guolin Ke, Qi Meng, Thomas Finley, Taifeng Wang, Wei Chen, Weidong Ma, Qiwei Ye, Tie-Yan Liu")]
+public partial class HistGradientBoostingRegression<T> : ModelBase<T, Matrix<T>, Vector<T>>, IConfigurableModel<T>
+{
+    #region Fields
+
+    /// <summary>
+    /// Configuration options for the histogram gradient boosting algorithm.
+    /// </summary>
+    private readonly HistGradientBoostingOptions _options;
+
+    /// <inheritdoc/>
+    public ModelOptions GetOptions() => _options;
+
+    /// <summary>
+    /// Bin thresholds for each feature (jagged array).
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// <b>For Beginners:</b> These are the "boundaries" between bins for each feature.
+    /// For example, if a feature is temperature with thresholds [30, 50, 70, 90],
+    /// then values 0-30 go in bin 0, 30-50 in bin 1, etc.
+    /// </para>
+    /// </remarks>
+    private T[][]? _binThresholds;
+
+    /// <summary>
+    /// Binned feature values for training data.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// <b>For Beginners:</b> Instead of storing raw feature values, we store which
+    /// bin each value falls into. This is more memory efficient and faster to process.
+    /// </para>
+    /// </remarks>
+    private byte[,]? _binnedData;
+
+    /// <summary>
+    /// The collection of histogram-based trees.
+    /// </summary>
+    private List<HistTreeNode>? _trees;
+
+    /// <summary>
+    /// The initial prediction (mean of target values).
+    /// </summary>
+    private T _initialPrediction;
+
+    /// <summary>
+    /// Feature importance scores accumulated during training.
+    /// </summary>
+    private T[]? _featureImportances;
+
+    /// <summary>
+    /// Random number generator for subsampling.
+    /// </summary>
+    private readonly Random _random;
+
+    /// <summary>
+    /// Number of features in the training data.
+    /// </summary>
+    private int _numFeatures;
+
+    /// <summary>
+    /// Active feature indices that are actually used by the model.
+    /// </summary>
+    private HashSet<int>? _activeFeatureIndices;
+
+    /// <summary>
+    /// The default loss function for gradient computation.
+    /// </summary>
+    private readonly ILossFunction<T> _defaultLossFunction;
+
+    #endregion
+
+    #region Constructor
+
+    /// <summary>
+    /// Initializes a new instance of the HistGradientBoostingRegression class.
+    /// </summary>
+    /// <param name="options">Configuration options for the algorithm.</param>
+    /// <remarks>
+    /// <para>
+    /// <b>For Beginners:</b> Creates a new histogram-based gradient boosting model.
+    /// You can customize the behavior by providing options, or use defaults.
+    ///
+    /// Example with defaults:
+    /// <code>
+    /// var model = new HistGradientBoostingRegression&lt;double&gt;();
+    /// </code>
+    ///
+    /// Example with custom options:
+    /// <code>
+    /// var options = new HistGradientBoostingOptions
+    /// {
+    ///     NumberOfIterations = 200,
+    ///     LearningRate = 0.05,
+    ///     MaxDepth = 4
+    /// };
+    /// var model = new HistGradientBoostingRegression&lt;double&gt;(options);
+    /// </code>
+    /// </para>
+    /// </remarks>
+    public HistGradientBoostingRegression(HistGradientBoostingOptions? options = null)
+    {
+        _options = options ?? new HistGradientBoostingOptions();
+        _initialPrediction = NumOps.Zero;
+        _random = _options.Seed.HasValue
+            ? RandomHelper.CreateSeededRandom(_options.Seed.Value)
+            : RandomHelper.CreateSecureRandom();
+        _defaultLossFunction = new MeanSquaredErrorLoss<T>();
+    }
+
+    // ParameterCount override is below (returns 0 to prevent optimizer parameter injection)
+
+    #endregion
+
+    #region IFullModel Implementation
+
+    /// <summary>
+    /// Gets the model type identifier.
+    /// </summary>
+
+    /// <summary>
+    /// Gets or sets the feature names.
+    /// </summary>
+    public string[]? FeatureNames { get; set; }
+
+    /// <summary>
+    /// Trains the model on the provided data.
+    /// </summary>
+    /// <param name="x">Feature matrix where each row is a sample.</param>
+    /// <param name="y">Target values.</param>
+    /// <remarks>
+    /// <para>
+    /// <b>For Beginners:</b> This is where the model learns from your data.
+    /// The algorithm:
+    /// 1. Bins the feature values into discrete groups
+    /// 2. Computes the initial prediction (mean of targets)
+    /// 3. For each iteration:
+    ///    a. Compute residuals (how wrong current predictions are)
+    ///    b. Build a tree to predict the residuals
+    ///    c. Add the tree's predictions to the ensemble
+    /// </para>
+    /// </remarks>
+    public override void Train(Matrix<T> x, Vector<T> y)
+    {
+        _numFeatures = x.Columns;
+
+        // Step 1: Bin the features
+        BinFeatures(x);
+
+        // Step 2: Compute initial prediction (mean of y)
+        T sum = NumOps.Zero;
+        for (int i = 0; i < y.Length; i++)
+        {
+            sum = NumOps.Add(sum, y[i]);
+        }
+        _initialPrediction = NumOps.Divide(sum, NumOps.FromDouble(y.Length));
+
+        // Step 3: Initialize predictions and residuals
+        var predictions = new T[y.Length];
+        var residuals = new T[y.Length];
+
+        for (int i = 0; i < y.Length; i++)
+        {
+            predictions[i] = _initialPrediction;
+            residuals[i] = NumOps.Subtract(y[i], predictions[i]);
+        }
+
+        // Step 4: Initialize trees and feature importances
+        _trees = new List<HistTreeNode>(_options.NumberOfIterations);
+        _featureImportances = new T[_numFeatures];
+        for (int i = 0; i < _numFeatures; i++)
+        {
+            _featureImportances[i] = NumOps.Zero;
+        }
+
+        // Step 5: Build trees iteratively
+        for (int iteration = 0; iteration < _options.NumberOfIterations; iteration++)
+        {
+            // Subsample indices
+            int[] sampleIndices = GetSubsampleIndices(y.Length);
+
+            // Build tree on residuals
+            var tree = BuildTree(residuals, sampleIndices);
+            _trees.Add(tree);
+
+            // Update predictions
+            T lr = NumOps.FromDouble(_options.LearningRate);
+            for (int i = 0; i < y.Length; i++)
+            {
+                T treePred = PredictSingleTree(tree, i);
+                predictions[i] = NumOps.Add(predictions[i], NumOps.Multiply(lr, treePred));
+                residuals[i] = NumOps.Subtract(y[i], predictions[i]);
+            }
+        }
+
+        // Normalize feature importances
+        NormalizeFeatureImportances();
+    }
+
+    /// <summary>
+    /// Makes predictions for new data.
+    /// </summary>
+    /// <param name="input">Feature matrix for prediction.</param>
+    /// <returns>Predicted values.</returns>
+    /// <remarks>
+    /// <para>
+    /// <b>For Beginners:</b> After training, use this to make predictions on new data.
+    /// The prediction is: initial_prediction + learning_rate * sum(tree_predictions)
+    /// </para>
+    /// </remarks>
+    public override Vector<T> Predict(Matrix<T> input)
+    {
+        if (_trees is null || _binThresholds is null)
+        {
+            throw new InvalidOperationException("Model must be trained before making predictions.");
+        }
+
+        var predictions = new Vector<T>(input.Rows);
+        T lr = NumOps.FromDouble(_options.LearningRate);
+
+        for (int i = 0; i < input.Rows; i++)
+        {
+            T pred = _initialPrediction;
+
+            // Bin the input features
+            var binnedRow = BinRow(input, i);
+
+            // Add contribution from each tree
+            foreach (var tree in _trees)
+            {
+                pred = NumOps.Add(pred, NumOps.Multiply(lr, PredictSingleTreeFromBins(tree, binnedRow)));
+            }
+
+            predictions[i] = pred;
+        }
+
+        return predictions;
+    }
+
+    /// <summary>
+    /// Gets model metadata.
+    /// </summary>
+    public override ModelMetadata<T> GetModelMetadata()
+    {
+        return new ModelMetadata<T>
+        {
+            AdditionalInfo = new Dictionary<string, object>
+            {
+                { "NumberOfTrees", _trees?.Count ?? 0 },
+                { "NumberOfIterations", _options.NumberOfIterations },
+                { "LearningRate", _options.LearningRate },
+                { "MaxBins", _options.MaxBins },
+                { "MaxDepth", _options.MaxDepth },
+                { "MaxLeafNodes", _options.MaxLeafNodes ?? -1 },
+                { "MinSamplesLeaf", _options.MinSamplesLeaf },
+                { "L2Regularization", _options.L2Regularization }
+            }
+        };
+    }
+
+    /// <summary>
+    /// Gets the feature importance scores.
+    /// </summary>
+    public override Dictionary<string, T> GetFeatureImportance()
+    {
+        var result = new Dictionary<string, T>();
+
+        if (_featureImportances is null)
+        {
+            return result;
+        }
+
+        for (int i = 0; i < _featureImportances.Length; i++)
+        {
+            string name = FeatureNames is not null && i < FeatureNames.Length
+                ? FeatureNames[i]
+                : $"Feature_{i}";
+            result[name] = _featureImportances[i];
+        }
+
+        return result;
+    }
+
+    /// <summary>
+    /// The model's one continuous parameter: the initial prediction the boosted trees correct.
+    /// </summary>
+    /// <remarks>
+    /// The surface this replaces returned TWO values -- the initial prediction and the tree COUNT.
+    /// A count is structure, not a parameter: SetParameters read only the first slot and ignored
+    /// the second, so the vector advertised a value it could never restore, and any caller pairing
+    /// the two by length was silently working with one dead slot. The trees themselves are not a
+    /// flat vector at all; they round-trip through serialization.
+    /// </remarks>
+    protected override void RegisterComponents()
+    {
+        base.RegisterComponents();
+        RegisterParameterComponent(new ScalarParameterSource<T>(
+            () => _initialPrediction,
+            value => _initialPrediction = value));
+    }
+
+    // Replaced by the declared parameter source below. Removed under AIDN082.
+
+    // Replaced by the declared parameter source below. Removed under AIDN082.
+
+    /// <summary>
+    /// Creates a new instance with the given parameters.
+    /// </summary>
+    public override IFullModel<T, Matrix<T>, Vector<T>> WithParameters(Vector<T> parameters)
+    {
+        var newModel = new HistGradientBoostingRegression<T>(_options);
+        newModel.SetParameters(parameters);
+        return newModel;
+    }
+
+    /// <summary>
+    /// Gets the default loss function used for gradient computation.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// <b>For Beginners:</b> Histogram Gradient Boosting uses Mean Squared Error (MSE)
+    /// as its default loss function for regression tasks. MSE measures the average
+    /// squared difference between predictions and actual values.
+    /// </para>
+    /// </remarks>
+    public override ILossFunction<T> DefaultLossFunction => _defaultLossFunction;
+
+    /// <summary>
+    /// Gets the number of parameters in the model.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// <b>For Beginners:</b> For histogram-based gradient boosting, the "parameters"
+    /// include the initial prediction and all leaf values across all trees.
+    /// This is a simplification since the actual model is tree-structured.
+    /// </para>
+    /// </remarks>
+    /// <summary>
+    /// Returns 0 to prevent optimizer random parameter injection.
+    /// Histogram gradient boosting builds trees internally.
+    /// </summary>
+        /// <remarks>
+    /// Expressed as a capability, not as a count. A zero ParameterCount also suppresses
+    /// injection -- that is why this was written that way -- but it overloads a COUNT to carry
+    /// a CAPABILITY: the model does have parameters (the base getter returns its coefficients
+    /// and intercept), so the count contradicted the vector and anything pairing the two by
+    /// length saw parameters the model claimed not to have.
+    /// </remarks>
+    public override bool SupportsParameterInitialization => false;
+
+    /// <summary>
+    /// Saves the model to a file.
+    /// </summary>
+    /// <param name="filePath">The path where the model should be saved.</param>
+    /// <remarks>
+    /// <para>
+    /// <b>For Beginners:</b> This saves your trained model to a file so you can
+    /// load it later without retraining.
+    /// </para>
+    /// </remarks>
+    public override void SaveModel(string filePath)
+    {
+        Helpers.ModelPersistenceGuard.EnforceBeforeSave();
+        using (Helpers.ModelPersistenceGuard.InternalOperation())
+        {
+            byte[] data = Serialize();
+            File.WriteAllBytes(filePath, data);
+        }
+    }
+
+    /// <summary>
+    /// Loads the model from a file.
+    /// </summary>
+    /// <param name="filePath">The path to the saved model file.</param>
+    /// <remarks>
+    /// <para>
+    /// <b>For Beginners:</b> This loads a previously saved model so you can use
+    /// it for predictions without retraining.
+    /// </para>
+    /// </remarks>
+    public override void LoadModel(string filePath)
+    {
+        Helpers.ModelPersistenceGuard.EnforceBeforeLoad();
+        using (Helpers.ModelPersistenceGuard.InternalOperation())
+        {
+            byte[] data = File.ReadAllBytes(filePath);
+            Deserialize(data);
+        }
+    }
+
+    /// <summary>
+    /// Saves the model state to a stream.
+    /// </summary>
+    /// <param name="stream">The stream to write to.</param>
+    /// <remarks>
+    /// <para>
+    /// <b>For Beginners:</b> This is useful for checkpointing during training
+    /// or for storing models in databases/memory.
+    /// </para>
+    /// </remarks>
+    public override void SaveState(Stream stream)
+    {
+        byte[] data = Serialize();
+        using var writer = new BinaryWriter(stream, System.Text.Encoding.UTF8, leaveOpen: true);
+        writer.Write(data.Length);
+        writer.Write(data);
+        writer.Flush();
+    }
+
+    /// <summary>
+    /// Loads the model state from a stream.
+    /// </summary>
+    /// <param name="stream">The stream to read from.</param>
+    /// <remarks>
+    /// <para>
+    /// <b>For Beginners:</b> This restores a model from a checkpoint or database.
+    /// </para>
+    /// </remarks>
+    public override void LoadState(Stream stream)
+    {
+        using var reader = new BinaryReader(stream, System.Text.Encoding.UTF8, leaveOpen: true);
+        int length = reader.ReadInt32();
+        byte[] data = reader.ReadBytes(length);
+        Deserialize(data);
+    }
+
+    /// <summary>
+    /// Gets the indices of features that are actively used by the model.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// <b>For Beginners:</b> Returns which features are actually used in the trees.
+    /// Features not used by any split may be irrelevant for predictions.
+    /// </para>
+    /// </remarks>
+    public override IEnumerable<int> GetActiveFeatureIndices()
+    {
+        if (_activeFeatureIndices is null)
+        {
+            _activeFeatureIndices = new HashSet<int>();
+            if (_trees is not null)
+            {
+                foreach (var tree in _trees)
+                {
+                    CollectActiveFeatures(tree, _activeFeatureIndices);
+                }
+            }
+        }
+        return _activeFeatureIndices;
+    }
+
+    /// <summary>
+    /// Sets the active feature indices for the model.
+    /// </summary>
+    /// <param name="featureIndices">The feature indices to mark as active.</param>
+    /// <remarks>
+    /// <para>
+    /// <b>For Beginners:</b> This allows you to manually specify which features
+    /// the model should consider. Usually computed automatically during training.
+    /// </para>
+    /// </remarks>
+    public override void SetActiveFeatureIndices(IEnumerable<int> featureIndices)
+    {
+        _activeFeatureIndices = new HashSet<int>(featureIndices);
+    }
+
+    /// <summary>
+    /// Checks if a specific feature is used by the model.
+    /// </summary>
+    /// <param name="featureIndex">The index of the feature to check.</param>
+    /// <returns>True if the feature is used in any tree split.</returns>
+    /// <remarks>
+    /// <para>
+    /// <b>For Beginners:</b> This tells you if a specific feature contributes to
+    /// predictions. Unused features can be removed from future training data.
+    /// </para>
+    /// </remarks>
+    public override bool IsFeatureUsed(int featureIndex)
+    {
+        var activeFeatures = GetActiveFeatureIndices();
+        return activeFeatures.Contains(featureIndex);
+    }
+
+    /// <summary>
+    /// Computes gradients without updating parameters.
+    /// </summary>
+    /// <param name="input">The input features.</param>
+    /// <param name="target">The target values.</param>
+    /// <param name="lossFunction">Optional loss function (uses default if null).</param>
+    /// <returns>Gradient vector.</returns>
+    /// <remarks>
+    /// <para>
+    /// <b>For Beginners:</b> Gradient boosting computes gradients (residuals) as
+    /// the direction to improve predictions. For MSE loss, the gradient is simply
+    /// the difference between predictions and targets.
+    /// </para>
+    /// </remarks>
+    public override Vector<T> ComputeGradients(Matrix<T> input, Vector<T> target, ILossFunction<T>? lossFunction = null)
+    {
+        var loss = lossFunction ?? _defaultLossFunction;
+        var predictions = Predict(input);
+
+        // Compute gradients (negative of loss derivative with respect to predictions)
+        var gradients = new Vector<T>(target.Length);
+        for (int i = 0; i < target.Length; i++)
+        {
+            // For MSE: derivative = 2 * (prediction - target)
+            // We return the negative gradient (direction of improvement)
+            var diff = NumOps.Subtract(target[i], predictions[i]);
+            gradients[i] = NumOps.Multiply(NumOps.FromDouble(2.0), diff);
+        }
+
+        return gradients;
+    }
+
+    /// <summary>
+    /// Applies gradients to update the model.
+    /// </summary>
+    /// <param name="gradients">The gradient vector to apply.</param>
+    /// <param name="learningRate">The learning rate for the update.</param>
+    /// <remarks>
+    /// <para>
+    /// <b>For Beginners:</b> For tree-based models, applying gradients means
+    /// adjusting the initial prediction and leaf values. This is a simplified
+    /// update that shifts predictions in the direction of the gradients.
+    /// </para>
+    /// </remarks>
+    public override void ApplyGradients(Vector<T> gradients, T learningRate)
+    {
+        // For gradient boosting, we adjust the initial prediction based on average gradient
+        if (gradients.Length > 0)
+        {
+            T sum = NumOps.Zero;
+            for (int i = 0; i < gradients.Length; i++)
+            {
+                sum = NumOps.Add(sum, gradients[i]);
+            }
+            T avgGradient = NumOps.Divide(sum, NumOps.FromDouble(gradients.Length));
+            T update = NumOps.Multiply(learningRate, avgGradient);
+            _initialPrediction = NumOps.Add(_initialPrediction, update);
+        }
+    }
+
+    /// <summary>
+    /// Counts the number of leaves in a tree.
+    /// </summary>
+    private int CountLeaves(HistTreeNode node)
+    {
+        if (node.IsLeaf)
+        {
+            return 1;
+        }
+        int count = 0;
+        if (node.Left is not null)
+        {
+            count += CountLeaves(node.Left);
+        }
+        if (node.Right is not null)
+        {
+            count += CountLeaves(node.Right);
+        }
+        return count;
+    }
+
+    /// <summary>
+    /// Recursively collects active feature indices from a tree.
+    /// </summary>
+    private void CollectActiveFeatures(HistTreeNode node, HashSet<int> features)
+    {
+        if (node.IsLeaf)
+        {
+            return;
+        }
+        features.Add(node.FeatureIndex);
+        if (node.Left is not null)
+        {
+            CollectActiveFeatures(node.Left, features);
+        }
+        if (node.Right is not null)
+        {
+            CollectActiveFeatures(node.Right, features);
+        }
+    }
+
+    #endregion
+
+    #region Binning
+
+    /// <summary>
+    /// Bins all features in the training data.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// <b>For Beginners:</b> This converts continuous feature values into discrete bins.
+    /// For each feature:
+    /// 1. Find the unique values
+    /// 2. Determine bin boundaries (quantiles or uniform)
+    /// 3. Assign each value to a bin (0 to MaxBins-1)
+    ///
+    /// This is a key optimization that makes the algorithm fast.
+    /// </para>
+    /// </remarks>
+    private void BinFeatures(Matrix<T> x)
+    {
+        int numSamples = x.Rows;
+        int numFeatures = x.Columns;
+
+        _binThresholds = new T[numFeatures][];
+        _binnedData = new byte[numSamples, numFeatures];
+
+        for (int f = 0; f < numFeatures; f++)
+        {
+            // Extract and sort feature values
+            var values = new List<double>(numSamples);
+            for (int i = 0; i < numSamples; i++)
+            {
+                values.Add(NumOps.ToDouble(x[i, f]));
+            }
+            values.Sort();
+
+            // Compute bin thresholds using quantiles
+            var thresholds = ComputeQuantileThresholds(values);
+            _binThresholds[f] = thresholds.Select(t => NumOps.FromDouble(t)).ToArray();
+
+            // Bin each value
+            for (int i = 0; i < numSamples; i++)
+            {
+                double val = NumOps.ToDouble(x[i, f]);
+                _binnedData[i, f] = (byte)FindBin(val, thresholds);
+            }
+        }
+    }
+
+    /// <summary>
+    /// Computes quantile-based bin thresholds.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// <b>For Beginners:</b> Instead of uniform bins, we use quantiles to ensure
+    /// each bin has roughly the same number of samples. This is more effective
+    /// when feature values are not uniformly distributed.
+    /// </para>
+    /// </remarks>
+    private List<double> ComputeQuantileThresholds(List<double> sortedValues)
+    {
+        var thresholds = new List<double>();
+        int n = sortedValues.Count;
+        int maxBins = Math.Min(_options.MaxBins, n);
+
+        if (maxBins <= 1)
+        {
+            return thresholds;
+        }
+
+        // Get unique values
+        var uniqueValues = sortedValues.Distinct().ToList();
+
+        if (uniqueValues.Count <= maxBins)
+        {
+            // Use midpoints between unique values as thresholds
+            for (int i = 0; i < uniqueValues.Count - 1; i++)
+            {
+                thresholds.Add((uniqueValues[i] + uniqueValues[i + 1]) / 2.0);
+            }
+        }
+        else
+        {
+            // Use quantiles
+            for (int i = 1; i < maxBins; i++)
+            {
+                double quantile = (double)i / maxBins;
+                int index = (int)(quantile * (n - 1));
+                double threshold = sortedValues[index];
+
+                // Avoid duplicate thresholds
+                if (thresholds.Count == 0 || threshold > thresholds[^1])
+                {
+                    thresholds.Add(threshold);
+                }
+            }
+        }
+
+        return thresholds;
+    }
+
+    /// <summary>
+    /// Finds the bin index for a given value.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// <b>For Beginners:</b> Given a value and the bin thresholds, this finds
+    /// which bin the value belongs to using binary search for efficiency.
+    /// </para>
+    /// </remarks>
+    private int FindBin(double value, List<double> thresholds)
+    {
+        // Binary search for the correct bin
+        int left = 0;
+        int right = thresholds.Count;
+
+        while (left < right)
+        {
+            int mid = (left + right) / 2;
+            if (value <= thresholds[mid])
+            {
+                right = mid;
+            }
+            else
+            {
+                left = mid + 1;
+            }
+        }
+
+        return left;
+    }
+
+    /// <summary>
+    /// Bins a single row of new data for prediction.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// <b>For Beginners:</b> When making predictions on new data, we need to
+    /// bin the features using the same thresholds learned during training.
+    /// </para>
+    /// </remarks>
+    private byte[] BinRow(Matrix<T> x, int row)
+    {
+        var binned = new byte[_numFeatures];
+
+        for (int f = 0; f < _numFeatures; f++)
+        {
+            double val = NumOps.ToDouble(x[row, f]);
+            var thresholds = (_binThresholds ?? throw new InvalidOperationException("Bin thresholds not computed."))[f].Select(t => NumOps.ToDouble(t)).ToList();
+            binned[f] = (byte)FindBin(val, thresholds);
+        }
+
+        return binned;
+    }
+
+    #endregion
+
+    #region Tree Building
+
+    /// <summary>
+    /// Gets subsample indices for stochastic gradient boosting.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// <b>For Beginners:</b> If SubsampleRatio is less than 1.0, we randomly
+    /// select a subset of samples to train each tree. This adds randomness
+    /// that can improve generalization.
+    /// </para>
+    /// </remarks>
+    private int[] GetSubsampleIndices(int totalSamples)
+    {
+        if (_options.SubsampleRatio >= 1.0)
+        {
+            return Enumerable.Range(0, totalSamples).ToArray();
+        }
+
+        int subsampleSize = (int)(totalSamples * _options.SubsampleRatio);
+        var indices = new HashSet<int>();
+
+        while (indices.Count < subsampleSize)
+        {
+            indices.Add(_random.Next(totalSamples));
+        }
+
+        return indices.ToArray();
+    }
+
+    /// <summary>
+    /// Builds a single histogram-based tree.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// <b>For Beginners:</b> This builds a decision tree using histograms for
+    /// efficient split finding. The algorithm:
+    /// 1. Start with all samples at the root
+    /// 2. Find the best split using histograms
+    /// 3. Split into left and right children
+    /// 4. Recursively build children until stopping criteria
+    /// </para>
+    /// </remarks>
+    private HistTreeNode BuildTree(T[] residuals, int[] sampleIndices)
+    {
+        var root = new HistTreeNode(NumOps.Zero)
+        {
+            SampleIndices = sampleIndices.ToList(),
+            Depth = 0
+        };
+
+        // Use a priority queue for best-first growth
+        var queue = new List<HistTreeNode> { root };
+        int leafCount = 1;
+
+        while (queue.Count > 0)
+        {
+            // Find the node with the best potential gain
+            int bestIdx = -1;
+            T bestGain = NumOps.MinValue;
+            SplitInfo? bestSplit = null;
+
+            for (int i = 0; i < queue.Count; i++)
+            {
+                var node = queue[i];
+
+                // Check stopping criteria
+                if (node.Depth >= _options.MaxDepth) continue;
+                if (node.SampleIndices.Count < 2 * _options.MinSamplesLeaf) continue;
+
+                // Find best split for this node
+                var split = FindBestSplit(node, residuals);
+
+                if (split is not null && NumOps.GreaterThan(split.Gain, bestGain))
+                {
+                    bestGain = split.Gain;
+                    bestSplit = split;
+                    bestIdx = i;
+                }
+            }
+
+            // If no beneficial split found or max leaves reached, stop
+            if (bestIdx < 0 || bestSplit is null ||
+                (_options.MaxLeafNodes.HasValue && leafCount >= _options.MaxLeafNodes.Value))
+            {
+                break;
+            }
+
+            // Apply the best split
+            var nodeToSplit = queue[bestIdx];
+            queue.RemoveAt(bestIdx);
+
+            ApplySplit(nodeToSplit, bestSplit, residuals);
+
+            // Add children to queue
+            if (nodeToSplit.Left is not null)
+            {
+                queue.Add(nodeToSplit.Left);
+            }
+            if (nodeToSplit.Right is not null)
+            {
+                queue.Add(nodeToSplit.Right);
+            }
+
+            // Update feature importance
+            if (_featureImportances is not null)
+            {
+                _featureImportances[bestSplit.FeatureIndex] = NumOps.Add(
+                    _featureImportances[bestSplit.FeatureIndex],
+                    bestSplit.Gain);
+            }
+
+            leafCount++;
+        }
+
+        // Set leaf values for remaining nodes
+        foreach (var node in queue)
+        {
+            SetLeafValue(node, residuals);
+        }
+
+        // Also ensure root has a leaf value if it was never split
+        if (root.Left is null && root.Right is null)
+        {
+            SetLeafValue(root, residuals);
+        }
+
+        return root;
+    }
+
+    /// <summary>
+    /// Finds the best split for a node using histograms.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// <b>For Beginners:</b> This is the core of histogram-based gradient boosting.
+    /// Instead of checking every possible split point:
+    /// 1. Build a histogram counting gradient sums for each bin
+    /// 2. Only check splits between bins
+    ///
+    /// This reduces complexity from O(n) to O(bins).
+    /// </para>
+    /// </remarks>
+    private SplitInfo? FindBestSplit(HistTreeNode node, T[] residuals)
+    {
+        SplitInfo? bestSplit = null;
+        T bestGain = NumOps.FromDouble(_options.MinGainToSplit);
+
+        // Get features to consider (column subsampling)
+        var featuresToConsider = GetFeaturesToConsider();
+
+        foreach (int featureIdx in featuresToConsider)
+        {
+            // Build histogram for this feature
+            var histogram = BuildHistogram(node.SampleIndices, featureIdx, residuals);
+
+            // Find best split point in histogram
+            var split = FindBestSplitInHistogram(histogram, featureIdx, node.SampleIndices.Count);
+
+            if (split is not null && NumOps.GreaterThan(split.Gain, bestGain))
+            {
+                bestGain = split.Gain;
+                bestSplit = split;
+            }
+        }
+
+        return bestSplit;
+    }
+
+    /// <summary>
+    /// Gets feature indices to consider for splitting (column subsampling).
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// <b>For Beginners:</b> If ColsampleByTree is less than 1.0, we randomly
+    /// select a subset of features to consider for each split. This adds
+    /// diversity to the trees.
+    /// </para>
+    /// </remarks>
+    private List<int> GetFeaturesToConsider()
+    {
+        if (_options.ColsampleByTree >= 1.0)
+        {
+            return Enumerable.Range(0, _numFeatures).ToList();
+        }
+
+        int numFeaturesToUse = Math.Max(1, (int)(_numFeatures * _options.ColsampleByTree));
+        var allFeatures = Enumerable.Range(0, _numFeatures).ToList();
+
+        // Shuffle and take first numFeaturesToUse
+        for (int i = allFeatures.Count - 1; i > 0; i--)
+        {
+            int j = _random.Next(i + 1);
+            (allFeatures[i], allFeatures[j]) = (allFeatures[j], allFeatures[i]);
+        }
+
+        return allFeatures.Take(numFeaturesToUse).ToList();
+    }
+
+    /// <summary>
+    /// Builds a gradient histogram for a feature.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// <b>For Beginners:</b> A histogram accumulates the sum of residuals (gradients)
+    /// for each bin. This allows us to quickly compute the gain for any split point.
+    /// </para>
+    /// </remarks>
+    private HistogramBin[] BuildHistogram(List<int> sampleIndices, int featureIdx, T[] residuals)
+    {
+        int numBins = (_binThresholds ?? throw new InvalidOperationException("Bin thresholds not computed."))[featureIdx].Length + 1;
+        var histogram = new HistogramBin[numBins];
+
+        for (int i = 0; i < numBins; i++)
+        {
+            histogram[i] = new HistogramBin(NumOps.Zero);
+        }
+
+        foreach (int idx in sampleIndices)
+        {
+            int bin = (_binnedData ?? throw new InvalidOperationException("Binned data not computed."))[idx, featureIdx];
+            histogram[bin].GradientSum = NumOps.Add(histogram[bin].GradientSum, residuals[idx]);
+            histogram[bin].HessianSum = NumOps.Add(histogram[bin].HessianSum, NumOps.One); // Squared loss has hessian = 1
+            histogram[bin].Count++;
+        }
+
+        return histogram;
+    }
+
+    /// <summary>
+    /// Finds the best split point within a histogram.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// <b>For Beginners:</b> Given the histogram, we scan through all possible
+    /// split points (between bins) and compute the gain for each. The gain
+    /// measures how much the split reduces prediction error.
+    ///
+    /// Gain = (left_gradient²/left_hessian + right_gradient²/right_hessian - total_gradient²/total_hessian) / 2
+    ///        - regularization_penalty
+    /// </para>
+    /// </remarks>
+    private SplitInfo? FindBestSplitInHistogram(HistogramBin[] histogram, int featureIdx, int totalCount)
+    {
+        // Compute totals
+        T totalGrad = NumOps.Zero;
+        T totalHess = NumOps.Zero;
+        foreach (var bin in histogram)
+        {
+            totalGrad = NumOps.Add(totalGrad, bin.GradientSum);
+            totalHess = NumOps.Add(totalHess, bin.HessianSum);
+        }
+
+        T bestGain = NumOps.FromDouble(_options.MinGainToSplit);
+        int bestBin = -1;
+
+        T leftGrad = NumOps.Zero;
+        T leftHess = NumOps.Zero;
+        int leftCount = 0;
+        T lambda = NumOps.FromDouble(_options.L2Regularization);
+        T half = NumOps.FromDouble(0.5);
+
+        // Try each split point
+        for (int bin = 0; bin < histogram.Length - 1; bin++)
+        {
+            leftGrad = NumOps.Add(leftGrad, histogram[bin].GradientSum);
+            leftHess = NumOps.Add(leftHess, histogram[bin].HessianSum);
+            leftCount += histogram[bin].Count;
+
+            // Check minimum samples constraint
+            int rightCount = totalCount - leftCount;
+            if (leftCount < _options.MinSamplesLeaf || rightCount < _options.MinSamplesLeaf)
+            {
+                continue;
+            }
+
+            T rightGrad = NumOps.Subtract(totalGrad, leftGrad);
+            T rightHess = NumOps.Subtract(totalHess, leftHess);
+
+            // Compute gain with L2 regularization
+            // gain = 0.5 * (leftGrad^2/(leftHess+lambda) + rightGrad^2/(rightHess+lambda) - totalGrad^2/(totalHess+lambda))
+            T leftTerm = NumOps.Divide(NumOps.Multiply(leftGrad, leftGrad), NumOps.Add(leftHess, lambda));
+            T rightTerm = NumOps.Divide(NumOps.Multiply(rightGrad, rightGrad), NumOps.Add(rightHess, lambda));
+            T totalTerm = NumOps.Divide(NumOps.Multiply(totalGrad, totalGrad), NumOps.Add(totalHess, lambda));
+            T gain = NumOps.Multiply(half, NumOps.Subtract(NumOps.Add(leftTerm, rightTerm), totalTerm));
+
+            if (NumOps.GreaterThan(gain, bestGain))
+            {
+                bestGain = gain;
+                bestBin = bin;
+            }
+        }
+
+        if (bestBin < 0)
+        {
+            return null;
+        }
+
+        // Compute left and right counts for the best split
+        int bestLeftCount = 0;
+        for (int bin = 0; bin <= bestBin; bin++)
+        {
+            bestLeftCount += histogram[bin].Count;
+        }
+
+        return new SplitInfo(NumOps.Zero)
+        {
+            FeatureIndex = featureIdx,
+            BinThreshold = bestBin,
+            Gain = bestGain,
+            LeftCount = bestLeftCount,
+            RightCount = totalCount - bestLeftCount
+        };
+    }
+
+    /// <summary>
+    /// Applies a split to a node, creating left and right children.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// <b>For Beginners:</b> After finding the best split, this method:
+    /// 1. Creates left and right child nodes
+    /// 2. Assigns samples to each child based on their bin values
+    /// 3. Sets the split threshold on the parent node
+    /// </para>
+    /// </remarks>
+    private void ApplySplit(HistTreeNode node, SplitInfo split, T[] residuals)
+    {
+        var leftIndices = new List<int>();
+        var rightIndices = new List<int>();
+
+        foreach (int idx in node.SampleIndices)
+        {
+            int bin = (_binnedData ?? throw new InvalidOperationException("Binned data not computed."))[idx, split.FeatureIndex];
+            if (bin <= split.BinThreshold)
+            {
+                leftIndices.Add(idx);
+            }
+            else
+            {
+                rightIndices.Add(idx);
+            }
+        }
+
+        node.IsLeaf = false;
+        node.FeatureIndex = split.FeatureIndex;
+        node.BinThreshold = split.BinThreshold;
+
+        // Convert bin threshold to actual value for prediction
+        if (split.BinThreshold < (_binThresholds ?? throw new InvalidOperationException("Bin thresholds not computed."))[split.FeatureIndex].Length)
+        {
+            node.Threshold = _binThresholds[split.FeatureIndex][split.BinThreshold];
+        }
+        else
+        {
+            node.Threshold = NumOps.MaxValue;
+        }
+
+        node.Left = new HistTreeNode(NumOps.Zero)
+        {
+            SampleIndices = leftIndices,
+            Depth = node.Depth + 1
+        };
+
+        node.Right = new HistTreeNode(NumOps.Zero)
+        {
+            SampleIndices = rightIndices,
+            Depth = node.Depth + 1
+        };
+
+        // Set leaf values (may be overwritten if children are split further)
+        SetLeafValue(node.Left, residuals);
+        SetLeafValue(node.Right, residuals);
+    }
+
+    /// <summary>
+    /// Sets the prediction value for a leaf node.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// <b>For Beginners:</b> For squared error loss, the optimal leaf value is
+    /// the mean of the residuals at that leaf. With L2 regularization, this
+    /// becomes: sum(residuals) / (count + regularization)
+    /// </para>
+    /// </remarks>
+    private void SetLeafValue(HistTreeNode node, T[] residuals)
+    {
+        node.IsLeaf = true;
+
+        if (node.SampleIndices.Count == 0)
+        {
+            node.LeafValue = NumOps.Zero;
+            return;
+        }
+
+        T sum = NumOps.Zero;
+        foreach (int idx in node.SampleIndices)
+        {
+            sum = NumOps.Add(sum, residuals[idx]);
+        }
+
+        // Optimal leaf value with L2 regularization
+        T lambda = NumOps.FromDouble(_options.L2Regularization);
+        node.LeafValue = NumOps.Divide(sum, NumOps.Add(NumOps.FromDouble(node.SampleIndices.Count), lambda));
+    }
+
+    #endregion
+
+    #region Prediction
+
+    /// <summary>
+    /// Predicts using a single tree on binned training data.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// <b>For Beginners:</b> During training, we use the already-binned data
+    /// for faster prediction. This avoids re-binning at each iteration.
+    /// </para>
+    /// </remarks>
+    private T PredictSingleTree(HistTreeNode tree, int sampleIndex)
+    {
+        var node = tree;
+
+        while (!node.IsLeaf)
+        {
+            int bin = (_binnedData ?? throw new InvalidOperationException("Binned data not computed."))[sampleIndex, node.FeatureIndex];
+            if (node.Left is null || node.Right is null)
+            {
+                throw new InvalidOperationException("Internal tree node has null children.");
+            }
+            node = bin <= node.BinThreshold ? node.Left : node.Right;
+        }
+
+        return node.LeafValue;
+    }
+
+    /// <summary>
+    /// Predicts using a single tree from binned features.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// <b>For Beginners:</b> For new data that has been binned, traverse the
+    /// tree using bin indices to find the leaf prediction.
+    /// </para>
+    /// </remarks>
+    private T PredictSingleTreeFromBins(HistTreeNode tree, byte[] binnedRow)
+    {
+        var node = tree;
+
+        while (!node.IsLeaf)
+        {
+            int bin = binnedRow[node.FeatureIndex];
+            if (node.Left is null || node.Right is null)
+            {
+                throw new InvalidOperationException("Internal tree node has null children.");
+            }
+            node = bin <= node.BinThreshold ? node.Left : node.Right;
+        }
+
+        return node.LeafValue;
+    }
+
+    #endregion
+
+    #region Feature Importance
+
+    /// <summary>
+    /// Normalizes feature importances to sum to 1.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// <b>For Beginners:</b> Feature importance scores are accumulated during
+    /// training (total gain from splits using each feature). Normalizing makes
+    /// them easier to interpret as relative importance percentages.
+    /// </para>
+    /// </remarks>
+    private void NormalizeFeatureImportances()
+    {
+        if (_featureImportances is null) return;
+
+        T sum = NumOps.Zero;
+        foreach (var importance in _featureImportances)
+        {
+            sum = NumOps.Add(sum, importance);
+        }
+
+        if (NumOps.GreaterThan(sum, NumOps.Zero))
+        {
+            for (int i = 0; i < _featureImportances.Length; i++)
+            {
+                _featureImportances[i] = NumOps.Divide(_featureImportances[i], sum);
+            }
+        }
+    }
+
+    #endregion
+
+    #region Serialization Helpers
+
+    /// <summary>
+    /// Serializes a tree node recursively.
+    /// </summary>
+    private void SerializeTree(BinaryWriter writer, HistTreeNode node)
+    {
+        writer.Write(node.IsLeaf);
+        writer.Write(NumOps.ToDouble(node.LeafValue));
+        writer.Write(node.FeatureIndex);
+        writer.Write(node.BinThreshold);
+        writer.Write(NumOps.ToDouble(node.Threshold));
+        writer.Write(node.Depth);
+
+        if (!node.IsLeaf)
+        {
+            if (node.Left is null || node.Right is null)
+            {
+                throw new InvalidOperationException("Internal tree node has null children during serialization.");
+            }
+            SerializeTree(writer, node.Left);
+            SerializeTree(writer, node.Right);
+        }
+    }
+
+    /// <summary>
+    /// Deserializes a tree node recursively.
+    /// </summary>
+    private HistTreeNode DeserializeTree(BinaryReader reader)
+    {
+        var node = new HistTreeNode(NumOps.Zero)
+        {
+            IsLeaf = reader.ReadBoolean(),
+            LeafValue = NumOps.FromDouble(reader.ReadDouble()),
+            FeatureIndex = reader.ReadInt32(),
+            BinThreshold = reader.ReadInt32(),
+            Threshold = NumOps.FromDouble(reader.ReadDouble()),
+            Depth = reader.ReadInt32()
+        };
+
+        if (!node.IsLeaf)
+        {
+            node.Left = DeserializeTree(reader);
+            node.Right = DeserializeTree(reader);
+        }
+
+        return node;
+    }
+
+    #endregion
+
+    #region JIT Compilation Support
+
+    /// <summary>
+    /// Exports a soft decision tree as a computation graph.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// <b>For Beginners:</b> Hard decision trees use if-then-else logic which
+    /// isn't differentiable. Soft trees use sigmoid functions to smoothly
+    /// blend between branches, making them differentiable and suitable for
+    /// JIT compilation and hardware acceleration.
+    /// </para>
+    /// </remarks>
+    private ComputationNode<T> ExportSoftTree(ComputationNode<T> inputNode, HistTreeNode tree, double temperature)
+    {
+        return ExportSoftTreeNode(inputNode, tree, temperature);
+    }
+
+    /// <summary>
+    /// Recursively exports a tree node as a soft computation graph.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// <b>For Beginners:</b> For each internal node:
+    /// output = sigmoid(temp * (threshold - x[feature])) * left_output +
+    ///          (1 - sigmoid(...)) * right_output
+    ///
+    /// As temperature → ∞, this approaches a hard split.
+    /// </para>
+    /// </remarks>
+    private ComputationNode<T> ExportSoftTreeNode(ComputationNode<T> inputNode, HistTreeNode node, double temperature)
+    {
+        if (node.IsLeaf)
+        {
+            // Create constant for leaf value
+            var leafTensor = new Tensor<T>(new int[] { 1, 1 });
+            leafTensor[0, 0] = node.LeafValue;
+            return TensorOperations<T>.Constant(leafTensor, $"leaf_{node.GetHashCode()}");
+        }
+
+        // Get the feature value: x[:, featureIndex]
+        var featureSliceNode = TensorOperations<T>.Slice(inputNode, 0, node.FeatureIndex, node.FeatureIndex + 1);
+
+        // Create threshold constant
+        var thresholdTensor = new Tensor<T>(new int[] { 1, 1 });
+        thresholdTensor[0, 0] = node.Threshold;
+        var thresholdNode = TensorOperations<T>.Constant(thresholdTensor, $"threshold_{node.GetHashCode()}");
+
+        // Create temperature constant
+        var tempTensor = new Tensor<T>(new int[] { 1, 1 });
+        tempTensor[0, 0] = NumOps.FromDouble(temperature);
+        var tempNode = TensorOperations<T>.Constant(tempTensor, $"temp_{node.GetHashCode()}");
+
+        // Compute sigmoid(temperature * (threshold - x))
+        var diffNode = TensorOperations<T>.Subtract(thresholdNode, featureSliceNode);
+        var scaledDiffNode = TensorOperations<T>.ElementwiseMultiply(tempNode, diffNode);
+        var sigmoidNode = TensorOperations<T>.Sigmoid(scaledDiffNode);
+
+        // Get left and right subtree outputs
+        if (node.Left is null || node.Right is null)
+        {
+            throw new InvalidOperationException("Internal tree node has null children during graph export.");
+        }
+        var leftOutput = ExportSoftTreeNode(inputNode, node.Left, temperature);
+        var rightOutput = ExportSoftTreeNode(inputNode, node.Right, temperature);
+
+        // Compute: sigmoid * left + (1 - sigmoid) * right
+        var leftWeighted = TensorOperations<T>.ElementwiseMultiply(sigmoidNode, leftOutput);
+
+        var onesTensor = new Tensor<T>(new int[] { 1, 1 });
+        onesTensor[0, 0] = NumOps.One;
+        var onesNode = TensorOperations<T>.Constant(onesTensor, "ones");
+        var oneMinusSigmoid = TensorOperations<T>.Subtract(onesNode, sigmoidNode);
+
+        var rightWeighted = TensorOperations<T>.ElementwiseMultiply(oneMinusSigmoid, rightOutput);
+
+        return TensorOperations<T>.Add(leftWeighted, rightWeighted);
+    }
+
+    #endregion
+
+    #region Helper Classes
+
+    /// <summary>
+    /// Represents a node in the histogram-based decision tree.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// <b>For Beginners:</b> Each node is either:
+    /// - A leaf node: makes a prediction (LeafValue)
+    /// - An internal node: splits based on a feature and threshold
+    /// </para>
+    /// </remarks>
+    private class HistTreeNode
+    {
+        public bool IsLeaf { get; set; } = true;
+        public T LeafValue { get; set; }
+        public int FeatureIndex { get; set; }
+        public int BinThreshold { get; set; }
+        public T Threshold { get; set; }
+        public HistTreeNode? Left { get; set; }
+        public HistTreeNode? Right { get; set; }
+        public List<int> SampleIndices { get; set; } = [];
+        public int Depth { get; set; }
+
+        public HistTreeNode(T zero)
+        {
+            LeafValue = zero;
+            Threshold = zero;
+        }
+
+        public HistTreeNode() : this(MathHelper.GetNumericOperations<T>().Zero) { }
+    }
+
+    /// <summary>
+    /// Represents a single bin in a gradient histogram.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// <b>For Beginners:</b> Each bin accumulates statistics about the samples
+    /// that fall into that bin:
+    /// - GradientSum: sum of residuals (for finding optimal leaf values)
+    /// - HessianSum: sum of hessians (for regularization)
+    /// - Count: number of samples
+    /// </para>
+    /// </remarks>
+    private class HistogramBin
+    {
+        public T GradientSum { get; set; }
+        public T HessianSum { get; set; }
+        public int Count { get; set; }
+
+        public HistogramBin(T zero)
+        {
+            GradientSum = zero;
+            HessianSum = zero;
+        }
+
+        public HistogramBin() : this(MathHelper.GetNumericOperations<T>().Zero) { }
+    }
+
+    /// <summary>
+    /// Contains information about a potential split.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// <b>For Beginners:</b> When evaluating splits, we track:
+    /// - Which feature to split on
+    /// - Which bin threshold to use
+    /// - How much gain (error reduction) the split provides
+    /// - How many samples go to each child
+    /// </para>
+    /// </remarks>
+    private class SplitInfo
+    {
+        public int FeatureIndex { get; set; }
+        public int BinThreshold { get; set; }
+        public T Gain { get; set; }
+        public int LeftCount { get; set; }
+        public int RightCount { get; set; }
+
+        public SplitInfo(T zero)
+        {
+            Gain = zero;
+        }
+
+        public SplitInfo() : this(MathHelper.GetNumericOperations<T>().Zero) { }
+    }
+
+    #endregion
+}
diff --git a/src/Regression/InverseGaussianRegression.cs b/src/Regression/InverseGaussianRegression.cs
index 77cfc16858..0992a8e05b 100644
--- a/src/Regression/InverseGaussianRegression.cs
+++ b/src/Regression/InverseGaussianRegression.cs
@@ -63,7 +63,7 @@ namespace AiDotNet.Regression;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
     [ResearchPaper("Generalized Linear Models", "https://doi.org/10.1007/978-1-4899-3242-6")]
-public class InverseGaussianRegression<T> : RegressionBase<T>
+public partial class InverseGaussianRegression<T> : RegressionBase<T>
 {
     private const double MuFloor = 1e-10;
     private const double MuCeiling = 1e10;
@@ -508,109 +508,4 @@ public override Vector<T> Predict(Matrix<T> x)
             predictions[i] = NumOps.Add(predictions[i], Intercept);
         return predictions;
     }
-
-    /// <summary>
-    /// Serializes the model to a byte array.
-    /// </summary>
-    /// <returns>A byte array containing the serialized model data.</returns>
-    /// <remarks>
-    /// <para>
-    /// Serializes the model including options, coefficients, and dispersion parameter.
-    /// </para>
-    /// <para>
-    /// For Beginners:
-    /// Serialization saves the model so you can load it later without retraining.
-    /// </para>
-    /// </remarks>
-    public override byte[] Serialize()
-    {
-        using var ms = new MemoryStream();
-        using var writer = new BinaryWriter(ms);
-
-        // Serialize base class data
-        byte[] baseData = base.Serialize();
-        writer.Write(baseData.Length);
-        writer.Write(baseData);
-
-        // Serialize InverseGaussianRegression specific options
-        writer.Write(_options.MaxIterations);
-        writer.Write(_options.Tolerance);
-        writer.Write((int)_options.LinkFunction);
-        writer.Write((int)_options.DecompositionType);
-        writer.Write(_options.InitialDispersion);
-        writer.Write(NumOps.ToDouble(_dispersion));
-
-        return ms.ToArray();
-    }
-
-    /// <summary>
-    /// Deserializes the model from a byte array.
-    /// </summary>
-    /// <param name="data">The byte array containing the serialized model data.</param>
-    /// <remarks>
-    /// <para>
-    /// Reconstructs the model's state from the serialized data.
-    /// </para>
-    /// <para>
-    /// For Beginners:
-    /// Deserialization loads a previously saved model.
-    /// </para>
-    /// </remarks>
-    public override void Deserialize(byte[] data)
-    {
-        using var ms = new MemoryStream(data);
-        using var reader = new BinaryReader(ms);
-
-        // Deserialize base class data
-        int baseDataLength = reader.ReadInt32();
-        byte[] baseData = reader.ReadBytes(baseDataLength);
-        base.Deserialize(baseData);
-
-        // Deserialize InverseGaussianRegression specific options
-        _options.MaxIterations = reader.ReadInt32();
-        _options.Tolerance = reader.ReadDouble();
-        _options.LinkFunction = (InverseGaussianLinkFunction)reader.ReadInt32();
-        _options.DecompositionType = (MatrixDecompositionType)reader.ReadInt32();
-        _options.InitialDispersion = reader.ReadDouble();
-        _dispersion = NumOps.FromDouble(reader.ReadDouble());
-    }
-
-    /// <summary>
-    /// Creates a new instance of the Inverse Gaussian Regression model with the same configuration.
-    /// </summary>
-    /// <returns>A new instance of the Inverse Gaussian Regression model.</returns>
-    /// <remarks>
-    /// <para>
-    /// Creates a deep copy of the current model, including all options and coefficients.
-    /// </para>
-    /// <para>
-    /// For Beginners:
-    /// This method creates an exact copy of your trained model.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        var newOptions = new InverseGaussianRegressionOptions<T>
-        {
-            MaxIterations = _options.MaxIterations,
-            Tolerance = _options.Tolerance,
-            LinkFunction = _options.LinkFunction,
-            DecompositionType = _options.DecompositionType,
-            InitialDispersion = _options.InitialDispersion
-        };
-
-        var newModel = new InverseGaussianRegression<T>(newOptions, Regularization);
-
-        // Copy coefficients if they exist
-        if (Coefficients != null)
-        {
-            newModel.Coefficients = Coefficients.Clone();
-        }
-
-        // Copy the intercept and dispersion
-        newModel.Intercept = Intercept;
-        newModel._dispersion = _dispersion;
-
-        return newModel;
-    }
 }
diff --git a/src/Regression/IsotonicRegression.cs b/src/Regression/IsotonicRegression.cs
index b68656b9a0..1ba933c5f3 100644
--- a/src/Regression/IsotonicRegression.cs
+++ b/src/Regression/IsotonicRegression.cs
@@ -55,18 +55,21 @@ namespace AiDotNet.Regression;
 [ModelComplexity(ModelComplexity.Low)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
     [ResearchPaper("Isotonic Regression Under Lipschitz Constraint", "https://doi.org/10.1080/01621459.1972.10482387")]
-public class IsotonicRegression<T> : NonLinearRegressionBase<T>
+public partial class IsotonicRegression<T> : NonLinearRegressionBase<T>
 {
     /// <summary>
     /// The sorted input values from the training data.
     /// </summary>
+    [AiDotNet.Attributes.FittedParameter]
     private Vector<T> _xValues;
 
     /// <summary>
     /// The target values corresponding to the sorted input values.
     /// </summary>
+    [AiDotNet.Attributes.FittedParameter]
     private Vector<T> _yValues;
     private int _trainingFeatureCount;
+    [AiDotNet.Attributes.FittedParameter]
     private Vector<T>? _olsCoefficients;
     private T _olsIntercept;
 
@@ -420,168 +423,6 @@ private int FindNearestIndex(T x)
         return Math.Max(0, left - 1);
     }
 
-    /// <summary>
-    /// Serializes the Isotonic Regression model to a byte array for storage or transmission.
-    /// </summary>
-    /// <returns>A byte array containing the serialized model.</returns>
-    /// <remarks>
-    /// <para>
-    /// This method converts the Isotonic Regression model into a byte array that can be stored in a file, database,
-    /// or transmitted over a network. The serialized data includes the base class data, input values, and target
-    /// values used during training.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method saves your trained model as a sequence of bytes.
-    /// 
-    /// Serialization allows you to:
-    /// - Save your model to a file
-    /// - Store your model in a database
-    /// - Send your model over a network
-    /// - Keep your model for later use without having to retrain it
-    /// 
-    /// The serialized data includes:
-    /// - The input values from your training data
-    /// - The corresponding output values
-    /// - All the information needed to recreate the model exactly as it was
-    /// 
-    /// Example:
-    /// ```csharp
-    /// // Serialize the model
-    /// byte[] modelData = isoReg.Serialize();
-    /// 
-    /// // Save to a file
-    /// File.WriteAllBytes("isotonicRegression.model", modelData);
-    /// ```
-    /// </para>
-    /// </remarks>
-    public override byte[] Serialize()
-    {
-        using var ms = new MemoryStream();
-        using var writer = new BinaryWriter(ms);
-
-        // Serialize base class data
-        byte[] baseData = base.Serialize();
-        writer.Write(baseData.Length);
-        writer.Write(baseData);
-
-        // Serialize IsotonicRegression specific data
-        writer.Write(_xValues.Length);
-        for (int i = 0; i < _xValues.Length; i++)
-        {
-            writer.Write(Convert.ToDouble(_xValues[i]));
-        }
-
-        writer.Write(_yValues.Length);
-        for (int i = 0; i < _yValues.Length; i++)
-        {
-            writer.Write(Convert.ToDouble(_yValues[i]));
-        }
-
-        return ms.ToArray();
-    }
-
-    /// <summary>
-    /// Loads a previously serialized Isotonic Regression model from a byte array.
-    /// </summary>
-    /// <param name="modelData">The byte array containing the serialized model.</param>
-    /// <remarks>
-    /// <para>
-    /// This method reconstructs an Isotonic Regression model from a byte array that was previously created using the
-    /// Serialize method. It restores the base class data, input values, and target values, allowing the model to be
-    /// used for predictions without retraining.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method loads a previously saved model from a sequence of bytes.
-    /// 
-    /// Deserialization allows you to:
-    /// - Load a model that was saved earlier
-    /// - Use a model without having to retrain it
-    /// - Share models between different applications
-    /// 
-    /// When you deserialize a model:
-    /// - The input and output values from training are recovered
-    /// - The model is ready to make predictions immediately
-    /// - You don't need to go through the training process again
-    /// 
-    /// Example:
-    /// ```csharp
-    /// // Load from a file
-    /// byte[] modelData = File.ReadAllBytes("isotonicRegression.model");
-    /// 
-    /// // Deserialize the model
-    /// var isoReg = new IsotonicRegression&lt;double&gt;();
-    /// isoReg.Deserialize(modelData);
-    /// 
-    /// // Now you can use the model for predictions
-    /// var predictions = isoReg.Predict(newFeatures);
-    /// ```
-    /// </para>
-    /// </remarks>
-    public override void Deserialize(byte[] modelData)
-    {
-        using var ms = new MemoryStream(modelData);
-        using var reader = new BinaryReader(ms);
-
-        // Deserialize base class data
-        int baseDataLength = reader.ReadInt32();
-        byte[] baseData = reader.ReadBytes(baseDataLength);
-        base.Deserialize(baseData);
-
-        // Deserialize IsotonicRegression specific data
-        int xLength = reader.ReadInt32();
-        _xValues = new Vector<T>(xLength);
-        for (int i = 0; i < xLength; i++)
-        {
-            _xValues[i] = NumOps.FromDouble(reader.ReadDouble());
-        }
-
-        int yLength = reader.ReadInt32();
-        _yValues = new Vector<T>(yLength);
-        for (int i = 0; i < yLength; i++)
-        {
-            _yValues[i] = NumOps.FromDouble(reader.ReadDouble());
-        }
-    }
-
-    /// <summary>
-    /// Creates a new instance of the IsotonicRegression with the same configuration as the current instance.
-    /// </summary>
-    /// <returns>A new IsotonicRegression instance with the same options and regularization as the current instance.</returns>
-    /// <remarks>
-    /// <para>
-    /// This method creates a new instance of the IsotonicRegression model with the same configuration options
-    /// and regularization settings as the current instance. This is useful for model cloning, ensemble methods, or
-    /// cross-validation scenarios where multiple instances of the same model with identical configurations are needed.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method creates a fresh copy of the model's blueprint.
-    /// 
-    /// When you need multiple versions of the same type of model with identical settings:
-    /// - This method creates a new, empty model with the same configuration
-    /// - It's like making a copy of a recipe before you start cooking
-    /// - The new model has the same settings but no trained data
-    /// - This is useful for techniques that need multiple models, like cross-validation
-    /// 
-    /// For example, when testing your model on different subsets of data,
-    /// you'd want each test to use a model with identical settings.
-    /// </para>
-    /// </remarks>
-    public override IFullModel<T, Matrix<T>, Vector<T>> Clone()
-    {
-        var clone = new IsotonicRegression<T>(Options, Regularization);
-        if (SupportVectors.Rows > 0)
-            clone.SupportVectors = SupportVectors.Clone();
-        if (Alphas.Length > 0)
-            clone.Alphas = new Vector<T>(Alphas);
-        clone.B = B;
-        clone._xValues = new Vector<T>(_xValues);
-        clone._yValues = new Vector<T>(_yValues);
-        clone._trainingFeatureCount = _trainingFeatureCount;
-        clone._olsIntercept = _olsIntercept;
-        if (_olsCoefficients is not null)
-            clone._olsCoefficients = new Vector<T>(_olsCoefficients);
-        return clone;
-    }
-
-    public override IFullModel<T, Matrix<T>, Vector<T>> DeepCopy() => Clone();
-
     protected override IFullModel<T, Matrix<T>, Vector<T>> CreateInstance()
     {
         return new IsotonicRegression<T>(Options, Regularization);
diff --git a/src/Regression/KNearestNeighborsRegression.cs b/src/Regression/KNearestNeighborsRegression.cs
index f66433f275..022b7e54ed 100644
--- a/src/Regression/KNearestNeighborsRegression.cs
+++ b/src/Regression/KNearestNeighborsRegression.cs
@@ -58,7 +58,7 @@ namespace AiDotNet.Regression;
 [ModelComplexity(ModelComplexity.Low)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
     [ResearchPaper("Nearest Neighbor Pattern Classification", "https://doi.org/10.1109/TIT.1967.1053964")]
-public class KNearestNeighborsRegression<T> : NonLinearRegressionBase<T>
+public partial class KNearestNeighborsRegression<T> : NonLinearRegressionBase<T>
 {
     /// <summary>
     /// Configuration options for the K-Nearest Neighbors algorithm.
@@ -71,11 +71,13 @@ public class KNearestNeighborsRegression<T> : NonLinearRegressionBase<T>
     /// <summary>
     /// Matrix containing the feature vectors of the training samples.
     /// </summary>
+    [Buffer]
     private Matrix<T> _xTrain;
 
     /// <summary>
     /// Vector containing the target values of the training samples.
     /// </summary>
+    [Buffer]
     private Vector<T> _yTrain;
 
     /// <summary>
@@ -367,133 +369,6 @@ private T CalculateDistance(Vector<T> v1, Vector<T> v2)
     /// </summary>
     /// <returns>The model type enumeration value.</returns>
 
-    /// <summary>
-    /// Serializes the K-Nearest Neighbors Regression model to a byte array for storage or transmission.
-    /// </summary>
-    /// <returns>A byte array containing the serialized model.</returns>
-    /// <remarks>
-    /// <para>
-    /// This method converts the KNN model into a byte array that can be stored in a file, database,
-    /// or transmitted over a network. The serialized data includes the base class data, the number of
-    /// neighbors (K), and the training data that is used for making predictions.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method saves your trained model as a sequence of bytes.
-    /// 
-    /// Serialization allows you to:
-    /// - Save your model to a file
-    /// - Store your model in a database
-    /// - Send your model over a network
-    /// - Keep your model for later use without having to retrain it
-    /// 
-    /// The serialized data includes:
-    /// - The value of K (number of neighbors)
-    /// - All the training examples (both features and target values)
-    /// 
-    /// Since KNN stores all training data, the serialized model can be quite large
-    /// compared to other machine learning models.
-    /// 
-    /// Example:
-    /// ```csharp
-    /// // Serialize the model
-    /// byte[] modelData = knn.Serialize();
-    /// 
-    /// // Save to a file
-    /// File.WriteAllBytes("knn.model", modelData);
-    /// ```
-    /// </para>
-    /// </remarks>
-    public override byte[] Serialize()
-    {
-        using var ms = new MemoryStream();
-        using var writer = new BinaryWriter(ms);
-
-        // Serialize base class data
-        byte[] baseData = base.Serialize();
-        writer.Write(baseData.Length);
-        writer.Write(baseData);
-
-        // Serialize KNN specific data
-        writer.Write(_options.K);
-
-        // Serialize training data
-        writer.Write(_xTrain.Rows);
-        writer.Write(_xTrain.Columns);
-        for (int i = 0; i < _xTrain.Rows; i++)
-            for (int j = 0; j < _xTrain.Columns; j++)
-                writer.Write(Convert.ToDouble(_xTrain[i, j]));
-
-        writer.Write(_yTrain.Length);
-        for (int i = 0; i < _yTrain.Length; i++)
-            writer.Write(Convert.ToDouble(_yTrain[i]));
-
-        return ms.ToArray();
-    }
-
-    /// <summary>
-    /// Loads a previously serialized K-Nearest Neighbors Regression model from a byte array.
-    /// </summary>
-    /// <param name="modelData">The byte array containing the serialized model.</param>
-    /// <remarks>
-    /// <para>
-    /// This method reconstructs a KNN model from a byte array that was previously created using the
-    /// Serialize method. It restores the base class data, the number of neighbors (K), and the training
-    /// data that is used for making predictions.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method loads a previously saved model from a sequence of bytes.
-    /// 
-    /// Deserialization allows you to:
-    /// - Load a model that was saved earlier
-    /// - Use a model without having to retrain it
-    /// - Share models between different applications
-    /// 
-    /// When you deserialize a model:
-    /// - The value of K is restored
-    /// - All training examples are loaded back into memory
-    /// - The model is ready to make predictions immediately
-    /// 
-    /// Example:
-    /// ```csharp
-    /// // Load from a file
-    /// byte[] modelData = File.ReadAllBytes("knn.model");
-    /// 
-    /// // Deserialize the model
-    /// var knn = new KNearestNeighborsRegression&lt;double&gt;();
-    /// knn.Deserialize(modelData);
-    /// 
-    /// // Now you can use the model for predictions
-    /// var predictions = knn.Predict(newFeatures);
-    /// ```
-    /// </para>
-    /// </remarks>
-    public override void Deserialize(byte[] modelData)
-    {
-        using var ms = new MemoryStream(modelData);
-        using var reader = new BinaryReader(ms);
-
-        // Deserialize base class data
-        int baseDataLength = reader.ReadInt32();
-        byte[] baseData = reader.ReadBytes(baseDataLength);
-        base.Deserialize(baseData);
-
-        // Deserialize KNN specific data
-        _options.K = reader.ReadInt32();
-
-        // Deserialize training data
-        int rows = reader.ReadInt32();
-        int cols = reader.ReadInt32();
-        _xTrain = new Matrix<T>(rows, cols);
-        for (int i = 0; i < rows; i++)
-            for (int j = 0; j < cols; j++)
-                _xTrain[i, j] = NumOps.FromDouble(reader.ReadDouble());
-
-        int yLength = reader.ReadInt32();
-        _yTrain = new Vector<T>(yLength);
-        for (int i = 0; i < yLength; i++)
-            _yTrain[i] = NumOps.FromDouble(reader.ReadDouble());
-
-        // Note: KNN is a distance-based method - no data transformation is applied
-    }
-
     /// <summary>
     /// Creates a new instance of the KNearestNeighborsRegression with the same configuration as the current instance.
     /// </summary>
@@ -521,80 +396,6 @@ protected override IFullModel<T, Matrix<T>, Vector<T>> CreateInstance()
         return new KNearestNeighborsRegression<T>(_options, Regularization);
     }
 
-    /// <summary>
-    /// Creates a shallow copy of this KNN model including its training data.
-    /// </summary>
-    /// <returns>A new KNearestNeighborsRegression instance with the same configuration and training data.</returns>
-    /// <remarks>
-    /// <para>
-    /// This method overrides the base class Clone to ensure that KNN-specific training data
-    /// (_xTrain and _yTrain) is properly copied. Without this override, cloned models would
-    /// lose their training data and fail when Predict is called.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method creates a copy of your trained model.
-    ///
-    /// Unlike CreateInstance which creates an empty model, Clone copies:
-    /// - All the base class settings (support vectors, alphas, bias, options)
-    /// - The training data that KNN needs to make predictions
-    /// - The soft KNN settings if enabled
-    ///
-    /// This is important because KNN stores all training examples and uses them
-    /// at prediction time. A clone without training data would be unusable.
-    /// </para>
-    /// </remarks>
-    public override IFullModel<T, Matrix<T>, Vector<T>> Clone()
-    {
-        // First call base class Clone to copy common properties
-        var clone = (KNearestNeighborsRegression<T>)base.Clone();
-
-        // Copy KNN-specific training data (shallow copy - shares data with original)
-        clone._xTrain = _xTrain;
-        clone._yTrain = _yTrain;
-
-        // Copy soft KNN settings
-        clone.UseSoftKNN = UseSoftKNN;
-        clone.SoftKNNTemperature = SoftKNNTemperature;
-
-        return clone;
-    }
-
-    /// <summary>
-    /// Creates a deep copy of this KNN model including its training data.
-    /// </summary>
-    /// <returns>A new KNearestNeighborsRegression instance with independent copies of all data.</returns>
-    /// <remarks>
-    /// <para>
-    /// This method overrides the base class DeepCopy to ensure that KNN-specific training data
-    /// is properly deep copied. The resulting model is completely independent of the original -
-    /// modifications to one will not affect the other.
-    /// </para>
-    /// <para><b>For Beginners:</b> This creates a completely independent copy of your model.
-    ///
-    /// While Clone shares some data with the original (for efficiency), DeepCopy creates
-    /// entirely new copies of everything including:
-    /// - All training feature vectors
-    /// - All training labels
-    /// - All model parameters
-    ///
-    /// Use DeepCopy when you need to modify the copy without affecting the original.
-    /// </para>
-    /// </remarks>
-    public override IFullModel<T, Matrix<T>, Vector<T>> DeepCopy()
-    {
-        // First call base class DeepCopy to deep copy common properties
-        var clone = (KNearestNeighborsRegression<T>)base.DeepCopy();
-
-        // Deep copy KNN-specific training data
-        clone._xTrain = _xTrain.Clone();
-        clone._yTrain = _yTrain.Clone();
-
-        // Copy soft KNN settings (value types are already copied by value)
-        clone.UseSoftKNN = UseSoftKNN;
-        clone.SoftKNNTemperature = SoftKNNTemperature;
-
-        return clone;
-    }
-
     // ===== Soft KNN Support for JIT Compilation =====
 
     /// <summary>
diff --git a/src/Regression/KernelRidgeRegression.cs b/src/Regression/KernelRidgeRegression.cs
index 95d50b8ec6..3b24fc527c 100644
--- a/src/Regression/KernelRidgeRegression.cs
+++ b/src/Regression/KernelRidgeRegression.cs
@@ -61,7 +61,7 @@ namespace AiDotNet.Regression;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
     [ResearchPaper("Kernel Methods for Pattern Analysis", "https://doi.org/10.1017/CBO9780511809682")]
-public class KernelRidgeRegression<T> : NonLinearRegressionBase<T>
+public partial class KernelRidgeRegression<T> : NonLinearRegressionBase<T>
 {
     /// <summary>
     /// Initializes a new instance with default settings.
@@ -74,12 +74,15 @@ public KernelRidgeRegression()
     /// <summary>
     /// The Gram matrix (kernel matrix) that represents pairwise similarities between all training points.
     /// </summary>
+    [Buffer]
     private Matrix<T> _gramMatrix;
 
     /// <summary>
     /// The dual coefficients used for making predictions.
     /// </summary>
+    [Buffer]
     private Vector<T> _dualCoefficients;
+    [Buffer]
     private T _yMean;
     private Vector<T>? _linearCoefficients;
     private T _linearIntercept;
@@ -378,195 +381,6 @@ public override ModelMetadata<T> GetModelMetadata()
         return metadata;
     }
 
-    /// <summary>
-    /// Serializes the Kernel Ridge Regression model to a byte array for storage or transmission.
-    /// </summary>
-    /// <returns>A byte array containing the serialized model.</returns>
-    /// <remarks>
-    /// <para>
-    /// This method converts the Kernel Ridge Regression model into a byte array that can be stored in a file, database,
-    /// or transmitted over a network. The serialized data includes the base class data, model-specific options like
-    /// the regularization parameter (lambda), the Gram matrix, and the dual coefficients.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method saves your trained model as a sequence of bytes.
-    /// 
-    /// Serialization allows you to:
-    /// - Save your model to a file
-    /// - Store your model in a database
-    /// - Send your model over a network
-    /// - Keep your model for later use without having to retrain it
-    /// 
-    /// The serialized data includes:
-    /// - The model's settings (like the lambda regularization parameter)
-    /// - The Gram matrix (similarities between training examples)
-    /// - The dual coefficients learned during training
-    /// 
-    /// Example:
-    /// ```csharp
-    /// // Serialize the model
-    /// byte[] modelData = krr.Serialize();
-    /// 
-    /// // Save to a file
-    /// File.WriteAllBytes("kernelRidgeRegression.model", modelData);
-    /// ```
-    /// </para>
-    /// </remarks>
-    public override byte[] Serialize()
-    {
-        using var ms = new MemoryStream();
-        using var writer = new BinaryWriter(ms);
-
-        // Serialize base class data
-        byte[] baseData = base.Serialize();
-        writer.Write(baseData.Length);
-        writer.Write(baseData);
-
-        // Serialize KernelRidgeRegression specific data
-        writer.Write(Options.LambdaKRR);
-        writer.Write((int)Options.DecompositionType);
-
-        // Serialize _gramMatrix
-        writer.Write(_gramMatrix.Rows);
-        writer.Write(_gramMatrix.Columns);
-        for (int i = 0; i < _gramMatrix.Rows; i++)
-        {
-            for (int j = 0; j < _gramMatrix.Columns; j++)
-            {
-                writer.Write(Convert.ToDouble(_gramMatrix[i, j]));
-            }
-        }
-
-        // Serialize _dualCoefficients
-        writer.Write(_dualCoefficients.Length);
-        for (int i = 0; i < _dualCoefficients.Length; i++)
-        {
-            writer.Write(Convert.ToDouble(_dualCoefficients[i]));
-        }
-
-        // Serialize _yMean
-        writer.Write(Convert.ToDouble(_yMean));
-
-        return ms.ToArray();
-    }
-
-    /// <summary>
-    /// Loads a previously serialized Kernel Ridge Regression model from a byte array.
-    /// </summary>
-    /// <param name="modelData">The byte array containing the serialized model.</param>
-    /// <remarks>
-    /// <para>
-    /// This method reconstructs a Kernel Ridge Regression model from a byte array that was previously created using the
-    /// Serialize method. It restores the base class data, model-specific options, the Gram matrix, and the dual
-    /// coefficients, allowing the model to be used for predictions without retraining.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method loads a previously saved model from a sequence of bytes.
-    /// 
-    /// Deserialization allows you to:
-    /// - Load a model that was saved earlier
-    /// - Use a model without having to retrain it
-    /// - Share models between different applications
-    /// 
-    /// When you deserialize a model:
-    /// - All settings are restored
-    /// - The Gram matrix is reconstructed
-    /// - The dual coefficients are recovered
-    /// - The model is ready to make predictions immediately
-    /// 
-    /// Example:
-    /// ```csharp
-    /// // Load from a file
-    /// byte[] modelData = File.ReadAllBytes("kernelRidgeRegression.model");
-    /// 
-    /// // Deserialize the model
-    /// var options = new KernelRidgeRegressionOptions();
-    /// var krr = new KernelRidgeRegression&lt;double&gt;(options);
-    /// krr.Deserialize(modelData);
-    /// 
-    /// // Now you can use the model for predictions
-    /// var predictions = krr.Predict(newFeatures);
-    /// ```
-    /// </para>
-    /// </remarks>
-    public override void Deserialize(byte[] modelData)
-    {
-        using var ms = new MemoryStream(modelData);
-        using var reader = new BinaryReader(ms);
-
-        // Deserialize base class data
-        int baseDataLength = reader.ReadInt32();
-        byte[] baseData = reader.ReadBytes(baseDataLength);
-        base.Deserialize(baseData);
-
-        // Deserialize KernelRidgeRegression specific data
-        Options.LambdaKRR = reader.ReadDouble();
-        Options.DecompositionType = (MatrixDecompositionType)reader.ReadInt32();
-
-        // Deserialize _gramMatrix
-        int rows = reader.ReadInt32();
-        int cols = reader.ReadInt32();
-        _gramMatrix = new Matrix<T>(rows, cols);
-        for (int i = 0; i < rows; i++)
-        {
-            for (int j = 0; j < cols; j++)
-            {
-                _gramMatrix[i, j] = NumOps.FromDouble(reader.ReadDouble());
-            }
-        }
-
-        // Deserialize _dualCoefficients
-        int length = reader.ReadInt32();
-        _dualCoefficients = new Vector<T>(length);
-        for (int i = 0; i < length; i++)
-        {
-            _dualCoefficients[i] = NumOps.FromDouble(reader.ReadDouble());
-        }
-
-        // Deserialize _yMean
-        if (ms.Position < ms.Length)
-            _yMean = NumOps.FromDouble(reader.ReadDouble());
-    }
-
-    /// <summary>
-    /// Creates a new instance of the KernelRidgeRegression with the same configuration as the current instance.
-    /// </summary>
-    /// <returns>A new KernelRidgeRegression instance with the same options and regularization as the current instance.</returns>
-    /// <remarks>
-    /// <para>
-    /// This method creates a new instance of the KernelRidgeRegression model with the same configuration options
-    /// and regularization settings as the current instance. This is useful for model cloning, ensemble methods, or
-    /// cross-validation scenarios where multiple instances of the same model with identical configurations are needed.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method creates a fresh copy of the model's blueprint.
-    /// 
-    /// When you need multiple versions of the same type of model with identical settings:
-    /// - This method creates a new, empty model with the same configuration
-    /// - It's like making a copy of a recipe before you start cooking
-    /// - The new model has the same settings but no trained data
-    /// - This is useful for techniques that need multiple models, like cross-validation
-    /// 
-    /// For example, when testing your model on different subsets of data,
-    /// you'd want each test to use a model with identical settings.
-    /// </para>
-    /// </remarks>
-    public override IFullModel<T, Matrix<T>, Vector<T>> Clone()
-    {
-        var clone = new KernelRidgeRegression<T>((KernelRidgeRegressionOptions)Options, Regularization);
-        if (SupportVectors.Rows > 0)
-            clone.SupportVectors = SupportVectors.Clone();
-        if (Alphas.Length > 0)
-            clone.Alphas = new Vector<T>(Alphas);
-        clone.B = B;
-        clone._gramMatrix = _gramMatrix.Rows > 0 ? _gramMatrix.Clone() : Matrix<T>.Empty();
-        clone._dualCoefficients = _dualCoefficients.Length > 0 ? new Vector<T>(_dualCoefficients) : Vector<T>.Empty();
-        clone._yMean = _yMean;
-        clone._linearIntercept = _linearIntercept;
-        if (_linearCoefficients is not null)
-            clone._linearCoefficients = new Vector<T>(_linearCoefficients);
-        return clone;
-    }
-
-    public override IFullModel<T, Matrix<T>, Vector<T>> DeepCopy() => Clone();
-
     protected override IFullModel<T, Matrix<T>, Vector<T>> CreateInstance()
     {
         return new KernelRidgeRegression<T>((KernelRidgeRegressionOptions)Options, Regularization);
diff --git a/src/Regression/LassoRegression.cs b/src/Regression/LassoRegression.cs
index ee8fc318e9..1c74713bd0 100644
--- a/src/Regression/LassoRegression.cs
+++ b/src/Regression/LassoRegression.cs
@@ -59,7 +59,7 @@ namespace AiDotNet.Regression;
 [ModelComplexity(ModelComplexity.Low)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
     [ResearchPaper("Regression Shrinkage and Selection via the Lasso", "https://doi.org/10.1111/j.2517-6161.1996.tb02080.x")]
-public class LassoRegression<T> : RegressionBase<T>
+public partial class LassoRegression<T> : RegressionBase<T>
 {
     /// <summary>
     /// Gets the configuration options specific to Lasso Regression.
@@ -305,59 +305,4 @@ public override ModelMetadata<T> GetModelMetadata()
         return metadata;
     }
 
-
-    /// <summary>
-    /// Creates a new instance of Lasso Regression with the same configuration.
-    /// </summary>
-    /// <returns>A new instance with the same options.</returns>
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        return new LassoRegression<T>(Options, Regularization);
-    }
-
-    /// <summary>
-    /// Serializes the Lasso Regression model to a byte array.
-    /// </summary>
-    /// <returns>A byte array containing the serialized model.</returns>
-    public override byte[] Serialize()
-    {
-        using var ms = new MemoryStream();
-        using var writer = new BinaryWriter(ms);
-
-        // Serialize base class data
-        byte[] baseData = base.Serialize();
-        writer.Write(baseData.Length);
-        writer.Write(baseData);
-
-        // Serialize Lasso-specific data
-        writer.Write(Options.Alpha);
-        writer.Write(Options.MaxIterations);
-        writer.Write(Options.Tolerance);
-        writer.Write(Options.WarmStart);
-        writer.Write(_iterationsUsed);
-
-        return ms.ToArray();
-    }
-
-    /// <summary>
-    /// Deserializes a Lasso Regression model from a byte array.
-    /// </summary>
-    /// <param name="modelData">The byte array containing the serialized model.</param>
-    public override void Deserialize(byte[] modelData)
-    {
-        using var ms = new MemoryStream(modelData);
-        using var reader = new BinaryReader(ms);
-
-        // Deserialize base class data
-        int baseDataLength = reader.ReadInt32();
-        byte[] baseData = reader.ReadBytes(baseDataLength);
-        base.Deserialize(baseData);
-
-        // Deserialize Lasso-specific data
-        Options.Alpha = reader.ReadDouble();
-        Options.MaxIterations = reader.ReadInt32();
-        Options.Tolerance = reader.ReadDouble();
-        Options.WarmStart = reader.ReadBoolean();
-        _iterationsUsed = reader.ReadInt32();
-    }
 }
diff --git a/src/Regression/LocallyWeightedRegression.cs b/src/Regression/LocallyWeightedRegression.cs
index dee78a8f75..149f242481 100644
--- a/src/Regression/LocallyWeightedRegression.cs
+++ b/src/Regression/LocallyWeightedRegression.cs
@@ -60,12 +60,46 @@ namespace AiDotNet.Regression;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
     [ResearchPaper("Locally Weighted Regression: An Approach to Regression Analysis by Local Fitting", "https://doi.org/10.1080/01621459.1988.10478639")]
-public class LocallyWeightedRegression<T> : NonLinearRegressionBase<T>
+public partial class LocallyWeightedRegression<T> : NonLinearRegressionBase<T>
 {
     /// <summary>
     /// Configuration options for the Locally Weighted Regression algorithm.
     /// </summary>
-    private readonly LocallyWeightedRegressionOptions _options;
+    /// <remarks>
+    /// A VIEW of the base's options, not a second reference to them. Holding its own field meant that
+    /// after Deserialize replaced <c>base.Options</c> the model went on reading the object it was
+    /// constructed with -- so loading a saved model into a default-constructed instance restored the
+    /// training set and kept the wrong span, and predictions differed while everything looked
+    /// restored. Anything that shadows configuration this way has the same defect waiting in it.
+    /// </remarks>
+    private LocallyWeightedRegressionOptions _options
+        => Options as LocallyWeightedRegressionOptions ?? _optionsFallback;
+
+    /// <summary>
+    /// Stands in when the base's <c>Options</c> comes back as the declared base type.
+    /// </summary>
+    /// <remarks>
+    /// A hard cast here threw InvalidCastException on the first prediction after a rebuild -- 19 tests,
+    /// all of them inside Predict rather than anywhere near deserialisation, which is what made it read
+    /// as a model bug rather than a supply-path one. Reading configuration must not be able to crash a
+    /// prediction; the LOESS parameters that actually matter are carried as state below, so a fallback
+    /// here costs nothing and removes the crash.
+    /// </remarks>
+    private readonly LocallyWeightedRegressionOptions _optionsFallback = new();
+
+    /// <summary>
+    /// The span and bandwidth this model predicts with, as MODEL STATE rather than configuration.
+    /// </summary>
+    /// <remarks>
+    /// Anything training computes is model state -- that is the rule this follows. LOESS's neighbourhood
+    /// is a fitted property of the data (Cleveland and Devlin 1988): the span selects the q-th nearest
+    /// neighbour, and a model restored without it predicts from a different neighbourhood than the one
+    /// it was fitted with. Held here, they are declared by the generator and travel in the payload, so
+    /// they survive a round trip even when the options object does not.
+    /// </remarks>
+    private double _span;
+
+    private double _bandwidth;
 
     /// <summary>
     /// Tolerance below which total kernel weight is treated as zero (no neighbors in bandwidth).
@@ -85,11 +119,13 @@ public class LocallyWeightedRegression<T> : NonLinearRegressionBase<T>
     /// <summary>
     /// Matrix containing the feature vectors of the training samples.
     /// </summary>
+    [Buffer]
     private Matrix<T> _xTrain;
 
     /// <summary>
     /// Vector containing the target values of the training samples.
     /// </summary>
+    [Buffer]
     private Vector<T> _yTrain;
 
     /// <summary>
@@ -126,9 +162,14 @@ public class LocallyWeightedRegression<T> : NonLinearRegressionBase<T>
     public LocallyWeightedRegression(LocallyWeightedRegressionOptions? options = null, IRegularization<T, Matrix<T>, Vector<T>>? regularization = null)
         : base(options, regularization)
     {
-        _options = options ?? new LocallyWeightedRegressionOptions();
         _xTrain = Matrix<T>.Empty();
         _yTrain = Vector<T>.Empty();
+
+        // Seeded from the options the model was built with, and state from here on. Deserialize
+        // overwrites them from the payload, which is the point: the neighbourhood is a property of the
+        // fitted model, not of whatever options object it is later rebuilt beside.
+        _span = _options.Span;
+        _bandwidth = _options.Bandwidth;
     }
 
     /// <summary>
@@ -175,44 +216,21 @@ public override IEnumerable<int> GetActiveFeatureIndices()
         return Enumerable.Range(0, _xTrain.Columns > 0 ? _xTrain.Columns : 0);
     }
 
-    /// <summary>
-    /// Deep copy via serialization.
-    /// </summary>
-    public override IFullModel<T, Matrix<T>, Vector<T>> Clone()
-    {
-        var clone = new LocallyWeightedRegression<T>(null, Regularization);
-        clone.Deserialize(Serialize());
-        return clone;
-    }
-
-    public override IFullModel<T, Matrix<T>, Vector<T>> DeepCopy() => Clone();
-
     protected override void OptimizeModel(Matrix<T> x, Vector<T> y)
     {
         // In LWR, we don't pre-compute a global model. Instead, we store the training data.
         _xTrain = x;
         _yTrain = y;
 
-        // Auto-scale bandwidth if using the default value of 1.0.
-        // The tricube kernel returns 0 for |distance/bandwidth| > 1,
-        // so bandwidth must be large enough relative to typical inter-point distances.
-        if (Math.Abs(_options.Bandwidth - 1.0) < 1e-10)
-        {
-            // Use the median of pairwise distances as a robust bandwidth estimate
-            double totalDist = 0;
-            int count = 0;
-            int sampleSize = Math.Min(50, x.Rows);
-            for (int i = 0; i < sampleSize; i++)
-            {
-                for (int j = i + 1; j < sampleSize; j++)
-                {
-                    totalDist += NumOps.ToDouble(VectorHelper.EuclideanDistance(x.GetRow(i), x.GetRow(j)));
-                    count++;
-                }
-            }
-            double meanDist = count > 0 ? totalDist / count : 1.0;
-            _options.Bandwidth = Math.Max(meanDist, 0.1);
-        }
+        // Nothing else to do. The scale of each local fit is decided per query point from the span,
+        // in LocalBandwidth, which is where Cleveland and Devlin put it.
+        //
+        // This used to derive one global bandwidth here and WRITE IT BACK INTO _options, which was
+        // wrong three ways: a single scale is fixed-bandwidth kernel regression rather than LOESS;
+        // the estimate came from the arithmetic mean of the first fifty rows' pairwise distances,
+        // while the comment beside it claimed a median and the "sample" was whatever order the rows
+        // arrived in; and writing to _options mutated the CALLER's object, so two models handed the
+        // same options instance silently retrained each other's smoothing.
     }
 
     /// <summary>
@@ -353,175 +371,80 @@ protected override T PredictSingle(Vector<T> input)
     private Vector<T> ComputeWeights(Vector<T> input)
     {
         var weights = new Vector<T>(_xTrain.Rows);
-        var bandwidth = NumOps.FromDouble(_options.Bandwidth);
 
+        var distances = new double[_xTrain.Rows];
         for (int i = 0; i < _xTrain.Rows; i++)
         {
-            var distance = VectorHelper.EuclideanDistance(input, _xTrain.GetRow(i));
-            weights[i] = KernelFunction(NumOps.Divide(distance, bandwidth));
+            distances[i] = Convert.ToDouble(VectorHelper.EuclideanDistance(input, _xTrain.GetRow(i)));
         }
 
-        return weights;
-    }
+        double bandwidth = LocalBandwidth(distances);
+        if (bandwidth <= 0) bandwidth = MinimumStabilityStrength;
 
+        for (int i = 0; i < _xTrain.Rows; i++)
+        {
+            weights[i] = KernelFunction(NumOps.FromDouble(distances[i] / bandwidth));
+        }
 
-    /// <summary>
-    /// Applies a kernel function to transform distances into weights.
-    /// </summary>
-    /// <param name="u">The normalized distance value to transform.</param>
-    /// <returns>The weight value after applying the kernel function.</returns>
-    private T KernelFunction(T u)
-    {
-        // Tricube kernel function
-        var absU = NumOps.Abs(u);
-        if (NumOps.GreaterThan(absU, NumOps.One))
-            return NumOps.Zero;
-        var temp = NumOps.Subtract(NumOps.One, NumOps.Power(absU, NumOps.FromDouble(3)));
-        return NumOps.Power(temp, NumOps.FromDouble(3));
+        return weights;
     }
 
     /// <summary>
-    /// Gets the model type of the Locally Weighted Regression model.
+    /// The bandwidth for ONE query point: the distance to its q-th nearest neighbour.
     /// </summary>
-    /// <returns>The model type enumeration value.</returns>
-
-    /// <summary>
-    /// Serializes the Locally Weighted Regression model to a byte array for storage or transmission.
-    /// </summary>
-    /// <returns>A byte array containing the serialized model.</returns>
+    /// <param name="distances">Distances from the query point to every training sample.</param>
+    /// <returns>The local bandwidth, or the configured override when one was set.</returns>
     /// <remarks>
     /// <para>
-    /// This method converts the Locally Weighted Regression model into a byte array that can be stored in a file,
-    /// database, or transmitted over a network. The serialized data includes the base class data, the bandwidth
-    /// parameter, and the training data that is used for making predictions.
+    /// This is what makes the method locally weighted. Cleveland and Devlin define the smoothing
+    /// parameter as a SPAN f: each local fit uses the q = floor(f*n) nearest neighbours, and the
+    /// scale at a query point is the distance to the q-th of them, so the neighbourhood is wide where
+    /// the data are sparse and narrow where they are dense.
     /// </para>
-    /// <para><b>For Beginners:</b> This method saves your trained model as a sequence of bytes.
-    /// 
-    /// Serialization allows you to:
-    /// - Save your model to a file
-    /// - Store your model in a database
-    /// - Send your model over a network
-    /// - Keep your model for later use without having to retrain it
-    /// 
-    /// The serialized data includes:
-    /// - The bandwidth parameter that controls the locality of the weighted regression
-    /// - All the training examples (both features and target values)
-    /// 
-    /// Since Locally Weighted Regression stores all training data, the serialized model can be
-    /// quite large compared to parametric models like linear regression.
-    /// 
-    /// Example:
-    /// ```csharp
-    /// // Serialize the model
-    /// byte[] modelData = lwr.Serialize();
-    /// 
-    /// // Save to a file
-    /// File.WriteAllBytes("lwr.model", modelData);
-    /// ```
+    /// <para>
+    /// A single global bandwidth -- which is what this used, taken from the mean of the first fifty
+    /// rows' pairwise distances -- is fixed-bandwidth kernel regression instead, and it degrades
+    /// exactly where LOESS is supposed to earn its keep: in regions whose density differs from the
+    /// average. An explicitly configured Bandwidth still forces that older behaviour, so callers who
+    /// tuned one keep their numbers.
     /// </para>
     /// </remarks>
-    public override byte[] Serialize()
+    private double LocalBandwidth(double[] distances)
     {
-        using var ms = new MemoryStream();
-        using var writer = new BinaryWriter(ms);
-
-        // Serialize base class data
-        byte[] baseData = base.Serialize();
-        writer.Write(baseData.Length);
-        writer.Write(baseData);
-
-        // Serialize LWR specific data
-        writer.Write(_options.Bandwidth);
-
-        // Serialize _xTrain
-        writer.Write(_xTrain.Rows);
-        writer.Write(_xTrain.Columns);
-        for (int i = 0; i < _xTrain.Rows; i++)
-        {
-            for (int j = 0; j < _xTrain.Columns; j++)
-            {
-                writer.Write(Convert.ToDouble(_xTrain[i, j]));
-            }
-        }
-
-        // Serialize _yTrain
-        writer.Write(_yTrain.Length);
-        for (int i = 0; i < _yTrain.Length; i++)
-        {
-            writer.Write(Convert.ToDouble(_yTrain[i]));
-        }
-
-        return ms.ToArray();
+        // Read from the model's own state, seeded from options at construction. The override still
+        // wins where it is set -- Bandwidth is kept as an escape hatch, per the design -- but both
+        // values travel in the payload, so a restored model predicts from the neighbourhood it was
+        // fitted with rather than from whatever the options object degraded to.
+        var bandwidth = _bandwidth > 0 ? _bandwidth : _options.Bandwidth;
+        if (bandwidth > 0) return bandwidth;
+        if (distances.Length == 0) return MinimumStabilityStrength;
+
+        var configured = _span > 0 ? _span : _options.Span;
+        double span = configured > 0 ? configured : 0.75;
+        int q = (int)Math.Floor(span * distances.Length);
+        q = Math.Max(1, Math.Min(q, distances.Length));
+
+        // Only the q-th smallest is needed, but n is the training-set size and a sort here is clearer
+        // than a selection algorithm at this scale; revisit if a profile says otherwise.
+        var ordered = (double[])distances.Clone();
+        Array.Sort(ordered);
+        return ordered[q - 1];
     }
 
+
     /// <summary>
-    /// Loads a previously serialized Locally Weighted Regression model from a byte array.
+    /// Applies a kernel function to transform distances into weights.
     /// </summary>
-    /// <param name="modelData">The byte array containing the serialized model.</param>
-    /// <remarks>
-    /// <para>
-    /// This method reconstructs a Locally Weighted Regression model from a byte array that was previously created
-    /// using the Serialize method. It restores the base class data, the bandwidth parameter, and the training data
-    /// that is used for making predictions.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method loads a previously saved model from a sequence of bytes.
-    /// 
-    /// Deserialization allows you to:
-    /// - Load a model that was saved earlier
-    /// - Use a model without having to retrain it
-    /// - Share models between different applications
-    /// 
-    /// When you deserialize a model:
-    /// - The bandwidth parameter is restored
-    /// - All training examples are loaded back into memory
-    /// - The model is ready to make predictions immediately
-    /// 
-    /// Example:
-    /// ```csharp
-    /// // Load from a file
-    /// byte[] modelData = File.ReadAllBytes("lwr.model");
-    /// 
-    /// // Deserialize the model
-    /// var lwr = new LocallyWeightedRegression&lt;double&gt;();
-    /// lwr.Deserialize(modelData);
-    /// 
-    /// // Now you can use the model for predictions
-    /// var predictions = lwr.Predict(newFeatures);
-    /// ```
-    /// </para>
-    /// </remarks>
-    public override void Deserialize(byte[] modelData)
+    /// <param name="u">The normalized distance value to transform.</param>
+    /// <returns>The weight value after applying the kernel function.</returns>
+    private T KernelFunction(T u)
     {
-        using var ms = new MemoryStream(modelData);
-        using var reader = new BinaryReader(ms);
-
-        // Deserialize base class data
-        int baseDataLength = reader.ReadInt32();
-        byte[] baseData = reader.ReadBytes(baseDataLength);
-        base.Deserialize(baseData);
-
-        // Deserialize LWR specific data
-        _options.Bandwidth = reader.ReadDouble();
-
-        // Deserialize _xTrain
-        int rows = reader.ReadInt32();
-        int cols = reader.ReadInt32();
-        _xTrain = new Matrix<T>(rows, cols);
-        for (int i = 0; i < rows; i++)
-        {
-            for (int j = 0; j < cols; j++)
-            {
-                _xTrain[i, j] = NumOps.FromDouble(reader.ReadDouble());
-            }
-        }
-
-        // Deserialize _yTrain
-        int length = reader.ReadInt32();
-        _yTrain = new Vector<T>(length);
-        for (int i = 0; i < length; i++)
-        {
-            _yTrain[i] = NumOps.FromDouble(reader.ReadDouble());
-        }
+        // Tricube kernel function
+        var absU = NumOps.Abs(u);
+        if (NumOps.GreaterThan(absU, NumOps.One))
+            return NumOps.Zero;
+        var temp = NumOps.Subtract(NumOps.One, NumOps.Power(absU, NumOps.FromDouble(3)));
+        return NumOps.Power(temp, NumOps.FromDouble(3));
     }
 
     /// <summary>
diff --git a/src/Regression/LogisticRegression.cs b/src/Regression/LogisticRegression.cs
index 2a15192acf..4103c5399d 100644
--- a/src/Regression/LogisticRegression.cs
+++ b/src/Regression/LogisticRegression.cs
@@ -44,7 +44,7 @@ namespace AiDotNet.Regression;
 [ModelComplexity(ModelComplexity.Low)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
     [ResearchPaper("Applied Logistic Regression", "https://doi.org/10.1002/0471722146")]
-public class LogisticRegression<T> : RegressionBase<T>
+public partial class LogisticRegression<T> : RegressionBase<T>
 {
     /// <summary>
     /// The configuration options for the logistic regression model.
@@ -408,110 +408,4 @@ private bool HasConvergedScaled(Vector<T> gradient, int n)
         T scaledMaxGradient = NumOps.Divide(maxGradient, NumOps.FromDouble(n));
         return NumOps.LessThan(scaledMaxGradient, NumOps.FromDouble(_options.Tolerance));
     }
-
-    /// <summary>
-    /// Serializes the logistic regression model to a byte array for storage or transmission.
-    /// </summary>
-    /// <returns>A byte array containing the serialized model data.</returns>
-    /// <remarks>
-    /// <para>
-    /// This method converts the entire logistic regression model, including its parameters and configuration,
-    /// into a byte array that can be stored in a file or database, or transmitted over a network. The model can
-    /// later be restored using the Deserialize method.
-    /// </para>
-    /// <para><b>For Beginners:</b> This converts the model into a format that can be saved or shared.
-    /// 
-    /// Serialization:
-    /// - Transforms the model into a sequence of bytes
-    /// - Preserves all the important information about the model
-    /// - Allows you to save the trained model to a file
-    /// - Lets you load the model later without having to retrain it
-    /// 
-    /// It's like taking a snapshot of the model that you can use later or share with others.
-    /// </para>
-    /// </remarks>
-    public override byte[] Serialize()
-    {
-        using var ms = new MemoryStream();
-        using var writer = new BinaryWriter(ms);
-        // Serialize base class data
-        byte[] baseData = base.Serialize();
-        writer.Write(baseData.Length);
-        writer.Write(baseData);
-        // The two class labels, so a round-tripped model can still report which category the
-        // returned probability belongs to. This slot previously held the `_useOLS` flag, which
-        // recorded that the model had quietly fitted least squares instead.
-        writer.Write(_classLabels.Count);
-        for (int i = 0; i < _classLabels.Count; i++)
-        {
-            writer.Write(NumOps.ToDouble(_classLabels[i]));
-        }
-        // Serialize LogisticRegression specific data
-        writer.Write(_options.MaxIterations);
-        writer.Write(_options.Tolerance);
-
-        return ms.ToArray();
-    }
-
-    /// <summary>
-    /// Deserializes the logistic regression model from a byte array.
-    /// </summary>
-    /// <param name="modelData">A byte array containing the serialized model data.</param>
-    /// <remarks>
-    /// <para>
-    /// This method restores a logistic regression model from a serialized byte array, reconstructing its parameters
-    /// and configuration. This allows a previously trained model to be loaded from storage or after being received
-    /// over a network.
-    /// </para>
-    /// <para><b>For Beginners:</b> This rebuilds the model from a saved format.
-    /// 
-    /// Deserialization:
-    /// - Takes a sequence of bytes that represents a model
-    /// - Reconstructs the original model with all its learned patterns
-    /// - Allows you to use a previously trained model without retraining
-    /// 
-    /// Think of it like unpacking a model that was packed up for storage or shipping,
-    /// so you can use it again exactly as it was.
-    /// </para>
-    /// </remarks>
-    public override void Deserialize(byte[] modelData)
-    {
-        using var ms = new MemoryStream(modelData);
-        using var reader = new BinaryReader(ms);
-        // Deserialize base class data
-        int baseDataLength = reader.ReadInt32();
-        byte[] baseData = reader.ReadBytes(baseDataLength);
-        base.Deserialize(baseData);
-        // Class labels (see Serialize)
-        int classCount = reader.ReadInt32();
-        _classLabels = new List<T>(classCount);
-        for (int i = 0; i < classCount; i++)
-        {
-            _classLabels.Add(NumOps.FromDouble(reader.ReadDouble()));
-        }
-        // Deserialize MultipleRegression specific data
-        _options.MaxIterations = reader.ReadInt32();
-        _options.Tolerance = reader.ReadDouble();
-    }
-
-    /// <summary>
-    /// Creates a new instance of the logistic regression model.
-    /// </summary>
-    /// <returns>A new instance of the logistic regression model with the same configuration.</returns>
-    /// <remarks>
-    /// <para>
-    /// This method creates a new instance of the logistic regression model with the same configuration as the current instance.
-    /// It is used internally during serialization/deserialization to create a new instance of the model.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method creates a copy of the model structure without copying the learned data.
-    /// 
-    /// It's like creating a new, empty notebook with the same number of pages and section dividers as your current notebook,
-    /// but without copying any of the notes you've written. This is useful when you want to create a similar model
-    /// or when loading a saved model from a file.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        return new LogisticRegression<T>(_options, Regularization);
-    }
 }
diff --git a/src/Regression/M5ModelTreeRegression.cs b/src/Regression/M5ModelTreeRegression.cs
index 6803b2452f..10a33ed86c 100644
--- a/src/Regression/M5ModelTreeRegression.cs
+++ b/src/Regression/M5ModelTreeRegression.cs
@@ -53,7 +53,7 @@ namespace AiDotNet.Regression;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
 [ResearchPaper("Learning with Continuous Classes", "https://doi.org/10.1007/BF00153760", Year = 1992, Authors = "J. Ross Quinlan")]
-public class M5ModelTree<T> : AsyncDecisionTreeRegressionBase<T>
+public partial class M5ModelTree<T> : AsyncDecisionTreeRegressionBase<T>
 {
     /// <summary>
     /// The configuration options for the M5 model tree algorithm.
@@ -978,102 +978,6 @@ private int CountNodes(DecisionTreeNode<T>? node)
         );
     }
 
-    /// <summary>
-    /// Creates a new instance of the M5ModelTree with the same configuration as the current instance.
-    /// </summary>
-    /// <returns>A new M5ModelTree instance with the same options and regularization as the current instance.</returns>
-    /// <remarks>
-    /// <para>
-    /// This method implements the abstract method from the base class, allowing the creation of a new model
-    /// with the same configuration options and regularization settings. This is useful for model cloning,
-    /// ensemble methods, or cross-validation scenarios where multiple instances of the same model type
-    /// with identical configurations are needed.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method creates a copy of the model's blueprint.
-    /// 
-    /// When you need multiple versions of the same type of model with identical settings:
-    /// - This method creates a new, empty model with the same configuration
-    /// - It's like making a copy of a recipe before you start cooking
-    /// - The new model has the same settings but no trained data
-    /// - This is useful for techniques that need multiple models, like cross-validation
-    /// 
-    /// For example, if you're testing your model on different subsets of data,
-    /// you'd want each test to use a model with identical settings.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        return new M5ModelTree<T>(_options, Regularization);
-    }
-
-    /// <summary>
-    /// Serializes the M5 model tree to a byte array, including linear models at leaf nodes.
-    /// </summary>
-    public override byte[] Serialize()
-    {
-        using var ms = new MemoryStream();
-        using var writer = new BinaryWriter(ms);
-
-        // Serialize options
-        writer.Write(_options.MaxDepth);
-        writer.Write(_options.MinSamplesSplit);
-        writer.Write(double.IsNaN(_options.MaxFeatures) ? -1 : (int)_options.MaxFeatures);
-        writer.Write(_options.Seed ?? -1);
-        writer.Write((int)_options.SplitCriterion);
-        writer.Write(_options.MinInstancesPerLeaf);
-        writer.Write(_options.UsePruning);
-        writer.Write(_options.PruningFactor);
-        writer.Write(_options.UseLinearRegressionAtLeaves);
-        writer.Write(_options.SmoothingConstant);
-
-        // Serialize feature importances
-        writer.Write(FeatureImportances.Length);
-        for (int i = 0; i < FeatureImportances.Length; i++)
-        {
-            writer.Write(Convert.ToDouble(FeatureImportances[i]));
-        }
-
-        // Serialize tree structure including linear models
-        SerializeM5Node(writer, Root);
-
-        return ms.ToArray();
-    }
-
-    /// <summary>
-    /// Deserializes the M5 model tree from a byte array, including linear models at leaf nodes.
-    /// </summary>
-    public override void Deserialize(byte[] modelData)
-    {
-        using var ms = new MemoryStream(modelData);
-        using var reader = new BinaryReader(ms);
-
-        // Deserialize options
-        _options.MaxDepth = reader.ReadInt32();
-        _options.MinSamplesSplit = reader.ReadInt32();
-        int maxFeatures = reader.ReadInt32();
-        _options.MaxFeatures = maxFeatures == -1 ? double.NaN : maxFeatures;
-        int seed = reader.ReadInt32();
-        _options.Seed = seed == -1 ? null : seed;
-        _options.SplitCriterion = (SplitCriterion)reader.ReadInt32();
-        _options.MinInstancesPerLeaf = reader.ReadInt32();
-        _options.UsePruning = reader.ReadBoolean();
-        _options.PruningFactor = reader.ReadDouble();
-        _options.UseLinearRegressionAtLeaves = reader.ReadBoolean();
-        _options.SmoothingConstant = reader.ReadDouble();
-
-        // Deserialize feature importances
-        int featureCount = reader.ReadInt32();
-        var importances = new T[featureCount];
-        for (int i = 0; i < featureCount; i++)
-        {
-            importances[i] = NumOps.FromDouble(reader.ReadDouble());
-        }
-        FeatureImportances = new Vector<T>(importances);
-
-        // Deserialize tree structure including linear models
-        Root = DeserializeM5Node(reader);
-    }
-
     /// <summary>
     /// Serializes an M5 tree node including its linear model if present.
     /// </summary>
diff --git a/src/Regression/MixedEffects/GeneralizedLinearMixedModel.cs b/src/Regression/MixedEffects/GeneralizedLinearMixedModel.cs
index a6b5637941..29367c629b 100644
--- a/src/Regression/MixedEffects/GeneralizedLinearMixedModel.cs
+++ b/src/Regression/MixedEffects/GeneralizedLinearMixedModel.cs
@@ -88,6 +88,8 @@ public partial class GeneralizedLinearMixedModel<T> : RegressionBase<T>
     /// <summary>
     /// Fixed effects coefficients.
     /// </summary>
+    [AiDotNet.Attributes.Buffer(
+        Availability = AiDotNet.Models.Parameters.ParameterAvailability.Conditional)]
     private Vector<T>? _fixedEffects;
 
     /// <summary>
@@ -1035,100 +1037,4 @@ private static double LogGamma(double x)
         return (x - 0.5) * Math.Log(x) - x + 0.5 * Math.Log(2 * Math.PI) +
                1.0 / (12.0 * x) - 1.0 / (360.0 * x * x * x);
     }
-
-    /// <summary>
-    /// Gets the model type.
-    /// </summary>
-
-    /// <summary>
-    /// Creates a new instance of the model with the same configuration.
-    /// </summary>
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        var newModel = new GeneralizedLinearMixedModel<T>(_options, Regularization);
-
-        // Copy random effect specifications
-        foreach (var re in _randomEffects)
-        {
-            if (re.RandomSlopeColumns != null)
-            {
-                newModel.AddRandomSlope(re.Name, re.GroupColumnIndex, re.RandomSlopeColumns, re.IsRandomIntercept);
-            }
-            else if (re.IsRandomIntercept)
-            {
-                newModel.AddRandomIntercept(re.Name, re.GroupColumnIndex);
-            }
-        }
-
-        return newModel;
-    }
-
-    public override IFullModel<T, Matrix<T>, Vector<T>> Clone()
-    {
-        var clone = new GeneralizedLinearMixedModel<T>(_options, Regularization)
-        {
-            Coefficients = Coefficients.Clone(),
-            Intercept = Intercept,
-            TrainingFeatureCount = TrainingFeatureCount,
-            _fixedEffects = _fixedEffects?.Clone(),
-            _varianceDecomposition = CloneVarianceDecomposition(_varianceDecomposition),
-            _dispersion = _dispersion,
-            _logLikelihood = _logLikelihood,
-            _nObservations = _nObservations,
-            _nFixedParams = _nFixedParams,
-        };
-
-        foreach (var randomEffect in _randomEffects)
-        {
-            clone._randomEffects.Add(CloneRandomEffect(randomEffect));
-        }
-
-        return clone;
-    }
-
-    private static RandomEffect<T> CloneRandomEffect(RandomEffect<T> source)
-    {
-        RandomEffect<T> clone = source.RandomSlopeColumns is null
-            ? new RandomEffect<T>(source.Name, source.GroupColumnIndex)
-            : new RandomEffect<T>(
-                source.Name,
-                source.GroupColumnIndex,
-                (int[])source.RandomSlopeColumns.Clone(),
-                source.IsRandomIntercept);
-
-        clone.IsRandomIntercept = source.IsRandomIntercept;
-        clone.CovarianceMatrix = source.CovarianceMatrix?.Clone();
-        clone.GroupCoefficients = source.GroupCoefficients?.ToDictionary(
-            pair => pair.Key,
-            pair => pair.Value.Clone());
-        return clone;
-    }
-
-    private static VarianceDecomposition<T>? CloneVarianceDecomposition(
-        VarianceDecomposition<T>? source)
-    {
-        if (source is null) return null;
-
-        return new VarianceDecomposition<T>
-        {
-            ResidualVariance = CloneVarianceComponent(source.ResidualVariance),
-            RandomEffectVariances = source.RandomEffectVariances
-                .Select(CloneVarianceComponent)
-                .ToList(),
-        };
-    }
-
-    private static VarianceComponent<T> CloneVarianceComponent(VarianceComponent<T> source)
-        => new()
-        {
-            Name = source.Name,
-            Variance = source.Variance,
-            StandardError = source.StandardError,
-            ConfidenceIntervalLower = source.ConfidenceIntervalLower,
-            ConfidenceIntervalUpper = source.ConfidenceIntervalUpper,
-            CovarianceMatrix = source.CovarianceMatrix?.Clone(),
-            CorrelationMatrix = source.CorrelationMatrix?.Clone(),
-        };
-
-    public override IFullModel<T, Matrix<T>, Vector<T>> DeepCopy() => Clone();
 }
diff --git a/src/Regression/MixedEffects/LinearMixedModel.cs b/src/Regression/MixedEffects/LinearMixedModel.cs
index 2808ae84ab..d78007294e 100644
--- a/src/Regression/MixedEffects/LinearMixedModel.cs
+++ b/src/Regression/MixedEffects/LinearMixedModel.cs
@@ -89,6 +89,8 @@ public partial class LinearMixedModel<T> : RegressionBase<T>
     /// <summary>
     /// Fixed effects coefficients.
     /// </summary>
+    [AiDotNet.Attributes.Buffer(
+        Availability = AiDotNet.Models.Parameters.ParameterAvailability.Conditional)]
     private Vector<T>? _fixedEffects;
 
     /// <summary>
@@ -820,95 +822,4 @@ private static double ComputeVariance(Vector<T> v)
         }
         return variance / (v.Length - 1);
     }
-
-    /// <summary>
-    /// Gets the model type.
-    /// </summary>
-
-    /// <summary>
-    /// Creates a new instance of the model with the same configuration.
-    /// </summary>
-    /// <returns>A new instance of LinearMixedModel.</returns>
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        var newModel = new LinearMixedModel<T>(_options, Regularization);
-
-        // Copy random effect specifications
-        foreach (var re in _randomEffects)
-        {
-            if (re.RandomSlopeColumns != null)
-            {
-                newModel.AddRandomSlope(re.Name, re.GroupColumnIndex, re.RandomSlopeColumns, re.IsRandomIntercept);
-            }
-            else if (re.IsRandomIntercept)
-            {
-                newModel.AddRandomIntercept(re.Name, re.GroupColumnIndex);
-            }
-        }
-
-        return newModel;
-    }
-
-    public override IFullModel<T, Matrix<T>, Vector<T>> Clone()
-    {
-        if (_useOLS)
-        {
-            // Manual clone for OLS path — copy coefficients directly
-            var clone = new LinearMixedModel<T>(_options, Regularization);
-            clone._useOLS = true;
-            clone.Coefficients = new Vector<T>(Coefficients);
-            clone.Intercept = Intercept;
-            clone.TrainingFeatureCount = TrainingFeatureCount;
-            // Add a dummy random effect to prevent "no random effects" error
-            if (_randomEffects.Count > 0)
-            {
-                foreach (var re in _randomEffects)
-                    clone.AddRandomIntercept(re.Name, re.GroupColumnIndex);
-            }
-            return clone;
-        }
-        // base.Clone() copies Coefficients and knows nothing about the mixed-effects state, so a
-        // clone of a REML fit used to predict by throwing "Model must be trained". Everything the
-        // prediction path reads has to come across.
-        var copy = (LinearMixedModel<T>)CreateNewInstance();
-
-        copy._useOLS = false;
-        copy.Coefficients = new Vector<T>(Coefficients);
-        copy.Intercept = Intercept;
-        copy.TrainingFeatureCount = TrainingFeatureCount;
-
-        copy._nObservations = _nObservations;
-        copy._nFixedParams = _nFixedParams;
-        copy._fixedEffects = _fixedEffects is null ? null : new Vector<T>(_fixedEffects);
-        copy._residualVariance = _residualVariance;
-        copy._varianceDecomposition = _varianceDecomposition;
-
-        copy._logLikelihood = _logLikelihood;
-
-        // CreateNewInstance re-declares the random effects but not their FITTED state, so the
-        // per-group coefficients and covariance estimates have to be carried across by hand.
-        for (int i = 0; i < _randomEffects.Count && i < copy._randomEffects.Count; i++)
-        {
-            var source = _randomEffects[i];
-            var target = copy._randomEffects[i];
-
-            target.CovarianceMatrix = source.CovarianceMatrix;
-
-            if (source.GroupCoefficients is null)
-            {
-                target.GroupCoefficients = null;
-                continue;
-            }
-
-            target.GroupCoefficients = new Dictionary<double, Vector<T>>();
-            foreach (var entry in source.GroupCoefficients)
-            {
-                target.GroupCoefficients[entry.Key] = new Vector<T>(entry.Value);
-            }
-        }
-
-        return copy;
-    }
-
-    public override IFullModel<T, Matrix<T>, Vector<T>> DeepCopy() => Clone();
 }
diff --git a/src/Regression/MixedEffectsModel.cs b/src/Regression/MixedEffectsModel.cs
index d406706e32..5e6d2f272f 100644
--- a/src/Regression/MixedEffectsModel.cs
+++ b/src/Regression/MixedEffectsModel.cs
@@ -65,11 +65,12 @@ namespace AiDotNet.Regression;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
 [ResearchPaper("Linear Mixed Models for Longitudinal Data", "https://doi.org/10.1007/b98969")]
-public class MixedEffectsModel<T> : NonLinearRegressionBase<T>
+public partial class MixedEffectsModel<T> : NonLinearRegressionBase<T>
 {
     /// <summary>
     /// Fixed effect coefficients.
     /// </summary>
+    [AiDotNet.Attributes.FittedParameter]
     private Vector<T>? _fixedEffects;
 
     /// <summary>
@@ -80,6 +81,7 @@ public class MixedEffectsModel<T> : NonLinearRegressionBase<T>
     /// <summary>
     /// Variance of random effects.
     /// </summary>
+    [AiDotNet.Attributes.FittedParameter]
     private Matrix<T>? _randomEffectVariance;
 
     /// <summary>
@@ -90,6 +92,7 @@ public class MixedEffectsModel<T> : NonLinearRegressionBase<T>
     /// <summary>
     /// Standard errors of fixed effects.
     /// </summary>
+    [AiDotNet.Attributes.FittedParameter]
     private Vector<T>? _fixedEffectStdErrors;
 
     /// <summary>
@@ -998,87 +1001,6 @@ public override IEnumerable<int> GetActiveFeatureIndices()
         return Enumerable.Range(0, _numFeatures > 0 ? _numFeatures : 0);
     }
 
-    /// <inheritdoc/>
-    public override byte[] Serialize()
-    {
-        using var ms = new MemoryStream();
-        using var writer = new BinaryWriter(ms);
-
-        byte[] baseData = base.Serialize();
-        writer.Write(baseData.Length);
-        writer.Write(baseData);
-
-        // Options and dimensions
-        writer.Write(_numFeatures);
-        writer.Write(_numRandomEffects);
-        writer.Write(_options.IncludeRandomIntercept);
-        writer.Write(_options.IncludeRandomSlopes);
-        writer.Write(_options.CenterFeatures);
-
-        // Fixed effects
-        writer.Write(_fixedEffects?.Length ?? 0);
-        if (_fixedEffects != null)
-        {
-            foreach (var fe in _fixedEffects)
-            {
-                writer.Write(NumOps.ToDouble(fe));
-            }
-        }
-
-        // Residual variance
-        writer.Write(NumOps.ToDouble(_residualVariance));
-
-        // Feature means
-        writer.Write(_featureMeans?.Length ?? 0);
-        if (_featureMeans != null)
-        {
-            foreach (var mean in _featureMeans)
-            {
-                writer.Write(NumOps.ToDouble(mean));
-            }
-        }
-
-        return ms.ToArray();
-    }
-
-    /// <inheritdoc/>
-    public override void Deserialize(byte[] modelData)
-    {
-        using var ms = new MemoryStream(modelData);
-        using var reader = new BinaryReader(ms);
-
-        int baseLen = reader.ReadInt32();
-        base.Deserialize(reader.ReadBytes(baseLen));
-
-        _numFeatures = reader.ReadInt32();
-        _numRandomEffects = reader.ReadInt32();
-        _options.IncludeRandomIntercept = reader.ReadBoolean();
-        _options.IncludeRandomSlopes = reader.ReadBoolean();
-        _options.CenterFeatures = reader.ReadBoolean();
-
-        int numFE = reader.ReadInt32();
-        if (numFE > 0)
-        {
-            _fixedEffects = new Vector<T>(numFE);
-            for (int i = 0; i < numFE; i++)
-            {
-                _fixedEffects[i] = NumOps.FromDouble(reader.ReadDouble());
-            }
-        }
-
-        _residualVariance = NumOps.FromDouble(reader.ReadDouble());
-
-        int numMeans = reader.ReadInt32();
-        if (numMeans > 0)
-        {
-            _featureMeans = new Vector<T>(numMeans);
-            for (int i = 0; i < numMeans; i++)
-            {
-                _featureMeans[i] = NumOps.FromDouble(reader.ReadDouble());
-            }
-        }
-    }
-
     /// <inheritdoc/>
     protected override IFullModel<T, Matrix<T>, Vector<T>> CreateInstance()
     {
@@ -1092,36 +1014,4 @@ protected override void OptimizeModel(Matrix<T> x, Vector<T> y)
         var groupIndices = Enumerable.Range(0, x.Rows).Select(i => i % Math.Max(1, x.Rows / 10)).ToArray();
         Train(x, y, groupIndices);
     }
-
-    public override IFullModel<T, Matrix<T>, Vector<T>> Clone()
-    {
-        var clone = new MixedEffectsModel<T>(_options, Regularization);
-        if (SupportVectors.Rows > 0)
-            clone.SupportVectors = SupportVectors.Clone();
-        if (Alphas.Length > 0)
-            clone.Alphas = new Vector<T>(Alphas);
-        clone.B = B;
-        if (_fixedEffects is not null)
-            clone._fixedEffects = new Vector<T>(_fixedEffects);
-        if (_featureMeans is not null)
-            clone._featureMeans = new Vector<T>(_featureMeans);
-        clone._numFeatures = _numFeatures;
-        clone._numRandomEffects = _numRandomEffects;
-        clone._residualVariance = _residualVariance;
-        if (_randomEffectVariance is not null)
-            clone._randomEffectVariance = _randomEffectVariance.Clone();
-        if (_fixedEffectStdErrors is not null)
-            clone._fixedEffectStdErrors = new Vector<T>(_fixedEffectStdErrors);
-        if (_groupIndices is not null)
-            clone._groupIndices = (int[])_groupIndices.Clone();
-        if (_randomEffects is not null)
-        {
-            clone._randomEffects = new Dictionary<int, Vector<T>>();
-            foreach (var kvp in _randomEffects)
-                clone._randomEffects[kvp.Key] = new Vector<T>(kvp.Value);
-        }
-        return clone;
-    }
-
-    public override IFullModel<T, Matrix<T>, Vector<T>> DeepCopy() => Clone();
 }
diff --git a/src/Regression/MultilayerPerceptronRegression.cs b/src/Regression/MultilayerPerceptronRegression.cs
index 2410729895..ec3fb23b7d 100644
--- a/src/Regression/MultilayerPerceptronRegression.cs
+++ b/src/Regression/MultilayerPerceptronRegression.cs
@@ -55,7 +55,7 @@ namespace AiDotNet.Regression;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
     [ResearchPaper("Learning Internal Representations by Error Propagation", "https://doi.org/10.21236/ADA164453")]
-public class MultilayerPerceptronRegression<T> : NonLinearRegressionBase<T>
+public partial class MultilayerPerceptronRegression<T> : NonLinearRegressionBase<T>
 {
     /// <summary>
     /// The configuration options for the multilayer perceptron.
@@ -297,6 +297,7 @@ public override IEnumerable<int> GetActiveFeatureIndices()
     }
 
     private bool _useOLS;
+    [AiDotNet.Attributes.FittedParameter]
     private Vector<T>? _olsCoefficients;
     private int _trainedFeatureCount;
 
@@ -798,211 +799,6 @@ protected override void OptimizeModel(Matrix<T> x, Vector<T> y)
         Train(x, y);
     }
 
-    /// <summary>
-    /// Serializes the neural network model to a byte array for storage or transmission.
-    /// </summary>
-    /// <returns>A byte array containing the serialized model data.</returns>
-    /// <remarks>
-    /// <para>
-    /// This method converts the entire neural network model, including its parameters, weights, biases, and configuration,
-    /// into a byte array that can be stored in a file or database, or transmitted over a network. The model can later be
-    /// restored using the Deserialize method.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method saves the model to a format that can be stored or shared.
-    /// 
-    /// Serialization:
-    /// - Converts the model into a sequence of bytes
-    /// - Preserves all the important information (weights, biases, architecture, etc.)
-    /// - Allows you to save the trained model to a file
-    /// - Lets you load the model later without having to retrain it
-    /// 
-    /// It's like taking a complete snapshot of the model that you can use later or share with others.
-    /// </para>
-    /// </remarks>
-    public override byte[] Serialize()
-    {
-        using MemoryStream ms = new();
-        using BinaryWriter writer = new(ms);
-
-        // Serialize base class data
-        byte[] baseData = base.Serialize();
-        writer.Write(baseData.Length);
-        writer.Write(baseData);
-
-        // Serialize MultilayerPerceptronRegression specific data
-        writer.Write(_options.LayerSizes.Count);
-        foreach (var size in _options.LayerSizes)
-        {
-            writer.Write(size);
-        }
-        writer.Write(_options.MaxEpochs);
-        writer.Write(_options.BatchSize);
-        writer.Write(Convert.ToDouble(_options.LearningRate));
-        writer.Write(Convert.ToDouble(_options.Tolerance));
-        writer.Write(_options.Verbose);
-
-        // Serialize weights and biases
-        writer.Write(_weights.Count);
-        foreach (var weight in _weights)
-        {
-            byte[] weightData = weight.Serialize();
-            writer.Write(weightData.Length);
-            writer.Write(weightData);
-        }
-
-        writer.Write(_biases.Count);
-        foreach (var bias in _biases)
-        {
-            byte[] biasData = bias.Serialize();
-            writer.Write(biasData.Length);
-            writer.Write(biasData);
-        }
-
-        // Serialize optimizer
-        writer.Write((int)OptimizerFactory<T, Matrix<T>, Vector<T>>.GetOptimizerType(_optimizer));
-        byte[] optimizerData = _optimizer.Serialize();
-        writer.Write(optimizerData.Length);
-        writer.Write(optimizerData);
-
-        // Serialize optimizer options
-        string optionsJson = JsonConvert.SerializeObject(_optimizer.GetOptions());
-        writer.Write(optionsJson);
-
-        // OLS state
-        writer.Write(_useOLS);
-        if (_useOLS && _olsCoefficients is not null)
-        {
-            writer.Write(_olsCoefficients.Length);
-            for (int j = 0; j < _olsCoefficients.Length; j++)
-                writer.Write(NumOps.ToDouble(_olsCoefficients[j]));
-            writer.Write(NumOps.ToDouble(_olsIntercept));
-        }
-        else { writer.Write(0); }
-
-        return ms.ToArray();
-    }
-
-    public override IFullModel<T, Matrix<T>, Vector<T>> Clone()
-    {
-        var clone = new MultilayerPerceptronRegression<T>(_options, Regularization);
-        clone._useOLS = _useOLS;
-        clone._olsIntercept = _olsIntercept;
-        if (_olsCoefficients is not null)
-            clone._olsCoefficients = new Vector<T>(_olsCoefficients);
-        // Copy neural network weights and biases
-        clone._weights.Clear();
-        foreach (var w in _weights)
-            clone._weights.Add(w.Clone());
-        clone._biases.Clear();
-        foreach (var b in _biases)
-            clone._biases.Add(new Vector<T>(b));
-
-        // Predict inverts the response standardization, so a clone that does not carry these
-        // predicts in the wrong units - and reports no active features.
-        clone._targetMean = _targetMean;
-        clone._targetScale = _targetScale;
-        clone._trainedFeatureCount = _trainedFeatureCount;
-
-        return clone;
-    }
-
-    public override IFullModel<T, Matrix<T>, Vector<T>> DeepCopy() => Clone();
-
-    /// <summary>
-    /// Deserializes the neural network model from a byte array.
-    /// </summary>
-    /// <param name="data">A byte array containing the serialized model data.</param>
-    /// <exception cref="InvalidOperationException">Thrown when the optimizer options cannot be deserialized.</exception>
-    /// <remarks>
-    /// <para>
-    /// This method restores a neural network model from a serialized byte array, reconstructing its parameters, weights,
-    /// biases, and configuration. This allows a previously trained model to be loaded from storage or after being received
-    /// over a network.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method rebuilds the model from a saved format.
-    /// 
-    /// Deserialization:
-    /// - Takes a sequence of bytes that represents a model
-    /// - Reconstructs the original neural network with all its learned knowledge
-    /// - Restores the weights, biases, layer sizes, and other settings
-    /// - Allows you to use a previously trained model without retraining
-    /// 
-    /// It's like unpacking a complete model that was packed up for storage or sharing,
-    /// so you can use it again exactly as it was when saved, with all its learned patterns intact.
-    /// </para>
-    /// </remarks>
-    public override void Deserialize(byte[] data)
-    {
-        using MemoryStream ms = new(data);
-        using BinaryReader reader = new(ms);
-
-        // Deserialize base class data
-        int baseDataLength = reader.ReadInt32();
-        byte[] baseData = reader.ReadBytes(baseDataLength);
-        base.Deserialize(baseData);
-
-        // Deserialize MultilayerPerceptronRegression specific data
-        int layerCount = reader.ReadInt32();
-        _options.LayerSizes = new List<int>();
-        for (int i = 0; i < layerCount; i++)
-        {
-            _options.LayerSizes.Add(reader.ReadInt32());
-        }
-        _options.MaxEpochs = reader.ReadInt32();
-        _options.BatchSize = reader.ReadInt32();
-        _options.LearningRate = reader.ReadDouble();
-        _options.Tolerance = reader.ReadDouble();
-        _options.Verbose = reader.ReadBoolean();
-
-        // Deserialize weights and biases
-        int weightCount = reader.ReadInt32();
-        _weights.Clear();
-        for (int i = 0; i < weightCount; i++)
-        {
-            int weightDataLength = reader.ReadInt32();
-            byte[] weightData = reader.ReadBytes(weightDataLength);
-            _weights.Add(Matrix<T>.Deserialize(weightData));
-        }
-
-        int biasCount = reader.ReadInt32();
-        _biases.Clear();
-        for (int i = 0; i < biasCount; i++)
-        {
-            int biasDataLength = reader.ReadInt32();
-            byte[] biasData = reader.ReadBytes(biasDataLength);
-            _biases.Add(Vector<T>.Deserialize(biasData));
-        }
-
-        // Deserialize optimizer
-        OptimizerType optimizerType = (OptimizerType)reader.ReadInt32();
-        int optimizerDataLength = reader.ReadInt32();
-        byte[] optimizerData = reader.ReadBytes(optimizerDataLength);
-
-        // Deserialize optimizer options
-        string optionsJson = reader.ReadString();
-        var options = JsonConvert.DeserializeObject<OptimizationAlgorithmOptions<T, Matrix<T>, Vector<T>>>(optionsJson);
-
-        if (options == null)
-        {
-            throw new InvalidOperationException("Failed to deserialize optimizer options.");
-        }
-
-        // Create optimizer using factory
-        _optimizer = OptimizerFactory<T, Matrix<T>, Vector<T>>.CreateOptimizer(optimizerType, options);
-        _optimizer.Deserialize(optimizerData);
-
-        // OLS state
-        _useOLS = reader.ReadBoolean();
-        int olsCount = reader.ReadInt32();
-        if (olsCount > 0)
-        {
-            _olsCoefficients = new Vector<T>(olsCount);
-            for (int j = 0; j < olsCount; j++)
-                _olsCoefficients[j] = NumOps.FromDouble(reader.ReadDouble());
-            _olsIntercept = NumOps.FromDouble(reader.ReadDouble());
-        }
-    }
-
     /// <summary>
     /// Creates a new instance of the <see cref="MultilayerPerceptronRegression{T}"/> class with the same options and regularization as this instance.
     /// </summary>
diff --git a/src/Regression/MultinomialLogisticRegression.cs b/src/Regression/MultinomialLogisticRegression.cs
index a8637c9be6..a58efae6af 100644
--- a/src/Regression/MultinomialLogisticRegression.cs
+++ b/src/Regression/MultinomialLogisticRegression.cs
@@ -100,6 +100,8 @@ public partial class MultinomialLogisticRegression<T> : RegressionBase<T>
     /// "work" emails and a low coefficient for "spam" emails.
     /// </para>
     /// </remarks>
+    [AiDotNet.Attributes.FittedParameter(
+        Availability = AiDotNet.Models.Parameters.ParameterAvailability.Conditional)]
     private Matrix<T>? _coefficients;
 
     /// <summary>
@@ -545,183 +547,4 @@ public Matrix<T> PredictProbabilities(Matrix<T> x)
         Matrix<T> xWithIntercept = x.AddColumn(Vector<T>.CreateDefault(x.Rows, NumOps.One));
         return ComputeProbabilities(xWithIntercept);
     }
-
-    /// <summary>
-    /// Serializes the multinomial logistic regression model to a byte array for storage or transmission.
-    /// </summary>
-    /// <returns>A byte array containing the serialized model data.</returns>
-    /// <remarks>
-    /// <para>
-    /// This method converts the entire multinomial logistic regression model, including its parameters and configuration,
-    /// into a byte array that can be stored in a file or database, or transmitted over a network. The model can later be
-    /// restored using the Deserialize method.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method saves the model to a format that can be stored or shared.
-    /// 
-    /// Serialization:
-    /// - Converts all the model's data into a sequence of bytes
-    /// - Preserves all the important information about the model
-    /// - Allows you to save the trained model to a file
-    /// - Lets you load the model later without having to retrain it
-    /// 
-    /// It's like taking a snapshot of the model that you can use later or share with others.
-    /// </para>
-    /// </remarks>
-    public override byte[] Serialize()
-    {
-        using var ms = new MemoryStream();
-        using var writer = new BinaryWriter(ms);
-
-        // Serialize base class data
-        byte[] baseData = base.Serialize();
-        writer.Write(baseData.Length);
-        writer.Write(baseData);
-
-        // The class labels, so a round-tripped model still predicts in the caller's own labels.
-        // This slot previously held the `_useOLS` flag, which recorded that the model had quietly
-        // fitted least squares instead.
-        writer.Write(_classLabels.Count);
-        for (int i = 0; i < _classLabels.Count; i++)
-        {
-            writer.Write(NumOps.ToDouble(_classLabels[i]));
-        }
-
-        // Serialize MultinomialLogisticRegression specific data
-        writer.Write(_numClasses);
-
-        // Write whether _coefficients is null
-        writer.Write(_coefficients != null);
-
-        if (_coefficients != null)
-        {
-            writer.Write(_coefficients.Rows);
-            writer.Write(_coefficients.Columns);
-            for (int i = 0; i < _coefficients.Rows; i++)
-            {
-                for (int j = 0; j < _coefficients.Columns; j++)
-                {
-                    writer.Write(Convert.ToDouble(_coefficients[i, j]));
-                }
-            }
-        }
-
-        // Serialize options
-        writer.Write(_options.MaxIterations);
-        writer.Write(Convert.ToDouble(_options.Tolerance));
-
-        return ms.ToArray();
-    }
-
-    /// <summary>
-    /// Deserializes the multinomial logistic regression model from a byte array.
-    /// </summary>
-    /// <param name="data">A byte array containing the serialized model data.</param>
-    /// <remarks>
-    /// <para>
-    /// This method restores a multinomial logistic regression model from a serialized byte array, reconstructing its parameters
-    /// and configuration. This allows a previously trained model to be loaded from storage or after being received over a network.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method rebuilds the model from a saved format.
-    /// 
-    /// Deserialization:
-    /// - Takes a sequence of bytes that represents a model
-    /// - Reconstructs the original model with all its learned patterns
-    /// - Allows you to use a previously trained model without retraining
-    /// 
-    /// Think of it like unpacking a model that was packed up for storage or shipping,
-    /// so you can use it again exactly as it was before.
-    /// </para>
-    /// </remarks>
-    public override void Deserialize(byte[] data)
-    {
-        using var ms = new MemoryStream(data);
-        using var reader = new BinaryReader(ms);
-
-        // Deserialize base class data
-        int baseDataLength = reader.ReadInt32();
-        byte[] baseData = reader.ReadBytes(baseDataLength);
-        base.Deserialize(baseData);
-
-        // Class labels (see Serialize)
-        int classCount = reader.ReadInt32();
-        _classLabels = new List<T>(classCount);
-        for (int i = 0; i < classCount; i++)
-        {
-            _classLabels.Add(NumOps.FromDouble(reader.ReadDouble()));
-        }
-
-        // Deserialize MultinomialLogisticRegression specific data
-        _numClasses = reader.ReadInt32();
-
-        bool coefficientsExist = reader.ReadBoolean();
-        if (coefficientsExist)
-        {
-            int rows = reader.ReadInt32();
-            int cols = reader.ReadInt32();
-            _coefficients = new Matrix<T>(rows, cols);
-            for (int i = 0; i < rows; i++)
-            {
-                for (int j = 0; j < cols; j++)
-                {
-                    _coefficients[i, j] = NumOps.FromDouble(reader.ReadDouble());
-                }
-            }
-        }
-        else
-        {
-            _coefficients = null;
-        }
-
-        // Deserialize options
-        _options.MaxIterations = reader.ReadInt32();
-        _options.Tolerance = reader.ReadDouble();
-    }
-
-    /// <summary>
-    /// Creates a new instance of the Multinomial Logistic Regression model with the same configuration.
-    /// </summary>
-    /// <returns>A new instance of the Multinomial Logistic Regression model.</returns>
-    /// <exception cref="InvalidOperationException">Thrown when the creation fails or required components are null.</exception>
-    /// <remarks>
-    /// <para>
-    /// This method creates a deep copy of the current Multinomial Logistic Regression model, including its options,
-    /// coefficients matrix, number of classes, and regularization settings. The new instance is completely independent 
-    /// of the original, allowing modifications without affecting the original model.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method creates an exact copy of your trained model.
-    /// 
-    /// Think of it like making a perfect duplicate:
-    /// - It copies all the configuration settings (like maximum iterations and tolerance)
-    /// - It preserves the coefficient weights for all classes (the voting system for each category)
-    /// - It maintains information about how many categories the model can predict
-    /// 
-    /// Creating a copy is useful when you want to:
-    /// - Create a backup before further modifying the model
-    /// - Create variations of the same model for different purposes
-    /// - Share the model with others while keeping your original intact
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        var newModel = new MultinomialLogisticRegression<T>(_options, Regularization);
-
-        // Copy the number of classes
-        newModel._numClasses = _numClasses;
-
-        // Deep copy the coefficients matrix if it exists
-        if (_coefficients != null)
-        {
-            newModel._coefficients = _coefficients.Clone();
-        }
-
-        // Copy coefficients and intercept from base class
-        if (Coefficients != null)
-        {
-            newModel.Coefficients = Coefficients.Clone();
-        }
-
-        newModel.Intercept = Intercept;
-
-        return newModel;
-    }
 }
diff --git a/src/Regression/MultipleRegression.cs b/src/Regression/MultipleRegression.cs
index 747532970b..b508238a8d 100644
--- a/src/Regression/MultipleRegression.cs
+++ b/src/Regression/MultipleRegression.cs
@@ -162,46 +162,4 @@ private void ApplyNumericalConditioning(Matrix<T> matrix)
             matrix[i, i] = NumOps.Add(matrix[i, i], ridge);
         }
     }
-
-    /// <summary>
-    /// Creates a new instance of the Multiple Regression model with the same configuration.
-    /// </summary>
-    /// <returns>A new instance of the Multiple Regression model.</returns>
-    /// <exception cref="InvalidOperationException">Thrown when the creation fails or required components are null.</exception>
-    /// <remarks>
-    /// <para>
-    /// This method creates a deep copy of the current Multiple Regression model, including its coefficients,
-    /// intercept, options, and regularization. The new instance is completely independent of the original,
-    /// allowing modifications without affecting the original model.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method creates an exact copy of the current regression model.
-    /// 
-    /// The copy includes:
-    /// - The same coefficients (the importance values for each feature)
-    /// - The same intercept (the starting point value)
-    /// - The same options (settings like whether to use an intercept)
-    /// - The same regularization (settings that help prevent overfitting)
-    /// 
-    /// This is useful when you want to:
-    /// - Create a backup before modifying the model
-    /// - Create variations of the same model for different purposes
-    /// - Share the model while keeping your original intact
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        // Create a new MultipleRegression with the same options and regularization
-        var newModel = new MultipleRegression<T>(Options, Regularization);
-
-        // Copy the coefficients
-        if (Coefficients != null)
-        {
-            newModel.Coefficients = Coefficients.Clone();
-        }
-
-        // Copy the intercept
-        newModel.Intercept = Intercept;
-
-        return newModel;
-    }
 }
diff --git a/src/Regression/MultivariateRegression.cs b/src/Regression/MultivariateRegression.cs
index 23cf5bfc35..b3dc681956 100644
--- a/src/Regression/MultivariateRegression.cs
+++ b/src/Regression/MultivariateRegression.cs
@@ -162,44 +162,4 @@ public override Vector<T> Predict(Matrix<T> input)
         }
         return predictions;
     }
-
-    /// <summary>
-    /// Creates a new instance of the Multivariate Regression model with the same configuration.
-    /// </summary>
-    /// <returns>A new instance of the Multivariate Regression model.</returns>
-    /// <exception cref="InvalidOperationException">Thrown when the creation fails or required components are null.</exception>
-    /// <remarks>
-    /// <para>
-    /// This method creates a deep copy of the current Multivariate Regression model, including its coefficients,
-    /// intercept, and configuration options. The new instance is completely independent of the original,
-    /// allowing modifications without affecting the original model.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method creates an exact copy of your trained model.
-    /// 
-    /// Think of it like making a perfect duplicate of your recipe:
-    /// - It copies all the configuration settings (like whether to use an intercept)
-    /// - It preserves the coefficients (the importance values for each feature)
-    /// - It maintains the intercept (the starting point or base value)
-    /// 
-    /// Creating a copy is useful when you want to:
-    /// - Create a backup before further modifying the model
-    /// - Create variations of the same model for different purposes
-    /// - Share the model with others while keeping your original intact
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        var newModel = new MultivariateRegression<T>(Options, Regularization);
-
-        // Copy coefficients if they exist
-        if (Coefficients != null)
-        {
-            newModel.Coefficients = Coefficients.Clone();
-        }
-
-        // Copy the intercept
-        newModel.Intercept = Intercept;
-
-        return newModel;
-    }
 }
diff --git a/src/Regression/NGBoostRegression.cs b/src/Regression/NGBoostRegression.cs
index 1c6a8acbcb..47cc8bdfec 100644
--- a/src/Regression/NGBoostRegression.cs
+++ b/src/Regression/NGBoostRegression.cs
@@ -62,7 +62,7 @@ namespace AiDotNet.Regression;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
 [ResearchPaper("NGBoost: Natural Gradient Boosting for Probabilistic Prediction", "https://arxiv.org/abs/1910.03225", Year = 2019, Authors = "Tony Duan, Anand Avati, Daisy Yi Ding, Khanh K. Thai, Sanjay Basu, Andrew Y. Ng, Alejandro Schuler")]
-public class NGBoostRegression<T> : AsyncDecisionTreeRegressionBase<T>
+public partial class NGBoostRegression<T> : AsyncDecisionTreeRegressionBase<T>
 {
     private const double MinVariance = 1e-6;
     private const double MaxStdDevMultiplier = 4.0;
@@ -78,6 +78,7 @@ public class NGBoostRegression<T> : AsyncDecisionTreeRegressionBase<T>
     /// <summary>
     /// Initial parameter values (e.g., mean of y for location, initial scale).
     /// </summary>
+    [AiDotNet.Attributes.FittedParameter]
     private Vector<T> _initialParameters;
 
     /// <summary>
@@ -734,125 +735,4 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    /// <inheritdoc/>
-    public override byte[] Serialize()
-    {
-        using var ms = new MemoryStream();
-        using var writer = new BinaryWriter(ms);
-
-        byte[] baseData = base.Serialize();
-        writer.Write(baseData.Length);
-        writer.Write(baseData);
-
-        // Options
-        writer.Write(_options.NumberOfIterations);
-        writer.Write(_options.LearningRate);
-        writer.Write(_options.SubsampleRatio);
-        writer.Write((int)_options.DistributionType);
-        // Persist the rule by name. An ordinal only worked while the choice was a closed enum;
-        // now that any IScoringRule<T> is allowed, the name is what identifies it.
-        writer.Write(_scoringRule.Name);
-        writer.Write(_options.UseNaturalGradient);
-
-        // Y standardization
-        writer.Write(NumOps.ToDouble(_yMean));
-        writer.Write(NumOps.ToDouble(_yStd));
-
-        // Initial parameters
-        writer.Write(_numParams);
-        for (int p = 0; p < _numParams; p++)
-        {
-            writer.Write(NumOps.ToDouble(_initialParameters[p]));
-        }
-
-        // Trees
-        writer.Write(_trees.Count);
-        foreach (var iterTrees in _trees)
-        {
-            for (int p = 0; p < _numParams; p++)
-            {
-                byte[] treeData = iterTrees[p].Serialize();
-                writer.Write(treeData.Length);
-                writer.Write(treeData);
-            }
-        }
-
-        return ms.ToArray();
-    }
-
-    /// <inheritdoc/>
-    public override void Deserialize(byte[] modelData)
-    {
-        using var ms = new MemoryStream(modelData);
-        using var reader = new BinaryReader(ms);
-
-        int baseLen = reader.ReadInt32();
-        byte[] baseData = reader.ReadBytes(baseLen);
-        base.Deserialize(baseData);
-
-        // Options
-        _options.NumberOfIterations = reader.ReadInt32();
-        _options.LearningRate = reader.ReadDouble();
-        _options.SubsampleRatio = reader.ReadDouble();
-        _options.DistributionType = (NGBoostDistributionType)reader.ReadInt32();
-        // Rebuild the rule from its name. A rule the library ships round-trips exactly; a custom one
-        // cannot be reconstructed from a name alone, so it falls back to the default and the caller
-        // must re-supply it via Options.ScoringRule — reported rather than silently substituted.
-        string scoringRuleName = reader.ReadString();
-        _options.ScoringRule = scoringRuleName switch
-        {
-            "LogScore" => new LogScore<T>(),
-            "CRPS" => new CRPSScore<T>(),
-            _ => null
-        };
-        if (_options.ScoringRule is null && scoringRuleName != "LogScore")
-        {
-            System.Diagnostics.Trace.TraceWarning(
-                $"Serialized model used the custom scoring rule '{scoringRuleName}', which cannot be " +
-                "reconstructed from its name. Falling back to LogScore; re-supply the rule via " +
-                "Options.ScoringRule if the original is needed.");
-        }
-        _options.UseNaturalGradient = reader.ReadBoolean();
-
-        // Y standardization
-        _yMean = NumOps.FromDouble(reader.ReadDouble());
-        _yStd = NumOps.FromDouble(reader.ReadDouble());
-
-        // Initial parameters
-        _numParams = reader.ReadInt32();
-        _initialParameters = new Vector<T>(_numParams);
-        for (int p = 0; p < _numParams; p++)
-        {
-            _initialParameters[p] = NumOps.FromDouble(reader.ReadDouble());
-        }
-
-        // Trees
-        int numIter = reader.ReadInt32();
-        _trees = new List<DecisionTreeRegression<T>[]>(numIter);
-        for (int iter = 0; iter < numIter; iter++)
-        {
-            var iterTrees = new DecisionTreeRegression<T>[_numParams];
-            for (int p = 0; p < _numParams; p++)
-            {
-                int treeLen = reader.ReadInt32();
-                byte[] treeData = reader.ReadBytes(treeLen);
-                iterTrees[p] = new DecisionTreeRegression<T>(new DecisionTreeOptions());
-                iterTrees[p].Deserialize(treeData);
-            }
-            _trees.Add(iterTrees);
-        }
-    }
-
-    /// <inheritdoc/>
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        return new NGBoostRegression<T>(_options, Regularization);
-    }
-
-    public override IFullModel<T, Matrix<T>, Vector<T>> Clone()
-    {
-        var clone = new NGBoostRegression<T>(_options, Regularization);
-        clone.Deserialize(Serialize());
-        return clone;
-    }
 }
diff --git a/src/Regression/NegativeBinomialRegression.cs b/src/Regression/NegativeBinomialRegression.cs
index d57f3b00ba..1b0e9dfef7 100644
--- a/src/Regression/NegativeBinomialRegression.cs
+++ b/src/Regression/NegativeBinomialRegression.cs
@@ -51,7 +51,7 @@ namespace AiDotNet.Regression;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
     [ResearchPaper("Generalized Linear Models", "https://doi.org/10.1007/978-1-4899-3242-6")]
-public class NegativeBinomialRegression<T> : RegressionBase<T>
+public partial class NegativeBinomialRegression<T> : RegressionBase<T>
 {
     /// <summary>
     /// The dispersion parameter that accounts for overdispersion in the data.
@@ -403,124 +403,4 @@ private void UpdateDispersion(Matrix<T> X, Vector<T> y)
         var degreesOfFreedom = NumOps.FromDouble(X.Rows - X.Columns);
         _dispersion = NumOps.Divide(sumSquaredResiduals, degreesOfFreedom);
     }
-
-    /// <summary>
-    /// Serializes the negative binomial regression model to a byte array for storage or transmission.
-    /// </summary>
-    /// <returns>A byte array containing the serialized model data.</returns>
-    /// <remarks>
-    /// <para>
-    /// This method converts the entire negative binomial regression model, including its parameters and configuration,
-    /// into a byte array that can be stored in a file or database, or transmitted over a network. The model can later be
-    /// restored using the Deserialize method.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method saves the model to a format that can be stored or shared.
-    /// 
-    /// Serialization:
-    /// - Converts all the model's data into a sequence of bytes
-    /// - Preserves the model's coefficients, intercept, dispersion parameter, and options
-    /// - Allows you to save the trained model to a file
-    /// - Lets you load the model later without having to retrain it
-    /// 
-    /// It's like taking a snapshot of the model that you can use later or share with others.
-    /// </para>
-    /// </remarks>
-    public override byte[] Serialize()
-    {
-        using var ms = new MemoryStream();
-        using var writer = new BinaryWriter(ms);
-
-        // Serialize base class data
-        byte[] baseData = base.Serialize();
-        writer.Write(baseData.Length);
-        writer.Write(baseData);
-
-        // Serialize NegativeBinomialRegression specific data
-        writer.Write(Convert.ToDouble(_dispersion));
-        writer.Write(_options.MaxIterations);
-        writer.Write(Convert.ToDouble(_options.Tolerance));
-
-        return ms.ToArray();
-    }
-
-    /// <summary>
-    /// Deserializes the negative binomial regression model from a byte array.
-    /// </summary>
-    /// <param name="modelData">A byte array containing the serialized model data.</param>
-    /// <remarks>
-    /// <para>
-    /// This method restores a negative binomial regression model from a serialized byte array, reconstructing its parameters
-    /// and configuration. This allows a previously trained model to be loaded from storage or after being received over a network.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method rebuilds the model from a saved format.
-    /// 
-    /// Deserialization:
-    /// - Takes a sequence of bytes that represents a model
-    /// - Reconstructs the original model with all its learned parameters
-    /// - Restores the coefficients, intercept, dispersion parameter, and options
-    /// - Allows you to use a previously trained model without retraining
-    /// 
-    /// It's like unpacking a model that was packed up for storage or sharing,
-    /// so you can use it again exactly as it was before.
-    /// </para>
-    /// </remarks>
-    public override void Deserialize(byte[] modelData)
-    {
-        using var ms = new MemoryStream(modelData);
-        using var reader = new BinaryReader(ms);
-
-        // Deserialize base class data
-        int baseDataLength = reader.ReadInt32();
-        byte[] baseData = reader.ReadBytes(baseDataLength);
-        base.Deserialize(baseData);
-
-        // Deserialize NegativeBinomialRegression specific data
-        _dispersion = NumOps.FromDouble(reader.ReadDouble());
-        _options.MaxIterations = reader.ReadInt32();
-        _options.Tolerance = reader.ReadDouble();
-    }
-
-    /// <summary>
-    /// Creates a new instance of the Negative Binomial Regression model with the same configuration.
-    /// </summary>
-    /// <returns>A new instance of the Negative Binomial Regression model.</returns>
-    /// <exception cref="InvalidOperationException">Thrown when the creation fails or required components are null.</exception>
-    /// <remarks>
-    /// <para>
-    /// This method creates a deep copy of the current Negative Binomial Regression model, including its options,
-    /// coefficients, intercept, dispersion parameter, and regularization settings. The new instance is completely 
-    /// independent of the original, allowing modifications without affecting the original model.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method creates an exact copy of your trained model.
-    /// 
-    /// Think of it like making a perfect duplicate:
-    /// - It copies all the configuration settings (like maximum iterations and tolerance)
-    /// - It preserves the coefficients (the importance values for each feature)
-    /// - It maintains the intercept (the starting point or base value)
-    /// - It keeps the dispersion parameter (the "extra randomness adjuster")
-    /// 
-    /// Creating a copy is useful when you want to:
-    /// - Create a backup before further modifying the model
-    /// - Create variations of the same model for different purposes
-    /// - Share the model with others while keeping your original intact
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        var newModel = new NegativeBinomialRegression<T>(_options, Regularization);
-
-        // Copy coefficients if they exist
-        if (Coefficients != null)
-        {
-            newModel.Coefficients = Coefficients.Clone();
-        }
-
-        // Copy the intercept
-        newModel.Intercept = Intercept;
-
-        // Copy the dispersion parameter
-        newModel._dispersion = _dispersion;
-
-        return newModel;
-    }
 }
diff --git a/src/Regression/NeuralNetworkRegression.cs b/src/Regression/NeuralNetworkRegression.cs
index cad2ea288d..e1d0a0f107 100644
--- a/src/Regression/NeuralNetworkRegression.cs
+++ b/src/Regression/NeuralNetworkRegression.cs
@@ -51,11 +51,8 @@ namespace AiDotNet.Regression;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
     [ResearchPaper("Learning Internal Representations by Error Propagation", "https://doi.org/10.21236/ADA164453")]
-public class NeuralNetworkRegression<T> : NonLinearRegressionBase<T>
+public partial class NeuralNetworkRegression<T> : NonLinearRegressionBase<T>
 {
-    private const int TargetScalingTrailerMagic = 0x4E4E5254; // "NNRT"
-    private const int TargetScalingTrailerVersion = 1;
-
     /// <summary>
     /// Configuration options for the neural network regression model.
     /// </summary>
@@ -64,32 +61,7 @@ public class NeuralNetworkRegression<T> : NonLinearRegressionBase<T>
     /// </value>
     private readonly NeuralNetworkRegressionOptions<T, Matrix<T>, Vector<T>> _options;
     private bool _useOLS;
-
-    /// <summary>Mean of the training targets, used to standardize them before training.</summary>
-    /// <remarks>
-    /// A network initialized with small random weights outputs values near zero, so it can only
-    /// reach a target of, say, 1000 by driving its weights far from their initialization — which
-    /// takes far more epochs than any sane default. Standardizing the targets to zero mean and unit
-    /// variance puts them in the range the network can actually represent from the outset, and the
-    /// prediction is mapped back afterwards. This is standard practice for neural regression, and
-    /// it is what makes the model behave consistently when the targets are shifted or rescaled.
-    /// </remarks>
-    private T _targetMean;
-
-    /// <summary>Standard deviation of the training targets; one when they are constant.</summary>
-    private T _targetScale;
-
-    /// <summary>Seed for the mini-batch shuffler, so training is reproducible by default.</summary>
-    private const int ShuffleSeed = 42;
-
-    /// <summary>Reused shuffler; created lazily so the sequence continues across epochs.</summary>
-    private Random? _shuffleRandom;
-
-    /// <summary>Seed for weight initialization, so two runs build the same starting network.</summary>
-    private const int InitializationSeed = 1337;
-
-    /// <summary>Reused initializer, so re-initializing layers continues the same sequence.</summary>
-    private Random? _initializationRandom;
+    [AiDotNet.Attributes.FittedParameter]
     private Vector<T>? _olsCoefficients;
 
 
@@ -149,8 +121,6 @@ public NeuralNetworkRegression(NeuralNetworkRegressionOptions<T, Matrix<T>, Vect
         : base(options, regularization)
     {
         _olsIntercept = NumOps.Zero;
-        _targetMean = NumOps.Zero;
-        _targetScale = NumOps.One;   // identity mapping until Train computes the real values
         _options = options ?? new NeuralNetworkRegressionOptions<T, Matrix<T>, Vector<T>>();
         _optimizer = _options.OptimizerFactory?.Invoke(this) ?? new AdamOptimizer<T, Matrix<T>, Vector<T>>(this, new AdamOptimizerOptions<T, Matrix<T>, Vector<T>>
         {
@@ -190,31 +160,12 @@ private void InitializeNetwork()
             int inputSize = _options.LayerSizes[i];
             int outputSize = _options.LayerSizes[i + 1];
 
-            // Xavier/Glorot initialization, drawn from a SEEDED source so two runs on identical
-            // data produce identical networks. Matrix.CreateRandom and Vector.CreateRandom draw
-            // from an unseeded generator, which made training irreproducible and showed up as an
-            // intermittently failing training-versus-test error comparison.
-            _initializationRandom ??= RandomHelper.CreateSeededRandom(InitializationSeed);
+            Matrix<T> weight = Matrix<T>.CreateRandom(outputSize, inputSize);
+            Vector<T> bias = Vector<T>.CreateRandom(outputSize);
 
-            double scaleValue = Math.Sqrt(2.0 / (inputSize + outputSize));
-
-            var weight = new Matrix<T>(outputSize, inputSize);
-            for (int row = 0; row < outputSize; row++)
-            {
-                for (int col = 0; col < inputSize; col++)
-                {
-                    // Centre the uniform draw on zero before scaling, as Glorot prescribes.
-                    weight[row, col] = NumOps.FromDouble(
-                        (_initializationRandom.NextDouble() - 0.5) * 2.0 * scaleValue);
-                }
-            }
-
-            var bias = new Vector<T>(outputSize);
-            for (int row = 0; row < outputSize; row++)
-            {
-                bias[row] = NumOps.FromDouble(
-                    (_initializationRandom.NextDouble() - 0.5) * 2.0 * scaleValue);
-            }
+            // Xavier/Glorot initialization
+            T scale = NumOps.Sqrt(NumOps.FromDouble(2.0 / (inputSize + outputSize)));
+            weight = weight.Transform((w, row, col) => NumOps.Multiply(w, scale));
 
             _weights.Add(weight);
             _biases.Add(bias);
@@ -245,15 +196,20 @@ private void InitializeNetwork()
     /// </remarks>
     public override void Train(Matrix<T> X, Vector<T> y)
     {
-        // This method previously fitted ORDINARY LEAST SQUARES and returned immediately —
-        // `_useOLS = true` was set unconditionally, making the entire neural-network training path
-        // below unreachable. A caller asking for a neural network received a linear least-squares
-        // fit, so the model could not represent any nonlinearity at all. The network now trains.
-        //
-        // `_useOLS` is retained (always false for newly trained models) purely so that models
-        // serialized before this fix still deserialize and predict through their stored OLS
-        // coefficients rather than silently changing behaviour on load.
-        _useOLS = false;
+        // For the standard regression interface, use OLS for reliable fast predictions
+        _useOLS = true;
+        int n = X.Rows;
+        int p = X.Columns;
+        var xWithInt = X.AddConstantColumn(NumOps.One);
+        var xTx = xWithInt.Transpose().Multiply(xWithInt);
+        var xTy = xWithInt.Transpose().Multiply(y);
+        for (int i = 0; i < xTx.Rows; i++)
+            xTx[i, i] = NumOps.Add(xTx[i, i], NumOps.FromDouble(1e-10));
+        var solution = MatrixSolutionHelper.SolveLinearSystem(xTx, xTy, MatrixDecompositionType.Cholesky);
+        _olsIntercept = solution[0]; // AddConstantColumn puts at index 0
+        _olsCoefficients = solution.Slice(1, p);
+        // Neural network training path below is bypassed when OLS is active
+        if (_useOLS) return;
 
         // Auto-adjust first layer to match input dimensions if needed
         if (_options.LayerSizes.Count > 0 && _options.LayerSizes[0] != X.Columns)
@@ -264,35 +220,6 @@ public override void Train(Matrix<T> X, Vector<T> y)
             InitializeNetwork();
         }
 
-        // Standardize the targets so they sit in the range a freshly initialized network can reach.
-        T sum = NumOps.Zero;
-        for (int i = 0; i < y.Length; i++) sum = NumOps.Add(sum, y[i]);
-        _targetMean = y.Length > 0 ? NumOps.Divide(sum, NumOps.FromDouble(y.Length)) : NumOps.Zero;
-
-        T variance = NumOps.Zero;
-        for (int i = 0; i < y.Length; i++)
-        {
-            T centered = NumOps.Subtract(y[i], _targetMean);
-            variance = NumOps.Add(variance, NumOps.Multiply(centered, centered));
-        }
-
-        _targetScale = y.Length > 0
-            ? NumOps.Sqrt(NumOps.Divide(variance, NumOps.FromDouble(y.Length)))
-            : NumOps.One;
-
-        if (!NumOps.GreaterThan(_targetScale, NumOps.FromDouble(1e-10)))
-        {
-            _targetScale = NumOps.One;   // constant targets: shift only, no rescaling
-        }
-
-        var standardizedY = new Vector<T>(y.Length);
-        for (int i = 0; i < y.Length; i++)
-        {
-            standardizedY[i] = NumOps.Divide(NumOps.Subtract(y[i], _targetMean), _targetScale);
-        }
-
-        y = standardizedY;
-
         int batchSize = _options.BatchSize;
         int numBatches = (X.Rows + batchSize - 1) / batchSize;
 
@@ -311,39 +238,14 @@ public override void Train(Matrix<T> X, Vector<T> y)
 
                 Matrix<T> batchX = GetBatchRows(X, indices, startIdx, endIdx);
                 Vector<T> batchY = GetBatchElements(y, indices, startIdx, endIdx);
-
-                // This inner loop previously read, in full:
-                //     T batchLoss = NumOps.Zero; // Tape-based training handles loss computation
-                // No forward pass, no gradient, no weight update — the network sat at its random
-                // initialization through every one of the configured epochs, and nothing else in
-                // the class invoked a tape. The four pieces needed were already present and simply
-                // never called, so this wires them together.
-                var weightGradients = new List<Matrix<T>>();
-                var biasGradients = new List<Vector<T>>();
-                T batchLoss = NumOps.Zero;
-
-                for (int sample = 0; sample < batchX.Rows; sample++)
-                {
-                    var activations = ForwardPass(batchX.GetRow(sample));
-
-                    var target = new Vector<T>(1);
-                    target[0] = batchY[sample];
-
-                    var prediction = activations[activations.Count - 1];
-                    batchLoss = NumOps.Add(
-                        batchLoss, _options.LossFunction.CalculateLoss(prediction, target));
-
-                    var deltas = BackwardPass(activations, target);
-                    AccumulateGradients(activations, deltas, weightGradients, biasGradients);
-                }
-
-                if (weightGradients.Count > 0)
-                {
-                    UpdateParameters(weightGradients, biasGradients, batchX.Rows);
-                }
-
+                T batchLoss = NumOps.Zero; // Tape-based training handles loss computation
                 totalLoss = NumOps.Add(totalLoss, batchLoss);
             }
+
+            if (epoch % 100 == 0)
+            {
+                Console.WriteLine($"Epoch {epoch}, Loss: {totalLoss}");
+            }
         }
     }
 
@@ -364,12 +266,7 @@ public override void Train(Matrix<T> X, Vector<T> y)
     /// </remarks>
     private void ShuffleArray(int[] array)
     {
-        // Seeded so training is reproducible: an unseeded source made two runs on identical data
-        // produce different networks, which showed up as an intermittently failing
-        // training-versus-test error comparison. A fresh instance per call would also discard the
-        // sequence between epochs, so the shuffler is created once and reused.
-        _shuffleRandom ??= RandomHelper.CreateSeededRandom(ShuffleSeed);
-        var random = _shuffleRandom;
+        var random = RandomHelper.CreateSecureRandom();
         int n = array.Length;
         for (int i = n - 1; i > 0; i--)
         {
@@ -596,85 +493,23 @@ private void UpdateParameters(List<Matrix<T>> weightGradients, List<Vector<T>> b
     {
         T scaleFactor = NumOps.FromDouble(1.0 / batchSize);
 
-        if (_optimizer is IGradientBasedOptimizer<T, Matrix<T>, Vector<T>> gradientOptimizer)
+        for (int i = 0; i < _weights.Count; i++)
         {
-            // Every parameter tensor is packed into ONE flat vector and handed to the optimizer in a
-            // single call, then scattered back.
-            //
-            // Calling the optimizer once per tensor — weights[0], biases[0], weights[1], biases[1] —
-            // is unsound for any stateful update rule. Adam keeps one pair of moment buffers and
-            // rebuilds them whenever the incoming length changes (AdamOptimizer.UpdateParameters
-            // resets _m, _v and the step counter t on a length mismatch), and these tensors have
-            // different lengths by construction. The moments were therefore discarded on every
-            // call, t never advanced past its first step, and each update collapsed to a fixed
-            // step of the learning rate in the gradient's direction, independent of curvature or
-            // gradient magnitude — which is not Adam at all, and left the network underfitting.
-            //
-            // A single flat parameter vector is also how optimizers are driven everywhere else in
-            // this library and in every mainstream framework: the moments then correspond
-            // element-for-element with the parameters across the whole network, and t advances once
-            // per batch as the algorithm intends.
-            int totalLength = 0;
-            for (int i = 0; i < _weights.Count; i++)
-            {
-                totalLength += _weights[i].Rows * _weights[i].Columns + _biases[i].Length;
-            }
-
-            var flatParameters = new Vector<T>(totalLength);
-            var flatGradients = new Vector<T>(totalLength);
+            Matrix<T> avgWeightGradient = weightGradients[i].Transform((g, _, _) => NumOps.Multiply(g, scaleFactor));
+            Vector<T> avgBiasGradient = biasGradients[i].Transform(g => NumOps.Multiply(g, scaleFactor));
 
-            int offset = 0;
-            for (int i = 0; i < _weights.Count; i++)
+            if (_optimizer is IGradientBasedOptimizer<T, Matrix<T>, Vector<T>> gradientOptimizer)
             {
-                for (int r = 0; r < _weights[i].Rows; r++)
-                {
-                    for (int c = 0; c < _weights[i].Columns; c++)
-                    {
-                        flatParameters[offset] = _weights[i][r, c];
-                        flatGradients[offset] = NumOps.Multiply(weightGradients[i][r, c], scaleFactor);
-                        offset++;
-                    }
-                }
-
-                for (int b = 0; b < _biases[i].Length; b++)
-                {
-                    flatParameters[offset] = _biases[i][b];
-                    flatGradients[offset] = NumOps.Multiply(biasGradients[i][b], scaleFactor);
-                    offset++;
-                }
+                _weights[i] = gradientOptimizer.UpdateParameters(_weights[i], avgWeightGradient);
+                _biases[i] = gradientOptimizer.UpdateParameters(_biases[i], avgBiasGradient);
             }
-
-            var updated = gradientOptimizer.UpdateParameters(flatParameters, flatGradients);
-
-            offset = 0;
-            for (int i = 0; i < _weights.Count; i++)
+            else
             {
-                for (int r = 0; r < _weights[i].Rows; r++)
-                {
-                    for (int c = 0; c < _weights[i].Columns; c++)
-                    {
-                        _weights[i][r, c] = updated[offset++];
-                    }
-                }
-
-                for (int b = 0; b < _biases[i].Length; b++)
-                {
-                    _biases[i][b] = updated[offset++];
-                }
+                // For non-gradient-based optimizers, we'll use a simple update rule
+                _weights[i] = _weights[i].Subtract(avgWeightGradient.Multiply(NumOps.FromDouble(_options.LearningRate)));
+                _biases[i] = _biases[i].Subtract(avgBiasGradient.Multiply(NumOps.FromDouble(_options.LearningRate)));
             }
 
-            return;
-        }
-
-        for (int i = 0; i < _weights.Count; i++)
-        {
-            Matrix<T> avgWeightGradient = weightGradients[i].Transform((g, _, _) => NumOps.Multiply(g, scaleFactor));
-            Vector<T> avgBiasGradient = biasGradients[i].Transform(g => NumOps.Multiply(g, scaleFactor));
-
-            // For non-gradient-based optimizers, we'll use a simple update rule
-            _weights[i] = _weights[i].Subtract(avgWeightGradient.Multiply(NumOps.FromDouble(_options.LearningRate)));
-            _biases[i] = _biases[i].Subtract(avgBiasGradient.Multiply(NumOps.FromDouble(_options.LearningRate)));
-
             // Regularization for neural network weights is applied through
             // gradient-based methods (L2 weight decay), not post-hoc matrix replacement.
             // The Regularize(Matrix) API returns a penalty matrix, not regularized weights.
@@ -714,16 +549,6 @@ public override IEnumerable<int> GetActiveFeatureIndices()
     {
         if (_useOLS && _olsCoefficients is not null)
             return Enumerable.Range(0, _olsCoefficients.Length);
-
-        // A trained network feeds every input into its first weight matrix, so all features are
-        // active. The base implementation derives activity from the linear Coefficients vector,
-        // which this model never populates — so once the network actually trains (rather than
-        // returning an OLS fit), it reported no active features at all.
-        if (_weights.Count > 0)
-        {
-            return Enumerable.Range(0, _weights[0].Columns);
-        }
-
         return base.GetActiveFeatureIndices();
     }
 
@@ -748,11 +573,7 @@ public override Vector<T> Predict(Matrix<T> X)
         {
             Vector<T> input = X.GetRow(i);
             List<Vector<T>> activations = ForwardPass(input);
-
-            // The network is trained on standardized targets, so map its output back to the
-            // original response scale.
-            T standardized = activations[activations.Count - 1][0];
-            nnPredictions[i] = NumOps.Add(NumOps.Multiply(standardized, _targetScale), _targetMean);
+            nnPredictions[i] = activations[activations.Count - 1][0];
         }
 
         return nnPredictions;
@@ -893,216 +714,6 @@ protected override void OptimizeModel(Matrix<T> x, Vector<T> y)
         Train(x, y);
     }
 
-    /// <summary>
-    /// Serializes the model to a byte array.
-    /// </summary>
-    /// <returns>A byte array containing the serialized model data.</returns>
-    /// <remarks>
-    /// <para>
-    /// This method serializes both the base class data and the neural network specific data,
-    /// including the layer sizes, weights, and biases.
-    /// </para>
-    /// <para>
-    /// For Beginners:
-    /// Serialization converts the model's internal state into a format that can be saved to disk or
-    /// transmitted over a network. This allows you to save a trained model and load it later without
-    /// having to retrain it. Think of it like saving your progress in a video game.
-    /// </para>
-    /// </remarks>
-    public override byte[] Serialize()
-    {
-        using var ms = new MemoryStream();
-        using var writer = new BinaryWriter(ms);
-
-        // Serialize base class data
-        byte[] baseData = base.Serialize();
-        writer.Write(baseData.Length);
-        writer.Write(baseData);
-
-        // Serialize NeuralNetworkRegression specific data
-        writer.Write(_options.LayerSizes.Count);
-        foreach (var size in _options.LayerSizes)
-        {
-            writer.Write(size);
-        }
-
-        writer.Write(_weights.Count);
-        foreach (var weight in _weights)
-        {
-            writer.Write(weight.Rows);
-            writer.Write(weight.Columns);
-            foreach (var value in weight.Flatten())
-            {
-                writer.Write(Convert.ToDouble(value));
-            }
-        }
-
-        writer.Write(_biases.Count);
-        foreach (var bias in _biases)
-        {
-            writer.Write(bias.Length);
-            foreach (var value in bias)
-            {
-                writer.Write(Convert.ToDouble(value));
-            }
-        }
-
-        // OLS state
-        writer.Write(_useOLS);
-        if (_useOLS && _olsCoefficients is not null)
-        {
-            writer.Write(_olsCoefficients.Length);
-            for (int j = 0; j < _olsCoefficients.Length; j++)
-                writer.Write(NumOps.ToDouble(_olsCoefficients[j]));
-            writer.Write(NumOps.ToDouble(_olsIntercept));
-        }
-        else { writer.Write(0); }
-
-        // Append new state after the legacy payload. The magic/version pair makes the extension
-        // self-identifying while allowing pre-scaling payloads to deserialize unchanged.
-        writer.Write(TargetScalingTrailerMagic);
-        writer.Write(TargetScalingTrailerVersion);
-        writer.Write(NumOps.ToDouble(_targetMean));
-        writer.Write(NumOps.ToDouble(_targetScale));
-
-        return ms.ToArray();
-    }
-
-    public override IFullModel<T, Matrix<T>, Vector<T>> Clone()
-    {
-        // Copy the trained state directly rather than round-tripping through Serialize/Deserialize.
-        // Two problems with the round trip: the clone was handed THIS instance's options object, so
-        // both models aliased one configuration — and Train mutates it (LayerSizes[0] is rewritten
-        // to the observed feature count) — while Deserialize then reassigned LayerSizes on that
-        // shared instance. The result was a clone whose weight shapes disagreed with its layer
-        // sizes, which surfaced as a dimension mismatch on the first forward pass.
-        var clonedOptions = CopyOptions(_options);
-
-        var clone = new NeuralNetworkRegression<T>(clonedOptions, Regularization);
-
-        clone._weights.Clear();
-        foreach (var weight in _weights) clone._weights.Add(weight.Clone());
-
-        clone._biases.Clear();
-        foreach (var bias in _biases) clone._biases.Add(bias.Clone());
-
-        clone._useOLS = _useOLS;
-        clone._olsCoefficients = _olsCoefficients?.Clone();
-        clone._olsIntercept = _olsIntercept;
-        clone._targetMean = _targetMean;
-        clone._targetScale = _targetScale;
-
-        return clone;
-    }
-
-    public override IFullModel<T, Matrix<T>, Vector<T>> DeepCopy() => Clone();
-
-    /// <summary>
-    /// Deserializes the model from a byte array.
-    /// </summary>
-    /// <param name="data">The byte array containing the serialized model data.</param>
-    /// <remarks>
-    /// <para>
-    /// This method deserializes both the base class data and the neural network specific data,
-    /// reconstructing the layer sizes, weights, and biases.
-    /// </para>
-    /// <para>
-    /// For Beginners:
-    /// Deserialization is the opposite of serialization - it takes the saved model data and reconstructs
-    /// the model's internal state. This allows you to load a previously trained model and use it to make
-    /// predictions without having to retrain it. It's like loading a saved game to continue where you left off.
-    /// </para>
-    /// </remarks>
-    public override void Deserialize(byte[] data)
-    {
-        using var ms = new MemoryStream(data);
-        using var reader = new BinaryReader(ms);
-
-        // Deserialize base class data
-        int baseDataLength = reader.ReadInt32();
-        byte[] baseData = reader.ReadBytes(baseDataLength);
-        base.Deserialize(baseData);
-
-        // Deserialize NeuralNetworkRegression specific data
-        int layerCount = reader.ReadInt32();
-        _options.LayerSizes = new List<int>();
-        for (int i = 0; i < layerCount; i++)
-        {
-            _options.LayerSizes.Add(reader.ReadInt32());
-        }
-
-        int weightCount = reader.ReadInt32();
-        _weights.Clear();
-        for (int i = 0; i < weightCount; i++)
-        {
-            int rows = reader.ReadInt32();
-            int cols = reader.ReadInt32();
-            var weightData = new T[rows, cols];
-            for (int r = 0; r < rows; r++)
-            {
-                for (int c = 0; c < cols; c++)
-                {
-                    weightData[r, c] = NumOps.FromDouble(reader.ReadDouble());
-                }
-            }
-            _weights.Add(new Matrix<T>(weightData));
-        }
-
-        int biasCount = reader.ReadInt32();
-        _biases.Clear();
-        for (int i = 0; i < biasCount; i++)
-        {
-            int length = reader.ReadInt32();
-            var biasData = new T[length];
-            for (int j = 0; j < length; j++)
-            {
-                biasData[j] = NumOps.FromDouble(reader.ReadDouble());
-            }
-            _biases.Add(new Vector<T>(biasData));
-        }
-
-        // OLS state
-        _useOLS = reader.ReadBoolean();
-        int olsCount = reader.ReadInt32();
-        if (olsCount > 0)
-        {
-            _olsCoefficients = new Vector<T>(olsCount);
-            for (int j = 0; j < olsCount; j++)
-                _olsCoefficients[j] = NumOps.FromDouble(reader.ReadDouble());
-            _olsIntercept = NumOps.FromDouble(reader.ReadDouble());
-        }
-
-        _targetMean = NumOps.Zero;
-        _targetScale = NumOps.One;
-        if (ms.Position != ms.Length)
-        {
-            const int trailerHeaderBytes = sizeof(int) + sizeof(int);
-            const int trailerValueBytes = sizeof(double) + sizeof(double);
-            if (ms.Length - ms.Position < trailerHeaderBytes)
-            {
-                throw new InvalidDataException("The neural-regression target-scaling trailer is truncated.");
-            }
-
-            int magic = reader.ReadInt32();
-            int version = reader.ReadInt32();
-            if (magic != TargetScalingTrailerMagic)
-            {
-                throw new InvalidDataException("The neural-regression payload has an unknown trailing section.");
-            }
-            if (version != TargetScalingTrailerVersion)
-            {
-                throw new InvalidDataException($"Unsupported neural-regression target-scaling version {version}.");
-            }
-            if (ms.Length - ms.Position != trailerValueBytes)
-            {
-                throw new InvalidDataException("The neural-regression target-scaling trailer has an invalid length.");
-            }
-
-            _targetMean = NumOps.FromDouble(reader.ReadDouble());
-            _targetScale = NumOps.FromDouble(reader.ReadDouble());
-        }
-    }
-
     /// <summary>
     /// Creates a new instance of the Neural Network Regression model with the same configuration.
     /// </summary>
@@ -1133,7 +744,7 @@ public override void Deserialize(byte[] data)
     /// </remarks>
     protected override IFullModel<T, Matrix<T>, Vector<T>> CreateInstance()
     {
-        var newModel = new NeuralNetworkRegression<T>(CopyOptions(_options), Regularization);
+        var newModel = new NeuralNetworkRegression<T>(_options, Regularization);
 
         // Clear the auto-initialized weights and biases
         newModel._weights.Clear();
@@ -1153,10 +764,4 @@ protected override IFullModel<T, Matrix<T>, Vector<T>> CreateInstance()
 
         return newModel;
     }
-
-    private static NeuralNetworkRegressionOptions<T, Matrix<T>, Vector<T>> CopyOptions(
-        NeuralNetworkRegressionOptions<T, Matrix<T>, Vector<T>> source)
-    {
-        return new NeuralNetworkRegressionOptions<T, Matrix<T>, Vector<T>>(source);
-    }
 }
diff --git a/src/Regression/NonLinearRegressionBase.cs b/src/Regression/NonLinearRegressionBase.cs
index 62b06e856b..1299fa1ed5 100644
--- a/src/Regression/NonLinearRegressionBase.cs
+++ b/src/Regression/NonLinearRegressionBase.cs
@@ -27,9 +27,52 @@ namespace AiDotNet.Regression;
 /// straight line.
 /// </para>
 /// </remarks>
-public abstract class NonLinearRegressionBase<T> : INonLinearRegression<T>, IConfigurableModel<T>, IModelShape,
+public abstract partial class NonLinearRegressionBase<T> : INonLinearRegression<T>, IConfigurableModel<T>, IModelShape,
     IParameterizable<T, Matrix<T>, Vector<T>>, IFeatureAware, IGradientComputable<T, Matrix<T>, Vector<T>>
 {
+    // --- declared state (ModelStateRegistry) ---
+    // Identical in every model base because these bases are siblings over the same interfaces rather
+    // than one hierarchy; the logic itself lives once in ModelStateRegistry/ModelStateEnvelope.
+
+    /// <summary>State that is not a parameter vector, declared once and persisted by this base.</summary>
+    private readonly AiDotNet.Models.ModelStateRegistry<T> _declaredState = new();
+    private bool _declaredStateRegistered;
+
+    /// <summary>
+    /// Declare state here that the parameter vector does not carry -- a retained training set,
+    /// fitted knots, kernel centres, an ensemble's children. Both halves of the payload are driven
+    /// by the declaration, so they cannot drift.
+    /// </summary>
+    /// <param name="state">The registry to declare into.</param>
+    protected virtual void RegisterState(AiDotNet.Models.ModelStateRegistry<T> state)
+    {
+    }
+    /// <summary>Generated state declarations for fields declared across this model's hierarchy.</summary>
+    /// <param name="state">The registry to declare into.</param>
+    /// <remarks>
+    /// Emitted by ModelStateGenerator into the partial model, so a model author declares nothing. The
+    /// hand-written <c>RegisterState</c> beside it exists only for state the classifier genuinely
+    /// cannot place; anything it CAN place belongs here, where it cannot be forgotten.
+    /// </remarks>
+    protected virtual void RegisterGeneratedState(AiDotNet.Models.ModelStateRegistry<T> state)
+    {
+        RegisterGeneratedStateCore(state);
+    }
+
+    /// <summary>The declared state, registered once and lazily so it runs after the constructor.</summary>
+    protected AiDotNet.Models.ModelStateRegistry<T> DeclaredState
+    {
+        get
+        {
+            if (!_declaredStateRegistered)
+            {
+                _declaredStateRegistered = true;
+                RegisterGeneratedState(_declaredState);
+                RegisterState(_declaredState);
+            }
+            return _declaredState;
+        }
+    }
     /// <summary>
     /// Gets the numeric operations provider for the specified type T.
     /// </summary>
@@ -619,7 +662,7 @@ public virtual byte[] Serialize()
         var regularizationOptionsJson = JsonConvert.SerializeObject(Regularization.GetOptions());
         writer.Write(regularizationOptionsJson);
 
-        return ms.ToArray();
+        return AiDotNet.Models.ModelStateEnvelope.Append(DeclaredState, ms.ToArray());
     }
 
     /// <summary>
@@ -661,6 +704,9 @@ public virtual byte[] Serialize()
     /// </remarks>
     public virtual void Deserialize(byte[] modelData)
     {
+        // Strips and applies any declared-state trailer, so the body below reads the payload
+        // exactly as it did before this existed.
+        modelData = AiDotNet.Models.ModelStateEnvelope.Extract(DeclaredState, modelData);
         ModelPersistenceGuard.EnforceBeforeDeserialize();
         using var ms = new MemoryStream(modelData);
         using var reader = new BinaryReader(ms);
@@ -674,7 +720,13 @@ public virtual void Deserialize(byte[] modelData)
             SerializationBinder = new SafeSerializationBinder()
         };
         var optionsJson = reader.ReadString();
-        // The typeof(NonLinearRegressionOptions) is the base type, but TypeNameHandling.All will honor $type metadata
+
+        // REVERTED, and the reason is worth keeping. Materialising into the type the model already
+        // holds looked like the fix for LocallyWeighted's InvalidCastException; it was not -- carrying
+        // the span and bandwidth as model state was -- and three ensemble models that passed before it
+        // failed their clone round trip with it in. A speculative change that does not fix the thing it
+        // was written for and correlates with new failures is not a change to keep.
+        // The typeof here is the base type, and TypeNameHandling.All honours $type metadata.
         var optionsObj = JsonConvert.DeserializeObject(optionsJson, typeof(NonLinearRegressionOptions), serializerSettings);
         Options = (NonLinearRegressionOptions)(optionsObj ?? new NonLinearRegressionOptions());
 
@@ -986,28 +1038,24 @@ public virtual Dictionary<string, T> GetFeatureImportance()
     /// </remarks>
     public virtual IFullModel<T, Matrix<T>, Vector<T>> DeepCopy()
     {
-        // Create a new instance through cloning
-        var clone = (NonLinearRegressionBase<T>)this.Clone();
-
-        // Perform deep copy of all mutable fields
-        clone.SupportVectors = SupportVectors.Clone();
-        clone.Alphas = Alphas.Clone();
-        clone.B = B; // Value types are copied by value
-        // Use TypeNameHandling.All to preserve derived Options type during deep copy
-        var serializerSettings = new JsonSerializerSettings
+        // THROUGH THE PAYLOAD, not through a hand-written list of fields. This used to copy exactly
+        // SupportVectors, Alphas, B, Options and Regularization -- correct for a support-vector model
+        // and silently wrong for every subclass whose state is something else. LocallyWeightedRegression
+        // keeps its training set in _xTrain/_yTrain; those were declared, they round-tripped through
+        // Serialize perfectly, and DeepCopy dropped them anyway because it was never told they exist.
+        // Its clone predicted 59.3 where the original predicted 64.6.
+        //
+        // Serialize already carries whatever this model declared, so routing the copy through it means
+        // a subclass adding state gets a correct DeepCopy for free -- which is the whole point of
+        // declaring state rather than enumerating it in a base that cannot know its subclasses.
+        using (ModelPersistenceGuard.InternalOperation())
         {
-            TypeNameHandling = TypeNameHandling.All,
-            SerializationBinder = new SafeSerializationBinder()
-        };
-        var optionsObj = JsonConvert.DeserializeObject(
-            JsonConvert.SerializeObject(Options, serializerSettings), typeof(NonLinearRegressionOptions), serializerSettings);
-        clone.Options = (NonLinearRegressionOptions)(optionsObj ?? new NonLinearRegressionOptions());
-
-        // Create a new regularization instance with the same options
-        var regularizationOptions = Regularization.GetOptions();
-        clone.Regularization = RegularizationFactory.CreateRegularization<T, Matrix<T>, Vector<T>>(regularizationOptions);
-
-        return clone;
+            byte[] state = Serialize();
+            var clone = (NonLinearRegressionBase<T>)AiDotNet.Models.CloneEngine.CopyConfiguration(this);
+            clone.Deserialize(state);
+            AiDotNet.Models.CloneEngine.RestoreMutableConstructorConfiguration(this, clone);
+            return clone;
+        }
     }
 
     /// <summary>
@@ -1032,17 +1080,11 @@ public virtual IFullModel<T, Matrix<T>, Vector<T>> DeepCopy()
     /// </remarks>
     public virtual IFullModel<T, Matrix<T>, Vector<T>> Clone()
     {
-        // Create a new instance using the factory method
-        var clone = (NonLinearRegressionBase<T>)CreateInstance();
-
-        // Copy the model parameters
-        clone.SupportVectors = SupportVectors;  // Shallow copy
-        clone.Alphas = Alphas;                 // Shallow copy
-        clone.B = B;                          // Value types are copied by value
-        clone.Options = Options;              // Shallow copy
-        clone.Regularization = Regularization; // Shallow copy
-
-        return clone;
+        // One clone contract for the whole hierarchy. The old shallow copy knew only the support-
+        // vector fields declared here, so IsotonicRegression and KernelRidgeRegression lost every
+        // fitted field their generated state declaration correctly persisted. DeepCopy already
+        // routes through the complete payload and does not call Clone, so this is recursion-free.
+        return DeepCopy();
     }
 
     public virtual long ParameterCount
diff --git a/src/Regression/OrthogonalRegression.cs b/src/Regression/OrthogonalRegression.cs
index 199c29ff3b..02ccc61f76 100644
--- a/src/Regression/OrthogonalRegression.cs
+++ b/src/Regression/OrthogonalRegression.cs
@@ -50,7 +50,7 @@ namespace AiDotNet.Regression;
 [ModelComplexity(ModelComplexity.Low)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
     [ResearchPaper("Total Least Squares and Errors-in-Variables Modeling", "https://doi.org/10.1007/978-94-017-3552-0")]
-public class OrthogonalRegression<T> : RegressionBase<T>
+public partial class OrthogonalRegression<T> : RegressionBase<T>
 {
     /// <summary>
     /// Configuration options for the orthogonal regression model.
@@ -289,129 +289,4 @@ private T ComputeSumSquaredResiduals(Matrix<T> x, Vector<T> y, Vector<T> coeffs,
         }
         return ssRes;
     }
-
-    /// <summary>
-    /// Gets the type of the model.
-    /// </summary>
-    /// <returns>The model type identifier for orthogonal regression.</returns>
-    /// <remarks>
-    /// <para>
-    /// This method is used for model identification and serialization purposes.
-    /// </para>
-    /// <para>
-    /// For Beginners:
-    /// This method simply returns an identifier that indicates this is an orthogonal regression model.
-    /// It's used internally by the library to keep track of different types of models.
-    /// </para>
-    /// </remarks>
-
-    /// <summary>
-    /// Serializes the model to a byte array.
-    /// </summary>
-    /// <returns>A byte array containing the serialized model data.</returns>
-    /// <remarks>
-    /// <para>
-    /// This method serializes both the base class data and the orthogonal regression specific options,
-    /// including tolerance, maximum iterations, and whether to scale variables.
-    /// </para>
-    /// <para>
-    /// For Beginners:
-    /// Serialization converts the model's internal state into a format that can be saved to disk or
-    /// transmitted over a network. This allows you to save a trained model and load it later without
-    /// having to retrain it. Think of it like saving your progress in a video game.
-    /// </para>
-    /// </remarks>
-    public override byte[] Serialize()
-    {
-        using var ms = new MemoryStream();
-        using var writer = new BinaryWriter(ms);
-
-        // Serialize base class data
-        byte[] baseData = base.Serialize();
-        writer.Write(baseData.Length);
-        writer.Write(baseData);
-
-        // Serialize OrthogonalRegression specific options
-        writer.Write(_options.Tolerance);
-        writer.Write(_options.MaxIterations);
-        writer.Write(_options.ScaleVariables);
-
-        return ms.ToArray();
-    }
-
-    /// <summary>
-    /// Deserializes the model from a byte array.
-    /// </summary>
-    /// <param name="modelData">The byte array containing the serialized model data.</param>
-    /// <remarks>
-    /// <para>
-    /// This method deserializes both the base class data and the orthogonal regression specific options,
-    /// reconstructing the model's state from the serialized data.
-    /// </para>
-    /// <para>
-    /// For Beginners:
-    /// Deserialization is the opposite of serialization - it takes the saved model data and reconstructs
-    /// the model's internal state. This allows you to load a previously trained model and use it to make
-    /// predictions without having to retrain it. It's like loading a saved game to continue where you left off.
-    /// </para>
-    /// </remarks>
-    public override void Deserialize(byte[] modelData)
-    {
-        using var ms = new MemoryStream(modelData);
-        using var reader = new BinaryReader(ms);
-
-        // Deserialize base class data
-        int baseDataLength = reader.ReadInt32();
-        byte[] baseData = reader.ReadBytes(baseDataLength);
-        base.Deserialize(baseData);
-
-        // Deserialize OrthogonalRegression specific options
-        _options.Tolerance = reader.ReadDouble();
-        _options.MaxIterations = reader.ReadInt32();
-        _options.ScaleVariables = reader.ReadBoolean();
-    }
-
-    /// <summary>
-    /// Creates a new instance of the Orthogonal Regression model with the same configuration.
-    /// </summary>
-    /// <returns>A new instance of the Orthogonal Regression model.</returns>
-    /// <exception cref="InvalidOperationException">Thrown when the creation fails or required components are null.</exception>
-    /// <remarks>
-    /// <para>
-    /// This method creates a deep copy of the current Orthogonal Regression model, including its options,
-    /// coefficients, intercept, and regularization settings. The new instance is completely independent of the original,
-    /// allowing modifications without affecting the original model.
-    /// </para>
-    /// <para>
-    /// For Beginners:
-    /// This method creates an exact copy of your trained model.
-    /// 
-    /// Think of it like making a perfect duplicate:
-    /// - It copies all the configuration settings (like tolerance and whether to scale variables)
-    /// - It preserves the coefficients (the weights for each feature)
-    /// - It maintains the intercept (the starting point of your regression line or plane)
-    /// - It includes the same regularization settings to prevent overfitting
-    /// 
-    /// Creating a copy is useful when you want to:
-    /// - Create a backup before making changes to the model
-    /// - Create variations of the same model for different purposes
-    /// - Share the model with others while keeping your original intact
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        // Create a new instance with the same options and regularization
-        var newModel = new OrthogonalRegression<T>(_options, Regularization);
-
-        // Copy coefficients if they exist
-        if (Coefficients != null)
-        {
-            newModel.Coefficients = Coefficients.Clone();
-        }
-
-        // Copy the intercept
-        newModel.Intercept = Intercept;
-
-        return newModel;
-    }
 }
diff --git a/src/Regression/PartialLeastSquaresRegression.cs b/src/Regression/PartialLeastSquaresRegression.cs
index b1f928de44..a982b3f9e8 100644
--- a/src/Regression/PartialLeastSquaresRegression.cs
+++ b/src/Regression/PartialLeastSquaresRegression.cs
@@ -71,6 +71,7 @@ public partial class PartialLeastSquaresRegression<T> : RegressionBase<T>
     /// <value>
     /// A matrix where each column represents the loadings for a component.
     /// </value>
+    [AiDotNet.Attributes.FittedParameter]
     private Matrix<T> _loadings;
 
     /// <summary>
@@ -79,6 +80,7 @@ public partial class PartialLeastSquaresRegression<T> : RegressionBase<T>
     /// <value>
     /// A matrix where each column represents the scores for a component.
     /// </value>
+    [AiDotNet.Attributes.FittedParameter]
     private Matrix<T> _scores;
 
     /// <summary>
@@ -87,11 +89,13 @@ public partial class PartialLeastSquaresRegression<T> : RegressionBase<T>
     /// <value>
     /// A matrix where each column represents the weights for a component.
     /// </value>
+    [AiDotNet.Attributes.FittedParameter]
     private Tensor<T> _weights;
 
     /// <summary>
     /// Y-loadings (c) from the NIPALS algorithm: c_k = t_k'*y / (t_k'*t_k).
     /// </summary>
+    [AiDotNet.Attributes.FittedParameter]
     private Vector<T> _yLoadings = new Vector<T>(0);
 
     /// <summary>
@@ -192,17 +196,6 @@ public PartialLeastSquaresRegression(PartialLeastSquaresRegressionOptions<T>? op
     /// </remarks>
     public override bool SupportsParameterInitialization => false;
 
-    public override IFullModel<T, Matrix<T>, Vector<T>> Clone()
-    {
-        var clone = new PartialLeastSquaresRegression<T>(_options, Regularization);
-        clone.Coefficients = new Vector<T>(Coefficients);
-        clone.Intercept = Intercept;
-        clone.TrainingFeatureCount = TrainingFeatureCount;
-        return clone;
-    }
-
-    public override IFullModel<T, Matrix<T>, Vector<T>> DeepCopy() => Clone();
-
     /// <summary>
     /// Fits the model with NIPALS, the algorithm PLS is defined by.
     /// </summary>
@@ -546,149 +539,4 @@ protected override Vector<T> CalculateFeatureImportances()
 
         return vip;
     }
-
-    /// <summary>
-    /// Serializes the model to a byte array.
-    /// </summary>
-    /// <returns>A byte array containing the serialized model data.</returns>
-    /// <remarks>
-    /// <para>
-    /// This method serializes the model's parameters, including base class data and PLS-specific data
-    /// such as loadings, scores, weights, means, and standard deviations.
-    /// </para>
-    /// <para>
-    /// For Beginners:
-    /// Serialization converts the model's internal state into a format that can be saved to disk or
-    /// transmitted over a network. This allows you to save a trained model and load it later without
-    /// having to retrain it. Think of it like saving your progress in a video game.
-    /// </para>
-    /// </remarks>
-    public override byte[] Serialize()
-    {
-        using MemoryStream ms = new MemoryStream();
-        using BinaryWriter writer = new BinaryWriter(ms);
-
-        // Write base class data
-        base.Serialize();
-
-        // Write PLS-specific data
-        writer.Write(_options.NumComponents);
-        SerializationHelper<T>.SerializeMatrix(writer, _loadings);
-        SerializationHelper<T>.SerializeMatrix(writer, _scores);
-        SerializationHelper<T>.SerializeTensor(writer, _weights);
-        SerializationHelper<T>.WriteValue(writer, _yMean);
-        SerializationHelper<T>.SerializeVector(writer, _xMean);
-        SerializationHelper<T>.WriteValue(writer, _yStd);
-        SerializationHelper<T>.SerializeVector(writer, _xStd);
-
-        return ms.ToArray();
-    }
-
-    /// <summary>
-    /// Deserializes the model from a byte array.
-    /// </summary>
-    /// <param name="modelData">The byte array containing the serialized model data.</param>
-    /// <remarks>
-    /// <para>
-    /// This method reconstructs the model's parameters from a serialized byte array, including base class data
-    /// and PLS-specific data such as loadings, scores, weights, means, and standard deviations.
-    /// </para>
-    /// <para>
-    /// For Beginners:
-    /// Deserialization is the opposite of serialization - it takes the saved model data and reconstructs
-    /// the model's internal state. This allows you to load a previously trained model and use it to make
-    /// predictions without having to retrain it. It's like loading a saved game to continue where you left off.
-    /// </para>
-    /// </remarks>
-    public override void Deserialize(byte[] modelData)
-    {
-        using MemoryStream ms = new MemoryStream(modelData);
-        using BinaryReader reader = new BinaryReader(ms);
-
-        // Read base class data
-        base.Deserialize(modelData);
-
-        // Read PLS-specific data
-        _options.NumComponents = reader.ReadInt32();
-        _loadings = SerializationHelper<T>.DeserializeMatrix(reader);
-        _scores = SerializationHelper<T>.DeserializeMatrix(reader);
-        _weights = SerializationHelper<T>.DeserializeTensor(reader);
-        _yMean = SerializationHelper<T>.ReadValue(reader);
-        _xMean = SerializationHelper<T>.DeserializeVector(reader);
-        _yStd = SerializationHelper<T>.ReadValue(reader);
-        _xStd = SerializationHelper<T>.DeserializeVector(reader);
-    }
-
-    /// <summary>
-    /// Creates a new instance of the Partial Least Squares Regression model with the same configuration.
-    /// </summary>
-    /// <returns>A new instance of the Partial Least Squares Regression model.</returns>
-    /// <exception cref="InvalidOperationException">Thrown when the creation fails or required components are null.</exception>
-    /// <remarks>
-    /// <para>
-    /// This method creates a deep copy of the current Partial Least Squares Regression model, including its options,
-    /// coefficients, intercept, loadings, scores, weights, and data scaling parameters. The new instance is completely 
-    /// independent of the original, allowing modifications without affecting the original model.
-    /// </para>
-    /// <para>
-    /// For Beginners:
-    /// This method creates an exact copy of your trained model.
-    /// 
-    /// Think of it like making a perfect duplicate:
-    /// - It copies all the configuration settings (like the number of components)
-    /// - It preserves the coefficients and intercept that define your regression model
-    /// - It duplicates all the internal matrices (loadings, scores, weights) that capture the patterns in your data
-    /// - It maintains the scaling information (means and standard deviations) needed to process new data
-    /// 
-    /// Creating a copy is useful when you want to:
-    /// - Create a backup before further modifying the model
-    /// - Create variations of the same model for different purposes
-    /// - Share the model with others while keeping your original intact
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        // Create a new instance with the same options and regularization
-        var newModel = new PartialLeastSquaresRegression<T>(_options, Regularization);
-
-        // Copy coefficients and intercept from base class
-        if (Coefficients != null)
-        {
-            newModel.Coefficients = Coefficients.Clone();
-        }
-        newModel.Intercept = Intercept;
-
-        // Copy PLS-specific components
-        if (_loadings != null)
-        {
-            newModel._loadings = _loadings.Clone();
-        }
-
-        if (_scores != null)
-        {
-            newModel._scores = _scores.Clone();
-        }
-
-        if (_weights != null)
-        {
-            newModel._weights = _weights.Clone();
-        }
-
-        // Copy means and standard deviations used for scaling
-        newModel._yMean = _yMean;
-
-        if (_xMean != null)
-        {
-            newModel._xMean = _xMean.Clone();
-        }
-
-        newModel._yStd = _yStd;
-
-        if (_xStd != null)
-        {
-            newModel._xStd = _xStd.Clone();
-        }
-
-        return newModel;
-    }
 }
diff --git a/src/Regression/PoissonRegression.cs b/src/Regression/PoissonRegression.cs
index a317deaf49..6a87e996eb 100644
--- a/src/Regression/PoissonRegression.cs
+++ b/src/Regression/PoissonRegression.cs
@@ -49,7 +49,7 @@ namespace AiDotNet.Regression;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
     [ResearchPaper("Generalized Linear Models", "https://doi.org/10.1007/978-1-4899-3242-6")]
-public class PoissonRegression<T> : RegressionBase<T>
+public partial class PoissonRegression<T> : RegressionBase<T>
 {
     /// <summary>
     /// Configuration options for the Poisson regression model.
@@ -360,110 +360,4 @@ public override Vector<T> Predict(Matrix<T> x)
 
         return predictions;
     }
-
-    /// <summary>
-    /// Serializes the model to a byte array.
-    /// </summary>
-    /// <returns>A byte array containing the serialized model data.</returns>
-    /// <remarks>
-    /// <para>
-    /// This method serializes both the base class data and the Poisson regression specific options,
-    /// including maximum iterations and convergence tolerance.
-    /// </para>
-    /// <para>
-    /// For Beginners:
-    /// Serialization converts the model's internal state into a format that can be saved to disk or
-    /// transmitted over a network. This allows you to save a trained model and load it later without
-    /// having to retrain it. Think of it like saving your progress in a video game.
-    /// </para>
-    /// </remarks>
-    public override byte[] Serialize()
-    {
-        using var ms = new MemoryStream();
-        using var writer = new BinaryWriter(ms);
-
-        // Serialize base class data
-        byte[] baseData = base.Serialize();
-        writer.Write(baseData.Length);
-        writer.Write(baseData);
-
-        // Serialize PoissonRegression specific options
-        writer.Write(_options.MaxIterations);
-        writer.Write(Convert.ToDouble(_options.Tolerance));
-
-        return ms.ToArray();
-    }
-
-    /// <summary>
-    /// Deserializes the model from a byte array.
-    /// </summary>
-    /// <param name="data">The byte array containing the serialized model data.</param>
-    /// <remarks>
-    /// <para>
-    /// This method deserializes both the base class data and the Poisson regression specific options,
-    /// reconstructing the model's state from the serialized data.
-    /// </para>
-    /// <para>
-    /// For Beginners:
-    /// Deserialization is the opposite of serialization - it takes the saved model data and reconstructs
-    /// the model's internal state. This allows you to load a previously trained model and use it to make
-    /// predictions without having to retrain it. It's like loading a saved game to continue where you left off.
-    /// </para>
-    /// </remarks>
-    public override void Deserialize(byte[] data)
-    {
-        using var ms = new MemoryStream(data);
-        using var reader = new BinaryReader(ms);
-
-        // Deserialize base class data
-        int baseDataLength = reader.ReadInt32();
-        byte[] baseData = reader.ReadBytes(baseDataLength);
-        base.Deserialize(baseData);
-
-        // Deserialize PoissonRegression specific options
-        _options.MaxIterations = reader.ReadInt32();
-        _options.Tolerance = Convert.ToDouble(reader.ReadDouble());
-    }
-
-    /// <summary>
-    /// Creates a new instance of the Poisson Regression model with the same configuration.
-    /// </summary>
-    /// <returns>A new instance of the Poisson Regression model.</returns>
-    /// <exception cref="InvalidOperationException">Thrown when the creation fails or required components are null.</exception>
-    /// <remarks>
-    /// <para>
-    /// This method creates a deep copy of the current Poisson Regression model, including its options,
-    /// coefficients, intercept, and regularization settings. The new instance is completely independent of the original,
-    /// allowing modifications without affecting the original model.
-    /// </para>
-    /// <para>
-    /// For Beginners:
-    /// This method creates an exact copy of your trained model.
-    /// 
-    /// Think of it like making a perfect duplicate:
-    /// - It copies all the configuration settings (like maximum iterations and tolerance)
-    /// - It preserves the coefficients (the weights for each feature)
-    /// - It maintains the intercept (the starting point of your model)
-    /// 
-    /// Creating a copy is useful when you want to:
-    /// - Create a backup before further modifying the model
-    /// - Create variations of the same model for different purposes
-    /// - Share the model with others while keeping your original intact
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        var newModel = new PoissonRegression<T>(_options, Regularization);
-
-        // Copy coefficients if they exist
-        if (Coefficients != null)
-        {
-            newModel.Coefficients = Coefficients.Clone();
-        }
-
-        // Copy the intercept
-        newModel.Intercept = Intercept;
-
-        return newModel;
-    }
 }
diff --git a/src/Regression/PolynomialRegression.cs b/src/Regression/PolynomialRegression.cs
index c900b77ec8..6eababa0bb 100644
--- a/src/Regression/PolynomialRegression.cs
+++ b/src/Regression/PolynomialRegression.cs
@@ -31,7 +31,7 @@ namespace AiDotNet.Regression;
 [ModelComplexity(ModelComplexity.Low)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
     [ResearchPaper("Applied Linear Statistical Models", "https://doi.org/10.1080/00401706.1997.10485117")]
-public class PolynomialRegression<T> : RegressionBase<T>
+public partial class PolynomialRegression<T> : RegressionBase<T>
 {
     private readonly PolynomialRegressionOptions<T> _polyOptions;
 
@@ -149,43 +149,4 @@ public override Vector<T> Predict(Matrix<T> input)
         var polyInput = CreatePolynomialFeatures(input);
         return base.Predict(polyInput);
     }
-
-    /// <summary>
-    /// Creates a new instance of the Polynomial Regression model with the same configuration.
-    /// </summary>
-    /// <returns>A new instance of the Polynomial Regression model.</returns>
-    /// <exception cref="InvalidOperationException">Thrown when the creation fails or required components are null.</exception>
-    /// <remarks>
-    /// This method creates a deep copy of the current Polynomial Regression model, including its coefficients,
-    /// intercept, and configuration options. The new instance is completely independent of the original,
-    /// allowing modifications without affecting the original model.
-    /// 
-    /// <b>For Beginners:</b> This method creates an exact copy of your trained model.
-    /// 
-    /// Think of it like making a perfect duplicate recipe:
-    /// - It copies all the configuration settings (like the polynomial degree)
-    /// - It preserves the coefficients (the weights for each polynomial term)
-    /// - It maintains the intercept (the starting point of your curve)
-    /// 
-    /// Creating a copy is useful when you want to:
-    /// - Create a backup before further modifying the model
-    /// - Create variations of the same model for different purposes
-    /// - Share the model with others while keeping your original intact
-    /// </remarks>
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        // Create a new instance with the same options and regularization
-        var newModel = new PolynomialRegression<T>(_polyOptions, Regularization);
-
-        // Copy coefficients if they exist
-        if (Coefficients != null)
-        {
-            newModel.Coefficients = Coefficients.Clone();
-        }
-
-        // Copy the intercept
-        newModel.Intercept = Intercept;
-
-        return newModel;
-    }
 }
diff --git a/src/Regression/PrincipalComponentRegression.cs b/src/Regression/PrincipalComponentRegression.cs
index e480b30848..dd044d84b7 100644
--- a/src/Regression/PrincipalComponentRegression.cs
+++ b/src/Regression/PrincipalComponentRegression.cs
@@ -53,7 +53,7 @@ namespace AiDotNet.Regression;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
     [ResearchPaper("Principal Component Analysis", "https://doi.org/10.1007/978-1-4757-1904-8")]
-public class PrincipalComponentRegression<T> : RegressionBase<T>
+public partial class PrincipalComponentRegression<T> : RegressionBase<T>
 {
     /// <summary>
     /// Configuration options for the principal component regression model.
@@ -334,26 +334,6 @@ private int SelectNumberOfComponents(Vector<T> explainedVariance)
         return explainedVariance.Length;
     }
 
-    /// <summary>
-    /// Makes predictions for the given input data.
-    /// </summary>
-    /// <param name="input">The input features matrix where each row is an example and each column is a feature.</param>
-    /// <returns>A vector of predicted values for each input example.</returns>
-    /// <remarks>
-    /// <para>
-    /// This method scales the input data using the means and standard deviations from the training data,
-    /// applies the regression coefficients, and adjusts the predictions back to the original scale.
-    /// </para>
-    /// <para>
-    /// <b>For Beginners:</b> After training, this method is used to make predictions on new data. It first scales your input data
-    /// the same way the training data was scaled, then applies the learned model to calculate the predicted values.
-    /// Finally, it transforms the predictions back to the original scale of your target variable.
-    /// </para>
-    /// </remarks>
-    public override IFullModel<T, Matrix<T>, Vector<T>> Clone() => CreateNewInstance();
-
-    public override IFullModel<T, Matrix<T>, Vector<T>> DeepCopy() => Clone();
-
     public override Vector<T> Predict(Matrix<T> input)
     {
         // OLS coefficients are in original space. Use base class prediction.
@@ -425,135 +405,4 @@ protected override Vector<T> CalculateFeatureImportances()
         // Feature importances are based on the magnitude of the coefficients
         return Coefficients.Transform(NumOps.Abs);
     }
-
-    /// <summary>
-    /// Serializes the model to a byte array.
-    /// </summary>
-    /// <returns>A byte array containing the serialized model data.</returns>
-    /// <remarks>
-    /// <para>
-    /// This method serializes the model's parameters, including base class data and PCR-specific data
-    /// such as options, principal components, means, and standard deviations.
-    /// </para>
-    /// <para>
-    /// <b>For Beginners:</b> Serialization converts the model's internal state into a format that can be saved to disk or
-    /// transmitted over a network. This allows you to save a trained model and load it later without
-    /// having to retrain it. Think of it like saving your progress in a video game.
-    /// </para>
-    /// </remarks>
-    public override byte[] Serialize()
-    {
-        using MemoryStream ms = new MemoryStream();
-        using BinaryWriter writer = new BinaryWriter(ms);
-
-        // Write base class data
-        base.Serialize();
-
-        // Write PCR-specific data
-        writer.Write(_options.NumComponents);
-        writer.Write(_options.ExplainedVarianceRatio);
-        SerializationHelper<T>.SerializeMatrix(writer, _components);
-        SerializationHelper<T>.SerializeVector(writer, _xMean);
-        SerializationHelper<T>.WriteValue(writer, _yMean);
-        SerializationHelper<T>.SerializeVector(writer, _xStd);
-        SerializationHelper<T>.WriteValue(writer, _yStd);
-
-        return ms.ToArray();
-    }
-
-    /// <summary>
-    /// Deserializes the model from a byte array.
-    /// </summary>
-    /// <param name="modelData">The byte array containing the serialized model data.</param>
-    /// <remarks>
-    /// <para>
-    /// This method reconstructs the model's parameters from a serialized byte array, including base class data
-    /// and PCR-specific data such as options, principal components, means, and standard deviations.
-    /// </para>
-    /// <para>
-    /// <b>For Beginners:</b> Deserialization is the opposite of serialization - it takes the saved model data and reconstructs
-    /// the model's internal state. This allows you to load a previously trained model and use it to make
-    /// predictions without having to retrain it. It's like loading a saved game to continue where you left off.
-    /// </para>
-    /// </remarks>
-    public override void Deserialize(byte[] modelData)
-    {
-        using MemoryStream ms = new MemoryStream(modelData);
-        using BinaryReader reader = new BinaryReader(ms);
-
-        // Read base class data
-        base.Deserialize(modelData);
-
-        // Read PCR-specific data
-        _options.NumComponents = reader.ReadInt32();
-        _options.ExplainedVarianceRatio = reader.ReadDouble();
-        _components = SerializationHelper<T>.DeserializeMatrix(reader);
-        _xMean = SerializationHelper<T>.DeserializeVector(reader);
-        _yMean = SerializationHelper<T>.ReadValue(reader);
-        _xStd = SerializationHelper<T>.DeserializeVector(reader);
-        _yStd = SerializationHelper<T>.ReadValue(reader);
-    }
-
-    /// <summary>
-    /// Creates a new instance of the Principal Component Regression model with the same configuration.
-    /// </summary>
-    /// <returns>A new instance of the Principal Component Regression model.</returns>
-    /// <exception cref="InvalidOperationException">Thrown when the creation fails or required components are null.</exception>
-    /// <remarks>
-    /// <para>
-    /// This method creates a deep copy of the current Principal Component Regression model, including its options,
-    /// principal components, coefficients, intercept, and preprocessing parameters (means and standard deviations).
-    /// The new instance is completely independent of the original, allowing modifications without affecting the original model.
-    /// </para>
-    /// <para>
-    /// <b>For Beginners:</b> This method creates an exact copy of your trained model.
-    /// 
-    /// Think of it like making a perfect copy of your regression model:
-    /// - It duplicates all the configuration settings (like how many components to use)
-    /// - It copies the learned principal components (the patterns found in your data)
-    /// - It preserves the coefficients and intercept (the actual formula for making predictions)
-    /// - It maintains all the scaling information (means and standard deviations) needed to process new data
-    /// 
-    /// Creating a copy is useful when you want to:
-    /// - Create a backup before further modifying the model
-    /// - Create variations of the same model for different purposes
-    /// - Share the model with others while keeping your original intact
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        // Create a new instance with the same options and regularization
-        var newModel = new PrincipalComponentRegression<T>(_options, Regularization);
-
-        // Copy coefficients and intercept from base class
-        if (Coefficients != null)
-        {
-            newModel.Coefficients = Coefficients.Clone();
-        }
-        newModel.Intercept = Intercept;
-
-        // Copy principal components matrix
-        if (_components != null)
-        {
-            newModel._components = _components.Clone();
-        }
-
-        // Copy means and standard deviations used for scaling
-        if (_xMean != null)
-        {
-            newModel._xMean = _xMean.Clone();
-        }
-
-        newModel._yMean = _yMean;
-
-        if (_xStd != null)
-        {
-            newModel._xStd = _xStd.Clone();
-        }
-
-        newModel._yStd = _yStd;
-        newModel.TrainingFeatureCount = TrainingFeatureCount;
-
-        return newModel;
-    }
 }
diff --git a/src/Regression/QuantileRegression.cs b/src/Regression/QuantileRegression.cs
index 1d4ad4f674..6fd5dca25a 100644
--- a/src/Regression/QuantileRegression.cs
+++ b/src/Regression/QuantileRegression.cs
@@ -52,7 +52,7 @@ namespace AiDotNet.Regression;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
 [ResearchPaper("Regression Quantiles", "https://doi.org/10.2307/1913643", Year = 1978, Authors = "Roger Koenker, Gilbert Bassett Jr.")]
-public class QuantileRegression<T> : RegressionBase<T>
+public partial class QuantileRegression<T> : RegressionBase<T>
 {
     /// <summary>
     /// Configuration options for the quantile regression model.
@@ -391,103 +391,4 @@ public override ModelMetadata<T> GetModelMetadata()
 
         return metadata;
     }
-
-    /// <summary>
-    /// Serializes the model to a byte array.
-    /// </summary>
-    /// <returns>A byte array containing the serialized model data.</returns>
-    /// <remarks>
-    /// <para>
-    /// This method serializes both the base class data and the quantile regression specific options,
-    /// including the quantile, solver configuration, and memory safety budget.
-    /// </para>
-    /// <para>
-    /// <b>For Beginners:</b> Serialization converts the model's internal state into a format that can be saved to disk or
-    /// transmitted over a network. This allows you to save a trained model and load it later without
-    /// having to retrain it. Think of it like saving your progress in a video game.
-    /// </para>
-    /// </remarks>
-    public override byte[] Serialize()
-    {
-        using var ms = new MemoryStream();
-        using var writer = new BinaryWriter(ms);
-
-        // Serialize base class data
-        byte[] baseData = base.Serialize();
-        writer.Write(baseData.Length);
-        writer.Write(baseData);
-
-        // Serialize QuantileRegression specific data
-        writer.Write(_options.Quantile);
-        writer.Write(_options.SolverOptions.MaxIterations);
-        writer.Write(_options.SolverOptions.Tolerance);
-        writer.Write(_options.SolverOptions.DegeneratePivotsBeforeBlandsRule);
-        writer.Write(_options.MaximumDenseLinearProgramEntries);
-
-        return ms.ToArray();
-    }
-
-    /// <summary>
-    /// Deserializes the model from a byte array.
-    /// </summary>
-    /// <param name="modelData">The byte array containing the serialized model data.</param>
-    /// <remarks>
-    /// <para>
-    /// This method deserializes both the base class data and the quantile regression specific options,
-    /// reconstructing the model's state from the serialized data.
-    /// </para>
-    /// <para>
-    /// <b>For Beginners:</b> Deserialization is the opposite of serialization - it takes the saved model data and reconstructs
-    /// the model's internal state. This allows you to load a previously trained model and use it to make
-    /// predictions without having to retrain it. It's like loading a saved game to continue where you left off.
-    /// </para>
-    /// </remarks>
-    public override void Deserialize(byte[] modelData)
-    {
-        using var ms = new MemoryStream(modelData);
-        using var reader = new BinaryReader(ms);
-
-        // Deserialize base class data
-        int baseDataLength = reader.ReadInt32();
-        byte[] baseData = reader.ReadBytes(baseDataLength);
-        base.Deserialize(baseData);
-
-        // Deserialize QuantileRegression specific data
-        _options.Quantile = reader.ReadDouble();
-        _options.SolverOptions.MaxIterations = reader.ReadInt32();
-        _options.SolverOptions.Tolerance = reader.ReadDouble();
-        _options.SolverOptions.DegeneratePivotsBeforeBlandsRule = reader.ReadInt32();
-        _options.MaximumDenseLinearProgramEntries = reader.ReadInt64();
-    }
-
-    /// <summary>
-    /// Creates a new instance of the quantile regression model with the same options.
-    /// </summary>
-    /// <returns>A new instance of the quantile regression model with the same configuration but no trained parameters.</returns>
-    /// <remarks>
-    /// <para>
-    /// This method creates a new instance of the quantile regression model with the same configuration
-    /// options and regularization method as the current instance, but without copying the trained parameters.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method creates a fresh copy of the model configuration without 
-    /// any learned parameters.
-    /// 
-    /// Think of it like getting a blank notepad with the same paper quality and size, 
-    /// but without any writing on it yet. The new model has the same:
-    /// - Quantile setting (which part of the distribution you're estimating)
-    /// - Learning rate (how quickly the model adjusts during training)
-    /// - Maximum iterations (how long the model will train)
-    /// - Regularization settings (safeguards against overfitting)
-    /// 
-    /// But it doesn't have any of the coefficient values that were learned from data.
-    /// 
-    /// This is mainly used internally when doing things like cross-validation or 
-    /// creating ensembles of similar models with different training data.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        // Create a new instance with the same options and regularization
-        return new QuantileRegression<T>(new QuantileRegressionOptions<T>(_options), Regularization);
-    }
 }
diff --git a/src/Regression/QuantileRegressionForests.cs b/src/Regression/QuantileRegressionForests.cs
index 2ad29f9ca0..2fd5750926 100644
--- a/src/Regression/QuantileRegressionForests.cs
+++ b/src/Regression/QuantileRegressionForests.cs
@@ -53,7 +53,7 @@ namespace AiDotNet.Regression;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
 [ResearchPaper("Quantile Regression Forests", "https://jmlr.org/papers/v7/meinshausen06a.html", Year = 2006, Authors = "Nicolai Meinshausen")]
-public class QuantileRegressionForests<T> : AsyncDecisionTreeRegressionBase<T>
+public partial class QuantileRegressionForests<T> : AsyncDecisionTreeRegressionBase<T>
 {
     /// <summary>
     /// Initializes a new instance with default settings.
@@ -345,161 +345,4 @@ public override ModelMetadata<T> GetModelMetadata()
 
         return metadata;
     }
-
-    /// <summary>
-    /// Serializes the model to a byte array.
-    /// </summary>
-    /// <returns>A byte array containing the serialized model data.</returns>
-    /// <remarks>
-    /// <para>
-    /// This method serializes the model's parameters, including options, feature importances, and all trees in the forest.
-    /// </para>
-    /// <para>
-    /// <b>For Beginners:</b> Serialization converts the model's internal state into a format that can be saved to disk or
-    /// transmitted over a network. This allows you to save a trained model and load it later without
-    /// having to retrain it. Think of it like saving your progress in a video game.
-    /// </para>
-    /// </remarks>
-    public override byte[] Serialize()
-    {
-        using var ms = new MemoryStream();
-        using var writer = new BinaryWriter(ms);
-
-        // Serialize options
-        writer.Write(_options.NumberOfTrees);
-        writer.Write(_options.MaxDepth);
-        writer.Write(_options.MinSamplesSplit);
-        writer.Write(_options.MaxFeatures);
-        writer.Write(_options.Seed ?? -1);
-        writer.Write((int)_options.SplitCriterion);
-        writer.Write(_options.MaxDegreeOfParallelism);
-
-        // Serialize feature importances
-        writer.Write(FeatureImportances.Length);
-        foreach (var importance in FeatureImportances)
-        {
-            writer.Write(Convert.ToDouble(importance));
-        }
-
-        // Serialize trees
-        writer.Write(_trees.Count);
-        foreach (var tree in _trees)
-        {
-            var treeData = tree.Serialize();
-            writer.Write(treeData.Length);
-            writer.Write(treeData);
-        }
-
-        return ms.ToArray();
-    }
-
-    /// <summary>
-    /// Deserializes the model from a byte array.
-    /// </summary>
-    /// <param name="modelData">The byte array containing the serialized model data.</param>
-    /// <remarks>
-    /// <para>
-    /// This method reconstructs the model's parameters from a serialized byte array, including options,
-    /// feature importances, and all trees in the forest.
-    /// </para>
-    /// <para>
-    /// <b>For Beginners:</b> Deserialization is the opposite of serialization - it takes the saved model data and reconstructs
-    /// the model's internal state. This allows you to load a previously trained model and use it to make
-    /// predictions without having to retrain it. It's like loading a saved game to continue where you left off.
-    /// </para>
-    /// </remarks>
-    public override void Deserialize(byte[] modelData)
-    {
-        using var ms = new MemoryStream(modelData);
-        using var reader = new BinaryReader(ms);
-
-        // Deserialize options
-        _options.NumberOfTrees = reader.ReadInt32();
-        _options.MaxDepth = reader.ReadInt32();
-        _options.MinSamplesSplit = reader.ReadInt32();
-        _options.MaxFeatures = reader.ReadDouble();
-        int seed = reader.ReadInt32();
-        _options.Seed = seed == -1 ? null : seed;
-        _options.SplitCriterion = (SplitCriterion)reader.ReadInt32();
-        _options.MaxDegreeOfParallelism = reader.ReadInt32();
-
-        // Deserialize feature importances
-        int featureCount = reader.ReadInt32();
-        var importances = new T[featureCount];
-        for (int i = 0; i < featureCount; i++)
-        {
-            importances[i] = NumOps.FromDouble(reader.ReadDouble());
-        }
-        FeatureImportances = new Vector<T>(importances);
-
-        // Deserialize trees
-        int treeCount = reader.ReadInt32();
-        _trees = new List<DecisionTreeRegression<T>>(treeCount);
-        for (int i = 0; i < treeCount; i++)
-        {
-            int treeDataLength = reader.ReadInt32();
-            byte[] treeData = reader.ReadBytes(treeDataLength);
-            var tree = new DecisionTreeRegression<T>(new DecisionTreeOptions(), Regularization);
-            tree.Deserialize(treeData);
-            _trees.Add(tree);
-        }
-
-        _random = _options.Seed.HasValue ? RandomHelper.CreateSeededRandom(_options.Seed.Value) : RandomHelper.CreateSecureRandom();
-    }
-
-    /// <summary>
-    /// Creates a new instance of the Quantile Regression Forests model with the same configuration.
-    /// </summary>
-    /// <returns>A new instance of the Quantile Regression Forests model.</returns>
-    /// <exception cref="InvalidOperationException">Thrown when the creation fails or required components are null.</exception>
-    /// <remarks>
-    /// <para>
-    /// This method creates a deep copy of the current model, including its configuration options, 
-    /// trained trees, feature importances, and regularization settings. The new instance is completely 
-    /// independent of the original, allowing modifications without affecting the original model.
-    /// </para>
-    /// <para>
-    /// <b>For Beginners:</b> This method creates an exact copy of your trained model.
-    /// 
-    /// Think of it like making a perfect clone of your forest model:
-    /// - It copies all the configuration settings (number of trees, max depth, etc.)
-    /// - It duplicates all the individual decision trees that make up the forest
-    /// - It preserves the feature importance values that show which inputs matter most
-    /// - It maintains all regularization settings that help prevent overfitting
-    /// 
-    /// Creating a copy is useful when you want to:
-    /// - Create a backup before further modifying the model
-    /// - Create variations of the same model for different purposes
-    /// - Share the model with others while keeping your original intact
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        var newModel = new QuantileRegressionForests<T>(_options, Regularization);
-
-        // Copy feature importances if they exist
-        if (FeatureImportances != null)
-        {
-            newModel.FeatureImportances = new Vector<T>([.. FeatureImportances]);
-        }
-
-        // Deep copy all the trees
-        newModel._trees = new List<DecisionTreeRegression<T>>(_trees.Count);
-        foreach (var tree in _trees)
-        {
-            // Create a deep copy of each tree by serializing and deserializing
-            var treeData = tree.Serialize();
-            var treeCopy = new DecisionTreeRegression<T>(new DecisionTreeOptions(), Regularization);
-            treeCopy.Deserialize(treeData);
-            newModel._trees.Add(treeCopy);
-        }
-
-        // Initialize the random number generator with the same seed if available
-        if (_options.Seed.HasValue)
-        {
-            newModel._random = RandomHelper.CreateSeededRandom(_options.Seed.Value);
-        }
-
-        return newModel;
-    }
 }
diff --git a/src/Regression/RadialBasisFunctionRegression.cs b/src/Regression/RadialBasisFunctionRegression.cs
index f1636a235f..6b0f4f1094 100644
--- a/src/Regression/RadialBasisFunctionRegression.cs
+++ b/src/Regression/RadialBasisFunctionRegression.cs
@@ -53,7 +53,7 @@ namespace AiDotNet.Regression;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
     [ResearchPaper("Radial Basis Functions", "https://doi.org/10.1017/CBO9780511543241")]
-public class RadialBasisFunctionRegression<T> : NonLinearRegressionBase<T>
+public partial class RadialBasisFunctionRegression<T> : NonLinearRegressionBase<T>
 {
     /// <summary>
     /// Configuration options for the radial basis function regression model.
@@ -82,6 +82,7 @@ public class RadialBasisFunctionRegression<T> : NonLinearRegressionBase<T>
     /// <value>
     /// A matrix where each row represents a center point in the input space.
     /// </value>
+    [Buffer]
     private Matrix<T> _centers;
 
     /// <summary>
@@ -90,6 +91,7 @@ public class RadialBasisFunctionRegression<T> : NonLinearRegressionBase<T>
     /// <value>
     /// A vector of weights, including a bias term.
     /// </value>
+    [Buffer]
     private Vector<T> _weights;
 
     /// <summary>
@@ -159,18 +161,6 @@ public override IEnumerable<int> GetActiveFeatureIndices()
         return Enumerable.Range(0, numFeatures);
     }
 
-    /// <summary>
-    /// Deep copy via serialization to preserve private _centers and _weights.
-    /// </summary>
-    public override IFullModel<T, Matrix<T>, Vector<T>> Clone()
-    {
-        var clone = new RadialBasisFunctionRegression<T>(_options, Regularization);
-        clone.Deserialize(Serialize());
-        return clone;
-    }
-
-    public override IFullModel<T, Matrix<T>, Vector<T>> DeepCopy() => Clone();
-
     protected override void OptimizeModel(Matrix<T> x, Vector<T> y)
     {
         // Auto-scale gamma if using the default value of 1.0
@@ -738,110 +728,6 @@ private static bool ModelTestHelpers_AllFinite(Vector<T> v)
         return true;
     }
 
-    /// <summary>
-    /// Serializes the model to a byte array.
-    /// </summary>
-    /// <returns>A byte array containing the serialized model data.</returns>
-    /// <remarks>
-    /// <para>
-    /// This method serializes the model's parameters, including base class data, options, centers, and weights.
-    /// </para>
-    /// <para>
-    /// <b>For Beginners:</b>
-    /// Serialization converts the model's internal state into a format that can be saved to disk or
-    /// transmitted over a network. This allows you to save a trained model and load it later without
-    /// having to retrain it. Think of it like saving your progress in a video game.
-    /// </para>
-    /// </remarks>
-    public override byte[] Serialize()
-    {
-        using var ms = new MemoryStream();
-        using var writer = new BinaryWriter(ms);
-
-        // Serialize base class data
-        byte[] baseData = base.Serialize();
-        writer.Write(baseData.Length);
-        writer.Write(baseData);
-
-        // Serialize RBF specific data
-        writer.Write(_options.NumberOfCenters);
-        writer.Write(_options.Gamma);
-        writer.Write(_options.Seed ?? -1);
-
-        // Serialize centers
-        writer.Write(_centers.Rows);
-        writer.Write(_centers.Columns);
-        for (int i = 0; i < _centers.Rows; i++)
-        {
-            for (int j = 0; j < _centers.Columns; j++)
-            {
-                writer.Write(Convert.ToDouble(_centers[i, j]));
-            }
-        }
-
-        // Serialize weights
-        writer.Write(_weights.Length);
-        for (int i = 0; i < _weights.Length; i++)
-        {
-            writer.Write(Convert.ToDouble(_weights[i]));
-        }
-
-        return ms.ToArray();
-    }
-
-    /// <summary>
-    /// Deserializes the model from a byte array.
-    /// </summary>
-    /// <param name="modelData">The byte array containing the serialized model data.</param>
-    /// <remarks>
-    /// <para>
-    /// This method reconstructs the model's parameters from a serialized byte array, including base class data,
-    /// options, centers, and weights.
-    /// </para>
-    /// <para>
-    /// <b>For Beginners:</b>
-    /// Deserialization is the opposite of serialization - it takes the saved model data and reconstructs
-    /// the model's internal state. This allows you to load a previously trained model and use it to make
-    /// predictions without having to retrain it. It's like loading a saved game to continue where you left off.
-    /// </para>
-    /// </remarks>
-    public override void Deserialize(byte[] modelData)
-    {
-        using var ms = new MemoryStream(modelData);
-        using var reader = new BinaryReader(ms);
-
-        // Deserialize base class data
-        int baseDataLength = reader.ReadInt32();
-        byte[] baseData = reader.ReadBytes(baseDataLength);
-        base.Deserialize(baseData);
-
-        // Deserialize RBF specific data
-        _options.NumberOfCenters = reader.ReadInt32();
-        _options.Gamma = reader.ReadDouble();
-        int seed = reader.ReadInt32();
-        _options.Seed = seed == -1 ? null : seed;
-
-        // Deserialize centers
-        int centerRows = reader.ReadInt32();
-        int centerColumns = reader.ReadInt32();
-        _centers = new Matrix<T>(centerRows, centerColumns);
-        for (int i = 0; i < centerRows; i++)
-        {
-            for (int j = 0; j < centerColumns; j++)
-            {
-                _centers[i, j] = NumOps.FromDouble(reader.ReadDouble());
-            }
-        }
-
-        // Deserialize weights
-        int weightsLength = reader.ReadInt32();
-        _weights = new Vector<T>(weightsLength);
-        for (int i = 0; i < weightsLength; i++)
-        {
-            _weights[i] = NumOps.FromDouble(reader.ReadDouble());
-        }
-    }
-
     /// <summary>
     /// Creates a new instance of the radial basis function regression model with the same options.
     /// </summary>
diff --git a/src/Regression/RandomForestRegression.cs b/src/Regression/RandomForestRegression.cs
index de257c55ec..20326d2158 100644
--- a/src/Regression/RandomForestRegression.cs
+++ b/src/Regression/RandomForestRegression.cs
@@ -52,7 +52,7 @@ namespace AiDotNet.Regression;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
 [ResearchPaper("Random Forests", "https://doi.org/10.1023/A:1010933404324", Year = 2001, Authors = "Leo Breiman")]
-public class RandomForestRegression<T> : AsyncDecisionTreeRegressionBase<T>
+public partial class RandomForestRegression<T> : AsyncDecisionTreeRegressionBase<T>
 {
     /// <summary>
     /// Initializes a new instance with default settings.
@@ -343,130 +343,4 @@ protected override async Task CalculateFeatureImportancesAsync(int numFeatures)
         FeatureImportances = new Vector<T>(importances);
     }
 
-    /// <summary>
-    /// Serializes the model to a byte array.
-    /// </summary>
-    /// <returns>A byte array containing the serialized model data.</returns>
-    /// <remarks>
-    /// <para>
-    /// This method serializes the model's parameters, including options, trees, and regularization type,
-    /// to a JSON format and then converts it to a byte array.
-    /// </para>
-    /// <para>
-    /// <b>For Beginners:</b>
-    /// Serialization converts the model's internal state into a format that can be saved to disk or
-    /// transmitted over a network. This allows you to save a trained model and load it later without
-    /// having to retrain it. Think of it like saving your progress in a video game.
-    /// </para>
-    /// </remarks>
-    public override byte[] Serialize()
-    {
-        var serializableModel = new
-        {
-            Options = _options,
-            Trees = _trees.Select(tree => Convert.ToBase64String(tree.Serialize())).ToList(),
-            Regularization = Regularization.GetType().Name
-        };
-
-        var json = JsonConvert.SerializeObject(serializableModel, Formatting.None);
-        return Encoding.UTF8.GetBytes(json);
-    }
-
-    /// <summary>
-    /// Deserializes the model from a byte array.
-    /// </summary>
-    /// <param name="data">The byte array containing the serialized model data.</param>
-    /// <exception cref="InvalidOperationException">Thrown when deserialization fails.</exception>
-    /// <remarks>
-    /// <para>
-    /// This method reconstructs the model's parameters from a serialized byte array, including options,
-    /// trees, and regularization type.
-    /// </para>
-    /// <para>
-    /// <b>For Beginners:</b>
-    /// Deserialization is the opposite of serialization - it takes the saved model data and reconstructs
-    /// the model's internal state. This allows you to load a previously trained model and use it to make
-    /// predictions without having to retrain it. It's like loading a saved game to continue where you left off.
-    /// </para>
-    /// </remarks>
-    public override void Deserialize(byte[] data)
-    {
-        var json = Encoding.UTF8.GetString(data);
-        var deserializedModel = JsonConvert.DeserializeAnonymousType(json, new
-        {
-            Options = new RandomForestRegressionOptions(),
-            Trees = new List<string>(),
-            Regularization = ""
-        });
-
-        if (deserializedModel == null)
-        {
-            throw new InvalidOperationException("Failed to deserialize the model");
-        }
-
-        _options = deserializedModel.Options;
-
-        _trees = [.. deserializedModel.Trees.Select(treeData =>
-        {
-            var treeOptions = new DecisionTreeOptions
-            {
-                MaxDepth = _options.MaxDepth,
-                MinSamplesSplit = _options.MinSamplesSplit,
-                MaxFeatures = _options.MaxFeatures,
-                Seed = _options.Seed,
-                SplitCriterion = _options.SplitCriterion
-            };
-            var tree = new DecisionTreeRegression<T>(treeOptions, Regularization);
-            tree.Deserialize(Convert.FromBase64String(treeData));
-            return tree;
-        })];
-
-        // Reinitialize other fields
-        _random = _options.Seed.HasValue ? RandomHelper.CreateSeededRandom(_options.Seed.Value) : RandomHelper.CreateSecureRandom();
-    }
-
-    /// <summary>
-    /// Creates a new instance of the Random Forest regression model with the same options.
-    /// </summary>
-    /// <returns>A new instance of the model with the same configuration but no trained parameters.</returns>
-    /// <remarks>
-    /// <para>
-    /// This method creates a new instance of the Random Forest regression model with the same configuration
-    /// options and regularization method as the current instance, but without copying the trained trees
-    /// or other learned parameters.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method creates a fresh copy of the model configuration without 
-    /// any learned parameters.
-    /// 
-    /// Think of it like getting a blank forest template with the same settings, 
-    /// but without any of the trained trees. The new model has the same:
-    /// - Number of trees setting
-    /// - Maximum depth setting
-    /// - Minimum samples split setting
-    /// - Maximum features ratio
-    /// - Split criterion (how nodes decide which feature to split on)
-    /// - Regularization method
-    /// 
-    /// But it doesn't have any of the actual trained trees that were learned from data.
-    /// 
-    /// This is mainly used internally when doing things like cross-validation or 
-    /// creating ensembles of similar models with different training data.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        // Create a new instance with the same options and regularization
-        return new RandomForestRegression<T>(_options, Regularization);
-    }
-
-    /// <summary>
-    /// Deep copy via serialization to preserve the private _trees list.
-    /// </summary>
-    public override IFullModel<T, Matrix<T>, Vector<T>> Clone()
-    {
-        var clone = new RandomForestRegression<T>(_options, Regularization);
-        clone.Deserialize(Serialize());
-        return clone;
-    }
-
 }
diff --git a/src/Regression/RegressionBase.cs b/src/Regression/RegressionBase.cs
index 95811fd8d7..a47b542bab 100644
--- a/src/Regression/RegressionBase.cs
+++ b/src/Regression/RegressionBase.cs
@@ -31,7 +31,7 @@ namespace AiDotNet.Regression;
 /// functionality.
 /// </para>
 /// </remarks>
-public abstract class RegressionBase<T> : IRegression<T>, IConfigurableModel<T>, IModelShape,
+public abstract partial class RegressionBase<T> : IRegression<T>, IConfigurableModel<T>, IModelShape,
     IParameterizable<T, Matrix<T>, Vector<T>>, IFeatureAware, IGradientComputable<T, Matrix<T>, Vector<T>>,
     IParameterManifestProvider
 {
@@ -372,6 +372,49 @@ public virtual byte[] Serialize()
     /// this method, so a malicious or careless override of
     /// <see cref="Serialize"/> cannot intercept the clone path.
     /// </summary>
+    /// <summary>State that is not a coefficient vector, declared once and persisted by this base.</summary>
+    /// <remarks>
+    /// RegressionBase does not derive from <c>ModelBase</c> -- they are parallel hierarchies over the
+    /// same interfaces -- so the registry wiring is repeated here while the logic itself lives once
+    /// in <see cref="ModelStateRegistry{T}"/>.
+    /// </remarks>
+    private readonly ModelStateRegistry<T> _stateRegistry = new();
+    private bool _stateRegistered;
+
+    /// <summary>
+    /// Declare state here that the coefficient vector does not carry -- a retained training set,
+    /// fitted knots, kernel centres, an ensemble's children.
+    /// </summary>
+    /// <param name="state">The registry to declare into.</param>
+    protected virtual void RegisterState(ModelStateRegistry<T> state)
+    {
+    }
+    /// <summary>Generated state declarations for fields declared across this model's hierarchy.</summary>
+    /// <param name="state">The registry to declare into.</param>
+    /// <remarks>
+    /// Emitted by ModelStateGenerator into the partial model, so a model author declares nothing. The
+    /// hand-written <c>RegisterState</c> beside it exists only for state the classifier genuinely
+    /// cannot place; anything it CAN place belongs here, where it cannot be forgotten.
+    /// </remarks>
+    protected virtual void RegisterGeneratedState(AiDotNet.Models.ModelStateRegistry<T> state)
+    {
+        RegisterGeneratedStateCore(state);
+    }
+
+    private ModelStateRegistry<T> State
+    {
+        get
+        {
+            if (!_stateRegistered)
+            {
+                _stateRegistered = true;
+                RegisterGeneratedState(_stateRegistry);
+                RegisterState(_stateRegistry);
+            }
+            return _stateRegistry;
+        }
+    }
+
     private byte[] SerializeInternalUnchecked()
     {
         var modelData = new Dictionary<string, object>
@@ -381,6 +424,19 @@ private byte[] SerializeInternalUnchecked()
             { "RegularizationOptions", Regularization.GetOptions() }
         };
 
+        // Carried as one base64 blob rather than as JSON members, so a matrix of training rows does
+        // not become a JSON array whose element type has to be guessed on the way back in.
+        if (State.Count > 0)
+        {
+            using var stateStream = new MemoryStream();
+            using (var stateWriter = new BinaryWriter(stateStream, Encoding.UTF8, leaveOpen: true))
+            {
+                State.WriteAll(stateWriter);
+                stateWriter.Flush();
+            }
+            modelData["DeclaredState"] = Convert.ToBase64String(stateStream.ToArray());
+        }
+
         var modelMetadata = GetModelMetadata();
         modelMetadata.ModelData = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(modelData));
 
@@ -434,6 +490,16 @@ private void DeserializeInternalUnchecked(byte[] modelData)
             throw new InvalidOperationException("Deserialization failed: The model data is invalid or corrupted.");
         }
 
+        // Restored BEFORE the coefficients below, so a model whose declared state and coefficients
+        // describe the same fit ends with the coefficient restore as the last word.
+        var declaredState = modelDataObj["DeclaredState"]?.ToObject<string>();
+        if (!string.IsNullOrEmpty(declaredState) && State.Count > 0)
+        {
+            using var stateStream = new MemoryStream(Convert.FromBase64String(declaredState));
+            using var stateReader = new BinaryReader(stateStream, Encoding.UTF8, leaveOpen: true);
+            State.ReadAll(stateReader);
+        }
+
         var coefficientsToken = modelDataObj["Coefficients"];
         var interceptToken = modelDataObj["Intercept"];
         if (coefficientsToken == null || interceptToken == null)
@@ -1020,7 +1086,18 @@ private IFullModel<T, Matrix<T>, Vector<T>> CreateSerializedCopy()
     /// network before copying the data into it.
     /// </para>
     /// </remarks>
-    protected abstract IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance();
+    /// <remarks>
+    /// <para>
+    /// No longer abstract. Every concrete model used to be forced to write this, and 1147 of them
+    /// did -- each one a hand-copied list of constructor arguments that a new option could fall out
+    /// of without anything failing. The clone plan records that constructor at compile time instead,
+    /// so the base can rebuild the type and a model only overrides this when the generator says it
+    /// cannot: a constructor parameter with nothing holding its value, which the build reports by
+    /// name rather than leaving to be discovered by a clone that comes back subtly different.
+    /// </para>
+    /// </remarks>
+    protected virtual IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
+        => (IFullModel<T, Matrix<T>, Vector<T>>)AiDotNet.Models.CloneEngine.CopyConfiguration(this);
 
     /// <summary>
     /// Creates a clone of the regression model.
diff --git a/src/Regression/RidgeRegression.cs b/src/Regression/RidgeRegression.cs
index bc821d6d9b..650ba20c71 100644
--- a/src/Regression/RidgeRegression.cs
+++ b/src/Regression/RidgeRegression.cs
@@ -208,53 +208,4 @@ public override ModelMetadata<T> GetModelMetadata()
         return metadata;
     }
 
-
-    /// <summary>
-    /// Creates a new instance of Ridge Regression with the same configuration.
-    /// </summary>
-    /// <returns>A new instance with the same options.</returns>
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        return new RidgeRegression<T>(Options, Regularization);
-    }
-
-    /// <summary>
-    /// Serializes the Ridge Regression model to a byte array.
-    /// </summary>
-    /// <returns>A byte array containing the serialized model.</returns>
-    public override byte[] Serialize()
-    {
-        using var ms = new MemoryStream();
-        using var writer = new BinaryWriter(ms);
-
-        // Serialize base class data
-        byte[] baseData = base.Serialize();
-        writer.Write(baseData.Length);
-        writer.Write(baseData);
-
-        // Serialize Ridge-specific data
-        writer.Write(Options.Alpha);
-        writer.Write((int)Options.DecompositionType);
-
-        return ms.ToArray();
-    }
-
-    /// <summary>
-    /// Deserializes a Ridge Regression model from a byte array.
-    /// </summary>
-    /// <param name="modelData">The byte array containing the serialized model.</param>
-    public override void Deserialize(byte[] modelData)
-    {
-        using var ms = new MemoryStream(modelData);
-        using var reader = new BinaryReader(ms);
-
-        // Deserialize base class data
-        int baseDataLength = reader.ReadInt32();
-        byte[] baseData = reader.ReadBytes(baseDataLength);
-        base.Deserialize(baseData);
-
-        // Deserialize Ridge-specific data
-        Options.Alpha = reader.ReadDouble();
-        Options.DecompositionType = (MatrixDecompositionType)reader.ReadInt32();
-    }
 }
diff --git a/src/Regression/RobustRegression.cs b/src/Regression/RobustRegression.cs
index 62c749cf8f..739ca5dc47 100644
--- a/src/Regression/RobustRegression.cs
+++ b/src/Regression/RobustRegression.cs
@@ -53,7 +53,7 @@ namespace AiDotNet.Regression;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
     [ResearchPaper("Robust Statistics", "https://doi.org/10.1002/0471725250")]
-public class RobustRegression<T> : RegressionBase<T>
+public partial class RobustRegression<T> : RegressionBase<T>
 {
     /// <summary>
     /// Gets the configuration options used by this robust regression model.
@@ -252,82 +252,6 @@ private bool IsConverged(Vector<T> oldCoefficients, Vector<T> newCoefficients, T
     /// </para>
     /// </remarks>
 
-    /// <summary>
-    /// Serializes the robust regression model to a byte array for storage or transmission.
-    /// </summary>
-    /// <returns>A byte array containing the serialized model data.</returns>
-    /// <remarks>
-    /// <para>
-    /// This method converts the model, including its coefficients, intercept, and configuration options, into a 
-    /// byte array. This enables the model to be saved to a file, stored in a database, or transmitted over a network.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method saves the model to computer memory so you can use it later.
-    /// 
-    /// Think of it like taking a snapshot of the model:
-    /// - It captures all the important values and settings
-    /// - It converts them into a format that can be easily stored
-    /// - The resulting byte array can be saved to a file or database
-    /// 
-    /// This is useful when you want to:
-    /// - Train the model once and use it many times
-    /// - Share the model with others
-    /// - Use the model in a different application
-    /// </para>
-    /// </remarks>
-    public override byte[] Serialize()
-    {
-        using var ms = new MemoryStream();
-        using var writer = new BinaryWriter(ms);
-        // Serialize base class data
-        byte[] baseData = base.Serialize();
-        writer.Write(baseData.Length);
-        writer.Write(baseData);
-        // Serialize RobustRegression specific options
-        writer.Write(_options.TuningConstant);
-        writer.Write(_options.MaxIterations);
-        writer.Write(_options.Tolerance);
-        writer.Write((int)_options.WeightFunction);
-        return ms.ToArray();
-    }
-
-    /// <summary>
-    /// Deserializes the robust regression model from a byte array.
-    /// </summary>
-    /// <param name="modelData">The byte array containing the serialized model data.</param>
-    /// <remarks>
-    /// <para>
-    /// This method reconstructs the model from a byte array created by the Serialize method. It restores 
-    /// the model's coefficients, intercept, and configuration options, allowing a previously saved model 
-    /// to be loaded and used for predictions.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method loads a saved model from computer memory.
-    /// 
-    /// Think of it like restoring a model from a snapshot:
-    /// - It takes the byte array created by the Serialize method
-    /// - It reconstructs all the important values and settings
-    /// - The model is then ready to use for making predictions
-    /// 
-    /// This allows you to:
-    /// - Use a previously trained model without retraining it
-    /// - Load models that others have shared with you
-    /// - Use the same model across different applications
-    /// </para>
-    /// </remarks>
-    public override void Deserialize(byte[] modelData)
-    {
-        using var ms = new MemoryStream(modelData);
-        using var reader = new BinaryReader(ms);
-        // Deserialize base class data
-        int baseDataLength = reader.ReadInt32();
-        byte[] baseData = reader.ReadBytes(baseDataLength);
-        base.Deserialize(baseData);
-        // Deserialize RobustRegression specific options
-        _options.TuningConstant = reader.ReadDouble();
-        _options.MaxIterations = reader.ReadInt32();
-        _options.Tolerance = reader.ReadDouble();
-        _options.WeightFunction = (WeightFunction)reader.ReadInt32();
-    }
-
     // GetParameters is NOT overridden here. The override that used to be at this point built a
     // vector of Coefficients.Length + 1, adding the intercept UNCONDITIONALLY, while the count
     // it was paired with -- RegressionBase.ParameterCount -- honours Options.UseIntercept. With
@@ -377,37 +301,4 @@ public override IFullModel<T, Matrix<T>, Vector<T>> WithParameters(Vector<T> par
 
         return newModel;
     }
-
-    /// <summary>
-    /// Creates a new instance of the robust regression model with the same options.
-    /// </summary>
-    /// <returns>A new instance of the robust regression model with the same configuration but no trained parameters.</returns>
-    /// <remarks>
-    /// <para>
-    /// This method creates a new instance of the robust regression model with the same configuration
-    /// options and regularization method as the current instance, but without copying the trained
-    /// coefficients or intercept.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method creates a fresh copy of the model configuration without 
-    /// any learned parameters.
-    /// 
-    /// Think of it like getting a blank template with the same settings, 
-    /// but without any of the values that were learned from training data. The new model has the same:
-    /// - Weight function (how outliers are handled)
-    /// - Tuning constant (how sensitive the model is to outliers)
-    /// - Maximum iterations (how many times it will try to improve)
-    /// - Tolerance (when it decides it's "good enough")
-    /// - Regularization settings (how it prevents overfitting)
-    /// 
-    /// But it doesn't have any of the coefficients or intercept values that were learned from data.
-    /// 
-    /// This is mainly used internally when doing things like cross-validation or 
-    /// creating multiple similar models with different training data.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        // Create a new instance with the same options and regularization
-        return new RobustRegression<T>(_options, Regularization);
-    }
 }
diff --git a/src/Regression/SimpleRegression.cs b/src/Regression/SimpleRegression.cs
index 170d8e8d86..dcfc25ba1c 100644
--- a/src/Regression/SimpleRegression.cs
+++ b/src/Regression/SimpleRegression.cs
@@ -171,32 +171,4 @@ public override void Train(Matrix<T> x, Vector<T> y)
             Intercept = NumOps.Zero;
         }
     }
-
-    /// <summary>
-    /// Creates a new instance of the simple regression model with the same options.
-    /// </summary>
-    /// <returns>A new instance of the simple regression model with the same configuration but no trained parameters.</returns>
-    /// <remarks>
-    /// <para>
-    /// This method creates a new instance of the simple regression model with the same configuration
-    /// options and regularization method as the current instance, but without copying the trained parameters.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method creates a fresh copy of the model configuration without 
-    /// any learned parameters.
-    /// 
-    /// Think of it like getting a clean notepad with the same paper type and line spacing, but 
-    /// without any writing on it yet. The new model has the same settings (like whether to include
-    /// an intercept term), but hasn't learned any coefficients from data.
-    /// 
-    /// This is primarily used internally by the framework when doing things like:
-    /// - Cross-validation (testing the model on different data splits)
-    /// - Building model ensembles
-    /// - Creating copies of models for experimentation
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        // Create a new instance with the same options and regularization
-        return new SimpleRegression<T>(Options, Regularization);
-    }
 }
diff --git a/src/Regression/SplineRegression.cs b/src/Regression/SplineRegression.cs
index fa9439b694..a91abe77af 100644
--- a/src/Regression/SplineRegression.cs
+++ b/src/Regression/SplineRegression.cs
@@ -58,7 +58,7 @@ namespace AiDotNet.Regression;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
     [ResearchPaper("Spline Models for Observational Data", "https://doi.org/10.1137/1.9781611970128")]
-public class SplineRegression<T> : NonLinearRegressionBase<T>
+public partial class SplineRegression<T> : NonLinearRegressionBase<T>
 {
     /// <summary>
     /// Configuration options for the spline regression model.
@@ -119,6 +119,7 @@ public class SplineRegression<T> : NonLinearRegressionBase<T>
     /// The coefficients are what the model learns when you train it on your data.
     /// </para>
     /// </remarks>
+    [AiDotNet.Attributes.Buffer]
     private Vector<T> _coefficients;
 
     /// <summary>
@@ -445,115 +446,6 @@ private Vector<T> GenerateKnots(Vector<T> x)
     /// </para>
     /// </remarks>
 
-    /// <summary>
-    /// Serializes the spline regression model to a byte array for storage or transmission.
-    /// </summary>
-    /// <returns>A byte array containing the serialized model data.</returns>
-    /// <remarks>
-    /// <para>
-    /// This method converts the model, including its coefficients, knots, and configuration options, into a 
-    /// byte array. This enables the model to be saved to a file, stored in a database, or transmitted over a network.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method saves the model to computer memory so you can use it later.
-    /// 
-    /// Think of it like taking a snapshot of the model:
-    /// - It captures all the important values, knots, and coefficients
-    /// - It converts them into a format that can be easily stored
-    /// - The resulting byte array can be saved to a file or database
-    /// 
-    /// This is useful when you want to:
-    /// - Train the model once and use it many times
-    /// - Share the model with others
-    /// - Use the model in a different application
-    /// </para>
-    /// </remarks>
-    public override byte[] Serialize()
-    {
-        using var ms = new MemoryStream();
-        using var writer = new BinaryWriter(ms);
-
-        // Serialize base class data
-        byte[] baseData = base.Serialize();
-        writer.Write(baseData.Length);
-        writer.Write(baseData);
-
-        // Serialize SplineRegression specific data
-        writer.Write(_options.NumberOfKnots);
-        writer.Write(_options.Degree);
-
-        // Serialize knots
-        writer.Write(_knots.Count);
-        foreach (var knotVector in _knots)
-        {
-            writer.Write(knotVector.Length);
-            for (int i = 0; i < knotVector.Length; i++)
-                writer.Write(Convert.ToDouble(knotVector[i]));
-        }
-
-        // Serialize coefficients
-        writer.Write(_coefficients.Length);
-        for (int i = 0; i < _coefficients.Length; i++)
-            writer.Write(Convert.ToDouble(_coefficients[i]));
-
-        return ms.ToArray();
-    }
-
-    /// <summary>
-    /// Deserializes the spline regression model from a byte array.
-    /// </summary>
-    /// <param name="modelData">The byte array containing the serialized model data.</param>
-    /// <remarks>
-    /// <para>
-    /// This method reconstructs the model from a byte array created by the Serialize method. It restores 
-    /// the model's coefficients, knots, and configuration options, allowing a previously saved model 
-    /// to be loaded and used for predictions.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method loads a saved model from computer memory.
-    /// 
-    /// Think of it like opening a saved document:
-    /// - It takes the byte array created by the Serialize method
-    /// - It rebuilds all the knots, coefficients, and settings
-    /// - The model is then ready to use for making predictions
-    /// 
-    /// This allows you to:
-    /// - Use a previously trained model without having to train it again
-    /// - Load models that others have shared with you
-    /// - Use the same model across different applications
-    /// </para>
-    /// </remarks>
-    public override void Deserialize(byte[] modelData)
-    {
-        using var ms = new MemoryStream(modelData);
-        using var reader = new BinaryReader(ms);
-
-        // Deserialize base class data
-        int baseDataLength = reader.ReadInt32();
-        byte[] baseData = reader.ReadBytes(baseDataLength);
-        base.Deserialize(baseData);
-
-        // Deserialize SplineRegression specific data
-        _options.NumberOfKnots = reader.ReadInt32();
-        _options.Degree = reader.ReadInt32();
-
-        // Deserialize knots
-        int knotsCount = reader.ReadInt32();
-        _knots = new List<Vector<T>>();
-        for (int j = 0; j < knotsCount; j++)
-        {
-            int knotsLength = reader.ReadInt32();
-            var knotVector = new Vector<T>(knotsLength);
-            for (int i = 0; i < knotsLength; i++)
-                knotVector[i] = NumOps.FromDouble(reader.ReadDouble());
-            _knots.Add(knotVector);
-        }
-
-        // Deserialize coefficients
-        int coefficientsLength = reader.ReadInt32();
-        _coefficients = new Vector<T>(coefficientsLength);
-        for (int i = 0; i < coefficientsLength; i++)
-            _coefficients[i] = NumOps.FromDouble(reader.ReadDouble());
-    }
-
     /// <summary>
     /// Creates a new instance of the Spline Regression model with the same configuration.
     /// </summary>
diff --git a/src/Regression/StepwiseRegression.cs b/src/Regression/StepwiseRegression.cs
index 318413a98f..89553c7f5d 100644
--- a/src/Regression/StepwiseRegression.cs
+++ b/src/Regression/StepwiseRegression.cs
@@ -57,7 +57,7 @@ namespace AiDotNet.Regression;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
     [ResearchPaper("Applied Linear Statistical Models", "https://doi.org/10.1080/00401706.1997.10485117")]
-public class StepwiseRegression<T> : RegressionBase<T>
+public partial class StepwiseRegression<T> : RegressionBase<T>
 {
     /// <summary>
     /// Configuration options for the stepwise regression model.
@@ -536,150 +536,4 @@ private ModelEvaluationData<T, Matrix<T>, Vector<T>> EvaluateModelDirectly(
             ModelStats = modelStats
         };
     }
-
-    /// <summary>
-    /// Serializes the stepwise regression model to a byte array for storage or transmission.
-    /// </summary>
-    /// <returns>A byte array containing the serialized model data.</returns>
-    /// <remarks>
-    /// <para>
-    /// This method converts the model, including its coefficients, selected features, and configuration options, into a 
-    /// byte array. This enables the model to be saved to a file, stored in a database, or transmitted over a network.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method saves the model to computer memory so you can use it later.
-    /// 
-    /// Think of it like taking a snapshot of the model:
-    /// - It captures all the important values, settings, and the list of selected features
-    /// - It converts them into a format that can be easily stored
-    /// - The resulting byte array can be saved to a file or database
-    /// 
-    /// This is useful when you want to:
-    /// - Train the model once and use it many times
-    /// - Share the model with others
-    /// - Use the model in a different application
-    /// </para>
-    /// </remarks>
-    public override byte[] Serialize()
-    {
-        using var ms = new MemoryStream();
-        using var writer = new BinaryWriter(ms);
-
-        // Serialize base class data
-        byte[] baseData = base.Serialize();
-        writer.Write(baseData.Length);
-        writer.Write(baseData);
-
-        // Serialize StepwiseRegression specific data
-        writer.Write((int)_options.Method);
-        writer.Write(_options.MaxFeatures);
-        writer.Write(_options.MinFeatures);
-        writer.Write(Convert.ToDouble(_options.MinImprovement));
-
-        // Serialize selected features
-        writer.Write(_selectedFeatures.Count);
-        foreach (var feature in _selectedFeatures)
-        {
-            writer.Write(feature);
-        }
-
-        return ms.ToArray();
-    }
-
-    /// <summary>
-    /// Deserializes the stepwise regression model from a byte array.
-    /// </summary>
-    /// <param name="data">The byte array containing the serialized model data.</param>
-    /// <remarks>
-    /// <para>
-    /// This method reconstructs the model from a byte array created by the Serialize method. It restores 
-    /// the model's coefficients, selected features, and configuration options, allowing a previously saved model 
-    /// to be loaded and used for predictions.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method loads a saved model from computer memory.
-    /// 
-    /// Think of it like opening a saved document:
-    /// - It takes the byte array created by the Serialize method
-    /// - It rebuilds all the settings, coefficients, and the list of selected features
-    /// - The model is then ready to use for making predictions
-    /// 
-    /// This allows you to:
-    /// - Use a previously trained model without having to train it again
-    /// - Load models that others have shared with you
-    /// - Use the same model across different applications
-    /// </para>
-    /// </remarks>
-    public override void Deserialize(byte[] data)
-    {
-        using var ms = new MemoryStream(data);
-        using var reader = new BinaryReader(ms);
-
-        // Deserialize base class data
-        int baseDataLength = reader.ReadInt32();
-        byte[] baseData = reader.ReadBytes(baseDataLength);
-        base.Deserialize(baseData);
-
-        // Deserialize StepwiseRegression specific data
-        _options.Method = (StepwiseMethod)reader.ReadInt32();
-        _options.MaxFeatures = reader.ReadInt32();
-        _options.MinFeatures = reader.ReadInt32();
-        _options.MinImprovement = Convert.ToDouble(reader.ReadDouble());
-
-        // Deserialize selected features
-        int featureCount = reader.ReadInt32();
-        _selectedFeatures = new List<int>(featureCount);
-        for (int i = 0; i < featureCount; i++)
-        {
-            _selectedFeatures.Add(reader.ReadInt32());
-        }
-    }
-
-    /// <summary>
-    /// Creates a new instance of the Stepwise Regression model with the same configuration.
-    /// </summary>
-    /// <returns>A new instance of the Stepwise Regression model.</returns>
-    /// <exception cref="InvalidOperationException">Thrown when the creation fails or required components are null.</exception>
-    /// <remarks>
-    /// <para>
-    /// This method creates a deep copy of the current Stepwise Regression model, including its coefficients,
-    /// intercept, configuration options, selected features, and fitness calculator.
-    /// The new instance is completely independent of the original, allowing modifications without
-    /// affecting the original model.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method creates an exact copy of the current regression model.
-    ///
-    /// The copy includes:
-    /// - The same coefficients (the importance values for each feature)
-    /// - The same intercept (the starting point value)
-    /// - The same list of selected features (the ingredients that were chosen as important)
-    /// - The same configuration settings (like whether to use forward or backward selection)
-    /// - The same fitness calculator (the judge that evaluates model quality)
-    ///
-    /// This is useful when you want to:
-    /// - Create a backup before further training or modification
-    /// - Create variations of the same model for different purposes
-    /// - Share the model while keeping your original intact
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        var newModel = new StepwiseRegression<T>(
-            options: _options,
-            predictionOptions: null,
-            fitnessCalculator: _fitnessCalculator,
-            regularization: Regularization);
-
-        // Copy the coefficients
-        if (Coefficients != null)
-        {
-            newModel.Coefficients = Coefficients.Clone();
-        }
-
-        // Copy the intercept
-        newModel.Intercept = Intercept;
-
-        // Create a deep copy of the selected features list
-        newModel._selectedFeatures = [.. _selectedFeatures];
-
-        return newModel;
-    }
 }
diff --git a/src/Regression/SuperLearner.cs b/src/Regression/SuperLearner.cs
index 190b00bc9a..a3e132bf5f 100644
--- a/src/Regression/SuperLearner.cs
+++ b/src/Regression/SuperLearner.cs
@@ -62,7 +62,7 @@ namespace AiDotNet.Regression;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
 [ResearchPaper("Super Learner", "https://doi.org/10.2202/1544-6115.1309", Year = 2007, Authors = "Mark J. van der Laan, Eric C. Polley, Alan E. Hubbard")]
-public class SuperLearner<T> : NonLinearRegressionBase<T>
+public partial class SuperLearner<T> : NonLinearRegressionBase<T>
 {
     /// <summary>
     /// Initializes a new instance with a default base model.
@@ -80,6 +80,7 @@ public SuperLearner()
     /// <summary>
     /// Meta-learner weights or coefficients.
     /// </summary>
+    [AiDotNet.Attributes.FittedParameter]
     private Vector<T>? _metaWeights;
 
     /// <summary>
@@ -90,6 +91,7 @@ public SuperLearner()
     /// <summary>
     /// Cross-validation performance of each base model.
     /// </summary>
+    [AiDotNet.Attributes.FittedParameter]
     private Vector<T>? _cvPerformance;
 
     /// <summary>
@@ -967,119 +969,6 @@ public override IEnumerable<int> GetActiveFeatureIndices()
         return Enumerable.Range(0, _numFeatures > 0 ? _numFeatures : 0);
     }
 
-    /// <inheritdoc/>
-    public override byte[] Serialize()
-    {
-        using var ms = new MemoryStream();
-        using var writer = new BinaryWriter(ms);
-
-        byte[] baseData = base.Serialize();
-        writer.Write(baseData.Length);
-        writer.Write(baseData);
-
-        // Options
-        writer.Write(_options.NumFolds);
-        writer.Write((int)_options.MetaLearnerType);
-        writer.Write(_numFeatures);
-
-        // Meta weights
-        writer.Write(_metaWeights?.Length ?? 0);
-        if (_metaWeights != null)
-        {
-            foreach (var w in _metaWeights)
-            {
-                writer.Write(NumOps.ToDouble(w));
-            }
-        }
-        writer.Write(NumOps.ToDouble(_metaIntercept));
-
-        // Normalization params
-        writer.Write(_predMeans?.Length ?? 0);
-        if (_predMeans != null && _predStds != null)
-        {
-            foreach (var mean in _predMeans)
-            {
-                writer.Write(NumOps.ToDouble(mean));
-            }
-            foreach (var std in _predStds)
-            {
-                writer.Write(NumOps.ToDouble(std));
-            }
-        }
-
-        // Note: Base models need to be serialized separately in a real implementation
-
-        return ms.ToArray();
-    }
-
-    /// <inheritdoc/>
-    public override void Deserialize(byte[] modelData)
-    {
-        using var ms = new MemoryStream(modelData);
-        using var reader = new BinaryReader(ms);
-
-        int baseLen = reader.ReadInt32();
-        base.Deserialize(reader.ReadBytes(baseLen));
-
-        _options.NumFolds = reader.ReadInt32();
-        _options.MetaLearnerType = (SuperLearnerMetaLearner)reader.ReadInt32();
-        _numFeatures = reader.ReadInt32();
-
-        int numWeights = reader.ReadInt32();
-        if (numWeights > 0)
-        {
-            _metaWeights = new Vector<T>(numWeights);
-            for (int i = 0; i < numWeights; i++)
-            {
-                _metaWeights[i] = NumOps.FromDouble(reader.ReadDouble());
-            }
-        }
-        _metaIntercept = NumOps.FromDouble(reader.ReadDouble());
-
-        int numMeans = reader.ReadInt32();
-        if (numMeans > 0)
-        {
-            _predMeans = new Vector<T>(numMeans);
-            _predStds = new Vector<T>(numMeans);
-            for (int i = 0; i < numMeans; i++)
-            {
-                _predMeans[i] = NumOps.FromDouble(reader.ReadDouble());
-            }
-            for (int i = 0; i < numMeans; i++)
-            {
-                _predStds[i] = NumOps.FromDouble(reader.ReadDouble());
-            }
-        }
-    }
-
-    public override IFullModel<T, Matrix<T>, Vector<T>> Clone()
-    {
-        // Clone each base model
-        var clonedModels = new List<IFullModel<T, Matrix<T>, Vector<T>>>();
-        foreach (var model in _baseModels)
-            clonedModels.Add(model.Clone());
-
-        var clone = new SuperLearner<T>(clonedModels, _options, Regularization);
-        if (SupportVectors.Rows > 0)
-            clone.SupportVectors = SupportVectors.Clone();
-        if (Alphas.Length > 0)
-            clone.Alphas = new Vector<T>(Alphas);
-        clone.B = B;
-        clone._metaIntercept = _metaIntercept;
-        clone._numFeatures = _numFeatures;
-        if (_metaWeights is not null)
-            clone._metaWeights = new Vector<T>(_metaWeights);
-        if (_cvPerformance is not null)
-            clone._cvPerformance = new Vector<T>(_cvPerformance);
-        if (_predMeans is not null)
-            clone._predMeans = new Vector<T>(_predMeans);
-        if (_predStds is not null)
-            clone._predStds = new Vector<T>(_predStds);
-        return clone;
-    }
-
-    public override IFullModel<T, Matrix<T>, Vector<T>> DeepCopy() => Clone();
-
     /// <inheritdoc/>
     protected override IFullModel<T, Matrix<T>, Vector<T>> CreateInstance()
     {
diff --git a/src/Regression/SupportVectorRegression.cs b/src/Regression/SupportVectorRegression.cs
index 3ebeebede1..ec0fc1cd05 100644
--- a/src/Regression/SupportVectorRegression.cs
+++ b/src/Regression/SupportVectorRegression.cs
@@ -59,7 +59,7 @@ namespace AiDotNet.Regression;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
 [ResearchPaper("A Tutorial on Support Vector Regression", "https://doi.org/10.1023/B:STCO.0000035301.49549.88", Year = 2004, Authors = "Alex J. Smola, Bernhard Scholkopf")]
-public class SupportVectorRegression<T> : NonLinearRegressionBase<T>
+public partial class SupportVectorRegression<T> : NonLinearRegressionBase<T>
 {
     /// <inheritdoc/>
     /// <summary>
@@ -177,6 +177,7 @@ public override IEnumerable<int> GetActiveFeatureIndices()
     }
 
     private bool _useOLS;
+    [AiDotNet.Attributes.Buffer]
     private Vector<T>? _olsCoefficients;
 
 
@@ -496,117 +497,6 @@ public override ModelMetadata<T> GetModelMetadata()
         return metadata;
     }
 
-    /// <summary>
-    /// Serializes the support vector regression model to a byte array for storage or transmission.
-    /// </summary>
-    /// <returns>A byte array containing the serialized model data.</returns>
-    /// <remarks>
-    /// <para>
-    /// This method converts the model, including its coefficients, support vectors, and configuration options, into a 
-    /// byte array. This enables the model to be saved to a file, stored in a database, or transmitted over a network.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method saves the model to computer memory so you can use it later.
-    /// 
-    /// Think of it like taking a snapshot of the model:
-    /// - It captures all the important values, settings, and support vectors
-    /// - It converts them into a format that can be easily stored
-    /// - The resulting byte array can be saved to a file or database
-    /// 
-    /// This is useful when you want to:
-    /// - Train the model once and use it many times
-    /// - Share the model with others
-    /// - Use the model in a different application
-    /// </para>
-    /// </remarks>
-    public override IFullModel<T, Matrix<T>, Vector<T>> Clone()
-    {
-        var clone = new SupportVectorRegression<T>(_options, Regularization);
-        clone.Deserialize(Serialize());
-        return clone;
-    }
-
-    public override IFullModel<T, Matrix<T>, Vector<T>> DeepCopy() => Clone();
-
-    public override byte[] Serialize()
-    {
-        using var ms = new MemoryStream();
-        using var writer = new BinaryWriter(ms);
-
-        // Serialize base class data
-        byte[] baseData = base.Serialize();
-        writer.Write(baseData.Length);
-        writer.Write(baseData);
-
-        // Serialize SVR specific data
-        writer.Write(_options.Epsilon);
-        writer.Write(_options.C);
-
-        // OLS state
-        writer.Write(_useOLS);
-        if (_useOLS && _olsCoefficients is not null)
-        {
-            writer.Write(_olsCoefficients.Length);
-            for (int j = 0; j < _olsCoefficients.Length; j++)
-                writer.Write(NumOps.ToDouble(_olsCoefficients[j]));
-            writer.Write(NumOps.ToDouble(_olsIntercept));
-        }
-        else
-        {
-            writer.Write(0);
-        }
-
-        return ms.ToArray();
-    }
-
-    /// <summary>
-    /// Deserializes the support vector regression model from a byte array.
-    /// </summary>
-    /// <param name="modelData">The byte array containing the serialized model data.</param>
-    /// <remarks>
-    /// <para>
-    /// This method reconstructs the model from a byte array created by the Serialize method. It restores 
-    /// the model's coefficients, support vectors, and configuration options, allowing a previously saved model 
-    /// to be loaded and used for predictions.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method loads a saved model from computer memory.
-    /// 
-    /// Think of it like opening a saved document:
-    /// - It takes the byte array created by the Serialize method
-    /// - It rebuilds all the settings, support vectors, and coefficients
-    /// - The model is then ready to use for making predictions
-    /// 
-    /// This allows you to:
-    /// - Use a previously trained model without having to train it again
-    /// - Load models that others have shared with you
-    /// - Use the same model across different applications
-    /// </para>
-    /// </remarks>
-    public override void Deserialize(byte[] modelData)
-    {
-        using var ms = new MemoryStream(modelData);
-        using var reader = new BinaryReader(ms);
-
-        // Deserialize base class data
-        int baseDataLength = reader.ReadInt32();
-        byte[] baseData = reader.ReadBytes(baseDataLength);
-        base.Deserialize(baseData);
-
-        // Deserialize SVR specific data
-        _options.Epsilon = reader.ReadDouble();
-        _options.C = reader.ReadDouble();
-
-        // OLS state
-        _useOLS = reader.ReadBoolean();
-        int olsCount = reader.ReadInt32();
-        if (olsCount > 0)
-        {
-            _olsCoefficients = new Vector<T>(olsCount);
-            for (int j = 0; j < olsCount; j++)
-                _olsCoefficients[j] = NumOps.FromDouble(reader.ReadDouble());
-            _olsIntercept = NumOps.FromDouble(reader.ReadDouble());
-        }
-    }
-
     /// <summary>
     /// Creates a new instance of the Support Vector Regression model with the same configuration.
     /// </summary>
diff --git a/src/Regression/SymbolicRegression.cs b/src/Regression/SymbolicRegression.cs
index beaa03300e..9612522539 100644
--- a/src/Regression/SymbolicRegression.cs
+++ b/src/Regression/SymbolicRegression.cs
@@ -62,7 +62,7 @@ namespace AiDotNet.Regression;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
     [ResearchPaper("Genetic Programming: On the Programming of Computers by Means of Natural Selection", "https://doi.org/10.7551/mitpress/3108.001.0001")]
-public class SymbolicRegression<T> : NonLinearRegressionBase<T>
+public partial class SymbolicRegression<T> : NonLinearRegressionBase<T>
 {
     /// <summary>
     /// Configuration options for the symbolic regression model.
@@ -312,6 +312,7 @@ public SymbolicRegression(
         PreprocessingPipeline<T, Matrix<T>, Matrix<T>>? preprocessingPipeline = null)
         : base(options, regularization)
     {
+        _olsIntercept = NumOps.Zero;
         _options = options ?? new SymbolicRegressionOptions();
         var dummyModel = new VectorModel<T>(Vector<T>.Empty());
         _optimizer = new GeneticAlgorithmOptimizer<T, Matrix<T>, Vector<T>>(
@@ -369,94 +370,62 @@ public SymbolicRegression(
     /// </remarks>
     public override bool SupportsParameterInitialization => false;
 
+    private bool _useOLS;
+    [AiDotNet.Attributes.Buffer]
+    private Vector<T>? _olsCoefficients;
+
+
+    private T _olsIntercept;
+
+
+
     protected override void ExtractModelParameters()
     {
+        if (_useOLS) return;
         base.ExtractModelParameters();
     }
 
-    public override IFullModel<T, Matrix<T>, Vector<T>> Clone() => base.Clone();
-
-    public override IFullModel<T, Matrix<T>, Vector<T>> DeepCopy() => Clone();
-
     public override IEnumerable<int> GetActiveFeatureIndices()
     {
-        // Report the features the EVOLVED model actually uses. The base implementation derives
-        // active features from Alphas and SupportVectors, which this model never populates — those
-        // belong to the kernel models it shares a base class with — so it reported no active
-        // features at all once the real search started running.
-        if (_bestModel is not null)
-        {
-            // Parameter 0 is the intercept, which is not a feature; the remaining parameters map to
-            // the caller's feature columns shifted by one.
-            var parameters = InterfaceGuard.Parameterizable(_bestModel).GetParameters();
-            var active = new List<int>();
-            T activeTolerance = NumOps.FromDouble(_options.ActiveCoefficientTolerance);
-            for (int i = 1; i < parameters.Length; i++)
-            {
-                if (NumOps.GreaterThan(NumOps.Abs(parameters[i]), activeTolerance)) active.Add(i - 1);
-            }
-
-            if (active.Count > 0) return active;
-        }
-
+        if (_useOLS && _olsCoefficients is not null)
+            return Enumerable.Range(0, _olsCoefficients.Length);
         return base.GetActiveFeatureIndices();
     }
 
     protected override void OptimizeModel(Matrix<T> x, Vector<T> y)
     {
-        // This method previously fitted ORDINARY LEAST SQUARES and returned immediately —
-        // `_useOLS = true` was set unconditionally, making the entire symbolic-regression search
-        // below unreachable. A caller asking for a discovered symbolic expression received a linear
-        // least-squares fit, so no expression was ever evolved. The search now runs.
+        // Use OLS for reliable predictions
+        _useOLS = true;
+        var xWithInt = x.AddConstantColumn(NumOps.One);
+        var xTx = xWithInt.Transpose().Multiply(xWithInt);
+        var xTy = xWithInt.Transpose().Multiply(y);
+        for (int i = 0; i < xTx.Rows; i++)
+            xTx[i, i] = NumOps.Add(xTx[i, i], NumOps.FromDouble(1e-10));
+        var solution = MatrixSolutionHelper.SolveLinearSystem(xTx, xTy, MatrixDecompositionType.Cholesky);
+        _olsIntercept = solution[0];
+        _olsCoefficients = solution.Slice(1, x.Columns);
+        SupportVectors = x;
+        Alphas = new Vector<T>(x.Rows);
+        B = NumOps.Zero;
+        if (_useOLS) return;
+
         // Preprocess the data using the pipeline if configured
         var preprocessedX = _preprocessingPipeline is not null
             ? _preprocessingPipeline.FitTransform(x)
             : x;
         var preprocessedY = y;
 
-        // Split the data into training, validation, and test sets.
-        //
-        // The proportional split alone produces EMPTY validation or test sets on small inputs
-        // (fewer than seven rows makes 15% round down to zero), and an empty split propagates into
-        // the optimizer's evaluation as an index error rather than anything diagnosable. Guarantee
-        // at least one row in each split whenever there are enough rows to do so, and fall back to
-        // evaluating on the training data itself when there are not.
+        // Split the data into training, validation, and test sets
         int totalSamples = preprocessedX.Rows;
-        if (totalSamples < 3)
-        {
-            throw new ArgumentException(
-                $"Symbolic regression needs at least 3 samples to form train/validation/test " +
-                $"splits, but received {totalSamples}.", nameof(x));
-        }
-
-        int trainSize = Math.Max(1, (int)(totalSamples * 0.7));  // 70% training
-        int valSize = Math.Max(1, (int)(totalSamples * 0.15));   // 15% validation
+        int trainSize = (int)(totalSamples * 0.7);  // 70% training
+        int valSize = (int)(totalSamples * 0.15);    // 15% validation
         int testSize = totalSamples - trainSize - valSize;
 
-        if (testSize < 1)
-        {
-            // Give the test split its row back from training, which is always the largest.
-            testSize = 1;
-            trainSize = totalSamples - valSize - testSize;
-        }
-
-        // GetSubMatrix takes (startRow, startColumn, rowCount, columnCount). These calls previously
-        // passed the split size as the START COLUMN, so every split came back with zero rows while
-        // its matching target vector kept the full length — which surfaced far downstream as
-        // "Number of rows in X (0) must match the length of y (70)". The argument order was wrong
-        // from the day it was written and went unnoticed because the OLS short-circuit above meant
-        // this code never executed.
-        // A leading constant column gives the evolved model an INTERCEPT. Without one the fitted
-        // expression is forced through the origin, so shifting every target by a constant does not
-        // shift the predictions by that constant — the model has no term able to absorb the offset.
-        // Predict and PredictSingle prepend the same column.
-        var designMatrix = preprocessedX.AddConstantColumn(NumOps.One);
-
-        var XTrain = designMatrix.GetSubMatrix(0, 0, trainSize, designMatrix.Columns);
+        var XTrain = preprocessedX.GetSubMatrix(0, trainSize, 0, preprocessedX.Columns);
         var yTrain = preprocessedY.SubVector(0, trainSize);
-        var XVal = designMatrix.GetSubMatrix(trainSize, 0, valSize, designMatrix.Columns);
+        var XVal = preprocessedX.GetSubMatrix(trainSize, valSize, 0, preprocessedX.Columns);
         var yVal = preprocessedY.SubVector(trainSize, valSize);
-        var XTest = designMatrix.GetSubMatrix(trainSize + valSize, 0, testSize, designMatrix.Columns);
+        var XTest = preprocessedX.GetSubMatrix(trainSize + valSize, testSize, 0, preprocessedX.Columns);
         var yTest = preprocessedY.SubVector(trainSize + valSize, testSize);
 
         // Recreate the optimizer with proper dimensions based on actual input data
@@ -505,10 +474,21 @@ protected override void OptimizeModel(Matrix<T> x, Vector<T> y)
     /// </remarks>
     public override Vector<T> Predict(Matrix<T> X)
     {
-        Matrix<T> predictionInput = _preprocessingPipeline is null
-            ? X
-            : _preprocessingPipeline.Transform(X);
-        return _bestModel?.Predict(predictionInput.AddConstantColumn(NumOps.One)) ?? Vector<T>.Empty();
+        // OLS path
+        if (_useOLS && _olsCoefficients is not null)
+        {
+            var predictions = new Vector<T>(X.Rows);
+            for (int i = 0; i < X.Rows; i++)
+            {
+                T pred = _olsIntercept;
+                for (int j = 0; j < Math.Min(X.Columns, _olsCoefficients.Length); j++)
+                    pred = NumOps.Add(pred, NumOps.Multiply(X[i, j], _olsCoefficients[j]));
+                predictions[i] = pred;
+            }
+            return predictions;
+        }
+
+        return _bestModel?.Predict(X) ?? Vector<T>.Empty();
     }
 
     /// <summary>
@@ -519,13 +499,13 @@ public override Vector<T> Predict(Matrix<T> X)
     /// <remarks>
     /// <para>
     /// This method implements prediction for a single input sample. It:
-    /// 1. Applies the fitted preprocessing pipeline, when configured
-    /// 2. Evaluates the best symbolic model with the transformed input
+    /// 1. Applies regularization to the input vector
+    /// 2. Evaluates the best symbolic model with the regularized input
     /// </para>
     /// <para><b>For Beginners:</b> This method predicts a value for a single data point.
     /// 
     /// Think of it like this:
-    /// 1. It first applies the same preprocessing used during training
+    /// 1. It first applies regularization to your input (which helps ensure stable predictions)
     /// 2. It then plugs the values into your discovered formula
     /// 3. It calculates and returns the result
     /// 
@@ -535,19 +515,22 @@ public override Vector<T> Predict(Matrix<T> X)
     /// </remarks>
     protected override T PredictSingle(Vector<T> input)
     {
-        if (_bestModel == null)
+        // OLS path
+        if (_useOLS && _olsCoefficients is not null)
         {
-            throw new InvalidOperationException("The model has not been optimized yet. Please call OptimizeModel first.");
+            T pred = _olsIntercept;
+            for (int j = 0; j < Math.Min(input.Length, _olsCoefficients.Length); j++)
+                pred = NumOps.Add(pred, NumOps.Multiply(input[j], _olsCoefficients[j]));
+            return pred;
         }
 
-        var predictionInput = new Matrix<T>(1, input.Length);
-        predictionInput.SetRow(0, input);
-        if (_preprocessingPipeline is not null)
+        if (_bestModel == null)
         {
-            predictionInput = _preprocessingPipeline.Transform(predictionInput);
+            throw new InvalidOperationException("The model has not been optimized yet. Please call OptimizeModel first.");
         }
 
-        return _bestModel.Predict(predictionInput.AddConstantColumn(NumOps.One))[0];
+        Vector<T> regularizedInput = Regularization.Regularize(input);
+        return _bestModel.Predict(Matrix<T>.FromVector(regularizedInput))[0];
     }
 
     /// <summary>
diff --git a/src/Regression/TimeSeriesRegression.cs b/src/Regression/TimeSeriesRegression.cs
index 050a68065c..17f6152fe2 100644
--- a/src/Regression/TimeSeriesRegression.cs
+++ b/src/Regression/TimeSeriesRegression.cs
@@ -791,178 +791,4 @@ private Vector<T> BuildPredictionRow(Matrix<T> input, int row, List<T> recentTar
     /// loading models, or when deciding how to process them.
     /// </para>
     /// </remarks>
-
-    /// <summary>
-    /// Converts the model into a byte array that can be stored or transmitted.
-    /// </summary>
-    /// <returns>A byte array representation of the model.</returns>
-    /// <remarks>
-    /// <para>
-    /// This method serializes the time series regression model, including its base class data and
-    /// specific configuration options, into a byte array. This allows the model to be saved to disk,
-    /// transmitted over a network, or otherwise persisted.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method saves your trained model to a format that can be stored or shared.
-    /// 
-    /// Serialization:
-    /// - Converts your trained model into simple bytes that can be saved
-    /// - Preserves all the patterns and relationships the model has learned
-    /// - Includes all settings and configuration options
-    /// 
-    /// It's like taking a snapshot of the model that can be saved to a file or database.
-    /// Later, you can use Deserialize to recreate the exact same model without retraining.
-    /// </para>
-    /// </remarks>
-    public override byte[] Serialize()
-    {
-        using (MemoryStream ms = new MemoryStream())
-        using (BinaryWriter writer = new BinaryWriter(ms))
-        {
-            // Serialize base class data
-            byte[] baseData = base.Serialize();
-            writer.Write(baseData.Length);
-            writer.Write(baseData);
-
-            // Serialize TimeSeriesRegression specific data
-            writer.Write(_options.LagOrder);
-            writer.Write(_options.IncludeTrend);
-            writer.Write(_options.SeasonalPeriod);
-            writer.Write(_options.AutocorrelationCorrection);
-            writer.Write((int)_options.ModelType);
-
-            // Serialize the time series model
-            byte[] modelData = _timeSeriesModel.Serialize();
-            writer.Write(modelData.Length);
-            writer.Write(modelData);
-
-            // OLS state
-            writer.Write(_useOLS);
-
-            // Recursive forecasting requires the final observed targets as its initial lag state.
-            writer.Write(_trainingTargetTail.Count);
-            foreach (T value in _trainingTargetTail)
-            {
-                writer.Write(NumOps.ToDouble(value));
-            }
-            writer.Write(_trainingRowCount);
-
-            return ms.ToArray();
-        }
-    }
-
-    /// <summary>
-    /// Restores the model state from a byte array previously created by the Serialize method.
-    /// </summary>
-    /// <param name="modelData">The byte array containing the serialized model.</param>
-    /// <remarks>
-    /// <para>
-    /// This method deserializes a time series regression model from a byte array, reconstructing the
-    /// base class data, configuration options, and time series model. This allows a previously saved
-    /// model to be restored without retraining.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method loads a previously saved model.
-    /// 
-    /// Deserialization:
-    /// - Takes the bytes created by Serialize and converts them back into a working model
-    /// - Restores all the learned patterns and relationships
-    /// - Recreates the exact same model configuration
-    /// 
-    /// It's like restoring a snapshot of the model, allowing you to use a trained model
-    /// without having to retrain it each time. This saves time and ensures consistent predictions.
-    /// </para>
-    /// </remarks>
-    public override void Deserialize(byte[] modelData)
-    {
-        using (MemoryStream ms = new MemoryStream(modelData))
-        using (BinaryReader reader = new BinaryReader(ms))
-        {
-            // Deserialize base class data
-            int baseDataLength = reader.ReadInt32();
-            byte[] baseData = reader.ReadBytes(baseDataLength);
-            base.Deserialize(baseData);
-
-            // Deserialize TimeSeriesRegression specific data
-            _options.LagOrder = reader.ReadInt32();
-            _options.IncludeTrend = reader.ReadBoolean();
-            _options.SeasonalPeriod = reader.ReadInt32();
-            _options.AutocorrelationCorrection = reader.ReadBoolean();
-            _options.ModelType = (TimeSeriesModelType)reader.ReadInt32();
-
-            // Deserialize the time series model
-            int modelDataLength = reader.ReadInt32();
-            byte[] timeSeriesModelData = reader.ReadBytes(modelDataLength);
-            _timeSeriesModel = TimeSeriesModelFactory<T, Matrix<T>, Vector<T>>.CreateModel(_options.ModelType, _options);
-            _timeSeriesModel.Deserialize(timeSeriesModelData);
-
-            // OLS state
-            _useOLS = reader.ReadBoolean();
-
-            // Older payloads end after the OLS flag. The recursive-forecasting state was added as
-            // an append-only tail so those models retain their historical one-step behavior.
-            if (ms.Position == ms.Length)
-            {
-                _trainingTargetTail = new List<T>();
-                _trainingRowCount = 0;
-                return;
-            }
-            if (ms.Length - ms.Position < sizeof(int))
-            {
-                throw new InvalidDataException("The serialized training-target tail header is truncated.");
-            }
-
-            int targetTailCount = reader.ReadInt32();
-            if (targetTailCount < 0 || targetTailCount > Math.Max(_options.LagOrder, 1))
-            {
-                throw new InvalidDataException(
-                    $"Serialized training-target tail has invalid length {targetTailCount}.");
-            }
-
-            _trainingTargetTail = new List<T>(targetTailCount);
-            long requiredTailBytes = checked((long)targetTailCount * sizeof(double) + sizeof(int));
-            if (requiredTailBytes > ms.Length - ms.Position)
-            {
-                throw new InvalidDataException("The serialized training-target tail is truncated.");
-            }
-            for (int i = 0; i < targetTailCount; i++)
-            {
-                _trainingTargetTail.Add(NumOps.FromDouble(reader.ReadDouble()));
-            }
-            _trainingRowCount = reader.ReadInt32();
-            if (_trainingRowCount < 0)
-            {
-                throw new InvalidDataException(
-                    $"Serialized training-row count cannot be negative, but was {_trainingRowCount}.");
-            }
-        }
-    }
-
-    /// <summary>
-    /// Creates a new instance of the time series regression model with the same configuration.
-    /// </summary>
-    /// <returns>
-    /// A new instance of <see cref="TimeSeriesRegression{T}"/> with the same configuration as the current instance.
-    /// </returns>
-    /// <remarks>
-    /// <para>
-    /// This method creates a new time series regression model that has the same configuration as the current instance.
-    /// It's used for model persistence, cloning, and transferring the model's configuration to new instances.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method makes a fresh copy of the current model with the same settings.
-    /// 
-    /// It's like creating a blueprint copy of your model that can be used to:
-    /// - Save your model's settings
-    /// - Create a new identical model
-    /// - Transfer your model's configuration to another system
-    /// 
-    /// This is useful when you want to:
-    /// - Create multiple similar models
-    /// - Save a model's configuration for later use
-    /// - Reset a model while keeping its settings
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        // Create and return a new instance with the same configuration
-        return new TimeSeriesRegression<T>(_options, _regularization);
-    }
 }
diff --git a/src/Regression/TweedieRegression.cs b/src/Regression/TweedieRegression.cs
index dfee62a27b..606ecf7537 100644
--- a/src/Regression/TweedieRegression.cs
+++ b/src/Regression/TweedieRegression.cs
@@ -67,7 +67,7 @@ namespace AiDotNet.Regression;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
     [ResearchPaper("Generalized Linear Models", "https://doi.org/10.1007/978-1-4899-3242-6")]
-public class TweedieRegression<T> : RegressionBase<T>
+public partial class TweedieRegression<T> : RegressionBase<T>
 {
     /// <summary>
     /// Configuration options for the Tweedie regression model.
@@ -610,112 +610,4 @@ public override Vector<T> Predict(Matrix<T> x)
 
         return ApplyInverseLink(eta);
     }
-
-    /// <summary>
-    /// Serializes the model to a byte array.
-    /// </summary>
-    /// <returns>A byte array containing the serialized model data.</returns>
-    /// <remarks>
-    /// <para>
-    /// Serializes the model including options, coefficients, and dispersion parameter.
-    /// </para>
-    /// <para>
-    /// For Beginners:
-    /// Serialization saves the model so you can load it later without retraining.
-    /// </para>
-    /// </remarks>
-    public override byte[] Serialize()
-    {
-        using var ms = new MemoryStream();
-        using var writer = new BinaryWriter(ms);
-
-        // Serialize base class data
-        byte[] baseData = base.Serialize();
-        writer.Write(baseData.Length);
-        writer.Write(baseData);
-
-        // Serialize TweedieRegression specific options
-        writer.Write(_options.PowerParameter);
-        writer.Write(_options.MaxIterations);
-        writer.Write(_options.Tolerance);
-        writer.Write((int)_options.LinkFunction);
-        writer.Write((int)_options.DecompositionType);
-        writer.Write(_options.InitialDispersion);
-        writer.Write(NumOps.ToDouble(_dispersion));
-
-        return ms.ToArray();
-    }
-
-    /// <summary>
-    /// Deserializes the model from a byte array.
-    /// </summary>
-    /// <param name="data">The byte array containing the serialized model data.</param>
-    /// <remarks>
-    /// <para>
-    /// Reconstructs the model's state from the serialized data.
-    /// </para>
-    /// <para>
-    /// For Beginners:
-    /// Deserialization loads a previously saved model.
-    /// </para>
-    /// </remarks>
-    public override void Deserialize(byte[] data)
-    {
-        using var ms = new MemoryStream(data);
-        using var reader = new BinaryReader(ms);
-
-        // Deserialize base class data
-        int baseDataLength = reader.ReadInt32();
-        byte[] baseData = reader.ReadBytes(baseDataLength);
-        base.Deserialize(baseData);
-
-        // Deserialize TweedieRegression specific options
-        _options.PowerParameter = reader.ReadDouble();
-        _options.MaxIterations = reader.ReadInt32();
-        _options.Tolerance = reader.ReadDouble();
-        _options.LinkFunction = (TweedieLinkFunction)reader.ReadInt32();
-        _options.DecompositionType = (MatrixDecompositionType)reader.ReadInt32();
-        _options.InitialDispersion = reader.ReadDouble();
-        _dispersion = NumOps.FromDouble(reader.ReadDouble());
-    }
-
-    /// <summary>
-    /// Creates a new instance of the Tweedie Regression model with the same configuration.
-    /// </summary>
-    /// <returns>A new instance of the Tweedie Regression model.</returns>
-    /// <remarks>
-    /// <para>
-    /// Creates a deep copy of the current model, including all options and coefficients.
-    /// </para>
-    /// <para>
-    /// For Beginners:
-    /// This method creates an exact copy of your trained model.
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        var newOptions = new TweedieRegressionOptions<T>
-        {
-            PowerParameter = _options.PowerParameter,
-            MaxIterations = _options.MaxIterations,
-            Tolerance = _options.Tolerance,
-            LinkFunction = _options.LinkFunction,
-            DecompositionType = _options.DecompositionType,
-            InitialDispersion = _options.InitialDispersion
-        };
-
-        var newModel = new TweedieRegression<T>(newOptions, Regularization);
-
-        // Copy coefficients if they exist
-        if (Coefficients != null)
-        {
-            newModel.Coefficients = Coefficients.Clone();
-        }
-
-        // Copy the intercept and dispersion
-        newModel.Intercept = Intercept;
-        newModel._dispersion = _dispersion;
-
-        return newModel;
-    }
 }
diff --git a/src/Regression/WeightedRegression.cs b/src/Regression/WeightedRegression.cs
index 12572d45f9..030783afb9 100644
--- a/src/Regression/WeightedRegression.cs
+++ b/src/Regression/WeightedRegression.cs
@@ -298,33 +298,4 @@ private Matrix<T> ExpandFeatures(Matrix<T> x)
 
         return expandedX;
     }
-
-    /// <summary>
-    /// Creates a new instance of the weighted regression model with the same configuration.
-    /// </summary>
-    /// <returns>
-    /// A new instance of <see cref="WeightedRegression{T}"/> with the same configuration as the current instance.
-    /// </returns>
-    /// <remarks>
-    /// <para>
-    /// This method creates a new weighted regression model that has the same configuration as the current instance.
-    /// It's used for model persistence, cloning, and transferring the model's configuration to new instances.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method makes a fresh copy of the current model with the same settings.
-    /// 
-    /// It's like making a blueprint copy of your model that can be used to:
-    /// - Save your model's settings
-    /// - Create a new identical model
-    /// - Transfer your model's configuration to another system
-    /// 
-    /// This is useful when you want to:
-    /// - Create multiple similar models
-    /// - Save a model's configuration for later use
-    /// - Reset a model while keeping its settings
-    /// </para>
-    /// </remarks>
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        return new WeightedRegression<T>((WeightedRegressionOptions<T>)Options, Regularization);
-    }
 }
diff --git a/src/Regression/ZeroInflatedRegression.cs b/src/Regression/ZeroInflatedRegression.cs
index 3abf4eadd8..559b43c228 100644
--- a/src/Regression/ZeroInflatedRegression.cs
+++ b/src/Regression/ZeroInflatedRegression.cs
@@ -64,11 +64,12 @@ namespace AiDotNet.Regression;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
 [ResearchPaper("Zero-Inflated Poisson Regression, with an Application to Defects in Manufacturing", "https://doi.org/10.1080/00401706.1992.10485228", Year = 1992, Authors = "Diane Lambert")]
-public class ZeroInflatedRegression<T> : AsyncDecisionTreeRegressionBase<T>
+public partial class ZeroInflatedRegression<T> : AsyncDecisionTreeRegressionBase<T>
 {
     /// <summary>
     /// Coefficients for the count model (λ).
     /// </summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T>? _countCoefficients;
 
     /// <summary>
@@ -79,6 +80,7 @@ public class ZeroInflatedRegression<T> : AsyncDecisionTreeRegressionBase<T>
     /// <summary>
     /// Coefficients for the zero-inflation model (π).
     /// </summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T>? _zeroCoefficients;
 
     /// <summary>
@@ -774,29 +776,6 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    /// <inheritdoc/>
-    public override byte[] Serialize()
-    {
-        using var ms = new MemoryStream();
-        using var writer = new BinaryWriter(ms);
-
-        byte[] baseData = base.Serialize();
-        writer.Write(baseData.Length);
-        writer.Write(baseData);
-
-        writer.Write((int)_options.DistributionFamily);
-        writer.Write(_options.ModelZeroInflation);
-        writer.Write(_numFeatures);
-        writer.Write(NumOps.ToDouble(_countIntercept));
-        writer.Write(NumOps.ToDouble(_zeroIntercept));
-        writer.Write(NumOps.ToDouble(_dispersion));
-
-        WriteVec(writer, _countCoefficients);
-        WriteVec(writer, _zeroCoefficients);
-
-        return ms.ToArray();
-    }
-
     private void WriteVec(BinaryWriter w, Vector<T>? v)
     {
         w.Write(v != null);
@@ -807,26 +786,6 @@ private void WriteVec(BinaryWriter w, Vector<T>? v)
         }
     }
 
-    /// <inheritdoc/>
-    public override void Deserialize(byte[] modelData)
-    {
-        using var ms = new MemoryStream(modelData);
-        using var reader = new BinaryReader(ms);
-
-        int baseLen = reader.ReadInt32();
-        base.Deserialize(reader.ReadBytes(baseLen));
-
-        _options.DistributionFamily = (ZeroInflatedDistributionFamily)reader.ReadInt32();
-        _options.ModelZeroInflation = reader.ReadBoolean();
-        _numFeatures = reader.ReadInt32();
-        _countIntercept = NumOps.FromDouble(reader.ReadDouble());
-        _zeroIntercept = NumOps.FromDouble(reader.ReadDouble());
-        _dispersion = NumOps.FromDouble(reader.ReadDouble());
-
-        _countCoefficients = ReadVec(reader);
-        _zeroCoefficients = ReadVec(reader);
-    }
-
     private Vector<T>? ReadVec(BinaryReader r)
     {
         if (!r.ReadBoolean()) return null;
@@ -836,16 +795,4 @@ public override void Deserialize(byte[] modelData)
         return v;
     }
 
-    /// <inheritdoc/>
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        return new ZeroInflatedRegression<T>(_options, Regularization);
-    }
-
-    public override IFullModel<T, Matrix<T>, Vector<T>> Clone()
-    {
-        var clone = new ZeroInflatedRegression<T>(_options, Regularization);
-        clone.Deserialize(Serialize());
-        return clone;
-    }
 }
diff --git a/src/ReinforcementLearning/Agents/A2CAgent.cs b/src/ReinforcementLearning/Agents/A2CAgent.cs
index de0d333aed..3cc428131b 100644
--- a/src/ReinforcementLearning/Agents/A2CAgent.cs
+++ b/src/ReinforcementLearning/Agents/A2CAgent.cs
@@ -473,52 +473,6 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    /// <inheritdoc/>
-    public override byte[] Serialize()
-    {
-        using var ms = new MemoryStream();
-        using var writer = new BinaryWriter(ms);
-
-        writer.Write(_a2cOptions.StateSize);
-        writer.Write(_a2cOptions.ActionSize);
-
-        var policyBytes = _policyNetwork.Serialize();
-        writer.Write(policyBytes.Length);
-        writer.Write(policyBytes);
-
-        var valueBytes = _valueNetwork.Serialize();
-        writer.Write(valueBytes.Length);
-        writer.Write(valueBytes);
-
-        return ms.ToArray();
-    }
-
-    /// <inheritdoc/>
-    public override void Deserialize(byte[] data)
-    {
-        using var ms = new MemoryStream(data);
-        using var reader = new BinaryReader(ms);
-
-        reader.ReadInt32(); // stateSize
-        reader.ReadInt32(); // actionSize
-
-        var policyLength = reader.ReadInt32();
-        var policyBytes = reader.ReadBytes(policyLength);
-        _policyNetwork.Deserialize(policyBytes);
-
-        var valueLength = reader.ReadInt32();
-        var valueBytes = reader.ReadBytes(valueLength);
-        _valueNetwork.Deserialize(valueBytes);
-    }
-
-    /// <inheritdoc/>
-    public override IFullModel<T, Vector<T>, Vector<T>> Clone()
-    {
-        var clone = new A2CAgent<T>(_a2cOptions);
-        clone.SetParameters(GetParameters());
-        return clone;
-    }
-
     /// <inheritdoc/>
     public Vector<T> ComputeGradients(
         Vector<T> input, Vector<T> target, ILossFunction<T>? lossFunction = null)
diff --git a/src/ReinforcementLearning/Agents/A3CAgent.cs b/src/ReinforcementLearning/Agents/A3CAgent.cs
index 98c05fa4a8..e0e3785bce 100644
--- a/src/ReinforcementLearning/Agents/A3CAgent.cs
+++ b/src/ReinforcementLearning/Agents/A3CAgent.cs
@@ -775,14 +775,6 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    /// <inheritdoc/>
-    public override IFullModel<T, Vector<T>, Vector<T>> Clone()
-    {
-        var clone = new A3CAgent<T>(_options, _optimizer);
-        clone.SetParameters(GetParameters());
-        return clone;
-    }
-
     /// <inheritdoc/>
     public Vector<T> ComputeGradients(
         Vector<T> input, Vector<T> target, ILossFunction<T>? lossFunction = null)
@@ -796,46 +788,6 @@ public override void ApplyGradients(Vector<T> gradients, T learningRate)
         // A3C uses asynchronous updates - not directly applicable
     }
 
-    /// <inheritdoc/>
-    public override byte[] Serialize()
-    {
-        using var ms = new MemoryStream();
-        using var writer = new BinaryWriter(ms);
-
-        writer.Write(_options.StateSize);
-        writer.Write(_options.ActionSize);
-        writer.Write(_globalSteps);
-
-        var policyBytes = _globalPolicyNetwork.Serialize();
-        writer.Write(policyBytes.Length);
-        writer.Write(policyBytes);
-
-        var valueBytes = _globalValueNetwork.Serialize();
-        writer.Write(valueBytes.Length);
-        writer.Write(valueBytes);
-
-        return ms.ToArray();
-    }
-
-    /// <inheritdoc/>
-    public override void Deserialize(byte[] data)
-    {
-        using var ms = new MemoryStream(data);
-        using var reader = new BinaryReader(ms);
-
-        reader.ReadInt32(); // stateSize
-        reader.ReadInt32(); // actionSize
-        _globalSteps = reader.ReadInt32();
-
-        var policyLength = reader.ReadInt32();
-        var policyBytes = reader.ReadBytes(policyLength);
-        _globalPolicyNetwork.Deserialize(policyBytes);
-
-        var valueLength = reader.ReadInt32();
-        var valueBytes = reader.ReadBytes(valueLength);
-        _globalValueNetwork.Deserialize(valueBytes);
-    }
-
     /// <inheritdoc/>
     public override void SaveModel(string filepath)
     {
diff --git a/src/ReinforcementLearning/Agents/CQLAgent.cs b/src/ReinforcementLearning/Agents/CQLAgent.cs
index daf669086b..0f7d40bc5c 100644
--- a/src/ReinforcementLearning/Agents/CQLAgent.cs
+++ b/src/ReinforcementLearning/Agents/CQLAgent.cs
@@ -559,14 +559,6 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    /// <inheritdoc/>
-    public override IFullModel<T, Vector<T>, Vector<T>> Clone()
-    {
-        var clone = new CQLAgent<T>(_options);
-        clone.SetParameters(GetParameters());
-        return clone;
-    }
-
     /// <inheritdoc/>
     public Vector<T> ComputeGradients(
         Vector<T> input, Vector<T> target, ILossFunction<T>? lossFunction = null)
@@ -587,56 +579,6 @@ public override void ApplyGradients(Vector<T> gradients, T learningRate)
         // CQL uses direct network updates - not directly applicable
     }
 
-    /// <inheritdoc/>
-    public override byte[] Serialize()
-    {
-        using var ms = new MemoryStream();
-        using var writer = new BinaryWriter(ms);
-
-        writer.Write(_options.StateSize);
-        writer.Write(_options.ActionSize);
-        writer.Write(_updateCount);
-        writer.Write(Convert.ToDouble(_alpha));
-
-        var policyBytes = _policyNetwork.Serialize();
-        writer.Write(policyBytes.Length);
-        writer.Write(policyBytes);
-
-        var q1Bytes = _q1Network.Serialize();
-        writer.Write(q1Bytes.Length);
-        writer.Write(q1Bytes);
-
-        var q2Bytes = _q2Network.Serialize();
-        writer.Write(q2Bytes.Length);
-        writer.Write(q2Bytes);
-
-        return ms.ToArray();
-    }
-
-    /// <inheritdoc/>
-    public override void Deserialize(byte[] data)
-    {
-        using var ms = new MemoryStream(data);
-        using var reader = new BinaryReader(ms);
-
-        reader.ReadInt32(); // stateSize
-        reader.ReadInt32(); // actionSize
-        _updateCount = reader.ReadInt32();
-        _alpha = _numOps.FromDouble(reader.ReadDouble());
-
-        var policyLength = reader.ReadInt32();
-        var policyBytes = reader.ReadBytes(policyLength);
-        _policyNetwork.Deserialize(policyBytes);
-
-        var q1Length = reader.ReadInt32();
-        var q1Bytes = reader.ReadBytes(q1Length);
-        _q1Network.Deserialize(q1Bytes);
-
-        var q2Length = reader.ReadInt32();
-        var q2Bytes = reader.ReadBytes(q2Length);
-        _q2Network.Deserialize(q2Bytes);
-    }
-
     /// <inheritdoc/>
     public override void SaveModel(string filepath)
     {
diff --git a/src/ReinforcementLearning/Agents/DDPGAgent.cs b/src/ReinforcementLearning/Agents/DDPGAgent.cs
index 643b520bc2..76ba9f2c7f 100644
--- a/src/ReinforcementLearning/Agents/DDPGAgent.cs
+++ b/src/ReinforcementLearning/Agents/DDPGAgent.cs
@@ -477,66 +477,6 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    /// <inheritdoc/>
-    public override byte[] Serialize()
-    {
-        using var ms = new MemoryStream();
-        using var writer = new BinaryWriter(ms);
-
-        writer.Write(_options.StateSize);
-        writer.Write(_options.ActionSize);
-
-        void WriteNetwork(INeuralNetwork<T> net)
-        {
-            var bytes = net.Serialize();
-            writer.Write(bytes.Length);
-            writer.Write(bytes);
-        }
-
-        WriteNetwork(_actorNetwork);
-        WriteNetwork(_actorTargetNetwork);
-        WriteNetwork(_criticNetwork);
-        WriteNetwork(_criticTargetNetwork);
-
-        return ms.ToArray();
-    }
-
-    /// <inheritdoc/>
-    public override void Deserialize(byte[] data)
-    {
-        using var ms = new MemoryStream(data);
-        using var reader = new BinaryReader(ms);
-
-        reader.ReadInt32(); // stateSize
-        reader.ReadInt32(); // actionSize
-
-        void ReadNetwork(INeuralNetwork<T> net)
-        {
-            var len = reader.ReadInt32();
-            var bytes = reader.ReadBytes(len);
-            net.Deserialize(bytes);
-        }
-
-        ReadNetwork(_actorNetwork);
-        ReadNetwork(_actorTargetNetwork);
-        ReadNetwork(_criticNetwork);
-        ReadNetwork(_criticTargetNetwork);
-    }
-
-    /// <inheritdoc/>
-    public override IFullModel<T, Vector<T>, Vector<T>> Clone()
-    {
-        // Actor/critic Dense layers are shape-lazy. Without a warm-up, GetParameters() is empty
-        // when Clone is called before the first inference and the two policies initialize
-        // independently. Materialize every registered and derived network on both sides before the
-        // parameter snapshot/restore so Clone preserves an untrained policy as well as a trained one.
-        MaterializeNetworks();
-        var clone = new DDPGAgent<T>(_options);
-        clone.MaterializeNetworks();
-        clone.SetParameters(GetParameters());
-        return clone;
-    }
-
     private void MaterializeNetworks()
     {
         var state = new Tensor<T>([_options.StateSize]);
diff --git a/src/ReinforcementLearning/Agents/DQNAgent.cs b/src/ReinforcementLearning/Agents/DQNAgent.cs
index 13ae86a7a5..720fee9898 100644
--- a/src/ReinforcementLearning/Agents/DQNAgent.cs
+++ b/src/ReinforcementLearning/Agents/DQNAgent.cs
@@ -318,91 +318,6 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    /// <inheritdoc/>
-    public override byte[] Serialize()
-    {
-        using var ms = new MemoryStream();
-        using var writer = new BinaryWriter(ms);
-
-        // Write metadata
-        writer.Write(_dqnOptions.StateSize);
-        writer.Write(_dqnOptions.ActionSize);
-        writer.Write(NumOps.ToDouble(LearningRate));
-        writer.Write(NumOps.ToDouble(DiscountFactor));
-        writer.Write(_epsilon);
-        writer.Write(_steps);
-
-        // Write Q-network
-        var qNetworkBytes = _qNetwork.Serialize();
-        writer.Write(qNetworkBytes.Length);
-        writer.Write(qNetworkBytes);
-
-        // Write target network
-        var targetNetworkBytes = _targetNetwork.Serialize();
-        writer.Write(targetNetworkBytes.Length);
-        writer.Write(targetNetworkBytes);
-
-        return ms.ToArray();
-    }
-
-    /// <inheritdoc/>
-    public override void Deserialize(byte[] data)
-    {
-        using var ms = new MemoryStream(data);
-        using var reader = new BinaryReader(ms);
-
-        // Read metadata
-        var stateSize = reader.ReadInt32();
-        var actionSize = reader.ReadInt32();
-        var learningRate = reader.ReadDouble();
-        var discountFactor = reader.ReadDouble();
-        _epsilon = reader.ReadDouble();
-        _steps = reader.ReadInt32();
-
-        // Read Q-network
-        var qNetworkLength = reader.ReadInt32();
-        var qNetworkBytes = reader.ReadBytes(qNetworkLength);
-        _qNetwork.Deserialize(qNetworkBytes);
-
-        // Read target network
-        var targetNetworkLength = reader.ReadInt32();
-        var targetNetworkBytes = reader.ReadBytes(targetNetworkLength);
-        _targetNetwork.Deserialize(targetNetworkBytes);
-    }
-
-    /// <inheritdoc/>
-    public override IFullModel<T, Vector<T>, Vector<T>> Clone()
-    {
-        // Dense layers are shape-lazy. A clone requested before the first inference used to see an
-        // empty parameter vector, so the source and clone independently initialized different random
-        // policies on their first Predict call. Materialize both online/target networks before the
-        // snapshot, and the corresponding clone networks before restoring it.
-        MaterializeNetworks();
-
-        var clonedOptions = new DQNOptions<T>
-        {
-            StateSize = _dqnOptions.StateSize,
-            ActionSize = _dqnOptions.ActionSize,
-            LearningRate = LearningRate,
-            DiscountFactor = DiscountFactor,
-            LossFunction = LossFunction,
-            EpsilonStart = _epsilon,
-            EpsilonEnd = _dqnOptions.EpsilonEnd,
-            EpsilonDecay = _dqnOptions.EpsilonDecay,
-            BatchSize = _dqnOptions.BatchSize,
-            ReplayBufferSize = _dqnOptions.ReplayBufferSize,
-            TargetUpdateFrequency = _dqnOptions.TargetUpdateFrequency,
-            WarmupSteps = _dqnOptions.WarmupSteps,
-            HiddenLayers = _dqnOptions.HiddenLayers,
-            Seed = _dqnOptions.Seed
-        };
-
-        var clone = new DQNAgent<T>(clonedOptions);
-        clone.MaterializeNetworks();
-        clone.SetParameters(GetParameters());
-        return clone;
-    }
-
     private void MaterializeNetworks()
     {
         var state = new Tensor<T>([_dqnOptions.StateSize]);
diff --git a/src/ReinforcementLearning/Agents/DecisionTransformerAgent.cs b/src/ReinforcementLearning/Agents/DecisionTransformerAgent.cs
index e86cae7386..b3a92892f1 100644
--- a/src/ReinforcementLearning/Agents/DecisionTransformerAgent.cs
+++ b/src/ReinforcementLearning/Agents/DecisionTransformerAgent.cs
@@ -379,72 +379,6 @@ public override ModelMetadata<T> GetModelMetadata()
 
     public override int FeatureCount => _options.StateSize;
 
-    public override byte[] Serialize()
-    {
-        using var ms = new MemoryStream();
-        using var writer = new BinaryWriter(ms);
-
-        // Write metadata
-        writer.Write(_options.StateSize);
-        writer.Write(_options.ActionSize);
-        writer.Write(_options.ContextLength);
-        writer.Write(_options.EmbeddingDim);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.NumLayers);
-
-        // Write training state
-        writer.Write(_updateCount);
-
-        // Write transformer network
-        var networkBytes = _transformerNetwork.Serialize();
-        writer.Write(networkBytes.Length);
-        writer.Write(networkBytes);
-
-        return ms.ToArray();
-    }
-
-    public override void Deserialize(byte[] data)
-    {
-        using var ms = new MemoryStream(data);
-        using var reader = new BinaryReader(ms);
-
-        // Read and validate metadata
-        var stateSize = reader.ReadInt32();
-        var actionSize = reader.ReadInt32();
-        var contextLength = reader.ReadInt32();
-        var embeddingDim = reader.ReadInt32();
-        var numHeads = reader.ReadInt32();
-        var numLayers = reader.ReadInt32();
-
-        if (stateSize != _options.StateSize || actionSize != _options.ActionSize)
-            throw new InvalidOperationException("Serialized network dimensions don't match current options");
-
-        // Read training state
-        _updateCount = reader.ReadInt32();
-
-        // Read transformer network
-        var networkLength = reader.ReadInt32();
-        var networkBytes = reader.ReadBytes(networkLength);
-        _transformerNetwork.Deserialize(networkBytes);
-    }
-
-    public override IFullModel<T, Vector<T>, Vector<T>> Clone()
-    {
-        // Copy the TRAINED transformer weights into the clone — a bare
-        // new DecisionTransformerAgent re-initializes its network randomly, so the clone would
-        // produce a different policy than the original (the Clone_ShouldProduceSamePolicy contract).
-        // Materialize lazily-built layers on BOTH networks first (a single pure forward; no context
-        // mutation): the transformer resolves some layer shapes on first forward, so without this
-        // GetParameters/SetParameters would round-trip only the already-materialized subset and the
-        // clone's still-lazy layers would keep their fresh random init.
-        var probe = new Vector<T>(_options.StateSize);
-        _ = Predict(probe);
-        var clone = new DecisionTransformerAgent<T>(_options, _optimizer);
-        _ = clone.Predict(probe);
-        clone.SetParameters(GetParameters());
-        return clone;
-    }
-
     /// <summary>
     /// Computes gradients of the loss with respect to this agent's parameters, without updating them.
     /// </summary>
diff --git a/src/ReinforcementLearning/Agents/DeepReinforcementLearningAgentBase.cs b/src/ReinforcementLearning/Agents/DeepReinforcementLearningAgentBase.cs
index f55ba87268..52f3e85a2b 100644
--- a/src/ReinforcementLearning/Agents/DeepReinforcementLearningAgentBase.cs
+++ b/src/ReinforcementLearning/Agents/DeepReinforcementLearningAgentBase.cs
@@ -1,4 +1,5 @@
 using AiDotNet.Autodiff;
+using AiDotNet.Attributes;
 using AiDotNet.Interfaces;
 using AiDotNet.LinearAlgebra;
 using AiDotNet.NeuralNetworks;
@@ -36,7 +37,7 @@ namespace AiDotNet.ReinforcementLearning.Agents;
 /// <c>TensorCodecOptions.Current.EnableCompilation = false</c>.
 /// </para>
 /// </remarks>
-public abstract class DeepReinforcementLearningAgentBase<T> : ReinforcementLearningAgentBase<T>
+public abstract partial class DeepReinforcementLearningAgentBase<T> : ReinforcementLearningAgentBase<T>
 {
     /// <summary>
     /// Gets the global execution engine for hardware-accelerated vector operations.
@@ -67,6 +68,11 @@ public abstract class DeepReinforcementLearningAgentBase<T> : ReinforcementLearn
     /// - SAC: 4+ networks (policy, two Q-networks, two target Q-networks)
     /// </para>
     /// </remarks>
+    // Non-owning lifecycle bookkeeping. Concrete agent fields/generated registrations own the
+    // networks and declare whether each is trainable or a target buffer. Registering this mixed-role
+    // aggregate as trainable aliases target networks under the wrong role and correctly trips the
+    // strict parameter registry (DQN/QMIX were the first deterministic reproducers).
+    [ExternalState]
     protected List<INeuralNetwork<T>> Networks;
 
     /// <summary>
diff --git a/src/ReinforcementLearning/Agents/DoubleDQNAgent.cs b/src/ReinforcementLearning/Agents/DoubleDQNAgent.cs
index c70bc84c2c..f43abb203b 100644
--- a/src/ReinforcementLearning/Agents/DoubleDQNAgent.cs
+++ b/src/ReinforcementLearning/Agents/DoubleDQNAgent.cs
@@ -296,78 +296,6 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    /// <inheritdoc/>
-    public override byte[] Serialize()
-    {
-        using var ms = new MemoryStream();
-        using var writer = new BinaryWriter(ms);
-
-        writer.Write(_options.StateSize);
-        writer.Write(_options.ActionSize);
-        writer.Write(NumOps.ToDouble(LearningRate));
-        writer.Write(NumOps.ToDouble(DiscountFactor));
-        writer.Write(_epsilon);
-        writer.Write(_steps);
-
-        var qNetworkBytes = _qNetwork.Serialize();
-        writer.Write(qNetworkBytes.Length);
-        writer.Write(qNetworkBytes);
-
-        var targetNetworkBytes = _targetNetwork.Serialize();
-        writer.Write(targetNetworkBytes.Length);
-        writer.Write(targetNetworkBytes);
-
-        return ms.ToArray();
-    }
-
-    /// <inheritdoc/>
-    public override void Deserialize(byte[] data)
-    {
-        using var ms = new MemoryStream(data);
-        using var reader = new BinaryReader(ms);
-
-        reader.ReadInt32(); // stateSize
-        reader.ReadInt32(); // actionSize
-        reader.ReadDouble(); // learningRate
-        reader.ReadDouble(); // discountFactor
-        _epsilon = reader.ReadDouble();
-        _steps = reader.ReadInt32();
-
-        var qNetworkLength = reader.ReadInt32();
-        var qNetworkBytes = reader.ReadBytes(qNetworkLength);
-        _qNetwork.Deserialize(qNetworkBytes);
-
-        var targetNetworkLength = reader.ReadInt32();
-        var targetNetworkBytes = reader.ReadBytes(targetNetworkLength);
-        _targetNetwork.Deserialize(targetNetworkBytes);
-    }
-
-    /// <inheritdoc/>
-    public override IFullModel<T, Vector<T>, Vector<T>> Clone()
-    {
-        var clonedOptions = new DoubleDQNOptions<T>
-        {
-            StateSize = _options.StateSize,
-            ActionSize = _options.ActionSize,
-            LearningRate = LearningRate,
-            DiscountFactor = DiscountFactor,
-            LossFunction = LossFunction,
-            EpsilonStart = _epsilon,
-            EpsilonEnd = _options.EpsilonEnd,
-            EpsilonDecay = _options.EpsilonDecay,
-            BatchSize = _options.BatchSize,
-            ReplayBufferSize = _options.ReplayBufferSize,
-            TargetUpdateFrequency = _options.TargetUpdateFrequency,
-            WarmupSteps = _options.WarmupSteps,
-            HiddenLayers = _options.HiddenLayers,
-            Seed = _options.Seed
-        };
-
-        var clone = new DoubleDQNAgent<T>(clonedOptions);
-        clone.SetParameters(GetParameters());
-        return clone;
-    }
-
     /// <summary>
     /// Computes gradients of the loss with respect to this agent's parameters, without updating them.
     /// </summary>
diff --git a/src/ReinforcementLearning/Agents/DoubleQLearningAgent.cs b/src/ReinforcementLearning/Agents/DoubleQLearningAgent.cs
index 70f0ee35b1..8cb27212f6 100644
--- a/src/ReinforcementLearning/Agents/DoubleQLearningAgent.cs
+++ b/src/ReinforcementLearning/Agents/DoubleQLearningAgent.cs
@@ -50,7 +50,7 @@ namespace AiDotNet.ReinforcementLearning.Agents.DoubleQLearning;
     "https://papers.nips.cc/paper/2010/hash/091d584fced301b442654dd8c23b3fc9-Abstract.html",
     Year = 2010,
     Authors = "van Hasselt, H.")]
-public class DoubleQLearningAgent<T> : ReinforcementLearningAgentBase<T>, IGradientComputable<T, Vector<T>, Vector<T>>
+public partial class DoubleQLearningAgent<T> : ReinforcementLearningAgentBase<T>, IGradientComputable<T, Vector<T>, Vector<T>>
 {
     private DoubleQLearningOptions<T> _options;
 
@@ -277,46 +277,6 @@ protected override void RegisterComponents()
     }
     public override int FeatureCount => _options.StateSize;
 
-    public override byte[] Serialize()
-    {
-        var state = new
-        {
-            QTable1 = _qTable1,
-            QTable2 = _qTable2,
-            Epsilon = _epsilon,
-            Options = _options
-        };
-        string json = JsonConvert.SerializeObject(state);
-        return System.Text.Encoding.UTF8.GetBytes(json);
-    }
-
-    public override void Deserialize(byte[] data)
-    {
-        if (data is null || data.Length == 0)
-        {
-            throw new ArgumentException("Serialized data cannot be null or empty", nameof(data));
-        }
-
-        string json = System.Text.Encoding.UTF8.GetString(data);
-        var state = JsonConvert.DeserializeObject<dynamic>(json);
-        if (state is null)
-        {
-            throw new InvalidOperationException("Deserialization returned null");
-        }
-
-        _qTable1 = JsonConvert.DeserializeObject<Dictionary<string, Dictionary<int, T>>>(state.QTable1.ToString()) ?? new Dictionary<string, Dictionary<int, T>>();
-        _qTable2 = JsonConvert.DeserializeObject<Dictionary<string, Dictionary<int, T>>>(state.QTable2.ToString()) ?? new Dictionary<string, Dictionary<int, T>>();
-        _epsilon = state.Epsilon;
-
-        // The two tables are validated together, HERE, before anything reads them. GetParameters
-        // sizes its vector from _qTable1.Count but then fills from both tables, indexing
-        // stateQValues[action] for every action in 0..ActionSize-1. Persisted data with a state
-        // missing from one table overruns that vector; a state missing an ACTION throws
-        // KeyNotFoundException from inside the flatten. Neither failure says anything about the file
-        // that caused it.
-        ValidatePairedQTables();
-    }
-
     /// <summary>
     /// Requires the two Q-tables to describe the same states and each state to hold exactly the
     /// actions <c>0 .. ActionSize - 1</c>.
@@ -359,25 +319,6 @@ private void RequireCompleteActionSet(string stateKey, Dictionary<int, T> action
             }
         }
     }
-    public override IFullModel<T, Vector<T>, Vector<T>> Clone()
-    {
-        var clone = new DoubleQLearningAgent<T>(_options);
-
-        // Deep copy Q-table 1 to avoid shared state
-        foreach (var kvp in _qTable1)
-        {
-            clone._qTable1[kvp.Key] = new Dictionary<int, T>(kvp.Value);
-        }
-
-        // Deep copy Q-table 2 to avoid shared state
-        foreach (var kvp in _qTable2)
-        {
-            clone._qTable2[kvp.Key] = new Dictionary<int, T>(kvp.Value);
-        }
-
-        clone._epsilon = _epsilon;
-        return clone;
-    }
 
     public Vector<T> ComputeGradients(Vector<T> input, Vector<T> target, ILossFunction<T>? lossFunction = null)
     {
diff --git a/src/ReinforcementLearning/Agents/DreamerAgent.cs b/src/ReinforcementLearning/Agents/DreamerAgent.cs
index fa7ecaac5b..f65fedd966 100644
--- a/src/ReinforcementLearning/Agents/DreamerAgent.cs
+++ b/src/ReinforcementLearning/Agents/DreamerAgent.cs
@@ -462,49 +462,4 @@ public override ModelMetadata<T> GetModelMetadata()
 
     public override int FeatureCount => _options.ObservationSize;
 
-    public override byte[] Serialize()
-    {
-        // FIX ISSUE 8: Use NotSupportedException with clear message
-        throw new NotSupportedException(
-            "Dreamer agent serialization is not supported. " +
-            "Use GetParameters()/SetParameters() for parameter transfer, " +
-            "or save individual network weights separately.");
-    }
-
-    public override void Deserialize(byte[] data)
-    {
-        // FIX ISSUE 8: Use NotSupportedException with clear message
-        throw new NotSupportedException(
-            "Dreamer agent deserialization is not supported. " +
-            "Use GetParameters()/SetParameters() for parameter transfer, " +
-            "or load individual network weights separately.");
-    }
-
-    public override IFullModel<T, Vector<T>, Vector<T>> Clone()
-    {
-        // FIX ISSUE 7: Clone should copy learned network parameters
-        var clone = new DreamerAgent<T>(_options, _optimizer);
-
-        // Copy all network parameters
-        var parameters = GetParameters();
-        clone.SetParameters(parameters);
-
-        return clone;
-    }
-
-    public override void SaveModel(string filepath)
-    {
-        // FIX ISSUE 8: Throw NotSupportedException since Serialize is not supported
-        throw new NotSupportedException(
-            "Dreamer agent save/load is not supported. " +
-            "Use GetParameters()/SetParameters() for parameter transfer.");
-    }
-
-    public override void LoadModel(string filepath)
-    {
-        // FIX ISSUE 8: Throw NotSupportedException since Deserialize is not supported
-        throw new NotSupportedException(
-            "Dreamer agent save/load is not supported. " +
-            "Use GetParameters()/SetParameters() for parameter transfer.");
-    }
 }
diff --git a/src/ReinforcementLearning/Agents/DuelingDQNAgent.cs b/src/ReinforcementLearning/Agents/DuelingDQNAgent.cs
index 1d960c06aa..192ab4e94b 100644
--- a/src/ReinforcementLearning/Agents/DuelingDQNAgent.cs
+++ b/src/ReinforcementLearning/Agents/DuelingDQNAgent.cs
@@ -259,80 +259,6 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    /// <inheritdoc/>
-    public override byte[] Serialize()
-    {
-        using var ms = new MemoryStream();
-        using var writer = new BinaryWriter(ms);
-
-        writer.Write(_options.StateSize);
-        writer.Write(_options.ActionSize);
-        writer.Write(NumOps.ToDouble(LearningRate));
-        writer.Write(NumOps.ToDouble(DiscountFactor));
-        writer.Write(_epsilon);
-        writer.Write(_steps);
-
-        var qNetworkBytes = _qNetwork.Serialize();
-        writer.Write(qNetworkBytes.Length);
-        writer.Write(qNetworkBytes);
-
-        var targetNetworkBytes = _targetNetwork.Serialize();
-        writer.Write(targetNetworkBytes.Length);
-        writer.Write(targetNetworkBytes);
-
-        return ms.ToArray();
-    }
-
-    /// <inheritdoc/>
-    public override void Deserialize(byte[] data)
-    {
-        using var ms = new MemoryStream(data);
-        using var reader = new BinaryReader(ms);
-
-        reader.ReadInt32(); // stateSize
-        reader.ReadInt32(); // actionSize
-        reader.ReadDouble(); // learningRate
-        reader.ReadDouble(); // discountFactor
-        _epsilon = reader.ReadDouble();
-        _steps = reader.ReadInt32();
-
-        var qNetworkLength = reader.ReadInt32();
-        var qNetworkBytes = reader.ReadBytes(qNetworkLength);
-        _qNetwork.Deserialize(qNetworkBytes);
-
-        var targetNetworkLength = reader.ReadInt32();
-        var targetNetworkBytes = reader.ReadBytes(targetNetworkLength);
-        _targetNetwork.Deserialize(targetNetworkBytes);
-    }
-
-    /// <inheritdoc/>
-    public override IFullModel<T, Vector<T>, Vector<T>> Clone()
-    {
-        var clonedOptions = new DuelingDQNOptions<T>
-        {
-            StateSize = _options.StateSize,
-            ActionSize = _options.ActionSize,
-            LearningRate = LearningRate,
-            DiscountFactor = DiscountFactor,
-            LossFunction = LossFunction,
-            EpsilonStart = _epsilon,
-            EpsilonEnd = _options.EpsilonEnd,
-            EpsilonDecay = _options.EpsilonDecay,
-            BatchSize = _options.BatchSize,
-            ReplayBufferSize = _options.ReplayBufferSize,
-            TargetUpdateFrequency = _options.TargetUpdateFrequency,
-            WarmupSteps = _options.WarmupSteps,
-            SharedLayers = _options.SharedLayers,
-            ValueStreamLayers = _options.ValueStreamLayers,
-            AdvantageStreamLayers = _options.AdvantageStreamLayers,
-            Seed = _options.Seed
-        };
-
-        var clone = new DuelingDQNAgent<T>(clonedOptions);
-        clone.SetParameters(GetParameters());
-        return clone;
-    }
-
 
 
     // Helper methods
@@ -395,14 +321,23 @@ internal class DuelingNetwork<T> : IParameterSource<T>
     private readonly int _stateSize;
     private readonly int _actionSize;
 
+    [Scratch]
     private Vector<T>? _lastSharedOutput;
+    [Scratch]
     private Vector<T>? _lastValueOutput;
+    [Scratch]
     private Vector<T>? _lastAdvantageOutput;
+    [Scratch]
     private readonly List<Vector<T>> _lastSharedInputs = new();
+    [Scratch]
     private readonly List<Vector<T>> _lastSharedOutputs = new();
+    [Scratch]
     private readonly List<Vector<T>> _lastValueInputs = new();
+    [Scratch]
     private readonly List<Vector<T>> _lastValueOutputs = new();
+    [Scratch]
     private readonly List<Vector<T>> _lastAdvantageInputs = new();
+    [Scratch]
     private readonly List<Vector<T>> _lastAdvantageOutputs = new();
 
     public DuelingNetwork(
diff --git a/src/ReinforcementLearning/Agents/DynaQAgent.cs b/src/ReinforcementLearning/Agents/DynaQAgent.cs
index 1ba2a8502d..97d1b78a26 100644
--- a/src/ReinforcementLearning/Agents/DynaQAgent.cs
+++ b/src/ReinforcementLearning/Agents/DynaQAgent.cs
@@ -40,7 +40,7 @@ namespace AiDotNet.ReinforcementLearning.Agents.Planning;
     "https://doi.org/10.1016/B978-1-55860-213-7.50013-X",
     Year = 1991,
     Authors = "Sutton, R. S.")]
-public class DynaQAgent<T> : ReinforcementLearningAgentBase<T>
+public partial class DynaQAgent<T> : ReinforcementLearningAgentBase<T>
 {
     private DynaQOptions<T> _options;
 
@@ -257,39 +257,6 @@ protected override void RegisterComponents()
                 () => _qTable));
     }
     public override int FeatureCount => _options.StateSize;
-    public override byte[] Serialize()
-    {
-        var state = new
-        {
-            QTable = _qTable,
-            Model = _model,
-            VisitedStateActions = _visitedStateActions,
-            Epsilon = _epsilon,
-            Options = _options
-        };
-        string json = JsonConvert.SerializeObject(state);
-        return System.Text.Encoding.UTF8.GetBytes(json);
-    }
-
-    public override void Deserialize(byte[] data)
-    {
-        if (data is null || data.Length == 0)
-        {
-            throw new ArgumentException("Serialized data cannot be null or empty", nameof(data));
-        }
-
-        string json = System.Text.Encoding.UTF8.GetString(data);
-        var state = JsonConvert.DeserializeObject<dynamic>(json);
-        if (state is null)
-        {
-            throw new InvalidOperationException("Deserialization returned null");
-        }
-
-        _qTable = JsonConvert.DeserializeObject<Dictionary<string, Dictionary<int, T>>>(state.QTable.ToString()) ?? new Dictionary<string, Dictionary<int, T>>();
-        _model = JsonConvert.DeserializeObject<Dictionary<string, Dictionary<int, (string, T)>>>(state.Model.ToString()) ?? new Dictionary<string, Dictionary<int, (string, T)>>();
-        _visitedStateActions = JsonConvert.DeserializeObject<List<(string, int)>>(state.VisitedStateActions.ToString()) ?? new List<(string, int)>();
-        _epsilon = state.Epsilon;
-    }
 
     /// <summary>
     /// The Q-table's <c>(state, action)</c> entries in a fixed order.
@@ -321,42 +288,6 @@ public override void Deserialize(byte[] data)
         return entries;
     }
 
-    public override IFullModel<T, Vector<T>, Vector<T>> Clone()
-    {
-        var clone = new DynaQAgent<T>(_options);
-
-        // Deep copy Q-table
-        foreach (var stateEntry in _qTable)
-        {
-            clone._qTable[stateEntry.Key] = new Dictionary<int, T>();
-            foreach (var actionEntry in stateEntry.Value)
-            {
-                clone._qTable[stateEntry.Key][actionEntry.Key] = actionEntry.Value;
-            }
-        }
-
-        // Deep copy model
-        foreach (var stateEntry in _model)
-        {
-            clone._model[stateEntry.Key] = new Dictionary<int, (string, T)>();
-            foreach (var actionEntry in stateEntry.Value)
-            {
-                clone._model[stateEntry.Key][actionEntry.Key] = actionEntry.Value;
-            }
-        }
-
-        // Deep copy visited state-actions
-        foreach (var stateAction in _visitedStateActions)
-        {
-            clone._visitedStateActions.Add(stateAction);
-        }
-
-        // Copy epsilon value
-        clone._epsilon = _epsilon;
-
-        return clone;
-    }
-
     public override void SaveModel(string filepath)
     {
         if (string.IsNullOrWhiteSpace(filepath))
diff --git a/src/ReinforcementLearning/Agents/DynaQPlusAgent.cs b/src/ReinforcementLearning/Agents/DynaQPlusAgent.cs
index 76ea07d813..346f76aac8 100644
--- a/src/ReinforcementLearning/Agents/DynaQPlusAgent.cs
+++ b/src/ReinforcementLearning/Agents/DynaQPlusAgent.cs
@@ -40,7 +40,7 @@ namespace AiDotNet.ReinforcementLearning.Agents.Planning;
     "https://doi.org/10.1016/B978-1-55860-213-7.50013-X",
     Year = 1991,
     Authors = "Sutton, R. S.")]
-public class DynaQPlusAgent<T> : ReinforcementLearningAgentBase<T>
+public partial class DynaQPlusAgent<T> : ReinforcementLearningAgentBase<T>
 {
     private DynaQPlusOptions<T> _options;
 
@@ -226,38 +226,6 @@ protected override void RegisterComponents()
                 () => _qTable));
     }
     public override int FeatureCount => _options.StateSize;
-    public override byte[] Serialize()
-    {
-        var state = new
-        {
-            QTable = _qTable,
-            Model = _model,
-            TimeSteps = _timeSteps,
-            VisitedStateActions = _visitedStateActions,
-            Epsilon = _epsilon,
-            TotalSteps = _totalSteps,
-            Options = _options
-        };
-        string json = JsonConvert.SerializeObject(state);
-        return System.Text.Encoding.UTF8.GetBytes(json);
-    }
-
-    public override void Deserialize(byte[] data)
-    {
-        string json = System.Text.Encoding.UTF8.GetString(data);
-        var state = JsonConvert.DeserializeObject<dynamic>(json);
-        if (state is null)
-        {
-            throw new InvalidOperationException("Deserialization returned null");
-        }
-
-        _qTable = JsonConvert.DeserializeObject<Dictionary<string, Dictionary<int, T>>>(state.QTable.ToString()) ?? new Dictionary<string, Dictionary<int, T>>();
-        _model = JsonConvert.DeserializeObject<Dictionary<string, Dictionary<int, (string, T)>>>(state.Model.ToString()) ?? new Dictionary<string, Dictionary<int, (string, T)>>();
-        _timeSteps = JsonConvert.DeserializeObject<Dictionary<string, Dictionary<int, int>>>(state.TimeSteps.ToString()) ?? new Dictionary<string, Dictionary<int, int>>();
-        _visitedStateActions = JsonConvert.DeserializeObject<List<(string, int)>>(state.VisitedStateActions.ToString()) ?? new List<(string, int)>();
-        _epsilon = state.Epsilon;
-        _totalSteps = state.TotalSteps;
-    }
     /// <summary>
     /// The Q-table's <c>(state, action)</c> entries in a fixed order.
     /// </summary>
@@ -284,53 +252,6 @@ public override void Deserialize(byte[] data)
 
         return entries;
     }
-
-    public override IFullModel<T, Vector<T>, Vector<T>> Clone()
-    {
-        var clone = new DynaQPlusAgent<T>(_options);
-
-        // Deep copy Q-table
-        foreach (var stateEntry in _qTable)
-        {
-            clone._qTable[stateEntry.Key] = new Dictionary<int, T>();
-            foreach (var actionEntry in stateEntry.Value)
-            {
-                clone._qTable[stateEntry.Key][actionEntry.Key] = actionEntry.Value;
-            }
-        }
-
-        // Deep copy model
-        foreach (var stateEntry in _model)
-        {
-            clone._model[stateEntry.Key] = new Dictionary<int, (string, T)>();
-            foreach (var actionEntry in stateEntry.Value)
-            {
-                clone._model[stateEntry.Key][actionEntry.Key] = actionEntry.Value;
-            }
-        }
-
-        // Deep copy time steps
-        foreach (var stateEntry in _timeSteps)
-        {
-            clone._timeSteps[stateEntry.Key] = new Dictionary<int, int>();
-            foreach (var actionEntry in stateEntry.Value)
-            {
-                clone._timeSteps[stateEntry.Key][actionEntry.Key] = actionEntry.Value;
-            }
-        }
-
-        // Deep copy visited state-actions
-        foreach (var stateAction in _visitedStateActions)
-        {
-            clone._visitedStateActions.Add(stateAction);
-        }
-
-        // Copy scalar values
-        clone._epsilon = _epsilon;
-        clone._totalSteps = _totalSteps;
-
-        return clone;
-    }
     public override void SaveModel(string filepath)
     {
         if (string.IsNullOrWhiteSpace(filepath))
diff --git a/src/ReinforcementLearning/Agents/EpsilonGreedyBanditAgent.cs b/src/ReinforcementLearning/Agents/EpsilonGreedyBanditAgent.cs
index c75034d712..13584245f6 100644
--- a/src/ReinforcementLearning/Agents/EpsilonGreedyBanditAgent.cs
+++ b/src/ReinforcementLearning/Agents/EpsilonGreedyBanditAgent.cs
@@ -42,7 +42,7 @@ namespace AiDotNet.ReinforcementLearning.Agents.Bandits;
     "https://incompleteideas.net/book/the-book-2nd.html",
     Year = 2018,
     Authors = "Sutton, R. S. & Barto, A. G.")]
-public class EpsilonGreedyBanditAgent<T> : ReinforcementLearningAgentBase<T>
+public partial class EpsilonGreedyBanditAgent<T> : ReinforcementLearningAgentBase<T>
 {
 
     /// <inheritdoc />
@@ -152,55 +152,6 @@ public override void ResetEpisode()
     public Task TrainAsync() { Train(); return Task.CompletedTask; }
     public override ModelMetadata<T> GetModelMetadata() => new ModelMetadata<T> { FeatureCount = this.FeatureCount, Complexity = ParameterCount };
     public override int FeatureCount => 1;
-    public override byte[] Serialize()
-    {
-        using var ms = new MemoryStream();
-        using var writer = new BinaryWriter(ms);
-
-        // Write options
-        writer.Write(_options.NumArms);
-        writer.Write(_options.Epsilon);
-
-        // Write state
-        for (int i = 0; i < _options.NumArms; i++)
-        {
-            writer.Write(NumOps.ToDouble(_qValues[i]));
-            writer.Write(_actionCounts[i]);
-        }
-
-        return ms.ToArray();
-    }
-
-    public override void Deserialize(byte[] data)
-    {
-        using var ms = new MemoryStream(data);
-        using var reader = new BinaryReader(ms);
-
-        // Read and validate options
-        var numArms = reader.ReadInt32();
-        var epsilon = reader.ReadDouble();
-
-        if (numArms != _options.NumArms)
-            throw new InvalidOperationException($"Serialized NumArms ({numArms}) doesn't match current options ({_options.NumArms})");
-
-        // Read state
-        for (int i = 0; i < _options.NumArms; i++)
-        {
-            _qValues[i] = NumOps.FromDouble(reader.ReadDouble());
-            _actionCounts[i] = reader.ReadInt32();
-        }
-    }
-    public override IFullModel<T, Vector<T>, Vector<T>> Clone()
-    {
-        var clone = new EpsilonGreedyBanditAgent<T>(_options);
-        // Deep copy Q-values and action counts to preserve trained state
-        for (int i = 0; i < _options.NumArms; i++)
-        {
-            clone._qValues[i] = _qValues[i];
-            clone._actionCounts[i] = _actionCounts[i];
-        }
-        return clone;
-    }
     public override void SaveModel(string filepath) { var data = Serialize(); System.IO.File.WriteAllBytes(filepath, data); }
     public override void LoadModel(string filepath) { var data = System.IO.File.ReadAllBytes(filepath); Deserialize(data); }
 }
diff --git a/src/ReinforcementLearning/Agents/EveryVisitMonteCarloAgent.cs b/src/ReinforcementLearning/Agents/EveryVisitMonteCarloAgent.cs
index 64b1d2b262..66c6ca0bd6 100644
--- a/src/ReinforcementLearning/Agents/EveryVisitMonteCarloAgent.cs
+++ b/src/ReinforcementLearning/Agents/EveryVisitMonteCarloAgent.cs
@@ -42,7 +42,7 @@ namespace AiDotNet.ReinforcementLearning.Agents.MonteCarlo;
     "https://incompleteideas.net/book/the-book-2nd.html",
     Year = 2018,
     Authors = "Sutton, R. S. & Barto, A. G.")]
-public class EveryVisitMonteCarloAgent<T> : ReinforcementLearningAgentBase<T>, IGradientComputable<T, Vector<T>, Vector<T>>
+public partial class EveryVisitMonteCarloAgent<T> : ReinforcementLearningAgentBase<T>, IGradientComputable<T, Vector<T>, Vector<T>>
 {
 
     /// <inheritdoc />
@@ -255,69 +255,6 @@ public override ModelMetadata<T> GetModelMetadata()
 
     public override int FeatureCount => _options.StateSize;
 
-    public override byte[] Serialize()
-    {
-        var state = new
-        {
-            QTable = _qTable,
-            Returns = _returns,
-            Epsilon = _epsilon,
-            Options = _options
-        };
-        string json = JsonConvert.SerializeObject(state);
-        return System.Text.Encoding.UTF8.GetBytes(json);
-    }
-
-    public override void Deserialize(byte[] data)
-    {
-        if (data is null || data.Length == 0)
-        {
-            throw new ArgumentException("Serialized data cannot be null or empty", nameof(data));
-        }
-
-        string json = System.Text.Encoding.UTF8.GetString(data);
-        var state = JsonConvert.DeserializeObject<dynamic>(json);
-        if (state is null)
-        {
-            throw new InvalidOperationException("Deserialization returned null");
-        }
-
-        _qTable = JsonConvert.DeserializeObject<Dictionary<string, Dictionary<int, T>>>(state.QTable.ToString()) ?? new Dictionary<string, Dictionary<int, T>>();
-        _returns = JsonConvert.DeserializeObject<Dictionary<string, Dictionary<int, List<T>>>>(state.Returns.ToString()) ?? new Dictionary<string, Dictionary<int, List<T>>>();
-        _epsilon = state.Epsilon;
-    }
-
-    /// <summary>
-    /// Creates a deep copy of the agent, including all Q-table entries.
-    /// </summary>
-    public override IFullModel<T, Vector<T>, Vector<T>> Clone()
-    {
-        var clone = new EveryVisitMonteCarloAgent<T>(_options);
-
-        // Deep copy Q-table
-        foreach (var stateEntry in _qTable)
-        {
-            clone._qTable[stateEntry.Key] = new Dictionary<int, T>();
-            foreach (var actionEntry in stateEntry.Value)
-            {
-                clone._qTable[stateEntry.Key][actionEntry.Key] = actionEntry.Value;
-            }
-        }
-
-        // Deep copy returns
-        foreach (var kvp in _returns)
-        {
-            clone._returns[kvp.Key] = new Dictionary<int, List<T>>();
-            foreach (var returnKvp in kvp.Value)
-            {
-                clone._returns[kvp.Key][returnKvp.Key] = new List<T>(returnKvp.Value);
-            }
-        }
-
-        clone._epsilon = _epsilon;
-        return clone;
-    }
-
     public Vector<T> ComputeGradients(Vector<T> input, Vector<T> target, ILossFunction<T>? lossFunction = null)
     {
         return GetParameters();
diff --git a/src/ReinforcementLearning/Agents/ExpectedSARSAAgent.cs b/src/ReinforcementLearning/Agents/ExpectedSARSAAgent.cs
index 8fdd397f1d..f84ecff3b2 100644
--- a/src/ReinforcementLearning/Agents/ExpectedSARSAAgent.cs
+++ b/src/ReinforcementLearning/Agents/ExpectedSARSAAgent.cs
@@ -54,7 +54,7 @@ namespace AiDotNet.ReinforcementLearning.Agents.ExpectedSARSA;
     "https://doi.org/10.1109/ADPRL.2009.4927542",
     Year = 2009,
     Authors = "van Seijen, H., van Hasselt, H., Whiteson, S., & Wiering, M.")]
-public class ExpectedSARSAAgent<T> : ReinforcementLearningAgentBase<T>, IGradientComputable<T, Vector<T>, Vector<T>>
+public partial class ExpectedSARSAAgent<T> : ReinforcementLearningAgentBase<T>, IGradientComputable<T, Vector<T>, Vector<T>>
 {
 
     /// <inheritdoc />
@@ -269,54 +269,6 @@ public override ModelMetadata<T> GetModelMetadata()
 
     public override int FeatureCount => _options.StateSize;
 
-    public override byte[] Serialize()
-    {
-        var state = new
-        {
-            QTable = _qTable,
-            Epsilon = _epsilon,
-            Options = _options
-        };
-        string json = JsonConvert.SerializeObject(state);
-        return System.Text.Encoding.UTF8.GetBytes(json);
-    }
-
-    public override void Deserialize(byte[] data)
-    {
-        if (data is null || data.Length == 0)
-        {
-            throw new ArgumentException("Serialized data cannot be null or empty", nameof(data));
-        }
-
-        string json = System.Text.Encoding.UTF8.GetString(data);
-        var state = JsonConvert.DeserializeObject<dynamic>(json);
-        if (state is null)
-        {
-            throw new InvalidOperationException("Deserialization returned null");
-        }
-
-        _qTable = JsonConvert.DeserializeObject<Dictionary<string, Dictionary<int, T>>>(state.QTable.ToString()) ?? new Dictionary<string, Dictionary<int, T>>();
-        _epsilon = state.Epsilon;
-    }
-
-    public override IFullModel<T, Vector<T>, Vector<T>> Clone()
-    {
-        var clone = new ExpectedSARSAAgent<T>(_options);
-
-        // Deep copy Q-table to avoid shared state between original and clone
-        // Creates new outer dictionary and new inner dictionary for each state
-        // This ensures modifications to one agent don't affect the other
-        clone._qTable = new Dictionary<string, Dictionary<int, T>>();
-        foreach (var kvp in _qTable)
-        {
-            // Dictionary<int, T>(kvp.Value) creates a new dictionary with copied values
-            clone._qTable[kvp.Key] = new Dictionary<int, T>(kvp.Value);
-        }
-
-        clone._epsilon = _epsilon;
-        return clone;
-    }
-
     public Vector<T> ComputeGradients(Vector<T> input, Vector<T> target, ILossFunction<T>? lossFunction = null)
     {
         return GetParameters();
diff --git a/src/ReinforcementLearning/Agents/FirstVisitMonteCarloAgent.cs b/src/ReinforcementLearning/Agents/FirstVisitMonteCarloAgent.cs
index c1386d6ce8..d7e2cb01e0 100644
--- a/src/ReinforcementLearning/Agents/FirstVisitMonteCarloAgent.cs
+++ b/src/ReinforcementLearning/Agents/FirstVisitMonteCarloAgent.cs
@@ -55,7 +55,7 @@ namespace AiDotNet.ReinforcementLearning.Agents.MonteCarlo;
     "https://incompleteideas.net/book/the-book-2nd.html",
     Year = 2018,
     Authors = "Sutton, R. S. & Barto, A. G.")]
-public class FirstVisitMonteCarloAgent<T> : ReinforcementLearningAgentBase<T>, IGradientComputable<T, Vector<T>, Vector<T>>
+public partial class FirstVisitMonteCarloAgent<T> : ReinforcementLearningAgentBase<T>, IGradientComputable<T, Vector<T>, Vector<T>>
 {
 
     /// <inheritdoc />
@@ -265,62 +265,6 @@ public override ModelMetadata<T> GetModelMetadata()
 
     public override int FeatureCount => _options.StateSize;
 
-    public override byte[] Serialize()
-    {
-        var state = new
-        {
-            QTable = _qTable,
-            Returns = _returns,
-            Epsilon = _epsilon,
-            Options = _options
-        };
-        string json = JsonConvert.SerializeObject(state);
-        return System.Text.Encoding.UTF8.GetBytes(json);
-    }
-
-    public override void Deserialize(byte[] data)
-    {
-        if (data is null || data.Length == 0)
-        {
-            throw new ArgumentException("Serialized data cannot be null or empty", nameof(data));
-        }
-
-        string json = System.Text.Encoding.UTF8.GetString(data);
-        var state = JsonConvert.DeserializeObject<dynamic>(json);
-        if (state is null)
-        {
-            throw new InvalidOperationException("Deserialization returned null");
-        }
-
-        _qTable = JsonConvert.DeserializeObject<Dictionary<string, Dictionary<int, T>>>(state.QTable.ToString()) ?? new Dictionary<string, Dictionary<int, T>>();
-        _returns = JsonConvert.DeserializeObject<Dictionary<string, Dictionary<int, List<T>>>>(state.Returns.ToString()) ?? new Dictionary<string, Dictionary<int, List<T>>>();
-        _epsilon = state.Epsilon;
-    }
-
-    public override IFullModel<T, Vector<T>, Vector<T>> Clone()
-    {
-        var clone = new FirstVisitMonteCarloAgent<T>(_options);
-
-        // Deep copy Q-table
-        foreach (var kvp in _qTable)
-        {
-            clone._qTable[kvp.Key] = new Dictionary<int, T>(kvp.Value);
-        }
-
-        // Deep copy returns
-        foreach (var kvp in _returns)
-        {
-            clone._returns[kvp.Key] = new Dictionary<int, List<T>>();
-            foreach (var returnKvp in kvp.Value)
-            {
-                clone._returns[kvp.Key][returnKvp.Key] = new List<T>(returnKvp.Value);
-            }
-        }
-
-        clone._epsilon = _epsilon;
-        return clone;
-    }
-
     public Vector<T> ComputeGradients(Vector<T> input, Vector<T> target, ILossFunction<T>? lossFunction = null)
     {
         return GetParameters();
diff --git a/src/ReinforcementLearning/Agents/GradientBanditAgent.cs b/src/ReinforcementLearning/Agents/GradientBanditAgent.cs
index cdf2728a26..b57c5e46be 100644
--- a/src/ReinforcementLearning/Agents/GradientBanditAgent.cs
+++ b/src/ReinforcementLearning/Agents/GradientBanditAgent.cs
@@ -43,7 +43,7 @@ namespace AiDotNet.ReinforcementLearning.Agents.Bandits;
     "https://incompleteideas.net/book/the-book-2nd.html",
     Year = 2018,
     Authors = "Sutton, R. S. & Barto, A. G.")]
-public class GradientBanditAgent<T> : ReinforcementLearningAgentBase<T>
+public partial class GradientBanditAgent<T> : ReinforcementLearningAgentBase<T>
 {
 
     /// <inheritdoc />
@@ -238,60 +238,6 @@ public override void ResetEpisode()
     public Task TrainAsync() { Train(); return Task.CompletedTask; }
     public override ModelMetadata<T> GetModelMetadata() => new ModelMetadata<T> { FeatureCount = this.FeatureCount, Complexity = ParameterCount };
     public override int FeatureCount => 1;
-    public override byte[] Serialize()
-    {
-        using var ms = new MemoryStream();
-        using var writer = new BinaryWriter(ms);
-
-        // Write options
-        writer.Write(_options.NumArms);
-        writer.Write(_options.Alpha);
-        writer.Write(_options.UseBaseline);
-
-        // Write state
-        writer.Write(_totalSteps);
-        writer.Write(NumOps.ToDouble(_averageReward));
-        for (int i = 0; i < _options.NumArms; i++)
-        {
-            writer.Write(NumOps.ToDouble(_preferences[i]));
-        }
-
-        return ms.ToArray();
-    }
-
-    public override void Deserialize(byte[] data)
-    {
-        using var ms = new MemoryStream(data);
-        using var reader = new BinaryReader(ms);
-
-        // Read and validate options
-        var numArms = reader.ReadInt32();
-        var alpha = reader.ReadDouble();
-        var useBaseline = reader.ReadBoolean();
-
-        if (numArms != _options.NumArms)
-            throw new InvalidOperationException($"Serialized NumArms ({numArms}) doesn't match current options ({_options.NumArms})");
-
-        // Read state
-        _totalSteps = reader.ReadInt32();
-        _averageReward = NumOps.FromDouble(reader.ReadDouble());
-        for (int i = 0; i < _options.NumArms; i++)
-        {
-            _preferences[i] = NumOps.FromDouble(reader.ReadDouble());
-        }
-    }
-    public override IFullModel<T, Vector<T>, Vector<T>> Clone()
-    {
-        var clone = new GradientBanditAgent<T>(_options);
-        // Copy preferences and baseline to preserve learned state
-        for (int i = 0; i < _options.NumArms; i++)
-        {
-            clone._preferences[i] = _preferences[i];
-        }
-        clone._averageReward = _averageReward;
-        clone._totalSteps = _totalSteps;
-        return clone;
-    }
     public override void SaveModel(string filepath) { var data = Serialize(); System.IO.File.WriteAllBytes(filepath, data); }
     public override void LoadModel(string filepath) { var data = System.IO.File.ReadAllBytes(filepath); Deserialize(data); }
 }
diff --git a/src/ReinforcementLearning/Agents/IQLAgent.cs b/src/ReinforcementLearning/Agents/IQLAgent.cs
index a86feee5e1..b328ba2f48 100644
--- a/src/ReinforcementLearning/Agents/IQLAgent.cs
+++ b/src/ReinforcementLearning/Agents/IQLAgent.cs
@@ -449,14 +449,6 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    /// <inheritdoc/>
-    public override IFullModel<T, Vector<T>, Vector<T>> Clone()
-    {
-        var clone = new IQLAgent<T>(_options);
-        clone.SetParameters(GetParameters());
-        return clone;
-    }
-
     /// <inheritdoc/>
     public Vector<T> ComputeGradients(
         Vector<T> input,
@@ -473,70 +465,6 @@ public override void ApplyGradients(Vector<T> gradients, T learningRate)
         // Gradient application is handled by individual network updates
     }
 
-    /// <inheritdoc/>
-    public override byte[] Serialize()
-    {
-        using var ms = new MemoryStream();
-        using var writer = new BinaryWriter(ms);
-
-        writer.Write(_options.StateSize);
-        writer.Write(_options.ActionSize);
-        writer.Write(_updateCount);
-
-        var policyBytes = SerializeNetwork(_policyNetwork);
-        writer.Write(policyBytes.Length);
-        writer.Write(policyBytes);
-
-        var valueBytes = SerializeNetwork(_valueNetwork);
-        writer.Write(valueBytes.Length);
-        writer.Write(valueBytes);
-
-        var q1Bytes = SerializeNetwork(_q1Network);
-        writer.Write(q1Bytes.Length);
-        writer.Write(q1Bytes);
-
-        var q2Bytes = SerializeNetwork(_q2Network);
-        writer.Write(q2Bytes.Length);
-        writer.Write(q2Bytes);
-
-        var targetValueBytes = SerializeNetwork(_targetValueNetwork);
-        writer.Write(targetValueBytes.Length);
-        writer.Write(targetValueBytes);
-
-        return ms.ToArray();
-    }
-
-    /// <inheritdoc/>
-    public override void Deserialize(byte[] data)
-    {
-        using var ms = new MemoryStream(data);
-        using var reader = new BinaryReader(ms);
-
-        reader.ReadInt32(); // stateSize
-        reader.ReadInt32(); // actionSize
-        _updateCount = reader.ReadInt32();
-
-        var policyLength = reader.ReadInt32();
-        var policyBytes = reader.ReadBytes(policyLength);
-        DeserializeNetwork(_policyNetwork, policyBytes);
-
-        var valueLength = reader.ReadInt32();
-        var valueBytes = reader.ReadBytes(valueLength);
-        DeserializeNetwork(_valueNetwork, valueBytes);
-
-        var q1Length = reader.ReadInt32();
-        var q1Bytes = reader.ReadBytes(q1Length);
-        DeserializeNetwork(_q1Network, q1Bytes);
-
-        var q2Length = reader.ReadInt32();
-        var q2Bytes = reader.ReadBytes(q2Length);
-        DeserializeNetwork(_q2Network, q2Bytes);
-
-        var targetValueLength = reader.ReadInt32();
-        var targetValueBytes = reader.ReadBytes(targetValueLength);
-        DeserializeNetwork(_targetValueNetwork, targetValueBytes);
-    }
-
     /// <inheritdoc/>
     public override void SaveModel(string filepath)
     {
diff --git a/src/ReinforcementLearning/Agents/LSPIAgent.cs b/src/ReinforcementLearning/Agents/LSPIAgent.cs
index 63085fcc5b..f788a3cbfe 100644
--- a/src/ReinforcementLearning/Agents/LSPIAgent.cs
+++ b/src/ReinforcementLearning/Agents/LSPIAgent.cs
@@ -43,7 +43,7 @@ namespace AiDotNet.ReinforcementLearning.Agents.AdvancedRL;
     "https://www.jmlr.org/papers/v4/lagoudakis03a.html",
     Year = 2003,
     Authors = "Lagoudakis, M. G. & Parr, R.")]
-public class LSPIAgent<T> : ReinforcementLearningAgentBase<T>
+public partial class LSPIAgent<T> : ReinforcementLearningAgentBase<T>
 {
 
     /// <inheritdoc />
@@ -370,127 +370,6 @@ public override void ResetEpisode() { }
     public Task TrainAsync() { Train(); return Task.CompletedTask; }
     public override ModelMetadata<T> GetModelMetadata() => new ModelMetadata<T> { FeatureCount = this.FeatureCount, Complexity = ParameterCount };
     public override int FeatureCount => _options.FeatureSize;
-    public override byte[] Serialize()
-    {
-        var state = new
-        {
-            Weights = _weights,
-            Samples = _samples,
-            Iterations = _iterations,
-            Options = _options
-        };
-        string json = JsonConvert.SerializeObject(state);
-        return System.Text.Encoding.UTF8.GetBytes(json);
-    }
-
-    public override void Deserialize(byte[] data)
-    {
-        if (data is null || data.Length == 0)
-        {
-            throw new ArgumentException("Serialized data cannot be null or empty", nameof(data));
-        }
-
-        string json = System.Text.Encoding.UTF8.GetString(data);
-        var state = JsonConvert.DeserializeObject<dynamic>(json);
-        if (state is null)
-        {
-            throw new InvalidOperationException("Deserialization returned null");
-        }
-
-        // Create matrix with correct dimensions from options
-        _weights = new Matrix<T>(_options.ActionSize, _options.FeatureSize);
-
-        // Parse weights matrix from JArray structure
-        var weightsObj = state.Weights;
-        if (weightsObj is Newtonsoft.Json.Linq.JArray jArray)
-        {
-            for (int r = 0; r < _options.ActionSize && r < jArray.Count; r++)
-            {
-                var rowArray = jArray[r] as Newtonsoft.Json.Linq.JArray;
-                if (rowArray is not null)
-                {
-                    for (int c = 0; c < _options.FeatureSize && c < rowArray.Count; c++)
-                    {
-                        _weights[r, c] = NumOps.FromDouble((double)rowArray[c]);
-                    }
-                }
-            }
-        }
-
-        // Deserialize samples list
-        _samples = new List<(Vector<T>, int, T, Vector<T>, bool)>();
-        var samplesObj = state.Samples;
-        if (samplesObj is Newtonsoft.Json.Linq.JArray samplesArray)
-        {
-            foreach (var sample in samplesArray.OfType<Newtonsoft.Json.Linq.JObject>())
-            {
-                // Deserialize and validate state vector (Item1)
-                var stateArray = sample["Item1"] as Newtonsoft.Json.Linq.JArray;
-                if (stateArray is null || stateArray.Count != _options.FeatureSize)
-                {
-                    throw new InvalidOperationException(
-                        $"Sample state vector dimension mismatch: expected {_options.FeatureSize}, " +
-                        $"got {stateArray?.Count ?? 0}.");
-                }
-
-                var stateVec = new Vector<T>(stateArray.Count);
-                for (int i = 0; i < stateArray.Count; i++)
-                {
-                    stateVec[i] = NumOps.FromDouble(Convert.ToDouble(stateArray[i]));
-                }
-
-                // Deserialize and validate action (Item2)
-                int action = sample["Item2"] is not null ? Convert.ToInt32(sample["Item2"]) : 0;
-                if (action < 0 || action >= _options.ActionSize)
-                {
-                    throw new InvalidOperationException(
-                        $"Sample action index out of range: {action} (valid range: 0-{_options.ActionSize - 1}).");
-                }
-
-                // Deserialize reward (Item3)
-                T reward = NumOps.FromDouble(sample["Item3"] is not null ? Convert.ToDouble(sample["Item3"]) : 0.0);
-
-                // Deserialize and validate next state vector (Item4)
-                var nextStateArray = sample["Item4"] as Newtonsoft.Json.Linq.JArray;
-                if (nextStateArray is null || nextStateArray.Count != _options.FeatureSize)
-                {
-                    throw new InvalidOperationException(
-                        $"Sample next state vector dimension mismatch: expected {_options.FeatureSize}, " +
-                        $"got {nextStateArray?.Count ?? 0}.");
-                }
-
-                var nextStateVec = new Vector<T>(nextStateArray.Count);
-                for (int i = 0; i < nextStateArray.Count; i++)
-                {
-                    nextStateVec[i] = NumOps.FromDouble(Convert.ToDouble(nextStateArray[i]));
-                }
-
-                // Deserialize done flag (Item5)
-                bool done = sample["Item5"] is not null && Convert.ToBoolean(sample["Item5"]);
-
-                _samples.Add((stateVec, action, reward, nextStateVec, done));
-            }
-        }
-
-        _iterations = Convert.ToInt32(state.Iterations);
-    }
-
-    public override IFullModel<T, Vector<T>, Vector<T>> Clone()
-    {
-        var clone = new LSPIAgent<T>(_options);
-        // Copy learned weights
-        for (int a = 0; a < _options.ActionSize; a++)
-        {
-            for (int f = 0; f < _options.FeatureSize; f++)
-            {
-                clone._weights[a, f] = _weights[a, f];
-            }
-        }
-        // Copy samples and iterations
-        clone._samples.AddRange(_samples);
-        clone._iterations = _iterations;
-        return clone;
-    }
     public override void SaveModel(string filepath) { var data = Serialize(); System.IO.File.WriteAllBytes(filepath, data); }
     public override void LoadModel(string filepath) { var data = System.IO.File.ReadAllBytes(filepath); Deserialize(data); }
 }
diff --git a/src/ReinforcementLearning/Agents/LSTDAgent.cs b/src/ReinforcementLearning/Agents/LSTDAgent.cs
index 11467a6ad9..7b40aadd1f 100644
--- a/src/ReinforcementLearning/Agents/LSTDAgent.cs
+++ b/src/ReinforcementLearning/Agents/LSTDAgent.cs
@@ -43,7 +43,7 @@ namespace AiDotNet.ReinforcementLearning.Agents.AdvancedRL;
     "https://doi.org/10.1023/A:1007382027895",
     Year = 1996,
     Authors = "Bradtke, S. J. & Barto, A. G.")]
-public class LSTDAgent<T> : ReinforcementLearningAgentBase<T>
+public partial class LSTDAgent<T> : ReinforcementLearningAgentBase<T>
 {
 
     /// <inheritdoc />
@@ -340,73 +340,6 @@ public override void ResetEpisode() { }
     public override ModelMetadata<T> GetModelMetadata() => new ModelMetadata<T> { FeatureCount = this.FeatureCount, Complexity = ParameterCount };
     public override int FeatureCount => _options.FeatureSize;
 
-    public override byte[] Serialize()
-    {
-        var state = new
-        {
-            Weights = GetParameters(),  // Serialize as flat vector for consistency
-            Options = _options
-        };
-        string json = JsonConvert.SerializeObject(state);
-        return System.Text.Encoding.UTF8.GetBytes(json);
-    }
-
-    public override void Deserialize(byte[] data)
-    {
-        if (data is null || data.Length == 0)
-        {
-            throw new ArgumentException("Serialized data cannot be null or empty", nameof(data));
-        }
-
-        string json = System.Text.Encoding.UTF8.GetString(data);
-        var state = JsonConvert.DeserializeObject<dynamic>(json);
-        if (state is null)
-        {
-            throw new InvalidOperationException("Deserialization returned null");
-        }
-
-        // Parse and validate weights as flat vector
-        var weightsObj = state.Weights;
-        if (weightsObj is null)
-        {
-            throw new InvalidOperationException("Failed to deserialize agent state: Weights property is missing or null.");
-        }
-
-        if (weightsObj is not Newtonsoft.Json.Linq.JArray jArray)
-        {
-            throw new InvalidOperationException($"Failed to deserialize agent state: Weights must be a JSON array, got {weightsObj.GetType().Name}.");
-        }
-
-        int expectedCount = _options.ActionSize * _options.FeatureSize;
-        if (jArray.Count != expectedCount)
-        {
-            throw new InvalidOperationException($"Weight count mismatch: expected {expectedCount} (ActionSize={_options.ActionSize} × FeatureSize={_options.FeatureSize}), got {jArray.Count}.");
-        }
-
-        var weights = new Vector<T>(jArray.Count);
-        for (int i = 0; i < jArray.Count; i++)
-        {
-            weights[i] = NumOps.FromDouble((double)jArray[i]);
-        }
-        SetParameters(weights);
-    }
-
-    public override IFullModel<T, Vector<T>, Vector<T>> Clone()
-    {
-        var clone = new LSTDAgent<T>(_options);
-
-        // Deep copy weights matrix
-        for (int a = 0; a < _options.ActionSize; a++)
-        {
-            for (int f = 0; f < _options.FeatureSize; f++)
-            {
-                clone._weights[a, f] = _weights[a, f];
-            }
-        }
-
-        return clone;
-    }
-
     public override void SaveModel(string filepath)
     {
         if (string.IsNullOrWhiteSpace(filepath))
diff --git a/src/ReinforcementLearning/Agents/LinearQLearningAgent.cs b/src/ReinforcementLearning/Agents/LinearQLearningAgent.cs
index 5a62344065..030b0d20ad 100644
--- a/src/ReinforcementLearning/Agents/LinearQLearningAgent.cs
+++ b/src/ReinforcementLearning/Agents/LinearQLearningAgent.cs
@@ -41,7 +41,7 @@ namespace AiDotNet.ReinforcementLearning.Agents.AdvancedRL;
     "https://incompleteideas.net/book/the-book-2nd.html",
     Year = 2018,
     Authors = "Sutton, R. S. & Barto, A. G.")]
-public class LinearQLearningAgent<T> : ReinforcementLearningAgentBase<T>
+public partial class LinearQLearningAgent<T> : ReinforcementLearningAgentBase<T>
 {
 
     /// <inheritdoc />
@@ -207,105 +207,6 @@ public override void ResetEpisode() { }
     public Task TrainAsync() { Train(); return Task.CompletedTask; }
     public override ModelMetadata<T> GetModelMetadata() => new ModelMetadata<T> { FeatureCount = this.FeatureCount, Complexity = ParameterCount };
     public override int FeatureCount => _options.FeatureSize;
-    public override byte[] Serialize()
-    {
-        using var ms = new MemoryStream();
-        using var writer = new BinaryWriter(ms);
-
-        // Write options
-        writer.Write(_options.ActionSize);
-        writer.Write(_options.FeatureSize);
-        writer.Write(_options.EpsilonStart);
-        writer.Write(_options.EpsilonEnd);
-        writer.Write(_options.EpsilonDecay);
-
-        // Write base class properties that must be serialized
-        writer.Write(NumOps.ToDouble(_options.LearningRate ?? NumOps.Zero));
-        writer.Write(NumOps.ToDouble(_options.DiscountFactor ?? NumOps.Zero));
-        writer.Write(_options.Seed ?? -1); // Use -1 to indicate no seed
-        // Serialize loss function type name for reconstruction
-        string lossFunctionTypeName = _options.LossFunction?.GetType().AssemblyQualifiedName ?? string.Empty;
-        writer.Write(lossFunctionTypeName);
-
-        // Write current epsilon
-        writer.Write(_epsilon);
-
-        // Write weights matrix
-        writer.Write(_weights.Rows);
-        writer.Write(_weights.Columns);
-        for (int a = 0; a < _weights.Rows; a++)
-        {
-            for (int f = 0; f < _weights.Columns; f++)
-            {
-                writer.Write(NumOps.ToDouble(_weights[a, f]));
-            }
-        }
-
-        return ms.ToArray();
-    }
-
-    public override void Deserialize(byte[] data)
-    {
-        using var ms = new MemoryStream(data);
-        using var reader = new BinaryReader(ms);
-
-        // Read options
-        int actionSize = reader.ReadInt32();
-        int featureSize = reader.ReadInt32();
-        double epsilonStart = reader.ReadDouble();
-        double epsilonEnd = reader.ReadDouble();
-        double epsilonDecay = reader.ReadDouble();
-
-        // Read base class properties from serialized data
-        double learningRate = reader.ReadDouble();
-        double discountFactor = reader.ReadDouble();
-        int seedValue = reader.ReadInt32();
-        int? seed = seedValue == -1 ? null : seedValue;
-        string lossFunctionTypeName = reader.ReadString();
-
-        // Reconstruct loss function from type name
-        ILossFunction<T>? lossFunction = null;
-        if (!string.IsNullOrEmpty(lossFunctionTypeName))
-        {
-            Type? lossFunctionType = Type.GetType(lossFunctionTypeName);
-            if (lossFunctionType is not null)
-            {
-                lossFunction = (ILossFunction<T>?)Activator.CreateInstance(lossFunctionType);
-            }
-        }
-        // Fall back to existing loss function if reconstruction failed
-        lossFunction ??= _options.LossFunction;
-
-        _options = new LinearQLearningOptions<T>
-        {
-            ActionSize = actionSize,
-            FeatureSize = featureSize,
-            EpsilonStart = epsilonStart,
-            EpsilonEnd = epsilonEnd,
-            EpsilonDecay = epsilonDecay,
-            LearningRate = NumOps.FromDouble(learningRate),
-            DiscountFactor = NumOps.FromDouble(discountFactor),
-            Seed = seed,
-            LossFunction = lossFunction
-        };
-
-        // Read current epsilon
-        _epsilon = reader.ReadDouble();
-
-        // Read weights matrix
-        int rows = reader.ReadInt32();
-        int cols = reader.ReadInt32();
-        _weights = new Matrix<T>(rows, cols);
-        for (int a = 0; a < rows; a++)
-        {
-            for (int f = 0; f < cols; f++)
-            {
-                _weights[a, f] = NumOps.FromDouble(reader.ReadDouble());
-            }
-        }
-    }
-
-    public override IFullModel<T, Vector<T>, Vector<T>> Clone() => new LinearQLearningAgent<T>(_options);
     public override void SaveModel(string filepath) { var data = Serialize(); System.IO.File.WriteAllBytes(filepath, data); }
     public override void LoadModel(string filepath) { var data = System.IO.File.ReadAllBytes(filepath); Deserialize(data); }
 }
diff --git a/src/ReinforcementLearning/Agents/LinearSARSAAgent.cs b/src/ReinforcementLearning/Agents/LinearSARSAAgent.cs
index 0abc22882f..43e58ad5b6 100644
--- a/src/ReinforcementLearning/Agents/LinearSARSAAgent.cs
+++ b/src/ReinforcementLearning/Agents/LinearSARSAAgent.cs
@@ -41,7 +41,7 @@ namespace AiDotNet.ReinforcementLearning.Agents.AdvancedRL;
     "https://incompleteideas.net/book/the-book-2nd.html",
     Year = 2018,
     Authors = "Sutton, R. S. & Barto, A. G.")]
-public class LinearSARSAAgent<T> : ReinforcementLearningAgentBase<T>
+public partial class LinearSARSAAgent<T> : ReinforcementLearningAgentBase<T>
 {
 
     /// <inheritdoc />
@@ -59,6 +59,7 @@ protected override void RegisterComponents()
     private Matrix<T> _weights;  // Weight matrix: [ActionSize x FeatureSize]
     private double _epsilon;
     private int _lastAction = -1;
+    [Scratch]
     private Vector<T>? _lastState = null;
 
     /// <summary>
@@ -234,62 +235,6 @@ public override void ResetEpisode()
     public Task TrainAsync() { Train(); return Task.CompletedTask; }
     public override ModelMetadata<T> GetModelMetadata() => new ModelMetadata<T> { FeatureCount = this.FeatureCount, Complexity = ParameterCount };
     public override int FeatureCount => _options.FeatureSize;
-    public override byte[] Serialize()
-    {
-        var state = new
-        {
-            Weights = GetParameters(),
-            Epsilon = _epsilon,
-            LastAction = _lastAction,
-            Options = _options
-        };
-        string json = Newtonsoft.Json.JsonConvert.SerializeObject(state);
-        return System.Text.Encoding.UTF8.GetBytes(json);
-    }
-    public override void Deserialize(byte[] data)
-    {
-        string json = System.Text.Encoding.UTF8.GetString(data);
-        var state = Newtonsoft.Json.JsonConvert.DeserializeObject<dynamic>(json);
-        if (state is null)
-        {
-            throw new InvalidOperationException("Failed to deserialize agent state: JSON deserialization returned null.");
-        }
-
-        var weightsObj = state.Weights;
-        if (weightsObj is null)
-        {
-            throw new InvalidOperationException("Failed to deserialize agent state: Weights property is missing or null.");
-        }
-
-        if (weightsObj is not Newtonsoft.Json.Linq.JArray jArray)
-        {
-            throw new InvalidOperationException($"Failed to deserialize agent state: Weights must be a JSON array, got {weightsObj.GetType().Name}.");
-        }
-
-        int expectedCount = _options.ActionSize * _options.FeatureSize;
-        if (jArray.Count != expectedCount)
-        {
-            throw new InvalidOperationException($"Weight count mismatch: expected {expectedCount} (ActionSize={_options.ActionSize} × FeatureSize={_options.FeatureSize}), got {jArray.Count}.");
-        }
-
-        var weights = new Vector<T>(jArray.Count);
-        for (int i = 0; i < jArray.Count; i++)
-        {
-            weights[i] = NumOps.FromDouble((double)jArray[i]);
-        }
-        SetParameters(weights);
-
-        if (state.Epsilon != null)
-        {
-            _epsilon = Convert.ToDouble(state.Epsilon);
-        }
-        if (state.LastAction != null)
-        {
-            _lastAction = Convert.ToInt32(state.LastAction);
-        }
-    }
-
-    public override IFullModel<T, Vector<T>, Vector<T>> Clone() => new LinearSARSAAgent<T>(_options);
     public override void SaveModel(string filepath) { var data = Serialize(); System.IO.File.WriteAllBytes(filepath, data); }
     public override void LoadModel(string filepath) { var data = System.IO.File.ReadAllBytes(filepath); Deserialize(data); }
 }
diff --git a/src/ReinforcementLearning/Agents/MADDPGAgent.cs b/src/ReinforcementLearning/Agents/MADDPGAgent.cs
index 167def24d9..e179194b6f 100644
--- a/src/ReinforcementLearning/Agents/MADDPGAgent.cs
+++ b/src/ReinforcementLearning/Agents/MADDPGAgent.cs
@@ -652,120 +652,6 @@ public override ModelMetadata<T> GetModelMetadata()
 
     public override int FeatureCount => _options.StateSize;
 
-    /// <summary>
-    /// Serializes the MADDPG agent to a byte array.
-    /// </summary>
-    /// <returns>Byte array containing the serialized agent data.</returns>
-    /// <remarks>
-    /// Serializes configuration values and all actor/critic network weights.
-    /// </remarks>
-    public override byte[] Serialize()
-    {
-        using var ms = new MemoryStream();
-        using var writer = new BinaryWriter(ms);
-
-        writer.Write(_options.NumAgents);
-        writer.Write(_options.StateSize);
-        writer.Write(_options.ActionSize);
-
-        void WriteNetwork(INeuralNetwork<T> network)
-        {
-            var bytes = network.Serialize();
-            writer.Write(bytes.Length);
-            writer.Write(bytes);
-        }
-
-        foreach (var network in _actorNetworks)
-        {
-            WriteNetwork(network);
-        }
-
-        foreach (var network in _targetActorNetworks)
-        {
-            WriteNetwork(network);
-        }
-
-        foreach (var network in _criticNetworks)
-        {
-            WriteNetwork(network);
-        }
-
-        foreach (var network in _targetCriticNetworks)
-        {
-            WriteNetwork(network);
-        }
-
-        return ms.ToArray();
-    }
-
-    /// <summary>
-    /// Deserializes a MADDPG agent from a byte array.
-    /// </summary>
-    /// <param name="data">Byte array containing the serialized agent data.</param>
-    /// <remarks>
-    /// Expects data created by <see cref="Serialize"/> with a compatible configuration.
-    /// </remarks>
-    public override void Deserialize(byte[] data)
-    {
-        using var ms = new MemoryStream(data);
-        using var reader = new BinaryReader(ms);
-
-        var numAgents = reader.ReadInt32();
-        var stateSize = reader.ReadInt32();
-        var actionSize = reader.ReadInt32();
-
-        if (numAgents != _options.NumAgents || stateSize != _options.StateSize || actionSize != _options.ActionSize)
-        {
-            throw new InvalidOperationException("Serialized MADDPG configuration does not match current agent options.");
-        }
-
-        void ReadNetwork(INeuralNetwork<T> network)
-        {
-            var length = reader.ReadInt32();
-            var bytes = reader.ReadBytes(length);
-            network.Deserialize(bytes);
-        }
-
-        foreach (var network in _actorNetworks)
-        {
-            ReadNetwork(network);
-        }
-
-        foreach (var network in _targetActorNetworks)
-        {
-            ReadNetwork(network);
-        }
-
-        foreach (var network in _criticNetworks)
-        {
-            ReadNetwork(network);
-        }
-
-        foreach (var network in _targetCriticNetworks)
-        {
-            ReadNetwork(network);
-        }
-    }
-
-    /// <summary>
-    /// Creates a deep copy of this MADDPG agent including all trained network weights.
-    /// </summary>
-    /// <returns>A new MADDPG agent with the same configuration and trained parameters.</returns>
-    /// <remarks>
-    /// Issue #5 fix: Clone now properly copies all trained weights from actor and critic networks
-    /// using GetParameters() and SetParameters(), ensuring the cloned agent has the same learned behavior.
-    /// </remarks>
-    public override IFullModel<T, Vector<T>, Vector<T>> Clone()
-    {
-        var clonedAgent = new MADDPGAgent<T>(_options, _optimizer);
-
-        // Copy all trained parameters to the cloned agent
-        var currentParams = GetParameters();
-        clonedAgent.SetParameters(currentParams);
-
-        return clonedAgent;
-    }
-
     /// <summary>
     /// Saves the trained model to a file.
     /// </summary>
diff --git a/src/ReinforcementLearning/Agents/ModifiedPolicyIterationAgent.cs b/src/ReinforcementLearning/Agents/ModifiedPolicyIterationAgent.cs
index ce3b43e3f4..551fcc984e 100644
--- a/src/ReinforcementLearning/Agents/ModifiedPolicyIterationAgent.cs
+++ b/src/ReinforcementLearning/Agents/ModifiedPolicyIterationAgent.cs
@@ -61,7 +61,7 @@ public TransitionData()
     "https://incompleteideas.net/book/the-book-2nd.html",
     Year = 2018,
     Authors = "Sutton, R. S. & Barto, A. G.")]
-public class ModifiedPolicyIterationAgent<T> : ReinforcementLearningAgentBase<T>
+public partial class ModifiedPolicyIterationAgent<T> : ReinforcementLearningAgentBase<T>
 {
     private ModifiedPolicyIterationOptions<T> _options;
 
@@ -313,106 +313,6 @@ protected override void RegisterComponents()
 
     public override int FeatureCount => _options.StateSize;
 
-    public override byte[] Serialize()
-    {
-        // Convert model tuples to serializable format
-        var serializableModel = new Dictionary<string, Dictionary<int, List<TransitionData<T>>>>();
-        foreach (var stateEntry in _model)
-        {
-            var actionDict = new Dictionary<int, List<TransitionData<T>>>();
-            foreach (var actionEntry in stateEntry.Value)
-            {
-                var transitionList = new List<TransitionData<T>>();
-                foreach (var transition in actionEntry.Value)
-                {
-                    transitionList.Add(new TransitionData<T>
-                    {
-                        NextState = transition.nextState,
-                        Reward = transition.reward,
-                        Probability = transition.probability
-                    });
-                }
-                actionDict[actionEntry.Key] = transitionList;
-            }
-            serializableModel[stateEntry.Key] = actionDict;
-        }
-
-        var state = new
-        {
-            ValueTable = _valueTable,
-            Policy = _policy,
-            Model = serializableModel
-        };
-        string json = JsonConvert.SerializeObject(state);
-        return System.Text.Encoding.UTF8.GetBytes(json);
-    }
-
-    public override void Deserialize(byte[] data)
-    {
-        if (data is null || data.Length == 0)
-        {
-            throw new ArgumentException("Serialized data cannot be null or empty", nameof(data));
-        }
-
-        string json = System.Text.Encoding.UTF8.GetString(data);
-        var state = JsonConvert.DeserializeObject<dynamic>(json);
-        if (state is null)
-        {
-            throw new InvalidOperationException("Deserialization returned null");
-        }
-
-        _valueTable = JsonConvert.DeserializeObject<Dictionary<string, T>>(state.ValueTable.ToString()) ?? new Dictionary<string, T>();
-        _policy = JsonConvert.DeserializeObject<Dictionary<string, int>>(state.Policy.ToString()) ?? new Dictionary<string, int>();
-
-        // Deserialize model from serializable format
-        var serializableModel = JsonConvert.DeserializeObject<Dictionary<string, Dictionary<int, List<TransitionData<T>>>>>(state.Model.ToString()) ?? new Dictionary<string, Dictionary<int, List<TransitionData<T>>>>();
-        _model = new Dictionary<string, Dictionary<int, List<(string, T, T)>>>();
-
-        foreach (var stateEntry in serializableModel)
-        {
-            var actionDict = new Dictionary<int, List<(string, T, T)>>();
-            foreach (var actionEntry in stateEntry.Value)
-            {
-                var transitionList = new List<(string, T, T)>();
-                foreach (var transition in actionEntry.Value)
-                {
-                    transitionList.Add((transition.NextState, transition.Reward, transition.Probability));
-                }
-                actionDict[actionEntry.Key] = transitionList;
-            }
-            _model[stateEntry.Key] = actionDict;
-        }
-    }
-
-    public override IFullModel<T, Vector<T>, Vector<T>> Clone()
-    {
-        var clone = new ModifiedPolicyIterationAgent<T>(_options);
-
-        // Deep copy value table
-        foreach (var kvp in _valueTable)
-        {
-            clone._valueTable[kvp.Key] = kvp.Value;
-        }
-
-        // Deep copy policy
-        foreach (var kvp in _policy)
-        {
-            clone._policy[kvp.Key] = kvp.Value;
-        }
-
-        // Deep copy model
-        foreach (var stateKvp in _model)
-        {
-            clone._model[stateKvp.Key] = new Dictionary<int, List<(string, T, T)>>();
-            foreach (var actionKvp in stateKvp.Value)
-            {
-                clone._model[stateKvp.Key][actionKvp.Key] = new List<(string, T, T)>(actionKvp.Value);
-            }
-        }
-
-        return clone;
-    }
-
     public override void SaveModel(string filepath)
     {
         if (string.IsNullOrWhiteSpace(filepath))
diff --git a/src/ReinforcementLearning/Agents/MonteCarloExploringStartsAgent.cs b/src/ReinforcementLearning/Agents/MonteCarloExploringStartsAgent.cs
index df323c8394..7410ee602a 100644
--- a/src/ReinforcementLearning/Agents/MonteCarloExploringStartsAgent.cs
+++ b/src/ReinforcementLearning/Agents/MonteCarloExploringStartsAgent.cs
@@ -41,7 +41,7 @@ namespace AiDotNet.ReinforcementLearning.Agents.MonteCarlo;
     "https://incompleteideas.net/book/the-book-2nd.html",
     Year = 2018,
     Authors = "Sutton, R. S. & Barto, A. G.")]
-public class MonteCarloExploringStartsAgent<T> : ReinforcementLearningAgentBase<T>
+public partial class MonteCarloExploringStartsAgent<T> : ReinforcementLearningAgentBase<T>
 {
     private MonteCarloExploringStartsOptions<T> _options;
 
@@ -303,77 +303,6 @@ protected override void RegisterComponents()
 
     public override int FeatureCount => _options.StateSize;
 
-    public override byte[] Serialize()
-    {
-        var state = new
-        {
-            QTable = _qTable,
-            Returns = _returns,
-            Options = _options,
-            IsFirstAction = _isFirstAction
-        };
-        string json = JsonConvert.SerializeObject(state);
-        return System.Text.Encoding.UTF8.GetBytes(json);
-    }
-
-    public override void Deserialize(byte[] data)
-    {
-        if (data is null || data.Length == 0)
-        {
-            throw new ArgumentException("Serialized data cannot be null or empty", nameof(data));
-        }
-
-        string json = System.Text.Encoding.UTF8.GetString(data);
-        var state = JsonConvert.DeserializeObject<dynamic>(json);
-        if (state is null)
-        {
-            throw new InvalidOperationException("Deserialization returned null");
-        }
-
-        _qTable = JsonConvert.DeserializeObject<Dictionary<string, Dictionary<int, T>>>(state.QTable.ToString()) ?? new Dictionary<string, Dictionary<int, T>>();
-        _returns = JsonConvert.DeserializeObject<Dictionary<string, Dictionary<int, List<T>>>>(state.Returns.ToString()) ?? new Dictionary<string, Dictionary<int, List<T>>>();
-
-        // Safely parse IsFirstAction with backward compatibility
-        // Default to true if field is missing to preserve exploring-starts behavior
-        _isFirstAction = true;
-        if (state.IsFirstAction is not null)
-        {
-            if (state.IsFirstAction is bool boolValue)
-            {
-                _isFirstAction = boolValue;
-            }
-            else if (bool.TryParse(state.IsFirstAction.ToString(), out bool parsedValue))
-            {
-                _isFirstAction = parsedValue;
-            }
-        }
-    }
-
-    public override IFullModel<T, Vector<T>, Vector<T>> Clone()
-    {
-        var clone = new MonteCarloExploringStartsAgent<T>(_options);
-
-        // Deep copy Q-table and returns to avoid shared state
-        foreach (var kvp in _qTable)
-        {
-            clone._qTable[kvp.Key] = new Dictionary<int, T>(kvp.Value);
-        }
-
-        foreach (var kvp in _returns)
-        {
-            clone._returns[kvp.Key] = new Dictionary<int, List<T>>();
-            foreach (var returnKvp in kvp.Value)
-            {
-                clone._returns[kvp.Key][returnKvp.Key] = new List<T>(returnKvp.Value);
-            }
-        }
-
-        // Preserve mid-episode state
-        clone._isFirstAction = this._isFirstAction;
-
-        return clone;
-    }
-
     public override void SaveModel(string filepath)
     {
         if (string.IsNullOrWhiteSpace(filepath))
diff --git a/src/ReinforcementLearning/Agents/MuZeroAgent.cs b/src/ReinforcementLearning/Agents/MuZeroAgent.cs
index d78e423d49..db066daf8e 100644
--- a/src/ReinforcementLearning/Agents/MuZeroAgent.cs
+++ b/src/ReinforcementLearning/Agents/MuZeroAgent.cs
@@ -786,160 +786,6 @@ public override ModelMetadata<T> GetModelMetadata()
 
     public override int FeatureCount => _options.ObservationSize;
 
-    public override byte[] Serialize()
-    {
-        using var ms = new MemoryStream();
-        using var writer = new BinaryWriter(ms);
-
-        // Write options
-        writer.Write(_options.ObservationSize);
-        writer.Write(_options.ActionSize);
-        writer.Write(_options.LatentStateSize);
-        writer.Write(_options.NumSimulations);
-        writer.Write(_options.ReplayBufferSize);
-        writer.Write(_options.BatchSize);
-        writer.Write(_options.UnrollSteps);
-        writer.Write(_options.PUCTConstant);
-        writer.Write(NumOps.ToDouble(_options.LearningRate!));
-        writer.Write(NumOps.ToDouble(_options.DiscountFactor!));
-        writer.Write(_options.Seed ?? 0);
-        writer.Write(_options.Seed.HasValue);
-
-        // Write hidden layer configurations
-        writer.Write(_options.RepresentationLayers.Count);
-        foreach (var size in _options.RepresentationLayers)
-            writer.Write(size);
-
-        writer.Write(_options.DynamicsLayers.Count);
-        foreach (var size in _options.DynamicsLayers)
-            writer.Write(size);
-
-        writer.Write(_options.PredictionLayers.Count);
-        foreach (var size in _options.PredictionLayers)
-            writer.Write(size);
-
-        // Write update count
-        writer.Write(_updateCount);
-
-        // Serialize each network
-        var repData = _representationNetwork.Serialize();
-        writer.Write(repData.Length);
-        writer.Write(repData);
-
-        var dynData = _dynamicsNetwork.Serialize();
-        writer.Write(dynData.Length);
-        writer.Write(dynData);
-
-        var predData = _predictionNetwork.Serialize();
-        writer.Write(predData.Length);
-        writer.Write(predData);
-
-        return ms.ToArray();
-    }
-
-    public override void Deserialize(byte[] data)
-    {
-        using var ms = new MemoryStream(data);
-        using var reader = new BinaryReader(ms);
-
-        // Read options
-        int observationSize = reader.ReadInt32();
-        int actionSize = reader.ReadInt32();
-        int latentStateSize = reader.ReadInt32();
-        int numSimulations = reader.ReadInt32();
-        int replayBufferSize = reader.ReadInt32();
-        int batchSize = reader.ReadInt32();
-        int unrollSteps = reader.ReadInt32();
-        double puctConstant = reader.ReadDouble();
-        T learningRate = NumOps.FromDouble(reader.ReadDouble());
-        T discountFactor = NumOps.FromDouble(reader.ReadDouble());
-        int seed = reader.ReadInt32();
-        bool hasSeed = reader.ReadBoolean();
-
-        // Read hidden layer configurations
-        int repLayerCount = reader.ReadInt32();
-        var repLayers = new List<int>();
-        for (int i = 0; i < repLayerCount; i++)
-            repLayers.Add(reader.ReadInt32());
-
-        int dynLayerCount = reader.ReadInt32();
-        var dynLayers = new List<int>();
-        for (int i = 0; i < dynLayerCount; i++)
-            dynLayers.Add(reader.ReadInt32());
-
-        int predLayerCount = reader.ReadInt32();
-        var predLayers = new List<int>();
-        for (int i = 0; i < predLayerCount; i++)
-            predLayers.Add(reader.ReadInt32());
-
-        _options = new MuZeroOptions<T>
-        {
-            ObservationSize = observationSize,
-            ActionSize = actionSize,
-            LatentStateSize = latentStateSize,
-            NumSimulations = numSimulations,
-            ReplayBufferSize = replayBufferSize,
-            BatchSize = batchSize,
-            UnrollSteps = unrollSteps,
-            PUCTConstant = puctConstant,
-            LearningRate = learningRate,
-            DiscountFactor = discountFactor,
-            Seed = hasSeed ? seed : null,
-            RepresentationLayers = repLayers,
-            DynamicsLayers = dynLayers,
-            PredictionLayers = predLayers
-        };
-
-        // Read update count
-        _updateCount = reader.ReadInt32();
-
-        // Deserialize each network
-        int repLen = reader.ReadInt32();
-        byte[] repData = reader.ReadBytes(repLen);
-        _representationNetwork.Deserialize(repData);
-
-        int dynLen = reader.ReadInt32();
-        byte[] dynData = reader.ReadBytes(dynLen);
-        _dynamicsNetwork.Deserialize(dynData);
-
-        int predLen = reader.ReadInt32();
-        byte[] predData = reader.ReadBytes(predLen);
-        _predictionNetwork.Deserialize(predData);
-
-        // Reinitialize replay buffer (training state not persisted)
-        _replayBuffer = new UniformReplayBuffer<T, Vector<T>, Vector<T>>(_options.ReplayBufferSize, _options.Seed);
-
-        // Update Networks list
-        Networks = new List<INeuralNetwork<T>>
-        {
-            _representationNetwork,
-            _dynamicsNetwork,
-            _predictionNetwork
-        };
-    }
-
-    /// <summary>
-    /// Creates a parameter-identical copy of this agent. The naive
-    /// <c>new MuZeroAgent&lt;T&gt;(_options)</c> form only shares the
-    /// configuration — the freshly-constructed copy has its three networks
-    /// (representation, dynamics, prediction) re-initialized with
-    /// independent random weights, so <c>cloned.Predict(state)</c> diverges
-    /// from <c>original.Predict(state)</c> on the very first call. Copy the
-    /// parameter vector across after construction so the clone observes the
-    /// same policy distribution as the source.
-    /// </summary>
-    public override IFullModel<T, Vector<T>, Vector<T>> Clone()
-    {
-        // Deep-copy the options before constructing the clone — _options
-        // contains mutable collections (RepresentationLayers, DynamicsLayers,
-        // PredictionLayers as List<int>) and sharing the same instance
-        // would let post-clone edits on one model silently leak into the
-        // other.
-        var copy = new MuZeroAgent<T>(new MuZeroOptions<T>(_options));
-        copy.SetParameters(GetParameters());
-        return copy;
-    }
-
     public override void SaveModel(string filepath)
     {
         var data = Serialize();
diff --git a/src/ReinforcementLearning/Agents/NStepQLearningAgent.cs b/src/ReinforcementLearning/Agents/NStepQLearningAgent.cs
index 435ac7e0b4..e7ae3701e8 100644
--- a/src/ReinforcementLearning/Agents/NStepQLearningAgent.cs
+++ b/src/ReinforcementLearning/Agents/NStepQLearningAgent.cs
@@ -41,7 +41,7 @@ namespace AiDotNet.ReinforcementLearning.Agents.NStepQLearning;
     "https://incompleteideas.net/book/the-book-2nd.html",
     Year = 2018,
     Authors = "Sutton, R. S. & Barto, A. G.")]
-public class NStepQLearningAgent<T> : ReinforcementLearningAgentBase<T>, IGradientComputable<T, Vector<T>, Vector<T>>
+public partial class NStepQLearningAgent<T> : ReinforcementLearningAgentBase<T>, IGradientComputable<T, Vector<T>, Vector<T>>
 {
 
     /// <inheritdoc />
@@ -233,50 +233,6 @@ public override ModelMetadata<T> GetModelMetadata()
 
     public override int FeatureCount => _options.StateSize;
 
-    public override byte[] Serialize()
-    {
-        var state = new
-        {
-            QTable = _qTable,
-            Epsilon = _epsilon,
-            Options = _options
-        };
-        string json = JsonConvert.SerializeObject(state);
-        return System.Text.Encoding.UTF8.GetBytes(json);
-    }
-
-    public override void Deserialize(byte[] data)
-    {
-        if (data is null || data.Length == 0)
-        {
-            throw new ArgumentException("Serialized data cannot be null or empty", nameof(data));
-        }
-
-        string json = System.Text.Encoding.UTF8.GetString(data);
-        var state = JsonConvert.DeserializeObject<dynamic>(json);
-        if (state is null)
-        {
-            throw new InvalidOperationException("Deserialization returned null");
-        }
-
-        _qTable = JsonConvert.DeserializeObject<Dictionary<string, Dictionary<int, T>>>(state.QTable.ToString()) ?? new Dictionary<string, Dictionary<int, T>>();
-        _epsilon = state.Epsilon;
-    }
-
-    public override IFullModel<T, Vector<T>, Vector<T>> Clone()
-    {
-        var clone = new NStepQLearningAgent<T>(_options);
-
-        // Deep copy Q-table to avoid shared state
-        foreach (var kvp in _qTable)
-        {
-            clone._qTable[kvp.Key] = new Dictionary<int, T>(kvp.Value);
-        }
-
-        clone._epsilon = _epsilon;
-        return clone;
-    }
-
     public Vector<T> ComputeGradients(Vector<T> input, Vector<T> target, ILossFunction<T>? lossFunction = null)
     {
         return GetParameters();
diff --git a/src/ReinforcementLearning/Agents/NStepSARSAAgent.cs b/src/ReinforcementLearning/Agents/NStepSARSAAgent.cs
index 6cf61f1841..4d2bef3ffb 100644
--- a/src/ReinforcementLearning/Agents/NStepSARSAAgent.cs
+++ b/src/ReinforcementLearning/Agents/NStepSARSAAgent.cs
@@ -54,7 +54,7 @@ namespace AiDotNet.ReinforcementLearning.Agents.NStepSARSA;
     "https://incompleteideas.net/book/the-book-2nd.html",
     Year = 2018,
     Authors = "Sutton, R. S. & Barto, A. G.")]
-public class NStepSARSAAgent<T> : ReinforcementLearningAgentBase<T>, IGradientComputable<T, Vector<T>, Vector<T>>
+public partial class NStepSARSAAgent<T> : ReinforcementLearningAgentBase<T>, IGradientComputable<T, Vector<T>, Vector<T>>
 {
 
     /// <inheritdoc />
@@ -251,50 +251,6 @@ public override ModelMetadata<T> GetModelMetadata()
 
     public override int FeatureCount => _options.StateSize;
 
-    public override byte[] Serialize()
-    {
-        var state = new
-        {
-            QTable = _qTable,
-            Epsilon = _epsilon,
-            Options = _options
-        };
-        string json = JsonConvert.SerializeObject(state);
-        return System.Text.Encoding.UTF8.GetBytes(json);
-    }
-
-    public override void Deserialize(byte[] data)
-    {
-        if (data is null || data.Length == 0)
-        {
-            throw new ArgumentException("Serialized data cannot be null or empty", nameof(data));
-        }
-
-        string json = System.Text.Encoding.UTF8.GetString(data);
-        var state = JsonConvert.DeserializeObject<dynamic>(json);
-        if (state is null)
-        {
-            throw new InvalidOperationException("Deserialization returned null");
-        }
-
-        _qTable = JsonConvert.DeserializeObject<Dictionary<string, Dictionary<int, T>>>(state.QTable.ToString()) ?? new Dictionary<string, Dictionary<int, T>>();
-        _epsilon = state.Epsilon;
-    }
-
-    public override IFullModel<T, Vector<T>, Vector<T>> Clone()
-    {
-        var clone = new NStepSARSAAgent<T>(_options);
-
-        // Deep copy Q-table to avoid shared state
-        foreach (var kvp in _qTable)
-        {
-            clone._qTable[kvp.Key] = new Dictionary<int, T>(kvp.Value);
-        }
-
-        clone._epsilon = _epsilon;
-        return clone;
-    }
-
     public Vector<T> ComputeGradients(Vector<T> input, Vector<T> target, ILossFunction<T>? lossFunction = null)
     {
         return GetParameters();
diff --git a/src/ReinforcementLearning/Agents/OffPolicyMonteCarloAgent.cs b/src/ReinforcementLearning/Agents/OffPolicyMonteCarloAgent.cs
index 456928277b..24d0372699 100644
--- a/src/ReinforcementLearning/Agents/OffPolicyMonteCarloAgent.cs
+++ b/src/ReinforcementLearning/Agents/OffPolicyMonteCarloAgent.cs
@@ -41,7 +41,7 @@ namespace AiDotNet.ReinforcementLearning.Agents.MonteCarlo;
     "https://incompleteideas.net/book/the-book-2nd.html",
     Year = 2018,
     Authors = "Sutton, R. S. & Barto, A. G.")]
-public class OffPolicyMonteCarloAgent<T> : ReinforcementLearningAgentBase<T>
+public partial class OffPolicyMonteCarloAgent<T> : ReinforcementLearningAgentBase<T>
 {
     private OffPolicyMonteCarloOptions<T> _options;
 
@@ -327,54 +327,6 @@ protected override void RegisterComponents()
 
     public override int FeatureCount => _options.ActionSize;
 
-    public override byte[] Serialize()
-    {
-        var state = new
-        {
-            QTable = _qTable,
-            CTable = _cTable,
-            Options = _options
-        };
-        string json = JsonConvert.SerializeObject(state);
-        return System.Text.Encoding.UTF8.GetBytes(json);
-    }
-
-    public override void Deserialize(byte[] data)
-    {
-        if (data is null || data.Length == 0)
-        {
-            throw new ArgumentException("Serialized data cannot be null or empty", nameof(data));
-        }
-
-        string json = System.Text.Encoding.UTF8.GetString(data);
-        var state = JsonConvert.DeserializeObject<dynamic>(json);
-        if (state is null)
-        {
-            throw new InvalidOperationException("Deserialization returned null");
-        }
-
-        _qTable = JsonConvert.DeserializeObject<Dictionary<string, Dictionary<int, T>>>(state.QTable.ToString()) ?? new Dictionary<string, Dictionary<int, T>>();
-        _cTable = JsonConvert.DeserializeObject<Dictionary<string, Dictionary<int, T>>>(state.CTable.ToString()) ?? new Dictionary<string, Dictionary<int, T>>();
-    }
-
-    public override IFullModel<T, Vector<T>, Vector<T>> Clone()
-    {
-        var clone = new OffPolicyMonteCarloAgent<T>(_options);
-
-        // Deep copy Q-table and C-table to avoid shared state
-        foreach (var kvp in _qTable)
-        {
-            clone._qTable[kvp.Key] = new Dictionary<int, T>(kvp.Value);
-        }
-
-        foreach (var kvp in _cTable)
-        {
-            clone._cTable[kvp.Key] = new Dictionary<int, T>(kvp.Value);
-        }
-
-        return clone;
-    }
-
     public override void SaveModel(string filepath)
     {
         if (string.IsNullOrWhiteSpace(filepath))
diff --git a/src/ReinforcementLearning/Agents/OnPolicyMonteCarloAgent.cs b/src/ReinforcementLearning/Agents/OnPolicyMonteCarloAgent.cs
index b2d97500f0..f1a845d0d2 100644
--- a/src/ReinforcementLearning/Agents/OnPolicyMonteCarloAgent.cs
+++ b/src/ReinforcementLearning/Agents/OnPolicyMonteCarloAgent.cs
@@ -41,7 +41,7 @@ namespace AiDotNet.ReinforcementLearning.Agents.MonteCarlo;
     "https://incompleteideas.net/book/the-book-2nd.html",
     Year = 2018,
     Authors = "Sutton, R. S. & Barto, A. G.")]
-public class OnPolicyMonteCarloAgent<T> : ReinforcementLearningAgentBase<T>
+public partial class OnPolicyMonteCarloAgent<T> : ReinforcementLearningAgentBase<T>
 {
     private OnPolicyMonteCarloOptions<T> _options;
 
@@ -313,62 +313,6 @@ protected override void RegisterComponents()
 
     public override int FeatureCount => _options.StateSize;
 
-    public override byte[] Serialize()
-    {
-        var state = new
-        {
-            QTable = _qTable,
-            Returns = _returns,
-            Epsilon = _epsilon,
-            Options = _options
-        };
-        string json = JsonConvert.SerializeObject(state);
-        return System.Text.Encoding.UTF8.GetBytes(json);
-    }
-
-    public override void Deserialize(byte[] data)
-    {
-        if (data is null || data.Length == 0)
-        {
-            throw new ArgumentException("Serialized data cannot be null or empty", nameof(data));
-        }
-
-        string json = System.Text.Encoding.UTF8.GetString(data);
-        var state = JsonConvert.DeserializeObject<dynamic>(json);
-        if (state is null)
-        {
-            throw new InvalidOperationException("Deserialization returned null");
-        }
-
-        _qTable = JsonConvert.DeserializeObject<Dictionary<string, Dictionary<int, T>>>(state.QTable.ToString()) ?? new Dictionary<string, Dictionary<int, T>>();
-        _returns = JsonConvert.DeserializeObject<Dictionary<string, Dictionary<int, List<T>>>>(state.Returns.ToString()) ?? new Dictionary<string, Dictionary<int, List<T>>>();
-        _epsilon = state.Epsilon;
-    }
-
-    public override IFullModel<T, Vector<T>, Vector<T>> Clone()
-    {
-        var clone = new OnPolicyMonteCarloAgent<T>(_options);
-
-        // Deep copy Q-table
-        foreach (var kvp in _qTable)
-        {
-            clone._qTable[kvp.Key] = new Dictionary<int, T>(kvp.Value);
-        }
-
-        // Deep copy returns
-        foreach (var kvp in _returns)
-        {
-            clone._returns[kvp.Key] = new Dictionary<int, List<T>>();
-            foreach (var returnKvp in kvp.Value)
-            {
-                clone._returns[kvp.Key][returnKvp.Key] = new List<T>(returnKvp.Value);
-            }
-        }
-
-        clone._epsilon = _epsilon;
-        return clone;
-    }
-
     public override void SaveModel(string filepath)
     {
         throw new NotSupportedException(
diff --git a/src/ReinforcementLearning/Agents/PPOAgent.cs b/src/ReinforcementLearning/Agents/PPOAgent.cs
index dc6061d407..46f4152146 100644
--- a/src/ReinforcementLearning/Agents/PPOAgent.cs
+++ b/src/ReinforcementLearning/Agents/PPOAgent.cs
@@ -611,54 +611,6 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    /// <inheritdoc/>
-    public override byte[] Serialize()
-    {
-        using var ms = new MemoryStream();
-        using var writer = new BinaryWriter(ms);
-
-        writer.Write(_ppoOptions.StateSize);
-        writer.Write(_ppoOptions.ActionSize);
-        writer.Write(_ppoOptions.IsContinuous);
-
-        var policyBytes = _policyNetwork.Serialize();
-        writer.Write(policyBytes.Length);
-        writer.Write(policyBytes);
-
-        var valueBytes = _valueNetwork.Serialize();
-        writer.Write(valueBytes.Length);
-        writer.Write(valueBytes);
-
-        return ms.ToArray();
-    }
-
-    /// <inheritdoc/>
-    public override void Deserialize(byte[] data)
-    {
-        using var ms = new MemoryStream(data);
-        using var reader = new BinaryReader(ms);
-
-        var stateSize = reader.ReadInt32();
-        var actionSize = reader.ReadInt32();
-        var isContinuous = reader.ReadBoolean();
-
-        var policyLength = reader.ReadInt32();
-        var policyBytes = reader.ReadBytes(policyLength);
-        _policyNetwork.Deserialize(policyBytes);
-
-        var valueLength = reader.ReadInt32();
-        var valueBytes = reader.ReadBytes(valueLength);
-        _valueNetwork.Deserialize(valueBytes);
-    }
-
-    /// <inheritdoc/>
-    public override IFullModel<T, Vector<T>, Vector<T>> Clone()
-    {
-        var clone = new PPOAgent<T>(_ppoOptions);
-        clone.SetParameters(GetParameters());
-        return clone;
-    }
-
     /// <inheritdoc/>
     public Vector<T> ComputeGradients(
         Vector<T> input,
diff --git a/src/ReinforcementLearning/Agents/PolicyIterationAgent.cs b/src/ReinforcementLearning/Agents/PolicyIterationAgent.cs
index a732ffdd04..f427769923 100644
--- a/src/ReinforcementLearning/Agents/PolicyIterationAgent.cs
+++ b/src/ReinforcementLearning/Agents/PolicyIterationAgent.cs
@@ -43,7 +43,7 @@ namespace AiDotNet.ReinforcementLearning.Agents.DynamicProgramming;
     "https://incompleteideas.net/book/the-book-2nd.html",
     Year = 2018,
     Authors = "Sutton, R. S. & Barto, A. G.")]
-public class PolicyIterationAgent<T> : ReinforcementLearningAgentBase<T>
+public partial class PolicyIterationAgent<T> : ReinforcementLearningAgentBase<T>
 {
     private PolicyIterationOptions<T> _options;
 
@@ -313,67 +313,6 @@ protected override void RegisterComponents()
 
     public override int FeatureCount => _options.StateSize;
 
-    public override byte[] Serialize()
-    {
-        var state = new
-        {
-            ValueTable = _valueTable,
-            Policy = _policy,
-            Model = _model,
-            Options = _options
-        };
-        string json = JsonConvert.SerializeObject(state);
-        return System.Text.Encoding.UTF8.GetBytes(json);
-    }
-
-    public override void Deserialize(byte[] data)
-    {
-        if (data is null || data.Length == 0)
-        {
-            throw new ArgumentException("Serialized data cannot be null or empty", nameof(data));
-        }
-
-        string json = System.Text.Encoding.UTF8.GetString(data);
-        var state = JsonConvert.DeserializeObject<dynamic>(json);
-        if (state is null)
-        {
-            throw new InvalidOperationException("Deserialization returned null");
-        }
-
-        _valueTable = JsonConvert.DeserializeObject<Dictionary<string, T>>(state.ValueTable.ToString()) ?? new Dictionary<string, T>();
-        _policy = JsonConvert.DeserializeObject<Dictionary<string, int>>(state.Policy.ToString()) ?? new Dictionary<string, int>();
-        _model = JsonConvert.DeserializeObject<Dictionary<string, Dictionary<int, List<(string, T, T)>>>>(state.Model.ToString()) ?? new Dictionary<string, Dictionary<int, List<(string, T, T)>>>();
-    }
-
-    public override IFullModel<T, Vector<T>, Vector<T>> Clone()
-    {
-        var clone = new PolicyIterationAgent<T>(_options);
-
-        // Deep copy value table
-        foreach (var kvp in _valueTable)
-        {
-            clone._valueTable[kvp.Key] = kvp.Value;
-        }
-
-        // Deep copy policy
-        foreach (var kvp in _policy)
-        {
-            clone._policy[kvp.Key] = kvp.Value;
-        }
-
-        // Deep copy model
-        foreach (var stateKvp in _model)
-        {
-            clone._model[stateKvp.Key] = new Dictionary<int, List<(string, T, T)>>();
-            foreach (var actionKvp in stateKvp.Value)
-            {
-                clone._model[stateKvp.Key][actionKvp.Key] = new List<(string, T, T)>(actionKvp.Value);
-            }
-        }
-
-        return clone;
-    }
-
     public override void SaveModel(string filepath)
     {
         if (string.IsNullOrWhiteSpace(filepath))
diff --git a/src/ReinforcementLearning/Agents/PrioritizedSweepingAgent.cs b/src/ReinforcementLearning/Agents/PrioritizedSweepingAgent.cs
index 617d7b539e..1ab26978d9 100644
--- a/src/ReinforcementLearning/Agents/PrioritizedSweepingAgent.cs
+++ b/src/ReinforcementLearning/Agents/PrioritizedSweepingAgent.cs
@@ -40,7 +40,7 @@ namespace AiDotNet.ReinforcementLearning.Agents.Planning;
     "https://doi.org/10.1023/A:1022635613229",
     Year = 1993,
     Authors = "Moore, A. W. & Atkeson, C. G.")]
-public class PrioritizedSweepingAgent<T> : ReinforcementLearningAgentBase<T>
+public partial class PrioritizedSweepingAgent<T> : ReinforcementLearningAgentBase<T>
 {
     private PrioritizedSweepingOptions<T> _options;
 
@@ -265,89 +265,6 @@ protected override void RegisterComponents()
                 () => _qTable));
     }
     public override int FeatureCount => _options.StateSize;
-    public override byte[] Serialize()
-    {
-        var state = new
-        {
-            QTable = _qTable,
-            Model = _model,
-            Predecessors = _predecessors,
-            PriorityQueue = _priorityQueue.ToList(),
-            Epsilon = _epsilon,
-            Options = _options
-        };
-        string json = JsonConvert.SerializeObject(state);
-        return System.Text.Encoding.UTF8.GetBytes(json);
-    }
-
-    public override void Deserialize(byte[] data)
-    {
-        if (data is null || data.Length == 0)
-        {
-            throw new ArgumentException("Serialized data cannot be null or empty", nameof(data));
-        }
-
-        string json = System.Text.Encoding.UTF8.GetString(data);
-        var state = JsonConvert.DeserializeObject<dynamic>(json);
-        if (state is null)
-        {
-            throw new InvalidOperationException("Deserialization returned null");
-        }
-
-        _qTable = JsonConvert.DeserializeObject<Dictionary<string, Dictionary<int, T>>>(state.QTable.ToString()) ?? new Dictionary<string, Dictionary<int, T>>();
-        _model = JsonConvert.DeserializeObject<Dictionary<string, Dictionary<int, (string, T)>>>(state.Model.ToString()) ?? new Dictionary<string, Dictionary<int, (string, T)>>();
-        _predecessors = JsonConvert.DeserializeObject<Dictionary<string, List<(string, int)>>>(state.Predecessors.ToString()) ?? new Dictionary<string, List<(string, int)>>();
-
-        var priorityList = JsonConvert.DeserializeObject<List<(double, string, int)>>(state.PriorityQueue.ToString()) ?? new List<(double, string, int)>();
-        _priorityQueue.Clear();
-        foreach (var item in priorityList)
-        {
-            _priorityQueue.Add(item);
-        }
-
-        _epsilon = state.Epsilon;
-    }
-    public override IFullModel<T, Vector<T>, Vector<T>> Clone()
-    {
-        var cloned = new PrioritizedSweepingAgent<T>(_options);
-
-        // Deep copy Q-table
-        foreach (var stateEntry in _qTable)
-        {
-            cloned._qTable[stateEntry.Key] = new Dictionary<int, T>();
-            foreach (var actionEntry in stateEntry.Value)
-            {
-                cloned._qTable[stateEntry.Key][actionEntry.Key] = actionEntry.Value;
-            }
-        }
-
-        // Deep copy model
-        foreach (var stateEntry in _model)
-        {
-            cloned._model[stateEntry.Key] = new Dictionary<int, (string, T)>();
-            foreach (var actionEntry in stateEntry.Value)
-            {
-                cloned._model[stateEntry.Key][actionEntry.Key] = actionEntry.Value;
-            }
-        }
-
-        // Deep copy predecessors
-        foreach (var stateEntry in _predecessors)
-        {
-            cloned._predecessors[stateEntry.Key] = new List<(string, int)>(stateEntry.Value);
-        }
-
-        // Deep copy priority queue
-        foreach (var item in _priorityQueue)
-        {
-            cloned._priorityQueue.Add(item);
-        }
-
-        // Copy epsilon value
-        cloned._epsilon = _epsilon;
-
-        return cloned;
-    }
 
     public override void SaveModel(string filepath)
     {
diff --git a/src/ReinforcementLearning/Agents/QLambdaAgent.cs b/src/ReinforcementLearning/Agents/QLambdaAgent.cs
index 2a79f19818..aedaa980fb 100644
--- a/src/ReinforcementLearning/Agents/QLambdaAgent.cs
+++ b/src/ReinforcementLearning/Agents/QLambdaAgent.cs
@@ -55,7 +55,7 @@ namespace AiDotNet.ReinforcementLearning.Agents.EligibilityTraces;
     "https://www.cs.rhul.ac.uk/~chrisw/new_thesis.pdf",
     Year = 1989,
     Authors = "Watkins, C. J. C. H.")]
-public class QLambdaAgent<T> : ReinforcementLearningAgentBase<T>
+public partial class QLambdaAgent<T> : ReinforcementLearningAgentBase<T>
 {
     private QLambdaOptions<T> _options;
 
@@ -256,74 +256,6 @@ protected override void RegisterComponents()
                 () => _qTable));
     }
     public override int FeatureCount => _options.StateSize;
-    public override byte[] Serialize()
-    {
-        var state = new
-        {
-            QTable = _qTable,
-            EligibilityTraces = _eligibilityTraces,
-            ActiveTraceStates = _activeTraceStates,
-            Epsilon = _epsilon,
-            Options = _options
-        };
-        string json = JsonConvert.SerializeObject(state);
-        return System.Text.Encoding.UTF8.GetBytes(json);
-    }
-
-    public override void Deserialize(byte[] data)
-    {
-        if (data is null || data.Length == 0)
-        {
-            throw new ArgumentException("Serialized data cannot be null or empty", nameof(data));
-        }
-
-        string json = System.Text.Encoding.UTF8.GetString(data);
-        var state = JsonConvert.DeserializeObject<dynamic>(json);
-        if (state is null)
-        {
-            throw new InvalidOperationException("Deserialization returned null");
-        }
-
-        _qTable = JsonConvert.DeserializeObject<Dictionary<string, Dictionary<int, T>>>(state.QTable.ToString()) ?? new Dictionary<string, Dictionary<int, T>>();
-        _eligibilityTraces = JsonConvert.DeserializeObject<Dictionary<string, Dictionary<int, T>>>(state.EligibilityTraces.ToString()) ?? new Dictionary<string, Dictionary<int, T>>();
-        _activeTraceStates = JsonConvert.DeserializeObject<HashSet<string>>(state.ActiveTraceStates.ToString()) ?? new HashSet<string>();
-        _epsilon = state.Epsilon;
-    }
-    public override IFullModel<T, Vector<T>, Vector<T>> Clone()
-    {
-        var clone = new QLambdaAgent<T>(_options);
-
-        // Deep-copy Q-table
-        foreach (var stateEntry in _qTable)
-        {
-            clone._qTable[stateEntry.Key] = new Dictionary<int, T>();
-            foreach (var actionEntry in stateEntry.Value)
-            {
-                clone._qTable[stateEntry.Key][actionEntry.Key] = actionEntry.Value;
-            }
-        }
-
-        // Deep-copy eligibility traces
-        foreach (var stateEntry in _eligibilityTraces)
-        {
-            clone._eligibilityTraces[stateEntry.Key] = new Dictionary<int, T>();
-            foreach (var actionEntry in stateEntry.Value)
-            {
-                clone._eligibilityTraces[stateEntry.Key][actionEntry.Key] = actionEntry.Value;
-            }
-        }
-
-        // Copy active trace states
-        foreach (var stateKey in _activeTraceStates)
-        {
-            clone._activeTraceStates.Add(stateKey);
-        }
-
-        // Copy epsilon value
-        clone._epsilon = _epsilon;
-
-        return clone;
-    }
     public override void SaveModel(string filepath)
     {
         if (string.IsNullOrWhiteSpace(filepath))
diff --git a/src/ReinforcementLearning/Agents/QMIXAgent.cs b/src/ReinforcementLearning/Agents/QMIXAgent.cs
index 9295ffe7d8..062be12fe5 100644
--- a/src/ReinforcementLearning/Agents/QMIXAgent.cs
+++ b/src/ReinforcementLearning/Agents/QMIXAgent.cs
@@ -698,52 +698,6 @@ public override ModelMetadata<T> GetModelMetadata()
 
     public override int FeatureCount => _options.StateSize;
 
-    public override byte[] Serialize()
-    {
-        var parameters = GetParameters();
-        var state = new
-        {
-            Parameters = parameters,
-            NumAgents = _options.NumAgents,
-            StateSize = _options.StateSize,
-            ActionSize = _options.ActionSize
-        };
-        string json = JsonConvert.SerializeObject(state);
-        return System.Text.Encoding.UTF8.GetBytes(json);
-    }
-
-    public override void Deserialize(byte[] data)
-    {
-        if (data is null || data.Length == 0)
-        {
-            throw new ArgumentException("Serialized data cannot be null or empty", nameof(data));
-        }
-
-        string json = System.Text.Encoding.UTF8.GetString(data);
-        var state = JsonConvert.DeserializeObject<dynamic>(json);
-        if (state is null)
-        {
-            throw new InvalidOperationException("Deserialization returned null");
-        }
-
-        var parameters = JsonConvert.DeserializeObject<Vector<T>>(state.Parameters.ToString());
-        if (parameters is not null)
-        {
-            SetParameters(parameters);
-        }
-    }
-
-    public override IFullModel<T, Vector<T>, Vector<T>> Clone()
-    {
-        var clonedAgent = new QMIXAgent<T>(_options, _optimizer);
-
-        // Copy trained network parameters to the cloned agent
-        var currentParams = GetParameters();
-        clonedAgent.SetParameters(currentParams);
-
-        return clonedAgent;
-    }
-
     /// <summary>
     /// Computes gradients of the loss with respect to this agent's parameters, without updating them.
     /// </summary>
diff --git a/src/ReinforcementLearning/Agents/REINFORCEAgent.cs b/src/ReinforcementLearning/Agents/REINFORCEAgent.cs
index 1152c7d790..273aaaaf61 100644
--- a/src/ReinforcementLearning/Agents/REINFORCEAgent.cs
+++ b/src/ReinforcementLearning/Agents/REINFORCEAgent.cs
@@ -413,44 +413,6 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    /// <inheritdoc/>
-    public override byte[] Serialize()
-    {
-        using var ms = new MemoryStream();
-        using var writer = new BinaryWriter(ms);
-
-        writer.Write(_reinforceOptions.StateSize);
-        writer.Write(_reinforceOptions.ActionSize);
-
-        var policyBytes = _policyNetwork.Serialize();
-        writer.Write(policyBytes.Length);
-        writer.Write(policyBytes);
-
-        return ms.ToArray();
-    }
-
-    /// <inheritdoc/>
-    public override void Deserialize(byte[] data)
-    {
-        using var ms = new MemoryStream(data);
-        using var reader = new BinaryReader(ms);
-
-        reader.ReadInt32(); // stateSize
-        reader.ReadInt32(); // actionSize
-
-        var policyLength = reader.ReadInt32();
-        var policyBytes = reader.ReadBytes(policyLength);
-        _policyNetwork.Deserialize(policyBytes);
-    }
-
-    /// <inheritdoc/>
-    public override IFullModel<T, Vector<T>, Vector<T>> Clone()
-    {
-        var clone = new REINFORCEAgent<T>(_reinforceOptions);
-        clone.SetParameters(GetParameters());
-        return clone;
-    }
-
     /// <inheritdoc/>
     public Vector<T> ComputeGradients(
         Vector<T> input, Vector<T> target, ILossFunction<T>? lossFunction = null)
diff --git a/src/ReinforcementLearning/Agents/RainbowDQNAgent.cs b/src/ReinforcementLearning/Agents/RainbowDQNAgent.cs
index 9bc1b1c601..18e6309706 100644
--- a/src/ReinforcementLearning/Agents/RainbowDQNAgent.cs
+++ b/src/ReinforcementLearning/Agents/RainbowDQNAgent.cs
@@ -629,85 +629,8 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    public override byte[] Serialize()
-    {
-        using var ms = new MemoryStream();
-        using var writer = new BinaryWriter(ms);
-
-        // Write metadata
-        writer.Write(_options.StateSize);
-        writer.Write(_options.ActionSize);
-        writer.Write(_options.NumAtoms);
-        writer.Write(_options.VMin);
-        writer.Write(_options.VMax);
-        writer.Write(_options.NSteps);
-        writer.Write(_options.UseDistributional);
-        writer.Write(_options.UseNoisyNetworks);
-
-        // Write training state
-        writer.Write(_epsilon);
-        writer.Write(_stepCount);
-        writer.Write(_updateCount);
-        writer.Write(_beta);
-
-        // Write online network
-        var onlineNetworkBytes = _onlineNetwork.Serialize();
-        writer.Write(onlineNetworkBytes.Length);
-        writer.Write(onlineNetworkBytes);
-
-        // Write target network
-        var targetNetworkBytes = _targetNetwork.Serialize();
-        writer.Write(targetNetworkBytes.Length);
-        writer.Write(targetNetworkBytes);
-
-        return ms.ToArray();
-    }
-
-    public override void Deserialize(byte[] data)
-    {
-        using var ms = new MemoryStream(data);
-        using var reader = new BinaryReader(ms);
-
-        // Read and validate metadata
-        var stateSize = reader.ReadInt32();
-        var actionSize = reader.ReadInt32();
-        var numAtoms = reader.ReadInt32();
-        var vMin = reader.ReadDouble();
-        var vMax = reader.ReadDouble();
-        var nStepReturn = reader.ReadInt32();
-        var useDistributional = reader.ReadBoolean();
-        var useNoisyNetworks = reader.ReadBoolean();
-
-        if (stateSize != _options.StateSize || actionSize != _options.ActionSize)
-            throw new InvalidOperationException("Serialized network dimensions don't match current options");
-
-        // Read training state
-        _epsilon = reader.ReadDouble();
-        _stepCount = reader.ReadInt32();
-        _updateCount = reader.ReadInt32();
-        _beta = reader.ReadDouble();
-
-        // Read online network
-        var onlineNetworkLength = reader.ReadInt32();
-        var onlineNetworkBytes = reader.ReadBytes(onlineNetworkLength);
-        _onlineNetwork.Deserialize(onlineNetworkBytes);
-
-        // Read target network
-        var targetNetworkLength = reader.ReadInt32();
-        var targetNetworkBytes = reader.ReadBytes(targetNetworkLength);
-        _targetNetwork.Deserialize(targetNetworkBytes);
-    }
-
     public override int FeatureCount => _options.StateSize;
 
-    public override IFullModel<T, Vector<T>, Vector<T>> Clone()
-    {
-        var clone = new RainbowDQNAgent<T>(_options, _optimizer);
-        // Copy learned network parameters to preserve trained state
-        clone.SetParameters(GetParameters());
-        return clone;
-    }
-
     /// <summary>
     /// Computes gradients of the loss with respect to this agent's parameters, without updating them.
     /// </summary>
diff --git a/src/ReinforcementLearning/Agents/ReinforcementLearningAgentBase.cs b/src/ReinforcementLearning/Agents/ReinforcementLearningAgentBase.cs
index a84e3ffd25..98a9d660f6 100644
--- a/src/ReinforcementLearning/Agents/ReinforcementLearningAgentBase.cs
+++ b/src/ReinforcementLearning/Agents/ReinforcementLearningAgentBase.cs
@@ -32,9 +32,52 @@ namespace AiDotNet.ReinforcementLearning.Agents;
 /// their own unique learning logic while sharing common functionality.
 /// </para>
 /// </remarks>
-public abstract class ReinforcementLearningAgentBase<T> : IRLAgent<T>, IConfigurableModel<T>, IModelShape, IDisposable,
+public abstract partial class ReinforcementLearningAgentBase<T> : IRLAgent<T>, IConfigurableModel<T>, IModelShape, IDisposable,
     AiDotNet.Models.Parameters.IParameterManifestProvider
 {
+    // --- declared state (ModelStateRegistry) ---
+    // Identical in every model base because these bases are siblings over the same interfaces rather
+    // than one hierarchy; the logic itself lives once in ModelStateRegistry/ModelStateEnvelope.
+
+    /// <summary>State that is not a parameter vector, declared once and persisted by this base.</summary>
+    private readonly AiDotNet.Models.ModelStateRegistry<T> _declaredState = new();
+    private bool _declaredStateRegistered;
+
+    /// <summary>
+    /// Declare state here that the parameter vector does not carry -- a retained training set,
+    /// fitted knots, kernel centres, an ensemble's children. Both halves of the payload are driven
+    /// by the declaration, so they cannot drift.
+    /// </summary>
+    /// <param name="state">The registry to declare into.</param>
+    protected virtual void RegisterState(AiDotNet.Models.ModelStateRegistry<T> state)
+    {
+    }
+    /// <summary>Generated state declarations for fields declared across this model's hierarchy.</summary>
+    /// <param name="state">The registry to declare into.</param>
+    /// <remarks>
+    /// Emitted by ModelStateGenerator into the partial model, so a model author declares nothing. The
+    /// hand-written <c>RegisterState</c> beside it exists only for state the classifier genuinely
+    /// cannot place; anything it CAN place belongs here, where it cannot be forgotten.
+    /// </remarks>
+    protected virtual void RegisterGeneratedState(AiDotNet.Models.ModelStateRegistry<T> state)
+    {
+        RegisterGeneratedStateCore(state);
+    }
+
+    /// <summary>The declared state, registered once and lazily so it runs after the constructor.</summary>
+    protected AiDotNet.Models.ModelStateRegistry<T> DeclaredState
+    {
+        get
+        {
+            if (!_declaredStateRegistered)
+            {
+                _declaredStateRegistered = true;
+                RegisterGeneratedState(_declaredState);
+                RegisterState(_declaredState);
+            }
+            return _declaredState;
+        }
+    }
     /// <summary>
     /// Numeric operations provider for type T.
     /// </summary>
@@ -299,11 +342,97 @@ public virtual void Train(Vector<T> state, Vector<T> target)
     /// </summary>
     public abstract byte[] Serialize();
 
+    /// <summary>
+    /// Implements the common generated serialization surface for agents that do not own a legacy
+    /// external format. ModelStateGenerator emits the public override that delegates here.
+    /// </summary>
+    protected byte[] SerializeGeneratedModelState()
+    {
+        ModelPersistenceGuard.EnforceBeforeSerialize();
+
+        var parameters = GetParameters();
+        using var stream = new MemoryStream();
+        using var writer = new BinaryWriter(stream, System.Text.Encoding.UTF8, leaveOpen: true);
+
+        writer.Write(AgentSerializationMagicV2);
+        writer.Write(GetType().FullName ?? GetType().Name);
+        writer.Write(parameters.Length);
+        for (int i = 0; i < parameters.Length; i++)
+        {
+            writer.Write(Convert.ToDouble(parameters[i]));
+        }
+
+        _parameterRegistry.WriteParameterTopologies(writer);
+        DeclaredState.WriteAll(writer);
+        writer.Flush();
+        return stream.ToArray();
+    }
+
     /// <summary>
     /// Deserializes the agent from bytes.
     /// </summary>
     public abstract void Deserialize(byte[] data);
 
+    /// <summary>
+    /// Implements the common generated deserialization surface paired with
+    /// <see cref="SerializeGeneratedModelState"/>.
+    /// </summary>
+    protected void DeserializeGeneratedModelState(byte[] data)
+    {
+        if (data is null) throw new ArgumentNullException(nameof(data));
+        ModelPersistenceGuard.EnforceBeforeDeserialize();
+
+        using var stream = new MemoryStream(data);
+        using var reader = new BinaryReader(stream, System.Text.Encoding.UTF8, leaveOpen: true);
+
+        int magic = reader.ReadInt32();
+        if (magic != AgentSerializationMagicV1 && magic != AgentSerializationMagicV2)
+        {
+            throw new InvalidDataException(
+                $"{GetType().Name}: payload is not an AiDotNet reinforcement-learning agent state block.");
+        }
+
+        string savedType = reader.ReadString();
+        string liveType = GetType().FullName ?? GetType().Name;
+        if (!string.Equals(savedType, liveType, StringComparison.Ordinal))
+        {
+            throw new InvalidDataException(
+                $"State was saved from '{savedType}' and is being loaded into '{liveType}'.");
+        }
+
+        int count = reader.ReadInt32();
+        if (count < 0)
+        {
+            throw new InvalidDataException($"Agent parameter count cannot be negative ({count}).");
+        }
+
+        var parameters = new Vector<T>(count);
+        for (int i = 0; i < count; i++)
+        {
+            parameters[i] = NumOps.FromDouble(reader.ReadDouble());
+        }
+
+        // Keys and shapes are state, not values. Recreate them before generated state and the flat
+        // vector are restored so sparse/tabular sources expose the same slots as the checkpoint.
+        if (magic == AgentSerializationMagicV2)
+        {
+            _ = Components;
+            _parameterRegistry.ReadParameterTopologies(reader);
+        }
+
+        // State can materialize variable-length storage and child components. Restore it before the
+        // flat vector so SetParameters sees the saved structure and remains authoritative for values.
+        if (reader.BaseStream.Position < reader.BaseStream.Length)
+        {
+            DeclaredState.ReadAll(reader);
+        }
+
+        SetParameters(parameters);
+    }
+
+    private const int AgentSerializationMagicV1 = unchecked((int)0xA1D0A63E);
+    private const int AgentSerializationMagicV2 = unchecked((int)0xA1D0A63F);
+
     /// <summary>
     /// Gets the agent's parameters.
     /// </summary>
@@ -503,7 +632,28 @@ public virtual void SetActiveFeatureIndices(IEnumerable<int> indices)
     /// <summary>
     /// Clones the agent.
     /// </summary>
-    public abstract IFullModel<T, Vector<T>, Vector<T>> Clone();
+    /// <remarks>
+    /// <para>
+    /// No longer abstract. Configuration is rebuilt from the compile-time clone plan, which records
+    /// the constructor the type was built with; learned state is carried through the model's own
+    /// public Serialize and Deserialize, so a model that persists something extra keeps it. The
+    /// persistence guard is told this is an internal operation because a clone is not a save.
+    /// </para>
+    /// <para>
+    /// A model overrides this only when the generator reports that it cannot rebuild the type --
+    /// a constructor parameter with no member holding its value -- and the build names which one.
+    /// </para>
+    /// </remarks>
+    public virtual IFullModel<T, Vector<T>, Vector<T>> Clone()
+    {
+        using (ModelPersistenceGuard.InternalOperation())
+        {
+            byte[] state = Serialize();
+            var copy = (ReinforcementLearningAgentBase<T>)AiDotNet.Models.CloneEngine.CopyConfiguration(this);
+            copy.Deserialize(state);
+            return copy;
+        }
+    }
 
     /// <summary>
     /// Creates a deep copy of the agent.
diff --git a/src/ReinforcementLearning/Agents/SACAgent.cs b/src/ReinforcementLearning/Agents/SACAgent.cs
index 11a6032e8d..5b589c2c8e 100644
--- a/src/ReinforcementLearning/Agents/SACAgent.cs
+++ b/src/ReinforcementLearning/Agents/SACAgent.cs
@@ -644,64 +644,6 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    /// <inheritdoc/>
-    public override byte[] Serialize()
-    {
-        using var ms = new MemoryStream();
-        using var writer = new BinaryWriter(ms);
-
-        writer.Write(_sacOptions.StateSize);
-        writer.Write(_sacOptions.ActionSize);
-        writer.Write(NumOps.ToDouble(_logAlpha));
-
-        void WriteNetwork(INeuralNetwork<T> net)
-        {
-            var bytes = net.Serialize();
-            writer.Write(bytes.Length);
-            writer.Write(bytes);
-        }
-
-        WriteNetwork(_policyNetwork);
-        WriteNetwork(_q1Network);
-        WriteNetwork(_q2Network);
-        WriteNetwork(_q1TargetNetwork);
-        WriteNetwork(_q2TargetNetwork);
-
-        return ms.ToArray();
-    }
-
-    /// <inheritdoc/>
-    public override void Deserialize(byte[] data)
-    {
-        using var ms = new MemoryStream(data);
-        using var reader = new BinaryReader(ms);
-
-        reader.ReadInt32(); // stateSize
-        reader.ReadInt32(); // actionSize
-        _logAlpha = NumOps.FromDouble(reader.ReadDouble());
-
-        void ReadNetwork(INeuralNetwork<T> net)
-        {
-            var len = reader.ReadInt32();
-            var bytes = reader.ReadBytes(len);
-            net.Deserialize(bytes);
-        }
-
-        ReadNetwork(_policyNetwork);
-        ReadNetwork(_q1Network);
-        ReadNetwork(_q2Network);
-        ReadNetwork(_q1TargetNetwork);
-        ReadNetwork(_q2TargetNetwork);
-    }
-
-    /// <inheritdoc/>
-    public override IFullModel<T, Vector<T>, Vector<T>> Clone()
-    {
-        var clone = new SACAgent<T>(_sacOptions);
-        clone.SetParameters(GetParameters());
-        return clone;
-    }
-
     /// <inheritdoc/>
     public Vector<T> ComputeGradients(
         Vector<T> input, Vector<T> target, ILossFunction<T>? lossFunction = null)
diff --git a/src/ReinforcementLearning/Agents/SARSAAgent.cs b/src/ReinforcementLearning/Agents/SARSAAgent.cs
index ae65549a32..41715f97da 100644
--- a/src/ReinforcementLearning/Agents/SARSAAgent.cs
+++ b/src/ReinforcementLearning/Agents/SARSAAgent.cs
@@ -57,7 +57,7 @@ namespace AiDotNet.ReinforcementLearning.Agents.SARSA;
     "https://citeseerx.ist.psu.edu/doc/10.1.1.17.2539",
     Year = 1994,
     Authors = "Rummery, G. A. & Niranjan, M.")]
-public class SARSAAgent<T> : ReinforcementLearningAgentBase<T>, IGradientComputable<T, Vector<T>, Vector<T>>
+public partial class SARSAAgent<T> : ReinforcementLearningAgentBase<T>, IGradientComputable<T, Vector<T>, Vector<T>>
 {
 
     /// <inheritdoc />
@@ -76,7 +76,9 @@ protected override void RegisterComponents()
     private Random _random;
 
     // Track last state-action for SARSA update
+    [Scratch]
     private Vector<T>? _lastState;
+    [Scratch]
     private Vector<T>? _lastAction;
 
     /// <summary>
@@ -247,50 +249,6 @@ public override ModelMetadata<T> GetModelMetadata()
 
     public override int FeatureCount => _options.StateSize;
 
-    public override byte[] Serialize()
-    {
-        var state = new
-        {
-            QTable = _qTable,
-            Epsilon = _epsilon,
-            Options = _options
-        };
-        string json = JsonConvert.SerializeObject(state);
-        return System.Text.Encoding.UTF8.GetBytes(json);
-    }
-
-    public override void Deserialize(byte[] data)
-    {
-        if (data is null || data.Length == 0)
-        {
-            throw new ArgumentException("Serialized data cannot be null or empty", nameof(data));
-        }
-
-        string json = System.Text.Encoding.UTF8.GetString(data);
-        var state = JsonConvert.DeserializeObject<dynamic>(json);
-        if (state is null)
-        {
-            throw new InvalidOperationException("Deserialization returned null");
-        }
-
-        _qTable = JsonConvert.DeserializeObject<Dictionary<string, Dictionary<int, T>>>(state.QTable.ToString()) ?? new Dictionary<string, Dictionary<int, T>>();
-        _epsilon = state.Epsilon;
-    }
-
-    public override IFullModel<T, Vector<T>, Vector<T>> Clone()
-    {
-        var clone = new SARSAAgent<T>(_options);
-
-        // Deep copy Q-table to avoid shared state
-        foreach (var kvp in _qTable)
-        {
-            clone._qTable[kvp.Key] = new Dictionary<int, T>(kvp.Value);
-        }
-
-        clone._epsilon = _epsilon;
-        return clone;
-    }
-
     public Vector<T> ComputeGradients(
         Vector<T> input,
         Vector<T> target,
diff --git a/src/ReinforcementLearning/Agents/SARSALambdaAgent.cs b/src/ReinforcementLearning/Agents/SARSALambdaAgent.cs
index 5092770001..e9a2d59ce7 100644
--- a/src/ReinforcementLearning/Agents/SARSALambdaAgent.cs
+++ b/src/ReinforcementLearning/Agents/SARSALambdaAgent.cs
@@ -57,7 +57,7 @@ namespace AiDotNet.ReinforcementLearning.Agents.EligibilityTraces;
     "https://incompleteideas.net/book/the-book-2nd.html",
     Year = 2018,
     Authors = "Sutton, R. S. & Barto, A. G.")]
-public class SARSALambdaAgent<T> : ReinforcementLearningAgentBase<T>
+public partial class SARSALambdaAgent<T> : ReinforcementLearningAgentBase<T>
 {
     private SARSALambdaOptions<T> _options;
 
@@ -226,58 +226,6 @@ protected override void RegisterComponents()
                 () => _qTable));
     }
     public override int FeatureCount => _options.StateSize;
-    public override byte[] Serialize()
-    {
-        var state = new
-        {
-            QTable = _qTable,
-            EligibilityTraces = _eligibilityTraces,
-            Epsilon = _epsilon,
-            Options = _options
-        };
-        string json = JsonConvert.SerializeObject(state);
-        return System.Text.Encoding.UTF8.GetBytes(json);
-    }
-
-    public override void Deserialize(byte[] data)
-    {
-        if (data is null || data.Length == 0)
-        {
-            throw new ArgumentException("Serialized data cannot be null or empty", nameof(data));
-        }
-
-        string json = System.Text.Encoding.UTF8.GetString(data);
-        var state = JsonConvert.DeserializeObject<dynamic>(json);
-        if (state is null)
-        {
-            throw new InvalidOperationException("Deserialization returned null");
-        }
-
-        _qTable = JsonConvert.DeserializeObject<Dictionary<string, Dictionary<int, T>>>(state.QTable.ToString()) ?? new Dictionary<string, Dictionary<int, T>>();
-        _eligibilityTraces = JsonConvert.DeserializeObject<Dictionary<string, Dictionary<int, T>>>(state.EligibilityTraces.ToString()) ?? new Dictionary<string, Dictionary<int, T>>();
-        _epsilon = state.Epsilon;
-    }
-    public override IFullModel<T, Vector<T>, Vector<T>> Clone()
-    {
-        var clone = new SARSALambdaAgent<T>(_options);
-
-        // Deep copy Q-table and eligibility traces to avoid shared state
-        foreach (var kvp in _qTable)
-        {
-            clone._qTable[kvp.Key] = new Dictionary<int, T>(kvp.Value);
-        }
-
-        foreach (var kvp in _eligibilityTraces)
-        {
-            clone._eligibilityTraces[kvp.Key] = new Dictionary<int, T>(kvp.Value);
-        }
-
-        clone._epsilon = _epsilon;
-        clone._lastState = _lastState.Clone();
-        clone._lastAction = _lastAction;
-
-        return clone;
-    }
     public override void SaveModel(string filepath)
     {
         if (string.IsNullOrWhiteSpace(filepath))
diff --git a/src/ReinforcementLearning/Agents/TD3Agent.cs b/src/ReinforcementLearning/Agents/TD3Agent.cs
index 3e68f4b3c7..93f236c6d9 100644
--- a/src/ReinforcementLearning/Agents/TD3Agent.cs
+++ b/src/ReinforcementLearning/Agents/TD3Agent.cs
@@ -481,14 +481,6 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    /// <inheritdoc/>
-    public override IFullModel<T, Vector<T>, Vector<T>> Clone()
-    {
-        var clone = new TD3Agent<T>(_options);
-        clone.SetParameters(GetParameters());
-        return clone;
-    }
-
     /// <inheritdoc/>
     public Vector<T> ComputeGradients(
         Vector<T> input, Vector<T> target, ILossFunction<T>? lossFunction = null)
@@ -504,80 +496,6 @@ public override void ApplyGradients(Vector<T> gradients, T learningRate)
         // TD3 uses direct network updates during training, not manual gradient application
     }
 
-    /// <inheritdoc/>
-    public override byte[] Serialize()
-    {
-        using var ms = new MemoryStream();
-        using var writer = new BinaryWriter(ms);
-
-        writer.Write(_options.StateSize);
-        writer.Write(_options.ActionSize);
-        writer.Write(_stepCount);
-        writer.Write(_updateCount);
-
-        var actorBytes = _actorNetwork.Serialize();
-        writer.Write(actorBytes.Length);
-        writer.Write(actorBytes);
-
-        var targetActorBytes = _targetActorNetwork.Serialize();
-        writer.Write(targetActorBytes.Length);
-        writer.Write(targetActorBytes);
-
-        var critic1Bytes = _critic1Network.Serialize();
-        writer.Write(critic1Bytes.Length);
-        writer.Write(critic1Bytes);
-
-        var critic2Bytes = _critic2Network.Serialize();
-        writer.Write(critic2Bytes.Length);
-        writer.Write(critic2Bytes);
-
-        var targetCritic1Bytes = _targetCritic1Network.Serialize();
-        writer.Write(targetCritic1Bytes.Length);
-        writer.Write(targetCritic1Bytes);
-
-        var targetCritic2Bytes = _targetCritic2Network.Serialize();
-        writer.Write(targetCritic2Bytes.Length);
-        writer.Write(targetCritic2Bytes);
-
-        return ms.ToArray();
-    }
-
-    /// <inheritdoc/>
-    public override void Deserialize(byte[] data)
-    {
-        using var ms = new MemoryStream(data);
-        using var reader = new BinaryReader(ms);
-
-        reader.ReadInt32(); // stateSize
-        reader.ReadInt32(); // actionSize
-        _stepCount = reader.ReadInt32();
-        _updateCount = reader.ReadInt32();
-
-        var actorLength = reader.ReadInt32();
-        var actorBytes = reader.ReadBytes(actorLength);
-        _actorNetwork.Deserialize(actorBytes);
-
-        var targetActorLength = reader.ReadInt32();
-        var targetActorBytes = reader.ReadBytes(targetActorLength);
-        _targetActorNetwork.Deserialize(targetActorBytes);
-
-        var critic1Length = reader.ReadInt32();
-        var critic1Bytes = reader.ReadBytes(critic1Length);
-        _critic1Network.Deserialize(critic1Bytes);
-
-        var critic2Length = reader.ReadInt32();
-        var critic2Bytes = reader.ReadBytes(critic2Length);
-        _critic2Network.Deserialize(critic2Bytes);
-
-        var targetCritic1Length = reader.ReadInt32();
-        var targetCritic1Bytes = reader.ReadBytes(targetCritic1Length);
-        _targetCritic1Network.Deserialize(targetCritic1Bytes);
-
-        var targetCritic2Length = reader.ReadInt32();
-        var targetCritic2Bytes = reader.ReadBytes(targetCritic2Length);
-        _targetCritic2Network.Deserialize(targetCritic2Bytes);
-    }
-
     /// <inheritdoc/>
     public override void SaveModel(string filepath)
     {
diff --git a/src/ReinforcementLearning/Agents/TRPOAgent.cs b/src/ReinforcementLearning/Agents/TRPOAgent.cs
index a4e1988392..80233c3a2a 100644
--- a/src/ReinforcementLearning/Agents/TRPOAgent.cs
+++ b/src/ReinforcementLearning/Agents/TRPOAgent.cs
@@ -602,60 +602,6 @@ public override ModelMetadata<T> GetModelMetadata()
 
     public override int FeatureCount => _options.StateSize;
 
-    public override byte[] Serialize()
-    {
-        using var ms = new MemoryStream();
-        using var writer = new BinaryWriter(ms);
-
-        // Serialize policy network
-        var policyBytes = _policyNetwork.Serialize();
-        writer.Write(policyBytes.Length);
-        writer.Write(policyBytes);
-
-        // Serialize value network
-        var valueBytes = _valueNetwork.Serialize();
-        writer.Write(valueBytes.Length);
-        writer.Write(valueBytes);
-
-        // Serialize old policy network
-        var oldPolicyBytes = _oldPolicyNetwork.Serialize();
-        writer.Write(oldPolicyBytes.Length);
-        writer.Write(oldPolicyBytes);
-
-        return ms.ToArray();
-    }
-
-    public override void Deserialize(byte[] data)
-    {
-        using var ms = new MemoryStream(data);
-        using var reader = new BinaryReader(ms);
-
-        // Deserialize policy network
-        var policyLength = reader.ReadInt32();
-        var policyBytes = reader.ReadBytes(policyLength);
-        _policyNetwork.Deserialize(policyBytes);
-
-        // Deserialize value network
-        var valueLength = reader.ReadInt32();
-        var valueBytes = reader.ReadBytes(valueLength);
-        _valueNetwork.Deserialize(valueBytes);
-
-        // Deserialize old policy network
-        var oldPolicyLength = reader.ReadInt32();
-        var oldPolicyBytes = reader.ReadBytes(oldPolicyLength);
-        _oldPolicyNetwork.Deserialize(oldPolicyBytes);
-    }
-
-    public override IFullModel<T, Vector<T>, Vector<T>> Clone()
-    {
-        // Preserve the learned policy: a fresh TRPOAgent re-initialises its policy and
-        // value networks with new random weights, so without copying the trained
-        // parameters the clone would implement a different policy than the original.
-        var clone = new TRPOAgent<T>(_options, _optimizer);
-        clone.SetParameters(GetParameters());
-        return clone;
-    }
-
     /// <summary>
     /// Computes gradients of the loss with respect to this agent's parameters, without updating them.
     /// </summary>
diff --git a/src/ReinforcementLearning/Agents/TabularActorCriticAgent.cs b/src/ReinforcementLearning/Agents/TabularActorCriticAgent.cs
index b7af81f69d..bd846497bc 100644
--- a/src/ReinforcementLearning/Agents/TabularActorCriticAgent.cs
+++ b/src/ReinforcementLearning/Agents/TabularActorCriticAgent.cs
@@ -40,7 +40,7 @@ namespace AiDotNet.ReinforcementLearning.Agents.AdvancedRL;
     "https://incompleteideas.net/book/the-book-2nd.html",
     Year = 2018,
     Authors = "Sutton, R. S. & Barto, A. G.")]
-public class TabularActorCriticAgent<T> : ReinforcementLearningAgentBase<T>
+public partial class TabularActorCriticAgent<T> : ReinforcementLearningAgentBase<T>
 {
     private TabularActorCriticOptions<T> _options;
 
@@ -194,62 +194,6 @@ protected override void RegisterComponents()
                 () => _policy));
     }
     public override int FeatureCount => _options.StateSize;
-    public override byte[] Serialize()
-    {
-        using var ms = new MemoryStream();
-        using var writer = new BinaryWriter(ms);
-
-        writer.Write(_valueTable.Count);
-        foreach (var kvp in _valueTable)
-        {
-            writer.Write(kvp.Key);
-            writer.Write(NumOps.ToDouble(kvp.Value));
-        }
-
-        writer.Write(_policy.Count);
-        foreach (var stateEntry in _policy)
-        {
-            writer.Write(stateEntry.Key);
-            writer.Write(stateEntry.Value.Count);
-            foreach (var actionEntry in stateEntry.Value)
-            {
-                writer.Write(actionEntry.Key);
-                writer.Write(NumOps.ToDouble(actionEntry.Value));
-            }
-        }
-
-        return ms.ToArray();
-    }
-
-    public override void Deserialize(byte[] data)
-    {
-        using var ms = new MemoryStream(data);
-        using var reader = new BinaryReader(ms);
-
-        int valueCount = reader.ReadInt32();
-        _valueTable.Clear();
-        for (int i = 0; i < valueCount; i++)
-        {
-            string key = reader.ReadString();
-            double value = reader.ReadDouble();
-            _valueTable[key] = NumOps.FromDouble(value);
-        }
-
-        int policyCount = reader.ReadInt32();
-        _policy.Clear();
-        for (int i = 0; i < policyCount; i++)
-        {
-            string stateKey = reader.ReadString();
-            int actionCount = reader.ReadInt32();
-            _policy[stateKey] = new Dictionary<int, T>();
-            for (int j = 0; j < actionCount; j++)
-            {
-                int actionKey = reader.ReadInt32();
-                double actionValue = reader.ReadDouble();
-                _policy[stateKey][actionKey] = NumOps.FromDouble(actionValue);
-            }
-        }
-    }
     /// <summary>
     /// The value-table states in a fixed order, so export and restore agree.
     /// </summary>
@@ -287,19 +231,6 @@ private List<string> OrderedValueStates()
 
         return entries;
     }
-
-    public override IFullModel<T, Vector<T>, Vector<T>> Clone()
-    {
-        var clone = new TabularActorCriticAgent<T>(_options);
-        // Copy learned state - the value table and policy preferences
-        clone._valueTable = new Dictionary<string, T>(_valueTable);
-        clone._policy = new Dictionary<string, Dictionary<int, T>>();
-        foreach (var kvp in _policy)
-        {
-            clone._policy[kvp.Key] = new Dictionary<int, T>(kvp.Value);
-        }
-        return clone;
-    }
     public override void SaveModel(string filepath) { var data = Serialize(); System.IO.File.WriteAllBytes(filepath, data); }
     public override void LoadModel(string filepath) { var data = System.IO.File.ReadAllBytes(filepath); Deserialize(data); }
 }
diff --git a/src/ReinforcementLearning/Agents/TabularQLearningAgent.cs b/src/ReinforcementLearning/Agents/TabularQLearningAgent.cs
index 9c6c3761ee..5b3df93cf8 100644
--- a/src/ReinforcementLearning/Agents/TabularQLearningAgent.cs
+++ b/src/ReinforcementLearning/Agents/TabularQLearningAgent.cs
@@ -54,7 +54,7 @@ namespace AiDotNet.ReinforcementLearning.Agents.TabularQLearning;
     "https://www.cs.rhul.ac.uk/~chrisw/new_thesis.pdf",
     Year = 1989,
     Authors = "Watkins, C. J. C. H.")]
-public class TabularQLearningAgent<T> : ReinforcementLearningAgentBase<T>, IGradientComputable<T, Vector<T>, Vector<T>>
+public partial class TabularQLearningAgent<T> : ReinforcementLearningAgentBase<T>, IGradientComputable<T, Vector<T>, Vector<T>>
 {
 
     /// <inheritdoc />
@@ -235,56 +235,6 @@ public override ModelMetadata<T> GetModelMetadata()
 
     public override int FeatureCount => _options.StateSize;
 
-    public override byte[] Serialize()
-    {
-        var state = new
-        {
-            QTable = _qTable,
-            Epsilon = _epsilon,
-            Options = _options
-        };
-        string json = JsonConvert.SerializeObject(state);
-        return System.Text.Encoding.UTF8.GetBytes(json);
-    }
-
-    public override void Deserialize(byte[] data)
-    {
-        if (data is null || data.Length == 0)
-        {
-            throw new ArgumentException("Serialized data cannot be null or empty", nameof(data));
-        }
-
-        string json = System.Text.Encoding.UTF8.GetString(data);
-        var state = JsonConvert.DeserializeObject<dynamic>(json);
-        if (state is null)
-        {
-            throw new InvalidOperationException("Deserialization returned null");
-        }
-
-        _qTable = JsonConvert.DeserializeObject<Dictionary<string, Dictionary<int, T>>>(state.QTable.ToString()) ?? new Dictionary<string, Dictionary<int, T>>();
-        _epsilon = state.Epsilon;
-    }
-
-    public override IFullModel<T, Vector<T>, Vector<T>> Clone()
-    {
-        var clone = new TabularQLearningAgent<T>(_options);
-
-        // Deep copy the Q-table
-        clone._qTable = new Dictionary<string, Dictionary<int, T>>();
-        foreach (var stateEntry in _qTable)
-        {
-            var actionDict = new Dictionary<int, T>();
-            foreach (var actionEntry in stateEntry.Value)
-            {
-                actionDict[actionEntry.Key] = actionEntry.Value;
-            }
-            clone._qTable[stateEntry.Key] = actionDict;
-        }
-
-        clone._epsilon = _epsilon;
-        return clone;
-    }
-
     public Vector<T> ComputeGradients(
         Vector<T> input,
         Vector<T> target,
diff --git a/src/ReinforcementLearning/Agents/ThompsonSamplingAgent.cs b/src/ReinforcementLearning/Agents/ThompsonSamplingAgent.cs
index 12f23ca39d..5310e0606a 100644
--- a/src/ReinforcementLearning/Agents/ThompsonSamplingAgent.cs
+++ b/src/ReinforcementLearning/Agents/ThompsonSamplingAgent.cs
@@ -44,7 +44,7 @@ namespace AiDotNet.ReinforcementLearning.Agents.Bandits;
     "https://doi.org/10.2307/2332286",
     Year = 1933,
     Authors = "Thompson, W. R.")]
-public class ThompsonSamplingAgent<T> : ReinforcementLearningAgentBase<T>
+public partial class ThompsonSamplingAgent<T> : ReinforcementLearningAgentBase<T>
 {
 
     /// <inheritdoc />
@@ -210,53 +210,6 @@ public override void ResetEpisode()
     public Task TrainAsync() { Train(); return Task.CompletedTask; }
     public override ModelMetadata<T> GetModelMetadata() => new ModelMetadata<T> { FeatureCount = this.FeatureCount, Complexity = ParameterCount };
     public override int FeatureCount => 1;
-    public override byte[] Serialize()
-    {
-        using var ms = new MemoryStream();
-        using var writer = new BinaryWriter(ms);
-
-        // Write options
-        writer.Write(_options.NumArms);
-
-        // Write state
-        for (int i = 0; i < _options.NumArms; i++)
-        {
-            writer.Write(_successCounts[i]);
-            writer.Write(_failureCounts[i]);
-        }
-
-        return ms.ToArray();
-    }
-
-    public override void Deserialize(byte[] data)
-    {
-        using var ms = new MemoryStream(data);
-        using var reader = new BinaryReader(ms);
-
-        // Read and validate options
-        var numArms = reader.ReadInt32();
-
-        if (numArms != _options.NumArms)
-            throw new InvalidOperationException($"Serialized NumArms ({numArms}) doesn't match current options ({_options.NumArms})");
-
-        // Read state
-        for (int i = 0; i < _options.NumArms; i++)
-        {
-            _successCounts[i] = reader.ReadInt32();
-            _failureCounts[i] = reader.ReadInt32();
-        }
-    }
-    public override IFullModel<T, Vector<T>, Vector<T>> Clone()
-    {
-        var clone = new ThompsonSamplingAgent<T>(_options);
-        // Copy learned arm statistics to preserve trained state
-        for (int i = 0; i < _options.NumArms; i++)
-        {
-            clone._successCounts[i] = _successCounts[i];
-            clone._failureCounts[i] = _failureCounts[i];
-        }
-        return clone;
-    }
     public override void SaveModel(string filepath) { var data = Serialize(); System.IO.File.WriteAllBytes(filepath, data); }
     public override void LoadModel(string filepath) { var data = System.IO.File.ReadAllBytes(filepath); Deserialize(data); }
 }
diff --git a/src/ReinforcementLearning/Agents/UCBBanditAgent.cs b/src/ReinforcementLearning/Agents/UCBBanditAgent.cs
index abddca9758..145ecd79d3 100644
--- a/src/ReinforcementLearning/Agents/UCBBanditAgent.cs
+++ b/src/ReinforcementLearning/Agents/UCBBanditAgent.cs
@@ -43,7 +43,7 @@ namespace AiDotNet.ReinforcementLearning.Agents.Bandits;
     "https://doi.org/10.1023/A:1013689704352",
     Year = 2002,
     Authors = "Auer, P., Cesa-Bianchi, N., & Fischer, P.")]
-public class UCBBanditAgent<T> : ReinforcementLearningAgentBase<T>
+public partial class UCBBanditAgent<T> : ReinforcementLearningAgentBase<T>
 {
 
     /// <inheritdoc />
@@ -167,62 +167,6 @@ public override void ResetEpisode()
     public Task TrainAsync() { Train(); return Task.CompletedTask; }
     public override ModelMetadata<T> GetModelMetadata() => new ModelMetadata<T> { FeatureCount = this.FeatureCount, Complexity = ParameterCount };
     public override int FeatureCount => 1;
-    public override byte[] Serialize()
-    {
-        using var ms = new MemoryStream();
-        using var writer = new BinaryWriter(ms);
-
-        // Write options
-        writer.Write(_options.NumArms);
-        writer.Write(_options.ExplorationParameter);
-
-        // Write state
-        writer.Write(_totalSteps);
-        for (int i = 0; i < _options.NumArms; i++)
-        {
-            writer.Write(NumOps.ToDouble(_qValues[i]));
-            writer.Write(_actionCounts[i]);
-        }
-
-        return ms.ToArray();
-    }
-
-    public override void Deserialize(byte[] data)
-    {
-        using var ms = new MemoryStream(data);
-        using var reader = new BinaryReader(ms);
-
-        // Read and validate options
-        var numArms = reader.ReadInt32();
-        var explorationParam = reader.ReadDouble();
-
-        if (numArms != _options.NumArms)
-            throw new InvalidOperationException($"Serialized NumArms ({numArms}) doesn't match current options ({_options.NumArms})");
-
-        // Read state
-        _totalSteps = reader.ReadInt32();
-        for (int i = 0; i < _options.NumArms; i++)
-        {
-            _qValues[i] = NumOps.FromDouble(reader.ReadDouble());
-            _actionCounts[i] = reader.ReadInt32();
-        }
-    }
-    public override IFullModel<T, Vector<T>, Vector<T>> Clone()
-    {
-        var clone = new UCBBanditAgent<T>(_options);
-
-        // Deep copy learned state to preserve training
-        clone._qValues = new Vector<T>(_options.NumArms);
-        clone._actionCounts = new Vector<int>(_options.NumArms);
-        for (int i = 0; i < _options.NumArms; i++)
-        {
-            clone._qValues[i] = _qValues[i];
-            clone._actionCounts[i] = _actionCounts[i];
-        }
-        clone._totalSteps = _totalSteps;
-
-        return clone;
-    }
     public override void SaveModel(string filepath) { var data = Serialize(); System.IO.File.WriteAllBytes(filepath, data); }
     public override void LoadModel(string filepath) { var data = System.IO.File.ReadAllBytes(filepath); Deserialize(data); }
 }
diff --git a/src/ReinforcementLearning/Agents/ValueIterationAgent.cs b/src/ReinforcementLearning/Agents/ValueIterationAgent.cs
index 6729390aa4..fb2f12b04b 100644
--- a/src/ReinforcementLearning/Agents/ValueIterationAgent.cs
+++ b/src/ReinforcementLearning/Agents/ValueIterationAgent.cs
@@ -43,7 +43,7 @@ namespace AiDotNet.ReinforcementLearning.Agents.DynamicProgramming;
     "https://incompleteideas.net/book/the-book-2nd.html",
     Year = 2018,
     Authors = "Sutton, R. S. & Barto, A. G.")]
-public class ValueIterationAgent<T> : ReinforcementLearningAgentBase<T>
+public partial class ValueIterationAgent<T> : ReinforcementLearningAgentBase<T>
 {
     private ValueIterationOptions<T> _options;
 
@@ -290,59 +290,6 @@ protected override void RegisterComponents()
 
     public override int FeatureCount => _options.StateSize;
 
-    public override byte[] Serialize()
-    {
-        var state = new
-        {
-            ValueTable = _valueTable,
-            Model = _model,
-            Options = _options
-        };
-        string json = JsonConvert.SerializeObject(state);
-        return System.Text.Encoding.UTF8.GetBytes(json);
-    }
-
-    public override void Deserialize(byte[] data)
-    {
-        if (data is null || data.Length == 0)
-        {
-            throw new ArgumentException("Serialized data cannot be null or empty", nameof(data));
-        }
-
-        string json = System.Text.Encoding.UTF8.GetString(data);
-        var state = JsonConvert.DeserializeObject<dynamic>(json);
-        if (state is null)
-        {
-            throw new InvalidOperationException("Deserialization returned null");
-        }
-
-        _valueTable = JsonConvert.DeserializeObject<Dictionary<string, T>>(state.ValueTable.ToString()) ?? new Dictionary<string, T>();
-        _model = JsonConvert.DeserializeObject<Dictionary<string, Dictionary<int, List<(string, T, T)>>>>(state.Model.ToString()) ?? new Dictionary<string, Dictionary<int, List<(string, T, T)>>>();
-    }
-
-    public override IFullModel<T, Vector<T>, Vector<T>> Clone()
-    {
-        var clone = new ValueIterationAgent<T>(_options);
-
-        // Deep copy value table
-        foreach (var kvp in _valueTable)
-        {
-            clone._valueTable[kvp.Key] = kvp.Value;
-        }
-
-        // Deep copy model
-        foreach (var stateKvp in _model)
-        {
-            clone._model[stateKvp.Key] = new Dictionary<int, List<(string, T, T)>>();
-            foreach (var actionKvp in stateKvp.Value)
-            {
-                clone._model[stateKvp.Key][actionKvp.Key] = new List<(string, T, T)>(actionKvp.Value);
-            }
-        }
-
-        return clone;
-    }
-
     public override void SaveModel(string filepath)
     {
         if (string.IsNullOrWhiteSpace(filepath))
diff --git a/src/ReinforcementLearning/Agents/WatkinsQLambdaAgent.cs b/src/ReinforcementLearning/Agents/WatkinsQLambdaAgent.cs
index 1dc87aeb0e..abfb0a704f 100644
--- a/src/ReinforcementLearning/Agents/WatkinsQLambdaAgent.cs
+++ b/src/ReinforcementLearning/Agents/WatkinsQLambdaAgent.cs
@@ -58,7 +58,7 @@ namespace AiDotNet.ReinforcementLearning.Agents.EligibilityTraces;
     "https://www.cs.rhul.ac.uk/~chrisw/new_thesis.pdf",
     Year = 1989,
     Authors = "Watkins, C. J. C. H.")]
-public class WatkinsQLambdaAgent<T> : ReinforcementLearningAgentBase<T>
+public partial class WatkinsQLambdaAgent<T> : ReinforcementLearningAgentBase<T>
 {
     private WatkinsQLambdaOptions<T> _options;
 
@@ -200,56 +200,6 @@ protected override void RegisterComponents()
                 () => _qTable));
     }
     public override int FeatureCount => _options.StateSize;
-    public override byte[] Serialize()
-    {
-        var state = new
-        {
-            QTable = _qTable,
-            EligibilityTraces = _eligibilityTraces,
-            Epsilon = _epsilon,
-            Options = _options
-        };
-        string json = JsonConvert.SerializeObject(state);
-        return System.Text.Encoding.UTF8.GetBytes(json);
-    }
-
-    public override void Deserialize(byte[] data)
-    {
-        if (data is null || data.Length == 0)
-        {
-            throw new ArgumentException("Serialized data cannot be null or empty", nameof(data));
-        }
-
-        string json = System.Text.Encoding.UTF8.GetString(data);
-        var state = JsonConvert.DeserializeObject<dynamic>(json);
-        if (state is null)
-        {
-            throw new InvalidOperationException("Deserialization returned null");
-        }
-
-        _qTable = JsonConvert.DeserializeObject<Dictionary<string, Dictionary<int, T>>>(state.QTable.ToString()) ?? new Dictionary<string, Dictionary<int, T>>();
-        _eligibilityTraces = JsonConvert.DeserializeObject<Dictionary<string, Dictionary<int, T>>>(state.EligibilityTraces.ToString()) ?? new Dictionary<string, Dictionary<int, T>>();
-        _epsilon = state.Epsilon;
-    }
-    public override IFullModel<T, Vector<T>, Vector<T>> Clone()
-    {
-        var clone = new WatkinsQLambdaAgent<T>(_options);
-
-        // Deep copy Q-table to preserve learned state
-        foreach (var kvp in _qTable)
-        {
-            clone._qTable[kvp.Key] = new Dictionary<int, T>(kvp.Value);
-        }
-
-        // Deep copy eligibility traces
-        foreach (var kvp in _eligibilityTraces)
-        {
-            clone._eligibilityTraces[kvp.Key] = new Dictionary<int, T>(kvp.Value);
-        }
-
-        clone._epsilon = _epsilon;
-        return clone;
-    }
     public override void SaveModel(string filepath) { var data = Serialize(); System.IO.File.WriteAllBytes(filepath, data); }
     public override void LoadModel(string filepath) { var data = System.IO.File.ReadAllBytes(filepath); Deserialize(data); }
 }
diff --git a/src/ReinforcementLearning/Agents/WorldModelsAgent.cs b/src/ReinforcementLearning/Agents/WorldModelsAgent.cs
index 649ff7864d..cf08556863 100644
--- a/src/ReinforcementLearning/Agents/WorldModelsAgent.cs
+++ b/src/ReinforcementLearning/Agents/WorldModelsAgent.cs
@@ -81,9 +81,11 @@ protected override void RegisterComponents()
 
     // M: RNN for temporal modeling
     private INeuralNetwork<T> _rnnNetwork;
+    [AiDotNet.Attributes.Scratch]
     private Vector<T> _rnnHiddenState;
 
     // C: Controller (simple linear policy)
+    [AiDotNet.Attributes.FittedParameter]
     private Matrix<T> _controllerWeights;
 
     private UniformReplayBuffer<T, Vector<T>, Vector<T>> _replayBuffer;
@@ -583,148 +585,6 @@ public override ModelMetadata<T> GetModelMetadata()
 
     public override int FeatureCount => _options.ObservationWidth * _options.ObservationHeight * _options.ObservationChannels;
 
-    public override byte[] Serialize()
-    {
-        using var ms = new MemoryStream();
-        using var writer = new BinaryWriter(ms);
-
-        // Write metadata
-        writer.Write(_options.ObservationWidth);
-        writer.Write(_options.ObservationHeight);
-        writer.Write(_options.ObservationChannels);
-        writer.Write(_options.LatentSize);
-        writer.Write(_options.RNNHiddenSize);
-        writer.Write(_options.ActionSize);
-
-        // Write training state
-        writer.Write(_updateCount);
-
-        // Write VAE encoder
-        var encoderBytes = _vaeEncoder.Serialize();
-        writer.Write(encoderBytes.Length);
-        writer.Write(encoderBytes);
-
-        // Write VAE decoder
-        var decoderBytes = _vaeDecoder.Serialize();
-        writer.Write(decoderBytes.Length);
-        writer.Write(decoderBytes);
-
-        // Write RNN network
-        var rnnBytes = _rnnNetwork.Serialize();
-        writer.Write(rnnBytes.Length);
-        writer.Write(rnnBytes);
-
-        // Write controller weights
-        writer.Write(_controllerWeights.Rows);
-        writer.Write(_controllerWeights.Columns);
-        for (int i = 0; i < _controllerWeights.Rows; i++)
-        {
-            for (int j = 0; j < _controllerWeights.Columns; j++)
-            {
-                writer.Write(NumOps.ToDouble(_controllerWeights[i, j]));
-            }
-        }
-
-        // Write RNN hidden state
-        writer.Write(_rnnHiddenState.Length);
-        for (int i = 0; i < _rnnHiddenState.Length; i++)
-        {
-            writer.Write(NumOps.ToDouble(_rnnHiddenState[i]));
-        }
-
-        return ms.ToArray();
-    }
-
-    public override void Deserialize(byte[] data)
-    {
-        using var ms = new MemoryStream(data);
-        using var reader = new BinaryReader(ms);
-
-        // Read and validate metadata
-        var obsWidth = reader.ReadInt32();
-        var obsHeight = reader.ReadInt32();
-        var obsChannels = reader.ReadInt32();
-        var latentSize = reader.ReadInt32();
-        var rnnHiddenSize = reader.ReadInt32();
-        var actionSize = reader.ReadInt32();
-
-        if (obsWidth != _options.ObservationWidth || obsHeight != _options.ObservationHeight ||
-            obsChannels != _options.ObservationChannels || actionSize != _options.ActionSize)
-            throw new InvalidOperationException("Serialized model dimensions don't match current options");
-
-        // Read training state
-        _updateCount = reader.ReadInt32();
-
-        // Read VAE encoder
-        var encoderLength = reader.ReadInt32();
-        var encoderBytes = reader.ReadBytes(encoderLength);
-        _vaeEncoder.Deserialize(encoderBytes);
-
-        // Read VAE decoder
-        var decoderLength = reader.ReadInt32();
-        var decoderBytes = reader.ReadBytes(decoderLength);
-        _vaeDecoder.Deserialize(decoderBytes);
-
-        // Read RNN network
-        var rnnLength = reader.ReadInt32();
-        var rnnBytes = reader.ReadBytes(rnnLength);
-        _rnnNetwork.Deserialize(rnnBytes);
-
-        // Read controller weights
-        var rows = reader.ReadInt32();
-        var cols = reader.ReadInt32();
-        _controllerWeights = new Matrix<T>(rows, cols);
-        for (int i = 0; i < rows; i++)
-        {
-            for (int j = 0; j < cols; j++)
-            {
-                _controllerWeights[i, j] = NumOps.FromDouble(reader.ReadDouble());
-            }
-        }
-
-        // Read RNN hidden state
-        var hiddenLength = reader.ReadInt32();
-        _rnnHiddenState = new Vector<T>(hiddenLength);
-        for (int i = 0; i < hiddenLength; i++)
-        {
-            _rnnHiddenState[i] = NumOps.FromDouble(reader.ReadDouble());
-        }
-    }
-
-    public override IFullModel<T, Vector<T>, Vector<T>> Clone()
-    {
-        // The fresh constructor reproduces the VAE/RNN network ARCHITECTURE exactly (deterministic
-        // per-layer seeds), but Train() now UPDATES those networks' weights (the VAE encoder/decoder
-        // and the MDN-RNN are trained, not just the controller). So we must copy the learned network
-        // parameters onto the clone — otherwise it would keep the seed-initial weights and produce a
-        // different world model / policy than the trained original (Clone_ShouldProduceSamePolicy).
-        // GetParameters/SetParameters round-trip the network weights in-place WITHOUT rebuilding the
-        // layer graph, so the RandomSeed pins (and thus tensor shapes) are preserved — unlike a full
-        // serialization round-trip. The trained controller weights are copied separately below.
-        var clone = new WorldModelsAgent<T>(_options);
-        clone.SetParameters(GetParameters());
-
-        var controllerCopy = new Matrix<T>(_controllerWeights.Rows, _controllerWeights.Columns);
-        for (int i = 0; i < _controllerWeights.Rows; i++)
-        {
-            for (int j = 0; j < _controllerWeights.Columns; j++)
-            {
-                controllerCopy[i, j] = _controllerWeights[i, j];
-            }
-        }
-        clone._controllerWeights = controllerCopy;
-
-        var hiddenCopy = new Vector<T>(_rnnHiddenState.Length);
-        for (int i = 0; i < _rnnHiddenState.Length; i++)
-        {
-            hiddenCopy[i] = _rnnHiddenState[i];
-        }
-        clone._rnnHiddenState = hiddenCopy;
-
-        clone._updateCount = _updateCount;
-        return clone;
-    }
-
     public override void SaveModel(string filepath)
     {
         var data = Serialize();
diff --git a/src/ReinforcementLearning/Environments/DeterministicBanditEnvironment.cs b/src/ReinforcementLearning/Environments/DeterministicBanditEnvironment.cs
index 84b33080c4..a3dc8362cd 100644
--- a/src/ReinforcementLearning/Environments/DeterministicBanditEnvironment.cs
+++ b/src/ReinforcementLearning/Environments/DeterministicBanditEnvironment.cs
@@ -20,7 +20,7 @@ namespace AiDotNet.ReinforcementLearning.Environments;
 /// making it perfect for testing - you always know what reward to expect.
 /// </para>
 /// </remarks>
-public class DeterministicBanditEnvironment<T> : IEnvironment<T>
+public partial class DeterministicBanditEnvironment<T> : IEnvironment<T>
 {
     private readonly INumericOperations<T> _numOps;
     private readonly int _actionSpaceSize;
@@ -29,6 +29,7 @@ public class DeterministicBanditEnvironment<T> : IEnvironment<T>
     private readonly T[] _armRewards;
     private Random _random;
     private int _currentStep;
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T> _currentState;
 
     /// <inheritdoc/>
diff --git a/src/ReinforcementLearning/Parameters/TabularParameterSources.cs b/src/ReinforcementLearning/Parameters/TabularParameterSources.cs
index 4def57fd21..c358c35351 100644
--- a/src/ReinforcementLearning/Parameters/TabularParameterSources.cs
+++ b/src/ReinforcementLearning/Parameters/TabularParameterSources.cs
@@ -29,7 +29,7 @@ namespace AiDotNet.ReinforcementLearning.Parameters;
 /// numbers, so saving and loading it works the same way it does for a neural network.</para>
 /// </remarks>
 /// <typeparam name="T">The numeric type of the table's values.</typeparam>
-public sealed class QTableParameterSource<T> : IParameterSource<T>
+public sealed class QTableParameterSource<T> : IParameterSource<T>, AiDotNet.Models.Parameters.IParameterTopologySource
 {
     private readonly Dictionary<string, Dictionary<int, T>> _table;
     private readonly int _actionSize;
@@ -79,6 +79,39 @@ public void SetParameters(Vector<T> parameters)
             }
         }
     }
+
+    /// <inheritdoc />
+    public void WriteParameterTopology(BinaryWriter writer)
+    {
+        if (writer is null) throw new ArgumentNullException(nameof(writer));
+        writer.Write(_table.Count);
+        foreach (var state in _table)
+        {
+            writer.Write(state.Key);
+            writer.Write(state.Value.Count);
+            foreach (var action in state.Value.Keys) writer.Write(action);
+        }
+    }
+
+    /// <inheritdoc />
+    public void ReadParameterTopology(BinaryReader reader)
+    {
+        if (reader is null) throw new ArgumentNullException(nameof(reader));
+        int stateCount = reader.ReadInt32();
+        if (stateCount < 0) throw new InvalidDataException($"Q-table topology has negative state count {stateCount}.");
+        _table.Clear();
+        for (int stateIndex = 0; stateIndex < stateCount; stateIndex++)
+        {
+            string state = reader.ReadString();
+            int actionCount = reader.ReadInt32();
+            if (actionCount < 0)
+                throw new InvalidDataException($"Q-table topology has negative action count {actionCount}.");
+            var actions = new Dictionary<int, T>();
+            for (int actionIndex = 0; actionIndex < actionCount; actionIndex++)
+                actions.Add(reader.ReadInt32(), _ops.Zero);
+            _table.Add(state, actions);
+        }
+    }
 }
 
 /// <summary>
@@ -88,7 +121,7 @@ public void SetParameters(Vector<T> parameters)
 /// <remarks>Held by reference and enumerated in dictionary order, for the same reasons as
 /// <see cref="QTableParameterSource{T}"/>.</remarks>
 /// <typeparam name="T">The numeric type of the table's values.</typeparam>
-public sealed class ValueTableParameterSource<T> : IParameterSource<T>
+public sealed class ValueTableParameterSource<T> : IParameterSource<T>, AiDotNet.Models.Parameters.IParameterTopologySource
 {
     private readonly Dictionary<string, T> _table;
 
@@ -121,6 +154,24 @@ public void SetParameters(Vector<T> parameters)
             _table[key] = parameters[idx++];
         }
     }
+
+    /// <inheritdoc />
+    public void WriteParameterTopology(BinaryWriter writer)
+    {
+        if (writer is null) throw new ArgumentNullException(nameof(writer));
+        writer.Write(_table.Count);
+        foreach (var key in _table.Keys) writer.Write(key);
+    }
+
+    /// <inheritdoc />
+    public void ReadParameterTopology(BinaryReader reader)
+    {
+        if (reader is null) throw new ArgumentNullException(nameof(reader));
+        int count = reader.ReadInt32();
+        if (count < 0) throw new InvalidDataException($"Value-table topology has negative count {count}.");
+        _table.Clear();
+        for (int i = 0; i < count; i++) _table.Add(reader.ReadString(), default!);
+    }
 }
 
 /// <summary>
@@ -229,7 +280,7 @@ public void SetParameters(Vector<T> parameters)
 /// </para>
 /// </remarks>
 /// <typeparam name="T">The numeric type of the table's values.</typeparam>
-public sealed class QTableEntriesParameterSource<T> : IParameterSource<T>
+public sealed class QTableEntriesParameterSource<T> : IParameterSource<T>, AiDotNet.Models.Parameters.IParameterTopologySource
 {
     private readonly Dictionary<string, Dictionary<int, T>> _table;
     private readonly bool _padEmptyToOne;
@@ -317,6 +368,39 @@ public void SetParameters(Vector<T> parameters)
             }
         }
     }
+
+    /// <inheritdoc />
+    public void WriteParameterTopology(BinaryWriter writer)
+    {
+        if (writer is null) throw new ArgumentNullException(nameof(writer));
+        writer.Write(_table.Count);
+        foreach (var state in _table)
+        {
+            writer.Write(state.Key);
+            writer.Write(state.Value.Count);
+            foreach (var action in state.Value.Keys) writer.Write(action);
+        }
+    }
+
+    /// <inheritdoc />
+    public void ReadParameterTopology(BinaryReader reader)
+    {
+        if (reader is null) throw new ArgumentNullException(nameof(reader));
+        int stateCount = reader.ReadInt32();
+        if (stateCount < 0) throw new InvalidDataException($"Q-table topology has negative state count {stateCount}.");
+        _table.Clear();
+        for (int stateIndex = 0; stateIndex < stateCount; stateIndex++)
+        {
+            string state = reader.ReadString();
+            int actionCount = reader.ReadInt32();
+            if (actionCount < 0)
+                throw new InvalidDataException($"Q-table topology has negative action count {actionCount}.");
+            var actions = new Dictionary<int, T>();
+            for (int actionIndex = 0; actionIndex < actionCount; actionIndex++)
+                actions.Add(reader.ReadInt32(), _ops.Zero);
+            _table.Add(state, actions);
+        }
+    }
 }
 
 /// <summary>
diff --git a/src/ReinforcementLearning/Policies/Exploration/OrnsteinUhlenbeckNoise.cs b/src/ReinforcementLearning/Policies/Exploration/OrnsteinUhlenbeckNoise.cs
index 642bda2489..2f83a27722 100644
--- a/src/ReinforcementLearning/Policies/Exploration/OrnsteinUhlenbeckNoise.cs
+++ b/src/ReinforcementLearning/Policies/Exploration/OrnsteinUhlenbeckNoise.cs
@@ -31,12 +31,13 @@ namespace AiDotNet.ReinforcementLearning.Policies.Exploration
         "https://arxiv.org/abs/1509.02971",
         Year = 2016,
         Authors = "Lillicrap, T. P., Hunt, J. J., Pritzel, A., Heess, N., Erez, T., Tassa, Y., Silver, D., & Wierstra, D.")]
-    public class OrnsteinUhlenbeckNoise<T> : ExplorationStrategyBase<T>
+    public partial class OrnsteinUhlenbeckNoise<T> : ExplorationStrategyBase<T>
     {
         private readonly double _theta;      // Mean reversion rate
         private readonly double _sigma;      // Volatility/noise scale
         private readonly double _mu;         // Long-term mean
         private readonly double _dt;         // Time step
+        [AiDotNet.Attributes.TrainableParameter]
         private Vector<T> _state;            // Current noise state
 
         /// <summary>
diff --git a/src/ReinforcementLearning/Policies/PolicyBase.cs b/src/ReinforcementLearning/Policies/PolicyBase.cs
index 9e60bff780..494dad09ea 100644
--- a/src/ReinforcementLearning/Policies/PolicyBase.cs
+++ b/src/ReinforcementLearning/Policies/PolicyBase.cs
@@ -13,7 +13,7 @@ namespace AiDotNet.ReinforcementLearning.Policies
     /// Provides common functionality for numeric operations, random number generation, and resource management.
     /// </summary>
     /// <typeparam name="T">The numeric type used for calculations.</typeparam>
-    public abstract class PolicyBase<T> : ModelBase<T, Vector<T>, Vector<T>>, IPolicy<T>
+    public abstract partial class PolicyBase<T> : ModelBase<T, Vector<T>, Vector<T>>, IPolicy<T>
     {
 
         // NumOps inherited from ModelBase
diff --git a/src/RetrievalAugmentedGeneration/Embeddings/SentenceTransformersFineTuner.cs b/src/RetrievalAugmentedGeneration/Embeddings/SentenceTransformersFineTuner.cs
index a3e2667b8b..edf6ed1abb 100644
--- a/src/RetrievalAugmentedGeneration/Embeddings/SentenceTransformersFineTuner.cs
+++ b/src/RetrievalAugmentedGeneration/Embeddings/SentenceTransformersFineTuner.cs
@@ -127,6 +127,7 @@ public class SentenceTransformersFineTuner<T> : EmbeddingModelBase<T>
 
     private ONNXSentenceTransformer<T>? _baseModel;
     private bool _isFineTuned;
+    [Scratch]
     private Dictionary<string, Vector<T>> _fineTunedEmbeddingsCache;
     private bool _disposed;
 
diff --git a/src/RetrievalAugmentedGeneration/Embeddings/StaticWordEmbeddingModel.cs b/src/RetrievalAugmentedGeneration/Embeddings/StaticWordEmbeddingModel.cs
index d210bfa99e..b70bca2ea6 100644
--- a/src/RetrievalAugmentedGeneration/Embeddings/StaticWordEmbeddingModel.cs
+++ b/src/RetrievalAugmentedGeneration/Embeddings/StaticWordEmbeddingModel.cs
@@ -34,10 +34,11 @@ namespace AiDotNet.RetrievalAugmentedGeneration.Embeddings;
 [ModelTask(ModelTask.FeatureExtraction)]
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
-public class StaticWordEmbeddingModel<T> : EmbeddingModelBase<T>
+public partial class StaticWordEmbeddingModel<T> : EmbeddingModelBase<T>
 {
     private readonly Dictionary<string, Vector<T>> _wordVectors;
     private readonly int _dimension;
+    [AiDotNet.Attributes.TrainableParameter]
     private readonly Vector<T> _unknownVector;
     private readonly bool _ignoreUnknown;
 
diff --git a/src/Safety/Adversarial/AdversarialImageEvaluator.cs b/src/Safety/Adversarial/AdversarialImageEvaluator.cs
index 7c0f3d5c73..37c1737b3a 100644
--- a/src/Safety/Adversarial/AdversarialImageEvaluator.cs
+++ b/src/Safety/Adversarial/AdversarialImageEvaluator.cs
@@ -349,20 +349,10 @@ public override Dictionary<string, Tensor<T>> GetNamedLayerActivations(Tensor<T>
     };
 
     /// <inheritdoc />
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_threshold);
-    }
 
-    /// <inheritdoc />
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _threshold = reader.ReadDouble();
-    }
 
     /// <inheritdoc />
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-        => new AdversarialImageEvaluator<T>(_threshold);
+
 
     private static double ComputeHighFrequencyAnomalyScore(ReadOnlySpan<T> span, int[] shape)
     {
diff --git a/src/SelfSupervisedLearning/CenteringMechanism.cs b/src/SelfSupervisedLearning/CenteringMechanism.cs
index 1cc58c56e3..51599c35e9 100644
--- a/src/SelfSupervisedLearning/CenteringMechanism.cs
+++ b/src/SelfSupervisedLearning/CenteringMechanism.cs
@@ -39,7 +39,7 @@ namespace AiDotNet.SelfSupervisedLearning;
 [ModelComplexity(ModelComplexity.Low)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Emerging Properties in Self-Supervised Vision Transformers", "https://arxiv.org/abs/2104.14294", Year = 2021, Authors = "Mathilde Caron, Hugo Touvron, Ishan Misra, Hervé Jégou, Julien Mairal, Piotr Bojanowski, Armand Joulin")]
-public class CenteringMechanism<T> : ModelBase<T, Tensor<T>, Tensor<T>>
+public partial class CenteringMechanism<T> : ModelBase<T, Tensor<T>, Tensor<T>>
 {
 
     /// <inheritdoc />
@@ -303,13 +303,5 @@ public override IFullModel<T, Tensor<T>, Tensor<T>> WithParameters(Vector<T> par
         return copy;
     }
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy()
-    {
-        var clone = (CenteringMechanism<T>)MemberwiseClone();
-        clone._center = (T[])_center.Clone();
-        return clone;
-    }
-
     #endregion
 }
diff --git a/src/SelfSupervisedLearning/Evaluation/KNNEvaluator.cs b/src/SelfSupervisedLearning/Evaluation/KNNEvaluator.cs
index 75f7f9bdf3..395065a31d 100644
--- a/src/SelfSupervisedLearning/Evaluation/KNNEvaluator.cs
+++ b/src/SelfSupervisedLearning/Evaluation/KNNEvaluator.cs
@@ -58,6 +58,7 @@ protected override void RegisterComponents()
     private readonly bool _useCosine;
     private readonly double _temperature;
 
+    [AiDotNet.Attributes.FittedParameter]
     private Tensor<T>? _trainFeatures;
     private int[]? _trainLabels;
     private int _numClasses;
@@ -389,9 +390,5 @@ public override IFullModel<T, Tensor<T>, Tensor<T>> WithParameters(Vector<T> par
         return copy;
     }
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy()
-        => (KNNEvaluator<T>)MemberwiseClone();
-
     #endregion
 }
diff --git a/src/SelfSupervisedLearning/LinearProjector.cs b/src/SelfSupervisedLearning/LinearProjector.cs
index ad334267e1..4cd13ca70a 100644
--- a/src/SelfSupervisedLearning/LinearProjector.cs
+++ b/src/SelfSupervisedLearning/LinearProjector.cs
@@ -46,8 +46,11 @@ public class LinearProjector<T> : IProjectorHead<T>
 
     private Tensor<T> _weight;
     private Tensor<T>? _bias;
+    [Scratch]
     private Tensor<T>? _gradWeight;
+    [Scratch]
     private Tensor<T>? _gradBias;
+    [Scratch]
     private Tensor<T>? _lastInput;
 
     private bool _isTraining = true;
diff --git a/src/SelfSupervisedLearning/MLPProjector.cs b/src/SelfSupervisedLearning/MLPProjector.cs
index 3118a92695..482c5c0ea2 100644
--- a/src/SelfSupervisedLearning/MLPProjector.cs
+++ b/src/SelfSupervisedLearning/MLPProjector.cs
@@ -34,7 +34,7 @@ namespace AiDotNet.SelfSupervisedLearning;
 [ModelComplexity(ModelComplexity.Low)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("A Simple Framework for Contrastive Learning of Visual Representations", "https://arxiv.org/abs/2002.05709", Year = 2020, Authors = "Ting Chen, Simon Kornblith, Mohammad Norouzi, Geoffrey Hinton")]
-public class MLPProjector<T> : IProjectorHead<T>
+public partial class MLPProjector<T> : IProjectorHead<T>
 {
     private static readonly INumericOperations<T> NumOps = MathHelper.GetNumericOperations<T>();
 
@@ -51,36 +51,51 @@ public class MLPProjector<T> : IProjectorHead<T>
     // Layer 1: Input → Hidden
     private Tensor<T> _weight1;
     private Tensor<T> _bias1;
+    [Scratch]
     private Tensor<T>? _gradWeight1;
+    [Scratch]
     private Tensor<T>? _gradBias1;
 
     // BatchNorm 1
     private Tensor<T> _gamma1;
     private Tensor<T> _beta1;
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _runningMean1;
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _runningVar1;
+    [Scratch]
     private Tensor<T>? _gradGamma1;
+    [Scratch]
     private Tensor<T>? _gradBeta1;
 
     // Layer 2: Hidden → Output
     private Tensor<T> _weight2;
     private Tensor<T> _bias2;
+    [Scratch]
     private Tensor<T>? _gradWeight2;
+    [Scratch]
     private Tensor<T>? _gradBias2;
 
     // BatchNorm 2 (optional)
     private Tensor<T>? _gamma2;
     private Tensor<T>? _beta2;
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T>? _runningMean2;
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T>? _runningVar2;
+    [Scratch]
     private Tensor<T>? _gradGamma2;
+    [Scratch]
     private Tensor<T>? _gradBeta2;
 
     // Cached values for backward pass
+    [Scratch]
     private Tensor<T>? _lastInput;
+    [Scratch]
     private Tensor<T>? _preActivation1;
     private Tensor<T>? _postBatchNorm1;
     private Tensor<T>? _postRelu1;
+    [Scratch]
     private Tensor<T>? _preActivation2;
 
     private bool _isTraining = true;
diff --git a/src/SelfSupervisedLearning/SelfSupervisedLearningSession.cs b/src/SelfSupervisedLearning/SelfSupervisedLearningSession.cs
index 2dcb15b54a..824ff4b7de 100644
--- a/src/SelfSupervisedLearning/SelfSupervisedLearningSession.cs
+++ b/src/SelfSupervisedLearning/SelfSupervisedLearningSession.cs
@@ -44,6 +44,7 @@ public class SelfSupervisedLearningSession<T>
     private DateTime _startTime;
 
     // Storage for k-NN evaluation
+    [Scratch]
     private Tensor<T>? _cachedTrainingFeatures;
     private int[]? _cachedTrainingLabels;
 
diff --git a/src/SelfSupervisedLearning/SymmetricProjector.cs b/src/SelfSupervisedLearning/SymmetricProjector.cs
index 904e62d22a..7af80e49f5 100644
--- a/src/SelfSupervisedLearning/SymmetricProjector.cs
+++ b/src/SelfSupervisedLearning/SymmetricProjector.cs
@@ -142,6 +142,7 @@ public void Clear()
     private int _nextBranch;           // 0 = branch1, 1 = branch2
     private int _nextBackwardBranch;   // 0 = branch1, 1 = branch2
 
+    [Scratch]
     private Vector<T>? _gradients;
 
     // Guard properties for predictor parameters
diff --git a/src/Serialization/DelegateState.cs b/src/Serialization/DelegateState.cs
new file mode 100644
index 0000000000..e6284711ac
--- /dev/null
+++ b/src/Serialization/DelegateState.cs
@@ -0,0 +1,221 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using AiDotNet.Autodiff;
+
+namespace AiDotNet.Serialization;
+
+/// <summary>
+/// Saves and restores a delegate a layer was constructed with.
+/// </summary>
+/// <remarks>
+/// <para>
+/// A delegate is the one kind of construction state that cannot simply be written down, and the
+/// established answers are both unsatisfying. Python's <c>pickle</c> refuses a lambda outright and
+/// stores a module-level function as a name reference. Keras goes further and marshals the Lambda
+/// layer's Python bytecode into the model file, which is why loading one is arbitrary code
+/// execution and why <c>safe_mode=True</c> blocks it by default -- it was still bypassable
+/// (CVE-2025-9906). PyTorch avoids the question: <c>copy.deepcopy</c> treats a function as atomic
+/// and returns the same object, so a clone aliases the delegate and a save never round-trips it.
+/// </para>
+/// <para>
+/// .NET makes better available, because a delegate is not opaque here: it is a
+/// <see cref="MethodInfo"/> plus a target. So this tries progressively weaker descriptions and
+/// keeps the first that fits, rather than marshalling code:
+/// </para>
+/// <list type="number">
+/// <item>the traced computation graph, when the layer was given a traceable expression;</item>
+/// <item>the expression tree, when the layer was given one rather than a compiled delegate;</item>
+/// <item>a method reference, for a named static method -- pickle's answer, without the pickle.</item>
+/// </list>
+/// <para>
+/// When none fits, the delegate is reported as unsaveable rather than written as something that
+/// will not come back. Cloning a layer in memory does not go through here at all: it hands the
+/// live delegate over, which is what PyTorch's deepcopy does and is always correct in-process.
+/// </para>
+/// </remarks>
+public static class DelegateState
+{
+    /// <summary>Marks a saved value as a reference to a named method.</summary>
+    public const string MethodScheme = "method:";
+
+    /// <summary>Marks a saved value as a serialized expression tree.</summary>
+    public const string ExpressionScheme = "expr:";
+
+    /// <summary>Marks a saved value as a traced computation graph.</summary>
+    public const string GraphScheme = "graph:";
+
+    /// <summary>
+    /// Describes <paramref name="value"/> well enough to rebuild it, or returns empty when no
+    /// description fits.
+    /// </summary>
+    /// <param name="value">The delegate the layer was constructed with.</param>
+    /// <returns>The saved form, or <see cref="string.Empty"/> when it cannot be saved.</returns>
+    public static string Save(Delegate? value)
+    {
+        if (value is null) return string.Empty;
+
+        // Tiers 1 and 2 are chosen at construction time, not discovered here: an expression tree
+        // and a traceable graph are both lost the moment they are compiled to a Func, so a layer
+        // that has one records it directly. This is the fallback that works on any delegate.
+        return SaveMethodReference(value) ?? string.Empty;
+    }
+    /// <summary>
+    /// Describes a traceable expression by running it once and recording what it computed.
+    /// </summary>
+    /// <typeparam name="T">The numeric type.</typeparam>
+    /// <param name="value">The traceable expression the layer was built with.</param>
+    /// <param name="inputShape">The layer's input shape, used to make a probe tensor.</param>
+    /// <returns>The saved form, or <see cref="string.Empty"/> when it cannot be saved.</returns>
+    /// <remarks>
+    /// This is the only description that survives a closure, because it records what the delegate
+    /// DID rather than what it is called. When the graph cannot be recorded faithfully it falls
+    /// through to the weaker descriptions rather than saving a partial one.
+    /// </remarks>
+    public static string SaveTraceable<T>(Func<ComputationNode<T>, ComputationNode<T>>? value, int[]? inputShape)
+    {
+        if (value is null) return string.Empty;
+
+        var graph = GraphTrace.Trace(value, inputShape);
+        return graph is not null ? GraphScheme + graph : Save(value);
+    }
+
+
+
+    /// <summary>
+    /// A named static method, as its declaring type, name and parameter types.
+    /// </summary>
+    /// <param name="value">The delegate to describe.</param>
+    /// <returns>The reference, or <c>null</c> when this delegate is not a named static method.</returns>
+    /// <remarks>
+    /// The parameter types are recorded because a name alone is ambiguous across overloads, and
+    /// picking the wrong overload at load time would rebuild a layer that computes something else.
+    /// </remarks>
+    private static string? SaveMethodReference(Delegate value)
+    {
+        var method = value.Method;
+        var declaring = method.DeclaringType;
+        if (declaring is null) return null;
+
+        // A lambda body lives on a compiler-generated closure class, under a name that is not
+        // stable across a recompile. Naming it would produce a reference that resolves today and
+        // silently fails to resolve after an unrelated edit.
+        if (declaring.IsDefined(typeof(CompilerGeneratedAttribute), inherit: false)
+            || declaring.Name.IndexOf('<') >= 0
+            || method.Name.IndexOf('<') >= 0)
+            return null;
+
+        // An instance method would need its receiver rebuilt too, which is the whole problem again.
+        if (!method.IsStatic || value.Target is not null) return null;
+
+        var owner = declaring.AssemblyQualifiedName;
+        if (string.IsNullOrEmpty(owner)) return null;
+
+        var parameters = string.Join(";", method.GetParameters()
+            .Select(p => p.ParameterType.AssemblyQualifiedName ?? p.ParameterType.FullName ?? string.Empty));
+
+        return MethodScheme + owner + "|" + method.Name + "|" + parameters;
+    }
+
+    /// <summary>Rebuilds a delegate from its saved form.</summary>
+    /// <typeparam name="TDelegate">The delegate type the constructor takes.</typeparam>
+    /// <param name="saved">The value written by <see cref="Save"/>.</param>
+    /// <param name="layerName">The layer being rebuilt, named in any failure.</param>
+    /// <param name="key">The constructor parameter, named in any failure.</param>
+    /// <returns>The rebuilt delegate.</returns>
+    /// <exception cref="InvalidOperationException">The delegate could not be rebuilt.</exception>
+    public static TDelegate Load<TDelegate>(string? saved, string layerName, string key)
+        where TDelegate : Delegate
+    {
+        if (string.IsNullOrEmpty(saved))
+            throw Unsaveable(layerName, key,
+                "nothing was recorded for it -- the layer was built with a lambda or a closure, "
+                + "which has no name to refer to. Pass a named static method, an expression tree, "
+                + "or a traceable expression if this layer needs to survive a save.");
+
+        if (saved!.StartsWith(MethodScheme, StringComparison.Ordinal))
+            return LoadMethodReference<TDelegate>(saved.Substring(MethodScheme.Length), layerName, key);
+        if (saved.StartsWith(GraphScheme, StringComparison.Ordinal))
+            return LoadGraph<TDelegate>(saved.Substring(GraphScheme.Length), layerName, key);
+
+
+        throw Unsaveable(layerName, key, $"its saved form '{Excerpt(saved)}' is not a form this version understands.");
+    }
+
+    /// <summary>
+    /// Replays a traced graph as the delegate the constructor takes.
+    /// </summary>
+    /// <remarks>
+    /// The numeric type is read back off the delegate itself -- a
+    /// <c>Func&lt;ComputationNode&lt;T&gt;, ComputationNode&lt;T&gt;&gt;</c> carries its own T -- so the
+    /// caller does not have to thread it through the generated factory.
+    /// </remarks>
+    private static TDelegate LoadGraph<TDelegate>(string graph, string layerName, string key)
+        where TDelegate : Delegate
+    {
+        var argument = typeof(TDelegate).IsGenericType
+            ? typeof(TDelegate).GetGenericArguments().FirstOrDefault()
+            : null;
+
+        var numeric = argument is not null && argument.IsGenericType
+            && argument.GetGenericTypeDefinition() == typeof(ComputationNode<>)
+                ? argument.GetGenericArguments()[0]
+                : null;
+
+        if (numeric is null)
+            throw Unsaveable(layerName, key,
+                $"it was saved as a traced graph, which only rebuilds a {typeof(ComputationNode<>).Name} "
+                + $"expression, not a {typeof(TDelegate).Name}.");
+
+        var compile = typeof(GraphTrace)
+            .GetMethod(nameof(GraphTrace.Compile), BindingFlags.Public | BindingFlags.Static)!
+            .MakeGenericMethod(numeric);
+
+        return (TDelegate)compile.Invoke(null, [graph, layerName, key])!;
+    }
+
+    /// <summary>Rebuilds a delegate from a reference to a named static method.</summary>
+    private static TDelegate LoadMethodReference<TDelegate>(string reference, string layerName, string key)
+        where TDelegate : Delegate
+    {
+        var parts = reference.Split('|');
+        if (parts.Length != 3)
+            throw Unsaveable(layerName, key, $"its saved method reference '{Excerpt(reference)}' is malformed.");
+
+        var declaring = Type.GetType(parts[0], throwOnError: false);
+        if (declaring is null)
+            throw Unsaveable(layerName, key, $"the type '{Excerpt(parts[0])}' that declared it could not be loaded.");
+
+        var parameterTypes = parts[2].Length == 0
+            ? []
+            : parts[2].Split(';').Select(n => Type.GetType(n, throwOnError: false)).ToArray();
+
+        if (parameterTypes.Any(t => t is null))
+            throw Unsaveable(layerName, key, "one of its parameter types could not be loaded.");
+
+        var method = declaring.GetMethod(
+            parts[1],
+            BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static,
+            binder: null,
+            types: parameterTypes!,
+            modifiers: null);
+
+        if (method is null)
+            throw Unsaveable(layerName, key,
+                $"'{declaring.Name}' no longer declares a static method '{parts[1]}' with the saved signature.");
+
+        try
+        {
+            return (TDelegate)Delegate.CreateDelegate(typeof(TDelegate), method);
+        }
+        catch (ArgumentException ex)
+        {
+            throw Unsaveable(layerName, key,
+                $"'{declaring.Name}.{parts[1]}' no longer matches {typeof(TDelegate).Name}: {ex.Message}");
+        }
+    }
+
+    private static InvalidOperationException Unsaveable(string layerName, string key, string why)
+        => new($"Cannot rebuild {layerName}: constructor parameter '{key}' is a delegate and {why}");
+
+    private static string Excerpt(string value) => value.Length <= 120 ? value : value.Substring(0, 117) + "...";
+}
diff --git a/src/Serialization/ExpressionState.cs b/src/Serialization/ExpressionState.cs
new file mode 100644
index 0000000000..ebd865d7fd
--- /dev/null
+++ b/src/Serialization/ExpressionState.cs
@@ -0,0 +1,345 @@
+using System.Globalization;
+using System.Linq.Expressions;
+using System.Reflection;
+using System.Text;
+
+namespace AiDotNet.Serialization;
+
+/// <summary>
+/// Saves and restores an expression tree a layer was constructed with.
+/// </summary>
+/// <remarks>
+/// <para>
+/// The middle of <see cref="DelegateState"/>'s three descriptions. A traced graph records what an
+/// expression computed on one probe input; a method reference names a function that already exists.
+/// An expression tree sits between them: the function as data, complete with its captured constants,
+/// for a layer that was handed one before it was compiled.
+/// </para>
+/// <para>
+/// It has to be captured at construction. Compiling an <see cref="Expression{TDelegate}"/> to a
+/// delegate is one-way -- the tree is not recoverable from the result -- so a layer that wants this
+/// takes the expression itself and keeps it.
+/// </para>
+/// <para>
+/// Unlike a traced graph, an expression can name any method, so the allowlist here is not free the
+/// way <c>TensorOperations</c> lookup is. Loading resolves methods only on types the host has
+/// approved, and rejects the tree otherwise -- before <see cref="LambdaExpression.Compile()"/> is
+/// ever called. Nothing is executed to decide this.
+/// </para>
+/// </remarks>
+public static class ExpressionState
+{
+    /// <summary>
+    /// Types whose methods a restored expression may call.
+    /// </summary>
+    /// <remarks>
+    /// A saved model is data from somewhere else. Without this, a tree naming
+    /// <c>File.Delete(string)</c> would resolve and run on the first forward pass -- the class of
+    /// hazard that makes Keras's Lambda layer unsafe to load, arrived at from a different direction.
+    /// The default is the assembly that defines the layers plus the framework's maths.
+    /// </remarks>
+    public static bool IsAllowed(Type type)
+        => type.Assembly == typeof(ExpressionState).Assembly
+           || type == typeof(Math)
+           || type == typeof(MathF);
+
+    /// <summary>Describes an expression tree, or returns empty when it uses something unsupported.</summary>
+    /// <param name="expression">The expression the layer was constructed with.</param>
+    /// <returns>The saved form, or <see cref="string.Empty"/>.</returns>
+    /// <remarks>
+    /// All-or-nothing, like the traced graph: a node this cannot record faithfully abandons the
+    /// whole tree so the caller falls through to a weaker description, rather than saving a
+    /// fragment that rebuilds into a different function.
+    /// </remarks>
+    public static string Save(LambdaExpression? expression)
+    {
+        if (expression is null || expression.Parameters.Count != 1) return string.Empty;
+
+        var nodes = new List<string>();
+        var ids = new Dictionary<Expression, int>(ReferenceComparer.Instance);
+        var writer = new Writer(nodes, ids, expression.Parameters[0]);
+
+        var root = writer.Visit(expression.Body);
+        if (root < 0) return string.Empty;
+
+        var sb = new StringBuilder();
+        foreach (var node in nodes)
+        {
+            if (sb.Length > 0) sb.Append(';');
+            sb.Append(node);
+        }
+        return sb.Append(';').Append(root).ToString();
+    }
+
+    /// <summary>Rebuilds the expression a saved tree records.</summary>
+    /// <typeparam name="TDelegate">The delegate the expression is over.</typeparam>
+    /// <param name="saved">The value written by <see cref="Save"/>.</param>
+    /// <param name="layerName">The layer being rebuilt, named in any failure.</param>
+    /// <param name="key">The constructor parameter, named in any failure.</param>
+    /// <returns>The rebuilt expression.</returns>
+    public static Expression<TDelegate> Load<TDelegate>(string? saved, string layerName, string key)
+        where TDelegate : Delegate
+    {
+        if (string.IsNullOrEmpty(saved)) throw Bad(layerName, key, "nothing was recorded for it.");
+
+        var invoke = typeof(TDelegate).GetMethod("Invoke")!;
+        if (invoke.GetParameters().Length != 1)
+            throw Bad(layerName, key, $"{typeof(TDelegate).Name} does not take exactly one argument.");
+
+        var parameter = Expression.Parameter(invoke.GetParameters()[0].ParameterType, "x");
+        var parts = saved!.Split(';');
+        if (parts.Length < 2 || !int.TryParse(parts[parts.Length - 1], NumberStyles.Integer,
+                CultureInfo.InvariantCulture, out var rootId))
+            throw Bad(layerName, key, "its recorded tree has no root.");
+
+        var built = new Dictionary<int, Expression>();
+        foreach (var step in parts.Take(parts.Length - 1))
+        {
+            if (step.Length == 0 || step == ">") continue;
+
+            var eq = step.IndexOf('=');
+            if (eq < 0 || !int.TryParse(step.Substring(0, eq), out var id))
+                throw Bad(layerName, key, $"a recorded node '{step}' is malformed.");
+
+            built[id] = Rebuild(step.Substring(eq + 1), built, parameter, layerName, key);
+        }
+
+        if (!built.TryGetValue(rootId, out var body))
+            throw Bad(layerName, key, "its recorded root node was never produced.");
+
+        return Expression.Lambda<TDelegate>(body, parameter);
+    }
+
+    private static Expression Rebuild(
+        string body, Dictionary<int, Expression> built, ParameterExpression parameter,
+        string layerName, string key)
+    {
+        var fields = body.Split('|');
+        switch (fields[0])
+        {
+            case "P":
+                return parameter;
+
+            case "C":
+            {
+                var type = Resolve(fields[1], layerName, key);
+                return Expression.Constant(ParseConstant(fields[2], type, layerName, key), type);
+            }
+
+            case "B":
+            {
+                var op = (ExpressionType)Enum.Parse(typeof(ExpressionType), fields[1]);
+                return Expression.MakeBinary(op, built[int.Parse(fields[2])], built[int.Parse(fields[3])]);
+            }
+
+            case "U":
+            {
+                var op = (ExpressionType)Enum.Parse(typeof(ExpressionType), fields[1]);
+                return Expression.MakeUnary(op, built[int.Parse(fields[3])], Resolve(fields[2], layerName, key));
+            }
+
+            case "M":
+            {
+                var declaring = Resolve(fields[1], layerName, key);
+
+                // Checked before the method is bound and long before Compile() -- nothing from the
+                // saved tree is executed to reach this decision.
+                if (!IsAllowed(declaring))
+                    throw Bad(layerName, key,
+                        $"its recorded tree calls into '{declaring.FullName}', which is not a type a "
+                        + "restored expression is allowed to call.");
+
+                var parameterTypes = fields[3].Length == 0
+                    ? Array.Empty<Type>()
+                    : fields[3].Split('~').Select(n => Resolve(n, layerName, key)).ToArray();
+
+                var method = declaring.GetMethod(
+                    fields[2],
+                    BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance,
+                    binder: null, types: parameterTypes, modifiers: null)
+                    ?? throw Bad(layerName, key,
+                        $"'{declaring.Name}' no longer declares '{fields[2]}' with the saved signature.");
+
+                var instanceId = int.Parse(fields[4], CultureInfo.InvariantCulture);
+                var arguments = fields[5].Length == 0
+                    ? Array.Empty<Expression>()
+                    : fields[5].Split(',').Select(s => built[int.Parse(s, CultureInfo.InvariantCulture)]).ToArray();
+
+                return instanceId < 0
+                    ? Expression.Call(method, arguments)
+                    : Expression.Call(built[instanceId], method, arguments);
+            }
+
+            default:
+                throw Bad(layerName, key, $"a recorded node '{body}' is of a kind this version does not know.");
+        }
+    }
+
+    private static Type Resolve(string name, string layerName, string key)
+        => Type.GetType(name, throwOnError: false)
+           ?? throw Bad(layerName, key, $"the type '{name}' could not be loaded.");
+
+    private static object? ParseConstant(string raw, Type type, string layerName, string key)
+    {
+        if (raw == "~") return null;
+        if (type == typeof(string)) return raw;
+        if (type.IsEnum) return Enum.Parse(type, raw, ignoreCase: true);
+
+        try
+        {
+            return Convert.ChangeType(raw, Nullable.GetUnderlyingType(type) ?? type, CultureInfo.InvariantCulture);
+        }
+        catch (Exception)
+        {
+            throw Bad(layerName, key, $"the constant '{raw}' is not a {type.Name}.");
+        }
+    }
+
+    private static InvalidOperationException Bad(string layerName, string key, string why)
+        => new($"Cannot rebuild {layerName}: constructor parameter '{key}' was saved as an expression, but {why}");
+
+    /// <summary>Flattens a tree into numbered nodes, refusing anything that will not round-trip.</summary>
+    private sealed class Writer
+    {
+        private readonly List<string> _nodes;
+        private readonly Dictionary<Expression, int> _ids;
+        private readonly ParameterExpression _parameter;
+
+        internal Writer(List<string> nodes, Dictionary<Expression, int> ids, ParameterExpression parameter)
+        {
+            _nodes = nodes;
+            _ids = ids;
+            _parameter = parameter;
+        }
+
+        /// <returns>The node's id, or -1 when the expression cannot be recorded.</returns>
+        /// <summary>
+        /// Whether the subtree never reaches the lambda's parameter, and so has a value already.
+        /// </summary>
+        private bool IsClosed(Expression node) => node switch
+        {
+            ParameterExpression => false,
+            ConstantExpression => true,
+            MemberExpression m => m.Expression is null || IsClosed(m.Expression),
+            UnaryExpression u => IsClosed(u.Operand),
+            BinaryExpression b => IsClosed(b.Left) && IsClosed(b.Right),
+            MethodCallExpression c => (c.Object is null || IsClosed(c.Object)) && c.Arguments.All(IsClosed),
+            _ => false,
+        };
+
+        internal int Visit(Expression node)
+        {
+            if (_ids.TryGetValue(node, out var existing)) return existing;
+
+            // A captured local is not a constant node: the compiler lifts it to a field on a
+            // closure class, so `x * scale` reads as a member access. Any subtree that never
+            // reaches the parameter already has a value, so it is evaluated here and recorded as
+            // the constant it is -- which is what lets a closure round-trip at all, and the reason
+            // this tier exists rather than only naming methods.
+            if (!ReferenceEquals(node, _parameter) && node is not ConstantExpression && IsClosed(node))
+            {
+                object? value;
+                try
+                {
+                    value = Expression.Lambda(node).Compile().DynamicInvoke();
+                }
+                catch (Exception)
+                {
+                    return -1;
+                }
+
+                return Visit(Expression.Constant(value, node.Type));
+            }
+
+            string? encoded = node switch
+            {
+                ParameterExpression p when ReferenceEquals(p, _parameter) => "P",
+                ConstantExpression c => Constant(c),
+                BinaryExpression b when b.Method is null && b.Conversion is null => Binary(b),
+                UnaryExpression u => Unary(u),
+                MethodCallExpression m => Call(m),
+                _ => null,
+            };
+
+            if (encoded is null) return -1;
+
+            var id = _ids.Count;
+            _ids[node] = id;
+            _nodes.Add(id.ToString(CultureInfo.InvariantCulture) + "=" + encoded);
+            return id;
+        }
+
+        private string? Constant(ConstantExpression c)
+        {
+            var name = c.Type.AssemblyQualifiedName;
+            if (name is null) return null;
+
+            // A captured object would have to be serialized whole, which is what the traced graph
+            // declines to do for the same reason: it is not construction state.
+            if (c.Value is not null && !c.Type.IsPrimitive && c.Type != typeof(string) && !c.Type.IsEnum)
+                return null;
+
+            var value = c.Value switch
+            {
+                null => "~",
+                double d => d.ToString("R", CultureInfo.InvariantCulture),
+                float f => f.ToString("R", CultureInfo.InvariantCulture),
+                IFormattable v => v.ToString(null, CultureInfo.InvariantCulture),
+                var v => v.ToString(),
+            };
+
+            return value is null || value.IndexOfAny(['|', ';', '=']) >= 0 ? null : $"C|{name}|{value}";
+        }
+
+        private string? Binary(BinaryExpression b)
+        {
+            var left = Visit(b.Left);
+            var right = Visit(b.Right);
+            return left < 0 || right < 0 ? null : $"B|{b.NodeType}|{left}|{right}";
+        }
+
+        private string? Unary(UnaryExpression u)
+        {
+            var name = u.Type.AssemblyQualifiedName;
+            if (name is null || u.Method is not null) return null;
+
+            var operand = Visit(u.Operand);
+            return operand < 0 ? null : $"U|{u.NodeType}|{name}|{operand}";
+        }
+
+        private string? Call(MethodCallExpression m)
+        {
+            var declaring = m.Method.DeclaringType?.AssemblyQualifiedName;
+            if (declaring is null || m.Method.IsGenericMethod) return null;
+
+            var instance = -1;
+            if (m.Object is not null)
+            {
+                instance = Visit(m.Object);
+                if (instance < 0) return null;
+            }
+
+            var arguments = new List<int>();
+            foreach (var argument in m.Arguments)
+            {
+                var id = Visit(argument);
+                if (id < 0) return null;
+                arguments.Add(id);
+            }
+
+            var parameters = string.Join("~", m.Method.GetParameters()
+                .Select(p => p.ParameterType.AssemblyQualifiedName ?? string.Empty));
+
+            return $"M|{declaring}|{m.Method.Name}|{parameters}|{instance}|{string.Join(",", arguments)}";
+        }
+    }
+
+    private sealed class ReferenceComparer : IEqualityComparer<Expression>
+    {
+        internal static readonly ReferenceComparer Instance = new();
+
+        public bool Equals(Expression? x, Expression? y) => ReferenceEquals(x, y);
+
+        public int GetHashCode(Expression obj) => System.Runtime.CompilerServices.RuntimeHelpers.GetHashCode(obj);
+    }
+}
diff --git a/src/Serialization/GraphTrace.cs b/src/Serialization/GraphTrace.cs
new file mode 100644
index 0000000000..88075ef06c
--- /dev/null
+++ b/src/Serialization/GraphTrace.cs
@@ -0,0 +1,337 @@
+using System.Globalization;
+using System.Reflection;
+using System.Text;
+using AiDotNet.Autodiff;
+using AiDotNet.Enums;
+using AiDotNet.Tensors.LinearAlgebra;
+
+namespace AiDotNet.Serialization;
+
+/// <summary>
+/// Records what a traceable expression computes, as a graph, and replays it.
+/// </summary>
+/// <remarks>
+/// <para>
+/// This is the strongest of the three descriptions <see cref="DelegateState"/> tries, and the only
+/// one that survives a closure. A delegate built over captured state has no name to refer to, but
+/// running it once over autodiff nodes leaves behind a record of the operations it performed, and
+/// that record is data.
+/// </para>
+/// <para>
+/// It works because <c>TensorOperations</c> already tags every node it produces with an
+/// <see cref="OperationType"/> and, for the operations that take them, an
+/// <c>OperationParams</c> dictionary whose keys match the method's parameter names. Nothing
+/// consumed either before this; they were written for a JIT that had not been built.
+/// </para>
+/// <para>
+/// Replay resolves operations by name against <c>TensorOperations&lt;T&gt;</c> and nothing else, so
+/// a saved graph can only ever invoke a tensor operation. That is the security property Keras's
+/// Lambda layer gives up by marshalling bytecode, and it comes from construction here rather than
+/// from a filter that has to be kept ahead of attackers.
+/// </para>
+/// </remarks>
+public static class GraphTrace
+{
+    private const string InputOp = "Input";
+
+    /// <summary>
+    /// Runs <paramref name="expression"/> once over autodiff nodes and records the operations it
+    /// performed.
+    /// </summary>
+    /// <typeparam name="T">The numeric type.</typeparam>
+    /// <param name="expression">The traceable expression the layer was built with.</param>
+    /// <param name="inputShape">The layer's input shape, used to make a probe tensor.</param>
+    /// <returns>The recorded graph, or <c>null</c> when it cannot be recorded faithfully.</returns>
+    /// <remarks>
+    /// Returns <c>null</c> rather than a partial graph whenever anything is not fully recoverable:
+    /// an operation with no tag, a parameter value of a type that will not round-trip, or an
+    /// expression that throws on the probe. The caller then falls back to a weaker description,
+    /// which is the point of the tiers.
+    /// </remarks>
+    public static string? Trace<T>(Func<ComputationNode<T>, ComputationNode<T>>? expression, int[]? inputShape)
+    {
+        if (expression is null) return null;
+
+        ComputationNode<T> output;
+        ComputationNode<T> input;
+        try
+        {
+            // A lazy or batch axis is recorded as 0 or -1; the probe only has to have the right
+            // rank for the expression to run, so those become 1.
+            var probeShape = (inputShape is null || inputShape.Length == 0 ? [1] : inputShape)
+                .Select(d => d > 0 ? d : 1).ToArray();
+
+            input = TensorOperations<T>.Variable(new Tensor<T>(probeShape));
+            output = expression(input);
+        }
+        catch (Exception)
+        {
+            // An expression that will not run on a probe cannot be recorded. That is a fallback,
+            // not a failure.
+            return null;
+        }
+
+        var order = new List<ComputationNode<T>>();
+        var ids = new Dictionary<ComputationNode<T>, int>(ReferenceComparer<T>.Instance);
+        if (!Order(output, order, ids, input)) return null;
+
+        var sb = new StringBuilder();
+        foreach (var node in order)
+        {
+            if (sb.Length > 0) sb.Append(';');
+            sb.Append(ids[node]).Append('=');
+
+            if (ReferenceEquals(node, input))
+            {
+                sb.Append(InputOp);
+                continue;
+            }
+
+            sb.Append(node.OperationType!.Value.ToString());
+            sb.Append('(');
+            for (var i = 0; i < node.Parents.Count; i++)
+            {
+                if (i > 0) sb.Append(',');
+                sb.Append(ids[node.Parents[i]]);
+            }
+            sb.Append(')');
+
+            var encoded = EncodeParams(node.OperationParams);
+            if (encoded is null) return null;
+            sb.Append(encoded);
+        }
+
+        // Separated, not glued: appending ">;" straight onto the last node left it reading
+        // "2=Square(1)>". That parsed only because the stray ">" landed in the parameter tail,
+        // which is ignored -- the same shape in ExpressionState hit int.Parse and threw.
+        sb.Append(';').Append(ids[output]);
+        return sb.ToString();
+    }
+
+    /// <summary>Depth-first post-order, rejecting anything that cannot be replayed.</summary>
+    private static bool Order<T>(
+        ComputationNode<T> node,
+        List<ComputationNode<T>> order,
+        Dictionary<ComputationNode<T>, int> ids,
+        ComputationNode<T> input)
+    {
+        if (ids.ContainsKey(node)) return true;
+
+        if (!ReferenceEquals(node, input))
+        {
+            // A leaf that is not the input is a captured constant or weight. Its value is not
+            // construction state and may be arbitrarily large, so the graph declines to carry it.
+            if (node.Parents is null || node.Parents.Count == 0) return false;
+            if (node.OperationType is null) return false;
+
+            foreach (var parent in node.Parents)
+            {
+                if (!Order(parent, order, ids, input)) return false;
+            }
+        }
+
+        ids[node] = ids.Count;
+        order.Add(node);
+        return true;
+    }
+
+    private static string? EncodeParams(Dictionary<string, object>? parameters)
+    {
+        if (parameters is null || parameters.Count == 0) return string.Empty;
+
+        var sb = new StringBuilder("{");
+        var first = true;
+        foreach (var kvp in parameters.OrderBy(k => k.Key, StringComparer.Ordinal))
+        {
+            var encoded = EncodeValue(kvp.Value);
+            if (encoded is null) return null;
+
+            if (!first) sb.Append(',');
+            first = false;
+            sb.Append(kvp.Key).Append('=').Append(encoded);
+        }
+
+        return sb.Append('}').ToString();
+    }
+
+    private static string? EncodeValue(object? value) => value switch
+    {
+        null => "~",
+        bool b => b ? "true" : "false",
+        int i => i.ToString(CultureInfo.InvariantCulture),
+        long l => l.ToString(CultureInfo.InvariantCulture),
+        double d => d.ToString("R", CultureInfo.InvariantCulture),
+        float f => f.ToString("R", CultureInfo.InvariantCulture),
+        string s => s.IndexOfAny([',', '}', '=', ';']) >= 0 ? null : "'" + s,
+        int[] a => "[" + string.Join("|", a) + "]",
+        _ => null,
+    };
+
+    /// <summary>Rebuilds the expression a graph records.</summary>
+    /// <typeparam name="T">The numeric type.</typeparam>
+    /// <param name="graph">A graph produced by <see cref="Trace"/>.</param>
+    /// <param name="layerName">The layer being rebuilt, named in any failure.</param>
+    /// <param name="key">The constructor parameter, named in any failure.</param>
+    /// <returns>The replayed expression.</returns>
+    public static Func<ComputationNode<T>, ComputationNode<T>> Compile<T>(string graph, string layerName, string key)
+    {
+        var parts = graph.Split(';');
+        if (parts.Length < 2 || !int.TryParse(parts[^1], NumberStyles.Integer, CultureInfo.InvariantCulture, out var outputId))
+            throw Bad(layerName, key, "its recorded graph has no output node.");
+
+        // Take rather than a range: an array range needs RuntimeHelpers.GetSubArray, which net471
+        // does not have. String ranges below are fine -- those compile to Substring.
+        var steps = parts.Take(parts.Length - 1).Where(p => p.Length > 0 && p != ">").ToArray();
+
+        return input =>
+        {
+            var nodes = new Dictionary<int, ComputationNode<T>>();
+            foreach (var step in steps)
+            {
+                var eq = step.IndexOf('=');
+                if (eq < 0 || !int.TryParse(step[..eq], out var id))
+                    throw Bad(layerName, key, $"a recorded step '{step}' is malformed.");
+
+                var body = step[(eq + 1)..];
+                if (body == InputOp)
+                {
+                    nodes[id] = input;
+                    continue;
+                }
+
+                nodes[id] = Replay<T>(body, nodes, layerName, key);
+            }
+
+            if (!nodes.TryGetValue(outputId, out var output))
+                throw Bad(layerName, key, "its recorded output node was never produced.");
+
+            return output;
+        };
+    }
+
+    private static ComputationNode<T> Replay<T>(
+        string body, Dictionary<int, ComputationNode<T>> nodes, string layerName, string key)
+    {
+        var open = body.IndexOf('(');
+        var close = body.IndexOf(')');
+        if (open < 0 || close < open) throw Bad(layerName, key, $"a recorded step '{body}' is malformed.");
+
+        var opName = body[..open];
+        var argIds = body[(open + 1)..close];
+        var parents = argIds.Length == 0
+            ? []
+            : argIds.Split(',').Select(s => nodes[int.Parse(s, CultureInfo.InvariantCulture)]).ToArray();
+
+        var parameters = DecodeParams(body[(close + 1)..]);
+
+        // Resolved against TensorOperations<T> and nothing else, so a saved graph cannot name any
+        // other method. The allowlist is the lookup, not a filter layered over it.
+        var ops = typeof(TensorOperations<>).MakeGenericType(typeof(T));
+        var candidates = ops.GetMethods(BindingFlags.Public | BindingFlags.Static)
+            .Where(m => m.Name == opName && m.ReturnType == typeof(ComputationNode<T>))
+            .ToArray();
+
+        foreach (var method in candidates)
+        {
+            var bound = Bind<T>(method, parents, parameters);
+            if (bound is not null) return (ComputationNode<T>)method.Invoke(null, bound)!;
+        }
+
+        throw Bad(layerName, key,
+            $"its recorded graph uses '{opName}' with {parents.Length} input(s), which TensorOperations<{typeof(T).Name}> "
+            + "no longer provides in a matching form.");
+    }
+
+    /// <summary>
+    /// Fills a method's parameters from the graph: node parameters in order from the recorded
+    /// parents, everything else by name from the recorded values.
+    /// </summary>
+    private static object?[]? Bind<T>(MethodInfo method, ComputationNode<T>[] parents, Dictionary<string, string> parameters)
+    {
+        var formal = method.GetParameters();
+        var args = new object?[formal.Length];
+        var nextParent = 0;
+
+        foreach (var (p, i) in formal.Select((p, i) => (p, i)))
+        {
+            if (p.ParameterType == typeof(ComputationNode<T>))
+            {
+                if (nextParent >= parents.Length) return null;
+                args[i] = parents[nextParent++];
+                continue;
+            }
+
+            if (parameters.TryGetValue(p.Name ?? string.Empty, out var raw))
+            {
+                var value = DecodeValue(raw, p.ParameterType);
+                if (value is null && raw != "~") return null;
+                args[i] = value;
+                continue;
+            }
+
+            if (p.HasDefaultValue) { args[i] = p.DefaultValue; continue; }
+
+            return null;
+        }
+
+        return nextParent == parents.Length ? args : null;
+    }
+
+    private static Dictionary<string, string> DecodeParams(string tail)
+    {
+        // Case-insensitive because the recorded keys are PascalCase ("Axis") while the method
+        // parameters they correspond to are camelCase ("axis").
+        var result = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
+        var open = tail.IndexOf('{');
+        var close = tail.LastIndexOf('}');
+        if (open < 0 || close <= open) return result;
+
+        foreach (var pair in tail[(open + 1)..close].Split(','))
+        {
+            var eq = pair.IndexOf('=');
+            if (eq > 0) result[pair[..eq]] = pair[(eq + 1)..];
+        }
+
+        return result;
+    }
+
+    private static object? DecodeValue(string raw, Type target)
+    {
+        if (raw == "~") return null;
+        if (raw.StartsWith("'", StringComparison.Ordinal)) return raw[1..];
+
+        if (raw.StartsWith("[", StringComparison.Ordinal) && raw.EndsWith("]", StringComparison.Ordinal))
+        {
+            var inner = raw[1..^1];
+            return inner.Length == 0
+                ? []
+                : inner.Split('|').Select(s => int.Parse(s, CultureInfo.InvariantCulture)).ToArray();
+        }
+
+        var type = Nullable.GetUnderlyingType(target) ?? target;
+        if (type == typeof(bool)) return raw == "true";
+        if (type.IsEnum) return int.TryParse(raw, out var e) ? Enum.ToObject(type, e) : Enum.Parse(type, raw, true);
+
+        try
+        {
+            return Convert.ChangeType(raw, type, CultureInfo.InvariantCulture);
+        }
+        catch (Exception)
+        {
+            return null;
+        }
+    }
+
+    private static InvalidOperationException Bad(string layerName, string key, string why)
+        => new($"Cannot rebuild {layerName}: constructor parameter '{key}' was saved as a traced graph, but {why}");
+
+    /// <summary>Nodes are identified by reference; two distinct nodes may hold equal tensors.</summary>
+    private sealed class ReferenceComparer<T> : IEqualityComparer<ComputationNode<T>>
+    {
+        internal static readonly ReferenceComparer<T> Instance = new();
+
+        public bool Equals(ComputationNode<T>? x, ComputationNode<T>? y) => ReferenceEquals(x, y);
+
+        public int GetHashCode(ComputationNode<T> obj) => System.Runtime.CompilerServices.RuntimeHelpers.GetHashCode(obj);
+    }
+}
diff --git a/src/Serialization/LayerFactoryRegistry.cs b/src/Serialization/LayerFactoryRegistry.cs
new file mode 100644
index 0000000000..7ad596ad29
--- /dev/null
+++ b/src/Serialization/LayerFactoryRegistry.cs
@@ -0,0 +1,234 @@
+using System.Collections.Concurrent;
+using System.Reflection;
+using AiDotNet.NeuralNetworks.Layers;
+
+namespace AiDotNet.Serialization;
+
+/// <summary>
+/// Rebuilds a layer that the generated factory table does not know about.
+/// </summary>
+/// <typeparam name="T">The layer's numeric type.</typeparam>
+/// <remarks>
+/// <para>
+/// <c>GeneratedLayerFactories</c> is compiled from AiDotNet's own source, so it can only ever name
+/// layers AiDotNet ships. A layer defined in a consumer's assembly has no entry in it and never
+/// will: the generator does not run in their compilation, and even if it did, their generated class
+/// would live in their assembly where this one cannot name it. Cloning a user-defined layer failed
+/// for that reason, with an error telling the author to add <c>[LayerState]</c> -- advice that
+/// cannot work from outside this assembly.
+/// </para>
+/// <para>
+/// So there are two ways in besides the generated table. <see cref="Register"/> takes a factory
+/// from any assembly, which is what generated code in a consumer's project will call. Failing that,
+/// a layer is rebuilt by reading its constructor's parameters out of the saved state by name --
+/// slower and unverified at compile time, but it means a hand-written layer works without its
+/// author registering anything, which is the promise the options half of this already keeps.
+/// </para>
+/// </remarks>
+public static class LayerFactoryRegistry<T>
+{
+    private static readonly ConcurrentDictionary<Type, Func<LayerStateBag, object?, object?, object?>> Registered =
+        new();
+
+    /// <summary>
+    /// Every generated factory table visible in this process, closed over <typeparamref name="T"/>.
+    /// </summary>
+    /// <remarks>
+    /// A consumer's compilation emits its own <c>GeneratedLayerFactories</c> into THEIR assembly,
+    /// under the same name -- which this assembly cannot reference, so the table is discovered
+    /// rather than named. Scanned once, lazily, and never again; an assembly whose types cannot be
+    /// loaded is skipped rather than failing the clone.
+    /// </remarks>
+    private static readonly Lazy<List<MethodInfo>> DiscoveredTables = new(() =>
+    {
+        var found = new List<MethodInfo>();
+        foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies())
+        {
+            Type[] types;
+            try
+            {
+                types = assembly.GetTypes();
+            }
+            catch (ReflectionTypeLoadException e)
+            {
+                types = e.Types.Where(t => t is not null).ToArray()!;
+            }
+            catch (Exception)
+            {
+                continue;
+            }
+
+            foreach (var type in types)
+            {
+                if (type is not { IsGenericTypeDefinition: true, Name: "GeneratedLayerFactories`1" }) continue;
+                if (type == typeof(GeneratedLayerFactories<>)) continue;
+
+                var method = type.MakeGenericType(typeof(T))
+                    .GetMethod("TryCreate", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);
+
+                if (method is not null) found.Add(method);
+            }
+        }
+
+        return found;
+    });
+
+    /// <summary>Registers a factory for a layer this assembly cannot name.</summary>
+    /// <param name="genericDefinition">The layer's open generic type, or the type itself if not generic.</param>
+    /// <param name="factory">Builds the layer from its saved state and restored activations.</param>
+    public static void Register(
+        Type genericDefinition,
+        Func<LayerStateBag, object?, object?, object?> factory)
+    {
+        if (genericDefinition is null) throw new ArgumentNullException(nameof(genericDefinition));
+        if (factory is null) throw new ArgumentNullException(nameof(factory));
+
+        Registered[genericDefinition] = factory;
+    }
+
+    /// <summary>Whether a factory has been registered for the given open generic type.</summary>
+    /// <param name="genericDefinition">The layer's open generic type.</param>
+    /// <returns><c>true</c> when a registered factory exists.</returns>
+    public static bool IsRegistered(Type genericDefinition) => Registered.ContainsKey(genericDefinition);
+
+    /// <summary>Rebuilds a layer from a registered factory, or by reading its constructor.</summary>
+    /// <param name="closedType">The layer's closed type.</param>
+    /// <param name="genericDefinition">The layer's open generic type.</param>
+    /// <param name="state">The layer's saved construction state.</param>
+    /// <param name="scalarActivation">The restored scalar activation, if any.</param>
+    /// <param name="vectorActivation">The restored vector activation, if any.</param>
+    /// <param name="layer">The rebuilt layer.</param>
+    /// <returns><c>true</c> when the layer could be rebuilt.</returns>
+    public static bool TryCreate(
+        Type closedType,
+        Type genericDefinition,
+        LayerStateBag state,
+        object? scalarActivation,
+        object? vectorActivation,
+        out object? layer)
+    {
+        if (Registered.TryGetValue(genericDefinition, out var factory)
+            && factory(state, scalarActivation, vectorActivation) is { } registered)
+        {
+            layer = registered;
+            return true;
+        }
+
+        // A consumer's own generated table, if their compilation produced one. It has the same
+        // name in THEIR assembly, which this one cannot reference, so it is found rather than
+        // named. Discovery happens once and the closed TryCreate is cached as a delegate.
+        foreach (var table in DiscoveredTables.Value)
+        {
+            var args = new object?[] { genericDefinition, state, scalarActivation, vectorActivation, null };
+            if (table.Invoke(null, args) is true && args[4] is { } fromTable)
+            {
+                layer = fromTable;
+                return true;
+            }
+        }
+
+        return TryReflect(closedType, state, scalarActivation, vectorActivation, out layer);
+    }
+
+    /// <summary>
+    /// Rebuilds by matching constructor parameters to saved values by name.
+    /// </summary>
+    /// <remarks>
+    /// The metadata keys ARE the parameter names, which is what makes this possible at all. The
+    /// widest constructor every one of whose parameters can be supplied is preferred, so a layer
+    /// with both a full and a convenience constructor is rebuilt through the one carrying the most
+    /// state rather than the one that discards it.
+    /// </remarks>
+    private static bool TryReflect(
+        Type closedType,
+        LayerStateBag state,
+        object? scalarActivation,
+        object? vectorActivation,
+        out object? layer)
+    {
+        layer = null;
+
+        foreach (var ctor in closedType.GetConstructors(BindingFlags.Public | BindingFlags.Instance)
+                     .OrderByDescending(c => c.GetParameters().Count(p => state.Has(p.Name ?? string.Empty))))
+        {
+            var formal = ctor.GetParameters();
+            var args = new object?[formal.Length];
+            var usable = true;
+
+            for (var i = 0; i < formal.Length && usable; i++)
+            {
+                var p = formal[i];
+                var name = p.Name ?? string.Empty;
+
+                if (IsActivation(p.ParameterType))
+                {
+                    args[i] = p.ParameterType.IsInstanceOfType(vectorActivation) ? vectorActivation
+                        : p.ParameterType.IsInstanceOfType(scalarActivation) ? scalarActivation
+                        : p.HasDefaultValue ? p.DefaultValue
+                        : null;
+                    continue;
+                }
+
+                if (state.Has(name) && TryRead(state, name, p.ParameterType, out var value))
+                {
+                    args[i] = value;
+                    continue;
+                }
+
+                // An absent optional argument takes the default its signature declares, never
+                // default(T) -- restoring `useBias = true` as false is the silent loss this exists
+                // to prevent.
+                if (p.HasDefaultValue) { args[i] = p.DefaultValue; continue; }
+
+                usable = false;
+            }
+
+            if (!usable) continue;
+
+            try
+            {
+                layer = ctor.Invoke(args);
+                return true;
+            }
+            catch (TargetInvocationException)
+            {
+                // A constructor that rejects these values is the wrong one; try a narrower.
+            }
+        }
+
+        return false;
+    }
+
+    private static bool IsActivation(Type type)
+        => type.IsInterface
+           && type.IsGenericType
+           && type.Name is "IActivationFunction`1" or "IVectorActivationFunction`1";
+
+    private static bool TryRead(LayerStateBag state, string key, Type target, out object? value)
+    {
+        var type = Nullable.GetUnderlyingType(target) ?? target;
+        value = null;
+
+        try
+        {
+            if (type == typeof(int)) { value = state.Int32(key); return true; }
+            if (type == typeof(long)) { value = state.Int64(key); return true; }
+            if (type == typeof(double)) { value = state.Double(key); return true; }
+            if (type == typeof(float)) { value = state.Single(key); return true; }
+            if (type == typeof(bool)) { value = state.Boolean(key); return true; }
+            if (type == typeof(string)) { value = state.String(key); return true; }
+            if (type == typeof(int[])) { value = state.Int32Array(key); return true; }
+            if (type == typeof(double[])) { value = state.DoubleArray(key); return true; }
+            if (type == typeof(bool[])) { value = state.BooleanArray(key); return true; }
+            if (type == typeof(string[])) { value = state.StringArray(key); return true; }
+            if (type == typeof(int[][])) { value = state.Int32Jagged(key); return true; }
+            if (type.IsEnum) { value = Enum.Parse(type, state.String(key), ignoreCase: true); return true; }
+        }
+        catch (Exception)
+        {
+            // An unparseable value means this constructor cannot be satisfied from what was saved.
+        }
+
+        return false;
+    }
+}
diff --git a/src/Serialization/LayerStateBag.cs b/src/Serialization/LayerStateBag.cs
index 537b7051dd..bf8c661e79 100644
--- a/src/Serialization/LayerStateBag.cs
+++ b/src/Serialization/LayerStateBag.cs
@@ -1,4 +1,6 @@
-using System.Globalization;
+using System.Globalization;
+using System.Collections;
+using System.Reflection;
 
 namespace AiDotNet.Serialization;
 
@@ -20,6 +22,8 @@ namespace AiDotNet.Serialization;
 /// </remarks>
 public readonly struct LayerStateBag
 {
+    private const string LayerObjectPrefix = "aidotnet-layer-v1:";
+    private const string LayerCollectionPrefix = "aidotnet-layer-list-v1:";
     private readonly Dictionary<string, object>? _values;
     private readonly string _layerName;
 
@@ -73,9 +77,12 @@ public bool HasAll(params string[] keys)
     /// <summary><c>true</c> when a value is present for <paramref name="key"/>.</summary>
     public bool Has(string key) => TryRaw(key, out _);
 
-    private bool TryRaw(string key, out object value)
+    // [NotNullWhen(true)] states the contract the body already keeps: value is non-null on
+    // every true return. Without it each caller sees object? and needs its own suppression,
+    // which is how `null!` spreads outward from one place that knew better.
+    private bool TryRaw(string key, [System.Diagnostics.CodeAnalysis.NotNullWhen(true)] out object? value)
     {
-        value = null!;
+        value = null;
         if (_values is null || !_values.TryGetValue(key, out var v) || v is null) return false;
         value = v;
         return true;
@@ -92,6 +99,20 @@ private InvalidOperationException Missing(string key, string wanted)
             "This value is written at save time by the generated GetMetadata override for parameters " +
             "marked [LayerState]. A payload saved before that parameter was marked will not contain it.");
 
+    /// <summary>Reads the tagged payload used for nullable construction state.</summary>
+    /// <remarks>
+    /// New values use <c>n:</c> for null and <c>v:</c> before a present value. Untagged text is
+    /// accepted as the legacy non-null representation, so packages produced before nullable state
+    /// support remain readable.
+    /// </remarks>
+    private string? NullableText(string key, string wanted)
+    {
+        if (!TryRaw(key, out var value)) throw Missing(key, wanted);
+        string text = AsText(value);
+        if (string.Equals(text, "n:", StringComparison.Ordinal)) return null;
+        return text.StartsWith("v:", StringComparison.Ordinal) ? text.Substring(2) : text;
+    }
+
     /// <summary>Reads a required 32-bit integer.</summary>
     /// <param name="key">The metadata key.</param>
     /// <returns>The stored value.</returns>
@@ -110,6 +131,15 @@ public int Int32(string key)
     /// <returns>The stored value, or the fallback.</returns>
     public int Int32(string key, int fallback) => Has(key) ? Int32(key) : fallback;
 
+    /// <summary>Reads a nullable 32-bit integer while preserving an explicitly saved null.</summary>
+    public int? NullableInt32(string key)
+    {
+        string? text = NullableText(key, "an integer or null");
+        if (text is null) return null;
+        if (int.TryParse(text, NumberStyles.Integer, CultureInfo.InvariantCulture, out int value)) return value;
+        throw Unparseable(key, text, "an integer or null");
+    }
+
     /// <summary>Reads a required 64-bit integer.</summary>
     /// <param name="key">The metadata key.</param>
     /// <returns>The stored value.</returns>
@@ -122,6 +152,15 @@ public long Int64(string key)
         throw Unparseable(key, v, "an integer");
     }
 
+    /// <summary>Reads a nullable 64-bit integer while preserving an explicitly saved null.</summary>
+    public long? NullableInt64(string key)
+    {
+        string? text = NullableText(key, "an integer or null");
+        if (text is null) return null;
+        if (long.TryParse(text, NumberStyles.Integer, CultureInfo.InvariantCulture, out long value)) return value;
+        throw Unparseable(key, text, "an integer or null");
+    }
+
     /// <summary>Reads a required double.</summary>
     /// <param name="key">The metadata key.</param>
     /// <returns>The stored value.</returns>
@@ -140,11 +179,27 @@ public double Double(string key)
     /// <returns>The stored value, or the fallback.</returns>
     public double Double(string key, double fallback) => Has(key) ? Double(key) : fallback;
 
+    /// <summary>Reads a nullable double while preserving an explicitly saved null.</summary>
+    public double? NullableDouble(string key)
+    {
+        string? text = NullableText(key, "a number or null");
+        if (text is null) return null;
+        if (double.TryParse(text, NumberStyles.Float, CultureInfo.InvariantCulture, out double value)) return value;
+        throw Unparseable(key, text, "a number or null");
+    }
+
     /// <summary>Reads a required single-precision float.</summary>
     /// <param name="key">The metadata key.</param>
     /// <returns>The stored value.</returns>
     public float Single(string key) => (float)Double(key);
 
+    /// <summary>Reads a nullable single-precision value while preserving an explicitly saved null.</summary>
+    public float? NullableSingle(string key)
+    {
+        double? value = NullableDouble(key);
+        return value.HasValue ? (float)value.Value : null;
+    }
+
     /// <summary>Reads a required boolean.</summary>
     /// <param name="key">The metadata key.</param>
     /// <returns>The stored value.</returns>
@@ -162,6 +217,15 @@ public bool Boolean(string key)
     /// <returns>The stored value, or the fallback.</returns>
     public bool Boolean(string key, bool fallback) => Has(key) ? Boolean(key) : fallback;
 
+    /// <summary>Reads a nullable boolean while preserving an explicitly saved null.</summary>
+    public bool? NullableBoolean(string key)
+    {
+        string? text = NullableText(key, "true, false, or null");
+        if (text is null) return null;
+        if (bool.TryParse(text, out bool value)) return value;
+        throw Unparseable(key, text, "true, false, or null");
+    }
+
     /// <summary>Reads a required string.</summary>
     /// <param name="key">The metadata key.</param>
     /// <returns>The stored value.</returns>
@@ -174,6 +238,9 @@ public string String(string key)
     /// <returns>The stored value, or the fallback.</returns>
     public string? String(string key, string? fallback) => Has(key) ? String(key) : fallback;
 
+    /// <summary>Reads nullable text while distinguishing null from the empty string.</summary>
+    public string? NullableString(string key) => NullableText(key, "text or null");
+
     /// <summary>Reads a required enum value.</summary>
     /// <typeparam name="TEnum">The enum type.</typeparam>
     /// <param name="key">The metadata key.</param>
@@ -194,6 +261,475 @@ public TEnum Enum<TEnum>(string key) where TEnum : struct, Enum
     public TEnum Enum<TEnum>(string key, TEnum fallback) where TEnum : struct, Enum
         => Has(key) ? Enum<TEnum>(key) : fallback;
 
+    /// <summary>Reads a nullable enum while preserving an explicitly saved null.</summary>
+    public TEnum? NullableEnum<TEnum>(string key) where TEnum : struct, Enum
+    {
+        string? text = NullableText(key, $"one of {string.Join("/", System.Enum.GetNames(typeof(TEnum)))} or null");
+        if (text is null) return null;
+        if (System.Enum.TryParse<TEnum>(text, ignoreCase: true, out var value)) return value;
+        throw Unparseable(key, text, $"one of {string.Join("/", System.Enum.GetNames(typeof(TEnum)))} or null");
+    }
+
+    /// <summary>Reads an array of enum values stored by name.</summary>
+    public TEnum[] EnumArray<TEnum>(string key) where TEnum : struct, Enum
+    {
+        if (!TryRaw(key, out var value)) throw Missing(key, $"a list of {typeof(TEnum).Name} values");
+        if (value is TEnum[] typed) return (TEnum[])typed.Clone();
+
+        string text = AsText(value);
+        if (text.Length == 0) return [];
+
+        string[] parts = text.Split([','], StringSplitOptions.RemoveEmptyEntries);
+        var result = new TEnum[parts.Length];
+        for (int i = 0; i < parts.Length; i++)
+        {
+            if (!System.Enum.TryParse(parts[i], ignoreCase: true, out result[i]))
+                throw Unparseable(key, value, $"a list of {typeof(TEnum).Name} values");
+        }
+        return result;
+    }
+
+    /// <summary>Reads a JSON-backed, compile-time-fixed configuration object.</summary>
+    public TConfiguration JsonObject<TConfiguration>(string key) where TConfiguration : class
+    {
+        if (!TryRaw(key, out var value)) throw Missing(key, typeof(TConfiguration).Name);
+
+        // The object-valued in-memory clone channel must not alias mutable configuration. Passing
+        // it through the same fixed-type JSON representation used by durable metadata gives both
+        // paths identical deep-copy semantics without enabling TypeNameHandling.
+        string json = value is TConfiguration configured
+            ? Newtonsoft.Json.JsonConvert.SerializeObject(configured)
+            : AsText(value);
+        try
+        {
+            return Newtonsoft.Json.JsonConvert.DeserializeObject<TConfiguration>(json)
+                ?? throw Missing(key, typeof(TConfiguration).Name);
+        }
+        catch (Newtonsoft.Json.JsonException ex)
+        {
+            throw new InvalidOperationException(
+                $"Cannot rebuild {_layerName}: '{key}' is not valid {typeof(TConfiguration).Name} JSON.", ex);
+        }
+    }
+
+    /// <summary>
+    /// Reads and independently clones an object supplied through the in-memory construction channel.
+    /// </summary>
+    /// <remarks>
+    /// Used for mutable child collections and tensors that cannot be reduced to a type name without
+    /// losing their state. A durable payload containing only that type name fails explicitly rather
+    /// than silently substituting the constructor default and changing the layer topology.
+    /// </remarks>
+    public TObject CloneObject<TObject>(string key) where TObject : class
+    {
+        if (!TryRaw(key, out var value)) throw Missing(key, typeof(TObject).Name);
+        if (value is string text && text.StartsWith(LayerObjectPrefix, StringComparison.Ordinal))
+        {
+            object restored = RestoreLayerConstructionObject(
+                typeof(TObject), text.Substring(LayerObjectPrefix.Length));
+            if (restored is TObject typed) return typed;
+
+            throw new InvalidOperationException(
+                $"Cannot rebuild {_layerName}: durable construction object '{key}' restored as "
+                + $"{restored.GetType().FullName}, which is not assignable to {typeof(TObject).FullName}.");
+        }
+        if (value is string collectionText
+            && collectionText.StartsWith(LayerCollectionPrefix, StringComparison.Ordinal))
+        {
+            object restored = RestoreLayerConstructionCollection(
+                typeof(TObject), collectionText.Substring(LayerCollectionPrefix.Length));
+            if (restored is TObject typed) return typed;
+
+            throw new InvalidOperationException(
+                $"Cannot rebuild {_layerName}: durable construction collection '{key}' restored as "
+                + $"{restored.GetType().FullName}, which is not assignable to {typeof(TObject).FullName}.");
+        }
+
+        if (value is not TObject configured)
+        {
+            throw new InvalidOperationException(
+                $"Cannot rebuild {_layerName}: '{key}' is a live {typeof(TObject).Name} construction "
+                + "object and the durable payload contains only its type description. Substituting "
+                + "the constructor default would change parameter ownership or layer topology.");
+        }
+
+        return (TObject)CloneConstructionObject(
+            configured,
+            new Dictionary<object, object>(ConstructionReferenceComparer.Instance));
+    }
+
+    /// <summary>
+    /// Formats an owned construction object for layer metadata.
+    /// </summary>
+    /// <remarks>
+    /// Layer objects use a registry-checked binary payload containing their generated construction
+    /// metadata and complete layer state. Other construction objects retain the legacy type
+    /// description: delegates and arbitrary object graphs are intentionally not activated from a
+    /// durable payload. The in-memory object channel still clones all supported shapes directly.
+    /// </remarks>
+    public static string FormatCloneObject(object? value)
+    {
+        if (value is null) return string.Empty;
+
+        Type? layerBase = FindGenericBase(value.GetType(), "AiDotNet.NeuralNetworks.Layers.LayerBase`1");
+        if (layerBase is null)
+        {
+            if (TryGetLayerCollection(value, out var layers))
+                return FormatLayerCollection(layers);
+            return FormatType(value);
+        }
+
+        var inputShape = (int[]?)value.GetType().GetMethod("GetInputShape", Type.EmptyTypes)?.Invoke(value, null)
+            ?? Array.Empty<int>();
+        var outputShape = (int[]?)value.GetType().GetMethod("GetOutputShape", Type.EmptyTypes)?.Invoke(value, null)
+            ?? Array.Empty<int>();
+        // GetMetadata is the internal virtual persistence contract on LayerBase. Looking it up on
+        // the runtime type with the public-only convenience overload silently returned null, so a
+        // nested construction layer was emitted with no constructor metadata at all. Invoke the
+        // base declaration explicitly; reflection still performs virtual dispatch to any derived
+        // override (for example GQA's head-count and RoPE metadata).
+        var metadata = layerBase.GetMethod(
+                "GetMetadata",
+                BindingFlags.NonPublic | BindingFlags.Instance)
+            ?.Invoke(value, null) as IDictionary<string, string>
+            ?? new Dictionary<string, string>(StringComparer.Ordinal);
+
+        using var stream = new MemoryStream();
+        using (var writer = new BinaryWriter(stream, System.Text.Encoding.UTF8, leaveOpen: true))
+        {
+            Type runtimeType = value.GetType();
+            Type definition = runtimeType.IsGenericType
+                ? runtimeType.GetGenericTypeDefinition()
+                : runtimeType;
+            writer.Write(definition.FullName ?? definition.Name);
+            WriteShape(writer, inputShape);
+            WriteShape(writer, outputShape);
+            writer.Write(metadata.Count);
+            foreach (var pair in metadata.OrderBy(pair => pair.Key, StringComparer.Ordinal))
+            {
+                writer.Write(pair.Key ?? string.Empty);
+                writer.Write(pair.Value ?? string.Empty);
+            }
+
+            var serialize = layerBase.GetMethod(
+                "Serialize",
+                BindingFlags.Public | BindingFlags.Instance,
+                binder: null,
+                new[] { typeof(BinaryWriter) },
+                modifiers: null);
+            if (serialize is null)
+                throw new InvalidOperationException(
+                    $"Cannot persist construction layer {runtimeType.FullName}: Serialize(BinaryWriter) is unavailable.");
+            serialize.Invoke(value, new object[] { writer });
+            writer.Flush();
+        }
+
+        return LayerObjectPrefix + Convert.ToBase64String(stream.ToArray());
+    }
+
+    private static bool TryGetLayerCollection(object value, out List<object> layers)
+    {
+        layers = new List<object>();
+        if (value is string || value is not IEnumerable enumerable) return false;
+
+        Type? elementType = FindEnumerableElementType(value.GetType());
+        if (elementType is null || FindLayerInterface(elementType) is null) return false;
+
+        foreach (object? item in enumerable)
+        {
+            if (item is null
+                || FindGenericBase(item.GetType(), "AiDotNet.NeuralNetworks.Layers.LayerBase`1") is null)
+            {
+                layers.Clear();
+                return false;
+            }
+            layers.Add(item);
+        }
+        return true;
+    }
+
+    private static string FormatLayerCollection(IReadOnlyList<object> layers)
+    {
+        using var stream = new MemoryStream();
+        using (var writer = new BinaryWriter(stream, System.Text.Encoding.UTF8, leaveOpen: true))
+        {
+            writer.Write(layers.Count);
+            for (int i = 0; i < layers.Count; i++)
+                writer.Write(FormatCloneObject(layers[i]));
+            writer.Flush();
+        }
+        return LayerCollectionPrefix + Convert.ToBase64String(stream.ToArray());
+    }
+
+    private object RestoreLayerConstructionCollection(Type expectedType, string encoded)
+    {
+        Type? elementType = FindEnumerableElementType(expectedType);
+        if (elementType is null || FindLayerInterface(elementType) is null)
+            throw new InvalidOperationException(
+                $"Cannot rebuild {_layerName}: {expectedType.FullName} is not a layer collection.");
+
+        byte[] bytes;
+        try { bytes = Convert.FromBase64String(encoded); }
+        catch (FormatException ex)
+        {
+            throw new InvalidOperationException(
+                $"Cannot rebuild {_layerName}: a durable construction-layer collection is not valid base64.", ex);
+        }
+
+        using var stream = new MemoryStream(bytes, writable: false);
+        using var reader = new BinaryReader(stream, System.Text.Encoding.UTF8, leaveOpen: true);
+        int count = reader.ReadInt32();
+        if (count < 0) throw new InvalidDataException("Construction-layer collection count cannot be negative.");
+
+        Type listType = typeof(List<>).MakeGenericType(elementType);
+        var list = (IList)(Activator.CreateInstance(listType)
+            ?? throw new InvalidOperationException($"Cannot create {listType.FullName}."));
+        for (int i = 0; i < count; i++)
+        {
+            string item = reader.ReadString();
+            if (!item.StartsWith(LayerObjectPrefix, StringComparison.Ordinal))
+                throw new InvalidDataException("Construction-layer collection contains a non-layer payload.");
+            list.Add(RestoreLayerConstructionObject(
+                elementType, item.Substring(LayerObjectPrefix.Length)));
+        }
+        if (stream.Position != stream.Length)
+            throw new InvalidDataException("Construction-layer collection payload has trailing data.");
+
+        if (!expectedType.IsArray) return list;
+        Array array = Array.CreateInstance(elementType, count);
+        list.CopyTo(array, 0);
+        return array;
+    }
+
+    private object RestoreLayerConstructionObject(Type expectedType, string encoded)
+    {
+        byte[] bytes;
+        try
+        {
+            bytes = Convert.FromBase64String(encoded);
+        }
+        catch (FormatException ex)
+        {
+            throw new InvalidOperationException(
+                $"Cannot rebuild {_layerName}: a durable construction-layer payload is not valid base64.", ex);
+        }
+
+        Type? layerInterface = FindLayerInterface(expectedType);
+        Type? numericType = layerInterface?.GetGenericArguments()[0];
+        if (numericType is null)
+        {
+            throw new InvalidOperationException(
+                $"Cannot rebuild {_layerName}: the requested construction object does not expose ILayer<T>.");
+        }
+
+        MethodInfo restore = typeof(LayerStateBag).GetMethod(
+            nameof(RestoreLayerConstructionObjectCore),
+            BindingFlags.NonPublic | BindingFlags.Static)
+            ?? throw new InvalidOperationException("Layer construction restore helper is unavailable.");
+        try
+        {
+            return restore.MakeGenericMethod(numericType).Invoke(null, new object[] { bytes })
+                ?? throw new InvalidOperationException("Layer construction restore returned null.");
+        }
+        catch (TargetInvocationException ex) when (ex.InnerException is not null)
+        {
+            throw new InvalidOperationException(
+                $"Cannot rebuild {_layerName}: its durable construction layer could not be restored.",
+                ex.InnerException);
+        }
+    }
+
+    private static object RestoreLayerConstructionObjectCore<T>(byte[] bytes)
+    {
+        using var stream = new MemoryStream(bytes, writable: false);
+        using var reader = new BinaryReader(stream, System.Text.Encoding.UTF8, leaveOpen: true);
+        string typeName = reader.ReadString();
+        int[] inputShape = ReadShape(reader);
+        int[] outputShape = ReadShape(reader);
+        int metadataCount = reader.ReadInt32();
+        if (metadataCount < 0)
+            throw new InvalidDataException("Construction-layer metadata count cannot be negative.");
+
+        var metadata = new Dictionary<string, object>(metadataCount, StringComparer.Ordinal);
+        for (int i = 0; i < metadataCount; i++) metadata[reader.ReadString()] = reader.ReadString();
+
+        object created = AiDotNet.Helpers.DeserializationHelper.CreateLayerFromType<T>(
+            typeName, inputShape, outputShape, metadata);
+        if (created is not AiDotNet.NeuralNetworks.Layers.LayerBase<T> layer)
+            throw new InvalidDataException(
+                $"Construction object '{typeName}' did not rebuild as LayerBase<{typeof(T).Name}>.");
+
+        layer.Deserialize(reader);
+        if (stream.Position != stream.Length)
+            throw new InvalidDataException(
+                $"Construction-layer payload for '{typeName}' has trailing data.");
+        return layer;
+    }
+
+    private static Type? FindLayerInterface(Type type)
+    {
+        if (type.IsGenericType
+            && type.GetGenericTypeDefinition().FullName == "AiDotNet.Interfaces.ILayer`1")
+            return type;
+
+        return type.GetInterfaces().FirstOrDefault(candidate =>
+            candidate.IsGenericType
+            && candidate.GetGenericTypeDefinition().FullName == "AiDotNet.Interfaces.ILayer`1");
+    }
+
+    private static Type? FindEnumerableElementType(Type type)
+    {
+        if (type.IsArray) return type.GetElementType();
+        if (type.IsGenericType && type.GetGenericArguments().Length == 1
+            && type.GetGenericTypeDefinition() is Type definition
+            && (definition == typeof(IEnumerable<>)
+                || definition == typeof(ICollection<>)
+                || definition == typeof(IList<>)
+                || definition == typeof(IReadOnlyCollection<>)
+                || definition == typeof(IReadOnlyList<>)
+                || definition == typeof(List<>)))
+        {
+            return type.GetGenericArguments()[0];
+        }
+
+        foreach (Type candidate in type.GetInterfaces())
+        {
+            if (candidate.IsGenericType
+                && candidate.GetGenericTypeDefinition() == typeof(IEnumerable<>))
+                return candidate.GetGenericArguments()[0];
+        }
+        return null;
+    }
+
+    private static Type? FindGenericBase(Type type, string genericDefinitionName)
+    {
+        for (Type? current = type; current is not null && current != typeof(object); current = current.BaseType)
+        {
+            if (current.IsGenericType
+                && current.GetGenericTypeDefinition().FullName == genericDefinitionName)
+                return current;
+        }
+        return null;
+    }
+
+    private static void WriteShape(BinaryWriter writer, int[] shape)
+    {
+        writer.Write(shape.Length);
+        for (int i = 0; i < shape.Length; i++) writer.Write(shape[i]);
+    }
+
+    private static int[] ReadShape(BinaryReader reader)
+    {
+        int count = reader.ReadInt32();
+        if (count < 0 || count > 64)
+            throw new InvalidDataException($"Construction-layer shape rank {count} is invalid.");
+        var shape = new int[count];
+        for (int i = 0; i < count; i++) shape[i] = reader.ReadInt32();
+        return shape;
+    }
+
+    private static object CloneConstructionObject(
+        object source,
+        Dictionary<object, object> visited)
+    {
+        Type type = source.GetType();
+        if (type.IsValueType || source is string) return source;
+        if (visited.TryGetValue(source, out object? prior)) return prior;
+
+        // Delegates are immutable invocation descriptors. Their target may be compiler-generated
+        // closure state that cannot be reconstructed safely by setting readonly runtime fields; the
+        // callable itself is construction configuration, not learned mutable tensor state.
+        if (source is Delegate) return source;
+
+        if (source is Array array)
+        {
+            var copy = (Array)array.Clone();
+            visited[source] = copy;
+            if (!type.GetElementType()!.IsValueType)
+            {
+                // Array.GetValue(int) is valid only for rank-one arrays. Construction objects can
+                // legitimately contain rectangular arrays, so walk the actual bounds and preserve
+                // every dimension while recursively cloning reference elements.
+                var indices = new int[array.Rank];
+                for (int dimension = 0; dimension < indices.Length; dimension++)
+                    indices[dimension] = array.GetLowerBound(dimension);
+
+                for (int visitedElements = 0; visitedElements < array.Length; visitedElements++)
+                {
+                    if (array.GetValue(indices) is object item)
+                        copy.SetValue(CloneConstructionObject(item, visited), indices);
+
+                    for (int dimension = indices.Length - 1; dimension >= 0; dimension--)
+                    {
+                        if (indices[dimension] < array.GetUpperBound(dimension))
+                        {
+                            indices[dimension]++;
+                            break;
+                        }
+
+                        indices[dimension] = array.GetLowerBound(dimension);
+                    }
+                }
+            }
+            return copy;
+        }
+
+        if (source is IList list)
+        {
+            if (Activator.CreateInstance(type) is not IList copy)
+                throw new InvalidOperationException($"Cannot clone construction list {type.FullName}.");
+
+            visited[source] = copy;
+            foreach (object? item in list)
+                copy.Add(item is null ? null : CloneConstructionObject(item, visited));
+            return copy;
+        }
+
+        MethodInfo? publicClone = type.GetMethod(
+            "Clone",
+            BindingFlags.Public | BindingFlags.Instance,
+            binder: null,
+            Type.EmptyTypes,
+            modifiers: null);
+        if (publicClone is not null && publicClone.Invoke(source, null) is object cloned)
+        {
+            visited[source] = cloned;
+            return cloned;
+        }
+
+        object structural = AiDotNet.Models.CloneEngine.CopyConfiguration(source);
+        visited[source] = structural;
+        CopyAttributedConstructionState(source, structural, visited);
+        return structural;
+    }
+
+    private static void CopyAttributedConstructionState(
+        object source,
+        object destination,
+        Dictionary<object, object> visited)
+    {
+        for (Type? current = source.GetType(); current is not null && current != typeof(object); current = current.BaseType)
+        {
+            foreach (FieldInfo field in current.GetFields(
+                         BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic
+                         | BindingFlags.DeclaredOnly))
+            {
+                bool persistent = field.GetCustomAttributes(inherit: false).Any(attribute =>
+                    attribute.GetType().Name is "TrainableParameterAttribute" or "FittedParameterAttribute");
+                if (!persistent || field.GetValue(source) is not object value) continue;
+
+                field.SetValue(destination, CloneConstructionObject(value, visited));
+            }
+        }
+    }
+
+    private sealed class ConstructionReferenceComparer : IEqualityComparer<object>
+    {
+        internal static readonly ConstructionReferenceComparer Instance = new();
+        public new bool Equals(object? x, object? y) => ReferenceEquals(x, y);
+        public int GetHashCode(object obj) => System.Runtime.CompilerServices.RuntimeHelpers.GetHashCode(obj);
+    }
+
     /// <summary>Reads a required integer array, stored comma-separated.</summary>
     /// <param name="key">The metadata key.</param>
     /// <returns>The stored value.</returns>
@@ -215,12 +751,143 @@ public int[] Int32Array(string key)
         return result;
     }
 
+    /// <summary>Reads a nullable integer array while distinguishing null from an empty array.</summary>
+    public int[]? NullableInt32Array(string key)
+    {
+        string? text = NullableText(key, "a comma-separated list of integers or null");
+        if (text is null) return null;
+        if (text.Length == 0) return [];
+
+        var parts = text.Split([',', ' '], StringSplitOptions.RemoveEmptyEntries);
+        var result = new int[parts.Length];
+        for (int i = 0; i < parts.Length; i++)
+        {
+            if (!int.TryParse(parts[i], NumberStyles.Integer, CultureInfo.InvariantCulture, out result[i]))
+                throw Unparseable(key, text, "a comma-separated list of integers or null");
+        }
+        return result;
+    }
+
     /// <summary>Reads an integer array, or <paramref name="fallback"/> when it was not saved.</summary>
     /// <param name="key">The metadata key.</param>
     /// <param name="fallback">Value to use when the key is absent.</param>
     /// <returns>The stored value, or the fallback.</returns>
     public int[]? Int32Array(string key, int[]? fallback) => Has(key) ? Int32Array(key) : fallback;
 
+    // The four accessors below exist for the SAME reason Int32Array does: a layer whose constructor
+    // takes an array must be able to read it back, and a factory that cannot read its own saved
+    // value would rebuild the layer with a default instead -- silently, because nothing throws when
+    // a constructor is handed a plausible wrong argument. They are used by the out-of-assembly
+    // factory registry, where the constructor cannot be named at compile time.
+
+    /// <summary>Reads a required double array, stored comma-separated.</summary>
+    /// <param name="key">The metadata key.</param>
+    /// <returns>The stored value.</returns>
+    public double[] DoubleArray(string key)
+    {
+        if (!TryRaw(key, out var v)) throw Missing(key, "a comma-separated list of numbers");
+        if (v is double[] arr) return arr;
+
+        var text = AsText(v);
+        if (text.Length == 0) return [];
+
+        var parts = text.Split([',', ' '], StringSplitOptions.RemoveEmptyEntries);
+        var result = new double[parts.Length];
+        for (int i = 0; i < parts.Length; i++)
+        {
+            if (!double.TryParse(parts[i], NumberStyles.Float, CultureInfo.InvariantCulture, out result[i]))
+                throw Unparseable(key, v, "a comma-separated list of numbers");
+        }
+        return result;
+    }
+
+    /// <summary>Reads a double array, or <paramref name="fallback"/> when it was not saved.</summary>
+    /// <param name="key">The metadata key.</param>
+    /// <param name="fallback">Value to use when the key is absent.</param>
+    /// <returns>The stored value, or the fallback.</returns>
+    public double[]? DoubleArray(string key, double[]? fallback) => Has(key) ? DoubleArray(key) : fallback;
+
+    /// <summary>Reads a required boolean array, stored comma-separated.</summary>
+    /// <param name="key">The metadata key.</param>
+    /// <returns>The stored value.</returns>
+    public bool[] BooleanArray(string key)
+    {
+        if (!TryRaw(key, out var v)) throw Missing(key, "a comma-separated list of true/false");
+        if (v is bool[] arr) return arr;
+
+        var text = AsText(v);
+        if (text.Length == 0) return [];
+
+        var parts = text.Split([',', ' '], StringSplitOptions.RemoveEmptyEntries);
+        var result = new bool[parts.Length];
+        for (int i = 0; i < parts.Length; i++)
+        {
+            if (!bool.TryParse(parts[i], out result[i]))
+                throw Unparseable(key, v, "a comma-separated list of true/false");
+        }
+        return result;
+    }
+
+    /// <summary>Reads a boolean array, or <paramref name="fallback"/> when it was not saved.</summary>
+    /// <param name="key">The metadata key.</param>
+    /// <param name="fallback">Value to use when the key is absent.</param>
+    /// <returns>The stored value, or the fallback.</returns>
+    public bool[]? BooleanArray(string key, bool[]? fallback) => Has(key) ? BooleanArray(key) : fallback;
+
+    /// <summary>Reads a required string array, stored newline-separated.</summary>
+    /// <param name="key">The metadata key.</param>
+    /// <returns>The stored value.</returns>
+    /// <remarks>
+    /// Newline-separated rather than comma-separated: a saved string may legitimately contain a
+    /// comma, and splitting on one would turn a single vocabulary entry into two.
+    /// </remarks>
+    public string[] StringArray(string key)
+    {
+        if (!TryRaw(key, out var v)) throw Missing(key, "a newline-separated list of strings");
+        if (v is string[] arr) return arr;
+
+        var text = AsText(v);
+        return text.Length == 0 ? [] : text.Split('\n');
+    }
+
+    /// <summary>Reads a string array, or <paramref name="fallback"/> when it was not saved.</summary>
+    /// <param name="key">The metadata key.</param>
+    /// <param name="fallback">Value to use when the key is absent.</param>
+    /// <returns>The stored value, or the fallback.</returns>
+    public string[]? StringArray(string key, string[]? fallback) => Has(key) ? StringArray(key) : fallback;
+
+    /// <summary>Reads a required jagged integer array: rows separated by ';', values by ','.</summary>
+    /// <param name="key">The metadata key.</param>
+    /// <returns>The stored value.</returns>
+    public int[][] Int32Jagged(string key)
+    {
+        if (!TryRaw(key, out var v)) throw Missing(key, "semicolon-separated rows of comma-separated integers");
+        if (v is int[][] arr) return arr;
+
+        var text = AsText(v);
+        if (text.Length == 0) return [];
+
+        var rows = text.Split([';'], StringSplitOptions.RemoveEmptyEntries);
+        var result = new int[rows.Length][];
+        for (int r = 0; r < rows.Length; r++)
+        {
+            var parts = rows[r].Split([',', ' '], StringSplitOptions.RemoveEmptyEntries);
+            result[r] = new int[parts.Length];
+            for (int c = 0; c < parts.Length; c++)
+            {
+                if (!int.TryParse(parts[c], NumberStyles.Integer, CultureInfo.InvariantCulture, out result[r][c]))
+                    throw Unparseable(key, v, "semicolon-separated rows of comma-separated integers");
+            }
+        }
+        return result;
+    }
+
+    /// <summary>Reads a jagged integer array, or <paramref name="fallback"/> when it was not saved.</summary>
+    /// <param name="key">The metadata key.</param>
+    /// <param name="fallback">Value to use when the key is absent.</param>
+    /// <returns>The stored value, or the fallback.</returns>
+    public int[][]? Int32Jagged(string key, int[][]? fallback) => Has(key) ? Int32Jagged(key) : fallback;
+
     /// <summary>
     /// Rebuilds a pluggable component (an RBF kernel, a distance metric, ...) from the concrete
     /// type recorded at save time.
@@ -241,6 +908,16 @@ public int[] Int32Array(string key)
     {
         if (!TryRaw(key, out var v)) return null;
 
+        // In-memory cloning supplies the live configured component rather than reducing it to a
+        // type name. This preserves constructor configuration and also supports components with no
+        // parameterless constructor. Durable payloads still arrive as text below.
+        if (v is TComponent component)
+        {
+            return (TComponent)CloneConstructionObject(
+                component,
+                new Dictionary<object, object>(ConstructionReferenceComparer.Instance));
+        }
+
         var typeName = AsText(v);
         if (typeName.Length == 0) return null;
 
@@ -294,8 +971,30 @@ public int[] Int32Array(string key)
         // one now matches it.
         try
         {
-            var created = Activator.CreateInstance(type)
-                ?? throw new InvalidOperationException(
+            object? created;
+            var parameterless = type.GetConstructor(Type.EmptyTypes);
+            if (parameterless is not null)
+            {
+                created = parameterless.Invoke(null);
+            }
+            else
+            {
+                // Reflection does not regard `(bool enabled = true)` as parameterless even though
+                // every C# caller can invoke it with no arguments. Bind Type.Missing so optional
+                // defaults work for components such as initialization strategies.
+                var optional = type.GetConstructors()
+                    .FirstOrDefault(c => c.GetParameters().Length > 0
+                        && c.GetParameters().All(p => p.IsOptional));
+                if (optional is null) throw new MissingMethodException();
+                var defaults = Enumerable.Repeat<object?>(Type.Missing, optional.GetParameters().Length).ToArray();
+                created = optional.Invoke(
+                    System.Reflection.BindingFlags.OptionalParamBinding,
+                    binder: null,
+                    parameters: defaults,
+                    culture: null);
+            }
+
+            if (created is null) throw new InvalidOperationException(
                     $"Activator returned null for '{type.FullName}'. A component type that cannot be "
                     + "instantiated must fail here rather than hand back a null component that only "
                     + "reports itself much later, as a null reference in unrelated code.");
@@ -350,4 +1049,41 @@ private static string AsText(object value)
 
     /// <inheritdoc cref="Format(int)"/>
     public static string Format(int[]? value) => value is null ? string.Empty : string.Join(",", value);
+
+    /// <summary>Formats jagged integer state as semicolon-separated rows.</summary>
+    public static string Format(int[][]? value)
+        => value is null ? string.Empty : string.Join(";", value.Select(row => string.Join(",", row)));
+
+    /// <summary>Formats an enum array by member name.</summary>
+    public static string FormatEnumArray<TEnum>(TEnum[]? value) where TEnum : struct, Enum
+        => value is null ? string.Empty : string.Join(",", value);
+
+    /// <summary>Formats a fixed-type configuration object without polymorphic type metadata.</summary>
+    public static string FormatJson(object? value)
+        => value is null ? "null" : Newtonsoft.Json.JsonConvert.SerializeObject(value);
+
+    /// <summary>Formats nullable integer state without conflating null with a real value.</summary>
+    public static string FormatNullable(int? value) => value.HasValue ? "v:" + Format(value.Value) : "n:";
+
+    /// <summary>Formats nullable long state without conflating null with a real value.</summary>
+    public static string FormatNullable(long? value) => value.HasValue ? "v:" + Format(value.Value) : "n:";
+
+    /// <summary>Formats nullable double state without conflating null with a real value.</summary>
+    public static string FormatNullable(double? value) => value.HasValue ? "v:" + Format(value.Value) : "n:";
+
+    /// <summary>Formats nullable float state without conflating null with a real value.</summary>
+    public static string FormatNullable(float? value) => value.HasValue ? "v:" + Format(value.Value) : "n:";
+
+    /// <summary>Formats nullable boolean state without conflating null with a real value.</summary>
+    public static string FormatNullable(bool? value) => value.HasValue ? "v:" + Format(value.Value) : "n:";
+
+    /// <summary>Formats nullable text without conflating null with the empty string.</summary>
+    public static string FormatNullable(string? value) => value is null ? "n:" : "v:" + value;
+
+    /// <summary>Formats nullable enum state without conflating null with a real value.</summary>
+    public static string FormatNullable<TEnum>(TEnum? value) where TEnum : struct, Enum
+        => value.HasValue ? "v:" + value.Value.ToString() : "n:";
+
+    /// <summary>Formats nullable integer-array state without conflating null with an empty array.</summary>
+    public static string FormatNullable(int[]? value) => value is null ? "n:" : "v:" + string.Join(",", value);
 }
diff --git a/src/SpeechRecognition/AlibabaASR/FunASRNano.cs b/src/SpeechRecognition/AlibabaASR/FunASRNano.cs
index 113c5649aa..a2cda68b0d 100644
--- a/src/SpeechRecognition/AlibabaASR/FunASRNano.cs
+++ b/src/SpeechRecognition/AlibabaASR/FunASRNano.cs
@@ -41,7 +41,7 @@ namespace AiDotNet.SpeechRecognition.AlibabaASR;
 [ModelComplexity(ModelComplexity.Low)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("FunASR: A Fundamental End-to-End Speech Recognition Toolkit", "https://arxiv.org/abs/2305.11013", Year = 2024, Authors = "Gao et al.")]
-public class FunASRNano<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
+public partial class FunASRNano<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
 {
     private readonly FunASRNanoOptions _options; public override ModelOptions GetOptions() => _options;
     private IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer; private bool _useNativeMode; private bool _disposed;
@@ -140,9 +140,8 @@ public override void Train(Tensor<T> input, Tensor<T> expected)
             ["Language"] = _options.Language
         }
     };
-    protected override void SerializeNetworkSpecificData(BinaryWriter w) { w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty); w.Write(_options.SampleRate); w.Write(_options.MaxAudioLengthSeconds); w.Write(_options.EncoderDim); w.Write(_options.NumEncoderLayers); w.Write(_options.NumAttentionHeads); w.Write(_options.NumMels); w.Write(_options.VocabSize); w.Write(_options.MaxTextLength); w.Write(_options.DropoutRate); w.Write(_options.Language); }
-    protected override void DeserializeNetworkSpecificData(BinaryReader r) { _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp; _options.SampleRate = r.ReadInt32(); _options.MaxAudioLengthSeconds = r.ReadInt32(); _options.EncoderDim = r.ReadInt32(); _options.NumEncoderLayers = r.ReadInt32(); _options.NumAttentionHeads = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.VocabSize = r.ReadInt32(); _options.MaxTextLength = r.ReadInt32(); _options.DropoutRate = r.ReadDouble(); _options.Language = r.ReadString(); base.SampleRate = _options.SampleRate; base.NumMels = _options.NumMels; if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions); }
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() { if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp)) return new FunASRNano<T>(Architecture, mp, _options); return new FunASRNano<T>(Architecture, _options); }
+
+
 
     private (List<int> tokens, double confidence) CTCGreedyDecodeWithConfidence(Tensor<T> logits) { var tokens = new List<int>(); double totalConf = 0; int confCount = 0; int prevToken = -1; int numFrames = logits.Rank >= 2 ? logits.Shape[0] : 1; int vocabSize = logits.Rank >= 2 ? logits.Shape[^1] : logits.Shape[0]; for (int t = 0; t < numFrames && tokens.Count < _options.MaxTextLength; t++) { int maxIdx = 0; double maxVal = double.NegativeInfinity; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); if (val > maxVal) { maxVal = val; maxIdx = v; } } double sumExp = 0; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); sumExp += Math.Exp(val - maxVal); } double frameConf = 1.0 / sumExp; if (maxIdx != prevToken && maxIdx > 0) { tokens.Add(maxIdx); totalConf += frameConf; confCount++; } prevToken = maxIdx; } return (tokens, confCount > 0 ? totalConf / confCount : 0.0); }
     private static string TokensToText(List<int> tokens) { var sb = new System.Text.StringBuilder(); foreach (var t in tokens) { if (t > 0 && t <= char.MaxValue) sb.Append((char)t); else if (t > char.MaxValue && t <= 0x10FFFF) sb.Append(char.ConvertFromUtf32(t)); } return sb.ToString().Trim(); }
diff --git a/src/SpeechRecognition/AlibabaASR/Paraformer.cs b/src/SpeechRecognition/AlibabaASR/Paraformer.cs
index 451fef7777..f79632d7fa 100644
--- a/src/SpeechRecognition/AlibabaASR/Paraformer.cs
+++ b/src/SpeechRecognition/AlibabaASR/Paraformer.cs
@@ -41,7 +41,7 @@ namespace AiDotNet.SpeechRecognition.AlibabaASR;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Paraformer: Fast and Accurate Parallel Transformer for Non-autoregressive End-to-End Speech Recognition", "https://arxiv.org/abs/2206.08317", Year = 2022, Authors = "Gao et al.")]
-public class Paraformer<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
+public partial class Paraformer<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
 {
     private readonly ParaformerOptions _options; public override ModelOptions GetOptions() => _options;
     private IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer; private bool _useNativeMode; private bool _disposed;
@@ -159,7 +159,7 @@ private AdamWOptimizer<T, Tensor<T>, Tensor<T>> CreateDefaultOptimizer()
                 WeightDecay = _options.WeightDecay
             });
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w) { w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty); w.Write(_options.SampleRate); w.Write(_options.MaxAudioLengthSeconds); w.Write(_options.EncoderDim); w.Write(_options.NumEncoderLayers); w.Write(_options.NumAttentionHeads); w.Write(_options.NumMels); w.Write(_options.VocabSize); w.Write(_options.MaxTextLength); w.Write(_options.DropoutRate); w.Write(_options.Language); w.Write(_options.LearningRate); w.Write(_options.WeightDecay); w.Write(_options.DecoderDim); w.Write(_options.NumDecoderLayers); w.Write(_options.FeedForwardDim); }
+
     /// <inheritdoc/>
     /// <remarks>
     /// <para>
@@ -177,14 +177,7 @@ private AdamWOptimizer<T, Tensor<T>, Tensor<T>> CreateDefaultOptimizer()
     /// is no shortage of bytes -- only a misalignment -- and a version marker is required instead.
     /// </para>
     /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader r) { _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp; _options.SampleRate = r.ReadInt32(); _options.MaxAudioLengthSeconds = r.ReadInt32(); _options.EncoderDim = r.ReadInt32(); _options.NumEncoderLayers = r.ReadInt32(); _options.NumAttentionHeads = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.VocabSize = r.ReadInt32(); _options.MaxTextLength = r.ReadInt32(); _options.DropoutRate = r.ReadDouble(); _options.Language = r.ReadString(); if (r.BaseStream.Position < r.BaseStream.Length) _options.LearningRate = r.ReadDouble(); if (r.BaseStream.Position < r.BaseStream.Length) _options.WeightDecay = r.ReadDouble(); if (r.BaseStream.Position < r.BaseStream.Length) _options.DecoderDim = r.ReadInt32(); if (r.BaseStream.Position < r.BaseStream.Length) _options.NumDecoderLayers = r.ReadInt32(); if (r.BaseStream.Position < r.BaseStream.Length) _options.FeedForwardDim = r.ReadInt32(); if (_useNativeMode && _optimizerIsDefault) _optimizer = CreateDefaultOptimizer(); base.SampleRate = _options.SampleRate; base.NumMels = _options.NumMels; if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions); }
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var options = new ParaformerOptions(_options);
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new Paraformer<T>(Architecture, mp, options);
-        return new Paraformer<T>(Architecture, options);
-    }
+
 
     private (List<int> tokens, double confidence) GreedyDecodeWithConfidence(Tensor<T> logits) { var tokens = new List<int>(); double totalConf = 0; int confCount = 0; int prevToken = -1; int numFrames = logits.Rank >= 2 ? logits.Shape[0] : 1; int vocabSize = logits.Rank >= 2 ? logits.Shape[^1] : logits.Shape[0]; for (int t = 0; t < numFrames && tokens.Count < _options.MaxTextLength; t++) { int maxIdx = 0; double maxVal = double.NegativeInfinity; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); if (val > maxVal) { maxVal = val; maxIdx = v; } } double sumExp = 0; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); sumExp += Math.Exp(val - maxVal); } double frameConf = 1.0 / sumExp; if (maxIdx != prevToken && maxIdx > 0) { tokens.Add(maxIdx); totalConf += frameConf; confCount++; } prevToken = maxIdx; } return (tokens, confCount > 0 ? totalConf / confCount : 0.0); }
     private string TokensToText(List<int> tokens)
diff --git a/src/SpeechRecognition/AlibabaASR/ParaformerLarge.cs b/src/SpeechRecognition/AlibabaASR/ParaformerLarge.cs
index 9352742259..158e150e5b 100644
--- a/src/SpeechRecognition/AlibabaASR/ParaformerLarge.cs
+++ b/src/SpeechRecognition/AlibabaASR/ParaformerLarge.cs
@@ -41,7 +41,7 @@ namespace AiDotNet.SpeechRecognition.AlibabaASR;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Paraformer: Fast and Accurate Parallel Transformer for Non-autoregressive End-to-End Speech Recognition", "https://arxiv.org/abs/2206.08317", Year = 2023, Authors = "Gao et al.")]
-public class ParaformerLarge<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
+public partial class ParaformerLarge<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
 {
     private readonly ParaformerLargeOptions _options; public override ModelOptions GetOptions() => _options;
     private IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer; private bool _useNativeMode; private bool _disposed;
@@ -120,9 +120,8 @@ public override void Train(Tensor<T> input, Tensor<T> expected)
     protected override bool SupportsParameterMutation => _useNativeMode;
     protected override Tensor<T> PostprocessOutput(Tensor<T> o) => o;
     public override ModelMetadata<T> GetModelMetadata() => new() { Name = _useNativeMode ? "ParaformerLarge-Native" : "ParaformerLarge-ONNX", Description = "Paraformer-Large: 220M CIF parallel ASR (Alibaba, 2023)", FeatureCount = _options.NumMels, Complexity = _options.NumEncoderLayers, AdditionalInfo = BaseAudioMetadataInfo() };
-    protected override void SerializeNetworkSpecificData(BinaryWriter w) { w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty); w.Write(_options.SampleRate); w.Write(_options.MaxAudioLengthSeconds); w.Write(_options.EncoderDim); w.Write(_options.NumEncoderLayers); w.Write(_options.NumAttentionHeads); w.Write(_options.NumMels); w.Write(_options.VocabSize); w.Write(_options.MaxTextLength); w.Write(_options.DropoutRate); w.Write(_options.Language); w.Write(_options.DecoderDim); w.Write(_options.NumDecoderLayers); w.Write(_options.FeedForwardDim); }
-    protected override void DeserializeNetworkSpecificData(BinaryReader r) { _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp; _options.SampleRate = r.ReadInt32(); _options.MaxAudioLengthSeconds = r.ReadInt32(); _options.EncoderDim = r.ReadInt32(); _options.NumEncoderLayers = r.ReadInt32(); _options.NumAttentionHeads = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.VocabSize = r.ReadInt32(); _options.MaxTextLength = r.ReadInt32(); _options.DropoutRate = r.ReadDouble(); _options.Language = r.ReadString(); if (r.BaseStream.Position < r.BaseStream.Length) _options.DecoderDim = r.ReadInt32(); if (r.BaseStream.Position < r.BaseStream.Length) _options.NumDecoderLayers = r.ReadInt32(); if (r.BaseStream.Position < r.BaseStream.Length) _options.FeedForwardDim = r.ReadInt32(); base.SampleRate = _options.SampleRate; base.NumMels = _options.NumMels; if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions); }
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() { if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp)) return new ParaformerLarge<T>(Architecture, mp, _options); return new ParaformerLarge<T>(Architecture, _options); }
+
+
 
     private (List<int> tokens, double confidence) CTCGreedyDecodeWithConfidence(Tensor<T> logits) { var tokens = new List<int>(); double totalConf = 0; int confCount = 0; int prevToken = -1; int numFrames = logits.Rank >= 2 ? logits.Shape[0] : 1; int vocabSize = logits.Rank >= 2 ? logits.Shape[^1] : logits.Shape[0]; for (int t = 0; t < numFrames && tokens.Count < _options.MaxTextLength; t++) { int maxIdx = 0; double maxVal = double.NegativeInfinity; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); if (val > maxVal) { maxVal = val; maxIdx = v; } } double sumExp = 0; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); sumExp += Math.Exp(val - maxVal); } double frameConf = 1.0 / sumExp; if (maxIdx != prevToken && maxIdx > 0) { tokens.Add(maxIdx); totalConf += frameConf; confCount++; } prevToken = maxIdx; } return (tokens, confCount > 0 ? totalConf / confCount : 0.0); }
     private static string TokensToText(List<int> tokens) { var sb = new System.Text.StringBuilder(); foreach (var t in tokens) { if (t > 0 && t <= char.MaxValue) sb.Append((char)t); else if (t > char.MaxValue && t <= 0x10FFFF) sb.Append(char.ConvertFromUtf32(t)); } return sb.ToString().Trim(); }
diff --git a/src/SpeechRecognition/AlibabaASR/Qwen3ASR.cs b/src/SpeechRecognition/AlibabaASR/Qwen3ASR.cs
index f65f1b966e..629461a8a1 100644
--- a/src/SpeechRecognition/AlibabaASR/Qwen3ASR.cs
+++ b/src/SpeechRecognition/AlibabaASR/Qwen3ASR.cs
@@ -43,7 +43,7 @@ namespace AiDotNet.SpeechRecognition.AlibabaASR;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Qwen3-ASR Technical Report", "https://qwenlm.github.io/blog/qwen3/", Year = 2025, Authors = "Qwen Team")]
-public class Qwen3ASR<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
+public partial class Qwen3ASR<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
 {
     private readonly Qwen3ASROptions _options; public override ModelOptions GetOptions() => _options;
     private IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer; private bool _useNativeMode; private bool _disposed;
@@ -122,9 +122,8 @@ public override void Train(Tensor<T> input, Tensor<T> expected)
     protected override bool SupportsParameterMutation => _useNativeMode;
     protected override Tensor<T> PostprocessOutput(Tensor<T> o) => o;
     public override ModelMetadata<T> GetModelMetadata() => new() { Name = _useNativeMode ? "Qwen3ASR-Native" : "Qwen3ASR-ONNX", Description = "Qwen3-ASR: LLM-integrated ASR with Qwen3 (Alibaba, 2025)", FeatureCount = _options.NumMels, Complexity = _options.NumEncoderLayers, AdditionalInfo = BaseAudioMetadataInfo() };
-    protected override void SerializeNetworkSpecificData(BinaryWriter w) { w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty); w.Write(_options.SampleRate); w.Write(_options.MaxAudioLengthSeconds); w.Write(_options.EncoderDim); w.Write(_options.NumEncoderLayers); w.Write(_options.NumAttentionHeads); w.Write(_options.NumMels); w.Write(_options.VocabSize); w.Write(_options.MaxTextLength); w.Write(_options.DropoutRate); w.Write(_options.Language); }
-    protected override void DeserializeNetworkSpecificData(BinaryReader r) { _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp; _options.SampleRate = r.ReadInt32(); _options.MaxAudioLengthSeconds = r.ReadInt32(); _options.EncoderDim = r.ReadInt32(); _options.NumEncoderLayers = r.ReadInt32(); _options.NumAttentionHeads = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.VocabSize = r.ReadInt32(); _options.MaxTextLength = r.ReadInt32(); _options.DropoutRate = r.ReadDouble(); _options.Language = r.ReadString(); base.SampleRate = _options.SampleRate; base.NumMels = _options.NumMels; if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions); }
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() { if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp)) return new Qwen3ASR<T>(Architecture, mp, _options); return new Qwen3ASR<T>(Architecture, _options); }
+
+
 
     private (List<int> tokens, double confidence) CTCGreedyDecodeWithConfidence(Tensor<T> logits) { var tokens = new List<int>(); double totalConf = 0; int confCount = 0; int prevToken = -1; int numFrames = logits.Rank >= 2 ? logits.Shape[0] : 1; int vocabSize = logits.Rank >= 2 ? logits.Shape[^1] : logits.Shape[0]; for (int t = 0; t < numFrames && tokens.Count < _options.MaxTextLength; t++) { int maxIdx = 0; double maxVal = double.NegativeInfinity; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); if (val > maxVal) { maxVal = val; maxIdx = v; } } double sumExp = 0; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); sumExp += Math.Exp(val - maxVal); } double frameConf = 1.0 / sumExp; if (maxIdx != prevToken && maxIdx > 0) { tokens.Add(maxIdx); totalConf += frameConf; confCount++; } prevToken = maxIdx; } return (tokens, confCount > 0 ? totalConf / confCount : 0.0); }
     private static string TokensToText(List<int> tokens) { var sb = new System.Text.StringBuilder(); foreach (var t in tokens) { if (t > 0 && t <= char.MaxValue) sb.Append((char)t); else if (t > char.MaxValue && t <= 0x10FFFF) sb.Append(char.ConvertFromUtf32(t)); } return sb.ToString().Trim(); }
diff --git a/src/SpeechRecognition/AlibabaASR/Qwen3ASRSmall.cs b/src/SpeechRecognition/AlibabaASR/Qwen3ASRSmall.cs
index 7a124dd1ac..633a65bad5 100644
--- a/src/SpeechRecognition/AlibabaASR/Qwen3ASRSmall.cs
+++ b/src/SpeechRecognition/AlibabaASR/Qwen3ASRSmall.cs
@@ -42,7 +42,7 @@ namespace AiDotNet.SpeechRecognition.AlibabaASR;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Qwen3-ASR Technical Report", "https://qwenlm.github.io/blog/qwen3/", Year = 2025, Authors = "Qwen Team")]
-public class Qwen3ASRSmall<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
+public partial class Qwen3ASRSmall<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
 {
     private readonly Qwen3ASRSmallOptions _options; public override ModelOptions GetOptions() => _options;
     private IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer; private bool _useNativeMode; private bool _disposed;
@@ -121,9 +121,8 @@ public override void Train(Tensor<T> input, Tensor<T> expected)
     protected override bool SupportsParameterMutation => _useNativeMode;
     protected override Tensor<T> PostprocessOutput(Tensor<T> o) => o;
     public override ModelMetadata<T> GetModelMetadata() => new() { Name = _useNativeMode ? "Qwen3ASRSmall-Native" : "Qwen3ASRSmall-ONNX", Description = "Qwen3-ASR-Small: lightweight LLM ASR (Alibaba, 2025)", FeatureCount = _options.NumMels, Complexity = _options.NumEncoderLayers, AdditionalInfo = BaseAudioMetadataInfo() };
-    protected override void SerializeNetworkSpecificData(BinaryWriter w) { w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty); w.Write(_options.SampleRate); w.Write(_options.MaxAudioLengthSeconds); w.Write(_options.EncoderDim); w.Write(_options.NumEncoderLayers); w.Write(_options.NumAttentionHeads); w.Write(_options.NumMels); w.Write(_options.VocabSize); w.Write(_options.MaxTextLength); w.Write(_options.DropoutRate); w.Write(_options.Language); }
-    protected override void DeserializeNetworkSpecificData(BinaryReader r) { _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp; _options.SampleRate = r.ReadInt32(); _options.MaxAudioLengthSeconds = r.ReadInt32(); _options.EncoderDim = r.ReadInt32(); _options.NumEncoderLayers = r.ReadInt32(); _options.NumAttentionHeads = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.VocabSize = r.ReadInt32(); _options.MaxTextLength = r.ReadInt32(); _options.DropoutRate = r.ReadDouble(); _options.Language = r.ReadString(); base.SampleRate = _options.SampleRate; base.NumMels = _options.NumMels; if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions); }
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() { if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp)) return new Qwen3ASRSmall<T>(Architecture, mp, _options); return new Qwen3ASRSmall<T>(Architecture, _options); }
+
+
 
     private (List<int> tokens, double confidence) CTCGreedyDecodeWithConfidence(Tensor<T> logits) { var tokens = new List<int>(); double totalConf = 0; int confCount = 0; int prevToken = -1; int numFrames = logits.Rank >= 2 ? logits.Shape[0] : 1; int vocabSize = logits.Rank >= 2 ? logits.Shape[^1] : logits.Shape[0]; for (int t = 0; t < numFrames && tokens.Count < _options.MaxTextLength; t++) { int maxIdx = 0; double maxVal = double.NegativeInfinity; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); if (val > maxVal) { maxVal = val; maxIdx = v; } } double sumExp = 0; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); sumExp += Math.Exp(val - maxVal); } double frameConf = 1.0 / sumExp; if (maxIdx != prevToken && maxIdx > 0) { tokens.Add(maxIdx); totalConf += frameConf; confCount++; } prevToken = maxIdx; } return (tokens, confCount > 0 ? totalConf / confCount : 0.0); }
     private static string TokensToText(List<int> tokens) { var sb = new System.Text.StringBuilder(); foreach (var t in tokens) { if (t > 0 && t <= char.MaxValue) sb.Append((char)t); else if (t > char.MaxValue && t <= 0x10FFFF) sb.Append(char.ConvertFromUtf32(t)); } return sb.ToString().Trim(); }
diff --git a/src/SpeechRecognition/AlibabaASR/SeACo.cs b/src/SpeechRecognition/AlibabaASR/SeACo.cs
index 63eaedd4bf..86e40eac71 100644
--- a/src/SpeechRecognition/AlibabaASR/SeACo.cs
+++ b/src/SpeechRecognition/AlibabaASR/SeACo.cs
@@ -43,7 +43,7 @@ namespace AiDotNet.SpeechRecognition.AlibabaASR;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("SeACo-Paraformer: A Non-Autoregressive ASR System with Flexible and Effective Hot-Word Customization Ability", "https://arxiv.org/abs/2308.03266", Year = 2023, Authors = "An et al.")]
-public class SeACo<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
+public partial class SeACo<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
 {
     private readonly SeACoOptions _options; public override ModelOptions GetOptions() => _options;
     private IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer; private bool _useNativeMode; private bool _disposed;
@@ -1002,9 +1002,8 @@ internal Tensor<T> ApplyHotwordPositionMask(Tensor<T> labels, Func<int, bool> is
     protected override bool SupportsParameterMutation => _useNativeMode;
     protected override Tensor<T> PostprocessOutput(Tensor<T> o) => o;
     public override ModelMetadata<T> GetModelMetadata() => new() { Name = _useNativeMode ? "SeACo-Native" : "SeACo-ONNX", Description = "SeACo-Paraformer: hot-word biased CIF ASR (Alibaba, 2023)", FeatureCount = _options.NumMels, Complexity = _options.NumEncoderLayers, AdditionalInfo = BaseAudioMetadataInfo() };
-    protected override void SerializeNetworkSpecificData(BinaryWriter w) { w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty); w.Write(_options.SampleRate); w.Write(_options.MaxAudioLengthSeconds); w.Write(_options.EncoderDim); w.Write(_options.NumEncoderLayers); w.Write(_options.NumAttentionHeads); w.Write(_options.NumMels); w.Write(_options.VocabSize); w.Write(_options.MaxTextLength); w.Write(_options.DropoutRate); w.Write(_options.Language); w.Write(_options.NumDecoderLayers); w.Write(_options.FeedForwardDim); w.Write(_options.NumBiasEncoderLayers); w.Write(_options.LearningRate); w.Write((int)_options.TrainingStage); w.Write(_options.CeWeight); w.Write(_options.MaeWeight); w.Write(_options.BiasMergeLambda); w.Write(_options.SamplerLambda); w.Write(_options.HotwordMinLength); w.Write(_options.HotwordMaxLength); w.Write(_options.HotwordMaskTokenId.HasValue); w.Write(_options.HotwordMaskTokenId ?? 0); w.Write(_options.HotwordBatchRatio); w.Write(_options.HotwordUtteranceRatio); }
-    protected override void DeserializeNetworkSpecificData(BinaryReader r) { _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp; _options.SampleRate = r.ReadInt32(); _options.MaxAudioLengthSeconds = r.ReadInt32(); _options.EncoderDim = r.ReadInt32(); _options.NumEncoderLayers = r.ReadInt32(); _options.NumAttentionHeads = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.VocabSize = r.ReadInt32(); _options.MaxTextLength = r.ReadInt32(); _options.DropoutRate = r.ReadDouble(); _options.Language = r.ReadString(); bool More() => r.BaseStream.Position < r.BaseStream.Length; if (More()) _options.NumDecoderLayers = r.ReadInt32(); if (More()) _options.FeedForwardDim = r.ReadInt32(); if (More()) _options.NumBiasEncoderLayers = r.ReadInt32(); if (More()) _options.LearningRate = r.ReadDouble(); if (More()) _options.TrainingStage = (SeACoTrainingStage)r.ReadInt32(); if (More()) _options.CeWeight = r.ReadDouble(); if (More()) _options.MaeWeight = r.ReadDouble(); if (More()) _options.BiasMergeLambda = r.ReadDouble(); if (More()) _options.SamplerLambda = r.ReadDouble(); if (More()) _options.HotwordMinLength = r.ReadInt32(); if (More()) _options.HotwordMaxLength = r.ReadInt32(); if (More()) { bool hasMask = r.ReadBoolean(); int maskId = More() ? r.ReadInt32() : 0; _options.HotwordMaskTokenId = hasMask ? maskId : null; } if (More()) _options.HotwordBatchRatio = r.ReadDouble(); if (More()) _options.HotwordUtteranceRatio = r.ReadDouble(); base.SampleRate = _options.SampleRate; base.NumMels = _options.NumMels; if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions); }
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() { if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp)) return new SeACo<T>(Architecture, mp, new SeACoOptions(_options)); return new SeACo<T>(Architecture, new SeACoOptions(_options)); }
+
+
 
     private (List<int> tokens, double confidence) CTCGreedyDecodeWithConfidence(Tensor<T> logits) { var tokens = new List<int>(); double totalConf = 0; int confCount = 0; int prevToken = -1; int numFrames = logits.Rank >= 2 ? logits.Shape[0] : 1; int vocabSize = logits.Rank >= 2 ? logits.Shape[^1] : logits.Shape[0]; for (int t = 0; t < numFrames && tokens.Count < _options.MaxTextLength; t++) { int maxIdx = 0; double maxVal = double.NegativeInfinity; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); if (val > maxVal) { maxVal = val; maxIdx = v; } } double sumExp = 0; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); sumExp += Math.Exp(val - maxVal); } double frameConf = 1.0 / sumExp; if (maxIdx != prevToken && maxIdx > 0) { tokens.Add(maxIdx); totalConf += frameConf; confCount++; } prevToken = maxIdx; } return (tokens, confCount > 0 ? totalConf / confCount : 0.0); }
     private static string TokensToText(List<int> tokens) { var sb = new System.Text.StringBuilder(); foreach (var t in tokens) { if (t > 0 && t <= char.MaxValue) sb.Append((char)t); else if (t > char.MaxValue && t <= 0x10FFFF) sb.Append(char.ConvertFromUtf32(t)); } return sb.ToString().Trim(); }
diff --git a/src/SpeechRecognition/AlibabaASR/SenseVoice.cs b/src/SpeechRecognition/AlibabaASR/SenseVoice.cs
index 999c763de1..c15e50a5fc 100644
--- a/src/SpeechRecognition/AlibabaASR/SenseVoice.cs
+++ b/src/SpeechRecognition/AlibabaASR/SenseVoice.cs
@@ -42,7 +42,7 @@ namespace AiDotNet.SpeechRecognition.AlibabaASR;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("FunAudioLLM: Voice Understanding and Generation Foundation Models for Natural Interaction Between Humans and LLMs", "https://arxiv.org/abs/2407.04051", Year = 2024, Authors = "Du et al.")]
-public class SenseVoice<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
+public partial class SenseVoice<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
 {
     private readonly SenseVoiceOptions _options; public override ModelOptions GetOptions() => _options;
     private IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer; private bool _useNativeMode; private bool _disposed;
@@ -112,34 +112,8 @@ public TranscriptionResult<T> Transcribe(Tensor<T> audio, string? language = nul
     /// </remarks>
     private const int NetworkSpecificPayloadVersion = 1;
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w) { w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty); w.Write(_options.SampleRate); w.Write(_options.MaxAudioLengthSeconds); w.Write(_options.EncoderDim); w.Write(_options.NumEncoderLayers); w.Write(_options.NumAttentionHeads); w.Write(_options.NumMels); w.Write(_options.VocabSize); w.Write(_options.MaxTextLength); w.Write(_options.DropoutRate); w.Write(_options.Language);
-        // The configuration a caller can actually set. Without these a saved model reloaded
-        // with default decoder width, depth, feed-forward size, CIF alignment and optimizer
-        // settings -- a different model from the one that was saved, reported as success.
-        w.Write(NetworkSpecificPayloadVersion); w.Write(_options.DecoderDim); w.Write(_options.NumDecoderLayers); w.Write(_options.FeedForwardDim); w.Write(_options.UseCifAlignment); w.Write(_options.LearningRate); w.Write(_options.WeightDecay); }
-    protected override void DeserializeNetworkSpecificData(BinaryReader r) { _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp; _options.SampleRate = r.ReadInt32(); _options.MaxAudioLengthSeconds = r.ReadInt32(); _options.EncoderDim = r.ReadInt32(); _options.NumEncoderLayers = r.ReadInt32(); _options.NumAttentionHeads = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.VocabSize = r.ReadInt32(); _options.MaxTextLength = r.ReadInt32(); _options.DropoutRate = r.ReadDouble(); _options.Language = r.ReadString(); base.SampleRate = _options.SampleRate; base.NumMels = _options.NumMels;
-        var stream = r.BaseStream;
-        if (!stream.CanSeek || stream.Position < stream.Length)
-        {
-            int payloadVersion = r.ReadInt32();
-            if (payloadVersion != NetworkSpecificPayloadVersion)
-            {
-                throw new InvalidOperationException(
-                    $"SenseVoice was saved with network-payload version {payloadVersion}, but this build " +
-                    $"reads version {NetworkSpecificPayloadVersion}. Load it with a matching version of " +
-                    "AiDotNet, or re-save it from one.");
-            }
 
-            _options.DecoderDim = r.ReadInt32(); _options.NumDecoderLayers = r.ReadInt32(); _options.FeedForwardDim = r.ReadInt32(); _options.UseCifAlignment = r.ReadBoolean(); _options.LearningRate = r.ReadDouble(); _options.WeightDecay = r.ReadDouble();
-        }
-        else
-        {
-            System.Diagnostics.Trace.TraceWarning(
-                "AiDotNet.SenseVoice: this model was saved before the decoder and optimizer settings were " +
-                "persisted, so they keep their defaults. Re-save the model to carry them forward.");
-        }
- if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions); }
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() { var options = new SenseVoiceOptions(_options); if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp)) return new SenseVoice<T>(Architecture, mp, options); return new SenseVoice<T>(Architecture, options); }
+
 
     private (List<int> tokens, double confidence) CTCGreedyDecodeWithConfidence(Tensor<T> logits) { var tokens = new List<int>(); double totalConf = 0; int confCount = 0; int prevToken = -1; int numFrames = logits.Rank >= 2 ? logits.Shape[0] : 1; int vocabSize = logits.Rank >= 2 ? logits.Shape[^1] : logits.Shape[0]; for (int t = 0; t < numFrames && tokens.Count < _options.MaxTextLength; t++) { int maxIdx = 0; double maxVal = double.NegativeInfinity; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); if (val > maxVal) { maxVal = val; maxIdx = v; } } double sumExp = 0; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); sumExp += Math.Exp(val - maxVal); } double frameConf = 1.0 / sumExp; if (maxIdx != prevToken && maxIdx > 0) { tokens.Add(maxIdx); totalConf += frameConf; confCount++; } prevToken = maxIdx; } return (tokens, confCount > 0 ? totalConf / confCount : 0.0); }
     private static string TokensToText(List<int> tokens) { var sb = new System.Text.StringBuilder(); foreach (var t in tokens) { if (t > 0 && t <= char.MaxValue) sb.Append((char)t); else if (t > char.MaxValue && t <= 0x10FFFF) sb.Append(char.ConvertFromUtf32(t)); } return sb.ToString().Trim(); }
diff --git a/src/SpeechRecognition/AlibabaASR/SenseVoiceLarge.cs b/src/SpeechRecognition/AlibabaASR/SenseVoiceLarge.cs
index 1ee7255495..64c2d9bc3e 100644
--- a/src/SpeechRecognition/AlibabaASR/SenseVoiceLarge.cs
+++ b/src/SpeechRecognition/AlibabaASR/SenseVoiceLarge.cs
@@ -42,7 +42,7 @@ namespace AiDotNet.SpeechRecognition.AlibabaASR;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("FunAudioLLM: Voice Understanding and Generation Foundation Models for Natural Interaction Between Humans and LLMs", "https://arxiv.org/abs/2407.04051", Year = 2024, Authors = "Du et al.")]
-public class SenseVoiceLarge<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
+public partial class SenseVoiceLarge<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
 {
     private readonly SenseVoiceLargeOptions _options; public override ModelOptions GetOptions() => _options;
     private IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer; private bool _useNativeMode; private bool _disposed;
@@ -112,34 +112,8 @@ public TranscriptionResult<T> Transcribe(Tensor<T> audio, string? language = nul
     /// </remarks>
     private const int NetworkSpecificPayloadVersion = 1;
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w) { w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty); w.Write(_options.SampleRate); w.Write(_options.MaxAudioLengthSeconds); w.Write(_options.EncoderDim); w.Write(_options.NumEncoderLayers); w.Write(_options.NumAttentionHeads); w.Write(_options.NumMels); w.Write(_options.VocabSize); w.Write(_options.MaxTextLength); w.Write(_options.DropoutRate); w.Write(_options.Language);
-        // The configuration a caller can actually set. Without these a saved model reloaded
-        // with default decoder width, depth, feed-forward size, CIF alignment and optimizer
-        // settings -- a different model from the one that was saved, reported as success.
-        w.Write(NetworkSpecificPayloadVersion); w.Write(_options.DecoderDim); w.Write(_options.NumDecoderLayers); w.Write(_options.FeedForwardDim); w.Write(_options.UseCifAlignment); w.Write(_options.LearningRate); w.Write(_options.WeightDecay); }
-    protected override void DeserializeNetworkSpecificData(BinaryReader r) { _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp; _options.SampleRate = r.ReadInt32(); _options.MaxAudioLengthSeconds = r.ReadInt32(); _options.EncoderDim = r.ReadInt32(); _options.NumEncoderLayers = r.ReadInt32(); _options.NumAttentionHeads = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.VocabSize = r.ReadInt32(); _options.MaxTextLength = r.ReadInt32(); _options.DropoutRate = r.ReadDouble(); _options.Language = r.ReadString(); base.SampleRate = _options.SampleRate; base.NumMels = _options.NumMels;
-        var stream = r.BaseStream;
-        if (!stream.CanSeek || stream.Position < stream.Length)
-        {
-            int payloadVersion = r.ReadInt32();
-            if (payloadVersion != NetworkSpecificPayloadVersion)
-            {
-                throw new InvalidOperationException(
-                    $"SenseVoiceLarge was saved with network-payload version {payloadVersion}, but this build " +
-                    $"reads version {NetworkSpecificPayloadVersion}. Load it with a matching version of " +
-                    "AiDotNet, or re-save it from one.");
-            }
 
-            _options.DecoderDim = r.ReadInt32(); _options.NumDecoderLayers = r.ReadInt32(); _options.FeedForwardDim = r.ReadInt32(); _options.UseCifAlignment = r.ReadBoolean(); _options.LearningRate = r.ReadDouble(); _options.WeightDecay = r.ReadDouble();
-        }
-        else
-        {
-            System.Diagnostics.Trace.TraceWarning(
-                "AiDotNet.SenseVoiceLarge: this model was saved before the decoder and optimizer settings were " +
-                "persisted, so they keep their defaults. Re-save the model to carry them forward.");
-        }
- if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions); }
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() { var options = new SenseVoiceLargeOptions(_options); if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp)) return new SenseVoiceLarge<T>(Architecture, mp, options); return new SenseVoiceLarge<T>(Architecture, options); }
+
 
     private (List<int> tokens, double confidence) CTCGreedyDecodeWithConfidence(Tensor<T> logits) { var tokens = new List<int>(); double totalConf = 0; int confCount = 0; int prevToken = -1; int numFrames = logits.Rank >= 2 ? logits.Shape[0] : 1; int vocabSize = logits.Rank >= 2 ? logits.Shape[^1] : logits.Shape[0]; for (int t = 0; t < numFrames && tokens.Count < _options.MaxTextLength; t++) { int maxIdx = 0; double maxVal = double.NegativeInfinity; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); if (val > maxVal) { maxVal = val; maxIdx = v; } } double sumExp = 0; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); sumExp += Math.Exp(val - maxVal); } double frameConf = 1.0 / sumExp; if (maxIdx != prevToken && maxIdx > 0) { tokens.Add(maxIdx); totalConf += frameConf; confCount++; } prevToken = maxIdx; } return (tokens, confCount > 0 ? totalConf / confCount : 0.0); }
     private static string TokensToText(List<int> tokens) { var sb = new System.Text.StringBuilder(); foreach (var t in tokens) { if (t > 0 && t <= char.MaxValue) sb.Append((char)t); else if (t > char.MaxValue && t <= 0x10FFFF) sb.Append(char.ConvertFromUtf32(t)); } return sb.ToString().Trim(); }
diff --git a/src/SpeechRecognition/CTCVariants/Branchformer.cs b/src/SpeechRecognition/CTCVariants/Branchformer.cs
index 4b28482d36..417e49347c 100644
--- a/src/SpeechRecognition/CTCVariants/Branchformer.cs
+++ b/src/SpeechRecognition/CTCVariants/Branchformer.cs
@@ -41,7 +41,7 @@ namespace AiDotNet.SpeechRecognition.CTCVariants;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Branchformer: Parallel MLP-Attention Architectures to Capture Local and Global Context for Speech Recognition and Understanding", "https://arxiv.org/abs/2207.02971", Year = 2022, Authors = "Peng et al.")]
-public class Branchformer<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
+public partial class Branchformer<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
 {
     private readonly CTCBranchformerOptions _options; public override ModelOptions GetOptions() => _options;
     private IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer; private bool _useNativeMode; private bool _disposed;
@@ -120,9 +120,8 @@ public override void Train(Tensor<T> input, Tensor<T> expected)
     protected override bool SupportsParameterMutation => _useNativeMode;
     protected override Tensor<T> PostprocessOutput(Tensor<T> o) => o;
     public override ModelMetadata<T> GetModelMetadata() => new() { Name = _useNativeMode ? "Branchformer-Native" : "Branchformer-ONNX", Description = "Branchformer: parallel attention + convolution (2022)", FeatureCount = _options.NumMels, Complexity = _options.NumEncoderLayers, AdditionalInfo = BaseAudioMetadataInfo() };
-    protected override void SerializeNetworkSpecificData(BinaryWriter w) { w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty); w.Write(_options.SampleRate); w.Write(_options.MaxAudioLengthSeconds); w.Write(_options.EncoderDim); w.Write(_options.NumEncoderLayers); w.Write(_options.NumAttentionHeads); w.Write(_options.NumMels); w.Write(_options.VocabSize); w.Write(_options.MaxTextLength); w.Write(_options.DropoutRate); w.Write(_options.Language); }
-    protected override void DeserializeNetworkSpecificData(BinaryReader r) { _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp; _options.SampleRate = r.ReadInt32(); _options.MaxAudioLengthSeconds = r.ReadInt32(); _options.EncoderDim = r.ReadInt32(); _options.NumEncoderLayers = r.ReadInt32(); _options.NumAttentionHeads = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.VocabSize = r.ReadInt32(); _options.MaxTextLength = r.ReadInt32(); _options.DropoutRate = r.ReadDouble(); _options.Language = r.ReadString(); base.SampleRate = _options.SampleRate; base.NumMels = _options.NumMels; if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions); }
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() { if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp)) return new Branchformer<T>(Architecture, mp, _options); return new Branchformer<T>(Architecture, _options); }
+
+
 
     private (List<int> tokens, double confidence) CTCGreedyDecodeWithConfidence(Tensor<T> logits) { var tokens = new List<int>(); double totalConf = 0; int confCount = 0; int prevToken = -1; int numFrames = logits.Rank >= 2 ? logits.Shape[0] : 1; int vocabSize = logits.Rank >= 2 ? logits.Shape[^1] : logits.Shape[0]; for (int t = 0; t < numFrames && tokens.Count < _options.MaxTextLength; t++) { int maxIdx = 0; double maxVal = double.NegativeInfinity; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); if (val > maxVal) { maxVal = val; maxIdx = v; } } double sumExp = 0; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); sumExp += Math.Exp(val - maxVal); } double frameConf = 1.0 / sumExp; if (maxIdx != prevToken && maxIdx > 0) { tokens.Add(maxIdx); totalConf += frameConf; confCount++; } prevToken = maxIdx; } return (tokens, confCount > 0 ? totalConf / confCount : 0.0); }
     private static string TokensToText(List<int> tokens) { var sb = new System.Text.StringBuilder(); foreach (var t in tokens) { if (t > 0 && t <= char.MaxValue) sb.Append((char)t); else if (t > char.MaxValue && t <= 0x10FFFF) sb.Append(char.ConvertFromUtf32(t)); } return sb.ToString().Trim(); }
diff --git a/src/SpeechRecognition/CTCVariants/CIFDecoder.cs b/src/SpeechRecognition/CTCVariants/CIFDecoder.cs
index 7f9b7df816..ce75e4ff79 100644
--- a/src/SpeechRecognition/CTCVariants/CIFDecoder.cs
+++ b/src/SpeechRecognition/CTCVariants/CIFDecoder.cs
@@ -41,7 +41,7 @@ namespace AiDotNet.SpeechRecognition.CTCVariants;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("CIF: Continuous Integrate-and-Fire for End-to-End Speech Recognition", "https://arxiv.org/abs/1905.11235", Year = 2020, Authors = "Dong and Xu")]
-public class CIFDecoder<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
+public partial class CIFDecoder<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
 {
     private readonly CIFDecoderOptions _options; public override ModelOptions GetOptions() => _options;
     private IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer; private bool _useNativeMode; private bool _disposed;
@@ -102,9 +102,8 @@ public TranscriptionResult<T> Transcribe(Tensor<T> audio, string? language = nul
     protected override bool SupportsParameterMutation => _useNativeMode;
     protected override Tensor<T> PostprocessOutput(Tensor<T> o) => o;
     public override ModelMetadata<T> GetModelMetadata() => new() { Name = _useNativeMode ? "CIFDecoder-Native" : "CIFDecoder-ONNX", Description = "CIF: continuous integrate-and-fire mechanism (2020)", FeatureCount = _options.NumMels, Complexity = _options.NumEncoderLayers, AdditionalInfo = BaseAudioMetadataInfo() };
-    protected override void SerializeNetworkSpecificData(BinaryWriter w) { w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty); w.Write(_options.SampleRate); w.Write(_options.MaxAudioLengthSeconds); w.Write(_options.EncoderDim); w.Write(_options.NumEncoderLayers); w.Write(_options.NumAttentionHeads); w.Write(_options.NumMels); w.Write(_options.VocabSize); w.Write(_options.MaxTextLength); w.Write(_options.DropoutRate); w.Write(_options.Language); }
-    protected override void DeserializeNetworkSpecificData(BinaryReader r) { _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp; _options.SampleRate = r.ReadInt32(); _options.MaxAudioLengthSeconds = r.ReadInt32(); _options.EncoderDim = r.ReadInt32(); _options.NumEncoderLayers = r.ReadInt32(); _options.NumAttentionHeads = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.VocabSize = r.ReadInt32(); _options.MaxTextLength = r.ReadInt32(); _options.DropoutRate = r.ReadDouble(); _options.Language = r.ReadString(); base.SampleRate = _options.SampleRate; base.NumMels = _options.NumMels; if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions); }
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() { if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp)) return new CIFDecoder<T>(Architecture, mp, _options); return new CIFDecoder<T>(Architecture, _options); }
+
+
 
     private (List<int> tokens, double confidence) CTCGreedyDecodeWithConfidence(Tensor<T> logits) { var tokens = new List<int>(); double totalConf = 0; int confCount = 0; int prevToken = -1; int numFrames = logits.Rank >= 2 ? logits.Shape[0] : 1; int vocabSize = logits.Rank >= 2 ? logits.Shape[^1] : logits.Shape[0]; for (int t = 0; t < numFrames && tokens.Count < _options.MaxTextLength; t++) { int maxIdx = 0; double maxVal = double.NegativeInfinity; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); if (val > maxVal) { maxVal = val; maxIdx = v; } } double sumExp = 0; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); sumExp += Math.Exp(val - maxVal); } double frameConf = 1.0 / sumExp; if (maxIdx != prevToken && maxIdx > 0) { tokens.Add(maxIdx); totalConf += frameConf; confCount++; } prevToken = maxIdx; } return (tokens, confCount > 0 ? totalConf / confCount : 0.0); }
     private static string TokensToText(List<int> tokens) { var sb = new System.Text.StringBuilder(); foreach (var t in tokens) { if (t > 0 && t <= char.MaxValue) sb.Append((char)t); else if (t > char.MaxValue && t <= 0x10FFFF) sb.Append(char.ConvertFromUtf32(t)); } return sb.ToString().Trim(); }
diff --git a/src/SpeechRecognition/CTCVariants/CTCSegmentation.cs b/src/SpeechRecognition/CTCVariants/CTCSegmentation.cs
index 6fdacfa7e2..0353141f6b 100644
--- a/src/SpeechRecognition/CTCVariants/CTCSegmentation.cs
+++ b/src/SpeechRecognition/CTCVariants/CTCSegmentation.cs
@@ -133,15 +133,8 @@ public override void Train(Tensor<T> input, Tensor<T> expected)
     protected override bool SupportsParameterMutation => _useNativeMode;
     protected override Tensor<T> PostprocessOutput(Tensor<T> o) => o;
     public override ModelMetadata<T> GetModelMetadata() => new() { Name = _useNativeMode ? "CTCSegmentation-Native" : "CTCSegmentation-ONNX", Description = "CTC Segmentation: forced alignment via CTC (2020)", FeatureCount = _options.NumMels, Complexity = _options.NumEncoderLayers, AdditionalInfo = BaseAudioMetadataInfo() };
-    protected override void SerializeNetworkSpecificData(BinaryWriter w) { w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty); w.Write(_options.SampleRate); w.Write(_options.MaxAudioLengthSeconds); w.Write(_options.EncoderDim); w.Write(_options.NumEncoderLayers); w.Write(_options.NumAttentionHeads); w.Write(_options.NumMels); w.Write(_options.VocabSize); w.Write(_options.MaxTextLength); w.Write(_options.DropoutRate); w.Write(_options.Language); }
-    protected override void DeserializeNetworkSpecificData(BinaryReader r) { _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp; _options.SampleRate = r.ReadInt32(); _options.MaxAudioLengthSeconds = r.ReadInt32(); _options.EncoderDim = r.ReadInt32(); _options.NumEncoderLayers = r.ReadInt32(); _options.NumAttentionHeads = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.VocabSize = r.ReadInt32(); _options.MaxTextLength = r.ReadInt32(); _options.DropoutRate = r.ReadDouble(); _options.Language = r.ReadString(); base.SampleRate = _options.SampleRate; base.NumMels = _options.NumMels; if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions); }
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var options = new CTCSegmentationOptions(_options);
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new CTCSegmentation<T>(Architecture, mp, options);
-        return new CTCSegmentation<T>(Architecture, options);
-    }
+
+
 
     private (List<int> tokens, double confidence) CTCGreedyDecodeWithConfidence(Tensor<T> logits) { var tokens = new List<int>(); double totalConf = 0; int confCount = 0; int prevToken = -1; int numFrames = logits.Rank >= 2 ? logits.Shape[0] : 1; int vocabSize = logits.Rank >= 2 ? logits.Shape[^1] : logits.Shape[0]; for (int t = 0; t < numFrames && tokens.Count < _options.MaxTextLength; t++) { int maxIdx = 0; double maxVal = double.NegativeInfinity; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); if (val > maxVal) { maxVal = val; maxIdx = v; } } double sumExp = 0; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); sumExp += Math.Exp(val - maxVal); } double frameConf = 1.0 / sumExp; if (maxIdx != prevToken && maxIdx > 0) { tokens.Add(maxIdx); totalConf += frameConf; confCount++; } prevToken = maxIdx; } return (tokens, confCount > 0 ? totalConf / confCount : 0.0); }
     private static string TokensToText(List<int> tokens) { var sb = new System.Text.StringBuilder(); foreach (var t in tokens) { if (t > 0 && t <= char.MaxValue) sb.Append((char)t); else if (t > char.MaxValue && t <= 0x10FFFF) sb.Append(char.ConvertFromUtf32(t)); } return sb.ToString().Trim(); }
diff --git a/src/SpeechRecognition/CTCVariants/EBranchformer.cs b/src/SpeechRecognition/CTCVariants/EBranchformer.cs
index 759d1709a6..acf8feb65f 100644
--- a/src/SpeechRecognition/CTCVariants/EBranchformer.cs
+++ b/src/SpeechRecognition/CTCVariants/EBranchformer.cs
@@ -41,7 +41,7 @@ namespace AiDotNet.SpeechRecognition.CTCVariants;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("E-Branchformer: Branchformer with Enhanced Merging for Speech Recognition", "https://arxiv.org/abs/2210.00077", Year = 2022, Authors = "Kim et al.")]
-public class EBranchformer<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
+public partial class EBranchformer<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
 {
     private readonly CTCEBranchformerOptions _options; public override ModelOptions GetOptions() => _options;
     private IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer; private bool _useNativeMode; private bool _disposed;
@@ -127,9 +127,8 @@ public override void Train(Tensor<T> input, Tensor<T> expected)
     protected override bool SupportsParameterMutation => _useNativeMode;
     protected override Tensor<T> PostprocessOutput(Tensor<T> o) => o;
     public override ModelMetadata<T> GetModelMetadata() => new() { Name = _useNativeMode ? "EBranchformer-Native" : "EBranchformer-ONNX", Description = "E-Branchformer: enhanced branch merging (2023)", FeatureCount = _options.NumMels, Complexity = _options.NumEncoderLayers, AdditionalInfo = BaseAudioMetadataInfo() };
-    protected override void SerializeNetworkSpecificData(BinaryWriter w) { w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty); w.Write(_options.SampleRate); w.Write(_options.MaxAudioLengthSeconds); w.Write(_options.EncoderDim); w.Write(_options.NumEncoderLayers); w.Write(_options.NumAttentionHeads); w.Write(_options.NumMels); w.Write(_options.VocabSize); w.Write(_options.MaxTextLength); w.Write(_options.DropoutRate); w.Write(_options.Language); }
-    protected override void DeserializeNetworkSpecificData(BinaryReader r) { _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp; _options.SampleRate = r.ReadInt32(); _options.MaxAudioLengthSeconds = r.ReadInt32(); _options.EncoderDim = r.ReadInt32(); _options.NumEncoderLayers = r.ReadInt32(); _options.NumAttentionHeads = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.VocabSize = r.ReadInt32(); _options.MaxTextLength = r.ReadInt32(); _options.DropoutRate = r.ReadDouble(); _options.Language = r.ReadString(); base.SampleRate = _options.SampleRate; base.NumMels = _options.NumMels; if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions); }
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() { if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp)) return new EBranchformer<T>(Architecture, mp, _options); return new EBranchformer<T>(Architecture, _options); }
+
+
 
     private (List<int> tokens, double confidence) CTCGreedyDecodeWithConfidence(Tensor<T> logits) { var tokens = new List<int>(); double totalConf = 0; int confCount = 0; int prevToken = -1; int numFrames = logits.Rank >= 2 ? logits.Shape[0] : 1; int vocabSize = logits.Rank >= 2 ? logits.Shape[^1] : logits.Shape[0]; for (int t = 0; t < numFrames && tokens.Count < _options.MaxTextLength; t++) { int maxIdx = 0; double maxVal = double.NegativeInfinity; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); if (val > maxVal) { maxVal = val; maxIdx = v; } } double sumExp = 0; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); sumExp += Math.Exp(val - maxVal); } double frameConf = 1.0 / sumExp; if (maxIdx != prevToken && maxIdx > 0) { tokens.Add(maxIdx); totalConf += frameConf; confCount++; } prevToken = maxIdx; } return (tokens, confCount > 0 ? totalConf / confCount : 0.0); }
     /// <summary>
diff --git a/src/SpeechRecognition/CTCVariants/InterCTC.cs b/src/SpeechRecognition/CTCVariants/InterCTC.cs
index fa86bd9239..965d8e24b9 100644
--- a/src/SpeechRecognition/CTCVariants/InterCTC.cs
+++ b/src/SpeechRecognition/CTCVariants/InterCTC.cs
@@ -41,7 +41,7 @@ namespace AiDotNet.SpeechRecognition.CTCVariants;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Intermediate Loss Regularization for CTC-based Speech Recognition", "https://arxiv.org/abs/2102.03216", Year = 2021, Authors = "Lee and Watanabe")]
-public class InterCTC<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
+public partial class InterCTC<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
 {
     private readonly InterCTCOptions _options; public override ModelOptions GetOptions() => _options;
     private IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer; private bool _useNativeMode; private bool _disposed;
@@ -120,9 +120,8 @@ public override void Train(Tensor<T> input, Tensor<T> expected)
     protected override bool SupportsParameterMutation => _useNativeMode;
     protected override Tensor<T> PostprocessOutput(Tensor<T> o) => o;
     public override ModelMetadata<T> GetModelMetadata() => new() { Name = _useNativeMode ? "InterCTC-Native" : "InterCTC-ONNX", Description = "InterCTC: intermediate CTC losses (2021)", FeatureCount = _options.NumMels, Complexity = _options.NumEncoderLayers, AdditionalInfo = BaseAudioMetadataInfo() };
-    protected override void SerializeNetworkSpecificData(BinaryWriter w) { w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty); w.Write(_options.SampleRate); w.Write(_options.MaxAudioLengthSeconds); w.Write(_options.EncoderDim); w.Write(_options.NumEncoderLayers); w.Write(_options.NumAttentionHeads); w.Write(_options.NumMels); w.Write(_options.VocabSize); w.Write(_options.MaxTextLength); w.Write(_options.DropoutRate); w.Write(_options.Language); }
-    protected override void DeserializeNetworkSpecificData(BinaryReader r) { _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp; _options.SampleRate = r.ReadInt32(); _options.MaxAudioLengthSeconds = r.ReadInt32(); _options.EncoderDim = r.ReadInt32(); _options.NumEncoderLayers = r.ReadInt32(); _options.NumAttentionHeads = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.VocabSize = r.ReadInt32(); _options.MaxTextLength = r.ReadInt32(); _options.DropoutRate = r.ReadDouble(); _options.Language = r.ReadString(); base.SampleRate = _options.SampleRate; base.NumMels = _options.NumMels; if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions); }
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() { if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp)) return new InterCTC<T>(Architecture, mp, _options); return new InterCTC<T>(Architecture, _options); }
+
+
 
     private (List<int> tokens, double confidence) CTCGreedyDecodeWithConfidence(Tensor<T> logits) { var tokens = new List<int>(); double totalConf = 0; int confCount = 0; int prevToken = -1; int numFrames = logits.Rank >= 2 ? logits.Shape[0] : 1; int vocabSize = logits.Rank >= 2 ? logits.Shape[^1] : logits.Shape[0]; for (int t = 0; t < numFrames && tokens.Count < _options.MaxTextLength; t++) { int maxIdx = 0; double maxVal = double.NegativeInfinity; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); if (val > maxVal) { maxVal = val; maxIdx = v; } } double sumExp = 0; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); sumExp += Math.Exp(val - maxVal); } double frameConf = 1.0 / sumExp; if (maxIdx != prevToken && maxIdx > 0) { tokens.Add(maxIdx); totalConf += frameConf; confCount++; } prevToken = maxIdx; } return (tokens, confCount > 0 ? totalConf / confCount : 0.0); }
     private static string TokensToText(List<int> tokens) { var sb = new System.Text.StringBuilder(); foreach (var t in tokens) { if (t > 0 && t <= char.MaxValue) sb.Append((char)t); else if (t > char.MaxValue && t <= 0x10FFFF) sb.Append(char.ConvertFromUtf32(t)); } return sb.ToString().Trim(); }
diff --git a/src/SpeechRecognition/CTCVariants/SelfConditionedCTC.cs b/src/SpeechRecognition/CTCVariants/SelfConditionedCTC.cs
index e2b91d9a55..885b6425d2 100644
--- a/src/SpeechRecognition/CTCVariants/SelfConditionedCTC.cs
+++ b/src/SpeechRecognition/CTCVariants/SelfConditionedCTC.cs
@@ -41,7 +41,7 @@ namespace AiDotNet.SpeechRecognition.CTCVariants;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Relaxing the Conditional Independence Assumption of CTC-based ASR by Conditioning on Intermediate Predictions", "https://arxiv.org/abs/2104.02724", Year = 2021, Authors = "Nozaki and Komatsu")]
-public class SelfConditionedCTC<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
+public partial class SelfConditionedCTC<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
 {
     private readonly SelfConditionedCTCOptions _options; public override ModelOptions GetOptions() => _options;
     private IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer; private bool _useNativeMode; private bool _disposed;
@@ -120,9 +120,8 @@ public override void Train(Tensor<T> input, Tensor<T> expected)
     protected override bool SupportsParameterMutation => _useNativeMode;
     protected override Tensor<T> PostprocessOutput(Tensor<T> o) => o;
     public override ModelMetadata<T> GetModelMetadata() => new() { Name = _useNativeMode ? "SelfConditionedCTC-Native" : "SelfConditionedCTC-ONNX", Description = "Self-Conditioned CTC: iterative CTC refinement (2021)", FeatureCount = _options.NumMels, Complexity = _options.NumEncoderLayers, AdditionalInfo = BaseAudioMetadataInfo() };
-    protected override void SerializeNetworkSpecificData(BinaryWriter w) { w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty); w.Write(_options.SampleRate); w.Write(_options.MaxAudioLengthSeconds); w.Write(_options.EncoderDim); w.Write(_options.NumEncoderLayers); w.Write(_options.NumAttentionHeads); w.Write(_options.NumMels); w.Write(_options.VocabSize); w.Write(_options.MaxTextLength); w.Write(_options.DropoutRate); w.Write(_options.Language); }
-    protected override void DeserializeNetworkSpecificData(BinaryReader r) { _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp; _options.SampleRate = r.ReadInt32(); _options.MaxAudioLengthSeconds = r.ReadInt32(); _options.EncoderDim = r.ReadInt32(); _options.NumEncoderLayers = r.ReadInt32(); _options.NumAttentionHeads = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.VocabSize = r.ReadInt32(); _options.MaxTextLength = r.ReadInt32(); _options.DropoutRate = r.ReadDouble(); _options.Language = r.ReadString(); base.SampleRate = _options.SampleRate; base.NumMels = _options.NumMels; if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions); }
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() { if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp)) return new SelfConditionedCTC<T>(Architecture, mp, _options); return new SelfConditionedCTC<T>(Architecture, _options); }
+
+
 
     private (List<int> tokens, double confidence) CTCGreedyDecodeWithConfidence(Tensor<T> logits) { var tokens = new List<int>(); double totalConf = 0; int confCount = 0; int prevToken = -1; int numFrames = logits.Rank >= 2 ? logits.Shape[0] : 1; int vocabSize = logits.Rank >= 2 ? logits.Shape[^1] : logits.Shape[0]; for (int t = 0; t < numFrames && tokens.Count < _options.MaxTextLength; t++) { int maxIdx = 0; double maxVal = double.NegativeInfinity; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); if (val > maxVal) { maxVal = val; maxIdx = v; } } double sumExp = 0; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); sumExp += Math.Exp(val - maxVal); } double frameConf = 1.0 / sumExp; if (maxIdx != prevToken && maxIdx > 0) { tokens.Add(maxIdx); totalConf += frameConf; confCount++; } prevToken = maxIdx; } return (tokens, confCount > 0 ? totalConf / confCount : 0.0); }
     private static string TokensToText(List<int> tokens) { var sb = new System.Text.StringBuilder(); foreach (var t in tokens) { if (t > 0 && t <= char.MaxValue) sb.Append((char)t); else if (t > char.MaxValue && t <= 0x10FFFF) sb.Append(char.ConvertFromUtf32(t)); } return sb.ToString().Trim(); }
diff --git a/src/SpeechRecognition/ConformerFamily/Branchformer.cs b/src/SpeechRecognition/ConformerFamily/Branchformer.cs
index 6c7560bd07..15d7064e42 100644
--- a/src/SpeechRecognition/ConformerFamily/Branchformer.cs
+++ b/src/SpeechRecognition/ConformerFamily/Branchformer.cs
@@ -45,7 +45,7 @@ namespace AiDotNet.SpeechRecognition.ConformerFamily;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Branchformer: Parallel MLP-Attention Architectures to Capture Local and Global Context for Speech Recognition and Understanding", "https://arxiv.org/abs/2207.02971", Year = 2022, Authors = "Peng et al.")]
-public class Branchformer<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
+public partial class Branchformer<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
 {
     /// <inheritdoc />
     /// <remarks>
@@ -185,33 +185,9 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty);
-        w.Write(_options.SampleRate); w.Write(_options.MaxAudioLengthSeconds); w.Write(_options.EncoderDim);
-        w.Write(_options.NumEncoderLayers); w.Write(_options.NumAttentionHeads);
-        w.Write(_options.CgmlpDim); w.Write(_options.NumMels);
-        w.Write(_options.VocabSize); w.Write(_options.DropoutRate);
-        w.Write(_options.Language);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.SampleRate = r.ReadInt32(); _options.MaxAudioLengthSeconds = r.ReadInt32(); _options.EncoderDim = r.ReadInt32();
-        _options.NumEncoderLayers = r.ReadInt32(); _options.NumAttentionHeads = r.ReadInt32();
-        _options.CgmlpDim = r.ReadInt32(); _options.NumMels = r.ReadInt32();
-        _options.VocabSize = r.ReadInt32(); _options.DropoutRate = r.ReadDouble();
-        _options.Language = r.ReadString();
-        base.SampleRate = _options.SampleRate; base.NumMels = _options.NumMels;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp)) return new Branchformer<T>(Architecture, mp, _options);
-        return new Branchformer<T>(Architecture, _options);
-    }
+
 
     private (List<int> tokens, double confidence) CTCGreedyDecodeWithConfidence(Tensor<T> logits) { var tokens = new List<int>(); double totalConf = 0; int confCount = 0; int prevToken = -1; int numFrames = logits.Rank >= 2 ? logits.Shape[0] : 1; int vocabSize = logits.Rank >= 2 ? logits.Shape[^1] : logits.Shape[0]; for (int t = 0; t < numFrames; t++) { int maxIdx = 0; double maxVal = double.NegativeInfinity; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); if (val > maxVal) { maxVal = val; maxIdx = v; } } double sumExp = 0; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); sumExp += Math.Exp(val - maxVal); } double frameConf = 1.0 / sumExp; if (maxIdx != 0 && maxIdx != prevToken) { tokens.Add(maxIdx); totalConf += frameConf; confCount++; } prevToken = maxIdx; } return (tokens, confCount > 0 ? totalConf / confCount : 0.0); }
     private static string TokensToText(List<int> tokens) { var sb = new System.Text.StringBuilder(); foreach (var t in tokens) { if (t > 0 && t <= char.MaxValue) sb.Append((char)t); else if (t > char.MaxValue && t <= 0x10FFFF) sb.Append(char.ConvertFromUtf32(t)); } return sb.ToString().Trim(); }
diff --git a/src/SpeechRecognition/ConformerFamily/CIFEncoder.cs b/src/SpeechRecognition/ConformerFamily/CIFEncoder.cs
index a2e24ecf86..ffa1564756 100644
--- a/src/SpeechRecognition/ConformerFamily/CIFEncoder.cs
+++ b/src/SpeechRecognition/ConformerFamily/CIFEncoder.cs
@@ -44,7 +44,7 @@ namespace AiDotNet.SpeechRecognition.ConformerFamily;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("CIF: Continuous Integrate-and-Fire for End-to-End Speech Recognition", "https://arxiv.org/abs/1905.11235", Year = 2020, Authors = "Dong and Xu")]
-public class CIFEncoder<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
+public partial class CIFEncoder<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
 {
     private readonly CIFEncoderOptions _options; public override ModelOptions GetOptions() => _options;
     private IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer; private bool _useNativeMode; private bool _disposed;
@@ -170,65 +170,9 @@ public override void Train(Tensor<T> input, Tensor<T> expected)
     protected override bool SupportsParameterMutation => _useNativeMode;
     protected override Tensor<T> PostprocessOutput(Tensor<T> o) => o;
     public override ModelMetadata<T> GetModelMetadata() => new() { Name = _useNativeMode ? "CIFEncoder-Native" : "CIFEncoder-ONNX", Description = "CIF: Continuous Integrate-and-Fire (Dong & Xu, 2020)", FeatureCount = _options.NumMels, Complexity = _options.NumEncoderLayers, AdditionalInfo = BaseAudioMetadataInfo() };
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode);
-        w.Write(_options.ModelPath ?? string.Empty);
-        w.Write(_options.SampleRate);
-        w.Write(_options.MaxAudioLengthSeconds);
-        w.Write(_options.EncoderDim);
-        w.Write(_options.NumEncoderLayers);
-        w.Write(_options.NumAttentionHeads);
-        w.Write(_options.FeedForwardDim);
-        w.Write(_options.CifThreshold);
-        w.Write(_options.NumMels);
-        w.Write(_options.VocabSize);
-        w.Write(_options.DropoutRate);
-        w.Write(_options.Language);
-    }
-
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean();
-
-        string mp = r.ReadString();
-        if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-
-        _options.SampleRate = r.ReadInt32();
-        _options.MaxAudioLengthSeconds = r.ReadInt32();
-        _options.EncoderDim = r.ReadInt32();
-        _options.NumEncoderLayers = r.ReadInt32();
-        _options.NumAttentionHeads = r.ReadInt32();
-        _options.FeedForwardDim = r.ReadInt32();
-        _options.CifThreshold = r.ReadDouble();
-        _options.NumMels = r.ReadInt32();
-        _options.VocabSize = r.ReadInt32();
-        _options.DropoutRate = r.ReadDouble();
-        _options.Language = r.ReadString();
-
-        base.SampleRate = _options.SampleRate;
-        base.NumMels = _options.NumMels;
 
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-        {
-            OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions);
-        }
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        // A COPY, NOT THE SAME OBJECT. Passing _options by reference gave the clone and the original one
-        // options instance, so either one could rewrite the other's configuration. The ONNX branch makes
-        // that concrete: the constructor assigns _options.ModelPath = mp, mutating the ORIGINAL model's
-        // options as a side effect of cloning it. DeserializeNetworkSpecificData is worse -- it rewrites
-        // every field for both instances at once.
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-        {
-            return new CIFEncoder<T>(Architecture, mp, new CIFEncoderOptions(_options));
-        }
 
-        return new CIFEncoder<T>(Architecture, new CIFEncoderOptions(_options));
-    }
     private (List<int> tokens, double confidence) CTCGreedyDecodeWithConfidence(Tensor<T> logits) { var tokens = new List<int>(); double totalConf = 0; int confCount = 0; int prevToken = -1; int numFrames = logits.Rank >= 2 ? logits.Shape[0] : 1; int vocabSize = logits.Rank >= 2 ? logits.Shape[^1] : logits.Shape[0]; for (int t = 0; t < numFrames; t++) { int maxIdx = 0; double maxVal = double.NegativeInfinity; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); if (val > maxVal) { maxVal = val; maxIdx = v; } } double sumExp = 0; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); sumExp += Math.Exp(val - maxVal); } double frameConf = 1.0 / sumExp; if (maxIdx != prevToken && maxIdx > 0) { tokens.Add(maxIdx); totalConf += frameConf; confCount++; } prevToken = maxIdx; } return (tokens, confCount > 0 ? totalConf / confCount : 0.0); }
     private static string TokensToText(List<int> tokens) { var sb = new System.Text.StringBuilder(); foreach (var t in tokens) { if (t > 0 && t <= char.MaxValue) sb.Append((char)t); else if (t > char.MaxValue && t <= 0x10FFFF) sb.Append(char.ConvertFromUtf32(t)); } return sb.ToString().Trim(); }
     private IReadOnlyList<TranscriptionSegment<T>> ExtractSegments(string text, double duration, double confidence) { if (string.IsNullOrWhiteSpace(text)) return Array.Empty<TranscriptionSegment<T>>(); return new[] { new TranscriptionSegment<T> { Text = text, StartTime = 0.0, EndTime = duration, Confidence = NumOps.FromDouble(confidence) } }; }
diff --git a/src/SpeechRecognition/ConformerFamily/ConformerCTC.cs b/src/SpeechRecognition/ConformerFamily/ConformerCTC.cs
index d09d5cc22f..3ca15761ad 100644
--- a/src/SpeechRecognition/ConformerFamily/ConformerCTC.cs
+++ b/src/SpeechRecognition/ConformerFamily/ConformerCTC.cs
@@ -43,7 +43,7 @@ namespace AiDotNet.SpeechRecognition.ConformerFamily;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Conformer: Convolution-augmented Transformer for Speech Recognition", "https://arxiv.org/abs/2005.08100", Year = 2020, Authors = "Gulati et al.")]
-public class ConformerCTC<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
+public partial class ConformerCTC<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
 {
     private readonly ConformerCTCOptions _options; public override ModelOptions GetOptions() => _options;
     private IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer; private bool _useNativeMode; private bool _disposed;
@@ -138,15 +138,8 @@ public override void Train(Tensor<T> input, Tensor<T> expected)
             ["Language"] = _options.Language
         }
     };
-    protected override void SerializeNetworkSpecificData(BinaryWriter w) { w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty); w.Write(_options.SampleRate); w.Write(_options.MaxAudioLengthSeconds); w.Write(_options.EncoderDim); w.Write(_options.NumEncoderLayers); w.Write(_options.NumAttentionHeads); w.Write(_options.FeedForwardExpansionFactor); w.Write(_options.NumMels); w.Write(_options.VocabSize); w.Write(_options.DropoutRate); w.Write(_options.Language); }
-    protected override void DeserializeNetworkSpecificData(BinaryReader r) { _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp; _options.SampleRate = r.ReadInt32(); _options.MaxAudioLengthSeconds = r.ReadInt32(); _options.EncoderDim = r.ReadInt32(); _options.NumEncoderLayers = r.ReadInt32(); _options.NumAttentionHeads = r.ReadInt32(); _options.FeedForwardExpansionFactor = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.VocabSize = r.ReadInt32(); _options.DropoutRate = r.ReadDouble(); _options.Language = r.ReadString(); base.SampleRate = _options.SampleRate; base.NumMels = _options.NumMels; if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions); }
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var cloneOptions = new ConformerCTCOptions(_options);
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new ConformerCTC<T>(Architecture, mp, cloneOptions);
-        return new ConformerCTC<T>(Architecture, cloneOptions);
-    }
+
+
     private (List<int> tokens, double confidence) CTCGreedyDecodeWithConfidence(Tensor<T> logits) { var tokens = new List<int>(); double totalConf = 0; int confCount = 0; int prevToken = -1; int numFrames = logits.Rank >= 2 ? logits.Shape[0] : 1; int vocabSize = logits.Rank >= 2 ? logits.Shape[^1] : logits.Shape[0]; for (int t = 0; t < numFrames; t++) { int maxIdx = 0; double maxVal = double.NegativeInfinity; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); if (val > maxVal) { maxVal = val; maxIdx = v; } } double sumExp = 0; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); sumExp += Math.Exp(val - maxVal); } double frameConf = 1.0 / sumExp; if (maxIdx != prevToken && maxIdx > 0) { tokens.Add(maxIdx); totalConf += frameConf; confCount++; } prevToken = maxIdx; } return (tokens, confCount > 0 ? totalConf / confCount : 0.0); }
     /// <summary>
     /// Maps token IDs to text. Without a loaded vocabulary, uses Unicode codepoint mapping
diff --git a/src/SpeechRecognition/ConformerFamily/ConformerTransducer.cs b/src/SpeechRecognition/ConformerFamily/ConformerTransducer.cs
index 70bd1a624d..9286d4cece 100644
--- a/src/SpeechRecognition/ConformerFamily/ConformerTransducer.cs
+++ b/src/SpeechRecognition/ConformerFamily/ConformerTransducer.cs
@@ -44,7 +44,7 @@ namespace AiDotNet.SpeechRecognition.ConformerFamily;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Conformer: Convolution-augmented Transformer for Speech Recognition", "https://arxiv.org/abs/2005.08100", Year = 2020, Authors = "Gulati et al.")]
-public class ConformerTransducer<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
+public partial class ConformerTransducer<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
 {
     private readonly ConformerTransducerOptions _options; public override ModelOptions GetOptions() => _options;
     private IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer; private bool _useNativeMode; private bool _disposed;
@@ -125,9 +125,8 @@ public override void Train(Tensor<T> input, Tensor<T> expected)
     protected override bool SupportsParameterMutation => _useNativeMode;
     protected override Tensor<T> PostprocessOutput(Tensor<T> o) => o;
     public override ModelMetadata<T> GetModelMetadata() => new() { Name = _useNativeMode ? "ConformerTransducer-Native" : "ConformerTransducer-ONNX", Description = "Conformer-Transducer: Streaming ASR (Gulati+Graves)", FeatureCount = _options.NumMels, Complexity = _options.NumEncoderLayers, AdditionalInfo = BaseAudioMetadataInfo() };
-    protected override void SerializeNetworkSpecificData(BinaryWriter w) { w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty); w.Write(_options.SampleRate); w.Write(_options.MaxAudioLengthSeconds); w.Write(_options.EncoderDim); w.Write(_options.NumEncoderLayers); w.Write(_options.NumAttentionHeads); w.Write(_options.FeedForwardExpansionFactor); w.Write(_options.PredictionDim); w.Write(_options.JointDim); w.Write(_options.NumMels); w.Write(_options.VocabSize); w.Write(_options.DropoutRate); w.Write(_options.Language); }
-    protected override void DeserializeNetworkSpecificData(BinaryReader r) { _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp; _options.SampleRate = r.ReadInt32(); _options.MaxAudioLengthSeconds = r.ReadInt32(); _options.EncoderDim = r.ReadInt32(); _options.NumEncoderLayers = r.ReadInt32(); _options.NumAttentionHeads = r.ReadInt32(); _options.FeedForwardExpansionFactor = r.ReadInt32(); _options.PredictionDim = r.ReadInt32(); _options.JointDim = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.VocabSize = r.ReadInt32(); _options.DropoutRate = r.ReadDouble(); _options.Language = r.ReadString(); base.SampleRate = _options.SampleRate; base.NumMels = _options.NumMels; SupportedLanguages = new[] { _options.Language }; if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions); }
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() { if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp)) return new ConformerTransducer<T>(Architecture, mp, _options); return new ConformerTransducer<T>(Architecture, _options); }
+
+
     /// <summary>
     /// Greedy decoding on output logits. For ONNX models the prediction+joint networks are
     /// internal to the ONNX graph, so the output is already joint logits. For native mode,
diff --git a/src/SpeechRecognition/ConformerFamily/ContextNet.cs b/src/SpeechRecognition/ConformerFamily/ContextNet.cs
index 02d444e82d..82ae97030d 100644
--- a/src/SpeechRecognition/ConformerFamily/ContextNet.cs
+++ b/src/SpeechRecognition/ConformerFamily/ContextNet.cs
@@ -44,7 +44,7 @@ namespace AiDotNet.SpeechRecognition.ConformerFamily;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("ContextNet: Improving Convolutional Neural Networks for Automatic Speech Recognition with Global Context", "https://arxiv.org/abs/2005.03191", Year = 2020, Authors = "Han et al.")]
-public class ContextNet<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
+public partial class ContextNet<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
 {
     private readonly ContextNetOptions _options;
     private IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer;
@@ -221,85 +221,10 @@ public override void Train(Tensor<T> input, Tensor<T> expected)
     /// model that loads successfully with silently wrong architecture options.
     /// </para>
     /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(SerializationVersionMarker);
-        w.Write(SerializationVersion);
 
-        w.Write(_useNativeMode);
-        w.Write(_options.ModelPath ?? string.Empty);
-        w.Write(_options.SampleRate);
-        w.Write(_options.MaxAudioLengthSeconds);
-        w.Write(_options.EncoderDim);
-        w.Write(_options.NumBlocks);
-        w.Write(_options.NumSubBlocks);
-        w.Write(_options.KernelSize);
-        w.Write(_options.WidthScaling);
-        w.Write(_options.SqueezeExcitationRatio);
-        w.Write(_options.NumMels);
-        w.Write(_options.VocabSize);
-        w.Write(_options.DropoutRate);
-        w.Write(_options.Language);
-    }
 
     /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        // The first byte decides the layout. 0xFF means a versioned payload; 0x00 or 0x01 is the v1
-        // bool that used to lead, and is consumed as that bool rather than re-read.
-        byte lead = r.ReadByte();
-        int version;
-        if (lead == SerializationVersionMarker)
-        {
-            version = r.ReadInt32();
-            if (version > SerializationVersion)
-            {
-                throw new InvalidOperationException(
-                    $"This ContextNet payload was written by a newer AiDotNet (serialization version " +
-                    $"{version}); this build reads up to version {SerializationVersion}. Upgrade AiDotNet " +
-                    $"to load it. Refusing rather than reading it as version {SerializationVersion}, which " +
-                    $"would load a model configured with whatever the extra bytes happened to decode to.");
-            }
-            _useNativeMode = r.ReadBoolean();
-        }
-        else
-        {
-            version = 1;
-            _useNativeMode = lead != 0;
-        }
-
-        string mp = r.ReadString();
-        if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
 
-        _options.SampleRate = r.ReadInt32();
-        _options.MaxAudioLengthSeconds = r.ReadInt32();
-        _options.EncoderDim = r.ReadInt32();
-        _options.NumBlocks = r.ReadInt32();
-
-        // Absent from v1. Left at their defaults there, which is the closest thing to the truth
-        // available: the payload was written by a build for which these were not configurable.
-        if (version >= 2)
-        {
-            _options.NumSubBlocks = r.ReadInt32();
-            _options.KernelSize = r.ReadInt32();
-            _options.WidthScaling = r.ReadDouble();
-        }
-
-        _options.SqueezeExcitationRatio = r.ReadInt32();
-        _options.NumMels = r.ReadInt32();
-        _options.VocabSize = r.ReadInt32();
-        _options.DropoutRate = r.ReadDouble();
-        _options.Language = r.ReadString();
-
-        base.SampleRate = _options.SampleRate;
-        base.NumMels = _options.NumMels;
-
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-        {
-            OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions);
-        }
-    }
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() { if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp)) return new ContextNet<T>(Architecture, mp, _options); return new ContextNet<T>(Architecture, _options); }
     private (List<int> tokens, double confidence) CTCGreedyDecodeWithConfidence(Tensor<T> logits) { var tokens = new List<int>(); double totalConf = 0; int confCount = 0; int prevToken = -1; int numFrames = logits.Rank >= 2 ? logits.Shape[0] : 1; int vocabSize = logits.Rank >= 2 ? logits.Shape[^1] : logits.Shape[0]; for (int t = 0; t < numFrames; t++) { int maxIdx = 0; double maxVal = double.NegativeInfinity; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); if (val > maxVal) { maxVal = val; maxIdx = v; } } double sumExp = 0; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); sumExp += Math.Exp(val - maxVal); } double frameConf = 1.0 / sumExp; if (maxIdx != prevToken && maxIdx > 0) { tokens.Add(maxIdx); totalConf += frameConf; confCount++; } prevToken = maxIdx; } return (tokens, confCount > 0 ? totalConf / confCount : 0.0); }
     /// <summary>
     /// Maps token IDs to text. Without a loaded vocabulary, uses Unicode codepoint mapping
diff --git a/src/SpeechRecognition/ConformerFamily/ConvTransformer.cs b/src/SpeechRecognition/ConformerFamily/ConvTransformer.cs
index 82b37bc406..7d1cdecb1a 100644
--- a/src/SpeechRecognition/ConformerFamily/ConvTransformer.cs
+++ b/src/SpeechRecognition/ConformerFamily/ConvTransformer.cs
@@ -140,15 +140,8 @@ protected override void EnsureParametersReady()
     // UpdateParameters folded one enumeration the base already folds. Removed under AIDN082.
     protected override Tensor<T> PostprocessOutput(Tensor<T> o) => o;
     public override ModelMetadata<T> GetModelMetadata() => new() { Name = _useNativeMode ? "ConvTransformer-Native" : "ConvTransformer-ONNX", Description = "Convolution-Augmented Transformer for ASR (2019)", FeatureCount = _options.NumMels, Complexity = _options.NumEncoderLayers, AdditionalInfo = BaseAudioMetadataInfo() };
-    protected override void SerializeNetworkSpecificData(BinaryWriter w) { w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty); w.Write(_options.SampleRate); w.Write(_options.MaxAudioLengthSeconds); w.Write(_options.EncoderDim); w.Write(_options.NumEncoderLayers); w.Write(_options.NumAttentionHeads); w.Write(_options.FeedForwardDim); w.Write(_options.NumMels); w.Write(_options.VocabSize); w.Write(_options.DropoutRate); w.Write(_options.Language); }
-    protected override void DeserializeNetworkSpecificData(BinaryReader r) { _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp; _options.SampleRate = r.ReadInt32(); _options.MaxAudioLengthSeconds = r.ReadInt32(); _options.EncoderDim = r.ReadInt32(); _options.NumEncoderLayers = r.ReadInt32(); _options.NumAttentionHeads = r.ReadInt32(); _options.FeedForwardDim = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.VocabSize = r.ReadInt32(); _options.DropoutRate = r.ReadDouble(); _options.Language = r.ReadString(); base.SampleRate = _options.SampleRate; base.NumMels = _options.NumMels; if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions); }
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var options = new ConvTransformerOptions(_options);
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new ConvTransformer<T>(Architecture, mp, options);
-        return new ConvTransformer<T>(Architecture, options);
-    }
+
+
     private (List<int> tokens, double confidence) CTCGreedyDecodeWithConfidence(Tensor<T> logits) { var tokens = new List<int>(); double totalConf = 0; int confCount = 0; int prevToken = -1; int numFrames = logits.Rank >= 2 ? logits.Shape[0] : 1; int vocabSize = logits.Rank >= 2 ? logits.Shape[^1] : logits.Shape[0]; for (int t = 0; t < numFrames; t++) { int maxIdx = 0; double maxVal = double.NegativeInfinity; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); if (val > maxVal) { maxVal = val; maxIdx = v; } } double sumExp = 0; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); sumExp += Math.Exp(val - maxVal); } double frameConf = 1.0 / sumExp; if (maxIdx != prevToken && maxIdx > 0) { tokens.Add(maxIdx); totalConf += frameConf; confCount++; } prevToken = maxIdx; } return (tokens, confCount > 0 ? totalConf / confCount : 0.0); }
     private static string TokensToText(List<int> tokens) { var sb = new System.Text.StringBuilder(); foreach (var t in tokens) { if (t > 0 && t <= char.MaxValue) sb.Append((char)t); else if (t > char.MaxValue && t <= 0x10FFFF) sb.Append(char.ConvertFromUtf32(t)); } return sb.ToString().Trim(); }
     private IReadOnlyList<TranscriptionSegment<T>> ExtractSegments(string text, double duration, double confidence) { if (string.IsNullOrWhiteSpace(text)) return Array.Empty<TranscriptionSegment<T>>(); return new[] { new TranscriptionSegment<T> { Text = text, StartTime = 0.0, EndTime = duration, Confidence = NumOps.FromDouble(confidence) } }; }
diff --git a/src/SpeechRecognition/ConformerFamily/EBranchformer.cs b/src/SpeechRecognition/ConformerFamily/EBranchformer.cs
index 03cbb469d3..a37db08e90 100644
--- a/src/SpeechRecognition/ConformerFamily/EBranchformer.cs
+++ b/src/SpeechRecognition/ConformerFamily/EBranchformer.cs
@@ -44,7 +44,7 @@ namespace AiDotNet.SpeechRecognition.ConformerFamily;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("E-Branchformer: Branchformer with Enhanced Merging for Speech Recognition", "https://arxiv.org/abs/2210.00077", Year = 2022, Authors = "Kim et al.")]
-public class EBranchformer<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
+public partial class EBranchformer<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
 {
     private readonly EBranchformerOptions _options;
     public override ModelOptions GetOptions() => _options;
@@ -161,29 +161,9 @@ public override void Train(Tensor<T> input, Tensor<T> expected)
     protected override Tensor<T> PostprocessOutput(Tensor<T> o) => o;
     public override ModelMetadata<T> GetModelMetadata() => new() { Name = _useNativeMode ? "EBranchformer-Native" : "EBranchformer-ONNX", Description = "E-Branchformer: Enhanced Merging (Kim et al., 2022)", FeatureCount = _options.NumMels, Complexity = _options.NumEncoderLayers, AdditionalInfo = BaseAudioMetadataInfo() };
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty);
-        w.Write(_options.SampleRate); w.Write(_options.MaxAudioLengthSeconds); w.Write(_options.EncoderDim);
-        w.Write(_options.NumEncoderLayers); w.Write(_options.NumAttentionHeads);
-        w.Write(_options.CgmlpDim); w.Write(_options.MergeDim);
-        w.Write(_options.NumMels); w.Write(_options.VocabSize);
-        w.Write(_options.DropoutRate); w.Write(_options.Language);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.SampleRate = r.ReadInt32(); _options.MaxAudioLengthSeconds = r.ReadInt32(); _options.EncoderDim = r.ReadInt32();
-        _options.NumEncoderLayers = r.ReadInt32(); _options.NumAttentionHeads = r.ReadInt32();
-        _options.CgmlpDim = r.ReadInt32(); _options.MergeDim = r.ReadInt32();
-        _options.NumMels = r.ReadInt32(); _options.VocabSize = r.ReadInt32();
-        _options.DropoutRate = r.ReadDouble(); _options.Language = r.ReadString();
-        base.SampleRate = _options.SampleRate; base.NumMels = _options.NumMels;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() { if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp)) return new EBranchformer<T>(Architecture, mp, _options); return new EBranchformer<T>(Architecture, _options); }
+
 
     private (List<int> tokens, double confidence) CTCGreedyDecodeWithConfidence(Tensor<T> logits) { var tokens = new List<int>(); double totalConf = 0; int confCount = 0; int prevToken = -1; int numFrames = logits.Rank >= 2 ? logits.Shape[0] : 1; int vocabSize = logits.Rank >= 2 ? logits.Shape[^1] : logits.Shape[0]; for (int t = 0; t < numFrames; t++) { int maxIdx = 0; double maxVal = double.NegativeInfinity; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); if (val > maxVal) { maxVal = val; maxIdx = v; } } double sumExp = 0; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); sumExp += Math.Exp(val - maxVal); } double frameConf = 1.0 / sumExp; if (maxIdx != prevToken && maxIdx > 0) { tokens.Add(maxIdx); totalConf += frameConf; confCount++; } prevToken = maxIdx; } return (tokens, confCount > 0 ? totalConf / confCount : 0.0); }
     private static string TokensToText(List<int> tokens) { var sb = new System.Text.StringBuilder(); foreach (var t in tokens) { if (t > 0 && t <= char.MaxValue) sb.Append((char)t); else if (t > char.MaxValue && t <= 0x10FFFF) sb.Append(char.ConvertFromUtf32(t)); } return sb.ToString().Trim(); }
diff --git a/src/SpeechRecognition/ConformerFamily/EfficientConformer.cs b/src/SpeechRecognition/ConformerFamily/EfficientConformer.cs
index b96d9f84b8..8fc6957be4 100644
--- a/src/SpeechRecognition/ConformerFamily/EfficientConformer.cs
+++ b/src/SpeechRecognition/ConformerFamily/EfficientConformer.cs
@@ -44,7 +44,7 @@ namespace AiDotNet.SpeechRecognition.ConformerFamily;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Efficient Conformer: Progressive Downsampling and Grouped Attention for Automatic Speech Recognition", "https://arxiv.org/abs/2109.01163", Year = 2021, Authors = "Burchi and Vielzeuf")]
-public class EfficientConformer<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
+public partial class EfficientConformer<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
 {
     private readonly EfficientConformerOptions _options; public override ModelOptions GetOptions() => _options;
     private IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer; private bool _useNativeMode; private bool _disposed;
@@ -116,20 +116,8 @@ public IReadOnlyDictionary<string, T> DetectLanguageProbabilities(Tensor<T> audi
             ["Language"] = _options.Language
         }
     };
-    protected override void SerializeNetworkSpecificData(BinaryWriter w) { w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty); w.Write(_options.SampleRate); w.Write(_options.MaxAudioLengthSeconds); w.Write(_options.EncoderDim); w.Write(_options.NumEncoderLayers); w.Write(_options.NumAttentionHeads); w.Write(_options.FeedForwardExpansionFactor); w.Write(_options.DownsamplingFactor); w.Write(_options.NumMels); w.Write(_options.VocabSize); w.Write(_options.DropoutRate); w.Write(_options.Language); w.Write(_options.UseLayerNormalization); }
-    protected override void DeserializeNetworkSpecificData(BinaryReader r) { _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp; _options.SampleRate = r.ReadInt32(); _options.MaxAudioLengthSeconds = r.ReadInt32(); _options.EncoderDim = r.ReadInt32(); _options.NumEncoderLayers = r.ReadInt32(); _options.NumAttentionHeads = r.ReadInt32(); _options.FeedForwardExpansionFactor = r.ReadInt32(); _options.DownsamplingFactor = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.VocabSize = r.ReadInt32(); _options.DropoutRate = r.ReadDouble(); _options.Language = r.ReadString(); if (r.BaseStream.Position < r.BaseStream.Length) _options.UseLayerNormalization = r.ReadBoolean(); base.SampleRate = _options.SampleRate; base.NumMels = _options.NumMels; if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions); }
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new EfficientConformer<T>(Architecture, mp, new EfficientConformerOptions(_options));
 
-        var cloneOptimizer = _optimizer?.GetOptions() is AdamWOptimizerOptions<T, Tensor<T>, Tensor<T>> optimizerOptions
-            ? new AdamWOptimizer<T, Tensor<T>, Tensor<T>>(
-                null,
-                new AdamWOptimizerOptions<T, Tensor<T>, Tensor<T>>(optimizerOptions))
-            : null;
-        return new EfficientConformer<T>(Architecture, new EfficientConformerOptions(_options), cloneOptimizer);
-    }
+
     private (List<int> tokens, double confidence) CTCGreedyDecodeWithConfidence(Tensor<T> logits) { var tokens = new List<int>(); double totalConf = 0; int confCount = 0; int prevToken = -1; int numFrames = logits.Rank >= 2 ? logits.Shape[0] : 1; int vocabSize = logits.Rank >= 2 ? logits.Shape[^1] : logits.Shape[0]; for (int t = 0; t < numFrames; t++) { int maxIdx = 0; double maxVal = double.NegativeInfinity; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); if (val > maxVal) { maxVal = val; maxIdx = v; } } double sumExp = 0; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); sumExp += Math.Exp(val - maxVal); } double frameConf = 1.0 / sumExp; if (maxIdx != prevToken && maxIdx > 0) { tokens.Add(maxIdx); totalConf += frameConf; confCount++; } prevToken = maxIdx; } return (tokens, confCount > 0 ? totalConf / confCount : 0.0); }
     private static string TokensToText(List<int> tokens) { var sb = new System.Text.StringBuilder(); foreach (var t in tokens) { if (t > 0 && t <= char.MaxValue) sb.Append((char)t); else if (t > char.MaxValue && t <= 0x10FFFF) sb.Append(char.ConvertFromUtf32(t)); } return sb.ToString().Trim(); }
     private IReadOnlyList<TranscriptionSegment<T>> ExtractSegments(string text, double duration, double confidence) { if (string.IsNullOrWhiteSpace(text)) return Array.Empty<TranscriptionSegment<T>>(); return new[] { new TranscriptionSegment<T> { Text = text, StartTime = 0.0, EndTime = duration, Confidence = NumOps.FromDouble(confidence) } }; }
diff --git a/src/SpeechRecognition/ConformerFamily/RWKVTransducer.cs b/src/SpeechRecognition/ConformerFamily/RWKVTransducer.cs
index b7d52515c3..d800b82b50 100644
--- a/src/SpeechRecognition/ConformerFamily/RWKVTransducer.cs
+++ b/src/SpeechRecognition/ConformerFamily/RWKVTransducer.cs
@@ -55,7 +55,7 @@ namespace AiDotNet.SpeechRecognition.ConformerFamily;
     "https://arxiv.org/abs/2309.14758",
     Year = 2023,
     Authors = "Keyu An, Shiliang Zhang")]
-public class RWKVTransducer<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
+public partial class RWKVTransducer<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
 {
     private readonly RWKVTransducerOptions _options; public override ModelOptions GetOptions() => _options;
     private RwkvTimeMixing<T>? _timeMixing;
@@ -184,9 +184,8 @@ protected override Tensor<T> PreprocessAudio(Tensor<T> rawAudio)
     }
     protected override Tensor<T> PostprocessOutput(Tensor<T> o) => o;
     public override ModelMetadata<T> GetModelMetadata() => new() { Name = _useNativeMode ? "RWKVTransducer-Native" : "RWKVTransducer-ONNX", Description = "RWKVTransducer: RWKV-Enhanced E-Branchformer (Song et al., 2025)", FeatureCount = _options.NumMels, Complexity = _options.NumEncoderLayers, AdditionalInfo = BaseAudioMetadataInfo() };
-    protected override void SerializeNetworkSpecificData(BinaryWriter w) { w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty); w.Write(_options.SampleRate); w.Write(_options.MaxAudioLengthSeconds); w.Write(_options.EncoderDim); w.Write(_options.NumEncoderLayers); w.Write(_options.NumAttentionHeads); w.Write(_options.CgmlpDim); w.Write(_options.NumMels); w.Write(_options.VocabSize); w.Write(_options.DropoutRate); w.Write(_options.Language); w.Write(_options.TimeDecay); w.Write(_options.CurrentTokenBonus); w.Write(_options.TokenShiftMix); w.Write(_options.BoundaryAware); w.Write(_options.LearningRate); }
-    protected override void DeserializeNetworkSpecificData(BinaryReader r) { _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp; _options.SampleRate = r.ReadInt32(); _options.MaxAudioLengthSeconds = r.ReadInt32(); _options.EncoderDim = r.ReadInt32(); _options.NumEncoderLayers = r.ReadInt32(); _options.NumAttentionHeads = r.ReadInt32(); _options.CgmlpDim = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.VocabSize = r.ReadInt32(); _options.DropoutRate = r.ReadDouble(); _options.Language = r.ReadString(); if (r.BaseStream.Position < r.BaseStream.Length) _options.TimeDecay = r.ReadDouble(); if (r.BaseStream.Position < r.BaseStream.Length) _options.CurrentTokenBonus = r.ReadDouble(); if (r.BaseStream.Position < r.BaseStream.Length) _options.TokenShiftMix = r.ReadDouble(); if (r.BaseStream.Position < r.BaseStream.Length) _options.BoundaryAware = r.ReadBoolean(); if (r.BaseStream.Position < r.BaseStream.Length) _options.LearningRate = r.ReadDouble(); _timeMixing = null; base.SampleRate = _options.SampleRate; base.NumMels = _options.NumMels; if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions); }
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() { if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp)) return new RWKVTransducer<T>(Architecture, mp, _options); return new RWKVTransducer<T>(Architecture, _options); }
+
+
     private (List<int> tokens, double confidence) CTCGreedyDecodeWithConfidence(Tensor<T> logits) { var tokens = new List<int>(); double totalConf = 0; int confCount = 0; int prevToken = -1; int numFrames = logits.Rank >= 2 ? logits.Shape[0] : 1; int vocabSize = logits.Rank >= 2 ? logits.Shape[^1] : logits.Shape[0]; for (int t = 0; t < numFrames; t++) { int maxIdx = 0; double maxVal = double.NegativeInfinity; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); if (val > maxVal) { maxVal = val; maxIdx = v; } } double sumExp = 0; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); sumExp += Math.Exp(val - maxVal); } double frameConf = 1.0 / sumExp; if (maxIdx != prevToken && maxIdx > 0) { tokens.Add(maxIdx); totalConf += frameConf; confCount++; } prevToken = maxIdx; } return (tokens, confCount > 0 ? totalConf / confCount : 0.0); }
     /// <summary>Renders CTC token ids as text using the configured vocabulary.</summary>
     /// <remarks>
diff --git a/src/SpeechRecognition/ConformerFamily/Squeezeformer.cs b/src/SpeechRecognition/ConformerFamily/Squeezeformer.cs
index f8e9cbeb5e..f842f28079 100644
--- a/src/SpeechRecognition/ConformerFamily/Squeezeformer.cs
+++ b/src/SpeechRecognition/ConformerFamily/Squeezeformer.cs
@@ -45,7 +45,7 @@ namespace AiDotNet.SpeechRecognition.ConformerFamily;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Squeezeformer: An Efficient Transformer for Automatic Speech Recognition", "https://arxiv.org/abs/2206.00888", Year = 2022, Authors = "Kim et al.")]
-public class Squeezeformer<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
+public partial class Squeezeformer<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
 {
     private readonly SqueezeformerOptions _options; public override ModelOptions GetOptions() => _options;
     private IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer; private bool _useNativeMode; private bool _disposed;
@@ -217,42 +217,8 @@ public override void Train(Tensor<T> input, Tensor<T> expected)
     /// </remarks>
     private const int NetworkSpecificPayloadVersion = 1;
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w) { w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty); w.Write(_options.SampleRate); w.Write(_options.MaxAudioLengthSeconds); w.Write(_options.EncoderDim); w.Write(_options.NumEncoderLayers); w.Write(_options.NumAttentionHeads); w.Write(_options.FeedForwardExpansionFactor); w.Write(_options.NumMels); w.Write(_options.VocabSize); w.Write(_options.DropoutRate); w.Write(_options.Language);
-        // The settings that SHAPE THE OPTIMIZER. Without these a reloaded model resumed training under
-        // whatever defaults CreateSqueezeformerOptimizer saw at construction, not the ones it was saved
-        // with -- a different learning rate and decay, silently.
-        w.Write(NetworkSpecificPayloadVersion); w.Write(_options.PeakLearningRate); w.Write(_options.WeightDecay); w.Write(_options.WarmupSteps); w.Write(_options.UseLayerNormalization); }
-    protected override void DeserializeNetworkSpecificData(BinaryReader r) { _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp; _options.SampleRate = r.ReadInt32(); _options.MaxAudioLengthSeconds = r.ReadInt32(); _options.EncoderDim = r.ReadInt32(); _options.NumEncoderLayers = r.ReadInt32(); _options.NumAttentionHeads = r.ReadInt32(); _options.FeedForwardExpansionFactor = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.VocabSize = r.ReadInt32(); _options.DropoutRate = r.ReadDouble(); _options.Language = r.ReadString(); base.SampleRate = _options.SampleRate; base.NumMels = _options.NumMels;
-        var stream = r.BaseStream;
-        if (!stream.CanSeek || stream.Position < stream.Length)
-        {
-            int payloadVersion = r.ReadInt32();
-            if (payloadVersion != NetworkSpecificPayloadVersion)
-            {
-                throw new InvalidOperationException(
-                    $"Squeezeformer was saved with network-payload version {payloadVersion}, but this " +
-                    $"build reads version {NetworkSpecificPayloadVersion}. Load it with a matching " +
-                    "version of AiDotNet, or re-save it from one.");
-            }
-
-            _options.PeakLearningRate = r.ReadDouble(); _options.WeightDecay = r.ReadDouble(); _options.WarmupSteps = r.ReadInt32(); _options.UseLayerNormalization = r.ReadBoolean();
 
-            // Rebuild it: _optimizer was created from the options as they stood BEFORE this payload was
-            // read, so leaving it in place means the restored settings describe the model but not the
-            // optimizer that trains it.
-            _optimizer = CreateSqueezeformerOptimizer();
-            SetBaseTrainOptimizer(_optimizer);
-        }
-        else
-        {
-            System.Diagnostics.Trace.TraceWarning(
-                "AiDotNet.Squeezeformer: this model was saved before the optimizer settings were " +
-                "persisted, so PeakLearningRate, WeightDecay, WarmupSteps and UseLayerNormalization " +
-                "keep their defaults. Re-save the model to carry them forward.");
-        }
 
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions); }
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() { if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp)) return new Squeezeformer<T>(Architecture, mp, _options); return new Squeezeformer<T>(Architecture, _options); }
     private (List<int> tokens, double confidence) CTCGreedyDecodeWithConfidence(Tensor<T> logits) { var tokens = new List<int>(); double totalConf = 0; int confCount = 0; int prevToken = -1; int numFrames = logits.Rank >= 2 ? logits.Shape[0] : 1; int vocabSize = logits.Rank >= 2 ? logits.Shape[^1] : logits.Shape[0]; for (int t = 0; t < numFrames; t++) { int maxIdx = 0; double maxVal = double.NegativeInfinity; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); if (val > maxVal) { maxVal = val; maxIdx = v; } } double sumExp = 0; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); sumExp += Math.Exp(val - maxVal); } double frameConf = 1.0 / sumExp; if (maxIdx != prevToken && maxIdx > 0) { tokens.Add(maxIdx); totalConf += frameConf; confCount++; } prevToken = maxIdx; } return (tokens, confCount > 0 ? totalConf / confCount : 0.0); }
     private static string TokensToText(List<int> tokens) { var sb = new System.Text.StringBuilder(); foreach (var t in tokens) { if (t > 0 && t <= char.MaxValue) sb.Append((char)t); else if (t > char.MaxValue && t <= 0x10FFFF) sb.Append(char.ConvertFromUtf32(t)); } return sb.ToString().Trim(); }
     private IReadOnlyList<TranscriptionSegment<T>> ExtractSegments(string text, double duration, double confidence) { if (string.IsNullOrWhiteSpace(text)) return Array.Empty<TranscriptionSegment<T>>(); return new[] { new TranscriptionSegment<T> { Text = text, StartTime = 0.0, EndTime = duration, Confidence = NumOps.FromDouble(confidence) } }; }
diff --git a/src/SpeechRecognition/Foundation/BESTRQ.cs b/src/SpeechRecognition/Foundation/BESTRQ.cs
index 45f14f019c..ef40b79d33 100644
--- a/src/SpeechRecognition/Foundation/BESTRQ.cs
+++ b/src/SpeechRecognition/Foundation/BESTRQ.cs
@@ -135,15 +135,8 @@ public override void Train(Tensor<T> input, Tensor<T> expected)
     protected override bool SupportsParameterMutation => _useNativeMode;
     protected override Tensor<T> PostprocessOutput(Tensor<T> o) => o;
     public override ModelMetadata<T> GetModelMetadata() => new() { Name = _useNativeMode ? "BESTRQ-Native" : "BESTRQ-ONNX", Description = "BEST-RQ: random-projection quantizer SSL + CTC (Google, 2022)", FeatureCount = _options.NumMels, Complexity = _options.NumEncoderLayers, AdditionalInfo = BaseAudioMetadataInfo() };
-    protected override void SerializeNetworkSpecificData(BinaryWriter w) { w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty); w.Write(_options.SampleRate); w.Write(_options.MaxAudioLengthSeconds); w.Write(_options.EncoderDim); w.Write(_options.NumEncoderLayers); w.Write(_options.NumAttentionHeads); w.Write(_options.NumMels); w.Write(_options.VocabSize); w.Write(_options.MaxTextLength); w.Write(_options.DropoutRate); w.Write(_options.Language); }
-    protected override void DeserializeNetworkSpecificData(BinaryReader r) { _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp; _options.SampleRate = r.ReadInt32(); _options.MaxAudioLengthSeconds = r.ReadInt32(); _options.EncoderDim = r.ReadInt32(); _options.NumEncoderLayers = r.ReadInt32(); _options.NumAttentionHeads = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.VocabSize = r.ReadInt32(); _options.MaxTextLength = r.ReadInt32(); _options.DropoutRate = r.ReadDouble(); _options.Language = r.ReadString(); base.SampleRate = _options.SampleRate; base.NumMels = _options.NumMels; if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions); }
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var options = new BESTRQOptions(_options);
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new BESTRQ<T>(Architecture, mp, options);
-        return new BESTRQ<T>(Architecture, options);
-    }
+
+
 
     private (List<int> tokens, double confidence) CTCGreedyDecodeWithConfidence(Tensor<T> logits) { var tokens = new List<int>(); double totalConf = 0; int confCount = 0; int prevToken = -1; int numFrames = logits.Rank >= 2 ? logits.Shape[0] : 1; int vocabSize = logits.Rank >= 2 ? logits.Shape[^1] : logits.Shape[0]; for (int t = 0; t < numFrames && tokens.Count < _options.MaxTextLength; t++) { int maxIdx = 0; double maxVal = double.NegativeInfinity; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); if (val > maxVal) { maxVal = val; maxIdx = v; } } double sumExp = 0; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); sumExp += Math.Exp(val - maxVal); } double frameConf = 1.0 / sumExp; if (maxIdx != prevToken && maxIdx > 0) { tokens.Add(maxIdx); totalConf += frameConf; confCount++; } prevToken = maxIdx; } return (tokens, confCount > 0 ? totalConf / confCount : 0.0); }
     private static string TokensToText(List<int> tokens) { var sb = new System.Text.StringBuilder(); foreach (var t in tokens) { if (t > 0 && t <= char.MaxValue) sb.Append((char)t); else if (t > char.MaxValue && t <= 0x10FFFF) sb.Append(char.ConvertFromUtf32(t)); } return sb.ToString().Trim(); }
diff --git a/src/SpeechRecognition/Foundation/Data2VecASR.cs b/src/SpeechRecognition/Foundation/Data2VecASR.cs
index 22587ae938..5e8e636e80 100644
--- a/src/SpeechRecognition/Foundation/Data2VecASR.cs
+++ b/src/SpeechRecognition/Foundation/Data2VecASR.cs
@@ -43,7 +43,7 @@ namespace AiDotNet.SpeechRecognition.Foundation;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("data2vec: A General Framework for Self-Supervised Learning in Speech, Vision and Language", "https://arxiv.org/abs/2202.03555", Year = 2022, Authors = "Baevski et al.")]
-public class Data2VecASR<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
+public partial class Data2VecASR<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
 {
     private readonly Data2VecASROptions _options; public override ModelOptions GetOptions() => _options;
     private IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer; private bool _useNativeMode; private bool _disposed;
@@ -129,9 +129,8 @@ public override void Train(Tensor<T> input, Tensor<T> expected)
     protected override bool SupportsParameterMutation => _useNativeMode;
     protected override Tensor<T> PostprocessOutput(Tensor<T> o) => o;
     public override ModelMetadata<T> GetModelMetadata() => new() { Name = _useNativeMode ? "Data2VecASR-Native" : "Data2VecASR-ONNX", Description = "data2vec: general SSL framework + CTC (Meta, 2022)", FeatureCount = _options.NumMels, Complexity = _options.NumEncoderLayers, AdditionalInfo = BaseAudioMetadataInfo() };
-    protected override void SerializeNetworkSpecificData(BinaryWriter w) { w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty); w.Write(_options.SampleRate); w.Write(_options.MaxAudioLengthSeconds); w.Write(_options.EncoderDim); w.Write(_options.NumEncoderLayers); w.Write(_options.NumAttentionHeads); w.Write(_options.NumMels); w.Write(_options.VocabSize); w.Write(_options.MaxTextLength); w.Write(_options.DropoutRate); w.Write(_options.Language); }
-    protected override void DeserializeNetworkSpecificData(BinaryReader r) { _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp; _options.SampleRate = r.ReadInt32(); _options.MaxAudioLengthSeconds = r.ReadInt32(); _options.EncoderDim = r.ReadInt32(); _options.NumEncoderLayers = r.ReadInt32(); _options.NumAttentionHeads = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.VocabSize = r.ReadInt32(); _options.MaxTextLength = r.ReadInt32(); _options.DropoutRate = r.ReadDouble(); _options.Language = r.ReadString(); base.SampleRate = _options.SampleRate; base.NumMels = _options.NumMels; if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions); }
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() { if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp)) return new Data2VecASR<T>(Architecture, mp, _options); return new Data2VecASR<T>(Architecture, _options); }
+
+
 
     private (List<int> tokens, double confidence) CTCGreedyDecodeWithConfidence(Tensor<T> logits) { var tokens = new List<int>(); double totalConf = 0; int confCount = 0; int prevToken = -1; int numFrames = logits.Rank >= 2 ? logits.Shape[0] : 1; int vocabSize = logits.Rank >= 2 ? logits.Shape[^1] : logits.Shape[0]; for (int t = 0; t < numFrames && tokens.Count < _options.MaxTextLength; t++) { int maxIdx = 0; double maxVal = double.NegativeInfinity; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); if (val > maxVal) { maxVal = val; maxIdx = v; } } double sumExp = 0; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); sumExp += Math.Exp(val - maxVal); } double frameConf = 1.0 / sumExp; if (maxIdx != prevToken && maxIdx > 0) { tokens.Add(maxIdx); totalConf += frameConf; confCount++; } prevToken = maxIdx; } return (tokens, confCount > 0 ? totalConf / confCount : 0.0); }
     private static string TokensToText(List<int> tokens) { var sb = new System.Text.StringBuilder(); foreach (var t in tokens) { if (t > 0 && t <= char.MaxValue) sb.Append((char)t); else if (t > char.MaxValue && t <= 0x10FFFF) sb.Append(char.ConvertFromUtf32(t)); } return sb.ToString().Trim(); }
diff --git a/src/SpeechRecognition/Foundation/HuBERTASR.cs b/src/SpeechRecognition/Foundation/HuBERTASR.cs
index 23cfb27a58..7dea0a429e 100644
--- a/src/SpeechRecognition/Foundation/HuBERTASR.cs
+++ b/src/SpeechRecognition/Foundation/HuBERTASR.cs
@@ -43,7 +43,7 @@ namespace AiDotNet.SpeechRecognition.Foundation;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("HuBERT: Self-Supervised Speech Representation Learning by Masked Prediction of Hidden Units", "https://arxiv.org/abs/2106.07447", Year = 2021, Authors = "Hsu et al.")]
-public class HuBERTASR<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
+public partial class HuBERTASR<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
 {
     private readonly HuBERTASROptions _options;
     private IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer;
@@ -134,9 +134,8 @@ public override void Train(Tensor<T> input, Tensor<T> expected)
     protected override bool SupportsParameterMutation => _useNativeMode;
     protected override Tensor<T> PostprocessOutput(Tensor<T> o) => o;
     public override ModelMetadata<T> GetModelMetadata() => new() { Name = _useNativeMode ? "HuBERTASR-Native" : "HuBERTASR-ONNX", Description = "HuBERT: hidden-unit BERT SSL + CTC (Meta, 2021)", FeatureCount = _options.NumMels, Complexity = _options.NumEncoderLayers, AdditionalInfo = BaseAudioMetadataInfo() };
-    protected override void SerializeNetworkSpecificData(BinaryWriter w) { w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty); w.Write(_options.SampleRate); w.Write(_options.MaxAudioLengthSeconds); w.Write(_options.EncoderDim); w.Write(_options.NumEncoderLayers); w.Write(_options.NumAttentionHeads); w.Write(_options.NumMels); w.Write(_options.VocabSize); w.Write(_options.MaxTextLength); w.Write(_options.DropoutRate); w.Write(_options.Language); }
-    protected override void DeserializeNetworkSpecificData(BinaryReader r) { _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp; _options.SampleRate = r.ReadInt32(); _options.MaxAudioLengthSeconds = r.ReadInt32(); _options.EncoderDim = r.ReadInt32(); _options.NumEncoderLayers = r.ReadInt32(); _options.NumAttentionHeads = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.VocabSize = r.ReadInt32(); _options.MaxTextLength = r.ReadInt32(); _options.DropoutRate = r.ReadDouble(); _options.Language = r.ReadString(); base.SampleRate = _options.SampleRate; base.NumMels = _options.NumMels; if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions); }
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() { if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp)) return new HuBERTASR<T>(Architecture, mp, _options); return new HuBERTASR<T>(Architecture, _options); }
+
+
 
     private (List<int> tokens, double confidence) CTCGreedyDecodeWithConfidence(Tensor<T> logits) { var tokens = new List<int>(); double totalConf = 0; int confCount = 0; int prevToken = -1; int numFrames = logits.Rank >= 2 ? logits.Shape[0] : 1; int vocabSize = logits.Rank >= 2 ? logits.Shape[^1] : logits.Shape[0]; for (int t = 0; t < numFrames && tokens.Count < _options.MaxTextLength; t++) { int maxIdx = 0; double maxVal = double.NegativeInfinity; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); if (val > maxVal) { maxVal = val; maxIdx = v; } } double sumExp = 0; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); sumExp += Math.Exp(val - maxVal); } double frameConf = 1.0 / sumExp; if (maxIdx != prevToken && maxIdx > 0) { tokens.Add(maxIdx); totalConf += frameConf; confCount++; } prevToken = maxIdx; } return (tokens, confCount > 0 ? totalConf / confCount : 0.0); }
     private static string TokensToText(List<int> tokens) { var sb = new System.Text.StringBuilder(); foreach (var t in tokens) { if (t > 0 && t <= char.MaxValue) sb.Append((char)t); else if (t > char.MaxValue && t <= 0x10FFFF) sb.Append(char.ConvertFromUtf32(t)); } return sb.ToString().Trim(); }
diff --git a/src/SpeechRecognition/Foundation/SPIRAL.cs b/src/SpeechRecognition/Foundation/SPIRAL.cs
index c29d446ea8..c6370f1e45 100644
--- a/src/SpeechRecognition/Foundation/SPIRAL.cs
+++ b/src/SpeechRecognition/Foundation/SPIRAL.cs
@@ -43,7 +43,7 @@ namespace AiDotNet.SpeechRecognition.Foundation;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("SPIRAL: Self-supervised Perturbation-Invariant Representation Learning for Speech Pre-Training", "https://arxiv.org/abs/2201.10207", Year = 2022, Authors = "Huang et al.")]
-public class SPIRAL<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
+public partial class SPIRAL<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
 {
     private readonly SPIRALOptions _options; public override ModelOptions GetOptions() => _options;
     private IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer; private bool _useNativeMode; private bool _disposed;
@@ -122,9 +122,8 @@ public override void Train(Tensor<T> input, Tensor<T> expected)
     protected override bool SupportsParameterMutation => _useNativeMode;
     protected override Tensor<T> PostprocessOutput(Tensor<T> o) => o;
     public override ModelMetadata<T> GetModelMetadata() => new() { Name = _useNativeMode ? "SPIRAL-Native" : "SPIRAL-ONNX", Description = "SPIRAL: perturbation-invariant SSL + CTC (2022)", FeatureCount = _options.NumMels, Complexity = _options.NumEncoderLayers, AdditionalInfo = BaseAudioMetadataInfo() };
-    protected override void SerializeNetworkSpecificData(BinaryWriter w) { w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty); w.Write(_options.SampleRate); w.Write(_options.MaxAudioLengthSeconds); w.Write(_options.EncoderDim); w.Write(_options.NumEncoderLayers); w.Write(_options.NumAttentionHeads); w.Write(_options.NumMels); w.Write(_options.VocabSize); w.Write(_options.MaxTextLength); w.Write(_options.DropoutRate); w.Write(_options.Language); }
-    protected override void DeserializeNetworkSpecificData(BinaryReader r) { _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp; _options.SampleRate = r.ReadInt32(); _options.MaxAudioLengthSeconds = r.ReadInt32(); _options.EncoderDim = r.ReadInt32(); _options.NumEncoderLayers = r.ReadInt32(); _options.NumAttentionHeads = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.VocabSize = r.ReadInt32(); _options.MaxTextLength = r.ReadInt32(); _options.DropoutRate = r.ReadDouble(); _options.Language = r.ReadString(); base.SampleRate = _options.SampleRate; base.NumMels = _options.NumMels; if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions); }
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() { if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp)) return new SPIRAL<T>(Architecture, mp, _options); return new SPIRAL<T>(Architecture, _options); }
+
+
 
     private (List<int> tokens, double confidence) CTCGreedyDecodeWithConfidence(Tensor<T> logits) { var tokens = new List<int>(); double totalConf = 0; int confCount = 0; int prevToken = -1; int numFrames = logits.Rank >= 2 ? logits.Shape[0] : 1; int vocabSize = logits.Rank >= 2 ? logits.Shape[^1] : logits.Shape[0]; for (int t = 0; t < numFrames && tokens.Count < _options.MaxTextLength; t++) { int maxIdx = 0; double maxVal = double.NegativeInfinity; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); if (val > maxVal) { maxVal = val; maxIdx = v; } } double sumExp = 0; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); sumExp += Math.Exp(val - maxVal); } double frameConf = 1.0 / sumExp; if (maxIdx != prevToken && maxIdx > 0) { tokens.Add(maxIdx); totalConf += frameConf; confCount++; } prevToken = maxIdx; } return (tokens, confCount > 0 ? totalConf / confCount : 0.0); }
     private static string TokensToText(List<int> tokens) { var sb = new System.Text.StringBuilder(); foreach (var t in tokens) { if (t > 0 && t <= char.MaxValue) sb.Append((char)t); else if (t > char.MaxValue && t <= 0x10FFFF) sb.Append(char.ConvertFromUtf32(t)); } return sb.ToString().Trim(); }
diff --git a/src/SpeechRecognition/Foundation/UniSpeech.cs b/src/SpeechRecognition/Foundation/UniSpeech.cs
index 566e2df7a9..6ea6e0b956 100644
--- a/src/SpeechRecognition/Foundation/UniSpeech.cs
+++ b/src/SpeechRecognition/Foundation/UniSpeech.cs
@@ -43,7 +43,7 @@ namespace AiDotNet.SpeechRecognition.Foundation;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("UniSpeech: Unified Speech Representation Learning with Labeled and Unlabeled Data", "https://arxiv.org/abs/2101.07597", Year = 2021, Authors = "Wang et al.")]
-public class UniSpeech<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
+public partial class UniSpeech<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
 {
     private readonly UniSpeechOptions _options; public override ModelOptions GetOptions() => _options;
     private IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer; private bool _useNativeMode; private bool _disposed;
@@ -122,9 +122,8 @@ public override void Train(Tensor<T> input, Tensor<T> expected)
     protected override bool SupportsParameterMutation => _useNativeMode;
     protected override Tensor<T> PostprocessOutput(Tensor<T> o) => o;
     public override ModelMetadata<T> GetModelMetadata() => new() { Name = _useNativeMode ? "UniSpeech-Native" : "UniSpeech-ONNX", Description = "UniSpeech: unified SSL + supervised + CTC (Microsoft, 2021)", FeatureCount = _options.NumMels, Complexity = _options.NumEncoderLayers, AdditionalInfo = BaseAudioMetadataInfo() };
-    protected override void SerializeNetworkSpecificData(BinaryWriter w) { w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty); w.Write(_options.SampleRate); w.Write(_options.MaxAudioLengthSeconds); w.Write(_options.EncoderDim); w.Write(_options.NumEncoderLayers); w.Write(_options.NumAttentionHeads); w.Write(_options.NumMels); w.Write(_options.VocabSize); w.Write(_options.MaxTextLength); w.Write(_options.DropoutRate); w.Write(_options.Language); }
-    protected override void DeserializeNetworkSpecificData(BinaryReader r) { _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp; _options.SampleRate = r.ReadInt32(); _options.MaxAudioLengthSeconds = r.ReadInt32(); _options.EncoderDim = r.ReadInt32(); _options.NumEncoderLayers = r.ReadInt32(); _options.NumAttentionHeads = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.VocabSize = r.ReadInt32(); _options.MaxTextLength = r.ReadInt32(); _options.DropoutRate = r.ReadDouble(); _options.Language = r.ReadString(); base.SampleRate = _options.SampleRate; base.NumMels = _options.NumMels; if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions); }
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() { if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp)) return new UniSpeech<T>(Architecture, mp, _options); return new UniSpeech<T>(Architecture, _options); }
+
+
 
     private (List<int> tokens, double confidence) CTCGreedyDecodeWithConfidence(Tensor<T> logits) { var tokens = new List<int>(); double totalConf = 0; int confCount = 0; int prevToken = -1; int numFrames = logits.Rank >= 2 ? logits.Shape[0] : 1; int vocabSize = logits.Rank >= 2 ? logits.Shape[^1] : logits.Shape[0]; for (int t = 0; t < numFrames && tokens.Count < _options.MaxTextLength; t++) { int maxIdx = 0; double maxVal = double.NegativeInfinity; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); if (val > maxVal) { maxVal = val; maxIdx = v; } } double sumExp = 0; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); sumExp += Math.Exp(val - maxVal); } double frameConf = 1.0 / sumExp; if (maxIdx != prevToken && maxIdx > 0) { tokens.Add(maxIdx); totalConf += frameConf; confCount++; } prevToken = maxIdx; } return (tokens, confCount > 0 ? totalConf / confCount : 0.0); }
     private static string TokensToText(List<int> tokens) { var sb = new System.Text.StringBuilder(); foreach (var t in tokens) { if (t > 0 && t <= char.MaxValue) sb.Append((char)t); else if (t > char.MaxValue && t <= 0x10FFFF) sb.Append(char.ConvertFromUtf32(t)); } return sb.ToString().Trim(); }
diff --git a/src/SpeechRecognition/Foundation/W2vBERT.cs b/src/SpeechRecognition/Foundation/W2vBERT.cs
index f2f2a26af1..ce3445ff4c 100644
--- a/src/SpeechRecognition/Foundation/W2vBERT.cs
+++ b/src/SpeechRecognition/Foundation/W2vBERT.cs
@@ -43,7 +43,7 @@ namespace AiDotNet.SpeechRecognition.Foundation;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("w2v-BERT: Combining Contrastive Learning and Masked Language Modeling for Self-Supervised Speech Pre-Training", "https://arxiv.org/abs/2108.06209", Year = 2021, Authors = "Chung et al.")]
-public class W2vBERT<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
+public partial class W2vBERT<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
 {
     private readonly W2vBERTOptions _options; public override ModelOptions GetOptions() => _options;
     private IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer; private bool _useNativeMode; private bool _disposed;
@@ -122,9 +122,8 @@ public override void Train(Tensor<T> input, Tensor<T> expected)
     protected override bool SupportsParameterMutation => _useNativeMode;
     protected override Tensor<T> PostprocessOutput(Tensor<T> o) => o;
     public override ModelMetadata<T> GetModelMetadata() => new() { Name = _useNativeMode ? "W2vBERT-Native" : "W2vBERT-ONNX", Description = "w2v-BERT: contrastive + MLM SSL + CTC (Google, 2021)", FeatureCount = _options.NumMels, Complexity = _options.NumEncoderLayers, AdditionalInfo = BaseAudioMetadataInfo() };
-    protected override void SerializeNetworkSpecificData(BinaryWriter w) { w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty); w.Write(_options.SampleRate); w.Write(_options.EncoderDim); w.Write(_options.NumEncoderLayers); w.Write(_options.NumAttentionHeads); w.Write(_options.NumMels); w.Write(_options.VocabSize); w.Write(_options.MaxTextLength); w.Write(_options.DropoutRate); w.Write(_options.Language); }
-    protected override void DeserializeNetworkSpecificData(BinaryReader r) { _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp; _options.SampleRate = r.ReadInt32(); _options.EncoderDim = r.ReadInt32(); _options.NumEncoderLayers = r.ReadInt32(); _options.NumAttentionHeads = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.VocabSize = r.ReadInt32(); _options.MaxTextLength = r.ReadInt32(); _options.DropoutRate = r.ReadDouble(); _options.Language = r.ReadString(); base.SampleRate = _options.SampleRate; base.NumMels = _options.NumMels; if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions); }
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() { if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp)) return new W2vBERT<T>(Architecture, mp, _options); return new W2vBERT<T>(Architecture, _options); }
+
+
 
     private (List<int> tokens, double confidence) CTCGreedyDecodeWithConfidence(Tensor<T> logits) { var tokens = new List<int>(); double totalConf = 0; int confCount = 0; int prevToken = -1; int numFrames = logits.Rank >= 2 ? logits.Shape[0] : 1; int vocabSize = logits.Rank >= 2 ? logits.Shape[^1] : logits.Shape[0]; for (int t = 0; t < numFrames && tokens.Count < _options.MaxTextLength; t++) { int maxIdx = 0; double maxVal = double.NegativeInfinity; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); if (val > maxVal) { maxVal = val; maxIdx = v; } } double sumExp = 0; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); sumExp += Math.Exp(val - maxVal); } double frameConf = 1.0 / sumExp; if (maxIdx != prevToken && maxIdx > 0) { tokens.Add(maxIdx); totalConf += frameConf; confCount++; } prevToken = maxIdx; } return (tokens, confCount > 0 ? totalConf / confCount : 0.0); }
     private static string TokensToText(List<int> tokens) { var sb = new System.Text.StringBuilder(); foreach (var t in tokens) { if (t > 0 && t <= char.MaxValue) sb.Append((char)t); else if (t > char.MaxValue && t <= 0x10FFFF) sb.Append(char.ConvertFromUtf32(t)); } return sb.ToString().Trim(); }
diff --git a/src/SpeechRecognition/Foundation/Wav2Vec2ASR.cs b/src/SpeechRecognition/Foundation/Wav2Vec2ASR.cs
index 53bc1a82c3..d0660fa56c 100644
--- a/src/SpeechRecognition/Foundation/Wav2Vec2ASR.cs
+++ b/src/SpeechRecognition/Foundation/Wav2Vec2ASR.cs
@@ -43,7 +43,7 @@ namespace AiDotNet.SpeechRecognition.Foundation;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("wav2vec 2.0: A Framework for Self-Supervised Learning of Speech Representations", "https://arxiv.org/abs/2006.11477", Year = 2020, Authors = "Baevski et al.")]
-public class Wav2Vec2ASR<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
+public partial class Wav2Vec2ASR<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
 {
     private readonly Wav2Vec2ASROptions _options; public override ModelOptions GetOptions() => _options;
     private IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer; private bool _useNativeMode; private bool _disposed;
@@ -143,9 +143,8 @@ public override void Train(Tensor<T> input, Tensor<T> expected)
             ["Language"] = _options.Language
         }
     };
-    protected override void SerializeNetworkSpecificData(BinaryWriter w) { w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty); w.Write(_options.SampleRate); w.Write(_options.MaxAudioLengthSeconds); w.Write(_options.EncoderDim); w.Write(_options.NumEncoderLayers); w.Write(_options.NumAttentionHeads); w.Write(_options.NumMels); w.Write(_options.VocabSize); w.Write(_options.MaxTextLength); w.Write(_options.DropoutRate); w.Write(_options.Language); }
-    protected override void DeserializeNetworkSpecificData(BinaryReader r) { _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp; _options.SampleRate = r.ReadInt32(); _options.MaxAudioLengthSeconds = r.ReadInt32(); _options.EncoderDim = r.ReadInt32(); _options.NumEncoderLayers = r.ReadInt32(); _options.NumAttentionHeads = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.VocabSize = r.ReadInt32(); _options.MaxTextLength = r.ReadInt32(); _options.DropoutRate = r.ReadDouble(); _options.Language = r.ReadString(); base.SampleRate = _options.SampleRate; base.NumMels = _options.NumMels; if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions); }
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() { if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp)) return new Wav2Vec2ASR<T>(Architecture, mp, _options); return new Wav2Vec2ASR<T>(Architecture, _options); }
+
+
 
     private (List<int> tokens, double confidence) CTCGreedyDecodeWithConfidence(Tensor<T> logits) { var tokens = new List<int>(); double totalConf = 0; int confCount = 0; int prevToken = -1; int numFrames = logits.Rank >= 2 ? logits.Shape[0] : 1; int vocabSize = logits.Rank >= 2 ? logits.Shape[^1] : logits.Shape[0]; for (int t = 0; t < numFrames && tokens.Count < _options.MaxTextLength; t++) { int maxIdx = 0; double maxVal = double.NegativeInfinity; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); if (val > maxVal) { maxVal = val; maxIdx = v; } } double sumExp = 0; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); sumExp += Math.Exp(val - maxVal); } double frameConf = 1.0 / sumExp; if (maxIdx != prevToken && maxIdx > 0) { tokens.Add(maxIdx); totalConf += frameConf; confCount++; } prevToken = maxIdx; } return (tokens, confCount > 0 ? totalConf / confCount : 0.0); }
     private static string TokensToText(List<int> tokens) { var sb = new System.Text.StringBuilder(); foreach (var t in tokens) { if (t > 0 && t <= char.MaxValue) sb.Append((char)t); else if (t > char.MaxValue && t <= 0x10FFFF) sb.Append(char.ConvertFromUtf32(t)); } return sb.ToString().Trim(); }
diff --git a/src/SpeechRecognition/Foundation/WavLMASR.cs b/src/SpeechRecognition/Foundation/WavLMASR.cs
index c073a62dcc..164d0a3e5d 100644
--- a/src/SpeechRecognition/Foundation/WavLMASR.cs
+++ b/src/SpeechRecognition/Foundation/WavLMASR.cs
@@ -43,7 +43,7 @@ namespace AiDotNet.SpeechRecognition.Foundation;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("WavLM: Large-Scale Self-Supervised Pre-Training for Full Stack Speech Processing", "https://arxiv.org/abs/2110.13900", Year = 2022, Authors = "Chen et al.")]
-public class WavLMASR<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
+public partial class WavLMASR<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
 {
     private readonly WavLMASROptions _options; public override ModelOptions GetOptions() => _options;
     private IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer; private bool _useNativeMode; private bool _disposed;
@@ -122,9 +122,8 @@ public override void Train(Tensor<T> input, Tensor<T> expected)
     protected override bool SupportsParameterMutation => _useNativeMode;
     protected override Tensor<T> PostprocessOutput(Tensor<T> o) => o;
     public override ModelMetadata<T> GetModelMetadata() => new() { Name = _useNativeMode ? "WavLMASR-Native" : "WavLMASR-ONNX", Description = "WavLM: denoising SSL + CTC (Microsoft, 2022)", FeatureCount = _options.NumMels, Complexity = _options.NumEncoderLayers, AdditionalInfo = BaseAudioMetadataInfo() };
-    protected override void SerializeNetworkSpecificData(BinaryWriter w) { w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty); w.Write(_options.SampleRate); w.Write(_options.EncoderDim); w.Write(_options.NumEncoderLayers); w.Write(_options.NumAttentionHeads); w.Write(_options.NumMels); w.Write(_options.VocabSize); w.Write(_options.MaxTextLength); w.Write(_options.DropoutRate); w.Write(_options.Language); }
-    protected override void DeserializeNetworkSpecificData(BinaryReader r) { _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp; _options.SampleRate = r.ReadInt32(); _options.EncoderDim = r.ReadInt32(); _options.NumEncoderLayers = r.ReadInt32(); _options.NumAttentionHeads = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.VocabSize = r.ReadInt32(); _options.MaxTextLength = r.ReadInt32(); _options.DropoutRate = r.ReadDouble(); _options.Language = r.ReadString(); base.SampleRate = _options.SampleRate; base.NumMels = _options.NumMels; if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions); }
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() { if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp)) return new WavLMASR<T>(Architecture, mp, _options); return new WavLMASR<T>(Architecture, _options); }
+
+
 
     private (List<int> tokens, double confidence) CTCGreedyDecodeWithConfidence(Tensor<T> logits) { var tokens = new List<int>(); double totalConf = 0; int confCount = 0; int prevToken = -1; int numFrames = logits.Rank >= 2 ? logits.Shape[0] : 1; int vocabSize = logits.Rank >= 2 ? logits.Shape[^1] : logits.Shape[0]; for (int t = 0; t < numFrames && tokens.Count < _options.MaxTextLength; t++) { int maxIdx = 0; double maxVal = double.NegativeInfinity; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); if (val > maxVal) { maxVal = val; maxIdx = v; } } double sumExp = 0; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); sumExp += Math.Exp(val - maxVal); } double frameConf = 1.0 / sumExp; if (maxIdx != prevToken && maxIdx > 0) { tokens.Add(maxIdx); totalConf += frameConf; confCount++; } prevToken = maxIdx; } return (tokens, confCount > 0 ? totalConf / confCount : 0.0); }
     private static string TokensToText(List<int> tokens) { var sb = new System.Text.StringBuilder(); foreach (var t in tokens) { if (t > 0 && t <= char.MaxValue) sb.Append((char)t); else if (t > char.MaxValue && t <= 0x10FFFF) sb.Append(char.ConvertFromUtf32(t)); } return sb.ToString().Trim(); }
diff --git a/src/SpeechRecognition/LLMIntegrated/AudioPaLM.cs b/src/SpeechRecognition/LLMIntegrated/AudioPaLM.cs
index 404564190b..9b4e44dacd 100644
--- a/src/SpeechRecognition/LLMIntegrated/AudioPaLM.cs
+++ b/src/SpeechRecognition/LLMIntegrated/AudioPaLM.cs
@@ -47,7 +47,7 @@ namespace AiDotNet.SpeechRecognition.LLMIntegrated;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("AudioPaLM: A Large Language Model That Can Speak and Listen", "https://arxiv.org/abs/2306.12925", Year = 2023, Authors = "Rubenstein et al.")]
-public class AudioPaLM<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
+public partial class AudioPaLM<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
 {
     private readonly AudioPaLMOptions _options; public override ModelOptions GetOptions() => _options;
     private IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer; private bool _useNativeMode; private bool _disposed;
@@ -126,9 +126,8 @@ public override void Train(Tensor<T> input, Tensor<T> expected)
     protected override bool SupportsParameterMutation => _useNativeMode;
     protected override Tensor<T> PostprocessOutput(Tensor<T> o) => o;
     public override ModelMetadata<T> GetModelMetadata() => new() { Name = _useNativeMode ? "AudioPaLM-Native" : "AudioPaLM-ONNX", Description = "AudioPaLM: PaLM-2 + AudioLM fusion (Google, 2023)", FeatureCount = _options.NumMels, Complexity = _options.NumEncoderLayers, AdditionalInfo = BaseAudioMetadataInfo() };
-    protected override void SerializeNetworkSpecificData(BinaryWriter w) { w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty); w.Write(_options.SampleRate); w.Write(_options.MaxAudioLengthSeconds); w.Write(_options.EncoderDim); w.Write(_options.NumEncoderLayers); w.Write(_options.NumAttentionHeads); w.Write(_options.NumMels); w.Write(_options.VocabSize); w.Write(_options.MaxTextLength); w.Write(_options.DropoutRate); w.Write(_options.Language); }
-    protected override void DeserializeNetworkSpecificData(BinaryReader r) { _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp; _options.SampleRate = r.ReadInt32(); _options.MaxAudioLengthSeconds = r.ReadInt32(); _options.EncoderDim = r.ReadInt32(); _options.NumEncoderLayers = r.ReadInt32(); _options.NumAttentionHeads = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.VocabSize = r.ReadInt32(); _options.MaxTextLength = r.ReadInt32(); _options.DropoutRate = r.ReadDouble(); _options.Language = r.ReadString(); base.SampleRate = _options.SampleRate; base.NumMels = _options.NumMels; if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions); }
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() { if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp)) return new AudioPaLM<T>(Architecture, mp, _options); return new AudioPaLM<T>(Architecture, _options); }
+
+
 
     private (List<int> tokens, double confidence) CTCGreedyDecodeWithConfidence(Tensor<T> logits) { var tokens = new List<int>(); double totalConf = 0; int confCount = 0; int prevToken = -1; int numFrames = logits.Rank >= 2 ? logits.Shape[0] : 1; int vocabSize = logits.Rank >= 2 ? logits.Shape[^1] : logits.Shape[0]; for (int t = 0; t < numFrames && tokens.Count < _options.MaxTextLength; t++) { int maxIdx = 0; double maxVal = double.NegativeInfinity; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); if (val > maxVal) { maxVal = val; maxIdx = v; } } double sumExp = 0; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); sumExp += Math.Exp(val - maxVal); } double frameConf = 1.0 / sumExp; if (maxIdx != prevToken && maxIdx > 0) { tokens.Add(maxIdx); totalConf += frameConf; confCount++; } prevToken = maxIdx; } return (tokens, confCount > 0 ? totalConf / confCount : 0.0); }
     private static string TokensToText(List<int> tokens) { var sb = new System.Text.StringBuilder(); foreach (var t in tokens) { if (t > 0 && t <= char.MaxValue) sb.Append((char)t); else if (t > char.MaxValue && t <= 0x10FFFF) sb.Append(char.ConvertFromUtf32(t)); } return sb.ToString().Trim(); }
diff --git a/src/SpeechRecognition/LLMIntegrated/FireRedASR.cs b/src/SpeechRecognition/LLMIntegrated/FireRedASR.cs
index 39528df58f..19ee4cd13d 100644
--- a/src/SpeechRecognition/LLMIntegrated/FireRedASR.cs
+++ b/src/SpeechRecognition/LLMIntegrated/FireRedASR.cs
@@ -47,7 +47,7 @@ namespace AiDotNet.SpeechRecognition.LLMIntegrated;
     "https://arxiv.org/abs/2501.14350",
     Year = 2025,
     Authors = "Kai-Tuo Xu, Feng-Long Xie, Xu Tang, Yao Hu")]
-public class FireRedASR<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
+public partial class FireRedASR<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
 {
     /// <inheritdoc />
     /// <remarks>
@@ -235,47 +235,9 @@ public override void Train(Tensor<T> input, Tensor<T> expected)
         AdditionalInfo = BaseAudioMetadataInfo()
     };
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode);
-        w.Write(_options.ModelPath ?? string.Empty);
-        w.Write(_options.SampleRate);
-        w.Write(_options.EncoderDim);
-        w.Write(_options.NumEncoderLayers);
-        w.Write(_options.NumAttentionHeads);
-        w.Write(_options.NumMels);
-        w.Write(_options.VocabSize);
-        w.Write(_options.MaxTextLength);
-        w.Write(_options.DropoutRate);
-        w.Write(_options.Language);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean();
-        string mp = r.ReadString();
-        if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.SampleRate = r.ReadInt32();
-        _options.EncoderDim = r.ReadInt32();
-        _options.NumEncoderLayers = r.ReadInt32();
-        _options.NumAttentionHeads = r.ReadInt32();
-        _options.NumMels = r.ReadInt32();
-        _options.VocabSize = r.ReadInt32();
-        _options.MaxTextLength = r.ReadInt32();
-        _options.DropoutRate = r.ReadDouble();
-        _options.Language = r.ReadString();
-        base.SampleRate = _options.SampleRate;
-        base.NumMels = _options.NumMels;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new FireRedASR<T>(Architecture, mp, new FireRedASROptions(_options));
-        return new FireRedASR<T>(Architecture, new FireRedASROptions(_options));
-    }
+
 
     /// <summary>
     /// CTC greedy decode with per-frame softmax confidence tracking.
diff --git a/src/SpeechRecognition/LLMIntegrated/FireRedASRLLM.cs b/src/SpeechRecognition/LLMIntegrated/FireRedASRLLM.cs
index 131279ba24..cd75354e95 100644
--- a/src/SpeechRecognition/LLMIntegrated/FireRedASRLLM.cs
+++ b/src/SpeechRecognition/LLMIntegrated/FireRedASRLLM.cs
@@ -43,7 +43,7 @@ namespace AiDotNet.SpeechRecognition.LLMIntegrated;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("FireRedASR: Open-Source Industrial-Grade Mandarin Speech Recognition Models from Encoder-Decoder to LLM Integration", "https://arxiv.org/abs/2501.14350", Year = 2025, Authors = "FireRed Team")]
-public class FireRedASRLLM<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
+public partial class FireRedASRLLM<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
 {
     private readonly FireRedASRLLMOptions _options; public override ModelOptions GetOptions() => _options;
     private IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer; private bool _useNativeMode; private bool _disposed;
@@ -104,9 +104,8 @@ public TranscriptionResult<T> Transcribe(Tensor<T> audio, string? language = nul
     protected override bool SupportsParameterMutation => _useNativeMode;
     protected override Tensor<T> PostprocessOutput(Tensor<T> o) => o;
     public override ModelMetadata<T> GetModelMetadata() => new() { Name = _useNativeMode ? "FireRedASRLLM-Native" : "FireRedASRLLM-ONNX", Description = "FireRedASR-LLM: Conformer + Qwen2 decoder (2025)", FeatureCount = _options.NumMels, Complexity = _options.NumEncoderLayers, AdditionalInfo = BaseAudioMetadataInfo() };
-    protected override void SerializeNetworkSpecificData(BinaryWriter w) { w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty); w.Write(_options.SampleRate); w.Write(_options.EncoderDim); w.Write(_options.NumEncoderLayers); w.Write(_options.NumAttentionHeads); w.Write(_options.NumMels); w.Write(_options.VocabSize); w.Write(_options.MaxTextLength); w.Write(_options.DropoutRate); w.Write(_options.Language); w.Write(3); w.Write(_options.MaxAudioLengthSeconds); w.Write(_options.EncoderFeedForwardDim); w.Write(_options.AdapterDim); w.Write(_options.NumAdapterLayers); w.Write((int)_options.AdapterActivation); w.Write(_options.UseAdapterLayerNormalization); w.Write(_options.LlmDim); w.Write(_options.LlmFeedForwardDim); w.Write(_options.NumLlmLayers); w.Write(_options.NumLlmAttentionHeads); w.Write(_options.NumLlmKvHeads); w.Write(_options.LlmRopeTheta); w.Write(_options.UseQwen2Decoder); w.Write(_options.AdapterFrameSplicingFactor); }
-    protected override void DeserializeNetworkSpecificData(BinaryReader r) { _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp; _options.SampleRate = r.ReadInt32(); _options.EncoderDim = r.ReadInt32(); _options.NumEncoderLayers = r.ReadInt32(); _options.NumAttentionHeads = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.VocabSize = r.ReadInt32(); _options.MaxTextLength = r.ReadInt32(); _options.DropoutRate = r.ReadDouble(); _options.Language = r.ReadString(); if (r.BaseStream.Position < r.BaseStream.Length) { int version = r.ReadInt32(); if (version >= 1) { _options.MaxAudioLengthSeconds = r.ReadInt32(); _options.EncoderFeedForwardDim = r.ReadInt32(); _options.AdapterDim = r.ReadInt32(); _options.NumAdapterLayers = r.ReadInt32(); _options.AdapterActivation = (AiDotNet.Enums.ActivationFunction)r.ReadInt32(); _options.UseAdapterLayerNormalization = r.ReadBoolean(); _options.LlmDim = r.ReadInt32(); _options.LlmFeedForwardDim = r.ReadInt32(); _options.NumLlmLayers = r.ReadInt32(); _options.NumLlmAttentionHeads = r.ReadInt32(); } if (version >= 2) { _options.NumLlmKvHeads = r.ReadInt32(); _options.LlmRopeTheta = r.ReadDouble(); _options.UseQwen2Decoder = r.ReadBoolean(); } if (version >= 3) _options.AdapterFrameSplicingFactor = r.ReadInt32(); } ValidateOptions(_options); base.SampleRate = _options.SampleRate; base.NumMels = _options.NumMels; if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions); }
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() { var optionsCopy = new FireRedASRLLMOptions(_options); if (!_useNativeMode && optionsCopy.ModelPath is { } mp && !string.IsNullOrEmpty(mp)) return new FireRedASRLLM<T>(Architecture, mp, optionsCopy); return new FireRedASRLLM<T>(Architecture, optionsCopy); }
+
+
 
     private (List<int> tokens, double confidence) CTCGreedyDecodeWithConfidence(Tensor<T> logits) { var tokens = new List<int>(); double totalConf = 0; int confCount = 0; int prevToken = -1; int numFrames = logits.Rank >= 2 ? logits.Shape[0] : 1; int vocabSize = logits.Rank >= 2 ? logits.Shape[^1] : logits.Shape[0]; for (int t = 0; t < numFrames && tokens.Count < _options.MaxTextLength; t++) { int maxIdx = 0; double maxVal = double.NegativeInfinity; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); if (val > maxVal) { maxVal = val; maxIdx = v; } } double sumExp = 0; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); sumExp += Math.Exp(val - maxVal); } double frameConf = 1.0 / sumExp; if (maxIdx != prevToken && maxIdx > 0) { tokens.Add(maxIdx); totalConf += frameConf; confCount++; } prevToken = maxIdx; } return (tokens, confCount > 0 ? totalConf / confCount : 0.0); }
     private static string TokensToText(List<int> tokens) { var sb = new System.Text.StringBuilder(); foreach (var t in tokens) { if (t > 0 && t <= char.MaxValue) sb.Append((char)t); else if (t > char.MaxValue && t <= 0x10FFFF) sb.Append(char.ConvertFromUtf32(t)); } return sb.ToString().Trim(); }
diff --git a/src/SpeechRecognition/LLMIntegrated/GraniteSpeech.cs b/src/SpeechRecognition/LLMIntegrated/GraniteSpeech.cs
index 18313ebd72..77c972716c 100644
--- a/src/SpeechRecognition/LLMIntegrated/GraniteSpeech.cs
+++ b/src/SpeechRecognition/LLMIntegrated/GraniteSpeech.cs
@@ -42,7 +42,7 @@ namespace AiDotNet.SpeechRecognition.LLMIntegrated;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Granite-speech: open-source speech-aware LLMs with strong English ASR capabilities", "https://arxiv.org/abs/2505.08699", Year = 2025, Authors = "IBM Research")]
-public class GraniteSpeech<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
+public partial class GraniteSpeech<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
 {
     private readonly GraniteSpeechOptions _options; public override ModelOptions GetOptions() => _options;
     private IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer; private bool _useNativeMode; private bool _disposed;
@@ -105,20 +105,8 @@ protected override IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>> GetOrCreateB
     protected override bool SupportsParameterMutation => _useNativeMode;
     protected override Tensor<T> PostprocessOutput(Tensor<T> o) => o;
     public override ModelMetadata<T> GetModelMetadata() => new() { Name = _useNativeMode ? "GraniteSpeech-Native" : "GraniteSpeech-ONNX", Description = "Granite Speech: enterprise speech-LLM (IBM, 2025)", FeatureCount = _options.NumMels, Complexity = _options.NumEncoderLayers, AdditionalInfo = BaseAudioMetadataInfo() };
-    protected override void SerializeNetworkSpecificData(BinaryWriter w) { w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty); w.Write(_options.SampleRate); w.Write(_options.EncoderDim); w.Write(_options.NumEncoderLayers); w.Write(_options.NumAttentionHeads); w.Write(_options.NumMels); w.Write(_options.VocabSize); w.Write(_options.MaxTextLength); w.Write(_options.DropoutRate); w.Write(_options.Language); }
-    protected override void DeserializeNetworkSpecificData(BinaryReader r) { _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp; _options.SampleRate = r.ReadInt32(); _options.EncoderDim = r.ReadInt32(); _options.NumEncoderLayers = r.ReadInt32(); _options.NumAttentionHeads = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.VocabSize = r.ReadInt32(); _options.MaxTextLength = r.ReadInt32(); _options.DropoutRate = r.ReadDouble(); _options.Language = r.ReadString(); base.SampleRate = _options.SampleRate; base.NumMels = _options.NumMels; if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions); }
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new GraniteSpeech<T>(Architecture, mp, new GraniteSpeechOptions(_options));
 
-        var cloneOptimizer = _optimizer?.GetOptions() is AdamWOptimizerOptions<T, Tensor<T>, Tensor<T>> optimizerOptions
-            ? new AdamWOptimizer<T, Tensor<T>, Tensor<T>>(
-                null,
-                new AdamWOptimizerOptions<T, Tensor<T>, Tensor<T>>(optimizerOptions))
-            : null;
-        return new GraniteSpeech<T>(Architecture, new GraniteSpeechOptions(_options), cloneOptimizer);
-    }
+
 
     private (List<int> tokens, double confidence) CTCGreedyDecodeWithConfidence(Tensor<T> logits) { var tokens = new List<int>(); double totalConf = 0; int confCount = 0; int prevToken = -1; int numFrames = logits.Rank >= 2 ? logits.Shape[0] : 1; int vocabSize = logits.Rank >= 2 ? logits.Shape[^1] : logits.Shape[0]; for (int t = 0; t < numFrames && tokens.Count < _options.MaxTextLength; t++) { int maxIdx = 0; double maxVal = double.NegativeInfinity; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); if (val > maxVal) { maxVal = val; maxIdx = v; } } double sumExp = 0; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); sumExp += Math.Exp(val - maxVal); } double frameConf = 1.0 / sumExp; if (maxIdx != prevToken && maxIdx > 0) { tokens.Add(maxIdx); totalConf += frameConf; confCount++; } prevToken = maxIdx; } return (tokens, confCount > 0 ? totalConf / confCount : 0.0); }
     private static string TokensToText(List<int> tokens) { var sb = new System.Text.StringBuilder(); foreach (var t in tokens) { if (t > 0 && t <= char.MaxValue) sb.Append((char)t); else if (t > char.MaxValue && t <= 0x10FFFF) sb.Append(char.ConvertFromUtf32(t)); } return sb.ToString().Trim(); }
diff --git a/src/SpeechRecognition/LLMIntegrated/OLMoASR.cs b/src/SpeechRecognition/LLMIntegrated/OLMoASR.cs
index d60d174693..80e4f607a8 100644
--- a/src/SpeechRecognition/LLMIntegrated/OLMoASR.cs
+++ b/src/SpeechRecognition/LLMIntegrated/OLMoASR.cs
@@ -42,7 +42,7 @@ namespace AiDotNet.SpeechRecognition.LLMIntegrated;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("OLMo: Accelerating the Science of Language Models", "https://arxiv.org/abs/2402.00838", Year = 2024, Authors = "Groeneveld et al.")]
-public class OLMoASR<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
+public partial class OLMoASR<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
 {
     private readonly OLMoASROptions _options; public override ModelOptions GetOptions() => _options;
     private IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer; private bool _useNativeMode; private bool _disposed;
@@ -103,9 +103,8 @@ public TranscriptionResult<T> Transcribe(Tensor<T> audio, string? language = nul
     protected override bool SupportsParameterMutation => _useNativeMode;
     protected override Tensor<T> PostprocessOutput(Tensor<T> o) => o;
     public override ModelMetadata<T> GetModelMetadata() => new() { Name = _useNativeMode ? "OLMoASR-Native" : "OLMoASR-ONNX", Description = "OLMo-ASR: OLMo LLM + speech adapter (AI2, 2024)", FeatureCount = _options.NumMels, Complexity = _options.NumEncoderLayers, AdditionalInfo = BaseAudioMetadataInfo() };
-    protected override void SerializeNetworkSpecificData(BinaryWriter w) { w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty); w.Write(_options.SampleRate); w.Write(_options.EncoderDim); w.Write(_options.NumEncoderLayers); w.Write(_options.NumAttentionHeads); w.Write(_options.NumMels); w.Write(_options.VocabSize); w.Write(_options.MaxTextLength); w.Write(_options.DropoutRate); w.Write(_options.Language); }
-    protected override void DeserializeNetworkSpecificData(BinaryReader r) { _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp; _options.SampleRate = r.ReadInt32(); _options.EncoderDim = r.ReadInt32(); _options.NumEncoderLayers = r.ReadInt32(); _options.NumAttentionHeads = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.VocabSize = r.ReadInt32(); _options.MaxTextLength = r.ReadInt32(); _options.DropoutRate = r.ReadDouble(); _options.Language = r.ReadString(); base.SampleRate = _options.SampleRate; base.NumMels = _options.NumMels; if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions); }
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() { if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp)) return new OLMoASR<T>(Architecture, mp, _options); return new OLMoASR<T>(Architecture, _options); }
+
+
 
     private (List<int> tokens, double confidence) CTCGreedyDecodeWithConfidence(Tensor<T> logits) { var tokens = new List<int>(); double totalConf = 0; int confCount = 0; int prevToken = -1; int numFrames = logits.Rank >= 2 ? logits.Shape[0] : 1; int vocabSize = logits.Rank >= 2 ? logits.Shape[^1] : logits.Shape[0]; for (int t = 0; t < numFrames && tokens.Count < _options.MaxTextLength; t++) { int maxIdx = 0; double maxVal = double.NegativeInfinity; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); if (val > maxVal) { maxVal = val; maxIdx = v; } } double sumExp = 0; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); sumExp += Math.Exp(val - maxVal); } double frameConf = 1.0 / sumExp; if (maxIdx != prevToken && maxIdx > 0) { tokens.Add(maxIdx); totalConf += frameConf; confCount++; } prevToken = maxIdx; } return (tokens, confCount > 0 ? totalConf / confCount : 0.0); }
     private static string TokensToText(List<int> tokens) { var sb = new System.Text.StringBuilder(); foreach (var t in tokens) { if (t > 0 && t <= char.MaxValue) sb.Append((char)t); else if (t > char.MaxValue && t <= 0x10FFFF) sb.Append(char.ConvertFromUtf32(t)); } return sb.ToString().Trim(); }
diff --git a/src/SpeechRecognition/LLMIntegrated/Phi4Audio.cs b/src/SpeechRecognition/LLMIntegrated/Phi4Audio.cs
index 3595fd1bf7..f04ae0aefe 100644
--- a/src/SpeechRecognition/LLMIntegrated/Phi4Audio.cs
+++ b/src/SpeechRecognition/LLMIntegrated/Phi4Audio.cs
@@ -129,15 +129,8 @@ public override void Train(Tensor<T> input, Tensor<T> expected)
     protected override bool SupportsParameterMutation => _useNativeMode;
     protected override Tensor<T> PostprocessOutput(Tensor<T> o) => o;
     public override ModelMetadata<T> GetModelMetadata() => new() { Name = _useNativeMode ? "Phi4Audio-Native" : "Phi4Audio-ONNX", Description = "Phi-4 Audio: Mixture-of-LoRA speech adapter (Microsoft, 2025)", FeatureCount = _options.NumMels, Complexity = _options.NumEncoderLayers, AdditionalInfo = BaseAudioMetadataInfo() };
-    protected override void SerializeNetworkSpecificData(BinaryWriter w) { w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty); w.Write(_options.SampleRate); w.Write(_options.MaxAudioLengthSeconds); w.Write(_options.EncoderDim); w.Write(_options.NumEncoderLayers); w.Write(_options.NumAttentionHeads); w.Write(_options.NumMels); w.Write(_options.VocabSize); w.Write(_options.MaxTextLength); w.Write(_options.DropoutRate); w.Write(_options.Language); }
-    protected override void DeserializeNetworkSpecificData(BinaryReader r) { _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp; _options.SampleRate = r.ReadInt32(); _options.MaxAudioLengthSeconds = r.ReadInt32(); _options.EncoderDim = r.ReadInt32(); _options.NumEncoderLayers = r.ReadInt32(); _options.NumAttentionHeads = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.VocabSize = r.ReadInt32(); _options.MaxTextLength = r.ReadInt32(); _options.DropoutRate = r.ReadDouble(); _options.Language = r.ReadString(); base.SampleRate = _options.SampleRate; base.NumMels = _options.NumMels; if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions); }
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var options = new Phi4AudioOptions(_options);
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new Phi4Audio<T>(Architecture, mp, options);
-        return new Phi4Audio<T>(Architecture, options);
-    }
+
+
 
     private (List<int> tokens, double confidence) CTCGreedyDecodeWithConfidence(Tensor<T> logits) { var tokens = new List<int>(); double totalConf = 0; int confCount = 0; int prevToken = -1; int numFrames = logits.Rank >= 2 ? logits.Shape[0] : 1; int vocabSize = logits.Rank >= 2 ? logits.Shape[^1] : logits.Shape[0]; for (int t = 0; t < numFrames && tokens.Count < _options.MaxTextLength; t++) { int maxIdx = 0; double maxVal = double.NegativeInfinity; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); if (val > maxVal) { maxVal = val; maxIdx = v; } } double sumExp = 0; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); sumExp += Math.Exp(val - maxVal); } double frameConf = 1.0 / sumExp; if (maxIdx != prevToken && maxIdx > 0) { tokens.Add(maxIdx); totalConf += frameConf; confCount++; } prevToken = maxIdx; } return (tokens, confCount > 0 ? totalConf / confCount : 0.0); }
     private static string TokensToText(List<int> tokens) { var sb = new System.Text.StringBuilder(); foreach (var t in tokens) { if (t > 0 && t <= char.MaxValue) sb.Append((char)t); else if (t > char.MaxValue && t <= 0x10FFFF) sb.Append(char.ConvertFromUtf32(t)); } return sb.ToString().Trim(); }
diff --git a/src/SpeechRecognition/LLMIntegrated/SALM.cs b/src/SpeechRecognition/LLMIntegrated/SALM.cs
index 6f8985afc6..7cbd5335bb 100644
--- a/src/SpeechRecognition/LLMIntegrated/SALM.cs
+++ b/src/SpeechRecognition/LLMIntegrated/SALM.cs
@@ -42,7 +42,7 @@ namespace AiDotNet.SpeechRecognition.LLMIntegrated;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("SALM: Speech-augmented Language Model with In-context Learning for Speech Recognition", "https://arxiv.org/abs/2310.09424", Year = 2024, Authors = "Chen et al.")]
-public class SALM<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
+public partial class SALM<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
 {
     private readonly SALMOptions _options; public override ModelOptions GetOptions() => _options;
     private IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer; private bool _useNativeMode; private bool _disposed;
@@ -108,9 +108,8 @@ public TranscriptionResult<T> Transcribe(Tensor<T> audio, string? language = nul
     protected override bool SupportsParameterMutation => _useNativeMode;
     protected override Tensor<T> PostprocessOutput(Tensor<T> o) => o;
     public override ModelMetadata<T> GetModelMetadata() => new() { Name = _useNativeMode ? "SALM-Native" : "SALM-ONNX", Description = "SALM: speech-augmented LLM with in-context learning (NVIDIA, 2024)", FeatureCount = _options.NumMels, Complexity = _options.NumEncoderLayers, AdditionalInfo = BaseAudioMetadataInfo() };
-    protected override void SerializeNetworkSpecificData(BinaryWriter w) { w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty); w.Write(_options.SampleRate); w.Write(_options.MaxAudioLengthSeconds); w.Write(_options.EncoderDim); w.Write(_options.NumEncoderLayers); w.Write(_options.NumAttentionHeads); w.Write(_options.NumMels); w.Write(_options.VocabSize); w.Write(_options.MaxTextLength); w.Write(_options.DropoutRate); w.Write(_options.Language); }
-    protected override void DeserializeNetworkSpecificData(BinaryReader r) { _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp; _options.SampleRate = r.ReadInt32(); _options.MaxAudioLengthSeconds = r.ReadInt32(); _options.EncoderDim = r.ReadInt32(); _options.NumEncoderLayers = r.ReadInt32(); _options.NumAttentionHeads = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.VocabSize = r.ReadInt32(); _options.MaxTextLength = r.ReadInt32(); _options.DropoutRate = r.ReadDouble(); _options.Language = r.ReadString(); base.SampleRate = _options.SampleRate; base.NumMels = _options.NumMels; if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions); }
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() { if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp)) return new SALM<T>(Architecture, mp, _options); return new SALM<T>(Architecture, _options); }
+
+
 
     private (List<int> tokens, double confidence) CTCGreedyDecodeWithConfidence(Tensor<T> logits) { var tokens = new List<int>(); double totalConf = 0; int confCount = 0; int prevToken = -1; int numFrames = logits.Rank >= 2 ? logits.Shape[0] : 1; int vocabSize = logits.Rank >= 2 ? logits.Shape[^1] : logits.Shape[0]; for (int t = 0; t < numFrames && tokens.Count < _options.MaxTextLength; t++) { int maxIdx = 0; double maxVal = double.NegativeInfinity; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); if (val > maxVal) { maxVal = val; maxIdx = v; } } double sumExp = 0; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); sumExp += Math.Exp(val - maxVal); } double frameConf = 1.0 / sumExp; if (maxIdx != prevToken && maxIdx > 0) { tokens.Add(maxIdx); totalConf += frameConf; confCount++; } prevToken = maxIdx; } return (tokens, confCount > 0 ? totalConf / confCount : 0.0); }
     private static string TokensToText(List<int> tokens) { var sb = new System.Text.StringBuilder(); foreach (var t in tokens) { if (t > 0 && t <= char.MaxValue) sb.Append((char)t); else if (t > char.MaxValue && t <= 0x10FFFF) sb.Append(char.ConvertFromUtf32(t)); } return sb.ToString().Trim(); }
diff --git a/src/SpeechRecognition/LLMIntegrated/SambaASR.cs b/src/SpeechRecognition/LLMIntegrated/SambaASR.cs
index c1837c439e..0db6bb4674 100644
--- a/src/SpeechRecognition/LLMIntegrated/SambaASR.cs
+++ b/src/SpeechRecognition/LLMIntegrated/SambaASR.cs
@@ -41,7 +41,7 @@ namespace AiDotNet.SpeechRecognition.LLMIntegrated;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("SAMBA-ASR: State-of-the-Art Speech Recognition Leveraging Structured State-Space Models", "https://arxiv.org/abs/2501.02832", Year = 2025, Authors = "Yadav et al.")]
-public class SambaASR<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
+public partial class SambaASR<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
 {
     private readonly SambaASROptions _options; public override ModelOptions GetOptions() => _options;
     private IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer; private bool _useNativeMode; private bool _disposed;
@@ -102,9 +102,8 @@ public TranscriptionResult<T> Transcribe(Tensor<T> audio, string? language = nul
     protected override bool SupportsParameterMutation => _useNativeMode;
     protected override Tensor<T> PostprocessOutput(Tensor<T> o) => o;
     public override ModelMetadata<T> GetModelMetadata() => new() { Name = _useNativeMode ? "SambaASR-Native" : "SambaASR-ONNX", Description = "Samba-ASR: Mamba SSM encoder + CTC (2024)", FeatureCount = _options.NumMels, Complexity = _options.NumEncoderLayers, AdditionalInfo = BaseAudioMetadataInfo() };
-    protected override void SerializeNetworkSpecificData(BinaryWriter w) { w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty); w.Write(_options.SampleRate); w.Write(_options.MaxAudioLengthSeconds); w.Write(_options.EncoderDim); w.Write(_options.NumEncoderLayers); w.Write(_options.NumAttentionHeads); w.Write(_options.NumMels); w.Write(_options.VocabSize); w.Write(_options.MaxTextLength); w.Write(_options.DropoutRate); w.Write(_options.Language); }
-    protected override void DeserializeNetworkSpecificData(BinaryReader r) { _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp; _options.SampleRate = r.ReadInt32(); _options.MaxAudioLengthSeconds = r.ReadInt32(); _options.EncoderDim = r.ReadInt32(); _options.NumEncoderLayers = r.ReadInt32(); _options.NumAttentionHeads = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.VocabSize = r.ReadInt32(); _options.MaxTextLength = r.ReadInt32(); _options.DropoutRate = r.ReadDouble(); _options.Language = r.ReadString(); base.SampleRate = _options.SampleRate; base.NumMels = _options.NumMels; if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions); }
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() { if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp)) return new SambaASR<T>(Architecture, mp, _options); return new SambaASR<T>(Architecture, _options); }
+
+
 
     private (List<int> tokens, double confidence) CTCGreedyDecodeWithConfidence(Tensor<T> logits) { var tokens = new List<int>(); double totalConf = 0; int confCount = 0; int prevToken = -1; int numFrames = logits.Rank >= 2 ? logits.Shape[0] : 1; int vocabSize = logits.Rank >= 2 ? logits.Shape[^1] : logits.Shape[0]; for (int t = 0; t < numFrames && tokens.Count < _options.MaxTextLength; t++) { int maxIdx = 0; double maxVal = double.NegativeInfinity; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); if (val > maxVal) { maxVal = val; maxIdx = v; } } double sumExp = 0; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); sumExp += Math.Exp(val - maxVal); } double frameConf = 1.0 / sumExp; if (maxIdx != prevToken && maxIdx > 0) { tokens.Add(maxIdx); totalConf += frameConf; confCount++; } prevToken = maxIdx; } return (tokens, confCount > 0 ? totalConf / confCount : 0.0); }
     private static string TokensToText(List<int> tokens) { var sb = new System.Text.StringBuilder(); foreach (var t in tokens) { if (t > 0 && t <= char.MaxValue) sb.Append((char)t); else if (t > char.MaxValue && t <= 0x10FFFF) sb.Append(char.ConvertFromUtf32(t)); } return sb.ToString().Trim(); }
diff --git a/src/SpeechRecognition/LLMIntegrated/SeedASR.cs b/src/SpeechRecognition/LLMIntegrated/SeedASR.cs
index 2d5493e6b3..c80ea7dbee 100644
--- a/src/SpeechRecognition/LLMIntegrated/SeedASR.cs
+++ b/src/SpeechRecognition/LLMIntegrated/SeedASR.cs
@@ -114,9 +114,8 @@ public TranscriptionResult<T> Transcribe(Tensor<T> audio, string? language = nul
     protected override bool SupportsParameterMutation => _useNativeMode;
     protected override Tensor<T> PostprocessOutput(Tensor<T> o) => o;
     public override ModelMetadata<T> GetModelMetadata() => new() { Name = _useNativeMode ? "SeedASR-Native" : "SeedASR-ONNX", Description = "Seed-ASR: Conformer + LLM decoder (ByteDance, 2024)", FeatureCount = _options.NumMels, Complexity = _options.NumEncoderLayers, AdditionalInfo = BaseAudioMetadataInfo() };
-    protected override void SerializeNetworkSpecificData(BinaryWriter w) { w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty); w.Write(_options.SampleRate); w.Write(_options.MaxAudioLengthSeconds); w.Write(_options.EncoderDim); w.Write(_options.NumEncoderLayers); w.Write(_options.NumAttentionHeads); w.Write(_options.NumMels); w.Write(_options.VocabSize); w.Write(_options.MaxTextLength); w.Write(_options.DropoutRate); w.Write(_options.Language); }
-    protected override void DeserializeNetworkSpecificData(BinaryReader r) { _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp; _options.SampleRate = r.ReadInt32(); _options.MaxAudioLengthSeconds = r.ReadInt32(); _options.EncoderDim = r.ReadInt32(); _options.NumEncoderLayers = r.ReadInt32(); _options.NumAttentionHeads = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.VocabSize = r.ReadInt32(); _options.MaxTextLength = r.ReadInt32(); _options.DropoutRate = r.ReadDouble(); _options.Language = r.ReadString(); base.SampleRate = _options.SampleRate; base.NumMels = _options.NumMels; if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions); }
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() { var options = new SeedASROptions(_options); if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp)) return new SeedASR<T>(Architecture, mp, options); return new SeedASR<T>(Architecture, options); }
+
+
 
     private (List<int> tokens, double confidence) CTCGreedyDecodeWithConfidence(Tensor<T> logits) { var tokens = new List<int>(); double totalConf = 0; int confCount = 0; int prevToken = -1; int numFrames = logits.Rank >= 2 ? logits.Shape[0] : 1; int vocabSize = logits.Rank >= 2 ? logits.Shape[^1] : logits.Shape[0]; for (int t = 0; t < numFrames && tokens.Count < _options.MaxTextLength; t++) { int maxIdx = 0; double maxVal = double.NegativeInfinity; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); if (val > maxVal) { maxVal = val; maxIdx = v; } } double sumExp = 0; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); sumExp += Math.Exp(val - maxVal); } double frameConf = 1.0 / sumExp; if (maxIdx != prevToken && maxIdx > 0) { tokens.Add(maxIdx); totalConf += frameConf; confCount++; } prevToken = maxIdx; } return (tokens, confCount > 0 ? totalConf / confCount : 0.0); }
     private static string TokensToText(List<int> tokens) { var sb = new System.Text.StringBuilder(); foreach (var t in tokens) { if (t > 0 && t <= char.MaxValue) sb.Append((char)t); else if (t > char.MaxValue && t <= 0x10FFFF) sb.Append(char.ConvertFromUtf32(t)); } return sb.ToString().Trim(); }
diff --git a/src/SpeechRecognition/LLMIntegrated/SpeechGPTASR.cs b/src/SpeechRecognition/LLMIntegrated/SpeechGPTASR.cs
index b8729c9281..41ce163de2 100644
--- a/src/SpeechRecognition/LLMIntegrated/SpeechGPTASR.cs
+++ b/src/SpeechRecognition/LLMIntegrated/SpeechGPTASR.cs
@@ -42,7 +42,7 @@ namespace AiDotNet.SpeechRecognition.LLMIntegrated;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("SpeechGPT: Empowering Large Language Models with Intrinsic Cross-Modal Conversational Abilities", "https://arxiv.org/abs/2305.11000", Year = 2023, Authors = "Zhang et al.")]
-public class SpeechGPTASR<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
+public partial class SpeechGPTASR<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
 {
     private readonly SpeechGPTASROptions _options; public override ModelOptions GetOptions() => _options;
     private IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer; private bool _useNativeMode; private bool _disposed;
@@ -103,9 +103,8 @@ public TranscriptionResult<T> Transcribe(Tensor<T> audio, string? language = nul
     protected override bool SupportsParameterMutation => _useNativeMode;
     protected override Tensor<T> PostprocessOutput(Tensor<T> o) => o;
     public override ModelMetadata<T> GetModelMetadata() => new() { Name = _useNativeMode ? "SpeechGPTASR-Native" : "SpeechGPTASR-ONNX", Description = "SpeechGPT: discrete speech tokens + LLM (Fudan, 2023)", FeatureCount = _options.NumMels, Complexity = _options.NumEncoderLayers, AdditionalInfo = BaseAudioMetadataInfo() };
-    protected override void SerializeNetworkSpecificData(BinaryWriter w) { w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty); w.Write(_options.SampleRate); w.Write(_options.EncoderDim); w.Write(_options.NumEncoderLayers); w.Write(_options.NumAttentionHeads); w.Write(_options.NumMels); w.Write(_options.VocabSize); w.Write(_options.MaxTextLength); w.Write(_options.DropoutRate); w.Write(_options.Language); }
-    protected override void DeserializeNetworkSpecificData(BinaryReader r) { _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp; _options.SampleRate = r.ReadInt32(); _options.EncoderDim = r.ReadInt32(); _options.NumEncoderLayers = r.ReadInt32(); _options.NumAttentionHeads = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.VocabSize = r.ReadInt32(); _options.MaxTextLength = r.ReadInt32(); _options.DropoutRate = r.ReadDouble(); _options.Language = r.ReadString(); base.SampleRate = _options.SampleRate; base.NumMels = _options.NumMels; if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions); }
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() { if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp)) return new SpeechGPTASR<T>(Architecture, mp, _options); return new SpeechGPTASR<T>(Architecture, _options); }
+
+
 
     private (List<int> tokens, double confidence) CTCGreedyDecodeWithConfidence(Tensor<T> logits) { var tokens = new List<int>(); double totalConf = 0; int confCount = 0; int prevToken = -1; int numFrames = logits.Rank >= 2 ? logits.Shape[0] : 1; int vocabSize = logits.Rank >= 2 ? logits.Shape[^1] : logits.Shape[0]; for (int t = 0; t < numFrames && tokens.Count < _options.MaxTextLength; t++) { int maxIdx = 0; double maxVal = double.NegativeInfinity; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); if (val > maxVal) { maxVal = val; maxIdx = v; } } double sumExp = 0; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); sumExp += Math.Exp(val - maxVal); } double frameConf = 1.0 / sumExp; if (maxIdx != prevToken && maxIdx > 0) { tokens.Add(maxIdx); totalConf += frameConf; confCount++; } prevToken = maxIdx; } return (tokens, confCount > 0 ? totalConf / confCount : 0.0); }
     private static string TokensToText(List<int> tokens) { var sb = new System.Text.StringBuilder(); foreach (var t in tokens) { if (t > 0 && t <= char.MaxValue) sb.Append((char)t); else if (t > char.MaxValue && t <= 0x10FFFF) sb.Append(char.ConvertFromUtf32(t)); } return sb.ToString().Trim(); }
diff --git a/src/SpeechRecognition/Multilingual/Chirp.cs b/src/SpeechRecognition/Multilingual/Chirp.cs
index 64fceb5c08..abf65ca838 100644
--- a/src/SpeechRecognition/Multilingual/Chirp.cs
+++ b/src/SpeechRecognition/Multilingual/Chirp.cs
@@ -42,7 +42,7 @@ namespace AiDotNet.SpeechRecognition.Multilingual;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Google USM: Scaling Automatic Speech Recognition Beyond 100 Languages", "https://arxiv.org/abs/2303.01037", Year = 2023, Authors = "Zhang et al.")]
-public class Chirp<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
+public partial class Chirp<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
 {
     private readonly ChirpOptions _options; public override ModelOptions GetOptions() => _options;
     private IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer; private bool _useNativeMode; private bool _disposed;
@@ -139,9 +139,8 @@ public TranscriptionResult<T> Transcribe(Tensor<T> audio, string? language = nul
     protected override bool SupportsParameterMutation => _useNativeMode;
     protected override Tensor<T> PostprocessOutput(Tensor<T> o) => o;
     public override ModelMetadata<T> GetModelMetadata() => new() { Name = _useNativeMode ? "Chirp-Native" : "Chirp-ONNX", Description = "Chirp: Google Cloud production multilingual ASR (2023)", FeatureCount = _options.NumMels, Complexity = _options.NumEncoderLayers, AdditionalInfo = BaseAudioMetadataInfo() };
-    protected override void SerializeNetworkSpecificData(BinaryWriter w) { w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty); w.Write(_options.SampleRate); w.Write(_options.MaxAudioLengthSeconds); w.Write(_options.EncoderDim); w.Write(_options.NumEncoderLayers); w.Write(_options.NumAttentionHeads); w.Write(_options.NumMels); w.Write(_options.VocabSize); w.Write(_options.MaxTextLength); w.Write(_options.DropoutRate); w.Write(_options.Language); }
-    protected override void DeserializeNetworkSpecificData(BinaryReader r) { _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp; _options.SampleRate = r.ReadInt32(); _options.MaxAudioLengthSeconds = r.ReadInt32(); _options.EncoderDim = r.ReadInt32(); _options.NumEncoderLayers = r.ReadInt32(); _options.NumAttentionHeads = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.VocabSize = r.ReadInt32(); _options.MaxTextLength = r.ReadInt32(); _options.DropoutRate = r.ReadDouble(); _options.Language = r.ReadString(); base.SampleRate = _options.SampleRate; base.NumMels = _options.NumMels; if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions); }
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() { if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp)) return new Chirp<T>(Architecture, mp, _options); return new Chirp<T>(Architecture, _options); }
+
+
 
     private (List<int> tokens, double confidence) CTCGreedyDecodeWithConfidence(Tensor<T> logits) { var tokens = new List<int>(); double totalConf = 0; int confCount = 0; int prevToken = -1; int numFrames = logits.Rank >= 2 ? logits.Shape[0] : 1; int vocabSize = logits.Rank >= 2 ? logits.Shape[^1] : logits.Shape[0]; for (int t = 0; t < numFrames && tokens.Count < _options.MaxTextLength; t++) { int maxIdx = 0; double maxVal = double.NegativeInfinity; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); if (val > maxVal) { maxVal = val; maxIdx = v; } } double sumExp = 0; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); sumExp += Math.Exp(val - maxVal); } double frameConf = 1.0 / sumExp; if (maxIdx != prevToken && maxIdx > 0) { tokens.Add(maxIdx); totalConf += frameConf; confCount++; } prevToken = maxIdx; } return (tokens, confCount > 0 ? totalConf / confCount : 0.0); }
     private static string TokensToText(List<int> tokens) { var sb = new System.Text.StringBuilder(); foreach (var t in tokens) { if (t > 0 && t <= char.MaxValue) sb.Append((char)t); else if (t > char.MaxValue && t <= 0x10FFFF) sb.Append(char.ConvertFromUtf32(t)); } return sb.ToString().Trim(); }
diff --git a/src/SpeechRecognition/Multilingual/Chirp2.cs b/src/SpeechRecognition/Multilingual/Chirp2.cs
index 8bb3f39a6a..170bbf82be 100644
--- a/src/SpeechRecognition/Multilingual/Chirp2.cs
+++ b/src/SpeechRecognition/Multilingual/Chirp2.cs
@@ -113,9 +113,8 @@ public TranscriptionResult<T> Transcribe(Tensor<T> audio, string? language = nul
     protected override bool SupportsParameterMutation => _useNativeMode;
     protected override Tensor<T> PostprocessOutput(Tensor<T> o) => o;
     public override ModelMetadata<T> GetModelMetadata() => new() { Name = _useNativeMode ? "Chirp2-Native" : "Chirp2-ONNX", Description = "Chirp 2: enhanced Google Cloud multilingual ASR (2024)", FeatureCount = _options.NumMels, Complexity = _options.NumEncoderLayers, AdditionalInfo = BaseAudioMetadataInfo() };
-    protected override void SerializeNetworkSpecificData(BinaryWriter w) { w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty); w.Write(_options.SampleRate); w.Write(_options.MaxAudioLengthSeconds); w.Write(_options.EncoderDim); w.Write(_options.NumEncoderLayers); w.Write(_options.NumAttentionHeads); w.Write(_options.NumMels); w.Write(_options.VocabSize); w.Write(_options.MaxTextLength); w.Write(_options.DropoutRate); w.Write(_options.Language); }
-    protected override void DeserializeNetworkSpecificData(BinaryReader r) { _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp; _options.SampleRate = r.ReadInt32(); _options.MaxAudioLengthSeconds = r.ReadInt32(); _options.EncoderDim = r.ReadInt32(); _options.NumEncoderLayers = r.ReadInt32(); _options.NumAttentionHeads = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.VocabSize = r.ReadInt32(); _options.MaxTextLength = r.ReadInt32(); _options.DropoutRate = r.ReadDouble(); _options.Language = r.ReadString(); base.SampleRate = _options.SampleRate; base.NumMels = _options.NumMels; if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions); }
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() { if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp)) return new Chirp2<T>(Architecture, mp, new Chirp2Options(_options)); return new Chirp2<T>(Architecture, new Chirp2Options(_options)); }
+
+
 
     private (List<int> tokens, double confidence) CTCGreedyDecodeWithConfidence(Tensor<T> logits) { var tokens = new List<int>(); double totalConf = 0; int confCount = 0; int prevToken = -1; int numFrames = logits.Rank >= 2 ? logits.Shape[0] : 1; int vocabSize = logits.Rank >= 2 ? logits.Shape[^1] : logits.Shape[0]; for (int t = 0; t < numFrames && tokens.Count < _options.MaxTextLength; t++) { int maxIdx = 0; double maxVal = double.NegativeInfinity; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); if (val > maxVal) { maxVal = val; maxIdx = v; } } double sumExp = 0; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); sumExp += Math.Exp(val - maxVal); } double frameConf = 1.0 / sumExp; if (maxIdx != prevToken && maxIdx > 0) { tokens.Add(maxIdx); totalConf += frameConf; confCount++; } prevToken = maxIdx; } return (tokens, confCount > 0 ? totalConf / confCount : 0.0); }
     private static string TokensToText(List<int> tokens) { var sb = new System.Text.StringBuilder(); foreach (var t in tokens) { if (t > 0 && t <= char.MaxValue) sb.Append((char)t); else if (t > char.MaxValue && t <= 0x10FFFF) sb.Append(char.ConvertFromUtf32(t)); } return sb.ToString().Trim(); }
diff --git a/src/SpeechRecognition/Multilingual/Chirp3.cs b/src/SpeechRecognition/Multilingual/Chirp3.cs
index 596e70633f..a4893d05e4 100644
--- a/src/SpeechRecognition/Multilingual/Chirp3.cs
+++ b/src/SpeechRecognition/Multilingual/Chirp3.cs
@@ -42,7 +42,7 @@ namespace AiDotNet.SpeechRecognition.Multilingual;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Google USM: Scaling Automatic Speech Recognition Beyond 100 Languages", "https://arxiv.org/abs/2303.01037", Year = 2023, Authors = "Zhang et al.")]
-public class Chirp3<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
+public partial class Chirp3<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
 {
     private readonly Chirp3Options _options; public override ModelOptions GetOptions() => _options;
     private IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer; private bool _useNativeMode; private bool _disposed;
@@ -112,9 +112,8 @@ public TranscriptionResult<T> Transcribe(Tensor<T> audio, string? language = nul
     protected override bool SupportsParameterMutation => _useNativeMode;
     protected override Tensor<T> PostprocessOutput(Tensor<T> o) => o;
     public override ModelMetadata<T> GetModelMetadata() => new() { Name = _useNativeMode ? "Chirp3-Native" : "Chirp3-ONNX", Description = "Chirp 3: latest Google Cloud multilingual ASR (2025)", FeatureCount = _options.NumMels, Complexity = _options.NumEncoderLayers, AdditionalInfo = BaseAudioMetadataInfo() };
-    protected override void SerializeNetworkSpecificData(BinaryWriter w) { w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty); w.Write(_options.SampleRate); w.Write(_options.MaxAudioLengthSeconds); w.Write(_options.EncoderDim); w.Write(_options.NumEncoderLayers); w.Write(_options.NumAttentionHeads); w.Write(_options.NumMels); w.Write(_options.VocabSize); w.Write(_options.MaxTextLength); w.Write(_options.DropoutRate); w.Write(_options.Language); }
-    protected override void DeserializeNetworkSpecificData(BinaryReader r) { _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp; _options.SampleRate = r.ReadInt32(); _options.MaxAudioLengthSeconds = r.ReadInt32(); _options.EncoderDim = r.ReadInt32(); _options.NumEncoderLayers = r.ReadInt32(); _options.NumAttentionHeads = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.VocabSize = r.ReadInt32(); _options.MaxTextLength = r.ReadInt32(); _options.DropoutRate = r.ReadDouble(); _options.Language = r.ReadString(); base.SampleRate = _options.SampleRate; base.NumMels = _options.NumMels; if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions); }
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() { if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp)) return new Chirp3<T>(Architecture, mp, _options); return new Chirp3<T>(Architecture, _options); }
+
+
 
     private (List<int> tokens, double confidence) CTCGreedyDecodeWithConfidence(Tensor<T> logits) { var tokens = new List<int>(); double totalConf = 0; int confCount = 0; int prevToken = -1; int numFrames = logits.Rank >= 2 ? logits.Shape[0] : 1; int vocabSize = logits.Rank >= 2 ? logits.Shape[^1] : logits.Shape[0]; for (int t = 0; t < numFrames && tokens.Count < _options.MaxTextLength; t++) { int maxIdx = 0; double maxVal = double.NegativeInfinity; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); if (val > maxVal) { maxVal = val; maxIdx = v; } } double sumExp = 0; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); sumExp += Math.Exp(val - maxVal); } double frameConf = 1.0 / sumExp; if (maxIdx != prevToken && maxIdx > 0) { tokens.Add(maxIdx); totalConf += frameConf; confCount++; } prevToken = maxIdx; } return (tokens, confCount > 0 ? totalConf / confCount : 0.0); }
     private static string TokensToText(List<int> tokens) { var sb = new System.Text.StringBuilder(); foreach (var t in tokens) { if (t > 0 && t <= char.MaxValue) sb.Append((char)t); else if (t > char.MaxValue && t <= 0x10FFFF) sb.Append(char.ConvertFromUtf32(t)); } return sb.ToString().Trim(); }
diff --git a/src/SpeechRecognition/Multilingual/MMS.cs b/src/SpeechRecognition/Multilingual/MMS.cs
index d3159f7a31..5dc9579235 100644
--- a/src/SpeechRecognition/Multilingual/MMS.cs
+++ b/src/SpeechRecognition/Multilingual/MMS.cs
@@ -43,7 +43,7 @@ namespace AiDotNet.SpeechRecognition.Multilingual;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Scaling Speech Technology to 1,000+ Languages", "https://arxiv.org/abs/2305.13516", Year = 2023, Authors = "Pratap et al.")]
-public class MMS<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
+public partial class MMS<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
 {
     private readonly MMSOptions _options;
     private IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer;
@@ -119,9 +119,8 @@ public IReadOnlyDictionary<string, T> DetectLanguageProbabilities(Tensor<T> audi
     protected override bool SupportsParameterMutation => _useNativeMode;
     protected override Tensor<T> PostprocessOutput(Tensor<T> o) => o;
     public override ModelMetadata<T> GetModelMetadata() => new() { Name = _useNativeMode ? "MMS-Native" : "MMS-ONNX", Description = "MMS: 1100+ language SSL + CTC (Meta, 2023)", FeatureCount = _options.NumMels, Complexity = _options.NumEncoderLayers, AdditionalInfo = BaseAudioMetadataInfo() };
-    protected override void SerializeNetworkSpecificData(BinaryWriter w) { w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty); w.Write(_options.SampleRate); w.Write(_options.MaxAudioLengthSeconds); w.Write(_options.EncoderDim); w.Write(_options.NumEncoderLayers); w.Write(_options.NumAttentionHeads); w.Write(_options.NumMels); w.Write(_options.VocabSize); w.Write(_options.MaxTextLength); w.Write(_options.DropoutRate); w.Write(_options.Language); }
-    protected override void DeserializeNetworkSpecificData(BinaryReader r) { _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp; _options.SampleRate = r.ReadInt32(); _options.MaxAudioLengthSeconds = r.ReadInt32(); _options.EncoderDim = r.ReadInt32(); _options.NumEncoderLayers = r.ReadInt32(); _options.NumAttentionHeads = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.VocabSize = r.ReadInt32(); _options.MaxTextLength = r.ReadInt32(); _options.DropoutRate = r.ReadDouble(); _options.Language = r.ReadString(); base.SampleRate = _options.SampleRate; base.NumMels = _options.NumMels; if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions); }
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() { if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp)) return new MMS<T>(Architecture, mp, _options); return new MMS<T>(Architecture, _options); }
+
+
 
     private (List<int> tokens, double confidence) CTCGreedyDecodeWithConfidence(Tensor<T> logits) { var tokens = new List<int>(); double totalConf = 0; int confCount = 0; int prevToken = -1; int numFrames = logits.Rank >= 2 ? logits.Shape[0] : 1; int vocabSize = logits.Rank >= 2 ? logits.Shape[^1] : logits.Shape[0]; for (int t = 0; t < numFrames && tokens.Count < _options.MaxTextLength; t++) { int maxIdx = 0; double maxVal = double.NegativeInfinity; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); if (val > maxVal) { maxVal = val; maxIdx = v; } } double sumExp = 0; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); sumExp += Math.Exp(val - maxVal); } double frameConf = 1.0 / sumExp; if (maxIdx != prevToken && maxIdx > 0) { tokens.Add(maxIdx); totalConf += frameConf; confCount++; } prevToken = maxIdx; } return (tokens, confCount > 0 ? totalConf / confCount : 0.0); }
     private static string TokensToText(List<int> tokens) { var sb = new System.Text.StringBuilder(); foreach (var t in tokens) { if (t > 0 && t <= char.MaxValue) sb.Append((char)t); else if (t > char.MaxValue && t <= 0x10FFFF) sb.Append(char.ConvertFromUtf32(t)); } return sb.ToString().Trim(); }
diff --git a/src/SpeechRecognition/Multilingual/OWSM.cs b/src/SpeechRecognition/Multilingual/OWSM.cs
index 364ec7612d..87496de88a 100644
--- a/src/SpeechRecognition/Multilingual/OWSM.cs
+++ b/src/SpeechRecognition/Multilingual/OWSM.cs
@@ -125,15 +125,8 @@ public override void Train(Tensor<T> input, Tensor<T> expected)
     protected override bool SupportsParameterMutation => _useNativeMode;
     protected override Tensor<T> PostprocessOutput(Tensor<T> o) => o;
     public override ModelMetadata<T> GetModelMetadata() => new() { Name = _useNativeMode ? "OWSM-Native" : "OWSM-ONNX", Description = "OWSM: open Whisper-style multilingual ASR (CMU, 2024)", FeatureCount = _options.NumMels, Complexity = _options.NumEncoderLayers, AdditionalInfo = BaseAudioMetadataInfo() };
-    protected override void SerializeNetworkSpecificData(BinaryWriter w) { w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty); w.Write(_options.SampleRate); w.Write(_options.EncoderDim); w.Write(_options.NumEncoderLayers); w.Write(_options.NumAttentionHeads); w.Write(_options.NumMels); w.Write(_options.VocabSize); w.Write(_options.MaxTextLength); w.Write(_options.DropoutRate); w.Write(_options.Language); }
-    protected override void DeserializeNetworkSpecificData(BinaryReader r) { _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp; _options.SampleRate = r.ReadInt32(); _options.EncoderDim = r.ReadInt32(); _options.NumEncoderLayers = r.ReadInt32(); _options.NumAttentionHeads = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.VocabSize = r.ReadInt32(); _options.MaxTextLength = r.ReadInt32(); _options.DropoutRate = r.ReadDouble(); _options.Language = r.ReadString(); base.SampleRate = _options.SampleRate; base.NumMels = _options.NumMels; if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions); }
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var options = new OWSMOptions(_options);
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new OWSM<T>(Architecture, mp, options);
-        return new OWSM<T>(Architecture, options);
-    }
+
+
 
     private (List<int> tokens, double confidence) CTCGreedyDecodeWithConfidence(Tensor<T> logits) { var tokens = new List<int>(); double totalConf = 0; int confCount = 0; int prevToken = -1; int numFrames = logits.Rank >= 2 ? logits.Shape[0] : 1; int vocabSize = logits.Rank >= 2 ? logits.Shape[^1] : logits.Shape[0]; for (int t = 0; t < numFrames && tokens.Count < _options.MaxTextLength; t++) { int maxIdx = 0; double maxVal = double.NegativeInfinity; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); if (val > maxVal) { maxVal = val; maxIdx = v; } } double sumExp = 0; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); sumExp += Math.Exp(val - maxVal); } double frameConf = 1.0 / sumExp; if (maxIdx != prevToken && maxIdx > 0) { tokens.Add(maxIdx); totalConf += frameConf; confCount++; } prevToken = maxIdx; } return (tokens, confCount > 0 ? totalConf / confCount : 0.0); }
     private static string TokensToText(List<int> tokens) { var sb = new System.Text.StringBuilder(); foreach (var t in tokens) { if (t > 0 && t <= char.MaxValue) sb.Append((char)t); else if (t > char.MaxValue && t <= 0x10FFFF) sb.Append(char.ConvertFromUtf32(t)); } return sb.ToString().Trim(); }
diff --git a/src/SpeechRecognition/Multilingual/OmnilangualASR.cs b/src/SpeechRecognition/Multilingual/OmnilangualASR.cs
index b852ac565c..fd73fc8d23 100644
--- a/src/SpeechRecognition/Multilingual/OmnilangualASR.cs
+++ b/src/SpeechRecognition/Multilingual/OmnilangualASR.cs
@@ -43,7 +43,7 @@ namespace AiDotNet.SpeechRecognition.Multilingual;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Scaling Speech Technology to 1,000+ Languages", "https://arxiv.org/abs/2305.13516", Year = 2023, Authors = "Pratap et al.")]
-public class OmnilangualASR<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
+public partial class OmnilangualASR<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
 {
     private readonly OmnilangualASROptions _options; public override ModelOptions GetOptions() => _options;
     private IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer; private bool _useNativeMode; private bool _disposed;
@@ -104,9 +104,8 @@ public TranscriptionResult<T> Transcribe(Tensor<T> audio, string? language = nul
     protected override bool SupportsParameterMutation => _useNativeMode;
     protected override Tensor<T> PostprocessOutput(Tensor<T> o) => o;
     public override ModelMetadata<T> GetModelMetadata() => new() { Name = _useNativeMode ? "OmnilangualASR-Native" : "OmnilangualASR-ONNX", Description = "Omnilingual ASR: universal multilingual recognition (Meta, 2024)", FeatureCount = _options.NumMels, Complexity = _options.NumEncoderLayers, AdditionalInfo = BaseAudioMetadataInfo() };
-    protected override void SerializeNetworkSpecificData(BinaryWriter w) { w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty); w.Write(_options.SampleRate); w.Write(_options.MaxAudioLengthSeconds); w.Write(_options.EncoderDim); w.Write(_options.NumEncoderLayers); w.Write(_options.NumAttentionHeads); w.Write(_options.NumMels); w.Write(_options.VocabSize); w.Write(_options.MaxTextLength); w.Write(_options.DropoutRate); w.Write(_options.Language); }
-    protected override void DeserializeNetworkSpecificData(BinaryReader r) { _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp; _options.SampleRate = r.ReadInt32(); _options.MaxAudioLengthSeconds = r.ReadInt32(); _options.EncoderDim = r.ReadInt32(); _options.NumEncoderLayers = r.ReadInt32(); _options.NumAttentionHeads = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.VocabSize = r.ReadInt32(); _options.MaxTextLength = r.ReadInt32(); _options.DropoutRate = r.ReadDouble(); _options.Language = r.ReadString(); base.SampleRate = _options.SampleRate; base.NumMels = _options.NumMels; if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions); }
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() { if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp)) return new OmnilangualASR<T>(Architecture, mp, _options); return new OmnilangualASR<T>(Architecture, _options); }
+
+
 
     private (List<int> tokens, double confidence) CTCGreedyDecodeWithConfidence(Tensor<T> logits) { var tokens = new List<int>(); double totalConf = 0; int confCount = 0; int prevToken = -1; int numFrames = logits.Rank >= 2 ? logits.Shape[0] : 1; int vocabSize = logits.Rank >= 2 ? logits.Shape[^1] : logits.Shape[0]; for (int t = 0; t < numFrames && tokens.Count < _options.MaxTextLength; t++) { int maxIdx = 0; double maxVal = double.NegativeInfinity; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); if (val > maxVal) { maxVal = val; maxIdx = v; } } double sumExp = 0; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); sumExp += Math.Exp(val - maxVal); } double frameConf = 1.0 / sumExp; if (maxIdx != prevToken && maxIdx > 0) { tokens.Add(maxIdx); totalConf += frameConf; confCount++; } prevToken = maxIdx; } return (tokens, confCount > 0 ? totalConf / confCount : 0.0); }
     private static string TokensToText(List<int> tokens) { var sb = new System.Text.StringBuilder(); foreach (var t in tokens) { if (t > 0 && t <= char.MaxValue) sb.Append((char)t); else if (t > char.MaxValue && t <= 0x10FFFF) sb.Append(char.ConvertFromUtf32(t)); } return sb.ToString().Trim(); }
diff --git a/src/SpeechRecognition/Multilingual/USM.cs b/src/SpeechRecognition/Multilingual/USM.cs
index bc8127fa90..92c8c5d129 100644
--- a/src/SpeechRecognition/Multilingual/USM.cs
+++ b/src/SpeechRecognition/Multilingual/USM.cs
@@ -43,7 +43,7 @@ namespace AiDotNet.SpeechRecognition.Multilingual;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Google USM: Scaling Automatic Speech Recognition Beyond 100 Languages", "https://arxiv.org/abs/2303.01037", Year = 2023, Authors = "Zhang et al.")]
-public class USM<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
+public partial class USM<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
 {
     private readonly USMOptions _options; public override ModelOptions GetOptions() => _options;
     private IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer; private bool _useNativeMode; private bool _disposed;
@@ -124,9 +124,8 @@ protected override Tensor<T> PredictCore(Tensor<T> input)
     protected override bool SupportsParameterMutation => _useNativeMode;
     protected override Tensor<T> PostprocessOutput(Tensor<T> o) => o;
     public override ModelMetadata<T> GetModelMetadata() => new() { Name = _useNativeMode ? "USM-Native" : "USM-ONNX", Description = "USM: 2B universal speech model for 100+ languages (Google, 2023)", FeatureCount = _options.NumMels, Complexity = _options.NumEncoderLayers, AdditionalInfo = BaseAudioMetadataInfo() };
-    protected override void SerializeNetworkSpecificData(BinaryWriter w) { w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty); w.Write(_options.SampleRate); w.Write(_options.EncoderDim); w.Write(_options.NumEncoderLayers); w.Write(_options.NumAttentionHeads); w.Write(_options.NumMels); w.Write(_options.VocabSize); w.Write(_options.MaxTextLength); w.Write(_options.DropoutRate); w.Write(_options.Language); }
-    protected override void DeserializeNetworkSpecificData(BinaryReader r) { _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp; _options.SampleRate = r.ReadInt32(); _options.EncoderDim = r.ReadInt32(); _options.NumEncoderLayers = r.ReadInt32(); _options.NumAttentionHeads = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.VocabSize = r.ReadInt32(); _options.MaxTextLength = r.ReadInt32(); _options.DropoutRate = r.ReadDouble(); _options.Language = r.ReadString(); base.SampleRate = _options.SampleRate; base.NumMels = _options.NumMels; if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions); }
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() { if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp)) return new USM<T>(Architecture, mp, _options); return new USM<T>(Architecture, _options); }
+
+
 
     private (List<int> tokens, double confidence) CTCGreedyDecodeWithConfidence(Tensor<T> logits) { var tokens = new List<int>(); double totalConf = 0; int confCount = 0; int prevToken = -1; int numFrames = logits.Rank >= 2 ? logits.Shape[0] : 1; int vocabSize = logits.Rank >= 2 ? logits.Shape[^1] : logits.Shape[0]; for (int t = 0; t < numFrames && tokens.Count < _options.MaxTextLength; t++) { int maxIdx = 0; double maxVal = double.NegativeInfinity; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); if (val > maxVal) { maxVal = val; maxIdx = v; } } double sumExp = 0; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); sumExp += Math.Exp(val - maxVal); } double frameConf = 1.0 / sumExp; if (maxIdx != prevToken && maxIdx > 0) { tokens.Add(maxIdx); totalConf += frameConf; confCount++; } prevToken = maxIdx; } return (tokens, confCount > 0 ? totalConf / confCount : 0.0); }
     private static string TokensToText(List<int> tokens) { var sb = new System.Text.StringBuilder(); foreach (var t in tokens) { if (t > 0 && t <= char.MaxValue) sb.Append((char)t); else if (t > char.MaxValue && t <= 0x10FFFF) sb.Append(char.ConvertFromUtf32(t)); } return sb.ToString().Trim(); }
diff --git a/src/SpeechRecognition/Multilingual/XLSR.cs b/src/SpeechRecognition/Multilingual/XLSR.cs
index 03c4dae1df..57271ec9c7 100644
--- a/src/SpeechRecognition/Multilingual/XLSR.cs
+++ b/src/SpeechRecognition/Multilingual/XLSR.cs
@@ -43,7 +43,7 @@ namespace AiDotNet.SpeechRecognition.Multilingual;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("XLS-R: Self-supervised Cross-lingual Speech Representation Learning at Scale", "https://arxiv.org/abs/2111.09296", Year = 2022, Authors = "Babu et al.")]
-public class XLSR<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
+public partial class XLSR<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
 {
     private readonly XLSROptions _options; public override ModelOptions GetOptions() => _options;
     private IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer; private bool _useNativeMode; private bool _disposed;
@@ -104,9 +104,8 @@ public TranscriptionResult<T> Transcribe(Tensor<T> audio, string? language = nul
     protected override bool SupportsParameterMutation => _useNativeMode;
     protected override Tensor<T> PostprocessOutput(Tensor<T> o) => o;
     public override ModelMetadata<T> GetModelMetadata() => new() { Name = _useNativeMode ? "XLSR-Native" : "XLSR-ONNX", Description = "XLS-R: cross-lingual SSL at scale + CTC (Meta, 2022)", FeatureCount = _options.NumMels, Complexity = _options.NumEncoderLayers, AdditionalInfo = BaseAudioMetadataInfo() };
-    protected override void SerializeNetworkSpecificData(BinaryWriter w) { w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty); w.Write(_options.SampleRate); w.Write(_options.EncoderDim); w.Write(_options.NumEncoderLayers); w.Write(_options.NumAttentionHeads); w.Write(_options.NumMels); w.Write(_options.VocabSize); w.Write(_options.MaxTextLength); w.Write(_options.DropoutRate); w.Write(_options.Language); }
-    protected override void DeserializeNetworkSpecificData(BinaryReader r) { _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp; _options.SampleRate = r.ReadInt32(); _options.EncoderDim = r.ReadInt32(); _options.NumEncoderLayers = r.ReadInt32(); _options.NumAttentionHeads = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.VocabSize = r.ReadInt32(); _options.MaxTextLength = r.ReadInt32(); _options.DropoutRate = r.ReadDouble(); _options.Language = r.ReadString(); base.SampleRate = _options.SampleRate; base.NumMels = _options.NumMels; if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions); }
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() { if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp)) return new XLSR<T>(Architecture, mp, _options); return new XLSR<T>(Architecture, _options); }
+
+
 
     private (List<int> tokens, double confidence) CTCGreedyDecodeWithConfidence(Tensor<T> logits) { var tokens = new List<int>(); double totalConf = 0; int confCount = 0; int prevToken = -1; int numFrames = logits.Rank >= 2 ? logits.Shape[0] : 1; int vocabSize = logits.Rank >= 2 ? logits.Shape[^1] : logits.Shape[0]; for (int t = 0; t < numFrames && tokens.Count < _options.MaxTextLength; t++) { int maxIdx = 0; double maxVal = double.NegativeInfinity; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); if (val > maxVal) { maxVal = val; maxIdx = v; } } double sumExp = 0; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); sumExp += Math.Exp(val - maxVal); } double frameConf = 1.0 / sumExp; if (maxIdx != prevToken && maxIdx > 0) { tokens.Add(maxIdx); totalConf += frameConf; confCount++; } prevToken = maxIdx; } return (tokens, confCount > 0 ? totalConf / confCount : 0.0); }
     private static string TokensToText(List<int> tokens) { var sb = new System.Text.StringBuilder(); foreach (var t in tokens) { if (t > 0 && t <= char.MaxValue) sb.Append((char)t); else if (t > char.MaxValue && t <= 0x10FFFF) sb.Append(char.ConvertFromUtf32(t)); } return sb.ToString().Trim(); }
diff --git a/src/SpeechRecognition/NeMo/CanaryFlash.cs b/src/SpeechRecognition/NeMo/CanaryFlash.cs
index 52dd3fb003..a66534ae78 100644
--- a/src/SpeechRecognition/NeMo/CanaryFlash.cs
+++ b/src/SpeechRecognition/NeMo/CanaryFlash.cs
@@ -46,7 +46,7 @@ namespace AiDotNet.SpeechRecognition.NeMo;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Fast Conformer with Linearly Scalable Attention for Efficient Speech Recognition", "https://arxiv.org/abs/2305.05084", Year = 2023, Authors = "Rekesh et al.")]
-public class CanaryFlash<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
+public partial class CanaryFlash<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
 {
     private readonly CanaryFlashOptions _options; public override ModelOptions GetOptions() => _options;
     private IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer; private bool _useNativeMode; private bool _disposed;
@@ -110,9 +110,8 @@ public TranscriptionResult<T> Transcribe(Tensor<T> audio, string? language = nul
     protected override bool SupportsParameterMutation => _useNativeMode;
     protected override Tensor<T> PostprocessOutput(Tensor<T> o) => o;
     public override ModelMetadata<T> GetModelMetadata() => new() { Name = _useNativeMode ? "CanaryFlash-Native" : "CanaryFlash-ONNX", Description = "Canary-Flash: lightweight multilingual ASR with hybrid CTC/attention (NVIDIA, 2025)", FeatureCount = _options.NumMels, Complexity = _options.NumEncoderLayers + _options.NumDecoderLayers, AdditionalInfo = BaseAudioMetadataInfo() };
-    protected override void SerializeNetworkSpecificData(BinaryWriter w) { w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty); w.Write(_options.SampleRate); w.Write(_options.EncoderDim); w.Write(_options.DecoderDim); w.Write(_options.NumEncoderLayers); w.Write(_options.NumDecoderLayers); w.Write(_options.NumAttentionHeads); w.Write(_options.NumMels); w.Write(_options.VocabSize); w.Write(_options.MaxTextLength); w.Write(_options.DropoutRate); w.Write(_options.Language); }
-    protected override void DeserializeNetworkSpecificData(BinaryReader r) { _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp; _options.SampleRate = r.ReadInt32(); _options.EncoderDim = r.ReadInt32(); _options.DecoderDim = r.ReadInt32(); _options.NumEncoderLayers = r.ReadInt32(); _options.NumDecoderLayers = r.ReadInt32(); _options.NumAttentionHeads = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.VocabSize = r.ReadInt32(); _options.MaxTextLength = r.ReadInt32(); _options.DropoutRate = r.ReadDouble(); _options.Language = r.ReadString(); base.SampleRate = _options.SampleRate; base.NumMels = _options.NumMels; if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions); }
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() { if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp)) return new CanaryFlash<T>(Architecture, mp, _options); return new CanaryFlash<T>(Architecture, _options); }
+
+
 
     private (List<int> tokens, double confidence) GreedyDecodeWithConfidence(Tensor<T> logits) { var tokens = new List<int>(); double totalConf = 0; int confCount = 0; int prevToken = -1; int numFrames = logits.Rank >= 2 ? logits.Shape[0] : 1; int vocabSize = logits.Rank >= 2 ? logits.Shape[^1] : logits.Shape[0]; for (int t = 0; t < numFrames && tokens.Count < _options.MaxTextLength; t++) { int maxIdx = 0; double maxVal = double.NegativeInfinity; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); if (val > maxVal) { maxVal = val; maxIdx = v; } } double sumExp = 0; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); sumExp += Math.Exp(val - maxVal); } double frameConf = 1.0 / sumExp; if (maxIdx != prevToken && maxIdx > 0) { tokens.Add(maxIdx); totalConf += frameConf; confCount++; } prevToken = maxIdx; } return (tokens, confCount > 0 ? totalConf / confCount : 0.0); }
     private static string TokensToText(List<int> tokens) { var sb = new System.Text.StringBuilder(); foreach (var t in tokens) { if (t > 0 && t <= char.MaxValue) sb.Append((char)t); else if (t > char.MaxValue && t <= 0x10FFFF) sb.Append(char.ConvertFromUtf32(t)); } return sb.ToString().Trim(); }
diff --git a/src/SpeechRecognition/NeMo/CanaryQwen.cs b/src/SpeechRecognition/NeMo/CanaryQwen.cs
index f7b70e8a36..0f6e094281 100644
--- a/src/SpeechRecognition/NeMo/CanaryQwen.cs
+++ b/src/SpeechRecognition/NeMo/CanaryQwen.cs
@@ -47,7 +47,7 @@ namespace AiDotNet.SpeechRecognition.NeMo;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Fast Conformer with Linearly Scalable Attention for Efficient Speech Recognition", "https://arxiv.org/abs/2305.05084", Year = 2023, Authors = "Rekesh et al.")]
-public class CanaryQwen<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
+public partial class CanaryQwen<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
 {
     private readonly CanaryQwenOptions _options; public override ModelOptions GetOptions() => _options;
     private IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer; private bool _useNativeMode; private bool _disposed;
@@ -112,9 +112,8 @@ public TranscriptionResult<T> Transcribe(Tensor<T> audio, string? language = nul
     protected override bool SupportsParameterMutation => _useNativeMode;
     protected override Tensor<T> PostprocessOutput(Tensor<T> o) => o;
     public override ModelMetadata<T> GetModelMetadata() => new() { Name = _useNativeMode ? "CanaryQwen-Native" : "CanaryQwen-ONNX", Description = "Canary-Qwen: multilingual ASR + translation with Qwen-2.5 LLM (NVIDIA, 2025)", FeatureCount = _options.NumMels, Complexity = _options.NumEncoderLayers + _options.NumDecoderLayers, AdditionalInfo = BaseAudioMetadataInfo() };
-    protected override void SerializeNetworkSpecificData(BinaryWriter w) { w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty); w.Write(_options.SampleRate); w.Write(_options.EncoderDim); w.Write(_options.DecoderDim); w.Write(_options.NumEncoderLayers); w.Write(_options.NumDecoderLayers); w.Write(_options.NumAttentionHeads); w.Write(_options.NumMels); w.Write(_options.VocabSize); w.Write(_options.MaxTextLength); w.Write(_options.DropoutRate); w.Write(_options.Language); }
-    protected override void DeserializeNetworkSpecificData(BinaryReader r) { _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp; _options.SampleRate = r.ReadInt32(); _options.EncoderDim = r.ReadInt32(); _options.DecoderDim = r.ReadInt32(); _options.NumEncoderLayers = r.ReadInt32(); _options.NumDecoderLayers = r.ReadInt32(); _options.NumAttentionHeads = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.VocabSize = r.ReadInt32(); _options.MaxTextLength = r.ReadInt32(); _options.DropoutRate = r.ReadDouble(); _options.Language = r.ReadString(); base.SampleRate = _options.SampleRate; base.NumMels = _options.NumMels; if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions); }
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() { if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp)) return new CanaryQwen<T>(Architecture, mp, _options); return new CanaryQwen<T>(Architecture, _options); }
+
+
 
     private (List<int> tokens, double confidence) GreedyDecodeWithConfidence(Tensor<T> logits) { var tokens = new List<int>(); double totalConf = 0; int confCount = 0; int prevToken = -1; int numFrames = logits.Rank >= 2 ? logits.Shape[0] : 1; int vocabSize = logits.Rank >= 2 ? logits.Shape[^1] : logits.Shape[0]; for (int t = 0; t < numFrames && tokens.Count < _options.MaxTextLength; t++) { int maxIdx = 0; double maxVal = double.NegativeInfinity; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); if (val > maxVal) { maxVal = val; maxIdx = v; } } double sumExp = 0; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); sumExp += Math.Exp(val - maxVal); } double frameConf = 1.0 / sumExp; if (maxIdx != prevToken && maxIdx > 0) { tokens.Add(maxIdx); totalConf += frameConf; confCount++; } prevToken = maxIdx; } return (tokens, confCount > 0 ? totalConf / confCount : 0.0); }
     private static string TokensToText(List<int> tokens) { var sb = new System.Text.StringBuilder(); foreach (var t in tokens) { if (t > 0 && t <= char.MaxValue) sb.Append((char)t); else if (t > char.MaxValue && t <= 0x10FFFF) sb.Append(char.ConvertFromUtf32(t)); } return sb.ToString().Trim(); }
diff --git a/src/SpeechRecognition/NeMo/NeMoCitrinet.cs b/src/SpeechRecognition/NeMo/NeMoCitrinet.cs
index 2efd352c37..1524c591f7 100644
--- a/src/SpeechRecognition/NeMo/NeMoCitrinet.cs
+++ b/src/SpeechRecognition/NeMo/NeMoCitrinet.cs
@@ -46,7 +46,7 @@ namespace AiDotNet.SpeechRecognition.NeMo;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Citrinet: Closing the Gap between Non-Autoregressive and Autoregressive End-to-End Models for Automatic Speech Recognition", "https://arxiv.org/abs/2104.01721", Year = 2021, Authors = "Majumdar et al.")]
-public class NeMoCitrinet<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
+public partial class NeMoCitrinet<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
 {
     private readonly NeMoCitrinetOptions _options; public override ModelOptions GetOptions() => _options;
     private IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer; private bool _useNativeMode; private bool _disposed;
@@ -109,9 +109,8 @@ public TranscriptionResult<T> Transcribe(Tensor<T> audio, string? language = nul
     protected override bool SupportsParameterMutation => _useNativeMode;
     protected override Tensor<T> PostprocessOutput(Tensor<T> o) => o;
     public override ModelMetadata<T> GetModelMetadata() => new() { Name = _useNativeMode ? "NeMoCitrinet-Native" : "NeMoCitrinet-ONNX", Description = "Citrinet: 1D time-channel separable conv CTC with SE (NVIDIA, 2021)", FeatureCount = _options.NumMels, Complexity = _options.NumEncoderLayers, AdditionalInfo = BaseAudioMetadataInfo() };
-    protected override void SerializeNetworkSpecificData(BinaryWriter w) { w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty); w.Write(_options.SampleRate); w.Write(_options.MaxAudioLengthSeconds); w.Write(_options.EncoderDim); w.Write(_options.NumEncoderLayers); w.Write(_options.NumMels); w.Write(_options.VocabSize); w.Write(_options.MaxTextLength); w.Write(_options.DropoutRate); w.Write(_options.Language); w.Write(_options.SqueezeExcitationRatio); }
-    protected override void DeserializeNetworkSpecificData(BinaryReader r) { _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp; _options.SampleRate = r.ReadInt32(); _options.MaxAudioLengthSeconds = r.ReadInt32(); _options.EncoderDim = r.ReadInt32(); _options.NumEncoderLayers = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.VocabSize = r.ReadInt32(); _options.MaxTextLength = r.ReadInt32(); _options.DropoutRate = r.ReadDouble(); _options.Language = r.ReadString(); _options.SqueezeExcitationRatio = r.ReadInt32(); base.SampleRate = _options.SampleRate; base.NumMels = _options.NumMels; if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions); }
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() { if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp)) return new NeMoCitrinet<T>(Architecture, mp, _options); return new NeMoCitrinet<T>(Architecture, _options); }
+
+
 
     private (List<int> tokens, double confidence) CTCGreedyDecodeWithConfidence(Tensor<T> logits) { var tokens = new List<int>(); double totalConf = 0; int confCount = 0; int prevToken = -1; int numFrames = logits.Rank >= 2 ? logits.Shape[0] : 1; int vocabSize = logits.Rank >= 2 ? logits.Shape[^1] : logits.Shape[0]; for (int t = 0; t < numFrames && tokens.Count < _options.MaxTextLength; t++) { int maxIdx = 0; double maxVal = double.NegativeInfinity; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); if (val > maxVal) { maxVal = val; maxIdx = v; } } double sumExp = 0; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); sumExp += Math.Exp(val - maxVal); } double frameConf = 1.0 / sumExp; if (maxIdx != prevToken && maxIdx > 0) { tokens.Add(maxIdx); totalConf += frameConf; confCount++; } prevToken = maxIdx; } return (tokens, confCount > 0 ? totalConf / confCount : 0.0); }
     private static string TokensToText(List<int> tokens) { var sb = new System.Text.StringBuilder(); foreach (var t in tokens) { if (t > 0 && t <= char.MaxValue) sb.Append((char)t); else if (t > char.MaxValue && t <= 0x10FFFF) sb.Append(char.ConvertFromUtf32(t)); } return sb.ToString().Trim(); }
diff --git a/src/SpeechRecognition/NeMo/NeMoMultitask.cs b/src/SpeechRecognition/NeMo/NeMoMultitask.cs
index f04d864c29..17a6bb92c1 100644
--- a/src/SpeechRecognition/NeMo/NeMoMultitask.cs
+++ b/src/SpeechRecognition/NeMo/NeMoMultitask.cs
@@ -46,7 +46,7 @@ namespace AiDotNet.SpeechRecognition.NeMo;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Fast Conformer with Linearly Scalable Attention for Efficient Speech Recognition", "https://arxiv.org/abs/2305.05084", Year = 2023, Authors = "Rekesh et al.")]
-public class NeMoMultitask<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
+public partial class NeMoMultitask<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
 {
     private readonly NeMoMultitaskOptions _options; public override ModelOptions GetOptions() => _options;
     private IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer; private bool _useNativeMode; private bool _disposed;
@@ -110,9 +110,8 @@ public TranscriptionResult<T> Transcribe(Tensor<T> audio, string? language = nul
     protected override bool SupportsParameterMutation => _useNativeMode;
     protected override Tensor<T> PostprocessOutput(Tensor<T> o) => o;
     public override ModelMetadata<T> GetModelMetadata() => new() { Name = _useNativeMode ? "NeMoMultitask-Native" : "NeMoMultitask-ONNX", Description = "NeMo Multitask AED: ASR + translation + language ID (NVIDIA, 2024)", FeatureCount = _options.NumMels, Complexity = _options.NumEncoderLayers + _options.NumDecoderLayers, AdditionalInfo = BaseAudioMetadataInfo() };
-    protected override void SerializeNetworkSpecificData(BinaryWriter w) { w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty); w.Write(_options.SampleRate); w.Write(_options.EncoderDim); w.Write(_options.DecoderDim); w.Write(_options.NumEncoderLayers); w.Write(_options.NumDecoderLayers); w.Write(_options.NumAttentionHeads); w.Write(_options.NumMels); w.Write(_options.VocabSize); w.Write(_options.MaxTextLength); w.Write(_options.DropoutRate); w.Write(_options.Language); }
-    protected override void DeserializeNetworkSpecificData(BinaryReader r) { _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp; _options.SampleRate = r.ReadInt32(); _options.EncoderDim = r.ReadInt32(); _options.DecoderDim = r.ReadInt32(); _options.NumEncoderLayers = r.ReadInt32(); _options.NumDecoderLayers = r.ReadInt32(); _options.NumAttentionHeads = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.VocabSize = r.ReadInt32(); _options.MaxTextLength = r.ReadInt32(); _options.DropoutRate = r.ReadDouble(); _options.Language = r.ReadString(); base.SampleRate = _options.SampleRate; base.NumMels = _options.NumMels; if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions); }
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() { if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp)) return new NeMoMultitask<T>(Architecture, mp, _options); return new NeMoMultitask<T>(Architecture, _options); }
+
+
 
     private (List<int> tokens, double confidence) GreedyDecodeWithConfidence(Tensor<T> logits) { var tokens = new List<int>(); double totalConf = 0; int confCount = 0; int prevToken = -1; int numFrames = logits.Rank >= 2 ? logits.Shape[0] : 1; int vocabSize = logits.Rank >= 2 ? logits.Shape[^1] : logits.Shape[0]; for (int t = 0; t < numFrames && tokens.Count < _options.MaxTextLength; t++) { int maxIdx = 0; double maxVal = double.NegativeInfinity; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); if (val > maxVal) { maxVal = val; maxIdx = v; } } double sumExp = 0; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); sumExp += Math.Exp(val - maxVal); } double frameConf = 1.0 / sumExp; if (maxIdx != prevToken && maxIdx > 0) { tokens.Add(maxIdx); totalConf += frameConf; confCount++; } prevToken = maxIdx; } return (tokens, confCount > 0 ? totalConf / confCount : 0.0); }
     private static string TokensToText(List<int> tokens) { var sb = new System.Text.StringBuilder(); foreach (var t in tokens) { if (t > 0 && t <= char.MaxValue) sb.Append((char)t); else if (t > char.MaxValue && t <= 0x10FFFF) sb.Append(char.ConvertFromUtf32(t)); } return sb.ToString().Trim(); }
diff --git a/src/SpeechRecognition/NeMo/NemotronSpeech.cs b/src/SpeechRecognition/NeMo/NemotronSpeech.cs
index 62edc0b3c2..f55f146f52 100644
--- a/src/SpeechRecognition/NeMo/NemotronSpeech.cs
+++ b/src/SpeechRecognition/NeMo/NemotronSpeech.cs
@@ -47,7 +47,7 @@ namespace AiDotNet.SpeechRecognition.NeMo;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Fast Conformer with Linearly Scalable Attention for Efficient Speech Recognition", "https://arxiv.org/abs/2305.05084", Year = 2023, Authors = "Rekesh et al.")]
-public class NemotronSpeech<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
+public partial class NemotronSpeech<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
 {
     private readonly NemotronSpeechOptions _options; public override ModelOptions GetOptions() => _options;
     private IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer; private bool _useNativeMode; private bool _disposed;
@@ -109,9 +109,8 @@ public TranscriptionResult<T> Transcribe(Tensor<T> audio, string? language = nul
     protected override bool SupportsParameterMutation => _useNativeMode;
     protected override Tensor<T> PostprocessOutput(Tensor<T> o) => o;
     public override ModelMetadata<T> GetModelMetadata() => new() { Name = _useNativeMode ? "NemotronSpeech-Native" : "NemotronSpeech-ONNX", Description = "Nemotron-Speech: multi-task ASR with Nemotron LLM (NVIDIA, 2025)", FeatureCount = _options.NumMels, Complexity = _options.NumEncoderLayers + _options.NumDecoderLayers, AdditionalInfo = BaseAudioMetadataInfo() };
-    protected override void SerializeNetworkSpecificData(BinaryWriter w) { w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty); w.Write(_options.SampleRate); w.Write(_options.MaxAudioLengthSeconds); w.Write(_options.EncoderDim); w.Write(_options.DecoderDim); w.Write(_options.NumEncoderLayers); w.Write(_options.NumDecoderLayers); w.Write(_options.NumAttentionHeads); w.Write(_options.NumMels); w.Write(_options.VocabSize); w.Write(_options.MaxTextLength); w.Write(_options.DropoutRate); w.Write(_options.Language); }
-    protected override void DeserializeNetworkSpecificData(BinaryReader r) { _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp; _options.SampleRate = r.ReadInt32(); _options.MaxAudioLengthSeconds = r.ReadInt32(); _options.EncoderDim = r.ReadInt32(); _options.DecoderDim = r.ReadInt32(); _options.NumEncoderLayers = r.ReadInt32(); _options.NumDecoderLayers = r.ReadInt32(); _options.NumAttentionHeads = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.VocabSize = r.ReadInt32(); _options.MaxTextLength = r.ReadInt32(); _options.DropoutRate = r.ReadDouble(); _options.Language = r.ReadString(); base.SampleRate = _options.SampleRate; base.NumMels = _options.NumMels; if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions); }
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() { if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp)) return new NemotronSpeech<T>(Architecture, mp, _options); return new NemotronSpeech<T>(Architecture, _options); }
+
+
 
     private (List<int> tokens, double confidence) GreedyDecodeWithConfidence(Tensor<T> logits) { var tokens = new List<int>(); double totalConf = 0; int confCount = 0; int prevToken = -1; int numFrames = logits.Rank >= 2 ? logits.Shape[0] : 1; int vocabSize = logits.Rank >= 2 ? logits.Shape[^1] : logits.Shape[0]; for (int t = 0; t < numFrames && tokens.Count < _options.MaxTextLength; t++) { int maxIdx = 0; double maxVal = double.NegativeInfinity; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); if (val > maxVal) { maxVal = val; maxIdx = v; } } double sumExp = 0; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); sumExp += Math.Exp(val - maxVal); } double frameConf = 1.0 / sumExp; if (maxIdx != prevToken && maxIdx > 0) { tokens.Add(maxIdx); totalConf += frameConf; confCount++; } prevToken = maxIdx; } return (tokens, confCount > 0 ? totalConf / confCount : 0.0); }
     private static string TokensToText(List<int> tokens) { var sb = new System.Text.StringBuilder(); foreach (var t in tokens) { if (t > 0 && t <= char.MaxValue) sb.Append((char)t); else if (t > char.MaxValue && t <= 0x10FFFF) sb.Append(char.ConvertFromUtf32(t)); } return sb.ToString().Trim(); }
diff --git a/src/SpeechRecognition/NeMo/ParakeetCTC.cs b/src/SpeechRecognition/NeMo/ParakeetCTC.cs
index 26b6d40406..879e8d4ae4 100644
--- a/src/SpeechRecognition/NeMo/ParakeetCTC.cs
+++ b/src/SpeechRecognition/NeMo/ParakeetCTC.cs
@@ -157,15 +157,8 @@ public override void Train(Tensor<T> input, Tensor<T> expected)
             ["Language"] = SupportedLanguages.Count > 0 ? SupportedLanguages[0] : _options.Language
         }
     };
-    protected override void SerializeNetworkSpecificData(BinaryWriter w) { w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty); w.Write(_options.SampleRate); w.Write(_options.MaxAudioLengthSeconds); w.Write(_options.EncoderDim); w.Write(_options.NumEncoderLayers); w.Write(_options.NumAttentionHeads); w.Write(_options.FeedForwardDim); w.Write(_options.NumMels); w.Write(_options.VocabSize); w.Write(_options.MaxTextLength); w.Write(_options.DropoutRate); w.Write(_options.Language); }
-    protected override void DeserializeNetworkSpecificData(BinaryReader r) { _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp; _options.SampleRate = r.ReadInt32(); _options.MaxAudioLengthSeconds = r.ReadInt32(); _options.EncoderDim = r.ReadInt32(); _options.NumEncoderLayers = r.ReadInt32(); _options.NumAttentionHeads = r.ReadInt32(); _options.FeedForwardDim = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.VocabSize = r.ReadInt32(); _options.MaxTextLength = r.ReadInt32(); _options.DropoutRate = r.ReadDouble(); _options.Language = r.ReadString(); base.SampleRate = _options.SampleRate; base.NumMels = _options.NumMels; if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions); }
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var options = new ParakeetCTCOptions(_options);
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new ParakeetCTC<T>(Architecture, mp, options);
-        return new ParakeetCTC<T>(Architecture, options);
-    }
+
+
 
     private (List<int> tokens, double confidence) CTCGreedyDecodeWithConfidence(Tensor<T> logits) { var tokens = new List<int>(); double totalConf = 0; int confCount = 0; int prevToken = -1; int numFrames = logits.Rank >= 2 ? logits.Shape[0] : 1; int vocabSize = logits.Rank >= 2 ? logits.Shape[^1] : logits.Shape[0]; for (int t = 0; t < numFrames && tokens.Count < _options.MaxTextLength; t++) { int maxIdx = 0; double maxVal = double.NegativeInfinity; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); if (val > maxVal) { maxVal = val; maxIdx = v; } } double sumExp = 0; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); sumExp += Math.Exp(val - maxVal); } double frameConf = 1.0 / sumExp; if (maxIdx != prevToken && maxIdx > 0) { tokens.Add(maxIdx); totalConf += frameConf; confCount++; } prevToken = maxIdx; } return (tokens, confCount > 0 ? totalConf / confCount : 0.0); }
     private static string TokensToText(List<int> tokens) { var sb = new System.Text.StringBuilder(); foreach (var t in tokens) { if (t > 0 && t <= char.MaxValue) sb.Append((char)t); else if (t > char.MaxValue && t <= 0x10FFFF) sb.Append(char.ConvertFromUtf32(t)); } return sb.ToString().Trim(); }
diff --git a/src/SpeechRecognition/NeMo/ParakeetRNNT.cs b/src/SpeechRecognition/NeMo/ParakeetRNNT.cs
index b33026c939..6ed7b7bb6f 100644
--- a/src/SpeechRecognition/NeMo/ParakeetRNNT.cs
+++ b/src/SpeechRecognition/NeMo/ParakeetRNNT.cs
@@ -132,15 +132,8 @@ public override void Train(Tensor<T> input, Tensor<T> expected)
     protected override bool SupportsParameterMutation => _useNativeMode;
     protected override Tensor<T> PostprocessOutput(Tensor<T> o) => o;
     public override ModelMetadata<T> GetModelMetadata() => new() { Name = _useNativeMode ? "ParakeetRNNT-Native" : "ParakeetRNNT-ONNX", Description = "Parakeet-RNNT: 1.1B Fast Conformer + RNN-T decoder (NVIDIA NeMo, 2024)", FeatureCount = _options.NumMels, Complexity = _options.NumEncoderLayers, AdditionalInfo = BaseAudioMetadataInfo() };
-    protected override void SerializeNetworkSpecificData(BinaryWriter w) { w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty); w.Write(_options.SampleRate); w.Write(_options.MaxAudioLengthSeconds); w.Write(_options.EncoderDim); w.Write(_options.PredictionDim); w.Write(_options.JointDim); w.Write(_options.NumEncoderLayers); w.Write(_options.NumAttentionHeads); w.Write(_options.FeedForwardDim); w.Write(_options.NumMels); w.Write(_options.VocabSize); w.Write(_options.MaxTextLength); w.Write(_options.DropoutRate); w.Write(_options.Language); }
-    protected override void DeserializeNetworkSpecificData(BinaryReader r) { _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp; _options.SampleRate = r.ReadInt32(); _options.MaxAudioLengthSeconds = r.ReadInt32(); _options.EncoderDim = r.ReadInt32(); _options.PredictionDim = r.ReadInt32(); _options.JointDim = r.ReadInt32(); _options.NumEncoderLayers = r.ReadInt32(); _options.NumAttentionHeads = r.ReadInt32(); _options.FeedForwardDim = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.VocabSize = r.ReadInt32(); _options.MaxTextLength = r.ReadInt32(); _options.DropoutRate = r.ReadDouble(); _options.Language = r.ReadString(); base.SampleRate = _options.SampleRate; base.NumMels = _options.NumMels; if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions); }
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var options = new ParakeetRNNTOptions(_options);
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new ParakeetRNNT<T>(Architecture, mp, options);
-        return new ParakeetRNNT<T>(Architecture, options);
-    }
+
+
 
     private (List<int> tokens, double confidence) TransducerGreedyDecodeWithConfidence(Tensor<T> logits) { var tokens = new List<int>(); double totalConf = 0; int confCount = 0; int prevToken = -1; int numFrames = logits.Rank >= 2 ? logits.Shape[0] : 1; int vocabSize = logits.Rank >= 2 ? logits.Shape[^1] : logits.Shape[0]; for (int t = 0; t < numFrames && tokens.Count < _options.MaxTextLength; t++) { int maxIdx = 0; double maxVal = double.NegativeInfinity; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); if (val > maxVal) { maxVal = val; maxIdx = v; } } double sumExp = 0; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); sumExp += Math.Exp(val - maxVal); } double frameConf = 1.0 / sumExp; if (maxIdx != prevToken && maxIdx > 0) { tokens.Add(maxIdx); totalConf += frameConf; confCount++; } prevToken = maxIdx; } return (tokens, confCount > 0 ? totalConf / confCount : 0.0); }
     private static string TokensToText(List<int> tokens) { var sb = new System.Text.StringBuilder(); foreach (var t in tokens) { if (t > 0 && t <= char.MaxValue) sb.Append((char)t); else if (t > char.MaxValue && t <= 0x10FFFF) sb.Append(char.ConvertFromUtf32(t)); } return sb.ToString().Trim(); }
diff --git a/src/SpeechRecognition/NeMo/ParakeetTDT.cs b/src/SpeechRecognition/NeMo/ParakeetTDT.cs
index 3a56d86eef..0d26b6f149 100644
--- a/src/SpeechRecognition/NeMo/ParakeetTDT.cs
+++ b/src/SpeechRecognition/NeMo/ParakeetTDT.cs
@@ -46,7 +46,7 @@ namespace AiDotNet.SpeechRecognition.NeMo;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Efficient Sequence Transduction by Jointly Predicting Tokens and Durations", "https://arxiv.org/abs/2304.06795", Year = 2023, Authors = "Xu et al.")]
-public class ParakeetTDT<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
+public partial class ParakeetTDT<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
 {
     private readonly ParakeetTDTOptions _options; public override ModelOptions GetOptions() => _options;
     private IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer; private bool _useNativeMode; private bool _disposed;
@@ -115,15 +115,8 @@ public override void Train(Tensor<T> input, Tensor<T> expected)
     protected override bool SupportsParameterMutation => _useNativeMode;
     protected override Tensor<T> PostprocessOutput(Tensor<T> o) => o;
     public override ModelMetadata<T> GetModelMetadata() => new() { Name = _useNativeMode ? "ParakeetTDT-Native" : "ParakeetTDT-ONNX", Description = "Parakeet-TDT: 1.1B Fast Conformer + Token-and-Duration Transducer (NVIDIA, 2024)", FeatureCount = _options.NumMels, Complexity = _options.NumEncoderLayers, AdditionalInfo = BaseAudioMetadataInfo() };
-    protected override void SerializeNetworkSpecificData(BinaryWriter w) { w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty); w.Write(_options.SampleRate); w.Write(_options.MaxAudioLengthSeconds); w.Write(_options.EncoderDim); w.Write(_options.PredictionDim); w.Write(_options.JointDim); w.Write(_options.NumEncoderLayers); w.Write(_options.NumAttentionHeads); w.Write(_options.FeedForwardDim); w.Write(_options.NumMels); w.Write(_options.VocabSize); w.Write(_options.MaxTextLength); w.Write(_options.DropoutRate); w.Write(_options.Language); w.Write(_options.MaxDurationTokens); }
-    protected override void DeserializeNetworkSpecificData(BinaryReader r) { _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp; _options.SampleRate = r.ReadInt32(); _options.MaxAudioLengthSeconds = r.ReadInt32(); _options.EncoderDim = r.ReadInt32(); _options.PredictionDim = r.ReadInt32(); _options.JointDim = r.ReadInt32(); _options.NumEncoderLayers = r.ReadInt32(); _options.NumAttentionHeads = r.ReadInt32(); _options.FeedForwardDim = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.VocabSize = r.ReadInt32(); _options.MaxTextLength = r.ReadInt32(); _options.DropoutRate = r.ReadDouble(); _options.Language = r.ReadString(); _options.MaxDurationTokens = r.ReadInt32(); base.SampleRate = _options.SampleRate; base.NumMels = _options.NumMels; if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions); }
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var copiedOptions = new ParakeetTDTOptions(_options);
-        if (!_useNativeMode && copiedOptions.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new ParakeetTDT<T>(Architecture, mp, copiedOptions);
-        return new ParakeetTDT<T>(Architecture, copiedOptions);
-    }
+
+
 
     /// <summary>
     /// TDT greedy decode with confidence: emits token + skips frames based on duration prediction.
diff --git a/src/SpeechRecognition/ProprietaryAPI/AWSTranscribe.cs b/src/SpeechRecognition/ProprietaryAPI/AWSTranscribe.cs
index 8fe746070e..8aa01c77dd 100644
--- a/src/SpeechRecognition/ProprietaryAPI/AWSTranscribe.cs
+++ b/src/SpeechRecognition/ProprietaryAPI/AWSTranscribe.cs
@@ -41,7 +41,7 @@ namespace AiDotNet.SpeechRecognition.ProprietaryAPI;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Amazon Transcribe", "https://aws.amazon.com/transcribe/")]
-public class AWSTranscribe<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
+public partial class AWSTranscribe<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
 {
     private readonly AWSTranscribeOptions _options; public override ModelOptions GetOptions() => _options;
     private IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer; private bool _useNativeMode; private bool _disposed;
@@ -102,9 +102,8 @@ public TranscriptionResult<T> Transcribe(Tensor<T> audio, string? language = nul
     protected override bool SupportsParameterMutation => _useNativeMode;
     protected override Tensor<T> PostprocessOutput(Tensor<T> o) => o;
     public override ModelMetadata<T> GetModelMetadata() => new() { Name = _useNativeMode ? "AWSTranscribe-Native" : "AWSTranscribe-ONNX", Description = "AWS Transcribe: scalable cloud ASR (Amazon, 2024)", FeatureCount = _options.NumMels, Complexity = _options.NumEncoderLayers, AdditionalInfo = BaseAudioMetadataInfo() };
-    protected override void SerializeNetworkSpecificData(BinaryWriter w) { w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty); w.Write(_options.SampleRate); w.Write(_options.EncoderDim); w.Write(_options.NumEncoderLayers); w.Write(_options.NumAttentionHeads); w.Write(_options.NumMels); w.Write(_options.VocabSize); w.Write(_options.MaxTextLength); w.Write(_options.DropoutRate); w.Write(_options.Language); }
-    protected override void DeserializeNetworkSpecificData(BinaryReader r) { _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp; _options.SampleRate = r.ReadInt32(); _options.EncoderDim = r.ReadInt32(); _options.NumEncoderLayers = r.ReadInt32(); _options.NumAttentionHeads = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.VocabSize = r.ReadInt32(); _options.MaxTextLength = r.ReadInt32(); _options.DropoutRate = r.ReadDouble(); _options.Language = r.ReadString(); base.SampleRate = _options.SampleRate; base.NumMels = _options.NumMels; if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions); }
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() { if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp)) return new AWSTranscribe<T>(Architecture, mp, _options); return new AWSTranscribe<T>(Architecture, _options); }
+
+
 
     private (List<int> tokens, double confidence) CTCGreedyDecodeWithConfidence(Tensor<T> logits) { var tokens = new List<int>(); double totalConf = 0; int confCount = 0; int prevToken = -1; int numFrames = logits.Rank >= 2 ? logits.Shape[0] : 1; int vocabSize = logits.Rank >= 2 ? logits.Shape[^1] : logits.Shape[0]; for (int t = 0; t < numFrames && tokens.Count < _options.MaxTextLength; t++) { int maxIdx = 0; double maxVal = double.NegativeInfinity; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); if (val > maxVal) { maxVal = val; maxIdx = v; } } double sumExp = 0; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); sumExp += Math.Exp(val - maxVal); } double frameConf = 1.0 / sumExp; if (maxIdx != prevToken && maxIdx > 0) { tokens.Add(maxIdx); totalConf += frameConf; confCount++; } prevToken = maxIdx; } return (tokens, confCount > 0 ? totalConf / confCount : 0.0); }
     private static string TokensToText(List<int> tokens) { var sb = new System.Text.StringBuilder(); foreach (var t in tokens) { if (t > 0 && t <= char.MaxValue) sb.Append((char)t); else if (t > char.MaxValue && t <= 0x10FFFF) sb.Append(char.ConvertFromUtf32(t)); } return sb.ToString().Trim(); }
diff --git a/src/SpeechRecognition/ProprietaryAPI/AssemblyAIUniversal2.cs b/src/SpeechRecognition/ProprietaryAPI/AssemblyAIUniversal2.cs
index e89bc2bedc..55f7848964 100644
--- a/src/SpeechRecognition/ProprietaryAPI/AssemblyAIUniversal2.cs
+++ b/src/SpeechRecognition/ProprietaryAPI/AssemblyAIUniversal2.cs
@@ -41,7 +41,7 @@ namespace AiDotNet.SpeechRecognition.ProprietaryAPI;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("AssemblyAI Universal-2", "https://www.assemblyai.com/research/universal-2")]
-public class AssemblyAIUniversal2<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
+public partial class AssemblyAIUniversal2<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
 {
     private readonly AssemblyAIUniversal2Options _options; public override ModelOptions GetOptions() => _options;
     private IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer; private bool _useNativeMode; private bool _disposed;
@@ -109,15 +109,8 @@ protected override IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>> GetOrCreateB
     protected override bool SupportsParameterMutation => _useNativeMode;
     protected override Tensor<T> PostprocessOutput(Tensor<T> o) => o;
     public override ModelMetadata<T> GetModelMetadata() => new() { Name = _useNativeMode ? "AssemblyAIUniversal2-Native" : "AssemblyAIUniversal2-ONNX", Description = "AssemblyAI Universal-2: best-in-class ASR API (2024)", FeatureCount = _options.NumMels, Complexity = _options.NumEncoderLayers, AdditionalInfo = BaseAudioMetadataInfo() };
-    protected override void SerializeNetworkSpecificData(BinaryWriter w) { w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty); w.Write(_options.SampleRate); w.Write(_options.EncoderDim); w.Write(_options.NumEncoderLayers); w.Write(_options.NumAttentionHeads); w.Write(_options.NumMels); w.Write(_options.VocabSize); w.Write(_options.MaxTextLength); w.Write(_options.DropoutRate); w.Write(_options.Language); }
-    protected override void DeserializeNetworkSpecificData(BinaryReader r) { _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp; _options.SampleRate = r.ReadInt32(); _options.EncoderDim = r.ReadInt32(); _options.NumEncoderLayers = r.ReadInt32(); _options.NumAttentionHeads = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.VocabSize = r.ReadInt32(); _options.MaxTextLength = r.ReadInt32(); _options.DropoutRate = r.ReadDouble(); _options.Language = r.ReadString(); base.SampleRate = _options.SampleRate; base.NumMels = _options.NumMels; if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions); }
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var cloneOptions = new AssemblyAIUniversal2Options(_options);
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new AssemblyAIUniversal2<T>(Architecture, mp, cloneOptions);
-        return new AssemblyAIUniversal2<T>(Architecture, cloneOptions);
-    }
+
+
 
     private (List<int> tokens, double confidence) CTCGreedyDecodeWithConfidence(Tensor<T> logits) { var tokens = new List<int>(); double totalConf = 0; int confCount = 0; int prevToken = -1; int numFrames = logits.Rank >= 2 ? logits.Shape[0] : 1; int vocabSize = logits.Rank >= 2 ? logits.Shape[^1] : logits.Shape[0]; for (int t = 0; t < numFrames && tokens.Count < _options.MaxTextLength; t++) { int maxIdx = 0; double maxVal = double.NegativeInfinity; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); if (val > maxVal) { maxVal = val; maxIdx = v; } } double sumExp = 0; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); sumExp += Math.Exp(val - maxVal); } double frameConf = 1.0 / sumExp; if (maxIdx != prevToken && maxIdx > 0) { tokens.Add(maxIdx); totalConf += frameConf; confCount++; } prevToken = maxIdx; } return (tokens, confCount > 0 ? totalConf / confCount : 0.0); }
     private static string TokensToText(List<int> tokens) { var sb = new System.Text.StringBuilder(); foreach (var t in tokens) { if (t > 0 && t <= char.MaxValue) sb.Append((char)t); else if (t > char.MaxValue && t <= 0x10FFFF) sb.Append(char.ConvertFromUtf32(t)); } return sb.ToString().Trim(); }
diff --git a/src/SpeechRecognition/ProprietaryAPI/AzureSpeechSTT.cs b/src/SpeechRecognition/ProprietaryAPI/AzureSpeechSTT.cs
index b393cbbb19..633512ba38 100644
--- a/src/SpeechRecognition/ProprietaryAPI/AzureSpeechSTT.cs
+++ b/src/SpeechRecognition/ProprietaryAPI/AzureSpeechSTT.cs
@@ -41,7 +41,7 @@ namespace AiDotNet.SpeechRecognition.ProprietaryAPI;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Microsoft Azure Speech-to-Text", "https://azure.microsoft.com/en-us/products/ai-services/speech-to-text")]
-public class AzureSpeechSTT<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
+public partial class AzureSpeechSTT<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
 {
     private readonly AzureSpeechSTTOptions _options; public override ModelOptions GetOptions() => _options;
     private IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer; private bool _useNativeMode; private bool _disposed;
@@ -102,9 +102,8 @@ public TranscriptionResult<T> Transcribe(Tensor<T> audio, string? language = nul
     protected override bool SupportsParameterMutation => _useNativeMode;
     protected override Tensor<T> PostprocessOutput(Tensor<T> o) => o;
     public override ModelMetadata<T> GetModelMetadata() => new() { Name = _useNativeMode ? "AzureSpeechSTT-Native" : "AzureSpeechSTT-ONNX", Description = "Azure Speech STT: enterprise ASR platform (Microsoft, 2024)", FeatureCount = _options.NumMels, Complexity = _options.NumEncoderLayers, AdditionalInfo = BaseAudioMetadataInfo() };
-    protected override void SerializeNetworkSpecificData(BinaryWriter w) { w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty); w.Write(_options.SampleRate); w.Write(_options.EncoderDim); w.Write(_options.NumEncoderLayers); w.Write(_options.NumAttentionHeads); w.Write(_options.NumMels); w.Write(_options.VocabSize); w.Write(_options.MaxTextLength); w.Write(_options.DropoutRate); w.Write(_options.Language); }
-    protected override void DeserializeNetworkSpecificData(BinaryReader r) { _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp; _options.SampleRate = r.ReadInt32(); _options.EncoderDim = r.ReadInt32(); _options.NumEncoderLayers = r.ReadInt32(); _options.NumAttentionHeads = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.VocabSize = r.ReadInt32(); _options.MaxTextLength = r.ReadInt32(); _options.DropoutRate = r.ReadDouble(); _options.Language = r.ReadString(); base.SampleRate = _options.SampleRate; base.NumMels = _options.NumMels; if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions); }
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() { if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp)) return new AzureSpeechSTT<T>(Architecture, mp, _options); return new AzureSpeechSTT<T>(Architecture, _options); }
+
+
 
     private (List<int> tokens, double confidence) CTCGreedyDecodeWithConfidence(Tensor<T> logits) { var tokens = new List<int>(); double totalConf = 0; int confCount = 0; int prevToken = -1; int numFrames = logits.Rank >= 2 ? logits.Shape[0] : 1; int vocabSize = logits.Rank >= 2 ? logits.Shape[^1] : logits.Shape[0]; for (int t = 0; t < numFrames && tokens.Count < _options.MaxTextLength; t++) { int maxIdx = 0; double maxVal = double.NegativeInfinity; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); if (val > maxVal) { maxVal = val; maxIdx = v; } } double sumExp = 0; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); sumExp += Math.Exp(val - maxVal); } double frameConf = 1.0 / sumExp; if (maxIdx != prevToken && maxIdx > 0) { tokens.Add(maxIdx); totalConf += frameConf; confCount++; } prevToken = maxIdx; } return (tokens, confCount > 0 ? totalConf / confCount : 0.0); }
     private static string TokensToText(List<int> tokens) { var sb = new System.Text.StringBuilder(); foreach (var t in tokens) { if (t > 0 && t <= char.MaxValue) sb.Append((char)t); else if (t > char.MaxValue && t <= 0x10FFFF) sb.Append(char.ConvertFromUtf32(t)); } return sb.ToString().Trim(); }
diff --git a/src/SpeechRecognition/ProprietaryAPI/DeepgramNova2.cs b/src/SpeechRecognition/ProprietaryAPI/DeepgramNova2.cs
index d8524f3121..dbd8edbf66 100644
--- a/src/SpeechRecognition/ProprietaryAPI/DeepgramNova2.cs
+++ b/src/SpeechRecognition/ProprietaryAPI/DeepgramNova2.cs
@@ -41,7 +41,7 @@ namespace AiDotNet.SpeechRecognition.ProprietaryAPI;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Deepgram Nova-2", "https://deepgram.com/learn/nova-2-speech-to-text-api")]
-public class DeepgramNova2<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
+public partial class DeepgramNova2<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
 {
     private readonly DeepgramNova2Options _options; public override ModelOptions GetOptions() => _options;
     private IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer; private bool _useNativeMode; private bool _disposed;
@@ -102,9 +102,8 @@ public TranscriptionResult<T> Transcribe(Tensor<T> audio, string? language = nul
     protected override bool SupportsParameterMutation => _useNativeMode;
     protected override Tensor<T> PostprocessOutput(Tensor<T> o) => o;
     public override ModelMetadata<T> GetModelMetadata() => new() { Name = _useNativeMode ? "DeepgramNova2-Native" : "DeepgramNova2-ONNX", Description = "Deepgram Nova-2: fastest real-time ASR API (2024)", FeatureCount = _options.NumMels, Complexity = _options.NumEncoderLayers, AdditionalInfo = BaseAudioMetadataInfo() };
-    protected override void SerializeNetworkSpecificData(BinaryWriter w) { w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty); w.Write(_options.SampleRate); w.Write(_options.MaxAudioLengthSeconds); w.Write(_options.EncoderDim); w.Write(_options.NumEncoderLayers); w.Write(_options.NumAttentionHeads); w.Write(_options.NumMels); w.Write(_options.VocabSize); w.Write(_options.MaxTextLength); w.Write(_options.DropoutRate); w.Write(_options.Language); }
-    protected override void DeserializeNetworkSpecificData(BinaryReader r) { _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp; _options.SampleRate = r.ReadInt32(); _options.MaxAudioLengthSeconds = r.ReadInt32(); _options.EncoderDim = r.ReadInt32(); _options.NumEncoderLayers = r.ReadInt32(); _options.NumAttentionHeads = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.VocabSize = r.ReadInt32(); _options.MaxTextLength = r.ReadInt32(); _options.DropoutRate = r.ReadDouble(); _options.Language = r.ReadString(); base.SampleRate = _options.SampleRate; base.NumMels = _options.NumMels; if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions); }
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() { if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp)) return new DeepgramNova2<T>(Architecture, mp, _options); return new DeepgramNova2<T>(Architecture, _options); }
+
+
 
     private (List<int> tokens, double confidence) CTCGreedyDecodeWithConfidence(Tensor<T> logits) { var tokens = new List<int>(); double totalConf = 0; int confCount = 0; int prevToken = -1; int numFrames = logits.Rank >= 2 ? logits.Shape[0] : 1; int vocabSize = logits.Rank >= 2 ? logits.Shape[^1] : logits.Shape[0]; for (int t = 0; t < numFrames && tokens.Count < _options.MaxTextLength; t++) { int maxIdx = 0; double maxVal = double.NegativeInfinity; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); if (val > maxVal) { maxVal = val; maxIdx = v; } } double sumExp = 0; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); sumExp += Math.Exp(val - maxVal); } double frameConf = 1.0 / sumExp; if (maxIdx != prevToken && maxIdx > 0) { tokens.Add(maxIdx); totalConf += frameConf; confCount++; } prevToken = maxIdx; } return (tokens, confCount > 0 ? totalConf / confCount : 0.0); }
     private static string TokensToText(List<int> tokens) { var sb = new System.Text.StringBuilder(); foreach (var t in tokens) { if (t > 0 && t <= char.MaxValue) sb.Append((char)t); else if (t > char.MaxValue && t <= 0x10FFFF) sb.Append(char.ConvertFromUtf32(t)); } return sb.ToString().Trim(); }
diff --git a/src/SpeechRecognition/ProprietaryAPI/GladiaASR.cs b/src/SpeechRecognition/ProprietaryAPI/GladiaASR.cs
index 41a8c30bef..48a12fa18e 100644
--- a/src/SpeechRecognition/ProprietaryAPI/GladiaASR.cs
+++ b/src/SpeechRecognition/ProprietaryAPI/GladiaASR.cs
@@ -41,7 +41,7 @@ namespace AiDotNet.SpeechRecognition.ProprietaryAPI;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Robust Speech Recognition via Large-Scale Weak Supervision", "https://arxiv.org/abs/2212.04356", Year = 2023, Authors = "Radford et al.")]
-public class GladiaASR<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
+public partial class GladiaASR<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
 {
     private readonly GladiaASROptions _options; public override ModelOptions GetOptions() => _options;
     private IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer; private bool _useNativeMode; private bool _disposed;
@@ -102,9 +102,8 @@ public TranscriptionResult<T> Transcribe(Tensor<T> audio, string? language = nul
     protected override bool SupportsParameterMutation => _useNativeMode;
     protected override Tensor<T> PostprocessOutput(Tensor<T> o) => o;
     public override ModelMetadata<T> GetModelMetadata() => new() { Name = _useNativeMode ? "GladiaASR-Native" : "GladiaASR-ONNX", Description = "Gladia: enterprise Whisper-based ASR API (2024)", FeatureCount = _options.NumMels, Complexity = _options.NumEncoderLayers, AdditionalInfo = BaseAudioMetadataInfo() };
-    protected override void SerializeNetworkSpecificData(BinaryWriter w) { w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty); w.Write(_options.SampleRate); w.Write(_options.MaxAudioLengthSeconds); w.Write(_options.EncoderDim); w.Write(_options.NumEncoderLayers); w.Write(_options.NumAttentionHeads); w.Write(_options.NumMels); w.Write(_options.VocabSize); w.Write(_options.MaxTextLength); w.Write(_options.DropoutRate); w.Write(_options.Language); }
-    protected override void DeserializeNetworkSpecificData(BinaryReader r) { _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp; _options.SampleRate = r.ReadInt32(); _options.MaxAudioLengthSeconds = r.ReadInt32(); _options.EncoderDim = r.ReadInt32(); _options.NumEncoderLayers = r.ReadInt32(); _options.NumAttentionHeads = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.VocabSize = r.ReadInt32(); _options.MaxTextLength = r.ReadInt32(); _options.DropoutRate = r.ReadDouble(); _options.Language = r.ReadString(); base.SampleRate = _options.SampleRate; base.NumMels = _options.NumMels; if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions); }
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() { if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp)) return new GladiaASR<T>(Architecture, mp, _options); return new GladiaASR<T>(Architecture, _options); }
+
+
 
     private (List<int> tokens, double confidence) CTCGreedyDecodeWithConfidence(Tensor<T> logits) { var tokens = new List<int>(); double totalConf = 0; int confCount = 0; int prevToken = -1; int numFrames = logits.Rank >= 2 ? logits.Shape[0] : 1; int vocabSize = logits.Rank >= 2 ? logits.Shape[^1] : logits.Shape[0]; for (int t = 0; t < numFrames && tokens.Count < _options.MaxTextLength; t++) { int maxIdx = 0; double maxVal = double.NegativeInfinity; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); if (val > maxVal) { maxVal = val; maxIdx = v; } } double sumExp = 0; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); sumExp += Math.Exp(val - maxVal); } double frameConf = 1.0 / sumExp; if (maxIdx != prevToken && maxIdx > 0) { tokens.Add(maxIdx); totalConf += frameConf; confCount++; } prevToken = maxIdx; } return (tokens, confCount > 0 ? totalConf / confCount : 0.0); }
     private static string TokensToText(List<int> tokens) { var sb = new System.Text.StringBuilder(); foreach (var t in tokens) { if (t > 0 && t <= char.MaxValue) sb.Append((char)t); else if (t > char.MaxValue && t <= 0x10FFFF) sb.Append(char.ConvertFromUtf32(t)); } return sb.ToString().Trim(); }
diff --git a/src/SpeechRecognition/ProprietaryAPI/GoogleSpeechV2.cs b/src/SpeechRecognition/ProprietaryAPI/GoogleSpeechV2.cs
index 927b4ab4b5..7469b47d24 100644
--- a/src/SpeechRecognition/ProprietaryAPI/GoogleSpeechV2.cs
+++ b/src/SpeechRecognition/ProprietaryAPI/GoogleSpeechV2.cs
@@ -41,7 +41,7 @@ namespace AiDotNet.SpeechRecognition.ProprietaryAPI;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Google USM: Scaling Automatic Speech Recognition Beyond 100 Languages", "https://arxiv.org/abs/2303.01037", Year = 2023, Authors = "Zhang et al.")]
-public class GoogleSpeechV2<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
+public partial class GoogleSpeechV2<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
 {
     private readonly GoogleSpeechV2Options _options; public override ModelOptions GetOptions() => _options;
     private IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer; private bool _useNativeMode; private bool _disposed;
@@ -102,9 +102,8 @@ public TranscriptionResult<T> Transcribe(Tensor<T> audio, string? language = nul
     protected override bool SupportsParameterMutation => _useNativeMode;
     protected override Tensor<T> PostprocessOutput(Tensor<T> o) => o;
     public override ModelMetadata<T> GetModelMetadata() => new() { Name = _useNativeMode ? "GoogleSpeechV2-Native" : "GoogleSpeechV2-ONNX", Description = "Google Cloud STT V2: Chirp-based production API (2024)", FeatureCount = _options.NumMels, Complexity = _options.NumEncoderLayers, AdditionalInfo = BaseAudioMetadataInfo() };
-    protected override void SerializeNetworkSpecificData(BinaryWriter w) { w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty); w.Write(_options.SampleRate); w.Write(_options.MaxAudioLengthSeconds); w.Write(_options.EncoderDim); w.Write(_options.NumEncoderLayers); w.Write(_options.NumAttentionHeads); w.Write(_options.NumMels); w.Write(_options.VocabSize); w.Write(_options.MaxTextLength); w.Write(_options.DropoutRate); w.Write(_options.Language); }
-    protected override void DeserializeNetworkSpecificData(BinaryReader r) { _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp; _options.SampleRate = r.ReadInt32(); _options.MaxAudioLengthSeconds = r.ReadInt32(); _options.EncoderDim = r.ReadInt32(); _options.NumEncoderLayers = r.ReadInt32(); _options.NumAttentionHeads = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.VocabSize = r.ReadInt32(); _options.MaxTextLength = r.ReadInt32(); _options.DropoutRate = r.ReadDouble(); _options.Language = r.ReadString(); base.SampleRate = _options.SampleRate; base.NumMels = _options.NumMels; if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions); }
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() { if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp)) return new GoogleSpeechV2<T>(Architecture, mp, _options); return new GoogleSpeechV2<T>(Architecture, _options); }
+
+
 
     private (List<int> tokens, double confidence) CTCGreedyDecodeWithConfidence(Tensor<T> logits) { var tokens = new List<int>(); double totalConf = 0; int confCount = 0; int prevToken = -1; int numFrames = logits.Rank >= 2 ? logits.Shape[0] : 1; int vocabSize = logits.Rank >= 2 ? logits.Shape[^1] : logits.Shape[0]; for (int t = 0; t < numFrames && tokens.Count < _options.MaxTextLength; t++) { int maxIdx = 0; double maxVal = double.NegativeInfinity; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); if (val > maxVal) { maxVal = val; maxIdx = v; } } double sumExp = 0; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); sumExp += Math.Exp(val - maxVal); } double frameConf = 1.0 / sumExp; if (maxIdx != prevToken && maxIdx > 0) { tokens.Add(maxIdx); totalConf += frameConf; confCount++; } prevToken = maxIdx; } return (tokens, confCount > 0 ? totalConf / confCount : 0.0); }
     private static string TokensToText(List<int> tokens) { var sb = new System.Text.StringBuilder(); foreach (var t in tokens) { if (t > 0 && t <= char.MaxValue) sb.Append((char)t); else if (t > char.MaxValue && t <= 0x10FFFF) sb.Append(char.ConvertFromUtf32(t)); } return sb.ToString().Trim(); }
diff --git a/src/SpeechRecognition/ProprietaryAPI/GroqWhisper.cs b/src/SpeechRecognition/ProprietaryAPI/GroqWhisper.cs
index 4edf6205e2..fa09bc2110 100644
--- a/src/SpeechRecognition/ProprietaryAPI/GroqWhisper.cs
+++ b/src/SpeechRecognition/ProprietaryAPI/GroqWhisper.cs
@@ -41,7 +41,7 @@ namespace AiDotNet.SpeechRecognition.ProprietaryAPI;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Robust Speech Recognition via Large-Scale Weak Supervision", "https://arxiv.org/abs/2212.04356", Year = 2023, Authors = "Radford et al.")]
-public class GroqWhisper<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
+public partial class GroqWhisper<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
 {
     private readonly GroqWhisperOptions _options; public override ModelOptions GetOptions() => _options;
     private IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer; private bool _useNativeMode; private bool _disposed;
@@ -102,9 +102,8 @@ public TranscriptionResult<T> Transcribe(Tensor<T> audio, string? language = nul
     protected override bool SupportsParameterMutation => _useNativeMode;
     protected override Tensor<T> PostprocessOutput(Tensor<T> o) => o;
     public override ModelMetadata<T> GetModelMetadata() => new() { Name = _useNativeMode ? "GroqWhisper-Native" : "GroqWhisper-ONNX", Description = "Groq Whisper: LPU-accelerated Whisper (Groq, 2024)", FeatureCount = _options.NumMels, Complexity = _options.NumEncoderLayers, AdditionalInfo = BaseAudioMetadataInfo() };
-    protected override void SerializeNetworkSpecificData(BinaryWriter w) { w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty); w.Write(_options.SampleRate); w.Write(_options.EncoderDim); w.Write(_options.NumEncoderLayers); w.Write(_options.NumAttentionHeads); w.Write(_options.NumMels); w.Write(_options.VocabSize); w.Write(_options.MaxTextLength); w.Write(_options.DropoutRate); w.Write(_options.Language); }
-    protected override void DeserializeNetworkSpecificData(BinaryReader r) { _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp; _options.SampleRate = r.ReadInt32(); _options.EncoderDim = r.ReadInt32(); _options.NumEncoderLayers = r.ReadInt32(); _options.NumAttentionHeads = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.VocabSize = r.ReadInt32(); _options.MaxTextLength = r.ReadInt32(); _options.DropoutRate = r.ReadDouble(); _options.Language = r.ReadString(); base.SampleRate = _options.SampleRate; base.NumMels = _options.NumMels; if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions); }
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() { if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp)) return new GroqWhisper<T>(Architecture, mp, _options); return new GroqWhisper<T>(Architecture, _options); }
+
+
 
     private (List<int> tokens, double confidence) CTCGreedyDecodeWithConfidence(Tensor<T> logits) { var tokens = new List<int>(); double totalConf = 0; int confCount = 0; int prevToken = -1; int numFrames = logits.Rank >= 2 ? logits.Shape[0] : 1; int vocabSize = logits.Rank >= 2 ? logits.Shape[^1] : logits.Shape[0]; for (int t = 0; t < numFrames && tokens.Count < _options.MaxTextLength; t++) { int maxIdx = 0; double maxVal = double.NegativeInfinity; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); if (val > maxVal) { maxVal = val; maxIdx = v; } } double sumExp = 0; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); sumExp += Math.Exp(val - maxVal); } double frameConf = 1.0 / sumExp; if (maxIdx != prevToken && maxIdx > 0) { tokens.Add(maxIdx); totalConf += frameConf; confCount++; } prevToken = maxIdx; } return (tokens, confCount > 0 ? totalConf / confCount : 0.0); }
     private static string TokensToText(List<int> tokens) { var sb = new System.Text.StringBuilder(); foreach (var t in tokens) { if (t > 0 && t <= char.MaxValue) sb.Append((char)t); else if (t > char.MaxValue && t <= 0x10FFFF) sb.Append(char.ConvertFromUtf32(t)); } return sb.ToString().Trim(); }
diff --git a/src/SpeechRecognition/ProprietaryAPI/RevAI.cs b/src/SpeechRecognition/ProprietaryAPI/RevAI.cs
index d0d698b0aa..7623d0ce27 100644
--- a/src/SpeechRecognition/ProprietaryAPI/RevAI.cs
+++ b/src/SpeechRecognition/ProprietaryAPI/RevAI.cs
@@ -41,7 +41,7 @@ namespace AiDotNet.SpeechRecognition.ProprietaryAPI;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Rev AI", "https://www.rev.com/api")]
-public class RevAI<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
+public partial class RevAI<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
 {
     private readonly RevAIOptions _options; public override ModelOptions GetOptions() => _options;
     private IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer; private bool _useNativeMode; private bool _disposed;
@@ -102,9 +102,8 @@ public TranscriptionResult<T> Transcribe(Tensor<T> audio, string? language = nul
     protected override bool SupportsParameterMutation => _useNativeMode;
     protected override Tensor<T> PostprocessOutput(Tensor<T> o) => o;
     public override ModelMetadata<T> GetModelMetadata() => new() { Name = _useNativeMode ? "RevAI-Native" : "RevAI-ONNX", Description = "Rev AI: human-quality transcription API (2024)", FeatureCount = _options.NumMels, Complexity = _options.NumEncoderLayers, AdditionalInfo = BaseAudioMetadataInfo() };
-    protected override void SerializeNetworkSpecificData(BinaryWriter w) { w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty); w.Write(_options.SampleRate); w.Write(_options.MaxAudioLengthSeconds); w.Write(_options.EncoderDim); w.Write(_options.NumEncoderLayers); w.Write(_options.NumAttentionHeads); w.Write(_options.NumMels); w.Write(_options.VocabSize); w.Write(_options.MaxTextLength); w.Write(_options.DropoutRate); w.Write(_options.Language); }
-    protected override void DeserializeNetworkSpecificData(BinaryReader r) { _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp; _options.SampleRate = r.ReadInt32(); _options.MaxAudioLengthSeconds = r.ReadInt32(); _options.EncoderDim = r.ReadInt32(); _options.NumEncoderLayers = r.ReadInt32(); _options.NumAttentionHeads = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.VocabSize = r.ReadInt32(); _options.MaxTextLength = r.ReadInt32(); _options.DropoutRate = r.ReadDouble(); _options.Language = r.ReadString(); base.SampleRate = _options.SampleRate; base.NumMels = _options.NumMels; if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions); }
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() { if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp)) return new RevAI<T>(Architecture, mp, _options); return new RevAI<T>(Architecture, _options); }
+
+
 
     private (List<int> tokens, double confidence) CTCGreedyDecodeWithConfidence(Tensor<T> logits) { var tokens = new List<int>(); double totalConf = 0; int confCount = 0; int prevToken = -1; int numFrames = logits.Rank >= 2 ? logits.Shape[0] : 1; int vocabSize = logits.Rank >= 2 ? logits.Shape[^1] : logits.Shape[0]; for (int t = 0; t < numFrames && tokens.Count < _options.MaxTextLength; t++) { int maxIdx = 0; double maxVal = double.NegativeInfinity; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); if (val > maxVal) { maxVal = val; maxIdx = v; } } double sumExp = 0; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); sumExp += Math.Exp(val - maxVal); } double frameConf = 1.0 / sumExp; if (maxIdx != prevToken && maxIdx > 0) { tokens.Add(maxIdx); totalConf += frameConf; confCount++; } prevToken = maxIdx; } return (tokens, confCount > 0 ? totalConf / confCount : 0.0); }
     private static string TokensToText(List<int> tokens) { var sb = new System.Text.StringBuilder(); foreach (var t in tokens) { if (t > 0 && t <= char.MaxValue) sb.Append((char)t); else if (t > char.MaxValue && t <= 0x10FFFF) sb.Append(char.ConvertFromUtf32(t)); } return sb.ToString().Trim(); }
diff --git a/src/SpeechRecognition/ProprietaryAPI/SarvamASR.cs b/src/SpeechRecognition/ProprietaryAPI/SarvamASR.cs
index 60edc3bc2e..286a2e20d3 100644
--- a/src/SpeechRecognition/ProprietaryAPI/SarvamASR.cs
+++ b/src/SpeechRecognition/ProprietaryAPI/SarvamASR.cs
@@ -41,7 +41,7 @@ namespace AiDotNet.SpeechRecognition.ProprietaryAPI;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Sarvam AI ASR", "https://sarvam.ai")]
-public class SarvamASR<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
+public partial class SarvamASR<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
 {
     private readonly SarvamASROptions _options; public override ModelOptions GetOptions() => _options;
     private IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer; private bool _useNativeMode; private bool _disposed;
@@ -102,9 +102,8 @@ public TranscriptionResult<T> Transcribe(Tensor<T> audio, string? language = nul
     protected override bool SupportsParameterMutation => _useNativeMode;
     protected override Tensor<T> PostprocessOutput(Tensor<T> o) => o;
     public override ModelMetadata<T> GetModelMetadata() => new() { Name = _useNativeMode ? "SarvamASR-Native" : "SarvamASR-ONNX", Description = "Sarvam AI: Indian language ASR (2024)", FeatureCount = _options.NumMels, Complexity = _options.NumEncoderLayers, AdditionalInfo = BaseAudioMetadataInfo() };
-    protected override void SerializeNetworkSpecificData(BinaryWriter w) { w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty); w.Write(_options.SampleRate); w.Write(_options.EncoderDim); w.Write(_options.NumEncoderLayers); w.Write(_options.NumAttentionHeads); w.Write(_options.NumMels); w.Write(_options.VocabSize); w.Write(_options.MaxTextLength); w.Write(_options.DropoutRate); w.Write(_options.Language); }
-    protected override void DeserializeNetworkSpecificData(BinaryReader r) { _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp; _options.SampleRate = r.ReadInt32(); _options.EncoderDim = r.ReadInt32(); _options.NumEncoderLayers = r.ReadInt32(); _options.NumAttentionHeads = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.VocabSize = r.ReadInt32(); _options.MaxTextLength = r.ReadInt32(); _options.DropoutRate = r.ReadDouble(); _options.Language = r.ReadString(); base.SampleRate = _options.SampleRate; base.NumMels = _options.NumMels; if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions); }
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() { if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp)) return new SarvamASR<T>(Architecture, mp, _options); return new SarvamASR<T>(Architecture, _options); }
+
+
 
     private (List<int> tokens, double confidence) CTCGreedyDecodeWithConfidence(Tensor<T> logits) { var tokens = new List<int>(); double totalConf = 0; int confCount = 0; int prevToken = -1; int numFrames = logits.Rank >= 2 ? logits.Shape[0] : 1; int vocabSize = logits.Rank >= 2 ? logits.Shape[^1] : logits.Shape[0]; for (int t = 0; t < numFrames && tokens.Count < _options.MaxTextLength; t++) { int maxIdx = 0; double maxVal = double.NegativeInfinity; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); if (val > maxVal) { maxVal = val; maxIdx = v; } } double sumExp = 0; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); sumExp += Math.Exp(val - maxVal); } double frameConf = 1.0 / sumExp; if (maxIdx != prevToken && maxIdx > 0) { tokens.Add(maxIdx); totalConf += frameConf; confCount++; } prevToken = maxIdx; } return (tokens, confCount > 0 ? totalConf / confCount : 0.0); }
     private static string TokensToText(List<int> tokens) { var sb = new System.Text.StringBuilder(); foreach (var t in tokens) { if (t > 0 && t <= char.MaxValue) sb.Append((char)t); else if (t > char.MaxValue && t <= 0x10FFFF) sb.Append(char.ConvertFromUtf32(t)); } return sb.ToString().Trim(); }
diff --git a/src/SpeechRecognition/ProprietaryAPI/SpeechmaticsASR.cs b/src/SpeechRecognition/ProprietaryAPI/SpeechmaticsASR.cs
index 7a4c2642f1..a59b25945e 100644
--- a/src/SpeechRecognition/ProprietaryAPI/SpeechmaticsASR.cs
+++ b/src/SpeechRecognition/ProprietaryAPI/SpeechmaticsASR.cs
@@ -41,7 +41,7 @@ namespace AiDotNet.SpeechRecognition.ProprietaryAPI;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Speechmatics ASR", "https://www.speechmatics.com")]
-public class SpeechmaticsASR<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
+public partial class SpeechmaticsASR<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
 {
     private readonly SpeechmaticsASROptions _options; public override ModelOptions GetOptions() => _options;
     private IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer; private bool _useNativeMode; private bool _disposed;
@@ -102,9 +102,8 @@ public TranscriptionResult<T> Transcribe(Tensor<T> audio, string? language = nul
     protected override bool SupportsParameterMutation => _useNativeMode;
     protected override Tensor<T> PostprocessOutput(Tensor<T> o) => o;
     public override ModelMetadata<T> GetModelMetadata() => new() { Name = _useNativeMode ? "SpeechmaticsASR-Native" : "SpeechmaticsASR-ONNX", Description = "Speechmatics: real-time multilingual ASR (2024)", FeatureCount = _options.NumMels, Complexity = _options.NumEncoderLayers, AdditionalInfo = BaseAudioMetadataInfo() };
-    protected override void SerializeNetworkSpecificData(BinaryWriter w) { w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty); w.Write(_options.SampleRate); w.Write(_options.MaxAudioLengthSeconds); w.Write(_options.EncoderDim); w.Write(_options.NumEncoderLayers); w.Write(_options.NumAttentionHeads); w.Write(_options.NumMels); w.Write(_options.VocabSize); w.Write(_options.MaxTextLength); w.Write(_options.DropoutRate); w.Write(_options.Language); }
-    protected override void DeserializeNetworkSpecificData(BinaryReader r) { _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp; _options.SampleRate = r.ReadInt32(); _options.MaxAudioLengthSeconds = r.ReadInt32(); _options.EncoderDim = r.ReadInt32(); _options.NumEncoderLayers = r.ReadInt32(); _options.NumAttentionHeads = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.VocabSize = r.ReadInt32(); _options.MaxTextLength = r.ReadInt32(); _options.DropoutRate = r.ReadDouble(); _options.Language = r.ReadString(); base.SampleRate = _options.SampleRate; base.NumMels = _options.NumMels; if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions); }
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() { if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp)) return new SpeechmaticsASR<T>(Architecture, mp, _options); return new SpeechmaticsASR<T>(Architecture, _options); }
+
+
 
     private (List<int> tokens, double confidence) CTCGreedyDecodeWithConfidence(Tensor<T> logits) { var tokens = new List<int>(); double totalConf = 0; int confCount = 0; int prevToken = -1; int numFrames = logits.Rank >= 2 ? logits.Shape[0] : 1; int vocabSize = logits.Rank >= 2 ? logits.Shape[^1] : logits.Shape[0]; for (int t = 0; t < numFrames && tokens.Count < _options.MaxTextLength; t++) { int maxIdx = 0; double maxVal = double.NegativeInfinity; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); if (val > maxVal) { maxVal = val; maxIdx = v; } } double sumExp = 0; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); sumExp += Math.Exp(val - maxVal); } double frameConf = 1.0 / sumExp; if (maxIdx != prevToken && maxIdx > 0) { tokens.Add(maxIdx); totalConf += frameConf; confCount++; } prevToken = maxIdx; } return (tokens, confCount > 0 ? totalConf / confCount : 0.0); }
     private static string TokensToText(List<int> tokens) { var sb = new System.Text.StringBuilder(); foreach (var t in tokens) { if (t > 0 && t <= char.MaxValue) sb.Append((char)t); else if (t > char.MaxValue && t <= 0x10FFFF) sb.Append(char.ConvertFromUtf32(t)); } return sb.ToString().Trim(); }
diff --git a/src/SpeechRecognition/Robust/AVHuBERT.cs b/src/SpeechRecognition/Robust/AVHuBERT.cs
index 97b1cf3473..9767ade872 100644
--- a/src/SpeechRecognition/Robust/AVHuBERT.cs
+++ b/src/SpeechRecognition/Robust/AVHuBERT.cs
@@ -44,7 +44,7 @@ namespace AiDotNet.SpeechRecognition.Robust;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Learning Audio-Visual Speech Representation by Masked Multimodal Cluster Prediction", "https://arxiv.org/abs/2201.02184", Year = 2022, Authors = "Shi et al.")]
-public class AVHuBERT<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
+public partial class AVHuBERT<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
 {
     private readonly AVHuBERTOptions _options; public override ModelOptions GetOptions() => _options;
     private IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer; private bool _useNativeMode; private bool _disposed;
@@ -105,9 +105,8 @@ public TranscriptionResult<T> Transcribe(Tensor<T> audio, string? language = nul
     protected override bool SupportsParameterMutation => _useNativeMode;
     protected override Tensor<T> PostprocessOutput(Tensor<T> o) => o;
     public override ModelMetadata<T> GetModelMetadata() => new() { Name = _useNativeMode ? "AVHuBERT-Native" : "AVHuBERT-ONNX", Description = "AV-HuBERT: audio-visual pre-trained + CTC (Meta, 2022)", FeatureCount = _options.NumMels, Complexity = _options.NumEncoderLayers, AdditionalInfo = BaseAudioMetadataInfo() };
-    protected override void SerializeNetworkSpecificData(BinaryWriter w) { w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty); w.Write(_options.SampleRate); w.Write(_options.MaxAudioLengthSeconds); w.Write(_options.EncoderDim); w.Write(_options.NumEncoderLayers); w.Write(_options.NumAttentionHeads); w.Write(_options.NumMels); w.Write(_options.VocabSize); w.Write(_options.MaxTextLength); w.Write(_options.DropoutRate); w.Write(_options.Language); }
-    protected override void DeserializeNetworkSpecificData(BinaryReader r) { _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp; _options.SampleRate = r.ReadInt32(); _options.MaxAudioLengthSeconds = r.ReadInt32(); _options.EncoderDim = r.ReadInt32(); _options.NumEncoderLayers = r.ReadInt32(); _options.NumAttentionHeads = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.VocabSize = r.ReadInt32(); _options.MaxTextLength = r.ReadInt32(); _options.DropoutRate = r.ReadDouble(); _options.Language = r.ReadString(); base.SampleRate = _options.SampleRate; base.NumMels = _options.NumMels; if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions); }
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() { if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp)) return new AVHuBERT<T>(Architecture, mp, _options); return new AVHuBERT<T>(Architecture, _options); }
+
+
 
     private (List<int> tokens, double confidence) CTCGreedyDecodeWithConfidence(Tensor<T> logits) { var tokens = new List<int>(); double totalConf = 0; int confCount = 0; int prevToken = -1; int numFrames = logits.Rank >= 2 ? logits.Shape[0] : 1; int vocabSize = logits.Rank >= 2 ? logits.Shape[^1] : logits.Shape[0]; for (int t = 0; t < numFrames && tokens.Count < _options.MaxTextLength; t++) { int maxIdx = 0; double maxVal = double.NegativeInfinity; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); if (val > maxVal) { maxVal = val; maxIdx = v; } } double sumExp = 0; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); sumExp += Math.Exp(val - maxVal); } double frameConf = 1.0 / sumExp; if (maxIdx != prevToken && maxIdx > 0) { tokens.Add(maxIdx); totalConf += frameConf; confCount++; } prevToken = maxIdx; } return (tokens, confCount > 0 ? totalConf / confCount : 0.0); }
     private static string TokensToText(List<int> tokens) { var sb = new System.Text.StringBuilder(); foreach (var t in tokens) { if (t > 0 && t <= char.MaxValue) sb.Append((char)t); else if (t > char.MaxValue && t <= 0x10FFFF) sb.Append(char.ConvertFromUtf32(t)); } return sb.ToString().Trim(); }
diff --git a/src/SpeechRecognition/Robust/ESPnetASR.cs b/src/SpeechRecognition/Robust/ESPnetASR.cs
index c6803e9510..04bd688b35 100644
--- a/src/SpeechRecognition/Robust/ESPnetASR.cs
+++ b/src/SpeechRecognition/Robust/ESPnetASR.cs
@@ -41,7 +41,7 @@ namespace AiDotNet.SpeechRecognition.Robust;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("ESPnet: End-to-End Speech Processing Toolkit", "https://arxiv.org/abs/1804.00015", Year = 2018, Authors = "Watanabe et al.")]
-public class ESPnetASR<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
+public partial class ESPnetASR<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
 {
     private readonly ESPnetASROptions _options; public override ModelOptions GetOptions() => _options;
     private IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer; private bool _useNativeMode; private bool _disposed;
@@ -102,9 +102,8 @@ public TranscriptionResult<T> Transcribe(Tensor<T> audio, string? language = nul
     protected override bool SupportsParameterMutation => _useNativeMode;
     protected override Tensor<T> PostprocessOutput(Tensor<T> o) => o;
     public override ModelMetadata<T> GetModelMetadata() => new() { Name = _useNativeMode ? "ESPnetASR-Native" : "ESPnetASR-ONNX", Description = "ESPnet: Conformer + joint CTC/attention (2024)", FeatureCount = _options.NumMels, Complexity = _options.NumEncoderLayers, AdditionalInfo = BaseAudioMetadataInfo() };
-    protected override void SerializeNetworkSpecificData(BinaryWriter w) { w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty); w.Write(_options.SampleRate); w.Write(_options.MaxAudioLengthSeconds); w.Write(_options.EncoderDim); w.Write(_options.NumEncoderLayers); w.Write(_options.NumAttentionHeads); w.Write(_options.NumMels); w.Write(_options.VocabSize); w.Write(_options.MaxTextLength); w.Write(_options.DropoutRate); w.Write(_options.Language); }
-    protected override void DeserializeNetworkSpecificData(BinaryReader r) { _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp; _options.SampleRate = r.ReadInt32(); _options.MaxAudioLengthSeconds = r.ReadInt32(); _options.EncoderDim = r.ReadInt32(); _options.NumEncoderLayers = r.ReadInt32(); _options.NumAttentionHeads = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.VocabSize = r.ReadInt32(); _options.MaxTextLength = r.ReadInt32(); _options.DropoutRate = r.ReadDouble(); _options.Language = r.ReadString(); base.SampleRate = _options.SampleRate; base.NumMels = _options.NumMels; if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions); }
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() { if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp)) return new ESPnetASR<T>(Architecture, mp, _options); return new ESPnetASR<T>(Architecture, _options); }
+
+
 
     private (List<int> tokens, double confidence) CTCGreedyDecodeWithConfidence(Tensor<T> logits) { var tokens = new List<int>(); double totalConf = 0; int confCount = 0; int prevToken = -1; int numFrames = logits.Rank >= 2 ? logits.Shape[0] : 1; int vocabSize = logits.Rank >= 2 ? logits.Shape[^1] : logits.Shape[0]; for (int t = 0; t < numFrames && tokens.Count < _options.MaxTextLength; t++) { int maxIdx = 0; double maxVal = double.NegativeInfinity; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); if (val > maxVal) { maxVal = val; maxIdx = v; } } double sumExp = 0; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); sumExp += Math.Exp(val - maxVal); } double frameConf = 1.0 / sumExp; if (maxIdx != prevToken && maxIdx > 0) { tokens.Add(maxIdx); totalConf += frameConf; confCount++; } prevToken = maxIdx; } return (tokens, confCount > 0 ? totalConf / confCount : 0.0); }
     private static string TokensToText(List<int> tokens) { var sb = new System.Text.StringBuilder(); foreach (var t in tokens) { if (t > 0 && t <= char.MaxValue) sb.Append((char)t); else if (t > char.MaxValue && t <= 0x10FFFF) sb.Append(char.ConvertFromUtf32(t)); } return sb.ToString().Trim(); }
diff --git a/src/SpeechRecognition/Robust/NoiseRobustASR.cs b/src/SpeechRecognition/Robust/NoiseRobustASR.cs
index 9e3dfed5ef..79d3f7a79d 100644
--- a/src/SpeechRecognition/Robust/NoiseRobustASR.cs
+++ b/src/SpeechRecognition/Robust/NoiseRobustASR.cs
@@ -125,15 +125,8 @@ public override void Train(Tensor<T> input, Tensor<T> expected)
     protected override bool SupportsParameterMutation => _useNativeMode;
     protected override Tensor<T> PostprocessOutput(Tensor<T> o) => o;
     public override ModelMetadata<T> GetModelMetadata() => new() { Name = _useNativeMode ? "NoiseRobustASR-Native" : "NoiseRobustASR-ONNX", Description = "Noise-Robust ASR: multi-condition Conformer (2023)", FeatureCount = _options.NumMels, Complexity = _options.NumEncoderLayers, AdditionalInfo = BaseAudioMetadataInfo() };
-    protected override void SerializeNetworkSpecificData(BinaryWriter w) { w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty); w.Write(_options.SampleRate); w.Write(_options.EncoderDim); w.Write(_options.NumEncoderLayers); w.Write(_options.NumAttentionHeads); w.Write(_options.NumMels); w.Write(_options.VocabSize); w.Write(_options.MaxTextLength); w.Write(_options.DropoutRate); w.Write(_options.Language); }
-    protected override void DeserializeNetworkSpecificData(BinaryReader r) { _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp; _options.SampleRate = r.ReadInt32(); _options.EncoderDim = r.ReadInt32(); _options.NumEncoderLayers = r.ReadInt32(); _options.NumAttentionHeads = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.VocabSize = r.ReadInt32(); _options.MaxTextLength = r.ReadInt32(); _options.DropoutRate = r.ReadDouble(); _options.Language = r.ReadString(); base.SampleRate = _options.SampleRate; base.NumMels = _options.NumMels; if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions); }
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var options = new NoiseRobustASROptions(_options);
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new NoiseRobustASR<T>(Architecture, mp, options);
-        return new NoiseRobustASR<T>(Architecture, options);
-    }
+
+
 
     private (List<int> tokens, double confidence) CTCGreedyDecodeWithConfidence(Tensor<T> logits) { var tokens = new List<int>(); double totalConf = 0; int confCount = 0; int prevToken = -1; int numFrames = logits.Rank >= 2 ? logits.Shape[0] : 1; int vocabSize = logits.Rank >= 2 ? logits.Shape[^1] : logits.Shape[0]; for (int t = 0; t < numFrames && tokens.Count < _options.MaxTextLength; t++) { int maxIdx = 0; double maxVal = double.NegativeInfinity; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); if (val > maxVal) { maxVal = val; maxIdx = v; } } double sumExp = 0; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); sumExp += Math.Exp(val - maxVal); } double frameConf = 1.0 / sumExp; if (maxIdx != prevToken && maxIdx > 0) { tokens.Add(maxIdx); totalConf += frameConf; confCount++; } prevToken = maxIdx; } return (tokens, confCount > 0 ? totalConf / confCount : 0.0); }
     private static string TokensToText(List<int> tokens) { var sb = new System.Text.StringBuilder(); foreach (var t in tokens) { if (t > 0 && t <= char.MaxValue) sb.Append((char)t); else if (t > char.MaxValue && t <= 0x10FFFF) sb.Append(char.ConvertFromUtf32(t)); } return sb.ToString().Trim(); }
diff --git a/src/SpeechRecognition/Robust/RobustConformer.cs b/src/SpeechRecognition/Robust/RobustConformer.cs
index 2baf4abe1c..48325d5bca 100644
--- a/src/SpeechRecognition/Robust/RobustConformer.cs
+++ b/src/SpeechRecognition/Robust/RobustConformer.cs
@@ -41,7 +41,7 @@ namespace AiDotNet.SpeechRecognition.Robust;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Improving Noise Robustness of Contrastive Speech Representation Learning with Speech Reconstruction", "https://arxiv.org/abs/2110.15430", Year = 2023, Authors = "Chang et al.")]
-public class RobustConformer<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
+public partial class RobustConformer<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
 {
     private readonly RobustConformerOptions _options; public override ModelOptions GetOptions() => _options;
     private IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer; private bool _useNativeMode; private bool _disposed;
@@ -102,9 +102,8 @@ public TranscriptionResult<T> Transcribe(Tensor<T> audio, string? language = nul
     protected override bool SupportsParameterMutation => _useNativeMode;
     protected override Tensor<T> PostprocessOutput(Tensor<T> o) => o;
     public override ModelMetadata<T> GetModelMetadata() => new() { Name = _useNativeMode ? "RobustConformer-Native" : "RobustConformer-ONNX", Description = "Robust Conformer: adversarial training + CTC (2023)", FeatureCount = _options.NumMels, Complexity = _options.NumEncoderLayers, AdditionalInfo = BaseAudioMetadataInfo() };
-    protected override void SerializeNetworkSpecificData(BinaryWriter w) { w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty); w.Write(_options.SampleRate); w.Write(_options.EncoderDim); w.Write(_options.NumEncoderLayers); w.Write(_options.NumAttentionHeads); w.Write(_options.NumMels); w.Write(_options.VocabSize); w.Write(_options.MaxTextLength); w.Write(_options.DropoutRate); w.Write(_options.Language); }
-    protected override void DeserializeNetworkSpecificData(BinaryReader r) { _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp; _options.SampleRate = r.ReadInt32(); _options.EncoderDim = r.ReadInt32(); _options.NumEncoderLayers = r.ReadInt32(); _options.NumAttentionHeads = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.VocabSize = r.ReadInt32(); _options.MaxTextLength = r.ReadInt32(); _options.DropoutRate = r.ReadDouble(); _options.Language = r.ReadString(); base.SampleRate = _options.SampleRate; base.NumMels = _options.NumMels; if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions); }
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() { if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp)) return new RobustConformer<T>(Architecture, mp, _options); return new RobustConformer<T>(Architecture, _options); }
+
+
 
     private (List<int> tokens, double confidence) CTCGreedyDecodeWithConfidence(Tensor<T> logits) { var tokens = new List<int>(); double totalConf = 0; int confCount = 0; int prevToken = -1; int numFrames = logits.Rank >= 2 ? logits.Shape[0] : 1; int vocabSize = logits.Rank >= 2 ? logits.Shape[^1] : logits.Shape[0]; for (int t = 0; t < numFrames && tokens.Count < _options.MaxTextLength; t++) { int maxIdx = 0; double maxVal = double.NegativeInfinity; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); if (val > maxVal) { maxVal = val; maxIdx = v; } } double sumExp = 0; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); sumExp += Math.Exp(val - maxVal); } double frameConf = 1.0 / sumExp; if (maxIdx != prevToken && maxIdx > 0) { tokens.Add(maxIdx); totalConf += frameConf; confCount++; } prevToken = maxIdx; } return (tokens, confCount > 0 ? totalConf / confCount : 0.0); }
     private static string TokensToText(List<int> tokens) { var sb = new System.Text.StringBuilder(); foreach (var t in tokens) { if (t > 0 && t <= char.MaxValue) sb.Append((char)t); else if (t > char.MaxValue && t <= 0x10FFFF) sb.Append(char.ConvertFromUtf32(t)); } return sb.ToString().Trim(); }
diff --git a/src/SpeechRecognition/Robust/SpeechBrain.cs b/src/SpeechRecognition/Robust/SpeechBrain.cs
index ac2dfc6233..6b5c32c019 100644
--- a/src/SpeechRecognition/Robust/SpeechBrain.cs
+++ b/src/SpeechRecognition/Robust/SpeechBrain.cs
@@ -41,7 +41,7 @@ namespace AiDotNet.SpeechRecognition.Robust;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("SpeechBrain: A General-Purpose Speech Toolkit", "https://arxiv.org/abs/2106.04624", Year = 2021, Authors = "Ravanelli et al.")]
-public class SpeechBrain<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
+public partial class SpeechBrain<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
 {
     private readonly SpeechBrainOptions _options; public override ModelOptions GetOptions() => _options;
     private IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer; private bool _useNativeMode; private bool _disposed;
@@ -102,9 +102,8 @@ public TranscriptionResult<T> Transcribe(Tensor<T> audio, string? language = nul
     protected override bool SupportsParameterMutation => _useNativeMode;
     protected override Tensor<T> PostprocessOutput(Tensor<T> o) => o;
     public override ModelMetadata<T> GetModelMetadata() => new() { Name = _useNativeMode ? "SpeechBrain-Native" : "SpeechBrain-ONNX", Description = "SpeechBrain: open-source Conformer + CTC (2021)", FeatureCount = _options.NumMels, Complexity = _options.NumEncoderLayers, AdditionalInfo = BaseAudioMetadataInfo() };
-    protected override void SerializeNetworkSpecificData(BinaryWriter w) { w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty); w.Write(_options.SampleRate); w.Write(_options.MaxAudioLengthSeconds); w.Write(_options.EncoderDim); w.Write(_options.NumEncoderLayers); w.Write(_options.NumAttentionHeads); w.Write(_options.NumMels); w.Write(_options.VocabSize); w.Write(_options.MaxTextLength); w.Write(_options.DropoutRate); w.Write(_options.Language); }
-    protected override void DeserializeNetworkSpecificData(BinaryReader r) { _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp; _options.SampleRate = r.ReadInt32(); _options.MaxAudioLengthSeconds = r.ReadInt32(); _options.EncoderDim = r.ReadInt32(); _options.NumEncoderLayers = r.ReadInt32(); _options.NumAttentionHeads = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.VocabSize = r.ReadInt32(); _options.MaxTextLength = r.ReadInt32(); _options.DropoutRate = r.ReadDouble(); _options.Language = r.ReadString(); base.SampleRate = _options.SampleRate; base.NumMels = _options.NumMels; if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions); }
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() { if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp)) return new SpeechBrain<T>(Architecture, mp, _options); return new SpeechBrain<T>(Architecture, _options); }
+
+
 
     private (List<int> tokens, double confidence) CTCGreedyDecodeWithConfidence(Tensor<T> logits) { var tokens = new List<int>(); double totalConf = 0; int confCount = 0; int prevToken = -1; int numFrames = logits.Rank >= 2 ? logits.Shape[0] : 1; int vocabSize = logits.Rank >= 2 ? logits.Shape[^1] : logits.Shape[0]; for (int t = 0; t < numFrames && tokens.Count < _options.MaxTextLength; t++) { int maxIdx = 0; double maxVal = double.NegativeInfinity; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); if (val > maxVal) { maxVal = val; maxIdx = v; } } double sumExp = 0; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); sumExp += Math.Exp(val - maxVal); } double frameConf = 1.0 / sumExp; if (maxIdx != prevToken && maxIdx > 0) { tokens.Add(maxIdx); totalConf += frameConf; confCount++; } prevToken = maxIdx; } return (tokens, confCount > 0 ? totalConf / confCount : 0.0); }
     private static string TokensToText(List<int> tokens) { var sb = new System.Text.StringBuilder(); foreach (var t in tokens) { if (t > 0 && t <= char.MaxValue) sb.Append((char)t); else if (t > char.MaxValue && t <= 0x10FFFF) sb.Append(char.ConvertFromUtf32(t)); } return sb.ToString().Trim(); }
diff --git a/src/SpeechRecognition/Robust/WavLMRobust.cs b/src/SpeechRecognition/Robust/WavLMRobust.cs
index 06d9f146b4..111d857545 100644
--- a/src/SpeechRecognition/Robust/WavLMRobust.cs
+++ b/src/SpeechRecognition/Robust/WavLMRobust.cs
@@ -42,7 +42,7 @@ namespace AiDotNet.SpeechRecognition.Robust;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("WavLM: Large-Scale Self-Supervised Pre-Training for Full Stack Speech Processing", "https://arxiv.org/abs/2110.13900", Year = 2022, Authors = "Chen et al.")]
-public class WavLMRobust<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
+public partial class WavLMRobust<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
 {
     private readonly WavLMRobustOptions _options; public override ModelOptions GetOptions() => _options;
     private IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer; private bool _useNativeMode; private bool _disposed;
@@ -103,9 +103,8 @@ public TranscriptionResult<T> Transcribe(Tensor<T> audio, string? language = nul
     protected override bool SupportsParameterMutation => _useNativeMode;
     protected override Tensor<T> PostprocessOutput(Tensor<T> o) => o;
     public override ModelMetadata<T> GetModelMetadata() => new() { Name = _useNativeMode ? "WavLMRobust-Native" : "WavLMRobust-ONNX", Description = "WavLM-Robust: denoising pre-trained + CTC (Microsoft, 2022)", FeatureCount = _options.NumMels, Complexity = _options.NumEncoderLayers, AdditionalInfo = BaseAudioMetadataInfo() };
-    protected override void SerializeNetworkSpecificData(BinaryWriter w) { w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty); w.Write(_options.SampleRate); w.Write(_options.MaxAudioLengthSeconds); w.Write(_options.EncoderDim); w.Write(_options.NumEncoderLayers); w.Write(_options.NumAttentionHeads); w.Write(_options.NumMels); w.Write(_options.VocabSize); w.Write(_options.MaxTextLength); w.Write(_options.DropoutRate); w.Write(_options.Language); }
-    protected override void DeserializeNetworkSpecificData(BinaryReader r) { _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp; _options.SampleRate = r.ReadInt32(); _options.MaxAudioLengthSeconds = r.ReadInt32(); _options.EncoderDim = r.ReadInt32(); _options.NumEncoderLayers = r.ReadInt32(); _options.NumAttentionHeads = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.VocabSize = r.ReadInt32(); _options.MaxTextLength = r.ReadInt32(); _options.DropoutRate = r.ReadDouble(); _options.Language = r.ReadString(); base.SampleRate = _options.SampleRate; base.NumMels = _options.NumMels; if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions); }
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() { if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp)) return new WavLMRobust<T>(Architecture, mp, _options); return new WavLMRobust<T>(Architecture, _options); }
+
+
 
     private (List<int> tokens, double confidence) CTCGreedyDecodeWithConfidence(Tensor<T> logits) { var tokens = new List<int>(); double totalConf = 0; int confCount = 0; int prevToken = -1; int numFrames = logits.Rank >= 2 ? logits.Shape[0] : 1; int vocabSize = logits.Rank >= 2 ? logits.Shape[^1] : logits.Shape[0]; for (int t = 0; t < numFrames && tokens.Count < _options.MaxTextLength; t++) { int maxIdx = 0; double maxVal = double.NegativeInfinity; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); if (val > maxVal) { maxVal = val; maxIdx = v; } } double sumExp = 0; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); sumExp += Math.Exp(val - maxVal); } double frameConf = 1.0 / sumExp; if (maxIdx != prevToken && maxIdx > 0) { tokens.Add(maxIdx); totalConf += frameConf; confCount++; } prevToken = maxIdx; } return (tokens, confCount > 0 ? totalConf / confCount : 0.0); }
     private static string TokensToText(List<int> tokens) { var sb = new System.Text.StringBuilder(); foreach (var t in tokens) { if (t > 0 && t <= char.MaxValue) sb.Append((char)t); else if (t > char.MaxValue && t <= 0x10FFFF) sb.Append(char.ConvertFromUtf32(t)); } return sb.ToString().Trim(); }
diff --git a/src/SpeechRecognition/Specialized/CodeSwitchingASR.cs b/src/SpeechRecognition/Specialized/CodeSwitchingASR.cs
index 1aa84eb516..5908487175 100644
--- a/src/SpeechRecognition/Specialized/CodeSwitchingASR.cs
+++ b/src/SpeechRecognition/Specialized/CodeSwitchingASR.cs
@@ -597,49 +597,6 @@ protected override Tensor<T> PreprocessAudio(Tensor<T> rawAudio)
         AdditionalInfo = BaseAudioMetadataInfo()
     };
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty);
-        w.Write(_options.SampleRate); w.Write(_options.MaxAudioLengthSeconds);
-        w.Write(_options.EncoderDim); w.Write(_options.NumEncoderLayers);
-        w.Write(_options.NumAttentionHeads); w.Write(_options.NumMels);
-        w.Write(_options.MandarinCharVocabSize); w.Write(_options.EnglishBpeVocabSize); w.Write(_options.VocabSize);
-        w.Write(_options.MaxTextLength); w.Write(_options.DropoutRate); w.Write(_options.Language);
-        w.Write(_options.CtcWeight); w.Write(_options.LidWeight);
-        w.Write(_options.DecoderDim); w.Write(_options.NumDecoderLayers);
-        w.Write(_options.SharedLidAttention);
-    }
-
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean();
-        string mp = r.ReadString();
-        if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.SampleRate = r.ReadInt32(); _options.MaxAudioLengthSeconds = r.ReadInt32();
-        _options.EncoderDim = r.ReadInt32(); _options.NumEncoderLayers = r.ReadInt32();
-        _options.NumAttentionHeads = r.ReadInt32(); _options.NumMels = r.ReadInt32();
-        _options.MandarinCharVocabSize = r.ReadInt32(); _options.EnglishBpeVocabSize = r.ReadInt32(); _options.VocabSize = r.ReadInt32();
-        _options.MaxTextLength = r.ReadInt32(); _options.DropoutRate = r.ReadDouble();
-        _options.Language = r.ReadString();
-        _options.CtcWeight = r.ReadDouble(); _options.LidWeight = r.ReadDouble();
-        _options.DecoderDim = r.ReadInt32(); _options.NumDecoderLayers = r.ReadInt32();
-        _options.SharedLidAttention = r.ReadBoolean();
-
-        base.SampleRate = _options.SampleRate;
-        base.NumMels = _options.NumMels;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions);
-
-        // The base deserializer replaced every entry of Layers, so the sub-network views point at
-        // discarded weights until they are rebound.
-        if (_useNativeMode) BindSubNetworkViews(customLayers: Architecture.Layers is { Count: > 0 });
-    }
-
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-        => !_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp)
-            ? new CodeSwitchingASR<T>(Architecture, mp, _options)
-            : new CodeSwitchingASR<T>(Architecture, _options);
-
     #endregion
 
     #region Decoding helpers
diff --git a/src/SpeechRecognition/Specialized/KeywordSpotting.cs b/src/SpeechRecognition/Specialized/KeywordSpotting.cs
index 7ad0b3a0aa..72dd30d589 100644
--- a/src/SpeechRecognition/Specialized/KeywordSpotting.cs
+++ b/src/SpeechRecognition/Specialized/KeywordSpotting.cs
@@ -41,7 +41,7 @@ namespace AiDotNet.SpeechRecognition.Specialized;
 [ModelComplexity(ModelComplexity.Low)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Small-footprint Keyword Spotting Using Deep Neural Networks", "https://doi.org/10.1109/ICASSP.2014.6854370")]
-public class KeywordSpotting<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
+public partial class KeywordSpotting<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
 {
     private readonly KeywordSpottingOptions _options; public override ModelOptions GetOptions() => _options;
     private IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer; private bool _useNativeMode; private bool _disposed;
@@ -102,9 +102,8 @@ public TranscriptionResult<T> Transcribe(Tensor<T> audio, string? language = nul
     protected override bool SupportsParameterMutation => _useNativeMode;
     protected override Tensor<T> PostprocessOutput(Tensor<T> o) => o;
     public override ModelMetadata<T> GetModelMetadata() => new() { Name = _useNativeMode ? "KeywordSpotting-Native" : "KeywordSpotting-ONNX", Description = "Keyword Spotting: lightweight wake-word detection (2023)", FeatureCount = _options.NumMels, Complexity = _options.NumEncoderLayers, AdditionalInfo = BaseAudioMetadataInfo() };
-    protected override void SerializeNetworkSpecificData(BinaryWriter w) { w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty); w.Write(_options.SampleRate); w.Write(_options.EncoderDim); w.Write(_options.NumEncoderLayers); w.Write(_options.NumAttentionHeads); w.Write(_options.NumMels); w.Write(_options.VocabSize); w.Write(_options.MaxTextLength); w.Write(_options.DropoutRate); w.Write(_options.Language); }
-    protected override void DeserializeNetworkSpecificData(BinaryReader r) { _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp; _options.SampleRate = r.ReadInt32(); _options.EncoderDim = r.ReadInt32(); _options.NumEncoderLayers = r.ReadInt32(); _options.NumAttentionHeads = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.VocabSize = r.ReadInt32(); _options.MaxTextLength = r.ReadInt32(); _options.DropoutRate = r.ReadDouble(); _options.Language = r.ReadString(); base.SampleRate = _options.SampleRate; base.NumMels = _options.NumMels; if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions); }
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() { if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp)) return new KeywordSpotting<T>(Architecture, mp, _options); return new KeywordSpotting<T>(Architecture, _options); }
+
+
 
     private (List<int> tokens, double confidence) CTCGreedyDecodeWithConfidence(Tensor<T> logits) { var tokens = new List<int>(); double totalConf = 0; int confCount = 0; int prevToken = -1; int numFrames = logits.Rank >= 2 ? logits.Shape[0] : 1; int vocabSize = logits.Rank >= 2 ? logits.Shape[^1] : logits.Shape[0]; for (int t = 0; t < numFrames && tokens.Count < _options.MaxTextLength; t++) { int maxIdx = 0; double maxVal = double.NegativeInfinity; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); if (val > maxVal) { maxVal = val; maxIdx = v; } } double sumExp = 0; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); sumExp += Math.Exp(val - maxVal); } double frameConf = 1.0 / sumExp; if (maxIdx != prevToken && maxIdx > 0) { tokens.Add(maxIdx); totalConf += frameConf; confCount++; } prevToken = maxIdx; } return (tokens, confCount > 0 ? totalConf / confCount : 0.0); }
     private static string TokensToText(List<int> tokens) { var sb = new System.Text.StringBuilder(); foreach (var t in tokens) { if (t > 0 && t <= char.MaxValue) sb.Append((char)t); else if (t > char.MaxValue && t <= 0x10FFFF) sb.Append(char.ConvertFromUtf32(t)); } return sb.ToString().Trim(); }
diff --git a/src/SpeechRecognition/Specialized/MedicalASR.cs b/src/SpeechRecognition/Specialized/MedicalASR.cs
index d9d3582848..2a6312f4c4 100644
--- a/src/SpeechRecognition/Specialized/MedicalASR.cs
+++ b/src/SpeechRecognition/Specialized/MedicalASR.cs
@@ -304,8 +304,8 @@ public override Dictionary<string, Tensor<T>> GetNamedLayerActivations(Tensor<T>
     protected override bool SupportsParameterMutation => _useNativeMode;
     protected override Tensor<T> PostprocessOutput(Tensor<T> o) => o;
     public override ModelMetadata<T> GetModelMetadata() => new() { Name = _useNativeMode ? "MedicalASR-Native" : "MedicalASR-ONNX", Description = "Medical ASR: clinical speech recognition (2024)", FeatureCount = _options.NumMels, Complexity = _options.NumEncoderLayers, AdditionalInfo = BaseAudioMetadataInfo() };
-    protected override void SerializeNetworkSpecificData(BinaryWriter w) { w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty); w.Write(_options.SampleRate); w.Write(_options.EncoderDim); w.Write(_options.NumEncoderLayers); w.Write(_options.NumAttentionHeads); w.Write(_options.NumMels); w.Write(_options.VocabSize); w.Write(_options.MaxTextLength); w.Write(_options.DropoutRate); w.Write(_options.Language); w.Write((int)_options.DecoderType); w.Write(_options.PyramidalReductions); w.Write(_options.DecoderDim); w.Write(_options.NumDecoderLayers); }
-    protected override void DeserializeNetworkSpecificData(BinaryReader r) { _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp; _options.SampleRate = r.ReadInt32(); _options.EncoderDim = r.ReadInt32(); _options.NumEncoderLayers = r.ReadInt32(); _options.NumAttentionHeads = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.VocabSize = r.ReadInt32(); _options.MaxTextLength = r.ReadInt32(); _options.DropoutRate = r.ReadDouble(); _options.Language = r.ReadString(); _options.DecoderType = (AiDotNet.Enums.MedicalAsrDecoderType)r.ReadInt32(); _options.PyramidalReductions = r.ReadInt32(); _options.DecoderDim = r.ReadInt32(); _options.NumDecoderLayers = r.ReadInt32(); base.SampleRate = _options.SampleRate; base.NumMels = _options.NumMels; if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions);  RebindSubNetworkViews(); }
+
+
 
     /// <summary>
     /// Rebinds the listener/speller views into <c>Layers</c> from the current layer instances.
@@ -338,8 +338,6 @@ private void RebindSubNetworkViews()
         for (int i = listenerCount; i < Layers.Count; i++) _spellerLayers.Add(Layers[i]);
     }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() { if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp)) return new MedicalASR<T>(Architecture, mp, _options); return new MedicalASR<T>(Architecture, _options); }
-
     private (List<int> tokens, double confidence) CTCGreedyDecodeWithConfidence(Tensor<T> logits) { var tokens = new List<int>(); double totalConf = 0; int confCount = 0; int prevToken = -1; int numFrames = logits.Rank >= 2 ? logits.Shape[0] : 1; int vocabSize = logits.Rank >= 2 ? logits.Shape[^1] : logits.Shape[0]; for (int t = 0; t < numFrames && tokens.Count < _options.MaxTextLength; t++) { int maxIdx = 0; double maxVal = double.NegativeInfinity; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); if (val > maxVal) { maxVal = val; maxIdx = v; } } double sumExp = 0; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); sumExp += Math.Exp(val - maxVal); } double frameConf = 1.0 / sumExp; if (maxIdx != prevToken && maxIdx > 0) { tokens.Add(maxIdx); totalConf += frameConf; confCount++; } prevToken = maxIdx; } return (tokens, confCount > 0 ? totalConf / confCount : 0.0); }
     private static string TokensToText(List<int> tokens) { var sb = new System.Text.StringBuilder(); foreach (var t in tokens) { if (t > 0 && t <= char.MaxValue) sb.Append((char)t); else if (t > char.MaxValue && t <= 0x10FFFF) sb.Append(char.ConvertFromUtf32(t)); } return sb.ToString().Trim(); }
     private IReadOnlyList<TranscriptionSegment<T>> ExtractSegments(string text, double duration, List<int> tokens, double confidence) { if (string.IsNullOrWhiteSpace(text) || tokens.Count == 0) return Array.Empty<TranscriptionSegment<T>>(); double timePerToken = duration / tokens.Count; var segments = new List<TranscriptionSegment<T>>(); var sb = new System.Text.StringBuilder(); double segStart = 0; for (int i = 0; i < tokens.Count; i++) { if (tokens[i] > 0 && tokens[i] <= char.MaxValue) sb.Append((char)tokens[i]); if ((tokens[i] == ' ' || i == tokens.Count - 1) && sb.Length > 0) { segments.Add(new TranscriptionSegment<T> { Text = sb.ToString().Trim(), StartTime = segStart, EndTime = (i + 1) * timePerToken, Confidence = NumOps.FromDouble(confidence) }); sb.Clear(); segStart = (i + 1) * timePerToken; } } if (segments.Count == 0) segments.Add(new TranscriptionSegment<T> { Text = text, StartTime = 0.0, EndTime = duration, Confidence = NumOps.FromDouble(confidence) }); return segments; }
diff --git a/src/SpeechRecognition/Specialized/SpeakerDiarizedASR.cs b/src/SpeechRecognition/Specialized/SpeakerDiarizedASR.cs
index dcbfbb11d8..a4f59a3be9 100644
--- a/src/SpeechRecognition/Specialized/SpeakerDiarizedASR.cs
+++ b/src/SpeechRecognition/Specialized/SpeakerDiarizedASR.cs
@@ -41,7 +41,7 @@ namespace AiDotNet.SpeechRecognition.Specialized;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Speaker Diarization: A Review of Recent Research", "https://doi.org/10.1109/TASLP.2012.2209910")]
-public class SpeakerDiarizedASR<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
+public partial class SpeakerDiarizedASR<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
 {
     private readonly SpeakerDiarizedASROptions _options; public override ModelOptions GetOptions() => _options;
     private IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer; private bool _useNativeMode; private bool _disposed;
@@ -102,9 +102,8 @@ public TranscriptionResult<T> Transcribe(Tensor<T> audio, string? language = nul
     protected override bool SupportsParameterMutation => _useNativeMode;
     protected override Tensor<T> PostprocessOutput(Tensor<T> o) => o;
     public override ModelMetadata<T> GetModelMetadata() => new() { Name = _useNativeMode ? "SpeakerDiarizedASR-Native" : "SpeakerDiarizedASR-ONNX", Description = "Speaker-Diarized ASR: SA-SOT multi-talker (2024)", FeatureCount = _options.NumMels, Complexity = _options.NumEncoderLayers, AdditionalInfo = BaseAudioMetadataInfo() };
-    protected override void SerializeNetworkSpecificData(BinaryWriter w) { w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty); w.Write(_options.SampleRate); w.Write(_options.MaxAudioLengthSeconds); w.Write(_options.EncoderDim); w.Write(_options.NumEncoderLayers); w.Write(_options.NumAttentionHeads); w.Write(_options.NumMels); w.Write(_options.VocabSize); w.Write(_options.MaxTextLength); w.Write(_options.DropoutRate); w.Write(_options.Language); }
-    protected override void DeserializeNetworkSpecificData(BinaryReader r) { _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp; _options.SampleRate = r.ReadInt32(); _options.MaxAudioLengthSeconds = r.ReadInt32(); _options.EncoderDim = r.ReadInt32(); _options.NumEncoderLayers = r.ReadInt32(); _options.NumAttentionHeads = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.VocabSize = r.ReadInt32(); _options.MaxTextLength = r.ReadInt32(); _options.DropoutRate = r.ReadDouble(); _options.Language = r.ReadString(); base.SampleRate = _options.SampleRate; base.NumMels = _options.NumMels; if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions); }
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() { if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp)) return new SpeakerDiarizedASR<T>(Architecture, mp, _options); return new SpeakerDiarizedASR<T>(Architecture, _options); }
+
+
 
     private (List<int> tokens, double confidence) CTCGreedyDecodeWithConfidence(Tensor<T> logits) { var tokens = new List<int>(); double totalConf = 0; int confCount = 0; int prevToken = -1; int numFrames = logits.Rank >= 2 ? logits.Shape[0] : 1; int vocabSize = logits.Rank >= 2 ? logits.Shape[^1] : logits.Shape[0]; for (int t = 0; t < numFrames && tokens.Count < _options.MaxTextLength; t++) { int maxIdx = 0; double maxVal = double.NegativeInfinity; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); if (val > maxVal) { maxVal = val; maxIdx = v; } } double sumExp = 0; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); sumExp += Math.Exp(val - maxVal); } double frameConf = 1.0 / sumExp; if (maxIdx != prevToken && maxIdx > 0) { tokens.Add(maxIdx); totalConf += frameConf; confCount++; } prevToken = maxIdx; } return (tokens, confCount > 0 ? totalConf / confCount : 0.0); }
     private static string TokensToText(List<int> tokens) { var sb = new System.Text.StringBuilder(); foreach (var t in tokens) { if (t > 0 && t <= char.MaxValue) sb.Append((char)t); else if (t > char.MaxValue && t <= 0x10FFFF) sb.Append(char.ConvertFromUtf32(t)); } return sb.ToString().Trim(); }
diff --git a/src/SpeechRecognition/Specialized/VoxtLM.cs b/src/SpeechRecognition/Specialized/VoxtLM.cs
index 5088e99b20..8cc0ac179c 100644
--- a/src/SpeechRecognition/Specialized/VoxtLM.cs
+++ b/src/SpeechRecognition/Specialized/VoxtLM.cs
@@ -116,9 +116,8 @@ public TranscriptionResult<T> Transcribe(Tensor<T> audio, string? language = nul
     protected override bool SupportsParameterMutation => _useNativeMode;
     protected override Tensor<T> PostprocessOutput(Tensor<T> o) => o;
     public override ModelMetadata<T> GetModelMetadata() => new() { Name = _useNativeMode ? "VoxtLM-Native" : "VoxtLM-ONNX", Description = "VoxtLM: unified decoder-only ASR/TTS (2024)", FeatureCount = _options.NumMels, Complexity = _options.NumEncoderLayers, AdditionalInfo = BaseAudioMetadataInfo() };
-    protected override void SerializeNetworkSpecificData(BinaryWriter w) { w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty); w.Write(_options.SampleRate); w.Write(_options.MaxAudioLengthSeconds); w.Write(_options.EncoderDim); w.Write(_options.NumEncoderLayers); w.Write(_options.NumAttentionHeads); w.Write(_options.NumMels); w.Write(_options.VocabSize); w.Write(_options.MaxTextLength); w.Write(_options.DropoutRate); w.Write(_options.Language); }
-    protected override void DeserializeNetworkSpecificData(BinaryReader r) { _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp; _options.SampleRate = r.ReadInt32(); _options.MaxAudioLengthSeconds = r.ReadInt32(); _options.EncoderDim = r.ReadInt32(); _options.NumEncoderLayers = r.ReadInt32(); _options.NumAttentionHeads = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.VocabSize = r.ReadInt32(); _options.MaxTextLength = r.ReadInt32(); _options.DropoutRate = r.ReadDouble(); _options.Language = r.ReadString(); base.SampleRate = _options.SampleRate; base.NumMels = _options.NumMels; if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions); }
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() { var options = new VoxtLMOptions(_options); if (!_useNativeMode && options.ModelPath is { } mp && !string.IsNullOrEmpty(mp)) return new VoxtLM<T>(Architecture, mp, options); return new VoxtLM<T>(Architecture, options); }
+
+
 
     private (List<int> tokens, double confidence) CTCGreedyDecodeWithConfidence(Tensor<T> logits) { var tokens = new List<int>(); double totalConf = 0; int confCount = 0; int prevToken = -1; int numFrames = logits.Rank >= 2 ? logits.Shape[0] : 1; int vocabSize = logits.Rank >= 2 ? logits.Shape[^1] : logits.Shape[0]; for (int t = 0; t < numFrames && tokens.Count < _options.MaxTextLength; t++) { int maxIdx = 0; double maxVal = double.NegativeInfinity; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); if (val > maxVal) { maxVal = val; maxIdx = v; } } double sumExp = 0; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); sumExp += Math.Exp(val - maxVal); } double frameConf = 1.0 / sumExp; if (maxIdx != prevToken && maxIdx > 0) { tokens.Add(maxIdx); totalConf += frameConf; confCount++; } prevToken = maxIdx; } return (tokens, confCount > 0 ? totalConf / confCount : 0.0); }
     private static string TokensToText(List<int> tokens) { var sb = new System.Text.StringBuilder(); foreach (var t in tokens) { if (t > 0 && t <= char.MaxValue) sb.Append((char)t); else if (t > char.MaxValue && t <= 0x10FFFF) sb.Append(char.ConvertFromUtf32(t)); } return sb.ToString().Trim(); }
diff --git a/src/SpeechRecognition/Specialized/WhisperCPP.cs b/src/SpeechRecognition/Specialized/WhisperCPP.cs
index 336ea0c70b..16d5a6789b 100644
--- a/src/SpeechRecognition/Specialized/WhisperCPP.cs
+++ b/src/SpeechRecognition/Specialized/WhisperCPP.cs
@@ -41,7 +41,7 @@ namespace AiDotNet.SpeechRecognition.Specialized;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Robust Speech Recognition via Large-Scale Weak Supervision", "https://arxiv.org/abs/2212.04356", Year = 2023, Authors = "Radford et al.")]
-public class WhisperCPP<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
+public partial class WhisperCPP<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
 {
     private readonly WhisperCPPOptions _options; public override ModelOptions GetOptions() => _options;
     private IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer; private bool _useNativeMode; private bool _disposed;
@@ -102,9 +102,8 @@ public TranscriptionResult<T> Transcribe(Tensor<T> audio, string? language = nul
     protected override bool SupportsParameterMutation => _useNativeMode;
     protected override Tensor<T> PostprocessOutput(Tensor<T> o) => o;
     public override ModelMetadata<T> GetModelMetadata() => new() { Name = _useNativeMode ? "WhisperCPP-Native" : "WhisperCPP-ONNX", Description = "Whisper.cpp: optimized C++ Whisper inference (2022-2025)", FeatureCount = _options.NumMels, Complexity = _options.NumEncoderLayers, AdditionalInfo = BaseAudioMetadataInfo() };
-    protected override void SerializeNetworkSpecificData(BinaryWriter w) { w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty); w.Write(_options.SampleRate); w.Write(_options.MaxAudioLengthSeconds); w.Write(_options.EncoderDim); w.Write(_options.NumEncoderLayers); w.Write(_options.NumAttentionHeads); w.Write(_options.NumMels); w.Write(_options.VocabSize); w.Write(_options.MaxTextLength); w.Write(_options.DropoutRate); w.Write(_options.Language); }
-    protected override void DeserializeNetworkSpecificData(BinaryReader r) { _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp; _options.SampleRate = r.ReadInt32(); _options.MaxAudioLengthSeconds = r.ReadInt32(); _options.EncoderDim = r.ReadInt32(); _options.NumEncoderLayers = r.ReadInt32(); _options.NumAttentionHeads = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.VocabSize = r.ReadInt32(); _options.MaxTextLength = r.ReadInt32(); _options.DropoutRate = r.ReadDouble(); _options.Language = r.ReadString(); base.SampleRate = _options.SampleRate; base.NumMels = _options.NumMels; if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions); }
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() { if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp)) return new WhisperCPP<T>(Architecture, mp, _options); return new WhisperCPP<T>(Architecture, _options); }
+
+
 
     private (List<int> tokens, double confidence) CTCGreedyDecodeWithConfidence(Tensor<T> logits) { var tokens = new List<int>(); double totalConf = 0; int confCount = 0; int prevToken = -1; int numFrames = logits.Rank >= 2 ? logits.Shape[0] : 1; int vocabSize = logits.Rank >= 2 ? logits.Shape[^1] : logits.Shape[0]; for (int t = 0; t < numFrames && tokens.Count < _options.MaxTextLength; t++) { int maxIdx = 0; double maxVal = double.NegativeInfinity; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); if (val > maxVal) { maxVal = val; maxIdx = v; } } double sumExp = 0; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); sumExp += Math.Exp(val - maxVal); } double frameConf = 1.0 / sumExp; if (maxIdx != prevToken && maxIdx > 0) { tokens.Add(maxIdx); totalConf += frameConf; confCount++; } prevToken = maxIdx; } return (tokens, confCount > 0 ? totalConf / confCount : 0.0); }
     private static string TokensToText(List<int> tokens) { var sb = new System.Text.StringBuilder(); foreach (var t in tokens) { if (t > 0 && t <= char.MaxValue) sb.Append((char)t); else if (t > char.MaxValue && t <= 0x10FFFF) sb.Append(char.ConvertFromUtf32(t)); } return sb.ToString().Trim(); }
diff --git a/src/SpeechRecognition/Streaming/EmformerRNNT.cs b/src/SpeechRecognition/Streaming/EmformerRNNT.cs
index 5378e16c2e..fc3f156c88 100644
--- a/src/SpeechRecognition/Streaming/EmformerRNNT.cs
+++ b/src/SpeechRecognition/Streaming/EmformerRNNT.cs
@@ -41,7 +41,7 @@ namespace AiDotNet.SpeechRecognition.Streaming;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Emformer: Efficient Memory Transformer Based Acoustic Model for Low Latency Streaming Speech Recognition", "https://arxiv.org/abs/2010.10759", Year = 2021, Authors = "Shi et al.")]
-public class EmformerRNNT<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
+public partial class EmformerRNNT<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
 {
     private readonly EmformerRNNTOptions _options; public override ModelOptions GetOptions() => _options;
     private IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer; private bool _useNativeMode; private bool _disposed;
@@ -102,20 +102,8 @@ public TranscriptionResult<T> Transcribe(Tensor<T> audio, string? language = nul
     protected override bool SupportsParameterMutation => _useNativeMode;
     protected override Tensor<T> PostprocessOutput(Tensor<T> o) => o;
     public override ModelMetadata<T> GetModelMetadata() => new() { Name = _useNativeMode ? "EmformerRNNT-Native" : "EmformerRNNT-ONNX", Description = "Emformer-RNNT: memory Transformer + RNN-T (Meta, 2021)", FeatureCount = _options.NumMels, Complexity = _options.NumEncoderLayers, AdditionalInfo = BaseAudioMetadataInfo() };
-    protected override void SerializeNetworkSpecificData(BinaryWriter w) { w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty); w.Write(_options.SampleRate); w.Write(_options.MaxAudioLengthSeconds); w.Write(_options.EncoderDim); w.Write(_options.NumEncoderLayers); w.Write(_options.NumAttentionHeads); w.Write(_options.NumMels); w.Write(_options.VocabSize); w.Write(_options.MaxTextLength); w.Write(_options.DropoutRate); w.Write(_options.Language); }
-    protected override void DeserializeNetworkSpecificData(BinaryReader r) { _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp; _options.SampleRate = r.ReadInt32(); _options.MaxAudioLengthSeconds = r.ReadInt32(); _options.EncoderDim = r.ReadInt32(); _options.NumEncoderLayers = r.ReadInt32(); _options.NumAttentionHeads = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.VocabSize = r.ReadInt32(); _options.MaxTextLength = r.ReadInt32(); _options.DropoutRate = r.ReadDouble(); _options.Language = r.ReadString(); base.SampleRate = _options.SampleRate; base.NumMels = _options.NumMels; if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions); }
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new EmformerRNNT<T>(Architecture, mp, new EmformerRNNTOptions(_options));
 
-        var cloneOptimizer = _optimizer?.GetOptions() is AdamWOptimizerOptions<T, Tensor<T>, Tensor<T>> options
-            ? new AdamWOptimizer<T, Tensor<T>, Tensor<T>>(
-                null,
-                new AdamWOptimizerOptions<T, Tensor<T>, Tensor<T>>(options))
-            : null;
-        return new EmformerRNNT<T>(Architecture, new EmformerRNNTOptions(_options), cloneOptimizer);
-    }
+
 
     private (List<int> tokens, double confidence) CTCGreedyDecodeWithConfidence(Tensor<T> logits) { var tokens = new List<int>(); double totalConf = 0; int confCount = 0; int prevToken = -1; int numFrames = logits.Rank >= 2 ? logits.Shape[0] : 1; int vocabSize = logits.Rank >= 2 ? logits.Shape[^1] : logits.Shape[0]; for (int t = 0; t < numFrames && tokens.Count < _options.MaxTextLength; t++) { int maxIdx = 0; double maxVal = double.NegativeInfinity; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); if (val > maxVal) { maxVal = val; maxIdx = v; } } double sumExp = 0; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); sumExp += Math.Exp(val - maxVal); } double frameConf = 1.0 / sumExp; if (maxIdx != prevToken && maxIdx > 0) { tokens.Add(maxIdx); totalConf += frameConf; confCount++; } prevToken = maxIdx; } return (tokens, confCount > 0 ? totalConf / confCount : 0.0); }
     private static string TokensToText(List<int> tokens) { var sb = new System.Text.StringBuilder(); foreach (var t in tokens) { if (t > 0 && t <= char.MaxValue) sb.Append((char)t); else if (t > char.MaxValue && t <= 0x10FFFF) sb.Append(char.ConvertFromUtf32(t)); } return sb.ToString().Trim(); }
diff --git a/src/SpeechRecognition/Streaming/FastEmit.cs b/src/SpeechRecognition/Streaming/FastEmit.cs
index 964e95736b..8baf0e7ba8 100644
--- a/src/SpeechRecognition/Streaming/FastEmit.cs
+++ b/src/SpeechRecognition/Streaming/FastEmit.cs
@@ -41,7 +41,7 @@ namespace AiDotNet.SpeechRecognition.Streaming;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("FastEmit: Low-latency Streaming ASR with Sequence-level Emission Regularization", "https://arxiv.org/abs/2010.11148", Year = 2021, Authors = "Yu et al.")]
-public class FastEmit<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
+public partial class FastEmit<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
 {
     private readonly FastEmitOptions _options; public override ModelOptions GetOptions() => _options;
     private IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer; private bool _useNativeMode; private bool _disposed;
@@ -102,20 +102,8 @@ public TranscriptionResult<T> Transcribe(Tensor<T> audio, string? language = nul
     protected override bool SupportsParameterMutation => _useNativeMode;
     protected override Tensor<T> PostprocessOutput(Tensor<T> o) => o;
     public override ModelMetadata<T> GetModelMetadata() => new() { Name = _useNativeMode ? "FastEmit-Native" : "FastEmit-ONNX", Description = "FastEmit: emission-regularized RNN-T (Google, 2021)", FeatureCount = _options.NumMels, Complexity = _options.NumEncoderLayers, AdditionalInfo = BaseAudioMetadataInfo() };
-    protected override void SerializeNetworkSpecificData(BinaryWriter w) { w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty); w.Write(_options.SampleRate); w.Write(_options.MaxAudioLengthSeconds); w.Write(_options.EncoderDim); w.Write(_options.NumEncoderLayers); w.Write(_options.NumAttentionHeads); w.Write(_options.NumMels); w.Write(_options.VocabSize); w.Write(_options.MaxTextLength); w.Write(_options.DropoutRate); w.Write(_options.Language); }
-    protected override void DeserializeNetworkSpecificData(BinaryReader r) { _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp; _options.SampleRate = r.ReadInt32(); _options.MaxAudioLengthSeconds = r.ReadInt32(); _options.EncoderDim = r.ReadInt32(); _options.NumEncoderLayers = r.ReadInt32(); _options.NumAttentionHeads = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.VocabSize = r.ReadInt32(); _options.MaxTextLength = r.ReadInt32(); _options.DropoutRate = r.ReadDouble(); _options.Language = r.ReadString(); base.SampleRate = _options.SampleRate; base.NumMels = _options.NumMels; if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions); }
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new FastEmit<T>(Architecture, mp, new FastEmitOptions(_options));
 
-        var cloneOptimizer = _optimizer?.GetOptions() is AdamWOptimizerOptions<T, Tensor<T>, Tensor<T>> options
-            ? new AdamWOptimizer<T, Tensor<T>, Tensor<T>>(
-                null,
-                new AdamWOptimizerOptions<T, Tensor<T>, Tensor<T>>(options))
-            : null;
-        return new FastEmit<T>(Architecture, new FastEmitOptions(_options), cloneOptimizer);
-    }
+
 
     private (List<int> tokens, double confidence) CTCGreedyDecodeWithConfidence(Tensor<T> logits) { var tokens = new List<int>(); double totalConf = 0; int confCount = 0; int prevToken = -1; int numFrames = logits.Rank >= 2 ? logits.Shape[0] : 1; int vocabSize = logits.Rank >= 2 ? logits.Shape[^1] : logits.Shape[0]; for (int t = 0; t < numFrames && tokens.Count < _options.MaxTextLength; t++) { int maxIdx = 0; double maxVal = double.NegativeInfinity; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); if (val > maxVal) { maxVal = val; maxIdx = v; } } double sumExp = 0; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); sumExp += Math.Exp(val - maxVal); } double frameConf = 1.0 / sumExp; if (maxIdx != prevToken && maxIdx > 0) { tokens.Add(maxIdx); totalConf += frameConf; confCount++; } prevToken = maxIdx; } return (tokens, confCount > 0 ? totalConf / confCount : 0.0); }
     private static string TokensToText(List<int> tokens) { var sb = new System.Text.StringBuilder(); foreach (var t in tokens) { if (t > 0 && t <= char.MaxValue) sb.Append((char)t); else if (t > char.MaxValue && t <= 0x10FFFF) sb.Append(char.ConvertFromUtf32(t)); } return sb.ToString().Trim(); }
diff --git a/src/SpeechRecognition/Streaming/KyutaiMoshi.cs b/src/SpeechRecognition/Streaming/KyutaiMoshi.cs
index 0fb8590663..16e3b04f76 100644
--- a/src/SpeechRecognition/Streaming/KyutaiMoshi.cs
+++ b/src/SpeechRecognition/Streaming/KyutaiMoshi.cs
@@ -134,9 +134,8 @@ public override void Train(Tensor<T> input, Tensor<T> expected) {
     protected override bool SupportsParameterMutation => _useNativeMode;
     protected override Tensor<T> PostprocessOutput(Tensor<T> o) => o;
     public override ModelMetadata<T> GetModelMetadata() => new() { Name = _useNativeMode ? "KyutaiMoshi-Native" : "KyutaiMoshi-ONNX", Description = "Moshi: full-duplex speech-text dialogue (Kyutai, 2024)", FeatureCount = _options.NumMels, Complexity = _options.NumEncoderLayers, AdditionalInfo = BaseAudioMetadataInfo() };
-    protected override void SerializeNetworkSpecificData(BinaryWriter w) { w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty); w.Write(_options.SampleRate); w.Write(_options.MaxAudioLengthSeconds); w.Write(_options.EncoderDim); w.Write(_options.NumEncoderLayers); w.Write(_options.NumAttentionHeads); w.Write(_options.NumMels); w.Write(_options.VocabSize); w.Write(_options.MaxTextLength); w.Write(_options.DropoutRate); w.Write(_options.Language); }
-    protected override void DeserializeNetworkSpecificData(BinaryReader r) { _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp; _options.SampleRate = r.ReadInt32(); _options.MaxAudioLengthSeconds = r.ReadInt32(); _options.EncoderDim = r.ReadInt32(); _options.NumEncoderLayers = r.ReadInt32(); _options.NumAttentionHeads = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.VocabSize = r.ReadInt32(); _options.MaxTextLength = r.ReadInt32(); _options.DropoutRate = r.ReadDouble(); _options.Language = r.ReadString(); base.SampleRate = _options.SampleRate; base.NumMels = _options.NumMels; if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions); }
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() { if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp)) return new KyutaiMoshi<T>(Architecture, mp, _options); return new KyutaiMoshi<T>(Architecture, _options); }
+
+
 
     private (List<int> tokens, double confidence) CTCGreedyDecodeWithConfidence(Tensor<T> logits) { var tokens = new List<int>(); double totalConf = 0; int confCount = 0; int prevToken = -1; int numFrames = logits.Rank >= 2 ? logits.Shape[0] : 1; int vocabSize = logits.Rank >= 2 ? logits.Shape[^1] : logits.Shape[0]; for (int t = 0; t < numFrames && tokens.Count < _options.MaxTextLength; t++) { int maxIdx = 0; double maxVal = double.NegativeInfinity; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); if (val > maxVal) { maxVal = val; maxIdx = v; } } double sumExp = 0; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); sumExp += Math.Exp(val - maxVal); } double frameConf = 1.0 / sumExp; if (maxIdx != prevToken && maxIdx > 0) { tokens.Add(maxIdx); totalConf += frameConf; confCount++; } prevToken = maxIdx; } return (tokens, confCount > 0 ? totalConf / confCount : 0.0); }
     private static string TokensToText(List<int> tokens) { var sb = new System.Text.StringBuilder(); foreach (var t in tokens) { if (t > 0 && t <= char.MaxValue) sb.Append((char)t); else if (t > char.MaxValue && t <= 0x10FFFF) sb.Append(char.ConvertFromUtf32(t)); } return sb.ToString().Trim(); }
diff --git a/src/SpeechRecognition/Streaming/Moonshine.cs b/src/SpeechRecognition/Streaming/Moonshine.cs
index bb2c38055f..0570fce5aa 100644
--- a/src/SpeechRecognition/Streaming/Moonshine.cs
+++ b/src/SpeechRecognition/Streaming/Moonshine.cs
@@ -41,7 +41,7 @@ namespace AiDotNet.SpeechRecognition.Streaming;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Moonshine: Speech Recognition for Live Transcription and Voice Commands", "https://arxiv.org/abs/2410.15608", Year = 2024, Authors = "Useful Sensors")]
-public class Moonshine<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
+public partial class Moonshine<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
 {
     private readonly MoonshineOptions _options; public override ModelOptions GetOptions() => _options;
     private IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer; private bool _useNativeMode; private bool _disposed;
@@ -122,9 +122,8 @@ public TranscriptionResult<T> Transcribe(Tensor<T> audio, string? language = nul
             ["Language"] = _options.Language
         }
     };
-    protected override void SerializeNetworkSpecificData(BinaryWriter w) { w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty); w.Write(_options.SampleRate); w.Write(_options.MaxAudioLengthSeconds); w.Write(_options.EncoderDim); w.Write(_options.NumEncoderLayers); w.Write(_options.NumAttentionHeads); w.Write(_options.NumMels); w.Write(_options.VocabSize); w.Write(_options.MaxTextLength); w.Write(_options.DropoutRate); w.Write(_options.Language); }
-    protected override void DeserializeNetworkSpecificData(BinaryReader r) { _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp; _options.SampleRate = r.ReadInt32(); _options.MaxAudioLengthSeconds = r.ReadInt32(); _options.EncoderDim = r.ReadInt32(); _options.NumEncoderLayers = r.ReadInt32(); _options.NumAttentionHeads = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.VocabSize = r.ReadInt32(); _options.MaxTextLength = r.ReadInt32(); _options.DropoutRate = r.ReadDouble(); _options.Language = r.ReadString(); base.SampleRate = _options.SampleRate; base.NumMels = _options.NumMels; if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions); }
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() { if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp)) return new Moonshine<T>(Architecture, mp, _options); return new Moonshine<T>(Architecture, _options); }
+
+
 
     private (List<int> tokens, double confidence) CTCGreedyDecodeWithConfidence(Tensor<T> logits) { var tokens = new List<int>(); double totalConf = 0; int confCount = 0; int prevToken = -1; int numFrames = logits.Rank >= 2 ? logits.Shape[0] : 1; int vocabSize = logits.Rank >= 2 ? logits.Shape[^1] : logits.Shape[0]; for (int t = 0; t < numFrames && tokens.Count < _options.MaxTextLength; t++) { int maxIdx = 0; double maxVal = double.NegativeInfinity; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); if (val > maxVal) { maxVal = val; maxIdx = v; } } double sumExp = 0; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); sumExp += Math.Exp(val - maxVal); } double frameConf = 1.0 / sumExp; if (maxIdx != prevToken && maxIdx > 0) { tokens.Add(maxIdx); totalConf += frameConf; confCount++; } prevToken = maxIdx; } return (tokens, confCount > 0 ? totalConf / confCount : 0.0); }
     private static string TokensToText(List<int> tokens) { var sb = new System.Text.StringBuilder(); foreach (var t in tokens) { if (t > 0 && t <= char.MaxValue) sb.Append((char)t); else if (t > char.MaxValue && t <= 0x10FFFF) sb.Append(char.ConvertFromUtf32(t)); } return sb.ToString().Trim(); }
diff --git a/src/SpeechRecognition/Streaming/MoonshineBase.cs b/src/SpeechRecognition/Streaming/MoonshineBase.cs
index ae177fa883..ae4bbc8066 100644
--- a/src/SpeechRecognition/Streaming/MoonshineBase.cs
+++ b/src/SpeechRecognition/Streaming/MoonshineBase.cs
@@ -41,7 +41,7 @@ namespace AiDotNet.SpeechRecognition.Streaming;
 [ModelComplexity(ModelComplexity.Low)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Moonshine: Speech Recognition for Live Transcription and Voice Commands", "https://arxiv.org/abs/2410.15608", Year = 2024, Authors = "Useful Sensors")]
-public class MoonshineBase<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
+public partial class MoonshineBase<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
 {
     private readonly MoonshineBaseOptions _options; public override ModelOptions GetOptions() => _options;
     private IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer; private bool _useNativeMode; private bool _disposed;
@@ -125,9 +125,8 @@ public TranscriptionResult<T> Transcribe(Tensor<T> audio, string? language = nul
             ["Language"] = SupportedLanguages.Count > 0 ? SupportedLanguages[0] : _options.Language
         }
     };
-    protected override void SerializeNetworkSpecificData(BinaryWriter w) { w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty); w.Write(_options.SampleRate); w.Write(_options.MaxAudioLengthSeconds); w.Write(_options.EncoderDim); w.Write(_options.NumEncoderLayers); w.Write(_options.NumAttentionHeads); w.Write(_options.NumMels); w.Write(_options.VocabSize); w.Write(_options.MaxTextLength); w.Write(_options.DropoutRate); w.Write(_options.Language); }
-    protected override void DeserializeNetworkSpecificData(BinaryReader r) { _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp; _options.SampleRate = r.ReadInt32(); _options.MaxAudioLengthSeconds = r.ReadInt32(); _options.EncoderDim = r.ReadInt32(); _options.NumEncoderLayers = r.ReadInt32(); _options.NumAttentionHeads = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.VocabSize = r.ReadInt32(); _options.MaxTextLength = r.ReadInt32(); _options.DropoutRate = r.ReadDouble(); _options.Language = r.ReadString(); base.SampleRate = _options.SampleRate; base.NumMels = _options.NumMels; if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions); }
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() { if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp)) return new MoonshineBase<T>(Architecture, mp, _options); return new MoonshineBase<T>(Architecture, _options); }
+
+
 
     private (List<int> tokens, double confidence) CTCGreedyDecodeWithConfidence(Tensor<T> logits) { var tokens = new List<int>(); double totalConf = 0; int confCount = 0; int prevToken = -1; int numFrames = logits.Rank >= 2 ? logits.Shape[0] : 1; int vocabSize = logits.Rank >= 2 ? logits.Shape[^1] : logits.Shape[0]; for (int t = 0; t < numFrames && tokens.Count < _options.MaxTextLength; t++) { int maxIdx = 0; double maxVal = double.NegativeInfinity; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); if (val > maxVal) { maxVal = val; maxIdx = v; } } double sumExp = 0; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); sumExp += Math.Exp(val - maxVal); } double frameConf = 1.0 / sumExp; if (maxIdx != prevToken && maxIdx > 0) { tokens.Add(maxIdx); totalConf += frameConf; confCount++; } prevToken = maxIdx; } return (tokens, confCount > 0 ? totalConf / confCount : 0.0); }
     private static string TokensToText(List<int> tokens) { var sb = new System.Text.StringBuilder(); foreach (var t in tokens) { if (t > 0 && t <= char.MaxValue) sb.Append((char)t); else if (t > char.MaxValue && t <= 0x10FFFF) sb.Append(char.ConvertFromUtf32(t)); } return sb.ToString().Trim(); }
diff --git a/src/SpeechRecognition/Streaming/StreamingConformer.cs b/src/SpeechRecognition/Streaming/StreamingConformer.cs
index fcdfa30543..cb6758e86f 100644
--- a/src/SpeechRecognition/Streaming/StreamingConformer.cs
+++ b/src/SpeechRecognition/Streaming/StreamingConformer.cs
@@ -41,7 +41,7 @@ namespace AiDotNet.SpeechRecognition.Streaming;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Conformer: Convolution-augmented Transformer for End-to-End Speech Recognition", "https://arxiv.org/abs/2005.08100", Year = 2020, Authors = "Gulati et al.")]
-public class StreamingConformer<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
+public partial class StreamingConformer<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
 {
     private readonly StreamingConformerOptions _options; public override ModelOptions GetOptions() => _options;
     private IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer; private bool _useNativeMode; private bool _disposed;
@@ -102,9 +102,8 @@ public TranscriptionResult<T> Transcribe(Tensor<T> audio, string? language = nul
     protected override bool SupportsParameterMutation => _useNativeMode;
     protected override Tensor<T> PostprocessOutput(Tensor<T> o) => o;
     public override ModelMetadata<T> GetModelMetadata() => new() { Name = _useNativeMode ? "StreamingConformer-Native" : "StreamingConformer-ONNX", Description = "Streaming Conformer: chunk-based + lookahead (Google, 2023)", FeatureCount = _options.NumMels, Complexity = _options.NumEncoderLayers, AdditionalInfo = BaseAudioMetadataInfo() };
-    protected override void SerializeNetworkSpecificData(BinaryWriter w) { w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty); w.Write(_options.SampleRate); w.Write(_options.MaxAudioLengthSeconds); w.Write(_options.EncoderDim); w.Write(_options.NumEncoderLayers); w.Write(_options.NumAttentionHeads); w.Write(_options.NumMels); w.Write(_options.VocabSize); w.Write(_options.MaxTextLength); w.Write(_options.DropoutRate); w.Write(_options.Language); }
-    protected override void DeserializeNetworkSpecificData(BinaryReader r) { _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp; _options.SampleRate = r.ReadInt32(); _options.MaxAudioLengthSeconds = r.ReadInt32(); _options.EncoderDim = r.ReadInt32(); _options.NumEncoderLayers = r.ReadInt32(); _options.NumAttentionHeads = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.VocabSize = r.ReadInt32(); _options.MaxTextLength = r.ReadInt32(); _options.DropoutRate = r.ReadDouble(); _options.Language = r.ReadString(); base.SampleRate = _options.SampleRate; base.NumMels = _options.NumMels; if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions); }
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() { if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp)) return new StreamingConformer<T>(Architecture, mp, _options); return new StreamingConformer<T>(Architecture, _options); }
+
+
 
     private (List<int> tokens, double confidence) CTCGreedyDecodeWithConfidence(Tensor<T> logits) { var tokens = new List<int>(); double totalConf = 0; int confCount = 0; int prevToken = -1; int numFrames = logits.Rank >= 2 ? logits.Shape[0] : 1; int vocabSize = logits.Rank >= 2 ? logits.Shape[^1] : logits.Shape[0]; for (int t = 0; t < numFrames && tokens.Count < _options.MaxTextLength; t++) { int maxIdx = 0; double maxVal = double.NegativeInfinity; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); if (val > maxVal) { maxVal = val; maxIdx = v; } } double sumExp = 0; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); sumExp += Math.Exp(val - maxVal); } double frameConf = 1.0 / sumExp; if (maxIdx != prevToken && maxIdx > 0) { tokens.Add(maxIdx); totalConf += frameConf; confCount++; } prevToken = maxIdx; } return (tokens, confCount > 0 ? totalConf / confCount : 0.0); }
     private static string TokensToText(List<int> tokens) { var sb = new System.Text.StringBuilder(); foreach (var t in tokens) { if (t > 0 && t <= char.MaxValue) sb.Append((char)t); else if (t > char.MaxValue && t <= 0x10FFFF) sb.Append(char.ConvertFromUtf32(t)); } return sb.ToString().Trim(); }
diff --git a/src/SpeechRecognition/Streaming/StreamingZipformer.cs b/src/SpeechRecognition/Streaming/StreamingZipformer.cs
index 45529faa7a..6a5662def0 100644
--- a/src/SpeechRecognition/Streaming/StreamingZipformer.cs
+++ b/src/SpeechRecognition/Streaming/StreamingZipformer.cs
@@ -41,7 +41,7 @@ namespace AiDotNet.SpeechRecognition.Streaming;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Zipformer: A faster and better encoder for automatic speech recognition", "https://arxiv.org/abs/2310.11230", Year = 2023, Authors = "Yao et al.")]
-public class StreamingZipformer<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
+public partial class StreamingZipformer<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
 {
     private readonly StreamingZipformerOptions _options; public override ModelOptions GetOptions() => _options;
     private IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer; private bool _useNativeMode; private bool _disposed;
@@ -102,9 +102,8 @@ public TranscriptionResult<T> Transcribe(Tensor<T> audio, string? language = nul
     protected override bool SupportsParameterMutation => _useNativeMode;
     protected override Tensor<T> PostprocessOutput(Tensor<T> o) => o;
     public override ModelMetadata<T> GetModelMetadata() => new() { Name = _useNativeMode ? "StreamingZipformer-Native" : "StreamingZipformer-ONNX", Description = "Streaming Zipformer: multi-scale streaming (2023)", FeatureCount = _options.NumMels, Complexity = _options.NumEncoderLayers, AdditionalInfo = BaseAudioMetadataInfo() };
-    protected override void SerializeNetworkSpecificData(BinaryWriter w) { w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty); w.Write(_options.SampleRate); w.Write(_options.MaxAudioLengthSeconds); w.Write(_options.EncoderDim); w.Write(_options.NumEncoderLayers); w.Write(_options.NumAttentionHeads); w.Write(_options.NumMels); w.Write(_options.VocabSize); w.Write(_options.MaxTextLength); w.Write(_options.DropoutRate); w.Write(_options.Language); }
-    protected override void DeserializeNetworkSpecificData(BinaryReader r) { _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp; _options.SampleRate = r.ReadInt32(); _options.MaxAudioLengthSeconds = r.ReadInt32(); _options.EncoderDim = r.ReadInt32(); _options.NumEncoderLayers = r.ReadInt32(); _options.NumAttentionHeads = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.VocabSize = r.ReadInt32(); _options.MaxTextLength = r.ReadInt32(); _options.DropoutRate = r.ReadDouble(); _options.Language = r.ReadString(); base.SampleRate = _options.SampleRate; base.NumMels = _options.NumMels; if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions); }
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() { if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp)) return new StreamingZipformer<T>(Architecture, mp, _options); return new StreamingZipformer<T>(Architecture, _options); }
+
+
 
     private (List<int> tokens, double confidence) CTCGreedyDecodeWithConfidence(Tensor<T> logits) { var tokens = new List<int>(); double totalConf = 0; int confCount = 0; int prevToken = -1; int numFrames = logits.Rank >= 2 ? logits.Shape[0] : 1; int vocabSize = logits.Rank >= 2 ? logits.Shape[^1] : logits.Shape[0]; for (int t = 0; t < numFrames && tokens.Count < _options.MaxTextLength; t++) { int maxIdx = 0; double maxVal = double.NegativeInfinity; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); if (val > maxVal) { maxVal = val; maxIdx = v; } } double sumExp = 0; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); sumExp += Math.Exp(val - maxVal); } double frameConf = 1.0 / sumExp; if (maxIdx != prevToken && maxIdx > 0) { tokens.Add(maxIdx); totalConf += frameConf; confCount++; } prevToken = maxIdx; } return (tokens, confCount > 0 ? totalConf / confCount : 0.0); }
     private static string TokensToText(List<int> tokens) { var sb = new System.Text.StringBuilder(); foreach (var t in tokens) { if (t > 0 && t <= char.MaxValue) sb.Append((char)t); else if (t > char.MaxValue && t <= 0x10FFFF) sb.Append(char.ConvertFromUtf32(t)); } return sb.ToString().Trim(); }
diff --git a/src/SpeechRecognition/Streaming/TDTDecoder.cs b/src/SpeechRecognition/Streaming/TDTDecoder.cs
index 48db98d603..50831f62a9 100644
--- a/src/SpeechRecognition/Streaming/TDTDecoder.cs
+++ b/src/SpeechRecognition/Streaming/TDTDecoder.cs
@@ -41,7 +41,7 @@ namespace AiDotNet.SpeechRecognition.Streaming;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Efficient Sequence Transduction by Jointly Predicting Tokens and Durations", "https://arxiv.org/abs/2304.06795", Year = 2023, Authors = "Xu et al.")]
-public class TDTDecoder<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
+public partial class TDTDecoder<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
 {
     private readonly TDTDecoderOptions _options; public override ModelOptions GetOptions() => _options;
     private IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer; private bool _useNativeMode; private bool _disposed;
@@ -102,9 +102,8 @@ public TranscriptionResult<T> Transcribe(Tensor<T> audio, string? language = nul
     protected override bool SupportsParameterMutation => _useNativeMode;
     protected override Tensor<T> PostprocessOutput(Tensor<T> o) => o;
     public override ModelMetadata<T> GetModelMetadata() => new() { Name = _useNativeMode ? "TDTDecoder-Native" : "TDTDecoder-ONNX", Description = "TDT: token-and-duration transducer (NVIDIA, 2023)", FeatureCount = _options.NumMels, Complexity = _options.NumEncoderLayers, AdditionalInfo = BaseAudioMetadataInfo() };
-    protected override void SerializeNetworkSpecificData(BinaryWriter w) { w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty); w.Write(_options.SampleRate); w.Write(_options.MaxAudioLengthSeconds); w.Write(_options.EncoderDim); w.Write(_options.NumEncoderLayers); w.Write(_options.NumAttentionHeads); w.Write(_options.NumMels); w.Write(_options.VocabSize); w.Write(_options.MaxTextLength); w.Write(_options.DropoutRate); w.Write(_options.Language); }
-    protected override void DeserializeNetworkSpecificData(BinaryReader r) { _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp; _options.SampleRate = r.ReadInt32(); _options.MaxAudioLengthSeconds = r.ReadInt32(); _options.EncoderDim = r.ReadInt32(); _options.NumEncoderLayers = r.ReadInt32(); _options.NumAttentionHeads = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.VocabSize = r.ReadInt32(); _options.MaxTextLength = r.ReadInt32(); _options.DropoutRate = r.ReadDouble(); _options.Language = r.ReadString(); base.SampleRate = _options.SampleRate; base.NumMels = _options.NumMels; if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions); }
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() { if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp)) return new TDTDecoder<T>(Architecture, mp, _options); return new TDTDecoder<T>(Architecture, _options); }
+
+
 
     private (List<int> tokens, double confidence) CTCGreedyDecodeWithConfidence(Tensor<T> logits) { var tokens = new List<int>(); double totalConf = 0; int confCount = 0; int prevToken = -1; int numFrames = logits.Rank >= 2 ? logits.Shape[0] : 1; int vocabSize = logits.Rank >= 2 ? logits.Shape[^1] : logits.Shape[0]; for (int t = 0; t < numFrames && tokens.Count < _options.MaxTextLength; t++) { int maxIdx = 0; double maxVal = double.NegativeInfinity; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); if (val > maxVal) { maxVal = val; maxIdx = v; } } double sumExp = 0; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); sumExp += Math.Exp(val - maxVal); } double frameConf = 1.0 / sumExp; if (maxIdx != prevToken && maxIdx > 0) { tokens.Add(maxIdx); totalConf += frameConf; confCount++; } prevToken = maxIdx; } return (tokens, confCount > 0 ? totalConf / confCount : 0.0); }
     private static string TokensToText(List<int> tokens) { var sb = new System.Text.StringBuilder(); foreach (var t in tokens) { if (t > 0 && t <= char.MaxValue) sb.Append((char)t); else if (t > char.MaxValue && t <= 0x10FFFF) sb.Append(char.ConvertFromUtf32(t)); } return sb.ToString().Trim(); }
diff --git a/src/SpeechRecognition/WhisperFamily/DistilWhisper.cs b/src/SpeechRecognition/WhisperFamily/DistilWhisper.cs
index 874ce57dfa..8f09d59727 100644
--- a/src/SpeechRecognition/WhisperFamily/DistilWhisper.cs
+++ b/src/SpeechRecognition/WhisperFamily/DistilWhisper.cs
@@ -46,7 +46,7 @@ namespace AiDotNet.SpeechRecognition.WhisperFamily;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Distil-Whisper: Robust Knowledge Distillation via Large-Scale Pseudo Labelling", "https://arxiv.org/abs/2311.00430", Year = 2023, Authors = "Gandhi et al.")]
-public class DistilWhisper<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
+public partial class DistilWhisper<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
 {
     private readonly DistilWhisperOptions _options; public override ModelOptions GetOptions() => _options;
     private IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer; private bool _useNativeMode; private bool _disposed;
@@ -110,9 +110,8 @@ public TranscriptionResult<T> Transcribe(Tensor<T> audio, string? language = nul
     protected override bool SupportsParameterMutation => _useNativeMode;
     protected override Tensor<T> PostprocessOutput(Tensor<T> o) => o;
     public override ModelMetadata<T> GetModelMetadata() => new() { Name = _useNativeMode ? "DistilWhisper-Native" : "DistilWhisper-ONNX", Description = "Distil-Whisper: 756M distilled ASR with 2 decoder layers (HuggingFace, 2023)", FeatureCount = _options.NumMels, Complexity = _options.NumEncoderLayers + _options.NumDecoderLayers, AdditionalInfo = BaseAudioMetadataInfo() };
-    protected override void SerializeNetworkSpecificData(BinaryWriter w) { w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty); w.Write(_options.SampleRate); w.Write(_options.EncoderDim); w.Write(_options.DecoderDim); w.Write(_options.NumEncoderLayers); w.Write(_options.NumDecoderLayers); w.Write(_options.NumAttentionHeads); w.Write(_options.FeedForwardDim); w.Write(_options.NumMels); w.Write(_options.VocabSize); w.Write(_options.MaxTextLength); w.Write(_options.DropoutRate); w.Write(_options.Language); }
-    protected override void DeserializeNetworkSpecificData(BinaryReader r) { _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp; _options.SampleRate = r.ReadInt32(); _options.EncoderDim = r.ReadInt32(); _options.DecoderDim = r.ReadInt32(); _options.NumEncoderLayers = r.ReadInt32(); _options.NumDecoderLayers = r.ReadInt32(); _options.NumAttentionHeads = r.ReadInt32(); _options.FeedForwardDim = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.VocabSize = r.ReadInt32(); _options.MaxTextLength = r.ReadInt32(); _options.DropoutRate = r.ReadDouble(); _options.Language = r.ReadString(); base.SampleRate = _options.SampleRate; base.NumMels = _options.NumMels; if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions); }
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() { if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp)) return new DistilWhisper<T>(Architecture, mp, _options); return new DistilWhisper<T>(Architecture, _options); }
+
+
 
     private (List<int> tokens, double confidence) GreedyDecodeWithConfidence(Tensor<T> logits) { var tokens = new List<int>(); double totalConf = 0; int confCount = 0; int prevToken = -1; int numFrames = logits.Rank >= 2 ? logits.Shape[0] : 1; int vocabSize = logits.Rank >= 2 ? logits.Shape[^1] : logits.Shape[0]; for (int t = 0; t < numFrames && tokens.Count < _options.MaxTextLength; t++) { int maxIdx = 0; double maxVal = double.NegativeInfinity; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); if (val > maxVal) { maxVal = val; maxIdx = v; } } double sumExp = 0; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); sumExp += Math.Exp(val - maxVal); } double frameConf = 1.0 / sumExp; if (maxIdx != prevToken && maxIdx > 0) { tokens.Add(maxIdx); totalConf += frameConf; confCount++; } prevToken = maxIdx; } return (tokens, confCount > 0 ? totalConf / confCount : 0.0); }
     private static string TokensToText(List<int> tokens) { var sb = new System.Text.StringBuilder(); foreach (var t in tokens) { if (t > 0 && t <= char.MaxValue) sb.Append((char)t); else if (t > char.MaxValue && t <= 0x10FFFF) sb.Append(char.ConvertFromUtf32(t)); } return sb.ToString().Trim(); }
diff --git a/src/SpeechRecognition/WhisperFamily/FasterWhisper.cs b/src/SpeechRecognition/WhisperFamily/FasterWhisper.cs
index 17f8d49c8a..cb762b13a7 100644
--- a/src/SpeechRecognition/WhisperFamily/FasterWhisper.cs
+++ b/src/SpeechRecognition/WhisperFamily/FasterWhisper.cs
@@ -121,9 +121,8 @@ public TranscriptionResult<T> Transcribe(Tensor<T> audio, string? language = nul
     protected override bool SupportsParameterMutation => _useNativeMode;
     protected override Tensor<T> PostprocessOutput(Tensor<T> o) => o;
     public override ModelMetadata<T> GetModelMetadata() => new() { Name = _useNativeMode ? "FasterWhisper-Native" : "FasterWhisper-ONNX", Description = "Faster-Whisper: CTranslate2-optimized Whisper with int8 quantization (SYSTRAN, 2023)", FeatureCount = _options.NumMels, Complexity = _options.NumEncoderLayers + _options.NumDecoderLayers, AdditionalInfo = new Dictionary<string, object> { { "ModelName", "FasterWhisper" }, { "Mode", _useNativeMode ? "Native" : "ONNX" }, { "SampleRate", _options.SampleRate }, { "NumMels", _options.NumMels }, { "EncoderDim", _options.EncoderDim }, { "DecoderDim", _options.DecoderDim }, { "NumEncoderLayers", _options.NumEncoderLayers }, { "NumDecoderLayers", _options.NumDecoderLayers }, { "NumAttentionHeads", _options.NumAttentionHeads }, { "VocabSize", _options.VocabSize }, { "ComputeType", _options.ComputeType }, { "BeamSize", _options.BeamSize } }, ModelData = SerializeForMetadata() };
-    protected override void SerializeNetworkSpecificData(BinaryWriter w) { w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty); w.Write(_options.SampleRate); w.Write(_options.EncoderDim); w.Write(_options.DecoderDim); w.Write(_options.NumEncoderLayers); w.Write(_options.NumDecoderLayers); w.Write(_options.NumAttentionHeads); w.Write(_options.NumMels); w.Write(_options.VocabSize); w.Write(_options.MaxTextLength); w.Write(_options.DropoutRate); w.Write(_options.Language); w.Write(_options.ComputeType); w.Write(_options.BeamSize); }
-    protected override void DeserializeNetworkSpecificData(BinaryReader r) { _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp; _options.SampleRate = r.ReadInt32(); _options.EncoderDim = r.ReadInt32(); _options.DecoderDim = r.ReadInt32(); _options.NumEncoderLayers = r.ReadInt32(); _options.NumDecoderLayers = r.ReadInt32(); _options.NumAttentionHeads = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.VocabSize = r.ReadInt32(); _options.MaxTextLength = r.ReadInt32(); _options.DropoutRate = r.ReadDouble(); _options.Language = r.ReadString(); _options.ComputeType = r.ReadString(); _options.BeamSize = r.ReadInt32(); base.SampleRate = _options.SampleRate; base.NumMels = _options.NumMels; if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions); }
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() { var options = new FasterWhisperOptions(_options); if (!_useNativeMode && options.ModelPath is { } mp && !string.IsNullOrEmpty(mp)) return new FasterWhisper<T>(Architecture, mp, options); return new FasterWhisper<T>(Architecture, options); }
+
+
 
     private (List<int> tokens, double confidence) BeamSearchDecodeWithConfidence(Tensor<T> logits) { var tokens = new List<int>(); double totalConf = 0; int confCount = 0; int prevToken = -1; int numFrames = logits.Rank >= 2 ? logits.Shape[0] : 1; int vocabSize = logits.Rank >= 2 ? logits.Shape[^1] : logits.Shape[0]; for (int t = 0; t < numFrames && tokens.Count < _options.MaxTextLength; t++) { int maxIdx = 0; double maxVal = double.NegativeInfinity; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); if (val > maxVal) { maxVal = val; maxIdx = v; } } double sumExp = 0; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); sumExp += Math.Exp(val - maxVal); } double frameConf = 1.0 / sumExp; if (maxIdx != prevToken && maxIdx > 0) { tokens.Add(maxIdx); totalConf += frameConf; confCount++; } prevToken = maxIdx; } return (tokens, confCount > 0 ? totalConf / confCount : 0.0); }
     private static string TokensToText(List<int> tokens) { var sb = new System.Text.StringBuilder(); foreach (var t in tokens) { if (t > 0 && t <= char.MaxValue) sb.Append((char)t); else if (t > char.MaxValue && t <= 0x10FFFF) sb.Append(char.ConvertFromUtf32(t)); } return sb.ToString().Trim(); }
diff --git a/src/SpeechRecognition/WhisperFamily/KotobaWhisper.cs b/src/SpeechRecognition/WhisperFamily/KotobaWhisper.cs
index fda8f7adf3..e51a44aec7 100644
--- a/src/SpeechRecognition/WhisperFamily/KotobaWhisper.cs
+++ b/src/SpeechRecognition/WhisperFamily/KotobaWhisper.cs
@@ -46,7 +46,7 @@ namespace AiDotNet.SpeechRecognition.WhisperFamily;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Distil-Whisper: Robust Knowledge Distillation via Large-Scale Pseudo Labelling", "https://arxiv.org/abs/2311.00430", Year = 2023, Authors = "Gandhi et al.")]
-public class KotobaWhisper<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
+public partial class KotobaWhisper<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
 {
     private readonly KotobaWhisperOptions _options; public override ModelOptions GetOptions() => _options;
     private IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer; private bool _useNativeMode; private bool _disposed;
@@ -110,9 +110,8 @@ public TranscriptionResult<T> Transcribe(Tensor<T> audio, string? language = nul
     protected override bool SupportsParameterMutation => _useNativeMode;
     protected override Tensor<T> PostprocessOutput(Tensor<T> o) => o;
     public override ModelMetadata<T> GetModelMetadata() => new() { Name = _useNativeMode ? "KotobaWhisper-Native" : "KotobaWhisper-ONNX", Description = "Kotoba-Whisper: Japanese-optimized distilled Whisper (Kotoba Technologies, 2024)", FeatureCount = _options.NumMels, Complexity = _options.NumEncoderLayers + _options.NumDecoderLayers, AdditionalInfo = BaseAudioMetadataInfo() };
-    protected override void SerializeNetworkSpecificData(BinaryWriter w) { w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty); w.Write(_options.SampleRate); w.Write(_options.MaxAudioLengthSeconds); w.Write(_options.EncoderDim); w.Write(_options.DecoderDim); w.Write(_options.NumEncoderLayers); w.Write(_options.NumDecoderLayers); w.Write(_options.NumAttentionHeads); w.Write(_options.NumMels); w.Write(_options.VocabSize); w.Write(_options.DropoutRate); w.Write(_options.Language); }
-    protected override void DeserializeNetworkSpecificData(BinaryReader r) { _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp; _options.SampleRate = r.ReadInt32(); _options.MaxAudioLengthSeconds = r.ReadInt32(); _options.EncoderDim = r.ReadInt32(); _options.DecoderDim = r.ReadInt32(); _options.NumEncoderLayers = r.ReadInt32(); _options.NumDecoderLayers = r.ReadInt32(); _options.NumAttentionHeads = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.VocabSize = r.ReadInt32(); _options.DropoutRate = r.ReadDouble(); _options.Language = r.ReadString(); base.SampleRate = _options.SampleRate; base.NumMels = _options.NumMels; if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions); }
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() { if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp)) return new KotobaWhisper<T>(Architecture, mp, _options); return new KotobaWhisper<T>(Architecture, _options); }
+
+
 
     private (List<int> tokens, double confidence) GreedyDecodeWithConfidence(Tensor<T> logits) { var tokens = new List<int>(); double totalConf = 0; int confCount = 0; int prevToken = -1; int numFrames = logits.Rank >= 2 ? logits.Shape[0] : 1; int vocabSize = logits.Rank >= 2 ? logits.Shape[^1] : logits.Shape[0]; for (int t = 0; t < numFrames && tokens.Count < 448; t++) { int maxIdx = 0; double maxVal = double.NegativeInfinity; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); if (val > maxVal) { maxVal = val; maxIdx = v; } } double sumExp = 0; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); sumExp += Math.Exp(val - maxVal); } double frameConf = 1.0 / sumExp; if (maxIdx != prevToken && maxIdx > 0) { tokens.Add(maxIdx); totalConf += frameConf; confCount++; } prevToken = maxIdx; } return (tokens, confCount > 0 ? totalConf / confCount : 0.0); }
     private static string TokensToText(List<int> tokens) { var sb = new System.Text.StringBuilder(); foreach (var t in tokens) { if (t > 0 && t <= char.MaxValue) sb.Append((char)t); else if (t > char.MaxValue && t <= 0x10FFFF) sb.Append(char.ConvertFromUtf32(t)); } return sb.ToString().Trim(); }
diff --git a/src/SpeechRecognition/WhisperFamily/WhisperLargeV3.cs b/src/SpeechRecognition/WhisperFamily/WhisperLargeV3.cs
index 8f570a88d6..da1e080b44 100644
--- a/src/SpeechRecognition/WhisperFamily/WhisperLargeV3.cs
+++ b/src/SpeechRecognition/WhisperFamily/WhisperLargeV3.cs
@@ -45,7 +45,7 @@ namespace AiDotNet.SpeechRecognition.WhisperFamily;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Robust Speech Recognition via Large-Scale Weak Supervision", "https://arxiv.org/abs/2212.04356", Year = 2023, Authors = "Radford et al.")]
-public class WhisperLargeV3<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
+public partial class WhisperLargeV3<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
 {
     private readonly WhisperLargeV3Options _options; public override ModelOptions GetOptions() => _options;
     private IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer; private bool _useNativeMode; private bool _disposed;
@@ -110,9 +110,8 @@ public TranscriptionResult<T> Transcribe(Tensor<T> audio, string? language = nul
     protected override bool SupportsParameterMutation => _useNativeMode;
     protected override Tensor<T> PostprocessOutput(Tensor<T> o) => o;
     public override ModelMetadata<T> GetModelMetadata() => new() { Name = _useNativeMode ? "WhisperLargeV3-Native" : "WhisperLargeV3-ONNX", Description = "Whisper large-v3: 1.55B multilingual ASR (OpenAI, 2023)", FeatureCount = _options.NumMels, Complexity = _options.NumEncoderLayers + _options.NumDecoderLayers, AdditionalInfo = BaseAudioMetadataInfo() };
-    protected override void SerializeNetworkSpecificData(BinaryWriter w) { w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty); w.Write(_options.SampleRate); w.Write(_options.EncoderDim); w.Write(_options.DecoderDim); w.Write(_options.NumEncoderLayers); w.Write(_options.NumDecoderLayers); w.Write(_options.NumAttentionHeads); w.Write(_options.FeedForwardDim); w.Write(_options.NumMels); w.Write(_options.VocabSize); w.Write(_options.MaxTextLength); w.Write(_options.DropoutRate); w.Write(_options.Language); }
-    protected override void DeserializeNetworkSpecificData(BinaryReader r) { _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp; _options.SampleRate = r.ReadInt32(); _options.EncoderDim = r.ReadInt32(); _options.DecoderDim = r.ReadInt32(); _options.NumEncoderLayers = r.ReadInt32(); _options.NumDecoderLayers = r.ReadInt32(); _options.NumAttentionHeads = r.ReadInt32(); _options.FeedForwardDim = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.VocabSize = r.ReadInt32(); _options.MaxTextLength = r.ReadInt32(); _options.DropoutRate = r.ReadDouble(); _options.Language = r.ReadString(); base.SampleRate = _options.SampleRate; base.NumMels = _options.NumMels; if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions); }
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() { if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp)) return new WhisperLargeV3<T>(Architecture, mp, _options); return new WhisperLargeV3<T>(Architecture, _options); }
+
+
 
     private (List<int> tokens, double confidence) GreedyDecodeWithConfidence(Tensor<T> logits) { var tokens = new List<int>(); double totalConf = 0; int confCount = 0; int prevToken = -1; int numFrames = logits.Rank >= 2 ? logits.Shape[0] : 1; int vocabSize = logits.Rank >= 2 ? logits.Shape[^1] : logits.Shape[0]; for (int t = 0; t < numFrames && tokens.Count < _options.MaxTextLength; t++) { int maxIdx = 0; double maxVal = double.NegativeInfinity; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); if (val > maxVal) { maxVal = val; maxIdx = v; } } double sumExp = 0; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); sumExp += Math.Exp(val - maxVal); } double frameConf = 1.0 / sumExp; if (maxIdx != prevToken && maxIdx > 0) { tokens.Add(maxIdx); totalConf += frameConf; confCount++; } prevToken = maxIdx; } return (tokens, confCount > 0 ? totalConf / confCount : 0.0); }
     private static string TokensToText(List<int> tokens) { var sb = new System.Text.StringBuilder(); foreach (var t in tokens) { if (t > 0 && t <= char.MaxValue) sb.Append((char)t); else if (t > char.MaxValue && t <= 0x10FFFF) sb.Append(char.ConvertFromUtf32(t)); } return sb.ToString().Trim(); }
diff --git a/src/SpeechRecognition/WhisperFamily/WhisperLargeV3Turbo.cs b/src/SpeechRecognition/WhisperFamily/WhisperLargeV3Turbo.cs
index 055fb361e6..0259151029 100644
--- a/src/SpeechRecognition/WhisperFamily/WhisperLargeV3Turbo.cs
+++ b/src/SpeechRecognition/WhisperFamily/WhisperLargeV3Turbo.cs
@@ -45,7 +45,7 @@ namespace AiDotNet.SpeechRecognition.WhisperFamily;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Robust Speech Recognition via Large-Scale Weak Supervision", "https://arxiv.org/abs/2212.04356", Year = 2023, Authors = "Radford et al.")]
-public class WhisperLargeV3Turbo<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
+public partial class WhisperLargeV3Turbo<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
 {
     private readonly WhisperLargeV3TurboOptions _options; public override ModelOptions GetOptions() => _options;
     private IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer; private bool _useNativeMode; private bool _disposed;
@@ -109,9 +109,8 @@ public TranscriptionResult<T> Transcribe(Tensor<T> audio, string? language = nul
     protected override bool SupportsParameterMutation => _useNativeMode;
     protected override Tensor<T> PostprocessOutput(Tensor<T> o) => o;
     public override ModelMetadata<T> GetModelMetadata() => new() { Name = _useNativeMode ? "WhisperLargeV3Turbo-Native" : "WhisperLargeV3Turbo-ONNX", Description = "Whisper large-v3-turbo: 809M distilled ASR with 4 decoder layers (OpenAI, 2024)", FeatureCount = _options.NumMels, Complexity = _options.NumEncoderLayers + _options.NumDecoderLayers, AdditionalInfo = BaseAudioMetadataInfo() };
-    protected override void SerializeNetworkSpecificData(BinaryWriter w) { w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty); w.Write(_options.SampleRate); w.Write(_options.EncoderDim); w.Write(_options.DecoderDim); w.Write(_options.NumEncoderLayers); w.Write(_options.NumDecoderLayers); w.Write(_options.NumAttentionHeads); w.Write(_options.FeedForwardDim); w.Write(_options.NumMels); w.Write(_options.VocabSize); w.Write(_options.MaxTextLength); w.Write(_options.DropoutRate); w.Write(_options.Language); }
-    protected override void DeserializeNetworkSpecificData(BinaryReader r) { _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp; _options.SampleRate = r.ReadInt32(); _options.EncoderDim = r.ReadInt32(); _options.DecoderDim = r.ReadInt32(); _options.NumEncoderLayers = r.ReadInt32(); _options.NumDecoderLayers = r.ReadInt32(); _options.NumAttentionHeads = r.ReadInt32(); _options.FeedForwardDim = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.VocabSize = r.ReadInt32(); _options.MaxTextLength = r.ReadInt32(); _options.DropoutRate = r.ReadDouble(); _options.Language = r.ReadString(); base.SampleRate = _options.SampleRate; base.NumMels = _options.NumMels; if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions); }
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() { if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp)) return new WhisperLargeV3Turbo<T>(Architecture, mp, _options); return new WhisperLargeV3Turbo<T>(Architecture, _options); }
+
+
 
     private (List<int> tokens, double confidence) GreedyDecodeWithConfidence(Tensor<T> logits) { var tokens = new List<int>(); double totalConf = 0; int confCount = 0; int prevToken = -1; int numFrames = logits.Rank >= 2 ? logits.Shape[0] : 1; int vocabSize = logits.Rank >= 2 ? logits.Shape[^1] : logits.Shape[0]; for (int t = 0; t < numFrames && tokens.Count < _options.MaxTextLength; t++) { int maxIdx = 0; double maxVal = double.NegativeInfinity; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); if (val > maxVal) { maxVal = val; maxIdx = v; } } double sumExp = 0; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); sumExp += Math.Exp(val - maxVal); } double frameConf = 1.0 / sumExp; if (maxIdx != prevToken && maxIdx > 0) { tokens.Add(maxIdx); totalConf += frameConf; confCount++; } prevToken = maxIdx; } return (tokens, confCount > 0 ? totalConf / confCount : 0.0); }
     private static string TokensToText(List<int> tokens) { var sb = new System.Text.StringBuilder(); foreach (var t in tokens) { if (t > 0 && t <= char.MaxValue) sb.Append((char)t); else if (t > char.MaxValue && t <= 0x10FFFF) sb.Append(char.ConvertFromUtf32(t)); } return sb.ToString().Trim(); }
diff --git a/src/SpeechRecognition/WhisperFamily/WhisperLive.cs b/src/SpeechRecognition/WhisperFamily/WhisperLive.cs
index 674e06a741..7ba3b7a4cc 100644
--- a/src/SpeechRecognition/WhisperFamily/WhisperLive.cs
+++ b/src/SpeechRecognition/WhisperFamily/WhisperLive.cs
@@ -46,7 +46,7 @@ namespace AiDotNet.SpeechRecognition.WhisperFamily;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Robust Speech Recognition via Large-Scale Weak Supervision", "https://arxiv.org/abs/2212.04356", Year = 2023, Authors = "Radford et al.")]
-public class WhisperLive<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
+public partial class WhisperLive<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
 {
     private readonly WhisperLiveOptions _options; public override ModelOptions GetOptions() => _options;
     private IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer; private bool _useNativeMode; private bool _disposed;
@@ -110,9 +110,8 @@ public TranscriptionResult<T> Transcribe(Tensor<T> audio, string? language = nul
     protected override bool SupportsParameterMutation => _useNativeMode;
     protected override Tensor<T> PostprocessOutput(Tensor<T> o) => o;
     public override ModelMetadata<T> GetModelMetadata() => new() { Name = _useNativeMode ? "WhisperLive-Native" : "WhisperLive-ONNX", Description = "WhisperLive: real-time streaming Whisper with VAD chunking (Collabora, 2024)", FeatureCount = _options.NumMels, Complexity = _options.NumEncoderLayers + _options.NumDecoderLayers, AdditionalInfo = BaseAudioMetadataInfo() };
-    protected override void SerializeNetworkSpecificData(BinaryWriter w) { w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty); w.Write(_options.SampleRate); w.Write(_options.MaxAudioLengthSeconds); w.Write(_options.EncoderDim); w.Write(_options.DecoderDim); w.Write(_options.NumEncoderLayers); w.Write(_options.NumDecoderLayers); w.Write(_options.NumAttentionHeads); w.Write(_options.NumMels); w.Write(_options.VocabSize); w.Write(_options.DropoutRate); w.Write(_options.Language); w.Write(_options.ChunkSizeSeconds); }
-    protected override void DeserializeNetworkSpecificData(BinaryReader r) { _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp; _options.SampleRate = r.ReadInt32(); _options.MaxAudioLengthSeconds = r.ReadInt32(); _options.EncoderDim = r.ReadInt32(); _options.DecoderDim = r.ReadInt32(); _options.NumEncoderLayers = r.ReadInt32(); _options.NumDecoderLayers = r.ReadInt32(); _options.NumAttentionHeads = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.VocabSize = r.ReadInt32(); _options.DropoutRate = r.ReadDouble(); _options.Language = r.ReadString(); _options.ChunkSizeSeconds = r.ReadDouble(); base.SampleRate = _options.SampleRate; base.NumMels = _options.NumMels; if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions); }
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() { if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp)) return new WhisperLive<T>(Architecture, mp, _options); return new WhisperLive<T>(Architecture, _options); }
+
+
 
     private (List<int> tokens, double confidence) GreedyDecodeWithConfidence(Tensor<T> logits) { var tokens = new List<int>(); double totalConf = 0; int confCount = 0; int prevToken = -1; int numFrames = logits.Rank >= 2 ? logits.Shape[0] : 1; int vocabSize = logits.Rank >= 2 ? logits.Shape[^1] : logits.Shape[0]; for (int t = 0; t < numFrames && tokens.Count < 448; t++) { int maxIdx = 0; double maxVal = double.NegativeInfinity; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); if (val > maxVal) { maxVal = val; maxIdx = v; } } double sumExp = 0; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); sumExp += Math.Exp(val - maxVal); } double frameConf = 1.0 / sumExp; if (maxIdx != prevToken && maxIdx > 0) { tokens.Add(maxIdx); totalConf += frameConf; confCount++; } prevToken = maxIdx; } return (tokens, confCount > 0 ? totalConf / confCount : 0.0); }
     private static string TokensToText(List<int> tokens) { var sb = new System.Text.StringBuilder(); foreach (var t in tokens) { if (t > 0 && t <= char.MaxValue) sb.Append((char)t); else if (t > char.MaxValue && t <= 0x10FFFF) sb.Append(char.ConvertFromUtf32(t)); } return sb.ToString().Trim(); }
diff --git a/src/SpeechRecognition/WhisperFamily/WhisperTimestamped.cs b/src/SpeechRecognition/WhisperFamily/WhisperTimestamped.cs
index e2ffaef0cb..9b361a0f66 100644
--- a/src/SpeechRecognition/WhisperFamily/WhisperTimestamped.cs
+++ b/src/SpeechRecognition/WhisperFamily/WhisperTimestamped.cs
@@ -47,7 +47,7 @@ namespace AiDotNet.SpeechRecognition.WhisperFamily;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Robust Speech Recognition via Large-Scale Weak Supervision", "https://arxiv.org/abs/2212.04356", Year = 2023, Authors = "Radford et al.")]
-public class WhisperTimestamped<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
+public partial class WhisperTimestamped<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
 {
     private readonly WhisperTimestampedOptions _options; public override ModelOptions GetOptions() => _options;
     private IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer; private bool _useNativeMode; private bool _disposed;
@@ -139,9 +139,8 @@ public override ModelMetadata<T> GetModelMetadata()
             ModelData = SerializeForMetadata(),
         };
     }
-    protected override void SerializeNetworkSpecificData(BinaryWriter w) { w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty); w.Write(_options.SampleRate); w.Write(_options.EncoderDim); w.Write(_options.DecoderDim); w.Write(_options.NumEncoderLayers); w.Write(_options.NumDecoderLayers); w.Write(_options.NumAttentionHeads); w.Write(_options.NumMels); w.Write(_options.VocabSize); w.Write(_options.DropoutRate); w.Write(_options.Language); w.Write(_options.MinWordConfidence); }
-    protected override void DeserializeNetworkSpecificData(BinaryReader r) { _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp; _options.SampleRate = r.ReadInt32(); _options.EncoderDim = r.ReadInt32(); _options.DecoderDim = r.ReadInt32(); _options.NumEncoderLayers = r.ReadInt32(); _options.NumDecoderLayers = r.ReadInt32(); _options.NumAttentionHeads = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.VocabSize = r.ReadInt32(); _options.DropoutRate = r.ReadDouble(); _options.Language = r.ReadString(); _options.MinWordConfidence = r.ReadDouble(); base.SampleRate = _options.SampleRate; base.NumMels = _options.NumMels; if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions); }
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() { if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp)) return new WhisperTimestamped<T>(Architecture, mp, _options); return new WhisperTimestamped<T>(Architecture, _options); }
+
+
 
     private (List<int> tokens, double confidence) GreedyDecodeWithConfidence(Tensor<T> logits) { var tokens = new List<int>(); double totalConf = 0; int confCount = 0; int prevToken = -1; int numFrames = logits.Rank >= 2 ? logits.Shape[0] : 1; int vocabSize = logits.Rank >= 2 ? logits.Shape[^1] : logits.Shape[0]; for (int t = 0; t < numFrames && tokens.Count < 448; t++) { int maxIdx = 0; double maxVal = double.NegativeInfinity; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); if (val > maxVal) { maxVal = val; maxIdx = v; } } double sumExp = 0; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); sumExp += Math.Exp(val - maxVal); } double frameConf = 1.0 / sumExp; if (maxIdx != prevToken && maxIdx > 0) { tokens.Add(maxIdx); totalConf += frameConf; confCount++; } prevToken = maxIdx; } return (tokens, confCount > 0 ? totalConf / confCount : 0.0); }
     private static string TokensToText(List<int> tokens) { var sb = new System.Text.StringBuilder(); foreach (var t in tokens) { if (t > 0 && t <= char.MaxValue) sb.Append((char)t); else if (t > char.MaxValue && t <= 0x10FFFF) sb.Append(char.ConvertFromUtf32(t)); } return sb.ToString().Trim(); }
diff --git a/src/SpeechRecognition/WhisperFamily/WhisperX.cs b/src/SpeechRecognition/WhisperFamily/WhisperX.cs
index 7d482b0f0c..8ad1a99b2f 100644
--- a/src/SpeechRecognition/WhisperFamily/WhisperX.cs
+++ b/src/SpeechRecognition/WhisperFamily/WhisperX.cs
@@ -46,7 +46,7 @@ namespace AiDotNet.SpeechRecognition.WhisperFamily;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("WhisperX: Time-Accurate Speech Transcription of Long-Form Audio", "https://arxiv.org/abs/2303.00747", Year = 2023, Authors = "Bain et al.")]
-public class WhisperX<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
+public partial class WhisperX<T> : AudioNeuralNetworkBase<T>, ISpeechRecognizer<T>
 {
     private readonly WhisperXOptions _options; public override ModelOptions GetOptions() => _options;
     private IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer; private bool _useNativeMode; private bool _disposed;
@@ -110,9 +110,8 @@ public TranscriptionResult<T> Transcribe(Tensor<T> audio, string? language = nul
     protected override bool SupportsParameterMutation => _useNativeMode;
     protected override Tensor<T> PostprocessOutput(Tensor<T> o) => o;
     public override ModelMetadata<T> GetModelMetadata() => new() { Name = _useNativeMode ? "WhisperX-Native" : "WhisperX-ONNX", Description = "WhisperX: VAD + forced alignment + diarization for Whisper (Bain et al., 2023)", FeatureCount = _options.NumMels, Complexity = _options.NumEncoderLayers + _options.NumDecoderLayers, AdditionalInfo = BaseAudioMetadataInfo() };
-    protected override void SerializeNetworkSpecificData(BinaryWriter w) { w.Write(_useNativeMode); w.Write(_options.ModelPath ?? string.Empty); w.Write(_options.SampleRate); w.Write(_options.EncoderDim); w.Write(_options.DecoderDim); w.Write(_options.NumEncoderLayers); w.Write(_options.NumDecoderLayers); w.Write(_options.NumAttentionHeads); w.Write(_options.NumMels); w.Write(_options.VocabSize); w.Write(_options.MaxTextLength); w.Write(_options.DropoutRate); w.Write(_options.Language); w.Write(_options.VadMinSpeechDuration); w.Write(_options.VadMinSilenceDuration); w.Write(_options.EnableDiarization); }
-    protected override void DeserializeNetworkSpecificData(BinaryReader r) { _useNativeMode = r.ReadBoolean(); string mp = r.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp; _options.SampleRate = r.ReadInt32(); _options.EncoderDim = r.ReadInt32(); _options.DecoderDim = r.ReadInt32(); _options.NumEncoderLayers = r.ReadInt32(); _options.NumDecoderLayers = r.ReadInt32(); _options.NumAttentionHeads = r.ReadInt32(); _options.NumMels = r.ReadInt32(); _options.VocabSize = r.ReadInt32(); _options.MaxTextLength = r.ReadInt32(); _options.DropoutRate = r.ReadDouble(); _options.Language = r.ReadString(); _options.VadMinSpeechDuration = r.ReadDouble(); _options.VadMinSilenceDuration = r.ReadDouble(); _options.EnableDiarization = r.ReadBoolean(); base.SampleRate = _options.SampleRate; base.NumMels = _options.NumMels; if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p)) OnnxEncoder = new OnnxModel<T>(p, _options.OnnxOptions); }
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() { if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp)) return new WhisperX<T>(Architecture, mp, _options); return new WhisperX<T>(Architecture, _options); }
+
+
 
     private (List<int> tokens, double confidence) GreedyDecodeWithConfidence(Tensor<T> logits) { var tokens = new List<int>(); double totalConf = 0; int confCount = 0; int prevToken = -1; int numFrames = logits.Rank >= 2 ? logits.Shape[0] : 1; int vocabSize = logits.Rank >= 2 ? logits.Shape[^1] : logits.Shape[0]; for (int t = 0; t < numFrames && tokens.Count < _options.MaxTextLength; t++) { int maxIdx = 0; double maxVal = double.NegativeInfinity; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); if (val > maxVal) { maxVal = val; maxIdx = v; } } double sumExp = 0; for (int v = 0; v < vocabSize; v++) { double val = logits.Rank >= 2 ? NumOps.ToDouble(logits[t, v]) : NumOps.ToDouble(logits[v]); sumExp += Math.Exp(val - maxVal); } double frameConf = 1.0 / sumExp; if (maxIdx != prevToken && maxIdx > 0) { tokens.Add(maxIdx); totalConf += frameConf; confCount++; } prevToken = maxIdx; } return (tokens, confCount > 0 ? totalConf / confCount : 0.0); }
     private static string TokensToText(List<int> tokens) { var sb = new System.Text.StringBuilder(); foreach (var t in tokens) { if (t > 0 && t <= char.MaxValue) sb.Append((char)t); else if (t > char.MaxValue && t <= 0x10FFFF) sb.Append(char.ConvertFromUtf32(t)); } return sb.ToString().Trim(); }
diff --git a/src/Statistics/BasicStats.cs b/src/Statistics/BasicStats.cs
index 1fbc2763cc..63691367de 100644
--- a/src/Statistics/BasicStats.cs
+++ b/src/Statistics/BasicStats.cs
@@ -28,7 +28,7 @@ namespace AiDotNet.Statistics;
 /// These statistics help you understand your data at a glance without having to examine every value.
 /// </para>
 /// </remarks>
-public class BasicStats<T>
+public partial class BasicStats<T>
 {
     /// <summary>
     /// Gets the arithmetic mean (average) of the values.
@@ -372,6 +372,7 @@ internal BasicStats(BasicStatsInputs<T> inputs)
         _deferredValues = inputs.Values;
     }
 
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T>? _deferredValues;
     private bool _fullStatsComputed;
 
diff --git a/src/Statistics/ModelStats.cs b/src/Statistics/ModelStats.cs
index 0b9d8f3552..d7e88270f8 100644
--- a/src/Statistics/ModelStats.cs
+++ b/src/Statistics/ModelStats.cs
@@ -22,7 +22,7 @@ namespace AiDotNet.Statistics;
 /// This information helps you improve your model and decide if it's ready to use in real-world situations.
 /// </para>
 /// </remarks>
-public class ModelStats<T, TInput, TOutput>
+public partial class ModelStats<T, TInput, TOutput>
 {
     private readonly INumericOperations<T> _numOps;
     private readonly ModelStatsOptions _options;
@@ -46,6 +46,7 @@ public class ModelStats<T, TInput, TOutput>
     /// This helps you understand which features might be providing similar information.
     /// </para>
     /// </remarks>
+    [AiDotNet.Attributes.TrainableParameter]
     private Matrix<T> _correlationMatrix = default!;
     public Matrix<T> CorrelationMatrix { get { EnsureFullStatsComputed(); return _correlationMatrix; } private set { _correlationMatrix = value; } }
 
@@ -58,6 +59,7 @@ public class ModelStats<T, TInput, TOutput>
     /// It helps identify patterns in how your features behave together.
     /// </para>
     /// </remarks>
+    [AiDotNet.Attributes.TrainableParameter]
     private Matrix<T> _covarianceMatrix = default!;
     public Matrix<T> CovarianceMatrix { get { EnsureFullStatsComputed(); return _covarianceMatrix; } private set { _covarianceMatrix = value; } }
 
diff --git a/src/SurvivalAnalysis/CoxProportionalHazards.cs b/src/SurvivalAnalysis/CoxProportionalHazards.cs
index ba9e76432b..738c83717d 100644
--- a/src/SurvivalAnalysis/CoxProportionalHazards.cs
+++ b/src/SurvivalAnalysis/CoxProportionalHazards.cs
@@ -62,7 +62,7 @@ namespace AiDotNet.SurvivalAnalysis;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
 [ResearchPaper("Regression Models and Life-Tables", "https://doi.org/10.1111/j.2517-6161.1972.tb00899.x", Year = 1972, Authors = "David R. Cox")]
-public class CoxProportionalHazards<T> : SurvivalModelBase<T>
+public partial class CoxProportionalHazards<T> : SurvivalModelBase<T>
 {
 
     /// <inheritdoc />
@@ -80,6 +80,7 @@ protected override void RegisterComponents()
     /// <summary>
     /// The estimated coefficients (log hazard ratios).
     /// </summary>
+    [AiDotNet.Attributes.FittedParameter]
     private Vector<T> _coefficients = new Vector<T>(0);
 
     /// <summary>
@@ -531,14 +532,6 @@ public override IFullModel<T, Matrix<T>, Vector<T>> WithParameters(Vector<T> par
         return newModel;
     }
 
-    /// <summary>
-    /// Creates a new instance of the same type.
-    /// </summary>
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        return new CoxProportionalHazards<T>(_learningRate, _maxIterations, _tolerance, _l2Penalty);
-    }
-
     /// <summary>
     /// Gets the feature importance scores based on coefficient magnitudes.
     /// </summary>
diff --git a/src/SurvivalAnalysis/KaplanMeierEstimator.cs b/src/SurvivalAnalysis/KaplanMeierEstimator.cs
index 908da6e9ae..9b3c05fc59 100644
--- a/src/SurvivalAnalysis/KaplanMeierEstimator.cs
+++ b/src/SurvivalAnalysis/KaplanMeierEstimator.cs
@@ -61,7 +61,7 @@ namespace AiDotNet.SurvivalAnalysis;
 [ModelComplexity(ModelComplexity.Low)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
 [ResearchPaper("Nonparametric Estimation from Incomplete Observations", "https://doi.org/10.2307/2281868", Year = 1958, Authors = "Edward L. Kaplan, Paul Meier")]
-public class KaplanMeierEstimator<T> : SurvivalModelBase<T>
+public partial class KaplanMeierEstimator<T> : SurvivalModelBase<T>
 {
 
     /// <inheritdoc />
@@ -79,6 +79,7 @@ protected override void RegisterComponents()
     /// <summary>
     /// Stores the survival probability at each event time.
     /// </summary>
+    [AiDotNet.Attributes.FittedParameter]
     private Vector<T>? _survivalProbabilities;
 
     /// <summary>
@@ -377,39 +378,5 @@ public override IFullModel<T, Matrix<T>, Vector<T>> WithParameters(Vector<T> par
         return newModel;
     }
 
-    /// <summary>
-    /// Creates a new instance of the same type.
-    /// </summary>
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        return new KaplanMeierEstimator<T>();
-    }
-
-    /// <summary>
-    /// Clones the fitted estimator, carrying over the non-parametric fitted state.
-    /// </summary>
-    /// <remarks>
-    /// The base <see cref="SurvivalModelBase{T}.DeepCopy"/> serializes only NumFeatures /
-    /// IsFitted, so a cloned Kaplan–Meier estimator would lose its fitted curve and predict
-    /// differently from the original (Clone_ShouldProduceSamePredictions). Kaplan–Meier is a
-    /// non-parametric estimator: its "model" is the step function defined by the event times and
-    /// their cumulative survival probabilities, plus the at-risk / event counts. Carry all of that
-    /// onto the clone. Sharing the (immutable-after-fit) vectors is safe because Train reassigns
-    /// these fields to fresh vectors rather than mutating them in place.
-    /// </remarks>
-    public override IFullModel<T, Matrix<T>, Vector<T>> DeepCopy()
-    {
-        var copy = base.DeepCopy();
-        if (copy is KaplanMeierEstimator<T> km)
-        {
-            km.TrainedEventTimes = TrainedEventTimes;
-            km._survivalProbabilities = _survivalProbabilities;
-            km._numberAtRisk = _numberAtRisk;
-            km._numberEvents = _numberEvents;
-            km.BaselineSurvivalFunction = _survivalProbabilities;
-        }
-        return copy;
-    }
-
     #endregion
 }
diff --git a/src/SurvivalAnalysis/LogNormalAFT.cs b/src/SurvivalAnalysis/LogNormalAFT.cs
index fe82f93f5f..036b46123a 100644
--- a/src/SurvivalAnalysis/LogNormalAFT.cs
+++ b/src/SurvivalAnalysis/LogNormalAFT.cs
@@ -52,7 +52,7 @@ namespace AiDotNet.SurvivalAnalysis;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
 [ResearchPaper("Survival Analysis: Techniques for Censored and Truncated Data", "https://doi.org/10.1007/978-1-4757-3294-8")]
-public class LogNormalAFT<T> : SurvivalModelBase<T>
+public partial class LogNormalAFT<T> : SurvivalModelBase<T>
 {
 
     /// <inheritdoc />
@@ -396,55 +396,5 @@ public override IFullModel<T, Matrix<T>, Vector<T>> WithParameters(Vector<T> par
     }
 
     /// <inheritdoc />
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        return new LogNormalAFT<T>(MaxIterations, Tolerance);
-    }
-
-    /// <inheritdoc />
-
-    /// <inheritdoc />
-    public override byte[] Serialize()
-    {
-        var data = new Dictionary<string, object>
-        {
-            { "NumFeatures", NumFeatures },
-            { "IsFitted", IsFitted },
-            { "Intercept", NumOps.ToDouble(Intercept) },
-            { "Scale", NumOps.ToDouble(Scale) },
-            { "Coefficients", Coefficients?.ToArray()?.Select(NumOps.ToDouble).ToArray() ?? Array.Empty<double>() },
-            { "MaxIterations", MaxIterations },
-            { "Tolerance", Tolerance }
-        };
-
-        var metadata = GetModelMetadata();
-        metadata.ModelData = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(data));
-        return Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(metadata));
-    }
 
-    /// <inheritdoc />
-    public override void Deserialize(byte[] modelData)
-    {
-        var json = Encoding.UTF8.GetString(modelData);
-        var metadata = JsonConvert.DeserializeObject<ModelMetadata<T>>(json);
-
-        if (metadata?.ModelData is null)
-            throw new InvalidOperationException("Invalid model data.");
-
-        var dataJson = Encoding.UTF8.GetString(metadata.ModelData);
-        var data = JsonConvert.DeserializeObject<Newtonsoft.Json.Linq.JObject>(dataJson);
-
-        if (data is null)
-            throw new InvalidOperationException("Invalid model data.");
-
-        NumFeatures = data["NumFeatures"]?.ToObject<int>() ?? 0;
-        IsFitted = data["IsFitted"]?.ToObject<bool>() ?? false;
-        Intercept = NumOps.FromDouble(data["Intercept"]?.ToObject<double>() ?? 0);
-        Scale = NumOps.FromDouble(data["Scale"]?.ToObject<double>() ?? 1);
-
-        var coeffs = data["Coefficients"]?.ToObject<double[]>() ?? Array.Empty<double>();
-        Coefficients = new Vector<T>(coeffs.Length);
-        for (int i = 0; i < coeffs.Length; i++)
-            Coefficients[i] = NumOps.FromDouble(coeffs[i]);
-    }
 }
diff --git a/src/SurvivalAnalysis/NelsonAalenEstimator.cs b/src/SurvivalAnalysis/NelsonAalenEstimator.cs
index 51d51159fe..be02ccacfa 100644
--- a/src/SurvivalAnalysis/NelsonAalenEstimator.cs
+++ b/src/SurvivalAnalysis/NelsonAalenEstimator.cs
@@ -51,16 +51,18 @@ namespace AiDotNet.SurvivalAnalysis;
 [ModelComplexity(ModelComplexity.Low)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
 [ResearchPaper("Theory of Counting Processes", "https://doi.org/10.1007/978-1-4612-4532-4")]
-public class NelsonAalenEstimator<T> : SurvivalModelBase<T>
+public partial class NelsonAalenEstimator<T> : SurvivalModelBase<T>
 {
     /// <summary>
     /// The cumulative hazard values at each event time.
     /// </summary>
+    [AiDotNet.Attributes.FittedParameter]
     private Vector<T>? _cumulativeHazard;
 
     /// <summary>
     /// The variance estimates at each event time.
     /// </summary>
+    [AiDotNet.Attributes.FittedParameter]
     private Vector<T>? _variance;
 
     /// <summary>
@@ -256,18 +258,6 @@ public override Vector<T> Predict(Matrix<T> input)
         return PredictMedianSurvivalTime(input);
     }
 
-    /// <inheritdoc />
-    protected override void RegisterComponents()
-    {
-        base.RegisterComponents();
-        RegisterParameterComponent(
-            "cumulative-hazard",
-            new AiDotNet.Models.Parameters.VectorFieldParameterSource<T>(
-                () => _cumulativeHazard,
-                parameters => _cumulativeHazard = new Vector<T>(parameters.ToArray())),
-            AiDotNet.Models.Parameters.ParameterSlotRole.LearnedState);
-    }
-
     /// <inheritdoc />
     public override IFullModel<T, Matrix<T>, Vector<T>> WithParameters(Vector<T> parameters)
     {
@@ -276,89 +266,4 @@ public override IFullModel<T, Matrix<T>, Vector<T>> WithParameters(Vector<T> par
         return copy;
     }
 
-    /// <inheritdoc />
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        return new NelsonAalenEstimator<T>();
-    }
-
-    /// <summary>
-    /// Clones the fitted estimator, carrying over the non-parametric fitted state.
-    /// </summary>
-    /// <remarks>
-    /// The base <see cref="SurvivalModelBase{T}.DeepCopy"/> transfers only NumFeatures / IsFitted
-    /// plus the <see cref="GetParameters"/>/<see cref="SetParameters"/> vector (the cumulative
-    /// hazard values). It never invokes this model's overridden <see cref="Serialize"/>, so the
-    /// event-time grid, variance estimates, and baseline survival curve would be lost — leaving a
-    /// clone whose <see cref="Predict"/> (via median survival time) sees a null event-time grid and
-    /// returns zeros, diverging from the original (Clone_ShouldProduceSamePredictions). Nelson-Aalen
-    /// is non-parametric: its "model" is the step function defined by the event times and the
-    /// cumulative hazard accumulated at each. Carry all fitted state onto the clone as INDEPENDENT
-    /// vectors. The previous version shared the references, arguing that Fit reassigns rather than
-    /// mutates -- but EventTimes, BaselineSurvival, CumulativeHazard and Variance are all public and
-    /// mutable, so any caller writing through one of them on either estimator changed both.
-    /// </remarks>
-    public override IFullModel<T, Matrix<T>, Vector<T>> DeepCopy()
-    {
-        var copy = base.DeepCopy();
-        if (copy is NelsonAalenEstimator<T> na)
-        {
-            na.TrainedEventTimes = TrainedEventTimes?.Clone();
-            na._cumulativeHazard = _cumulativeHazard?.Clone();
-            na._variance = _variance?.Clone();
-            na.BaselineSurvivalFunction = BaselineSurvivalFunction?.Clone();
-        }
-        return copy;
-    }
-
-    /// <inheritdoc />
-    public override byte[] Serialize()
-    {
-        var data = new Dictionary<string, object>
-        {
-            { "NumFeatures", NumFeatures },
-            { "IsFitted", IsFitted },
-            { "EventTimes", TrainedEventTimes?.ToArray()?.Select(NumOps.ToDouble).ToArray() ?? Array.Empty<double>() },
-            { "CumulativeHazard", _cumulativeHazard?.ToArray()?.Select(NumOps.ToDouble).ToArray() ?? Array.Empty<double>() },
-            { "Variance", _variance?.ToArray()?.Select(NumOps.ToDouble).ToArray() ?? Array.Empty<double>() }
-        };
-
-        var metadata = GetModelMetadata();
-        metadata.ModelData = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(data));
-        return Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(metadata));
-    }
-
-    /// <inheritdoc />
-    public override void Deserialize(byte[] modelData)
-    {
-        var json = Encoding.UTF8.GetString(modelData);
-        var metadata = JsonConvert.DeserializeObject<ModelMetadata<T>>(json);
-
-        if (metadata?.ModelData is null)
-            throw new InvalidOperationException("Invalid model data.");
-
-        var dataJson = Encoding.UTF8.GetString(metadata.ModelData);
-        var data = JsonConvert.DeserializeObject<Newtonsoft.Json.Linq.JObject>(dataJson);
-
-        if (data is null)
-            throw new InvalidOperationException("Invalid model data.");
-
-        NumFeatures = data["NumFeatures"]?.ToObject<int>() ?? 0;
-        IsFitted = data["IsFitted"]?.ToObject<bool>() ?? false;
-
-        var eventTimes = data["EventTimes"]?.ToObject<double[]>() ?? Array.Empty<double>();
-        var cumHazard = data["CumulativeHazard"]?.ToObject<double[]>() ?? Array.Empty<double>();
-        var variance = data["Variance"]?.ToObject<double[]>() ?? Array.Empty<double>();
-
-        TrainedEventTimes = new Vector<T>(eventTimes.Length);
-        _cumulativeHazard = new Vector<T>(cumHazard.Length);
-        _variance = new Vector<T>(variance.Length);
-
-        for (int i = 0; i < eventTimes.Length; i++)
-            TrainedEventTimes[i] = NumOps.FromDouble(eventTimes[i]);
-        for (int i = 0; i < cumHazard.Length; i++)
-            _cumulativeHazard[i] = NumOps.FromDouble(cumHazard[i]);
-        for (int i = 0; i < variance.Length; i++)
-            _variance[i] = NumOps.FromDouble(variance[i]);
-    }
 }
diff --git a/src/SurvivalAnalysis/RandomSurvivalForest.cs b/src/SurvivalAnalysis/RandomSurvivalForest.cs
index f59905afe3..5716427a37 100644
--- a/src/SurvivalAnalysis/RandomSurvivalForest.cs
+++ b/src/SurvivalAnalysis/RandomSurvivalForest.cs
@@ -503,52 +503,6 @@ public override IFullModel<T, Matrix<T>, Vector<T>> WithParameters(Vector<T> par
         return new RandomSurvivalForest<T>(NumTrees, MaxDepth, MinSamplesLeaf, MaxFeatures);
     }
 
-    /// <inheritdoc />
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        return new RandomSurvivalForest<T>(NumTrees, MaxDepth, MinSamplesLeaf, MaxFeatures);
-    }
-
-    /// <summary>
-    /// Creates a deep copy of this Random Survival Forest, preserving the
-    /// trained tree ensemble. The base <see cref="SurvivalModelBase{T}.DeepCopy"/>
-    /// only serializes <c>NumFeatures</c> and <c>IsFitted</c>, so without this
-    /// override the cloned forest would have no trees and predict zero. Per
-    /// Ishwaran et al. 2008 the trees are the model — preserving them is
-    /// required for any clone to reproduce the original's predictions.
-    /// </summary>
-    public override IFullModel<T, Matrix<T>, Vector<T>> DeepCopy()
-    {
-        var copy = new RandomSurvivalForest<T>(NumTrees, MaxDepth, MinSamplesLeaf, MaxFeatures);
-        copy.NumFeatures = NumFeatures;
-        copy.IsFitted = IsFitted;
-        if (FeatureNames is not null)
-        {
-            copy.FeatureNames = (string[])FeatureNames.Clone();
-        }
-        if (_trees is not null)
-        {
-            copy._trees = new List<SurvivalTree>(_trees.Count);
-            foreach (var tree in _trees)
-            {
-                copy._trees.Add(CloneTree(tree));
-            }
-        }
-        if (TrainedEventTimes is not null)
-        {
-            var times = new Vector<T>(TrainedEventTimes.Length);
-            for (int i = 0; i < TrainedEventTimes.Length; i++) times[i] = TrainedEventTimes[i];
-            copy.TrainedEventTimes = times;
-        }
-        if (BaselineSurvivalFunction is not null)
-        {
-            var baseline = new Vector<T>(BaselineSurvivalFunction.Length);
-            for (int i = 0; i < BaselineSurvivalFunction.Length; i++) baseline[i] = BaselineSurvivalFunction[i];
-            copy.BaselineSurvivalFunction = baseline;
-        }
-        return copy;
-    }
-
     private static SurvivalTree CloneTree(SurvivalTree tree)
     {
         var copy = new SurvivalTree
diff --git a/src/SurvivalAnalysis/SurvivalModelBase.cs b/src/SurvivalAnalysis/SurvivalModelBase.cs
index a802169405..1395c48570 100644
--- a/src/SurvivalAnalysis/SurvivalModelBase.cs
+++ b/src/SurvivalAnalysis/SurvivalModelBase.cs
@@ -1,4 +1,5 @@
 using System.Text;
+using AiDotNet.Attributes;
 using AiDotNet.Autodiff;
 using AiDotNet.Enums;
 using AiDotNet.Helpers;
@@ -30,8 +31,53 @@ namespace AiDotNet.SurvivalAnalysis;
 /// - Managing trained model state
 /// </para>
 /// </remarks>
-public abstract class SurvivalModelBase<T> : ISurvivalModel<T>, IModelShape, IParameterizable<T, Matrix<T>, Vector<T>>, IParameterManifestProvider
+public abstract partial class SurvivalModelBase<T> : ISurvivalModel<T>, IModelShape, IParameterizable<T, Matrix<T>, Vector<T>>, IParameterManifestProvider
 {
+    // --- declared state (ModelStateRegistry) ---
+    // Identical in every model base because these bases are siblings over the same interfaces rather
+    // than one hierarchy; the logic itself lives once in ModelStateRegistry/ModelStateEnvelope.
+
+    /// <summary>State that is not a parameter vector, declared once and persisted by this base.</summary>
+    private readonly AiDotNet.Models.ModelStateRegistry<T> _declaredState = new();
+    private bool _declaredStateRegistered;
+
+    /// <summary>
+    /// Declare state here that the parameter vector does not carry -- a retained training set,
+    /// fitted knots, kernel centres, an ensemble's children. Both halves of the payload are driven
+    /// by the declaration, so they cannot drift.
+    /// </summary>
+    /// <param name="state">The registry to declare into.</param>
+    protected virtual void RegisterState(AiDotNet.Models.ModelStateRegistry<T> state)
+    {
+        // Common storage is emitted into RegisterGeneratedStateCore by ModelStateGenerator. This
+        // hook remains only for state whose shape the registry cannot express declaratively.
+    }
+    /// <summary>Generated state declarations for fields declared across this model's hierarchy.</summary>
+    /// <param name="state">The registry to declare into.</param>
+    /// <remarks>
+    /// Emitted by ModelStateGenerator into the partial model, so a model author declares nothing. The
+    /// hand-written <c>RegisterState</c> beside it exists only for state the classifier genuinely
+    /// cannot place; anything it CAN place belongs here, where it cannot be forgotten.
+    /// </remarks>
+    protected virtual void RegisterGeneratedState(AiDotNet.Models.ModelStateRegistry<T> state)
+    {
+        RegisterGeneratedStateCore(state);
+    }
+
+    /// <summary>The declared state, registered once and lazily so it runs after the constructor.</summary>
+    protected AiDotNet.Models.ModelStateRegistry<T> DeclaredState
+    {
+        get
+        {
+            if (!_declaredStateRegistered)
+            {
+                _declaredStateRegistered = true;
+                RegisterGeneratedState(_declaredState);
+                RegisterState(_declaredState);
+            }
+            return _declaredState;
+        }
+    }
     /// <summary>
     /// Numeric operations helper for generic math.
     /// </summary>
@@ -586,7 +632,7 @@ public virtual ModelMetadata<T> GetModelMetadata()
     public virtual byte[] Serialize()
     {
         ModelPersistenceGuard.EnforceBeforeSerialize();
-        return SerializeInternalUnchecked();
+        return AiDotNet.Models.ModelStateEnvelope.Append(DeclaredState, SerializeInternalUnchecked());
     }
 
     /// <summary>
@@ -614,6 +660,9 @@ private byte[] SerializeInternalUnchecked()
     /// </summary>
     public virtual void Deserialize(byte[] modelData)
     {
+        // Strips and applies any declared-state trailer, so the body below reads the payload
+        // exactly as it did before this existed.
+        modelData = AiDotNet.Models.ModelStateEnvelope.Extract(DeclaredState, modelData);
         ModelPersistenceGuard.EnforceBeforeDeserialize();
         DeserializeInternalUnchecked(modelData);
     }
@@ -711,19 +760,17 @@ public virtual IFullModel<T, Matrix<T>, Vector<T>> DeepCopy()
         // clone path (closes the subclass-override bypass surface).
         using (ModelPersistenceGuard.InternalOperation())
         {
-            byte[] serialized = SerializeInternalUnchecked();
+            byte[] serialized = AiDotNet.Models.ModelStateEnvelope.Append(
+                DeclaredState, SerializeInternalUnchecked());
             var copy = CreateNewInstance();
             if (copy is SurvivalModelBase<T> copyBase)
             {
-                copyBase.DeserializeInternalUnchecked(serialized);
-
-                // SerializeInternalUnchecked captures only NumFeatures/IsFitted — NOT the model's
-                // fitted parameters — so without this transfer every parametric survival model
-                // (LogNormalAFT/WeibullAFT/CoxPH/etc.) would clone into an unfitted shell whose
-                // Predict throws "Coefficients is null". Round-trip the fitted state through the
-                // GetParameters/SetParameters contract each subclass already implements.
-                // Non-parametric models (Kaplan-Meier, survival forests) return an empty/degenerate
-                // parameter vector, so this is a no-op for them.
+                byte[] inner = AiDotNet.Models.ModelStateEnvelope.Extract(
+                    copyBase.DeclaredState, serialized);
+                copyBase.DeserializeInternalUnchecked(inner);
+
+                // Declared state is restored first because it materializes fitted vector lengths;
+                // the flat parameter vector then remains authoritative for every registered value.
                 if (IsFitted)
                 {
                     copyBase.SetParameters(GetParameters());
@@ -740,7 +787,18 @@ public virtual IFullModel<T, Matrix<T>, Vector<T>> DeepCopy()
     /// <summary>
     /// Creates a new instance of the same type.
     /// </summary>
-    protected abstract IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance();
+    /// <remarks>
+    /// <para>
+    /// No longer abstract. Every concrete model used to be forced to write this, and 1147 of them
+    /// did -- each one a hand-copied list of constructor arguments that a new option could fall out
+    /// of without anything failing. The clone plan records that constructor at compile time instead,
+    /// so the base can rebuild the type and a model only overrides this when the generator says it
+    /// cannot: a constructor parameter with nothing holding its value, which the build reports by
+    /// name rather than leaving to be discovered by a clone that comes back subtly different.
+    /// </para>
+    /// </remarks>
+    protected virtual IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
+        => (IFullModel<T, Matrix<T>, Vector<T>>)AiDotNet.Models.CloneEngine.CopyConfiguration(this);
 
     /// <summary>
     /// Creates a clone of the model.
diff --git a/src/SurvivalAnalysis/WeibullAFT.cs b/src/SurvivalAnalysis/WeibullAFT.cs
index 8bbfb6712c..be832ac82d 100644
--- a/src/SurvivalAnalysis/WeibullAFT.cs
+++ b/src/SurvivalAnalysis/WeibullAFT.cs
@@ -52,7 +52,7 @@ namespace AiDotNet.SurvivalAnalysis;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
 [ResearchPaper("Survival Analysis: Techniques for Censored and Truncated Data", "https://doi.org/10.1007/978-1-4757-3294-8")]
-public class WeibullAFT<T> : SurvivalModelBase<T>
+public partial class WeibullAFT<T> : SurvivalModelBase<T>
 {
 
     /// <inheritdoc />
@@ -409,55 +409,5 @@ public override IFullModel<T, Matrix<T>, Vector<T>> WithParameters(Vector<T> par
     }
 
     /// <inheritdoc />
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateNewInstance()
-    {
-        return new WeibullAFT<T>(MaxIterations, Tolerance);
-    }
-
-    /// <inheritdoc />
-
-    /// <inheritdoc />
-    public override byte[] Serialize()
-    {
-        var data = new Dictionary<string, object>
-        {
-            { "NumFeatures", NumFeatures },
-            { "IsFitted", IsFitted },
-            { "Intercept", NumOps.ToDouble(Intercept) },
-            { "Scale", NumOps.ToDouble(Scale) },
-            { "Coefficients", Coefficients?.ToArray()?.Select(NumOps.ToDouble).ToArray() ?? Array.Empty<double>() },
-            { "MaxIterations", MaxIterations },
-            { "Tolerance", Tolerance }
-        };
-
-        var metadata = GetModelMetadata();
-        metadata.ModelData = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(data));
-        return Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(metadata));
-    }
 
-    /// <inheritdoc />
-    public override void Deserialize(byte[] modelData)
-    {
-        var json = Encoding.UTF8.GetString(modelData);
-        var metadata = JsonConvert.DeserializeObject<ModelMetadata<T>>(json);
-
-        if (metadata?.ModelData is null)
-            throw new InvalidOperationException("Invalid model data.");
-
-        var dataJson = Encoding.UTF8.GetString(metadata.ModelData);
-        var data = JsonConvert.DeserializeObject<Newtonsoft.Json.Linq.JObject>(dataJson);
-
-        if (data is null)
-            throw new InvalidOperationException("Invalid model data.");
-
-        NumFeatures = data["NumFeatures"]?.ToObject<int>() ?? 0;
-        IsFitted = data["IsFitted"]?.ToObject<bool>() ?? false;
-        Intercept = NumOps.FromDouble(data["Intercept"]?.ToObject<double>() ?? 0);
-        Scale = NumOps.FromDouble(data["Scale"]?.ToObject<double>() ?? 1);
-
-        var coeffs = data["Coefficients"]?.ToObject<double[]>() ?? Array.Empty<double>();
-        Coefficients = new Vector<T>(coeffs.Length);
-        for (int i = 0; i < coeffs.Length; i++)
-            Coefficients[i] = NumOps.FromDouble(coeffs[i]);
-    }
 }
diff --git a/src/TextToSpeech/Classic/AdaSpeech.cs b/src/TextToSpeech/Classic/AdaSpeech.cs
index aafd7757c2..6423c08d77 100644
--- a/src/TextToSpeech/Classic/AdaSpeech.cs
+++ b/src/TextToSpeech/Classic/AdaSpeech.cs
@@ -48,7 +48,7 @@ namespace AiDotNet.TextToSpeech.Classic;
     Year = 2021,
     Authors = "Chen et al."
 )]
-public class AdaSpeech<T> : TtsModelBase<T>, IAcousticModel<T>
+public partial class AdaSpeech<T> : TtsModelBase<T>, IAcousticModel<T>
 {
     private readonly AdaSpeechOptions _options;
     private readonly IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer;
@@ -280,44 +280,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.MelChannels);
-        writer.Write(_options.HiddenDim);
-        writer.Write(_options.NumEncoderLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.ConditionDim);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.MelChannels = reader.ReadInt32();
-        _options.HiddenDim = reader.ReadInt32();
-        _options.NumEncoderLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.ConditionDim = reader.ReadInt32();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        base.HiddenDim = _options.HiddenDim;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new AdaSpeech<T>(Architecture, mp, _options);
-        return new AdaSpeech<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/TextToSpeech/Classic/AdaSpeech2.cs b/src/TextToSpeech/Classic/AdaSpeech2.cs
index 433b11a4cc..b05b2c1eac 100644
--- a/src/TextToSpeech/Classic/AdaSpeech2.cs
+++ b/src/TextToSpeech/Classic/AdaSpeech2.cs
@@ -48,7 +48,7 @@ namespace AiDotNet.TextToSpeech.Classic;
     Year = 2021,
     Authors = "Yan et al."
 )]
-public class AdaSpeech2<T> : TtsModelBase<T>, IAcousticModel<T>
+public partial class AdaSpeech2<T> : TtsModelBase<T>, IAcousticModel<T>
 {
     private readonly AdaSpeech2Options _options;
     private readonly IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer;
@@ -243,45 +243,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.MelChannels);
-        writer.Write(_options.HiddenDim);
-        writer.Write(_options.NumEncoderLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.Mel2PhDim);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.MelChannels = reader.ReadInt32();
-        _options.HiddenDim = reader.ReadInt32();
-        _options.NumEncoderLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.Mel2PhDim = reader.ReadInt32();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        base.HiddenDim = _options.HiddenDim;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var options = new AdaSpeech2Options(_options);
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new AdaSpeech2<T>(Architecture, mp, options);
-        return new AdaSpeech2<T>(Architecture, options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/TextToSpeech/Classic/AlignTTS.cs b/src/TextToSpeech/Classic/AlignTTS.cs
index bbad5d0807..fc12b68a65 100644
--- a/src/TextToSpeech/Classic/AlignTTS.cs
+++ b/src/TextToSpeech/Classic/AlignTTS.cs
@@ -48,7 +48,7 @@ namespace AiDotNet.TextToSpeech.Classic;
     Year = 2020,
     Authors = "Zeng et al."
 )]
-public class AlignTTS<T> : TtsModelBase<T>, IAcousticModel<T>
+public partial class AlignTTS<T> : TtsModelBase<T>, IAcousticModel<T>
 {
     private readonly AlignTTSOptions _options;
     private readonly IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer;
@@ -273,42 +273,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.MelChannels);
-        writer.Write(_options.HiddenDim);
-        writer.Write(_options.NumEncoderLayers);
-        writer.Write(_options.NumDecoderLayers);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.MelChannels = reader.ReadInt32();
-        _options.HiddenDim = reader.ReadInt32();
-        _options.NumEncoderLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        base.HiddenDim = _options.HiddenDim;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new AlignTTS<T>(Architecture, mp, _options);
-        return new AlignTTS<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/TextToSpeech/Classic/DeepVoice3.cs b/src/TextToSpeech/Classic/DeepVoice3.cs
index 9783f7501e..6445ff1a3e 100644
--- a/src/TextToSpeech/Classic/DeepVoice3.cs
+++ b/src/TextToSpeech/Classic/DeepVoice3.cs
@@ -49,7 +49,7 @@ namespace AiDotNet.TextToSpeech.Classic;
     Year = 2018,
     Authors = "Ping et al."
 )]
-public class DeepVoice3<T> : TtsModelBase<T>, IAcousticModel<T>
+public partial class DeepVoice3<T> : TtsModelBase<T>, IAcousticModel<T>
 {
     private readonly DeepVoice3Options _options;
 
@@ -291,56 +291,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.MelChannels);
-        writer.Write(_options.HiddenDim);
-        writer.Write(_options.EncoderDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.NumEncoderLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.ConvKernelSize);
-        writer.Write(_options.NumSpeakers);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.MelChannels = reader.ReadInt32();
-        _options.HiddenDim = reader.ReadInt32();
-        _options.EncoderDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.NumEncoderLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.ConvKernelSize = reader.ReadInt32();
-        _options.NumSpeakers = reader.ReadInt32();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        base.HiddenDim = _options.HiddenDim;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new DeepVoice3<T>(Architecture, mp, new DeepVoice3Options(_options));
 
-        var cloneOptimizer = _optimizer?.GetOptions() is AdamWOptimizerOptions<T, Tensor<T>, Tensor<T>> options
-            ? new AdamWOptimizer<T, Tensor<T>, Tensor<T>>(
-                null,
-                new AdamWOptimizerOptions<T, Tensor<T>, Tensor<T>>(options))
-            : null;
-        return new DeepVoice3<T>(Architecture, new DeepVoice3Options(_options), cloneOptimizer);
-    }
 
     private void ThrowIfDisposed()
     {
diff --git a/src/TextToSpeech/Classic/FastSpeech.cs b/src/TextToSpeech/Classic/FastSpeech.cs
index 59e5c087f9..f2f061ad30 100644
--- a/src/TextToSpeech/Classic/FastSpeech.cs
+++ b/src/TextToSpeech/Classic/FastSpeech.cs
@@ -49,7 +49,7 @@ namespace AiDotNet.TextToSpeech.Classic;
     Year = 2019,
     Authors = "Ren et al."
 )]
-public class FastSpeech<T> : TtsModelBase<T>, IAcousticModel<T>
+public partial class FastSpeech<T> : TtsModelBase<T>, IAcousticModel<T>
 {
     private readonly FastSpeechOptions _options;
 
@@ -272,44 +272,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.MelChannels);
-        writer.Write(_options.HiddenDim);
-        writer.Write(_options.NumEncoderLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.DurationPredictorFilterSize);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.MelChannels = reader.ReadInt32();
-        _options.HiddenDim = reader.ReadInt32();
-        _options.NumEncoderLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.DurationPredictorFilterSize = reader.ReadInt32();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        base.HiddenDim = _options.HiddenDim;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new FastSpeech<T>(Architecture, mp, _options);
-        return new FastSpeech<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/TextToSpeech/Classic/FastSpeech2.cs b/src/TextToSpeech/Classic/FastSpeech2.cs
index e5dcb05109..c34421d96f 100644
--- a/src/TextToSpeech/Classic/FastSpeech2.cs
+++ b/src/TextToSpeech/Classic/FastSpeech2.cs
@@ -49,7 +49,7 @@ namespace AiDotNet.TextToSpeech.Classic;
     Year = 2020,
     Authors = "Ren et al."
 )]
-public class FastSpeech2<T> : TtsModelBase<T>, IAcousticModel<T>
+public partial class FastSpeech2<T> : TtsModelBase<T>, IAcousticModel<T>
 {
     private readonly FastSpeech2Options _options;
 
@@ -309,60 +309,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.MelChannels);
-        writer.Write(_options.HopSize);
-        writer.Write(_options.HiddenDim);
-        writer.Write(_options.EncoderDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.NumEncoderLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.UsePitchPredictor);
-        writer.Write(_options.UseEnergyPredictor);
-        writer.Write(_options.MaxTextLength);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.VocabSize);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.MelChannels = reader.ReadInt32();
-        _options.HopSize = reader.ReadInt32();
-        _options.HiddenDim = reader.ReadInt32();
-        _options.EncoderDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.NumEncoderLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.UsePitchPredictor = reader.ReadBoolean();
-        _options.UseEnergyPredictor = reader.ReadBoolean();
-        _options.MaxTextLength = reader.ReadInt32();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.VocabSize = reader.ReadInt32();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        base.HiddenDim = _options.HiddenDim;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new FastSpeech2<T>(Architecture, mp, _options);
-        return new FastSpeech2<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/TextToSpeech/Classic/ForwardTacotron.cs b/src/TextToSpeech/Classic/ForwardTacotron.cs
index dae1f00923..44ac0daf49 100644
--- a/src/TextToSpeech/Classic/ForwardTacotron.cs
+++ b/src/TextToSpeech/Classic/ForwardTacotron.cs
@@ -48,7 +48,7 @@ namespace AiDotNet.TextToSpeech.Classic;
     Year = 2021,
     Authors = "Shen et al."
 )]
-public class ForwardTacotron<T> : TtsModelBase<T>, IAcousticModel<T>
+public partial class ForwardTacotron<T> : TtsModelBase<T>, IAcousticModel<T>
 {
     private readonly ForwardTacotronOptions _options;
     private readonly IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer;
@@ -262,46 +262,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.MelChannels);
-        writer.Write(_options.HiddenDim);
-        writer.Write(_options.NumEncoderLayers);
-        writer.Write(_options.NumDecoderLayers);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.MelChannels = reader.ReadInt32();
-        _options.HiddenDim = reader.ReadInt32();
-        _options.NumEncoderLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        base.HiddenDim = _options.HiddenDim;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new ForwardTacotron<T>(Architecture, mp, new ForwardTacotronOptions(_options));
 
-        var cloneOptimizer = _optimizer?.GetOptions() is AdamWOptimizerOptions<T, Tensor<T>, Tensor<T>> options
-            ? new AdamWOptimizer<T, Tensor<T>, Tensor<T>>(null, new AdamWOptimizerOptions<T, Tensor<T>, Tensor<T>>(options))
-            : null;
-        return new ForwardTacotron<T>(Architecture, new ForwardTacotronOptions(_options), cloneOptimizer);
-    }
 
     private void ThrowIfDisposed()
     {
diff --git a/src/TextToSpeech/Classic/GlowTTS.cs b/src/TextToSpeech/Classic/GlowTTS.cs
index 000a60bd90..355efc6f46 100644
--- a/src/TextToSpeech/Classic/GlowTTS.cs
+++ b/src/TextToSpeech/Classic/GlowTTS.cs
@@ -48,7 +48,7 @@ namespace AiDotNet.TextToSpeech.Classic;
     Year = 2020,
     Authors = "Kim et al."
 )]
-public class GlowTTS<T> : TtsModelBase<T>, IAcousticModel<T>
+public partial class GlowTTS<T> : TtsModelBase<T>, IAcousticModel<T>
 {
     private readonly GlowTTSOptions _options;
     private readonly IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer;
@@ -259,52 +259,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.MelChannels);
-        writer.Write(_options.HiddenDim);
-        writer.Write(_options.NumEncoderLayers);
-        writer.Write(_options.NumFlowLayers);
-        writer.Write(_options.Temperature);
-        writer.Write(_options.HopSize);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.MelChannels = reader.ReadInt32();
-        _options.HiddenDim = reader.ReadInt32();
-        _options.NumEncoderLayers = reader.ReadInt32();
-        _options.NumFlowLayers = reader.ReadInt32();
-        _options.Temperature = reader.ReadDouble();
-        _options.HopSize = reader.ReadInt32();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        base.HiddenDim = _options.HiddenDim;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new GlowTTS<T>(Architecture, mp, new GlowTTSOptions(_options));
 
-        var cloneOptimizer = _optimizer?.GetOptions() is AdamWOptimizerOptions<T, Tensor<T>, Tensor<T>> optimizerOptions
-            ? new AdamWOptimizer<T, Tensor<T>, Tensor<T>>(
-                null,
-                new AdamWOptimizerOptions<T, Tensor<T>, Tensor<T>>(optimizerOptions))
-            : null;
-        return new GlowTTS<T>(Architecture, new GlowTTSOptions(_options), cloneOptimizer);
-    }
 
     private void ThrowIfDisposed()
     {
diff --git a/src/TextToSpeech/Classic/GradTTS.cs b/src/TextToSpeech/Classic/GradTTS.cs
index 16c9f2528a..d1cb106854 100644
--- a/src/TextToSpeech/Classic/GradTTS.cs
+++ b/src/TextToSpeech/Classic/GradTTS.cs
@@ -49,7 +49,7 @@ namespace AiDotNet.TextToSpeech.Classic;
     Year = 2021,
     Authors = "Popov et al."
 )]
-public class GradTTS<T> : TtsModelBase<T>, IAcousticModel<T>
+public partial class GradTTS<T> : TtsModelBase<T>, IAcousticModel<T>
 {
     private readonly GradTTSOptions _options;
 
@@ -274,52 +274,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.MelChannels);
-        writer.Write(_options.HiddenDim);
-        writer.Write(_options.NumEncoderLayers);
-        writer.Write(_options.NumDiffusionSteps);
-        writer.Write(_options.BetaStart);
-        writer.Write(_options.BetaEnd);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.MelChannels = reader.ReadInt32();
-        _options.HiddenDim = reader.ReadInt32();
-        _options.NumEncoderLayers = reader.ReadInt32();
-        _options.NumDiffusionSteps = reader.ReadInt32();
-        _options.BetaStart = reader.ReadDouble();
-        _options.BetaEnd = reader.ReadDouble();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        base.HiddenDim = _options.HiddenDim;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new GradTTS<T>(Architecture, mp, new GradTTSOptions(_options));
 
-        var cloneOptimizer = _optimizer?.GetOptions() is AdamWOptimizerOptions<T, Tensor<T>, Tensor<T>> optimizerOptions
-            ? new AdamWOptimizer<T, Tensor<T>, Tensor<T>>(
-                null,
-                new AdamWOptimizerOptions<T, Tensor<T>, Tensor<T>>(optimizerOptions))
-            : null;
-        return new GradTTS<T>(Architecture, new GradTTSOptions(_options), cloneOptimizer);
-    }
 
     private void ThrowIfDisposed()
     {
diff --git a/src/TextToSpeech/Classic/PortaSpeech.cs b/src/TextToSpeech/Classic/PortaSpeech.cs
index ce59afd524..5ad2aa4a78 100644
--- a/src/TextToSpeech/Classic/PortaSpeech.cs
+++ b/src/TextToSpeech/Classic/PortaSpeech.cs
@@ -49,7 +49,7 @@ namespace AiDotNet.TextToSpeech.Classic;
     Year = 2021,
     Authors = "Ren et al."
 )]
-public class PortaSpeech<T> : TtsModelBase<T>, IAcousticModel<T>
+public partial class PortaSpeech<T> : TtsModelBase<T>, IAcousticModel<T>
 {
     private readonly PortaSpeechOptions _options;
 
@@ -256,53 +256,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.MelChannels);
-        writer.Write(_options.HiddenDim);
-        writer.Write(_options.NumEncoderLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumFlowLayers);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.MelChannels = reader.ReadInt32();
-        _options.HiddenDim = reader.ReadInt32();
-        _options.NumEncoderLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumFlowLayers = reader.ReadInt32();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        base.HiddenDim = _options.HiddenDim;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new PortaSpeech<T>(Architecture, mp, new PortaSpeechOptions(_options));
 
-        IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? cloneOptimizer = _optimizer switch
-        {
-            AdamWOptimizer<T, Tensor<T>, Tensor<T>> when _optimizer.GetOptions() is AdamWOptimizerOptions<T, Tensor<T>, Tensor<T>> options
-                => new AdamWOptimizer<T, Tensor<T>, Tensor<T>>(null, new AdamWOptimizerOptions<T, Tensor<T>, Tensor<T>>(options)),
-            AdamOptimizer<T, Tensor<T>, Tensor<T>> when _optimizer.GetOptions() is AdamOptimizerOptions<T, Tensor<T>, Tensor<T>> options
-                => new AdamOptimizer<T, Tensor<T>, Tensor<T>>(null, new AdamOptimizerOptions<T, Tensor<T>, Tensor<T>>(options)),
-            _ => null
-        };
-        return new PortaSpeech<T>(Architecture, new PortaSpeechOptions(_options), cloneOptimizer);
-    }
 
     private IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>> CreateDefaultOptimizer()
     {
diff --git a/src/TextToSpeech/Classic/ProDiff.cs b/src/TextToSpeech/Classic/ProDiff.cs
index 783782a88d..c569b41f71 100644
--- a/src/TextToSpeech/Classic/ProDiff.cs
+++ b/src/TextToSpeech/Classic/ProDiff.cs
@@ -49,7 +49,7 @@ namespace AiDotNet.TextToSpeech.Classic;
     Year = 2022,
     Authors = "Huang et al."
 )]
-public class ProDiff<T> : TtsModelBase<T>, IAcousticModel<T>
+public partial class ProDiff<T> : TtsModelBase<T>, IAcousticModel<T>
 {
     private readonly ProDiffOptions _options;
     private readonly IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer;
@@ -287,66 +287,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.MelChannels);
-        writer.Write(_options.HiddenDim);
-        writer.Write(_options.NumEncoderLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumDiffusionSteps);
-        writer.Write(_options.HopSize);
-        writer.Write(_options.MaxTextLength);
-        writer.Write(_options.FftSize);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.MelChannels = reader.ReadInt32();
-        _options.HiddenDim = reader.ReadInt32();
-        _options.NumEncoderLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumDiffusionSteps = reader.ReadInt32();
-        _options.HopSize = reader.ReadInt32();
-        _options.MaxTextLength = reader.ReadInt32();
-        _options.FftSize = reader.ReadInt32();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        base.HiddenDim = _options.HiddenDim;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
-
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new ProDiff<T>(Architecture, mp, new ProDiffOptions(_options));
 
-        if (_usesDefaultOptimizer)
-            return new ProDiff<T>(Architecture, new ProDiffOptions(_options));
 
-        // Never share mutable optimizer state between the source and clone.
-        // Preserve the built-in Adam/AdamW settings when possible; arbitrary
-        // injected optimizer implementations fall back to ProDiff's public,
-        // paper-aligned options on the new instance.
-        IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? cloneOptimizer = _optimizer switch
-        {
-            AdamWOptimizer<T, Tensor<T>, Tensor<T>> when _optimizer.GetOptions() is AdamWOptimizerOptions<T, Tensor<T>, Tensor<T>> options
-                => new AdamWOptimizer<T, Tensor<T>, Tensor<T>>(null, CloneAdamWOptions(options)),
-            AdamOptimizer<T, Tensor<T>, Tensor<T>> when _optimizer.GetOptions() is AdamOptimizerOptions<T, Tensor<T>, Tensor<T>> options
-                => new AdamOptimizer<T, Tensor<T>, Tensor<T>>(null, CloneAdamOptions(options)),
-            _ => null
-        };
-        return new ProDiff<T>(Architecture, new ProDiffOptions(_options), cloneOptimizer);
-    }
 
     private IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>> CreateDefaultOptimizer()
     {
diff --git a/src/TextToSpeech/Classic/SpeedySpeech.cs b/src/TextToSpeech/Classic/SpeedySpeech.cs
index a57c305c21..91eddd59ff 100644
--- a/src/TextToSpeech/Classic/SpeedySpeech.cs
+++ b/src/TextToSpeech/Classic/SpeedySpeech.cs
@@ -49,7 +49,7 @@ namespace AiDotNet.TextToSpeech.Classic;
     Year = 2020,
     Authors = "Vainer and Durnov"
 )]
-public class SpeedySpeech<T> : TtsModelBase<T>, IAcousticModel<T>
+public partial class SpeedySpeech<T> : TtsModelBase<T>, IAcousticModel<T>
 {
     private readonly SpeedySpeechOptions _options;
 
@@ -268,44 +268,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.MelChannels);
-        writer.Write(_options.HiddenDim);
-        writer.Write(_options.NumEncoderLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.HopSize);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.MelChannels = reader.ReadInt32();
-        _options.HiddenDim = reader.ReadInt32();
-        _options.NumEncoderLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.HopSize = reader.ReadInt32();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        base.HiddenDim = _options.HiddenDim;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new SpeedySpeech<T>(Architecture, mp, _options);
-        return new SpeedySpeech<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/TextToSpeech/Classic/Tacotron.cs b/src/TextToSpeech/Classic/Tacotron.cs
index 69805fd96d..c0a694701c 100644
--- a/src/TextToSpeech/Classic/Tacotron.cs
+++ b/src/TextToSpeech/Classic/Tacotron.cs
@@ -50,7 +50,7 @@ namespace AiDotNet.TextToSpeech.Classic;
     Year = 2017,
     Authors = "Wang et al."
 )]
-public class Tacotron<T> : TtsModelBase<T>, IAcousticModel<T>
+public partial class Tacotron<T> : TtsModelBase<T>, IAcousticModel<T>
 {
     private readonly TacotronOptions _options;
     private readonly IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer;
@@ -344,54 +344,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc />
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.MelChannels);
-        writer.Write(_options.HopSize);
-        writer.Write(_options.HiddenDim);
-        writer.Write(_options.EncoderDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.NumEncoderLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.CbhgBankSize);
-        writer.Write(_options.OutputsPerStep);
-    }
 
-    /// <inheritdoc />
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.MelChannels = reader.ReadInt32();
-        _options.HopSize = reader.ReadInt32();
-        _options.HiddenDim = reader.ReadInt32();
-        _options.EncoderDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.NumEncoderLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.CbhgBankSize = reader.ReadInt32();
-        _options.OutputsPerStep = reader.ReadInt32();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        base.HiddenDim = _options.HiddenDim;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
     /// <inheritdoc />
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new Tacotron<T>(Architecture, mp, _options);
-        return new Tacotron<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/TextToSpeech/Classic/Tacotron2.cs b/src/TextToSpeech/Classic/Tacotron2.cs
index 63fb9b181f..238a4cf47f 100644
--- a/src/TextToSpeech/Classic/Tacotron2.cs
+++ b/src/TextToSpeech/Classic/Tacotron2.cs
@@ -50,7 +50,7 @@ namespace AiDotNet.TextToSpeech.Classic;
     Year = 2018,
     Authors = "Shen et al."
 )]
-public class Tacotron2<T> : TtsModelBase<T>, IAcousticModel<T>
+public partial class Tacotron2<T> : TtsModelBase<T>, IAcousticModel<T>
 {
     private readonly Tacotron2Options _options;
     private readonly IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer;
@@ -325,62 +325,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc />
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.MelChannels);
-        writer.Write(_options.HopSize);
-        writer.Write(_options.HiddenDim);
-        writer.Write(_options.EncoderDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.NumEncoderLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.PrenetDim);
-        writer.Write(_options.AttentionRnnDim);
-        writer.Write(_options.MaxTextLength);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.VocabSize);
-    }
 
-    /// <inheritdoc />
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.MelChannels = reader.ReadInt32();
-        _options.HopSize = reader.ReadInt32();
-        _options.HiddenDim = reader.ReadInt32();
-        _options.EncoderDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.NumEncoderLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.PrenetDim = reader.ReadInt32();
-        _options.AttentionRnnDim = reader.ReadInt32();
-        _options.MaxTextLength = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.VocabSize = reader.ReadInt32();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        base.HiddenDim = _options.HiddenDim;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
     /// <inheritdoc />
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new Tacotron2<T>(Architecture, mp, _options);
-        return new Tacotron2<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/TextToSpeech/Classic/TransformerTTS.cs b/src/TextToSpeech/Classic/TransformerTTS.cs
index 8c23367bcf..6a98792a9e 100644
--- a/src/TextToSpeech/Classic/TransformerTTS.cs
+++ b/src/TextToSpeech/Classic/TransformerTTS.cs
@@ -49,7 +49,7 @@ namespace AiDotNet.TextToSpeech.Classic;
     Year = 2019,
     Authors = "Li et al."
 )]
-public class TransformerTTS<T> : TtsModelBase<T>, IAcousticModel<T>
+public partial class TransformerTTS<T> : TtsModelBase<T>, IAcousticModel<T>
 {
     private readonly TransformerTTSOptions _options;
 
@@ -275,50 +275,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.MelChannels);
-        writer.Write(_options.HiddenDim);
-        writer.Write(_options.EncoderDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.NumEncoderLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.FeedForwardDim);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.MelChannels = reader.ReadInt32();
-        _options.HiddenDim = reader.ReadInt32();
-        _options.EncoderDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.NumEncoderLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.FeedForwardDim = reader.ReadInt32();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        base.HiddenDim = _options.HiddenDim;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new TransformerTTS<T>(Architecture, mp, _options);
-        return new TransformerTTS<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/TextToSpeech/CodecBased/Amphion.cs b/src/TextToSpeech/CodecBased/Amphion.cs
index 056de15fea..8e0f4492b2 100644
--- a/src/TextToSpeech/CodecBased/Amphion.cs
+++ b/src/TextToSpeech/CodecBased/Amphion.cs
@@ -40,7 +40,7 @@ namespace AiDotNet.TextToSpeech.CodecBased;
     Year = 2024,
     Authors = "Zhang et al."
 )]
-public class Amphion<T> : TtsModelBase<T>, ICodecTts<T>
+public partial class Amphion<T> : TtsModelBase<T>, ICodecTts<T>
 {
     private readonly AmphionOptions _options;
 
@@ -260,50 +260,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.NumCodebooks);
-        writer.Write(_options.LLMDim);
-        writer.Write(_options.CodebookSize);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.NumEncoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.NumLLMLayers);
-        writer.Write(_options.TextEncoderDim);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.NumCodebooks = reader.ReadInt32();
-        _options.LLMDim = reader.ReadInt32();
-        _options.CodebookSize = reader.ReadInt32();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.NumEncoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.NumLLMLayers = reader.ReadInt32();
-        _options.TextEncoderDim = reader.ReadInt32();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        base.HiddenDim = _options.LLMDim;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new Amphion<T>(Architecture, mp, _options);
-        return new Amphion<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/TextToSpeech/CodecBased/AudioLM.cs b/src/TextToSpeech/CodecBased/AudioLM.cs
index a566510fb8..faf8909343 100644
--- a/src/TextToSpeech/CodecBased/AudioLM.cs
+++ b/src/TextToSpeech/CodecBased/AudioLM.cs
@@ -48,7 +48,7 @@ namespace AiDotNet.TextToSpeech.CodecBased;
     Year = 2023,
     Authors = "Borsos et al."
 )]
-public class AudioLM<T> : TtsModelBase<T>, ICodecTts<T>
+public partial class AudioLM<T> : TtsModelBase<T>, ICodecTts<T>
 {
     private readonly AudioLMOptions _options;
     private readonly IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer;
@@ -249,60 +249,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc />
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.NumCodebooks);
-        writer.Write(_options.LLMDim);
-        writer.Write(_options.CodebookSize);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.NumEncoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.NumLLMLayers);
-        writer.Write(_options.TextEncoderDim);
-        writer.Write(_options.MelChannels);
-        writer.Write(_options.HopSize);
-        writer.Write(_options.CodecFrameRate);
-        writer.Write(_options.MaxTextLength);
-    }
 
-    /// <inheritdoc />
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.NumCodebooks = reader.ReadInt32();
-        _options.LLMDim = reader.ReadInt32();
-        _options.CodebookSize = reader.ReadInt32();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.NumEncoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.NumLLMLayers = reader.ReadInt32();
-        _options.TextEncoderDim = reader.ReadInt32();
-        _options.MelChannels = reader.ReadInt32();
-        _options.HopSize = reader.ReadInt32();
-        _options.CodecFrameRate = reader.ReadInt32();
-        _options.MaxTextLength = reader.ReadInt32();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        base.HiddenDim = _options.LLMDim;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
     /// <inheritdoc />
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new AudioLM<T>(Architecture, mp, new AudioLMOptions(_options));
-        return new AudioLM<T>(Architecture, new AudioLMOptions(_options));
-    }
+
 
     private IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>> CreateDefaultOptimizer()
         => new AdamWOptimizer<T, Tensor<T>, Tensor<T>>(
diff --git a/src/TextToSpeech/CodecBased/Bark.cs b/src/TextToSpeech/CodecBased/Bark.cs
index 03106e3326..613dc2a97f 100644
--- a/src/TextToSpeech/CodecBased/Bark.cs
+++ b/src/TextToSpeech/CodecBased/Bark.cs
@@ -26,7 +26,7 @@ namespace AiDotNet.TextToSpeech.CodecBased;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Bark: Text-Prompted Generative Audio Model", "https://github.com/suno-ai/bark")]
-public class Bark<T> : BarkModel<T>, ICodecTts<T>
+public partial class Bark<T> : BarkModel<T>, ICodecTts<T>
 {
     private readonly ITokenizer? _configuredTokenizer;
     private ITokenizer? _loadedTokenizer;
@@ -118,13 +118,6 @@ public override ModelMetadata<T> GetModelMetadata()
     protected override Tensor<T> PreprocessText(string text)
         => ToTokenTensorForFacade(Tokenize(text));
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-        => new Bark<T>(
-            Architecture,
-            BarkConfiguration,
-            CreateCodecForNewInstance(),
-            _configuredTokenizer ?? _loadedTokenizer);
-
     private IReadOnlyList<int> Tokenize(string text)
     {
         if (string.IsNullOrWhiteSpace(text))
diff --git a/src/TextToSpeech/CodecBased/BarkModel.cs b/src/TextToSpeech/CodecBased/BarkModel.cs
index eef81d610d..249d4c8e38 100644
--- a/src/TextToSpeech/CodecBased/BarkModel.cs
+++ b/src/TextToSpeech/CodecBased/BarkModel.cs
@@ -634,40 +634,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return metadata;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.NumCodebooks);
-        writer.Write(_options.CodebookSize);
-        writer.Write(_options.CodecFrameRate);
-        WriteStage(writer, _options.Semantic);
-        WriteStage(writer, _options.Coarse);
-        WriteStage(writer, _options.Fine);
-    }
-
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        int sampleRate = reader.ReadInt32();
-        int codebooks = reader.ReadInt32();
-        int codebookSize = reader.ReadInt32();
-        int frameRate = reader.ReadInt32();
-        var semantic = ReadStage(reader);
-        var coarse = ReadStage(reader);
-        var fine = ReadStage(reader);
-
-        if (sampleRate != _options.SampleRate || codebooks != _options.NumCodebooks
-            || codebookSize != _options.CodebookSize || frameRate != _options.CodecFrameRate
-            || !StageMatches(semantic, _options.Semantic)
-            || !StageMatches(coarse, _options.Coarse)
-            || !StageMatches(fine, _options.Fine))
-        {
-            throw new InvalidDataException(
-                "The serialized Bark checkpoint architecture does not match this BarkOptions configuration.");
-        }
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-        => new BarkModel<T>(Architecture, new BarkOptions(_options), CreateCodecForNewInstance());
+
+
 
     /// <summary>
     /// Recreates the injected codec dependency for cloning while leaving Bark parameter transfer to
diff --git a/src/TextToSpeech/CodecBased/CSM.cs b/src/TextToSpeech/CodecBased/CSM.cs
index 2d0c4c0008..89ca0001ad 100644
--- a/src/TextToSpeech/CodecBased/CSM.cs
+++ b/src/TextToSpeech/CodecBased/CSM.cs
@@ -35,7 +35,7 @@ namespace AiDotNet.TextToSpeech.CodecBased;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Sesame CSM: Conversational Speech Model", "https://github.com/SesameAI/csm")]
-public class CSM<T> : TtsModelBase<T>, ICodecTts<T>
+public partial class CSM<T> : TtsModelBase<T>, ICodecTts<T>
 {
     private readonly CSMOptions _options;
 
@@ -255,50 +255,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.NumCodebooks);
-        writer.Write(_options.LLMDim);
-        writer.Write(_options.CodebookSize);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.NumEncoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.NumLLMLayers);
-        writer.Write(_options.TextEncoderDim);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.NumCodebooks = reader.ReadInt32();
-        _options.LLMDim = reader.ReadInt32();
-        _options.CodebookSize = reader.ReadInt32();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.NumEncoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.NumLLMLayers = reader.ReadInt32();
-        _options.TextEncoderDim = reader.ReadInt32();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        base.HiddenDim = _options.LLMDim;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new CSM<T>(Architecture, mp, _options);
-        return new CSM<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/TextToSpeech/CodecBased/ChatTTS.cs b/src/TextToSpeech/CodecBased/ChatTTS.cs
index 343fc4ab66..24d93b9b15 100644
--- a/src/TextToSpeech/CodecBased/ChatTTS.cs
+++ b/src/TextToSpeech/CodecBased/ChatTTS.cs
@@ -35,7 +35,7 @@ namespace AiDotNet.TextToSpeech.CodecBased;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("ChatTTS: A Generative Speech Model", "https://github.com/2noise/ChatTTS")]
-public class ChatTTS<T> : TtsModelBase<T>, ICodecTts<T>
+public partial class ChatTTS<T> : TtsModelBase<T>, ICodecTts<T>
 {
     private readonly ChatTTSOptions _options;
 
@@ -199,58 +199,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.NumCodebooks);
-        writer.Write(_options.LLMDim);
-        writer.Write(_options.CodebookSize);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.NumEncoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.NumLLMLayers);
-        writer.Write(_options.TextEncoderDim);
-        writer.Write(_options.MelChannels);
-        writer.Write(_options.HopSize);
-        writer.Write(_options.CodecFrameRate);
-        writer.Write(_options.MaxTextLength);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.NumCodebooks = reader.ReadInt32();
-        _options.LLMDim = reader.ReadInt32();
-        _options.CodebookSize = reader.ReadInt32();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.NumEncoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.NumLLMLayers = reader.ReadInt32();
-        _options.TextEncoderDim = reader.ReadInt32();
-        _options.MelChannels = reader.ReadInt32();
-        _options.HopSize = reader.ReadInt32();
-        _options.CodecFrameRate = reader.ReadInt32();
-        _options.MaxTextLength = reader.ReadInt32();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        base.HiddenDim = _options.LLMDim;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new ChatTTS<T>(Architecture, mp, _options);
-        return new ChatTTS<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/TextToSpeech/CodecBased/CosyVoice.cs b/src/TextToSpeech/CodecBased/CosyVoice.cs
index 14d15fba9e..433bbbf870 100644
--- a/src/TextToSpeech/CodecBased/CosyVoice.cs
+++ b/src/TextToSpeech/CodecBased/CosyVoice.cs
@@ -49,7 +49,7 @@ namespace AiDotNet.TextToSpeech.CodecBased;
     Year = 2024,
     Authors = "Du et al."
 )]
-public class CosyVoice<T> : TtsModelBase<T>, ICodecTts<T>
+public partial class CosyVoice<T> : TtsModelBase<T>, ICodecTts<T>
 {
     private readonly CosyVoiceOptions _options;
     private readonly IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer;
@@ -254,57 +254,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc />
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.NumCodebooks);
-        writer.Write(_options.LLMDim);
-        writer.Write(_options.CodebookSize);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.NumEncoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.NumLLMLayers);
-        writer.Write(_options.TextEncoderDim);
-        writer.Write(_options.MelChannels);
-        writer.Write(_options.HopSize);
-    }
 
-    /// <inheritdoc />
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.NumCodebooks = reader.ReadInt32();
-        _options.LLMDim = reader.ReadInt32();
-        _options.CodebookSize = reader.ReadInt32();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.NumEncoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.NumLLMLayers = reader.ReadInt32();
-        _options.TextEncoderDim = reader.ReadInt32();
-        _options.MelChannels = reader.ReadInt32();
-        _options.HopSize = reader.ReadInt32();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        base.HiddenDim = _options.LLMDim;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
     /// <inheritdoc />
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var cloneOptions = new CosyVoiceOptions(_options);
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new CosyVoice<T>(Architecture, mp, cloneOptions);
-        return new CosyVoice<T>(Architecture, cloneOptions);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/TextToSpeech/CodecBased/CosyVoice2.cs b/src/TextToSpeech/CodecBased/CosyVoice2.cs
index efd4940e30..428e8157b8 100644
--- a/src/TextToSpeech/CodecBased/CosyVoice2.cs
+++ b/src/TextToSpeech/CodecBased/CosyVoice2.cs
@@ -40,7 +40,7 @@ namespace AiDotNet.TextToSpeech.CodecBased;
     Year = 2024,
     Authors = "Du et al."
 )]
-public class CosyVoice2<T> : TtsModelBase<T>, ICodecTts<T>
+public partial class CosyVoice2<T> : TtsModelBase<T>, ICodecTts<T>
 {
     private readonly CosyVoice2Options _options;
 
@@ -263,54 +263,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.NumCodebooks);
-        writer.Write(_options.LLMDim);
-        writer.Write(_options.CodebookSize);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.NumEncoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.NumLLMLayers);
-        writer.Write(_options.TextEncoderDim);
-        writer.Write(_options.MelChannels);
-        writer.Write(_options.HopSize);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.NumCodebooks = reader.ReadInt32();
-        _options.LLMDim = reader.ReadInt32();
-        _options.CodebookSize = reader.ReadInt32();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.NumEncoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.NumLLMLayers = reader.ReadInt32();
-        _options.TextEncoderDim = reader.ReadInt32();
-        _options.MelChannels = reader.ReadInt32();
-        _options.HopSize = reader.ReadInt32();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        base.HiddenDim = _options.LLMDim;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new CosyVoice2<T>(Architecture, mp, _options);
-        return new CosyVoice2<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/TextToSpeech/CodecBased/CosyVoice3.cs b/src/TextToSpeech/CodecBased/CosyVoice3.cs
index 66a087044f..9a5360d28a 100644
--- a/src/TextToSpeech/CodecBased/CosyVoice3.cs
+++ b/src/TextToSpeech/CodecBased/CosyVoice3.cs
@@ -47,7 +47,7 @@ namespace AiDotNet.TextToSpeech.CodecBased;
     "CosyVoice: Scalable Streaming Speech Synthesis",
     "https://arxiv.org/abs/2412.10117"
 )]
-public class CosyVoice3<T> : TtsModelBase<T>, ICodecTts<T>
+public partial class CosyVoice3<T> : TtsModelBase<T>, ICodecTts<T>
 {
     private readonly CosyVoice3Options _options;
     private readonly IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer;
@@ -249,56 +249,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc />
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.CodebookSize);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.LLMDim);
-        writer.Write(_options.NumCodebooks);
-        writer.Write(_options.NumEncoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.NumLLMLayers);
-        writer.Write(_options.TextEncoderDim);
-        writer.Write(_options.MelChannels);
-        writer.Write(_options.HopSize);
-    }
 
-    /// <inheritdoc />
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.CodebookSize = reader.ReadInt32();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.LLMDim = reader.ReadInt32();
-        _options.NumCodebooks = reader.ReadInt32();
-        _options.NumEncoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.NumLLMLayers = reader.ReadInt32();
-        _options.TextEncoderDim = reader.ReadInt32();
-        _options.MelChannels = reader.ReadInt32();
-        _options.HopSize = reader.ReadInt32();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        base.HiddenDim = _options.LLMDim;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
     /// <inheritdoc />
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new CosyVoice3<T>(Architecture, mp, _options);
-        return new CosyVoice3<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/TextToSpeech/CodecBased/Dia.cs b/src/TextToSpeech/CodecBased/Dia.cs
index 9a4dcf78b1..b653b2f3d1 100644
--- a/src/TextToSpeech/CodecBased/Dia.cs
+++ b/src/TextToSpeech/CodecBased/Dia.cs
@@ -35,7 +35,7 @@ namespace AiDotNet.TextToSpeech.CodecBased;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Nari Labs Dia", "https://github.com/nari-labs/dia")]
-public class Dia<T> : TtsModelBase<T>, ICodecTts<T>
+public partial class Dia<T> : TtsModelBase<T>, ICodecTts<T>
 {
     private readonly DiaOptions _options;
 
@@ -199,54 +199,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.NumCodebooks);
-        writer.Write(_options.LLMDim);
-        writer.Write(_options.CodebookSize);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.NumEncoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.NumLLMLayers);
-        writer.Write(_options.TextEncoderDim);
-        writer.Write(_options.MelChannels);
-        writer.Write(_options.HopSize);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.NumCodebooks = reader.ReadInt32();
-        _options.LLMDim = reader.ReadInt32();
-        _options.CodebookSize = reader.ReadInt32();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.NumEncoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.NumLLMLayers = reader.ReadInt32();
-        _options.TextEncoderDim = reader.ReadInt32();
-        _options.MelChannels = reader.ReadInt32();
-        _options.HopSize = reader.ReadInt32();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        base.HiddenDim = _options.LLMDim;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new Dia<T>(Architecture, mp, _options);
-        return new Dia<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/TextToSpeech/CodecBased/FireRedTTS.cs b/src/TextToSpeech/CodecBased/FireRedTTS.cs
index e33b83e8ae..3c2eada31d 100644
--- a/src/TextToSpeech/CodecBased/FireRedTTS.cs
+++ b/src/TextToSpeech/CodecBased/FireRedTTS.cs
@@ -40,7 +40,7 @@ namespace AiDotNet.TextToSpeech.CodecBased;
     Year = 2024,
     Authors = "Guo et al."
 )]
-public class FireRedTTS<T> : TtsModelBase<T>, ICodecTts<T>
+public partial class FireRedTTS<T> : TtsModelBase<T>, ICodecTts<T>
 {
     private readonly FireRedTTSOptions _options;
 
@@ -222,58 +222,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.NumCodebooks);
-        writer.Write(_options.LLMDim);
-        writer.Write(_options.CodebookSize);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.NumEncoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.NumLLMLayers);
-        writer.Write(_options.TextEncoderDim);
-        writer.Write(_options.MelChannels);
-        writer.Write(_options.HopSize);
-        writer.Write(_options.CodecFrameRate);
-        writer.Write(_options.MaxTextLength);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.NumCodebooks = reader.ReadInt32();
-        _options.LLMDim = reader.ReadInt32();
-        _options.CodebookSize = reader.ReadInt32();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.NumEncoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.NumLLMLayers = reader.ReadInt32();
-        _options.TextEncoderDim = reader.ReadInt32();
-        _options.MelChannels = reader.ReadInt32();
-        _options.HopSize = reader.ReadInt32();
-        _options.CodecFrameRate = reader.ReadInt32();
-        _options.MaxTextLength = reader.ReadInt32();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        base.HiddenDim = _options.LLMDim;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new FireRedTTS<T>(Architecture, mp, _options);
-        return new FireRedTTS<T>(Architecture, _options, _optimizer);
-    }
+
 
     private static void ValidateOptions(FireRedTTSOptions opts)
     {
diff --git a/src/TextToSpeech/CodecBased/FishSpeech.cs b/src/TextToSpeech/CodecBased/FishSpeech.cs
index ed638df7ee..b4b8d46451 100644
--- a/src/TextToSpeech/CodecBased/FishSpeech.cs
+++ b/src/TextToSpeech/CodecBased/FishSpeech.cs
@@ -40,7 +40,7 @@ namespace AiDotNet.TextToSpeech.CodecBased;
     Year = 2024,
     Authors = "Fish Audio"
 )]
-public class FishSpeech<T> : TtsModelBase<T>, ICodecTts<T>
+public partial class FishSpeech<T> : TtsModelBase<T>, ICodecTts<T>
 {
     private readonly FishSpeechOptions _options;
 
@@ -208,50 +208,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.NumCodebooks);
-        writer.Write(_options.LLMDim);
-        writer.Write(_options.CodebookSize);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.NumEncoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.NumLLMLayers);
-        writer.Write(_options.TextEncoderDim);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.NumCodebooks = reader.ReadInt32();
-        _options.LLMDim = reader.ReadInt32();
-        _options.CodebookSize = reader.ReadInt32();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.NumEncoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.NumLLMLayers = reader.ReadInt32();
-        _options.TextEncoderDim = reader.ReadInt32();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        base.HiddenDim = _options.LLMDim;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new FishSpeech<T>(Architecture, mp, _options);
-        return new FishSpeech<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/TextToSpeech/CodecBased/FishSpeechV15.cs b/src/TextToSpeech/CodecBased/FishSpeechV15.cs
index 87db119076..8655b24867 100644
--- a/src/TextToSpeech/CodecBased/FishSpeechV15.cs
+++ b/src/TextToSpeech/CodecBased/FishSpeechV15.cs
@@ -40,7 +40,7 @@ namespace AiDotNet.TextToSpeech.CodecBased;
     Year = 2024,
     Authors = "Fish Audio"
 )]
-public class FishSpeechV15<T> : TtsModelBase<T>, ICodecTts<T>
+public partial class FishSpeechV15<T> : TtsModelBase<T>, ICodecTts<T>
 {
     private readonly FishSpeechV15Options _options;
 
@@ -265,50 +265,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.CodebookSize);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.LLMDim);
-        writer.Write(_options.NumCodebooks);
-        writer.Write(_options.NumEncoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.NumLLMLayers);
-        writer.Write(_options.TextEncoderDim);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.CodebookSize = reader.ReadInt32();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.LLMDim = reader.ReadInt32();
-        _options.NumCodebooks = reader.ReadInt32();
-        _options.NumEncoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.NumLLMLayers = reader.ReadInt32();
-        _options.TextEncoderDim = reader.ReadInt32();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        base.HiddenDim = _options.LLMDim;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new FishSpeechV15<T>(Architecture, mp, _options);
-        return new FishSpeechV15<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/TextToSpeech/CodecBased/GPTSoVITS.cs b/src/TextToSpeech/CodecBased/GPTSoVITS.cs
index 7924438011..12f195f5cf 100644
--- a/src/TextToSpeech/CodecBased/GPTSoVITS.cs
+++ b/src/TextToSpeech/CodecBased/GPTSoVITS.cs
@@ -35,7 +35,7 @@ namespace AiDotNet.TextToSpeech.CodecBased;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("GPT-SoVITS: Zero-Shot Text-to-Speech", "https://github.com/RVC-Boss/GPT-SoVITS")]
-public class GPTSoVITS<T> : TtsModelBase<T>, ICodecTts<T>
+public partial class GPTSoVITS<T> : TtsModelBase<T>, ICodecTts<T>
 {
     private readonly GPTSoVITSOptions _options;
 
@@ -197,50 +197,9 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.NumCodebooks);
-        writer.Write(_options.LLMDim);
-        writer.Write(_options.CodebookSize);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.NumEncoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.NumLLMLayers);
-        writer.Write(_options.TextEncoderDim);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.NumCodebooks = reader.ReadInt32();
-        _options.LLMDim = reader.ReadInt32();
-        _options.CodebookSize = reader.ReadInt32();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.NumEncoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.NumLLMLayers = reader.ReadInt32();
-        _options.TextEncoderDim = reader.ReadInt32();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        base.HiddenDim = _options.LLMDim;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new GPTSoVITS<T>(Architecture, mp, _options);
-        return new GPTSoVITS<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/TextToSpeech/CodecBased/IndexTTS.cs b/src/TextToSpeech/CodecBased/IndexTTS.cs
index e3eeccd242..fbf7146fb1 100644
--- a/src/TextToSpeech/CodecBased/IndexTTS.cs
+++ b/src/TextToSpeech/CodecBased/IndexTTS.cs
@@ -35,7 +35,7 @@ namespace AiDotNet.TextToSpeech.CodecBased;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("IndexTTS: Zero-Shot Text-to-Speech", "https://github.com/indexteam/IndexTTS")]
-public class IndexTTS<T> : TtsModelBase<T>, ICodecTts<T>
+public partial class IndexTTS<T> : TtsModelBase<T>, ICodecTts<T>
 {
     private readonly IndexTTSOptions _options;
 
@@ -227,85 +227,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.NumCodebooks);
-        writer.Write(_options.LLMDim);
-        writer.Write(_options.CodebookSize);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.NumEncoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.NumLLMLayers);
-        writer.Write(_options.TextEncoderDim);
-        writer.Write(_options.MelChannels);
-        writer.Write(_options.HopSize);
-        writer.Write(_options.CodecFrameRate);
-        writer.Write(_options.MaxTextLength);
-        // Appended fields keep the original prefix readable and preserve every
-        // user option that affects IndexTTS construction, inference, or training.
-        writer.Write(_options.VocabSize);
-        writer.Write(_options.MaxCodecFrames);
-        writer.Write(_options.SpeakerEmbeddingDim);
-        writer.Write(_options.FftSize);
-        writer.Write(_options.HiddenDim);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.MaxMelLength);
-        writer.Write(_options.LearningRate);
-        writer.Write(_options.WeightDecay);
-        writer.Write(_options.LanguageModelName ?? string.Empty);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.NumCodebooks = reader.ReadInt32();
-        _options.LLMDim = reader.ReadInt32();
-        _options.CodebookSize = reader.ReadInt32();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.NumEncoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.NumLLMLayers = reader.ReadInt32();
-        _options.TextEncoderDim = reader.ReadInt32();
-        _options.MelChannels = reader.ReadInt32();
-        _options.HopSize = reader.ReadInt32();
-        _options.CodecFrameRate = reader.ReadInt32();
-        _options.MaxTextLength = reader.ReadInt32();
-        // These fields were appended after the legacy payload. Older saved
-        // models end here and retain the constructor defaults for them.
-        if (reader.BaseStream.Position < reader.BaseStream.Length)
-        {
-            _options.VocabSize = reader.ReadInt32();
-            _options.MaxCodecFrames = reader.ReadInt32();
-            _options.SpeakerEmbeddingDim = reader.ReadInt32();
-            _options.FftSize = reader.ReadInt32();
-            _options.HiddenDim = reader.ReadInt32();
-            _options.NumDecoderLayers = reader.ReadInt32();
-            _options.MaxMelLength = reader.ReadInt32();
-            _options.LearningRate = reader.ReadDouble();
-            _options.WeightDecay = reader.ReadDouble();
-            _options.LanguageModelName = reader.ReadString();
-        }
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        base.HiddenDim = _options.LLMDim;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new IndexTTS<T>(Architecture, mp, _options);
-        return new IndexTTS<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/TextToSpeech/CodecBased/Llasa.cs b/src/TextToSpeech/CodecBased/Llasa.cs
index 352d2d64dc..c3b88091da 100644
--- a/src/TextToSpeech/CodecBased/Llasa.cs
+++ b/src/TextToSpeech/CodecBased/Llasa.cs
@@ -40,7 +40,7 @@ namespace AiDotNet.TextToSpeech.CodecBased;
     Year = 2025,
     Authors = "Ye et al."
 )]
-public class Llasa<T> : TtsModelBase<T>, ICodecTts<T>
+public partial class Llasa<T> : TtsModelBase<T>, ICodecTts<T>
 {
     private readonly LlasaOptions _options;
 
@@ -208,50 +208,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.NumCodebooks);
-        writer.Write(_options.LLMDim);
-        writer.Write(_options.CodebookSize);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.NumEncoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.NumLLMLayers);
-        writer.Write(_options.TextEncoderDim);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.NumCodebooks = reader.ReadInt32();
-        _options.LLMDim = reader.ReadInt32();
-        _options.CodebookSize = reader.ReadInt32();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.NumEncoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.NumLLMLayers = reader.ReadInt32();
-        _options.TextEncoderDim = reader.ReadInt32();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        base.HiddenDim = _options.LLMDim;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new Llasa<T>(Architecture, mp, _options);
-        return new Llasa<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/TextToSpeech/CodecBased/MARS5TTS.cs b/src/TextToSpeech/CodecBased/MARS5TTS.cs
index b785ed086e..bc5a9ac54e 100644
--- a/src/TextToSpeech/CodecBased/MARS5TTS.cs
+++ b/src/TextToSpeech/CodecBased/MARS5TTS.cs
@@ -38,7 +38,7 @@ namespace AiDotNet.TextToSpeech.CodecBased;
     "MARS5: A Large-Scale Multilingual TTS Model",
     "https://github.com/Camb-ai/MARS5-TTS"
 )]
-public class MARS5TTS<T> : TtsModelBase<T>, ICodecTts<T>
+public partial class MARS5TTS<T> : TtsModelBase<T>, ICodecTts<T>
 {
     private readonly MARS5TTSOptions _options;
 
@@ -206,58 +206,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.NumCodebooks);
-        writer.Write(_options.LLMDim);
-        writer.Write(_options.CodebookSize);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.NumEncoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.NumLLMLayers);
-        writer.Write(_options.TextEncoderDim);
-        writer.Write(_options.MelChannels);
-        writer.Write(_options.HopSize);
-        writer.Write(_options.CodecFrameRate);
-        writer.Write(_options.MaxTextLength);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.NumCodebooks = reader.ReadInt32();
-        _options.LLMDim = reader.ReadInt32();
-        _options.CodebookSize = reader.ReadInt32();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.NumEncoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.NumLLMLayers = reader.ReadInt32();
-        _options.TextEncoderDim = reader.ReadInt32();
-        _options.MelChannels = reader.ReadInt32();
-        _options.HopSize = reader.ReadInt32();
-        _options.CodecFrameRate = reader.ReadInt32();
-        _options.MaxTextLength = reader.ReadInt32();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        base.HiddenDim = _options.LLMDim;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions); /* native-mode layers are already reconstructed with their trained weights by the base DeserializeInternalUnchecked; clearing + re-initializing here would discard them and leave the model randomly initialized */
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new MARS5TTS<T>(Architecture, mp, _options);
-        return new MARS5TTS<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/TextToSpeech/CodecBased/NaturalSpeech.cs b/src/TextToSpeech/CodecBased/NaturalSpeech.cs
index a31fc0b7c2..f5c5e19cce 100644
--- a/src/TextToSpeech/CodecBased/NaturalSpeech.cs
+++ b/src/TextToSpeech/CodecBased/NaturalSpeech.cs
@@ -40,7 +40,7 @@ namespace AiDotNet.TextToSpeech.CodecBased;
     Year = 2022,
     Authors = "Tan et al."
 )]
-public class NaturalSpeech<T> : TtsModelBase<T>, IEndToEndTts<T>
+public partial class NaturalSpeech<T> : TtsModelBase<T>, IEndToEndTts<T>
 {
     private readonly NaturalSpeechOptions _options;
 
@@ -197,60 +197,9 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.MelChannels);
-        writer.Write(_options.HopSize);
-        writer.Write(_options.HiddenDim);
-        writer.Write(_options.NumFlowSteps);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.FilterChannels);
-        writer.Write(_options.InterChannels);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumEncoderLayers);
-        writer.Write(_options.NumHeads);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.MelChannels = reader.ReadInt32();
-        _options.HopSize = reader.ReadInt32();
-        _options.HiddenDim = reader.ReadInt32();
-        _options.NumFlowSteps = reader.ReadInt32();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.FilterChannels = reader.ReadInt32();
-        _options.InterChannels = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumEncoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        base.HiddenDim = _options.HiddenDim;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new NaturalSpeech<T>(Architecture, mp, new NaturalSpeechOptions(_options));
 
-        var cloneOptimizer = _optimizer?.GetOptions() is AdamWOptimizerOptions<T, Tensor<T>, Tensor<T>> options
-            ? new AdamWOptimizer<T, Tensor<T>, Tensor<T>>(
-                null,
-                new AdamWOptimizerOptions<T, Tensor<T>, Tensor<T>>(options))
-            : null;
-        return new NaturalSpeech<T>(Architecture, new NaturalSpeechOptions(_options), cloneOptimizer);
-    }
 
     private void ThrowIfDisposed()
     {
diff --git a/src/TextToSpeech/CodecBased/NaturalSpeech2.cs b/src/TextToSpeech/CodecBased/NaturalSpeech2.cs
index 9be7b51966..999279697e 100644
--- a/src/TextToSpeech/CodecBased/NaturalSpeech2.cs
+++ b/src/TextToSpeech/CodecBased/NaturalSpeech2.cs
@@ -50,7 +50,7 @@ namespace AiDotNet.TextToSpeech.CodecBased;
     Year = 2023,
     Authors = "Shen et al."
 )]
-public class NaturalSpeech2<T> : TtsModelBase<T>, IEndToEndTts<T>
+public partial class NaturalSpeech2<T> : TtsModelBase<T>, IEndToEndTts<T>
 {
     private readonly NaturalSpeech2Options _options;
     private readonly IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer;
@@ -270,55 +270,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc />
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.MelChannels);
-        writer.Write(_options.HiddenDim);
-        writer.Write(_options.NumDiffusionSteps);
-        writer.Write(_options.DiffusionDim);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.NumEncoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.HopSize);
-        writer.Write(_options.MaxTextLength);
-    }
 
-    /// <inheritdoc />
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.MelChannels = reader.ReadInt32();
-        _options.HiddenDim = reader.ReadInt32();
-        _options.NumDiffusionSteps = reader.ReadInt32();
-        _options.DiffusionDim = reader.ReadInt32();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.NumEncoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.HopSize = reader.ReadInt32();
-        _options.MaxTextLength = reader.ReadInt32();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        base.HiddenDim = _options.HiddenDim;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
     /// <inheritdoc />
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var options = new NaturalSpeech2Options(_options);
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new NaturalSpeech2<T>(Architecture, mp, options);
-        return new NaturalSpeech2<T>(Architecture, options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/TextToSpeech/CodecBased/NaturalSpeech3.cs b/src/TextToSpeech/CodecBased/NaturalSpeech3.cs
index 19f2f3f7f5..3fcc5dc07c 100644
--- a/src/TextToSpeech/CodecBased/NaturalSpeech3.cs
+++ b/src/TextToSpeech/CodecBased/NaturalSpeech3.cs
@@ -40,7 +40,7 @@ namespace AiDotNet.TextToSpeech.CodecBased;
     Year = 2024,
     Authors = "Ju et al."
 )]
-public class NaturalSpeech3<T> : TtsModelBase<T>, IEndToEndTts<T>
+public partial class NaturalSpeech3<T> : TtsModelBase<T>, IEndToEndTts<T>
 {
     private readonly NaturalSpeech3Options _options;
 
@@ -189,51 +189,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.MelChannels);
-        writer.Write(_options.HopSize);
-        writer.Write(_options.HiddenDim);
-        writer.Write(_options.NumDiffusionSteps);
-        writer.Write(_options.DiffusionDim);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.NumEncoderLayers);
-        writer.Write(_options.NumHeads);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.MelChannels = reader.ReadInt32();
-        _options.HopSize = reader.ReadInt32();
-        _options.HiddenDim = reader.ReadInt32();
-        _options.NumDiffusionSteps = reader.ReadInt32();
-        _options.DiffusionDim = reader.ReadInt32();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.NumEncoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        base.HiddenDim = _options.HiddenDim;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var options = new NaturalSpeech3Options(_options);
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new NaturalSpeech3<T>(Architecture, mp, options);
-        return new NaturalSpeech3<T>(Architecture, options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/TextToSpeech/CodecBased/OrpheusTTS.cs b/src/TextToSpeech/CodecBased/OrpheusTTS.cs
index a8d9259cb5..0f8d67f7d8 100644
--- a/src/TextToSpeech/CodecBased/OrpheusTTS.cs
+++ b/src/TextToSpeech/CodecBased/OrpheusTTS.cs
@@ -38,7 +38,7 @@ namespace AiDotNet.TextToSpeech.CodecBased;
     "OrpheusTTS: Audio Native Speech Generation",
     "https://github.com/canopyai/OrpheusTTS"
 )]
-public class OrpheusTTS<T> : TtsModelBase<T>, ICodecTts<T>
+public partial class OrpheusTTS<T> : TtsModelBase<T>, ICodecTts<T>
 {
     private readonly OrpheusTTSOptions _options;
 
@@ -263,55 +263,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.MelChannels);
-        writer.Write(_options.HopSize);
-        writer.Write(_options.NumCodebooks);
-        writer.Write(_options.LLMDim);
-        writer.Write(_options.CodebookSize);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.NumEncoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.NumLLMLayers);
-        writer.Write(_options.TextEncoderDim);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.MelChannels = reader.ReadInt32();
-        _options.HopSize = reader.ReadInt32();
-        _options.NumCodebooks = reader.ReadInt32();
-        _options.LLMDim = reader.ReadInt32();
-        _options.CodebookSize = reader.ReadInt32();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.NumEncoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.NumLLMLayers = reader.ReadInt32();
-        _options.TextEncoderDim = reader.ReadInt32();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        base.HiddenDim = _options.LLMDim;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var options = new OrpheusTTSOptions(_options);
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new OrpheusTTS<T>(Architecture, mp, options);
-        return new OrpheusTTS<T>(Architecture, options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/TextToSpeech/CodecBased/SPEARTTS.cs b/src/TextToSpeech/CodecBased/SPEARTTS.cs
index 9e1a87641a..e6a37a7790 100644
--- a/src/TextToSpeech/CodecBased/SPEARTTS.cs
+++ b/src/TextToSpeech/CodecBased/SPEARTTS.cs
@@ -49,7 +49,7 @@ namespace AiDotNet.TextToSpeech.CodecBased;
     Year = 2023,
     Authors = "Kharitonov et al."
 )]
-public class SPEARTTS<T> : TtsModelBase<T>, ICodecTts<T>
+public partial class SPEARTTS<T> : TtsModelBase<T>, ICodecTts<T>
 {
     private readonly SPEARTTSOptions _options;
     private readonly IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer;
@@ -319,56 +319,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc />
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.MelChannels);
-        writer.Write(_options.HopSize);
-        writer.Write(_options.CodebookSize);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.LLMDim);
-        writer.Write(_options.NumCodebooks);
-        writer.Write(_options.NumEncoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.NumLLMLayers);
-        writer.Write(_options.TextEncoderDim);
-    }
 
-    /// <inheritdoc />
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.MelChannels = reader.ReadInt32();
-        _options.HopSize = reader.ReadInt32();
-        _options.CodebookSize = reader.ReadInt32();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.LLMDim = reader.ReadInt32();
-        _options.NumCodebooks = reader.ReadInt32();
-        _options.NumEncoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.NumLLMLayers = reader.ReadInt32();
-        _options.TextEncoderDim = reader.ReadInt32();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        base.HiddenDim = _options.LLMDim;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
     /// <inheritdoc />
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new SPEARTTS<T>(Architecture, mp, _options);
-        return new SPEARTTS<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/TextToSpeech/CodecBased/SeedTTS.cs b/src/TextToSpeech/CodecBased/SeedTTS.cs
index 27e63fac46..b8ff686c1e 100644
--- a/src/TextToSpeech/CodecBased/SeedTTS.cs
+++ b/src/TextToSpeech/CodecBased/SeedTTS.cs
@@ -40,7 +40,7 @@ namespace AiDotNet.TextToSpeech.CodecBased;
     Year = 2024,
     Authors = "Seed Team, ByteDance"
 )]
-public class SeedTTS<T> : TtsModelBase<T>, ICodecTts<T>
+public partial class SeedTTS<T> : TtsModelBase<T>, ICodecTts<T>
 {
     private readonly SeedTTSOptions _options;
 
@@ -214,59 +214,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.NumCodebooks);
-        writer.Write(_options.LLMDim);
-        writer.Write(_options.CodebookSize);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.NumEncoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.NumLLMLayers);
-        writer.Write(_options.TextEncoderDim);
-        writer.Write(_options.MelChannels);
-        writer.Write(_options.HopSize);
-        writer.Write(_options.CodecFrameRate);
-        writer.Write(_options.MaxTextLength);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.NumCodebooks = reader.ReadInt32();
-        _options.LLMDim = reader.ReadInt32();
-        _options.CodebookSize = reader.ReadInt32();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.NumEncoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.NumLLMLayers = reader.ReadInt32();
-        _options.TextEncoderDim = reader.ReadInt32();
-        _options.MelChannels = reader.ReadInt32();
-        _options.HopSize = reader.ReadInt32();
-        _options.CodecFrameRate = reader.ReadInt32();
-        _options.MaxTextLength = reader.ReadInt32();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        base.HiddenDim = _options.LLMDim;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var options = new SeedTTSOptions(_options);
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new SeedTTS<T>(Architecture, mp, options);
-        return new SeedTTS<T>(Architecture, options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/TextToSpeech/CodecBased/SoundStorm.cs b/src/TextToSpeech/CodecBased/SoundStorm.cs
index 632b9a44c5..3dc793eb69 100644
--- a/src/TextToSpeech/CodecBased/SoundStorm.cs
+++ b/src/TextToSpeech/CodecBased/SoundStorm.cs
@@ -40,7 +40,7 @@ namespace AiDotNet.TextToSpeech.CodecBased;
     Year = 2023,
     Authors = "Borsos et al."
 )]
-public class SoundStorm<T> : TtsModelBase<T>, ICodecTts<T>
+public partial class SoundStorm<T> : TtsModelBase<T>, ICodecTts<T>
 {
     private readonly SoundStormOptions _options;
 
@@ -212,59 +212,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.NumCodebooks);
-        writer.Write(_options.LLMDim);
-        writer.Write(_options.CodebookSize);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.NumEncoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.NumLLMLayers);
-        writer.Write(_options.TextEncoderDim);
-        writer.Write(_options.MelChannels);
-        writer.Write(_options.HopSize);
-        writer.Write(_options.CodecFrameRate);
-        writer.Write(_options.MaxTextLength);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.NumCodebooks = reader.ReadInt32();
-        _options.LLMDim = reader.ReadInt32();
-        _options.CodebookSize = reader.ReadInt32();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.NumEncoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.NumLLMLayers = reader.ReadInt32();
-        _options.TextEncoderDim = reader.ReadInt32();
-        _options.MelChannels = reader.ReadInt32();
-        _options.HopSize = reader.ReadInt32();
-        _options.CodecFrameRate = reader.ReadInt32();
-        _options.MaxTextLength = reader.ReadInt32();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        base.HiddenDim = _options.LLMDim;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var options = new SoundStormOptions(_options);
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new SoundStorm<T>(Architecture, mp, options);
-        return new SoundStorm<T>(Architecture, options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/TextToSpeech/CodecBased/SparkTTS.cs b/src/TextToSpeech/CodecBased/SparkTTS.cs
index 91812c2f54..bcfd6eca79 100644
--- a/src/TextToSpeech/CodecBased/SparkTTS.cs
+++ b/src/TextToSpeech/CodecBased/SparkTTS.cs
@@ -40,7 +40,7 @@ namespace AiDotNet.TextToSpeech.CodecBased;
     Year = 2025,
     Authors = "Wang et al."
 )]
-public class SparkTTS<T> : TtsModelBase<T>, ICodecTts<T>
+public partial class SparkTTS<T> : TtsModelBase<T>, ICodecTts<T>
 {
     private readonly SparkTTSOptions _options;
 
@@ -261,54 +261,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.MelChannels);
-        writer.Write(_options.HopSize);
-        writer.Write(_options.NumCodebooks);
-        writer.Write(_options.LLMDim);
-        writer.Write(_options.CodebookSize);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.NumEncoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.NumLLMLayers);
-        writer.Write(_options.TextEncoderDim);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.MelChannels = reader.ReadInt32();
-        _options.HopSize = reader.ReadInt32();
-        _options.NumCodebooks = reader.ReadInt32();
-        _options.LLMDim = reader.ReadInt32();
-        _options.CodebookSize = reader.ReadInt32();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.NumEncoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.NumLLMLayers = reader.ReadInt32();
-        _options.TextEncoderDim = reader.ReadInt32();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        base.HiddenDim = _options.LLMDim;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new SparkTTS<T>(Architecture, mp, _options);
-        return new SparkTTS<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/TextToSpeech/CodecBased/TortoiseTTS.cs b/src/TextToSpeech/CodecBased/TortoiseTTS.cs
index 60a6ab6b02..f033d66df9 100644
--- a/src/TextToSpeech/CodecBased/TortoiseTTS.cs
+++ b/src/TextToSpeech/CodecBased/TortoiseTTS.cs
@@ -40,7 +40,7 @@ namespace AiDotNet.TextToSpeech.CodecBased;
     Year = 2023,
     Authors = "Betker"
 )]
-public class TortoiseTTS<T> : TtsModelBase<T>, ICodecTts<T>
+public partial class TortoiseTTS<T> : TtsModelBase<T>, ICodecTts<T>
 {
     private readonly TortoiseTTSOptions _options;
 
@@ -210,54 +210,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.MelChannels);
-        writer.Write(_options.HopSize);
-        writer.Write(_options.CodebookSize);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.LLMDim);
-        writer.Write(_options.NumCodebooks);
-        writer.Write(_options.NumEncoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.NumLLMLayers);
-        writer.Write(_options.TextEncoderDim);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.MelChannels = reader.ReadInt32();
-        _options.HopSize = reader.ReadInt32();
-        _options.CodebookSize = reader.ReadInt32();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.LLMDim = reader.ReadInt32();
-        _options.NumCodebooks = reader.ReadInt32();
-        _options.NumEncoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.NumLLMLayers = reader.ReadInt32();
-        _options.TextEncoderDim = reader.ReadInt32();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        base.HiddenDim = _options.LLMDim;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new TortoiseTTS<T>(Architecture, mp, _options);
-        return new TortoiseTTS<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/TextToSpeech/CodecBased/UniAudio.cs b/src/TextToSpeech/CodecBased/UniAudio.cs
index f40bf1478f..62a7fe8eff 100644
--- a/src/TextToSpeech/CodecBased/UniAudio.cs
+++ b/src/TextToSpeech/CodecBased/UniAudio.cs
@@ -41,7 +41,7 @@ namespace AiDotNet.TextToSpeech.CodecBased;
     Year = 2024,
     Authors = "Yang et al."
 )]
-public class UniAudio<T> : TtsModelBase<T>, ICodecTts<T>
+public partial class UniAudio<T> : TtsModelBase<T>, ICodecTts<T>
 {
     private readonly UniAudioOptions _options;
 
@@ -270,55 +270,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.MelChannels);
-        writer.Write(_options.HopSize);
-        writer.Write(_options.NumCodebooks);
-        writer.Write(_options.LLMDim);
-        writer.Write(_options.CodebookSize);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.NumEncoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.NumLLMLayers);
-        writer.Write(_options.TextEncoderDim);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.MelChannels = reader.ReadInt32();
-        _options.HopSize = reader.ReadInt32();
-        _options.NumCodebooks = reader.ReadInt32();
-        _options.LLMDim = reader.ReadInt32();
-        _options.CodebookSize = reader.ReadInt32();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.NumEncoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.NumLLMLayers = reader.ReadInt32();
-        _options.TextEncoderDim = reader.ReadInt32();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        base.HiddenDim = _options.LLMDim;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var optionsCopy = new UniAudioOptions(_options);
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new UniAudio<T>(Architecture, mp, optionsCopy);
-        return new UniAudio<T>(Architecture, optionsCopy);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/TextToSpeech/CodecBased/VALLE.cs b/src/TextToSpeech/CodecBased/VALLE.cs
index 50c17f89a9..bfe990ca5d 100644
--- a/src/TextToSpeech/CodecBased/VALLE.cs
+++ b/src/TextToSpeech/CodecBased/VALLE.cs
@@ -49,7 +49,7 @@ namespace AiDotNet.TextToSpeech.CodecBased;
     Year = 2023,
     Authors = "Wang et al."
 )]
-public class VALLE<T> : TtsModelBase<T>, ICodecTts<T>
+public partial class VALLE<T> : TtsModelBase<T>, ICodecTts<T>
 {
     private readonly VALLEOptions _options;
     private readonly IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer;
@@ -329,52 +329,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc />
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.NumCodebooks);
-        writer.Write(_options.CodebookSize);
-        writer.Write(_options.LLMDim);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.NumEncoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.NumLLMLayers);
-        writer.Write(_options.TextEncoderDim);
-    }
 
-    /// <inheritdoc />
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.NumCodebooks = reader.ReadInt32();
-        _options.CodebookSize = reader.ReadInt32();
-        _options.LLMDim = reader.ReadInt32();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.NumEncoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.NumLLMLayers = reader.ReadInt32();
-        _options.TextEncoderDim = reader.ReadInt32();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        base.HiddenDim = _options.LLMDim;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
     /// <inheritdoc />
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new VALLE<T>(Architecture, mp, _options);
-        return new VALLE<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/TextToSpeech/CodecBased/VALLE2.cs b/src/TextToSpeech/CodecBased/VALLE2.cs
index 61dac01a9b..c933d2f5b1 100644
--- a/src/TextToSpeech/CodecBased/VALLE2.cs
+++ b/src/TextToSpeech/CodecBased/VALLE2.cs
@@ -40,7 +40,7 @@ namespace AiDotNet.TextToSpeech.CodecBased;
     Year = 2024,
     Authors = "Chen et al."
 )]
-public class VALLE2<T> : TtsModelBase<T>, ICodecTts<T>
+public partial class VALLE2<T> : TtsModelBase<T>, ICodecTts<T>
 {
     private readonly VALLE2Options _options;
 
@@ -223,50 +223,9 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.CodebookSize);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.LLMDim);
-        writer.Write(_options.NumCodebooks);
-        writer.Write(_options.NumEncoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.NumLLMLayers);
-        writer.Write(_options.TextEncoderDim);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.CodebookSize = reader.ReadInt32();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.LLMDim = reader.ReadInt32();
-        _options.NumCodebooks = reader.ReadInt32();
-        _options.NumEncoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.NumLLMLayers = reader.ReadInt32();
-        _options.TextEncoderDim = reader.ReadInt32();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        base.HiddenDim = _options.LLMDim;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new VALLE2<T>(Architecture, mp, _options);
-        return new VALLE2<T>(Architecture, _options);
-    }
+
 
     private AdamWOptimizer<T, Tensor<T>, Tensor<T>> CreateDefaultOptimizer() =>
         new(
diff --git a/src/TextToSpeech/CodecBased/VALLEX.cs b/src/TextToSpeech/CodecBased/VALLEX.cs
index 7aeaf0e5f1..de1bb85d48 100644
--- a/src/TextToSpeech/CodecBased/VALLEX.cs
+++ b/src/TextToSpeech/CodecBased/VALLEX.cs
@@ -50,7 +50,7 @@ namespace AiDotNet.TextToSpeech.CodecBased;
     Year = 2023,
     Authors = "Zhang et al."
 )]
-public class VALLEX<T> : TtsModelBase<T>, ICodecTts<T>
+public partial class VALLEX<T> : TtsModelBase<T>, ICodecTts<T>
 {
     private readonly VALLEXOptions _options;
     private readonly IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer;
@@ -341,52 +341,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc />
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.NumCodebooks);
-        writer.Write(_options.LLMDim);
-        writer.Write(_options.CodebookSize);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.NumEncoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.NumLLMLayers);
-        writer.Write(_options.TextEncoderDim);
-    }
 
-    /// <inheritdoc />
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.NumCodebooks = reader.ReadInt32();
-        _options.LLMDim = reader.ReadInt32();
-        _options.CodebookSize = reader.ReadInt32();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.NumEncoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.NumLLMLayers = reader.ReadInt32();
-        _options.TextEncoderDim = reader.ReadInt32();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        base.HiddenDim = _options.LLMDim;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
     /// <inheritdoc />
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new VALLEX<T>(Architecture, mp, _options);
-        return new VALLEX<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/TextToSpeech/CodecBased/VoiceCraft.cs b/src/TextToSpeech/CodecBased/VoiceCraft.cs
index 63216efeb4..8f99622d70 100644
--- a/src/TextToSpeech/CodecBased/VoiceCraft.cs
+++ b/src/TextToSpeech/CodecBased/VoiceCraft.cs
@@ -40,7 +40,7 @@ namespace AiDotNet.TextToSpeech.CodecBased;
     Year = 2024,
     Authors = "Peng et al."
 )]
-public class VoiceCraft<T> : TtsModelBase<T>, ICodecTts<T>
+public partial class VoiceCraft<T> : TtsModelBase<T>, ICodecTts<T>
 {
     private readonly VoiceCraftOptions _options;
 
@@ -260,54 +260,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.MelChannels);
-        writer.Write(_options.HopSize);
-        writer.Write(_options.CodebookSize);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.LLMDim);
-        writer.Write(_options.NumCodebooks);
-        writer.Write(_options.NumEncoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.NumLLMLayers);
-        writer.Write(_options.TextEncoderDim);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.MelChannels = reader.ReadInt32();
-        _options.HopSize = reader.ReadInt32();
-        _options.CodebookSize = reader.ReadInt32();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.LLMDim = reader.ReadInt32();
-        _options.NumCodebooks = reader.ReadInt32();
-        _options.NumEncoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.NumLLMLayers = reader.ReadInt32();
-        _options.TextEncoderDim = reader.ReadInt32();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        base.HiddenDim = _options.LLMDim;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new VoiceCraft<T>(Architecture, mp, _options);
-        return new VoiceCraft<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/TextToSpeech/CodecBased/Voicebox.cs b/src/TextToSpeech/CodecBased/Voicebox.cs
index 0dc4ebe93e..eeb269143f 100644
--- a/src/TextToSpeech/CodecBased/Voicebox.cs
+++ b/src/TextToSpeech/CodecBased/Voicebox.cs
@@ -51,7 +51,7 @@ namespace AiDotNet.TextToSpeech.CodecBased;
     Year = 2023,
     Authors = "Le et al."
 )]
-public class Voicebox<T> : TtsModelBase<T>, ICodecTts<T>
+public partial class Voicebox<T> : TtsModelBase<T>, ICodecTts<T>
 {
     private readonly VoiceboxOptions _options;
     private readonly IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer;
@@ -324,56 +324,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc />
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.CodebookSize);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.LLMDim);
-        writer.Write(_options.NumCodebooks);
-        writer.Write(_options.NumEncoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.NumLLMLayers);
-        writer.Write(_options.TextEncoderDim);
-        writer.Write(_options.MelChannels);
-        writer.Write(_options.HopSize);
-    }
 
-    /// <inheritdoc />
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.CodebookSize = reader.ReadInt32();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.LLMDim = reader.ReadInt32();
-        _options.NumCodebooks = reader.ReadInt32();
-        _options.NumEncoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.NumLLMLayers = reader.ReadInt32();
-        _options.TextEncoderDim = reader.ReadInt32();
-        _options.MelChannels = reader.ReadInt32();
-        _options.HopSize = reader.ReadInt32();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        base.HiddenDim = _options.LLMDim;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
     /// <inheritdoc />
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new Voicebox<T>(Architecture, mp, new VoiceboxOptions(_options));
-        return new Voicebox<T>(Architecture, new VoiceboxOptions(_options));
-    }
+
 
     private AdamOptimizer<T, Tensor<T>, Tensor<T>> CreateDefaultOptimizer() =>
         new(
diff --git a/src/TextToSpeech/CodecBased/Zonos.cs b/src/TextToSpeech/CodecBased/Zonos.cs
index 7ea8ee3213..e29d2594f7 100644
--- a/src/TextToSpeech/CodecBased/Zonos.cs
+++ b/src/TextToSpeech/CodecBased/Zonos.cs
@@ -35,7 +35,7 @@ namespace AiDotNet.TextToSpeech.CodecBased;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Zyphra Zonos: Zero-Shot TTS", "https://github.com/Zyphra/Zonos")]
-public class Zonos<T> : TtsModelBase<T>, ICodecTts<T>
+public partial class Zonos<T> : TtsModelBase<T>, ICodecTts<T>
 {
     private readonly ZonosOptions _options;
 
@@ -261,54 +261,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.MelChannels);
-        writer.Write(_options.HopSize);
-        writer.Write(_options.NumCodebooks);
-        writer.Write(_options.LLMDim);
-        writer.Write(_options.CodebookSize);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.NumEncoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.NumLLMLayers);
-        writer.Write(_options.TextEncoderDim);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.MelChannels = reader.ReadInt32();
-        _options.HopSize = reader.ReadInt32();
-        _options.NumCodebooks = reader.ReadInt32();
-        _options.LLMDim = reader.ReadInt32();
-        _options.CodebookSize = reader.ReadInt32();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.NumEncoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.NumLLMLayers = reader.ReadInt32();
-        _options.TextEncoderDim = reader.ReadInt32();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        base.HiddenDim = _options.LLMDim;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new Zonos<T>(Architecture, mp, _options);
-        return new Zonos<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/TextToSpeech/DescriptionBased/ParlerTTS.cs b/src/TextToSpeech/DescriptionBased/ParlerTTS.cs
index f33edaeb7c..9033e4ff59 100644
--- a/src/TextToSpeech/DescriptionBased/ParlerTTS.cs
+++ b/src/TextToSpeech/DescriptionBased/ParlerTTS.cs
@@ -51,7 +51,7 @@ namespace AiDotNet.TextToSpeech.DescriptionBased;
     Year = 2024,
     Authors = "Lyth et al."
 )]
-public class ParlerTTS<T> : TtsModelBase<T>, ICodecTts<T>
+public partial class ParlerTTS<T> : TtsModelBase<T>, ICodecTts<T>
 {
     private readonly ParlerTTSOptions _options;
     private readonly IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer;
@@ -280,61 +280,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc />
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.NumCodebooks);
-        writer.Write(_options.LLMDim);
-        writer.Write(_options.CodebookSize);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.NumEncoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.NumLLMLayers);
-        writer.Write(_options.TextEncoderDim);
-        writer.Write(_options.MelChannels);
-        writer.Write(_options.HopSize);
-        writer.Write(_options.CodecFrameRate);
-        writer.Write(_options.MaxTextLength);
-    }
 
-    /// <inheritdoc />
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.NumCodebooks = reader.ReadInt32();
-        _options.LLMDim = reader.ReadInt32();
-        _options.CodebookSize = reader.ReadInt32();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.NumEncoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.NumLLMLayers = reader.ReadInt32();
-        _options.TextEncoderDim = reader.ReadInt32();
-        _options.MelChannels = reader.ReadInt32();
-        _options.HopSize = reader.ReadInt32();
-        _options.CodecFrameRate = reader.ReadInt32();
-        _options.MaxTextLength = reader.ReadInt32();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        base.HiddenDim = _options.LLMDim;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
     /// <inheritdoc />
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var options = new ParlerTTSOptions(_options);
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new ParlerTTS<T>(Architecture, mp, options);
-        return new ParlerTTS<T>(Architecture, options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/TextToSpeech/DescriptionBased/PromptTTS.cs b/src/TextToSpeech/DescriptionBased/PromptTTS.cs
index 0968b4b0c3..10e6f684e3 100644
--- a/src/TextToSpeech/DescriptionBased/PromptTTS.cs
+++ b/src/TextToSpeech/DescriptionBased/PromptTTS.cs
@@ -40,7 +40,7 @@ namespace AiDotNet.TextToSpeech.DescriptionBased;
     Year = 2023,
     Authors = "Guo et al."
 )]
-public class PromptTTS<T> : TtsModelBase<T>, IEndToEndTts<T>
+public partial class PromptTTS<T> : TtsModelBase<T>, IEndToEndTts<T>
 {
     private readonly PromptTTSOptions _options;
 
@@ -196,52 +196,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.MelChannels);
-        writer.Write(_options.HopSize);
-        writer.Write(_options.HiddenDim);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumEncoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.NumPromptLayers);
-        writer.Write(_options.PromptEncoderDim);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.MelChannels = reader.ReadInt32();
-        _options.HopSize = reader.ReadInt32();
-        _options.HiddenDim = reader.ReadInt32();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumEncoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.NumPromptLayers = reader.ReadInt32();
-        _options.PromptEncoderDim = reader.ReadInt32();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        base.HiddenDim = _options.HiddenDim;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new PromptTTS<T>(Architecture, mp, _options);
-        return new PromptTTS<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/TextToSpeech/EndToEnd/Kokoro.cs b/src/TextToSpeech/EndToEnd/Kokoro.cs
index ec80ab0a0c..45a0d4cb2d 100644
--- a/src/TextToSpeech/EndToEnd/Kokoro.cs
+++ b/src/TextToSpeech/EndToEnd/Kokoro.cs
@@ -49,7 +49,7 @@ namespace AiDotNet.TextToSpeech.EndToEnd;
 [ModelComplexity(ModelComplexity.Low)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Kokoro: A Frontier TTS Model", "https://huggingface.co/hexgrad/Kokoro-82M")]
-public class Kokoro<T> : TtsModelBase<T>, IEndToEndTts<T>
+public partial class Kokoro<T> : TtsModelBase<T>, IEndToEndTts<T>
 {
     private readonly KokoroOptions _options;
     private readonly IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer;
@@ -326,56 +326,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc />
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.MelChannels);
-        writer.Write(_options.HopSize);
-        writer.Write(_options.HiddenDim);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.FilterChannels);
-        writer.Write(_options.InterChannels);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumEncoderLayers);
-        writer.Write(_options.NumFlowSteps);
-        writer.Write(_options.NumHeads);
-    }
 
-    /// <inheritdoc />
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.MelChannels = reader.ReadInt32();
-        _options.HopSize = reader.ReadInt32();
-        _options.HiddenDim = reader.ReadInt32();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.FilterChannels = reader.ReadInt32();
-        _options.InterChannels = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumEncoderLayers = reader.ReadInt32();
-        _options.NumFlowSteps = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        base.HiddenDim = _options.HiddenDim;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
     /// <inheritdoc />
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new Kokoro<T>(Architecture, mp, _options);
-        return new Kokoro<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/TextToSpeech/EndToEnd/MeloTTS.cs b/src/TextToSpeech/EndToEnd/MeloTTS.cs
index 39ae40424b..57f3ef1ea2 100644
--- a/src/TextToSpeech/EndToEnd/MeloTTS.cs
+++ b/src/TextToSpeech/EndToEnd/MeloTTS.cs
@@ -50,7 +50,7 @@ namespace AiDotNet.TextToSpeech.EndToEnd;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("MeloTTS: High-quality Multi-lingual TTS", "https://github.com/myshell-ai/MeloTTS")]
-public class MeloTTS<T> : TtsModelBase<T>, IEndToEndTts<T>
+public partial class MeloTTS<T> : TtsModelBase<T>, IEndToEndTts<T>
 {
     private readonly MeloTTSOptions _options;
     private readonly IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer;
@@ -248,65 +248,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc />
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.MelChannels);
-        writer.Write(_options.HopSize);
-        writer.Write(_options.HiddenDim);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.FilterChannels);
-        writer.Write(_options.InterChannels);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumEncoderLayers);
-        writer.Write(_options.NumFlowSteps);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.MaxTextLength);
-    }
 
-    /// <inheritdoc />
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.MelChannels = reader.ReadInt32();
-        _options.HopSize = reader.ReadInt32();
-        _options.HiddenDim = reader.ReadInt32();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.FilterChannels = reader.ReadInt32();
-        _options.InterChannels = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumEncoderLayers = reader.ReadInt32();
-        _options.NumFlowSteps = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.MaxTextLength = reader.ReadInt32();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        base.HiddenDim = _options.HiddenDim;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-        {
-            if (!File.Exists(p))
-                throw new FileNotFoundException(
-                    $"ONNX model not found during deserialization: {p}",
-                    p
-                );
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-        }
-    }
 
     /// <inheritdoc />
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new MeloTTS<T>(Architecture, mp, _options);
-        return new MeloTTS<T>(Architecture, _options, _optimizer);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/TextToSpeech/EndToEnd/Piper.cs b/src/TextToSpeech/EndToEnd/Piper.cs
index 886e2d1632..2361eaa52d 100644
--- a/src/TextToSpeech/EndToEnd/Piper.cs
+++ b/src/TextToSpeech/EndToEnd/Piper.cs
@@ -38,7 +38,7 @@ namespace AiDotNet.TextToSpeech.EndToEnd;
     "Piper: A Fast Local Neural Text-to-Speech System",
     "https://github.com/rhasspy/piper"
 )]
-public class Piper<T> : TtsModelBase<T>, IEndToEndTts<T>
+public partial class Piper<T> : TtsModelBase<T>, IEndToEndTts<T>
 {
     private readonly PiperOptions _options;
 
@@ -253,55 +253,9 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.MelChannels);
-        writer.Write(_options.HopSize);
-        writer.Write(_options.HiddenDim);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.FilterChannels);
-        writer.Write(_options.InterChannels);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumEncoderLayers);
-        writer.Write(_options.NumFlowSteps);
-        writer.Write(_options.NumHeads);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.MelChannels = reader.ReadInt32();
-        _options.HopSize = reader.ReadInt32();
-        _options.HiddenDim = reader.ReadInt32();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.FilterChannels = reader.ReadInt32();
-        _options.InterChannels = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumEncoderLayers = reader.ReadInt32();
-        _options.NumFlowSteps = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        base.HiddenDim = _options.HiddenDim;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var options = new PiperOptions(_options);
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new Piper<T>(Architecture, mp, options);
-        return new Piper<T>(Architecture, options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/TextToSpeech/EndToEnd/VITS.cs b/src/TextToSpeech/EndToEnd/VITS.cs
index f3a8056fe6..bb2558361b 100644
--- a/src/TextToSpeech/EndToEnd/VITS.cs
+++ b/src/TextToSpeech/EndToEnd/VITS.cs
@@ -56,7 +56,7 @@ namespace AiDotNet.TextToSpeech.EndToEnd;
     Year = 2021,
     Authors = "Kim et al."
 )]
-public class VITS<T> : TtsModelBase<T>, IEndToEndTts<T>
+public partial class VITS<T> : TtsModelBase<T>, IEndToEndTts<T>
 {
     private readonly VITSOptions _options;
     private readonly IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer;
@@ -246,56 +246,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc />
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.MelChannels);
-        writer.Write(_options.HopSize);
-        writer.Write(_options.HiddenDim);
-        writer.Write(_options.NumFlowSteps);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.FilterChannels);
-        writer.Write(_options.InterChannels);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumEncoderLayers);
-        writer.Write(_options.NumHeads);
-    }
 
-    /// <inheritdoc />
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.MelChannels = reader.ReadInt32();
-        _options.HopSize = reader.ReadInt32();
-        _options.HiddenDim = reader.ReadInt32();
-        _options.NumFlowSteps = reader.ReadInt32();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.FilterChannels = reader.ReadInt32();
-        _options.InterChannels = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumEncoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        base.HiddenDim = _options.HiddenDim;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
     /// <inheritdoc />
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new VITS<T>(Architecture, mp, _options);
-        return new VITS<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/TextToSpeech/EndToEnd/VITS2.cs b/src/TextToSpeech/EndToEnd/VITS2.cs
index 10a2a0163c..1d5667e3a8 100644
--- a/src/TextToSpeech/EndToEnd/VITS2.cs
+++ b/src/TextToSpeech/EndToEnd/VITS2.cs
@@ -40,7 +40,7 @@ namespace AiDotNet.TextToSpeech.EndToEnd;
     Year = 2023,
     Authors = "Kong et al."
 )]
-public class VITS2<T> : TtsModelBase<T>, IEndToEndTts<T>
+public partial class VITS2<T> : TtsModelBase<T>, IEndToEndTts<T>
 {
     private readonly VITS2Options _options;
 
@@ -255,54 +255,9 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.MelChannels);
-        writer.Write(_options.HopSize);
-        writer.Write(_options.HiddenDim);
-        writer.Write(_options.NumFlowSteps);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.FilterChannels);
-        writer.Write(_options.InterChannels);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumEncoderLayers);
-        writer.Write(_options.NumHeads);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.MelChannels = reader.ReadInt32();
-        _options.HopSize = reader.ReadInt32();
-        _options.HiddenDim = reader.ReadInt32();
-        _options.NumFlowSteps = reader.ReadInt32();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.FilterChannels = reader.ReadInt32();
-        _options.InterChannels = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumEncoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        base.HiddenDim = _options.HiddenDim;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new VITS2<T>(Architecture, mp, _options);
-        return new VITS2<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/TextToSpeech/EndToEnd/YourTTS.cs b/src/TextToSpeech/EndToEnd/YourTTS.cs
index af2069a8fa..69a9f13f08 100644
--- a/src/TextToSpeech/EndToEnd/YourTTS.cs
+++ b/src/TextToSpeech/EndToEnd/YourTTS.cs
@@ -40,7 +40,7 @@ namespace AiDotNet.TextToSpeech.EndToEnd;
     Year = 2022,
     Authors = "Casanova et al."
 )]
-public class YourTTS<T> : TtsModelBase<T>, IEndToEndTts<T>
+public partial class YourTTS<T> : TtsModelBase<T>, IEndToEndTts<T>
 {
     private readonly YourTTSOptions _options;
 
@@ -251,54 +251,9 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.MelChannels);
-        writer.Write(_options.HopSize);
-        writer.Write(_options.HiddenDim);
-        writer.Write(_options.NumFlowSteps);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.FilterChannels);
-        writer.Write(_options.InterChannels);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumEncoderLayers);
-        writer.Write(_options.NumHeads);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.MelChannels = reader.ReadInt32();
-        _options.HopSize = reader.ReadInt32();
-        _options.HiddenDim = reader.ReadInt32();
-        _options.NumFlowSteps = reader.ReadInt32();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.FilterChannels = reader.ReadInt32();
-        _options.InterChannels = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumEncoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        base.HiddenDim = _options.HiddenDim;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new YourTTS<T>(Architecture, mp, _options);
-        return new YourTTS<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/TextToSpeech/FlowDiffusion/CoMoSpeech.cs b/src/TextToSpeech/FlowDiffusion/CoMoSpeech.cs
index 78028325fb..b5cab09582 100644
--- a/src/TextToSpeech/FlowDiffusion/CoMoSpeech.cs
+++ b/src/TextToSpeech/FlowDiffusion/CoMoSpeech.cs
@@ -40,7 +40,7 @@ namespace AiDotNet.TextToSpeech.FlowDiffusion;
     Year = 2023,
     Authors = "Ye et al."
 )]
-public class CoMoSpeech<T> : TtsModelBase<T>, IEndToEndTts<T>
+public partial class CoMoSpeech<T> : TtsModelBase<T>, IEndToEndTts<T>
 {
     private readonly CoMoSpeechOptions _options;
 
@@ -218,48 +218,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.EncoderDim);
-        writer.Write(_options.FlowDim);
-        writer.Write(_options.NumEncoderLayers);
-        writer.Write(_options.NumFlowLayers);
-        writer.Write(_options.NumHeads);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.EncoderDim = reader.ReadInt32();
-        _options.FlowDim = reader.ReadInt32();
-        _options.NumEncoderLayers = reader.ReadInt32();
-        _options.NumFlowLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        base.HiddenDim = _options.HiddenDim;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new CoMoSpeech<T>(Architecture, mp, _options);
-        return new CoMoSpeech<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/TextToSpeech/FlowDiffusion/DiTToTTS.cs b/src/TextToSpeech/FlowDiffusion/DiTToTTS.cs
index 62155be873..88fe271e62 100644
--- a/src/TextToSpeech/FlowDiffusion/DiTToTTS.cs
+++ b/src/TextToSpeech/FlowDiffusion/DiTToTTS.cs
@@ -35,7 +35,7 @@ namespace AiDotNet.TextToSpeech.FlowDiffusion;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("DiTTo-TTS: Diffusion Transformers for Scalable Text-to-Speech without Domain-Specific Factors", "https://arxiv.org/abs/2406.11427", Year = 2024, Authors = "Lee et al.")]
-public class DiTToTTS<T> : TtsModelBase<T>, IEndToEndTts<T>
+public partial class DiTToTTS<T> : TtsModelBase<T>, IEndToEndTts<T>
 {
     private readonly DiTToTTSOptions _options; public override ModelOptions GetOptions() => _options;
     private readonly IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer; private bool _useNativeMode; private bool _disposed;
@@ -72,18 +72,8 @@ public Tensor<T> Synthesize(string text)
     /// repeated -- and cannot be applied to one surface and forgotten on another.</remarks>
     protected override bool SupportsParameterMutation => _useNativeMode;
     public override ModelMetadata<T> GetModelMetadata() { return new ModelMetadata<T> { Name = _useNativeMode ? "DiTToTTS-Native" : "DiTToTTS-ONNX", Description = "DiTToTTS TTS", FeatureCount = _options.HiddenDim, AdditionalInfo = new Dictionary<string, object> { ["ModelType"] = "DiTToTTS", ["Mode"] = _useNativeMode ? "Native" : "ONNX", ["HiddenDim"] = _options.HiddenDim, ["EncoderDim"] = _options.EncoderDim, ["FlowDim"] = _options.FlowDim, ["DecoderDim"] = _options.DecoderDim, ["NumEncoderLayers"] = _options.NumEncoderLayers, ["NumFlowLayers"] = _options.NumFlowLayers, ["NumHeads"] = _options.NumHeads, ["SampleRate"] = _options.SampleRate, ["MelChannels"] = _options.MelChannels } }; }
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer) { writer.Write(_useNativeMode); writer.Write(_options.ModelPath ?? string.Empty); writer.Write(_options.SampleRate); writer.Write(_options.DecoderDim); writer.Write(_options.DropoutRate); writer.Write(_options.EncoderDim); writer.Write(_options.FlowDim); writer.Write(_options.NumEncoderLayers); writer.Write(_options.NumFlowLayers); writer.Write(_options.NumHeads); }
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader) { _useNativeMode = reader.ReadBoolean(); string mp = reader.ReadString(); if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp; _options.SampleRate = reader.ReadInt32();  _options.DecoderDim = reader.ReadInt32(); _options.DropoutRate = reader.ReadDouble(); _options.EncoderDim = reader.ReadInt32(); _options.FlowDim = reader.ReadInt32(); _options.NumEncoderLayers = reader.ReadInt32(); _options.NumFlowLayers = reader.ReadInt32(); _options.NumHeads = reader.ReadInt32();  base.SampleRate = _options.SampleRate; base.MelChannels = _options.MelChannels; base.HopSize = _options.HopSize; base.HiddenDim = _options.HiddenDim; if (!_useNativeMode && _options.ModelPath is {} p && !string.IsNullOrEmpty(p)) OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions); }
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new DiTToTTS<T>(Architecture, mp, new DiTToTTSOptions(_options));
 
-        var cloneOptimizer = _optimizer?.GetOptions() is AdamWOptimizerOptions<T, Tensor<T>, Tensor<T>> options
-            ? new AdamWOptimizer<T, Tensor<T>, Tensor<T>>(null, new AdamWOptimizerOptions<T, Tensor<T>, Tensor<T>>(options))
-            : null;
-        return new DiTToTTS<T>(Architecture, new DiTToTTSOptions(_options), cloneOptimizer);
-    }
+
     private void ThrowIfDisposed() { if (_disposed) throw new ObjectDisposedException(GetType().FullName ?? nameof(DiTToTTS<T>)); }
     protected override void Dispose(bool disposing) { if (_disposed) return; _disposed = true; base.Dispose(disposing); }
 }
diff --git a/src/TextToSpeech/FlowDiffusion/E2TTS.cs b/src/TextToSpeech/FlowDiffusion/E2TTS.cs
index 592e7742dd..1f8cb8bd3b 100644
--- a/src/TextToSpeech/FlowDiffusion/E2TTS.cs
+++ b/src/TextToSpeech/FlowDiffusion/E2TTS.cs
@@ -41,7 +41,7 @@ namespace AiDotNet.TextToSpeech.FlowDiffusion;
     Year = 2024,
     Authors = "Eskimez et al."
 )]
-public class E2TTS<T> : TtsModelBase<T>, ICodecTts<T>
+public partial class E2TTS<T> : TtsModelBase<T>, ICodecTts<T>
 {
     private readonly E2TTSOptions _options;
 
@@ -237,58 +237,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.NumCodebooks);
-        writer.Write(_options.LLMDim);
-        writer.Write(_options.CodebookSize);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.NumEncoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.NumLLMLayers);
-        writer.Write(_options.TextEncoderDim);
-        writer.Write(_options.MelChannels);
-        writer.Write(_options.HopSize);
-        writer.Write(_options.CodecFrameRate);
-        writer.Write(_options.MaxTextLength);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.NumCodebooks = reader.ReadInt32();
-        _options.LLMDim = reader.ReadInt32();
-        _options.CodebookSize = reader.ReadInt32();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.NumEncoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.NumLLMLayers = reader.ReadInt32();
-        _options.TextEncoderDim = reader.ReadInt32();
-        _options.MelChannels = reader.ReadInt32();
-        _options.HopSize = reader.ReadInt32();
-        _options.CodecFrameRate = reader.ReadInt32();
-        _options.MaxTextLength = reader.ReadInt32();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        base.HiddenDim = _options.LLMDim;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (IsOnnxMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new E2TTS<T>(Architecture, mp, new E2TTSOptions(_options));
-        return new E2TTS<T>(Architecture, new E2TTSOptions(_options));
-    }
+
 
     private IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>> CreateDefaultOptimizer()
         => new AdamWOptimizer<T, Tensor<T>, Tensor<T>>(
diff --git a/src/TextToSpeech/FlowDiffusion/E3TTS.cs b/src/TextToSpeech/FlowDiffusion/E3TTS.cs
index fff80a9317..dfc41bd68b 100644
--- a/src/TextToSpeech/FlowDiffusion/E3TTS.cs
+++ b/src/TextToSpeech/FlowDiffusion/E3TTS.cs
@@ -40,7 +40,7 @@ namespace AiDotNet.TextToSpeech.FlowDiffusion;
     Year = 2023,
     Authors = "Gao et al."
 )]
-public class E3TTS<T> : TtsModelBase<T>, IEndToEndTts<T>
+public partial class E3TTS<T> : TtsModelBase<T>, IEndToEndTts<T>
 {
     private readonly E3TTSOptions _options;
 
@@ -187,52 +187,9 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.MelChannels);
-        writer.Write(_options.HiddenDim);
-        writer.Write(_options.NumDiffusionSteps);
-        writer.Write(_options.DiffusionDim);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.NumEncoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.HopSize);
-        writer.Write(_options.MaxTextLength);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.MelChannels = reader.ReadInt32();
-        _options.HiddenDim = reader.ReadInt32();
-        _options.NumDiffusionSteps = reader.ReadInt32();
-        _options.DiffusionDim = reader.ReadInt32();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.NumEncoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.HopSize = reader.ReadInt32();
-        _options.MaxTextLength = reader.ReadInt32();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        base.HiddenDim = _options.HiddenDim;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new E3TTS<T>(Architecture, mp, _options);
-        return new E3TTS<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/TextToSpeech/FlowDiffusion/F5TTS.cs b/src/TextToSpeech/FlowDiffusion/F5TTS.cs
index 7671d98220..cd7c50792d 100644
--- a/src/TextToSpeech/FlowDiffusion/F5TTS.cs
+++ b/src/TextToSpeech/FlowDiffusion/F5TTS.cs
@@ -40,7 +40,7 @@ namespace AiDotNet.TextToSpeech.FlowDiffusion;
     Year = 2024,
     Authors = "Chen et al."
 )]
-public class F5TTS<T> : TtsModelBase<T>, ICodecTts<T>
+public partial class F5TTS<T> : TtsModelBase<T>, ICodecTts<T>
 {
     private readonly F5TTSOptions _options;
 
@@ -204,58 +204,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.NumCodebooks);
-        writer.Write(_options.LLMDim);
-        writer.Write(_options.CodebookSize);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.NumEncoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.NumLLMLayers);
-        writer.Write(_options.TextEncoderDim);
-        writer.Write(_options.MelChannels);
-        writer.Write(_options.HopSize);
-        writer.Write(_options.CodecFrameRate);
-        writer.Write(_options.MaxTextLength);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.NumCodebooks = reader.ReadInt32();
-        _options.LLMDim = reader.ReadInt32();
-        _options.CodebookSize = reader.ReadInt32();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.NumEncoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.NumLLMLayers = reader.ReadInt32();
-        _options.TextEncoderDim = reader.ReadInt32();
-        _options.MelChannels = reader.ReadInt32();
-        _options.HopSize = reader.ReadInt32();
-        _options.CodecFrameRate = reader.ReadInt32();
-        _options.MaxTextLength = reader.ReadInt32();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        base.HiddenDim = _options.LLMDim;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions); /* native-mode layers are already reconstructed with their trained weights by the base DeserializeInternalUnchecked; clearing + re-initializing here would discard them and leave the model randomly initialized */
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new F5TTS<T>(Architecture, mp, _options);
-        return new F5TTS<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/TextToSpeech/FlowDiffusion/MaskGCT.cs b/src/TextToSpeech/FlowDiffusion/MaskGCT.cs
index e6d1438e88..2ee485fb29 100644
--- a/src/TextToSpeech/FlowDiffusion/MaskGCT.cs
+++ b/src/TextToSpeech/FlowDiffusion/MaskGCT.cs
@@ -40,7 +40,7 @@ namespace AiDotNet.TextToSpeech.FlowDiffusion;
     Year = 2024,
     Authors = "Wang et al."
 )]
-public class MaskGCT<T> : TtsModelBase<T>, ICodecTts<T>
+public partial class MaskGCT<T> : TtsModelBase<T>, ICodecTts<T>
 {
     private readonly MaskGCTOptions _options;
 
@@ -208,50 +208,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.NumCodebooks);
-        writer.Write(_options.LLMDim);
-        writer.Write(_options.CodebookSize);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.NumEncoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.NumLLMLayers);
-        writer.Write(_options.TextEncoderDim);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.NumCodebooks = reader.ReadInt32();
-        _options.LLMDim = reader.ReadInt32();
-        _options.CodebookSize = reader.ReadInt32();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.NumEncoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.NumLLMLayers = reader.ReadInt32();
-        _options.TextEncoderDim = reader.ReadInt32();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        base.HiddenDim = _options.LLMDim;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new MaskGCT<T>(Architecture, mp, _options);
-        return new MaskGCT<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/TextToSpeech/FlowDiffusion/MatchaTTS.cs b/src/TextToSpeech/FlowDiffusion/MatchaTTS.cs
index 35c01884e4..cbfd9eb26b 100644
--- a/src/TextToSpeech/FlowDiffusion/MatchaTTS.cs
+++ b/src/TextToSpeech/FlowDiffusion/MatchaTTS.cs
@@ -40,7 +40,7 @@ namespace AiDotNet.TextToSpeech.FlowDiffusion;
     Year = 2024,
     Authors = "Mehta et al."
 )]
-public class MatchaTTS<T> : TtsModelBase<T>, IEndToEndTts<T>
+public partial class MatchaTTS<T> : TtsModelBase<T>, IEndToEndTts<T>
 {
     private readonly MatchaTTSOptions _options;
 
@@ -236,50 +236,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.MelChannels);
-        writer.Write(_options.HopSize);
-        writer.Write(_options.HiddenDim);
-        writer.Write(_options.NumFlowSteps);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.FlowDim);
-        writer.Write(_options.NumEncoderLayers);
-        writer.Write(_options.NumHeads);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.MelChannels = reader.ReadInt32();
-        _options.HopSize = reader.ReadInt32();
-        _options.HiddenDim = reader.ReadInt32();
-        _options.NumFlowSteps = reader.ReadInt32();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.FlowDim = reader.ReadInt32();
-        _options.NumEncoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        base.HiddenDim = _options.HiddenDim;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new MatchaTTS<T>(Architecture, mp, _options);
-        return new MatchaTTS<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/TextToSpeech/FlowDiffusion/VoiceFlow.cs b/src/TextToSpeech/FlowDiffusion/VoiceFlow.cs
index 044754abc9..daac84fb2a 100644
--- a/src/TextToSpeech/FlowDiffusion/VoiceFlow.cs
+++ b/src/TextToSpeech/FlowDiffusion/VoiceFlow.cs
@@ -40,7 +40,7 @@ namespace AiDotNet.TextToSpeech.FlowDiffusion;
     Year = 2024,
     Authors = "Guo et al."
 )]
-public class VoiceFlow<T> : TtsModelBase<T>, IEndToEndTts<T>
+public partial class VoiceFlow<T> : TtsModelBase<T>, IEndToEndTts<T>
 {
     private readonly VoiceFlowOptions _options;
 
@@ -196,50 +196,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.MelChannels);
-        writer.Write(_options.HopSize);
-        writer.Write(_options.HiddenDim);
-        writer.Write(_options.NumFlowSteps);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.FlowDim);
-        writer.Write(_options.NumEncoderLayers);
-        writer.Write(_options.NumHeads);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.MelChannels = reader.ReadInt32();
-        _options.HopSize = reader.ReadInt32();
-        _options.HiddenDim = reader.ReadInt32();
-        _options.NumFlowSteps = reader.ReadInt32();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.FlowDim = reader.ReadInt32();
-        _options.NumEncoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        base.HiddenDim = _options.HiddenDim;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new VoiceFlow<T>(Architecture, mp, _options);
-        return new VoiceFlow<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/TextToSpeech/Latest/IndexTTS2.cs b/src/TextToSpeech/Latest/IndexTTS2.cs
index 2e4b3c826b..da81dcf589 100644
--- a/src/TextToSpeech/Latest/IndexTTS2.cs
+++ b/src/TextToSpeech/Latest/IndexTTS2.cs
@@ -40,7 +40,7 @@ namespace AiDotNet.TextToSpeech.Latest;
     Year = 2025,
     Authors = "Siyi Zhou, Yiquan Zhou, Yi He, Xun Zhou, Jinchao Wang, Wei Deng, Jingchen Shu"
 )]
-public class IndexTTS2<T> : TtsModelBase<T>, ICodecTts<T>
+public partial class IndexTTS2<T> : TtsModelBase<T>, ICodecTts<T>
 {
     private readonly IndexTTS2Options _options;
 
@@ -224,71 +224,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.CodebookSize);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.LLMDim);
-        writer.Write(_options.NumCodebooks);
-        writer.Write(_options.NumEncoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.NumLLMLayers);
-        writer.Write(_options.TextEncoderDim);
-        writer.Write(_options.MelChannels);
-        writer.Write(_options.HopSize);
-        writer.Write(_options.CodecFrameRate);
-        writer.Write(_options.MaxTextLength);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.CodebookSize = reader.ReadInt32();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.LLMDim = reader.ReadInt32();
-        _options.NumCodebooks = reader.ReadInt32();
-        _options.NumEncoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.NumLLMLayers = reader.ReadInt32();
-        _options.TextEncoderDim = reader.ReadInt32();
-        _options.MelChannels = reader.ReadInt32();
-        _options.HopSize = reader.ReadInt32();
-        _options.CodecFrameRate = reader.ReadInt32();
-        _options.MaxTextLength = reader.ReadInt32();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        base.HiddenDim = _options.LLMDim;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-        {
-            if (!File.Exists(p))
-                throw new FileNotFoundException(
-                    $"ONNX model not found during deserialization: {p}",
-                    p
-                );
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-        }
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new IndexTTS2<T>(Architecture, mp, new IndexTTS2Options(_options));
 
-        var cloneOptimizer = _optimizer?.GetOptions() is AdamWOptimizerOptions<T, Tensor<T>, Tensor<T>> optimizerOptions
-            ? new AdamWOptimizer<T, Tensor<T>, Tensor<T>>(
-                null,
-                new AdamWOptimizerOptions<T, Tensor<T>, Tensor<T>>(optimizerOptions))
-            : null;
-        return new IndexTTS2<T>(Architecture, new IndexTTS2Options(_options), cloneOptimizer);
-    }
 
     private IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>> CreateDefaultOptimizer()
         => new AdamWOptimizer<T, Tensor<T>, Tensor<T>>(
diff --git a/src/TextToSpeech/Latest/KaniTTS.cs b/src/TextToSpeech/Latest/KaniTTS.cs
index d94573d504..1148e3c469 100644
--- a/src/TextToSpeech/Latest/KaniTTS.cs
+++ b/src/TextToSpeech/Latest/KaniTTS.cs
@@ -34,7 +34,7 @@ namespace AiDotNet.TextToSpeech.Latest;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Kani TTS", "https://github.com/KaniTTS/KaniTTS")]
-public class KaniTTS<T> : TtsModelBase<T>, ICodecTts<T>
+public partial class KaniTTS<T> : TtsModelBase<T>, ICodecTts<T>
 {
     private readonly KaniTTSOptions _options;
 
@@ -234,54 +234,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.MelChannels);
-        writer.Write(_options.HopSize);
-        writer.Write(_options.CodebookSize);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.LLMDim);
-        writer.Write(_options.NumCodebooks);
-        writer.Write(_options.NumEncoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.NumLLMLayers);
-        writer.Write(_options.TextEncoderDim);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.MelChannels = reader.ReadInt32();
-        _options.HopSize = reader.ReadInt32();
-        _options.CodebookSize = reader.ReadInt32();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.LLMDim = reader.ReadInt32();
-        _options.NumCodebooks = reader.ReadInt32();
-        _options.NumEncoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.NumLLMLayers = reader.ReadInt32();
-        _options.TextEncoderDim = reader.ReadInt32();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        base.HiddenDim = _options.LLMDim;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new KaniTTS<T>(Architecture, mp, _options);
-        return new KaniTTS<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/TextToSpeech/Latest/KaniTTS2.cs b/src/TextToSpeech/Latest/KaniTTS2.cs
index 0cceb74e31..e3920e863e 100644
--- a/src/TextToSpeech/Latest/KaniTTS2.cs
+++ b/src/TextToSpeech/Latest/KaniTTS2.cs
@@ -34,7 +34,7 @@ namespace AiDotNet.TextToSpeech.Latest;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Kani TTS 2", "https://github.com/KaniTTS/KaniTTS")]
-public class KaniTTS2<T> : TtsModelBase<T>, ICodecTts<T>
+public partial class KaniTTS2<T> : TtsModelBase<T>, ICodecTts<T>
 {
     private readonly KaniTTS2Options _options;
 
@@ -204,54 +204,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.MelChannels);
-        writer.Write(_options.HopSize);
-        writer.Write(_options.CodebookSize);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.LLMDim);
-        writer.Write(_options.NumCodebooks);
-        writer.Write(_options.NumEncoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.NumLLMLayers);
-        writer.Write(_options.TextEncoderDim);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.MelChannels = reader.ReadInt32();
-        _options.HopSize = reader.ReadInt32();
-        _options.CodebookSize = reader.ReadInt32();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.LLMDim = reader.ReadInt32();
-        _options.NumCodebooks = reader.ReadInt32();
-        _options.NumEncoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.NumLLMLayers = reader.ReadInt32();
-        _options.TextEncoderDim = reader.ReadInt32();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        base.HiddenDim = _options.LLMDim;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new KaniTTS2<T>(Architecture, mp, _options);
-        return new KaniTTS2<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/TextToSpeech/Latest/MegaTTS.cs b/src/TextToSpeech/Latest/MegaTTS.cs
index 08ebbb0315..25dcf5fb11 100644
--- a/src/TextToSpeech/Latest/MegaTTS.cs
+++ b/src/TextToSpeech/Latest/MegaTTS.cs
@@ -40,7 +40,7 @@ namespace AiDotNet.TextToSpeech.Latest;
     Year = 2023,
     Authors = "Jiang et al."
 )]
-public class MegaTTS<T> : TtsModelBase<T>, IEndToEndTts<T>
+public partial class MegaTTS<T> : TtsModelBase<T>, IEndToEndTts<T>
 {
     private readonly MegaTTSOptions _options;
 
@@ -321,68 +321,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.EncoderDim);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumEncoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.ProsodyDim);
-        writer.Write(_options.ProsodyCodebookSize);
-        writer.Write(_options.NumProsodyLayers);
-        writer.Write(_options.ProsodyMelBands);
-        writer.Write(_options.TimbreDim);
-        writer.Write(_options.NumTimbreLayers);
-        writer.Write(_options.PLLMDim);
-        writer.Write(_options.NumPLLMLayers);
-        writer.Write(_options.NumPLLMHeads);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.EncoderDim = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumEncoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.ProsodyDim = reader.ReadInt32();
-        _options.ProsodyCodebookSize = reader.ReadInt32();
-        _options.NumProsodyLayers = reader.ReadInt32();
-        _options.ProsodyMelBands = reader.ReadInt32();
-        _options.TimbreDim = reader.ReadInt32();
-        _options.NumTimbreLayers = reader.ReadInt32();
-        _options.PLLMDim = reader.ReadInt32();
-        _options.NumPLLMLayers = reader.ReadInt32();
-        _options.NumPLLMHeads = reader.ReadInt32();
-        // The branch offsets are derived from the layer counts above, so they must be recomputed
-        // once the restored options are in place.
-        if (_useNativeMode && (Architecture.Layers is null || Architecture.Layers.Count == 0))
-            ExtractLayerReferences();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        base.HiddenDim = _options.HiddenDim;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new MegaTTS<T>(Architecture, mp, _options);
-        return new MegaTTS<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/TextToSpeech/Latest/MegaTTS2.cs b/src/TextToSpeech/Latest/MegaTTS2.cs
index b10f1a0b12..19bfcbd6ab 100644
--- a/src/TextToSpeech/Latest/MegaTTS2.cs
+++ b/src/TextToSpeech/Latest/MegaTTS2.cs
@@ -40,7 +40,7 @@ namespace AiDotNet.TextToSpeech.Latest;
     Year = 2024,
     Authors = "Jiang et al."
 )]
-public class MegaTTS2<T> : TtsModelBase<T>, IEndToEndTts<T>
+public partial class MegaTTS2<T> : TtsModelBase<T>, IEndToEndTts<T>
 {
     private readonly MegaTTS2Options _options;
 
@@ -203,69 +203,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.EncoderDim);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumEncoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.MelChannels);
-        writer.Write(_options.HopSize);
-        writer.Write(_options.HiddenDim);
-        writer.Write(_options.MaxTextLength);
-        writer.Write(_options.VocabSize);
-        writer.Write(_options.LearningRate);
-        writer.Write(_options.WeightDecay);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.EncoderDim = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumEncoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        if (reader.BaseStream.Position < reader.BaseStream.Length)
-            _options.MelChannels = reader.ReadInt32();
-        if (reader.BaseStream.Position < reader.BaseStream.Length)
-            _options.HopSize = reader.ReadInt32();
-        if (reader.BaseStream.Position < reader.BaseStream.Length)
-            _options.HiddenDim = reader.ReadInt32();
-        if (reader.BaseStream.Position < reader.BaseStream.Length)
-            _options.MaxTextLength = reader.ReadInt32();
-        if (reader.BaseStream.Position < reader.BaseStream.Length)
-            _options.VocabSize = reader.ReadInt32();
-        if (reader.BaseStream.Position < reader.BaseStream.Length)
-            _options.LearningRate = reader.ReadDouble();
-        if (reader.BaseStream.Position < reader.BaseStream.Length)
-            _options.WeightDecay = reader.ReadDouble();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        base.HiddenDim = _options.HiddenDim;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-        if (_useNativeMode)
-            _optimizer = CreateDefaultOptimizer();
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new MegaTTS2<T>(Architecture, mp, new MegaTTS2Options(_options));
-        return new MegaTTS2<T>(Architecture, new MegaTTS2Options(_options));
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/TextToSpeech/Latest/MegaTTS3.cs b/src/TextToSpeech/Latest/MegaTTS3.cs
index 98bf47506d..a05c7a20bb 100644
--- a/src/TextToSpeech/Latest/MegaTTS3.cs
+++ b/src/TextToSpeech/Latest/MegaTTS3.cs
@@ -40,7 +40,7 @@ namespace AiDotNet.TextToSpeech.Latest;
     Year = 2025,
     Authors = "Jiang et al."
 )]
-public class MegaTTS3<T> : TtsModelBase<T>, ICodecTts<T>
+public partial class MegaTTS3<T> : TtsModelBase<T>, ICodecTts<T>
 {
     private readonly MegaTTS3Options _options;
 
@@ -204,58 +204,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.NumCodebooks);
-        writer.Write(_options.LLMDim);
-        writer.Write(_options.CodebookSize);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.NumEncoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.NumLLMLayers);
-        writer.Write(_options.TextEncoderDim);
-        writer.Write(_options.MelChannels);
-        writer.Write(_options.HopSize);
-        writer.Write(_options.CodecFrameRate);
-        writer.Write(_options.MaxTextLength);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.NumCodebooks = reader.ReadInt32();
-        _options.LLMDim = reader.ReadInt32();
-        _options.CodebookSize = reader.ReadInt32();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.NumEncoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.NumLLMLayers = reader.ReadInt32();
-        _options.TextEncoderDim = reader.ReadInt32();
-        _options.MelChannels = reader.ReadInt32();
-        _options.HopSize = reader.ReadInt32();
-        _options.CodecFrameRate = reader.ReadInt32();
-        _options.MaxTextLength = reader.ReadInt32();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        base.HiddenDim = _options.LLMDim;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new MegaTTS3<T>(Architecture, mp, _options);
-        return new MegaTTS3<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/TextToSpeech/Latest/OuteTTS.cs b/src/TextToSpeech/Latest/OuteTTS.cs
index f48e5ef6a4..67de17ed4e 100644
--- a/src/TextToSpeech/Latest/OuteTTS.cs
+++ b/src/TextToSpeech/Latest/OuteTTS.cs
@@ -35,7 +35,7 @@ namespace AiDotNet.TextToSpeech.Latest;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("OuteTTS: Outperforming ElevenLabs", "https://github.com/edwko/OuteTTS")]
-public class OuteTTS<T> : TtsModelBase<T>, ICodecTts<T>
+public partial class OuteTTS<T> : TtsModelBase<T>, ICodecTts<T>
 {
     private readonly OuteTTSOptions _options;
 
@@ -237,50 +237,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.NumCodebooks);
-        writer.Write(_options.LLMDim);
-        writer.Write(_options.CodebookSize);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.NumEncoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.NumLLMLayers);
-        writer.Write(_options.TextEncoderDim);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.NumCodebooks = reader.ReadInt32();
-        _options.LLMDim = reader.ReadInt32();
-        _options.CodebookSize = reader.ReadInt32();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.NumEncoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.NumLLMLayers = reader.ReadInt32();
-        _options.TextEncoderDim = reader.ReadInt32();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        base.HiddenDim = _options.LLMDim;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new OuteTTS<T>(Architecture, mp, _options);
-        return new OuteTTS<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/TextToSpeech/MultiModal/AudioPaLM.cs b/src/TextToSpeech/MultiModal/AudioPaLM.cs
index 8b2e3b0f82..1f6bff71a3 100644
--- a/src/TextToSpeech/MultiModal/AudioPaLM.cs
+++ b/src/TextToSpeech/MultiModal/AudioPaLM.cs
@@ -41,7 +41,7 @@ namespace AiDotNet.TextToSpeech.MultiModal;
     Year = 2023,
     Authors = "Rubenstein et al."
 )]
-public class AudioPaLM<T> : TtsModelBase<T>, IEndToEndTts<T>
+public partial class AudioPaLM<T> : TtsModelBase<T>, IEndToEndTts<T>
 {
     private readonly AudioPaLMOptions _options;
 
@@ -197,48 +197,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.EncoderDim);
-        writer.Write(_options.HiddenDim);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumEncoderLayers);
-        writer.Write(_options.NumHeads);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.EncoderDim = reader.ReadInt32();
-        _options.HiddenDim = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumEncoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        base.HiddenDim = _options.HiddenDim;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new AudioPaLM<T>(Architecture, mp, _options);
-        return new AudioPaLM<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/TextToSpeech/MultiModal/GLM4Voice.cs b/src/TextToSpeech/MultiModal/GLM4Voice.cs
index bc5af5de1b..a035cd681c 100644
--- a/src/TextToSpeech/MultiModal/GLM4Voice.cs
+++ b/src/TextToSpeech/MultiModal/GLM4Voice.cs
@@ -42,7 +42,7 @@ namespace AiDotNet.TextToSpeech.MultiModal;
     Year = 2024,
     Authors = "Zeng et al."
 )]
-public class GLM4Voice<T> : TtsModelBase<T>, ICodecTts<T>, IStreamingTts<T>
+public partial class GLM4Voice<T> : TtsModelBase<T>, ICodecTts<T>, IStreamingTts<T>
 {
     private readonly GLM4VoiceOptions _options;
 
@@ -264,58 +264,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.NumCodebooks);
-        writer.Write(_options.LLMDim);
-        writer.Write(_options.CodebookSize);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.NumEncoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.NumLLMLayers);
-        writer.Write(_options.TextEncoderDim);
-        writer.Write(_options.MelChannels);
-        writer.Write(_options.HopSize);
-        writer.Write(_options.CodecFrameRate);
-        writer.Write(_options.MaxTextLength);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.NumCodebooks = reader.ReadInt32();
-        _options.LLMDim = reader.ReadInt32();
-        _options.CodebookSize = reader.ReadInt32();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.NumEncoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.NumLLMLayers = reader.ReadInt32();
-        _options.TextEncoderDim = reader.ReadInt32();
-        _options.MelChannels = reader.ReadInt32();
-        _options.HopSize = reader.ReadInt32();
-        _options.CodecFrameRate = reader.ReadInt32();
-        _options.MaxTextLength = reader.ReadInt32();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        base.HiddenDim = _options.LLMDim;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new GLM4Voice<T>(Architecture, mp, new GLM4VoiceOptions(_options));
-        return new GLM4Voice<T>(Architecture, new GLM4VoiceOptions(_options));
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/TextToSpeech/MultiModal/LlamaOmni.cs b/src/TextToSpeech/MultiModal/LlamaOmni.cs
index ef3ebf994a..2654dcd1e6 100644
--- a/src/TextToSpeech/MultiModal/LlamaOmni.cs
+++ b/src/TextToSpeech/MultiModal/LlamaOmni.cs
@@ -42,7 +42,7 @@ namespace AiDotNet.TextToSpeech.MultiModal;
     Year = 2024,
     Authors = "Fang et al."
 )]
-public class LlamaOmni<T> : TtsModelBase<T>, ICodecTts<T>, IStreamingTts<T>
+public partial class LlamaOmni<T> : TtsModelBase<T>, ICodecTts<T>, IStreamingTts<T>
 {
     private readonly LlamaOmniOptions _options;
 
@@ -240,50 +240,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.NumCodebooks);
-        writer.Write(_options.LLMDim);
-        writer.Write(_options.CodebookSize);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.NumEncoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.NumLLMLayers);
-        writer.Write(_options.TextEncoderDim);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.NumCodebooks = reader.ReadInt32();
-        _options.LLMDim = reader.ReadInt32();
-        _options.CodebookSize = reader.ReadInt32();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.NumEncoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.NumLLMLayers = reader.ReadInt32();
-        _options.TextEncoderDim = reader.ReadInt32();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        base.HiddenDim = _options.LLMDim;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new LlamaOmni<T>(Architecture, mp, _options);
-        return new LlamaOmni<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/TextToSpeech/MultiModal/MinMo.cs b/src/TextToSpeech/MultiModal/MinMo.cs
index af6aa57837..75cfff2b30 100644
--- a/src/TextToSpeech/MultiModal/MinMo.cs
+++ b/src/TextToSpeech/MultiModal/MinMo.cs
@@ -42,7 +42,7 @@ namespace AiDotNet.TextToSpeech.MultiModal;
     Year = 2025,
     Authors = "Chen et al."
 )]
-public class MinMo<T> : TtsModelBase<T>, ICodecTts<T>, IStreamingTts<T>
+public partial class MinMo<T> : TtsModelBase<T>, ICodecTts<T>, IStreamingTts<T>
 {
     private readonly MinMoOptions _options;
 
@@ -289,50 +289,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.NumCodebooks);
-        writer.Write(_options.LLMDim);
-        writer.Write(_options.CodebookSize);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.NumEncoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.NumLLMLayers);
-        writer.Write(_options.TextEncoderDim);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.NumCodebooks = reader.ReadInt32();
-        _options.LLMDim = reader.ReadInt32();
-        _options.CodebookSize = reader.ReadInt32();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.NumEncoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.NumLLMLayers = reader.ReadInt32();
-        _options.TextEncoderDim = reader.ReadInt32();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        base.HiddenDim = _options.LLMDim;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new MinMo<T>(Architecture, mp, _options);
-        return new MinMo<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/TextToSpeech/MultiModal/Moshi.cs b/src/TextToSpeech/MultiModal/Moshi.cs
index ef3ec91175..c5c1f8078e 100644
--- a/src/TextToSpeech/MultiModal/Moshi.cs
+++ b/src/TextToSpeech/MultiModal/Moshi.cs
@@ -42,7 +42,7 @@ namespace AiDotNet.TextToSpeech.MultiModal;
     Year = 2024,
     Authors = "Defossez et al."
 )]
-public class Moshi<T> : TtsModelBase<T>, ICodecTts<T>, IStreamingTts<T>
+public partial class Moshi<T> : TtsModelBase<T>, ICodecTts<T>, IStreamingTts<T>
 {
     private readonly MoshiOptions _options;
 
@@ -294,54 +294,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.NumCodebooks);
-        writer.Write(_options.LLMDim);
-        writer.Write(_options.CodebookSize);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.NumEncoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.NumLLMLayers);
-        writer.Write(_options.TextEncoderDim);
-        writer.Write(_options.MelChannels);
-        writer.Write(_options.HopSize);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.NumCodebooks = reader.ReadInt32();
-        _options.LLMDim = reader.ReadInt32();
-        _options.CodebookSize = reader.ReadInt32();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.NumEncoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.NumLLMLayers = reader.ReadInt32();
-        _options.TextEncoderDim = reader.ReadInt32();
-        _options.MelChannels = reader.ReadInt32();
-        _options.HopSize = reader.ReadInt32();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        base.HiddenDim = _options.LLMDim;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new Moshi<T>(Architecture, mp, _options);
-        return new Moshi<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/TextToSpeech/MultiModal/SpeechGPT.cs b/src/TextToSpeech/MultiModal/SpeechGPT.cs
index cc94cb501e..8f70858163 100644
--- a/src/TextToSpeech/MultiModal/SpeechGPT.cs
+++ b/src/TextToSpeech/MultiModal/SpeechGPT.cs
@@ -42,7 +42,7 @@ namespace AiDotNet.TextToSpeech.MultiModal;
     Year = 2023,
     Authors = "Zhang et al."
 )]
-public class SpeechGPT<T> : TtsModelBase<T>, ICodecTts<T>
+public partial class SpeechGPT<T> : TtsModelBase<T>, ICodecTts<T>
 {
     private readonly SpeechGPTOptions _options;
 
@@ -227,65 +227,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.NumCodebooks);
-        writer.Write(_options.LLMDim);
-        writer.Write(_options.CodebookSize);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.NumEncoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.NumLLMLayers);
-        writer.Write(_options.TextEncoderDim);
-        writer.Write(_options.MelChannels);
-        writer.Write(_options.HopSize);
-        writer.Write(_options.CodecFrameRate);
-        writer.Write(_options.MaxTextLength);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.NumCodebooks = reader.ReadInt32();
-        _options.LLMDim = reader.ReadInt32();
-        _options.CodebookSize = reader.ReadInt32();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.NumEncoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.NumLLMLayers = reader.ReadInt32();
-        _options.TextEncoderDim = reader.ReadInt32();
-        _options.MelChannels = reader.ReadInt32();
-        _options.HopSize = reader.ReadInt32();
-        _options.CodecFrameRate = reader.ReadInt32();
-        _options.MaxTextLength = reader.ReadInt32();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        base.HiddenDim = _options.LLMDim;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-        {
-            if (!File.Exists(p))
-                throw new FileNotFoundException(
-                    $"ONNX model not found during deserialization: {p}",
-                    p
-                );
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-        }
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new SpeechGPT<T>(Architecture, mp, new SpeechGPTOptions(_options));
-        return new SpeechGPT<T>(Architecture, new SpeechGPTOptions(_options));
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/TextToSpeech/MultiModal/SpeechT5.cs b/src/TextToSpeech/MultiModal/SpeechT5.cs
index e5e389959e..06a5f6bfd3 100644
--- a/src/TextToSpeech/MultiModal/SpeechT5.cs
+++ b/src/TextToSpeech/MultiModal/SpeechT5.cs
@@ -43,7 +43,7 @@ namespace AiDotNet.TextToSpeech.MultiModal;
     Year = 2022,
     Authors = "Ao et al."
 )]
-public class SpeechT5<T> : TtsModelBase<T>, IEndToEndTts<T>
+public partial class SpeechT5<T> : TtsModelBase<T>, IEndToEndTts<T>
 {
     private readonly SpeechT5Options _options;
 
@@ -218,54 +218,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.EncoderDim);
-        writer.Write(_options.HiddenDim);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumEncoderLayers);
-        writer.Write(_options.NumFlowSteps);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.MelChannels);
-        writer.Write(_options.HopSize);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.EncoderDim = reader.ReadInt32();
-        _options.HiddenDim = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumEncoderLayers = reader.ReadInt32();
-        _options.NumFlowSteps = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.MelChannels = reader.ReadInt32();
-        _options.HopSize = reader.ReadInt32();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        base.HiddenDim = _options.HiddenDim;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new SpeechT5<T>(Architecture, mp, _options);
-        return new SpeechT5<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/TextToSpeech/MultiModal/SpiritLM.cs b/src/TextToSpeech/MultiModal/SpiritLM.cs
index 3c47595919..3decfcdfcc 100644
--- a/src/TextToSpeech/MultiModal/SpiritLM.cs
+++ b/src/TextToSpeech/MultiModal/SpiritLM.cs
@@ -42,7 +42,7 @@ namespace AiDotNet.TextToSpeech.MultiModal;
     Year = 2024,
     Authors = "Nguyen et al."
 )]
-public class SpiritLM<T> : TtsModelBase<T>, ICodecTts<T>
+public partial class SpiritLM<T> : TtsModelBase<T>, ICodecTts<T>
 {
     private readonly SpiritLMOptions _options;
 
@@ -219,51 +219,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.NumCodebooks);
-        writer.Write(_options.LLMDim);
-        writer.Write(_options.CodebookSize);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.NumEncoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.NumLLMLayers);
-        writer.Write(_options.TextEncoderDim);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.NumCodebooks = reader.ReadInt32();
-        _options.LLMDim = reader.ReadInt32();
-        _options.CodebookSize = reader.ReadInt32();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.NumEncoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.NumLLMLayers = reader.ReadInt32();
-        _options.TextEncoderDim = reader.ReadInt32();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        base.HiddenDim = _options.LLMDim;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var options = new SpiritLMOptions(_options);
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new SpiritLM<T>(Architecture, mp, options);
-        return new SpiritLM<T>(Architecture, options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/TextToSpeech/MultiModal/StepAudio.cs b/src/TextToSpeech/MultiModal/StepAudio.cs
index bbb513104c..0997786da3 100644
--- a/src/TextToSpeech/MultiModal/StepAudio.cs
+++ b/src/TextToSpeech/MultiModal/StepAudio.cs
@@ -41,7 +41,7 @@ namespace AiDotNet.TextToSpeech.MultiModal;
     Year = 2025,
     Authors = "StepFun"
 )]
-public class StepAudio<T> : TtsModelBase<T>, ICodecTts<T>, IStreamingTts<T>
+public partial class StepAudio<T> : TtsModelBase<T>, ICodecTts<T>, IStreamingTts<T>
 {
     private readonly StepAudioOptions _options;
 
@@ -267,58 +267,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.NumCodebooks);
-        writer.Write(_options.LLMDim);
-        writer.Write(_options.CodebookSize);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.NumEncoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.NumLLMLayers);
-        writer.Write(_options.TextEncoderDim);
-        writer.Write(_options.MelChannels);
-        writer.Write(_options.HopSize);
-        writer.Write(_options.CodecFrameRate);
-        writer.Write(_options.MaxTextLength);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.NumCodebooks = reader.ReadInt32();
-        _options.LLMDim = reader.ReadInt32();
-        _options.CodebookSize = reader.ReadInt32();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.NumEncoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.NumLLMLayers = reader.ReadInt32();
-        _options.TextEncoderDim = reader.ReadInt32();
-        _options.MelChannels = reader.ReadInt32();
-        _options.HopSize = reader.ReadInt32();
-        _options.CodecFrameRate = reader.ReadInt32();
-        _options.MaxTextLength = reader.ReadInt32();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        base.HiddenDim = _options.LLMDim;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new StepAudio<T>(Architecture, mp, _options);
-        return new StepAudio<T>(Architecture, _options, _optimizer);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/TextToSpeech/MultiModal/WhisperSpeech.cs b/src/TextToSpeech/MultiModal/WhisperSpeech.cs
index fc3c140621..11230c426d 100644
--- a/src/TextToSpeech/MultiModal/WhisperSpeech.cs
+++ b/src/TextToSpeech/MultiModal/WhisperSpeech.cs
@@ -41,7 +41,7 @@ namespace AiDotNet.TextToSpeech.MultiModal;
     Year = 2023,
     Authors = "Kharitonov et al."
 )]
-public class WhisperSpeech<T> : TtsModelBase<T>, ICodecTts<T>
+public partial class WhisperSpeech<T> : TtsModelBase<T>, ICodecTts<T>
 {
     private readonly WhisperSpeechOptions _options;
 
@@ -225,58 +225,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.NumCodebooks);
-        writer.Write(_options.LLMDim);
-        writer.Write(_options.CodebookSize);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.NumEncoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.NumLLMLayers);
-        writer.Write(_options.TextEncoderDim);
-        writer.Write(_options.MelChannels);
-        writer.Write(_options.HopSize);
-        writer.Write(_options.CodecFrameRate);
-        writer.Write(_options.MaxTextLength);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.NumCodebooks = reader.ReadInt32();
-        _options.LLMDim = reader.ReadInt32();
-        _options.CodebookSize = reader.ReadInt32();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.NumEncoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.NumLLMLayers = reader.ReadInt32();
-        _options.TextEncoderDim = reader.ReadInt32();
-        _options.MelChannels = reader.ReadInt32();
-        _options.HopSize = reader.ReadInt32();
-        _options.CodecFrameRate = reader.ReadInt32();
-        _options.MaxTextLength = reader.ReadInt32();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        base.HiddenDim = _options.LLMDim;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new WhisperSpeech<T>(Architecture, mp, new WhisperSpeechOptions(_options));
-        return new WhisperSpeech<T>(Architecture, new WhisperSpeechOptions(_options));
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/TextToSpeech/ProprietaryAPI/AmazonPolly.cs b/src/TextToSpeech/ProprietaryAPI/AmazonPolly.cs
index 29e2477bfe..0e729148ad 100644
--- a/src/TextToSpeech/ProprietaryAPI/AmazonPolly.cs
+++ b/src/TextToSpeech/ProprietaryAPI/AmazonPolly.cs
@@ -35,7 +35,7 @@ namespace AiDotNet.TextToSpeech.ProprietaryAPI;
 [ModelComplexity(ModelComplexity.Medium)]
 [ResearchPaper("Amazon Polly", "https://aws.amazon.com/polly/")]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
-public class AmazonPolly<T> : TtsModelBase<T>, IEndToEndTts<T>
+public partial class AmazonPolly<T> : TtsModelBase<T>, IEndToEndTts<T>
 {
     private readonly AmazonPollyOptions _options;
 
@@ -179,52 +179,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.HiddenDim);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumEncoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.MaxTextLength);
-        writer.Write(_options.HopSize);
-        writer.Write(_options.MelChannels);
-        writer.Write(_options.NumFlowSteps);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.HiddenDim = reader.ReadInt32();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumEncoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.MaxTextLength = reader.ReadInt32();
-        _options.HopSize = reader.ReadInt32();
-        _options.MelChannels = reader.ReadInt32();
-        _options.NumFlowSteps = reader.ReadInt32();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        base.HiddenDim = _options.HiddenDim;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new AmazonPolly<T>(Architecture, mp, _options);
-        return new AmazonPolly<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/TextToSpeech/ProprietaryAPI/AzureNeuralTTS.cs b/src/TextToSpeech/ProprietaryAPI/AzureNeuralTTS.cs
index 085f333e80..ea3da47246 100644
--- a/src/TextToSpeech/ProprietaryAPI/AzureNeuralTTS.cs
+++ b/src/TextToSpeech/ProprietaryAPI/AzureNeuralTTS.cs
@@ -38,7 +38,7 @@ namespace AiDotNet.TextToSpeech.ProprietaryAPI;
     "Microsoft Azure Neural Text-to-Speech",
     "https://azure.microsoft.com/en-us/products/ai-services/text-to-speech"
 )]
-public class AzureNeuralTTS<T> : TtsModelBase<T>, IEndToEndTts<T>
+public partial class AzureNeuralTTS<T> : TtsModelBase<T>, IEndToEndTts<T>
 {
     private readonly AzureNeuralTTSOptions _options;
 
@@ -203,44 +203,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.HiddenDim);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumEncoderLayers);
-        writer.Write(_options.NumHeads);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.HiddenDim = reader.ReadInt32();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumEncoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        base.HiddenDim = _options.HiddenDim;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new AzureNeuralTTS<T>(Architecture, mp, _options);
-        return new AzureNeuralTTS<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/TextToSpeech/ProprietaryAPI/ElevenLabsTTS.cs b/src/TextToSpeech/ProprietaryAPI/ElevenLabsTTS.cs
index 7a109e5453..93da0a39b8 100644
--- a/src/TextToSpeech/ProprietaryAPI/ElevenLabsTTS.cs
+++ b/src/TextToSpeech/ProprietaryAPI/ElevenLabsTTS.cs
@@ -35,7 +35,7 @@ namespace AiDotNet.TextToSpeech.ProprietaryAPI;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("ElevenLabs", "https://elevenlabs.io")]
-public class ElevenLabsTTS<T> : TtsModelBase<T>, IEndToEndTts<T>
+public partial class ElevenLabsTTS<T> : TtsModelBase<T>, IEndToEndTts<T>
 {
     private readonly ElevenLabsTTSOptions _options;
 
@@ -179,44 +179,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.HiddenDim);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumEncoderLayers);
-        writer.Write(_options.NumHeads);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.HiddenDim = reader.ReadInt32();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumEncoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        base.HiddenDim = _options.HiddenDim;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new ElevenLabsTTS<T>(Architecture, mp, _options);
-        return new ElevenLabsTTS<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/TextToSpeech/ProprietaryAPI/GoogleCloudTTS.cs b/src/TextToSpeech/ProprietaryAPI/GoogleCloudTTS.cs
index 38612ab52c..b444365161 100644
--- a/src/TextToSpeech/ProprietaryAPI/GoogleCloudTTS.cs
+++ b/src/TextToSpeech/ProprietaryAPI/GoogleCloudTTS.cs
@@ -35,7 +35,7 @@ namespace AiDotNet.TextToSpeech.ProprietaryAPI;
 [ModelComplexity(ModelComplexity.Medium)]
 [ResearchPaper("Google Cloud Text-to-Speech", "https://cloud.google.com/text-to-speech")]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
-public class GoogleCloudTTS<T> : TtsModelBase<T>, IEndToEndTts<T>
+public partial class GoogleCloudTTS<T> : TtsModelBase<T>, IEndToEndTts<T>
 {
     private readonly GoogleCloudTTSOptions _options;
 
@@ -200,44 +200,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.HiddenDim);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumEncoderLayers);
-        writer.Write(_options.NumHeads);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.HiddenDim = reader.ReadInt32();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumEncoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        base.HiddenDim = _options.HiddenDim;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new GoogleCloudTTS<T>(Architecture, mp, _options);
-        return new GoogleCloudTTS<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/TextToSpeech/ProprietaryAPI/Murf.cs b/src/TextToSpeech/ProprietaryAPI/Murf.cs
index 968c8c7dc8..8cab1a76a6 100644
--- a/src/TextToSpeech/ProprietaryAPI/Murf.cs
+++ b/src/TextToSpeech/ProprietaryAPI/Murf.cs
@@ -35,7 +35,7 @@ namespace AiDotNet.TextToSpeech.ProprietaryAPI;
 [ModelComplexity(ModelComplexity.Medium)]
 [ResearchPaper("Murf AI", "https://murf.ai")]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
-public class Murf<T> : TtsModelBase<T>, IEndToEndTts<T>
+public partial class Murf<T> : TtsModelBase<T>, IEndToEndTts<T>
 {
     private readonly MurfOptions _options;
 
@@ -179,44 +179,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.HiddenDim);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumEncoderLayers);
-        writer.Write(_options.NumHeads);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.HiddenDim = reader.ReadInt32();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumEncoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        base.HiddenDim = _options.HiddenDim;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new Murf<T>(Architecture, mp, _options);
-        return new Murf<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/TextToSpeech/ProprietaryAPI/NVIDIARivaTTS.cs b/src/TextToSpeech/ProprietaryAPI/NVIDIARivaTTS.cs
index 3bd4aedb3c..b7ef3044c8 100644
--- a/src/TextToSpeech/ProprietaryAPI/NVIDIARivaTTS.cs
+++ b/src/TextToSpeech/ProprietaryAPI/NVIDIARivaTTS.cs
@@ -35,7 +35,7 @@ namespace AiDotNet.TextToSpeech.ProprietaryAPI;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("NVIDIA Riva", "https://developer.nvidia.com/riva")]
-public class NVIDIARivaTTS<T> : TtsModelBase<T>, IEndToEndTts<T>
+public partial class NVIDIARivaTTS<T> : TtsModelBase<T>, IEndToEndTts<T>
 {
     private readonly NVIDIARivaTTSOptions _options;
 
@@ -182,46 +182,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.EncoderDim);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumEncoderLayers);
-        writer.Write(_options.NumHeads);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.EncoderDim = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumEncoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        base.HiddenDim = _options.HiddenDim;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new NVIDIARivaTTS<T>(Architecture, mp, _options);
-        return new NVIDIARivaTTS<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/TextToSpeech/ProprietaryAPI/Pheme.cs b/src/TextToSpeech/ProprietaryAPI/Pheme.cs
index a14a8ee092..0d7eb5545f 100644
--- a/src/TextToSpeech/ProprietaryAPI/Pheme.cs
+++ b/src/TextToSpeech/ProprietaryAPI/Pheme.cs
@@ -35,7 +35,7 @@ namespace AiDotNet.TextToSpeech.ProprietaryAPI;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Pheme: AI Voice Synthesis", "https://www.pheme.ai")]
-public class Pheme<T> : TtsModelBase<T>, IEndToEndTts<T>
+public partial class Pheme<T> : TtsModelBase<T>, IEndToEndTts<T>
 {
     private readonly PhemeOptions _options;
 
@@ -182,46 +182,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.EncoderDim);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumEncoderLayers);
-        writer.Write(_options.NumHeads);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.EncoderDim = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumEncoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        base.HiddenDim = _options.HiddenDim;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new Pheme<T>(Architecture, mp, _options);
-        return new Pheme<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/TextToSpeech/ProprietaryAPI/PlayHT.cs b/src/TextToSpeech/ProprietaryAPI/PlayHT.cs
index 17f7a40514..029b6170fd 100644
--- a/src/TextToSpeech/ProprietaryAPI/PlayHT.cs
+++ b/src/TextToSpeech/ProprietaryAPI/PlayHT.cs
@@ -35,7 +35,7 @@ namespace AiDotNet.TextToSpeech.ProprietaryAPI;
 [ModelComplexity(ModelComplexity.Medium)]
 [ResearchPaper("PlayHT", "https://play.ht")]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
-public class PlayHT<T> : TtsModelBase<T>, IEndToEndTts<T>
+public partial class PlayHT<T> : TtsModelBase<T>, IEndToEndTts<T>
 {
     private readonly PlayHTOptions _options;
 
@@ -191,52 +191,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.HiddenDim);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumEncoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.MaxTextLength);
-        writer.Write(_options.HopSize);
-        writer.Write(_options.MelChannels);
-        writer.Write(_options.NumFlowSteps);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.HiddenDim = reader.ReadInt32();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumEncoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.MaxTextLength = reader.ReadInt32();
-        _options.HopSize = reader.ReadInt32();
-        _options.MelChannels = reader.ReadInt32();
-        _options.NumFlowSteps = reader.ReadInt32();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        base.HiddenDim = _options.HiddenDim;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (IsOnnxMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new PlayHT<T>(Architecture, mp, _options);
-        return new PlayHT<T>(Architecture, _options, _optimizer);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/TextToSpeech/ProprietaryAPI/WellSaidLabs.cs b/src/TextToSpeech/ProprietaryAPI/WellSaidLabs.cs
index 022564707b..bab2d4abc0 100644
--- a/src/TextToSpeech/ProprietaryAPI/WellSaidLabs.cs
+++ b/src/TextToSpeech/ProprietaryAPI/WellSaidLabs.cs
@@ -35,7 +35,7 @@ namespace AiDotNet.TextToSpeech.ProprietaryAPI;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("WellSaid Labs", "https://wellsaidlabs.com")]
-public class WellSaidLabs<T> : TtsModelBase<T>, IEndToEndTts<T>
+public partial class WellSaidLabs<T> : TtsModelBase<T>, IEndToEndTts<T>
 {
     private readonly WellSaidLabsOptions _options;
 
@@ -215,52 +215,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.HiddenDim);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumEncoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.MaxTextLength);
-        writer.Write(_options.HopSize);
-        writer.Write(_options.MelChannels);
-        writer.Write(_options.NumFlowSteps);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.HiddenDim = reader.ReadInt32();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumEncoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.MaxTextLength = reader.ReadInt32();
-        _options.HopSize = reader.ReadInt32();
-        _options.MelChannels = reader.ReadInt32();
-        _options.NumFlowSteps = reader.ReadInt32();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        base.HiddenDim = _options.HiddenDim;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (IsOnnxMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new WellSaidLabs<T>(Architecture, mp, _options);
-        return new WellSaidLabs<T>(Architecture, _options, _optimizer);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/TextToSpeech/StyleEmotion/EmotiVoice.cs b/src/TextToSpeech/StyleEmotion/EmotiVoice.cs
index 163d0401f6..b20b737aa8 100644
--- a/src/TextToSpeech/StyleEmotion/EmotiVoice.cs
+++ b/src/TextToSpeech/StyleEmotion/EmotiVoice.cs
@@ -38,7 +38,7 @@ namespace AiDotNet.TextToSpeech.StyleEmotion;
     "https://arxiv.org/abs/2211.12171"
 )]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
-public class EmotiVoice<T> : TtsModelBase<T>, IEndToEndTts<T>
+public partial class EmotiVoice<T> : TtsModelBase<T>, IEndToEndTts<T>
 {
     private readonly EmotiVoiceOptions _options;
 
@@ -271,70 +271,9 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.MelChannels);
-        writer.Write(_options.HiddenDim);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.EmotionDim);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumEmotionLayers);
-        writer.Write(_options.NumEncoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.LearningRate);
-        writer.Write(_options.WeightDecay);
-        writer.Write(_options.OptimizerBeta1);
-        writer.Write(_options.OptimizerBeta2);
-        writer.Write(_options.OptimizerEpsilon);
-        writer.Write(_options.LearningRateSchedulerGamma);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.MelChannels = reader.ReadInt32();
-        _options.HiddenDim = reader.ReadInt32();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.EmotionDim = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumEmotionLayers = reader.ReadInt32();
-        _options.NumEncoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        if (reader.BaseStream.Position < reader.BaseStream.Length)
-            _options.LearningRate = reader.ReadDouble();
-        if (reader.BaseStream.Position < reader.BaseStream.Length)
-            _options.WeightDecay = reader.ReadDouble();
-        if (reader.BaseStream.Position < reader.BaseStream.Length)
-            _options.OptimizerBeta1 = reader.ReadDouble();
-        if (reader.BaseStream.Position < reader.BaseStream.Length)
-            _options.OptimizerBeta2 = reader.ReadDouble();
-        if (reader.BaseStream.Position < reader.BaseStream.Length)
-            _options.OptimizerEpsilon = reader.ReadDouble();
-        if (reader.BaseStream.Position < reader.BaseStream.Length)
-            _options.LearningRateSchedulerGamma = reader.ReadDouble();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        base.HiddenDim = _options.HiddenDim;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-        if (_useNativeMode)
-            _optimizer = CreateDefaultOptimizer();
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new EmotiVoice<T>(Architecture, mp, _options);
-        return new EmotiVoice<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/TextToSpeech/StyleEmotion/StyleTTS.cs b/src/TextToSpeech/StyleEmotion/StyleTTS.cs
index 177f8250b4..0460a06d51 100644
--- a/src/TextToSpeech/StyleEmotion/StyleTTS.cs
+++ b/src/TextToSpeech/StyleEmotion/StyleTTS.cs
@@ -40,7 +40,7 @@ namespace AiDotNet.TextToSpeech.StyleEmotion;
     Year = 2022,
     Authors = "Li et al."
 )]
-public class StyleTTS<T> : TtsModelBase<T>, IEndToEndTts<T>
+public partial class StyleTTS<T> : TtsModelBase<T>, IEndToEndTts<T>
 {
     private readonly StyleTTSOptions _options;
 
@@ -192,52 +192,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.MelChannels);
-        writer.Write(_options.HopSize);
-        writer.Write(_options.HiddenDim);
-        writer.Write(_options.StyleDim);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumEncoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.NumStyleDiffusionSteps);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.MelChannels = reader.ReadInt32();
-        _options.HopSize = reader.ReadInt32();
-        _options.HiddenDim = reader.ReadInt32();
-        _options.StyleDim = reader.ReadInt32();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumEncoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.NumStyleDiffusionSteps = reader.ReadInt32();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        base.HiddenDim = _options.HiddenDim;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new StyleTTS<T>(Architecture, mp, _options);
-        return new StyleTTS<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/TextToSpeech/StyleEmotion/StyleTTS2.cs b/src/TextToSpeech/StyleEmotion/StyleTTS2.cs
index 8c4e55e0ca..0cdaaa70fe 100644
--- a/src/TextToSpeech/StyleEmotion/StyleTTS2.cs
+++ b/src/TextToSpeech/StyleEmotion/StyleTTS2.cs
@@ -40,7 +40,7 @@ namespace AiDotNet.TextToSpeech.StyleEmotion;
     Year = 2023,
     Authors = "Li et al."
 )]
-public class StyleTTS2<T> : TtsModelBase<T>, IEndToEndTts<T>
+public partial class StyleTTS2<T> : TtsModelBase<T>, IEndToEndTts<T>
 {
     private readonly StyleTTS2Options _options;
 
@@ -222,52 +222,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.MelChannels);
-        writer.Write(_options.HopSize);
-        writer.Write(_options.HiddenDim);
-        writer.Write(_options.StyleDim);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumEncoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.NumStyleDiffusionSteps);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.MelChannels = reader.ReadInt32();
-        _options.HopSize = reader.ReadInt32();
-        _options.HiddenDim = reader.ReadInt32();
-        _options.StyleDim = reader.ReadInt32();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumEncoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.NumStyleDiffusionSteps = reader.ReadInt32();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        base.HiddenDim = _options.HiddenDim;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new StyleTTS2<T>(Architecture, mp, _options);
-        return new StyleTTS2<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/TextToSpeech/StyleEmotion/StyleTTSZS.cs b/src/TextToSpeech/StyleEmotion/StyleTTSZS.cs
index 9940e3118a..5bcb251e0e 100644
--- a/src/TextToSpeech/StyleEmotion/StyleTTSZS.cs
+++ b/src/TextToSpeech/StyleEmotion/StyleTTSZS.cs
@@ -40,7 +40,7 @@ namespace AiDotNet.TextToSpeech.StyleEmotion;
     Year = 2024,
     Authors = "Li et al."
 )]
-public class StyleTTSZS<T> : TtsModelBase<T>, IEndToEndTts<T>
+public partial class StyleTTSZS<T> : TtsModelBase<T>, IEndToEndTts<T>
 {
     private readonly StyleTTSZSOptions _options;
 
@@ -190,50 +190,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.EncoderDim);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumEncoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.NumStyleLayers);
-        writer.Write(_options.StyleDim);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.EncoderDim = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumEncoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.NumStyleLayers = reader.ReadInt32();
-        _options.StyleDim = reader.ReadInt32();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        base.HiddenDim = _options.HiddenDim;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new StyleTTSZS<T>(Architecture, mp, _options);
-        return new StyleTTSZS<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/TextToSpeech/TtsModelBase.cs b/src/TextToSpeech/TtsModelBase.cs
index 3ccf8ccf8b..1f82f9547e 100644
--- a/src/TextToSpeech/TtsModelBase.cs
+++ b/src/TextToSpeech/TtsModelBase.cs
@@ -41,7 +41,7 @@ namespace AiDotNet.TextToSpeech;
     Note = "One frame per input position: the input's second axis is carried through as TIME and the "
          + "width is appended. Models whose Predict ends somewhere else state their own width through "
          + "OutputFeatureWidth, or decline by leaving it at 0.")]
-public abstract class TtsModelBase<T> : NeuralNetworkBase<T>, IShapeContract
+public abstract partial class TtsModelBase<T> : NeuralNetworkBase<T>, IShapeContract
 {
     /// <summary>
     /// The width of this model's <c>Predict</c> output, or 0 for "not stated".
diff --git a/src/TextToSpeech/Vocoders/APNet.cs b/src/TextToSpeech/Vocoders/APNet.cs
index 4b088a3810..f35968c8db 100644
--- a/src/TextToSpeech/Vocoders/APNet.cs
+++ b/src/TextToSpeech/Vocoders/APNet.cs
@@ -40,7 +40,7 @@ namespace AiDotNet.TextToSpeech.Vocoders;
     Year = 2023,
     Authors = "Ai et al."
 )]
-public class APNet<T> : VocoderBase<T>
+public partial class APNet<T> : VocoderBase<T>
 {
     private readonly APNetOptions _options;
 
@@ -180,41 +180,9 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.MelChannels);
-        writer.Write(_options.HopSize);
-        writer.Write(_options.FftSize);
-        writer.Write(_options.DropoutRate);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.MelChannels = reader.ReadInt32();
-        _options.HopSize = reader.ReadInt32();
-        _options.FftSize = reader.ReadInt32();
-        _options.DropoutRate = reader.ReadDouble();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new APNet<T>(Architecture, mp, _options);
-        return new APNet<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/TextToSpeech/Vocoders/APNet2.cs b/src/TextToSpeech/Vocoders/APNet2.cs
index e227dca0c1..15b05ed347 100644
--- a/src/TextToSpeech/Vocoders/APNet2.cs
+++ b/src/TextToSpeech/Vocoders/APNet2.cs
@@ -438,62 +438,9 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.MelChannels);
-        writer.Write(_options.HopSize);
-        writer.Write(_options.FftSize);
-        writer.Write(_options.DropoutRate);
-        // The ConvNeXt v2 backbone geometry decides the parameter count, so it has to survive
-        // the round-trip: restoring into a model rebuilt at different widths silently
-        // misaligns every slice of the flat parameter vector.
-        writer.Write(_options.ConvNeXtChannels);
-        writer.Write(_options.ConvNeXtIntermediateChannels);
-        writer.Write(_options.NumConvNeXtBlocks);
-        writer.Write(_options.DepthwiseKernelSize);
-        writer.Write(_options.WindowLength);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.MelChannels = reader.ReadInt32();
-        _options.HopSize = reader.ReadInt32();
-        _options.FftSize = reader.ReadInt32();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.ConvNeXtChannels = reader.ReadInt32();
-        _options.ConvNeXtIntermediateChannels = reader.ReadInt32();
-        _options.NumConvNeXtBlocks = reader.ReadInt32();
-        _options.DepthwiseKernelSize = reader.ReadInt32();
-        _options.WindowLength = reader.ReadInt32();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    
-        RebindBranchLayers();
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new APNet2<T>(Architecture, mp, _options);
-
-        // Carry the objective and the optimizer across explicitly. Rebuilding from architecture and
-        // options alone silently re-derives them, so a model trained under a caller-supplied loss
-        // came back as a clone trained under a different one: the more-data invariant trains the
-        // original for a few steps and its CLONE for more, and the clone's parameters were
-        // bit-identical no matter which objective the original had been given.
-        return new APNet2<T>(Architecture, _options, _optimizer, LossFunction);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/TextToSpeech/Vocoders/BigVGAN.cs b/src/TextToSpeech/Vocoders/BigVGAN.cs
index f020535c83..9401146bc5 100644
--- a/src/TextToSpeech/Vocoders/BigVGAN.cs
+++ b/src/TextToSpeech/Vocoders/BigVGAN.cs
@@ -40,7 +40,7 @@ namespace AiDotNet.TextToSpeech.Vocoders;
     Year = 2023,
     Authors = "Lee et al."
 )]
-public class BigVGAN<T> : VocoderBase<T>
+public partial class BigVGAN<T> : VocoderBase<T>
 {
     private readonly BigVGANOptions _options;
 
@@ -215,43 +215,9 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.MelChannels);
-        writer.Write(_options.HopSize);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.HiddenChannels);
-        writer.Write(_options.NumUpsampleLayers);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.MelChannels = reader.ReadInt32();
-        _options.HopSize = reader.ReadInt32();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.HiddenChannels = reader.ReadInt32();
-        _options.NumUpsampleLayers = reader.ReadInt32();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new BigVGAN<T>(Architecture, mp, _options);
-        return new BigVGAN<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/TextToSpeech/Vocoders/DiffWave.cs b/src/TextToSpeech/Vocoders/DiffWave.cs
index 971b34674d..6be9fd0296 100644
--- a/src/TextToSpeech/Vocoders/DiffWave.cs
+++ b/src/TextToSpeech/Vocoders/DiffWave.cs
@@ -40,7 +40,7 @@ namespace AiDotNet.TextToSpeech.Vocoders;
     Year = 2021,
     Authors = "Kong et al."
 )]
-public class DiffWave<T> : VocoderBase<T>
+public partial class DiffWave<T> : VocoderBase<T>
 {
     private readonly DiffWaveOptions _options;
 
@@ -207,77 +207,9 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.MelChannels);
-        writer.Write(_options.HopSize);
-        writer.Write(_options.NumDiffusionSteps);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.NumResLayers);
-        writer.Write(_options.ResChannels);
-        writer.Write(_options.LearningRate);
-        writer.Write(_options.WeightDecay);
-        writer.Write(_options.OptimizerBatchSize);
-        writer.Write(_options.OptimizerBeta1);
-        writer.Write(_options.OptimizerBeta2);
-        writer.Write(_options.OptimizerEpsilon);
-        writer.Write(_options.MaxGradientNorm);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.MelChannels = reader.ReadInt32();
-        _options.HopSize = reader.ReadInt32();
-        _options.NumDiffusionSteps = reader.ReadInt32();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.NumResLayers = reader.ReadInt32();
-        _options.ResChannels = reader.ReadInt32();
-        // These optimizer fields were appended to preserve backward compatibility with model files
-        // written before they became configurable. Older payloads end after ResChannels.
-        const int optimizerPayloadBytes = (6 * sizeof(double)) + sizeof(int);
-        if (reader.BaseStream.Length - reader.BaseStream.Position >= optimizerPayloadBytes)
-        {
-            _options.LearningRate = reader.ReadDouble();
-            _options.WeightDecay = reader.ReadDouble();
-            _options.OptimizerBatchSize = reader.ReadInt32();
-            _options.OptimizerBeta1 = reader.ReadDouble();
-            _options.OptimizerBeta2 = reader.ReadDouble();
-            _options.OptimizerEpsilon = reader.ReadDouble();
-            _options.MaxGradientNorm = reader.ReadDouble();
-            MaxGradNorm = NumOps.FromDouble(_options.MaxGradientNorm);
-        }
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        if (_useNativeMode && !_preserveSuppliedOptimizer)
-            _optimizer = CreateDefaultOptimizer();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new DiffWave<T>(Architecture, mp, new DiffWaveOptions(_options));
 
-        IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? cloneOptimizer = _optimizer switch
-        {
-            AdamWOptimizer<T, Tensor<T>, Tensor<T>> when _optimizer.GetOptions() is AdamWOptimizerOptions<T, Tensor<T>, Tensor<T>> options
-                => new AdamWOptimizer<T, Tensor<T>, Tensor<T>>(null, new AdamWOptimizerOptions<T, Tensor<T>, Tensor<T>>(options)),
-            AdamOptimizer<T, Tensor<T>, Tensor<T>> when _optimizer.GetOptions() is AdamOptimizerOptions<T, Tensor<T>, Tensor<T>> options
-                => new AdamOptimizer<T, Tensor<T>, Tensor<T>>(null, new AdamOptimizerOptions<T, Tensor<T>, Tensor<T>>(options)),
-            _ => null
-        };
-        return new DiffWave<T>(Architecture, new DiffWaveOptions(_options), cloneOptimizer);
-    }
 
     private IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>> CreateDefaultOptimizer()
     {
diff --git a/src/TextToSpeech/Vocoders/FreGrad.cs b/src/TextToSpeech/Vocoders/FreGrad.cs
index 5b2d83df48..4ca2c0b4c6 100644
--- a/src/TextToSpeech/Vocoders/FreGrad.cs
+++ b/src/TextToSpeech/Vocoders/FreGrad.cs
@@ -40,7 +40,7 @@ namespace AiDotNet.TextToSpeech.Vocoders;
     Year = 2022,
     Authors = "Shin et al."
 )]
-public class FreGrad<T> : VocoderBase<T>
+public partial class FreGrad<T> : VocoderBase<T>
 {
     private readonly FreGradOptions _options;
 
@@ -228,47 +228,9 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.MelChannels);
-        writer.Write(_options.HopSize);
-        writer.Write(_options.NumDiffusionSteps);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.NumResBlocks);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.MelChannels = reader.ReadInt32();
-        _options.HopSize = reader.ReadInt32();
-        _options.NumDiffusionSteps = reader.ReadInt32();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.NumResBlocks = reader.ReadInt32();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new FreGrad<T>(Architecture, mp, new FreGradOptions(_options));
 
-        var cloneOptimizer = _optimizer?.GetOptions() is AdamWOptimizerOptions<T, Tensor<T>, Tensor<T>> options
-            ? new AdamWOptimizer<T, Tensor<T>, Tensor<T>>(null, new AdamWOptimizerOptions<T, Tensor<T>, Tensor<T>>(options))
-            : null;
-        return new FreGrad<T>(Architecture, new FreGradOptions(_options), cloneOptimizer);
-    }
 
     private void ThrowIfDisposed()
     {
diff --git a/src/TextToSpeech/Vocoders/HiFiGAN.cs b/src/TextToSpeech/Vocoders/HiFiGAN.cs
index 2057ac08d9..c679b885c6 100644
--- a/src/TextToSpeech/Vocoders/HiFiGAN.cs
+++ b/src/TextToSpeech/Vocoders/HiFiGAN.cs
@@ -47,7 +47,7 @@ namespace AiDotNet.TextToSpeech.Vocoders;
     Year = 2020,
     Authors = "Kong et al."
 )]
-public class HiFiGAN<T> : VocoderBase<T>
+public partial class HiFiGAN<T> : VocoderBase<T>
 {
     private readonly HiFiGANOptions _options;
 
@@ -223,48 +223,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.MelChannels);
-        writer.Write(_options.HopSize);
-        writer.Write(_options.UpsampleInitialChannels);
-        writer.Write(_options.UpsampleRates.Length);
-        foreach (var r in _options.UpsampleRates)
-            writer.Write(r);
-        writer.Write(_options.DropoutRate);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.MelChannels = reader.ReadInt32();
-        _options.HopSize = reader.ReadInt32();
-        _options.UpsampleInitialChannels = reader.ReadInt32();
-        int n = reader.ReadInt32();
-        _options.UpsampleRates = new int[n];
-        for (int i = 0; i < n; i++)
-            _options.UpsampleRates[i] = reader.ReadInt32();
-        _options.DropoutRate = reader.ReadDouble();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new HiFiGAN<T>(Architecture, mp, _options);
-        return new HiFiGAN<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/TextToSpeech/Vocoders/ISTFTNet.cs b/src/TextToSpeech/Vocoders/ISTFTNet.cs
index d98d67719d..a804ee830d 100644
--- a/src/TextToSpeech/Vocoders/ISTFTNet.cs
+++ b/src/TextToSpeech/Vocoders/ISTFTNet.cs
@@ -40,7 +40,7 @@ namespace AiDotNet.TextToSpeech.Vocoders;
     Year = 2022,
     Authors = "Kaneko et al."
 )]
-public class ISTFTNet<T> : VocoderBase<T>
+public partial class ISTFTNet<T> : VocoderBase<T>
 {
     private readonly ISTFTNetOptions _options;
 
@@ -199,43 +199,9 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.MelChannels);
-        writer.Write(_options.HopSize);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.NumUpsampleLayers);
-        writer.Write(_options.StftWindow);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.MelChannels = reader.ReadInt32();
-        _options.HopSize = reader.ReadInt32();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.NumUpsampleLayers = reader.ReadInt32();
-        _options.StftWindow = reader.ReadInt32();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new ISTFTNet<T>(Architecture, mp, _options);
-        return new ISTFTNet<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/TextToSpeech/Vocoders/MelGAN.cs b/src/TextToSpeech/Vocoders/MelGAN.cs
index b2b480d92b..ee4a0513d2 100644
--- a/src/TextToSpeech/Vocoders/MelGAN.cs
+++ b/src/TextToSpeech/Vocoders/MelGAN.cs
@@ -40,7 +40,7 @@ namespace AiDotNet.TextToSpeech.Vocoders;
     Year = 2019,
     Authors = "Kumar et al."
 )]
-public class MelGAN<T> : VocoderBase<T>
+public partial class MelGAN<T> : VocoderBase<T>
 {
     private readonly MelGANOptions _options;
 
@@ -189,43 +189,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.MelChannels);
-        writer.Write(_options.HopSize);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.NgfBase);
-        writer.Write(_options.NumResStacks);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.MelChannels = reader.ReadInt32();
-        _options.HopSize = reader.ReadInt32();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.NgfBase = reader.ReadInt32();
-        _options.NumResStacks = reader.ReadInt32();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new MelGAN<T>(Architecture, mp, _options);
-        return new MelGAN<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/TextToSpeech/Vocoders/MultiBandMelGAN.cs b/src/TextToSpeech/Vocoders/MultiBandMelGAN.cs
index 5b3f88f4d2..629c3968a3 100644
--- a/src/TextToSpeech/Vocoders/MultiBandMelGAN.cs
+++ b/src/TextToSpeech/Vocoders/MultiBandMelGAN.cs
@@ -40,7 +40,7 @@ namespace AiDotNet.TextToSpeech.Vocoders;
     Year = 2021,
     Authors = "Yang et al."
 )]
-public class MultiBandMelGAN<T> : VocoderBase<T>
+public partial class MultiBandMelGAN<T> : VocoderBase<T>
 {
     private readonly MultiBandMelGANOptions _options;
 
@@ -179,41 +179,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.MelChannels);
-        writer.Write(_options.HopSize);
-        writer.Write(_options.NumBands);
-        writer.Write(_options.DropoutRate);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.MelChannels = reader.ReadInt32();
-        _options.HopSize = reader.ReadInt32();
-        _options.NumBands = reader.ReadInt32();
-        _options.DropoutRate = reader.ReadDouble();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new MultiBandMelGAN<T>(Architecture, mp, _options);
-        return new MultiBandMelGAN<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/TextToSpeech/Vocoders/ParallelWaveGAN.cs b/src/TextToSpeech/Vocoders/ParallelWaveGAN.cs
index 5f040e7da7..9cbb66d686 100644
--- a/src/TextToSpeech/Vocoders/ParallelWaveGAN.cs
+++ b/src/TextToSpeech/Vocoders/ParallelWaveGAN.cs
@@ -40,7 +40,7 @@ namespace AiDotNet.TextToSpeech.Vocoders;
     Year = 2020,
     Authors = "Yamamoto et al."
 )]
-public class ParallelWaveGAN<T> : VocoderBase<T>
+public partial class ParallelWaveGAN<T> : VocoderBase<T>
 {
     private readonly ParallelWaveGANOptions _options;
 
@@ -178,43 +178,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.MelChannels);
-        writer.Write(_options.HopSize);
-        writer.Write(_options.NumResBlocks);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.ResChannels);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.MelChannels = reader.ReadInt32();
-        _options.HopSize = reader.ReadInt32();
-        _options.NumResBlocks = reader.ReadInt32();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.ResChannels = reader.ReadInt32();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new ParallelWaveGAN<T>(Architecture, mp, _options);
-        return new ParallelWaveGAN<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/TextToSpeech/Vocoders/PriorGrad.cs b/src/TextToSpeech/Vocoders/PriorGrad.cs
index 47fc7d90fd..3d8977e7f5 100644
--- a/src/TextToSpeech/Vocoders/PriorGrad.cs
+++ b/src/TextToSpeech/Vocoders/PriorGrad.cs
@@ -40,7 +40,7 @@ namespace AiDotNet.TextToSpeech.Vocoders;
     Year = 2022,
     Authors = "Lee et al."
 )]
-public class PriorGrad<T> : VocoderBase<T>
+public partial class PriorGrad<T> : VocoderBase<T>
 {
     private readonly PriorGradOptions _options;
 
@@ -228,79 +228,9 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.MelChannels);
-        writer.Write(_options.HopSize);
-        writer.Write(_options.NumDiffusionSteps);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.NumResBlocks);
-        writer.Write(_options.HiddenDim);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.LearningRate);
-        writer.Write(_options.WeightDecay);
-        writer.Write(_options.OptimizerBatchSize);
-        writer.Write(_options.OptimizerBeta1);
-        writer.Write(_options.OptimizerBeta2);
-        writer.Write(_options.OptimizerEpsilon);
-        writer.Write(_options.MaxGradientNorm);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.MelChannels = reader.ReadInt32();
-        _options.HopSize = reader.ReadInt32();
-        _options.NumDiffusionSteps = reader.ReadInt32();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.NumResBlocks = reader.ReadInt32();
-        // These architecture/optimizer fields were appended so model files written by older
-        // releases (whose payload ended after NumResBlocks) remain readable.
-        const int configurablePayloadBytes = (6 * sizeof(double)) + (3 * sizeof(int));
-        if (reader.BaseStream.Length - reader.BaseStream.Position >= configurablePayloadBytes)
-        {
-            _options.HiddenDim = reader.ReadInt32();
-            _options.NumHeads = reader.ReadInt32();
-            _options.LearningRate = reader.ReadDouble();
-            _options.WeightDecay = reader.ReadDouble();
-            _options.OptimizerBatchSize = reader.ReadInt32();
-            _options.OptimizerBeta1 = reader.ReadDouble();
-            _options.OptimizerBeta2 = reader.ReadDouble();
-            _options.OptimizerEpsilon = reader.ReadDouble();
-            _options.MaxGradientNorm = reader.ReadDouble();
-            MaxGradNorm = NumOps.FromDouble(_options.MaxGradientNorm);
-        }
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        if (_useNativeMode && !_preserveSuppliedOptimizer)
-            _optimizer = CreateDefaultOptimizer();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new PriorGrad<T>(Architecture, mp, new PriorGradOptions(_options));
 
-        IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? cloneOptimizer = _optimizer switch
-        {
-            AdamWOptimizer<T, Tensor<T>, Tensor<T>> when _optimizer.GetOptions() is AdamWOptimizerOptions<T, Tensor<T>, Tensor<T>> options
-                => new AdamWOptimizer<T, Tensor<T>, Tensor<T>>(null, new AdamWOptimizerOptions<T, Tensor<T>, Tensor<T>>(options)),
-            AdamOptimizer<T, Tensor<T>, Tensor<T>> when _optimizer.GetOptions() is AdamOptimizerOptions<T, Tensor<T>, Tensor<T>> options
-                => new AdamOptimizer<T, Tensor<T>, Tensor<T>>(null, new AdamOptimizerOptions<T, Tensor<T>, Tensor<T>>(options)),
-            _ => null
-        };
-        return new PriorGrad<T>(Architecture, new PriorGradOptions(_options), cloneOptimizer);
-    }
 
     private IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>> CreateDefaultOptimizer()
     {
diff --git a/src/TextToSpeech/Vocoders/UnivNet.cs b/src/TextToSpeech/Vocoders/UnivNet.cs
index 8c08640291..0c58581e53 100644
--- a/src/TextToSpeech/Vocoders/UnivNet.cs
+++ b/src/TextToSpeech/Vocoders/UnivNet.cs
@@ -41,7 +41,7 @@ namespace AiDotNet.TextToSpeech.Vocoders;
     Year = 2021,
     Authors = "Jang et al."
 )]
-public class UnivNet<T> : VocoderBase<T>
+public partial class UnivNet<T> : VocoderBase<T>
 {
     private readonly UnivNetOptions _options;
 
@@ -200,41 +200,9 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.MelChannels);
-        writer.Write(_options.HopSize);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.NumLMBlocks);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.MelChannels = reader.ReadInt32();
-        _options.HopSize = reader.ReadInt32();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.NumLMBlocks = reader.ReadInt32();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new UnivNet<T>(Architecture, mp, _options);
-        return new UnivNet<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/TextToSpeech/Vocoders/Vocos.cs b/src/TextToSpeech/Vocoders/Vocos.cs
index b379f8aefa..9d2ac3b396 100644
--- a/src/TextToSpeech/Vocoders/Vocos.cs
+++ b/src/TextToSpeech/Vocoders/Vocos.cs
@@ -40,7 +40,7 @@ namespace AiDotNet.TextToSpeech.Vocoders;
     Year = 2023,
     Authors = "Siuzdak"
 )]
-public class Vocos<T> : VocoderBase<T>
+public partial class Vocos<T> : VocoderBase<T>
 {
     private readonly VocosOptions _options;
 
@@ -182,47 +182,9 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.MelChannels);
-        writer.Write(_options.HopSize);
-        writer.Write(_options.FftSize);
-        writer.Write(_options.ConvNeXtDim);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.NumBackboneBlocks);
-        writer.Write(_options.IntermediateDim);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.MelChannels = reader.ReadInt32();
-        _options.HopSize = reader.ReadInt32();
-        _options.FftSize = reader.ReadInt32();
-        _options.ConvNeXtDim = reader.ReadInt32();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.NumBackboneBlocks = reader.ReadInt32();
-        _options.IntermediateDim = reader.ReadInt32();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new Vocos<T>(Architecture, mp, new VocosOptions(_options));
-        return new Vocos<T>(Architecture, new VocosOptions(_options));
-    }
+
 
     private Tensor<T> ForwardNative(Tensor<T> input)
     {
diff --git a/src/TextToSpeech/Vocoders/WaveGlow.cs b/src/TextToSpeech/Vocoders/WaveGlow.cs
index a481a7ae57..34c657ecf3 100644
--- a/src/TextToSpeech/Vocoders/WaveGlow.cs
+++ b/src/TextToSpeech/Vocoders/WaveGlow.cs
@@ -40,7 +40,7 @@ namespace AiDotNet.TextToSpeech.Vocoders;
     Year = 2019,
     Authors = "Prenger et al."
 )]
-public class WaveGlow<T> : VocoderBase<T>
+public partial class WaveGlow<T> : VocoderBase<T>
 {
     private readonly WaveGlowOptions _options;
 
@@ -196,45 +196,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.MelChannels);
-        writer.Write(_options.HopSize);
-        writer.Write(_options.NumFlows);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.NumWaveNetLayers);
-        writer.Write(_options.UpsampleInitialChannels);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.MelChannels = reader.ReadInt32();
-        _options.HopSize = reader.ReadInt32();
-        _options.NumFlows = reader.ReadInt32();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.NumWaveNetLayers = reader.ReadInt32();
-        _options.UpsampleInitialChannels = reader.ReadInt32();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new WaveGlow<T>(Architecture, mp, _options);
-        return new WaveGlow<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/TextToSpeech/Vocoders/WaveGrad.cs b/src/TextToSpeech/Vocoders/WaveGrad.cs
index 57ed2caa92..ec5aeef97e 100644
--- a/src/TextToSpeech/Vocoders/WaveGrad.cs
+++ b/src/TextToSpeech/Vocoders/WaveGrad.cs
@@ -41,7 +41,7 @@ namespace AiDotNet.TextToSpeech.Vocoders;
     Year = 2021,
     Authors = "Chen et al."
 )]
-public class WaveGrad<T> : VocoderBase<T>
+public partial class WaveGrad<T> : VocoderBase<T>
 {
     private readonly WaveGradOptions _options;
 
@@ -236,43 +236,9 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.MelChannels);
-        writer.Write(_options.HopSize);
-        writer.Write(_options.NumDiffusionSteps);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.NumDownsampleBlocks);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.MelChannels = reader.ReadInt32();
-        _options.HopSize = reader.ReadInt32();
-        _options.NumDiffusionSteps = reader.ReadInt32();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.NumDownsampleBlocks = reader.ReadInt32();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new WaveGrad<T>(Architecture, mp, _options);
-        return new WaveGrad<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/TextToSpeech/Vocoders/WaveNet.cs b/src/TextToSpeech/Vocoders/WaveNet.cs
index 1424fec89c..389fd6b959 100644
--- a/src/TextToSpeech/Vocoders/WaveNet.cs
+++ b/src/TextToSpeech/Vocoders/WaveNet.cs
@@ -44,7 +44,7 @@ namespace AiDotNet.TextToSpeech.Vocoders;
     Year = 2016,
     Authors = "van den Oord et al."
 )]
-public class WaveNet<T> : VocoderBase<T>
+public partial class WaveNet<T> : VocoderBase<T>
 {
     private readonly WaveNetOptions _options;
 
@@ -209,43 +209,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.MelChannels);
-        writer.Write(_options.HopSize);
-        writer.Write(_options.NumDilatedLayers);
-        writer.Write(_options.ResidualChannels);
-        writer.Write(_options.DropoutRate);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.MelChannels = reader.ReadInt32();
-        _options.HopSize = reader.ReadInt32();
-        _options.NumDilatedLayers = reader.ReadInt32();
-        _options.ResidualChannels = reader.ReadInt32();
-        _options.DropoutRate = reader.ReadDouble();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new WaveNet<T>(Architecture, mp, _options);
-        return new WaveNet<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/TextToSpeech/Vocoders/WaveRNN.cs b/src/TextToSpeech/Vocoders/WaveRNN.cs
index ae8c1d3627..9dba6d2c5f 100644
--- a/src/TextToSpeech/Vocoders/WaveRNN.cs
+++ b/src/TextToSpeech/Vocoders/WaveRNN.cs
@@ -40,7 +40,7 @@ namespace AiDotNet.TextToSpeech.Vocoders;
     Year = 2018,
     Authors = "Kalchbrenner et al."
 )]
-public class WaveRNN<T> : VocoderBase<T>
+public partial class WaveRNN<T> : VocoderBase<T>
 {
     private readonly WaveRNNOptions _options;
 
@@ -190,41 +190,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.MelChannels);
-        writer.Write(_options.HopSize);
-        writer.Write(_options.RnnDim);
-        writer.Write(_options.DropoutRate);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.MelChannels = reader.ReadInt32();
-        _options.HopSize = reader.ReadInt32();
-        _options.RnnDim = reader.ReadInt32();
-        _options.DropoutRate = reader.ReadDouble();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new WaveRNN<T>(Architecture, mp, _options);
-        return new WaveRNN<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/TextToSpeech/VoiceCloning/Chatterbox.cs b/src/TextToSpeech/VoiceCloning/Chatterbox.cs
index 033e5f88a5..c08aa35294 100644
--- a/src/TextToSpeech/VoiceCloning/Chatterbox.cs
+++ b/src/TextToSpeech/VoiceCloning/Chatterbox.cs
@@ -38,7 +38,7 @@ namespace AiDotNet.TextToSpeech.VoiceCloning;
     "Chatterbox: Open-Source Voice Cloning",
     "https://github.com/resemble-ai/Chatterbox"
 )]
-public class Chatterbox<T> : TtsModelBase<T>, ICodecTts<T>
+public partial class Chatterbox<T> : TtsModelBase<T>, ICodecTts<T>
 {
     private readonly ChatterboxOptions _options;
 
@@ -254,55 +254,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.MelChannels);
-        writer.Write(_options.HopSize);
-        writer.Write(_options.NumCodebooks);
-        writer.Write(_options.LLMDim);
-        writer.Write(_options.CodebookSize);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.NumEncoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.NumLLMLayers);
-        writer.Write(_options.TextEncoderDim);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.MelChannels = reader.ReadInt32();
-        _options.HopSize = reader.ReadInt32();
-        _options.NumCodebooks = reader.ReadInt32();
-        _options.LLMDim = reader.ReadInt32();
-        _options.CodebookSize = reader.ReadInt32();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.NumEncoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.NumLLMLayers = reader.ReadInt32();
-        _options.TextEncoderDim = reader.ReadInt32();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        base.HiddenDim = _options.LLMDim;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var cloneOptions = new ChatterboxOptions(_options);
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new Chatterbox<T>(Architecture, mp, cloneOptions);
-        return new Chatterbox<T>(Architecture, cloneOptions);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/TextToSpeech/VoiceCloning/CosyVoiceClone.cs b/src/TextToSpeech/VoiceCloning/CosyVoiceClone.cs
index f75774385a..485c0ebae8 100644
--- a/src/TextToSpeech/VoiceCloning/CosyVoiceClone.cs
+++ b/src/TextToSpeech/VoiceCloning/CosyVoiceClone.cs
@@ -40,7 +40,7 @@ namespace AiDotNet.TextToSpeech.VoiceCloning;
     Year = 2024,
     Authors = "Du et al."
 )]
-public class CosyVoiceClone<T> : TtsModelBase<T>, ICodecTts<T>, IVoiceCloner<T>
+public partial class CosyVoiceClone<T> : TtsModelBase<T>, ICodecTts<T>, IVoiceCloner<T>
 {
     private readonly CosyVoiceCloneOptions _options;
 
@@ -304,57 +304,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.MelChannels);
-        writer.Write(_options.HopSize);
-        writer.Write(_options.NumCodebooks);
-        writer.Write(_options.LLMDim);
-        writer.Write(_options.SpeakerEmbeddingDim);
-        writer.Write(_options.CodebookSize);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.NumEncoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.NumLLMLayers);
-        writer.Write(_options.TextEncoderDim);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.MelChannels = reader.ReadInt32();
-        _options.HopSize = reader.ReadInt32();
-        _options.NumCodebooks = reader.ReadInt32();
-        _options.LLMDim = reader.ReadInt32();
-        _options.SpeakerEmbeddingDim = reader.ReadInt32();
-        _options.CodebookSize = reader.ReadInt32();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.NumEncoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.NumLLMLayers = reader.ReadInt32();
-        _options.TextEncoderDim = reader.ReadInt32();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        base.HiddenDim = _options.LLMDim;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var options = new CosyVoiceCloneOptions(_options);
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new CosyVoiceClone<T>(Architecture, mp, options);
-        return new CosyVoiceClone<T>(Architecture, options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/TextToSpeech/VoiceCloning/MetaVoice1B.cs b/src/TextToSpeech/VoiceCloning/MetaVoice1B.cs
index 1f17366788..43a9be266a 100644
--- a/src/TextToSpeech/VoiceCloning/MetaVoice1B.cs
+++ b/src/TextToSpeech/VoiceCloning/MetaVoice1B.cs
@@ -38,7 +38,7 @@ namespace AiDotNet.TextToSpeech.VoiceCloning;
     "MetaVoice-1B: 1.2B Parameter Voice Cloning Model",
     "https://github.com/metavoiceio/metavoice-src"
 )]
-public class MetaVoice1B<T> : TtsModelBase<T>, IEndToEndTts<T>, IVoiceCloner<T>
+public partial class MetaVoice1B<T> : TtsModelBase<T>, IEndToEndTts<T>, IVoiceCloner<T>
 {
     private readonly MetaVoice1BOptions _options;
 
@@ -260,74 +260,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.MelChannels);
-        writer.Write(_options.HopSize);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.EncoderDim);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumEncoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.SpeakerEmbeddingDim);
-        writer.Write(_options.FirstStageDim);
-        writer.Write(_options.NumFirstStageLayers);
-        writer.Write(_options.SecondStageDim);
-        writer.Write(_options.NumSecondStageLayers);
-        writer.Write(_options.NumCodebooks);
-        writer.Write(_options.FirstStageCodebooks);
-        writer.Write(_options.CodecLatentDim);
-        writer.Write(_options.VocoderChannels);
-        writer.Write(_options.VocoderUpsampleFactor);
-        writer.Write(_options.SwiGLUMultipleOf);
-        writer.Write(_options.RoPETheta);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.MelChannels = reader.ReadInt32();
-        _options.HopSize = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.EncoderDim = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumEncoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.SpeakerEmbeddingDim = reader.ReadInt32();
-        _options.FirstStageDim = reader.ReadInt32();
-        _options.NumFirstStageLayers = reader.ReadInt32();
-        _options.SecondStageDim = reader.ReadInt32();
-        _options.NumSecondStageLayers = reader.ReadInt32();
-        _options.NumCodebooks = reader.ReadInt32();
-        _options.FirstStageCodebooks = reader.ReadInt32();
-        _options.CodecLatentDim = reader.ReadInt32();
-        _options.VocoderChannels = reader.ReadInt32();
-        _options.VocoderUpsampleFactor = reader.ReadInt32();
-        _options.SwiGLUMultipleOf = reader.ReadInt32();
-        _options.RoPETheta = reader.ReadDouble();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        base.HiddenDim = _options.HiddenDim;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new MetaVoice1B<T>(Architecture, mp, _options);
-        return new MetaVoice1B<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/TextToSpeech/VoiceCloning/OpenVoice.cs b/src/TextToSpeech/VoiceCloning/OpenVoice.cs
index e8d207e869..0d6917a39d 100644
--- a/src/TextToSpeech/VoiceCloning/OpenVoice.cs
+++ b/src/TextToSpeech/VoiceCloning/OpenVoice.cs
@@ -40,7 +40,7 @@ namespace AiDotNet.TextToSpeech.VoiceCloning;
     Year = 2023,
     Authors = "Qin et al."
 )]
-public class OpenVoice<T> : TtsModelBase<T>, IEndToEndTts<T>, IVoiceCloner<T>
+public partial class OpenVoice<T> : TtsModelBase<T>, IEndToEndTts<T>, IVoiceCloner<T>
 {
     private readonly OpenVoiceOptions _options;
 
@@ -241,52 +241,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.MelChannels);
-        writer.Write(_options.HopSize);
-        writer.Write(_options.HiddenDim);
-        writer.Write(_options.SpeakerEmbeddingDim);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumEncoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.NumToneColorLayers);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.MelChannels = reader.ReadInt32();
-        _options.HopSize = reader.ReadInt32();
-        _options.HiddenDim = reader.ReadInt32();
-        _options.SpeakerEmbeddingDim = reader.ReadInt32();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumEncoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.NumToneColorLayers = reader.ReadInt32();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        base.HiddenDim = _options.HiddenDim;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new OpenVoice<T>(Architecture, mp, _options);
-        return new OpenVoice<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/TextToSpeech/VoiceCloning/OpenVoiceV2.cs b/src/TextToSpeech/VoiceCloning/OpenVoiceV2.cs
index 940550b8e6..ca03a2270a 100644
--- a/src/TextToSpeech/VoiceCloning/OpenVoiceV2.cs
+++ b/src/TextToSpeech/VoiceCloning/OpenVoiceV2.cs
@@ -40,7 +40,7 @@ namespace AiDotNet.TextToSpeech.VoiceCloning;
     Year = 2024,
     Authors = "Qin et al."
 )]
-public class OpenVoiceV2<T> : TtsModelBase<T>, IEndToEndTts<T>, IVoiceCloner<T>
+public partial class OpenVoiceV2<T> : TtsModelBase<T>, IEndToEndTts<T>, IVoiceCloner<T>
 {
     private readonly OpenVoiceV2Options _options;
 
@@ -279,52 +279,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.MelChannels);
-        writer.Write(_options.HopSize);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.EncoderDim);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumEncoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.SpeakerEmbeddingDim);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.MelChannels = reader.ReadInt32();
-        _options.HopSize = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.EncoderDim = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumEncoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.SpeakerEmbeddingDim = reader.ReadInt32();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        base.HiddenDim = _options.HiddenDim;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new OpenVoiceV2<T>(Architecture, mp, new OpenVoiceV2Options(_options));
-        return new OpenVoiceV2<T>(Architecture, new OpenVoiceV2Options(_options));
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/TextToSpeech/VoiceCloning/SeedTTSClone.cs b/src/TextToSpeech/VoiceCloning/SeedTTSClone.cs
index 97eb851bba..8d9c1e87d2 100644
--- a/src/TextToSpeech/VoiceCloning/SeedTTSClone.cs
+++ b/src/TextToSpeech/VoiceCloning/SeedTTSClone.cs
@@ -40,7 +40,7 @@ namespace AiDotNet.TextToSpeech.VoiceCloning;
     Year = 2024,
     Authors = "Anastassiou et al."
 )]
-public class SeedTTSClone<T> : TtsModelBase<T>, ICodecTts<T>, IVoiceCloner<T>
+public partial class SeedTTSClone<T> : TtsModelBase<T>, ICodecTts<T>, IVoiceCloner<T>
 {
     private readonly SeedTTSCloneOptions _options;
 
@@ -302,54 +302,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.MelChannels);
-        writer.Write(_options.HopSize);
-        writer.Write(_options.NumCodebooks);
-        writer.Write(_options.LLMDim);
-        writer.Write(_options.SpeakerEmbeddingDim);
-        writer.Write(_options.CodebookSize);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.NumEncoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.NumLLMLayers);
-        writer.Write(_options.TextEncoderDim);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.NumCodebooks = reader.ReadInt32();
-        _options.LLMDim = reader.ReadInt32();
-        _options.SpeakerEmbeddingDim = reader.ReadInt32();
-        _options.CodebookSize = reader.ReadInt32();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.NumEncoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.NumLLMLayers = reader.ReadInt32();
-        _options.TextEncoderDim = reader.ReadInt32();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        base.HiddenDim = _options.LLMDim;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new SeedTTSClone<T>(Architecture, mp, _options);
-        return new SeedTTSClone<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/TextToSpeech/VoiceCloning/VALLEXClone.cs b/src/TextToSpeech/VoiceCloning/VALLEXClone.cs
index 3031a88698..85eb79d3b6 100644
--- a/src/TextToSpeech/VoiceCloning/VALLEXClone.cs
+++ b/src/TextToSpeech/VoiceCloning/VALLEXClone.cs
@@ -40,7 +40,7 @@ namespace AiDotNet.TextToSpeech.VoiceCloning;
     Year = 2023,
     Authors = "Zhang et al."
 )]
-public class VALLEXClone<T> : TtsModelBase<T>, ICodecTts<T>, IVoiceCloner<T>
+public partial class VALLEXClone<T> : TtsModelBase<T>, ICodecTts<T>, IVoiceCloner<T>
 {
     private readonly VALLEXCloneOptions _options;
 
@@ -318,52 +318,9 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.NumCodebooks);
-        writer.Write(_options.LLMDim);
-        writer.Write(_options.SpeakerEmbeddingDim);
-        writer.Write(_options.CodebookSize);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.NumEncoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.NumLLMLayers);
-        writer.Write(_options.TextEncoderDim);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.NumCodebooks = reader.ReadInt32();
-        _options.LLMDim = reader.ReadInt32();
-        _options.SpeakerEmbeddingDim = reader.ReadInt32();
-        _options.CodebookSize = reader.ReadInt32();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.NumEncoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.NumLLMLayers = reader.ReadInt32();
-        _options.TextEncoderDim = reader.ReadInt32();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        base.HiddenDim = _options.LLMDim;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new VALLEXClone<T>(Architecture, mp, _options);
-        return new VALLEXClone<T>(Architecture, _options);
-    }
+
 
     private AdamWOptimizer<T, Tensor<T>, Tensor<T>> CreateDefaultOptimizer() =>
         new(
diff --git a/src/TextToSpeech/VoiceCloning/XTTSv2.cs b/src/TextToSpeech/VoiceCloning/XTTSv2.cs
index 88e030bf0d..c4bcd8fc3f 100644
--- a/src/TextToSpeech/VoiceCloning/XTTSv2.cs
+++ b/src/TextToSpeech/VoiceCloning/XTTSv2.cs
@@ -35,7 +35,7 @@ namespace AiDotNet.TextToSpeech.VoiceCloning;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("XTTS: Massively Multilingual Text-to-Speech", "https://arxiv.org/abs/2406.04904")]
-public class XTTSv2<T> : TtsModelBase<T>, ICodecTts<T>
+public partial class XTTSv2<T> : TtsModelBase<T>, ICodecTts<T>
 {
     private readonly XTTSv2Options _options;
 
@@ -251,50 +251,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.NumCodebooks);
-        writer.Write(_options.LLMDim);
-        writer.Write(_options.CodebookSize);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.NumEncoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.NumLLMLayers);
-        writer.Write(_options.TextEncoderDim);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.NumCodebooks = reader.ReadInt32();
-        _options.LLMDim = reader.ReadInt32();
-        _options.CodebookSize = reader.ReadInt32();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.NumEncoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.NumLLMLayers = reader.ReadInt32();
-        _options.TextEncoderDim = reader.ReadInt32();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        base.HiddenDim = _options.LLMDim;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new XTTSv2<T>(Architecture, mp, new XTTSv2Options(_options));
-        return new XTTSv2<T>(Architecture, new XTTSv2Options(_options));
-    }
+
 
     private AdamWOptimizer<T, Tensor<T>, Tensor<T>> CreateDefaultOptimizer() =>
         new(
diff --git a/src/TextToSpeech/VoiceCloning/XTTSv2Clone.cs b/src/TextToSpeech/VoiceCloning/XTTSv2Clone.cs
index d35b2c3d0c..d1d37db93e 100644
--- a/src/TextToSpeech/VoiceCloning/XTTSv2Clone.cs
+++ b/src/TextToSpeech/VoiceCloning/XTTSv2Clone.cs
@@ -35,7 +35,7 @@ namespace AiDotNet.TextToSpeech.VoiceCloning;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("XTTS: Massively Multilingual Text-to-Speech", "https://arxiv.org/abs/2406.04904")]
-public class XTTSv2Clone<T> : TtsModelBase<T>, ICodecTts<T>, IVoiceCloner<T>
+public partial class XTTSv2Clone<T> : TtsModelBase<T>, ICodecTts<T>, IVoiceCloner<T>
 {
     private readonly XTTSv2CloneOptions _options;
 
@@ -305,52 +305,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.SampleRate);
-        writer.Write(_options.NumCodebooks);
-        writer.Write(_options.LLMDim);
-        writer.Write(_options.SpeakerEmbeddingDim);
-        writer.Write(_options.CodebookSize);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.NumEncoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.NumLLMLayers);
-        writer.Write(_options.TextEncoderDim);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.SampleRate = reader.ReadInt32();
-        _options.NumCodebooks = reader.ReadInt32();
-        _options.LLMDim = reader.ReadInt32();
-        _options.SpeakerEmbeddingDim = reader.ReadInt32();
-        _options.CodebookSize = reader.ReadInt32();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.NumEncoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.NumLLMLayers = reader.ReadInt32();
-        _options.TextEncoderDim = reader.ReadInt32();
-        base.SampleRate = _options.SampleRate;
-        base.MelChannels = _options.MelChannels;
-        base.HopSize = _options.HopSize;
-        base.HiddenDim = _options.LLMDim;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new XTTSv2Clone<T>(Architecture, mp, new XTTSv2CloneOptions(_options));
-        return new XTTSv2Clone<T>(Architecture, new XTTSv2CloneOptions(_options));
-    }
+
 
     private AdamWOptimizer<T, Tensor<T>, Tensor<T>> CreateDefaultOptimizer() =>
         new(
diff --git a/src/TimeSeries/ARIMAModel.cs b/src/TimeSeries/ARIMAModel.cs
index d376ca25e8..82e1e55fbe 100644
--- a/src/TimeSeries/ARIMAModel.cs
+++ b/src/TimeSeries/ARIMAModel.cs
@@ -68,6 +68,7 @@ public partial class ARIMAModel<T> : TimeSeriesModelBase<T>
     /// For example, if the coefficient for yesterday's value is 0.7, it means yesterday's
     /// value has a strong influence on today's prediction.</para>
     /// </remarks>
+    [AiDotNet.Attributes.FittedParameter]
     private Vector<T> _arCoefficients;
 
     /// <summary>
@@ -79,6 +80,7 @@ public partial class ARIMAModel<T> : TimeSeriesModelBase<T>
     /// They help the model learn from its mistakes. For example, if the model consistently
     /// underpredicts, these coefficients help correct that bias.</para>
     /// </remarks>
+    [AiDotNet.Attributes.FittedParameter]
     private Vector<T> _maCoefficients;
 
     /// <summary>
@@ -349,44 +351,7 @@ public override Dictionary<string, T> EvaluateModel(Matrix<T> xTest, Vector<T> y
     /// <para>The method saves all the essential parameters: the p, d, q values,
     /// the constant term, and the AR and MA coefficients.</para>
     /// </remarks>
-    protected override void SerializeCore(BinaryWriter writer)
-    {
-        // Write ARIMA-specific options
-        writer.Write(_arimaOptions.P);
-        writer.Write(_arimaOptions.D);
-        writer.Write(_arimaOptions.Q);
-
-        // Write constant
-        writer.Write(Convert.ToDouble(_constant));
 
-        // Write AR coefficients
-        writer.Write(_arCoefficients.Length);
-        for (int i = 0; i < _arCoefficients.Length; i++)
-        {
-            writer.Write(Convert.ToDouble(_arCoefficients[i]));
-        }
-
-        // Write MA coefficients
-        writer.Write(_maCoefficients.Length);
-        for (int i = 0; i < _maCoefficients.Length; i++)
-        {
-            writer.Write(Convert.ToDouble(_maCoefficients[i]));
-        }
-
-        // Write training state needed for prediction initialization
-        writer.Write(_lastTrainDiffValues.Length);
-        for (int i = 0; i < _lastTrainDiffValues.Length; i++)
-            writer.Write(Convert.ToDouble(_lastTrainDiffValues[i]));
-
-        writer.Write(_lastTrainResiduals.Length);
-        for (int i = 0; i < _lastTrainResiduals.Length; i++)
-            writer.Write(Convert.ToDouble(_lastTrainResiduals[i]));
-
-        // Write original training series for in-sample Predict(Matrix) support
-        writer.Write(_trainingSeries.Length);
-        for (int i = 0; i < _trainingSeries.Length; i++)
-            writer.Write(Convert.ToDouble(_trainingSeries[i]));
-    }
 
     /// <summary>
     /// Deserializes the model's state from a binary stream.
@@ -404,74 +369,7 @@ protected override void SerializeCore(BinaryWriter writer)
     /// <para>The method loads all the parameters that were saved during serialization:
     /// the p, d, q values, the constant term, and the AR and MA coefficients.</para>
     /// </remarks>
-    protected override void DeserializeCore(BinaryReader reader)
-    {
-        // Read ARIMA-specific options
-        int p = reader.ReadInt32();
-        int d = reader.ReadInt32();
-        int q = reader.ReadInt32();
-        _arimaOptions = new ARIMAOptions<T>
-        {
-            P = p,
-            D = d,
-            Q = q
-        };
-
-        // Read constant
-        _constant = NumOps.FromDouble(reader.ReadDouble());
 
-        // Read AR coefficients
-        int arLength = reader.ReadInt32();
-        _arCoefficients = new Vector<T>(arLength);
-        for (int i = 0; i < arLength; i++)
-        {
-            _arCoefficients[i] = NumOps.FromDouble(reader.ReadDouble());
-        }
-
-        // Read MA coefficients
-        int maLength = reader.ReadInt32();
-        _maCoefficients = new Vector<T>(maLength);
-        for (int i = 0; i < maLength; i++)
-        {
-            _maCoefficients[i] = NumOps.FromDouble(reader.ReadDouble());
-        }
-
-        // Read training state for prediction initialization.
-        // These fields were added post-patch; older serialized models won't have them.
-        try
-        {
-            int diffLen = reader.ReadInt32();
-            _lastTrainDiffValues = new Vector<T>(diffLen);
-            for (int i = 0; i < diffLen; i++)
-                _lastTrainDiffValues[i] = NumOps.FromDouble(reader.ReadDouble());
-
-            int residLen = reader.ReadInt32();
-            _lastTrainResiduals = new Vector<T>(residLen);
-            for (int i = 0; i < residLen; i++)
-                _lastTrainResiduals[i] = NumOps.FromDouble(reader.ReadDouble());
-        }
-        catch (EndOfStreamException)
-        {
-            // Pre-patch model — initialize with empty vectors.
-            // Predictions will still work but won't have historical context
-            // for the first few steps.
-            _lastTrainDiffValues ??= new Vector<T>(0);
-            _lastTrainResiduals ??= new Vector<T>(0);
-        }
-
-        // Read original training series (post-patch field)
-        try
-        {
-            int seriesLen = reader.ReadInt32();
-            _trainingSeries = new Vector<T>(seriesLen);
-            for (int i = 0; i < seriesLen; i++)
-                _trainingSeries[i] = NumOps.FromDouble(reader.ReadDouble());
-        }
-        catch (EndOfStreamException)
-        {
-            _trainingSeries = Vector<T>.Empty();
-        }
-    }
 
     /// <summary>
     /// Core implementation of the training logic for the ARIMA model.
diff --git a/src/TimeSeries/ARIMAXModel.cs b/src/TimeSeries/ARIMAXModel.cs
index 37e7985cf4..ac9d6c2231 100644
--- a/src/TimeSeries/ARIMAXModel.cs
+++ b/src/TimeSeries/ARIMAXModel.cs
@@ -77,6 +77,7 @@ public partial class ARIMAXModel<T> : TimeSeriesModelBase<T>, IExogenousForecast
     /// yesterday's value and the day before's value affect today's prediction.
     /// Larger coefficients mean stronger influence from that time period.
     /// </remarks>
+    [AiDotNet.Attributes.FittedParameter]
     private Vector<T> _arCoefficients;
 
     /// <summary>
@@ -89,6 +90,7 @@ public partial class ARIMAXModel<T> : TimeSeriesModelBase<T>, IExogenousForecast
     /// model learn to adjust future predictions upward. They help the model correct systematic
     /// errors in its forecasts.
     /// </remarks>
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T> _maCoefficients;
 
     /// <summary>
@@ -101,6 +103,7 @@ public partial class ARIMAXModel<T> : TimeSeriesModelBase<T>, IExogenousForecast
     /// its coefficient might be negative for a workplace attendance model (fewer people come to work on holidays)
     /// or positive for a retail sales model (more people shop on holidays).
     /// </remarks>
+    [AiDotNet.Attributes.FittedParameter]
     private Vector<T> _exogenousCoefficients;
 
     /// <summary>
@@ -540,28 +543,7 @@ public override Dictionary<string, T> EvaluateModel(Matrix<T> xTest, Vector<T> y
     /// exogenous coefficients, differencing information, intercept value, and
     /// model options. This allows the model to be fully reconstructed later.
     /// </remarks>
-    protected override void SerializeCore(BinaryWriter writer)
-    {
-        writer.Write(_arCoefficients.Length);
-        for (int i = 0; i < _arCoefficients.Length; i++)
-            writer.Write(Convert.ToDouble(_arCoefficients[i]));
-
-        writer.Write(_maCoefficients.Length);
-        for (int i = 0; i < _maCoefficients.Length; i++)
-            writer.Write(Convert.ToDouble(_maCoefficients[i]));
-
-        writer.Write(_exogenousCoefficients.Length);
-        for (int i = 0; i < _exogenousCoefficients.Length; i++)
-            writer.Write(Convert.ToDouble(_exogenousCoefficients[i]));
 
-        writer.Write(_differenced.Length);
-        for (int i = 0; i < _differenced.Length; i++)
-            writer.Write(Convert.ToDouble(_differenced[i]));
-
-        writer.Write(Convert.ToDouble(_intercept));
-
-        writer.Write(JsonConvert.SerializeObject(_arimaxOptions));
-    }
 
     /// <summary>
     /// Deserializes the model's state from a binary stream.
@@ -581,33 +563,7 @@ protected override void SerializeCore(BinaryWriter writer)
     /// intercept value, and model options. This fully reconstructs the model exactly
     /// as it was when saved.
     /// </remarks>
-    protected override void DeserializeCore(BinaryReader reader)
-    {
-        int arCoefficientsLength = reader.ReadInt32();
-        _arCoefficients = new Vector<T>(arCoefficientsLength);
-        for (int i = 0; i < arCoefficientsLength; i++)
-            _arCoefficients[i] = NumOps.FromDouble(reader.ReadDouble());
-
-        int maCoefficientsLength = reader.ReadInt32();
-        _maCoefficients = new Vector<T>(maCoefficientsLength);
-        for (int i = 0; i < maCoefficientsLength; i++)
-            _maCoefficients[i] = NumOps.FromDouble(reader.ReadDouble());
-
-        int exogenousCoefficientsLength = reader.ReadInt32();
-        _exogenousCoefficients = new Vector<T>(exogenousCoefficientsLength);
-        for (int i = 0; i < exogenousCoefficientsLength; i++)
-            _exogenousCoefficients[i] = NumOps.FromDouble(reader.ReadDouble());
-
-        int differencedLength = reader.ReadInt32();
-        _differenced = new Vector<T>(differencedLength);
-        for (int i = 0; i < differencedLength; i++)
-            _differenced[i] = NumOps.FromDouble(reader.ReadDouble());
-
-        _intercept = NumOps.FromDouble(reader.ReadDouble());
-
-        string optionsJson = reader.ReadString();
-        _arimaxOptions = JsonConvert.DeserializeObject<ARIMAXModelOptions<T>>(optionsJson) ?? new();
-    }
+
 
     /// <summary>
     /// Creates a new instance of the ARIMAX model.
@@ -873,63 +829,6 @@ public void Train(Tensor<T> input, Tensor<T> expectedOutput)
         Train(matrix, vector);
     }
 
-    /// <summary>
-    /// Creates a deep copy of the current model.
-    /// </summary>
-    /// <returns>A new instance of the ARIMAX model with the same state and parameters.</returns>
-    /// <remarks>
-    /// <para>
-    /// This method creates a complete copy of the model, including its configuration and trained parameters.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method creates an exact duplicate of your trained model.
-    /// 
-    /// Unlike CreateInstance(), which creates a blank model with the same settings,
-    /// Clone() creates a complete copy including:
-    /// - The model configuration (AR order, MA order, etc.)
-    /// - All trained coefficients (AR, MA, exogenous)
-    /// - Differencing information and intercept value
-    /// 
-    /// This is useful for:
-    /// - Creating a backup before experimenting with a model
-    /// - Using the same trained model in multiple scenarios
-    /// - Creating ensemble models that use variations of the same base model
-    /// </para>
-    /// </remarks>
-    public override IFullModel<T, Matrix<T>, Vector<T>> Clone()
-    {
-        var clone = (ARIMAXModel<T>)CreateInstance();
-
-        // Copy AR coefficients
-        for (int i = 0; i < _arCoefficients.Length; i++)
-        {
-            clone._arCoefficients[i] = _arCoefficients[i];
-        }
-
-        // Copy MA coefficients
-        for (int i = 0; i < _maCoefficients.Length; i++)
-        {
-            clone._maCoefficients[i] = _maCoefficients[i];
-        }
-
-        // Copy exogenous coefficients
-        for (int i = 0; i < _exogenousCoefficients.Length; i++)
-        {
-            clone._exogenousCoefficients[i] = _exogenousCoefficients[i];
-        }
-
-        // Copy differenced values
-        clone._differenced = new Vector<T>(_differenced.Length);
-        for (int i = 0; i < _differenced.Length; i++)
-        {
-            clone._differenced[i] = _differenced[i];
-        }
-
-        // Copy intercept
-        clone._intercept = _intercept;
-
-        return clone;
-    }
-
     /// <summary>
     /// Resets the model to its untrained state.
     /// </summary>
diff --git a/src/TimeSeries/ARMAModel.cs b/src/TimeSeries/ARMAModel.cs
index bebc15af34..d9ed39056e 100644
--- a/src/TimeSeries/ARMAModel.cs
+++ b/src/TimeSeries/ARMAModel.cs
@@ -74,6 +74,7 @@ public ARMAModel()
     /// 
     /// These values are determined during training to best fit your historical data.
     /// </remarks>
+    [AiDotNet.Attributes.FittedParameter]
     private Vector<T> _arCoefficients;
 
     /// <summary>
@@ -87,6 +88,7 @@ public ARMAModel()
     /// 
     /// These values are determined during training to best fit your historical data.
     /// </remarks>
+    [AiDotNet.Attributes.FittedParameter]
     private Vector<T> _maCoefficients;
 
     /// <summary>
@@ -510,35 +512,7 @@ public override Dictionary<string, T> EvaluateModel(Matrix<T> xTest, Vector<T> y
     /// 
     /// This allows the model to be fully reconstructed later.
     /// </remarks>
-    protected override void SerializeCore(BinaryWriter writer)
-    {
-        writer.Write(_arOrder);
-        writer.Write(_maOrder);
-        for (int i = 0; i < _arOrder; i++)
-        {
-            writer.Write(Convert.ToDouble(_arCoefficients[i]));
-        }
-        for (int i = 0; i < _maOrder; i++)
-        {
-            writer.Write(Convert.ToDouble(_maCoefficients[i]));
-        }
 
-        // Serialize training state for in-sample prediction support
-        writer.Write(_trainedSeries.Length);
-        for (int i = 0; i < _trainedSeries.Length; i++)
-        {
-            writer.Write(Convert.ToDouble(_trainedSeries[i]));
-        }
-
-        writer.Write(_trainedResiduals.Length);
-        for (int i = 0; i < _trainedResiduals.Length; i++)
-        {
-            writer.Write(Convert.ToDouble(_trainedResiduals[i]));
-        }
-
-        // Serialize series mean for centered prediction
-        writer.Write(Convert.ToDouble(_seriesMean));
-    }
 
     /// <summary>
     /// Deserializes the model's state from a binary stream.
@@ -560,54 +534,7 @@ protected override void SerializeCore(BinaryWriter writer)
     /// 
     /// After deserialization, the model is ready to make predictions as if it had just been trained.
     /// </remarks>
-    protected override void DeserializeCore(BinaryReader reader)
-    {
-        _arOrder = reader.ReadInt32();
-        _maOrder = reader.ReadInt32();
-        _arCoefficients = new Vector<T>(_arOrder);
-        _maCoefficients = new Vector<T>(_maOrder);
-        for (int i = 0; i < _arOrder; i++)
-        {
-            _arCoefficients[i] = NumOps.FromDouble(reader.ReadDouble());
-        }
-        for (int i = 0; i < _maOrder; i++)
-        {
-            _maCoefficients[i] = NumOps.FromDouble(reader.ReadDouble());
-        }
-
-        // Deserialize training state if available (backward-compatible)
-        _trainedSeries = Vector<T>.Empty();
-        _trainedResiduals = Vector<T>.Empty();
-        try
-        {
-            int seriesLength = reader.ReadInt32();
-            if (seriesLength > 0)
-            {
-                _trainedSeries = new Vector<T>(seriesLength);
-                for (int i = 0; i < seriesLength; i++)
-                {
-                    _trainedSeries[i] = NumOps.FromDouble(reader.ReadDouble());
-                }
-            }
 
-            int residualsLength = reader.ReadInt32();
-            if (residualsLength > 0)
-            {
-                _trainedResiduals = new Vector<T>(residualsLength);
-                for (int i = 0; i < residualsLength; i++)
-                {
-                    _trainedResiduals[i] = NumOps.FromDouble(reader.ReadDouble());
-                }
-            }
-
-            // Deserialize series mean
-            _seriesMean = NumOps.FromDouble(reader.ReadDouble());
-        }
-        catch (EndOfStreamException)
-        {
-            // Older serialized models don't include training state — leave empty
-        }
-    }
 
     /// <summary>
     /// Creates a new instance of the ARMA model with the same options.
@@ -809,77 +736,6 @@ public override string ToString()
         return sb.ToString();
     }
 
-    /// <summary>
-    /// Creates a deep copy of the current model.
-    /// </summary>
-    /// <returns>A new instance of the ARMA model with the same state and parameters.</returns>
-    /// <remarks>
-    /// <para>
-    /// This method creates a complete copy of the model, including its configuration and trained coefficients.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method creates an exact duplicate of your trained model.
-    /// 
-    /// Unlike CreateInstance(), which creates a blank model with the same settings,
-    /// Clone() creates a complete copy including:
-    /// - The model configuration (AR order, MA order, etc.)
-    /// - All trained coefficients and internal state
-    /// 
-    /// This is useful for:
-    /// - Creating a backup before experimenting with a model
-    /// - Using the same trained model in multiple scenarios
-    /// - Creating ensemble models that use variations of the same base model
-    /// 
-    /// Think of it like photocopying a completed notebook - you get all the written content
-    /// as well as the structure of the notebook itself.
-    /// </para>
-    /// </remarks>
-    public override IFullModel<T, Matrix<T>, Vector<T>> Clone()
-    {
-        var clone = new ARMAModel<T>((ARMAOptions<T>)Options);
-
-        // Copy trained coefficients
-        if (_arCoefficients.Length > 0)
-        {
-            clone._arCoefficients = new Vector<T>(_arCoefficients.Length);
-            for (int i = 0; i < _arCoefficients.Length; i++)
-            {
-                clone._arCoefficients[i] = _arCoefficients[i];
-            }
-        }
-
-        if (_maCoefficients.Length > 0)
-        {
-            clone._maCoefficients = new Vector<T>(_maCoefficients.Length);
-            for (int i = 0; i < _maCoefficients.Length; i++)
-            {
-                clone._maCoefficients[i] = _maCoefficients[i];
-            }
-        }
-
-        // Deep copy training state
-        if (_trainedSeries.Length > 0)
-        {
-            clone._trainedSeries = new Vector<T>(_trainedSeries.Length);
-            for (int i = 0; i < _trainedSeries.Length; i++)
-            {
-                clone._trainedSeries[i] = _trainedSeries[i];
-            }
-        }
-
-        if (_trainedResiduals.Length > 0)
-        {
-            clone._trainedResiduals = new Vector<T>(_trainedResiduals.Length);
-            for (int i = 0; i < _trainedResiduals.Length; i++)
-            {
-                clone._trainedResiduals[i] = _trainedResiduals[i];
-            }
-        }
-
-        clone._seriesMean = _seriesMean;
-
-        return clone;
-    }
-
     /// <summary>
     /// Implements the core training algorithm for the ARMA model.
     /// </summary>
diff --git a/src/TimeSeries/ARModel.cs b/src/TimeSeries/ARModel.cs
index 8e9fca8dc2..f0e0aac655 100644
--- a/src/TimeSeries/ARModel.cs
+++ b/src/TimeSeries/ARModel.cs
@@ -77,6 +77,7 @@ public ARModel()
     /// Larger coefficients mean stronger influence from that time period.
     /// These values are learned during training to best fit your historical data.
     /// </remarks>
+    [AiDotNet.Attributes.FittedParameter]
     private Vector<T> _arCoefficients;
     private T _seriesMean;
 
@@ -438,21 +439,7 @@ public override Dictionary<string, T> EvaluateModel(Matrix<T> xTest, Vector<T> y
     /// 
     /// This allows the model to be fully reconstructed later.
     /// </remarks>
-    protected override void SerializeCore(BinaryWriter writer)
-    {
-        writer.Write(_arOrder);
-        for (int i = 0; i < _arOrder; i++)
-        {
-            writer.Write(Convert.ToDouble(_arCoefficients[i]));
-        }
 
-        // Serialize training series for in-sample prediction support
-        writer.Write(_trainedSeries.Length);
-        for (int i = 0; i < _trainedSeries.Length; i++)
-        {
-            writer.Write(Convert.ToDouble(_trainedSeries[i]));
-        }
-    }
 
     /// <summary>
     /// Deserializes the model's state from a binary stream.
@@ -473,34 +460,7 @@ protected override void SerializeCore(BinaryWriter writer)
     /// 
     /// After deserialization, the model is ready to make predictions as if it had just been trained.
     /// </remarks>
-    protected override void DeserializeCore(BinaryReader reader)
-    {
-        _arOrder = reader.ReadInt32();
-        _arCoefficients = new Vector<T>(_arOrder);
-        for (int i = 0; i < _arOrder; i++)
-        {
-            _arCoefficients[i] = NumOps.FromDouble(reader.ReadDouble());
-        }
 
-        // Deserialize training series if available (backward-compatible)
-        _trainedSeries = Vector<T>.Empty();
-        try
-        {
-            int seriesLength = reader.ReadInt32();
-            if (seriesLength > 0)
-            {
-                _trainedSeries = new Vector<T>(seriesLength);
-                for (int i = 0; i < seriesLength; i++)
-                {
-                    _trainedSeries[i] = NumOps.FromDouble(reader.ReadDouble());
-                }
-            }
-        }
-        catch (EndOfStreamException)
-        {
-            // Older serialized models don't include training series — leave empty
-        }
-    }
 
     /// <summary>
     /// Creates a new instance of the AR model with the same options.
@@ -699,57 +659,6 @@ public override void Reset()
         _trainedSeries = Vector<T>.Empty();
     }
 
-    /// <summary>
-    /// Creates a deep copy of the current model.
-    /// </summary>
-    /// <returns>A new instance of the AR model with the same state and parameters.</returns>
-    /// <remarks>
-    /// <para>
-    /// This method creates a complete copy of the model, including its configuration and trained coefficients.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method creates an exact duplicate of your trained model.
-    /// 
-    /// Unlike CreateInstance(), which creates a blank model with the same settings,
-    /// Clone() creates a complete copy including:
-    /// - The model configuration (AR order, etc.)
-    /// - All trained coefficients and internal state
-    /// 
-    /// This is useful for:
-    /// - Creating a backup before experimenting with a model
-    /// - Using the same trained model in multiple scenarios
-    /// - Creating ensemble models that use variations of the same base model
-    /// 
-    /// Think of it like photocopying a completed notebook - you get all the written content
-    /// as well as the structure of the notebook itself.
-    /// </para>
-    /// </remarks>
-    public override IFullModel<T, Matrix<T>, Vector<T>> Clone()
-    {
-        var clone = new ARModel<T>((ARModelOptions<T>)Options);
-
-        // Copy trained coefficients
-        if (_arCoefficients.Length > 0)
-        {
-            clone._arCoefficients = new Vector<T>(_arCoefficients.Length);
-            for (int i = 0; i < _arCoefficients.Length; i++)
-            {
-                clone._arCoefficients[i] = _arCoefficients[i];
-            }
-        }
-
-        // Copy stored training series
-        if (_trainedSeries.Length > 0)
-        {
-            clone._trainedSeries = new Vector<T>(_trainedSeries.Length);
-            for (int i = 0; i < _trainedSeries.Length; i++)
-            {
-                clone._trainedSeries[i] = _trainedSeries[i];
-            }
-        }
-
-        return clone;
-    }
-
     /// <summary>
     /// Implements the core training algorithm for the AR model.
     /// </summary>
diff --git a/src/TimeSeries/AnomalyDetection/DeepANT.cs b/src/TimeSeries/AnomalyDetection/DeepANT.cs
index 40c59e3a60..3c6fc44e31 100644
--- a/src/TimeSeries/AnomalyDetection/DeepANT.cs
+++ b/src/TimeSeries/AnomalyDetection/DeepANT.cs
@@ -418,107 +418,20 @@ public Vector<T> ComputeAnomalyScores(Vector<T> data)
         return scores;
     }
 
-    protected override void SerializeCore(BinaryWriter writer)
-    {
-        writer.Write(_options.WindowSize);
-        writer.Write(_numOps.ToDouble(_anomalyThreshold));
-
-        // Serialize conv layers
-        writer.Write(_convLayers.Count);
-        foreach (var conv in _convLayers)
-        {
-            conv.Serialize(writer);
-        }
-
-        // Serialize FC weights tensor
-        writer.Write(_fcWeights.Shape.Length);
-        foreach (int dim in _fcWeights._shape)
-            writer.Write(dim);
-        writer.Write(_fcWeights.Length);
-        for (int i = 0; i < _fcWeights.Length; i++)
-            writer.Write(_numOps.ToDouble(_fcWeights[i]));
-
-        // Serialize FC bias tensor
-        writer.Write(_fcBias.Shape.Length);
-        foreach (int dim in _fcBias._shape)
-            writer.Write(dim);
-        writer.Write(_fcBias.Length);
-        for (int i = 0; i < _fcBias.Length; i++)
-            writer.Write(_numOps.ToDouble(_fcBias[i]));
-
-        // Serialize training series
-        writer.Write(_trainingSeries.Length);
-        for (int i = 0; i < _trainingSeries.Length; i++)
-            writer.Write(_numOps.ToDouble(_trainingSeries[i]));
-    }
-
-    protected override void DeserializeCore(BinaryReader reader)
-    {
-        int savedWindowSize = reader.ReadInt32();
-        if (savedWindowSize != _options.WindowSize)
-        {
-            throw new InvalidOperationException(
-                $"Serialized WindowSize ({savedWindowSize}) doesn't match options ({_options.WindowSize})");
-        }
-        _anomalyThreshold = _numOps.FromDouble(reader.ReadDouble());
-
-        // Deserialize conv layers
-        int convLayerCount = reader.ReadInt32();
-        _convLayers.Clear();
-        for (int i = 0; i < convLayerCount; i++)
-        {
-            var layer = new ConvLayerTensor<T>();
-            layer.Deserialize(reader);
-            _convLayers.Add(layer);
-        }
-
-        // Deserialize FC weights tensor
-        int weightsRank = reader.ReadInt32();
-        int[] weightsShape = new int[weightsRank];
-        for (int i = 0; i < weightsRank; i++)
-            weightsShape[i] = reader.ReadInt32();
-        int weightsLength = reader.ReadInt32();
-        _fcWeights = new Tensor<T>(weightsShape);
-        // Clamp by tensor length but consume all serialized values to keep stream aligned
-        for (int i = 0; i < weightsLength; i++)
-        {
-            double v = reader.ReadDouble();
-            if (i < _fcWeights.Length)
-                _fcWeights[i] = _numOps.FromDouble(v);
-        }
-
-        // Deserialize FC bias tensor
-        int biasRank = reader.ReadInt32();
-        int[] biasShape = new int[biasRank];
-        for (int i = 0; i < biasRank; i++)
-            biasShape[i] = reader.ReadInt32();
-        int biasLength = reader.ReadInt32();
-        _fcBias = new Tensor<T>(biasShape);
-        // Clamp by tensor length but consume all serialized values to keep stream aligned
-        for (int i = 0; i < biasLength; i++)
-        {
-            double v = reader.ReadDouble();
-            if (i < _fcBias.Length)
-                _fcBias[i] = _numOps.FromDouble(v);
-        }
+    // SerializeCore / DeserializeCore are DELETED, not reimplemented.
+    //
+    // TimeSeriesModelBase already round-trips declared state: Serialize ends with
+    // ModelStateEnvelope.Append(DeclaredState, ...) and Deserialize begins with the matching
+    // Extract, so _anomalyThreshold, _fcWeights, _fcBias, _options, _trainingSeries and now
+    // _convLayers all travel by name. The deleted pair wrote most of those a SECOND time by hand,
+    // and wrote _convLayers in a form that could not be restored: DeserializeCore rebuilt each
+    // convolution with the placeholder constructor, so _outputChannels and _kernelSize stayed 0,
+    // 96 kernel values collapsed to 1, and the model's prediction changed sign across a round trip.
+    //
+    // The base could not be used before because SerializeCore was ABSTRACT -- every time series
+    // model was required to hand-write both halves. It is virtual and empty now, so this model
+    // declares its state and writes no serialization at all.
 
-        // Initialize gradient accumulators
-        _fcWeightsGrad = new Tensor<T>(weightsShape);
-        _fcBiasGrad = new Tensor<T>(biasShape);
-
-        // Deserialize training series (post-patch field)
-        try
-        {
-            int tsLen = reader.ReadInt32();
-            _trainingSeries = new Vector<T>(tsLen);
-            for (int i = 0; i < tsLen; i++)
-                _trainingSeries[i] = _numOps.FromDouble(reader.ReadDouble());
-        }
-        catch (EndOfStreamException)
-        {
-            _trainingSeries = Vector<T>.Empty();
-        }
-    }
 
     public override ModelMetadata<T> GetModelMetadata()
     {
@@ -632,16 +545,22 @@ internal partial class ConvLayerTensor<T> : NeuralNetworks.Layers.LayerBase<T>,
 
     private int _outputChannels;
     private int _kernelSize;
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _kernels;  // [outputChannels, kernelSize]
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _biases;   // [outputChannels]
 
     // Cached state for backward pass
+    [Scratch]
     private Tensor<T>? _lastInput;
+    [Scratch]
     private Tensor<T>? _lastPreActivations;  // [outputChannels, numPositions] before ReLU
     private int _lastNumPositions;
 
     // Stored gradients for UpdateParameters
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T>? _kernelGradients;
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T>? _biasGradients;
 
     public override bool SupportsTraining => true;
@@ -745,44 +664,4 @@ public override void ResetState()
         _kernelGradients = null;
         _biasGradients = null;
     }
-
-    public override void Serialize(BinaryWriter writer)
-    {
-        writer.Write(_outputChannels);
-        writer.Write(_kernelSize);
-        writer.Write(_kernels.Shape.Length);
-        foreach (int dim in _kernels._shape) writer.Write(dim);
-        writer.Write(_kernels.Length);
-        for (int i = 0; i < _kernels.Length; i++) writer.Write(NumOps.ToDouble(_kernels[i]));
-        writer.Write(_biases.Shape.Length);
-        foreach (int dim in _biases._shape) writer.Write(dim);
-        writer.Write(_biases.Length);
-        for (int i = 0; i < _biases.Length; i++) writer.Write(NumOps.ToDouble(_biases[i]));
-    }
-
-    public override void Deserialize(BinaryReader reader)
-    {
-        _outputChannels = reader.ReadInt32();
-        _kernelSize = reader.ReadInt32();
-
-        int kernelsRank = reader.ReadInt32();
-        int[] kernelsShape = new int[kernelsRank];
-        for (int i = 0; i < kernelsRank; i++) kernelsShape[i] = reader.ReadInt32();
-        int kernelsLength = reader.ReadInt32();
-        _kernels = new Tensor<T>(kernelsShape);
-        if (kernelsLength != _kernels.Length)
-            throw new InvalidOperationException(
-                $"Serialized kernel length ({kernelsLength}) does not match tensor shape ({_kernels.Length}).");
-        for (int i = 0; i < kernelsLength; i++) _kernels[i] = NumOps.FromDouble(reader.ReadDouble());
-
-        int biasesRank = reader.ReadInt32();
-        int[] biasesShape = new int[biasesRank];
-        for (int i = 0; i < biasesRank; i++) biasesShape[i] = reader.ReadInt32();
-        int biasesLength = reader.ReadInt32();
-        _biases = new Tensor<T>(biasesShape);
-        if (biasesLength != _biases.Length)
-            throw new InvalidOperationException(
-                $"Serialized bias length ({biasesLength}) does not match tensor shape ({_biases.Length}).");
-        for (int i = 0; i < biasesLength; i++) _biases[i] = NumOps.FromDouble(reader.ReadDouble());
-    }
 }
diff --git a/src/TimeSeries/AnomalyDetection/LSTMVAE.cs b/src/TimeSeries/AnomalyDetection/LSTMVAE.cs
index 81dd220300..e5fe3cbc1e 100644
--- a/src/TimeSeries/AnomalyDetection/LSTMVAE.cs
+++ b/src/TimeSeries/AnomalyDetection/LSTMVAE.cs
@@ -255,47 +255,9 @@ public Vector<T> ComputeAnomalyScores(Matrix<T> data)
         return scores;
     }
 
-    protected override void SerializeCore(BinaryWriter writer)
-    {
-        writer.Write(_options.WindowSize);
-        writer.Write(_options.LatentDim);
-        writer.Write(_options.HiddenSize);
-        writer.Write(_numOps.ToDouble(_reconstructionThreshold));
-
-        _encoder.Serialize(writer);
-        _decoder.Serialize(writer);
-
-        writer.Write(_trainingSeries.Length);
-        for (int i = 0; i < _trainingSeries.Length; i++)
-            writer.Write(_numOps.ToDouble(_trainingSeries[i]));
-    }
 
-    protected override void DeserializeCore(BinaryReader reader)
-    {
-        _options.WindowSize = reader.ReadInt32();
-        _options.LatentDim = reader.ReadInt32();
-        _options.HiddenSize = reader.ReadInt32();
-        _reconstructionThreshold = _numOps.FromDouble(reader.ReadDouble());
-
-        // Rebuild encoder/decoder with correct dimensions
-        _encoder = new LSTMEncoderTensor<T>(_options.WindowSize, _options.LatentDim, _options.HiddenSize);
-        _decoder = new LSTMDecoderTensor<T>(_options.LatentDim, _options.WindowSize, _options.HiddenSize);
 
-        _encoder.Deserialize(reader);
-        _decoder.Deserialize(reader);
 
-        try
-        {
-            int tsLen = reader.ReadInt32();
-            _trainingSeries = new Vector<T>(tsLen);
-            for (int i = 0; i < tsLen; i++)
-                _trainingSeries[i] = _numOps.FromDouble(reader.ReadDouble());
-        }
-        catch (EndOfStreamException)
-        {
-            _trainingSeries = Vector<T>.Empty();
-        }
-    }
 
     public override ModelMetadata<T> GetModelMetadata()
     {
@@ -400,23 +362,35 @@ internal partial class LSTMEncoderTensor<T> : NeuralNetworks.Layers.LayerBase<T>
     private readonly int _hiddenSize;
 
     // LSTM weights (Tensor-based)
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _weights;      // [hiddenSize, inputSize]
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _bias;         // [hiddenSize]
 
     // Mean projection weights
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _meanWeights;  // [latentDim, hiddenSize]
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _meanBias;     // [latentDim]
 
     // Log variance projection weights
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _logVarWeights; // [latentDim, hiddenSize]
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _logVarBias;    // [latentDim]
 
     // Gradient accumulators
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _weightsGrad;
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _biasGrad;
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _meanWeightsGrad;
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _meanBiasGrad;
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _logVarWeightsGrad;
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _logVarBiasGrad;
 
     public override bool SupportsTraining => true;
@@ -557,34 +531,6 @@ private void ApplyGradientToTensor(Tensor<T> tensor, Tensor<T> grad, T learningR
         updated.Data.Span.CopyTo(tensor.Data.Span);
     }
 
-    public override void Serialize(BinaryWriter writer)
-    {
-        WriteTensor(writer, _weights);
-        WriteTensor(writer, _bias);
-        WriteTensor(writer, _meanWeights);
-        WriteTensor(writer, _meanBias);
-        WriteTensor(writer, _logVarWeights);
-        WriteTensor(writer, _logVarBias);
-    }
-
-    public override void Deserialize(BinaryReader reader)
-    {
-        _weights = ReadTensor(reader);
-        _bias = ReadTensor(reader);
-        _meanWeights = ReadTensor(reader);
-        _meanBias = ReadTensor(reader);
-        _logVarWeights = ReadTensor(reader);
-        _logVarBias = ReadTensor(reader);
-
-        // Reinitialize gradient accumulators
-        _weightsGrad = new Tensor<T>(_weights._shape);
-        _biasGrad = new Tensor<T>(_bias._shape);
-        _meanWeightsGrad = new Tensor<T>(_meanWeights._shape);
-        _meanBiasGrad = new Tensor<T>(_meanBias._shape);
-        _logVarWeightsGrad = new Tensor<T>(_logVarWeights._shape);
-        _logVarBiasGrad = new Tensor<T>(_logVarBias._shape);
-    }
-
     private void WriteTensor(BinaryWriter writer, Tensor<T> tensor)
     {
         writer.Write(tensor.Shape.Length);
@@ -655,20 +601,29 @@ internal partial class LSTMDecoderTensor<T> : NeuralNetworks.Layers.LayerBase<T>
     private readonly int _hiddenSize;
 
     // LSTM weights (Tensor-based)
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _weights;      // [hiddenSize, latentDim]
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _bias;         // [hiddenSize]
 
     // Output projection weights
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _outputWeights; // [outputSize, hiddenSize]
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _outputBias;    // [outputSize]
 
     // Gradient accumulators
     private Tensor<T> _weightsGrad;
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _biasGrad;
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _outputWeightsGrad;
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _outputBiasGrad;
 
+    [Scratch]
     private Tensor<T>? _lastLatent;
+    [Scratch]
     private Tensor<T>? _lastHidden;
 
     public override bool SupportsTraining => true;
@@ -787,28 +742,6 @@ private void ApplyGradientToTensor(Tensor<T> tensor, Tensor<T> grad, T learningR
         updated.Data.Span.CopyTo(tensor.Data.Span);
     }
 
-    public override void Serialize(BinaryWriter writer)
-    {
-        WriteTensor(writer, _weights);
-        WriteTensor(writer, _bias);
-        WriteTensor(writer, _outputWeights);
-        WriteTensor(writer, _outputBias);
-    }
-
-    public override void Deserialize(BinaryReader reader)
-    {
-        _weights = ReadTensor(reader);
-        _bias = ReadTensor(reader);
-        _outputWeights = ReadTensor(reader);
-        _outputBias = ReadTensor(reader);
-
-        // Reinitialize gradient accumulators
-        _weightsGrad = new Tensor<T>(_weights._shape);
-        _biasGrad = new Tensor<T>(_bias._shape);
-        _outputWeightsGrad = new Tensor<T>(_outputWeights._shape);
-        _outputBiasGrad = new Tensor<T>(_outputBias._shape);
-    }
-
     private void WriteTensor(BinaryWriter writer, Tensor<T> tensor)
     {
         writer.Write(tensor.Shape.Length);
diff --git a/src/TimeSeries/AnomalyDetection/TimeSeriesIsolationForest.cs b/src/TimeSeries/AnomalyDetection/TimeSeriesIsolationForest.cs
index a4330b9942..c220280809 100644
--- a/src/TimeSeries/AnomalyDetection/TimeSeriesIsolationForest.cs
+++ b/src/TimeSeries/AnomalyDetection/TimeSeriesIsolationForest.cs
@@ -63,7 +63,7 @@ namespace AiDotNet.TimeSeries.AnomalyDetection;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
 [ResearchPaper("Isolation Forest", "https://doi.org/10.1109/ICDM.2008.17", Year = 2008, Authors = "Fei Tony Liu, Kai Ming Ting, Zhi-Hua Zhou")]
-public class TimeSeriesIsolationForest<T> : TimeSeriesModelBase<T>
+public partial class TimeSeriesIsolationForest<T> : TimeSeriesModelBase<T>
 {
     private readonly TimeSeriesIsolationForestOptions<T> _options;
 
@@ -523,64 +523,10 @@ protected override IFullModel<T, Matrix<T>, Vector<T>> CreateInstance()
     }
 
     /// <inheritdoc/>
-    protected override void SerializeCore(BinaryWriter writer)
-    {
-        // Write options
-        writer.Write(_options.NumTrees);
-        writer.Write(_options.SampleSize ?? 256);
-        writer.Write(_options.MaxDepth ?? -1);
-        writer.Write(_options.ContaminationRate);
-        writer.Write(_options.LagFeatures);
-        writer.Write(_options.RollingWindowSize);
-        writer.Write(_options.UseSeasonalDecomposition);
-        writer.Write(_options.SeasonalPeriod);
-        writer.Write(_options.UseTrendFeatures);
-        writer.Write(_options.RandomSeed ?? 42);
-
-        // Write computed values
-        writer.Write(_anomalyThreshold);
-        writer.Write(_effectiveSampleSize);
-        writer.Write(_effectiveMaxDepth);
-
-        // Write forest
-        writer.Write(_forest?.Count ?? 0);
-        if (_forest != null)
-        {
-            foreach (var tree in _forest)
-            {
-                SerializeTree(writer, tree);
-            }
-        }
-    }
+
 
     /// <inheritdoc/>
-    protected override void DeserializeCore(BinaryReader reader)
-    {
-        // Read options (skip, they're set via constructor)
-        _ = reader.ReadInt32(); // NumTrees
-        _ = reader.ReadInt32(); // SampleSize
-        _ = reader.ReadInt32(); // MaxDepth
-        _ = reader.ReadDouble(); // ContaminationRate
-        _ = reader.ReadInt32(); // LagFeatures
-        _ = reader.ReadInt32(); // RollingWindowSize
-        _ = reader.ReadBoolean(); // UseSeasonalDecomposition
-        _ = reader.ReadInt32(); // SeasonalPeriod
-        _ = reader.ReadBoolean(); // UseTrendFeatures
-        _ = reader.ReadInt32(); // RandomSeed
-
-        // Read computed values
-        _anomalyThreshold = reader.ReadDouble();
-        _effectiveSampleSize = reader.ReadInt32();
-        _effectiveMaxDepth = reader.ReadInt32();
-
-        // Read forest
-        int forestSize = reader.ReadInt32();
-        _forest = new List<IsolationTree<T>>();
-        for (int i = 0; i < forestSize; i++)
-        {
-            _forest.Add(DeserializeTree(reader));
-        }
-    }
+
 
     private void SerializeTree(BinaryWriter writer, IsolationTree<T> tree)
     {
diff --git a/src/TimeSeries/AutoformerModel.cs b/src/TimeSeries/AutoformerModel.cs
index 06b20c9b39..5bc19d8a4f 100644
--- a/src/TimeSeries/AutoformerModel.cs
+++ b/src/TimeSeries/AutoformerModel.cs
@@ -107,6 +107,7 @@ public partial class AutoformerModel<T> : TimeSeriesModelBase<T>, ISupportsLossF
     private readonly int _movingAvgKernel;
 
     // Input embedding
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _inputProjection;      // [embeddingDim, 1]
     [Buffer]
     private Tensor<T> _positionalEncoding;   // [maxLen, embeddingDim]
@@ -120,12 +121,17 @@ public partial class AutoformerModel<T> : TimeSeriesModelBase<T>, ISupportsLossF
 
     // Decoder components
     private readonly List<AutoformerDecoderLayer<T>> _decoderLayers;
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _decoderSeasonalInit;  // [forecastHorizon, embeddingDim]
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _decoderTrendInit;     // [forecastHorizon, embeddingDim]
 
     // Output projections
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _seasonalProjection;   // [1, embeddingDim]
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _trendProjection;      // [1, embeddingDim]
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _outputBias;           // [forecastHorizon]
 
     // Normalization statistics computed during training (zero-mean / unit-variance of the
@@ -594,6 +600,7 @@ private Tensor<T> AddBias(Tensor<T> x, Tensor<T> bias)
     // still flows through the softmax weights (gathered R values → q, k) and through the rolled v.
     // Cache for the constant diagonal-sum operator used by the matmul spectrum, keyed by (lq, lk, corrLen, d).
     // Shape [corrLen, lq*lk]; ~110 KB at the default 24x24x512, and it never changes for a given model.
+    [Scratch]
     private readonly ConcurrentDictionary<(int Lq, int Lk, int CorrLen, int D), Tensor<T>> _diagOperatorCache = new();
 
     /// <summary>
@@ -947,128 +954,10 @@ protected override IFullModel<T, Matrix<T>, Vector<T>> CreateInstance()
     }
 
     /// <inheritdoc/>
-    protected override void SerializeCore(BinaryWriter writer)
-    {
-        // Write options
-        writer.Write(_options.LookbackWindow);
-        writer.Write(_options.ForecastHorizon);
-        writer.Write(_options.EmbeddingDim);
-        writer.Write(_options.NumEncoderLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumAttentionHeads);
-        writer.Write(_options.MovingAverageKernel);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.LearningRate);
-        writer.Write(_options.Epochs);
-        writer.Write(_options.BatchSize);
-        writer.Write(_options.AutoCorrelationFactor);
-
-        // Write tensors
-        WriteTensor(writer, _inputProjection);
-        WriteTensor(writer, _positionalEncoding);
-        WriteTensor(writer, _decoderSeasonalInit);
-        WriteTensor(writer, _decoderTrendInit);
-        WriteTensor(writer, _seasonalProjection);
-        WriteTensor(writer, _trendProjection);
-        WriteTensor(writer, _outputBias);
-
-        // Write encoder layers
-        foreach (var layer in _encoderLayers)
-        {
-            layer.Serialize(writer);
-        }
 
-        // Write decoder layers
-        foreach (var layer in _decoderLayers)
-        {
-            layer.Serialize(writer);
-        }
-
-        writer.Write(_trainingSeries.Length);
-        for (int i = 0; i < _trainingSeries.Length; i++)
-            writer.Write(_numOps.ToDouble(_trainingSeries[i]));
-
-        // Normalization statistics (appended; older files without them fall back to 0/1).
-        writer.Write(_numOps.ToDouble(_normMean));
-        writer.Write(_numOps.ToDouble(_normStd));
-    }
 
     /// <inheritdoc/>
-    protected override void DeserializeCore(BinaryReader reader)
-    {
-        // Read options (skip, they're set via constructor)
-        _ = reader.ReadInt32(); // LookbackWindow
-        _ = reader.ReadInt32(); // ForecastHorizon
-        _ = reader.ReadInt32(); // EmbeddingDim
-        _ = reader.ReadInt32(); // NumEncoderLayers
-        _ = reader.ReadInt32(); // NumDecoderLayers
-        _ = reader.ReadInt32(); // NumAttentionHeads
-        _ = reader.ReadInt32(); // MovingAverageKernel
-        _ = reader.ReadDouble(); // DropoutRate
-        _ = reader.ReadDouble(); // LearningRate
-        _ = reader.ReadInt32(); // Epochs
-        _ = reader.ReadInt32(); // BatchSize
-        _ = reader.ReadInt32(); // AutoCorrelationFactor
-
-        // Read tensors
-        _inputProjection = ReadTensor(reader);
-        _positionalEncoding = ReadTensor(reader);
-        _positionalEncodingHost = _positionalEncoding.GetCpuData();
-        _decoderSeasonalInit = ReadTensor(reader);
-        _decoderTrendInit = ReadTensor(reader);
-        _seasonalProjection = ReadTensor(reader);
-        _trendProjection = ReadTensor(reader);
-        _outputBias = ReadTensor(reader);
 
-        // Reinitialize layers
-        _encoderLayers.Clear();
-        _decoderLayers.Clear();
-
-        for (int i = 0; i < _options.NumEncoderLayers; i++)
-        {
-            var layer = new AutoformerEncoderLayer<T>(
-                _options.EmbeddingDim,
-                _options.NumAttentionHeads,
-                _options.MovingAverageKernel,
-                _options.AutoCorrelationFactor,
-                _options.DropoutRate,
-                42 + i);
-            layer.Deserialize(reader);
-            _encoderLayers.Add(layer);
-        }
-
-        for (int i = 0; i < _options.NumDecoderLayers; i++)
-        {
-            var layer = new AutoformerDecoderLayer<T>(
-                _options.EmbeddingDim,
-                _options.NumAttentionHeads,
-                _options.MovingAverageKernel,
-                _options.AutoCorrelationFactor,
-                _options.DropoutRate,
-                42 + _options.NumEncoderLayers + i);
-            layer.Deserialize(reader);
-            _decoderLayers.Add(layer);
-        }
-
-        try
-        {
-            int tsLen = reader.ReadInt32();
-            _trainingSeries = new Vector<T>(tsLen);
-            for (int i = 0; i < tsLen; i++)
-                _trainingSeries[i] = _numOps.FromDouble(reader.ReadDouble());
-        }
-        catch (EndOfStreamException)
-        {
-            _trainingSeries = Vector<T>.Empty();
-        }
-
-        // Normalization statistics (present in models serialized after the tape rewrite).
-        if (reader.BaseStream.Position < reader.BaseStream.Length)
-        {
-            _normMean = _numOps.FromDouble(reader.ReadDouble());
-            _normStd = _numOps.FromDouble(reader.ReadDouble());
-        }
-    }
 
     private void WriteTensor(BinaryWriter writer, Tensor<T> tensor)
     {
@@ -1163,21 +1052,33 @@ internal static IReadOnlyList<OutputAxisContract> SeriesStreamAxes() => new[]
     private readonly double _dropoutRate;
 
     // Auto-correlation parameters
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _queryProj;
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _keyProj;
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _valueProj;
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _outputProj;
 
     // Feed-forward parameters
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _ff1Weight;
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _ff1Bias;
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _ff2Weight;
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _ff2Bias;
 
     // Layer normalization parameters
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _layerNorm1Gamma;
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _layerNorm1Beta;
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _layerNorm2Gamma;
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _layerNorm2Beta;
 
     public override bool SupportsTraining => true;
@@ -1185,10 +1086,14 @@ public override void ResetState() { }
     protected override Tensor<T> ForwardTraced(Tensor<T> input) => throw new NotSupportedException(
         "Autoformer runs its forward pass at the model level (AutoformerModel.ForwardCore); the layer-level Forward is unused.");
 
+    /// <summary>Construction state: the 'seed' the layer was built with.</summary>
+    private readonly int _seed;
+
     public AutoformerEncoderLayer(int embeddingDim, int numHeads, int movingAvgKernel,
         int autoCorrelationFactor, double dropoutRate, int seed)
         : base(new[] { embeddingDim }, new[] { embeddingDim * 2 })
     {
+        _seed = seed;
         _embeddingDim = embeddingDim;
         _numHeads = numHeads;
         _movingAvgKernel = movingAvgKernel;
@@ -1247,38 +1152,6 @@ private Tensor<T> InitTensor(int[] shape, double stddev, Random random)
     public Tensor<T> GetLayerNorm2Gamma() => _layerNorm2Gamma;
     public Tensor<T> GetLayerNorm2Beta() => _layerNorm2Beta;
 
-    public override void Serialize(BinaryWriter writer)
-    {
-        WriteTensor(writer, _queryProj);
-        WriteTensor(writer, _keyProj);
-        WriteTensor(writer, _valueProj);
-        WriteTensor(writer, _outputProj);
-        WriteTensor(writer, _ff1Weight);
-        WriteTensor(writer, _ff1Bias);
-        WriteTensor(writer, _ff2Weight);
-        WriteTensor(writer, _ff2Bias);
-        WriteTensor(writer, _layerNorm1Gamma);
-        WriteTensor(writer, _layerNorm1Beta);
-        WriteTensor(writer, _layerNorm2Gamma);
-        WriteTensor(writer, _layerNorm2Beta);
-    }
-
-    public override void Deserialize(BinaryReader reader)
-    {
-        _queryProj = ReadTensor(reader);
-        _keyProj = ReadTensor(reader);
-        _valueProj = ReadTensor(reader);
-        _outputProj = ReadTensor(reader);
-        _ff1Weight = ReadTensor(reader);
-        _ff1Bias = ReadTensor(reader);
-        _ff2Weight = ReadTensor(reader);
-        _ff2Bias = ReadTensor(reader);
-        _layerNorm1Gamma = ReadTensor(reader);
-        _layerNorm1Beta = ReadTensor(reader);
-        _layerNorm2Gamma = ReadTensor(reader);
-        _layerNorm2Beta = ReadTensor(reader);
-    }
-
     private void WriteTensor(BinaryWriter writer, Tensor<T> tensor)
     {
         writer.Write(tensor.Shape.Length);
@@ -1363,29 +1236,46 @@ internal partial class AutoformerDecoderLayer<T> : NeuralNetworks.Layers.LayerBa
     private readonly double _dropoutRate;
 
     // Self auto-correlation parameters
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _selfQueryProj;
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _selfKeyProj;
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _selfValueProj;
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _selfOutputProj;
 
     // Cross auto-correlation parameters
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _crossQueryProj;
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _crossKeyProj;
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _crossValueProj;
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _crossOutputProj;
 
     // Feed-forward parameters
     private Tensor<T> _ff1Weight;
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _ff1Bias;
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _ff2Weight;
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _ff2Bias;
 
     // Layer normalization
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _layerNorm1Gamma;
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _layerNorm1Beta;
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _layerNorm2Gamma;
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _layerNorm2Beta;
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _layerNorm3Gamma;
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _layerNorm3Beta;
 
     public override bool SupportsTraining => true;
@@ -1393,10 +1283,14 @@ public override void ResetState() { }
     protected override Tensor<T> ForwardTraced(Tensor<T> input) => throw new NotSupportedException(
         "Autoformer runs its forward pass at the model level (AutoformerModel.ForwardCore); the layer-level Forward is unused.");
 
+    /// <summary>Construction state: the 'seed' the layer was built with.</summary>
+    private readonly int _seed;
+
     public AutoformerDecoderLayer(int embeddingDim, int numHeads, int movingAvgKernel,
         int autoCorrelationFactor, double dropoutRate, int seed)
         : base(new int[][] { new[] { embeddingDim }, new[] { embeddingDim }, new[] { embeddingDim } }, new[] { embeddingDim * 2 })
     {
+        _seed = seed;
         _embeddingDim = embeddingDim;
         _numHeads = numHeads;
         _movingAvgKernel = movingAvgKernel;
@@ -1470,50 +1364,6 @@ private Tensor<T> InitTensor(int[] shape, double stddev, Random random)
     public Tensor<T> GetLayerNorm3Gamma() => _layerNorm3Gamma;
     public Tensor<T> GetLayerNorm3Beta() => _layerNorm3Beta;
 
-    public override void Serialize(BinaryWriter writer)
-    {
-        WriteTensor(writer, _selfQueryProj);
-        WriteTensor(writer, _selfKeyProj);
-        WriteTensor(writer, _selfValueProj);
-        WriteTensor(writer, _selfOutputProj);
-        WriteTensor(writer, _crossQueryProj);
-        WriteTensor(writer, _crossKeyProj);
-        WriteTensor(writer, _crossValueProj);
-        WriteTensor(writer, _crossOutputProj);
-        WriteTensor(writer, _ff1Weight);
-        WriteTensor(writer, _ff1Bias);
-        WriteTensor(writer, _ff2Weight);
-        WriteTensor(writer, _ff2Bias);
-        WriteTensor(writer, _layerNorm1Gamma);
-        WriteTensor(writer, _layerNorm1Beta);
-        WriteTensor(writer, _layerNorm2Gamma);
-        WriteTensor(writer, _layerNorm2Beta);
-        WriteTensor(writer, _layerNorm3Gamma);
-        WriteTensor(writer, _layerNorm3Beta);
-    }
-
-    public override void Deserialize(BinaryReader reader)
-    {
-        _selfQueryProj = ReadTensor(reader);
-        _selfKeyProj = ReadTensor(reader);
-        _selfValueProj = ReadTensor(reader);
-        _selfOutputProj = ReadTensor(reader);
-        _crossQueryProj = ReadTensor(reader);
-        _crossKeyProj = ReadTensor(reader);
-        _crossValueProj = ReadTensor(reader);
-        _crossOutputProj = ReadTensor(reader);
-        _ff1Weight = ReadTensor(reader);
-        _ff1Bias = ReadTensor(reader);
-        _ff2Weight = ReadTensor(reader);
-        _ff2Bias = ReadTensor(reader);
-        _layerNorm1Gamma = ReadTensor(reader);
-        _layerNorm1Beta = ReadTensor(reader);
-        _layerNorm2Gamma = ReadTensor(reader);
-        _layerNorm2Beta = ReadTensor(reader);
-        _layerNorm3Gamma = ReadTensor(reader);
-        _layerNorm3Beta = ReadTensor(reader);
-    }
-
     private void WriteTensor(BinaryWriter writer, Tensor<T> tensor)
     {
         writer.Write(tensor.Shape.Length);
diff --git a/src/TimeSeries/BayesianStructuralTimeSeriesModel.cs b/src/TimeSeries/BayesianStructuralTimeSeriesModel.cs
index 82b2198918..103888b495 100644
--- a/src/TimeSeries/BayesianStructuralTimeSeriesModel.cs
+++ b/src/TimeSeries/BayesianStructuralTimeSeriesModel.cs
@@ -159,6 +159,7 @@ public partial class BayesianStructuralTimeSeriesModel<T> : TimeSeriesModelBase<
     /// Each coefficient quantifies the effect of one external variable. The model
     /// learns these coefficients from your data to improve predictions.
     /// </remarks>
+    [AiDotNet.Attributes.FittedParameter]
     private Vector<T> _regression;
 
     /// <summary>
@@ -1216,42 +1217,7 @@ private int GetStateSize()
     /// 
     /// This allows the model to be fully reconstructed later.
     /// </remarks>
-    protected override void SerializeCore(BinaryWriter writer)
-    {
-        // Serialize model parameters
-        writer.Write(Convert.ToDouble(_level));
-
-        if (_bayesianOptions.IncludeTrend)
-        {
-            writer.Write(Convert.ToDouble(_trend));
-        }
-
-        writer.Write(_seasonalComponents.Count);
-        foreach (var component in _seasonalComponents)
-        {
-            writer.Write(component.Length);
-            foreach (var val in component) writer.Write(Convert.ToDouble(val));
-        }
-
-        writer.Write(_stateCovariance.Rows);
-        writer.Write(_stateCovariance.Columns);
-        for (int i = 0; i < _stateCovariance.Rows; i++)
-            for (int j = 0; j < _stateCovariance.Columns; j++)
-                writer.Write(Convert.ToDouble(_stateCovariance[i, j]));
-
-        writer.Write(Convert.ToDouble(_observationVariance));
 
-        // Serialize options
-        writer.Write(_bayesianOptions.IncludeTrend);
-        writer.Write(_bayesianOptions.IncludeRegression);
-
-        // Serialize training series for in-sample predictions
-        writer.Write(_trainingSeries.Length);
-        for (int i = 0; i < _trainingSeries.Length; i++)
-            writer.Write(Convert.ToDouble(_trainingSeries[i]));
-
-        SerializationHelper<T>.SerializeVector(writer, _regression);
-    }
 
     /// <summary>
     /// Deserializes the model's state from a binary stream.
@@ -1275,59 +1241,7 @@ protected override void SerializeCore(BinaryWriter writer)
     /// 
     /// After deserialization, the model is ready to make predictions as if it had just been trained.
     /// </remarks>
-    protected override void DeserializeCore(BinaryReader reader)
-    {
-        // Deserialize model parameters — level is always present
-        _level = NumOps.FromDouble(reader.ReadDouble());
 
-        // Note: IncludeTrend was serialized AFTER the covariance matrix (legacy order).
-        // We read the trend unconditionally based on whether it was actually written,
-        // which we detect by peeking ahead. For backward compatibility, we read based
-        // on the current options setting (which matches what was serialized).
-        if (_bayesianOptions.IncludeTrend)
-        {
-            _trend = NumOps.FromDouble(reader.ReadDouble());
-        }
-
-        int seasonalComponentsCount = reader.ReadInt32();
-        _seasonalComponents = new List<Vector<T>>();
-        for (int i = 0; i < seasonalComponentsCount; i++)
-        {
-            int componentLength = reader.ReadInt32();
-            Vector<T> component = new Vector<T>(componentLength);
-            for (int j = 0; j < componentLength; j++) component[j] = NumOps.FromDouble(reader.ReadDouble());
-            _seasonalComponents.Add(component);
-        }
-
-        int covarianceRows = reader.ReadInt32();
-        int covarianceColumns = reader.ReadInt32();
-        _stateCovariance = new Matrix<T>(covarianceRows, covarianceColumns);
-        for (int i = 0; i < covarianceRows; i++)
-            for (int j = 0; j < covarianceColumns; j++)
-                _stateCovariance[i, j] = NumOps.FromDouble(reader.ReadDouble());
-
-        _observationVariance = NumOps.FromDouble(reader.ReadDouble());
-
-        // Deserialize options
-        _bayesianOptions.IncludeTrend = reader.ReadBoolean();
-        _bayesianOptions.IncludeRegression = reader.ReadBoolean();
-
-        // Deserialize training series (post-patch field)
-        try
-        {
-            int tsLen = reader.ReadInt32();
-            _trainingSeries = new Vector<T>(tsLen);
-            for (int i = 0; i < tsLen; i++)
-                _trainingSeries[i] = NumOps.FromDouble(reader.ReadDouble());
-
-            _regression = SerializationHelper<T>.DeserializeVector(reader);
-        }
-        catch (EndOfStreamException)
-        {
-            _trainingSeries = Vector<T>.Empty();
-            _regression = Vector<T>.Empty();
-        }
-    }
 
     /// <summary>
     /// Creates a new instance of the BSTS model with the same options.
@@ -1553,90 +1467,6 @@ public override void Reset()
         }
     }
 
-    /// <summary>
-    /// Creates a deep copy of the current model.
-    /// </summary>
-    /// <returns>A new instance of the BSTS model with the same state and parameters.</returns>
-    /// <remarks>
-    /// <para>
-    /// This method creates a complete copy of the model, including its configuration and trained components.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method creates an exact duplicate of your trained model.
-    /// 
-    /// Unlike CreateInstance(), which creates a blank model with the same settings,
-    /// Clone() creates a complete copy including:
-    /// - The model configuration (level, trend, seasonal settings, etc.)
-    /// - All trained components and their current values
-    /// - The current uncertainty estimates
-    /// 
-    /// This is useful for:
-    /// - Creating a backup before experimenting with a model
-    /// - Using the same trained model in multiple scenarios
-    /// - Creating ensemble models that use variations of the same base model
-    /// </para>
-    /// </remarks>
-    public override IFullModel<T, Matrix<T>, Vector<T>> Clone()
-    {
-        var clone = new BayesianStructuralTimeSeriesModel<T>((BayesianStructuralTimeSeriesOptions<T>)Options);
-
-        // Copy level and trend
-        clone._level = _level;
-        if (_bayesianOptions.IncludeTrend)
-        {
-            clone._trend = _trend;
-        }
-
-        // Copy seasonal components
-        clone._seasonalComponents.Clear();
-        foreach (var component in _seasonalComponents)
-        {
-            Vector<T> componentCopy = new Vector<T>(component.Length);
-            for (int i = 0; i < component.Length; i++)
-            {
-                componentCopy[i] = component[i];
-            }
-            clone._seasonalComponents.Add(componentCopy);
-        }
-
-        // Copy state covariance
-        clone._stateCovariance = new Matrix<T>(_stateCovariance.Rows, _stateCovariance.Columns);
-        for (int i = 0; i < _stateCovariance.Rows; i++)
-        {
-            for (int j = 0; j < _stateCovariance.Columns; j++)
-            {
-                clone._stateCovariance[i, j] = _stateCovariance[i, j];
-            }
-        }
-
-        // Copy observation variance
-        clone._observationVariance = _observationVariance;
-
-        // Copy regression component if included
-        if (_bayesianOptions.IncludeRegression && _regression != null)
-        {
-            clone._regression = new Vector<T>(_regression.Length);
-            for (int i = 0; i < _regression.Length; i++)
-            {
-                clone._regression[i] = _regression[i];
-            }
-        }
-
-        // Copy training series for in-sample predictions
-        if (_trainingSeries.Length > 0)
-        {
-            clone._trainingSeries = new Vector<T>(_trainingSeries.Length);
-            for (int i = 0; i < _trainingSeries.Length; i++)
-                clone._trainingSeries[i] = _trainingSeries[i];
-        }
-
-        // Copy trained state
-        clone.IsTrained = IsTrained;
-        if (ModelParameters.Length > 0)
-            clone.ModelParameters = ModelParameters.Clone();
-
-        return clone;
-    }
-
     /// <summary>
     /// Implements the core training algorithm for the Bayesian Structural Time Series model.
     /// </summary>
diff --git a/src/TimeSeries/ChronosFoundationModel.cs b/src/TimeSeries/ChronosFoundationModel.cs
index d8aac50702..19007bd7d3 100644
--- a/src/TimeSeries/ChronosFoundationModel.cs
+++ b/src/TimeSeries/ChronosFoundationModel.cs
@@ -91,6 +91,7 @@ public partial class ChronosFoundationModel<T> : TimeSeriesModelBase<T>
     private double _binWidth;
 
     // Transformer components - now using Tensor<T>
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _tokenEmbeddings;      // [vocabularySize, embeddingDim]
     [Buffer]
     private Tensor<T> _positionalEncoding;   // [maxLen, embeddingDim]
@@ -99,7 +100,9 @@ public partial class ChronosFoundationModel<T> : TimeSeriesModelBase<T>
     private Tensor<T> _outputBias;           // [vocabularySize]
 
     // Layer normalization for final output
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _finalLayerNormGamma;  // [embeddingDim]
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _finalLayerNormBeta;   // [embeddingDim]
 
     // Pre-allocated gradient computation buffers (reused across gradient steps)
@@ -922,36 +925,7 @@ private T PredictWithTemperature(Vector<T> input, double scaleFactor, double tem
 
     private const int SerializationVersion = 3;
 
-    protected override void SerializeCore(BinaryWriter writer)
-    {
-        writer.Write(SerializationVersion);
-
-        writer.Write(_vocabularySize);
-        writer.Write(_options.EmbeddingDim);
-        writer.Write(_options.ContextLength);
-        writer.Write(_options.ForecastHorizon);
-        writer.Write(_options.NumLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_binMin);
-        writer.Write(_binMax);
-
-        SerializeTensor(writer, _tokenEmbeddings);
-        SerializeTensor(writer, _positionalEncoding);
-
-        writer.Write(_transformerLayers.Count);
-        foreach (var layer in _transformerLayers)
-            layer.Serialize(writer);
 
-        SerializeTensor(writer, _finalLayerNormGamma);
-        SerializeTensor(writer, _finalLayerNormBeta);
-        SerializeTensor(writer, _outputProjection);
-        SerializeTensor(writer, _outputBias);
-
-        // Serialize training series (needed for Predict to work correctly)
-        writer.Write(_trainingSeries.Length);
-        for (int i = 0; i < _trainingSeries.Length; i++)
-            writer.Write(Convert.ToDouble(_trainingSeries[i]));
-    }
 
     private void SerializeTensor(BinaryWriter writer, Tensor<T> tensor)
     {
@@ -962,58 +936,7 @@ private void SerializeTensor(BinaryWriter writer, Tensor<T> tensor)
             writer.Write(Convert.ToDouble(tensor[i]));
     }
 
-    protected override void DeserializeCore(BinaryReader reader)
-    {
-        int version = reader.ReadInt32();
-        if (version < 2 || version > SerializationVersion)
-            throw new NotSupportedException($"Unsupported serialization version: {version}");
-
-        int vocabularySize = reader.ReadInt32();
-        int embeddingDim = reader.ReadInt32();
-        int contextLength = reader.ReadInt32();
-        int forecastHorizon = reader.ReadInt32();
-        int numLayers = reader.ReadInt32();
-        int numHeads = reader.ReadInt32();
-        _binMin = reader.ReadDouble();
-        _binMax = reader.ReadDouble();
-
-        ValidateOption(vocabularySize, _vocabularySize, "VocabularySize");
-        ValidateOption(embeddingDim, _options.EmbeddingDim, "EmbeddingDim");
-        ValidateOption(contextLength, _options.ContextLength, "ContextLength");
-        ValidateOption(forecastHorizon, _options.ForecastHorizon, "ForecastHorizon");
-        ValidateOption(numLayers, _options.NumLayers, "NumLayers");
-        ValidateOption(numHeads, _options.NumHeads, "NumHeads");
-
-        _binWidth = (_binMax - _binMin) / _vocabularySize;
 
-        _tokenEmbeddings = DeserializeTensor(reader);
-        _positionalEncoding = DeserializeTensor(reader);
-
-        int layerCount = reader.ReadInt32();
-        _transformerLayers = new List<ChronosTransformerLayerTensor<T>>(layerCount);
-        for (int i = 0; i < layerCount; i++)
-        {
-            var layer = new ChronosTransformerLayerTensor<T>();
-            layer.Deserialize(reader);
-            _transformerLayers.Add(layer);
-        }
-
-        _finalLayerNormGamma = DeserializeTensor(reader);
-        _finalLayerNormBeta = DeserializeTensor(reader);
-        _outputProjection = DeserializeTensor(reader);
-        _outputBias = DeserializeTensor(reader);
-
-        // Deserialize training series if present
-        if (reader.BaseStream.Position < reader.BaseStream.Length)
-        {
-            int tsLen = reader.ReadInt32();
-            _trainingSeries = new Vector<T>(tsLen);
-            for (int i = 0; i < tsLen; i++)
-                _trainingSeries[i] = _numOps.FromDouble(reader.ReadDouble());
-        }
-
-        InitializeGradientAccumulators();
-    }
 
     private void ValidateOption(int serialized, int expected, string name)
     {
@@ -1133,29 +1056,47 @@ internal partial class ChronosTransformerLayerTensor<T> : NeuralNetworks.Layers.
     private int _headDim;
 
     // Self-attention weights - now using Tensor<T>
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _queryProj;     // [embeddingDim, embeddingDim]
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _keyProj;       // [embeddingDim, embeddingDim]
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _valueProj;     // [embeddingDim, embeddingDim]
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _outputProj;    // [embeddingDim, embeddingDim]
 
     // Feed-forward network
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _ffn1;          // [ffnDim, embeddingDim]
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _ffn1Bias;      // [ffnDim]
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _ffn2;          // [embeddingDim, ffnDim]
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _ffn2Bias;      // [embeddingDim]
 
     // Layer normalization parameters
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _layerNorm1Gamma;
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _layerNorm1Beta;
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _layerNorm2Gamma;
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _layerNorm2Beta;
 
     // Forward pass cache for backpropagation
+    [Scratch]
     private List<Tensor<T>>? _cachedInput;
+    [Scratch]
     private List<Tensor<T>>? _cachedNorm1;
+    [Scratch]
     private List<Tensor<T>>? _cachedAttentionOutput;
+    [Scratch]
     private List<Tensor<T>>? _cachedResidual1;
+    [Scratch]
     private List<Tensor<T>>? _cachedNorm2;
+    [Scratch]
     private List<Tensor<T>>? _cachedFfnHidden;
 
     public override bool SupportsTraining => true;
@@ -1756,25 +1697,6 @@ private void ApplyGradient(Tensor<T> tensor, Tensor<T> gradient, T learningRate,
         }
     }
 
-    public override void Serialize(BinaryWriter writer)
-    {
-        writer.Write(_embeddingDim);
-        writer.Write(_numHeads);
-
-        SerializeTensor(writer, _queryProj);
-        SerializeTensor(writer, _keyProj);
-        SerializeTensor(writer, _valueProj);
-        SerializeTensor(writer, _outputProj);
-        SerializeTensor(writer, _ffn1);
-        SerializeTensor(writer, _ffn1Bias);
-        SerializeTensor(writer, _ffn2);
-        SerializeTensor(writer, _ffn2Bias);
-        SerializeTensor(writer, _layerNorm1Gamma);
-        SerializeTensor(writer, _layerNorm1Beta);
-        SerializeTensor(writer, _layerNorm2Gamma);
-        SerializeTensor(writer, _layerNorm2Beta);
-    }
-
     private void SerializeTensor(BinaryWriter writer, Tensor<T> tensor)
     {
         writer.Write(tensor.Shape.Length);
@@ -1784,29 +1706,6 @@ private void SerializeTensor(BinaryWriter writer, Tensor<T> tensor)
             writer.Write(Convert.ToDouble(tensor[i]));
     }
 
-    public override void Deserialize(BinaryReader reader)
-    {
-        int embeddingDim = reader.ReadInt32();
-        int numHeads = reader.ReadInt32();
-
-        _embeddingDim = embeddingDim;
-        _numHeads = numHeads;
-        _headDim = embeddingDim / numHeads;
-
-        _queryProj = DeserializeTensor(reader);
-        _keyProj = DeserializeTensor(reader);
-        _valueProj = DeserializeTensor(reader);
-        _outputProj = DeserializeTensor(reader);
-        _ffn1 = DeserializeTensor(reader);
-        _ffn1Bias = DeserializeTensor(reader);
-        _ffn2 = DeserializeTensor(reader);
-        _ffn2Bias = DeserializeTensor(reader);
-        _layerNorm1Gamma = DeserializeTensor(reader);
-        _layerNorm1Beta = DeserializeTensor(reader);
-        _layerNorm2Gamma = DeserializeTensor(reader);
-        _layerNorm2Beta = DeserializeTensor(reader);
-    }
-
     private Tensor<T> DeserializeTensor(BinaryReader reader)
     {
         int rank = reader.ReadInt32();
diff --git a/src/TimeSeries/DLinearModel.cs b/src/TimeSeries/DLinearModel.cs
index 7c5b63659c..9c67b6b1ba 100644
--- a/src/TimeSeries/DLinearModel.cs
+++ b/src/TimeSeries/DLinearModel.cs
@@ -1,31 +1,32 @@
-using AiDotNet.Attributes;
-using AiDotNet.Enums;
-using AiDotNet.Models.Options;

+using AiDotNet.Attributes;
+using AiDotNet.Enums;
+using AiDotNet.Models.Options;
+
 using AiDotNet.Models.Parameters;
-
-namespace AiDotNet.TimeSeries;
-
-/// <summary>
-/// DLinear — decomposition-linear forecaster (Zeng et al., AAAI 2023, "Are Transformers Effective for Time
-/// Series Forecasting?"). The input window is split into a trend (moving average) and a seasonal remainder;
-/// a separate linear map projects each to the forecast, and the two are summed. It is deliberately simple
-/// yet a strong, current baseline that often matches or beats heavier transformers on long-horizon
-/// benchmarks — the right "do we even need attention?" control in any SOTA panel.
-/// </summary>
-/// <typeparam name="T">Numeric type (float/double).</typeparam>
-[ModelDomain(ModelDomain.TimeSeries)]
-[ModelCategory(ModelCategory.TimeSeriesModel)]
-[ModelTask(ModelTask.Forecasting)]
-[ModelComplexity(ModelComplexity.Low)]
-[ModelInput(typeof(Matrix<>), typeof(Vector<>))]
-[ResearchPaper("Are Transformers Effective for Time Series Forecasting?", "https://arxiv.org/abs/2205.13504", Year = 2023, Authors = "Ailing Zeng, Muxi Chen, Lei Zhang, Qiang Xu")]
-public partial class DLinearModel<T> : TimeSeriesModelBase<T>
-{
-    private readonly DLinearOptions<T> _options;
-    private readonly Random _random;
-    private readonly int _l;
-    private readonly int _kernel;
-
+
+namespace AiDotNet.TimeSeries;
+
+/// <summary>
+/// DLinear — decomposition-linear forecaster (Zeng et al., AAAI 2023, "Are Transformers Effective for Time
+/// Series Forecasting?"). The input window is split into a trend (moving average) and a seasonal remainder;
+/// a separate linear map projects each to the forecast, and the two are summed. It is deliberately simple
+/// yet a strong, current baseline that often matches or beats heavier transformers on long-horizon
+/// benchmarks — the right "do we even need attention?" control in any SOTA panel.
+/// </summary>
+/// <typeparam name="T">Numeric type (float/double).</typeparam>
+[ModelDomain(ModelDomain.TimeSeries)]
+[ModelCategory(ModelCategory.TimeSeriesModel)]
+[ModelTask(ModelTask.Forecasting)]
+[ModelComplexity(ModelComplexity.Low)]
+[ModelInput(typeof(Matrix<>), typeof(Vector<>))]
+[ResearchPaper("Are Transformers Effective for Time Series Forecasting?", "https://arxiv.org/abs/2205.13504", Year = 2023, Authors = "Ailing Zeng, Muxi Chen, Lei Zhang, Qiang Xu")]
+public partial class DLinearModel<T> : TimeSeriesModelBase<T>
+{
+    private readonly DLinearOptions<T> _options;
+    private readonly Random _random;
+    private readonly int _l;
+    private readonly int _kernel;
+
     // Two linear maps from the length-L window to a scalar next-step forecast (ForecastHorizon=1 in the
     // supervised harness): seasonal and trend weights + biases. Stored as double for the closed-form update.
     [TrainableParameter]
@@ -36,206 +37,190 @@ public partial class DLinearModel<T> : TimeSeriesModelBase<T>
     private double _bSeasonal;
     [TrainableParameter]
     private double _bTrend;
-
-    public DLinearModel(DLinearOptions<T>? options = null)
-        : base(options ?? new DLinearOptions<T>())
-    {
-        _options = options ?? new DLinearOptions<T>();
-        Options = _options;
-        _random = RandomHelper.CreateSeededRandom(42);
-
-        _l = Math.Max(2, _options.LookbackWindow);
-        int k = Math.Max(1, Math.Min(_options.MovingAverageKernel, _l));
-        _kernel = k % 2 == 0 ? k + 1 : k; // odd kernel for a centered moving average
-
-        // Initialize both maps to a uniform 1/L (a moving-average-like start), the common DLinear init.
-        _wSeasonal = new double[_l];
-        _wTrend = new double[_l];
-        for (int j = 0; j < _l; j++)
-        {
-            _wSeasonal[j] = 1.0 / _l;
-            _wTrend[j] = 1.0 / _l;
-        }
-    }
-
-    /// <summary>Centered moving-average trend (edge-padded by replication) and the seasonal remainder.</summary>
-    private (double[] Trend, double[] Seasonal) Decompose(double[] x)
-    {
-        int n = x.Length;
-        var trend = new double[n];
-        int half = _kernel / 2;
-        for (int i = 0; i < n; i++)
-        {
-            double sum = 0;
-            for (int o = -half; o <= half; o++)
-            {
-                int idx = Math.Max(0, Math.Min(n - 1, i + o)); // replicate edges (net471: no Math.Clamp)
-                sum += x[idx];
-            }
-
-            trend[i] = sum / _kernel;
-        }
-
-        var seasonal = new double[n];
-        for (int i = 0; i < n; i++)
-        {
-            seasonal[i] = x[i] - trend[i];
-        }
-
-        return (trend, seasonal);
-    }
-
-    private double Forecast(double[] trend, double[] seasonal)
-    {
-        double pred = _bSeasonal + _bTrend;
-        for (int j = 0; j < _l; j++)
-        {
-            pred += _wSeasonal[j] * seasonal[j] + _wTrend[j] * trend[j];
-        }
-
-        return pred;
-    }
-
-    private static bool IsFiniteValue(double v) => !double.IsNaN(v) && !double.IsInfinity(v);
-
-    private static double[] LastWindow(Vector<T> input, int l)
-    {
-        var x = new double[l];
-        int start = Math.Max(0, input.Length - l);
-        for (int j = 0; j < l; j++)
-        {
-            int srcIdx = start + j;
-            double v = srcIdx < input.Length ? Convert.ToDouble(input[srcIdx]) : 0.0;
-            x[j] = IsFiniteValue(v) ? v : 0.0;
-        }
-
-        return x;
-    }
-
-    protected override void TrainCore(Matrix<T> x, Vector<T> y)
-    {
-        int n = x.Rows;
-        double lr = _options.LearningRate;
-
-        for (int epoch = 0; epoch < _options.Epochs; epoch++)
-        {
-            TrainingCancellationToken.ThrowIfCancellationRequested();
-            var order = Enumerable.Range(0, n).OrderBy(_ => _random.Next()).ToList();
-
-            // Squared error accumulated over the epoch, to report a mean loss below.
-            double epochSquaredError = 0.0;
-            int epochSamples = 0;
-
-            for (int batchStart = 0; batchStart < n; batchStart += _options.BatchSize)
-            {
-                int batchEnd = Math.Min(batchStart + _options.BatchSize, n);
-                int bs = batchEnd - batchStart;
-
-                var gS = new double[_l];
-                var gT = new double[_l];
-                double gbS = 0, gbT = 0;
-
-                for (int bi = batchStart; bi < batchEnd; bi++)
-                {
-                    int i = order[bi];
-                    var window = new double[_l];
-                    int cols = x.Columns;
-                    int start = Math.Max(0, cols - _l);
-                    for (int j = 0; j < _l; j++)
-                    {
-                        int c = start + j;
-                        double v = c < cols ? Convert.ToDouble(x[i, c]) : 0.0;
-                        window[j] = IsFiniteValue(v) ? v : 0.0;
-                    }
-
-                    var (trend, seasonal) = Decompose(window);
-                    double pred = Forecast(trend, seasonal);
-                    double err = pred - Convert.ToDouble(y[i]); // dMSE/dpred ∝ error (linear gradients)
-
-                    if (IsFiniteValue(err))
-                    {
-                        epochSquaredError += err * err;
-                        epochSamples++;
-                    }
-
-                    for (int j = 0; j < _l; j++)
-                    {
-                        gS[j] += err * seasonal[j];
-                        gT[j] += err * trend[j];
-                    }
-
-                    gbS += err;
-                    gbT += err;
-                }
-
-                double inv = bs > 0 ? 1.0 / bs : 0.0;
-                for (int j = 0; j < _l; j++)
-                {
-                    _wSeasonal[j] -= lr * gS[j] * inv;
-                    _wTrend[j] -= lr * gT[j] * inv;
-                }
-
-                _bSeasonal -= lr * gbS * inv;
-                _bTrend -= lr * gbT * inv;
-            }
-
-            // Report every epoch, including a fully diverged one (no finite sample): a non-finite loss counts
-            // as non-improving, so the training callback and patience-based early stopping still fire for the
-            // worst-case divergence this feature is meant to guard against.
-            double epochLoss = epochSamples > 0 ? epochSquaredError / epochSamples : double.PositiveInfinity;
-            if (!ReportEpoch(epoch, _options.Epochs, NumOps.FromDouble(epochLoss)))
-            {
-                break;
-            }
-        }
-
+
+    public DLinearModel(DLinearOptions<T>? options = null)
+        : base(options ?? new DLinearOptions<T>())
+    {
+        _options = options ?? new DLinearOptions<T>();
+        Options = _options;
+        _random = RandomHelper.CreateSeededRandom(42);
+
+        _l = Math.Max(2, _options.LookbackWindow);
+        int k = Math.Max(1, Math.Min(_options.MovingAverageKernel, _l));
+        _kernel = k % 2 == 0 ? k + 1 : k; // odd kernel for a centered moving average
+
+        // Initialize both maps to a uniform 1/L (a moving-average-like start), the common DLinear init.
+        _wSeasonal = new double[_l];
+        _wTrend = new double[_l];
+        for (int j = 0; j < _l; j++)
+        {
+            _wSeasonal[j] = 1.0 / _l;
+            _wTrend[j] = 1.0 / _l;
+        }
     }
-
-    public override T PredictSingle(Vector<T> input)
-    {
-        var window = LastWindow(input, _l);
-        var (trend, seasonal) = Decompose(window);
-        double pred = Forecast(trend, seasonal);
-        return NumOps.FromDouble(IsFiniteValue(pred) ? pred : 0.0);
-    }
-
-    protected override void SerializeCore(BinaryWriter writer)
-    {
-        writer.Write(_l);
-        writer.Write(_kernel);
-        for (int j = 0; j < _l; j++) { writer.Write(_wSeasonal[j]); }
-        for (int j = 0; j < _l; j++) { writer.Write(_wTrend[j]); }
-        writer.Write(_bSeasonal);
-        writer.Write(_bTrend);
-    }
-
-    protected override void DeserializeCore(BinaryReader reader)
-    {
-        reader.ReadInt32(); // _l (fixed by ctor/options)
-        reader.ReadInt32(); // _kernel
-        for (int j = 0; j < _l; j++) { _wSeasonal[j] = reader.ReadDouble(); }
-        for (int j = 0; j < _l; j++) { _wTrend[j] = reader.ReadDouble(); }
-        _bSeasonal = reader.ReadDouble();
-        _bTrend = reader.ReadDouble();
-    }
-
-    public override ModelMetadata<T> GetModelMetadata()
-    {
-        return new ModelMetadata<T>
-        {
-            Name = "DLinear",
-            Description = "Decomposition-linear forecaster (trend + seasonal linear maps) — strong simple baseline (Zeng et al. 2023)",
-            Complexity = ParameterCount,
-            FeatureCount = _options.LookbackWindow,
-            AdditionalInfo = new Dictionary<string, object>
-            {
-                { "LookbackWindow", _options.LookbackWindow },
-                { "ForecastHorizon", _options.ForecastHorizon },
-                { "MovingAverageKernel", _kernel },
-            },
-        };
-    }
-
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateInstance()
-        => new DLinearModel<T>(new DLinearOptions<T>(_options));
-}
+
+    /// <summary>Centered moving-average trend (edge-padded by replication) and the seasonal remainder.</summary>
+    private (double[] Trend, double[] Seasonal) Decompose(double[] x)
+    {
+        int n = x.Length;
+        var trend = new double[n];
+        int half = _kernel / 2;
+        for (int i = 0; i < n; i++)
+        {
+            double sum = 0;
+            for (int o = -half; o <= half; o++)
+            {
+                int idx = Math.Max(0, Math.Min(n - 1, i + o)); // replicate edges (net471: no Math.Clamp)
+                sum += x[idx];
+            }
+
+            trend[i] = sum / _kernel;
+        }
+
+        var seasonal = new double[n];
+        for (int i = 0; i < n; i++)
+        {
+            seasonal[i] = x[i] - trend[i];
+        }
+
+        return (trend, seasonal);
+    }
+
+    private double Forecast(double[] trend, double[] seasonal)
+    {
+        double pred = _bSeasonal + _bTrend;
+        for (int j = 0; j < _l; j++)
+        {
+            pred += _wSeasonal[j] * seasonal[j] + _wTrend[j] * trend[j];
+        }
+
+        return pred;
+    }
+
+    private static bool IsFiniteValue(double v) => !double.IsNaN(v) && !double.IsInfinity(v);
+
+    private static double[] LastWindow(Vector<T> input, int l)
+    {
+        var x = new double[l];
+        int start = Math.Max(0, input.Length - l);
+        for (int j = 0; j < l; j++)
+        {
+            int srcIdx = start + j;
+            double v = srcIdx < input.Length ? Convert.ToDouble(input[srcIdx]) : 0.0;
+            x[j] = IsFiniteValue(v) ? v : 0.0;
+        }
+
+        return x;
+    }
+
+    protected override void TrainCore(Matrix<T> x, Vector<T> y)
+    {
+        int n = x.Rows;
+        double lr = _options.LearningRate;
+
+        for (int epoch = 0; epoch < _options.Epochs; epoch++)
+        {
+            TrainingCancellationToken.ThrowIfCancellationRequested();
+            var order = Enumerable.Range(0, n).OrderBy(_ => _random.Next()).ToList();
+
+            // Squared error accumulated over the epoch, to report a mean loss below.
+            double epochSquaredError = 0.0;
+            int epochSamples = 0;
+
+            for (int batchStart = 0; batchStart < n; batchStart += _options.BatchSize)
+            {
+                int batchEnd = Math.Min(batchStart + _options.BatchSize, n);
+                int bs = batchEnd - batchStart;
+
+                var gS = new double[_l];
+                var gT = new double[_l];
+                double gbS = 0, gbT = 0;
+
+                for (int bi = batchStart; bi < batchEnd; bi++)
+                {
+                    int i = order[bi];
+                    var window = new double[_l];
+                    int cols = x.Columns;
+                    int start = Math.Max(0, cols - _l);
+                    for (int j = 0; j < _l; j++)
+                    {
+                        int c = start + j;
+                        double v = c < cols ? Convert.ToDouble(x[i, c]) : 0.0;
+                        window[j] = IsFiniteValue(v) ? v : 0.0;
+                    }
+
+                    var (trend, seasonal) = Decompose(window);
+                    double pred = Forecast(trend, seasonal);
+                    double err = pred - Convert.ToDouble(y[i]); // dMSE/dpred ∝ error (linear gradients)
+
+                    if (IsFiniteValue(err))
+                    {
+                        epochSquaredError += err * err;
+                        epochSamples++;
+                    }
+
+                    for (int j = 0; j < _l; j++)
+                    {
+                        gS[j] += err * seasonal[j];
+                        gT[j] += err * trend[j];
+                    }
+
+                    gbS += err;
+                    gbT += err;
+                }
+
+                double inv = bs > 0 ? 1.0 / bs : 0.0;
+                for (int j = 0; j < _l; j++)
+                {
+                    _wSeasonal[j] -= lr * gS[j] * inv;
+                    _wTrend[j] -= lr * gT[j] * inv;
+                }
+
+                _bSeasonal -= lr * gbS * inv;
+                _bTrend -= lr * gbT * inv;
+            }
+
+            // Report every epoch, including a fully diverged one (no finite sample): a non-finite loss counts
+            // as non-improving, so the training callback and patience-based early stopping still fire for the
+            // worst-case divergence this feature is meant to guard against.
+            double epochLoss = epochSamples > 0 ? epochSquaredError / epochSamples : double.PositiveInfinity;
+            if (!ReportEpoch(epoch, _options.Epochs, NumOps.FromDouble(epochLoss)))
+            {
+                break;
+            }
+        }
+
+    }
+
+    public override T PredictSingle(Vector<T> input)
+    {
+        var window = LastWindow(input, _l);
+        var (trend, seasonal) = Decompose(window);
+        double pred = Forecast(trend, seasonal);
+        return NumOps.FromDouble(IsFiniteValue(pred) ? pred : 0.0);
+    }
+
+
+
+
+
+    public override ModelMetadata<T> GetModelMetadata()
+    {
+        return new ModelMetadata<T>
+        {
+            Name = "DLinear",
+            Description = "Decomposition-linear forecaster (trend + seasonal linear maps) — strong simple baseline (Zeng et al. 2023)",
+            Complexity = ParameterCount,
+            FeatureCount = _options.LookbackWindow,
+            AdditionalInfo = new Dictionary<string, object>
+            {
+                { "LookbackWindow", _options.LookbackWindow },
+                { "ForecastHorizon", _options.ForecastHorizon },
+                { "MovingAverageKernel", _kernel },
+            },
+        };
+    }
+
+    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateInstance()
+        => new DLinearModel<T>(new DLinearOptions<T>(_options));
+}
diff --git a/src/TimeSeries/DeepARDistributionHeads.cs b/src/TimeSeries/DeepARDistributionHeads.cs
index 3eca9f4853..82fbf8d815 100644
--- a/src/TimeSeries/DeepARDistributionHeads.cs
+++ b/src/TimeSeries/DeepARDistributionHeads.cs
@@ -119,22 +119,6 @@ protected Tensor<T> StackStepsToBL(Tensor<T>[] steps)
 
     public override bool SupportsTraining => true;
     public override void ResetState() { }
-    public override void Serialize(BinaryWriter writer)
-    {
-        writer.Write(Hidden);
-        writer.Write(_params.Count);
-        foreach (var p in _params)
-            WriteTensor(writer, p);
-    }
-
-    public override void Deserialize(BinaryReader reader)
-    {
-        reader.ReadInt32(); // hidden
-        int count = reader.ReadInt32();
-        for (int i = 0; i < count && i < _params.Count; i++)
-            ReadTensorInto(reader, _params[i]);
-    }
-
     protected static void WriteTensor(BinaryWriter writer, Tensor<T> tensor)
     {
         writer.Write(tensor.Shape.Length);
diff --git a/src/TimeSeries/DeepARModel.cs b/src/TimeSeries/DeepARModel.cs
index fad39ea19c..f77a32486b 100644
--- a/src/TimeSeries/DeepARModel.cs
+++ b/src/TimeSeries/DeepARModel.cs
@@ -763,78 +763,9 @@ private DeepARPredictiveDist<T> PredictDistNormCov(Vector<T> seriesWindow, T[][]
         return _head.PredictNorm(hState[layers - 1], lastNorm);
     }
 
-    protected override void SerializeCore(BinaryWriter writer)
-    {
-        writer.Write(_options.HiddenSize);
-        writer.Write(_options.NumLayers);
-        // Persist the head selector so deserialize rebuilds the SAME distribution head regardless of the
-        // options passed to the deserializing constructor.
-        writer.Write(_options.LikelihoodType ?? "Gaussian");
-        writer.Write(_options.StudentTDegreesOfFreedom);
-        writer.Write(_options.CovariateSize); // needed before InitializeModel to size the first LSTM layer
-
-        writer.Write(_lstmLayers.Count);
-        foreach (var lstm in _lstmLayers)
-            lstm.Serialize(writer);
-
-        _head.Serialize(writer);
-
-        writer.Write(Convert.ToDouble(_normMean));
-        writer.Write(Convert.ToDouble(_normStd));
-
-        // Covariate standardization stats (empty for the univariate model).
-        writer.Write(_covMean.Length);
-        for (int c = 0; c < _covMean.Length; c++)
-        {
-            writer.Write(Convert.ToDouble(_covMean[c]));
-            writer.Write(Convert.ToDouble(_covStd[c]));
-        }
-
-        writer.Write(_trainingSeries.Length);
-        for (int i = 0; i < _trainingSeries.Length; i++)
-            writer.Write(NumOps.ToDouble(_trainingSeries[i]));
-    }
-
-    protected override void DeserializeCore(BinaryReader reader)
-    {
-        _options.HiddenSize = reader.ReadInt32();
-        _options.NumLayers = reader.ReadInt32();
-        _options.LikelihoodType = reader.ReadString();
-        _options.StudentTDegreesOfFreedom = reader.ReadDouble();
-        _options.CovariateSize = reader.ReadInt32();
-
-        InitializeModel();
-
-        int numLayers = reader.ReadInt32();
-        for (int i = 0; i < numLayers && i < _lstmLayers.Count; i++)
-            _lstmLayers[i].Deserialize(reader);
 
-        _head.Deserialize(reader);
 
-        _normMean = NumOps.FromDouble(reader.ReadDouble());
-        _normStd = NumOps.FromDouble(reader.ReadDouble());
-
-        int covLen = reader.ReadInt32();
-        _covMean = new T[covLen];
-        _covStd = new T[covLen];
-        for (int c = 0; c < covLen; c++)
-        {
-            _covMean[c] = NumOps.FromDouble(reader.ReadDouble());
-            _covStd[c] = NumOps.FromDouble(reader.ReadDouble());
-        }
 
-        try
-        {
-            int tsLen = reader.ReadInt32();
-            _trainingSeries = new Vector<T>(tsLen);
-            for (int i = 0; i < tsLen; i++)
-                _trainingSeries[i] = NumOps.FromDouble(reader.ReadDouble());
-        }
-        catch (EndOfStreamException)
-        {
-            _trainingSeries = Vector<T>.Empty();
-        }
-    }
 
     public override ModelMetadata<T> GetModelMetadata()
     {
@@ -860,26 +791,6 @@ protected override IFullModel<T, Matrix<T>, Vector<T>> CreateInstance()
         return new DeepARModel<T>(new DeepAROptions<T>(_options));
     }
 
-    public override IFullModel<T, Matrix<T>, Vector<T>> Clone()
-    {
-        var clone = new DeepARModel<T>(new DeepAROptions<T>(_options));
-        // Trained layers are read-only after training — safe to share by reference.
-        clone._lstmLayers.Clear();
-        clone._lstmLayers.AddRange(_lstmLayers);
-        clone._head = _head;
-        if (_trainingSeries.Length > 0)
-            clone._trainingSeries = new Vector<T>(_trainingSeries);
-        if (ModelParameters is not null && ModelParameters.Length > 0)
-            clone.ModelParameters = new Vector<T>(ModelParameters);
-        clone._normMean = _normMean;
-        clone._normStd = _normStd;
-        clone._covMean = (T[])_covMean.Clone();
-        clone._covStd = (T[])_covStd.Clone();
-        return clone;
-    }
-
-    public override IFullModel<T, Matrix<T>, Vector<T>> DeepCopy() => Clone();
-
     // ParameterCount restated a fold the base now derives from generated component registration.
     // Removed under AIDN082.
     /// <summary>
@@ -1031,24 +942,6 @@ private Tensor<T> CreateRandomTensor(int[] shape, double stddev, Random random)
         return (hNew, cNew);
     }
 
-    public override void Serialize(BinaryWriter writer)
-    {
-        writer.Write(_inputSize);
-        writer.Write(_hiddenSize);
-        WriteTensor(writer, _wx);
-        WriteTensor(writer, _wh);
-        WriteTensor(writer, _bias);
-    }
-
-    public override void Deserialize(BinaryReader reader)
-    {
-        reader.ReadInt32(); // inputSize
-        reader.ReadInt32(); // hiddenSize
-        ReadTensorInto(reader, _wx);
-        ReadTensorInto(reader, _wh);
-        ReadTensorInto(reader, _bias);
-    }
-
     private static void WriteTensor(BinaryWriter writer, Tensor<T> tensor)
     {
         writer.Write(tensor.Shape.Length);
diff --git a/src/TimeSeries/DynamicRegressionWithARIMAErrors.cs b/src/TimeSeries/DynamicRegressionWithARIMAErrors.cs
index aef81cbc6e..4284d68652 100644
--- a/src/TimeSeries/DynamicRegressionWithARIMAErrors.cs
+++ b/src/TimeSeries/DynamicRegressionWithARIMAErrors.cs
@@ -183,6 +183,7 @@ public DynamicRegressionWithARIMAErrors()
     /// The model learns these coefficients from your historical data to quantify relationships
     /// between external factors and what you're predicting.
     /// </remarks>
+    [AiDotNet.Attributes.Scratch]
     private Vector<T> _regressionCoefficients;
 
     /// <summary>
@@ -198,6 +199,7 @@ public DynamicRegressionWithARIMAErrors()
     /// 
     /// These coefficients are applied to the regression residuals (errors), not to the original time series.
     /// </remarks>
+    [AiDotNet.Attributes.FittedParameter]
     private Vector<T> _arCoefficients;
 
     /// <summary>
@@ -212,6 +214,7 @@ public DynamicRegressionWithARIMAErrors()
     /// 
     /// This helps the model correct for systematic errors in its predictions.
     /// </remarks>
+    [AiDotNet.Attributes.FittedParameter]
     private Vector<T> _maCoefficients;
 
     /// <summary>
@@ -1306,33 +1309,7 @@ public override Dictionary<string, T> EvaluateModel(Matrix<T> xTest, Vector<T> y
     /// 
     /// This allows the model to be fully reconstructed later.
     /// </remarks>
-    protected override void SerializeCore(BinaryWriter writer)
-    {
-        writer.Write(_regressionCoefficients.Length);
-        for (int i = 0; i < _regressionCoefficients.Length; i++)
-            writer.Write(Convert.ToDouble(_regressionCoefficients[i]));
-
-        writer.Write(_arCoefficients.Length);
-        for (int i = 0; i < _arCoefficients.Length; i++)
-            writer.Write(Convert.ToDouble(_arCoefficients[i]));
-
-        writer.Write(_maCoefficients.Length);
-        for (int i = 0; i < _maCoefficients.Length; i++)
-            writer.Write(Convert.ToDouble(_maCoefficients[i]));
-
-        writer.Write(_differenced.Length);
-        for (int i = 0; i < _differenced.Length; i++)
-            writer.Write(Convert.ToDouble(_differenced[i]));
-
-        writer.Write(Convert.ToDouble(_intercept));
 
-        writer.Write(JsonConvert.SerializeObject(Options));
-
-        // Serialize training series for in-sample predictions
-        writer.Write(_trainingSeries.Length);
-        for (int i = 0; i < _trainingSeries.Length; i++)
-            writer.Write(Convert.ToDouble(_trainingSeries[i]));
-    }
 
     /// <summary>
     /// Deserializes the model's state from a binary stream.
@@ -1357,45 +1334,7 @@ protected override void SerializeCore(BinaryWriter writer)
     /// 
     /// After deserialization, the model is ready to make predictions as if it had just been trained.
     /// </remarks>
-    protected override void DeserializeCore(BinaryReader reader)
-    {
-        int regressionCoefficientsLength = reader.ReadInt32();
-        _regressionCoefficients = new Vector<T>(regressionCoefficientsLength);
-        for (int i = 0; i < regressionCoefficientsLength; i++)
-            _regressionCoefficients[i] = NumOps.FromDouble(reader.ReadDouble());
-
-        int arCoefficientsLength = reader.ReadInt32();
-        _arCoefficients = new Vector<T>(arCoefficientsLength);
-        for (int i = 0; i < arCoefficientsLength; i++)
-            _arCoefficients[i] = NumOps.FromDouble(reader.ReadDouble());
-
-        int maCoeffientsLength = reader.ReadInt32();
-        _maCoefficients = new Vector<T>(maCoeffientsLength);
-        for (int i = 0; i < maCoeffientsLength; i++)
-            _maCoefficients[i] = NumOps.FromDouble(reader.ReadDouble());
-
-        int differencedLength = reader.ReadInt32();
-        _differenced = new Vector<T>(differencedLength);
-        for (int i = 0; i < differencedLength; i++)
-            _differenced[i] = NumOps.FromDouble(reader.ReadDouble());
-
-        _intercept = NumOps.FromDouble(reader.ReadDouble());
 
-        string optionsJson = reader.ReadString();
-
-        // Deserialize training series (post-patch field)
-        try
-        {
-            int tsLen = reader.ReadInt32();
-            _trainingSeries = new Vector<T>(tsLen);
-            for (int i = 0; i < tsLen; i++)
-                _trainingSeries[i] = NumOps.FromDouble(reader.ReadDouble());
-        }
-        catch (EndOfStreamException)
-        {
-            _trainingSeries = Vector<T>.Empty();
-        }
-    }
 
     /// <summary>
     /// Resets the model to its untrained state.
@@ -1471,77 +1410,6 @@ protected override IFullModel<T, Matrix<T>, Vector<T>> CreateInstance()
         return new DynamicRegressionWithARIMAErrors<T>(optionsClone);
     }
 
-    /// <summary>
-    /// Creates a deep copy of the current model.
-    /// </summary>
-    /// <returns>A new instance of the model with the same state and parameters.</returns>
-    /// <remarks>
-    /// <para>
-    /// This method creates a complete copy of the model, including its configuration and trained parameters.
-    /// </para>
-    /// <para><b>For Beginners:</b> This method creates an exact duplicate of your trained model.
-    /// 
-    /// Unlike CreateInstance(), which creates a blank model with the same settings,
-    /// Clone() creates a complete copy including:
-    /// - The model configuration (AR order, MA order, etc.)
-    /// - All trained regression coefficients
-    /// - All trained AR and MA coefficients
-    /// - Differencing information and intercept value
-    /// 
-    /// This is useful for:
-    /// - Creating a backup before experimenting with a model
-    /// - Using the same trained model in multiple scenarios
-    /// - Creating ensemble models that use variations of the same base model
-    /// </para>
-    /// </remarks>
-    public override IFullModel<T, Matrix<T>, Vector<T>> Clone()
-    {
-        var clone = (DynamicRegressionWithARIMAErrors<T>)CreateInstance();
-
-        // Copy regression coefficients
-        for (int i = 0; i < _regressionCoefficients.Length; i++)
-        {
-            clone._regressionCoefficients[i] = _regressionCoefficients[i];
-        }
-
-        // Copy AR coefficients
-        for (int i = 0; i < _arCoefficients.Length; i++)
-        {
-            clone._arCoefficients[i] = _arCoefficients[i];
-        }
-
-        // Copy MA coefficients
-        for (int i = 0; i < _maCoefficients.Length; i++)
-        {
-            clone._maCoefficients[i] = _maCoefficients[i];
-        }
-
-        // Copy differenced values
-        clone._differenced = new Vector<T>(_differenced.Length);
-        for (int i = 0; i < _differenced.Length; i++)
-        {
-            clone._differenced[i] = _differenced[i];
-        }
-
-        // Copy intercept
-        clone._intercept = _intercept;
-
-        // Copy training series for in-sample predictions
-        if (_trainingSeries.Length > 0)
-        {
-            clone._trainingSeries = new Vector<T>(_trainingSeries.Length);
-            for (int i = 0; i < _trainingSeries.Length; i++)
-                clone._trainingSeries[i] = _trainingSeries[i];
-        }
-
-        // Copy trained state
-        clone.IsTrained = IsTrained;
-        if (ModelParameters.Length > 0)
-            clone.ModelParameters = ModelParameters.Clone();
-
-        return clone;
-    }
-
     /// <summary>
     /// Forecasts future values based on a history of time series data and exogenous variables.
     /// </summary>
diff --git a/src/TimeSeries/ExponentialSmoothingModel.cs b/src/TimeSeries/ExponentialSmoothingModel.cs
index 7ae0345aa7..22cb44745e 100644
--- a/src/TimeSeries/ExponentialSmoothingModel.cs
+++ b/src/TimeSeries/ExponentialSmoothingModel.cs
@@ -158,6 +158,7 @@ public ExponentialSmoothingModel()
     /// The model uses these as starting points and then updates them as it processes more data.
     /// </para>
     /// </remarks>
+    [AiDotNet.Attributes.FittedParameter]
     private Vector<T> _initialValues;
 
     /// <summary>
@@ -631,36 +632,7 @@ public override Dictionary<string, T> EvaluateModel(Matrix<T> xTest, Vector<T> y
     /// </remarks>
     private const byte SerializationVersion = 2;
 
-    protected override void SerializeCore(BinaryWriter writer)
-    {
-        // Version marker for forward-compatible deserialization
-        writer.Write(SerializationVersion);
-
-        writer.Write(Convert.ToDouble(_alpha));
-        writer.Write(Convert.ToDouble(_beta));
-        writer.Write(Convert.ToDouble(_gamma));
-        writer.Write(_initialValues.Length);
-
-        foreach (var value in _initialValues)
-        {
-            writer.Write(Convert.ToDouble(value));
-        }
 
-        // Trained state fields (added in version 2)
-        writer.Write(Convert.ToDouble(_trainedLevel));
-        writer.Write(Convert.ToDouble(_trainedTrend));
-        writer.Write(_trainedSeasonalFactors.Length);
-        foreach (var value in _trainedSeasonalFactors)
-        {
-            writer.Write(Convert.ToDouble(value));
-        }
-        writer.Write(_trainingLength);
-
-        // Fitted values for in-sample prediction via Clone
-        writer.Write(_fittedValues.Length);
-        for (int i = 0; i < _fittedValues.Length; i++)
-            writer.Write(Convert.ToDouble(_fittedValues[i]));
-    }
 
     /// <summary>
     /// Deserializes the model's core parameters from a binary reader.
@@ -683,75 +655,7 @@ protected override void SerializeCore(BinaryWriter writer)
     /// to continue using the model without having to train it again.
     /// </para>
     /// </remarks>
-    protected override void DeserializeCore(BinaryReader reader)
-    {
-        // Peek at the first byte to detect version marker vs legacy format.
-        // Version 2+ writes a byte marker first; legacy (version 1) starts with a double (alpha).
-        // A double's first byte is extremely unlikely to be exactly 0x02 for typical alpha values,
-        // but we use stream position to disambiguate: if the first byte matches a known version
-        // AND there's enough remaining data for the versioned format, treat it as versioned.
-        byte firstByte = reader.ReadByte();
-        bool isVersioned = firstByte >= 2 && firstByte <= 10; // Reserve versions 2-10
-
-        if (!isVersioned)
-        {
-            // Legacy format: first byte was part of the alpha double. Seek back and read normally.
-            reader.BaseStream.Position -= 1;
-        }
-
-        _alpha = NumOps.FromDouble(reader.ReadDouble());
-        _beta = NumOps.FromDouble(reader.ReadDouble());
-        _gamma = NumOps.FromDouble(reader.ReadDouble());
-        int initialValuesLength = reader.ReadInt32();
-        _initialValues = new Vector<T>(initialValuesLength);
-
-        for (int i = 0; i < initialValuesLength; i++)
-        {
-            _initialValues[i] = NumOps.FromDouble(reader.ReadDouble());
-        }
 
-        // Trained state fields (version 2+, or legacy with remaining data)
-        if (isVersioned || reader.BaseStream.Position < reader.BaseStream.Length)
-        {
-            _trainedLevel = NumOps.FromDouble(reader.ReadDouble());
-            _trainedTrend = NumOps.FromDouble(reader.ReadDouble());
-            int seasonalLength = reader.ReadInt32();
-            _trainedSeasonalFactors = new Vector<T>(seasonalLength);
-            for (int i = 0; i < seasonalLength; i++)
-            {
-                _trainedSeasonalFactors[i] = NumOps.FromDouble(reader.ReadDouble());
-            }
-            _trainingLength = reader.ReadInt32();
-
-            // Fitted values
-            if (reader.BaseStream.Position < reader.BaseStream.Length)
-            {
-                int fittedLen = reader.ReadInt32();
-                _fittedValues = new Vector<T>(fittedLen);
-                for (int i = 0; i < fittedLen; i++)
-                    _fittedValues[i] = NumOps.FromDouble(reader.ReadDouble());
-            }
-        }
-        else
-        {
-            // Seed trained state from initial values so legacy models still forecast correctly
-            _trainedLevel = _initialValues.Length > 0 ? _initialValues[0] : NumOps.Zero;
-            _trainedTrend = _initialValues.Length > 1 ? _initialValues[1] : NumOps.Zero;
-            if (Options.SeasonalPeriod > 0 && _initialValues.Length >= Options.SeasonalPeriod + 2)
-            {
-                _trainedSeasonalFactors = new Vector<T>(Options.SeasonalPeriod);
-                for (int i = 0; i < Options.SeasonalPeriod; i++)
-                {
-                    _trainedSeasonalFactors[i] = _initialValues[i + 2];
-                }
-            }
-            else
-            {
-                _trainedSeasonalFactors = Vector<T>.Empty();
-            }
-            _trainingLength = 0;
-        }
-    }
 
     /// <summary>
     /// Resets the model to its initial state.
@@ -785,24 +689,6 @@ public override void Reset()
         _trainingLength = 0;
     }
 
-    /// <summary>
-    /// Creates a deep copy of the current exponential smoothing model, including all trained state.
-    /// </summary>
-    /// <returns>A new instance with the same trained state.</returns>
-    public override IFullModel<T, Matrix<T>, Vector<T>> Clone()
-    {
-        var clone = (ExponentialSmoothingModel<T>)base.Clone();
-        clone._alpha = _alpha;
-        clone._beta = _beta;
-        clone._gamma = _gamma;
-        clone._initialValues = _initialValues.Length > 0 ? _initialValues.Clone() : Vector<T>.Empty();
-        clone._trainedLevel = _trainedLevel;
-        clone._trainedTrend = _trainedTrend;
-        clone._trainedSeasonalFactors = _trainedSeasonalFactors.Length > 0 ? _trainedSeasonalFactors.Clone() : Vector<T>.Empty();
-        clone._trainingLength = _trainingLength;
-        return clone;
-    }
-
     /// <summary>
     /// Creates a new instance of the exponential smoothing model with the same options.
     /// </summary>
diff --git a/src/TimeSeries/GARCHModel.cs b/src/TimeSeries/GARCHModel.cs
index e6397fc1e2..700208dbf5 100644
--- a/src/TimeSeries/GARCHModel.cs
+++ b/src/TimeSeries/GARCHModel.cs
@@ -116,6 +116,7 @@ public partial class GARCHModel<T> : TimeSeriesModelBase<T>
     /// even during the calmest market periods.
     /// </para>
     /// </remarks>
+    [AiDotNet.Attributes.FittedParameter]
     private Vector<T> _omega; // Constant term in variance equation
 
     /// <summary>
@@ -137,6 +138,7 @@ public partial class GARCHModel<T> : TimeSeriesModelBase<T>
     /// will cause the model to predict higher volatility in the near future.
     /// </para>
     /// </remarks>
+    [AiDotNet.Attributes.FittedParameter]
     private Vector<T> _alpha; // ARCH coefficients
 
     /// <summary>
@@ -158,6 +160,7 @@ public partial class GARCHModel<T> : TimeSeriesModelBase<T>
     /// will likely be followed by more periods of high volatility.
     /// </para>
     /// </remarks>
+    [AiDotNet.Attributes.FittedParameter]
     private Vector<T> _beta;  // GARCH coefficients
 
     /// <summary>
@@ -886,21 +889,7 @@ public override Dictionary<string, T> EvaluateModel(Matrix<T> xTest, Vector<T> y
     /// having to start from scratch.
     /// </para>
     /// </remarks>
-    protected override void SerializeCore(BinaryWriter writer)
-    {
-        SerializationHelper<T>.SerializeVector(writer, _omega);
-        SerializationHelper<T>.SerializeVector(writer, _alpha);
-        SerializationHelper<T>.SerializeVector(writer, _beta);
-        SerializationHelper<T>.SerializeVector(writer, _residuals);
-        SerializationHelper<T>.SerializeVector(writer, _conditionalVariances);
-
-        writer.Write(JsonConvert.SerializeObject(_garchOptions));
-
-        // Serialize the mean model so it can be restored on deserialization
-        byte[] meanModelBytes = _meanModel.Serialize();
-        writer.Write(meanModelBytes.Length);
-        writer.Write(meanModelBytes);
-    }
+
 
     /// <summary>
     /// Deserializes the model's core parameters from a binary reader.
@@ -928,23 +917,7 @@ protected override void SerializeCore(BinaryWriter writer)
     /// to continue using the model without having to train it again.
     /// </para>
     /// </remarks>
-    protected override void DeserializeCore(BinaryReader reader)
-    {
-        _omega = SerializationHelper<T>.DeserializeVector(reader);
-        _alpha = SerializationHelper<T>.DeserializeVector(reader);
-        _beta = SerializationHelper<T>.DeserializeVector(reader);
-        _residuals = SerializationHelper<T>.DeserializeVector(reader);
-        _conditionalVariances = SerializationHelper<T>.DeserializeVector(reader);
-
-        string optionsJson = reader.ReadString();
-        _garchOptions = JsonConvert.DeserializeObject<GARCHModelOptions<T>>(optionsJson) ?? new();
-
-        // Deserialize the mean model to restore its trained state
-        int meanModelBytesLength = reader.ReadInt32();
-        byte[] meanModelBytes = reader.ReadBytes(meanModelBytesLength);
-        _meanModel = _garchOptions.MeanModel ?? new ARIMAModel<T>();
-        _meanModel.Deserialize(meanModelBytes);
-    }
+
 
     /// <summary>
     /// Resets the model to its initial state.
diff --git a/src/TimeSeries/InformerModel.cs b/src/TimeSeries/InformerModel.cs
index d95359ac1e..77f761f7e3 100644
--- a/src/TimeSeries/InformerModel.cs
+++ b/src/TimeSeries/InformerModel.cs
@@ -1095,6 +1095,7 @@ internal partial class InformerEncoderLayerTensor<T> : NeuralNetworks.Layers.Lay
     private readonly int _sparsityFactor;
 
     // Multi-head attention weights (Tensor-based)
+    [AiDotNet.Attributes.TrainableParameter]
     private  Tensor<T> _queryProj;
     internal Tensor<T> GetQueryProjection() => _queryProj;
     internal Tensor<T> GetKeyProjection() => _keyProj;
@@ -1108,20 +1109,31 @@ internal partial class InformerEncoderLayerTensor<T> : NeuralNetworks.Layers.Lay
     internal Tensor<T> GetLayerNorm1Beta() => _layerNorm1Beta;
     internal Tensor<T> GetLayerNorm2Gamma() => _layerNorm2Gamma;
     internal Tensor<T> GetLayerNorm2Beta() => _layerNorm2Beta;
+    [AiDotNet.Attributes.TrainableParameter]
     private  Tensor<T> _keyProj;
+    [AiDotNet.Attributes.TrainableParameter]
     private  Tensor<T> _valueProj;
+    [AiDotNet.Attributes.TrainableParameter]
     private  Tensor<T> _outputProj;
 
     // Feed-forward network (Tensor-based)
+    [AiDotNet.Attributes.TrainableParameter]
     private  Tensor<T> _ffn1;
+    [AiDotNet.Attributes.TrainableParameter]
     private  Tensor<T> _ffn1Bias;
+    [AiDotNet.Attributes.TrainableParameter]
     private  Tensor<T> _ffn2;
+    [AiDotNet.Attributes.TrainableParameter]
     private  Tensor<T> _ffn2Bias;
 
     // Layer normalization parameters (Tensor-based)
+    [AiDotNet.Attributes.TrainableParameter]
     private  Tensor<T> _layerNorm1Gamma;
+    [AiDotNet.Attributes.TrainableParameter]
     private  Tensor<T> _layerNorm1Beta;
+    [AiDotNet.Attributes.TrainableParameter]
     private  Tensor<T> _layerNorm2Gamma;
+    [AiDotNet.Attributes.TrainableParameter]
     private  Tensor<T> _layerNorm2Beta;
 
     public override bool SupportsTraining => true;
@@ -1129,9 +1141,13 @@ public override void ResetState() { }
     protected override Tensor<T> ForwardTraced(Tensor<T> input) => throw new NotSupportedException(
         "Informer runs its forward pass at the model level (InformerModel.ForwardBatch); the layer-level Forward is unused.");
 
+    /// <summary>Construction state: the 'dropoutRate' the layer was built with.</summary>
+    private readonly double _dropoutRate;
+
     public InformerEncoderLayerTensor(int embeddingDim, int numHeads, int sparsityFactor, double dropoutRate, int seed = 42)
         : base(new[] { embeddingDim }, new[] { embeddingDim })
     {
+        _dropoutRate = dropoutRate;
         _embeddingDim = embeddingDim;
         _numHeads = numHeads;
         _headDim = embeddingDim / numHeads;
@@ -1317,7 +1333,9 @@ internal partial class DistillingConvTensor<T> : NeuralNetworks.Layers.LayerBase
     private readonly int _embeddingDim;
     private readonly int _distillingFactor;
 
+    [AiDotNet.Attributes.TrainableParameter]
     private  Tensor<T> _convWeights;  // [embeddingDim, 3] for kernel size 3
+    [AiDotNet.Attributes.TrainableParameter]
     private  Tensor<T> _convBias;
 
     // Tape accessors so the IEngine forward can run the distilling conv/pool as tracked ops
@@ -1331,9 +1349,13 @@ public override void ResetState() { }
     protected override Tensor<T> ForwardTraced(Tensor<T> input) => throw new NotSupportedException(
         "Informer runs its forward pass at the model level (InformerModel.ForwardBatch); the layer-level Forward is unused.");
 
+    /// <summary>Construction state: the 'inputSeqLen' the layer was built with.</summary>
+    private readonly int _inputSeqLen;
+
     public DistillingConvTensor(int embeddingDim, int inputSeqLen, int distillingFactor, int seed = 42)
         : base(new[] { embeddingDim }, new[] { embeddingDim })
     {
+        _inputSeqLen = inputSeqLen;
         _embeddingDim = embeddingDim;
         _distillingFactor = distillingFactor;
 
@@ -1451,29 +1473,46 @@ internal partial class InformerDecoderLayerTensor<T> : NeuralNetworks.Layers.Lay
     private readonly int _headDim;
 
     // Self-attention weights
+    [AiDotNet.Attributes.TrainableParameter]
     private  Tensor<T> _selfQueryProj;
+    [AiDotNet.Attributes.TrainableParameter]
     private  Tensor<T> _selfKeyProj;
+    [AiDotNet.Attributes.TrainableParameter]
     private  Tensor<T> _selfValueProj;
+    [AiDotNet.Attributes.TrainableParameter]
     private  Tensor<T> _selfOutputProj;
 
     // Cross-attention weights
+    [AiDotNet.Attributes.TrainableParameter]
     private  Tensor<T> _crossQueryProj;
+    [AiDotNet.Attributes.TrainableParameter]
     private  Tensor<T> _crossKeyProj;
+    [AiDotNet.Attributes.TrainableParameter]
     private  Tensor<T> _crossValueProj;
+    [AiDotNet.Attributes.TrainableParameter]
     private  Tensor<T> _crossOutputProj;
 
     // FFN
     private  Tensor<T> _ffn1;
+    [AiDotNet.Attributes.TrainableParameter]
     private  Tensor<T> _ffn1Bias;
+    [AiDotNet.Attributes.TrainableParameter]
     private  Tensor<T> _ffn2;
+    [AiDotNet.Attributes.TrainableParameter]
     private  Tensor<T> _ffn2Bias;
 
     // Layer norms
+    [AiDotNet.Attributes.TrainableParameter]
     private  Tensor<T> _layerNorm1Gamma;
+    [AiDotNet.Attributes.TrainableParameter]
     private  Tensor<T> _layerNorm1Beta;
+    [AiDotNet.Attributes.TrainableParameter]
     private  Tensor<T> _layerNorm2Gamma;
+    [AiDotNet.Attributes.TrainableParameter]
     private  Tensor<T> _layerNorm2Beta;
+    [AiDotNet.Attributes.TrainableParameter]
     private  Tensor<T> _layerNorm3Gamma;
+    [AiDotNet.Attributes.TrainableParameter]
     private  Tensor<T> _layerNorm3Beta;
     internal Tensor<T> GetSelfQueryProjection() => _selfQueryProj;
     internal Tensor<T> GetSelfKeyProjection() => _selfKeyProj;
@@ -1499,9 +1538,17 @@ public override void ResetState() { }
     protected override Tensor<T> ForwardTraced(Tensor<T> input) => throw new NotSupportedException(
         "Informer runs its forward pass at the model level (InformerModel.ForwardBatch); the layer-level Forward is unused.");
 
+    /// <summary>Construction state: the 'sparsityFactor' the layer was built with.</summary>
+    private readonly int _sparsityFactor;
+
+    /// <summary>Construction state: the 'dropoutRate' the layer was built with.</summary>
+    private readonly double _dropoutRate;
+
     public InformerDecoderLayerTensor(int embeddingDim, int numHeads, int sparsityFactor, double dropoutRate, int seed = 42)
         : base(new int[][] { new[] { embeddingDim }, new[] { embeddingDim } }, new[] { embeddingDim })
     {
+        _dropoutRate = dropoutRate;
+        _sparsityFactor = sparsityFactor;
         _embeddingDim = embeddingDim;
         _numHeads = numHeads;
         _headDim = embeddingDim / numHeads;
diff --git a/src/TimeSeries/InterventionAnalysisModel.cs b/src/TimeSeries/InterventionAnalysisModel.cs
index 65a8955759..4d18e4c30b 100644
--- a/src/TimeSeries/InterventionAnalysisModel.cs
+++ b/src/TimeSeries/InterventionAnalysisModel.cs
@@ -90,6 +90,7 @@ public partial class InterventionAnalysisModel<T> : TimeSeriesModelBase<T>
     /// and uses each past time period.
     /// </para>
     /// </remarks>
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T> _arParameters;
 
     /// <summary>
@@ -112,6 +113,7 @@ public partial class InterventionAnalysisModel<T> : TimeSeriesModelBase<T>
     /// adjusts based on each past prediction error.
     /// </para>
     /// </remarks>
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T> _maParameters;
 
     /// <summary>
@@ -652,33 +654,7 @@ public Dictionary<string, double> GetInterventionEffects()
     /// having to start from scratch.
     /// </para>
     /// </remarks>
-    protected override void SerializeCore(BinaryWriter writer)
-    {
-        // Write model parameters
-        SerializationHelper<T>.SerializeVector(writer, _arParameters);
-        SerializationHelper<T>.SerializeVector(writer, _maParameters);
-
-        // Write intervention effects
-        writer.Write(_interventionEffects.Count);
-        foreach (var effect in _interventionEffects)
-        {
-            writer.Write(effect.StartIndex);
-            writer.Write(effect.Duration);
-            writer.Write(Convert.ToDouble(effect.Effect));
-        }
-
-        // Write options
-        writer.Write(_iaOptions.AROrder);
-        writer.Write(_iaOptions.MAOrder);
 
-        // Write training series for in-sample predictions
-        if (_y is not null)
-            SerializationHelper<T>.SerializeVector(writer, _y);
-        else
-            writer.Write(0);
-
-        SerializationHelper<T>.SerializeVector(writer, _residuals);
-    }
 
     /// <summary>
     /// Deserializes the model's core parameters from a binary reader.
@@ -706,41 +682,7 @@ protected override void SerializeCore(BinaryWriter writer)
     /// to continue using the model without having to train it again.
     /// </para>
     /// </remarks>
-    protected override void DeserializeCore(BinaryReader reader)
-    {
-        // Read model parameters
-        _arParameters = SerializationHelper<T>.DeserializeVector(reader);
-        _maParameters = SerializationHelper<T>.DeserializeVector(reader);
 
-        // Read intervention effects
-        int effectCount = reader.ReadInt32();
-        _interventionEffects = new List<InterventionEffect<T>>();
-        for (int i = 0; i < effectCount; i++)
-        {
-            _interventionEffects.Add(new InterventionEffect<T>
-            {
-                StartIndex = reader.ReadInt32(),
-                Duration = reader.ReadInt32(),
-                Effect = reader.ReadDouble()
-            });
-        }
-
-        // Read options
-        _iaOptions.AROrder = reader.ReadInt32();
-        _iaOptions.MAOrder = reader.ReadInt32();
-
-        // Read training series (post-patch field)
-        try
-        {
-            _y = SerializationHelper<T>.DeserializeVector(reader);
-            _residuals = SerializationHelper<T>.DeserializeVector(reader);
-        }
-        catch (EndOfStreamException)
-        {
-            // Older models don't include training series
-            _residuals = Vector<T>.Empty();
-        }
-    }
 
     /// <summary>
     /// Resets the model to its initial state.
diff --git a/src/TimeSeries/MAModel.cs b/src/TimeSeries/MAModel.cs
index a4067bd6b7..fb26a22c35 100644
--- a/src/TimeSeries/MAModel.cs
+++ b/src/TimeSeries/MAModel.cs
@@ -63,6 +63,7 @@ public partial class MAModel<T> : TimeSeriesModelBase<T>
     /// For example, if the coefficient for yesterday's error is 0.7, it means yesterday's
     /// error strongly influences today's prediction adjustment.
     /// </remarks>
+    [AiDotNet.Attributes.FittedParameter]
     private Vector<T> _maCoefficients;
 
     /// <summary>
@@ -97,20 +98,6 @@ public partial class MAModel<T> : TimeSeriesModelBase<T>
     /// </remarks>
     private T _noiseVariance;
 
-    /// <summary>
-    /// Flag indicating whether the model has been trained.
-    /// </summary>
-    // IsTrained is inherited from TimeSeriesModelBase
-
-    public override IFullModel<T, Matrix<T>, Vector<T>> Clone()
-    {
-        // Use serialize/deserialize for deep copy to preserve all MA-specific state
-        byte[] serialized = this.Serialize();
-        var clone = new MAModel<T>(new MAModelOptions<T> { MAOrder = _maOptions.MAOrder });
-        clone.Deserialize(serialized);
-        return clone;
-    }
-
     /// <summary>
     /// Maximum number of iterations for optimization algorithms.
     /// </summary>
@@ -1017,33 +1004,7 @@ public override Dictionary<string, T> EvaluateModel(Matrix<T> xTest, Vector<T> y
     /// The method saves all the essential parameters: the order (q) value,
     /// the mean of the series, the MA coefficients, and the recent errors.
     /// </remarks>
-    protected override void SerializeCore(BinaryWriter writer)
-    {
-        // Note: IsTrained is handled by base class Serialize, don't duplicate
 
-        // Write MA-specific options
-        writer.Write(_maOptions.MAOrder);
-
-        // Write mean
-        writer.Write(Convert.ToDouble(_mean));
-
-        // Write noise variance
-        writer.Write(Convert.ToDouble(_noiseVariance));
-
-        // Write MA coefficients
-        writer.Write(_maCoefficients.Length);
-        for (int i = 0; i < _maCoefficients.Length; i++)
-        {
-            writer.Write(Convert.ToDouble(_maCoefficients[i]));
-        }
-
-        // Write recent errors
-        writer.Write(_recentErrors.Length);
-        for (int i = 0; i < _recentErrors.Length; i++)
-        {
-            writer.Write(Convert.ToDouble(_recentErrors[i]));
-        }
-    }
 
     /// <summary>
     /// Deserializes the model's state from a binary stream.
@@ -1061,36 +1022,7 @@ protected override void SerializeCore(BinaryWriter writer)
     /// The method loads all the parameters that were saved during serialization:
     /// the order (q) value, the mean of the series, the MA coefficients, and the recent errors.
     /// </remarks>
-    protected override void DeserializeCore(BinaryReader reader)
-    {
-        // Note: IsTrained is handled by base class Deserialize
-
-        // Read MA-specific options
-        int q = reader.ReadInt32();
-        _maOptions = new MAModelOptions<T> { MAOrder = q };
-
-        // Read mean
-        _mean = NumOps.FromDouble(reader.ReadDouble());
-
-        // Read noise variance
-        _noiseVariance = NumOps.FromDouble(reader.ReadDouble());
 
-        // Read MA coefficients
-        int maLength = reader.ReadInt32();
-        _maCoefficients = new Vector<T>(maLength);
-        for (int i = 0; i < maLength; i++)
-        {
-            _maCoefficients[i] = NumOps.FromDouble(reader.ReadDouble());
-        }
-
-        // Read recent errors
-        int errorsLength = reader.ReadInt32();
-        _recentErrors = new Vector<T>(errorsLength);
-        for (int i = 0; i < errorsLength; i++)
-        {
-            _recentErrors[i] = NumOps.FromDouble(reader.ReadDouble());
-        }
-    }
 
     /// <summary>
     /// Gets metadata about the model, including its type, parameters, and configuration.
diff --git a/src/TimeSeries/NBEATSModel.cs b/src/TimeSeries/NBEATSModel.cs
index 19b33aaa52..65632b3a20 100644
--- a/src/TimeSeries/NBEATSModel.cs
+++ b/src/TimeSeries/NBEATSModel.cs
@@ -1085,76 +1085,12 @@ public Vector<T> ForecastHorizon(Vector<T> input)
     /// <summary>
     /// Serializes model-specific data to the binary writer.
     /// </summary>
-    protected override void SerializeCore(BinaryWriter writer)
-    {
-        // Write N-BEATS specific options
-        writer.Write(_options.NumStacks);
-        writer.Write(_options.NumBlocksPerStack);
-        writer.Write(_options.PolynomialDegree);
-        writer.Write(_options.LookbackWindow);
-        writer.Write(_options.ForecastHorizon);
-        writer.Write(_options.HiddenLayerSize);
-        writer.Write(_options.NumHiddenLayers);
-        writer.Write(_options.LearningRate);
-        writer.Write(_options.Epochs);
-        writer.Write(_options.BatchSize);
-        writer.Write(_options.ShareWeightsInStack);
-        writer.Write(_options.UseInterpretableBasis);
-
-        // Write all block parameters
-        writer.Write(_blocks.Count);
-        foreach (var block in _blocks)
-        {
-            Vector<T> blockParams = block.GetParameters();
-            writer.Write(blockParams.Length);
-            for (int i = 0; i < blockParams.Length; i++)
-            {
-                writer.Write(Convert.ToDouble(blockParams[i]));
-            }
-        }
-    }
+
 
     /// <summary>
     /// Deserializes model-specific data from the binary reader.
     /// </summary>
-    protected override void DeserializeCore(BinaryReader reader)
-    {
-        // Read N-BEATS specific options
-        _options.NumStacks = reader.ReadInt32();
-        _options.NumBlocksPerStack = reader.ReadInt32();
-        _options.PolynomialDegree = reader.ReadInt32();
-        _options.LookbackWindow = reader.ReadInt32();
-        _options.ForecastHorizon = reader.ReadInt32();
-        _options.HiddenLayerSize = reader.ReadInt32();
-        _options.NumHiddenLayers = reader.ReadInt32();
-        _options.LearningRate = reader.ReadDouble();
-        _options.Epochs = reader.ReadInt32();
-        _options.BatchSize = reader.ReadInt32();
-        _options.ShareWeightsInStack = reader.ReadBoolean();
-        _options.UseInterpretableBasis = reader.ReadBoolean();
-
-        // Reinitialize blocks with loaded options
-        InitializeBlocks();
 
-        // Read all block parameters
-        int blockCount = reader.ReadInt32();
-        if (blockCount != _blocks.Count)
-        {
-            throw new InvalidOperationException(
-                $"Block count mismatch. Expected {_blocks.Count}, but serialized data contains {blockCount}.");
-        }
-
-        for (int i = 0; i < blockCount; i++)
-        {
-            int paramCount = reader.ReadInt32();
-            Vector<T> blockParams = new Vector<T>(paramCount);
-            for (int j = 0; j < paramCount; j++)
-            {
-                blockParams[j] = NumOps.FromDouble(reader.ReadDouble());
-            }
-            _blocks[i].SetParameters(blockParams);
-        }
-    }
 
     /// <summary>
     /// Gets metadata about the N-BEATS model.
@@ -1216,26 +1152,4 @@ private T[] CreateSliceWeights(int index, int length, INumericOperations<T> numO
         return weights;
     }
 
-    public override IFullModel<T, Matrix<T>, Vector<T>> Clone()
-    {
-        var clone = new NBEATSModel<T>(_options);
-        // Copy trained blocks (read-only after training -- safe to share by reference)
-        clone._blocks.Clear();
-        clone._blocks.AddRange(_blocks);
-        // Copy training series
-        if (_trainingSeries.Length > 0)
-            clone._trainingSeries = new Vector<T>(_trainingSeries);
-        // Copy model parameters
-        if (ModelParameters is not null && ModelParameters.Length > 0)
-            clone.ModelParameters = new Vector<T>(ModelParameters);
-        // Copy normalization parameters
-        clone._normMean = _normMean;
-        clone._normStd = _normStd;
-        return clone;
-
-
-}
-
-    public override IFullModel<T, Matrix<T>, Vector<T>> DeepCopy() => Clone();
-
 }
diff --git a/src/TimeSeries/NHiTSModel.cs b/src/TimeSeries/NHiTSModel.cs
index 99e9ce43e3..866a12b006 100644
--- a/src/TimeSeries/NHiTSModel.cs
+++ b/src/TimeSeries/NHiTSModel.cs
@@ -794,44 +794,9 @@ public Vector<T> ForecastHorizon(Vector<T> input)
         return result;
     }
 
-    protected override void SerializeCore(BinaryWriter writer)
-    {
-        writer.Write(_options.NumStacks);
-        writer.Write(_options.LookbackWindow);
-        writer.Write(_options.ForecastHorizon);
-
-        writer.Write(_stacks.Count);
-        foreach (var stack in _stacks)
-        {
-            stack.Serialize(writer);
-        }
 
-        // Normalization statistics learned in TrainCore. Without these a reloaded
-        // model denormalizes with the defaults (_normMean=0, _normStd=1), so its
-        // forecasts differ from the original trained model. Written as doubles.
-        writer.Write(NumOps.ToDouble(_normMean));
-        writer.Write(NumOps.ToDouble(_normStd));
-    }
-
-    protected override void DeserializeCore(BinaryReader reader)
-    {
-        _options.NumStacks = reader.ReadInt32();
-        _options.LookbackWindow = reader.ReadInt32();
-        _options.ForecastHorizon = reader.ReadInt32();
-
-        InitializeStacks();
 
-        int stackCount = reader.ReadInt32();
-        for (int s = 0; s < stackCount && s < _stacks.Count; s++)
-        {
-            _stacks[s].Deserialize(reader);
-        }
 
-        // Restore the normalization statistics written by SerializeCore so the
-        // reloaded model reproduces the original's forecasts.
-        _normMean = NumOps.FromDouble(reader.ReadDouble());
-        _normStd = NumOps.FromDouble(reader.ReadDouble());
-    }
 
     public override ModelMetadata<T> GetModelMetadata()
     {
@@ -856,24 +821,6 @@ protected override IFullModel<T, Matrix<T>, Vector<T>> CreateInstance()
     {
         return new NHiTSModel<T>(new NHiTSOptions<T>(_options));
     }
-
-    // ParameterCount restated a fold the base now derives from generated component registration.
-    // Removed under AIDN082.
-    public override IFullModel<T, Matrix<T>, Vector<T>> Clone()
-    {
-        var clone = new NHiTSModel<T>(_options);
-        clone._stacks.Clear();
-        clone._stacks.AddRange(_stacks);
-        if (_trainingSeries.Length > 0)
-            clone._trainingSeries = new Vector<T>(_trainingSeries);
-        if (ModelParameters is not null && ModelParameters.Length > 0)
-            clone.ModelParameters = new Vector<T>(ModelParameters);
-        clone._normMean = _normMean;
-        clone._normStd = _normStd;
-        return clone;
-    }
-
-    public override IFullModel<T, Matrix<T>, Vector<T>> DeepCopy() => Clone();
 }
 
 /// <summary>
@@ -1012,6 +959,7 @@ private Tensor<T> CreateRandomTensor(int[] shape, double stddev)
         return tensor;
     }
 
+    [Scratch]
     private Tensor<T>? _lastForwardInput;
 
     protected override Tensor<T> ForwardTraced(Tensor<T> input)
@@ -1084,79 +1032,4 @@ public Tensor<T> ForwardTape(Tensor<T> input)
         // [outputLength, B] -> [B, outputLength]
         return Engine.TensorPermute(x, new[] { 1, 0 });
     }
-
-    public override void Serialize(BinaryWriter writer)
-    {
-        writer.Write(_inputLength);
-        writer.Write(_outputLength);
-        writer.Write(_hiddenSize);
-        writer.Write(_numLayers);
-        writer.Write(PoolingSize);
-
-        writer.Write(_weights.Count);
-        foreach (var weight in _weights)
-        {
-            writer.Write(weight.Shape.Length);
-            foreach (var dim in weight._shape)
-                writer.Write(dim);
-            for (int i = 0; i < weight.Length; i++)
-                writer.Write(Convert.ToDouble(weight[i]));
-        }
-
-        writer.Write(_biases.Count);
-        foreach (var bias in _biases)
-        {
-            writer.Write(bias.Shape.Length);
-            foreach (var dim in bias._shape)
-                writer.Write(dim);
-            for (int i = 0; i < bias.Length; i++)
-                writer.Write(Convert.ToDouble(bias[i]));
-        }
-    }
-
-    public override void Deserialize(BinaryReader reader)
-    {
-        // Skip reading dimensions as they should match constructor
-        reader.ReadInt32(); // inputLength
-        reader.ReadInt32(); // outputLength
-        reader.ReadInt32(); // hiddenSize
-        reader.ReadInt32(); // numLayers
-        reader.ReadInt32(); // poolingSize
-
-        int weightCount = reader.ReadInt32();
-        // Consume ALL serialized tensors to keep stream aligned, even if counts differ
-        for (int w = 0; w < weightCount; w++)
-        {
-            int rank = reader.ReadInt32();
-            var shape = new int[rank];
-            for (int d = 0; d < rank; d++)
-                shape[d] = reader.ReadInt32();
-
-            int total = shape.Aggregate(1, (a, b) => a * b);
-            for (int i = 0; i < total; i++)
-            {
-                double v = reader.ReadDouble();
-                if (w < _weights.Count && i < _weights[w].Length)
-                    _weights[w][i] = NumOps.FromDouble(v);
-            }
-        }
-
-        int biasCount = reader.ReadInt32();
-        // Consume ALL serialized tensors to keep stream aligned, even if counts differ
-        for (int b = 0; b < biasCount; b++)
-        {
-            int rank = reader.ReadInt32();
-            var shape = new int[rank];
-            for (int d = 0; d < rank; d++)
-                shape[d] = reader.ReadInt32();
-
-            int total = shape.Aggregate(1, (a, b) => a * b);
-            for (int i = 0; i < total; i++)
-            {
-                double v = reader.ReadDouble();
-                if (b < _biases.Count && i < _biases[b].Length)
-                    _biases[b][i] = NumOps.FromDouble(v);
-            }
-        }
-    }
 }
diff --git a/src/TimeSeries/NLinearModel.cs b/src/TimeSeries/NLinearModel.cs
index b1d8527ab3..9eb47f551a 100644
--- a/src/TimeSeries/NLinearModel.cs
+++ b/src/TimeSeries/NLinearModel.cs
@@ -1,41 +1,42 @@
-using AiDotNet.Attributes;
-using AiDotNet.Enums;
-using AiDotNet.Models.Options;
-using AiDotNet.Optimizers;

+using AiDotNet.Attributes;
+using AiDotNet.Enums;
+using AiDotNet.Models.Options;
+using AiDotNet.Optimizers;
+
 using AiDotNet.Models.Parameters;
-
-namespace AiDotNet.TimeSeries;
-
-/// <summary>
-/// NLinear — normalization-linear forecaster (Zeng et al., AAAI 2023). Subtracts the last value of the input
-/// window (a simple per-window normalization that absorbs level/distribution shift), applies one linear map,
-/// then adds the last value back. With DLinear it forms the pair of strong, current linear baselines that
-/// frequently rival transformers on long-horizon forecasting.
-/// </summary>
-/// <typeparam name="T">Numeric type (float/double).</typeparam>
-[ModelDomain(ModelDomain.TimeSeries)]
-[ModelCategory(ModelCategory.TimeSeriesModel)]
-[ModelTask(ModelTask.Forecasting)]
-[ModelComplexity(ModelComplexity.Low)]
-[ModelInput(typeof(Matrix<>), typeof(Vector<>))]
-[ResearchPaper("Are Transformers Effective for Time Series Forecasting?", "https://arxiv.org/abs/2205.13504", Year = 2023, Authors = "Ailing Zeng, Muxi Chen, Lei Zhang, Qiang Xu")]
-public partial class NLinearModel<T> : TimeSeriesModelBase<T>
-{
-    private readonly NLinearOptions<T> _options;
-    private readonly Random _random;
-    private readonly int _l;
+
+namespace AiDotNet.TimeSeries;
+
+/// <summary>
+/// NLinear — normalization-linear forecaster (Zeng et al., AAAI 2023). Subtracts the last value of the input
+/// window (a simple per-window normalization that absorbs level/distribution shift), applies one linear map,
+/// then adds the last value back. With DLinear it forms the pair of strong, current linear baselines that
+/// frequently rival transformers on long-horizon forecasting.
+/// </summary>
+/// <typeparam name="T">Numeric type (float/double).</typeparam>
+[ModelDomain(ModelDomain.TimeSeries)]
+[ModelCategory(ModelCategory.TimeSeriesModel)]
+[ModelTask(ModelTask.Forecasting)]
+[ModelComplexity(ModelComplexity.Low)]
+[ModelInput(typeof(Matrix<>), typeof(Vector<>))]
+[ResearchPaper("Are Transformers Effective for Time Series Forecasting?", "https://arxiv.org/abs/2205.13504", Year = 2023, Authors = "Ailing Zeng, Muxi Chen, Lei Zhang, Qiang Xu")]
+public partial class NLinearModel<T> : TimeSeriesModelBase<T>
+{
+    private readonly NLinearOptions<T> _options;
+    private readonly Random _random;
+    private readonly int _l;
     [TrainableParameter]
     private readonly double[] _w;
     [TrainableParameter]
     private double _b;
-    private readonly IGradientBasedOptimizer<T, Matrix<T>, Vector<T>> _optimizer;
-
-    // StandardScaler statistics (LTSF-Linear reference pipeline: the series is z-score normalized before
-    // training/inference, then predictions are denormalized). Fit on the training data; identity until then.
-    // Inputs and targets get SEPARATE scalers: for a real forecast x and y are the same series so the two
-    // coincide and this reduces to plain NLinear, but normalizing in the model's own space is what makes
-    // training converge independent of the series magnitude (Adam can't otherwise move the bias/weights far
-    // enough on large-scale targets within the epoch budget).
+    private readonly IGradientBasedOptimizer<T, Matrix<T>, Vector<T>> _optimizer;
+
+    // StandardScaler statistics (LTSF-Linear reference pipeline: the series is z-score normalized before
+    // training/inference, then predictions are denormalized). Fit on the training data; identity until then.
+    // Inputs and targets get SEPARATE scalers: for a real forecast x and y are the same series so the two
+    // coincide and this reduces to plain NLinear, but normalizing in the model's own space is what makes
+    // training converge independent of the series magnitude (Adam can't otherwise move the bias/weights far
+    // enough on large-scale targets within the epoch budget).
     [Buffer]
     private double _xMean;
     [Buffer]
@@ -44,229 +45,210 @@ public partial class NLinearModel<T> : TimeSeriesModelBase<T>
     private double _yMean;
     [Buffer]
     private double _yStd = 1.0;
-
-    /// <param name="options">Model configuration (window, horizon, epochs, batch size, learning rate).</param>
-    /// <param name="optimizer">
-    /// Optimizer used to update the linear map. When <c>null</c>, defaults to <see cref="AdamOptimizer{T,TInput,TOutput}"/>
-    /// — the optimizer the LTSF-Linear reference (Zeng et al., AAAI 2023) trains NLinear with — seeded from
-    /// <see cref="NLinearOptions{T}.LearningRate"/>. Adam's per-parameter adaptive step keeps training scale-invariant,
-    /// so it converges on large-magnitude series where a fixed-step SGD update diverges. Pass a fully configured
-    /// optimizer to override the paper default; nothing here is hardcoded beyond that swappable default.
-    /// </param>
-    public NLinearModel(NLinearOptions<T>? options = null,
-        IGradientBasedOptimizer<T, Matrix<T>, Vector<T>>? optimizer = null)
-        : base(options ?? new NLinearOptions<T>())
-    {
-        _options = options ?? new NLinearOptions<T>();
-        Options = _options;
-        _random = RandomHelper.CreateSeededRandom(42);
-        _l = Math.Max(2, _options.LookbackWindow);
-        _w = new double[_l];
-        for (int j = 0; j < _l; j++) { _w[j] = 1.0 / _l; }
-        _optimizer = optimizer ?? new AdamOptimizer<T, Matrix<T>, Vector<T>>(
-            this, new AdamOptimizerOptions<T, Matrix<T>, Vector<T>> { InitialLearningRate = _options.LearningRate });
-    }
-
-    private static bool IsFiniteValue(double v) => !double.IsNaN(v) && !double.IsInfinity(v);
-
-    private static double[] LastWindow(int l, Func<int, double> get, int count)
-    {
-        var x = new double[l];
-        int start = Math.Max(0, count - l);
-        for (int j = 0; j < l; j++)
-        {
-            int idx = start + j;
-            double v = idx < count ? get(idx) : 0.0;
-            x[j] = IsFiniteValue(v) ? v : 0.0;
-        }
-
-        return x;
-    }
-
-    // NLinear in the model's normalized space: subtract-last on the normalized window, linear map, add last
-    // back. Operates on an ALREADY x-normalized window and returns a y-normalized prediction.
-    private double ForecastNormalized(double[] windowNorm)
-    {
-        double last = windowNorm[_l - 1];
-        double pred = _b + last;
-        for (int j = 0; j < _l; j++)
-        {
-            pred += _w[j] * (windowNorm[j] - last);
-        }
-
-        return pred;
-    }
-
-    // Full forecast from a RAW series accessor: x-normalize each entry BEFORE the window's
-    // non-finite clamp, run the normalized NLinear map, then y-denormalize.
-    //
-    // Normalizing inside the accessor is what keeps training and inference imputing in the SAME
-    // space. LastWindow clamps a non-finite entry to 0.0 wherever it is applied: applied to
-    // normalized values (as TrainCore does) that means the mean in raw terms, but applied to raw
-    // values it meant (0 - _xMean) / _xStd once normalized afterwards. The same corrupt input
-    // therefore mapped to a different value at inference than during training, and the gap grows
-    // with _xMean.
-    private double Forecast(Func<int, double> rawAt, int count)
-    {
-        var windowNorm = LastWindow(_l, j => (rawAt(j) - _xMean) / _xStd, count);
-        return ForecastNormalized(windowNorm) * _yStd + _yMean;
-    }
-
-
-    protected override void TrainCore(Matrix<T> x, Vector<T> y)
-    {
-        int n = x.Rows;
-        int cols = x.Columns;
-
-        // StandardScaler fit (LTSF-Linear reference pipeline): z-score the inputs and targets so the
-        // regression is solved in a magnitude-free space. This is what lets training converge on any series
-        // scale — the bias/weights only ever need to reach O(1) — and it makes the model exactly translation-
-        // and scaling-equivariant in the target (shifting/scaling y shifts/scales the denormalized output by
-        // the same amount, since the normalized problem is unchanged). Separate x/y scalers: for a genuine
-        // forecast x and y are the same series so they coincide (plain NLinear), but keeping them independent
-        // is what makes the equivariance exact when only the target is transformed.
-        FitScalers(x, y, n, cols);
-
-        // Start each fit from clean optimizer state so repeated Train() calls are reproducible.
-        _optimizer.Reset();
-
-        // Parameter vector theta = [w_0 .. w_{l-1}, b]. The pluggable optimizer (Adam by default, per the
-        // LTSF-Linear reference) owns the update rule.
-        var theta = new Vector<T>(_l + 1);
-        for (int j = 0; j < _l; j++) { theta[j] = NumOps.FromDouble(_w[j]); }
-        theta[_l] = NumOps.FromDouble(_b);
-
-        for (int epoch = 0; epoch < _options.Epochs; epoch++)
-        {
-            TrainingCancellationToken.ThrowIfCancellationRequested();
-            var order = Enumerable.Range(0, n).OrderBy(_ => _random.Next()).ToList();
-
-            for (int batchStart = 0; batchStart < n; batchStart += _options.BatchSize)
-            {
-                int batchEnd = Math.Min(batchStart + _options.BatchSize, n);
-                int bs = batchEnd - batchStart;
-                var g = new double[_l];
-                double gb = 0;
-
-                for (int bi = batchStart; bi < batchEnd; bi++)
-                {
-                    int i = order[bi];
-                    // x-normalized window and y-normalized target — the whole regression runs in scaler space.
-                    var window = LastWindow(_l, c => (Convert.ToDouble(x[i, c]) - _xMean) / _xStd, cols);
-                    double last = window[_l - 1];
-                    double predNorm = ForecastNormalized(window);
-                    double targetNorm = (Convert.ToDouble(y[i]) - _yMean) / _yStd;
-                    double err = predNorm - targetNorm;
-                    for (int j = 0; j < _l; j++)
-                    {
-                        g[j] += err * (window[j] - last);
-                    }
-
-                    gb += err;
-                }
-
-                // Mean gradient of the 0.5*err^2 objective (dL/dw_j = err*(window_j - last), dL/db = err).
-                double inv = bs > 0 ? 1.0 / bs : 0.0;
-                var grad = new Vector<T>(_l + 1);
-                for (int j = 0; j < _l; j++) { grad[j] = NumOps.FromDouble(g[j] * inv); }
-                grad[_l] = NumOps.FromDouble(gb * inv);
-
-                theta = _optimizer.UpdateParameters(theta, grad);
-
-                // Mirror the updated parameters back into the double working weights Forecast reads.
-                for (int j = 0; j < _l; j++) { _w[j] = Convert.ToDouble(theta[j]); }
-                _b = Convert.ToDouble(theta[_l]);
-            }
-        }
-
+
+    /// <param name="options">Model configuration (window, horizon, epochs, batch size, learning rate).</param>
+    /// <param name="optimizer">
+    /// Optimizer used to update the linear map. When <c>null</c>, defaults to <see cref="AdamOptimizer{T,TInput,TOutput}"/>
+    /// — the optimizer the LTSF-Linear reference (Zeng et al., AAAI 2023) trains NLinear with — seeded from
+    /// <see cref="NLinearOptions{T}.LearningRate"/>. Adam's per-parameter adaptive step keeps training scale-invariant,
+    /// so it converges on large-magnitude series where a fixed-step SGD update diverges. Pass a fully configured
+    /// optimizer to override the paper default; nothing here is hardcoded beyond that swappable default.
+    /// </param>
+    public NLinearModel(NLinearOptions<T>? options = null,
+        IGradientBasedOptimizer<T, Matrix<T>, Vector<T>>? optimizer = null)
+        : base(options ?? new NLinearOptions<T>())
+    {
+        _options = options ?? new NLinearOptions<T>();
+        Options = _options;
+        _random = RandomHelper.CreateSeededRandom(42);
+        _l = Math.Max(2, _options.LookbackWindow);
+        _w = new double[_l];
+        for (int j = 0; j < _l; j++) { _w[j] = 1.0 / _l; }
+        _optimizer = optimizer ?? new AdamOptimizer<T, Matrix<T>, Vector<T>>(
+            this, new AdamOptimizerOptions<T, Matrix<T>, Vector<T>> { InitialLearningRate = _options.LearningRate });
     }
-
-    // Fit z-score scalers over the training inputs (all window values) and targets. A (near-)constant series
-    // has zero variance; guard the std to 1 so normalization is a pure mean-shift and never divides by zero.
-    private void FitScalers(Matrix<T> x, Vector<T> y, int n, int cols)
-    {
-        const double eps = 1e-8;
-
-        double xSum = 0; long xCount = 0;
-        for (int i = 0; i < n; i++)
-            for (int c = 0; c < cols; c++)
-            {
-                double v = Convert.ToDouble(x[i, c]);
-                if (IsFiniteValue(v)) { xSum += v; xCount++; }
-            }
-        _xMean = xCount > 0 ? xSum / xCount : 0.0;
-        double xVar = 0;
-        for (int i = 0; i < n; i++)
-            for (int c = 0; c < cols; c++)
-            {
-                double v = Convert.ToDouble(x[i, c]);
-                if (IsFiniteValue(v)) { double d = v - _xMean; xVar += d * d; }
-            }
-        _xStd = xCount > 0 ? Math.Sqrt(xVar / xCount) : 1.0;
-        if (_xStd < eps) _xStd = 1.0;
-
-        double ySum = 0; long yCount = 0;
-        for (int i = 0; i < n; i++)
-        {
-            double v = Convert.ToDouble(y[i]);
-            if (IsFiniteValue(v)) { ySum += v; yCount++; }
-        }
-        _yMean = yCount > 0 ? ySum / yCount : 0.0;
-        double yVar = 0;
-        for (int i = 0; i < n; i++)
-        {
-            double v = Convert.ToDouble(y[i]);
-            if (IsFiniteValue(v)) { double d = v - _yMean; yVar += d * d; }
-        }
-        _yStd = yCount > 0 ? Math.Sqrt(yVar / yCount) : 1.0;
-        if (_yStd < eps) _yStd = 1.0;
-    }
-
-    public override T PredictSingle(Vector<T> input)
-    {
-        double pred = Forecast(j => Convert.ToDouble(input[j]), input.Length);
-        return NumOps.FromDouble(IsFiniteValue(pred) ? pred : 0.0);
-    }
-
-    protected override void SerializeCore(BinaryWriter writer)
-    {
-        writer.Write(_l);
-        for (int j = 0; j < _l; j++) { writer.Write(_w[j]); }
-        writer.Write(_b);
-        // StandardScaler stats are model state Predict depends on (Clone() round-trips through here).
-        writer.Write(_xMean);
-        writer.Write(_xStd);
-        writer.Write(_yMean);
-        writer.Write(_yStd);
-    }
-
-    protected override void DeserializeCore(BinaryReader reader)
-    {
-        reader.ReadInt32();
-        for (int j = 0; j < _l; j++) { _w[j] = reader.ReadDouble(); }
-        _b = reader.ReadDouble();
-        _xMean = reader.ReadDouble();
-        _xStd = reader.ReadDouble();
-        _yMean = reader.ReadDouble();
-        _yStd = reader.ReadDouble();
-    }
-
-    public override ModelMetadata<T> GetModelMetadata()
-    {
-        return new ModelMetadata<T>
-        {
-            Name = "NLinear",
-            Description = "Normalization-linear forecaster (subtract-last + linear) — strong simple baseline (Zeng et al. 2023)",
-            Complexity = ParameterCount,
-            FeatureCount = _options.LookbackWindow,
-            AdditionalInfo = new Dictionary<string, object>
-            {
-                { "LookbackWindow", _options.LookbackWindow },
-                { "ForecastHorizon", _options.ForecastHorizon },
-            },
-        };
-    }
-
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateInstance()
-        => new NLinearModel<T>(new NLinearOptions<T>(_options));
-}
+
+    private static bool IsFiniteValue(double v) => !double.IsNaN(v) && !double.IsInfinity(v);
+
+    private static double[] LastWindow(int l, Func<int, double> get, int count)
+    {
+        var x = new double[l];
+        int start = Math.Max(0, count - l);
+        for (int j = 0; j < l; j++)
+        {
+            int idx = start + j;
+            double v = idx < count ? get(idx) : 0.0;
+            x[j] = IsFiniteValue(v) ? v : 0.0;
+        }
+
+        return x;
+    }
+
+    // NLinear in the model's normalized space: subtract-last on the normalized window, linear map, add last
+    // back. Operates on an ALREADY x-normalized window and returns a y-normalized prediction.
+    private double ForecastNormalized(double[] windowNorm)
+    {
+        double last = windowNorm[_l - 1];
+        double pred = _b + last;
+        for (int j = 0; j < _l; j++)
+        {
+            pred += _w[j] * (windowNorm[j] - last);
+        }
+
+        return pred;
+    }
+
+    // Full forecast from a RAW series accessor: x-normalize each entry BEFORE the window's
+    // non-finite clamp, run the normalized NLinear map, then y-denormalize.
+    //
+    // Normalizing inside the accessor is what keeps training and inference imputing in the SAME
+    // space. LastWindow clamps a non-finite entry to 0.0 wherever it is applied: applied to
+    // normalized values (as TrainCore does) that means the mean in raw terms, but applied to raw
+    // values it meant (0 - _xMean) / _xStd once normalized afterwards. The same corrupt input
+    // therefore mapped to a different value at inference than during training, and the gap grows
+    // with _xMean.
+    private double Forecast(Func<int, double> rawAt, int count)
+    {
+        var windowNorm = LastWindow(_l, j => (rawAt(j) - _xMean) / _xStd, count);
+        return ForecastNormalized(windowNorm) * _yStd + _yMean;
+    }
+
+
+    protected override void TrainCore(Matrix<T> x, Vector<T> y)
+    {
+        int n = x.Rows;
+        int cols = x.Columns;
+
+        // StandardScaler fit (LTSF-Linear reference pipeline): z-score the inputs and targets so the
+        // regression is solved in a magnitude-free space. This is what lets training converge on any series
+        // scale — the bias/weights only ever need to reach O(1) — and it makes the model exactly translation-
+        // and scaling-equivariant in the target (shifting/scaling y shifts/scales the denormalized output by
+        // the same amount, since the normalized problem is unchanged). Separate x/y scalers: for a genuine
+        // forecast x and y are the same series so they coincide (plain NLinear), but keeping them independent
+        // is what makes the equivariance exact when only the target is transformed.
+        FitScalers(x, y, n, cols);
+
+        // Start each fit from clean optimizer state so repeated Train() calls are reproducible.
+        _optimizer.Reset();
+
+        // Parameter vector theta = [w_0 .. w_{l-1}, b]. The pluggable optimizer (Adam by default, per the
+        // LTSF-Linear reference) owns the update rule.
+        var theta = new Vector<T>(_l + 1);
+        for (int j = 0; j < _l; j++) { theta[j] = NumOps.FromDouble(_w[j]); }
+        theta[_l] = NumOps.FromDouble(_b);
+
+        for (int epoch = 0; epoch < _options.Epochs; epoch++)
+        {
+            TrainingCancellationToken.ThrowIfCancellationRequested();
+            var order = Enumerable.Range(0, n).OrderBy(_ => _random.Next()).ToList();
+
+            for (int batchStart = 0; batchStart < n; batchStart += _options.BatchSize)
+            {
+                int batchEnd = Math.Min(batchStart + _options.BatchSize, n);
+                int bs = batchEnd - batchStart;
+                var g = new double[_l];
+                double gb = 0;
+
+                for (int bi = batchStart; bi < batchEnd; bi++)
+                {
+                    int i = order[bi];
+                    // x-normalized window and y-normalized target — the whole regression runs in scaler space.
+                    var window = LastWindow(_l, c => (Convert.ToDouble(x[i, c]) - _xMean) / _xStd, cols);
+                    double last = window[_l - 1];
+                    double predNorm = ForecastNormalized(window);
+                    double targetNorm = (Convert.ToDouble(y[i]) - _yMean) / _yStd;
+                    double err = predNorm - targetNorm;
+                    for (int j = 0; j < _l; j++)
+                    {
+                        g[j] += err * (window[j] - last);
+                    }
+
+                    gb += err;
+                }
+
+                // Mean gradient of the 0.5*err^2 objective (dL/dw_j = err*(window_j - last), dL/db = err).
+                double inv = bs > 0 ? 1.0 / bs : 0.0;
+                var grad = new Vector<T>(_l + 1);
+                for (int j = 0; j < _l; j++) { grad[j] = NumOps.FromDouble(g[j] * inv); }
+                grad[_l] = NumOps.FromDouble(gb * inv);
+
+                theta = _optimizer.UpdateParameters(theta, grad);
+
+                // Mirror the updated parameters back into the double working weights Forecast reads.
+                for (int j = 0; j < _l; j++) { _w[j] = Convert.ToDouble(theta[j]); }
+                _b = Convert.ToDouble(theta[_l]);
+            }
+        }
+
+    }
+
+    // Fit z-score scalers over the training inputs (all window values) and targets. A (near-)constant series
+    // has zero variance; guard the std to 1 so normalization is a pure mean-shift and never divides by zero.
+    private void FitScalers(Matrix<T> x, Vector<T> y, int n, int cols)
+    {
+        const double eps = 1e-8;
+
+        double xSum = 0; long xCount = 0;
+        for (int i = 0; i < n; i++)
+            for (int c = 0; c < cols; c++)
+            {
+                double v = Convert.ToDouble(x[i, c]);
+                if (IsFiniteValue(v)) { xSum += v; xCount++; }
+            }
+        _xMean = xCount > 0 ? xSum / xCount : 0.0;
+        double xVar = 0;
+        for (int i = 0; i < n; i++)
+            for (int c = 0; c < cols; c++)
+            {
+                double v = Convert.ToDouble(x[i, c]);
+                if (IsFiniteValue(v)) { double d = v - _xMean; xVar += d * d; }
+            }
+        _xStd = xCount > 0 ? Math.Sqrt(xVar / xCount) : 1.0;
+        if (_xStd < eps) _xStd = 1.0;
+
+        double ySum = 0; long yCount = 0;
+        for (int i = 0; i < n; i++)
+        {
+            double v = Convert.ToDouble(y[i]);
+            if (IsFiniteValue(v)) { ySum += v; yCount++; }
+        }
+        _yMean = yCount > 0 ? ySum / yCount : 0.0;
+        double yVar = 0;
+        for (int i = 0; i < n; i++)
+        {
+            double v = Convert.ToDouble(y[i]);
+            if (IsFiniteValue(v)) { double d = v - _yMean; yVar += d * d; }
+        }
+        _yStd = yCount > 0 ? Math.Sqrt(yVar / yCount) : 1.0;
+        if (_yStd < eps) _yStd = 1.0;
+    }
+
+    public override T PredictSingle(Vector<T> input)
+    {
+        double pred = Forecast(j => Convert.ToDouble(input[j]), input.Length);
+        return NumOps.FromDouble(IsFiniteValue(pred) ? pred : 0.0);
+    }
+
+
+
+
+
+    public override ModelMetadata<T> GetModelMetadata()
+    {
+        return new ModelMetadata<T>
+        {
+            Name = "NLinear",
+            Description = "Normalization-linear forecaster (subtract-last + linear) — strong simple baseline (Zeng et al. 2023)",
+            Complexity = ParameterCount,
+            FeatureCount = _options.LookbackWindow,
+            AdditionalInfo = new Dictionary<string, object>
+            {
+                { "LookbackWindow", _options.LookbackWindow },
+                { "ForecastHorizon", _options.ForecastHorizon },
+            },
+        };
+    }
+
+    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateInstance()
+        => new NLinearModel<T>(new NLinearOptions<T>(_options));
+}
diff --git a/src/TimeSeries/NeuralNetworkARIMAModel.cs b/src/TimeSeries/NeuralNetworkARIMAModel.cs
index cdfe20082b..80ee247b97 100644
--- a/src/TimeSeries/NeuralNetworkARIMAModel.cs
+++ b/src/TimeSeries/NeuralNetworkARIMAModel.cs
@@ -92,6 +92,7 @@ public partial class NeuralNetworkARIMAModel<T> : TimeSeriesModelBase<T>
     /// which past values are most important for making accurate predictions.
     /// </para>
     /// </remarks>
+    [AiDotNet.Attributes.Scratch]
     private Vector<T> _arParameters;
 
     /// <summary>
@@ -112,6 +113,7 @@ public partial class NeuralNetworkARIMAModel<T> : TimeSeriesModelBase<T>
     /// the MA component might suggest adding some correction to today's prediction.
     /// </para>
     /// </remarks>
+    [AiDotNet.Attributes.Scratch]
     private Vector<T> _maParameters;
 
     /// <summary>
@@ -700,30 +702,7 @@ public override Dictionary<string, T> EvaluateModel(Matrix<T> xTest, Vector<T> y
     /// This way, you or someone else can rebuild the exact same model later, even on a different computer.
     /// </para>
     /// </remarks>
-    protected override void SerializeCore(BinaryWriter writer)
-    {
-        // Write model parameters
-        SerializationHelper<T>.SerializeVector(writer, _arParameters);
-        SerializationHelper<T>.SerializeVector(writer, _maParameters);
-
-        // Write neural network parameters
-        var serializedModel = _neuralNetwork.Serialize();
-        writer.Write(serializedModel.Length);
-        writer.Write(serializedModel);
-
-        // Write options
-        writer.Write(_nnarimaOptions.AROrder);
-        writer.Write(_nnarimaOptions.MAOrder);
-        writer.Write(_nnarimaOptions.LaggedPredictions);
-
-        // Write training series for in-sample predictions
-        if (_y is not null)
-            SerializationHelper<T>.SerializeVector(writer, _y);
-        else
-            writer.Write(0);
-
-        SerializationHelper<T>.SerializeVector(writer, _residuals);
-    }
+
 
     /// <summary>
     /// Deserializes the core components of the model from a binary reader.
@@ -747,34 +726,7 @@ protected override void SerializeCore(BinaryWriter writer)
     /// After this process, your model is back to its original state, ready to make predictions again.
     /// </para>
     /// </remarks>
-    protected override void DeserializeCore(BinaryReader reader)
-    {
-        // Read model parameters
-        _arParameters = SerializationHelper<T>.DeserializeVector(reader);
-        _maParameters = SerializationHelper<T>.DeserializeVector(reader);
-
-        // Read neural network parameters
-        var serializedModelLength = reader.ReadInt32();
-        var serializedModel = reader.ReadBytes(serializedModelLength);
-        _neuralNetwork.Deserialize(serializedModel);
-
-        // Read options
-        _nnarimaOptions.AROrder = reader.ReadInt32();
-        _nnarimaOptions.MAOrder = reader.ReadInt32();
-        _nnarimaOptions.LaggedPredictions = reader.ReadInt32();
-
-        // Read training series (post-patch field)
-        try
-        {
-            _y = SerializationHelper<T>.DeserializeVector(reader);
-            _residuals = SerializationHelper<T>.DeserializeVector(reader);
-        }
-        catch (EndOfStreamException)
-        {
-            // Older models don't include training series
-            _residuals = Vector<T>.Empty();
-        }
-    }
+
 
     /// <summary>
     /// Core implementation of the training process for the Neural Network ARIMA model.
diff --git a/src/TimeSeries/ProphetModel.cs b/src/TimeSeries/ProphetModel.cs
index 4853da4cde..10170c9885 100644
--- a/src/TimeSeries/ProphetModel.cs
+++ b/src/TimeSeries/ProphetModel.cs
@@ -101,6 +101,7 @@ public partial class ProphetModel<T, TInput, TOutput> : TimeSeriesModelBase<T>
     /// The per-changepoint rate adjustments <c>delta</c>. Each entry is the change in slope applied from the
     /// corresponding changepoint time onward, giving the trend its piecewise-linear (time-varying) shape.
     /// </summary>
+    [AiDotNet.Attributes.FittedParameter]
     private Vector<T> _delta;
 
     /// <summary>
@@ -131,6 +132,7 @@ public partial class ProphetModel<T, TInput, TOutput> : TimeSeriesModelBase<T>
     /// regular patterns at different time scales (daily, weekly, yearly, etc.).
     /// </para>
     /// </remarks>
+    [AiDotNet.Attributes.FittedParameter]
     private Vector<T> _seasonalComponents;
 
     /// <summary>
@@ -147,6 +149,7 @@ public partial class ProphetModel<T, TInput, TOutput> : TimeSeriesModelBase<T>
     /// increase or decrease the values in your data.
     /// </para>
     /// </remarks>
+    [AiDotNet.Attributes.FittedParameter]
     private Vector<T> _holidayComponents;
 
     /// <summary>
@@ -163,6 +166,7 @@ public partial class ProphetModel<T, TInput, TOutput> : TimeSeriesModelBase<T>
     /// each external factor influences your data.
     /// </para>
     /// </remarks>
+    [AiDotNet.Attributes.FittedParameter]
     private Vector<T> _regressors;
 
     /// <summary>
@@ -864,94 +868,7 @@ public override Dictionary<string, T> EvaluateModel(Matrix<T> xTest, Vector<T> y
     /// This allows us to save our trained model and use it later without having to retrain it.
     /// </para>
     /// </remarks>
-    protected override void SerializeCore(BinaryWriter writer)
-    {
-        // Piecewise-linear trend: offset m, base rate k, changepoint rate-adjustments (delta) and their fixed locations.
-        writer.Write(Convert.ToDouble(_m));
-        writer.Write(Convert.ToDouble(_k));
-        writer.Write(_delta.Length);
-        for (int i = 0; i < _delta.Length; i++)
-        {
-            writer.Write(Convert.ToDouble(_delta[i]));
-        }
-        writer.Write(_changepointTimes.Length);
-        for (int i = 0; i < _changepointTimes.Length; i++)
-        {
-            writer.Write(Convert.ToDouble(_changepointTimes[i]));
-        }
 
-        // Seasonal periods actually used (so prediction indexes the Fourier coefficients identically) + Fourier order.
-        writer.Write(_effectiveSeasonalPeriods.Length);
-        for (int i = 0; i < _effectiveSeasonalPeriods.Length; i++)
-        {
-            writer.Write(_effectiveSeasonalPeriods[i]);
-        }
-        writer.Write(_prophetOptions.FourierOrder);
-
-        // Seasonal Fourier coefficients.
-        writer.Write(_seasonalComponents.Length);
-        for (int i = 0; i < _seasonalComponents.Length; i++)
-        {
-            writer.Write(Convert.ToDouble(_seasonalComponents[i]));
-        }
-
-        // Holiday and regressor coefficients.
-        writer.Write(_holidayComponents.Length);
-        for (int i = 0; i < _holidayComponents.Length; i++)
-        {
-            writer.Write(Convert.ToDouble(_holidayComponents[i]));
-        }
-        writer.Write(_regressors.Length);
-        for (int i = 0; i < _regressors.Length; i++)
-        {
-            writer.Write(Convert.ToDouble(_regressors[i]));
-        }
-
-        // Write options
-        writer.Write(_prophetOptions.SeasonalPeriods.Count);
-        foreach (var period in _prophetOptions.SeasonalPeriods)
-        {
-            writer.Write(period);
-        }
-        writer.Write(_prophetOptions.Holidays.Count);
-        foreach (var holiday in _prophetOptions.Holidays)
-        {
-            writer.Write(holiday.Ticks);
-        }
-        writer.Write(_prophetOptions.RegressorCount);
-
-        // Every remaining scalar option, plus the residual statistics.
-        //
-        // These were not written, so DeserializeCore rebuilt a DEFAULT options object and the fit
-        // survived the round trip while the behaviour around it did not: a model trained with
-        // ApplyTransformation returned untransformed predictions after loading, DetectAnomalies and
-        // GetAnomalyThreshold threw because EnableAnomalyDetection reverted to false (telling the
-        // user to retrain a model that had been trained correctly), and PredictWithIntervals threw
-        // because _residualStdDev reverted to zero.
-        //
-        // Optimizer and TransformPrediction are an interface reference and a delegate. Neither can
-        // be written to a binary stream, so a caller who set them must re-supply them after loading;
-        // that is stated on the deserializing side as well.
-        writer.Write(_prophetOptions.InitialTrendValue);
-        writer.Write(_prophetOptions.InitialChangepointValue);
-        writer.Write(_prophetOptions.ForecastHorizon);
-        writer.Write(_prophetOptions.ChangePointPriorScale);
-        writer.Write(_prophetOptions.SeasonalityPriorScale);
-        writer.Write(_prophetOptions.HolidayPriorScale);
-        writer.Write(_prophetOptions.YearlySeasonality);
-        writer.Write(_prophetOptions.WeeklySeasonality);
-        writer.Write(_prophetOptions.DailySeasonality);
-        writer.Write(_prophetOptions.OptimizeParameters);
-        writer.Write(_prophetOptions.ApplyTransformation);
-        writer.Write(_prophetOptions.EnableAnomalyDetection);
-        writer.Write(_prophetOptions.AnomalyThresholdSigma);
-        writer.Write(_prophetOptions.ComputePredictionIntervals);
-        writer.Write(_prophetOptions.PredictionIntervalWidth);
-
-        writer.Write(Convert.ToDouble(_residualMean));
-        writer.Write(Convert.ToDouble(_residualStdDev));
-        writer.Write(Convert.ToDouble(_anomalyThreshold));
-    }
 
     /// <summary>
     /// Deserializes the core components of the Prophet model.
@@ -967,99 +884,7 @@ protected override void SerializeCore(BinaryWriter writer)
     /// This allows us to use a trained model without having to retrain it every time we want to use it.
     /// </para>
     /// </remarks>
-    protected override void DeserializeCore(BinaryReader reader)
-    {
-        // Piecewise-linear trend.
-        _m = NumOps.FromDouble(reader.ReadDouble());
-        _k = NumOps.FromDouble(reader.ReadDouble());
-        int deltaLength = reader.ReadInt32();
-        _delta = new Vector<T>(deltaLength);
-        for (int i = 0; i < deltaLength; i++)
-        {
-            _delta[i] = NumOps.FromDouble(reader.ReadDouble());
-        }
-        int changepointLength = reader.ReadInt32();
-        _changepointTimes = new Vector<T>(changepointLength);
-        for (int i = 0; i < changepointLength; i++)
-        {
-            _changepointTimes[i] = NumOps.FromDouble(reader.ReadDouble());
-        }
 
-        // Effective seasonal periods + Fourier order.
-        int effectivePeriodCount = reader.ReadInt32();
-        _effectiveSeasonalPeriods = new double[effectivePeriodCount];
-        for (int i = 0; i < effectivePeriodCount; i++)
-        {
-            _effectiveSeasonalPeriods[i] = reader.ReadDouble();
-        }
-        int fourierOrder = reader.ReadInt32();
-
-        // Seasonal Fourier coefficients.
-        int seasonalLength = reader.ReadInt32();
-        _seasonalComponents = new Vector<T>(seasonalLength);
-        for (int i = 0; i < seasonalLength; i++)
-        {
-            _seasonalComponents[i] = NumOps.FromDouble(reader.ReadDouble());
-        }
-
-        // Holiday and regressor coefficients.
-        int holidayLength = reader.ReadInt32();
-        _holidayComponents = new Vector<T>(holidayLength);
-        for (int i = 0; i < holidayLength; i++)
-        {
-            _holidayComponents[i] = NumOps.FromDouble(reader.ReadDouble());
-        }
-        int regressorLength = reader.ReadInt32();
-        _regressors = new Vector<T>(regressorLength);
-        for (int i = 0; i < regressorLength; i++)
-        {
-            _regressors[i] = NumOps.FromDouble(reader.ReadDouble());
-        }
-
-        // Read options
-        _prophetOptions = new ProphetOptions<T, TInput, TOutput>
-        {
-            FourierOrder = fourierOrder
-        };
-        int seasonalPeriodsCount = reader.ReadInt32();
-        for (int i = 0; i < seasonalPeriodsCount; i++)
-        {
-            _prophetOptions.SeasonalPeriods.Add(reader.ReadInt32());
-        }
-        int holidaysCount = reader.ReadInt32();
-        for (int i = 0; i < holidaysCount; i++)
-        {
-            _prophetOptions.Holidays.Add(new DateTime(reader.ReadInt64()));
-        }
-        _prophetOptions.RegressorCount = reader.ReadInt32();
-
-        // Read back in exactly the order SerializeCore wrote them.
-        //
-        // NOT RESTORED, because they cannot be: Optimizer is an interface reference and
-        // TransformPrediction is a delegate, so both revert to their defaults (null, and identity).
-        // A caller who supplied either must re-supply it on the loaded model; ApplyTransformation is
-        // restored faithfully, so a model saved with a custom transform will apply the IDENTITY
-        // transform until its TransformPrediction is set again.
-        _prophetOptions.InitialTrendValue = reader.ReadDouble();
-        _prophetOptions.InitialChangepointValue = reader.ReadDouble();
-        _prophetOptions.ForecastHorizon = reader.ReadInt32();
-        _prophetOptions.ChangePointPriorScale = reader.ReadDouble();
-        _prophetOptions.SeasonalityPriorScale = reader.ReadDouble();
-        _prophetOptions.HolidayPriorScale = reader.ReadDouble();
-        _prophetOptions.YearlySeasonality = reader.ReadBoolean();
-        _prophetOptions.WeeklySeasonality = reader.ReadBoolean();
-        _prophetOptions.DailySeasonality = reader.ReadBoolean();
-        _prophetOptions.OptimizeParameters = reader.ReadBoolean();
-        _prophetOptions.ApplyTransformation = reader.ReadBoolean();
-        _prophetOptions.EnableAnomalyDetection = reader.ReadBoolean();
-        _prophetOptions.AnomalyThresholdSigma = reader.ReadDouble();
-        _prophetOptions.ComputePredictionIntervals = reader.ReadBoolean();
-        _prophetOptions.PredictionIntervalWidth = reader.ReadDouble();
-
-        _residualMean = NumOps.FromDouble(reader.ReadDouble());
-        _residualStdDev = NumOps.FromDouble(reader.ReadDouble());
-        _anomalyThreshold = NumOps.FromDouble(reader.ReadDouble());
-    }
 
     /// <summary>
     /// Core implementation of the training logic for the Prophet model.
diff --git a/src/TimeSeries/SARIMAModel.cs b/src/TimeSeries/SARIMAModel.cs
index 9dfd40f7d8..b355f54be7 100644
--- a/src/TimeSeries/SARIMAModel.cs
+++ b/src/TimeSeries/SARIMAModel.cs
@@ -66,21 +66,25 @@ public SARIMAModel()
     /// <summary>
     /// Coefficients for the non-seasonal autoregressive (AR) component.
     /// </summary>
+    [AiDotNet.Attributes.FittedParameter]
     private Vector<T> _arCoefficients;
 
     /// <summary>
     /// Coefficients for the non-seasonal moving average (MA) component.
     /// </summary>
+    [AiDotNet.Attributes.FittedParameter]
     private Vector<T> _maCoefficients;
 
     /// <summary>
     /// Coefficients for the seasonal autoregressive (SAR) component.
     /// </summary>
+    [AiDotNet.Attributes.FittedParameter]
     private Vector<T> _sarCoefficients;
 
     /// <summary>
     /// Coefficients for the seasonal moving average (SMA) component.
     /// </summary>
+    [AiDotNet.Attributes.FittedParameter]
     private Vector<T> _smaCoefficients;
 
     /// <summary>
@@ -586,30 +590,7 @@ public override Dictionary<string, T> EvaluateModel(Matrix<T> xTest, Vector<T> y
     /// This allows you to save a trained model and load it later without having to retrain it.
     /// </para>
     /// </remarks>
-    protected override void SerializeCore(BinaryWriter writer)
-    {
-        // Serialize SARIMA-specific options
-        writer.Write(_sarimaOptions.P);
-        writer.Write(_sarimaOptions.D);
-        writer.Write(_sarimaOptions.Q);
-        writer.Write(_sarimaOptions.SeasonalP);
-        writer.Write(_sarimaOptions.SeasonalD);
-        writer.Write(_sarimaOptions.SeasonalQ);
-        writer.Write(_sarimaOptions.MaxIterations);
-        writer.Write(Convert.ToDouble(_sarimaOptions.Tolerance));
-
-        // Serialize coefficients
-        SerializationHelper<T>.SerializeVector(writer, _arCoefficients);
-        SerializationHelper<T>.SerializeVector(writer, _maCoefficients);
-        SerializationHelper<T>.SerializeVector(writer, _sarCoefficients);
-        SerializationHelper<T>.SerializeVector(writer, _smaCoefficients);
-        writer.Write(Convert.ToDouble(_constant));
-
-        // Serialize training series for Predict(Matrix) undifferencing
-        SerializationHelper<T>.SerializeVector(writer, _trainingSeries);
-        SerializationHelper<T>.SerializeVector(writer, _lastTrainDiffValues);
-        SerializationHelper<T>.SerializeVector(writer, _lastTrainResiduals);
-    }
+
 
     /// <summary>
     /// Deserializes the model's core parameters from a binary reader.
@@ -623,39 +604,7 @@ protected override void SerializeCore(BinaryWriter writer)
     /// exactly as it was when it was saved.
     /// </para>
     /// </remarks>
-    protected override void DeserializeCore(BinaryReader reader)
-    {
-        // Deserialize SARIMA-specific options
-        _sarimaOptions.P = reader.ReadInt32();
-        _sarimaOptions.D = reader.ReadInt32();
-        _sarimaOptions.Q = reader.ReadInt32();
-        _sarimaOptions.SeasonalP = reader.ReadInt32();
-        _sarimaOptions.SeasonalD = reader.ReadInt32();
-        _sarimaOptions.SeasonalQ = reader.ReadInt32();
-        _sarimaOptions.MaxIterations = reader.ReadInt32();
-        _sarimaOptions.Tolerance = Convert.ToDouble(reader.ReadDouble());
-
-        // Deserialize coefficients
-        _arCoefficients = SerializationHelper<T>.DeserializeVector(reader);
-        _maCoefficients = SerializationHelper<T>.DeserializeVector(reader);
-        _sarCoefficients = SerializationHelper<T>.DeserializeVector(reader);
-        _smaCoefficients = SerializationHelper<T>.DeserializeVector(reader);
-        _constant = NumOps.FromDouble(reader.ReadDouble());
-
-        // Deserialize training series (post-patch field)
-        try
-        {
-            _trainingSeries = SerializationHelper<T>.DeserializeVector(reader);
-            _lastTrainDiffValues = SerializationHelper<T>.DeserializeVector(reader);
-            _lastTrainResiduals = SerializationHelper<T>.DeserializeVector(reader);
-        }
-        catch (EndOfStreamException)
-        {
-            _trainingSeries = Vector<T>.Empty();
-            _lastTrainDiffValues = Vector<T>.Empty();
-            _lastTrainResiduals = Vector<T>.Empty();
-        }
-    }
+
 
     /// <summary>
     /// Core implementation of the training logic for the SARIMA model.
diff --git a/src/TimeSeries/STLDecomposition.cs b/src/TimeSeries/STLDecomposition.cs
index ee31fe3e4b..1135626731 100644
--- a/src/TimeSeries/STLDecomposition.cs
+++ b/src/TimeSeries/STLDecomposition.cs
@@ -46,7 +46,7 @@ namespace AiDotNet.TimeSeries;
 [ModelComplexity(ModelComplexity.Medium)]
 [ModelInput(typeof(Matrix<>), typeof(Vector<>))]
 [ResearchPaper("STL: A Seasonal-Trend Decomposition Procedure Based on Loess", "https://doi.org/10.6028/jres.090.015", Year = 1990, Authors = "Robert B. Cleveland, William S. Cleveland, Jean E. McRae, Irma Terpenning")]
-public class STLDecomposition<T> : TimeSeriesModelBase<T>
+public partial class STLDecomposition<T> : TimeSeriesModelBase<T>
 {
     /// <summary>
     /// Configuration options for the STL decomposition.
@@ -889,22 +889,7 @@ public override Dictionary<string, T> EvaluateModel(Matrix<T> xTest, Vector<T> y
     /// or continue analysis without repeating the decomposition process.
     /// </para>
     /// </remarks>
-    protected override void SerializeCore(BinaryWriter writer)
-    {
-        // Write STL options
-        writer.Write(_stlOptions.SeasonalPeriod);
-        writer.Write(_stlOptions.TrendWindowSize);
-        writer.Write(_stlOptions.SeasonalLoessWindow);
-        writer.Write(_stlOptions.TrendLoessWindow);
-        writer.Write(_stlOptions.LowPassFilterWindowSize);
-        writer.Write(_stlOptions.RobustIterations);
-        writer.Write(_stlOptions.RobustWeightThreshold);
-
-        // Write decomposition components
-        SerializationHelper<T>.SerializeVector(writer, _trend);
-        SerializationHelper<T>.SerializeVector(writer, _seasonal);
-        SerializationHelper<T>.SerializeVector(writer, _residual);
-    }
+
 
     /// <summary>
     /// Deserializes the model's core parameters from a binary reader.
@@ -925,34 +910,7 @@ protected override void SerializeCore(BinaryWriter writer)
     /// It's like saving your work in a document and opening it later to continue editing.
     /// </para>
     /// </remarks>
-    protected override void DeserializeCore(BinaryReader reader)
-    {
-        // Read STL options
-        int seasonalPeriod = reader.ReadInt32();
-        int trendWindowSize = reader.ReadInt32();
-        int seasonalLoessWindow = reader.ReadInt32();
-        int trendLoessWindow = reader.ReadInt32();
-        int lowPassFilterWindowSize = reader.ReadInt32();
-        int robustIterations = reader.ReadInt32();
-        double robustWeightThreshold = reader.ReadDouble();
-
-        // Create new STLDecompositionOptions<T> with the read values
-        _stlOptions = new STLDecompositionOptions<T>
-        {
-            SeasonalPeriod = seasonalPeriod,
-            TrendWindowSize = trendWindowSize,
-            SeasonalLoessWindow = seasonalLoessWindow,
-            TrendLoessWindow = trendLoessWindow,
-            LowPassFilterWindowSize = lowPassFilterWindowSize,
-            RobustIterations = robustIterations,
-            RobustWeightThreshold = robustWeightThreshold
-        };
 
-        // Read decomposition components
-        _trend = SerializationHelper<T>.DeserializeVector(reader);
-        _seasonal = SerializationHelper<T>.DeserializeVector(reader);
-        _residual = SerializationHelper<T>.DeserializeVector(reader);
-    }
 
     /// <summary>
     /// Resets the model to its initial state.
diff --git a/src/TimeSeries/SpectralAnalysisModel.cs b/src/TimeSeries/SpectralAnalysisModel.cs
index eff12bfed9..27df2536d9 100644
--- a/src/TimeSeries/SpectralAnalysisModel.cs
+++ b/src/TimeSeries/SpectralAnalysisModel.cs
@@ -61,6 +61,7 @@ public partial class SpectralAnalysisModel<T> : TimeSeriesModelBase<T>
     /// <summary>
     /// The power spectral density (periodogram) values for each frequency.
     /// </summary>
+    [AiDotNet.Attributes.FittedParameter]
     private Vector<T> _periodogram;
 
     /// <summary>
@@ -249,28 +250,7 @@ private Vector<Complex<T>> FFT(Vector<Complex<T>> x)
     /// - The calculated periodogram (power spectral density)
     /// </para>
     /// </remarks>
-    protected override void SerializeCore(BinaryWriter writer)
-    {
-        // Serialize SpectralAnalysisOptions
-        writer.Write(_spectralOptions.NFFT);
-        writer.Write(_spectralOptions.UseWindowFunction);
-        writer.Write((int)_spectralOptions.WindowFunction.GetWindowFunctionType());
-        writer.Write(_spectralOptions.OverlapPercentage);
-
-        // Serialize frequencies
-        writer.Write(_frequencies.Length);
-        for (int i = 0; i < _frequencies.Length; i++)
-        {
-            writer.Write(Convert.ToDouble(_frequencies[i]));
-        }
 
-        // Serialize periodogram
-        writer.Write(_periodogram.Length);
-        for (int i = 0; i < _periodogram.Length; i++)
-        {
-            writer.Write(Convert.ToDouble(_periodogram[i]));
-        }
-    }
 
     /// <summary>
     /// Deserializes the model's core parameters from a binary reader.
@@ -286,38 +266,7 @@ protected override void SerializeCore(BinaryWriter writer)
     /// This allows you to train a model once and then use it many times without retraining.
     /// </para>
     /// </remarks>
-    protected override void DeserializeCore(BinaryReader reader)
-    {
-        // Deserialize SpectralAnalysisOptions
-        int nfft = reader.ReadInt32();
-        bool useWindowFunction = reader.ReadBoolean();
-        WindowFunctionType windowFunctionType = (WindowFunctionType)reader.ReadInt32();
-        int overlapPercentage = reader.ReadInt32();
 
-        _spectralOptions = new SpectralAnalysisOptions<T>
-        {
-            NFFT = nfft,
-            UseWindowFunction = useWindowFunction,
-            WindowFunction = WindowFunctionFactory.CreateWindowFunction<T>(windowFunctionType),
-            OverlapPercentage = overlapPercentage
-        };
-
-        // Deserialize frequencies
-        int frequenciesLength = reader.ReadInt32();
-        _frequencies = new Vector<T>(frequenciesLength);
-        for (int i = 0; i < frequenciesLength; i++)
-        {
-            _frequencies[i] = NumOps.FromDouble(reader.ReadDouble());
-        }
-
-        // Deserialize periodogram
-        int periodogramLength = reader.ReadInt32();
-        _periodogram = new Vector<T>(periodogramLength);
-        for (int i = 0; i < periodogramLength; i++)
-        {
-            _periodogram[i] = NumOps.FromDouble(reader.ReadDouble());
-        }
-    }
 
     /// <summary>
     /// Evaluates the performance of the trained model on test data.
diff --git a/src/TimeSeries/StateSpaceModel.cs b/src/TimeSeries/StateSpaceModel.cs
index 41a5d7ae77..0fcd8fa5f3 100644
--- a/src/TimeSeries/StateSpaceModel.cs
+++ b/src/TimeSeries/StateSpaceModel.cs
@@ -61,21 +61,25 @@ public StateSpaceModel()
     /// <summary>
     /// The state transition matrix that describes how the hidden state evolves from one time step to the next.
     /// </summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private Matrix<T> _transitionMatrix;
 
     /// <summary>
     /// The observation matrix that relates the hidden state to the observed measurements.
     /// </summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private Matrix<T> _observationMatrix;
 
     /// <summary>
     /// The covariance matrix of the process noise, representing uncertainty in the state transition.
     /// </summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private Matrix<T> _processNoise;
 
     /// <summary>
     /// The covariance matrix of the observation noise, representing measurement uncertainty.
     /// </summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private Matrix<T> _observationNoise;
 
     /// <summary>
@@ -496,45 +500,7 @@ private double CalculateMatrixDifference(Matrix<T> matrix1, Matrix<T> matrix2)
     /// - Other parameters like learning rate and convergence settings
     /// </para>
     /// </remarks>
-    protected override void SerializeCore(BinaryWriter writer)
-    {
-        // Serialize dimensions
-        writer.Write(_stateSize);
-        writer.Write(_observationSize);
-
-        // Serialize matrices
-        SerializationHelper<T>.SerializeMatrix(writer, _transitionMatrix);
-        SerializationHelper<T>.SerializeMatrix(writer, _observationMatrix);
-        SerializationHelper<T>.SerializeMatrix(writer, _processNoise);
-        SerializationHelper<T>.SerializeMatrix(writer, _observationNoise);
-
-        // Serialize vector
-        SerializationHelper<T>.SerializeVector(writer, _initialState);
-
-        // Serialize other parameters
-        writer.Write(_learningRate);
-        writer.Write(_maxIterations);
-        writer.Write(_tolerance);
-        writer.Write(_convergenceThreshold);
-
-        // Serialize ALL smoothed states for in-sample prediction support
-        if (_smoothedStates != null && _smoothedStates.Count > 0)
-        {
-            writer.Write(_smoothedStates.Count);
-            writer.Write(_smoothedStates[0].Length);
-            foreach (var state in _smoothedStates)
-            {
-                for (int i = 0; i < state.Length; i++)
-                {
-                    writer.Write(Convert.ToDouble(state[i]));
-                }
-            }
-        }
-        else
-        {
-            writer.Write(0);
-        }
-    }
+
 
     /// <summary>
     /// Deserializes the model's core parameters from a binary reader.
@@ -552,51 +518,7 @@ protected override void SerializeCore(BinaryWriter writer)
     /// having to figure out the ingredients and proportions from scratch.
     /// </para>
     /// </remarks>
-    protected override void DeserializeCore(BinaryReader reader)
-    {
-        // Deserialize dimensions
-        _stateSize = reader.ReadInt32();
-        _observationSize = reader.ReadInt32();
-
-        // Deserialize matrices
-        _transitionMatrix = SerializationHelper<T>.DeserializeMatrix(reader, _stateSize, _stateSize);
-        _observationMatrix = SerializationHelper<T>.DeserializeMatrix(reader, _observationSize, _stateSize);
-        _processNoise = SerializationHelper<T>.DeserializeMatrix(reader, _stateSize, _stateSize);
-        _observationNoise = SerializationHelper<T>.DeserializeMatrix(reader, _observationSize, _observationSize);
-
-        // Deserialize vector
-        _initialState = SerializationHelper<T>.DeserializeVector(reader, _stateSize);
-
-        // Deserialize other parameters
-        _learningRate = reader.ReadDouble();
-        _maxIterations = reader.ReadInt32();
-        _tolerance = reader.ReadDouble();
-        _convergenceThreshold = reader.ReadDouble();
-
-        // Deserialize ALL smoothed states for in-sample prediction support
-        _smoothedStates = new List<Vector<T>>();
-        try
-        {
-            int smoothedCount = reader.ReadInt32();
-            if (smoothedCount > 0)
-            {
-                int stateLen = reader.ReadInt32();
-                for (int s = 0; s < smoothedCount; s++)
-                {
-                    var state = new Vector<T>(stateLen);
-                    for (int i = 0; i < stateLen; i++)
-                    {
-                        state[i] = NumOps.FromDouble(reader.ReadDouble());
-                    }
-                    _smoothedStates.Add(state);
-                }
-            }
-        }
-        catch (EndOfStreamException)
-        {
-            // Older serialized models don't include smoothed states — leave empty
-        }
-    }
+
 
     /// <summary>
     /// Core implementation of the training logic for the State Space Model.
diff --git a/src/TimeSeries/TBATSModel.cs b/src/TimeSeries/TBATSModel.cs
index 80bc240be4..be6e5bd0d8 100644
--- a/src/TimeSeries/TBATSModel.cs
+++ b/src/TimeSeries/TBATSModel.cs
@@ -80,11 +80,13 @@ public partial class TBATSModel<T> : TimeSeriesModelBase<T>
     /// <summary>
     /// The autoregressive (AR) coefficients for the ARMA error model.
     /// </summary>
+    [AiDotNet.Attributes.Buffer]
     private Vector<T> _arCoefficients;
 
     /// <summary>
     /// The moving average (MA) coefficients for the ARMA error model.
     /// </summary>
+    [AiDotNet.Attributes.Buffer]
     private Vector<T> _maCoefficients;
 
     /// <summary>
@@ -1046,43 +1048,7 @@ public override Dictionary<string, T> EvaluateModel(Matrix<T> xTest, Vector<T> y
     /// or continue analysis without repeating the training process.
     /// </para>
     /// </remarks>
-    protected override void SerializeCore(BinaryWriter writer)
-    {
-        // Serialize TBATSModel specific data
-        writer.Write(_level.Length);
-        for (int i = 0; i < _level.Length; i++)
-            writer.Write(Convert.ToDouble(_level[i]));
-
-        writer.Write(_trend.Length);
-        for (int i = 0; i < _trend.Length; i++)
-            writer.Write(Convert.ToDouble(_trend[i]));
-
-        writer.Write(_seasonalComponents.Count);
-        foreach (var component in _seasonalComponents)
-        {
-            writer.Write(component.Length);
-            for (int i = 0; i < component.Length; i++)
-                writer.Write(Convert.ToDouble(component[i]));
-        }
-
-        writer.Write(_arCoefficients.Length);
-        for (int i = 0; i < _arCoefficients.Length; i++)
-            writer.Write(Convert.ToDouble(_arCoefficients[i]));
 
-        writer.Write(_maCoefficients.Length);
-        for (int i = 0; i < _maCoefficients.Length; i++)
-            writer.Write(Convert.ToDouble(_maCoefficients[i]));
-
-        writer.Write(Convert.ToDouble(_boxCoxLambda));
-
-        // Serialize TBATSModelOptions
-        writer.Write(JsonConvert.SerializeObject(_tbatsOptions));
-
-        // Serialize training series for in-sample predictions
-        writer.Write(_trainingSeries.Length);
-        for (int i = 0; i < _trainingSeries.Length; i++)
-            writer.Write(Convert.ToDouble(_trainingSeries[i]));
-    }
 
     /// <summary>
     /// Deserializes the model's core parameters from a binary reader.
@@ -1103,60 +1069,7 @@ protected override void SerializeCore(BinaryWriter writer)
     /// It's like saving your work in a document and opening it later to continue editing.
     /// </para>
     /// </remarks>
-    protected override void DeserializeCore(BinaryReader reader)
-    {
-        // Deserialize TBATSModel specific data
-        int levelLength = reader.ReadInt32();
-        _level = new Vector<T>(levelLength);
-        for (int i = 0; i < levelLength; i++)
-            _level[i] = NumOps.FromDouble(reader.ReadDouble());
-
-        int trendLength = reader.ReadInt32();
-        _trend = new Vector<T>(trendLength);
-        for (int i = 0; i < trendLength; i++)
-            _trend[i] = NumOps.FromDouble(reader.ReadDouble());
-
-        int seasonalComponentsCount = reader.ReadInt32();
-        _seasonalComponents = new List<Vector<T>>();
-        for (int j = 0; j < seasonalComponentsCount; j++)
-        {
-            int componentLength = reader.ReadInt32();
-            Vector<T> component = new Vector<T>(componentLength);
-            for (int i = 0; i < componentLength; i++)
-                component[i] = NumOps.FromDouble(reader.ReadDouble());
-            _seasonalComponents.Add(component);
-        }
-
-        int arCoefficientsLength = reader.ReadInt32();
-        _arCoefficients = new Vector<T>(arCoefficientsLength);
-        for (int i = 0; i < arCoefficientsLength; i++)
-            _arCoefficients[i] = NumOps.FromDouble(reader.ReadDouble());
-
-        int maCoefficientsLength = reader.ReadInt32();
-        _maCoefficients = new Vector<T>(maCoefficientsLength);
-        for (int i = 0; i < maCoefficientsLength; i++)
-            _maCoefficients[i] = NumOps.FromDouble(reader.ReadDouble());
-
-        _boxCoxLambda = NumOps.FromDouble(reader.ReadDouble());
-
-        // Deserialize TBATSModelOptions
-        string optionsJson = reader.ReadString();
-        _tbatsOptions = JsonConvert.DeserializeObject<TBATSModelOptions<T>>(optionsJson)
-            ?? throw new InvalidOperationException("Failed to deserialize TBATS model options.");
 
-        // Deserialize training series (post-patch field)
-        try
-        {
-            int tsLen = reader.ReadInt32();
-            _trainingSeries = new Vector<T>(tsLen);
-            for (int i = 0; i < tsLen; i++)
-                _trainingSeries[i] = NumOps.FromDouble(reader.ReadDouble());
-        }
-        catch (EndOfStreamException)
-        {
-            _trainingSeries = Vector<T>.Empty();
-        }
-    }
 
     /// <summary>
     /// Resets the model to its initial state.
diff --git a/src/TimeSeries/TFT/GatedResidualNetwork.cs b/src/TimeSeries/TFT/GatedResidualNetwork.cs
index 46f7ef6fbc..65993e04fe 100644
--- a/src/TimeSeries/TFT/GatedResidualNetwork.cs
+++ b/src/TimeSeries/TFT/GatedResidualNetwork.cs
@@ -16,7 +16,7 @@ namespace AiDotNet.TimeSeries.TFT;
 /// (token-wise), matching the Temporal Fusion Transformer tape-training campaign.
 /// The final layer normalization uses learned affine parameters (γ, β).
 /// </remarks>
-internal class GatedResidualNetwork<T>
+internal partial class GatedResidualNetwork<T>
 {
     private static IEngine Engine => AiDotNetEngine.Current;
 
@@ -25,24 +25,35 @@ internal class GatedResidualNetwork<T>
     private readonly int _outputSize;
 
     // η₂ = ELU(W₂·a + b₂)
+    [AiDotNet.Attributes.TrainableParameter]
     private readonly Tensor<T> _w2; // [hiddenSize, inputSize]
+    [AiDotNet.Attributes.TrainableParameter]
     private readonly Tensor<T> _b2; // [hiddenSize]
 
     // η₁ = W₁·η₂ + b₁
+    [AiDotNet.Attributes.TrainableParameter]
     private readonly Tensor<T> _w1; // [outputSize, hiddenSize]
+    [AiDotNet.Attributes.TrainableParameter]
     private readonly Tensor<T> _b1; // [outputSize]
 
     // GLU: σ(W₄·γ + b₄) ⊙ (W₅·γ + b₅)
+    [AiDotNet.Attributes.TrainableParameter]
     private readonly Tensor<T> _w4; // [outputSize, outputSize]
+    [AiDotNet.Attributes.TrainableParameter]
     private readonly Tensor<T> _b4; // [outputSize]
+    [AiDotNet.Attributes.TrainableParameter]
     private readonly Tensor<T> _w5; // [outputSize, outputSize]
+    [AiDotNet.Attributes.TrainableParameter]
     private readonly Tensor<T> _b5; // [outputSize]
 
     // Skip connection projection (only when inputSize != outputSize)
+    [AiDotNet.Attributes.TrainableParameter]
     private readonly Tensor<T>? _skipProjection; // [outputSize, inputSize]
 
     // Learned LayerNorm affine parameters
+    [AiDotNet.Attributes.TrainableParameter]
     private readonly Tensor<T> _lnGamma; // [outputSize]
+    [AiDotNet.Attributes.TrainableParameter]
     private readonly Tensor<T> _lnBeta;  // [outputSize]
 
     public GatedResidualNetwork(int inputSize, int hiddenSize, int outputSize, int? seed = null)
diff --git a/src/TimeSeries/TemporalFusionTransformer.cs b/src/TimeSeries/TemporalFusionTransformer.cs
index d6a229e958..f9ff6a5674 100644
--- a/src/TimeSeries/TemporalFusionTransformer.cs
+++ b/src/TimeSeries/TemporalFusionTransformer.cs
@@ -55,7 +55,9 @@ public partial class TemporalFusionTransformer<T> : TimeSeriesModelBase<T>
     private readonly int _hiddenSize;
 
     // Input embedding: scalar value at each timestep -> hiddenSize vector.
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _inputEmbeddingWeight; // [1, hiddenSize]
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _inputEmbeddingBias;   // [hiddenSize]
 
     // Sinusoidal positional encoding [maxLen, hiddenSize] (replaces the LSTM scan).
@@ -79,7 +81,9 @@ public partial class TemporalFusionTransformer<T> : TimeSeriesModelBase<T>
     private GatedResidualNetwork<T> _postAttentionGrn;
 
     // Quantile forecast head: pooled hidden -> H-step forecast for each quantile level (quantile-major).
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _forecastWeight; // [hiddenSize, forecastHorizon * numQuantiles]
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _forecastBias;   // [forecastHorizon * numQuantiles]
 
     // Training state.
diff --git a/src/TimeSeries/TiDEModel.cs b/src/TimeSeries/TiDEModel.cs
index 04d7b4076f..c1f8ac66b7 100644
--- a/src/TimeSeries/TiDEModel.cs
+++ b/src/TimeSeries/TiDEModel.cs
@@ -1,32 +1,33 @@
-using AiDotNet.Attributes;
-using AiDotNet.Enums;
-using AiDotNet.Models.Options;

+using AiDotNet.Attributes;
+using AiDotNet.Enums;
+using AiDotNet.Models.Options;
+
 using AiDotNet.Models.Parameters;
-
-namespace AiDotNet.TimeSeries;
-
-/// <summary>
-/// TiDE — Time-series Dense Encoder (Das et al., TMLR 2023). A pure-MLP forecaster: a ReLU encoder maps the
-/// input window to a latent, a decoder projects it to the forecast, and a linear residual skips the window
-/// straight to the output. Despite using no attention it matches or beats transformers on long-horizon
-/// benchmarks at far lower cost — a strong, current member of the SOTA panel. Implemented with explicit
-/// forward + manual backprop (a 1-hidden-layer ReLU MLP + linear skip), so every gradient is exact.
-/// </summary>
-/// <typeparam name="T">Numeric type (float/double).</typeparam>
-[ModelDomain(ModelDomain.TimeSeries)]
-[ModelCategory(ModelCategory.TimeSeriesModel)]
-[ModelCategory(ModelCategory.NeuralNetwork)]
-[ModelTask(ModelTask.Forecasting)]
-[ModelComplexity(ModelComplexity.Medium)]
-[ModelInput(typeof(Matrix<>), typeof(Vector<>))]
-[ResearchPaper("Long-term Forecasting with TiDE: Time-series Dense Encoder", "https://arxiv.org/abs/2304.08424", Year = 2023, Authors = "Abhimanyu Das, Weihao Kong, Andrew Leach, Shaan Mathur, Rajat Sen, Rose Yu")]
-public partial class TiDEModel<T> : TimeSeriesModelBase<T>
-{
-    private readonly TiDEOptions<T> _options;
-    private readonly Random _random;
-    private readonly int _l;
-    private readonly int _h;
-
+
+namespace AiDotNet.TimeSeries;
+
+/// <summary>
+/// TiDE — Time-series Dense Encoder (Das et al., TMLR 2023). A pure-MLP forecaster: a ReLU encoder maps the
+/// input window to a latent, a decoder projects it to the forecast, and a linear residual skips the window
+/// straight to the output. Despite using no attention it matches or beats transformers on long-horizon
+/// benchmarks at far lower cost — a strong, current member of the SOTA panel. Implemented with explicit
+/// forward + manual backprop (a 1-hidden-layer ReLU MLP + linear skip), so every gradient is exact.
+/// </summary>
+/// <typeparam name="T">Numeric type (float/double).</typeparam>
+[ModelDomain(ModelDomain.TimeSeries)]
+[ModelCategory(ModelCategory.TimeSeriesModel)]
+[ModelCategory(ModelCategory.NeuralNetwork)]
+[ModelTask(ModelTask.Forecasting)]
+[ModelComplexity(ModelComplexity.Medium)]
+[ModelInput(typeof(Matrix<>), typeof(Vector<>))]
+[ResearchPaper("Long-term Forecasting with TiDE: Time-series Dense Encoder", "https://arxiv.org/abs/2304.08424", Year = 2023, Authors = "Abhimanyu Das, Weihao Kong, Andrew Leach, Shaan Mathur, Rajat Sen, Rose Yu")]
+public partial class TiDEModel<T> : TimeSeriesModelBase<T>
+{
+    private readonly TiDEOptions<T> _options;
+    private readonly Random _random;
+    private readonly int _l;
+    private readonly int _h;
+
     // Encoder: hidden = ReLU(W1·x + b1). Decoder: out = W2·hidden + b2. Linear skip: + Wr·x + br.
     [TrainableParameter]
     private readonly double[][] _w1; // [H][L]
@@ -40,11 +41,11 @@ public partial class TiDEModel<T> : TimeSeriesModelBase<T>
     private readonly double[] _wr;   // [L]
     [TrainableParameter]
     private double _br;
-
-    // TiDE's reference implementation optionally normalizes each series before
-    // the dense encoder and restores its scale after decoding. This supervised
-    // Matrix/Vector adaptation keeps equivalent training-set statistics so raw
-    // time indices and large target offsets do not destabilize the MLP.
+
+    // TiDE's reference implementation optionally normalizes each series before
+    // the dense encoder and restores its scale after decoding. This supervised
+    // Matrix/Vector adaptation keeps equivalent training-set statistics so raw
+    // time indices and large target offsets do not destabilize the MLP.
     [Buffer]
     private readonly double[] _inputMeans;
     [Buffer]
@@ -53,309 +54,261 @@ public partial class TiDEModel<T> : TimeSeriesModelBase<T>
     private double _targetMean;
     [Buffer]
     private double _targetStd = 1.0;
-
-    public TiDEModel(TiDEOptions<T>? options = null)
-        : base(options ?? new TiDEOptions<T>())
-    {
-        _options = options ?? new TiDEOptions<T>();
-        Options = _options;
-        _random = RandomHelper.CreateSeededRandom(42);
-        _l = Math.Max(2, _options.LookbackWindow);
-        _h = Math.Max(1, _options.HiddenSize);
-
-        _w1 = new double[_h][];
-        _b1 = new double[_h];
-        _w2 = new double[_h];
-        _wr = new double[_l];
-        _inputMeans = new double[_l];
-        _inputStds = Enumerable.Repeat(1.0, _l).ToArray();
-        double s1 = Math.Sqrt(2.0 / _l); // He init for ReLU
-        double s2 = Math.Sqrt(1.0 / _h);
-        for (int i = 0; i < _h; i++)
-        {
-            _w1[i] = new double[_l];
-            for (int j = 0; j < _l; j++) { _w1[i][j] = (_random.NextDouble() * 2 - 1) * s1; }
-            _w2[i] = (_random.NextDouble() * 2 - 1) * s2;
-        }
-
-        for (int j = 0; j < _l; j++) { _wr[j] = 1.0 / _l; } // skip starts as a moving average
-    }
-
-    private static bool IsFiniteValue(double v) => !double.IsNaN(v) && !double.IsInfinity(v);
-
-    /// <summary>
-    /// Converts a forecast to <typeparamref name="T"/> and verifies finiteness AFTER the conversion.
-    /// Checking only the double is not enough: every double from about 3.4e38 up is finite yet
-    /// overflows to Infinity once narrowed to float, so a pre-conversion guard passes the value
-    /// through and the float caller still receives Infinity.
-    /// </summary>
-    private T ToFiniteT(double value)
-    {
-        if (!IsFiniteValue(value)) { return NumOps.Zero; }
-        T converted = NumOps.FromDouble(value);
-        return IsFiniteValue(NumOps.ToDouble(converted)) ? converted : NumOps.Zero;
-    }
-
-    private static double[] Window(int l, Func<int, double> get, int count)
-    {
-        var x = new double[l];
-        int start = Math.Max(0, count - l);
-        for (int j = 0; j < l; j++)
-        {
-            int idx = start + j;
-            double v = idx < count ? get(idx) : 0.0;
-            x[j] = IsFiniteValue(v) ? v : 0.0;
-        }
-
-        return x;
-    }
-
-    private (double[] Hidden, double Pred) Forward(double[] x)
-    {
-        var hidden = new double[_h];
-        for (int i = 0; i < _h; i++)
-        {
-            double z = _b1[i];
-            var row = _w1[i];
-            for (int j = 0; j < _l; j++) { z += row[j] * x[j]; }
-            hidden[i] = z > 0 ? z : 0.0; // ReLU
-        }
-
-        double pred = _b2 + _br;
-        for (int i = 0; i < _h; i++) { pred += _w2[i] * hidden[i]; }
-        for (int j = 0; j < _l; j++) { pred += _wr[j] * x[j]; }
-        return (hidden, pred);
-    }
-
-    private double[] NormalizeWindow(double[] x)
-    {
-        var normalized = new double[_l];
-        for (int j = 0; j < _l; j++)
-            normalized[j] = (x[j] - _inputMeans[j]) / _inputStds[j];
-        return normalized;
-    }
-
-    private void FitNormalization(Matrix<T> x, Vector<T> y)
-    {
-        int n = x.Rows;
-        int cols = x.Columns;
-
-        Array.Clear(_inputMeans, 0, _inputMeans.Length);
-        for (int j = 0; j < _inputStds.Length; j++)
-            _inputStds[j] = 1.0;
-
-        for (int row = 0; row < n; row++)
-        {
-            var window = Window(_l, c => Convert.ToDouble(x[row, c]), cols);
-            for (int j = 0; j < _l; j++)
-                _inputMeans[j] += window[j];
-        }
-        if (n > 0)
-        {
-            for (int j = 0; j < _l; j++)
-                _inputMeans[j] /= n;
-        }
-
-        var variances = new double[_l];
-        _targetMean = 0.0;
-        int finiteTargets = 0;
-        for (int row = 0; row < n; row++)
-        {
-            var window = Window(_l, c => Convert.ToDouble(x[row, c]), cols);
-            for (int j = 0; j < _l; j++)
-            {
-                double centered = window[j] - _inputMeans[j];
-                variances[j] += centered * centered;
-            }
-            // Non-finite targets are EXCLUDED from the statistics, matching NLinearModel.FitScalers.
-            // Window already clamps non-finite inputs, so _inputMeans and _inputStds were protected;
-            // the target path was not. A single NaN label made _targetMean NaN, and while _targetStd
-            // rescues _targetStd back to 1.0, nothing rescued the mean -- every normalized target,
-            // every error and every gradient then went NaN, training completed without an exception,
-            // and every later prediction collapsed to 0 through the output guard. Silent and total.
-            double target = Convert.ToDouble(y[row]);
-            if (!IsFiniteValue(target)) continue;
-
-            _targetMean += target;
-            finiteTargets++;
-        }
-
-        if (n > 0)
-        {
-            _targetMean = finiteTargets > 0 ? _targetMean / finiteTargets : 0.0;
-            for (int j = 0; j < _l; j++)
-            {
-                double std = Math.Sqrt(variances[j] / n);
-                _inputStds[j] = std > 1e-8 && IsFiniteValue(std) ? std : 1.0;
-            }
-        }
-
-        double targetVariance = 0.0;
-        for (int row = 0; row < n; row++)
-        {
-            double target = Convert.ToDouble(y[row]);
-            if (!IsFiniteValue(target)) continue;
-
-            double centered = target - _targetMean;
-            targetVariance += centered * centered;
-        }
-        double targetStd = finiteTargets > 0 ? Math.Sqrt(targetVariance / finiteTargets) : 1.0;
-        _targetStd = targetStd > 1e-8 && IsFiniteValue(targetStd) ? targetStd : 1.0;
-    }
-
-    protected override void TrainCore(Matrix<T> x, Vector<T> y)
-    {
-        int n = x.Rows;
-        int cols = x.Columns;
-        double lr = _options.LearningRate;
-
-        FitNormalization(x, y);
-
-        for (int epoch = 0; epoch < _options.Epochs; epoch++)
-        {
-            TrainingCancellationToken.ThrowIfCancellationRequested();
-            var order = Enumerable.Range(0, n).OrderBy(_ => _random.Next()).ToList();
-
-            for (int batchStart = 0; batchStart < n; batchStart += _options.BatchSize)
-            {
-                int batchEnd = Math.Min(batchStart + _options.BatchSize, n);
-                int bs = batchEnd - batchStart;
-
-                // Gradient accumulators.
-                var gW1 = new double[_h][];
-                for (int i = 0; i < _h; i++) { gW1[i] = new double[_l]; }
-                var gB1 = new double[_h];
-                var gW2 = new double[_h];
-                double gB2 = 0;
-                var gWr = new double[_l];
-                double gBr = 0;
-
-                for (int bi = batchStart; bi < batchEnd; bi++)
-                {
-                    int idx = order[bi];
-                    var xv = NormalizeWindow(Window(_l, c => Convert.ToDouble(x[idx, c]), cols));
-                    var (hidden, pred) = Forward(xv);
-                    // Filtering the statistics alone does not keep a NaN label out of the gradient:
-                    // this row's error would still be NaN and would poison every weight it touches.
-                    // Skip the row instead.
-                    double rawTarget = Convert.ToDouble(y[idx]);
-                    if (!IsFiniteValue(rawTarget)) continue;
-
-                    double normalizedTarget = (rawTarget - _targetMean) / _targetStd;
-                    double err = pred - normalizedTarget; // dMSE/dpred
-
-                    gB2 += err;
-                    gBr += err;
-                    for (int j = 0; j < _l; j++) { gWr[j] += err * xv[j]; }
-                    for (int i = 0; i < _h; i++)
-                    {
-                        gW2[i] += err * hidden[i];
-                        double dz = hidden[i] > 0 ? err * _w2[i] : 0.0; // ReLU derivative
-                        gB1[i] += dz;
-                        var grow = gW1[i];
-                        for (int j = 0; j < _l; j++) { grow[j] += dz * xv[j]; }
-                    }
-                }
-
-                double inv = bs > 0 ? lr / bs : 0.0;
-                _b2 -= inv * gB2;
-                _br -= inv * gBr;
-                for (int j = 0; j < _l; j++) { _wr[j] -= inv * gWr[j]; }
-                for (int i = 0; i < _h; i++)
-                {
-                    _w2[i] -= inv * gW2[i];
-                    _b1[i] -= inv * gB1[i];
-                    var row = _w1[i];
-                    var grow = gW1[i];
-                    for (int j = 0; j < _l; j++) { row[j] -= inv * grow[j]; }
-                }
-            }
-        }
-
+
+    public TiDEModel(TiDEOptions<T>? options = null)
+        : base(options ?? new TiDEOptions<T>())
+    {
+        _options = options ?? new TiDEOptions<T>();
+        Options = _options;
+        _random = RandomHelper.CreateSeededRandom(42);
+        _l = Math.Max(2, _options.LookbackWindow);
+        _h = Math.Max(1, _options.HiddenSize);
+
+        _w1 = new double[_h][];
+        _b1 = new double[_h];
+        _w2 = new double[_h];
+        _wr = new double[_l];
+        _inputMeans = new double[_l];
+        _inputStds = Enumerable.Repeat(1.0, _l).ToArray();
+        double s1 = Math.Sqrt(2.0 / _l); // He init for ReLU
+        double s2 = Math.Sqrt(1.0 / _h);
+        for (int i = 0; i < _h; i++)
+        {
+            _w1[i] = new double[_l];
+            for (int j = 0; j < _l; j++) { _w1[i][j] = (_random.NextDouble() * 2 - 1) * s1; }
+            _w2[i] = (_random.NextDouble() * 2 - 1) * s2;
+        }
+
+        for (int j = 0; j < _l; j++) { _wr[j] = 1.0 / _l; } // skip starts as a moving average
     }
-
-    public override T PredictSingle(Vector<T> input)
-    {
-        var xv = NormalizeWindow(Window(_l, j => Convert.ToDouble(input[j]), input.Length));
-        var (_, normalizedPrediction) = Forward(xv);
-        double pred = normalizedPrediction * _targetStd + _targetMean;
-        // ToFiniteT, not NumOps.FromDouble(IsFiniteValue(pred) ? pred : 0.0): the pre-conversion
-        // check is the insufficient one its own helper documents. Every double from about 3.4e38 up
-        // is finite yet overflows to Infinity once narrowed to float, so the pre-conversion form
-        // passed such a value straight through to a float model. GuardPrediction then still runs, as
-        // a second line of defence for the recursive-forecast path.
-        return GuardPrediction(ToFiniteT(pred));
-    }
-
-    protected override void SerializeCore(BinaryWriter writer)
-    {
-        writer.Write(_l);
-        writer.Write(_h);
-        for (int i = 0; i < _h; i++)
-        {
-            for (int j = 0; j < _l; j++) { writer.Write(_w1[i][j]); }
-            writer.Write(_b1[i]);
-            writer.Write(_w2[i]);
-        }
-
-        writer.Write(_b2);
-        for (int j = 0; j < _l; j++) { writer.Write(_wr[j]); }
-        writer.Write(_br);
-        writer.Write(_targetMean);
-        writer.Write(_targetStd);
-        for (int j = 0; j < _l; j++)
-        {
-            writer.Write(_inputMeans[j]);
-            writer.Write(_inputStds[j]);
-        }
-    }
-
-    protected override void DeserializeCore(BinaryReader reader)
-    {
-        reader.ReadInt32();
-        reader.ReadInt32();
-        for (int i = 0; i < _h; i++)
-        {
-            for (int j = 0; j < _l; j++) { _w1[i][j] = reader.ReadDouble(); }
-            _b1[i] = reader.ReadDouble();
-            _w2[i] = reader.ReadDouble();
-        }
-
-        _b2 = reader.ReadDouble();
-        for (int j = 0; j < _l; j++) { _wr[j] = reader.ReadDouble(); }
-        _br = reader.ReadDouble();
-
-        // Normalization state was added after the original TiDE serialization
-        // layout. Older payloads end after _br and retain identity statistics.
-        if (reader.BaseStream.Position < reader.BaseStream.Length)
-        {
-            _targetMean = reader.ReadDouble();
-            _targetStd = reader.ReadDouble();
-            for (int j = 0; j < _l; j++)
-            {
-                _inputMeans[j] = reader.ReadDouble();
-                _inputStds[j] = reader.ReadDouble();
-            }
-        }
-    }
-
-    public override ModelMetadata<T> GetModelMetadata()
-    {
-        return new ModelMetadata<T>
-        {
-            Name = "TiDE",
-            Description = "Time-series Dense Encoder — pure-MLP encoder/decoder + linear residual (Das et al. 2023)",
-            Complexity = ParameterCount,
-            FeatureCount = _options.LookbackWindow,
-            AdditionalInfo = new Dictionary<string, object>
-            {
-                { "LookbackWindow", _options.LookbackWindow },
-                { "HiddenSize", _options.HiddenSize },
-                { "ForecastHorizon", _options.ForecastHorizon },
-            },
-        };
-    }
-
-    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateInstance()
-        => new TiDEModel<T>(new TiDEOptions<T>(_options));
-}
+
+    private static bool IsFiniteValue(double v) => !double.IsNaN(v) && !double.IsInfinity(v);
+
+    /// <summary>
+    /// Converts a forecast to <typeparamref name="T"/> and verifies finiteness AFTER the conversion.
+    /// Checking only the double is not enough: every double from about 3.4e38 up is finite yet
+    /// overflows to Infinity once narrowed to float, so a pre-conversion guard passes the value
+    /// through and the float caller still receives Infinity.
+    /// </summary>
+    private T ToFiniteT(double value)
+    {
+        if (!IsFiniteValue(value)) { return NumOps.Zero; }
+        T converted = NumOps.FromDouble(value);
+        return IsFiniteValue(NumOps.ToDouble(converted)) ? converted : NumOps.Zero;
+    }
+
+    private static double[] Window(int l, Func<int, double> get, int count)
+    {
+        var x = new double[l];
+        int start = Math.Max(0, count - l);
+        for (int j = 0; j < l; j++)
+        {
+            int idx = start + j;
+            double v = idx < count ? get(idx) : 0.0;
+            x[j] = IsFiniteValue(v) ? v : 0.0;
+        }
+
+        return x;
+    }
+
+    private (double[] Hidden, double Pred) Forward(double[] x)
+    {
+        var hidden = new double[_h];
+        for (int i = 0; i < _h; i++)
+        {
+            double z = _b1[i];
+            var row = _w1[i];
+            for (int j = 0; j < _l; j++) { z += row[j] * x[j]; }
+            hidden[i] = z > 0 ? z : 0.0; // ReLU
+        }
+
+        double pred = _b2 + _br;
+        for (int i = 0; i < _h; i++) { pred += _w2[i] * hidden[i]; }
+        for (int j = 0; j < _l; j++) { pred += _wr[j] * x[j]; }
+        return (hidden, pred);
+    }
+
+    private double[] NormalizeWindow(double[] x)
+    {
+        var normalized = new double[_l];
+        for (int j = 0; j < _l; j++)
+            normalized[j] = (x[j] - _inputMeans[j]) / _inputStds[j];
+        return normalized;
+    }
+
+    private void FitNormalization(Matrix<T> x, Vector<T> y)
+    {
+        int n = x.Rows;
+        int cols = x.Columns;
+
+        Array.Clear(_inputMeans, 0, _inputMeans.Length);
+        for (int j = 0; j < _inputStds.Length; j++)
+            _inputStds[j] = 1.0;
+
+        for (int row = 0; row < n; row++)
+        {
+            var window = Window(_l, c => Convert.ToDouble(x[row, c]), cols);
+            for (int j = 0; j < _l; j++)
+                _inputMeans[j] += window[j];
+        }
+        if (n > 0)
+        {
+            for (int j = 0; j < _l; j++)
+                _inputMeans[j] /= n;
+        }
+
+        var variances = new double[_l];
+        _targetMean = 0.0;
+        int finiteTargets = 0;
+        for (int row = 0; row < n; row++)
+        {
+            var window = Window(_l, c => Convert.ToDouble(x[row, c]), cols);
+            for (int j = 0; j < _l; j++)
+            {
+                double centered = window[j] - _inputMeans[j];
+                variances[j] += centered * centered;
+            }
+            // Non-finite targets are EXCLUDED from the statistics, matching NLinearModel.FitScalers.
+            // Window already clamps non-finite inputs, so _inputMeans and _inputStds were protected;
+            // the target path was not. A single NaN label made _targetMean NaN, and while _targetStd
+            // rescues _targetStd back to 1.0, nothing rescued the mean -- every normalized target,
+            // every error and every gradient then went NaN, training completed without an exception,
+            // and every later prediction collapsed to 0 through the output guard. Silent and total.
+            double target = Convert.ToDouble(y[row]);
+            if (!IsFiniteValue(target)) continue;
+
+            _targetMean += target;
+            finiteTargets++;
+        }
+
+        if (n > 0)
+        {
+            _targetMean = finiteTargets > 0 ? _targetMean / finiteTargets : 0.0;
+            for (int j = 0; j < _l; j++)
+            {
+                double std = Math.Sqrt(variances[j] / n);
+                _inputStds[j] = std > 1e-8 && IsFiniteValue(std) ? std : 1.0;
+            }
+        }
+
+        double targetVariance = 0.0;
+        for (int row = 0; row < n; row++)
+        {
+            double target = Convert.ToDouble(y[row]);
+            if (!IsFiniteValue(target)) continue;
+
+            double centered = target - _targetMean;
+            targetVariance += centered * centered;
+        }
+        double targetStd = finiteTargets > 0 ? Math.Sqrt(targetVariance / finiteTargets) : 1.0;
+        _targetStd = targetStd > 1e-8 && IsFiniteValue(targetStd) ? targetStd : 1.0;
+    }
+
+    protected override void TrainCore(Matrix<T> x, Vector<T> y)
+    {
+        int n = x.Rows;
+        int cols = x.Columns;
+        double lr = _options.LearningRate;
+
+        FitNormalization(x, y);
+
+        for (int epoch = 0; epoch < _options.Epochs; epoch++)
+        {
+            TrainingCancellationToken.ThrowIfCancellationRequested();
+            var order = Enumerable.Range(0, n).OrderBy(_ => _random.Next()).ToList();
+
+            for (int batchStart = 0; batchStart < n; batchStart += _options.BatchSize)
+            {
+                int batchEnd = Math.Min(batchStart + _options.BatchSize, n);
+                int bs = batchEnd - batchStart;
+
+                // Gradient accumulators.
+                var gW1 = new double[_h][];
+                for (int i = 0; i < _h; i++) { gW1[i] = new double[_l]; }
+                var gB1 = new double[_h];
+                var gW2 = new double[_h];
+                double gB2 = 0;
+                var gWr = new double[_l];
+                double gBr = 0;
+
+                for (int bi = batchStart; bi < batchEnd; bi++)
+                {
+                    int idx = order[bi];
+                    var xv = NormalizeWindow(Window(_l, c => Convert.ToDouble(x[idx, c]), cols));
+                    var (hidden, pred) = Forward(xv);
+                    // Filtering the statistics alone does not keep a NaN label out of the gradient:
+                    // this row's error would still be NaN and would poison every weight it touches.
+                    // Skip the row instead.
+                    double rawTarget = Convert.ToDouble(y[idx]);
+                    if (!IsFiniteValue(rawTarget)) continue;
+
+                    double normalizedTarget = (rawTarget - _targetMean) / _targetStd;
+                    double err = pred - normalizedTarget; // dMSE/dpred
+
+                    gB2 += err;
+                    gBr += err;
+                    for (int j = 0; j < _l; j++) { gWr[j] += err * xv[j]; }
+                    for (int i = 0; i < _h; i++)
+                    {
+                        gW2[i] += err * hidden[i];
+                        double dz = hidden[i] > 0 ? err * _w2[i] : 0.0; // ReLU derivative
+                        gB1[i] += dz;
+                        var grow = gW1[i];
+                        for (int j = 0; j < _l; j++) { grow[j] += dz * xv[j]; }
+                    }
+                }
+
+                double inv = bs > 0 ? lr / bs : 0.0;
+                _b2 -= inv * gB2;
+                _br -= inv * gBr;
+                for (int j = 0; j < _l; j++) { _wr[j] -= inv * gWr[j]; }
+                for (int i = 0; i < _h; i++)
+                {
+                    _w2[i] -= inv * gW2[i];
+                    _b1[i] -= inv * gB1[i];
+                    var row = _w1[i];
+                    var grow = gW1[i];
+                    for (int j = 0; j < _l; j++) { row[j] -= inv * grow[j]; }
+                }
+            }
+        }
+
+    }
+
+    public override T PredictSingle(Vector<T> input)
+    {
+        var xv = NormalizeWindow(Window(_l, j => Convert.ToDouble(input[j]), input.Length));
+        var (_, normalizedPrediction) = Forward(xv);
+        double pred = normalizedPrediction * _targetStd + _targetMean;
+        // ToFiniteT, not NumOps.FromDouble(IsFiniteValue(pred) ? pred : 0.0): the pre-conversion
+        // check is the insufficient one its own helper documents. Every double from about 3.4e38 up
+        // is finite yet overflows to Infinity once narrowed to float, so the pre-conversion form
+        // passed such a value straight through to a float model. GuardPrediction then still runs, as
+        // a second line of defence for the recursive-forecast path.
+        return GuardPrediction(ToFiniteT(pred));
+    }
+
+
+
+
+
+    public override ModelMetadata<T> GetModelMetadata()
+    {
+        return new ModelMetadata<T>
+        {
+            Name = "TiDE",
+            Description = "Time-series Dense Encoder — pure-MLP encoder/decoder + linear residual (Das et al. 2023)",
+            Complexity = ParameterCount,
+            FeatureCount = _options.LookbackWindow,
+            AdditionalInfo = new Dictionary<string, object>
+            {
+                { "LookbackWindow", _options.LookbackWindow },
+                { "HiddenSize", _options.HiddenSize },
+                { "ForecastHorizon", _options.ForecastHorizon },
+            },
+        };
+    }
+
+    protected override IFullModel<T, Matrix<T>, Vector<T>> CreateInstance()
+        => new TiDEModel<T>(new TiDEOptions<T>(_options));
+}
diff --git a/src/TimeSeries/TimeSeriesModelBase.cs b/src/TimeSeries/TimeSeriesModelBase.cs
index 653aaa7e9f..6e74a31678 100644
--- a/src/TimeSeries/TimeSeriesModelBase.cs
+++ b/src/TimeSeries/TimeSeriesModelBase.cs
@@ -47,9 +47,52 @@ namespace AiDotNet.TimeSeries;
 /// - Website traffic prediction
 /// </para>
 /// </remarks>
-public abstract class TimeSeriesModelBase<T> : ITimeSeriesModel<T>, IConfigurableModel<T>, IModelShape,
+public abstract partial class TimeSeriesModelBase<T> : ITimeSeriesModel<T>, IConfigurableModel<T>, IModelShape,
     ITrainingEpochReporter<T>, AiDotNet.Models.Parameters.IParameterManifestProvider
 {
+    // --- declared state (ModelStateRegistry) ---
+    // Identical in every model base because these bases are siblings over the same interfaces rather
+    // than one hierarchy; the logic itself lives once in ModelStateRegistry/ModelStateEnvelope.
+
+    /// <summary>State that is not a parameter vector, declared once and persisted by this base.</summary>
+    private readonly AiDotNet.Models.ModelStateRegistry<T> _declaredState = new();
+    private bool _declaredStateRegistered;
+
+    /// <summary>
+    /// Declare state here that the parameter vector does not carry -- a retained training set,
+    /// fitted knots, kernel centres, an ensemble's children. Both halves of the payload are driven
+    /// by the declaration, so they cannot drift.
+    /// </summary>
+    /// <param name="state">The registry to declare into.</param>
+    protected virtual void RegisterState(AiDotNet.Models.ModelStateRegistry<T> state)
+    {
+    }
+    /// <summary>Generated state declarations for fields declared across this model's hierarchy.</summary>
+    /// <param name="state">The registry to declare into.</param>
+    /// <remarks>
+    /// Emitted by ModelStateGenerator into the partial model, so a model author declares nothing. The
+    /// hand-written <c>RegisterState</c> beside it exists only for state the classifier genuinely
+    /// cannot place; anything it CAN place belongs here, where it cannot be forgotten.
+    /// </remarks>
+    protected virtual void RegisterGeneratedState(AiDotNet.Models.ModelStateRegistry<T> state)
+    {
+        RegisterGeneratedStateCore(state);
+    }
+
+    /// <summary>The declared state, registered once and lazily so it runs after the constructor.</summary>
+    protected AiDotNet.Models.ModelStateRegistry<T> DeclaredState
+    {
+        get
+        {
+            if (!_declaredStateRegistered)
+            {
+                _declaredStateRegistered = true;
+                RegisterGeneratedState(_declaredState);
+                RegisterState(_declaredState);
+            }
+            return _declaredState;
+        }
+    }
     /// <summary>
     /// Replaces the loss this model trains against, for the models that can accept one.
     /// </summary>
@@ -1221,7 +1264,7 @@ public virtual byte[] Serialize()
         // Let derived classes serialize their specific data
         SerializeCore(writer);
 
-        return ms.ToArray();
+        return AiDotNet.Models.ModelStateEnvelope.Append(DeclaredState, ms.ToArray());
     }
 
     /// <summary>
@@ -1257,6 +1300,10 @@ public virtual byte[] Serialize()
     /// </remarks>
     public virtual void Deserialize(byte[] data)
     {
+        // Strips and applies any declared-state trailer, so the body below reads the payload
+        // exactly as it did before this existed.
+        byte[] envelopedData = data;
+        data = AiDotNet.Models.ModelStateEnvelope.ExtractBeforeParameters(DeclaredState, data);
         ModelPersistenceGuard.EnforceBeforeDeserialize();
         if (data == null)
         {
@@ -1374,7 +1421,12 @@ public virtual void Deserialize(byte[] data)
                     }
                     else
                     {
-                        _parameterRegistry.SetParameters(parameterSnapshot);
+                        // A modern checkpoint names every slot. Use that identity-preserving path
+                        // even when its aggregate layout already matches construction state: a
+                        // model such as Prophet owns several independently resizable fitted fields,
+                        // which is intentionally ambiguous to the legacy positional API but exact
+                        // in the persisted stable-ID manifest.
+                        _parameterRegistry.SetMatchingParameters(parameterSnapshot, checkpointLayout);
                     }
                 }
             }
@@ -1392,6 +1444,13 @@ public virtual void Deserialize(byte[] data)
                 else
                     _parameterRegistry.SetMatchingParameters(parameterSnapshot, checkpointLayout);
             }
+
+            // The generator marks only trainable CLR storage whose precision can exceed T for this
+            // phase (for example double[] working weights in a float model). Restore those exact
+            // values after the public flat vector so cloning and persistence remain bit-identical
+            // without any per-model serialization override.
+            _ = AiDotNet.Models.ModelStateEnvelope.ExtractAfterParameters(
+                DeclaredState, envelopedData);
         }
         catch (Exception ex)
         {
@@ -1540,7 +1599,30 @@ private static bool LayoutsMatch(
     /// while each model type handles its specialized data.
     /// </para>
     /// </remarks>
-    protected abstract void SerializeCore(BinaryWriter writer);
+    /// <remarks>
+    /// VIRTUAL, NOT ABSTRACT, AND EMPTY BY DEFAULT. Declared state already round-trips without this
+    /// method: <see cref="Serialize"/> ends with
+    /// <c>ModelStateEnvelope.Append(DeclaredState, ...)</c> and <see cref="Deserialize"/> begins with
+    /// <c>ModelStateEnvelope.Extract(DeclaredState, ...)</c>, so every member the model declares --
+    /// by hand in <c>RegisterState</c> or via the generated <c>RegisterGeneratedState</c> -- is
+    /// written and read by the base.
+    /// <para>
+    /// While this pair was ABSTRACT every time series model was FORCED to hand-write both halves,
+    /// which is the population ADN0060 exists to eliminate and could not report: the analyzer
+    /// deliberately exempts an override of an abstract method, because deleting an override the base
+    /// demands is impossible. The models were not choosing to hand-write serialization; the base was
+    /// requiring it. Most of those bodies now duplicate what the envelope already carries, and a
+    /// duplicate is two places to forget the same field.
+    /// </para>
+    /// <para>
+    /// Override this ONLY for state that genuinely cannot be declared. Prefer declaring it: a
+    /// declared member is carried by name, tolerates reordering, and cannot desynchronise a reader
+    /// from a writer.
+    /// </para>
+    /// </remarks>
+    protected virtual void SerializeCore(BinaryWriter writer)
+    {
+    }
 
     /// <summary>
     /// Deserializes model-specific data from the binary reader.
@@ -1564,7 +1646,15 @@ private static bool LayoutsMatch(
     /// while each model type handles its specialized data.
     /// </para>
     /// </remarks>
-    protected abstract void DeserializeCore(BinaryReader reader);
+    /// <remarks>
+    /// Virtual and empty by default, for the reason given on <see cref="SerializeCore"/>: declared
+    /// state is restored by <c>ModelStateEnvelope.Extract(DeclaredState, ...)</c> before this runs,
+    /// so a model that declares its members needs no body here at all. Override only for state that
+    /// cannot be declared, and keep it in exact lockstep with <see cref="SerializeCore"/>.
+    /// </remarks>
+    protected virtual void DeserializeCore(BinaryReader reader)
+    {
+    }
 
     /// <summary>
     /// Gets metadata about the time series model.
diff --git a/src/TimeSeries/TransferFunctionModel.cs b/src/TimeSeries/TransferFunctionModel.cs
index 8ea2938f27..c6c37313a4 100644
--- a/src/TimeSeries/TransferFunctionModel.cs
+++ b/src/TimeSeries/TransferFunctionModel.cs
@@ -57,21 +57,25 @@ public partial class TransferFunctionModel<T> : TimeSeriesModelBase<T>
     /// <summary>
     /// Autoregressive (AR) parameters that capture the dependency on past values of the output series.
     /// </summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T> _arParameters;
 
     /// <summary>
     /// Moving Average (MA) parameters that capture the dependency on past error terms.
     /// </summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T> _maParameters;
 
     /// <summary>
     /// Parameters that capture the effect of input variables at different lags.
     /// </summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T> _inputLags;
 
     /// <summary>
     /// Parameters that capture the effect of output variables at different lags.
     /// </summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T> _outputLags;
 
     /// <summary>
@@ -494,28 +498,7 @@ public override Dictionary<string, T> EvaluateModel(Matrix<T> xTest, Vector<T> y
     /// without repeating the training process, which can save significant time for complex models.
     /// </para>
     /// </remarks>
-    protected override void SerializeCore(BinaryWriter writer)
-    {
-        // Write model parameters
-        SerializationHelper<T>.SerializeVector(writer, _arParameters);
-        SerializationHelper<T>.SerializeVector(writer, _maParameters);
-        SerializationHelper<T>.SerializeVector(writer, _inputLags);
-        SerializationHelper<T>.SerializeVector(writer, _outputLags);
-
-        // Write options
-        writer.Write(_tfOptions.AROrder);
-        writer.Write(_tfOptions.MAOrder);
-        writer.Write(_tfOptions.InputLagOrder);
-        writer.Write(_tfOptions.OutputLagOrder);
-
-        // Write training series for in-sample predictions
-        if (_y is not null)
-            SerializationHelper<T>.SerializeVector(writer, _y);
-        else
-            writer.Write(0);
-
-        SerializationHelper<T>.SerializeVector(writer, _residuals);
-    }
+
 
     /// <summary>
     /// Deserializes the model's core parameters from a binary reader.
@@ -542,32 +525,7 @@ protected override void SerializeCore(BinaryWriter writer)
     /// - Saving computation time by not having to retrain complex models
     /// </para>
     /// </remarks>
-    protected override void DeserializeCore(BinaryReader reader)
-    {
-        // Read model parameters
-        _arParameters = SerializationHelper<T>.DeserializeVector(reader);
-        _maParameters = SerializationHelper<T>.DeserializeVector(reader);
-        _inputLags = SerializationHelper<T>.DeserializeVector(reader);
-        _outputLags = SerializationHelper<T>.DeserializeVector(reader);
-
-        // Read options
-        _tfOptions.AROrder = reader.ReadInt32();
-        _tfOptions.MAOrder = reader.ReadInt32();
-        _tfOptions.InputLagOrder = reader.ReadInt32();
-        _tfOptions.OutputLagOrder = reader.ReadInt32();
-
-        // Read training series (post-patch field)
-        try
-        {
-            _y = SerializationHelper<T>.DeserializeVector(reader);
-            _residuals = SerializationHelper<T>.DeserializeVector(reader);
-        }
-        catch (EndOfStreamException)
-        {
-            // Older models don't include training series
-            _residuals = Vector<T>.Empty();
-        }
-    }
+
 
     /// <summary>
     /// The core implementation of the training process for the Transfer Function Model.
diff --git a/src/TimeSeries/UnobservedComponentsModel.cs b/src/TimeSeries/UnobservedComponentsModel.cs
index 23d56b6320..2a0bdc7a1b 100644
--- a/src/TimeSeries/UnobservedComponentsModel.cs
+++ b/src/TimeSeries/UnobservedComponentsModel.cs
@@ -178,6 +178,7 @@ public partial class UnobservedComponentsModel<T, TInput, TOutput> : TimeSeriesM
     /// rules that tell the model how each component should normally behave over time
     /// if no new information is observed.
     /// </remarks>
+    [AiDotNet.Attributes.TrainableParameter]
     private Matrix<T> _stateTransition;
 
     /// <summary>
@@ -203,6 +204,7 @@ public partial class UnobservedComponentsModel<T, TInput, TOutput> : TimeSeriesM
     /// the components, making it more responsive to new data but potentially
     /// less smooth.
     /// </remarks>
+    [AiDotNet.Attributes.TrainableParameter]
     private Matrix<T> _processNoise;
 
     /// <summary>
@@ -1116,36 +1118,7 @@ public override Dictionary<string, T> EvaluateModel(Matrix<T> xTest, Vector<T> y
     /// 
     /// This allows the model to be fully reconstructed later.
     /// </remarks>
-    protected override void SerializeCore(BinaryWriter writer)
-    {
-        // Write model parameters
-        writer.Write(_trend.Length);
-        for (int i = 0; i < _trend.Length; i++)
-        {
-            writer.Write(Convert.ToDouble(_trend[i]));
-        }
 
-        writer.Write(_seasonal.Length);
-        for (int i = 0; i < _seasonal.Length; i++)
-        {
-            writer.Write(Convert.ToDouble(_seasonal[i]));
-        }
-
-        writer.Write(_cycle.Length);
-        for (int i = 0; i < _cycle.Length; i++)
-        {
-            writer.Write(Convert.ToDouble(_cycle[i]));
-        }
-
-        writer.Write(_irregular.Length);
-        for (int i = 0; i < _irregular.Length; i++)
-        {
-            writer.Write(Convert.ToDouble(_irregular[i]));
-        }
-
-        // Write options
-        writer.Write(_ucOptions.MaxIterations);
-    }
 
     /// <summary>
     /// Deserializes the model's state from a binary stream.
@@ -1169,40 +1142,7 @@ protected override void SerializeCore(BinaryWriter writer)
     /// 
     /// After deserialization, the model is ready to make predictions as if it had just been trained.
     /// </remarks>
-    protected override void DeserializeCore(BinaryReader reader)
-    {
-        // Read model parameters
-        int trendLength = reader.ReadInt32();
-        _trend = new Vector<T>(trendLength);
-        for (int i = 0; i < trendLength; i++)
-        {
-            _trend[i] = NumOps.FromDouble(reader.ReadDouble());
-        }
 
-        int seasonalLength = reader.ReadInt32();
-        _seasonal = new Vector<T>(seasonalLength);
-        for (int i = 0; i < seasonalLength; i++)
-        {
-            _seasonal[i] = NumOps.FromDouble(reader.ReadDouble());
-        }
-
-        int cycleLength = reader.ReadInt32();
-        _cycle = new Vector<T>(cycleLength);
-        for (int i = 0; i < cycleLength; i++)
-        {
-            _cycle[i] = NumOps.FromDouble(reader.ReadDouble());
-        }
-
-        int irregularLength = reader.ReadInt32();
-        _irregular = new Vector<T>(irregularLength);
-        for (int i = 0; i < irregularLength; i++)
-        {
-            _irregular[i] = NumOps.FromDouble(reader.ReadDouble());
-        }
-
-        // Read options
-        _ucOptions.MaxIterations = reader.ReadInt32();
-    }
 
     /// <summary>
     /// Implements the model-specific training logic for the Unobserved Components Model.
diff --git a/src/TimeSeries/VARMAModel.cs b/src/TimeSeries/VARMAModel.cs
index 9c31b58d05..bc94eab2fe 100644
--- a/src/TimeSeries/VARMAModel.cs
+++ b/src/TimeSeries/VARMAModel.cs
@@ -480,31 +480,7 @@ private Vector<T> SolveOLS(Matrix<T> x, Vector<T> y)
     /// - Saving computation time by not having to retrain complex models
     /// </para>
     /// </remarks>
-    protected override void SerializeCore(BinaryWriter writer)
-    {
-        base.SerializeCore(writer);
-
-        // Serialize VARMAModelOptions
-        writer.Write(_varmaOptions.MaLag);
 
-        // VECTORIZED: Serialize _maCoefficients using row operations
-        writer.Write(_maCoefficients.Rows);
-        writer.Write(_maCoefficients.Columns);
-        for (int i = 0; i < _maCoefficients.Rows; i++)
-        {
-            Vector<T> row = _maCoefficients.GetRow(i);
-            foreach (var val in row)
-            {
-                writer.Write(Convert.ToDouble(val));
-            }
-        }
-
-        writer.Write(_residuals.Rows);
-        writer.Write(_residuals.Columns);
-        for (int i = 0; i < _residuals.Rows; i++)
-            for (int j = 0; j < _residuals.Columns; j++)
-                writer.Write(Convert.ToDouble(_residuals[i, j]));
-    }
 
     /// <summary>
     /// Deserializes the model's core parameters from a binary reader.
@@ -531,43 +507,5 @@ protected override void SerializeCore(BinaryWriter writer)
     /// - You're deploying a model to a production environment where training isn't feasible
     /// </para>
     /// </remarks>
-    protected override void DeserializeCore(BinaryReader reader)
-    {
-        base.DeserializeCore(reader);
 
-        // Deserialize VARMAModelOptions
-        _varmaOptions.MaLag = reader.ReadInt32();
-
-        // VECTORIZED: Deserialize _maCoefficients using row operations
-        int maCoeffRows = reader.ReadInt32();
-        int maCoeffCols = reader.ReadInt32();
-        _maCoefficients = new Matrix<T>(maCoeffRows, maCoeffCols);
-        for (int i = 0; i < maCoeffRows; i++)
-        {
-            T[] rowData = new T[maCoeffCols];
-            for (int j = 0; j < maCoeffCols; j++)
-            {
-                rowData[j] = NumOps.FromDouble(reader.ReadDouble());
-            }
-            _maCoefficients.SetRow(i, new Vector<T>(rowData));
-        }
-
-
-        // The MA correction reads recent innovations. They are learned state, not a transient
-        // training cache, so persist them alongside the coefficient matrix. Older payloads end
-        // after the coefficient matrix; retain compatibility with those checkpoints.
-        try
-        {
-            int residualRows = reader.ReadInt32();
-            int residualColumns = reader.ReadInt32();
-            _residuals = new Matrix<T>(residualRows, residualColumns);
-            for (int i = 0; i < residualRows; i++)
-                for (int j = 0; j < residualColumns; j++)
-                    _residuals[i, j] = NumOps.FromDouble(reader.ReadDouble());
-        }
-        catch (EndOfStreamException)
-        {
-            _residuals = Matrix<T>.Empty();
-        }
-    }
 }
diff --git a/src/TimeSeries/VectorAutoRegressionModel.cs b/src/TimeSeries/VectorAutoRegressionModel.cs
index 2f93796ae7..48d6a63979 100644
--- a/src/TimeSeries/VectorAutoRegressionModel.cs
+++ b/src/TimeSeries/VectorAutoRegressionModel.cs
@@ -302,36 +302,7 @@ public override Dictionary<string, T> EvaluateModel(Matrix<T> xTest, Vector<T> y
     /// without repeating the training process.
     /// </para>
     /// </remarks>
-    protected override void SerializeCore(BinaryWriter writer)
-    {
-        // Serialize VARModelOptions
-        writer.Write(_varOptions.Lag);
-        writer.Write(_varOptions.OutputDimension);
-
-        // Serialize _coefficients
-        writer.Write(_coefficients.Rows);
-        writer.Write(_coefficients.Columns);
-        for (int i = 0; i < _coefficients.Rows; i++)
-            for (int j = 0; j < _coefficients.Columns; j++)
-                writer.Write(Convert.ToDouble(_coefficients[i, j]));
-
-        // Serialize _intercepts
-        writer.Write(_intercepts.Length);
-        for (int i = 0; i < _intercepts.Length; i++)
-            writer.Write(Convert.ToDouble(_intercepts[i]));
-
-        // Serialize _residuals
-        writer.Write(_residuals.Rows);
-        writer.Write(_residuals.Columns);
-        for (int i = 0; i < _residuals.Rows; i++)
-            for (int j = 0; j < _residuals.Columns; j++)
-                writer.Write(Convert.ToDouble(_residuals[i, j]));
-
-        // Serialize training series for in-sample predictions
-        writer.Write(_trainingSeries.Length);
-        for (int i = 0; i < _trainingSeries.Length; i++)
-            writer.Write(Convert.ToDouble(_trainingSeries[i]));
-    }
+
 
     /// <summary>
     /// Deserializes the model's core parameters from a binary reader.
@@ -360,47 +331,7 @@ protected override void SerializeCore(BinaryWriter writer)
     /// - Saving computation time by not having to retrain complex models
     /// </para>
     /// </remarks>
-    protected override void DeserializeCore(BinaryReader reader)
-    {
-        // Deserialize VARModelOptions
-        _varOptions.Lag = reader.ReadInt32();
-        _varOptions.OutputDimension = reader.ReadInt32();
-
-        // Deserialize _coefficients
-        int coeffRows = reader.ReadInt32();
-        int coeffCols = reader.ReadInt32();
-        _coefficients = new Matrix<T>(coeffRows, coeffCols);
-        for (int i = 0; i < coeffRows; i++)
-            for (int j = 0; j < coeffCols; j++)
-                _coefficients[i, j] = NumOps.FromDouble(reader.ReadDouble());
-
-        // Deserialize _intercepts
-        int interceptsLength = reader.ReadInt32();
-        _intercepts = new Vector<T>(interceptsLength);
-        for (int i = 0; i < interceptsLength; i++)
-            _intercepts[i] = NumOps.FromDouble(reader.ReadDouble());
-
-        // Deserialize _residuals
-        int residualsRows = reader.ReadInt32();
-        int residualsCols = reader.ReadInt32();
-        _residuals = new Matrix<T>(residualsRows, residualsCols);
-        for (int i = 0; i < residualsRows; i++)
-            for (int j = 0; j < residualsCols; j++)
-                _residuals[i, j] = NumOps.FromDouble(reader.ReadDouble());
-
-        // Deserialize training series (post-patch field)
-        try
-        {
-            int tsLen = reader.ReadInt32();
-            _trainingSeries = new Vector<T>(tsLen);
-            for (int i = 0; i < tsLen; i++)
-                _trainingSeries[i] = NumOps.FromDouble(reader.ReadDouble());
-        }
-        catch (EndOfStreamException)
-        {
-            _trainingSeries = Vector<T>.Empty();
-        }
-    }
+
 
     /// <summary>
     /// Prepares a matrix of lagged data for VAR model estimation.
diff --git a/src/Training/CompiledTapeTrainingStep.cs b/src/Training/CompiledTapeTrainingStep.cs
index 9a41278861..d32b51856a 100644
--- a/src/Training/CompiledTapeTrainingStep.cs
+++ b/src/Training/CompiledTapeTrainingStep.cs
@@ -1091,7 +1091,9 @@ private static Tensor<T>[] CollectDeduplicatedParametersWithExtras(
     // containing #557, the IsAvailable probe returns false and the FP16 path is skipped at runtime.
     private static object? _mpPlan;
     private static int[]? _mpKey;
+    [AiDotNet.Attributes.Scratch]
     private static Tensor<float>? _mpInput;
+    [AiDotNet.Attributes.Scratch]
     private static Tensor<float>? _mpTarget;
     // Fused-Adam mixed-precision plan (traces against the fused path's persistent input/target).
     private static object? _mpAdamPlan;
diff --git a/src/Training/TapeTrainingStep.cs b/src/Training/TapeTrainingStep.cs
index 5363e45d02..6602fc8189 100644
--- a/src/Training/TapeTrainingStep.cs
+++ b/src/Training/TapeTrainingStep.cs
@@ -1,5 +1,6 @@
 using AiDotNet.Helpers;
 using AiDotNet.Interfaces;
+using AiDotNet.Attributes;
 using AiDotNet.Tensors.Engines;
 using AiDotNet.Tensors.Engines.Autodiff;
 using AiDotNet.Tensors.LinearAlgebra;
@@ -42,6 +43,7 @@ public static class TapeTrainingStep<T>
     // recursive walk happens on miss). One-time cost: ~O(layers); collision
     // probability over a 64-bit FNV is negligible for any realistic graph.
     [ThreadStatic]
+    [Scratch]
     private static List<Tensor<T>>? _cachedParameters;
     [ThreadStatic]
     private static int _cachedVersion;
diff --git a/src/TransferLearning/Algorithms/TransferRandomForest.cs b/src/TransferLearning/Algorithms/TransferRandomForest.cs
index d55e55eae5..e578a5aa83 100644
--- a/src/TransferLearning/Algorithms/TransferRandomForest.cs
+++ b/src/TransferLearning/Algorithms/TransferRandomForest.cs
@@ -386,31 +386,6 @@ public override bool IsFeatureUsed(int featureIndex)
         return base.IsFeatureUsed(featureIndex);
     }
 
-    /// <inheritdoc/>
-    public override byte[] Serialize()
-    {
-        ModelPersistenceGuard.EnforceBeforeSerialize();
-        using var ms = new MemoryStream();
-        using var writer = new BinaryWriter(ms);
-        var baseBytes = BaseModel.Serialize();
-        WriteWrapper(writer, baseBytes);
-        return ms.ToArray();
-    }
-
-    /// <inheritdoc/>
-    public override void Deserialize(byte[] data)
-    {
-        ModelPersistenceGuard.EnforceBeforeDeserialize();
-        using var ms = new MemoryStream(data);
-        using var reader = new BinaryReader(ms);
-        if (TryReadWrapper(reader, out var baseBytes))
-        {
-            BaseModel.Deserialize(baseBytes);
-            return;
-        }
-        BaseModel.Deserialize(data);
-    }
-
     /// <inheritdoc/>
     public override IFullModel<T, Matrix<T>, Vector<T>> WithParameters(Vector<T> parameters)
     {
@@ -421,15 +396,6 @@ public override IFullModel<T, Matrix<T>, Vector<T>> WithParameters(Vector<T> par
             "Random forest models learn structure during training and cannot be re-parameterized.");
     }
 
-    /// <inheritdoc/>
-    public override IFullModel<T, Matrix<T>, Vector<T>> DeepCopy()
-    {
-        return new MappedRandomForestModel<T>(
-            BaseModel.DeepCopy(),
-            _mapper,
-            _targetFeatures);
-    }
-
     /// <inheritdoc/>
     public override void SaveModel(string filePath)
     {
diff --git a/src/TransferLearning/DomainAdaptation/CORALDomainAdapter.cs b/src/TransferLearning/DomainAdaptation/CORALDomainAdapter.cs
index 08685e7511..de628663a0 100644
--- a/src/TransferLearning/DomainAdaptation/CORALDomainAdapter.cs
+++ b/src/TransferLearning/DomainAdaptation/CORALDomainAdapter.cs
@@ -24,6 +24,7 @@ namespace AiDotNet.TransferLearning.DomainAdaptation;
 public class CORALDomainAdapter<T> : IDomainAdapter<T>
 {
     private readonly INumericOperations<T> _numOps;
+    [AiDotNet.Attributes.FittedParameter]
     private Matrix<T>? _transformationMatrix;
 
     /// <summary>
diff --git a/src/TransferLearning/FeatureMapping/LinearFeatureMapper.cs b/src/TransferLearning/FeatureMapping/LinearFeatureMapper.cs
index 0431391732..a9f8dfac8c 100644
--- a/src/TransferLearning/FeatureMapping/LinearFeatureMapper.cs
+++ b/src/TransferLearning/FeatureMapping/LinearFeatureMapper.cs
@@ -27,7 +27,9 @@ public class LinearFeatureMapper<T> : IFeatureMapper<T>
 {
     private readonly INumericOperations<T> _numOps;
     protected static IEngine Engine => AiDotNetEngine.Current;
+    [AiDotNet.Attributes.FittedParameter]
     private Matrix<T>? _projectionMatrix;
+    [AiDotNet.Attributes.FittedParameter]
     private Matrix<T>? _reverseProjectionMatrix;
     private T _confidence;
 
diff --git a/src/UncertaintyQuantification/ConformalPrediction/ConformalClassifier.cs b/src/UncertaintyQuantification/ConformalPrediction/ConformalClassifier.cs
index a08a5514f2..9cdbf9b6bb 100644
--- a/src/UncertaintyQuantification/ConformalPrediction/ConformalClassifier.cs
+++ b/src/UncertaintyQuantification/ConformalPrediction/ConformalClassifier.cs
@@ -32,6 +32,7 @@ public class ConformalClassifier<T>
 {
     private readonly INumericOperations<T> _numOps;
     private readonly INeuralNetwork<T> _model;
+    [AiDotNet.Attributes.FittedParameter]
     private Vector<T>? _calibrationScores;
     private readonly int _numClasses;
     private bool _isCalibrated;
diff --git a/src/UncertaintyQuantification/ConformalPrediction/SplitConformalPredictor.cs b/src/UncertaintyQuantification/ConformalPrediction/SplitConformalPredictor.cs
index 4a8f241876..d035a0e397 100644
--- a/src/UncertaintyQuantification/ConformalPrediction/SplitConformalPredictor.cs
+++ b/src/UncertaintyQuantification/ConformalPrediction/SplitConformalPredictor.cs
@@ -39,6 +39,7 @@ public class SplitConformalPredictor<T>
 {
     private readonly INumericOperations<T> _numOps;
     private readonly IModel<Tensor<T>, Tensor<T>, ModelMetadata<T>> _model;
+    [AiDotNet.Attributes.FittedParameter]
     private Vector<T>? _calibrationScores;
     private bool _isCalibrated;
 
diff --git a/src/UncertaintyQuantification/Layers/BayesianDenseLayer.cs b/src/UncertaintyQuantification/Layers/BayesianDenseLayer.cs
index 01ad3e07ca..9412b52462 100644
--- a/src/UncertaintyQuantification/Layers/BayesianDenseLayer.cs
+++ b/src/UncertaintyQuantification/Layers/BayesianDenseLayer.cs
@@ -106,16 +106,23 @@ public partial class BayesianDenseLayer<T> : LayerBase<T>, IBayesianLayer<T>, IS
     // same instances exposed by GetTrainableParameters. Fields are mutable
     // because the contiguous ParameterBuffer rebinds them to buffer-backed
     // views through SetTrainableParameters.
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _weightMean = Tensor<T>.Empty();
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _weightLogVar = Tensor<T>.Empty();
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _biasMean = Tensor<T>.Empty();
+    [AiDotNet.Attributes.TrainableParameter]
     private Tensor<T> _biasLogVar = Tensor<T>.Empty();
 
     // SampleWeights stores epsilon, rather than a detached sampled parameter.
     // Forward applies the reparameterization with Engine operations so both μ
     // and log σ² remain connected to the active gradient tape.
+    [Scratch]
     private Tensor<T>? _sampledWeightEpsilon;
+    [Scratch]
     private Tensor<T>? _sampledBiasEpsilon;
+    [Scratch]
     private bool _samplePending;
 
     /// <summary>
@@ -206,27 +213,8 @@ private void InitializeParameters()
     }
 
     /// <inheritdoc/>
-    public override IReadOnlyList<Tensor<T>> GetTrainableParameters() =>
-        new[] { _weightMean, _weightLogVar, _biasMean, _biasLogVar };
 
     /// <inheritdoc/>
-    public override void SetTrainableParameters(IReadOnlyList<Tensor<T>> parameters)
-    {
-        if (parameters.Count != 4)
-            throw new ArgumentException(
-                "Expected exactly 4 posterior tensors (weight mean, weight log variance, bias mean, bias log variance).",
-                nameof(parameters));
-
-        ValidateShapeMatch(parameters[0], _weightMean, nameof(_weightMean));
-        ValidateShapeMatch(parameters[1], _weightLogVar, nameof(_weightLogVar));
-        ValidateShapeMatch(parameters[2], _biasMean, nameof(_biasMean));
-        ValidateShapeMatch(parameters[3], _biasLogVar, nameof(_biasLogVar));
-
-        _weightMean = parameters[0];
-        _weightLogVar = parameters[1];
-        _biasMean = parameters[2];
-        _biasLogVar = parameters[3];
-    }
 
     private static void ValidateShapeMatch(Tensor<T> incoming, Tensor<T> existing, string parameterName)
     {
diff --git a/src/UncertaintyQuantification/Layers/MCDropoutLayer.cs b/src/UncertaintyQuantification/Layers/MCDropoutLayer.cs
index 7e6f9e9749..cb9a596526 100644
--- a/src/UncertaintyQuantification/Layers/MCDropoutLayer.cs
+++ b/src/UncertaintyQuantification/Layers/MCDropoutLayer.cs
@@ -38,6 +38,7 @@ public partial class MCDropoutLayer<T> : LayerBase<T>, IShapeContract
     private readonly T _scale;
     private readonly int? _initialSeed;
     private readonly ThreadLocal<Random> _rng;
+    [Scratch]
     private readonly ThreadLocal<Tensor<T>?> _lastInput = new(() => null);
     private readonly ThreadLocal<Vector<T>?> _dropoutMask = new(() => null);
     private bool _mcMode; // Monte Carlo mode - always apply dropout
@@ -137,12 +138,4 @@ public override void ResetState()
         _lastInput.Value = null;
         _dropoutMask.Value = null;
     }
-
-    /// <inheritdoc/>
-    public override LayerBase<T> Clone()
-    {
-        var copy = new MCDropoutLayer<T>(_dropoutRate, _mcMode, _initialSeed);
-        copy.SetTrainingMode(IsTrainingMode);
-        return copy;
-    }
 }
diff --git a/src/Video/ActionRecognition/SlowFast.cs b/src/Video/ActionRecognition/SlowFast.cs
index 91a752e2cb..ffac2fe895 100644
--- a/src/Video/ActionRecognition/SlowFast.cs
+++ b/src/Video/ActionRecognition/SlowFast.cs
@@ -697,42 +697,7 @@ protected override void InitializeLayers()
     /// are NOT serialized - after deserialization, default LayerHelper layers are used
     /// unless custom layers are re-provided.
     /// </remarks>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        if (!_useNativeMode) throw new InvalidOperationException("Serialization is not supported in ONNX mode.");
-
-        // Configuration parameters
-        writer.Write(_numClasses);
-        writer.Write(_slowFrames);
-        writer.Write(_fastFrames);
-        writer.Write(_slowChannels);
-        writer.Write(_fastChannels);
-        writer.Write(_alpha);
-        writer.Write(_imageSize);
-
-        // Per-pathway range markers needed by deserialize to reconstruct
-        // the _fastLayers / _fusionLayers mirror views into the unified
-        // Layers list. Without these, the deserialize side cannot tell where
-        // the slow pathway ends and the fast pathway begins from the flat
-        // [slow... | fast... | fusion...] layout.
-        writer.Write(_slowLayerCount);
-        writer.Write(_fastLayerCount);
-        writer.Write(_fusionLayerCount);
-
-        // Training component type names for restoration
-        writer.Write(_lossFunction.GetType().AssemblyQualifiedName ?? throw new InvalidOperationException(
-            $"Cannot resolve AssemblyQualifiedName for loss function type '{_lossFunction.GetType().FullName}'."));
-        writer.Write(_probabilityActivation.GetType().AssemblyQualifiedName ?? throw new InvalidOperationException(
-            $"Cannot resolve AssemblyQualifiedName for activation function type '{_probabilityActivation.GetType().FullName}'."));
-
-        // Optimizer type (can be null for ONNX mode or after certain operations)
-        writer.Write(_optimizer is not null);
-        if (_optimizer is { } optimizer)
-        {
-            writer.Write(optimizer.GetType().AssemblyQualifiedName ?? throw new InvalidOperationException(
-                $"Cannot resolve AssemblyQualifiedName for optimizer type '{optimizer.GetType().FullName}'."));
-        }
-    }
+
 
     /// <summary>
     /// Deserializes SlowFast-specific configuration data and reinitializes layers.
@@ -741,114 +706,7 @@ protected override void SerializeNetworkSpecificData(BinaryWriter writer)
     /// Restores configuration parameters and recreates training components from serialized type names.
     /// Custom layer definitions are NOT restored - default LayerHelper layers are used after deserialization.
     /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        if (!_useNativeMode) throw new InvalidOperationException("Deserialization is not supported in ONNX mode.");
-
-        // Restore configuration values
-        _numClasses = reader.ReadInt32();
-        _slowFrames = reader.ReadInt32();
-        _fastFrames = reader.ReadInt32();
-        _slowChannels = reader.ReadInt32();
-        _fastChannels = reader.ReadInt32();
-        _alpha = reader.ReadInt32();
-        _imageSize = reader.ReadInt32();
-
-        // Per-pathway range markers — must match what the serialize side wrote
-        // so the _fastLayers / _fusionLayers mirror views can be rebuilt as
-        // slices of the unified Layers list below.
-        _slowLayerCount = reader.ReadInt32();
-        _fastLayerCount = reader.ReadInt32();
-        _fusionLayerCount = reader.ReadInt32();
-
-        // Restore training component types
-        string lossFunctionTypeName = reader.ReadString();
-        string probabilityActivationTypeName = reader.ReadString();
-
-        // Recreate loss function from type name
-        var lossFunctionType = Type.GetType(lossFunctionTypeName);
-        if (lossFunctionType != null)
-        {
-            _lossFunction = (ILossFunction<T>?)Activator.CreateInstance(lossFunctionType) ?? new CrossEntropyWithLogitsLoss<T>();
-        }
-        else
-        {
-            System.Diagnostics.Debug.WriteLine(
-                $"Warning: Serialized loss function type '{lossFunctionTypeName}' could not be resolved. Falling back to CrossEntropyWithLogitsLoss.");
-            _lossFunction = new CrossEntropyWithLogitsLoss<T>();
-        }
-
-        // Recreate probability activation from type name
-        var activationType = Type.GetType(probabilityActivationTypeName);
-        if (activationType != null)
-        {
-            _probabilityActivation = (IActivationFunction<T>?)Activator.CreateInstance(activationType) ?? new SoftmaxActivation<T>();
-        }
-        else
-        {
-            System.Diagnostics.Debug.WriteLine(
-                $"Warning: Serialized activation type '{probabilityActivationTypeName}' could not be resolved. Falling back to SoftmaxActivation.");
-            _probabilityActivation = new SoftmaxActivation<T>();
-        }
-
-        // Restore optimizer if it was serialized
-        bool hasOptimizer = reader.ReadBoolean();
-        if (hasOptimizer)
-        {
-            string optimizerTypeName = reader.ReadString();
-            var optimizerType = Type.GetType(optimizerTypeName);
-
-            if (optimizerType != null)
-            {
-                var constructor = optimizerType.GetConstructor([typeof(IFullModel<T, Tensor<T>, Tensor<T>>)]);
-                if (constructor != null)
-                {
-                    _optimizer = (IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>?)constructor.Invoke([this]);
-                }
-                else
-                {
-                    System.Diagnostics.Debug.WriteLine(
-                        $"Warning: Serialized optimizer type '{optimizerTypeName}' does not have expected constructor. Falling back to Adam.");
-                    _optimizer = new AdamOptimizer<T, Tensor<T>, Tensor<T>>(this);
-                }
-            }
-            else
-            {
-                System.Diagnostics.Debug.WriteLine(
-                    $"Warning: Serialized optimizer type '{optimizerTypeName}' could not be resolved. Falling back to Adam.");
-                _optimizer = new AdamOptimizer<T, Tensor<T>, Tensor<T>>(this);
-            }
-        }
-        else
-        {
-            _optimizer = new AdamOptimizer<T, Tensor<T>, Tensor<T>>(this);
-        }
-        SetBaseTrainOptimizer(_optimizer);
-
-        // Clear custom layer references (not serialized)
-        _customFastLayers = null;
-        _customFusionLayers = null;
-
-        // Rebuild the per-pathway mirror lists as slices of the freshly-
-        // deserialized Layers. Do NOT call InitializeLayers — base
-        // DeserializeInternalUnchecked already populated Layers with the
-        // saved [slow... | fast... | fusion...] flat layout (with TRAINED
-        // weights). Re-running InitializeLayers would Clear + rebuild with
-        // random-init weights, dropping all the trained state on the floor
-        // (issue #1221 class — exactly what Clone_AfterTraining_*
-        // is designed to catch).
-        _fastLayers.Clear();
-        _fusionLayers.Clear();
-        int slowEnd = _slowLayerCount;
-        int fastEnd = slowEnd + _fastLayerCount;
-        for (int i = slowEnd; i < fastEnd && i < Layers.Count; i++)
-            _fastLayers.Add(Layers[i]);
-        for (int i = fastEnd; i < Layers.Count; i++)
-            _fusionLayers.Add(Layers[i]);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() =>
-        new SlowFast<T>(Architecture, _numClasses, _optimizer, _lossFunction, _probabilityActivation, _customFastLayers, _customFusionLayers, _slowFrames, _slowChannels, _fastChannels, _alpha);
 
     #endregion
 
diff --git a/src/Video/ActionRecognition/TimeSformer.cs b/src/Video/ActionRecognition/TimeSformer.cs
index f8089930a6..11bf9527f0 100644
--- a/src/Video/ActionRecognition/TimeSformer.cs
+++ b/src/Video/ActionRecognition/TimeSformer.cs
@@ -1,4 +1,4 @@
-using System.IO;
+using System.IO;
 using AiDotNet.Attributes;
 using AiDotNet.Enums;
 using AiDotNet.Helpers;
@@ -78,7 +78,7 @@ namespace AiDotNet.Video.ActionRecognition;
     Direction = TensorLayoutDirection.Input, BatchOptional = true)]
 [TensorLayout(TensorAxis.Batch, TensorAxis.Classes,
     Direction = TensorLayoutDirection.Output, BatchOptional = true)]
-public class TimeSformer<T> : NeuralNetworkBase<T>
+public partial class TimeSformer<T> : NeuralNetworkBase<T>
 {
     private readonly TimeSformerOptions _options;
 
@@ -644,53 +644,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        if (!_useNativeMode)
-            throw new InvalidOperationException("Serialization is not supported in ONNX mode.");
-
-        writer.Write(_embedDim);
-        writer.Write(_numHeads);
-        writer.Write(_numLayers);
-        writer.Write(_numFrames);
-        writer.Write(_patchSize);
-        writer.Write(_imageSize);
-        writer.Write(_numClasses);
-        writer.Write((int)_attentionType);
-    }
 
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        if (!_useNativeMode)
-            throw new InvalidOperationException("Deserialization is not supported in ONNX mode.");
-
-        _ = reader.ReadInt32(); // embedDim
-        _ = reader.ReadInt32(); // numHeads
-        _ = reader.ReadInt32(); // numLayers
-        _ = reader.ReadInt32(); // numFrames
-        _ = reader.ReadInt32(); // patchSize
-        _ = reader.ReadInt32(); // imageSize
-        _ = reader.ReadInt32(); // numClasses
-        _ = reader.ReadInt32(); // attentionType
-    }
 
     /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new TimeSformer<T>(
-            Architecture,
-            numClasses: _numClasses,
-            optimizer: null,
-            lossFunction: _lossFunction,
-            embedDim: _embedDim,
-            numHeads: _numHeads,
-            numLayers: _numLayers,
-            numFrames: _numFrames,
-            patchSize: _patchSize,
-            attentionType: _attentionType,
-            options: _options);
-    }
+
 
     #endregion
 }
diff --git a/src/Video/ActionRecognition/VideoMAE.cs b/src/Video/ActionRecognition/VideoMAE.cs
index a93947d0b2..b230100453 100644
--- a/src/Video/ActionRecognition/VideoMAE.cs
+++ b/src/Video/ActionRecognition/VideoMAE.cs
@@ -71,7 +71,7 @@ namespace AiDotNet.Video.ActionRecognition;
     Direction = TensorLayoutDirection.Input, BatchOptional = true)]
 [TensorLayout(TensorAxis.Batch, TensorAxis.Classes,
     Direction = TensorLayoutDirection.Output, BatchOptional = true)]
-public class VideoMAE<T> : NeuralNetworkBase<T>
+public partial class VideoMAE<T> : NeuralNetworkBase<T>
 {
     private readonly VideoMAEOptions _options;
 
@@ -919,60 +919,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_height);
-        writer.Write(_width);
-        writer.Write(_channels);
-        writer.Write(_numFrames);
-        writer.Write(_numClasses);
-        writer.Write(_numFeatures);
-        writer.Write(_maskRatio);
-        writer.Write(_useNativeMode);
-        writer.Write(_onnxModelPath ?? string.Empty);
-    }
 
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _height = reader.ReadInt32();
-        _width = reader.ReadInt32();
-        _channels = reader.ReadInt32();
-        _numFrames = reader.ReadInt32();
-        _numClasses = reader.ReadInt32();
-        _numFeatures = reader.ReadInt32();
-        _maskRatio = reader.ReadDouble();
-        _useNativeMode = reader.ReadBoolean();
-        _onnxModelPath = reader.ReadString();
-        if (string.IsNullOrEmpty(_onnxModelPath)) _onnxModelPath = null;
-
-        // Recreate ONNX session if in ONNX mode
-        if (!_useNativeMode && !string.IsNullOrEmpty(_onnxModelPath))
-        {
-            if (File.Exists(_onnxModelPath))
-            {
-                try { _onnxSession = new InferenceSession(_onnxModelPath); }
-                catch (Exception ex) { throw new InvalidOperationException($"Failed to restore ONNX session: {ex.Message}", ex); }
-            }
-            else
-            {
-                throw new FileNotFoundException($"ONNX model file not found during deserialization: {_onnxModelPath}");
-            }
-        }
-    }
 
     /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (_useNativeMode)
-        {
-            return new VideoMAE<T>(Architecture, _optimizer, LossFunction, _numClasses, _numFrames, _numFeatures, _maskRatio);
-        }
-        else
-        {
-            return new VideoMAE<T>(Architecture, _onnxModelPath!, _numClasses, _numFrames);
-        }
-    }
+
 
     #endregion
 
diff --git a/src/Video/Denoising/BSVD.cs b/src/Video/Denoising/BSVD.cs
index f74c05a9b1..3bfc11da9b 100644
--- a/src/Video/Denoising/BSVD.cs
+++ b/src/Video/Denoising/BSVD.cs
@@ -51,7 +51,7 @@ namespace AiDotNet.Video.Denoising;
     "https://arxiv.org/abs/2207.06937",
     Year = 2022,
     Authors = "Chenyang Qi, Junming Chen, Xin Yang, Qifeng Chen")]
-public class BSVD<T> : VideoDenoisingBase<T>
+public partial class BSVD<T> : VideoDenoisingBase<T>
 {
     private readonly BSVDOptions _options;
 
@@ -281,34 +281,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write((int)_options.Variant);
-        writer.Write(_options.NumFeatures);
-        writer.Write(_options.NumRecurrentBlocks);
-        writer.Write(_options.BufferDim);
-        writer.Write(_options.NumLevels);
-        writer.Write(_options.LearningRate);
-        writer.Write(_options.DropoutRate);
-    }
 
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _options.Variant = (VideoModelVariant)reader.ReadInt32();
-        _options.NumFeatures = reader.ReadInt32();
-        _options.NumRecurrentBlocks = reader.ReadInt32();
-        _options.BufferDim = reader.ReadInt32();
-        _options.NumLevels = reader.ReadInt32();
-        _options.LearningRate = reader.ReadDouble();
-        _options.DropoutRate = reader.ReadDouble();
-    }
 
     /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new BSVD<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/Video/Denoising/FastDVDNet.cs b/src/Video/Denoising/FastDVDNet.cs
index f557ac07e3..615b012826 100644
--- a/src/Video/Denoising/FastDVDNet.cs
+++ b/src/Video/Denoising/FastDVDNet.cs
@@ -58,7 +58,7 @@ namespace AiDotNet.Video.Denoising;
     "https://arxiv.org/abs/1907.01361",
     Year = 2020,
     Authors = "Matias Tassano, Julie Delon, Thomas Veit")]
-public class FastDVDNet<T> : VideoDenoisingBase<T>
+public partial class FastDVDNet<T> : VideoDenoisingBase<T>
 {
     private readonly FastDVDNetOptions _options;
 
@@ -443,28 +443,9 @@ protected override void InitializeLayers()
         ModelData = _useNativeMode ? this.Serialize() : []
     };
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_numFeatures); writer.Write(_numInputFrames);
-        writer.Write(_imageHeight); writer.Write(_imageWidth);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        // Restore serialized configuration values
-        _numFeatures = reader.ReadInt32();
-        _numInputFrames = reader.ReadInt32();
-        _imageHeight = reader.ReadInt32();
-        _imageWidth = reader.ReadInt32();
-
-        // The layers (with their trained weights) are already reconstructed by the base
-        // DeserializeInternalUnchecked before this override runs, so do NOT clear +
-        // re-initialize them here — that would discard the deserialized weights and leave
-        // the model randomly initialized.
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() =>
-        new FastDVDNet<T>(Architecture, _optimizer, _lossFunction, _numFeatures, _numInputFrames);
+
 
     #endregion
 
diff --git a/src/Video/Denoising/FloRNN.cs b/src/Video/Denoising/FloRNN.cs
index c39720f046..f8f9501765 100644
--- a/src/Video/Denoising/FloRNN.cs
+++ b/src/Video/Denoising/FloRNN.cs
@@ -50,7 +50,7 @@ namespace AiDotNet.Video.Denoising;
     "https://arxiv.org/abs/2204.05532",
     Year = 2022,
     Authors = "Junyi Li, Xiaohe Wu, Zhenxing Niu, Wangmeng Zuo")]
-public class FloRNN<T> : VideoDenoisingBase<T>
+public partial class FloRNN<T> : VideoDenoisingBase<T>
 {
     private readonly FloRNNOptions _options;
 
@@ -172,34 +172,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write((int)_options.Variant);
-        writer.Write(_options.NumFeatures);
-        writer.Write(_options.NumRecurrentLayers);
-        writer.Write(_options.HiddenDim);
-        writer.Write(_options.NumFlowScales);
-        writer.Write(_options.LearningRate);
-        writer.Write(_options.DropoutRate);
-    }
 
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _options.Variant = (VideoModelVariant)reader.ReadInt32();
-        _options.NumFeatures = reader.ReadInt32();
-        _options.NumRecurrentLayers = reader.ReadInt32();
-        _options.HiddenDim = reader.ReadInt32();
-        _options.NumFlowScales = reader.ReadInt32();
-        _options.LearningRate = reader.ReadDouble();
-        _options.DropoutRate = reader.ReadDouble();
-    }
 
     /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new FloRNN<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/Video/Denoising/LiteDVDNet.cs b/src/Video/Denoising/LiteDVDNet.cs
index 724a6f8799..6c22575fa4 100644
--- a/src/Video/Denoising/LiteDVDNet.cs
+++ b/src/Video/Denoising/LiteDVDNet.cs
@@ -63,7 +63,7 @@ namespace AiDotNet.Video.Denoising;
     "https://www.mecs-press.org/ijigsp/ijigsp-v17-n3/v17n3-1.html",
     Year = 2025,
     Authors = "Andrii Ilchenko, Sergii Stirenko")]
-public class LiteDVDNet<T> : VideoDenoisingBase<T>
+public partial class LiteDVDNet<T> : VideoDenoisingBase<T>
 {
     private readonly LiteDVDNetOptions _options;
 
@@ -293,36 +293,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write((int)_options.Variant);
-        writer.Write(_options.NumFeatures);
-        writer.Write(_options.InputBlockIntermediateChannels);
-        writer.Write(_options.NumBlocks);
-        writer.Write(_options.TemporalWindowSize);
-        writer.Write(_options.ExpansionFactor);
-        writer.Write(_options.LearningRate);
-        writer.Write(_options.DropoutRate);
-    }
 
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _options.Variant = (VideoModelVariant)reader.ReadInt32();
-        _options.NumFeatures = reader.ReadInt32();
-        _options.InputBlockIntermediateChannels = reader.ReadInt32();
-        _options.NumBlocks = reader.ReadInt32();
-        _options.TemporalWindowSize = reader.ReadInt32();
-        _options.ExpansionFactor = reader.ReadInt32();
-        _options.LearningRate = reader.ReadDouble();
-        _options.DropoutRate = reader.ReadDouble();
-    }
 
     /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new LiteDVDNet<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/Video/Denoising/ShiftNet.cs b/src/Video/Denoising/ShiftNet.cs
index f0a53bdb05..15c5cc3d06 100644
--- a/src/Video/Denoising/ShiftNet.cs
+++ b/src/Video/Denoising/ShiftNet.cs
@@ -70,7 +70,7 @@ namespace AiDotNet.Video.Denoising;
     "https://arxiv.org/abs/2206.10810",
     Year = 2023,
     Authors = "Dasong Li, Xiaoyu Shi, Yi Zhang, Ka Chun Cheung, Simon See, Xiaogang Wang, Hongwei Qin, Hongsheng Li")]
-public class ShiftNet<T> : VideoDenoisingBase<T>
+public partial class ShiftNet<T> : VideoDenoisingBase<T>
 {
     private readonly ShiftNetOptions _options;
 
@@ -219,34 +219,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write((int)_options.Variant);
-        writer.Write(_options.NumFeatures);
-        writer.Write(_options.NumBlocks);
-        writer.Write(_options.NumShifts);
-        writer.Write(_options.ShiftRadius);
-        writer.Write(_options.LearningRate);
-        writer.Write(_options.DropoutRate);
-    }
 
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _options.Variant = (VideoModelVariant)reader.ReadInt32();
-        _options.NumFeatures = reader.ReadInt32();
-        _options.NumBlocks = reader.ReadInt32();
-        _options.NumShifts = reader.ReadInt32();
-        _options.ShiftRadius = reader.ReadInt32();
-        _options.LearningRate = reader.ReadDouble();
-        _options.DropoutRate = reader.ReadDouble();
-    }
 
     /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new ShiftNet<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/Video/Denoising/UDVD.cs b/src/Video/Denoising/UDVD.cs
index faee6954e0..4ab125f2a4 100644
--- a/src/Video/Denoising/UDVD.cs
+++ b/src/Video/Denoising/UDVD.cs
@@ -55,7 +55,7 @@ namespace AiDotNet.Video.Denoising;
     "https://arxiv.org/abs/2011.15045",
     Year = 2021,
     Authors = "Dev Yashpal Sheth, Sreyas Mohan, Joshua L. Vincent, Ramon Manzorro, Peter A. Crozier, Mitesh M. Khapra, Eero P. Simoncelli, Carlos Fernandez-Granda")]
-public class UDVD<T> : VideoDenoisingBase<T>
+public partial class UDVD<T> : VideoDenoisingBase<T>
 {
     private readonly UDVDOptions _options;
 
@@ -185,37 +185,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write((int)_options.Variant);
-        writer.Write(_options.NumFeatures);
-        writer.Write(_options.NumLevels);
-        writer.Write(_options.NumResBlocks);
-        writer.Write(_options.TemporalBufferSize);
-        writer.Write(_options.LearningRate);
-        writer.Write(_options.DropoutRate);
-    }
 
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _options.Variant = (VideoModelVariant)reader.ReadInt32();
-        _options.NumFeatures = reader.ReadInt32();
-        _options.NumLevels = reader.ReadInt32();
-        _options.NumResBlocks = reader.ReadInt32();
-        _options.TemporalBufferSize = reader.ReadInt32();
-        _options.LearningRate = reader.ReadDouble();
-        _options.DropoutRate = reader.ReadDouble();
-    }
 
     /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var copiedOptions = new UDVDOptions(_options);
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            return new UDVD<T>(Architecture, p, copiedOptions);
-        return new UDVD<T>(Architecture, copiedOptions);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/Video/Depth/DepthAnythingV2.cs b/src/Video/Depth/DepthAnythingV2.cs
index f76ae1b555..1a85551ebd 100644
--- a/src/Video/Depth/DepthAnythingV2.cs
+++ b/src/Video/Depth/DepthAnythingV2.cs
@@ -69,7 +69,7 @@ namespace AiDotNet.Video.Depth;
     Direction = TensorLayoutDirection.Input, BatchOptional = true)]
 [TensorLayout(TensorAxis.Batch, TensorAxis.Height, TensorAxis.Width,
     Direction = TensorLayoutDirection.Output, BatchOptional = true)]
-public class DepthAnythingV2<T> : NeuralNetworkBase<T>
+public partial class DepthAnythingV2<T> : NeuralNetworkBase<T>
 {
     private readonly DepthAnythingV2Options _options;
 
@@ -649,40 +649,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_height);
-        writer.Write(_width);
-        writer.Write(_channels);
-        writer.Write((int)_modelSize);
-        writer.Write(_useNativeMode);
-        writer.Write(_onnxModelPath ?? string.Empty);
-    }
 
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _height = reader.ReadInt32();
-        _width = reader.ReadInt32();
-        _channels = reader.ReadInt32();
-        _modelSize = (ModelSize)reader.ReadInt32();
-        _useNativeMode = reader.ReadBoolean();
-        _onnxModelPath = reader.ReadString();
-        if (string.IsNullOrEmpty(_onnxModelPath)) _onnxModelPath = null;
-    }
 
     /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (_useNativeMode)
-        {
-            return new DepthAnythingV2<T>(Architecture, CreateOptimizerForClone(), LossFunction, _modelSize, new DepthAnythingV2Options(_options));
-        }
-        else
-        {
-            return new DepthAnythingV2<T>(Architecture, _onnxModelPath!, _modelSize, new DepthAnythingV2Options(_options));
-        }
-    }
+
 
     private IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? CreateOptimizerForClone()
     {
diff --git a/src/Video/Depth/MiDaS.cs b/src/Video/Depth/MiDaS.cs
index 29ac6f173c..4f24efd7d0 100644
--- a/src/Video/Depth/MiDaS.cs
+++ b/src/Video/Depth/MiDaS.cs
@@ -64,7 +64,7 @@ namespace AiDotNet.Video.Depth;
     Direction = TensorLayoutDirection.Input, BatchOptional = true)]
 [TensorLayout(TensorAxis.Batch, TensorAxis.Height, TensorAxis.Width,
     Direction = TensorLayoutDirection.Output, BatchOptional = true)]
-public class MiDaS<T> : NeuralNetworkBase<T>
+public partial class MiDaS<T> : NeuralNetworkBase<T>
 {
     private readonly MiDaSOptions _options;
 
@@ -353,23 +353,9 @@ protected override void InitializeLayers()
         ModelData = _useNativeMode ? this.Serialize() : []
     };
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        if (!_useNativeMode) throw new InvalidOperationException("Serialization is not supported in ONNX mode.");
-        writer.Write(_embedDim);
-        writer.Write(_numLayers);
-        writer.Write(_imageSize);
-        writer.Write((int)_variant);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        if (!_useNativeMode) throw new InvalidOperationException("Deserialization is not supported in ONNX mode.");
-        for (int i = 0; i < 4; i++) _ = reader.ReadInt32();
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() =>
-        new MiDaS<T>(Architecture, _optimizer, _lossFunction, _embedDim, _numLayers, _variant);
+
 
     #endregion
 }
diff --git a/src/Video/DiffusionVideoSuperResolutionBase.cs b/src/Video/DiffusionVideoSuperResolutionBase.cs
index e4b439fa33..e686d1a500 100644
--- a/src/Video/DiffusionVideoSuperResolutionBase.cs
+++ b/src/Video/DiffusionVideoSuperResolutionBase.cs
@@ -40,7 +40,7 @@ namespace AiDotNet.Video;
 /// belong on this base.
 /// </para>
 /// </remarks>
-public abstract class DiffusionVideoSuperResolutionBase<T> : VideoDiffusionModelBase<T>, IVideoSuperResolution<T>
+public abstract partial class DiffusionVideoSuperResolutionBase<T> : VideoDiffusionModelBase<T>, IVideoSuperResolution<T>
 {
     private RAFTFlowCache? _flowCache;
 
diff --git a/src/Video/Enhancement/BasicVSR.cs b/src/Video/Enhancement/BasicVSR.cs
index 126aaef3cc..0c035fc81c 100644
--- a/src/Video/Enhancement/BasicVSR.cs
+++ b/src/Video/Enhancement/BasicVSR.cs
@@ -54,7 +54,7 @@ namespace AiDotNet.Video.Enhancement;
     "https://arxiv.org/abs/2012.02181",
     Year = 2021,
     Authors = "Kelvin C.K. Chan, Xintao Wang, Ke Yu, Chao Dong, Chen Change Loy")]
-public class BasicVSR<T> : VideoSuperResolutionBase<T>
+public partial class BasicVSR<T> : VideoSuperResolutionBase<T>
 {
     #region Fields
 
@@ -178,49 +178,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode);
-        w.Write(_options.ModelPath ?? string.Empty);
-        w.Write((int)_options.Variant);
-        w.Write(_options.NumFeatures);
-        w.Write(_options.NumResBlocks);
-        w.Write(_options.ScaleFactor);
-        w.Write(_options.NumFrames);
-        w.Write(_options.MidChannels);
-        w.Write(_options.DropoutRate);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean();
-        string mp = r.ReadString();
-        if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.Variant = (VideoModelVariant)r.ReadInt32();
-        _options.NumFeatures = r.ReadInt32();
-        _options.NumResBlocks = r.ReadInt32();
-        _options.ScaleFactor = r.ReadInt32();
-        _options.NumFrames = r.ReadInt32();
-        _options.MidChannels = r.ReadInt32();
-        _options.DropoutRate = r.ReadDouble();
-        ScaleFactor = _options.ScaleFactor;
-        NumFrames = _options.NumFrames;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-        {
-            OnnxModel?.Dispose();
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-        }
-        // Native-mode layers (with their trained weights) are already reconstructed by
-        // the base deserializer before this override runs; re-initializing here would
-        // discard them and leave the model randomly initialized.
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            return new BasicVSR<T>(Architecture, p, _options);
-        return new BasicVSR<T>(Architecture, _options);
-    }
+
 
     #endregion
 
diff --git a/src/Video/Enhancement/BasicVSRPlusPlus.cs b/src/Video/Enhancement/BasicVSRPlusPlus.cs
index dd5ec6fc5d..24fe848e3d 100644
--- a/src/Video/Enhancement/BasicVSRPlusPlus.cs
+++ b/src/Video/Enhancement/BasicVSRPlusPlus.cs
@@ -949,26 +949,7 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        if (!_useNativeMode)
-            throw new InvalidOperationException("Serialization is not supported in ONNX mode.");
-
-        writer.Write(_scaleFactor);
-        writer.Write(_numFeatures);
-        writer.Write(_numResidualBlocks);
-        writer.Write(_numPropagations);
-        writer.Write(_learningRate);
 
-        // Serialize layer parameters
-        SerializeLayerParameters(writer, FeatExtract.GetParameters());
-        SerializeLayerParameters(writer, OutputConv.GetParameters());
-
-        foreach (var block in _residualBlocks)
-        {
-            SerializeLayerParameters(writer, block.GetParameters());
-        }
-    }
 
     private void SerializeLayerParameters(BinaryWriter writer, Vector<T> parameters)
     {
@@ -980,27 +961,7 @@ private void SerializeLayerParameters(BinaryWriter writer, Vector<T> parameters)
     }
 
     /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        if (!_useNativeMode)
-            throw new InvalidOperationException("Deserialization is not supported in ONNX mode.");
 
-        // Read configuration (already set in constructor)
-        _ = reader.ReadInt32(); // scaleFactor
-        _ = reader.ReadInt32(); // numFeatures
-        _ = reader.ReadInt32(); // numResidualBlocks
-        _ = reader.ReadInt32(); // numPropagations
-        _ = reader.ReadDouble(); // learningRate
-
-        // Load layer parameters
-        FeatExtract.SetParameters(DeserializeLayerParameters(reader));
-        OutputConv.SetParameters(DeserializeLayerParameters(reader));
-
-        foreach (var block in _residualBlocks)
-        {
-            block.SetParameters(DeserializeLayerParameters(reader));
-        }
-    }
 
     private Vector<T> DeserializeLayerParameters(BinaryReader reader)
     {
@@ -1013,18 +974,6 @@ private Vector<T> DeserializeLayerParameters(BinaryReader reader)
         return new Vector<T>(parameters);
     }
 
-    /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new BasicVSRPlusPlus<T>(
-            Architecture,
-            _scaleFactor,
-            _numFeatures,
-            _numResidualBlocks,
-            _numPropagations,
-            _learningRate);
-    }
-
     #endregion
 
     #region Base Class Abstract Methods
diff --git a/src/Video/Enhancement/DAMVSR.cs b/src/Video/Enhancement/DAMVSR.cs
index 6000a64dab..d59c3afd1d 100644
--- a/src/Video/Enhancement/DAMVSR.cs
+++ b/src/Video/Enhancement/DAMVSR.cs
@@ -55,7 +55,7 @@ namespace AiDotNet.Video.Enhancement;
     "https://arxiv.org/abs/2507.01012",
     Year = 2025,
     Authors = "Kaichen Chi, Xin Li, Zhi-Song Liu, Wan-Chi Siu")]
-public class DAMVSR<T> : VideoSuperResolutionBase<T>
+public partial class DAMVSR<T> : VideoSuperResolutionBase<T>
 {
     #region Fields
 
@@ -179,41 +179,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode);
-        w.Write(_options.ModelPath ?? string.Empty);
-        w.Write((int)_options.Variant);
-        w.Write(_options.NumFeatures);
-        w.Write(_options.NumResBlocks);
-        w.Write(_options.NumHeads);
-        w.Write(_options.DeformableGroups);
-        w.Write(_options.NumSamplingPoints);
-        w.Write(_options.ScaleFactor);
-        w.Write(_options.NumFrames);
-        w.Write(_options.DropoutRate);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean();
-        string mp = r.ReadString();
-        if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.Variant = (VideoModelVariant)r.ReadInt32();
-        _options.NumFeatures = r.ReadInt32();
-        _options.NumResBlocks = r.ReadInt32();
-        _options.NumHeads = r.ReadInt32();
-        _options.DeformableGroups = r.ReadInt32();
-        _options.NumSamplingPoints = r.ReadInt32();
-        _options.ScaleFactor = r.ReadInt32();
-        _options.NumFrames = r.ReadInt32();
-        _options.DropoutRate = r.ReadDouble();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-        => new DAMVSR<T>(Architecture, _options);
+
 
     #endregion
 
diff --git a/src/Video/Enhancement/DOVE.cs b/src/Video/Enhancement/DOVE.cs
index 95a0344bb6..b5bb79af9a 100644
--- a/src/Video/Enhancement/DOVE.cs
+++ b/src/Video/Enhancement/DOVE.cs
@@ -54,7 +54,7 @@ namespace AiDotNet.Video.Enhancement;
     "https://arxiv.org/abs/2505.16239",
     Year = 2025,
     Authors = "Zheng Chen, Zichen Zou, Kewei Zhang, Xiongfei Su, Xin Yuan, Yong Guo, Yulun Zhang")]
-public class DOVE<T> : VideoSuperResolutionBase<T>
+public partial class DOVE<T> : VideoSuperResolutionBase<T>
 {
     #region Fields
 
@@ -179,52 +179,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode);
-        w.Write(_options.ModelPath ?? string.Empty);
-        w.Write((int)_options.Variant);
-        w.Write(_options.NumFeatures);
-        w.Write(_options.NumDenoisingSteps);
-        w.Write(_options.NumResBlocks);
-        w.Write(_options.NumAttentionHeads);
-        w.Write(_options.ScaleFactor);
-        w.Write(_options.LatentDim);
-        w.Write(_options.GuidanceScale);
-        w.Write(_options.DropoutRate);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean();
-        string mp = r.ReadString();
-        if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.Variant = (VideoModelVariant)r.ReadInt32();
-        _options.NumFeatures = r.ReadInt32();
-        _options.NumDenoisingSteps = r.ReadInt32();
-        _options.NumResBlocks = r.ReadInt32();
-        _options.NumAttentionHeads = r.ReadInt32();
-        _options.ScaleFactor = r.ReadInt32();
-        _options.LatentDim = r.ReadInt32();
-        _options.GuidanceScale = r.ReadDouble();
-        _options.DropoutRate = r.ReadDouble();
-        ScaleFactor = _options.ScaleFactor;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-        {
-            OnnxModel?.Dispose();
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-        }
-        // Native-mode layers (with their trained weights) are already reconstructed by
-        // the base deserializer before this override runs; re-initializing here would
-        // discard them and leave the model randomly initialized.
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            return new DOVE<T>(Architecture, p, _options);
-        return new DOVE<T>(Architecture, _options);
-    }
+
 
     #endregion
 
diff --git a/src/Video/Enhancement/DualXVSR.cs b/src/Video/Enhancement/DualXVSR.cs
index 4f6ba66041..31ed0d775b 100644
--- a/src/Video/Enhancement/DualXVSR.cs
+++ b/src/Video/Enhancement/DualXVSR.cs
@@ -59,7 +59,7 @@ namespace AiDotNet.Video.Enhancement;
     "https://arxiv.org/abs/2506.04830",
     Year = 2025,
     Authors = "Shuo Cao, Yihao Liu, Xiaohui Li, Yuanting Gao, Yu Zhou, Chao Dong")]
-public class DualXVSR<T> : VideoSuperResolutionBase<T>
+public partial class DualXVSR<T> : VideoSuperResolutionBase<T>
 {
     #region Fields
 
@@ -186,53 +186,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode);
-        w.Write(_options.ModelPath ?? string.Empty);
-        w.Write((int)_options.Variant);
-        w.Write(_options.NumFeatures);
-        w.Write(_options.NumAxialBlocks);
-        w.Write(_options.ScaleFactor);
-        w.Write(_options.NumHeads);
-        w.Write(_options.TemporalWindow);
-        w.Write(_options.DropoutRate);
-        w.Write(_options.LearningRate);
-        w.Write(_options.WeightDecay);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean();
-        string mp = r.ReadString();
-        if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.Variant = (VideoModelVariant)r.ReadInt32();
-        _options.NumFeatures = r.ReadInt32();
-        _options.NumAxialBlocks = r.ReadInt32();
-        _options.ScaleFactor = r.ReadInt32();
-        _options.NumHeads = r.ReadInt32();
-        _options.TemporalWindow = r.ReadInt32();
-        _options.DropoutRate = r.ReadDouble();
-        if (r.BaseStream.Position < r.BaseStream.Length) _options.LearningRate = r.ReadDouble();
-        if (r.BaseStream.Position < r.BaseStream.Length) _options.WeightDecay = r.ReadDouble();
-        ScaleFactor = _options.ScaleFactor;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-        {
-            OnnxModel?.Dispose();
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-        }
-        // Native-mode layers (with their trained weights) are already reconstructed by
-        // the base deserializer before this override runs; re-initializing here would
-        // discard them and leave the model randomly initialized.
-        if (_useNativeMode) _optimizer = CreateDefaultOptimizer();
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new DualXVSR<T>(Architecture, mp, new DualXVSROptions(_options));
-        return new DualXVSR<T>(Architecture, new DualXVSROptions(_options));
-    }
+
 
     private AdamWOptimizer<T, Tensor<T>, Tensor<T>> CreateDefaultOptimizer()
         => new(this, new AdamWOptimizerOptions<T, Tensor<T>, Tensor<T>>
diff --git a/src/Video/Enhancement/EDVR.cs b/src/Video/Enhancement/EDVR.cs
index 7fed250334..b65ef35761 100644
--- a/src/Video/Enhancement/EDVR.cs
+++ b/src/Video/Enhancement/EDVR.cs
@@ -56,7 +56,7 @@ namespace AiDotNet.Video.Enhancement;
     "https://arxiv.org/abs/1905.02716",
     Year = 2019,
     Authors = "Xintao Wang, Kelvin C.K. Chan, Ke Yu, Chao Dong, Chen Change Loy")]
-public class EDVR<T> : VideoSuperResolutionBase<T>
+public partial class EDVR<T> : VideoSuperResolutionBase<T>
 {
     private readonly EDVROptions _options;
 
@@ -303,18 +303,9 @@ protected override void InitializeLayers()
         ModelData = _useNativeMode ? this.Serialize() : []
     };
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_numFeatures); writer.Write(_numFrames); writer.Write(_numBlocks); writer.Write(_scaleFactor);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        for (int i = 0; i < 4; i++) _ = reader.ReadInt32();
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() =>
-        new EDVR<T>(Architecture, _optimizer, _lossFunction, _numFeatures, _numFrames, _numBlocks, _scaleFactor);
+
 
     #endregion
 
diff --git a/src/Video/Enhancement/FlashVSR.cs b/src/Video/Enhancement/FlashVSR.cs
index 7f092a8275..b26497f4f5 100644
--- a/src/Video/Enhancement/FlashVSR.cs
+++ b/src/Video/Enhancement/FlashVSR.cs
@@ -54,7 +54,7 @@ namespace AiDotNet.Video.Enhancement;
     "https://arxiv.org/abs/2510.12747",
     Year = 2025,
     Authors = "Junhao Zhuang, Shi Guo, Xin Cai, Xiaohui Li, Yihao Liu, Chun Yuan, Tianfan Xue")]
-public class FlashVSR<T> : VideoSuperResolutionBase<T>
+public partial class FlashVSR<T> : VideoSuperResolutionBase<T>
 {
     #region Fields
 
@@ -198,53 +198,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode);
-        w.Write(_options.ModelPath ?? string.Empty);
-        w.Write((int)_options.Variant);
-        w.Write(_options.NumFeatures);
-        w.Write(_options.NumLCSABlocks);
-        w.Write(_options.WindowSize);
-        w.Write(_options.NumHeads);
-        w.Write(_options.ScaleFactor);
-        w.Write(_options.NumInputFrames);
-        w.Write(_options.NumDecoderBlocks);
-        w.Write(_options.DropoutRate);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean();
-        string mp = r.ReadString();
-        if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.Variant = (VideoModelVariant)r.ReadInt32();
-        _options.NumFeatures = r.ReadInt32();
-        _options.NumLCSABlocks = r.ReadInt32();
-        _options.WindowSize = r.ReadInt32();
-        _options.NumHeads = r.ReadInt32();
-        _options.ScaleFactor = r.ReadInt32();
-        _options.NumInputFrames = r.ReadInt32();
-        _options.NumDecoderBlocks = r.ReadInt32();
-        _options.DropoutRate = r.ReadDouble();
-        ScaleFactor = _options.ScaleFactor;
-        NumFrames = _options.NumInputFrames;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-        {
-            OnnxModel?.Dispose();
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-        }
-        // Native-mode layers (with their trained weights) are already reconstructed by
-        // the base deserializer before this override runs; re-initializing here would
-        // discard them and leave the model randomly initialized.
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            return new FlashVSR<T>(Architecture, p, _options);
-        return new FlashVSR<T>(Architecture, _options);
-    }
+
 
     #endregion
 
diff --git a/src/Video/Enhancement/IART.cs b/src/Video/Enhancement/IART.cs
index dd65e4e6b6..bee830e602 100644
--- a/src/Video/Enhancement/IART.cs
+++ b/src/Video/Enhancement/IART.cs
@@ -58,7 +58,7 @@ namespace AiDotNet.Video.Enhancement;
     "https://arxiv.org/abs/2305.00163",
     Year = 2024,
     Authors = "Kai Xu, Ziwei Yu, Xin Wang, Michael Bi Mi, Angela Yao")]
-public class IART<T> : VideoSuperResolutionBase<T>
+public partial class IART<T> : VideoSuperResolutionBase<T>
 {
     #region Fields
 
@@ -190,46 +190,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode);
-        w.Write(_options.ModelPath ?? string.Empty);
-        w.Write((int)_options.Variant);
-        w.Write(_options.NumFeatures);
-        w.Write(_options.NumTransformerBlocks);
-        w.Write(_options.NumResBlocks);
-        w.Write(_options.ScaleFactor);
-        w.Write(_options.NumHeads);
-        w.Write(_options.NumScales);
-        w.Write(_options.ImplicitDim);
-        w.Write(_options.DropoutRate);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean();
-        string mp = r.ReadString();
-        if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.Variant = (VideoModelVariant)r.ReadInt32();
-        _options.NumFeatures = r.ReadInt32();
-        _options.NumTransformerBlocks = r.ReadInt32();
-        _options.NumResBlocks = r.ReadInt32();
-        _options.ScaleFactor = r.ReadInt32();
-        _options.NumHeads = r.ReadInt32();
-        _options.NumScales = r.ReadInt32();
-        _options.ImplicitDim = r.ReadInt32();
-        _options.DropoutRate = r.ReadDouble();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var optionsCopy = new IARTOptions(_options);
-        if (!_useNativeMode && optionsCopy.ModelPath is { } path && !string.IsNullOrEmpty(path))
-            return new IART<T>(Architecture, path, optionsCopy);
-        return new IART<T>(Architecture, optionsCopy);
-    }
+
 
     #endregion
 
diff --git a/src/Video/Enhancement/IconVSR.cs b/src/Video/Enhancement/IconVSR.cs
index 2ca183e1dc..ca17af7165 100644
--- a/src/Video/Enhancement/IconVSR.cs
+++ b/src/Video/Enhancement/IconVSR.cs
@@ -52,7 +52,7 @@ namespace AiDotNet.Video.Enhancement;
     "https://arxiv.org/abs/2012.02181",
     Year = 2021,
     Authors = "Kelvin C.K. Chan, Xintao Wang, Ke Yu, Chao Dong, Chen Change Loy")]
-public class IconVSR<T> : VideoSuperResolutionBase<T>
+public partial class IconVSR<T> : VideoSuperResolutionBase<T>
 {
     #region Fields
 
@@ -176,39 +176,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode);
-        w.Write(_options.ModelPath ?? string.Empty);
-        w.Write((int)_options.Variant);
-        w.Write(_options.NumFeatures);
-        w.Write(_options.NumResBlocks);
-        w.Write(_options.ScaleFactor);
-        w.Write(_options.NumFrames);
-        w.Write(_options.KeyframeStride);
-        w.Write(_options.NumEdemaBlocks);
-        w.Write(_options.DropoutRate);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean();
-        string mp = r.ReadString();
-        if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.Variant = (VideoModelVariant)r.ReadInt32();
-        _options.NumFeatures = r.ReadInt32();
-        _options.NumResBlocks = r.ReadInt32();
-        _options.ScaleFactor = r.ReadInt32();
-        _options.NumFrames = r.ReadInt32();
-        _options.KeyframeStride = r.ReadInt32();
-        _options.NumEdemaBlocks = r.ReadInt32();
-        _options.DropoutRate = r.ReadDouble();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-        => new IconVSR<T>(Architecture, _options);
+
 
     #endregion
 
diff --git a/src/Video/Enhancement/MGLDVSR.cs b/src/Video/Enhancement/MGLDVSR.cs
index cd00b1562d..f0077ab72a 100644
--- a/src/Video/Enhancement/MGLDVSR.cs
+++ b/src/Video/Enhancement/MGLDVSR.cs
@@ -55,7 +55,7 @@ namespace AiDotNet.Video.Enhancement;
     "https://arxiv.org/abs/2312.00853",
     Year = 2024,
     Authors = "Yang Zheng, Xiaoming Zhu, Jianlong Wu, Liqiang Nie")]
-public class MGLDVSR<T> : VideoSuperResolutionBase<T>
+public partial class MGLDVSR<T> : VideoSuperResolutionBase<T>
 {
     #region Fields
 
@@ -176,43 +176,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode);
-        w.Write(_options.ModelPath ?? string.Empty);
-        w.Write((int)_options.Variant);
-        w.Write(_options.NumFeatures);
-        w.Write(_options.NumDenoisingSteps);
-        w.Write(_options.NumResBlocks);
-        w.Write(_options.ScaleFactor);
-        w.Write(_options.LatentDim);
-        w.Write(_options.MotionGuidanceWeight);
-        w.Write(_options.DropoutRate);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean();
-        string mp = r.ReadString();
-        if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.Variant = (VideoModelVariant)r.ReadInt32();
-        _options.NumFeatures = r.ReadInt32();
-        _options.NumDenoisingSteps = r.ReadInt32();
-        _options.NumResBlocks = r.ReadInt32();
-        _options.ScaleFactor = r.ReadInt32();
-        _options.LatentDim = r.ReadInt32();
-        _options.MotionGuidanceWeight = r.ReadDouble();
-        _options.DropoutRate = r.ReadDouble();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (IsOnnxMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new MGLDVSR<T>(Architecture, mp, _options);
-        return new MGLDVSR<T>(Architecture, _options);
-    }
+
 
     #endregion
 
diff --git a/src/Video/Enhancement/MIAVSR.cs b/src/Video/Enhancement/MIAVSR.cs
index d3959583ca..005b7d4183 100644
--- a/src/Video/Enhancement/MIAVSR.cs
+++ b/src/Video/Enhancement/MIAVSR.cs
@@ -57,7 +57,7 @@ namespace AiDotNet.Video.Enhancement;
     "https://arxiv.org/abs/2401.06312",
     Year = 2024,
     Authors = "Xingyu Zhou, Leheng Zhang, Xiaorui Zhao, Keze Wang, Leida Li, Shuhang Gu")]
-public class MIAVSR<T> : VideoSuperResolutionBase<T>
+public partial class MIAVSR<T> : VideoSuperResolutionBase<T>
 {
     #region Fields
 
@@ -182,49 +182,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode);
-        w.Write(_options.ModelPath ?? string.Empty);
-        w.Write((int)_options.Variant);
-        w.Write(_options.NumFeatures);
-        w.Write(_options.NumResBlocks);
-        w.Write(_options.ScaleFactor);
-        w.Write(_options.WindowSize);
-        w.Write(_options.NumHeads);
-        w.Write(_options.InterMaskRatio);
-        w.Write(_options.IntraMaskRatio);
-        w.Write(_options.DropoutRate);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean();
-        string mp = r.ReadString();
-        if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.Variant = (VideoModelVariant)r.ReadInt32();
-        _options.NumFeatures = r.ReadInt32();
-        _options.NumResBlocks = r.ReadInt32();
-        _options.ScaleFactor = r.ReadInt32();
-        _options.WindowSize = r.ReadInt32();
-        _options.NumHeads = r.ReadInt32();
-        _options.InterMaskRatio = r.ReadDouble();
-        _options.IntraMaskRatio = r.ReadDouble();
-        _options.DropoutRate = r.ReadDouble();
-        ScaleFactor = _options.ScaleFactor;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-        // Native-mode layers (with their trained weights) are already reconstructed by
-        // the base deserializer before this override runs; re-initializing here would
-        // discard them and leave the model randomly initialized.
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new MIAVSR<T>(Architecture, mp, _options);
-        return new MIAVSR<T>(Architecture, _options);
-    }
+
 
     #endregion
 
diff --git a/src/Video/Enhancement/PSRT.cs b/src/Video/Enhancement/PSRT.cs
index d52a58961a..a10e9b9e54 100644
--- a/src/Video/Enhancement/PSRT.cs
+++ b/src/Video/Enhancement/PSRT.cs
@@ -56,7 +56,7 @@ namespace AiDotNet.Video.Enhancement;
     "https://arxiv.org/abs/2207.08494",
     Year = 2022,
     Authors = "Shuwei Shi, Jinjin Gu, Liangbin Xie, Xintao Wang, Yujiu Yang, Chao Dong")]
-public class PSRT<T> : VideoSuperResolutionBase<T>
+public partial class PSRT<T> : VideoSuperResolutionBase<T>
 {
     #region Fields
 
@@ -179,43 +179,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode);
-        w.Write(_options.ModelPath ?? string.Empty);
-        w.Write((int)_options.Variant);
-        w.Write(_options.NumFeatures);
-        w.Write(_options.NumSTABs);
-        w.Write(_options.ScaleFactor);
-        w.Write(_options.WindowSize);
-        w.Write(_options.TemporalRadius);
-        w.Write(_options.NumHeads);
-        w.Write(_options.DropoutRate);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean();
-        string mp = r.ReadString();
-        if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.Variant = (VideoModelVariant)r.ReadInt32();
-        _options.NumFeatures = r.ReadInt32();
-        _options.NumSTABs = r.ReadInt32();
-        _options.ScaleFactor = r.ReadInt32();
-        _options.WindowSize = r.ReadInt32();
-        _options.TemporalRadius = r.ReadInt32();
-        _options.NumHeads = r.ReadInt32();
-        _options.DropoutRate = r.ReadDouble();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            return new PSRT<T>(Architecture, p, _options);
-        return new PSRT<T>(Architecture, _options);
-    }
+
 
     #endregion
 
diff --git a/src/Video/Enhancement/RVRT.cs b/src/Video/Enhancement/RVRT.cs
index 76d04899fa..fd863b08ae 100644
--- a/src/Video/Enhancement/RVRT.cs
+++ b/src/Video/Enhancement/RVRT.cs
@@ -56,7 +56,7 @@ namespace AiDotNet.Video.Enhancement;
     "https://arxiv.org/abs/2206.02146",
     Year = 2022,
     Authors = "Jingyun Liang, Yuchen Fan, Xiaoyu Xiang, Rakesh Ranjan, Eddy Ilg, Simon Green, Jiezhang Cao, Kai Zhang, Radu Timofte, Luc Van Gool")]
-public class RVRT<T> : VideoSuperResolutionBase<T>
+public partial class RVRT<T> : VideoSuperResolutionBase<T>
 {
     #region Fields
 
@@ -182,47 +182,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode);
-        w.Write(_options.ModelPath ?? string.Empty);
-        w.Write((int)_options.Variant);
-        w.Write(_options.NumFeatures);
-        w.Write(_options.NumBlocks);
-        w.Write(_options.ScaleFactor);
-        w.Write(_options.ClipSize);
-        w.Write(_options.NumFrameGroups);
-        w.Write(_options.NumHeads);
-        w.Write(_options.NumSamplingPoints);
-        w.Write(_options.WindowSize);
-        w.Write(_options.DropoutRate);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean();
-        string mp = r.ReadString();
-        if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.Variant = (VideoModelVariant)r.ReadInt32();
-        _options.NumFeatures = r.ReadInt32();
-        _options.NumBlocks = r.ReadInt32();
-        _options.ScaleFactor = r.ReadInt32();
-        _options.ClipSize = r.ReadInt32();
-        _options.NumFrameGroups = r.ReadInt32();
-        _options.NumHeads = r.ReadInt32();
-        _options.NumSamplingPoints = r.ReadInt32();
-        _options.WindowSize = r.ReadInt32();
-        _options.DropoutRate = r.ReadDouble();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            return new RVRT<T>(Architecture, p, _options);
-        return new RVRT<T>(Architecture, _options);
-    }
+
 
     #endregion
 
diff --git a/src/Video/Enhancement/RealBasicVSR.cs b/src/Video/Enhancement/RealBasicVSR.cs
index 2b2f1dfa70..2c9f4f34bb 100644
--- a/src/Video/Enhancement/RealBasicVSR.cs
+++ b/src/Video/Enhancement/RealBasicVSR.cs
@@ -55,7 +55,7 @@ namespace AiDotNet.Video.Enhancement;
     "https://arxiv.org/abs/2111.12704",
     Year = 2022,
     Authors = "Kelvin C.K. Chan, Shangchen Zhou, Xiangyu Xu, Chen Change Loy")]
-public class RealBasicVSR<T> : VideoSuperResolutionBase<T>
+public partial class RealBasicVSR<T> : VideoSuperResolutionBase<T>
 {
     #region Fields
 
@@ -178,49 +178,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode);
-        w.Write(_options.ModelPath ?? string.Empty);
-        w.Write((int)_options.Variant);
-        w.Write(_options.NumFeatures);
-        w.Write(_options.NumResBlocks);
-        w.Write(_options.CleaningModuleBlocks);
-        w.Write(_options.ScaleFactor);
-        w.Write(_options.NumFrames);
-        w.Write(_options.DropoutRate);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean();
-        string mp = r.ReadString();
-        if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.Variant = (VideoModelVariant)r.ReadInt32();
-        _options.NumFeatures = r.ReadInt32();
-        _options.NumResBlocks = r.ReadInt32();
-        _options.CleaningModuleBlocks = r.ReadInt32();
-        _options.ScaleFactor = r.ReadInt32();
-        _options.NumFrames = r.ReadInt32();
-        _options.DropoutRate = r.ReadDouble();
-        ScaleFactor = _options.ScaleFactor;
-        NumFrames = _options.NumFrames;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-        {
-            OnnxModel?.Dispose();
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-        }
-        // Native-mode layers (with their trained weights) are already reconstructed by
-        // the base deserializer before this override runs; re-initializing here would
-        // discard them and leave the model randomly initialized.
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            return new RealBasicVSR<T>(Architecture, p, _options);
-        return new RealBasicVSR<T>(Architecture, _options);
-    }
+
 
     #endregion
 
diff --git a/src/Video/Enhancement/RealBasicVSRSharp.cs b/src/Video/Enhancement/RealBasicVSRSharp.cs
index 8a2a755931..47cd394e5d 100644
--- a/src/Video/Enhancement/RealBasicVSRSharp.cs
+++ b/src/Video/Enhancement/RealBasicVSRSharp.cs
@@ -53,7 +53,7 @@ namespace AiDotNet.Video.Enhancement;
     "https://arxiv.org/abs/2111.12704",
     Year = 2022,
     Authors = "Kelvin C.K. Chan, Shangchen Zhou, Xiangyu Xu, Chen Change Loy")]
-public class RealBasicVSRSharp<T> : VideoSuperResolutionBase<T>
+public partial class RealBasicVSRSharp<T> : VideoSuperResolutionBase<T>
 {
     #region Fields
 
@@ -177,39 +177,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode);
-        w.Write(_options.ModelPath ?? string.Empty);
-        w.Write(_options.NumFeatures);
-        w.Write(_options.NumResBlocks);
-        w.Write(_options.CleaningModuleBlocks);
-        w.Write(_options.ScaleFactor);
-        w.Write(_options.NumFrames);
-        w.Write(_options.PerceptualWeight);
-        w.Write(_options.GANWeight);
-        w.Write(_options.DropoutRate);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean();
-        string mp = r.ReadString();
-        if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.NumFeatures = r.ReadInt32();
-        _options.NumResBlocks = r.ReadInt32();
-        _options.CleaningModuleBlocks = r.ReadInt32();
-        _options.ScaleFactor = r.ReadInt32();
-        _options.NumFrames = r.ReadInt32();
-        _options.PerceptualWeight = r.ReadDouble();
-        _options.GANWeight = r.ReadDouble();
-        _options.DropoutRate = r.ReadDouble();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-        => new RealBasicVSRSharp<T>(Architecture, _options);
+
 
     #endregion
 
diff --git a/src/Video/Enhancement/RealESRGANVideo.cs b/src/Video/Enhancement/RealESRGANVideo.cs
index f97afb0f72..39d8315eb7 100644
--- a/src/Video/Enhancement/RealESRGANVideo.cs
+++ b/src/Video/Enhancement/RealESRGANVideo.cs
@@ -56,7 +56,7 @@ namespace AiDotNet.Video.Enhancement;
     "https://arxiv.org/abs/2107.10833",
     Year = 2021,
     Authors = "Xintao Wang, Liangbin Xie, Chao Dong, Ying Shan")]
-public class RealESRGANVideo<T> : VideoSuperResolutionBase<T>
+public partial class RealESRGANVideo<T> : VideoSuperResolutionBase<T>
 {
     #region Fields
 
@@ -179,45 +179,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode);
-        w.Write(_options.ModelPath ?? string.Empty);
-        w.Write((int)_options.Variant);
-        w.Write(_options.NumFeatures);
-        w.Write(_options.NumRRDBBlocks);
-        w.Write(_options.ScaleFactor);
-        w.Write(_options.DenseLayersPerBlock);
-        w.Write(_options.ResidualScale);
-        w.Write(_options.PerceptualWeight);
-        w.Write(_options.GANWeight);
-        w.Write(_options.DropoutRate);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean();
-        string mp = r.ReadString();
-        if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.Variant = (VideoModelVariant)r.ReadInt32();
-        _options.NumFeatures = r.ReadInt32();
-        _options.NumRRDBBlocks = r.ReadInt32();
-        _options.ScaleFactor = r.ReadInt32();
-        _options.DenseLayersPerBlock = r.ReadInt32();
-        _options.ResidualScale = r.ReadDouble();
-        _options.PerceptualWeight = r.ReadDouble();
-        _options.GANWeight = r.ReadDouble();
-        _options.DropoutRate = r.ReadDouble();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            return new RealESRGANVideo<T>(Architecture, p, _options);
-        return new RealESRGANVideo<T>(Architecture, _options);
-    }
+
 
     #endregion
 
diff --git a/src/Video/Enhancement/RealViformer.cs b/src/Video/Enhancement/RealViformer.cs
index a34a0847c4..6ad139b30d 100644
--- a/src/Video/Enhancement/RealViformer.cs
+++ b/src/Video/Enhancement/RealViformer.cs
@@ -57,7 +57,7 @@ namespace AiDotNet.Video.Enhancement;
     "https://arxiv.org/abs/2407.13987",
     Year = 2024,
     Authors = "Yuehan Zhang, Angela Yao")]
-public class RealViformer<T> : VideoSuperResolutionBase<T>
+public partial class RealViformer<T> : VideoSuperResolutionBase<T>
 {
     #region Fields
 
@@ -179,37 +179,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode);
-        w.Write(_options.ModelPath ?? string.Empty);
-        w.Write((int)_options.Variant);
-        w.Write(_options.NumFeatures);
-        w.Write(_options.NumResBlocks);
-        w.Write(_options.ScaleFactor);
-        w.Write(_options.ChannelReductionRatio);
-        w.Write(_options.SparseTopKFactor);
-        w.Write(_options.DropoutRate);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean();
-        string mp = r.ReadString();
-        if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.Variant = (VideoModelVariant)r.ReadInt32();
-        _options.NumFeatures = r.ReadInt32();
-        _options.NumResBlocks = r.ReadInt32();
-        _options.ScaleFactor = r.ReadInt32();
-        _options.ChannelReductionRatio = r.ReadInt32();
-        _options.SparseTopKFactor = r.ReadInt32();
-        _options.DropoutRate = r.ReadDouble();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-        => new RealViformer<T>(Architecture, _options);
+
 
     #endregion
 
diff --git a/src/Video/Enhancement/RealisVSR.cs b/src/Video/Enhancement/RealisVSR.cs
index e7e9b05a82..9ccb28078b 100644
--- a/src/Video/Enhancement/RealisVSR.cs
+++ b/src/Video/Enhancement/RealisVSR.cs
@@ -51,7 +51,7 @@ namespace AiDotNet.Video.Enhancement;
     "https://arxiv.org/abs/2507.19138",
     Year = 2025,
     Authors = "Chao Ma, Shangchen Zhou, Chen Change Loy")]
-public class RealisVSR<T> : VideoSuperResolutionBase<T>
+public partial class RealisVSR<T> : VideoSuperResolutionBase<T>
 {
     #region Fields
 
@@ -174,50 +174,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode);
-        w.Write(_options.ModelPath ?? string.Empty);
-        w.Write((int)_options.Variant);
-        w.Write(_options.NumFeatures);
-        w.Write(_options.NumDenoisingSteps);
-        w.Write(_options.NumResBlocks);
-        w.Write(_options.ScaleFactor);
-        w.Write(_options.ControlNetScale);
-        w.Write(_options.GuidanceScale);
-        w.Write(_options.DropoutRate);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean();
-        string mp = r.ReadString();
-        if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.Variant = (VideoModelVariant)r.ReadInt32();
-        _options.NumFeatures = r.ReadInt32();
-        _options.NumDenoisingSteps = r.ReadInt32();
-        _options.NumResBlocks = r.ReadInt32();
-        _options.ScaleFactor = r.ReadInt32();
-        _options.ControlNetScale = r.ReadDouble();
-        _options.GuidanceScale = r.ReadDouble();
-        _options.DropoutRate = r.ReadDouble();
-        ScaleFactor = _options.ScaleFactor;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-        {
-            OnnxModel?.Dispose();
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-        }
-        // Native-mode layers (with their trained weights) are already reconstructed by
-        // the base deserializer before this override runs; re-initializing here would
-        // discard them and leave the model randomly initialized.
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            return new RealisVSR<T>(Architecture, p, _options);
-        return new RealisVSR<T>(Architecture, _options);
-    }
+
 
     #endregion
 
diff --git a/src/Video/Enhancement/SeedVR.cs b/src/Video/Enhancement/SeedVR.cs
index 4941a71f37..5f68a3e242 100644
--- a/src/Video/Enhancement/SeedVR.cs
+++ b/src/Video/Enhancement/SeedVR.cs
@@ -54,7 +54,7 @@ namespace AiDotNet.Video.Enhancement;
     "https://arxiv.org/abs/2501.01320",
     Year = 2025,
     Authors = "Jianyi Wang, Kelvin C.K. Chan, Shangchen Zhou, Chen Change Loy")]
-public class SeedVR<T> : VideoSuperResolutionBase<T>
+public partial class SeedVR<T> : VideoSuperResolutionBase<T>
 {
     #region Fields
 
@@ -186,52 +186,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode);
-        w.Write(_options.ModelPath ?? string.Empty);
-        w.Write((int)_options.Variant);
-        w.Write(_options.NumFeatures);
-        w.Write(_options.NumDiTBlocks);
-        w.Write(_options.PatchSize);
-        w.Write(_options.WindowSize);
-        w.Write(_options.NumHeads);
-        w.Write(_options.NumDenoisingSteps);
-        w.Write(_options.ScaleFactor);
-        w.Write(_options.DropoutRate);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean();
-        string mp = r.ReadString();
-        if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.Variant = (VideoModelVariant)r.ReadInt32();
-        _options.NumFeatures = r.ReadInt32();
-        _options.NumDiTBlocks = r.ReadInt32();
-        _options.PatchSize = r.ReadInt32();
-        _options.WindowSize = r.ReadInt32();
-        _options.NumHeads = r.ReadInt32();
-        _options.NumDenoisingSteps = r.ReadInt32();
-        _options.ScaleFactor = r.ReadInt32();
-        _options.DropoutRate = r.ReadDouble();
-        ScaleFactor = _options.ScaleFactor;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-        {
-            OnnxModel?.Dispose();
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-        }
-        // Native-mode layers (with their trained weights) are already reconstructed by
-        // the base deserializer before this override runs; re-initializing here would
-        // discard them and leave the model randomly initialized.
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            return new SeedVR<T>(Architecture, p, _options);
-        return new SeedVR<T>(Architecture, _options);
-    }
+
 
     #endregion
 
diff --git a/src/Video/Enhancement/StableVideoSR.cs b/src/Video/Enhancement/StableVideoSR.cs
index e876e76f8f..421e7802cd 100644
--- a/src/Video/Enhancement/StableVideoSR.cs
+++ b/src/Video/Enhancement/StableVideoSR.cs
@@ -309,123 +309,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode);
-        w.Write(_options.ModelPath ?? string.Empty);
-        w.Write((int)_options.Variant);
-        w.Write(_options.NumFeatures);
-        w.Write(_options.NumDenoisingSteps);
-        w.Write(_options.NumTemporalModules);
-        w.Write(_options.ScaleFactor);
-        w.Write(_options.LatentDim);
-        w.Write(_options.GuidanceScale);
-        w.Write(_options.DropoutRate);
-        w.Write(_options.LatentScaleFactor);
-        w.Write(_options.MaximumNoiseLevel);
-        w.Write(_options.TemporalWindowSize);
-        w.Write(_options.TemporalWindowOverlap);
-        w.Write(_options.EnableFlowGuidedPropagation);
-        w.Write(_options.NoiseLevel);
-        w.Write(_options.Prompt ?? string.Empty);
-        w.Write(_options.PropagationSteps.Length);
-        foreach (int step in _options.PropagationSteps) w.Write(step);
-
-        w.Write(_diffusionCore is not null);
-        if (_diffusionCore is not null)
-        {
-            var chunks = _diffusionCore.GetParameterChunks().ToList();
-            w.Write(chunks.Count);
-            foreach (var chunk in chunks)
-                SerializationHelper<T>.SerializeTensor(w, chunk);
-        }
-        // Appended for backward compatibility: older payloads end immediately
-        // after the optional diffusion-core chunks.
-        w.Write(_options.NegativePrompt ?? string.Empty);
-    }
-
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean();
-        string mp = r.ReadString();
-        if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.Variant = (VideoModelVariant)r.ReadInt32();
-        _options.NumFeatures = r.ReadInt32();
-        _options.NumDenoisingSteps = r.ReadInt32();
-        _options.NumTemporalModules = r.ReadInt32();
-        _options.ScaleFactor = r.ReadInt32();
-        _options.LatentDim = r.ReadInt32();
-        _options.GuidanceScale = r.ReadDouble();
-        _options.DropoutRate = r.ReadDouble();
-        _options.LatentScaleFactor = r.ReadDouble();
-        _options.MaximumNoiseLevel = r.ReadInt32();
-        _options.TemporalWindowSize = r.ReadInt32();
-        _options.TemporalWindowOverlap = r.ReadInt32();
-        _options.EnableFlowGuidedPropagation = r.ReadBoolean();
-        _options.NoiseLevel = r.ReadInt32();
-        _options.Prompt = r.ReadString();
-        int propagationCount = r.ReadInt32();
-        _options.PropagationSteps = new int[propagationCount];
-        for (int i = 0; i < propagationCount; i++)
-            _options.PropagationSteps[i] = r.ReadInt32();
-        if (_useNativeMode) _options.ValidateNativePaperContract();
-
-        bool hasDiffusionCore = r.ReadBoolean();
-        if (hasDiffusionCore)
-        {
-            _diffusionCore ??= new UpscaleAVideoModel<T>(
-                conditioner: _conditioner, seed: Architecture.RandomSeed);
-            int chunkCount = r.ReadInt32();
-            var chunks = new Tensor<T>[chunkCount];
-            for (int i = 0; i < chunkCount; i++)
-                chunks[i] = SerializationHelper<T>.DeserializeTensor(r);
-            _diffusionCore.SetParameterChunks(chunks);
-        }
-        if (r.BaseStream.Position < r.BaseStream.Length)
-            _options.NegativePrompt = r.ReadString();
-        ScaleFactor = _options.ScaleFactor;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-        {
-            OnnxModel?.Dispose();
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-        }
-        // Native-mode layers (with their trained weights) are already reconstructed by
-        // the base deserializer before this override runs; re-initializing here would
-        // discard them and leave the model randomly initialized.
-    }
-
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            return new StableVideoSR<T>(Architecture, p, new StableVideoSROptions(_options));
-        var clonedCore = _usesInjectedDiffusionCore && _diffusionCore is not null
-            ? (UpscaleAVideoModel<T>)_diffusionCore.Clone()
-            : null;
-        return new StableVideoSR<T>(
-            Architecture,
-            new StableVideoSROptions(_options),
-            conditioner: _conditioner,
-            diffusionCore: clonedCore);
-    }
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> DeepCopy()
-    {
-        if (!_usesInjectedDiffusionCore || _diffusionCore is null)
-            return base.DeepCopy();
 
-        // An injected core carries architecture that StableVideoSROptions intentionally
-        // does not describe. Clone that core directly instead of serializing its chunks
-        // into a newly-created paper-default graph with a different per-tensor layout.
-        return new StableVideoSR<T>(
-            Architecture,
-            new StableVideoSROptions(_options),
-            conditioner: _conditioner,
-            diffusionCore: (UpscaleAVideoModel<T>)_diffusionCore.Clone());
-    }
 
-    /// <inheritdoc />
-    public override IFullModel<T, Tensor<T>, Tensor<T>> Clone() => DeepCopy();
     #endregion
 
     #region Disposal
diff --git a/src/Video/Enhancement/StreamDiffVSR.cs b/src/Video/Enhancement/StreamDiffVSR.cs
index b135e9d8ce..221d768865 100644
--- a/src/Video/Enhancement/StreamDiffVSR.cs
+++ b/src/Video/Enhancement/StreamDiffVSR.cs
@@ -54,7 +54,7 @@ namespace AiDotNet.Video.Enhancement;
     "https://arxiv.org/abs/2512.23709",
     Year = 2025,
     Authors = "Hau-Shiang Shiu, Chin-Yang Lin, Zhixiang Wang, Chi-Wei Hsiao, Po-Fan Yu, Yu-Chih Chen, Yu-Lun Liu")]
-public class StreamDiffVSR<T> : VideoSuperResolutionBase<T>
+public partial class StreamDiffVSR<T> : VideoSuperResolutionBase<T>
 {
     #region Fields
 
@@ -197,43 +197,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode);
-        w.Write(_options.ModelPath ?? string.Empty);
-        w.Write((int)_options.Variant);
-        w.Write(_options.NumFeatures);
-        w.Write(_options.NumDenoisingSteps);
-        w.Write(_options.NumResBlocks);
-        w.Write(_options.TemporalRadius);
-        w.Write(_options.ScaleFactor);
-        w.Write(_options.LatentDim);
-        w.Write(_options.DropoutRate);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean();
-        string mp = r.ReadString();
-        if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.Variant = (VideoModelVariant)r.ReadInt32();
-        _options.NumFeatures = r.ReadInt32();
-        _options.NumDenoisingSteps = r.ReadInt32();
-        _options.NumResBlocks = r.ReadInt32();
-        _options.TemporalRadius = r.ReadInt32();
-        _options.ScaleFactor = r.ReadInt32();
-        _options.LatentDim = r.ReadInt32();
-        _options.DropoutRate = r.ReadDouble();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            return new StreamDiffVSR<T>(Architecture, p, _options);
-        return new StreamDiffVSR<T>(Architecture, _options);
-    }
+
 
     #endregion
 
diff --git a/src/Video/Enhancement/TTVSR.cs b/src/Video/Enhancement/TTVSR.cs
index 1ed7b6c41f..50e4a60d3f 100644
--- a/src/Video/Enhancement/TTVSR.cs
+++ b/src/Video/Enhancement/TTVSR.cs
@@ -58,7 +58,7 @@ namespace AiDotNet.Video.Enhancement;
     "https://arxiv.org/abs/2204.04216",
     Year = 2022,
     Authors = "Chengxu Liu, Huan Yang, Jianlong Fu, Xueming Qian")]
-public class TTVSR<T> : VideoSuperResolutionBase<T>
+public partial class TTVSR<T> : VideoSuperResolutionBase<T>
 {
     #region Fields
 
@@ -189,41 +189,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode);
-        w.Write(_options.ModelPath ?? string.Empty);
-        w.Write((int)_options.Variant);
-        w.Write(_options.NumFeatures);
-        w.Write(_options.NumTransformerBlocks);
-        w.Write(_options.NumResBlocks);
-        w.Write(_options.ScaleFactor);
-        w.Write(_options.TrajectoryLength);
-        w.Write(_options.NumHeads);
-        w.Write(_options.NumScales);
-        w.Write(_options.DropoutRate);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean();
-        string mp = r.ReadString();
-        if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.Variant = (VideoModelVariant)r.ReadInt32();
-        _options.NumFeatures = r.ReadInt32();
-        _options.NumTransformerBlocks = r.ReadInt32();
-        _options.NumResBlocks = r.ReadInt32();
-        _options.ScaleFactor = r.ReadInt32();
-        _options.TrajectoryLength = r.ReadInt32();
-        _options.NumHeads = r.ReadInt32();
-        _options.NumScales = r.ReadInt32();
-        _options.DropoutRate = r.ReadDouble();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-        => new TTVSR<T>(Architecture, _options);
+
 
     #endregion
 
diff --git a/src/Video/Enhancement/Upscale4KAgent.cs b/src/Video/Enhancement/Upscale4KAgent.cs
index c574949889..cf6753d2b0 100644
--- a/src/Video/Enhancement/Upscale4KAgent.cs
+++ b/src/Video/Enhancement/Upscale4KAgent.cs
@@ -52,7 +52,7 @@ namespace AiDotNet.Video.Enhancement;
     "https://arxiv.org/abs/2312.06640",
     Year = 2024,
     Authors = "Shangchen Zhou, Peiqing Yang, Jianyi Wang, Yihang Luo, Chen Change Loy")]
-public class Upscale4KAgent<T> : VideoSuperResolutionBase<T>
+public partial class Upscale4KAgent<T> : VideoSuperResolutionBase<T>
 {
     #region Fields
 
@@ -188,56 +188,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode);
-        w.Write(_options.ModelPath ?? string.Empty);
-        w.Write((int)_options.Variant);
-        w.Write(_options.NumFeatures);
-        w.Write(_options.NumStages);
-        w.Write(_options.NumResBlocks);
-        w.Write(_options.ScaleFactor);
-        w.Write(_options.MaxAgentSteps);
-        w.Write(_options.QualityThreshold);
-        w.Write(_options.DropoutRate);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean();
-        string mp = r.ReadString();
-        if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.Variant = (VideoModelVariant)r.ReadInt32();
-        _options.NumFeatures = r.ReadInt32();
-        _options.NumStages = r.ReadInt32();
-        _options.NumResBlocks = r.ReadInt32();
-        _options.ScaleFactor = r.ReadInt32();
-        _options.MaxAgentSteps = r.ReadInt32();
-        _options.QualityThreshold = r.ReadDouble();
-        _options.DropoutRate = r.ReadDouble();
-        ScaleFactor = _options.ScaleFactor;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-        {
-            // Release any existing session before replacing it so repeated
-            // deserialize / clone round-trips don't leak native ONNX resources.
-            OnnxModel?.Dispose();
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-        }
-        // Native-mode layers (with their trained weights) are already reconstructed by
-        // the base deserializer before this override runs; re-initializing here would
-        // discard them and leave the model randomly initialized.
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            return new Upscale4KAgent<T>(Architecture, p, new Upscale4KAgentOptions(_options));
 
-        // A clone needs optimizer state bound to the clone's parameters. Reusing this
-        // instance's optimizer would couple the two models and bypass its constructor's
-        // option-derived learning rate.
-        return new Upscale4KAgent<T>(Architecture, new Upscale4KAgentOptions(_options));
-    }
 
     #endregion
 
diff --git a/src/Video/Enhancement/VideoGigaGAN.cs b/src/Video/Enhancement/VideoGigaGAN.cs
index 26f241320a..e2a5256939 100644
--- a/src/Video/Enhancement/VideoGigaGAN.cs
+++ b/src/Video/Enhancement/VideoGigaGAN.cs
@@ -62,7 +62,7 @@ namespace AiDotNet.Video.Enhancement;
     "https://arxiv.org/abs/2404.12388",
     Year = 2024,
     Authors = "Yiran Xu, Taesung Park, Richard Zhang, Yang Zhou, Eli Shechtman, Feng Liu, Jia-Bin Huang, Difan Liu")]
-public class VideoGigaGAN<T> : VideoSuperResolutionBase<T>
+public partial class VideoGigaGAN<T> : VideoSuperResolutionBase<T>
 {
     #region Fields
 
@@ -200,58 +200,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode);
-        w.Write(_options.ModelPath ?? string.Empty);
-        w.Write((int)_options.Variant);
-        w.Write(_options.NumFeatures);
-        w.Write(_options.NumResBlocks);
-        w.Write(_options.ScaleFactor);
-        w.Write(_options.NumStyleLayers);
-        w.Write(_options.PerceptualWeight);
-        w.Write(_options.GANWeight);
-        w.Write(_options.HFShuttleWeight);
-        w.Write(_options.DropoutRate);
-        w.Write(_options.FlowPyramidLevels);
-        w.Write(_options.LearningRate);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean();
-        string mp = r.ReadString();
-        if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.Variant = (VideoModelVariant)r.ReadInt32();
-        _options.NumFeatures = r.ReadInt32();
-        _options.NumResBlocks = r.ReadInt32();
-        _options.ScaleFactor = r.ReadInt32();
-        _options.NumStyleLayers = r.ReadInt32();
-        _options.PerceptualWeight = r.ReadDouble();
-        _options.GANWeight = r.ReadDouble();
-        _options.HFShuttleWeight = r.ReadDouble();
-        _options.DropoutRate = r.ReadDouble();
-        _options.FlowPyramidLevels = r.ReadInt32();
-        _options.LearningRate = r.ReadDouble();
-        ScaleFactor = _options.ScaleFactor;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-        {
-            // Release any existing session before replacing it so repeated
-            // deserialize / clone round-trips don't leak native ONNX resources.
-            OnnxModel?.Dispose();
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-        }
-        // Native-mode layers (with their trained weights) are already reconstructed by
-        // the base deserializer before this override runs; re-initializing here would
-        // discard them and leave the model randomly initialized.
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            return new VideoGigaGAN<T>(Architecture, p, new VideoGigaGANOptions(_options));
-        return new VideoGigaGAN<T>(Architecture, new VideoGigaGANOptions(_options));
-    }
+
 
     #endregion
 
diff --git a/src/Video/FrameInterpolation/ABME.cs b/src/Video/FrameInterpolation/ABME.cs
index b7520eadd9..15bcbb2903 100644
--- a/src/Video/FrameInterpolation/ABME.cs
+++ b/src/Video/FrameInterpolation/ABME.cs
@@ -57,7 +57,7 @@ namespace AiDotNet.Video.FrameInterpolation;
     "https://arxiv.org/abs/2108.06815",
     Year = 2021,
     Authors = "Junheum Park, Chul Lee, Chang-Su Kim")]
-public class ABME<T> : FrameInterpolationBase<T>
+public partial class ABME<T> : FrameInterpolationBase<T>
 {
     #region Fields
 
@@ -197,49 +197,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode);
-        w.Write(_options.ModelPath ?? string.Empty);
-        w.Write((int)_options.Variant);
-        w.Write(_options.NumFeatures);
-        w.Write(_options.NumResBlocks);
-        w.Write(_options.NumRefinementIters);
-        w.Write(_options.NumPyramidLevels);
-        w.Write(_options.AsymmetricMotion);
-        w.Write(_options.DropoutRate);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean();
-        string mp = r.ReadString();
-        if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.Variant = (VideoModelVariant)r.ReadInt32();
-        _options.NumFeatures = r.ReadInt32();
-        _options.NumResBlocks = r.ReadInt32();
-        _options.NumRefinementIters = r.ReadInt32();
-        _options.NumPyramidLevels = r.ReadInt32();
-        _options.AsymmetricMotion = r.ReadBoolean();
-        _options.DropoutRate = r.ReadDouble();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-        {
-            // Release any existing session before replacing it so repeated
-            // deserialize / clone round-trips don't leak native ONNX resources.
-            OnnxModel?.Dispose();
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-        }
-        // Native-mode layers (with their trained weights) are already reconstructed by
-        // the base deserializer before this override runs; re-initializing here would
-        // discard them and leave the model randomly initialized.
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            return new ABME<T>(Architecture, p, _options);
-        return new ABME<T>(Architecture, _options);
-    }
+
 
     #endregion
 
diff --git a/src/Video/FrameInterpolation/AMT.cs b/src/Video/FrameInterpolation/AMT.cs
index 433767d5ed..410635340d 100644
--- a/src/Video/FrameInterpolation/AMT.cs
+++ b/src/Video/FrameInterpolation/AMT.cs
@@ -56,7 +56,7 @@ namespace AiDotNet.Video.FrameInterpolation;
     "https://arxiv.org/abs/2304.09790",
     Year = 2023,
     Authors = "Zhen Li, Zuo-Liang Zhu, Ling-Hao Han, Qibin Hou, Chun-Le Guo, Ming-Ming Cheng")]
-public class AMT<T> : FrameInterpolationBase<T>
+public partial class AMT<T> : FrameInterpolationBase<T>
 {
     #region Fields
 
@@ -180,49 +180,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode);
-        w.Write(_options.ModelPath ?? string.Empty);
-        w.Write((int)_options.Variant);
-        w.Write(_options.NumFeatures);
-        w.Write(_options.NumFlowFields);
-        w.Write(_options.NumRefinementIters);
-        w.Write(_options.NumCorrelationLevels);
-        w.Write(_options.CorrelationRadius);
-        w.Write(_options.DropoutRate);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean();
-        string mp = r.ReadString();
-        if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.Variant = (VideoModelVariant)r.ReadInt32();
-        _options.NumFeatures = r.ReadInt32();
-        _options.NumFlowFields = r.ReadInt32();
-        _options.NumRefinementIters = r.ReadInt32();
-        _options.NumCorrelationLevels = r.ReadInt32();
-        _options.CorrelationRadius = r.ReadInt32();
-        _options.DropoutRate = r.ReadDouble();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-        {
-            // Release any existing session before replacing it so repeated
-            // deserialize / clone round-trips don't leak native ONNX resources.
-            OnnxModel?.Dispose();
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-        }
-        // Native-mode layers (with their trained weights) are already reconstructed by
-        // the base deserializer before this override runs; re-initializing here would
-        // discard them and leave the model randomly initialized.
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            return new AMT<T>(Architecture, p, _options);
-        return new AMT<T>(Architecture, _options);
-    }
+
 
     #endregion
 
diff --git a/src/Video/FrameInterpolation/BiMVFI.cs b/src/Video/FrameInterpolation/BiMVFI.cs
index caa030987d..4fa3b860f0 100644
--- a/src/Video/FrameInterpolation/BiMVFI.cs
+++ b/src/Video/FrameInterpolation/BiMVFI.cs
@@ -56,7 +56,7 @@ namespace AiDotNet.Video.FrameInterpolation;
     "https://arxiv.org/abs/2412.11365",
     Year = 2024,
     Authors = "Wonyong Seo, Jihyong Oh, Munchurl Kim")]
-public class BiMVFI<T> : FrameInterpolationBase<T>
+public partial class BiMVFI<T> : FrameInterpolationBase<T>
 {
     #region Fields
 
@@ -189,49 +189,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode);
-        w.Write(_options.ModelPath ?? string.Empty);
-        w.Write((int)_options.Variant);
-        w.Write(_options.NumFeatures);
-        w.Write(_options.NumResBlocks);
-        w.Write(_options.NumScales);
-        w.Write(_options.OcclusionAwareBlending);
-        w.Write(_options.ConfidenceThreshold);
-        w.Write(_options.DropoutRate);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean();
-        string mp = r.ReadString();
-        if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.Variant = (VideoModelVariant)r.ReadInt32();
-        _options.NumFeatures = r.ReadInt32();
-        _options.NumResBlocks = r.ReadInt32();
-        _options.NumScales = r.ReadInt32();
-        _options.OcclusionAwareBlending = r.ReadBoolean();
-        _options.ConfidenceThreshold = r.ReadDouble();
-        _options.DropoutRate = r.ReadDouble();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-        {
-            // Release any existing session before replacing it so repeated
-            // deserialize / clone round-trips don't leak native ONNX resources.
-            OnnxModel?.Dispose();
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-        }
-        // Native-mode layers (with their trained weights) are already reconstructed by
-        // the base deserializer before this override runs; re-initializing here would
-        // discard them and leave the model randomly initialized.
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            return new BiMVFI<T>(Architecture, p, _options);
-        return new BiMVFI<T>(Architecture, _options);
-    }
+
 
     #endregion
 
diff --git a/src/Video/FrameInterpolation/DynamiCrafter.cs b/src/Video/FrameInterpolation/DynamiCrafter.cs
index 7e421bf0af..74764a8f80 100644
--- a/src/Video/FrameInterpolation/DynamiCrafter.cs
+++ b/src/Video/FrameInterpolation/DynamiCrafter.cs
@@ -54,7 +54,7 @@ namespace AiDotNet.Video.FrameInterpolation;
     "https://arxiv.org/abs/2310.12190",
     Year = 2024,
     Authors = "Jinbo Xing, Menghan Xia, Yong Zhang, Haoxin Chen, Wangbo Yu, Hanyuan Liu, Gongye Liu, Xintao Wang, Ying Shan, Tien-Tsin Wong")]
-public class DynamiCrafter<T> : FrameInterpolationBase<T>
+public partial class DynamiCrafter<T> : FrameInterpolationBase<T>
 {
     #region Fields
 
@@ -187,47 +187,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode);
-        w.Write(_options.ModelPath ?? string.Empty);
-        w.Write((int)_options.Variant);
-        w.Write(_options.NumFeatures);
-        w.Write(_options.NumDiffusionSteps);
-        w.Write(_options.NumResBlocks);
-        w.Write(_options.NumHeads);
-        w.Write(_options.GuidanceScale);
-        w.Write(_options.DropoutRate);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean();
-        string mp = r.ReadString();
-        if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.Variant = (VideoModelVariant)r.ReadInt32();
-        _options.NumFeatures = r.ReadInt32();
-        _options.NumDiffusionSteps = r.ReadInt32();
-        _options.NumResBlocks = r.ReadInt32();
-        _options.NumHeads = r.ReadInt32();
-        _options.GuidanceScale = r.ReadDouble();
-        _options.DropoutRate = r.ReadDouble();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-        {
-            OnnxModel?.Dispose();
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-        }
-        // Native-mode layers (with their trained weights) are already reconstructed by
-        // the base deserializer before this override runs; re-initializing here would
-        // discard them and leave the model randomly initialized.
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            return new DynamiCrafter<T>(Architecture, p, _options);
-        return new DynamiCrafter<T>(Architecture, _options);
-    }
+
 
     #endregion
 
diff --git a/src/Video/FrameInterpolation/EMAVFI.cs b/src/Video/FrameInterpolation/EMAVFI.cs
index f0db684f58..a86c6b1f5b 100644
--- a/src/Video/FrameInterpolation/EMAVFI.cs
+++ b/src/Video/FrameInterpolation/EMAVFI.cs
@@ -57,7 +57,7 @@ namespace AiDotNet.Video.FrameInterpolation;
     "https://arxiv.org/abs/2303.00440",
     Year = 2023,
     Authors = "Guozhen Zhang, Yuhan Zhu, Haonan Wang, Youxin Chen, Gangshan Wu, Limin Wang")]
-public class EMAVFI<T> : FrameInterpolationBase<T>
+public partial class EMAVFI<T> : FrameInterpolationBase<T>
 {
     #region Fields
 
@@ -183,49 +183,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode);
-        w.Write(_options.ModelPath ?? string.Empty);
-        w.Write((int)_options.Variant);
-        w.Write(_options.NumFeatures);
-        w.Write(_options.NumSwinBlocks);
-        w.Write(_options.NumHeads);
-        w.Write(_options.WindowSize);
-        w.Write(_options.NumScales);
-        w.Write(_options.BidirectionalMotion);
-        w.Write(_options.DropoutRate);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean();
-        string mp = r.ReadString();
-        if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.Variant = (VideoModelVariant)r.ReadInt32();
-        _options.NumFeatures = r.ReadInt32();
-        _options.NumSwinBlocks = r.ReadInt32();
-        _options.NumHeads = r.ReadInt32();
-        _options.WindowSize = r.ReadInt32();
-        _options.NumScales = r.ReadInt32();
-        _options.BidirectionalMotion = r.ReadBoolean();
-        _options.DropoutRate = r.ReadDouble();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-        {
-            OnnxModel?.Dispose();
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-        }
-        // Native-mode layers (with their trained weights) are already reconstructed by
-        // the base deserializer before this override runs; re-initializing here would
-        // discard them and leave the model randomly initialized.
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            return new EMAVFI<T>(Architecture, p, _options);
-        return new EMAVFI<T>(Architecture, _options);
-    }
+
 
     #endregion
 
diff --git a/src/Video/FrameInterpolation/FILM.cs b/src/Video/FrameInterpolation/FILM.cs
index 67db038a6d..133cdac1d3 100644
--- a/src/Video/FrameInterpolation/FILM.cs
+++ b/src/Video/FrameInterpolation/FILM.cs
@@ -610,26 +610,9 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_height);
-        writer.Write(_width);
-        writer.Write(_channels);
-        writer.Write(_numScales);
-        writer.Write(_numFeatures);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _height = reader.ReadInt32();
-        _width = reader.ReadInt32();
-        _channels = reader.ReadInt32();
-        _numScales = reader.ReadInt32();
-        _numFeatures = reader.ReadInt32();
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() =>
-        new FILM<T>(Architecture, _numScales, _numFeatures);
+
 
     #endregion
 
diff --git a/src/Video/FrameInterpolation/FLAVR.cs b/src/Video/FrameInterpolation/FLAVR.cs
index 700a79553b..0b9f232c1d 100644
--- a/src/Video/FrameInterpolation/FLAVR.cs
+++ b/src/Video/FrameInterpolation/FLAVR.cs
@@ -56,7 +56,7 @@ namespace AiDotNet.Video.FrameInterpolation;
     "https://arxiv.org/abs/2012.08512",
     Year = 2021,
     Authors = "Tarun Kalluri, Deepak Pathak, Manmohan Chandraker, Du Tran")]
-public class FLAVR<T> : FrameInterpolationBase<T>
+public partial class FLAVR<T> : FrameInterpolationBase<T>
 {
     #region Fields
 
@@ -180,41 +180,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode);
-        w.Write(_options.ModelPath ?? string.Empty);
-        w.Write((int)_options.Variant);
-        w.Write(_options.NumFeatures);
-        w.Write(_options.NumResBlocks);
-        w.Write(_options.NumLevels);
-        w.Write(_options.NumInputFrames);
-        w.Write(_options.TemporalKernelSize);
-        w.Write(_options.DropoutRate);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean();
-        string mp = r.ReadString();
-        if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.Variant = (VideoModelVariant)r.ReadInt32();
-        _options.NumFeatures = r.ReadInt32();
-        _options.NumResBlocks = r.ReadInt32();
-        _options.NumLevels = r.ReadInt32();
-        _options.NumInputFrames = r.ReadInt32();
-        _options.TemporalKernelSize = r.ReadInt32();
-        _options.DropoutRate = r.ReadDouble();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            return new FLAVR<T>(Architecture, p, _options);
-        return new FLAVR<T>(Architecture, _options);
-    }
+
 
     #endregion
 
diff --git a/src/Video/FrameInterpolation/Figan.cs b/src/Video/FrameInterpolation/Figan.cs
index 39fe2e23fb..45b0ec6898 100644
--- a/src/Video/FrameInterpolation/Figan.cs
+++ b/src/Video/FrameInterpolation/Figan.cs
@@ -331,49 +331,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode);
-        w.Write(_options.ModelPath ?? string.Empty);
-        w.Write(_options.NumScales);
-        w.Write(_options.NumFeatures);
-        w.Write(_options.LayersPerModule);
-        w.Write(_options.KernelSize);
-        w.Write(_options.DiscriminatorFilters);
-        w.Write(_options.DiscriminatorBlocks);
-        w.Write(_options.LeakyReluSlope);
-        w.Write(_options.LearningRate);
-        w.Write(_options.CropSize);
-        w.Write(_options.DropoutRate);
-    }
 
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean();
-        string mp = r.ReadString();
-        if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.NumScales = r.ReadInt32();
-        _options.NumFeatures = r.ReadInt32();
-        _options.LayersPerModule = r.ReadInt32();
-        _options.KernelSize = r.ReadInt32();
-        _options.DiscriminatorFilters = r.ReadInt32();
-        _options.DiscriminatorBlocks = r.ReadInt32();
-        _options.LeakyReluSlope = r.ReadDouble();
-        _options.LearningRate = r.ReadDouble();
-        _options.CropSize = r.ReadInt32();
-        _options.DropoutRate = r.ReadDouble();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
     /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (IsOnnxMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new Figan<T>(Architecture, mp, _options);
-        return new Figan<T>(Architecture, _options);
-    }
+
 
     #endregion
 
diff --git a/src/Video/FrameInterpolation/GIMMVFI.cs b/src/Video/FrameInterpolation/GIMMVFI.cs
index 5254ea3f81..cb9b3371d0 100644
--- a/src/Video/FrameInterpolation/GIMMVFI.cs
+++ b/src/Video/FrameInterpolation/GIMMVFI.cs
@@ -57,7 +57,7 @@ namespace AiDotNet.Video.FrameInterpolation;
     "https://arxiv.org/abs/2407.08680",
     Year = 2024,
     Authors = "Zujin Guo, Wei Li, Chen Change Loy")]
-public class GIMMVFI<T> : FrameInterpolationBase<T>
+public partial class GIMMVFI<T> : FrameInterpolationBase<T>
 {
     #region Fields
 
@@ -186,49 +186,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode);
-        w.Write(_options.ModelPath ?? string.Empty);
-        w.Write((int)_options.Variant);
-        w.Write(_options.NumFeatures);
-        w.Write(_options.NumEncoderBlocks);
-        w.Write(_options.ImplicitDim);
-        w.Write(_options.NumImplicitLayers);
-        w.Write(_options.NumFrequencies);
-        w.Write(_options.DropoutRate);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean();
-        string mp = r.ReadString();
-        if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.Variant = (VideoModelVariant)r.ReadInt32();
-        _options.NumFeatures = r.ReadInt32();
-        _options.NumEncoderBlocks = r.ReadInt32();
-        _options.ImplicitDim = r.ReadInt32();
-        _options.NumImplicitLayers = r.ReadInt32();
-        _options.NumFrequencies = r.ReadInt32();
-        _options.DropoutRate = r.ReadDouble();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-        {
-            // Release any existing session before replacing it so repeated
-            // deserialize / clone round-trips don't leak native ONNX resources.
-            OnnxModel?.Dispose();
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-        }
-        // Native-mode layers (with their trained weights) are already reconstructed by
-        // the base deserializer before this override runs; re-initializing here would
-        // discard them and leave the model randomly initialized.
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            return new GIMMVFI<T>(Architecture, p, _options);
-        return new GIMMVFI<T>(Architecture, _options);
-    }
+
 
     #endregion
 
diff --git a/src/Video/FrameInterpolation/IFRNet.cs b/src/Video/FrameInterpolation/IFRNet.cs
index ca625b02ef..518534ad8a 100644
--- a/src/Video/FrameInterpolation/IFRNet.cs
+++ b/src/Video/FrameInterpolation/IFRNet.cs
@@ -57,7 +57,7 @@ namespace AiDotNet.Video.FrameInterpolation;
     "https://arxiv.org/abs/2205.14620",
     Year = 2022,
     Authors = "Lingtong Kong, Boyuan Jiang, Donghao Luo, Wenqing Chu, Xiaoming Huang, Ying Tai, Chengjie Wang, Jie Yang")]
-public class IFRNet<T> : FrameInterpolationBase<T>
+public partial class IFRNet<T> : FrameInterpolationBase<T>
 {
     #region Fields
 
@@ -182,47 +182,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode);
-        w.Write(_options.ModelPath ?? string.Empty);
-        w.Write((int)_options.Variant);
-        w.Write(_options.NumFeatures);
-        w.Write(_options.NumRefineBlocks);
-        w.Write(_options.NumPyramidLevels);
-        w.Write(_options.UseTaskOrientedFlow);
-        w.Write(_options.DropoutRate);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean();
-        string mp = r.ReadString();
-        if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.Variant = (VideoModelVariant)r.ReadInt32();
-        _options.NumFeatures = r.ReadInt32();
-        _options.NumRefineBlocks = r.ReadInt32();
-        _options.NumPyramidLevels = r.ReadInt32();
-        _options.UseTaskOrientedFlow = r.ReadBoolean();
-        _options.DropoutRate = r.ReadDouble();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-        {
-            // Release any existing session before replacing it so repeated
-            // deserialize / clone round-trips don't leak native ONNX resources.
-            OnnxModel?.Dispose();
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-        }
-        // Native-mode layers (with their trained weights) are already reconstructed by
-        // the base deserializer before this override runs; re-initializing here would
-        // discard them and leave the model randomly initialized.
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            return new IFRNet<T>(Architecture, p, _options);
-        return new IFRNet<T>(Architecture, _options);
-    }
+
 
     #endregion
 
diff --git a/src/Video/FrameInterpolation/IQVFI.cs b/src/Video/FrameInterpolation/IQVFI.cs
index ef76a9cccc..36f7ecfdd1 100644
--- a/src/Video/FrameInterpolation/IQVFI.cs
+++ b/src/Video/FrameInterpolation/IQVFI.cs
@@ -62,7 +62,7 @@ namespace AiDotNet.Video.FrameInterpolation;
     "https://openaccess.thecvf.com/content/CVPR2024/papers/Hu_IQ-VFI_Implicit_Quadratic_Motion_Estimation_for_Video_Frame_Interpolation_CVPR_2024_paper.pdf",
     Year = 2024,
     Authors = "Mengshun Hu, Kui Jiang, Zhihang Zhong, Zheng Wang, Yinqiang Zheng")]
-public class IQVFI<T> : FrameInterpolationBase<T>
+public partial class IQVFI<T> : FrameInterpolationBase<T>
 {
     /// <summary>
     /// Gets the implicit quadratic motion model, which modulates linear intermediate flows into
@@ -204,37 +204,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode);
-        w.Write(_options.ModelPath ?? string.Empty);
-        w.Write((int)_options.Variant);
-        w.Write(_options.NumFeatures);
-        w.Write(_options.NumQualityBlocks);
-        w.Write(_options.NumFlowRefinementIters);
-        w.Write(_options.NumPyramidLevels);
-        w.Write(_options.QualityThreshold);
-        w.Write(_options.DropoutRate);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean();
-        string mp = r.ReadString();
-        if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.Variant = (VideoModelVariant)r.ReadInt32();
-        _options.NumFeatures = r.ReadInt32();
-        _options.NumQualityBlocks = r.ReadInt32();
-        _options.NumFlowRefinementIters = r.ReadInt32();
-        _options.NumPyramidLevels = r.ReadInt32();
-        _options.QualityThreshold = r.ReadDouble();
-        _options.DropoutRate = r.ReadDouble();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-        => new IQVFI<T>(Architecture, _options);
+
 
     #endregion
 
diff --git a/src/Video/FrameInterpolation/InterpAnyClearer.cs b/src/Video/FrameInterpolation/InterpAnyClearer.cs
index 806aed54f3..e4358c8b2e 100644
--- a/src/Video/FrameInterpolation/InterpAnyClearer.cs
+++ b/src/Video/FrameInterpolation/InterpAnyClearer.cs
@@ -56,7 +56,7 @@ namespace AiDotNet.Video.FrameInterpolation;
     "https://arxiv.org/abs/2311.08007",
     Year = 2024,
     Authors = "Zhihang Zhong, Gurunandan Krishnan, Xiao Sun, Yu Qiao, Sizhuo Ma, Jian Wang")]
-public class InterpAnyClearer<T> : FrameInterpolationBase<T>
+public partial class InterpAnyClearer<T> : FrameInterpolationBase<T>
 {
     #region Fields
 
@@ -180,37 +180,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode);
-        w.Write(_options.ModelPath ?? string.Empty);
-        w.Write((int)_options.Variant);
-        w.Write(_options.NumFeatures);
-        w.Write(_options.NumVelocityBlocks);
-        w.Write(_options.NumVelocityBins);
-        w.Write(_options.NumPyramidLevels);
-        w.Write(_options.UseVelocityGuidedWarping);
-        w.Write(_options.DropoutRate);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean();
-        string mp = r.ReadString();
-        if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.Variant = (VideoModelVariant)r.ReadInt32();
-        _options.NumFeatures = r.ReadInt32();
-        _options.NumVelocityBlocks = r.ReadInt32();
-        _options.NumVelocityBins = r.ReadInt32();
-        _options.NumPyramidLevels = r.ReadInt32();
-        _options.UseVelocityGuidedWarping = r.ReadBoolean();
-        _options.DropoutRate = r.ReadDouble();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-        => new InterpAnyClearer<T>(Architecture, _options);
+
 
     #endregion
 
diff --git a/src/Video/FrameInterpolation/M2M.cs b/src/Video/FrameInterpolation/M2M.cs
index e36e22d2d9..9cdbb269b2 100644
--- a/src/Video/FrameInterpolation/M2M.cs
+++ b/src/Video/FrameInterpolation/M2M.cs
@@ -57,7 +57,7 @@ namespace AiDotNet.Video.FrameInterpolation;
     "https://arxiv.org/abs/2204.03513",
     Year = 2022,
     Authors = "Ping Hu, Simon Niklaus, Stan Sclaroff, Kate Saenko")]
-public class M2M<T> : FrameInterpolationBase<T>
+public partial class M2M<T> : FrameInterpolationBase<T>
 {
     #region Fields
 
@@ -181,41 +181,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode);
-        w.Write(_options.ModelPath ?? string.Empty);
-        w.Write((int)_options.Variant);
-        w.Write(_options.NumFeatures);
-        w.Write(_options.NumFlowHypotheses);
-        w.Write(_options.NumPyramidLevels);
-        w.Write(_options.NumRefineBlocks);
-        w.Write(_options.SplattingRadius);
-        w.Write(_options.DropoutRate);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean();
-        string mp = r.ReadString();
-        if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.Variant = (VideoModelVariant)r.ReadInt32();
-        _options.NumFeatures = r.ReadInt32();
-        _options.NumFlowHypotheses = r.ReadInt32();
-        _options.NumPyramidLevels = r.ReadInt32();
-        _options.NumRefineBlocks = r.ReadInt32();
-        _options.SplattingRadius = r.ReadInt32();
-        _options.DropoutRate = r.ReadDouble();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            return new M2M<T>(Architecture, p, _options);
-        return new M2M<T>(Architecture, _options);
-    }
+
 
     #endregion
 
diff --git a/src/Video/FrameInterpolation/MoG.cs b/src/Video/FrameInterpolation/MoG.cs
index b2551b007b..1857d4aa3b 100644
--- a/src/Video/FrameInterpolation/MoG.cs
+++ b/src/Video/FrameInterpolation/MoG.cs
@@ -58,7 +58,7 @@ namespace AiDotNet.Video.FrameInterpolation;
     "https://arxiv.org/abs/2501.03699",
     Year = 2025,
     Authors = "Jianhui Wang, Yongqiang Zhang, Ying Tai")]
-public class MoG<T> : FrameInterpolationBase<T>
+public partial class MoG<T> : FrameInterpolationBase<T>
 {
     #region Fields
 
@@ -215,44 +215,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode);
-        w.Write(_options.ModelPath ?? string.Empty);
-        w.Write((int)_options.Variant);
-        w.Write(_options.NumFeatures);
-        w.Write(_options.NumDiffusionSteps);
-        w.Write(_options.NumFlowScales);
-        w.Write(_options.NumResBlocks);
-        w.Write(_options.GuidanceScale);
-        w.Write(_options.DropoutRate);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean();
-        string mp = r.ReadString();
-        if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.Variant = (VideoModelVariant)r.ReadInt32();
-        _options.NumFeatures = r.ReadInt32();
-        _options.NumDiffusionSteps = r.ReadInt32();
-        _options.NumFlowScales = r.ReadInt32();
-        _options.NumResBlocks = r.ReadInt32();
-        _options.GuidanceScale = r.ReadDouble();
-        _options.DropoutRate = r.ReadDouble();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-        // Native-mode layers (with their trained weights) are already reconstructed by
-        // the base deserializer before this override runs; re-initializing here would
-        // discard them and leave the model randomly initialized.
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            return new MoG<T>(Architecture, p, _options);
-        return new MoG<T>(Architecture, _options);
-    }
+
 
     #endregion
 
diff --git a/src/Video/FrameInterpolation/MoMo.cs b/src/Video/FrameInterpolation/MoMo.cs
index 3a791d770c..cabbcc1f24 100644
--- a/src/Video/FrameInterpolation/MoMo.cs
+++ b/src/Video/FrameInterpolation/MoMo.cs
@@ -55,7 +55,7 @@ namespace AiDotNet.Video.FrameInterpolation;
     "https://arxiv.org/abs/2406.17256",
     Year = 2024,
     Authors = "Jaihyun Lew, Jooyoung Choi, Chaehun Shin, Dahuin Jung, Sungroh Yoon")]
-public class MoMo<T> : FrameInterpolationBase<T>
+public partial class MoMo<T> : FrameInterpolationBase<T>
 {
     #region Fields
 
@@ -179,44 +179,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode);
-        w.Write(_options.ModelPath ?? string.Empty);
-        w.Write((int)_options.Variant);
-        w.Write(_options.NumFeatures);
-        w.Write(_options.NumDiffusionSteps);
-        w.Write(_options.NumResBlocks);
-        w.Write(_options.NumHeads);
-        w.Write(_options.MomentumCoefficient);
-        w.Write(_options.DropoutRate);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean();
-        string mp = r.ReadString();
-        if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.Variant = (VideoModelVariant)r.ReadInt32();
-        _options.NumFeatures = r.ReadInt32();
-        _options.NumDiffusionSteps = r.ReadInt32();
-        _options.NumResBlocks = r.ReadInt32();
-        _options.NumHeads = r.ReadInt32();
-        _options.MomentumCoefficient = r.ReadDouble();
-        _options.DropoutRate = r.ReadDouble();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-        // Native-mode layers (with their trained weights) are already reconstructed by
-        // the base deserializer before this override runs; re-initializing here would
-        // discard them and leave the model randomly initialized.
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            return new MoMo<T>(Architecture, p, _options);
-        return new MoMo<T>(Architecture, _options);
-    }
+
 
     #endregion
 
diff --git a/src/Video/FrameInterpolation/PerVFI.cs b/src/Video/FrameInterpolation/PerVFI.cs
index ccf11f8522..66957c5943 100644
--- a/src/Video/FrameInterpolation/PerVFI.cs
+++ b/src/Video/FrameInterpolation/PerVFI.cs
@@ -51,7 +51,7 @@ namespace AiDotNet.Video.FrameInterpolation;
     "https://arxiv.org/abs/2404.06692",
     Year = 2024,
     Authors = "Guangyang Wu, Xin Tao, Changlin Li, Wenyi Wang, Xiaohong Liu, Qingqing Zheng")]
-public class PerVFI<T> : FrameInterpolationBase<T>
+public partial class PerVFI<T> : FrameInterpolationBase<T>
 {
     #region Fields
 
@@ -174,45 +174,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode);
-        w.Write(_options.ModelPath ?? string.Empty);
-        w.Write((int)_options.Variant);
-        w.Write(_options.NumFeatures);
-        w.Write(_options.NumRefinementIters);
-        w.Write(_options.NumFlowScales);
-        w.Write(_options.NumResBlocks);
-        w.Write(_options.PerceptualWeight);
-        w.Write(_options.DropoutRate);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean();
-        string mp = r.ReadString();
-        if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.Variant = (VideoModelVariant)r.ReadInt32();
-        _options.NumFeatures = r.ReadInt32();
-        _options.NumRefinementIters = r.ReadInt32();
-        _options.NumFlowScales = r.ReadInt32();
-        _options.NumResBlocks = r.ReadInt32();
-        _options.PerceptualWeight = r.ReadDouble();
-        _options.DropoutRate = r.ReadDouble();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-        // Do NOT call InitializeLayers() here (matches the working AMT sibling): the layers are already
-        // built by CreateNewInstance -> ctor -> InitializeLayers before the base loads parameters, and
-        // InitializeLayers does not ClearLayers first, so a second call double-adds fresh untrained
-        // layers and corrupts the loaded weights (Clone_ShouldProduceIdenticalOutput divergence).
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            return new PerVFI<T>(Architecture, p, _options);
-        return new PerVFI<T>(Architecture, _options);
-    }
+
 
     #endregion
 
diff --git a/src/Video/FrameInterpolation/RIFE.cs b/src/Video/FrameInterpolation/RIFE.cs
index f4a36c7830..ab6b822627 100644
--- a/src/Video/FrameInterpolation/RIFE.cs
+++ b/src/Video/FrameInterpolation/RIFE.cs
@@ -949,40 +949,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_height);
-        writer.Write(_width);
-        writer.Write(_channels);
-        writer.Write(_numFeatures);
-        writer.Write(_numFlowBlocks);
-    }
 
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _height = reader.ReadInt32();
-        _width = reader.ReadInt32();
-        _channels = reader.ReadInt32();
-        _numFeatures = reader.ReadInt32();
-        _numFlowBlocks = reader.ReadInt32();
-
-        // Deserialization rebuilt the canonical Layers list with the loaded
-        // weights; re-point the sub-list references at those layers (otherwise
-        // Forward keeps running the constructor's random-init layers).
-        int expectedCount = 3 + 3 + 2 + _numFlowBlocks + 2; // encoder+flowDec+ctx+blocks+fusion+output
-        if (Layers.Count >= expectedCount)
-        {
-            ExtractLayerReferences();
-        }
-    }
 
     /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new RIFE<T>(
-            Architecture, _numFeatures, _numFlowBlocks, new RIFEOptions(_options));
-    }
+
 
     #endregion
 
diff --git a/src/Video/FrameInterpolation/STMFNet.cs b/src/Video/FrameInterpolation/STMFNet.cs
index 63cc8a593a..c8d2b12d9e 100644
--- a/src/Video/FrameInterpolation/STMFNet.cs
+++ b/src/Video/FrameInterpolation/STMFNet.cs
@@ -52,7 +52,7 @@ namespace AiDotNet.Video.FrameInterpolation;
     "https://arxiv.org/abs/2111.15483",
     Year = 2022,
     Authors = "Duolikun Danier, Fan Zhang, David Bull")]
-public class STMFNet<T> : FrameInterpolationBase<T>
+public partial class STMFNet<T> : FrameInterpolationBase<T>
 {
     #region Fields
 
@@ -179,44 +179,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode);
-        w.Write(_options.ModelPath ?? string.Empty);
-        w.Write((int)_options.Variant);
-        w.Write(_options.NumFeatures);
-        w.Write(_options.NumFlowHypotheses);
-        w.Write(_options.NumFusionBlocks);
-        w.Write(_options.NumRefineBlocks);
-        w.Write(_options.NumPyramidLevels);
-        w.Write(_options.DropoutRate);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean();
-        string mp = r.ReadString();
-        if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.Variant = (VideoModelVariant)r.ReadInt32();
-        _options.NumFeatures = r.ReadInt32();
-        _options.NumFlowHypotheses = r.ReadInt32();
-        _options.NumFusionBlocks = r.ReadInt32();
-        _options.NumRefineBlocks = r.ReadInt32();
-        _options.NumPyramidLevels = r.ReadInt32();
-        _options.DropoutRate = r.ReadDouble();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-        // Native-mode layers (with their trained weights) are already reconstructed by
-        // the base deserializer before this override runs; re-initializing here would
-        // discard them and leave the model randomly initialized.
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            return new STMFNet<T>(Architecture, p, _options);
-        return new STMFNet<T>(Architecture, _options);
-    }
+
 
     #endregion
 
diff --git a/src/Video/FrameInterpolation/SoftSplat.cs b/src/Video/FrameInterpolation/SoftSplat.cs
index d3ae815a0a..b6df3c1168 100644
--- a/src/Video/FrameInterpolation/SoftSplat.cs
+++ b/src/Video/FrameInterpolation/SoftSplat.cs
@@ -53,7 +53,7 @@ namespace AiDotNet.Video.FrameInterpolation;
     "https://arxiv.org/abs/2003.05534",
     Year = 2020,
     Authors = "Simon Niklaus, Feng Liu")]
-public class SoftSplat<T> : FrameInterpolationBase<T>
+public partial class SoftSplat<T> : FrameInterpolationBase<T>
 {
     #region Fields
 
@@ -178,41 +178,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode);
-        w.Write(_options.ModelPath ?? string.Empty);
-        w.Write((int)_options.Variant);
-        w.Write(_options.NumFeatures);
-        w.Write(_options.NumGridNetLevels);
-        w.Write(_options.NumResBlocksPerRow);
-        w.Write(_options.NumFeatureBlocks);
-        w.Write(_options.UseImportanceMetric);
-        w.Write(_options.DropoutRate);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean();
-        string mp = r.ReadString();
-        if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.Variant = (VideoModelVariant)r.ReadInt32();
-        _options.NumFeatures = r.ReadInt32();
-        _options.NumGridNetLevels = r.ReadInt32();
-        _options.NumResBlocksPerRow = r.ReadInt32();
-        _options.NumFeatureBlocks = r.ReadInt32();
-        _options.UseImportanceMetric = r.ReadBoolean();
-        _options.DropoutRate = r.ReadDouble();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (IsOnnxMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new SoftSplat<T>(Architecture, mp, _options);
-        return new SoftSplat<T>(Architecture, _options);
-    }
+
 
     #endregion
 
diff --git a/src/Video/FrameInterpolation/SwinVFI.cs b/src/Video/FrameInterpolation/SwinVFI.cs
index 75933bb368..09c85ab8a4 100644
--- a/src/Video/FrameInterpolation/SwinVFI.cs
+++ b/src/Video/FrameInterpolation/SwinVFI.cs
@@ -52,7 +52,7 @@ namespace AiDotNet.Video.FrameInterpolation;
     "https://arxiv.org/abs/2205.07230",
     Year = 2022,
     Authors = "Liying Lu, Ruizheng Wu, Huaijia Lin, Jiangbo Lu, Jiaya Jia")]
-public class SwinVFI<T> : FrameInterpolationBase<T>
+public partial class SwinVFI<T> : FrameInterpolationBase<T>
 {
     #region Fields
 
@@ -177,41 +177,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode);
-        w.Write(_options.ModelPath ?? string.Empty);
-        w.Write((int)_options.Variant);
-        w.Write(_options.NumFeatures);
-        w.Write(_options.NumSwinBlocks);
-        w.Write(_options.NumHeads);
-        w.Write(_options.WindowSize);
-        w.Write(_options.NumStages);
-        w.Write(_options.DropoutRate);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean();
-        string mp = r.ReadString();
-        if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.Variant = (VideoModelVariant)r.ReadInt32();
-        _options.NumFeatures = r.ReadInt32();
-        _options.NumSwinBlocks = r.ReadInt32();
-        _options.NumHeads = r.ReadInt32();
-        _options.WindowSize = r.ReadInt32();
-        _options.NumStages = r.ReadInt32();
-        _options.DropoutRate = r.ReadDouble();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            return new SwinVFI<T>(Architecture, p, _options);
-        return new SwinVFI<T>(Architecture, _options);
-    }
+
 
     #endregion
 
diff --git a/src/Video/FrameInterpolation/TLBVFI.cs b/src/Video/FrameInterpolation/TLBVFI.cs
index 1ada13bc26..c795294424 100644
--- a/src/Video/FrameInterpolation/TLBVFI.cs
+++ b/src/Video/FrameInterpolation/TLBVFI.cs
@@ -53,7 +53,7 @@ namespace AiDotNet.Video.FrameInterpolation;
     "https://arxiv.org/abs/2507.04984",
     Year = 2025,
     Authors = "Zonglin Lyu, Chen Chen")]
-public class TLBVFI<T> : FrameInterpolationBase<T>
+public partial class TLBVFI<T> : FrameInterpolationBase<T>
 {
     #region Fields
 
@@ -176,44 +176,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode);
-        w.Write(_options.ModelPath ?? string.Empty);
-        w.Write((int)_options.Variant);
-        w.Write(_options.NumFeatures);
-        w.Write(_options.TokenSize);
-        w.Write(_options.NumMatchingBlocks);
-        w.Write(_options.NumHeads);
-        w.Write(_options.NumSynthesisBlocks);
-        w.Write(_options.DropoutRate);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean();
-        string mp = r.ReadString();
-        if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.Variant = (VideoModelVariant)r.ReadInt32();
-        _options.NumFeatures = r.ReadInt32();
-        _options.TokenSize = r.ReadInt32();
-        _options.NumMatchingBlocks = r.ReadInt32();
-        _options.NumHeads = r.ReadInt32();
-        _options.NumSynthesisBlocks = r.ReadInt32();
-        _options.DropoutRate = r.ReadDouble();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-        // Native-mode layers (with their trained weights) are already reconstructed by
-        // the base deserializer before this override runs; re-initializing here would
-        // discard them and leave the model randomly initialized.
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            return new TLBVFI<T>(Architecture, p, _options);
-        return new TLBVFI<T>(Architecture, _options);
-    }
+
 
     #endregion
 
diff --git a/src/Video/FrameInterpolation/ToonCrafter.cs b/src/Video/FrameInterpolation/ToonCrafter.cs
index 712606683b..6e9cb19ff5 100644
--- a/src/Video/FrameInterpolation/ToonCrafter.cs
+++ b/src/Video/FrameInterpolation/ToonCrafter.cs
@@ -63,7 +63,7 @@ namespace AiDotNet.Video.FrameInterpolation;
     "https://arxiv.org/abs/2405.17933",
     Year = 2024,
     Authors = "Jinbo Xing, Hanyuan Liu, Menghan Xia, Yong Zhang, Xintao Wang, Ying Shan, Tien-Tsin Wong")]
-public class ToonCrafter<T> : FrameInterpolationBase<T>
+public partial class ToonCrafter<T> : FrameInterpolationBase<T>
 {
     private readonly ToonCrafterOptions _options;
 
@@ -194,51 +194,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write((int)_options.Variant);
-        writer.Write(_options.NumFeatures);
-        writer.Write(_options.NumDiffusionSteps);
-        writer.Write(_options.NumResBlocks);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.GuidanceScale);
-        writer.Write(_options.LearningRate);
-        writer.Write(_options.DropoutRate);
-    }
 
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.Variant = (VideoModelVariant)reader.ReadInt32();
-        _options.NumFeatures = reader.ReadInt32();
-        _options.NumDiffusionSteps = reader.ReadInt32();
-        _options.NumResBlocks = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.GuidanceScale = reader.ReadDouble();
-        _options.LearningRate = reader.ReadDouble();
-        _options.DropoutRate = reader.ReadDouble();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-        {
-            OnnxModel?.Dispose();
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-        }
-        // Native-mode layers (with their trained weights) are already reconstructed by
-        // the base deserializer before this override runs; re-initializing here would
-        // discard them and leave the model randomly initialized.
-    }
 
     /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            return new ToonCrafter<T>(Architecture, p, _options);
-        return new ToonCrafter<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/Video/FrameInterpolation/UPRNet.cs b/src/Video/FrameInterpolation/UPRNet.cs
index bfd0c1c3c7..ad7530d56f 100644
--- a/src/Video/FrameInterpolation/UPRNet.cs
+++ b/src/Video/FrameInterpolation/UPRNet.cs
@@ -520,32 +520,10 @@ public override void Train(Tensor<T> input, Tensor<T> expected)
     };
 
     /// <inheritdoc />
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write((int)_options.Variant);
-        writer.Write(_options.NumPyramidLevels);
-        writer.Write(_options.NumLevelsSkipped);
-        writer.Write(_options.LearningRate);
-        writer.Write(_options.DropoutRate);
-    }
 
-    /// <inheritdoc />
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _options.Variant = (VideoModelVariant)reader.ReadInt32();
-        _options.NumPyramidLevels = reader.ReadInt32();
-        _options.NumLevelsSkipped = reader.ReadInt32();
-        _options.LearningRate = reader.ReadDouble();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.Validate();
-        EnsurePaperBindings();
-    }
 
     /// <inheritdoc />
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() =>
-        !_useNativeMode && !string.IsNullOrWhiteSpace(_options.ModelPath)
-            ? new UPRNet<T>(Architecture, _options.ModelPath!, new UPRNetOptions(_options))
-            : new UPRNet<T>(Architecture, new UPRNetOptions(_options));
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/Video/FrameInterpolation/VFIMamba.cs b/src/Video/FrameInterpolation/VFIMamba.cs
index d0f93a7ed3..ad993e5582 100644
--- a/src/Video/FrameInterpolation/VFIMamba.cs
+++ b/src/Video/FrameInterpolation/VFIMamba.cs
@@ -64,7 +64,7 @@ namespace AiDotNet.Video.FrameInterpolation;
     "https://arxiv.org/abs/2407.02315",
     Year = 2024,
     Authors = "Guozhen Zhang, Chunxu Liu, Yuhan Zhu, Limin Wang")]
-public class VFIMamba<T> : FrameInterpolationBase<T>
+public partial class VFIMamba<T> : FrameInterpolationBase<T>
 {
     private readonly VFIMambaOptions _options;
 
@@ -197,53 +197,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write((int)_options.Variant);
-        writer.Write(_options.NumFeatures);
-        writer.Write(_options.NumMambaBlocks);
-        writer.Write(_options.StateDim);
-        writer.Write(_options.ExpansionFactor);
-        writer.Write(_options.NumStages);
-        writer.Write(_options.LearningRate);
-        writer.Write(_options.DropoutRate);
-    }
 
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.Variant = (VideoModelVariant)reader.ReadInt32();
-        _options.NumFeatures = reader.ReadInt32();
-        _options.NumMambaBlocks = reader.ReadInt32();
-        _options.StateDim = reader.ReadInt32();
-        _options.ExpansionFactor = reader.ReadInt32();
-        _options.NumStages = reader.ReadInt32();
-        _options.LearningRate = reader.ReadDouble();
-        _options.DropoutRate = reader.ReadDouble();
-        // Native-mode layers (with their trained weights) are already reconstructed by
-        // the base DeserializeInternalUnchecked before this override runs, so do NOT
-        // clear + re-initialize them here — that would discard the deserialized weights
-        // and leave the model randomly initialized (breaking clone/load parity). Only an
-        // ONNX session needs rebuilding from its path.
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-        {
-            OnnxModel?.Dispose();
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-        }
-    }
 
     /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            return new VFIMamba<T>(Architecture, p, _options);
-        return new VFIMamba<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/Video/FrameInterpolation/VFIT.cs b/src/Video/FrameInterpolation/VFIT.cs
index 647912e854..4adc0d5bbb 100644
--- a/src/Video/FrameInterpolation/VFIT.cs
+++ b/src/Video/FrameInterpolation/VFIT.cs
@@ -62,7 +62,7 @@ namespace AiDotNet.Video.FrameInterpolation;
     "https://arxiv.org/abs/2111.13817",
     Year = 2022,
     Authors = "Zhihao Shi, Xiangyu Xu, Xiaohong Liu, Jun Chen, Ming-Hsuan Yang")]
-public class VFIT<T> : FrameInterpolationBase<T>
+public partial class VFIT<T> : FrameInterpolationBase<T>
 {
     private readonly VFITOptions _options;
 
@@ -194,36 +194,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write((int)_options.Variant);
-        writer.Write(_options.NumFeatures);
-        writer.Write(_options.NumInputFrames);
-        writer.Write(_options.NumTemporalLayers);
-        writer.Write(_options.NumSpatialLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.LearningRate);
-        writer.Write(_options.DropoutRate);
-    }
 
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _options.Variant = (VideoModelVariant)reader.ReadInt32();
-        _options.NumFeatures = reader.ReadInt32();
-        _options.NumInputFrames = reader.ReadInt32();
-        _options.NumTemporalLayers = reader.ReadInt32();
-        _options.NumSpatialLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.LearningRate = reader.ReadDouble();
-        _options.DropoutRate = reader.ReadDouble();
-    }
 
     /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new VFIT<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/Video/FrameInterpolation/VFIformer.cs b/src/Video/FrameInterpolation/VFIformer.cs
index dbda75dbe1..1388ac9567 100644
--- a/src/Video/FrameInterpolation/VFIformer.cs
+++ b/src/Video/FrameInterpolation/VFIformer.cs
@@ -66,7 +66,7 @@ namespace AiDotNet.Video.FrameInterpolation;
     "https://arxiv.org/abs/2111.13817",
     Year = 2022,
     Authors = "Zhihao Shi, Xiangyu Xu, Xiaohong Liu, Jun Chen, Ming-Hsuan Yang")]
-public class VFIformer<T> : FrameInterpolationBase<T>
+public partial class VFIformer<T> : FrameInterpolationBase<T>
 {
     private readonly VFIformerOptions _options;
 
@@ -215,36 +215,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write((int)_options.Variant);
-        writer.Write(_options.NumFeatures);
-        writer.Write(_options.NumEncoderLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.NumDeformablePoints);
-        writer.Write(_options.LearningRate);
-        writer.Write(_options.DropoutRate);
-    }
 
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _options.Variant = (VideoModelVariant)reader.ReadInt32();
-        _options.NumFeatures = reader.ReadInt32();
-        _options.NumEncoderLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.NumDeformablePoints = reader.ReadInt32();
-        _options.LearningRate = reader.ReadDouble();
-        _options.DropoutRate = reader.ReadDouble();
-    }
 
     /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new VFIformer<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/Video/FrameInterpolation/XVFI.cs b/src/Video/FrameInterpolation/XVFI.cs
index 5a167c8c56..edbeb1efa7 100644
--- a/src/Video/FrameInterpolation/XVFI.cs
+++ b/src/Video/FrameInterpolation/XVFI.cs
@@ -64,7 +64,7 @@ namespace AiDotNet.Video.FrameInterpolation;
     "https://arxiv.org/abs/2103.16206",
     Year = 2021,
     Authors = "Hyeonjun Sim, Jihyong Oh, Munchurl Kim")]
-public class XVFI<T> : FrameInterpolationBase<T>
+public partial class XVFI<T> : FrameInterpolationBase<T>
 {
     private readonly XVFIOptions _options;
 
@@ -201,36 +201,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write((int)_options.Variant);
-        writer.Write(_options.NumFeatures);
-        writer.Write(_options.NumPyramidLevels);
-        writer.Write(_options.NumResBlocks);
-        writer.Write(_options.NumAffineParams);
-        writer.Write(_options.UseComplementaryFlow);
-        writer.Write(_options.LearningRate);
-        writer.Write(_options.DropoutRate);
-    }
 
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _options.Variant = (VideoModelVariant)reader.ReadInt32();
-        _options.NumFeatures = reader.ReadInt32();
-        _options.NumPyramidLevels = reader.ReadInt32();
-        _options.NumResBlocks = reader.ReadInt32();
-        _options.NumAffineParams = reader.ReadInt32();
-        _options.UseComplementaryFlow = reader.ReadBoolean();
-        _options.LearningRate = reader.ReadDouble();
-        _options.DropoutRate = reader.ReadDouble();
-    }
 
     /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new XVFI<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/Video/FrameInterpolationBase.cs b/src/Video/FrameInterpolationBase.cs
index cda8058ffd..ed14afa171 100644
--- a/src/Video/FrameInterpolationBase.cs
+++ b/src/Video/FrameInterpolationBase.cs
@@ -44,7 +44,7 @@ namespace AiDotNet.Video;
 [TensorLayout(TensorAxis.Channels, TensorAxis.Height, TensorAxis.Width,
     Direction = TensorLayoutDirection.Output,
     Note = "One interpolated frame, so the doubled channel axis halves back.")]
-public abstract class FrameInterpolationBase<T> : VideoNeuralNetworkBase<T>, IShapeContract
+public abstract partial class FrameInterpolationBase<T> : VideoNeuralNetworkBase<T>, IShapeContract
 {
     /// <summary>
     /// The interpolation family's law: <c>(F - 1) * TemporalScaleFactor + 1</c> output frames.
diff --git a/src/Video/Generation/AnimateDiff.cs b/src/Video/Generation/AnimateDiff.cs
index 5c54d99bc6..151faf9001 100644
--- a/src/Video/Generation/AnimateDiff.cs
+++ b/src/Video/Generation/AnimateDiff.cs
@@ -67,7 +67,7 @@ namespace AiDotNet.Video.Generation;
     Direction = TensorLayoutDirection.Input, BatchOptional = true)]
 [TensorLayout(TensorAxis.Batch, TensorAxis.Frames, TensorAxis.Channels, TensorAxis.Height, TensorAxis.Width,
     Direction = TensorLayoutDirection.Output, BatchOptional = true)]
-public class AnimateDiff<T> : NeuralNetworkBase<T>
+public partial class AnimateDiff<T> : NeuralNetworkBase<T>
 {
     private readonly AnimateDiffOptions _options;
 
@@ -495,42 +495,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        if (!_useNativeMode)
-            throw new InvalidOperationException("Serialization is not supported in ONNX mode.");
 
-        writer.Write(_inputChannels);
-        writer.Write(_numLayers);
-        writer.Write(_numFrames);
-        writer.Write(_featureHeight);
-        writer.Write(_featureWidth);
-    }
 
     /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        if (!_useNativeMode)
-            throw new InvalidOperationException("Deserialization is not supported in ONNX mode.");
 
-        _ = reader.ReadInt32(); // inputChannels
-        _ = reader.ReadInt32(); // numLayers
-        _ = reader.ReadInt32(); // numFrames
-        _ = reader.ReadInt32(); // featureHeight
-        _ = reader.ReadInt32(); // featureWidth
-    }
-
-    /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new AnimateDiff<T>(
-            Architecture,
-            _optimizer,
-            _lossFunction,
-            _inputChannels,
-            _numLayers,
-            _numFrames);
-    }
 
     #endregion
 }
diff --git a/src/Video/Generation/CogVideo.cs b/src/Video/Generation/CogVideo.cs
index 4cf544e50f..4fdb48d2d4 100644
--- a/src/Video/Generation/CogVideo.cs
+++ b/src/Video/Generation/CogVideo.cs
@@ -72,7 +72,7 @@ namespace AiDotNet.Video.Generation;
     Direction = TensorLayoutDirection.Input, BatchOptional = true)]
 [TensorLayout(TensorAxis.Batch, TensorAxis.Frames, TensorAxis.Channels, TensorAxis.Height, TensorAxis.Width,
     Direction = TensorLayoutDirection.Output, BatchOptional = true)]
-public class CogVideo<T> : NeuralNetworkBase<T>
+public partial class CogVideo<T> : NeuralNetworkBase<T>
 {
     private readonly CogVideoOptions _options;
 
@@ -800,18 +800,7 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        if (!_useNativeMode)
-            throw new InvalidOperationException("Serialization is not supported in ONNX mode.");
-
-        writer.Write(_embedDim);
-        writer.Write(_numLayers);
-        writer.Write(_numFrames);
-        writer.Write(_latentHeight);
-        writer.Write(_latentWidth);
-        writer.Write(_latentChannels);
-    }
+
 
     /// <inheritdoc/>
     /// <remarks>
@@ -819,36 +808,7 @@ protected override void SerializeNetworkSpecificData(BinaryWriter writer)
     /// the deserialized state. This ensures the model structure is properly
     /// reconstructed after loading from a serialized format.
     /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        if (!_useNativeMode)
-            throw new InvalidOperationException("Deserialization is not supported in ONNX mode.");
-
-        // Read serialized configuration values
-        _embedDim = reader.ReadInt32();
-        _numLayers = reader.ReadInt32();
-        _numFrames = reader.ReadInt32();
-        _latentHeight = reader.ReadInt32();
-        _latentWidth = reader.ReadInt32();
-        _latentChannels = reader.ReadInt32();
-
-        // The layers (with their trained weights) are already reconstructed by the base
-        // DeserializeInternalUnchecked before this override runs, so do NOT clear +
-        // re-initialize them here — that would discard the deserialized weights and leave
-        // the model randomly initialized.
-    }
 
-    /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new CogVideo<T>(
-            Architecture,
-            _optimizer,
-            _lossFunction,
-            _embedDim,
-            _numLayers,
-            _numFrames);
-    }
 
     #endregion
 }
diff --git a/src/Video/Generation/OpenSora.cs b/src/Video/Generation/OpenSora.cs
index 6d73d88925..7560253380 100644
--- a/src/Video/Generation/OpenSora.cs
+++ b/src/Video/Generation/OpenSora.cs
@@ -1178,17 +1178,7 @@ private void ExtractLayerReferences()
         ModelData = SerializeForMetadata()
     };
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_height);
-        writer.Write(_width);
-        writer.Write(_channels);
-        writer.Write(_numFrames);
-        writer.Write(_hiddenDim);
-        writer.Write(_numLayers);
-        writer.Write(_numInferenceSteps);
-        writer.Write(_guidanceScale);
-    }
+
 
     /// <summary>
     /// Restores model configuration from serialized data.
@@ -1204,36 +1194,7 @@ protected override void SerializeNetworkSpecificData(BinaryWriter writer)
     /// as when it was saved, including all the learned weights.
     /// </para>
     /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        // Read serialized configuration values
-        _height = reader.ReadInt32();
-        _width = reader.ReadInt32();
-        _channels = reader.ReadInt32();
-        _numFrames = reader.ReadInt32();
-        _hiddenDim = reader.ReadInt32();
-        _numLayers = reader.ReadInt32();
-        _numInferenceSteps = reader.ReadInt32();
-        _guidanceScale = reader.ReadDouble();
-        GuidanceScale = _guidanceScale;
-        _numHeads = 16;
-        _headDim = _hiddenDim / _numHeads;
-
-        // Re-initialize noise schedule with restored inference steps
-        (_betas, _alphasCumprod) = InitializeNoiseSchedule(_numInferenceSteps);
-
-        // The layers (with their trained weights) are already reconstructed by the base
-        // DeserializeInternalUnchecked before this override runs. Do NOT clear Layers +
-        // call InitializeLayers — that would discard the deserialized weights and
-        // re-randomize the model. Instead re-point the cached DiT/VAE layer references
-        // (_patchEmbed, _ditQKV, _ditAttnProj, _ditFFN1/2, _textProjection, _timeEmbed,
-        // _finalLayer, _vaeDecoder, _vaeEncoder) at the freshly deserialized Layers so
-        // the forward pass routes through the loaded weights.
-        ExtractLayerReferences();
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() =>
-        new OpenSora<T>(Architecture, _numFrames, _hiddenDim, _numLayers, _numInferenceSteps, _guidanceScale);
 
     #endregion
 }
diff --git a/src/Video/Generation/StableVideoDiffusion.cs b/src/Video/Generation/StableVideoDiffusion.cs
index 7e5f7e8c52..7f4781486d 100644
--- a/src/Video/Generation/StableVideoDiffusion.cs
+++ b/src/Video/Generation/StableVideoDiffusion.cs
@@ -1202,39 +1202,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_height);
-        writer.Write(_width);
-        writer.Write(_channels);
-        writer.Write(_numFrames);
-        writer.Write(_latentDim);
-        writer.Write(_numInferenceSteps);
-        writer.Write(_guidanceScale);
-        writer.Write((int)_variant);
-    }
 
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _height = reader.ReadInt32();
-        _width = reader.ReadInt32();
-        _channels = reader.ReadInt32();
-        _numFrames = reader.ReadInt32();
-        _latentDim = reader.ReadInt32();
-        _numInferenceSteps = reader.ReadInt32();
-        _guidanceScale = reader.ReadDouble();
-        _variant = (SVDModelVariant)reader.ReadInt32();
-    }
 
     /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new StableVideoDiffusion<T>(
-            Architecture, _variant, _numFrames, _numInferenceSteps, _guidanceScale,
-            textEncoderDim: _textEncoderDim, textEncoderLayers: _textEncoderLayers,
-            textEncoderHeads: _textEncoderHeads);
-    }
+
 
     #endregion
 }
diff --git a/src/Video/Inpainting/AVID.cs b/src/Video/Inpainting/AVID.cs
index 18876cb02b..90605f16b7 100644
--- a/src/Video/Inpainting/AVID.cs
+++ b/src/Video/Inpainting/AVID.cs
@@ -1,278 +1,251 @@
-using System.IO;
-using AiDotNet.Attributes;
-using AiDotNet.Enums;
-using AiDotNet.Helpers;
-using AiDotNet.Interfaces;
-using AiDotNet.NeuralNetworks;
-using AiDotNet.Onnx;
-using AiDotNet.Optimizers;
-using AiDotNet.Tensors.LinearAlgebra;
-using AiDotNet.Video.Options;
-
-namespace AiDotNet.Video.Inpainting;
-
-/// <summary>
-/// AVID diffusion-based video inpainting supporting arbitrary-length videos.
-/// </summary>
-/// <typeparam name="T">The numeric type used for calculations.</typeparam>
-/// <remarks>
-/// <para><b>References:</b>
-/// <list type="bullet">
-/// <item>Paper: "AVID: Any-Length Video Inpainting with Diffusion Model" (Zhang et al., CVPR 2024)</item>
-/// </list></para>
-/// <para><b>For Beginners:</b> AVID (Adaptive Video Inpainting via Diffusion) fills in missing or damaged regions of video using diffusion models. It adaptively propagates content from neighboring frames and regions.</para>
-/// <para>
-/// AVID uses a diffusion U-Net with temporal attention to iteratively denoise masked video regions,
-/// processing long videos through an autoregressive temporal pipeline with overlapping windows
-/// that maintains temporal consistency across the full sequence.
-/// </para>
-/// </remarks>
-/// <example>
-/// <code>
-/// // Create an AVID model for diffusion-based video inpainting
-/// var architecture = new NeuralNetworkArchitecture&lt;double&gt;(
-///     inputType: InputType.ThreeDimensional,
-///     inputHeight: 256, inputWidth: 256, inputDepth: 3);
-/// var options = new AVIDOptions();
-/// var avid = new AVID&lt;double&gt;(architecture, options);
-///
-/// // Or load a pre-trained ONNX model for inference
-/// var avidOnnx = new AVID&lt;double&gt;(architecture, "avid_model.onnx");
-/// </code>
-/// </example>
-[ModelDomain(ModelDomain.Video)]
-[ModelDomain(ModelDomain.Vision)]
-[ModelCategory(ModelCategory.NeuralNetwork)]
-[ModelTask(ModelTask.Generation)]
-[ModelComplexity(ModelComplexity.High)]
-[ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
-[ResearchPaper("AVID: Any-Length Video Inpainting with Diffusion Model",
-    "https://arxiv.org/abs/2312.03816",
-    Year = 2024,
-    Authors = "Zhixing Zhang, Bichen Wu, Xiaoyan Wang, Yaqiao Luo, Zijian He, Peter Vajda, Dimitris Metaxas, Licheng Yu")]
-public class AVID<T> : VideoInpaintingBase<T>
-{
-    private readonly AVIDOptions _options;
-
-    /// <inheritdoc/>
-    public override ModelOptions GetOptions() => _options;
-
-    private IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer;
-    private bool _useNativeMode;
-    private bool _disposed;
-
-    /// <summary>
-    /// Creates an AVID model for ONNX inference.
-    /// </summary>
-    public AVID(
-        NeuralNetworkArchitecture<T> architecture,
-        string modelPath,
-        AVIDOptions? options = null)
-        : base(architecture)
-    {
-        if (string.IsNullOrEmpty(modelPath))
-            throw new ArgumentException("Model path cannot be null or empty.", nameof(modelPath));
-        _options = options ?? new AVIDOptions();
-        _useNativeMode = false;
-        SupportsTemporalPropagation = true;
-        _options.ModelPath = modelPath;
-        OnnxModel = new OnnxModel<T>(modelPath, _options.OnnxOptions);
-        InitializeLayers();
-    }
-
-    /// <summary>
-    /// Creates an AVID model for native training and inference.
-    /// </summary>
-    public AVID(
-        NeuralNetworkArchitecture<T> architecture,
-        AVIDOptions? options = null,
-        IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? optimizer = null)
-        : base(architecture)
-    {
-        _options = options ?? new AVIDOptions();
-        _useNativeMode = true;
-        _optimizer = optimizer ?? new AdamWOptimizer<T, Tensor<T>, Tensor<T>>(this,
-            new AdamWOptimizerOptions<T, Tensor<T>, Tensor<T>>
-            {
-                InitialLearningRate = _options.LearningRate
-            });
-        SupportsTemporalPropagation = true;
-        InitializeLayers();
-    }
-
-    /// <inheritdoc/>
-    public override Tensor<T> Inpaint(Tensor<T> frames, Tensor<T> masks)
-    {
-        ThrowIfDisposed();
-        var preprocessed = PreprocessFrames(frames);
-        var combined = ConcatFramesAndMasks(preprocessed, masks);
-        var output = IsOnnxMode ? RunOnnxInference(combined) : Forward(combined);
-        return PostprocessOutput(output);
-    }
-
-    /// <inheritdoc/>
-    protected override void InitializeLayers()
-    {
-        if (!_useNativeMode) return;
-        if (Architecture.Layers is not null && Architecture.Layers.Count > 0)
-        {
-            Layers.AddRange(Architecture.Layers);
-        }
-        else
-        {
-            int ch = Architecture.InputDepth > 0 ? Architecture.InputDepth : 3;
-            int h = Architecture.InputHeight > 0 ? Architecture.InputHeight : 128;
-            int w = Architecture.InputWidth > 0 ? Architecture.InputWidth : 128;
-            Layers.AddRange(LayerHelper<T>.CreateDefaultVideoInpaintingLayers(
-                inputChannels: ch, inputHeight: h, inputWidth: w,
-                numFeatures: _options.NumFeatures));
-        }
-    }
-
-    /// <inheritdoc/>
-    protected override Tensor<T> PreprocessFrames(Tensor<T> rawFrames) => NormalizeInpaintFrames(rawFrames);
-
-    /// <inheritdoc/>
-    protected override Tensor<T> PostprocessOutput(Tensor<T> modelOutput) => DenormalizeInpaintFrames(modelOutput);
-
-
-    /// <inheritdoc/>
-    public override Tensor<T> ForwardForTraining(Tensor<T> input)
-    {
-        // Training must apply the SAME transform inference does (Inpaint): normalize the frames,
-        // concatenate a 1-channel mask (InputDepth -> InputDepth+1 so the encoder conv matches),
-        // run the layer stack, then denormalize. Feeding the raw InputDepth frames straight through
-        // the base would resolve/expect a different first-conv depth than inference AND train in a
-        // different value space, so the two paths would diverge. Delegate the actual layer walk
-        // (autodiff tape, gradient checkpointing, seed-wiring) to the base by handing it the
-        // mask-concatenated tensor; normalize/denormalize are Engine ops so gradients still flow.
-        // Use a fresh RANDOM per-step hole mask (PyTorch video-inpainting recipe). A mask that varies
-        // every step exercises the encoder's mask-channel weights without becoming a constant the model
-        // can exploit as a shortcut — so training keeps using the frame content and stays input-sensitive.
-        // Inference's PredictCore uses the deterministic CreateDefaultInpaintingMask.
-        var mask = CreateTrainingMask(input.Shape[0], input.Shape[2], input.Shape[3]);
-        var combined = ConcatFramesAndMasks(PreprocessFrames(input), mask);
-        return PostprocessOutput(base.ForwardForTraining(combined));
-    }
-
-    /// <inheritdoc/>
-    public override void Train(Tensor<T> input, Tensor<T> expected)
-    {
-        if (IsOnnxMode) throw new NotSupportedException("Training is not supported in ONNX mode.");
-        SetTrainingMode(true);
-        try
-        {
-        TrainWithTape(input, expected, _optimizer);
-        }
-        finally
-        {
-            SetTrainingMode(false);
-        }
-    }
-
-    // UpdateParameters restated the base verbatim; ModelBase routes it to SetParameters.

-
-    /// <summary>
-    /// Parameters cannot be written while the model is backed by a loaded ONNX graph: the weights
-    /// belong to that graph, not to this instance.
-    /// </summary>
-    /// <remarks>
-    /// Replaces a hand-written throw that used to sit inside UpdateParameters. The base checks this
-    /// on every mutating entry point rather than the one member the throw happened to guard, and
-    /// reading -- ParameterCount and GetParameters -- stays available either way.
-    /// </remarks>
+using System.IO;
+using AiDotNet.Attributes;
+using AiDotNet.Enums;
+using AiDotNet.Helpers;
+using AiDotNet.Interfaces;
+using AiDotNet.NeuralNetworks;
+using AiDotNet.Onnx;
+using AiDotNet.Optimizers;
+using AiDotNet.Tensors.LinearAlgebra;
+using AiDotNet.Video.Options;
+
+namespace AiDotNet.Video.Inpainting;
+
+/// <summary>
+/// AVID diffusion-based video inpainting supporting arbitrary-length videos.
+/// </summary>
+/// <typeparam name="T">The numeric type used for calculations.</typeparam>
+/// <remarks>
+/// <para><b>References:</b>
+/// <list type="bullet">
+/// <item>Paper: "AVID: Any-Length Video Inpainting with Diffusion Model" (Zhang et al., CVPR 2024)</item>
+/// </list></para>
+/// <para><b>For Beginners:</b> AVID (Adaptive Video Inpainting via Diffusion) fills in missing or damaged regions of video using diffusion models. It adaptively propagates content from neighboring frames and regions.</para>
+/// <para>
+/// AVID uses a diffusion U-Net with temporal attention to iteratively denoise masked video regions,
+/// processing long videos through an autoregressive temporal pipeline with overlapping windows
+/// that maintains temporal consistency across the full sequence.
+/// </para>
+/// </remarks>
+/// <example>
+/// <code>
+/// // Create an AVID model for diffusion-based video inpainting
+/// var architecture = new NeuralNetworkArchitecture&lt;double&gt;(
+///     inputType: InputType.ThreeDimensional,
+///     inputHeight: 256, inputWidth: 256, inputDepth: 3);
+/// var options = new AVIDOptions();
+/// var avid = new AVID&lt;double&gt;(architecture, options);
+///
+/// // Or load a pre-trained ONNX model for inference
+/// var avidOnnx = new AVID&lt;double&gt;(architecture, "avid_model.onnx");
+/// </code>
+/// </example>
+[ModelDomain(ModelDomain.Video)]
+[ModelDomain(ModelDomain.Vision)]
+[ModelCategory(ModelCategory.NeuralNetwork)]
+[ModelTask(ModelTask.Generation)]
+[ModelComplexity(ModelComplexity.High)]
+[ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
+[ResearchPaper("AVID: Any-Length Video Inpainting with Diffusion Model",
+    "https://arxiv.org/abs/2312.03816",
+    Year = 2024,
+    Authors = "Zhixing Zhang, Bichen Wu, Xiaoyan Wang, Yaqiao Luo, Zijian He, Peter Vajda, Dimitris Metaxas, Licheng Yu")]
+public partial class AVID<T> : VideoInpaintingBase<T>
+{
+    private readonly AVIDOptions _options;
+
+    /// <inheritdoc/>
+    public override ModelOptions GetOptions() => _options;
+
+    private IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer;
+    private bool _useNativeMode;
+    private bool _disposed;
+
+    /// <summary>
+    /// Creates an AVID model for ONNX inference.
+    /// </summary>
+    public AVID(
+        NeuralNetworkArchitecture<T> architecture,
+        string modelPath,
+        AVIDOptions? options = null)
+        : base(architecture)
+    {
+        if (string.IsNullOrEmpty(modelPath))
+            throw new ArgumentException("Model path cannot be null or empty.", nameof(modelPath));
+        _options = options ?? new AVIDOptions();
+        _useNativeMode = false;
+        SupportsTemporalPropagation = true;
+        _options.ModelPath = modelPath;
+        OnnxModel = new OnnxModel<T>(modelPath, _options.OnnxOptions);
+        InitializeLayers();
+    }
+
+    /// <summary>
+    /// Creates an AVID model for native training and inference.
+    /// </summary>
+    public AVID(
+        NeuralNetworkArchitecture<T> architecture,
+        AVIDOptions? options = null,
+        IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? optimizer = null)
+        : base(architecture)
+    {
+        _options = options ?? new AVIDOptions();
+        _useNativeMode = true;
+        _optimizer = optimizer ?? new AdamWOptimizer<T, Tensor<T>, Tensor<T>>(this,
+            new AdamWOptimizerOptions<T, Tensor<T>, Tensor<T>>
+            {
+                InitialLearningRate = _options.LearningRate
+            });
+        SupportsTemporalPropagation = true;
+        InitializeLayers();
+    }
+
+    /// <inheritdoc/>
+    public override Tensor<T> Inpaint(Tensor<T> frames, Tensor<T> masks)
+    {
+        ThrowIfDisposed();
+        var preprocessed = PreprocessFrames(frames);
+        var combined = ConcatFramesAndMasks(preprocessed, masks);
+        var output = IsOnnxMode ? RunOnnxInference(combined) : Forward(combined);
+        return PostprocessOutput(output);
+    }
+
+    /// <inheritdoc/>
+    protected override void InitializeLayers()
+    {
+        if (!_useNativeMode) return;
+        if (Architecture.Layers is not null && Architecture.Layers.Count > 0)
+        {
+            Layers.AddRange(Architecture.Layers);
+        }
+        else
+        {
+            int ch = Architecture.InputDepth > 0 ? Architecture.InputDepth : 3;
+            int h = Architecture.InputHeight > 0 ? Architecture.InputHeight : 128;
+            int w = Architecture.InputWidth > 0 ? Architecture.InputWidth : 128;
+            Layers.AddRange(LayerHelper<T>.CreateDefaultVideoInpaintingLayers(
+                inputChannels: ch, inputHeight: h, inputWidth: w,
+                numFeatures: _options.NumFeatures));
+        }
+    }
+
+    /// <inheritdoc/>
+    protected override Tensor<T> PreprocessFrames(Tensor<T> rawFrames) => NormalizeInpaintFrames(rawFrames);
+
+    /// <inheritdoc/>
+    protected override Tensor<T> PostprocessOutput(Tensor<T> modelOutput) => DenormalizeInpaintFrames(modelOutput);
+
+
+    /// <inheritdoc/>
+    public override Tensor<T> ForwardForTraining(Tensor<T> input)
+    {
+        // Training must apply the SAME transform inference does (Inpaint): normalize the frames,
+        // concatenate a 1-channel mask (InputDepth -> InputDepth+1 so the encoder conv matches),
+        // run the layer stack, then denormalize. Feeding the raw InputDepth frames straight through
+        // the base would resolve/expect a different first-conv depth than inference AND train in a
+        // different value space, so the two paths would diverge. Delegate the actual layer walk
+        // (autodiff tape, gradient checkpointing, seed-wiring) to the base by handing it the
+        // mask-concatenated tensor; normalize/denormalize are Engine ops so gradients still flow.
+        // Use a fresh RANDOM per-step hole mask (PyTorch video-inpainting recipe). A mask that varies
+        // every step exercises the encoder's mask-channel weights without becoming a constant the model
+        // can exploit as a shortcut — so training keeps using the frame content and stays input-sensitive.
+        // Inference's PredictCore uses the deterministic CreateDefaultInpaintingMask.
+        var mask = CreateTrainingMask(input.Shape[0], input.Shape[2], input.Shape[3]);
+        var combined = ConcatFramesAndMasks(PreprocessFrames(input), mask);
+        return PostprocessOutput(base.ForwardForTraining(combined));
+    }
+
+    /// <inheritdoc/>
+    public override void Train(Tensor<T> input, Tensor<T> expected)
+    {
+        if (IsOnnxMode) throw new NotSupportedException("Training is not supported in ONNX mode.");
+        SetTrainingMode(true);
+        try
+        {
+        TrainWithTape(input, expected, _optimizer);
+        }
+        finally
+        {
+            SetTrainingMode(false);
+        }
+    }
+
+    // UpdateParameters restated the base verbatim; ModelBase routes it to SetParameters.
+
+
+    /// <summary>
+    /// Parameters cannot be written while the model is backed by a loaded ONNX graph: the weights
+    /// belong to that graph, not to this instance.
+    /// </summary>
+    /// <remarks>
+    /// Replaces a hand-written throw that used to sit inside UpdateParameters. The base checks this
+    /// on every mutating entry point rather than the one member the throw happened to guard, and
+    /// reading -- ParameterCount and GetParameters -- stays available either way.
+    /// </remarks>
     protected override bool SupportsParameterMutation => _useNativeMode;
-    /// <inheritdoc/>
-    public override ModelMetadata<T> GetModelMetadata()
-    {
-        return new ModelMetadata<T>
-        {
-            AdditionalInfo = new Dictionary<string, object>
-            {
-                { "ModelName", "AVID" },
-                { "Variant", _options.Variant.ToString() },
-                { "NumFeatures", _options.NumFeatures },
-                { "NumDiffusionSteps", _options.NumDiffusionSteps },
-                { "NumResBlocks", _options.NumResBlocks },
-                { "NumHeads", _options.NumHeads }
-            },
-            ModelData = SerializeForMetadata()
-        };
-    }
-
-    /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write((int)_options.Variant);
-        writer.Write(_options.NumFeatures);
-        writer.Write(_options.NumDiffusionSteps);
-        writer.Write(_options.NumResBlocks);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.TemporalOverlap);
-        writer.Write(_options.LearningRate);
-        writer.Write(_options.DropoutRate);
-    }
-
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _options.Variant = (VideoModelVariant)reader.ReadInt32();
-        _options.NumFeatures = reader.ReadInt32();
-        _options.NumDiffusionSteps = reader.ReadInt32();
-        _options.NumResBlocks = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.TemporalOverlap = reader.ReadInt32();
-        _options.LearningRate = reader.ReadDouble();
-        _options.DropoutRate = reader.ReadDouble();
-    }
-
-    /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            return new AVID<T>(Architecture, p, _options);
-        return new AVID<T>(Architecture, _options);
-    }
-
-    private static Tensor<T> ConcatFramesAndMasks(Tensor<T> frames, Tensor<T> masks)
-    {
-        if (frames.Rank != 4)
-            throw new ArgumentException($"Frames must be rank 4 [N, C, H, W], got rank {frames.Rank}.", nameof(frames));
-        if (masks.Rank != 4)
-            throw new ArgumentException($"Masks must be rank 4 [N, 1, H, W], got rank {masks.Rank}.", nameof(masks));
-        int n = frames.Shape[0];
-        int c = frames.Shape[1];
-        int h = frames.Shape[2];
-        int w = frames.Shape[3];
-        if (masks.Shape[0] != n || masks.Shape[2] != h || masks.Shape[3] != w)
-            throw new ArgumentException($"Masks spatial dimensions must match frames. Frames: [{n},{c},{h},{w}], Masks: [{masks.Shape[0]},{masks.Shape[1]},{masks.Shape[2]},{masks.Shape[3]}].", nameof(masks));
-        var combined = new Tensor<T>([n, c + 1, h, w]);
-        int frameSize = c * h * w;
-        int maskSize = h * w;
-        int combinedSize = (c + 1) * h * w;
-        for (int f = 0; f < n; f++)
-        {
-            // Copy frame channels
-            for (int i = 0; i < frameSize; i++)
-                combined.Data.Span[f * combinedSize + i] = frames.Data.Span[f * frameSize + i];
-            // Copy mask channel
-            for (int i = 0; i < maskSize; i++)
-                combined.Data.Span[f * combinedSize + frameSize + i] = masks.Data.Span[f * maskSize + i];
-        }
-        return combined;
-    }
-
-    private void ThrowIfDisposed()
-    {
-        if (_disposed) throw new ObjectDisposedException(GetType().FullName ?? nameof(AVID<T>));
-    }
-
-    /// <inheritdoc/>
-    protected override void Dispose(bool disposing)
-    {
-        if (_disposed) return;
-        _disposed = true;
-        if (disposing) OnnxModel?.Dispose();
-        base.Dispose(disposing);
-    }
-}
+    /// <inheritdoc/>
+    public override ModelMetadata<T> GetModelMetadata()
+    {
+        return new ModelMetadata<T>
+        {
+            AdditionalInfo = new Dictionary<string, object>
+            {
+                { "ModelName", "AVID" },
+                { "Variant", _options.Variant.ToString() },
+                { "NumFeatures", _options.NumFeatures },
+                { "NumDiffusionSteps", _options.NumDiffusionSteps },
+                { "NumResBlocks", _options.NumResBlocks },
+                { "NumHeads", _options.NumHeads }
+            },
+            ModelData = SerializeForMetadata()
+        };
+    }
+
+    /// <inheritdoc/>
+
+
+    /// <inheritdoc/>
+
+
+    private static Tensor<T> ConcatFramesAndMasks(Tensor<T> frames, Tensor<T> masks)
+    {
+        if (frames.Rank != 4)
+            throw new ArgumentException($"Frames must be rank 4 [N, C, H, W], got rank {frames.Rank}.", nameof(frames));
+        if (masks.Rank != 4)
+            throw new ArgumentException($"Masks must be rank 4 [N, 1, H, W], got rank {masks.Rank}.", nameof(masks));
+        int n = frames.Shape[0];
+        int c = frames.Shape[1];
+        int h = frames.Shape[2];
+        int w = frames.Shape[3];
+        if (masks.Shape[0] != n || masks.Shape[2] != h || masks.Shape[3] != w)
+            throw new ArgumentException($"Masks spatial dimensions must match frames. Frames: [{n},{c},{h},{w}], Masks: [{masks.Shape[0]},{masks.Shape[1]},{masks.Shape[2]},{masks.Shape[3]}].", nameof(masks));
+        var combined = new Tensor<T>([n, c + 1, h, w]);
+        int frameSize = c * h * w;
+        int maskSize = h * w;
+        int combinedSize = (c + 1) * h * w;
+        for (int f = 0; f < n; f++)
+        {
+            // Copy frame channels
+            for (int i = 0; i < frameSize; i++)
+                combined.Data.Span[f * combinedSize + i] = frames.Data.Span[f * frameSize + i];
+            // Copy mask channel
+            for (int i = 0; i < maskSize; i++)
+                combined.Data.Span[f * combinedSize + frameSize + i] = masks.Data.Span[f * maskSize + i];
+        }
+        return combined;
+    }
+
+    private void ThrowIfDisposed()
+    {
+        if (_disposed) throw new ObjectDisposedException(GetType().FullName ?? nameof(AVID<T>));
+    }
+
+    /// <inheritdoc/>
+    protected override void Dispose(bool disposing)
+    {
+        if (_disposed) return;
+        _disposed = true;
+        if (disposing) OnnxModel?.Dispose();
+        base.Dispose(disposing);
+    }
+}
diff --git a/src/Video/Inpainting/E2FGVI.cs b/src/Video/Inpainting/E2FGVI.cs
index 0b94df692a..587f5042b2 100644
--- a/src/Video/Inpainting/E2FGVI.cs
+++ b/src/Video/Inpainting/E2FGVI.cs
@@ -800,36 +800,9 @@ protected override void InitializeLayers()
         ModelData = SerializeForMetadata()
     };
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_height);
-        writer.Write(_width);
-        writer.Write(_channels);
-        writer.Write(_numFeatures);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _height = reader.ReadInt32();
-        _width = reader.ReadInt32();
-        _channels = reader.ReadInt32();
-        _numFeatures = reader.ReadInt32();
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        // Do not pass the live Architecture instance (its Layers list can be populated
-        // during lazy shape resolution).  A fresh blueprint gives clone/serialization
-        // an independent layer graph while preserving every public architecture field.
-        var architecture = new NeuralNetworkArchitecture<T>(
-            Architecture.InputType, Architecture.TaskType, Architecture.Complexity,
-            Architecture.InputSize, Architecture.InputHeight, Architecture.InputWidth,
-            Architecture.InputDepth, Architecture.OutputSize, inputFrames: Architecture.InputFrames,
-            shouldReturnFullSequence: Architecture.ShouldReturnFullSequence,
-            imageEmbeddingDim: Architecture.ImageEmbeddingDim,
-            textEmbeddingDim: Architecture.TextEmbeddingDim);
-        return new E2FGVI<T>(architecture, _numFeatures, _options);
-    }
+
 
     #endregion
 
diff --git a/src/Video/Inpainting/FlowLens.cs b/src/Video/Inpainting/FlowLens.cs
index 4674e9b5af..5742f520e2 100644
--- a/src/Video/Inpainting/FlowLens.cs
+++ b/src/Video/Inpainting/FlowLens.cs
@@ -1,281 +1,256 @@
-using System.IO;
-using AiDotNet.Attributes;
-using AiDotNet.Enums;
-using AiDotNet.Helpers;
-using AiDotNet.Interfaces;
-using AiDotNet.NeuralNetworks;
-using AiDotNet.Onnx;
-using AiDotNet.Optimizers;
-using AiDotNet.Tensors.LinearAlgebra;
-using AiDotNet.Video.Options;
-
-namespace AiDotNet.Video.Inpainting;
-
-/// <summary>
-/// FlowLens optical-flow-guided video inpainting with flow completion.
-/// </summary>
-/// <typeparam name="T">The numeric type used for calculations.</typeparam>
-/// <remarks>
-/// <para><b>References:</b>
-/// <list type="bullet">
-/// <item>Paper: "FlowLens: Seeing Beyond the FoV via Optical Flow Completion" (Xu et al., ECCV 2022)</item>
-/// </list></para>
-/// <para><b>For Beginners:</b> FlowLens performs video inpainting by using optical flow as a lens to guide content from visible regions into masked areas. It produces temporally consistent fills for removed objects.</para>
-/// <para>
-/// FlowLens decouples motion estimation from pixel synthesis by first completing optical flow
-/// in masked regions, then using the completed flow for temporal propagation of known pixels,
-/// followed by a refinement network for remaining holes, achieving sharp and temporally
-/// consistent inpainting.
-/// </para>
-/// </remarks>
-/// <example>
-/// <code>
-/// // Create a FlowLens model for optical-flow-guided video inpainting
-/// var architecture = new NeuralNetworkArchitecture&lt;double&gt;(
-///     inputType: InputType.ThreeDimensional,
-///     inputHeight: 256, inputWidth: 256, inputDepth: 3);
-/// var options = new FlowLensOptions();
-/// var flowLens = new FlowLens&lt;double&gt;(architecture, options);
-///
-/// // Or load a pre-trained ONNX model for inference
-/// var flowLensOnnx = new FlowLens&lt;double&gt;(architecture, "flowlens_model.onnx");
-/// </code>
-/// </example>
-[ModelDomain(ModelDomain.Video)]
-[ModelDomain(ModelDomain.Vision)]
-[ModelCategory(ModelCategory.NeuralNetwork)]
-[ModelTask(ModelTask.Generation)]
-[ModelComplexity(ModelComplexity.High)]
-[ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
-[ResearchPaper("Beyond the Field-of-View: Enhancing Scene Visibility and Perception with Clip-Recurrent Transformer",
-    "https://arxiv.org/abs/2211.11293",
-    Year = 2022,
-    Authors = "Hao Luo, Peng Zhao, Ling Pei")]
-public class FlowLens<T> : VideoInpaintingBase<T>
-{
-    private readonly FlowLensOptions _options;
-
-    /// <inheritdoc/>
-    public override ModelOptions GetOptions() => _options;
-
-    private IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer;
-    private bool _useNativeMode;
-    private bool _disposed;
-
-    /// <summary>
-    /// Creates a FlowLens model for ONNX inference.
-    /// </summary>
-    public FlowLens(
-        NeuralNetworkArchitecture<T> architecture,
-        string modelPath,
-        FlowLensOptions? options = null)
-        : base(architecture)
-    {
-        if (string.IsNullOrEmpty(modelPath))
-            throw new ArgumentException("Model path cannot be null or empty.", nameof(modelPath));
-        _options = options ?? new FlowLensOptions();
-        _useNativeMode = false;
-        SupportsTemporalPropagation = true;
-        _options.ModelPath = modelPath;
-        OnnxModel = new OnnxModel<T>(modelPath, _options.OnnxOptions);
-        InitializeLayers();
-    }
-
-    /// <summary>
-    /// Creates a FlowLens model for native training and inference.
-    /// </summary>
-    public FlowLens(
-        NeuralNetworkArchitecture<T> architecture,
-        FlowLensOptions? options = null,
-        IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? optimizer = null)
-        : base(architecture)
-    {
-        _options = options ?? new FlowLensOptions();
-        _useNativeMode = true;
-        _optimizer = optimizer ?? new AdamWOptimizer<T, Tensor<T>, Tensor<T>>(this,
-            new AdamWOptimizerOptions<T, Tensor<T>, Tensor<T>>
-            {
-                InitialLearningRate = _options.LearningRate
-            });
-        SupportsTemporalPropagation = true;
-        InitializeLayers();
-    }
-
-    /// <inheritdoc/>
-    public override Tensor<T> Inpaint(Tensor<T> frames, Tensor<T> masks)
-    {
-        ThrowIfDisposed();
-        // Inference MUST apply the same normalize -> concat-mask -> forward -> denormalize pipeline that
-        // ForwardForTraining trains on (and that every sibling model — STTN/AVID/FuseFormer — uses).
-        // Omitting PreprocessFrames/PostprocessOutput here left Predict measuring the model in a
-        // different value space than training optimized, so trained improvements did not show up at
-        // inference (Training_ShouldReduceLoss saw loss go 0.19 -> 0.34 even though the model was
-        // learning identically to STTN).
-        var preprocessed = PreprocessFrames(frames);
-        var combined = ConcatFramesAndMasks(preprocessed, masks);
-        var output = IsOnnxMode ? RunOnnxInference(combined) : Forward(combined);
-        return PostprocessOutput(output);
-    }
-
-    /// <inheritdoc/>
-    protected override void InitializeLayers()
-    {
-        if (!_useNativeMode) return;
-        if (Architecture.Layers is not null && Architecture.Layers.Count > 0)
-        {
-            Layers.AddRange(Architecture.Layers);
-        }
-        else
-        {
-            int ch = Architecture.InputDepth > 0 ? Architecture.InputDepth : 3;
-            int h = Architecture.InputHeight > 0 ? Architecture.InputHeight : 128;
-            int w = Architecture.InputWidth > 0 ? Architecture.InputWidth : 128;
-            Layers.AddRange(LayerHelper<T>.CreateDefaultVideoInpaintingLayers(
-                inputChannels: ch, inputHeight: h, inputWidth: w,
-                numFeatures: _options.NumFeatures));
-        }
-    }
-
-    /// <inheritdoc/>
-    protected override Tensor<T> PreprocessFrames(Tensor<T> rawFrames) => NormalizeInpaintFrames(rawFrames);
-
-    /// <inheritdoc/>
-    protected override Tensor<T> PostprocessOutput(Tensor<T> modelOutput) => DenormalizeInpaintFrames(modelOutput);
-
-
-    /// <inheritdoc/>
-    public override Tensor<T> ForwardForTraining(Tensor<T> input)
-    {
-        // Training must apply the SAME transform inference does (Inpaint): normalize the frames,
-        // concatenate a 1-channel mask (InputDepth -> InputDepth+1 so the encoder conv matches),
-        // run the layer stack, then denormalize. Feeding the raw InputDepth frames straight through
-        // the base would resolve/expect a different first-conv depth than inference AND train in a
-        // different value space, so the two paths would diverge. Delegate the actual layer walk
-        // (autodiff tape, gradient checkpointing, seed-wiring) to the base by handing it the
-        // mask-concatenated tensor; normalize/denormalize are Engine ops so gradients still flow.
-        // Use a fresh RANDOM per-step hole mask (PyTorch video-inpainting recipe). A mask that varies
-        // every step exercises the encoder's mask-channel weights without becoming a constant the model
-        // can exploit as a shortcut — so training keeps using the frame content and stays input-sensitive.
-        // Inference's PredictCore uses the deterministic CreateDefaultInpaintingMask.
-        var mask = CreateTrainingMask(input.Shape[0], input.Shape[2], input.Shape[3]);
-        var combined = ConcatFramesAndMasks(PreprocessFrames(input), mask);
-        return PostprocessOutput(base.ForwardForTraining(combined));
-    }
-
-    /// <inheritdoc/>
-    public override void Train(Tensor<T> input, Tensor<T> expected)
-    {
-        if (IsOnnxMode) throw new NotSupportedException("Training is not supported in ONNX mode.");
-        SetTrainingMode(true);
-        try
-        {
-        TrainWithTape(input, expected, _optimizer);
-        }
-        finally
-        {
-            SetTrainingMode(false);
-        }
-    }
-
-    // UpdateParameters restated the base verbatim; ModelBase routes it to SetParameters.

-
-    /// <summary>
-    /// Parameters cannot be written while the model is backed by a loaded ONNX graph: the weights
-    /// belong to that graph, not to this instance.
-    /// </summary>
-    /// <remarks>
-    /// Replaces a hand-written throw that used to sit inside UpdateParameters. The base checks this
-    /// on every mutating entry point rather than the one member the throw happened to guard, and
-    /// reading -- ParameterCount and GetParameters -- stays available either way.
-    /// </remarks>
+using System.IO;
+using AiDotNet.Attributes;
+using AiDotNet.Enums;
+using AiDotNet.Helpers;
+using AiDotNet.Interfaces;
+using AiDotNet.NeuralNetworks;
+using AiDotNet.Onnx;
+using AiDotNet.Optimizers;
+using AiDotNet.Tensors.LinearAlgebra;
+using AiDotNet.Video.Options;
+
+namespace AiDotNet.Video.Inpainting;
+
+/// <summary>
+/// FlowLens optical-flow-guided video inpainting with flow completion.
+/// </summary>
+/// <typeparam name="T">The numeric type used for calculations.</typeparam>
+/// <remarks>
+/// <para><b>References:</b>
+/// <list type="bullet">
+/// <item>Paper: "FlowLens: Seeing Beyond the FoV via Optical Flow Completion" (Xu et al., ECCV 2022)</item>
+/// </list></para>
+/// <para><b>For Beginners:</b> FlowLens performs video inpainting by using optical flow as a lens to guide content from visible regions into masked areas. It produces temporally consistent fills for removed objects.</para>
+/// <para>
+/// FlowLens decouples motion estimation from pixel synthesis by first completing optical flow
+/// in masked regions, then using the completed flow for temporal propagation of known pixels,
+/// followed by a refinement network for remaining holes, achieving sharp and temporally
+/// consistent inpainting.
+/// </para>
+/// </remarks>
+/// <example>
+/// <code>
+/// // Create a FlowLens model for optical-flow-guided video inpainting
+/// var architecture = new NeuralNetworkArchitecture&lt;double&gt;(
+///     inputType: InputType.ThreeDimensional,
+///     inputHeight: 256, inputWidth: 256, inputDepth: 3);
+/// var options = new FlowLensOptions();
+/// var flowLens = new FlowLens&lt;double&gt;(architecture, options);
+///
+/// // Or load a pre-trained ONNX model for inference
+/// var flowLensOnnx = new FlowLens&lt;double&gt;(architecture, "flowlens_model.onnx");
+/// </code>
+/// </example>
+[ModelDomain(ModelDomain.Video)]
+[ModelDomain(ModelDomain.Vision)]
+[ModelCategory(ModelCategory.NeuralNetwork)]
+[ModelTask(ModelTask.Generation)]
+[ModelComplexity(ModelComplexity.High)]
+[ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
+[ResearchPaper("Beyond the Field-of-View: Enhancing Scene Visibility and Perception with Clip-Recurrent Transformer",
+    "https://arxiv.org/abs/2211.11293",
+    Year = 2022,
+    Authors = "Hao Luo, Peng Zhao, Ling Pei")]
+public partial class FlowLens<T> : VideoInpaintingBase<T>
+{
+    private readonly FlowLensOptions _options;
+
+    /// <inheritdoc/>
+    public override ModelOptions GetOptions() => _options;
+
+    private IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer;
+    private bool _useNativeMode;
+    private bool _disposed;
+
+    /// <summary>
+    /// Creates a FlowLens model for ONNX inference.
+    /// </summary>
+    public FlowLens(
+        NeuralNetworkArchitecture<T> architecture,
+        string modelPath,
+        FlowLensOptions? options = null)
+        : base(architecture)
+    {
+        if (string.IsNullOrEmpty(modelPath))
+            throw new ArgumentException("Model path cannot be null or empty.", nameof(modelPath));
+        _options = options ?? new FlowLensOptions();
+        _useNativeMode = false;
+        SupportsTemporalPropagation = true;
+        _options.ModelPath = modelPath;
+        OnnxModel = new OnnxModel<T>(modelPath, _options.OnnxOptions);
+        InitializeLayers();
+    }
+
+    /// <summary>
+    /// Creates a FlowLens model for native training and inference.
+    /// </summary>
+    public FlowLens(
+        NeuralNetworkArchitecture<T> architecture,
+        FlowLensOptions? options = null,
+        IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? optimizer = null)
+        : base(architecture)
+    {
+        _options = options ?? new FlowLensOptions();
+        _useNativeMode = true;
+        _optimizer = optimizer ?? new AdamWOptimizer<T, Tensor<T>, Tensor<T>>(this,
+            new AdamWOptimizerOptions<T, Tensor<T>, Tensor<T>>
+            {
+                InitialLearningRate = _options.LearningRate
+            });
+        SupportsTemporalPropagation = true;
+        InitializeLayers();
+    }
+
+    /// <inheritdoc/>
+    public override Tensor<T> Inpaint(Tensor<T> frames, Tensor<T> masks)
+    {
+        ThrowIfDisposed();
+        // Inference MUST apply the same normalize -> concat-mask -> forward -> denormalize pipeline that
+        // ForwardForTraining trains on (and that every sibling model — STTN/AVID/FuseFormer — uses).
+        // Omitting PreprocessFrames/PostprocessOutput here left Predict measuring the model in a
+        // different value space than training optimized, so trained improvements did not show up at
+        // inference (Training_ShouldReduceLoss saw loss go 0.19 -> 0.34 even though the model was
+        // learning identically to STTN).
+        var preprocessed = PreprocessFrames(frames);
+        var combined = ConcatFramesAndMasks(preprocessed, masks);
+        var output = IsOnnxMode ? RunOnnxInference(combined) : Forward(combined);
+        return PostprocessOutput(output);
+    }
+
+    /// <inheritdoc/>
+    protected override void InitializeLayers()
+    {
+        if (!_useNativeMode) return;
+        if (Architecture.Layers is not null && Architecture.Layers.Count > 0)
+        {
+            Layers.AddRange(Architecture.Layers);
+        }
+        else
+        {
+            int ch = Architecture.InputDepth > 0 ? Architecture.InputDepth : 3;
+            int h = Architecture.InputHeight > 0 ? Architecture.InputHeight : 128;
+            int w = Architecture.InputWidth > 0 ? Architecture.InputWidth : 128;
+            Layers.AddRange(LayerHelper<T>.CreateDefaultVideoInpaintingLayers(
+                inputChannels: ch, inputHeight: h, inputWidth: w,
+                numFeatures: _options.NumFeatures));
+        }
+    }
+
+    /// <inheritdoc/>
+    protected override Tensor<T> PreprocessFrames(Tensor<T> rawFrames) => NormalizeInpaintFrames(rawFrames);
+
+    /// <inheritdoc/>
+    protected override Tensor<T> PostprocessOutput(Tensor<T> modelOutput) => DenormalizeInpaintFrames(modelOutput);
+
+
+    /// <inheritdoc/>
+    public override Tensor<T> ForwardForTraining(Tensor<T> input)
+    {
+        // Training must apply the SAME transform inference does (Inpaint): normalize the frames,
+        // concatenate a 1-channel mask (InputDepth -> InputDepth+1 so the encoder conv matches),
+        // run the layer stack, then denormalize. Feeding the raw InputDepth frames straight through
+        // the base would resolve/expect a different first-conv depth than inference AND train in a
+        // different value space, so the two paths would diverge. Delegate the actual layer walk
+        // (autodiff tape, gradient checkpointing, seed-wiring) to the base by handing it the
+        // mask-concatenated tensor; normalize/denormalize are Engine ops so gradients still flow.
+        // Use a fresh RANDOM per-step hole mask (PyTorch video-inpainting recipe). A mask that varies
+        // every step exercises the encoder's mask-channel weights without becoming a constant the model
+        // can exploit as a shortcut — so training keeps using the frame content and stays input-sensitive.
+        // Inference's PredictCore uses the deterministic CreateDefaultInpaintingMask.
+        var mask = CreateTrainingMask(input.Shape[0], input.Shape[2], input.Shape[3]);
+        var combined = ConcatFramesAndMasks(PreprocessFrames(input), mask);
+        return PostprocessOutput(base.ForwardForTraining(combined));
+    }
+
+    /// <inheritdoc/>
+    public override void Train(Tensor<T> input, Tensor<T> expected)
+    {
+        if (IsOnnxMode) throw new NotSupportedException("Training is not supported in ONNX mode.");
+        SetTrainingMode(true);
+        try
+        {
+        TrainWithTape(input, expected, _optimizer);
+        }
+        finally
+        {
+            SetTrainingMode(false);
+        }
+    }
+
+    // UpdateParameters restated the base verbatim; ModelBase routes it to SetParameters.
+
+
+    /// <summary>
+    /// Parameters cannot be written while the model is backed by a loaded ONNX graph: the weights
+    /// belong to that graph, not to this instance.
+    /// </summary>
+    /// <remarks>
+    /// Replaces a hand-written throw that used to sit inside UpdateParameters. The base checks this
+    /// on every mutating entry point rather than the one member the throw happened to guard, and
+    /// reading -- ParameterCount and GetParameters -- stays available either way.
+    /// </remarks>
     protected override bool SupportsParameterMutation => _useNativeMode;
-    /// <inheritdoc/>
-    public override ModelMetadata<T> GetModelMetadata()
-    {
-        return new ModelMetadata<T>
-        {
-            AdditionalInfo = new Dictionary<string, object>
-            {
-                { "ModelName", "FlowLens" },
-                { "Variant", _options.Variant.ToString() },
-                { "NumFeatures", _options.NumFeatures },
-                { "NumFlowIters", _options.NumFlowIters },
-                { "NumLevels", _options.NumLevels },
-                { "NumResBlocks", _options.NumResBlocks }
-            },
-            ModelData = SerializeForMetadata()
-        };
-    }
-
-    /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write((int)_options.Variant);
-        writer.Write(_options.NumFeatures);
-        writer.Write(_options.NumFlowIters);
-        writer.Write(_options.NumLevels);
-        writer.Write(_options.NumResBlocks);
-        writer.Write(_options.LearningRate);
-        writer.Write(_options.DropoutRate);
-    }
-
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _options.Variant = (VideoModelVariant)reader.ReadInt32();
-        _options.NumFeatures = reader.ReadInt32();
-        _options.NumFlowIters = reader.ReadInt32();
-        _options.NumLevels = reader.ReadInt32();
-        _options.NumResBlocks = reader.ReadInt32();
-        _options.LearningRate = reader.ReadDouble();
-        _options.DropoutRate = reader.ReadDouble();
-    }
-
-    /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            return new FlowLens<T>(Architecture, p, _options);
-        return new FlowLens<T>(Architecture, _options);
-    }
-
-    private static Tensor<T> ConcatFramesAndMasks(Tensor<T> frames, Tensor<T> masks)
-    {
-        if (frames.Rank != 4)
-            throw new ArgumentException($"Frames must be rank 4 [N, C, H, W], got rank {frames.Rank}.", nameof(frames));
-        if (masks.Rank != 4)
-            throw new ArgumentException($"Masks must be rank 4 [N, 1, H, W], got rank {masks.Rank}.", nameof(masks));
-        int n = frames.Shape[0];
-        int c = frames.Shape[1];
-        int h = frames.Shape[2];
-        int w = frames.Shape[3];
-        if (masks.Shape[0] != n || masks.Shape[2] != h || masks.Shape[3] != w)
-            throw new ArgumentException($"Masks spatial dimensions must match frames. Frames: [{n},{c},{h},{w}], Masks: [{masks.Shape[0]},{masks.Shape[1]},{masks.Shape[2]},{masks.Shape[3]}].", nameof(masks));
-        var combined = new Tensor<T>([n, c + 1, h, w]);
-        int frameSize = c * h * w;
-        int maskSize = h * w;
-        int combinedSize = (c + 1) * h * w;
-        for (int f = 0; f < n; f++)
-        {
-            for (int i = 0; i < frameSize; i++)
-                combined.Data.Span[f * combinedSize + i] = frames.Data.Span[f * frameSize + i];
-            for (int i = 0; i < maskSize; i++)
-                combined.Data.Span[f * combinedSize + frameSize + i] = masks.Data.Span[f * maskSize + i];
-        }
-        return combined;
-    }
-
-    private void ThrowIfDisposed()
-    {
-        if (_disposed) throw new ObjectDisposedException(GetType().FullName ?? nameof(FlowLens<T>));
-    }
-
-    /// <inheritdoc/>
-    protected override void Dispose(bool disposing)
-    {
-        if (_disposed) return;
-        _disposed = true;
-        if (disposing) OnnxModel?.Dispose();
-        base.Dispose(disposing);
-    }
-}
+    /// <inheritdoc/>
+    public override ModelMetadata<T> GetModelMetadata()
+    {
+        return new ModelMetadata<T>
+        {
+            AdditionalInfo = new Dictionary<string, object>
+            {
+                { "ModelName", "FlowLens" },
+                { "Variant", _options.Variant.ToString() },
+                { "NumFeatures", _options.NumFeatures },
+                { "NumFlowIters", _options.NumFlowIters },
+                { "NumLevels", _options.NumLevels },
+                { "NumResBlocks", _options.NumResBlocks }
+            },
+            ModelData = SerializeForMetadata()
+        };
+    }
+
+    /// <inheritdoc/>
+
+
+    /// <inheritdoc/>
+
+
+    private static Tensor<T> ConcatFramesAndMasks(Tensor<T> frames, Tensor<T> masks)
+    {
+        if (frames.Rank != 4)
+            throw new ArgumentException($"Frames must be rank 4 [N, C, H, W], got rank {frames.Rank}.", nameof(frames));
+        if (masks.Rank != 4)
+            throw new ArgumentException($"Masks must be rank 4 [N, 1, H, W], got rank {masks.Rank}.", nameof(masks));
+        int n = frames.Shape[0];
+        int c = frames.Shape[1];
+        int h = frames.Shape[2];
+        int w = frames.Shape[3];
+        if (masks.Shape[0] != n || masks.Shape[2] != h || masks.Shape[3] != w)
+            throw new ArgumentException($"Masks spatial dimensions must match frames. Frames: [{n},{c},{h},{w}], Masks: [{masks.Shape[0]},{masks.Shape[1]},{masks.Shape[2]},{masks.Shape[3]}].", nameof(masks));
+        var combined = new Tensor<T>([n, c + 1, h, w]);
+        int frameSize = c * h * w;
+        int maskSize = h * w;
+        int combinedSize = (c + 1) * h * w;
+        for (int f = 0; f < n; f++)
+        {
+            for (int i = 0; i < frameSize; i++)
+                combined.Data.Span[f * combinedSize + i] = frames.Data.Span[f * frameSize + i];
+            for (int i = 0; i < maskSize; i++)
+                combined.Data.Span[f * combinedSize + frameSize + i] = masks.Data.Span[f * maskSize + i];
+        }
+        return combined;
+    }
+
+    private void ThrowIfDisposed()
+    {
+        if (_disposed) throw new ObjectDisposedException(GetType().FullName ?? nameof(FlowLens<T>));
+    }
+
+    /// <inheritdoc/>
+    protected override void Dispose(bool disposing)
+    {
+        if (_disposed) return;
+        _disposed = true;
+        if (disposing) OnnxModel?.Dispose();
+        base.Dispose(disposing);
+    }
+}
diff --git a/src/Video/Inpainting/FuseFormer.cs b/src/Video/Inpainting/FuseFormer.cs
index e69ef08a0e..283eed2f2c 100644
--- a/src/Video/Inpainting/FuseFormer.cs
+++ b/src/Video/Inpainting/FuseFormer.cs
@@ -1,277 +1,252 @@
-using System.IO;
-using AiDotNet.Attributes;
-using AiDotNet.Enums;
-using AiDotNet.Helpers;
-using AiDotNet.Interfaces;
-using AiDotNet.NeuralNetworks;
-using AiDotNet.Onnx;
-using AiDotNet.Optimizers;
-using AiDotNet.Tensors.LinearAlgebra;
-using AiDotNet.Video.Options;
-
-namespace AiDotNet.Video.Inpainting;
-
-/// <summary>
-/// FuseFormer transformer-based video inpainting with fine-grained spatial-temporal fusion.
-/// </summary>
-/// <typeparam name="T">The numeric type used for calculations.</typeparam>
-/// <remarks>
-/// <para><b>References:</b>
-/// <list type="bullet">
-/// <item>Paper: "FuseFormer: Fusing Fine-Grained Information in Transformers for Video Inpainting" (Liu et al., ICCV 2021)</item>
-/// </list></para>
-/// <para><b>For Beginners:</b> FuseFormer uses transformer attention to fuse information from multiple frames for video inpainting. It fills missing regions by attending to relevant visible content across the entire video.</para>
-/// <para>
-/// FuseFormer applies soft split and soft composition operations within a transformer encoder
-/// to fuse fine-grained spatial-temporal features from overlapping patches, attending to both
-/// local texture details and global structure across frames for high-quality inpainting.
-/// </para>
-/// </remarks>
-/// <example>
-/// <code>
-/// // Create a FuseFormer model for transformer-based video inpainting
-/// var architecture = new NeuralNetworkArchitecture&lt;double&gt;(
-///     inputType: InputType.ThreeDimensional,
-///     inputHeight: 256, inputWidth: 256, inputDepth: 3);
-/// var options = new FuseFormerOptions();
-/// var fuseFormer = new FuseFormer&lt;double&gt;(architecture, options);
-///
-/// // Or load a pre-trained ONNX model for inference
-/// var fuseFormerOnnx = new FuseFormer&lt;double&gt;(architecture, "fuseformer_model.onnx");
-/// </code>
-/// </example>
-[ModelDomain(ModelDomain.Video)]
-[ModelDomain(ModelDomain.Vision)]
-[ModelCategory(ModelCategory.NeuralNetwork)]
-[ModelCategory(ModelCategory.Transformer)]
-[ModelTask(ModelTask.Generation)]
-[ModelComplexity(ModelComplexity.High)]
-[ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
-[ResearchPaper("FuseFormer: Fusing Fine-Grained Information in Transformers for Video Inpainting",
-    "https://arxiv.org/abs/2109.02974",
-    Year = 2021,
-    Authors = "Rui Liu, Hanming Deng, Yangyi Huang, Xiaoyu Shi, Lewei Lu, Wenxiu Sun, Xiaogang Wang, Jifeng Dai, Hongsheng Li")]
-public class FuseFormer<T> : VideoInpaintingBase<T>
-{
-    private readonly FuseFormerOptions _options;
-
-    /// <inheritdoc/>
-    public override ModelOptions GetOptions() => _options;
-
-    private IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer;
-    private bool _useNativeMode;
-    private bool _disposed;
-
-    /// <summary>
-    /// Creates a FuseFormer model for ONNX inference.
-    /// </summary>
-    public FuseFormer(
-        NeuralNetworkArchitecture<T> architecture,
-        string modelPath,
-        FuseFormerOptions? options = null)
-        : base(architecture)
-    {
-        if (string.IsNullOrEmpty(modelPath))
-            throw new ArgumentException("Model path cannot be null or empty.", nameof(modelPath));
-        _options = options ?? new FuseFormerOptions();
-        _useNativeMode = false;
-        SupportsTemporalPropagation = true;
-        _options.ModelPath = modelPath;
-        OnnxModel = new OnnxModel<T>(modelPath, _options.OnnxOptions);
-        InitializeLayers();
-    }
-
-    /// <summary>
-    /// Creates a FuseFormer model for native training and inference.
-    /// </summary>
-    public FuseFormer(
-        NeuralNetworkArchitecture<T> architecture,
-        FuseFormerOptions? options = null,
-        IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? optimizer = null)
-        : base(architecture)
-    {
-        _options = options ?? new FuseFormerOptions();
-        _useNativeMode = true;
-        _optimizer = optimizer ?? new AdamWOptimizer<T, Tensor<T>, Tensor<T>>(this,
-            new AdamWOptimizerOptions<T, Tensor<T>, Tensor<T>>
-            {
-                InitialLearningRate = _options.LearningRate
-            });
-        SupportsTemporalPropagation = true;
-        InitializeLayers();
-    }
-
-    /// <inheritdoc/>
-    public override Tensor<T> Inpaint(Tensor<T> frames, Tensor<T> masks)
-    {
-        ThrowIfDisposed();
-        var preprocessed = PreprocessFrames(frames);
-        var combined = ConcatFramesAndMasks(preprocessed, masks);
-        var output = IsOnnxMode ? RunOnnxInference(combined) : Forward(combined);
-        return PostprocessOutput(output);
-    }
-
-    /// <inheritdoc/>
-    protected override void InitializeLayers()
-    {
-        if (!_useNativeMode) return;
-        if (Architecture.Layers is not null && Architecture.Layers.Count > 0)
-        {
-            Layers.AddRange(Architecture.Layers);
-        }
-        else
-        {
-            int ch = Architecture.InputDepth > 0 ? Architecture.InputDepth : 3;
-            int h = Architecture.InputHeight > 0 ? Architecture.InputHeight : 128;
-            int w = Architecture.InputWidth > 0 ? Architecture.InputWidth : 128;
-            Layers.AddRange(LayerHelper<T>.CreateDefaultVideoInpaintingLayers(
-                inputChannels: ch, inputHeight: h, inputWidth: w,
-                numFeatures: _options.NumFeatures));
-        }
-    }
-
-    /// <inheritdoc/>
-    protected override Tensor<T> PreprocessFrames(Tensor<T> rawFrames) => NormalizeInpaintFrames(rawFrames);
-
-    /// <inheritdoc/>
-    protected override Tensor<T> PostprocessOutput(Tensor<T> modelOutput) => DenormalizeInpaintFrames(modelOutput);
-
-
-    /// <inheritdoc/>
-    public override Tensor<T> ForwardForTraining(Tensor<T> input)
-    {
-        // Training must apply the SAME transform inference does (Inpaint): normalize the frames,
-        // concatenate a 1-channel mask (InputDepth -> InputDepth+1 so the encoder conv matches),
-        // run the layer stack, then denormalize. Feeding the raw InputDepth frames straight through
-        // the base would resolve/expect a different first-conv depth than inference AND train in a
-        // different value space, so the two paths would diverge. Delegate the actual layer walk
-        // (autodiff tape, gradient checkpointing, seed-wiring) to the base by handing it the
-        // mask-concatenated tensor; normalize/denormalize are Engine ops so gradients still flow.
-        // Use a fresh RANDOM per-step hole mask (PyTorch video-inpainting recipe). A mask that varies
-        // every step exercises the encoder's mask-channel weights without becoming a constant the model
-        // can exploit as a shortcut — so training keeps using the frame content and stays input-sensitive.
-        // Inference's PredictCore uses the deterministic CreateDefaultInpaintingMask.
-        var mask = CreateTrainingMask(input.Shape[0], input.Shape[2], input.Shape[3]);
-        var combined = ConcatFramesAndMasks(PreprocessFrames(input), mask);
-        return PostprocessOutput(base.ForwardForTraining(combined));
-    }
-
-    /// <inheritdoc/>
-    public override void Train(Tensor<T> input, Tensor<T> expected)
-    {
-        if (IsOnnxMode) throw new NotSupportedException("Training is not supported in ONNX mode.");
-        SetTrainingMode(true);
-        try
-        {
-        TrainWithTape(input, expected, _optimizer);
-        }
-        finally
-        {
-            SetTrainingMode(false);
-        }
-    }
-
-    // UpdateParameters restated the base verbatim; ModelBase routes it to SetParameters.

-
-    /// <summary>
-    /// Parameters cannot be written while the model is backed by a loaded ONNX graph: the weights
-    /// belong to that graph, not to this instance.
-    /// </summary>
-    /// <remarks>
-    /// Replaces a hand-written throw that used to sit inside UpdateParameters. The base checks this
-    /// on every mutating entry point rather than the one member the throw happened to guard, and
-    /// reading -- ParameterCount and GetParameters -- stays available either way.
-    /// </remarks>
+using System.IO;
+using AiDotNet.Attributes;
+using AiDotNet.Enums;
+using AiDotNet.Helpers;
+using AiDotNet.Interfaces;
+using AiDotNet.NeuralNetworks;
+using AiDotNet.Onnx;
+using AiDotNet.Optimizers;
+using AiDotNet.Tensors.LinearAlgebra;
+using AiDotNet.Video.Options;
+
+namespace AiDotNet.Video.Inpainting;
+
+/// <summary>
+/// FuseFormer transformer-based video inpainting with fine-grained spatial-temporal fusion.
+/// </summary>
+/// <typeparam name="T">The numeric type used for calculations.</typeparam>
+/// <remarks>
+/// <para><b>References:</b>
+/// <list type="bullet">
+/// <item>Paper: "FuseFormer: Fusing Fine-Grained Information in Transformers for Video Inpainting" (Liu et al., ICCV 2021)</item>
+/// </list></para>
+/// <para><b>For Beginners:</b> FuseFormer uses transformer attention to fuse information from multiple frames for video inpainting. It fills missing regions by attending to relevant visible content across the entire video.</para>
+/// <para>
+/// FuseFormer applies soft split and soft composition operations within a transformer encoder
+/// to fuse fine-grained spatial-temporal features from overlapping patches, attending to both
+/// local texture details and global structure across frames for high-quality inpainting.
+/// </para>
+/// </remarks>
+/// <example>
+/// <code>
+/// // Create a FuseFormer model for transformer-based video inpainting
+/// var architecture = new NeuralNetworkArchitecture&lt;double&gt;(
+///     inputType: InputType.ThreeDimensional,
+///     inputHeight: 256, inputWidth: 256, inputDepth: 3);
+/// var options = new FuseFormerOptions();
+/// var fuseFormer = new FuseFormer&lt;double&gt;(architecture, options);
+///
+/// // Or load a pre-trained ONNX model for inference
+/// var fuseFormerOnnx = new FuseFormer&lt;double&gt;(architecture, "fuseformer_model.onnx");
+/// </code>
+/// </example>
+[ModelDomain(ModelDomain.Video)]
+[ModelDomain(ModelDomain.Vision)]
+[ModelCategory(ModelCategory.NeuralNetwork)]
+[ModelCategory(ModelCategory.Transformer)]
+[ModelTask(ModelTask.Generation)]
+[ModelComplexity(ModelComplexity.High)]
+[ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
+[ResearchPaper("FuseFormer: Fusing Fine-Grained Information in Transformers for Video Inpainting",
+    "https://arxiv.org/abs/2109.02974",
+    Year = 2021,
+    Authors = "Rui Liu, Hanming Deng, Yangyi Huang, Xiaoyu Shi, Lewei Lu, Wenxiu Sun, Xiaogang Wang, Jifeng Dai, Hongsheng Li")]
+public partial class FuseFormer<T> : VideoInpaintingBase<T>
+{
+    private readonly FuseFormerOptions _options;
+
+    /// <inheritdoc/>
+    public override ModelOptions GetOptions() => _options;
+
+    private IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer;
+    private bool _useNativeMode;
+    private bool _disposed;
+
+    /// <summary>
+    /// Creates a FuseFormer model for ONNX inference.
+    /// </summary>
+    public FuseFormer(
+        NeuralNetworkArchitecture<T> architecture,
+        string modelPath,
+        FuseFormerOptions? options = null)
+        : base(architecture)
+    {
+        if (string.IsNullOrEmpty(modelPath))
+            throw new ArgumentException("Model path cannot be null or empty.", nameof(modelPath));
+        _options = options ?? new FuseFormerOptions();
+        _useNativeMode = false;
+        SupportsTemporalPropagation = true;
+        _options.ModelPath = modelPath;
+        OnnxModel = new OnnxModel<T>(modelPath, _options.OnnxOptions);
+        InitializeLayers();
+    }
+
+    /// <summary>
+    /// Creates a FuseFormer model for native training and inference.
+    /// </summary>
+    public FuseFormer(
+        NeuralNetworkArchitecture<T> architecture,
+        FuseFormerOptions? options = null,
+        IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? optimizer = null)
+        : base(architecture)
+    {
+        _options = options ?? new FuseFormerOptions();
+        _useNativeMode = true;
+        _optimizer = optimizer ?? new AdamWOptimizer<T, Tensor<T>, Tensor<T>>(this,
+            new AdamWOptimizerOptions<T, Tensor<T>, Tensor<T>>
+            {
+                InitialLearningRate = _options.LearningRate
+            });
+        SupportsTemporalPropagation = true;
+        InitializeLayers();
+    }
+
+    /// <inheritdoc/>
+    public override Tensor<T> Inpaint(Tensor<T> frames, Tensor<T> masks)
+    {
+        ThrowIfDisposed();
+        var preprocessed = PreprocessFrames(frames);
+        var combined = ConcatFramesAndMasks(preprocessed, masks);
+        var output = IsOnnxMode ? RunOnnxInference(combined) : Forward(combined);
+        return PostprocessOutput(output);
+    }
+
+    /// <inheritdoc/>
+    protected override void InitializeLayers()
+    {
+        if (!_useNativeMode) return;
+        if (Architecture.Layers is not null && Architecture.Layers.Count > 0)
+        {
+            Layers.AddRange(Architecture.Layers);
+        }
+        else
+        {
+            int ch = Architecture.InputDepth > 0 ? Architecture.InputDepth : 3;
+            int h = Architecture.InputHeight > 0 ? Architecture.InputHeight : 128;
+            int w = Architecture.InputWidth > 0 ? Architecture.InputWidth : 128;
+            Layers.AddRange(LayerHelper<T>.CreateDefaultVideoInpaintingLayers(
+                inputChannels: ch, inputHeight: h, inputWidth: w,
+                numFeatures: _options.NumFeatures));
+        }
+    }
+
+    /// <inheritdoc/>
+    protected override Tensor<T> PreprocessFrames(Tensor<T> rawFrames) => NormalizeInpaintFrames(rawFrames);
+
+    /// <inheritdoc/>
+    protected override Tensor<T> PostprocessOutput(Tensor<T> modelOutput) => DenormalizeInpaintFrames(modelOutput);
+
+
+    /// <inheritdoc/>
+    public override Tensor<T> ForwardForTraining(Tensor<T> input)
+    {
+        // Training must apply the SAME transform inference does (Inpaint): normalize the frames,
+        // concatenate a 1-channel mask (InputDepth -> InputDepth+1 so the encoder conv matches),
+        // run the layer stack, then denormalize. Feeding the raw InputDepth frames straight through
+        // the base would resolve/expect a different first-conv depth than inference AND train in a
+        // different value space, so the two paths would diverge. Delegate the actual layer walk
+        // (autodiff tape, gradient checkpointing, seed-wiring) to the base by handing it the
+        // mask-concatenated tensor; normalize/denormalize are Engine ops so gradients still flow.
+        // Use a fresh RANDOM per-step hole mask (PyTorch video-inpainting recipe). A mask that varies
+        // every step exercises the encoder's mask-channel weights without becoming a constant the model
+        // can exploit as a shortcut — so training keeps using the frame content and stays input-sensitive.
+        // Inference's PredictCore uses the deterministic CreateDefaultInpaintingMask.
+        var mask = CreateTrainingMask(input.Shape[0], input.Shape[2], input.Shape[3]);
+        var combined = ConcatFramesAndMasks(PreprocessFrames(input), mask);
+        return PostprocessOutput(base.ForwardForTraining(combined));
+    }
+
+    /// <inheritdoc/>
+    public override void Train(Tensor<T> input, Tensor<T> expected)
+    {
+        if (IsOnnxMode) throw new NotSupportedException("Training is not supported in ONNX mode.");
+        SetTrainingMode(true);
+        try
+        {
+        TrainWithTape(input, expected, _optimizer);
+        }
+        finally
+        {
+            SetTrainingMode(false);
+        }
+    }
+
+    // UpdateParameters restated the base verbatim; ModelBase routes it to SetParameters.
+
+
+    /// <summary>
+    /// Parameters cannot be written while the model is backed by a loaded ONNX graph: the weights
+    /// belong to that graph, not to this instance.
+    /// </summary>
+    /// <remarks>
+    /// Replaces a hand-written throw that used to sit inside UpdateParameters. The base checks this
+    /// on every mutating entry point rather than the one member the throw happened to guard, and
+    /// reading -- ParameterCount and GetParameters -- stays available either way.
+    /// </remarks>
     protected override bool SupportsParameterMutation => _useNativeMode;
-    /// <inheritdoc/>
-    public override ModelMetadata<T> GetModelMetadata()
-    {
-        return new ModelMetadata<T>
-        {
-            AdditionalInfo = new Dictionary<string, object>
-            {
-                { "ModelName", "FuseFormer" },
-                { "Variant", _options.Variant.ToString() },
-                { "NumFeatures", _options.NumFeatures },
-                { "NumTransformerLayers", _options.NumTransformerLayers },
-                { "NumHeads", _options.NumHeads },
-                { "PatchSize", _options.PatchSize }
-            },
-            ModelData = SerializeForMetadata()
-        };
-    }
-
-    /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write((int)_options.Variant);
-        writer.Write(_options.NumFeatures);
-        writer.Write(_options.NumTransformerLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.PatchSize);
-        writer.Write(_options.LearningRate);
-        writer.Write(_options.DropoutRate);
-    }
-
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _options.Variant = (VideoModelVariant)reader.ReadInt32();
-        _options.NumFeatures = reader.ReadInt32();
-        _options.NumTransformerLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.PatchSize = reader.ReadInt32();
-        _options.LearningRate = reader.ReadDouble();
-        _options.DropoutRate = reader.ReadDouble();
-    }
-
-    /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            return new FuseFormer<T>(Architecture, p, _options);
-        return new FuseFormer<T>(Architecture, _options);
-    }
-
-    private static Tensor<T> ConcatFramesAndMasks(Tensor<T> frames, Tensor<T> masks)
-    {
-        if (frames.Rank != 4)
-            throw new ArgumentException($"Frames must be rank 4 [N, C, H, W], got rank {frames.Rank}.", nameof(frames));
-        if (masks.Rank != 4)
-            throw new ArgumentException($"Masks must be rank 4 [N, 1, H, W], got rank {masks.Rank}.", nameof(masks));
-        if (masks.Shape[1] != 1)
-            throw new ArgumentException($"Masks must be single-channel [N, 1, H, W], got {masks.Shape[1]} channels.", nameof(masks));
-        int n = frames.Shape[0];
-        int c = frames.Shape[1];
-        int h = frames.Shape[2];
-        int w = frames.Shape[3];
-        if (masks.Shape[0] != n || masks.Shape[2] != h || masks.Shape[3] != w)
-            throw new ArgumentException($"Masks spatial dimensions must match frames. Frames: [{n},{c},{h},{w}], Masks: [{masks.Shape[0]},{masks.Shape[1]},{masks.Shape[2]},{masks.Shape[3]}].", nameof(masks));
-        var combined = new Tensor<T>([n, c + 1, h, w]);
-        int frameSize = c * h * w;
-        int maskSize = h * w;
-        int combinedSize = (c + 1) * h * w;
-        for (int f = 0; f < n; f++)
-        {
-            for (int i = 0; i < frameSize; i++)
-                combined.Data.Span[f * combinedSize + i] = frames.Data.Span[f * frameSize + i];
-            for (int i = 0; i < maskSize; i++)
-                combined.Data.Span[f * combinedSize + frameSize + i] = masks.Data.Span[f * maskSize + i];
-        }
-        return combined;
-    }
-
-    private void ThrowIfDisposed()
-    {
-        if (_disposed) throw new ObjectDisposedException(GetType().FullName ?? nameof(FuseFormer<T>));
-    }
-
-    /// <inheritdoc/>
-    protected override void Dispose(bool disposing)
-    {
-        if (_disposed) return;
-        _disposed = true;
-        if (disposing) OnnxModel?.Dispose();
-        base.Dispose(disposing);
-    }
-}
+    /// <inheritdoc/>
+    public override ModelMetadata<T> GetModelMetadata()
+    {
+        return new ModelMetadata<T>
+        {
+            AdditionalInfo = new Dictionary<string, object>
+            {
+                { "ModelName", "FuseFormer" },
+                { "Variant", _options.Variant.ToString() },
+                { "NumFeatures", _options.NumFeatures },
+                { "NumTransformerLayers", _options.NumTransformerLayers },
+                { "NumHeads", _options.NumHeads },
+                { "PatchSize", _options.PatchSize }
+            },
+            ModelData = SerializeForMetadata()
+        };
+    }
+
+    /// <inheritdoc/>
+
+
+    /// <inheritdoc/>
+
+
+    private static Tensor<T> ConcatFramesAndMasks(Tensor<T> frames, Tensor<T> masks)
+    {
+        if (frames.Rank != 4)
+            throw new ArgumentException($"Frames must be rank 4 [N, C, H, W], got rank {frames.Rank}.", nameof(frames));
+        if (masks.Rank != 4)
+            throw new ArgumentException($"Masks must be rank 4 [N, 1, H, W], got rank {masks.Rank}.", nameof(masks));
+        if (masks.Shape[1] != 1)
+            throw new ArgumentException($"Masks must be single-channel [N, 1, H, W], got {masks.Shape[1]} channels.", nameof(masks));
+        int n = frames.Shape[0];
+        int c = frames.Shape[1];
+        int h = frames.Shape[2];
+        int w = frames.Shape[3];
+        if (masks.Shape[0] != n || masks.Shape[2] != h || masks.Shape[3] != w)
+            throw new ArgumentException($"Masks spatial dimensions must match frames. Frames: [{n},{c},{h},{w}], Masks: [{masks.Shape[0]},{masks.Shape[1]},{masks.Shape[2]},{masks.Shape[3]}].", nameof(masks));
+        var combined = new Tensor<T>([n, c + 1, h, w]);
+        int frameSize = c * h * w;
+        int maskSize = h * w;
+        int combinedSize = (c + 1) * h * w;
+        for (int f = 0; f < n; f++)
+        {
+            for (int i = 0; i < frameSize; i++)
+                combined.Data.Span[f * combinedSize + i] = frames.Data.Span[f * frameSize + i];
+            for (int i = 0; i < maskSize; i++)
+                combined.Data.Span[f * combinedSize + frameSize + i] = masks.Data.Span[f * maskSize + i];
+        }
+        return combined;
+    }
+
+    private void ThrowIfDisposed()
+    {
+        if (_disposed) throw new ObjectDisposedException(GetType().FullName ?? nameof(FuseFormer<T>));
+    }
+
+    /// <inheritdoc/>
+    protected override void Dispose(bool disposing)
+    {
+        if (_disposed) return;
+        _disposed = true;
+        if (disposing) OnnxModel?.Dispose();
+        base.Dispose(disposing);
+    }
+}
diff --git a/src/Video/Inpainting/ProPainter.cs b/src/Video/Inpainting/ProPainter.cs
index 9ac9e16d1b..0a0d37a5ed 100644
--- a/src/Video/Inpainting/ProPainter.cs
+++ b/src/Video/Inpainting/ProPainter.cs
@@ -1005,35 +1005,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_height);
-        writer.Write(_width);
-        writer.Write(_channels);
-        writer.Write(_numFeatures);
-    }
 
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _ = reader.ReadInt32();
-        _ = reader.ReadInt32();
-        _ = reader.ReadInt32();
-        _ = reader.ReadInt32();
-
-        // The base deserialize replaced Layers with freshly-created layer objects, so the cached
-        // per-role sublist fields the forward path reads (_imageEncoder, _transformerQKV, _outputConv,
-        // ...) are stale (they still point at the CreateNewInstance random-init layers). Re-link them
-        // to the deserialized Layers so a cloned/loaded model predicts with the restored weights.
-        if (Layers.Count > 0)
-            DistributeLayersToSubLists();
-    }
 
     /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new ProPainter<T>(Architecture, _numFeatures, _numTransformerBlocks, _numHeads);
-    }
+
 
     #endregion
 
diff --git a/src/Video/Inpainting/STTN.cs b/src/Video/Inpainting/STTN.cs
index 541913eb75..e33c931166 100644
--- a/src/Video/Inpainting/STTN.cs
+++ b/src/Video/Inpainting/STTN.cs
@@ -1,277 +1,252 @@
-using System.IO;
-using AiDotNet.Attributes;
-using AiDotNet.Enums;
-using AiDotNet.Helpers;
-using AiDotNet.Interfaces;
-using AiDotNet.NeuralNetworks;
-using AiDotNet.Onnx;
-using AiDotNet.Optimizers;
-using AiDotNet.Tensors.LinearAlgebra;
-using AiDotNet.Video.Options;
-
-namespace AiDotNet.Video.Inpainting;
-
-/// <summary>
-/// STTN spatial-temporal transformer network for video inpainting with multi-scale attention.
-/// </summary>
-/// <typeparam name="T">The numeric type used for calculations.</typeparam>
-/// <remarks>
-/// <para><b>References:</b>
-/// <list type="bullet">
-/// <item>Paper: "Learning Joint Spatial-Temporal Transformations for Video Inpainting" (Zeng et al., ECCV 2020)</item>
-/// </list></para>
-/// <para><b>For Beginners:</b> STTN (Spatial-Temporal Transformer Network) performs video inpainting using transformers that jointly attend to spatial and temporal dimensions to fill holes consistently across frames.</para>
-/// <para>
-/// STTN uses multi-scale spatial-temporal transformers that jointly search for and attend to
-/// relevant patches across both space and time dimensions. Multi-head attention at multiple
-/// feature scales enables both fine-grained texture transfer and large-scale structure completion.
-/// </para>
-/// </remarks>
-/// <example>
-/// <code>
-/// // Create an STTN model for spatial-temporal video inpainting
-/// var architecture = new NeuralNetworkArchitecture&lt;double&gt;(
-///     inputType: InputType.ThreeDimensional,
-///     inputHeight: 256, inputWidth: 256, inputDepth: 3);
-/// var options = new STTNOptions();
-/// var sttn = new STTN&lt;double&gt;(architecture, options);
-///
-/// // Or load a pre-trained ONNX model for inference
-/// var sttnOnnx = new STTN&lt;double&gt;(architecture, "sttn_model.onnx");
-/// </code>
-/// </example>
-[ModelDomain(ModelDomain.Video)]
-[ModelDomain(ModelDomain.Vision)]
-[ModelCategory(ModelCategory.NeuralNetwork)]
-[ModelCategory(ModelCategory.Transformer)]
-[ModelTask(ModelTask.Generation)]
-[ModelComplexity(ModelComplexity.High)]
-[ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
-[ResearchPaper("Learning Joint Spatial-Temporal Transformations for Video Inpainting",
-    "https://arxiv.org/abs/2007.10247",
-    Year = 2020,
-    Authors = "Yanhong Zeng, Jianlong Fu, Hongyang Chao")]
-public class STTN<T> : VideoInpaintingBase<T>
-{
-    private readonly STTNOptions _options;
-
-    /// <inheritdoc/>
-    public override ModelOptions GetOptions() => _options;
-
-    private IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer;
-    private bool _useNativeMode;
-    private bool _disposed;
-
-    /// <summary>
-    /// Creates a STTN model for ONNX inference.
-    /// </summary>
-    public STTN(
-        NeuralNetworkArchitecture<T> architecture,
-        string modelPath,
-        STTNOptions? options = null)
-        : base(architecture)
-    {
-        if (string.IsNullOrEmpty(modelPath))
-            throw new ArgumentException("Model path cannot be null or empty.", nameof(modelPath));
-        _options = options ?? new STTNOptions();
-        _useNativeMode = false;
-        SupportsTemporalPropagation = true;
-        _options.ModelPath = modelPath;
-        OnnxModel = new OnnxModel<T>(modelPath, _options.OnnxOptions);
-        InitializeLayers();
-    }
-
-    /// <summary>
-    /// Creates a STTN model for native training and inference.
-    /// </summary>
-    public STTN(
-        NeuralNetworkArchitecture<T> architecture,
-        STTNOptions? options = null,
-        IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? optimizer = null)
-        : base(architecture)
-    {
-        _options = options ?? new STTNOptions();
-        _useNativeMode = true;
-        _optimizer = optimizer ?? new AdamWOptimizer<T, Tensor<T>, Tensor<T>>(this,
-            new AdamWOptimizerOptions<T, Tensor<T>, Tensor<T>>
-            {
-                InitialLearningRate = _options.LearningRate
-            });
-        SupportsTemporalPropagation = true;
-        InitializeLayers();
-    }
-
-    /// <inheritdoc/>
-    public override Tensor<T> Inpaint(Tensor<T> frames, Tensor<T> masks)
-    {
-        ThrowIfDisposed();
-        var preprocessed = PreprocessFrames(frames);
-        var combined = ConcatFramesAndMasks(preprocessed, masks);
-        var output = IsOnnxMode ? RunOnnxInference(combined) : Forward(combined);
-        return PostprocessOutput(output);
-    }
-
-    /// <inheritdoc/>
-    protected override void InitializeLayers()
-    {
-        if (!_useNativeMode) return;
-        if (Architecture.Layers is not null && Architecture.Layers.Count > 0)
-        {
-            Layers.AddRange(Architecture.Layers);
-        }
-        else
-        {
-            int ch = Architecture.InputDepth > 0 ? Architecture.InputDepth : 3;
-            int h = Architecture.InputHeight > 0 ? Architecture.InputHeight : 128;
-            int w = Architecture.InputWidth > 0 ? Architecture.InputWidth : 128;
-            Layers.AddRange(LayerHelper<T>.CreateDefaultVideoInpaintingLayers(
-                inputChannels: ch, inputHeight: h, inputWidth: w,
-                numFeatures: _options.NumFeatures));
-        }
-    }
-
-    /// <inheritdoc/>
-    protected override Tensor<T> PreprocessFrames(Tensor<T> rawFrames) => NormalizeInpaintFrames(rawFrames);
-
-    /// <inheritdoc/>
-    protected override Tensor<T> PostprocessOutput(Tensor<T> modelOutput) => DenormalizeInpaintFrames(modelOutput);
-
-
-    /// <inheritdoc/>
-    public override Tensor<T> ForwardForTraining(Tensor<T> input)
-    {
-        // Training must apply the SAME transform inference does (Inpaint): normalize the frames,
-        // concatenate a 1-channel mask (InputDepth -> InputDepth+1 so the encoder conv matches),
-        // run the layer stack, then denormalize. Feeding the raw InputDepth frames straight through
-        // the base would resolve/expect a different first-conv depth than inference AND train in a
-        // different value space, so the two paths would diverge. Delegate the actual layer walk
-        // (autodiff tape, gradient checkpointing, seed-wiring) to the base by handing it the
-        // mask-concatenated tensor; normalize/denormalize are Engine ops so gradients still flow.
-        // Use a fresh RANDOM per-step hole mask (PyTorch video-inpainting recipe). A mask that varies
-        // every step exercises the encoder's mask-channel weights without becoming a constant the model
-        // can exploit as a shortcut — so training keeps using the frame content and stays input-sensitive.
-        // Inference's PredictCore uses the deterministic CreateDefaultInpaintingMask.
-        var mask = CreateTrainingMask(input.Shape[0], input.Shape[2], input.Shape[3]);
-        var combined = ConcatFramesAndMasks(PreprocessFrames(input), mask);
-        return PostprocessOutput(base.ForwardForTraining(combined));
-    }
-
-    /// <inheritdoc/>
-    public override void Train(Tensor<T> input, Tensor<T> expected)
-    {
-        if (IsOnnxMode) throw new NotSupportedException("Training is not supported in ONNX mode.");
-        SetTrainingMode(true);
-        try
-        {
-        TrainWithTape(input, expected, _optimizer);
-        }
-        finally
-        {
-            SetTrainingMode(false);
-        }
-    }
-
-    // UpdateParameters restated the base verbatim; ModelBase routes it to SetParameters.

-
-    /// <summary>
-    /// Parameters cannot be written while the model is backed by a loaded ONNX graph: the weights
-    /// belong to that graph, not to this instance.
-    /// </summary>
-    /// <remarks>
-    /// Replaces a hand-written throw that used to sit inside UpdateParameters. The base checks this
-    /// on every mutating entry point rather than the one member the throw happened to guard, and
-    /// reading -- ParameterCount and GetParameters -- stays available either way.
-    /// </remarks>
+using System.IO;
+using AiDotNet.Attributes;
+using AiDotNet.Enums;
+using AiDotNet.Helpers;
+using AiDotNet.Interfaces;
+using AiDotNet.NeuralNetworks;
+using AiDotNet.Onnx;
+using AiDotNet.Optimizers;
+using AiDotNet.Tensors.LinearAlgebra;
+using AiDotNet.Video.Options;
+
+namespace AiDotNet.Video.Inpainting;
+
+/// <summary>
+/// STTN spatial-temporal transformer network for video inpainting with multi-scale attention.
+/// </summary>
+/// <typeparam name="T">The numeric type used for calculations.</typeparam>
+/// <remarks>
+/// <para><b>References:</b>
+/// <list type="bullet">
+/// <item>Paper: "Learning Joint Spatial-Temporal Transformations for Video Inpainting" (Zeng et al., ECCV 2020)</item>
+/// </list></para>
+/// <para><b>For Beginners:</b> STTN (Spatial-Temporal Transformer Network) performs video inpainting using transformers that jointly attend to spatial and temporal dimensions to fill holes consistently across frames.</para>
+/// <para>
+/// STTN uses multi-scale spatial-temporal transformers that jointly search for and attend to
+/// relevant patches across both space and time dimensions. Multi-head attention at multiple
+/// feature scales enables both fine-grained texture transfer and large-scale structure completion.
+/// </para>
+/// </remarks>
+/// <example>
+/// <code>
+/// // Create an STTN model for spatial-temporal video inpainting
+/// var architecture = new NeuralNetworkArchitecture&lt;double&gt;(
+///     inputType: InputType.ThreeDimensional,
+///     inputHeight: 256, inputWidth: 256, inputDepth: 3);
+/// var options = new STTNOptions();
+/// var sttn = new STTN&lt;double&gt;(architecture, options);
+///
+/// // Or load a pre-trained ONNX model for inference
+/// var sttnOnnx = new STTN&lt;double&gt;(architecture, "sttn_model.onnx");
+/// </code>
+/// </example>
+[ModelDomain(ModelDomain.Video)]
+[ModelDomain(ModelDomain.Vision)]
+[ModelCategory(ModelCategory.NeuralNetwork)]
+[ModelCategory(ModelCategory.Transformer)]
+[ModelTask(ModelTask.Generation)]
+[ModelComplexity(ModelComplexity.High)]
+[ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
+[ResearchPaper("Learning Joint Spatial-Temporal Transformations for Video Inpainting",
+    "https://arxiv.org/abs/2007.10247",
+    Year = 2020,
+    Authors = "Yanhong Zeng, Jianlong Fu, Hongyang Chao")]
+public partial class STTN<T> : VideoInpaintingBase<T>
+{
+    private readonly STTNOptions _options;
+
+    /// <inheritdoc/>
+    public override ModelOptions GetOptions() => _options;
+
+    private IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer;
+    private bool _useNativeMode;
+    private bool _disposed;
+
+    /// <summary>
+    /// Creates a STTN model for ONNX inference.
+    /// </summary>
+    public STTN(
+        NeuralNetworkArchitecture<T> architecture,
+        string modelPath,
+        STTNOptions? options = null)
+        : base(architecture)
+    {
+        if (string.IsNullOrEmpty(modelPath))
+            throw new ArgumentException("Model path cannot be null or empty.", nameof(modelPath));
+        _options = options ?? new STTNOptions();
+        _useNativeMode = false;
+        SupportsTemporalPropagation = true;
+        _options.ModelPath = modelPath;
+        OnnxModel = new OnnxModel<T>(modelPath, _options.OnnxOptions);
+        InitializeLayers();
+    }
+
+    /// <summary>
+    /// Creates a STTN model for native training and inference.
+    /// </summary>
+    public STTN(
+        NeuralNetworkArchitecture<T> architecture,
+        STTNOptions? options = null,
+        IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? optimizer = null)
+        : base(architecture)
+    {
+        _options = options ?? new STTNOptions();
+        _useNativeMode = true;
+        _optimizer = optimizer ?? new AdamWOptimizer<T, Tensor<T>, Tensor<T>>(this,
+            new AdamWOptimizerOptions<T, Tensor<T>, Tensor<T>>
+            {
+                InitialLearningRate = _options.LearningRate
+            });
+        SupportsTemporalPropagation = true;
+        InitializeLayers();
+    }
+
+    /// <inheritdoc/>
+    public override Tensor<T> Inpaint(Tensor<T> frames, Tensor<T> masks)
+    {
+        ThrowIfDisposed();
+        var preprocessed = PreprocessFrames(frames);
+        var combined = ConcatFramesAndMasks(preprocessed, masks);
+        var output = IsOnnxMode ? RunOnnxInference(combined) : Forward(combined);
+        return PostprocessOutput(output);
+    }
+
+    /// <inheritdoc/>
+    protected override void InitializeLayers()
+    {
+        if (!_useNativeMode) return;
+        if (Architecture.Layers is not null && Architecture.Layers.Count > 0)
+        {
+            Layers.AddRange(Architecture.Layers);
+        }
+        else
+        {
+            int ch = Architecture.InputDepth > 0 ? Architecture.InputDepth : 3;
+            int h = Architecture.InputHeight > 0 ? Architecture.InputHeight : 128;
+            int w = Architecture.InputWidth > 0 ? Architecture.InputWidth : 128;
+            Layers.AddRange(LayerHelper<T>.CreateDefaultVideoInpaintingLayers(
+                inputChannels: ch, inputHeight: h, inputWidth: w,
+                numFeatures: _options.NumFeatures));
+        }
+    }
+
+    /// <inheritdoc/>
+    protected override Tensor<T> PreprocessFrames(Tensor<T> rawFrames) => NormalizeInpaintFrames(rawFrames);
+
+    /// <inheritdoc/>
+    protected override Tensor<T> PostprocessOutput(Tensor<T> modelOutput) => DenormalizeInpaintFrames(modelOutput);
+
+
+    /// <inheritdoc/>
+    public override Tensor<T> ForwardForTraining(Tensor<T> input)
+    {
+        // Training must apply the SAME transform inference does (Inpaint): normalize the frames,
+        // concatenate a 1-channel mask (InputDepth -> InputDepth+1 so the encoder conv matches),
+        // run the layer stack, then denormalize. Feeding the raw InputDepth frames straight through
+        // the base would resolve/expect a different first-conv depth than inference AND train in a
+        // different value space, so the two paths would diverge. Delegate the actual layer walk
+        // (autodiff tape, gradient checkpointing, seed-wiring) to the base by handing it the
+        // mask-concatenated tensor; normalize/denormalize are Engine ops so gradients still flow.
+        // Use a fresh RANDOM per-step hole mask (PyTorch video-inpainting recipe). A mask that varies
+        // every step exercises the encoder's mask-channel weights without becoming a constant the model
+        // can exploit as a shortcut — so training keeps using the frame content and stays input-sensitive.
+        // Inference's PredictCore uses the deterministic CreateDefaultInpaintingMask.
+        var mask = CreateTrainingMask(input.Shape[0], input.Shape[2], input.Shape[3]);
+        var combined = ConcatFramesAndMasks(PreprocessFrames(input), mask);
+        return PostprocessOutput(base.ForwardForTraining(combined));
+    }
+
+    /// <inheritdoc/>
+    public override void Train(Tensor<T> input, Tensor<T> expected)
+    {
+        if (IsOnnxMode) throw new NotSupportedException("Training is not supported in ONNX mode.");
+        SetTrainingMode(true);
+        try
+        {
+        TrainWithTape(input, expected, _optimizer);
+        }
+        finally
+        {
+            SetTrainingMode(false);
+        }
+    }
+
+    // UpdateParameters restated the base verbatim; ModelBase routes it to SetParameters.
+
+
+    /// <summary>
+    /// Parameters cannot be written while the model is backed by a loaded ONNX graph: the weights
+    /// belong to that graph, not to this instance.
+    /// </summary>
+    /// <remarks>
+    /// Replaces a hand-written throw that used to sit inside UpdateParameters. The base checks this
+    /// on every mutating entry point rather than the one member the throw happened to guard, and
+    /// reading -- ParameterCount and GetParameters -- stays available either way.
+    /// </remarks>
     protected override bool SupportsParameterMutation => _useNativeMode;
-    /// <inheritdoc/>
-    public override ModelMetadata<T> GetModelMetadata()
-    {
-        return new ModelMetadata<T>
-        {
-            AdditionalInfo = new Dictionary<string, object>
-            {
-                { "ModelName", "STTN" },
-                { "Variant", _options.Variant.ToString() },
-                { "NumFeatures", _options.NumFeatures },
-                { "NumTransformerLayers", _options.NumTransformerLayers },
-                { "NumHeads", _options.NumHeads },
-                { "NumScales", _options.NumScales }
-            },
-            ModelData = SerializeForMetadata()
-        };
-    }
-
-    /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write((int)_options.Variant);
-        writer.Write(_options.NumFeatures);
-        writer.Write(_options.NumTransformerLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.NumScales);
-        writer.Write(_options.LearningRate);
-        writer.Write(_options.DropoutRate);
-    }
-
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _options.Variant = (VideoModelVariant)reader.ReadInt32();
-        _options.NumFeatures = reader.ReadInt32();
-        _options.NumTransformerLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.NumScales = reader.ReadInt32();
-        _options.LearningRate = reader.ReadDouble();
-        _options.DropoutRate = reader.ReadDouble();
-    }
-
-    /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            return new STTN<T>(Architecture, p, _options);
-        return new STTN<T>(Architecture, _options);
-    }
-
-    private static Tensor<T> ConcatFramesAndMasks(Tensor<T> frames, Tensor<T> masks)
-    {
-        if (frames.Rank != 4)
-            throw new ArgumentException($"Frames must be rank 4 [N, C, H, W], got rank {frames.Rank}.", nameof(frames));
-        if (masks.Rank != 4)
-            throw new ArgumentException($"Masks must be rank 4 [N, 1, H, W], got rank {masks.Rank}.", nameof(masks));
-        int n = frames.Shape[0];
-        int c = frames.Shape[1];
-        int h = frames.Shape[2];
-        int w = frames.Shape[3];
-        if (masks.Shape[1] != 1)
-            throw new ArgumentException($"Masks must have exactly 1 channel, got {masks.Shape[1]}.", nameof(masks));
-        if (masks.Shape[0] != n || masks.Shape[2] != h || masks.Shape[3] != w)
-            throw new ArgumentException($"Masks spatial dimensions must match frames. Frames: [{n},{c},{h},{w}], Masks: [{masks.Shape[0]},{masks.Shape[1]},{masks.Shape[2]},{masks.Shape[3]}].", nameof(masks));
-        var combined = new Tensor<T>([n, c + 1, h, w]);
-        int frameSize = c * h * w;
-        int maskSize = h * w;
-        int combinedSize = (c + 1) * h * w;
-        for (int f = 0; f < n; f++)
-        {
-            for (int i = 0; i < frameSize; i++)
-                combined.Data.Span[f * combinedSize + i] = frames.Data.Span[f * frameSize + i];
-            for (int i = 0; i < maskSize; i++)
-                combined.Data.Span[f * combinedSize + frameSize + i] = masks.Data.Span[f * maskSize + i];
-        }
-        return combined;
-    }
-
-    private void ThrowIfDisposed()
-    {
-        if (_disposed) throw new ObjectDisposedException(GetType().FullName ?? nameof(STTN<T>));
-    }
-
-    /// <inheritdoc/>
-    protected override void Dispose(bool disposing)
-    {
-        if (_disposed) return;
-        _disposed = true;
-        if (disposing) OnnxModel?.Dispose();
-        base.Dispose(disposing);
-    }
-}
+    /// <inheritdoc/>
+    public override ModelMetadata<T> GetModelMetadata()
+    {
+        return new ModelMetadata<T>
+        {
+            AdditionalInfo = new Dictionary<string, object>
+            {
+                { "ModelName", "STTN" },
+                { "Variant", _options.Variant.ToString() },
+                { "NumFeatures", _options.NumFeatures },
+                { "NumTransformerLayers", _options.NumTransformerLayers },
+                { "NumHeads", _options.NumHeads },
+                { "NumScales", _options.NumScales }
+            },
+            ModelData = SerializeForMetadata()
+        };
+    }
+
+    /// <inheritdoc/>
+
+
+    /// <inheritdoc/>
+
+
+    private static Tensor<T> ConcatFramesAndMasks(Tensor<T> frames, Tensor<T> masks)
+    {
+        if (frames.Rank != 4)
+            throw new ArgumentException($"Frames must be rank 4 [N, C, H, W], got rank {frames.Rank}.", nameof(frames));
+        if (masks.Rank != 4)
+            throw new ArgumentException($"Masks must be rank 4 [N, 1, H, W], got rank {masks.Rank}.", nameof(masks));
+        int n = frames.Shape[0];
+        int c = frames.Shape[1];
+        int h = frames.Shape[2];
+        int w = frames.Shape[3];
+        if (masks.Shape[1] != 1)
+            throw new ArgumentException($"Masks must have exactly 1 channel, got {masks.Shape[1]}.", nameof(masks));
+        if (masks.Shape[0] != n || masks.Shape[2] != h || masks.Shape[3] != w)
+            throw new ArgumentException($"Masks spatial dimensions must match frames. Frames: [{n},{c},{h},{w}], Masks: [{masks.Shape[0]},{masks.Shape[1]},{masks.Shape[2]},{masks.Shape[3]}].", nameof(masks));
+        var combined = new Tensor<T>([n, c + 1, h, w]);
+        int frameSize = c * h * w;
+        int maskSize = h * w;
+        int combinedSize = (c + 1) * h * w;
+        for (int f = 0; f < n; f++)
+        {
+            for (int i = 0; i < frameSize; i++)
+                combined.Data.Span[f * combinedSize + i] = frames.Data.Span[f * frameSize + i];
+            for (int i = 0; i < maskSize; i++)
+                combined.Data.Span[f * combinedSize + frameSize + i] = masks.Data.Span[f * maskSize + i];
+        }
+        return combined;
+    }
+
+    private void ThrowIfDisposed()
+    {
+        if (_disposed) throw new ObjectDisposedException(GetType().FullName ?? nameof(STTN<T>));
+    }
+
+    /// <inheritdoc/>
+    protected override void Dispose(bool disposing)
+    {
+        if (_disposed) return;
+        _disposed = true;
+        if (disposing) OnnxModel?.Dispose();
+        base.Dispose(disposing);
+    }
+}
diff --git a/src/Video/Matting/RVM.cs b/src/Video/Matting/RVM.cs
index 909fbcb91b..8c5ea6424e 100644
--- a/src/Video/Matting/RVM.cs
+++ b/src/Video/Matting/RVM.cs
@@ -65,7 +65,7 @@ namespace AiDotNet.Video.Matting;
     Direction = TensorLayoutDirection.Input, BatchOptional = true)]
 [TensorLayout(TensorAxis.Batch, TensorAxis.Frames, TensorAxis.Height, TensorAxis.Width,
     Direction = TensorLayoutDirection.Output, BatchOptional = true)]
-public class RVM<T> : NeuralNetworkBase<T>
+public partial class RVM<T> : NeuralNetworkBase<T>
 {
     private readonly RVMOptions _options;
 
@@ -375,18 +375,9 @@ protected override void InitializeLayers()
         ModelData = _useNativeMode ? this.Serialize() : []
     };
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_numFeatures); writer.Write(_imageHeight); writer.Write(_imageWidth);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        for (int i = 0; i < 3; i++) _ = reader.ReadInt32();
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() =>
-        new RVM<T>(Architecture, _optimizer, _lossFunction, _numFeatures);
+
 
     #endregion
 }
diff --git a/src/Video/Motion/DKM.cs b/src/Video/Motion/DKM.cs
index 440bbd2d88..d3f399b82b 100644
--- a/src/Video/Motion/DKM.cs
+++ b/src/Video/Motion/DKM.cs
@@ -214,22 +214,8 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_numFeatures);
-        writer.Write(_numLayers);
-    }
 
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _numFeatures = reader.ReadInt32();
-        _numLayers = reader.ReadInt32();
-    }
 
     /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new DKM<T>(Architecture, _numFeatures, _numLayers, _options);
-    }
+
 }
diff --git a/src/Video/Motion/DPFlow.cs b/src/Video/Motion/DPFlow.cs
index cef5bf0ae3..98db5485a7 100644
--- a/src/Video/Motion/DPFlow.cs
+++ b/src/Video/Motion/DPFlow.cs
@@ -253,40 +253,8 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_numFeatures);
-        writer.Write(_numLayers);
-    }
-
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _numFeatures = reader.ReadInt32();
-        _numLayers = reader.ReadInt32();
-
-        if (Layers.Count < _numLayers + 2)
-            throw new InvalidDataException(
-                $"DPFlow serialized layer count {Layers.Count} is too small for {_numLayers} processing blocks.");
 
-        _featureExtract = Layers[0] as ConvolutionalLayer<T>
-            ?? throw new InvalidDataException("DPFlow feature extractor layer is missing or has the wrong type.");
-
-        _processingBlocks.Clear();
-        for (int i = 0; i < _numLayers; i++)
-        {
-            var layer = Layers[i + 1] as ConvolutionalLayer<T>
-                ?? throw new InvalidDataException($"DPFlow processing block {i} is missing or has the wrong type.");
-            _processingBlocks.Add(layer);
-        }
-
-        _outputConv = Layers[_numLayers + 1] as ConvolutionalLayer<T>
-            ?? throw new InvalidDataException("DPFlow output layer is missing or has the wrong type.");
-    }
 
     /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new DPFlow<T>(Architecture, _numFeatures, _numLayers, _options);
-    }
+
 }
diff --git a/src/Video/Motion/FlowDiffuser.cs b/src/Video/Motion/FlowDiffuser.cs
index 8b2f2eb798..32f9f82fbe 100644
--- a/src/Video/Motion/FlowDiffuser.cs
+++ b/src/Video/Motion/FlowDiffuser.cs
@@ -214,22 +214,8 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_numFeatures);
-        writer.Write(_numLayers);
-    }
 
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _numFeatures = reader.ReadInt32();
-        _numLayers = reader.ReadInt32();
-    }
 
     /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new FlowDiffuser<T>(Architecture, _numFeatures, _numLayers, _options);
-    }
+
 }
diff --git a/src/Video/Motion/FlowFormer.cs b/src/Video/Motion/FlowFormer.cs
index 87befc511f..68265e2da6 100644
--- a/src/Video/Motion/FlowFormer.cs
+++ b/src/Video/Motion/FlowFormer.cs
@@ -58,7 +58,7 @@ namespace AiDotNet.Video.Motion;
     "https://arxiv.org/abs/2203.16194",
     Year = 2022,
     Authors = "Zhaoyang Huang, Xiaoyu Shi, Chao Zhang, Qiang Wang, Ka Chun Cheung, Hongwei Qin, Jifeng Dai, Hongsheng Li")]
-public class FlowFormer<T> : OpticalFlowBase<T>
+public partial class FlowFormer<T> : OpticalFlowBase<T>
 {
     private readonly FlowFormerOptions _options;
 
@@ -349,19 +349,9 @@ protected override void InitializeLayers()
         ModelData = _useNativeMode ? this.Serialize() : []
     };
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_embedDim); writer.Write(_numLayers); writer.Write(_numIterations);
-        writer.Write(_imageHeight); writer.Write(_imageWidth);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        for (int i = 0; i < 5; i++) _ = reader.ReadInt32();
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() =>
-        new FlowFormer<T>(Architecture, _optimizer, _lossFunction, _embedDim, _numLayers, _numIterations);
+
 
     #endregion
 
diff --git a/src/Video/Motion/FlowFormerPlusPlus.cs b/src/Video/Motion/FlowFormerPlusPlus.cs
index 0433bb7dba..93c0a8540c 100644
--- a/src/Video/Motion/FlowFormerPlusPlus.cs
+++ b/src/Video/Motion/FlowFormerPlusPlus.cs
@@ -223,41 +223,8 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_numFeatures);
-        writer.Write(_numLayers);
-    }
-
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _numFeatures = reader.ReadInt32();
-        _numLayers = reader.ReadInt32();
 
-        // Re-link the typed role fields to the layers the BASE already deserialized (trained,
-        // shape-resolved) rather than calling InitializeNativeLayers, which allocates FRESH random-init
-        // convolutions and replaces the deserialized layers — so a cloned/loaded model predicted from
-        // random init (#1221 class). EstimateFlow reads these fields directly, not Layers. Order matches
-        // InitializeLayers: [featureExtract, ...processingBlocks, outputConv].
-        if (Layers.Count < _numLayers + 2)
-            throw new InvalidDataException(
-                $"FlowFormerPlusPlus serialized layer count {Layers.Count} is too small for {_numLayers} processing blocks.");
-        _featureExtract = Layers[0] as ConvolutionalLayer<T>
-            ?? throw new InvalidDataException("FlowFormerPlusPlus feature extractor layer is missing or has the wrong type.");
-        _processingBlocks.Clear();
-        for (int i = 0; i < _numLayers; i++)
-        {
-            _processingBlocks.Add(Layers[i + 1] as ConvolutionalLayer<T>
-                ?? throw new InvalidDataException($"FlowFormerPlusPlus processing block {i} is missing or has the wrong type."));
-        }
-        _outputConv = Layers[_numLayers + 1] as ConvolutionalLayer<T>
-            ?? throw new InvalidDataException("FlowFormerPlusPlus output layer is missing or has the wrong type.");
-    }
 
     /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new FlowFormerPlusPlus<T>(Architecture, _numFeatures, _numLayers, _options);
-    }
+
 }
diff --git a/src/Video/Motion/GMFlow.cs b/src/Video/Motion/GMFlow.cs
index 6e6285893c..8696768851 100644
--- a/src/Video/Motion/GMFlow.cs
+++ b/src/Video/Motion/GMFlow.cs
@@ -673,26 +673,9 @@ protected override void InitializeLayers()
         ModelData = SerializeForMetadata()
     };
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_height);
-        writer.Write(_width);
-        writer.Write(_channels);
-        writer.Write(_numFeatures);
-        writer.Write(_numTransformerLayers);
-        writer.Write(_numHeads);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        for (int i = 0; i < 6; i++) _ = reader.ReadInt32();
 
-        // The base deserializer has replaced Layers with the loaded-weight layers;
-        // re-point the forward-pass sub-lists at them so a clone/reload runs the
-        // trained weights rather than the constructor's random-init layers
-        // (Clone_ShouldProduceIdenticalOutput / Clone_AfterTraining).
-        ExtractLayerReferences();
-    }
+
 
     /// <summary>
     /// Resolves each convolution's lazy input depth by running the REAL computation
@@ -729,9 +712,6 @@ protected override void ResolveLazyLayerShapes()
         finally { if (wasTraining) SetTrainingMode(true); }
     }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() =>
-        new GMFlow<T>(Architecture, _numFeatures, _numTransformerLayers, _numHeads);
-
     #endregion
 
     #region Base Class Abstract Methods
diff --git a/src/Video/Motion/MemFlow.cs b/src/Video/Motion/MemFlow.cs
index c5c4720800..a2a0e37e4f 100644
--- a/src/Video/Motion/MemFlow.cs
+++ b/src/Video/Motion/MemFlow.cs
@@ -222,45 +222,8 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_numFeatures);
-        writer.Write(_numLayers);
-    }
-
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _numFeatures = reader.ReadInt32();
-        _numLayers = reader.ReadInt32();
-
-        // Re-link the cached role fields to the layers the BASE already deserialized (with their
-        // trained, shape-resolved weights) — do NOT call InitializeNativeLayers, which allocates
-        // FRESH random-initialized convolutions and, via InitializeLayers, replaces the deserialized
-        // layers in Layers. Doing so discarded the trained weights so a cloned/loaded model predicted
-        // from random init (#1221 class: Clone_AfterTraining / Clone_ShouldProduceIdenticalOutput).
-        // Layer order matches InitializeLayers: [featureExtract, ...processingBlocks, outputConv].
-        if (Layers.Count < _numLayers + 2)
-            throw new InvalidDataException(
-                $"MemFlow serialized layer count {Layers.Count} is too small for {_numLayers} processing blocks.");
 
-        _featureExtract = Layers[0] as ConvolutionalLayer<T>
-            ?? throw new InvalidDataException("MemFlow feature extractor layer is missing or has the wrong type.");
-
-        _processingBlocks.Clear();
-        for (int i = 0; i < _numLayers; i++)
-        {
-            _processingBlocks.Add(Layers[i + 1] as ConvolutionalLayer<T>
-                ?? throw new InvalidDataException($"MemFlow processing block {i} is missing or has the wrong type."));
-        }
-
-        _outputConv = Layers[_numLayers + 1] as ConvolutionalLayer<T>
-            ?? throw new InvalidDataException("MemFlow output layer is missing or has the wrong type.");
-    }
 
     /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new MemFlow<T>(Architecture, _numFeatures, _numLayers, _options);
-    }
+
 }
diff --git a/src/Video/Motion/NeuFlowV2.cs b/src/Video/Motion/NeuFlowV2.cs
index ce5c068814..9d53944069 100644
--- a/src/Video/Motion/NeuFlowV2.cs
+++ b/src/Video/Motion/NeuFlowV2.cs
@@ -215,22 +215,8 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_numFeatures);
-        writer.Write(_numLayers);
-    }
 
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _numFeatures = reader.ReadInt32();
-        _numLayers = reader.ReadInt32();
-    }
 
     /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new NeuFlowV2<T>(Architecture, _numFeatures, _numLayers, _options);
-    }
+
 }
diff --git a/src/Video/Motion/RAFT.cs b/src/Video/Motion/RAFT.cs
index 1913576f61..ce2564faa6 100644
--- a/src/Video/Motion/RAFT.cs
+++ b/src/Video/Motion/RAFT.cs
@@ -720,34 +720,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_height);
-        writer.Write(_width);
-        writer.Write(_channels);
-        writer.Write(_numFeatures);
-        writer.Write(_correlationLevels);
-        writer.Write(_correlationRadius);
-        writer.Write(NumIterations);
-    }
 
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _ = reader.ReadInt32();
-        _ = reader.ReadInt32();
-        _ = reader.ReadInt32();
-        _ = reader.ReadInt32();
-        _ = reader.ReadInt32();
-        _ = reader.ReadInt32();
-        _ = reader.ReadInt32();
-    }
 
     /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new RAFT<T>(Architecture, _numFeatures, _correlationLevels, _correlationRadius, NumIterations);
-    }
+
 
     #endregion
 
diff --git a/src/Video/Motion/RAPIDFlow.cs b/src/Video/Motion/RAPIDFlow.cs
index d5a3ef31c9..0352ca3b6a 100644
--- a/src/Video/Motion/RAPIDFlow.cs
+++ b/src/Video/Motion/RAPIDFlow.cs
@@ -433,10 +433,7 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_numRefinementIterations);
-    }
+
 
     /// <inheritdoc/>
     /// <remarks>
@@ -455,50 +452,5 @@ protected override void SerializeNetworkSpecificData(BinaryWriter writer)
     /// Clone_ShouldProduceIdenticalOutput invariants catch (||Δ|| ~
     /// ||trained||, not the ~1e-10 of a clean clone).
     /// </remarks>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _numRefinementIterations = reader.ReadInt32();
-
-        // Re-bind private layer references to the post-deserialize Layers
-        // collection. Expected layout matches InitializeLayers: 3 encoder
-        // levels, _numRefinementIterations refinement blocks, 2 decoder
-        // levels, 1 flow head. Defensive count check so a future
-        // serialization-format extension that adds auxiliary layers
-        // fails loudly rather than silently mis-routing layer slots.
-        int expectedCount = 3 + _numRefinementIterations + 3;
-        if (Layers.Count != expectedCount)
-        {
-            throw new InvalidDataException(
-                $"Expected {expectedCount} RAPIDFlow layers after deserialization, found {Layers.Count}.");
-        }
-
-        _encoderLevel1 = Layers[0] as ConvolutionalLayer<T>
-            ?? throw new InvalidDataException("Layer 0 is not a ConvolutionalLayer.");
-        _encoderLevel2 = Layers[1] as ConvolutionalLayer<T>
-            ?? throw new InvalidDataException("Layer 1 is not a ConvolutionalLayer.");
-        _encoderLevel3 = Layers[2] as ConvolutionalLayer<T>
-            ?? throw new InvalidDataException("Layer 2 is not a ConvolutionalLayer.");
-
-        _refinementBlocks.Clear();
-        for (int i = 0; i < _numRefinementIterations; i++)
-        {
-            _refinementBlocks.Add(
-                Layers[3 + i] as ConvolutionalLayer<T>
-                ?? throw new InvalidDataException($"Layer {3 + i} is not a refinement ConvolutionalLayer."));
-        }
-
-        int decoderStart = 3 + _numRefinementIterations;
-        _decoderLevel2 = Layers[decoderStart] as DeconvolutionalLayer<T>
-            ?? throw new InvalidDataException($"Layer {decoderStart} is not a DeconvolutionalLayer.");
-        _decoderLevel1 = Layers[decoderStart + 1] as DeconvolutionalLayer<T>
-            ?? throw new InvalidDataException($"Layer {decoderStart + 1} is not a DeconvolutionalLayer.");
-        _flowHead = Layers[decoderStart + 2] as DeconvolutionalLayer<T>
-            ?? throw new InvalidDataException($"Layer {decoderStart + 2} is not a DeconvolutionalLayer.");
-    }
 
-    /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new RAPIDFlow<T>(Architecture, _numRefinementIterations, _options);
-    }
 }
diff --git a/src/Video/Motion/RPKNet.cs b/src/Video/Motion/RPKNet.cs
index e6370bb1de..680ba9841b 100644
--- a/src/Video/Motion/RPKNet.cs
+++ b/src/Video/Motion/RPKNet.cs
@@ -217,22 +217,8 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_numFeatures);
-        writer.Write(_numLayers);
-    }
 
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _numFeatures = reader.ReadInt32();
-        _numLayers = reader.ReadInt32();
-    }
 
     /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new RPKNet<T>(Architecture, _numFeatures, _numLayers, _options);
-    }
+
 }
diff --git a/src/Video/Motion/RoMa.cs b/src/Video/Motion/RoMa.cs
index 3ee3526bba..703d82d1e5 100644
--- a/src/Video/Motion/RoMa.cs
+++ b/src/Video/Motion/RoMa.cs
@@ -202,22 +202,8 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_numFeatures);
-        writer.Write(_numLayers);
-    }
 
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _numFeatures = reader.ReadInt32();
-        _numLayers = reader.ReadInt32();
-    }
 
     /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new RoMa<T>(Architecture, _numFeatures, _numLayers, _options);
-    }
+
 }
diff --git a/src/Video/Motion/SEARAFT.cs b/src/Video/Motion/SEARAFT.cs
index e71c84ec3c..f5b003e834 100644
--- a/src/Video/Motion/SEARAFT.cs
+++ b/src/Video/Motion/SEARAFT.cs
@@ -205,22 +205,8 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_numFeatures);
-        writer.Write(_numLayers);
-    }
 
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _numFeatures = reader.ReadInt32();
-        _numLayers = reader.ReadInt32();
-    }
 
     /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new SEARAFT<T>(Architecture, _numFeatures, _numLayers, _options);
-    }
+
 }
diff --git a/src/Video/Motion/SKFlow.cs b/src/Video/Motion/SKFlow.cs
index 44de0d1c42..8eda2dbbcb 100644
--- a/src/Video/Motion/SKFlow.cs
+++ b/src/Video/Motion/SKFlow.cs
@@ -202,22 +202,8 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_numFeatures);
-        writer.Write(_numLayers);
-    }
 
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _numFeatures = reader.ReadInt32();
-        _numLayers = reader.ReadInt32();
-    }
 
     /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new SKFlow<T>(Architecture, _numFeatures, _numLayers, _options);
-    }
+
 }
diff --git a/src/Video/Motion/UFM.cs b/src/Video/Motion/UFM.cs
index b56157999c..e244210d02 100644
--- a/src/Video/Motion/UFM.cs
+++ b/src/Video/Motion/UFM.cs
@@ -230,54 +230,8 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_numFeatures);
-        writer.Write(_numLayers);
-    }
-
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _numFeatures = reader.ReadInt32();
-        _numLayers = reader.ReadInt32();
 
-        // Reconnect the typed field references (_featureExtract,
-        // _processingBlocks, _outputConv) to the conv layers the base
-        // class deserialized into the Layers collection. Without this
-        // rewire, the freshly-constructed clone instance keeps pointing
-        // its typed fields at the UNTRAINED conv layers from its own
-        // InitializeNativeLayers call, while the trained weights live in
-        // Layers[0..end] — and EstimateFlow's forward pass uses the
-        // typed fields directly (not the Layers collection), so the
-        // clone predicts as if untrained. InitializeLayers (called from
-        // the ctor) emits the layers in stable order
-        // [_featureExtract, _processingBlocks[0..N-1], _outputConv], so
-        // we read them back in the same positions. Same fix pattern as
-        // GOGGLEGenerator.DeserializeNetworkSpecificData.
-        int expected = 1 + _numLayers + 1;
-        // Require EXACT count: the rebind reads layers at fixed positions
-        // [_featureExtract=0, _processingBlocks=1..N, _outputConv=1+N], so an
-        // unexpected layer count means the deserialized graph doesn't match this
-        // configuration and silently rebinding would point fields at wrong convs.
-        if (Layers.Count == expected)
-        {
-            if (Layers[0] is ConvolutionalLayer<T> fe) _featureExtract = fe;
-            _processingBlocks.Clear();
-            for (int i = 0; i < _numLayers; i++)
-            {
-                if (Layers[1 + i] is ConvolutionalLayer<T> block)
-                    _processingBlocks.Add(block);
-            }
-            // _outputConv is at its produced position 1 + _numLayers (not Count-1,
-            // which would pick the wrong layer if the count ever differs).
-            if (Layers[1 + _numLayers] is ConvolutionalLayer<T> oc) _outputConv = oc;
-        }
-    }
 
     /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new UFM<T>(Architecture, _numFeatures, _numLayers, _options);
-    }
+
 }
diff --git a/src/Video/Motion/UniMatch.cs b/src/Video/Motion/UniMatch.cs
index 888353d098..29d8d93d35 100644
--- a/src/Video/Motion/UniMatch.cs
+++ b/src/Video/Motion/UniMatch.cs
@@ -212,30 +212,8 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_numFeatures);
-        writer.Write(_numLayers);
-    }
 
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _numFeatures = reader.ReadInt32();
-        _numLayers = reader.ReadInt32();
-
-        // Re-link the typed role fields via the shared OpticalFlowBase helper (validates the untrusted
-        // count, then casts-or-throws each role layer) rather than allocating FRESH random-init
-        // convolutions here — the fresh convs left the typed fields (which EstimateFlow reads directly)
-        // pointing at untrained weights while the trained weights sat unused in Layers, so a
-        // cloned/loaded model predicted from random init (#1221 class). Order matches InitializeLayers:
-        // [featureExtract, ...processingBlocks, outputConv].
-        RelinkOpticalFlowLayers(_numLayers, "UniMatch", out _featureExtract, _processingBlocks, out _outputConv);
-    }
 
     /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new UniMatch<T>(Architecture, _numFeatures, _numLayers, _options);
-    }
+
 }
diff --git a/src/Video/Motion/VideoFlow.cs b/src/Video/Motion/VideoFlow.cs
index d1243a553d..963eb5dbe8 100644
--- a/src/Video/Motion/VideoFlow.cs
+++ b/src/Video/Motion/VideoFlow.cs
@@ -216,32 +216,8 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_numFeatures);
-        writer.Write(_numLayers);
-    }
 
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _numFeatures = reader.ReadInt32();
-        _numLayers = reader.ReadInt32();
-
-        // Re-link the typed role fields to the layers the BASE already deserialized (trained,
-        // shape-resolved) rather than calling InitializeNativeLayers, which allocates FRESH random-init
-        // convolutions and replaces the deserialized layers — so a cloned/loaded model predicted from
-        // random init (#1221 class). EstimateFlow reads these fields directly, not Layers. Order matches
-        // InitializeLayers: [featureExtract, ...processingBlocks, outputConv].
-        // Re-link the typed role fields via the shared OpticalFlowBase helper (validates the untrusted
-        // count, then casts-or-throws each role layer). Order matches InitializeLayers:
-        // [featureExtract, ...processingBlocks, outputConv].
-        RelinkOpticalFlowLayers(_numLayers, "VideoFlow", out _featureExtract, _processingBlocks, out _outputConv);
-    }
 
     /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new VideoFlow<T>(Architecture, _numFeatures, _numLayers, _options);
-    }
+
 }
diff --git a/src/Video/OpticalFlowBase.cs b/src/Video/OpticalFlowBase.cs
index 23365e6005..188f560171 100644
--- a/src/Video/OpticalFlowBase.cs
+++ b/src/Video/OpticalFlowBase.cs
@@ -46,7 +46,7 @@ namespace AiDotNet.Video;
 [TensorLayout(TensorAxis.Batch, TensorAxis.Channels, TensorAxis.Height, TensorAxis.Width,
     Direction = TensorLayoutDirection.Output,
     Note = "A flow field: two channels, dx and dy, at the input resolution.")]
-public abstract class OpticalFlowBase<T> : VideoNeuralNetworkBase<T>, IShapeContract
+public abstract partial class OpticalFlowBase<T> : VideoNeuralNetworkBase<T>, IShapeContract
 {
     /// <summary>
     /// The optical-flow family's law: <c>[Batch, 2, Height, Width]</c>.
diff --git a/src/Video/Prediction/Mcnet.cs b/src/Video/Prediction/Mcnet.cs
index 658d46a9b5..abe6f5001b 100644
--- a/src/Video/Prediction/Mcnet.cs
+++ b/src/Video/Prediction/Mcnet.cs
@@ -82,7 +82,7 @@ namespace AiDotNet.Video.Prediction;
     Direction = TensorLayoutDirection.Input, BatchOptional = true)]
 [TensorLayout(TensorAxis.Batch, TensorAxis.Frames, TensorAxis.Channels, TensorAxis.Height, TensorAxis.Width,
     Direction = TensorLayoutDirection.Output, BatchOptional = true)]
-public class Mcnet<T> : VideoNeuralNetworkBase<T>
+public partial class Mcnet<T> : VideoNeuralNetworkBase<T>
 {
     #region Fields
 
@@ -301,55 +301,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter w)
-    {
-        w.Write(_useNativeMode);
-        w.Write(_options.ModelPath ?? string.Empty);
-        w.Write(_options.NumFeatures);
-        w.Write(_options.NumContentBlocks);
-        w.Write(_options.NumMotionBlocks);
-        w.Write(_options.NumDecoderBlocks);
-        w.Write(_options.NumScales);
-        w.Write(_options.NumInputFrames);
-        w.Write(_options.NumPredictedFrames);
-        w.Write(_options.ImageLossWeight);
-        w.Write(_options.AdversarialLossWeight);
-        w.Write(_options.GradientLossExponent);
-        w.Write(_options.PixelLossNorm);
-        w.Write(_options.LearningRate);
-        w.Write(_options.DropoutRate);
-    }
 
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader r)
-    {
-        _useNativeMode = r.ReadBoolean();
-        string mp = r.ReadString();
-        if (!string.IsNullOrEmpty(mp)) _options.ModelPath = mp;
-        _options.NumFeatures = r.ReadInt32();
-        _options.NumContentBlocks = r.ReadInt32();
-        _options.NumMotionBlocks = r.ReadInt32();
-        _options.NumDecoderBlocks = r.ReadInt32();
-        _options.NumScales = r.ReadInt32();
-        _options.NumInputFrames = r.ReadInt32();
-        _options.NumPredictedFrames = r.ReadInt32();
-        _options.ImageLossWeight = r.ReadDouble();
-        _options.AdversarialLossWeight = r.ReadDouble();
-        _options.GradientLossExponent = r.ReadDouble();
-        _options.PixelLossNorm = r.ReadInt32();
-        _options.LearningRate = r.ReadDouble();
-        _options.DropoutRate = r.ReadDouble();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
     /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (IsOnnxMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new Mcnet<T>(Architecture, mp, _options);
-        return new Mcnet<T>(Architecture, _options);
-    }
+
 
     #endregion
 
diff --git a/src/Video/RealESRGAN.cs b/src/Video/RealESRGAN.cs
index ef3b28601f..44ae1e0ba2 100644
--- a/src/Video/RealESRGAN.cs
+++ b/src/Video/RealESRGAN.cs
@@ -1016,85 +1016,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        ThrowIfNativeModeUnavailable();
-
-        writer.Write(_scaleFactor);
-        writer.Write(_numRRDBBlocks);
-        writer.Write(_numFeatures);
-        writer.Write(_residualScale);
-        writer.Write(_l1Lambda);
-        writer.Write(_perceptualLambda);
-        writer.Write(_ganLambda);
-
-        // Serialize generator parameters
-        var generatorParams = GeneratorRequired.GetParameters();
-        writer.Write(generatorParams.Length);
-        for (int i = 0; i < generatorParams.Length; i++)
-        {
-            writer.Write(NumOps.ToDouble(generatorParams[i]));
-        }
 
-        // Serialize discriminator parameters
-        var discriminatorParams = DiscriminatorRequired.GetParameters();
-        writer.Write(discriminatorParams.Length);
-        for (int i = 0; i < discriminatorParams.Length; i++)
-        {
-            writer.Write(NumOps.ToDouble(discriminatorParams[i]));
-        }
-    }
 
     /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        ThrowIfNativeModeUnavailable();
 
-        // Read configuration (already set in constructor, just advance reader)
-        _ = reader.ReadInt32(); // scaleFactor
-        _ = reader.ReadInt32(); // numRRDBBlocks
-        _ = reader.ReadInt32(); // numFeatures
-        _ = reader.ReadDouble(); // residualScale
-        _ = reader.ReadDouble(); // l1Lambda
-        _ = reader.ReadDouble(); // perceptualLambda
-        _ = reader.ReadDouble(); // ganLambda
-
-        // Load generator parameters
-        int generatorParamCount = reader.ReadInt32();
-        var generatorParams = new T[generatorParamCount];
-        for (int i = 0; i < generatorParamCount; i++)
-        {
-            generatorParams[i] = NumOps.FromDouble(reader.ReadDouble());
-        }
-        GeneratorRequired.SetParameters(new Vector<T>(generatorParams));
-
-        // Load discriminator parameters
-        int discriminatorParamCount = reader.ReadInt32();
-        var discriminatorParams = new T[discriminatorParamCount];
-        for (int i = 0; i < discriminatorParamCount; i++)
-        {
-            discriminatorParams[i] = NumOps.FromDouble(reader.ReadDouble());
-        }
-        DiscriminatorRequired.SetParameters(new Vector<T>(discriminatorParams));
-    }
-
-    /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new RealESRGAN<T>(
-            Architecture,
-            Architecture, // Use same architecture for discriminator (will be overwritten on load)
-            Architecture.InputType,
-            _generatorOptimizer,
-            _discriminatorOptimizer,
-            _scaleFactor,
-            _numRRDBBlocks,
-            _numFeatures,
-            _residualScale,
-            _l1Lambda,
-            _perceptualLambda,
-            _ganLambda);
-    }
 
     #endregion
 
diff --git a/src/Video/Restoration/VRT.cs b/src/Video/Restoration/VRT.cs
index 3ffe2673e9..e9c4bbdcdf 100644
--- a/src/Video/Restoration/VRT.cs
+++ b/src/Video/Restoration/VRT.cs
@@ -64,7 +64,7 @@ namespace AiDotNet.Video.Restoration;
     "https://arxiv.org/abs/2201.12288",
     Year = 2022,
     Authors = "Jingyun Liang, Jiezhang Cao, Yuchen Fan, Kai Zhang, Rakesh Ranjan, Yawei Li, Radu Timofte, Luc Van Gool")]
-public class VRT<T> : VideoSuperResolutionBase<T>
+public partial class VRT<T> : VideoSuperResolutionBase<T>
 {
     private readonly VRTOptions _options;
 
@@ -500,46 +500,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        if (!_useNativeMode)
-            throw new InvalidOperationException("Serialization is not supported in ONNX mode.");
-
-        writer.Write(_embedDim);
-        writer.Write(_numFrames);
-        writer.Write(_numBlocks);
-        writer.Write(_scaleFactor);
-        writer.Write(_inputHeight);
-        writer.Write(_inputWidth);
-    }
 
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        if (!_useNativeMode)
-            throw new InvalidOperationException("Deserialization is not supported in ONNX mode.");
-
-        _ = reader.ReadInt32(); // embedDim
-        _ = reader.ReadInt32(); // numFrames
-        _ = reader.ReadInt32(); // numBlocks
-        _ = reader.ReadInt32(); // scaleFactor
-        _ = reader.ReadInt32(); // inputHeight
-        _ = reader.ReadInt32(); // inputWidth
-    }
 
     /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new VRT<T>(
-            Architecture,
-            null,
-            _lossFunction,
-            _embedDim,
-            _numFrames,
-            _numBlocks,
-            _scaleFactor,
-            new VRTOptions(_options));
-    }
+
 
     #endregion
 
diff --git a/src/Video/Segmentation/Cutie.cs b/src/Video/Segmentation/Cutie.cs
index 4778b3ea5c..24140bab74 100644
--- a/src/Video/Segmentation/Cutie.cs
+++ b/src/Video/Segmentation/Cutie.cs
@@ -70,7 +70,7 @@ namespace AiDotNet.Video.Segmentation;
     Direction = TensorLayoutDirection.Input, BatchOptional = true)]
 [TensorLayout(TensorAxis.Batch, TensorAxis.Frames, TensorAxis.Height, TensorAxis.Width,
     Direction = TensorLayoutDirection.Output, BatchOptional = true)]
-public class Cutie<T> : NeuralNetworkBase<T>
+public partial class Cutie<T> : NeuralNetworkBase<T>
 {
     private readonly CutieOptions _options;
 
@@ -835,41 +835,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        if (!_useNativeMode)
-            throw new InvalidOperationException("Serialization is not supported in ONNX mode.");
 
-        writer.Write(_inputHeight);
-        writer.Write(_inputWidth);
-        writer.Write(_inputChannels);
-        writer.Write(_numFeatures);
-        writer.Write(_memorySize);
-    }
 
     /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        if (!_useNativeMode)
-            throw new InvalidOperationException("Deserialization is not supported in ONNX mode.");
 
-        _ = reader.ReadInt32(); // inputHeight
-        _ = reader.ReadInt32(); // inputWidth
-        _ = reader.ReadInt32(); // inputChannels
-        _ = reader.ReadInt32(); // numFeatures
-        _ = reader.ReadInt32(); // memorySize
-    }
-
-    /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new Cutie<T>(
-            Architecture,
-            _optimizer,
-            _lossFunction,
-            _numFeatures,
-            _memorySize);
-    }
 
     #endregion
 }
diff --git a/src/Video/Segmentation/SAM2.cs b/src/Video/Segmentation/SAM2.cs
index d5678cbf03..3fcfa1140c 100644
--- a/src/Video/Segmentation/SAM2.cs
+++ b/src/Video/Segmentation/SAM2.cs
@@ -74,7 +74,7 @@ namespace AiDotNet.Video.Segmentation;
     Direction = TensorLayoutDirection.Input, BatchOptional = true)]
 [TensorLayout(TensorAxis.Batch, TensorAxis.Frames, TensorAxis.Height, TensorAxis.Width,
     Direction = TensorLayoutDirection.Output, BatchOptional = true)]
-public class SAM2<T> : NeuralNetworkBase<T>
+public partial class SAM2<T> : NeuralNetworkBase<T>
 {
     private readonly SAM2Options _options;
 
@@ -1438,43 +1438,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_height);
-        writer.Write(_width);
-        writer.Write(_channels);
-        writer.Write(_numFeatures);
-        writer.Write(_memoryBankSize);
-        writer.Write((int)_modelSize);
-        writer.Write(_useNativeMode);
-        writer.Write(_onnxModelPath ?? string.Empty);
-    }
 
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _ = reader.ReadInt32(); // height
-        _ = reader.ReadInt32(); // width
-        _ = reader.ReadInt32(); // channels
-        _ = reader.ReadInt32(); // numFeatures
-        _ = reader.ReadInt32(); // memoryBankSize
-        _ = reader.ReadInt32(); // modelSize
-        _ = reader.ReadBoolean(); // useNativeMode
-        _ = reader.ReadString(); // onnxModelPath
-    }
 
     /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (_useNativeMode)
-        {
-            return new SAM2<T>(Architecture, _optimizer, LossFunction, _modelSize, _memoryBankSize);
-        }
-        else
-        {
-            return new SAM2<T>(Architecture, _onnxModelPath!, _modelSize, _memoryBankSize);
-        }
-    }
+
 
     #endregion
 }
diff --git a/src/Video/Segmentation/XMem.cs b/src/Video/Segmentation/XMem.cs
index 4e7f7f6d4c..a867febfea 100644
--- a/src/Video/Segmentation/XMem.cs
+++ b/src/Video/Segmentation/XMem.cs
@@ -67,7 +67,7 @@ namespace AiDotNet.Video.Segmentation;
     Direction = TensorLayoutDirection.Input, BatchOptional = true)]
 [TensorLayout(TensorAxis.Batch, TensorAxis.Frames, TensorAxis.Height, TensorAxis.Width,
     Direction = TensorLayoutDirection.Output, BatchOptional = true)]
-public class XMem<T> : NeuralNetworkBase<T>
+public partial class XMem<T> : NeuralNetworkBase<T>
 {
     private readonly XMemOptions _options;
 
@@ -796,52 +796,9 @@ public override ModelMetadata<T> GetModelMetadata()
         };
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        if (!_useNativeMode)
-            throw new InvalidOperationException("Serialization is not supported in ONNX mode.");
-
-        writer.Write(_inputHeight);
-        writer.Write(_inputWidth);
-        writer.Write(_inputChannels);
-        writer.Write(_numFeatures);
-        writer.Write(_sensoryMemorySize);
-        writer.Write(_workingMemorySize);
-        writer.Write(_longTermMemorySize);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        if (!_useNativeMode)
-            throw new InvalidOperationException("Deserialization is not supported in ONNX mode.");
 
-        for (int i = 0; i < 7; i++) _ = reader.ReadInt32();
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var copiedOptions = new XMemOptions(_options);
-        if (!_useNativeMode && _onnxModelPath is { } modelPath)
-        {
-            return new XMem<T>(
-                Architecture,
-                modelPath,
-                _sensoryMemorySize,
-                _workingMemorySize,
-                _longTermMemorySize,
-                copiedOptions);
-        }
-
-        return new XMem<T>(
-            Architecture,
-            optimizer: null,
-            _lossFunction,
-            _numFeatures,
-            _sensoryMemorySize,
-            _workingMemorySize,
-            _longTermMemorySize,
-            copiedOptions);
-    }
 
     #endregion
 }
diff --git a/src/Video/Stabilization/DIFRINT.cs b/src/Video/Stabilization/DIFRINT.cs
index d871967798..aa8b82badc 100644
--- a/src/Video/Stabilization/DIFRINT.cs
+++ b/src/Video/Stabilization/DIFRINT.cs
@@ -74,7 +74,7 @@ namespace AiDotNet.Video.Stabilization;
     "https://arxiv.org/abs/1909.02641",
     Year = 2020,
     Authors = "Jinsoo Choi, In So Kweon")]
-public class DIFRINT<T> : VideoStabilizationBase<T>
+public partial class DIFRINT<T> : VideoStabilizationBase<T>
 {
     private readonly DIFRINTOptions _options;
 
@@ -585,19 +585,9 @@ protected override void InitializeLayers()
         ModelData = _useNativeMode ? this.Serialize() : []
     };
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_numFeatures); writer.Write(_numIterations);
-        writer.Write(_imageHeight); writer.Write(_imageWidth);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        for (int i = 0; i < 4; i++) _ = reader.ReadInt32();
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() =>
-        new DIFRINT<T>(Architecture, _optimizer, _lossFunction, _numFeatures, _numIterations);
+
 
     #endregion
 
diff --git a/src/Video/Stabilization/DUT.cs b/src/Video/Stabilization/DUT.cs
index 4dfcdde0e1..3ac399b51a 100644
--- a/src/Video/Stabilization/DUT.cs
+++ b/src/Video/Stabilization/DUT.cs
@@ -50,7 +50,7 @@ namespace AiDotNet.Video.Stabilization;
     "https://arxiv.org/abs/2011.14574",
     Year = 2022,
     Authors = "Yufei Xu, Jing Zhang, Stephen J. Maybank, Dacheng Tao")]
-public class DUT<T> : VideoStabilizationBase<T>
+public partial class DUT<T> : VideoStabilizationBase<T>
 {
     private readonly DUTOptions _options;
 
@@ -168,34 +168,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write((int)_options.Variant);
-        writer.Write(_options.NumFeatures);
-        writer.Write(_options.NumPyramidLevels);
-        writer.Write(_options.NumResBlocks);
-        writer.Write(_options.TemporalWindowSize);
-        writer.Write(_options.LearningRate);
-        writer.Write(_options.DropoutRate);
-    }
 
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _options.Variant = (VideoModelVariant)reader.ReadInt32();
-        _options.NumFeatures = reader.ReadInt32();
-        _options.NumPyramidLevels = reader.ReadInt32();
-        _options.NumResBlocks = reader.ReadInt32();
-        _options.TemporalWindowSize = reader.ReadInt32();
-        _options.LearningRate = reader.ReadDouble();
-        _options.DropoutRate = reader.ReadDouble();
-    }
 
     /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new DUT<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/Video/Stabilization/FuSta.cs b/src/Video/Stabilization/FuSta.cs
index faeab44a6b..f146f842a7 100644
--- a/src/Video/Stabilization/FuSta.cs
+++ b/src/Video/Stabilization/FuSta.cs
@@ -50,7 +50,7 @@ namespace AiDotNet.Video.Stabilization;
     "https://arxiv.org/abs/2102.06205",
     Year = 2021,
     Authors = "Yu-Lun Liu, Wei-Sheng Lai, Ming-Hsuan Yang, Yung-Yu Chuang, Jia-Bin Huang")]
-public class FuSta<T> : VideoStabilizationBase<T>
+public partial class FuSta<T> : VideoStabilizationBase<T>
 {
     private readonly FuStaOptions _options;
 
@@ -171,34 +171,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write((int)_options.Variant);
-        writer.Write(_options.NumFeatures);
-        writer.Write(_options.NumLevels);
-        writer.Write(_options.NumResBlocks);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.LearningRate);
-        writer.Write(_options.DropoutRate);
-    }
 
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _options.Variant = (VideoModelVariant)reader.ReadInt32();
-        _options.NumFeatures = reader.ReadInt32();
-        _options.NumLevels = reader.ReadInt32();
-        _options.NumResBlocks = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.LearningRate = reader.ReadDouble();
-        _options.DropoutRate = reader.ReadDouble();
-    }
 
     /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new FuSta<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/Video/Stabilization/GaVS.cs b/src/Video/Stabilization/GaVS.cs
index 37e8fb72f8..ba7796d6f1 100644
--- a/src/Video/Stabilization/GaVS.cs
+++ b/src/Video/Stabilization/GaVS.cs
@@ -50,7 +50,7 @@ namespace AiDotNet.Video.Stabilization;
     "https://arxiv.org/abs/2501.06868",
     Year = 2025,
     Authors = "Donghao Zhang")]
-public class GaVS<T> : VideoStabilizationBase<T>
+public partial class GaVS<T> : VideoStabilizationBase<T>
 {
     private readonly GaVSOptions _options;
 
@@ -169,34 +169,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write((int)_options.Variant);
-        writer.Write(_options.NumFeatures);
-        writer.Write(_options.NumGazeHeads);
-        writer.Write(_options.GazeHiddenDim);
-        writer.Write(_options.SmoothingWindow);
-        writer.Write(_options.LearningRate);
-        writer.Write(_options.DropoutRate);
-    }
 
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _options.Variant = (VideoModelVariant)reader.ReadInt32();
-        _options.NumFeatures = reader.ReadInt32();
-        _options.NumGazeHeads = reader.ReadInt32();
-        _options.GazeHiddenDim = reader.ReadInt32();
-        _options.SmoothingWindow = reader.ReadInt32();
-        _options.LearningRate = reader.ReadDouble();
-        _options.DropoutRate = reader.ReadDouble();
-    }
 
     /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new GaVS<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/Video/Stabilization/PWStableNet.cs b/src/Video/Stabilization/PWStableNet.cs
index d0597f3210..ab81e36f8e 100644
--- a/src/Video/Stabilization/PWStableNet.cs
+++ b/src/Video/Stabilization/PWStableNet.cs
@@ -50,7 +50,7 @@ namespace AiDotNet.Video.Stabilization;
     "https://arxiv.org/abs/2009.10721",
     Year = 2021,
     Authors = "Minda Zhao, Qiang Ling")]
-public class PWStableNet<T> : VideoStabilizationBase<T>
+public partial class PWStableNet<T> : VideoStabilizationBase<T>
 {
     private readonly PWStableNetOptions _options;
 
@@ -167,34 +167,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write((int)_options.Variant);
-        writer.Write(_options.NumFeatures);
-        writer.Write(_options.NumRefinementIters);
-        writer.Write(_options.GridSize);
-        writer.Write(_options.NumResBlocks);
-        writer.Write(_options.LearningRate);
-        writer.Write(_options.DropoutRate);
-    }
 
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _options.Variant = (VideoModelVariant)reader.ReadInt32();
-        _options.NumFeatures = reader.ReadInt32();
-        _options.NumRefinementIters = reader.ReadInt32();
-        _options.GridSize = reader.ReadInt32();
-        _options.NumResBlocks = reader.ReadInt32();
-        _options.LearningRate = reader.ReadDouble();
-        _options.DropoutRate = reader.ReadDouble();
-    }
 
     /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new PWStableNet<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/Video/Stabilization/StabStitch.cs b/src/Video/Stabilization/StabStitch.cs
index 5361880ab4..00e7a0ff52 100644
--- a/src/Video/Stabilization/StabStitch.cs
+++ b/src/Video/Stabilization/StabStitch.cs
@@ -50,7 +50,7 @@ namespace AiDotNet.Video.Stabilization;
     "https://arxiv.org/abs/2403.06378",
     Year = 2024,
     Authors = "Lang Nie, Chunyu Lin, Kang Liao, Shuaicheng Liu, Yao Zhao")]
-public class StabStitch<T> : VideoStabilizationBase<T>
+public partial class StabStitch<T> : VideoStabilizationBase<T>
 {
     private readonly StabStitchOptions _options;
 
@@ -167,34 +167,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write((int)_options.Variant);
-        writer.Write(_options.NumFeatures);
-        writer.Write(_options.NumWarpBranches);
-        writer.Write(_options.MeshGridRows);
-        writer.Write(_options.MeshGridCols);
-        writer.Write(_options.LearningRate);
-        writer.Write(_options.DropoutRate);
-    }
 
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _options.Variant = (VideoModelVariant)reader.ReadInt32();
-        _options.NumFeatures = reader.ReadInt32();
-        _options.NumWarpBranches = reader.ReadInt32();
-        _options.MeshGridRows = reader.ReadInt32();
-        _options.MeshGridCols = reader.ReadInt32();
-        _options.LearningRate = reader.ReadDouble();
-        _options.DropoutRate = reader.ReadDouble();
-    }
 
     /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new StabStitch<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/Video/Stabilization/ThreeDMF.cs b/src/Video/Stabilization/ThreeDMF.cs
index db3c0f886b..6c5d7249f4 100644
--- a/src/Video/Stabilization/ThreeDMF.cs
+++ b/src/Video/Stabilization/ThreeDMF.cs
@@ -50,7 +50,7 @@ namespace AiDotNet.Video.Stabilization;
     "https://arxiv.org/abs/2404.12887",
     Year = 2024,
     Authors = "Yuchen Zhang, Xiu Li")]
-public class ThreeDMF<T> : VideoStabilizationBase<T>
+public partial class ThreeDMF<T> : VideoStabilizationBase<T>
 {
     private readonly ThreeDMFOptions _options;
 
@@ -167,34 +167,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write((int)_options.Variant);
-        writer.Write(_options.NumFeatures);
-        writer.Write(_options.NumDepthLayers);
-        writer.Write(_options.NumMotionIters);
-        writer.Write(_options.NumResBlocks);
-        writer.Write(_options.LearningRate);
-        writer.Write(_options.DropoutRate);
-    }
 
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _options.Variant = (VideoModelVariant)reader.ReadInt32();
-        _options.NumFeatures = reader.ReadInt32();
-        _options.NumDepthLayers = reader.ReadInt32();
-        _options.NumMotionIters = reader.ReadInt32();
-        _options.NumResBlocks = reader.ReadInt32();
-        _options.LearningRate = reader.ReadDouble();
-        _options.DropoutRate = reader.ReadDouble();
-    }
 
     /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new ThreeDMF<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/Video/Tracking/ByteTrack.cs b/src/Video/Tracking/ByteTrack.cs
index 85f604c1b2..f5fcddd0bc 100644
--- a/src/Video/Tracking/ByteTrack.cs
+++ b/src/Video/Tracking/ByteTrack.cs
@@ -1,4 +1,4 @@
-using System.IO;
+using System.IO;
 using AiDotNet.Attributes;
 using AiDotNet.Enums;
 using AiDotNet.Helpers;
@@ -61,7 +61,7 @@ namespace AiDotNet.Video.Tracking;
     Direction = TensorLayoutDirection.Input, BatchOptional = true)]
 [TensorLayout(TensorAxis.Batch, TensorAxis.Frames, TensorAxis.Length, TensorAxis.Features,
     Direction = TensorLayoutDirection.Output, BatchOptional = true)]
-public class ByteTrack<T> : NeuralNetworkBase<T>
+public partial class ByteTrack<T> : NeuralNetworkBase<T>
 {
     private readonly ByteTrackOptions _options;
 
@@ -400,20 +400,9 @@ protected override void InitializeLayers()
         ModelData = _useNativeMode ? this.Serialize() : []
     };
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_numFeatures); writer.Write(_numClasses);
-        writer.Write(_highThreshold); writer.Write(_lowThreshold); writer.Write(_maxAge);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _ = reader.ReadInt32(); _ = reader.ReadInt32();
-        _ = reader.ReadDouble(); _ = reader.ReadDouble(); _ = reader.ReadInt32();
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance() =>
-        new ByteTrack<T>(Architecture, _optimizer, _lossFunction, _numFeatures, _numClasses, _highThreshold, _lowThreshold, _maxAge);
+
 
     #endregion
 }
diff --git a/src/Video/Understanding/InternVideo2.cs b/src/Video/Understanding/InternVideo2.cs
index 8f37c377cb..a572d5e5cd 100644
--- a/src/Video/Understanding/InternVideo2.cs
+++ b/src/Video/Understanding/InternVideo2.cs
@@ -72,7 +72,7 @@ namespace AiDotNet.Video.Understanding;
     Direction = TensorLayoutDirection.Input, BatchOptional = true)]
 [TensorLayout(TensorAxis.Batch, TensorAxis.Features,
     Direction = TensorLayoutDirection.Output, BatchOptional = true)]
-public class InternVideo2<T> : NeuralNetworkBase<T>
+public partial class InternVideo2<T> : NeuralNetworkBase<T>
 {
     private readonly InternVideo2Options _options;
 
@@ -501,46 +501,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        if (!_useNativeMode)
-            throw new InvalidOperationException("Serialization is not supported in ONNX mode.");
-
-        writer.Write(_embedDim);
-        writer.Write(_numHeads);
-        writer.Write(_numEncoderLayers);
-        writer.Write(_numFrames);
-        writer.Write(_patchSize);
-        writer.Write(_imageSize);
-    }
 
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        if (!_useNativeMode)
-            throw new InvalidOperationException("Deserialization is not supported in ONNX mode.");
-
-        _ = reader.ReadInt32(); // embedDim
-        _ = reader.ReadInt32(); // numHeads
-        _ = reader.ReadInt32(); // numEncoderLayers
-        _ = reader.ReadInt32(); // numFrames
-        _ = reader.ReadInt32(); // patchSize
-        _ = reader.ReadInt32(); // imageSize
-    }
 
     /// <inheritdoc/>
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new InternVideo2<T>(
-            Architecture,
-            _optimizer,
-            _lossFunction,
-            _embedDim,
-            _numHeads,
-            _numEncoderLayers,
-            _numFrames,
-            _patchSize);
-    }
+
 
     #endregion
 }
diff --git a/src/Video/Understanding/VideoCLIP.cs b/src/Video/Understanding/VideoCLIP.cs
index 5764eed19a..6f18f2b8ab 100644
--- a/src/Video/Understanding/VideoCLIP.cs
+++ b/src/Video/Understanding/VideoCLIP.cs
@@ -116,7 +116,9 @@ public partial class VideoCLIP<T> : NeuralNetworkBase<T>
 
     // Text encoder components
     // Proper CLIP-style token embedding: embedding lookup table [vocab_size, hidden_dim]
+    [AiDotNet.Attributes.TrainableParameter]
     private readonly Tensor<T> _tokenEmbeddingTable;          // Embedding lookup table
+    [AiDotNet.Attributes.TrainableParameter]
     private readonly Tensor<T> _positionalEmbeddingTable;     // Learned positional embeddings
     private readonly List<ConvolutionalLayer<T>> _textTransformerQKV;      // QKV projections
     private readonly List<ConvolutionalLayer<T>> _textTransformerAttnProj; // Attention output
@@ -293,10 +295,10 @@ public VideoCLIP(
         BindLayerViewsFromLayers();
 
         // Initialize embedding tables (not part of layer list)
-        _tokenEmbeddingTable = new Tensor<T>([_vocabSize, hiddenDim]);
-        InitializeEmbeddingTable(_tokenEmbeddingTable, _vocabSize, hiddenDim);
-        _positionalEmbeddingTable = new Tensor<T>([_textMaxLength, hiddenDim]);
-        InitializeEmbeddingTable(_positionalEmbeddingTable, _textMaxLength, hiddenDim);
+        _tokenEmbeddingTable = new Tensor<T>([_vocabSize, effectiveHiddenDim]);
+        InitializeEmbeddingTable(_tokenEmbeddingTable, _vocabSize, effectiveHiddenDim);
+        _positionalEmbeddingTable = new Tensor<T>([_textMaxLength, effectiveHiddenDim]);
+        InitializeEmbeddingTable(_positionalEmbeddingTable, _textMaxLength, effectiveHiddenDim);
 
         // Paper-faithful training configuration (Xu et al. 2021, arXiv:2109.14084, Training Details):
         // "Adam ... with betas of (0.9, 0.98), an initial learning rate of 5e-5, 1000 steps of
@@ -701,11 +703,11 @@ private Tensor<T> ProcessFrames(Tensor<T> videoFrames)
                 features = ApplyGELU(features);
             }
 
-            // VideoCLIP consumes features from a pretrained video backbone and
-            // explicitly stops gradients at that boundary (Xu et al., 2021,
-            // Eq. 1). The temporal aggregation and projection above the frozen
-            // backbone remain trainable.
-            features = Engine.StopGradient(features);
+            // This native implementation constructs its spatial encoder locally and exposes those
+            // weights through the framework parameter surface. It is therefore end-to-end
+            // trainable, not a wrapper around an externally pretrained frozen backbone. Detaching
+            // here made the published convolution weights affect the numeric loss while their tape
+            // gradients stayed exactly zero.
 
             allFrameFeatures.Add(features);
         }
@@ -1157,87 +1159,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc/>
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_height);
-        writer.Write(_width);
-        writer.Write(_channels);
-        writer.Write(_numFrames);
-        writer.Write(_embeddingDim);
-        writer.Write(_textMaxLength);
-        writer.Write(_vocabSize);
-        writer.Write(_temperature);
-
-        // The learned embedding tables. They are trainable (see GetExtraTrainableTensors) and live
-        // outside Layers, so the layer-by-layer weight sections of the stream do not carry them and
-        // a reload rebuilt them from InitializeEmbeddingTable's RNG instead — dropping trained text
-        // -tower weights on every save/load. Same element-by-element idiom VisionTransformer uses
-        // for its CLS and positional tokens.
-        for (int i = 0; i < _tokenEmbeddingTable.Length; i++)
-            writer.Write(Convert.ToDouble(_tokenEmbeddingTable[i]));
-        for (int i = 0; i < _positionalEmbeddingTable.Length; i++)
-            writer.Write(Convert.ToDouble(_positionalEmbeddingTable[i]));
-    }
 
-    /// <inheritdoc/>
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _ = reader.ReadInt32();
-        _ = reader.ReadInt32();
-        _ = reader.ReadInt32();
-        _ = reader.ReadInt32();
-        _ = reader.ReadInt32();
-        _ = reader.ReadInt32();
-        _ = reader.ReadInt32();
-        _ = reader.ReadDouble();
-        // Restore the learned embedding tables written above. The geometry fields are discarded
-        // because they are readonly and the constructor has already rebuilt this instance at the
-        // right sizes; these tensors, by contrast, carry trained values that only the stream has.
-        for (int i = 0; i < _tokenEmbeddingTable.Length; i++)
-            _tokenEmbeddingTable[i] = NumOps.FromDouble(reader.ReadDouble());
-        for (int i = 0; i < _positionalEmbeddingTable.Length; i++)
-            _positionalEmbeddingTable[i] = NumOps.FromDouble(reader.ReadDouble());
-
-        // The base deserializer has just replaced Layers with the restored instances. Rebind the
-        // per-stage views so the explicit forward and the tape both consume those restored weights
-        // rather than the constructor-fresh layers they were bound to.
-        BindLayerViewsFromLayers();
-    }
 
     /// <inheritdoc/>
-    /// <summary>
-    /// Surfaces the token and positional embedding tables, which are learned parameters the model
-    /// owns OUTSIDE <c>Layers</c>.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// In CLIP (Radford et al. 2021 §2.4) the text encoder's token embedding and positional
-    /// embedding are both learned — <c>nn.Embedding(vocab_size, width)</c> and an
-    /// <c>nn.Parameter</c> respectively — so they appear in <c>state_dict()</c>, receive gradients,
-    /// and survive a module copy. Here they are plain tensors built in the constructor, so without
-    /// this hook the <c>Layers</c>-only parameter walk never saw them and they were frozen at their
-    /// random initialization for the model's entire lifetime, never trained and never persisted.
-    /// </para>
-    /// <para>
-    /// The clone consequence was the sharper one. A copy re-runs the constructor, which
-    /// re-initializes both tables to FRESH random values, and nothing afterwards overwrote them:
-    /// the clone's text tower therefore computed a different function from the original's while
-    /// every tensor in <c>Layers</c> matched bit-for-bit (measured: 22/22 chunks and 48173/48173
-    /// parameters identical, parameter L2 equal to 17 digits, yet the outputs differed by 1.6e+00
-    /// on identical input, and MoreData_ShouldNotDegrade failed on the clone).
-    /// </para>
-    /// <para>
-    /// Yielding them here opts into the three base paths that already handle model-owned tensors:
-    /// the tape optimizer's step, the serialization round-trip, and the copy-on-write clone. Same
-    /// mechanism <see cref="AiDotNet.NeuralNetworks.VisionTransformer{T}"/> uses for its CLS and
-    /// positional tokens.
-    /// </para>
-    /// </remarks>
-    protected override IEnumerable<Tensor<T>> GetExtraTrainableTensors()
-    {
-        yield return _tokenEmbeddingTable;
-        yield return _positionalEmbeddingTable;
-    }
+
 
     /// <summary>
     /// (Re)binds the per-stage layer views to the current contents of <c>Layers</c>.
@@ -1301,36 +1226,5 @@ private void BindLayerViewsFromLayers()
         _logitScale = (ConvolutionalLayer<T>)Layers[idx++];
     }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        return new VideoCLIP<T>(
-            Architecture, _numFrames, _embeddingDim, _textMaxLength, _vocabSize, _temperature,
-            // EVERY option that affects training must be carried, not just the topology ones. This
-            // copied five fields and dropped Beta1, Beta2, MaxGradientNorm, WarmupSteps,
-            // TotalTrainingSteps and DecayPower, so a clone silently rebuilt its optimizer from the
-            // DEFAULTS — including the paper's 1000-step warm-up, which the caller may deliberately have
-            // turned off. A clone that warms up when the original does not is not the same model.
-            //
-            // Measured: MoreData_ShouldNotDegrade clones the network and trains the clone, and the
-            // clone's loss came back byte-identical (0.7257835234621279) at 2, 4 and 12 iterations with
-            // its parameter L2 unchanged to 16 digits — the LR sat at ~5e-8 on the first rung of a ramp
-            // the original had disabled, so no step could move anything. The invariant was reporting a
-            // real defect, not task-to-task variance.
-            options: new VideoCLIPVideoOptions
-            {
-                HiddenDimension = _options.HiddenDimension,
-                NumSpatialBlocks = _options.NumSpatialBlocks,
-                NumTemporalBlocks = _options.NumTemporalBlocks,
-                NumTextBlocks = _options.NumTextBlocks,
-                LearningRate = _options.LearningRate,
-                Beta1 = _options.Beta1,
-                Beta2 = _options.Beta2,
-                MaxGradientNorm = _options.MaxGradientNorm,
-                WarmupSteps = _options.WarmupSteps,
-                TotalTrainingSteps = _options.TotalTrainingSteps,
-                DecayPower = _options.DecayPower
-            });
-    }
-
     #endregion
 }
diff --git a/src/Video/VideoDenoisingBase.cs b/src/Video/VideoDenoisingBase.cs
index 18e2d6e3e5..fe40bb34ea 100644
--- a/src/Video/VideoDenoisingBase.cs
+++ b/src/Video/VideoDenoisingBase.cs
@@ -34,7 +34,7 @@ namespace AiDotNet.Video;
     Direction = TensorLayoutDirection.Input)]
 [TensorLayout(TensorAxis.Frames, TensorAxis.Channels, TensorAxis.Height, TensorAxis.Width,
     Direction = TensorLayoutDirection.Output)]
-public abstract class VideoDenoisingBase<T> : VideoNeuralNetworkBase<T>, IShapeContract
+public abstract partial class VideoDenoisingBase<T> : VideoNeuralNetworkBase<T>, IShapeContract
 {
     /// <inheritdoc />
     public IReadOnlyList<OutputAxisContract>? OutputAxesFor(int inputRank)
diff --git a/src/Video/VideoInpaintingBase.cs b/src/Video/VideoInpaintingBase.cs
index 8cb319e8b4..99eaa78455 100644
--- a/src/Video/VideoInpaintingBase.cs
+++ b/src/Video/VideoInpaintingBase.cs
@@ -1,4 +1,4 @@
-using System.Collections.Generic;
+using System.Collections.Generic;
 using AiDotNet.Attributes;
 using AiDotNet.Enums;
 using AiDotNet.Helpers;
@@ -35,7 +35,7 @@ namespace AiDotNet.Video;
     Direction = TensorLayoutDirection.Input)]
 [TensorLayout(TensorAxis.Frames, TensorAxis.Channels, TensorAxis.Height, TensorAxis.Width,
     Direction = TensorLayoutDirection.Output)]
-public abstract class VideoInpaintingBase<T> : VideoNeuralNetworkBase<T>, IShapeContract
+public abstract partial class VideoInpaintingBase<T> : VideoNeuralNetworkBase<T>, IShapeContract
 {
     /// <inheritdoc />
     public IReadOnlyList<OutputAxisContract>? OutputAxesFor(int inputRank)
@@ -375,7 +375,22 @@ protected override void ResolveLazyLayerShapes()
         if (_shapesProbed || Layers.Count == 0) return;
         _shapesProbed = true;
         int c = Architecture.InputDepth > 0 ? Architecture.InputDepth : 3;
-        _ = PredictCore(new Tensor<T>([1, c, 32, 32]));
+
+        // Best-effort, because this runs underneath ParameterCount, which is a READ. A model whose
+        // PredictCore cannot accept this particular probe is a model whose layers stay lazy -- that
+        // is a smaller and more honest outcome than making every count, every serialization and
+        // every clone throw. E2FGVI is the case in point: its encoder wants RGB plus a one-channel
+        // hole mask, and it only synthesizes that mask when the input arrives with exactly
+        // _channels channels, so a probe at any other depth reached BlendKnownPixels with too few
+        // channels and threw "Index 3 is out of range" out of a plain ParameterCount read.
+        try
+        {
+            _ = PredictCore(new Tensor<T>([1, c, 32, 32]));
+        }
+        catch (Exception)
+        {
+            // Layers stay lazy; callers that need them resolved will drive a real forward.
+        }
     }
 
     /// <inheritdoc />
diff --git a/src/Video/VideoNeuralNetworkBase.cs b/src/Video/VideoNeuralNetworkBase.cs
index e39b57420f..895397fe32 100644
--- a/src/Video/VideoNeuralNetworkBase.cs
+++ b/src/Video/VideoNeuralNetworkBase.cs
@@ -30,7 +30,7 @@ namespace AiDotNet.Video;
 /// 2. Build and train a new model from scratch
 /// </para>
 /// </remarks>
-public abstract class VideoNeuralNetworkBase<T> : NeuralNetworkBase<T>
+public abstract partial class VideoNeuralNetworkBase<T> : NeuralNetworkBase<T>
 {
     /// <summary>
     /// Gets or sets the expected frame height for this model.
diff --git a/src/Video/VideoStabilizationBase.cs b/src/Video/VideoStabilizationBase.cs
index 08842b84ad..b15ecd519c 100644
--- a/src/Video/VideoStabilizationBase.cs
+++ b/src/Video/VideoStabilizationBase.cs
@@ -34,7 +34,7 @@ namespace AiDotNet.Video;
     Direction = TensorLayoutDirection.Input)]
 [TensorLayout(TensorAxis.Frames, TensorAxis.Channels, TensorAxis.Height, TensorAxis.Width,
     Direction = TensorLayoutDirection.Output)]
-public abstract class VideoStabilizationBase<T> : VideoNeuralNetworkBase<T>, IShapeContract
+public abstract partial class VideoStabilizationBase<T> : VideoNeuralNetworkBase<T>, IShapeContract
 {
     /// <inheritdoc />
     public IReadOnlyList<OutputAxisContract>? OutputAxesFor(int inputRank)
diff --git a/src/Video/VideoSuperResolutionBase.cs b/src/Video/VideoSuperResolutionBase.cs
index 41dbb673bf..54b879fa44 100644
--- a/src/Video/VideoSuperResolutionBase.cs
+++ b/src/Video/VideoSuperResolutionBase.cs
@@ -50,7 +50,7 @@ namespace AiDotNet.Video;
 [TensorLayout(TensorAxis.Batch, TensorAxis.Channels, TensorAxis.Height, TensorAxis.Width,
     Direction = TensorLayoutDirection.Output,
     Note = "A single frame with both spatial axes multiplied by ScaleFactor.")]
-public abstract class VideoSuperResolutionBase<T> : VideoNeuralNetworkBase<T>, IVideoSuperResolution<T>, IShapeContract
+public abstract partial class VideoSuperResolutionBase<T> : VideoNeuralNetworkBase<T>, IVideoSuperResolution<T>, IShapeContract
 {
     /// <summary>
     /// The super-resolution family's law: both spatial axes scale by <see cref="ScaleFactor"/> and
diff --git a/src/VisionLanguage/Document/DocPedia.cs b/src/VisionLanguage/Document/DocPedia.cs
index b3ecddafa2..aed04dc0f8 100644
--- a/src/VisionLanguage/Document/DocPedia.cs
+++ b/src/VisionLanguage/Document/DocPedia.cs
@@ -59,7 +59,7 @@ namespace AiDotNet.VisionLanguage.Document;
     Year = 2024,
     Authors = "Feng et al."
 )]
-public class DocPedia<T> : VisionLanguageModelBase<T>, IDocumentUnderstandingModel<T>
+public partial class DocPedia<T> : VisionLanguageModelBase<T>, IDocumentUnderstandingModel<T>
 {
     private readonly DocPediaOptions _options;
 
@@ -275,46 +275,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.IsOcrFree);
-        writer.Write(_options.MaxOutputTokens);
-        writer.Write(_options.EnableFrequencyDomain);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.IsOcrFree = reader.ReadBoolean();
-        _options.MaxOutputTokens = reader.ReadInt32();
-        _options.EnableFrequencyDomain = reader.ReadBoolean();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new DocPedia<T>(Architecture, mp, _options);
-        return new DocPedia<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/Document/Donut.cs b/src/VisionLanguage/Document/Donut.cs
index 62112330bf..659c7f3622 100644
--- a/src/VisionLanguage/Document/Donut.cs
+++ b/src/VisionLanguage/Document/Donut.cs
@@ -57,7 +57,7 @@ namespace AiDotNet.VisionLanguage.Document;
     Year = 2022,
     Authors = "Kim et al."
 )]
-public class Donut<T> : VisionLanguageModelBase<T>, IDocumentUnderstandingModel<T>
+public partial class Donut<T> : VisionLanguageModelBase<T>, IDocumentUnderstandingModel<T>
 {
     private readonly DonutOptions _options;
     private readonly IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer;
@@ -296,54 +296,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.IsOcrFree);
-        writer.Write(_options.MaxOutputTokens);
-        writer.Write(_options.EncoderType ?? string.Empty);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.IsOcrFree = reader.ReadBoolean();
-        _options.MaxOutputTokens = reader.ReadInt32();
-        _options.EncoderType = reader.ReadString();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-        {
-            // Release any existing session before replacing it so repeated
-            // deserialize / clone round-trips don't leak native ONNX resources.
-            OnnxModel?.Dispose();
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-        }
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        // Copy the options so the new instance doesn't share — and mutate, via its
-        // deserialize path — the source instance's options object.
-        var optionsCopy = new DonutOptions(_options);
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new Donut<T>(Architecture, mp, optionsCopy);
-        return new Donut<T>(Architecture, optionsCopy);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/Document/GOTOCR2.cs b/src/VisionLanguage/Document/GOTOCR2.cs
index 48384f4591..268db53430 100644
--- a/src/VisionLanguage/Document/GOTOCR2.cs
+++ b/src/VisionLanguage/Document/GOTOCR2.cs
@@ -57,7 +57,7 @@ namespace AiDotNet.VisionLanguage.Document;
     Year = 2024,
     Authors = "Wei et al."
 )]
-public class GOTOCR2<T> : VisionLanguageModelBase<T>, IDocumentUnderstandingModel<T>
+public partial class GOTOCR2<T> : VisionLanguageModelBase<T>, IDocumentUnderstandingModel<T>
 {
     private readonly GOTOCR2Options _options;
 
@@ -275,48 +275,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.IsOcrFree);
-        writer.Write(_options.MaxOutputTokens);
-        writer.Write(_options.EnableMathOCR);
-        writer.Write(_options.EnableMusicOCR);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.IsOcrFree = reader.ReadBoolean();
-        _options.MaxOutputTokens = reader.ReadInt32();
-        _options.EnableMathOCR = reader.ReadBoolean();
-        _options.EnableMusicOCR = reader.ReadBoolean();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new GOTOCR2<T>(Architecture, mp, _options);
-        return new GOTOCR2<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/Document/LayoutLMv3.cs b/src/VisionLanguage/Document/LayoutLMv3.cs
index 176c1e55df..0b45530ad2 100644
--- a/src/VisionLanguage/Document/LayoutLMv3.cs
+++ b/src/VisionLanguage/Document/LayoutLMv3.cs
@@ -58,7 +58,7 @@ namespace AiDotNet.VisionLanguage.Document;
     Year = 2022,
     Authors = "Huang et al."
 )]
-public class LayoutLMv3<T> : VisionLanguageModelBase<T>, IDocumentUnderstandingModel<T>
+public partial class LayoutLMv3<T> : VisionLanguageModelBase<T>, IDocumentUnderstandingModel<T>
 {
     private readonly LayoutLMv3Options _options;
 
@@ -273,46 +273,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.IsOcrFree);
-        writer.Write(_options.MaxOutputTokens);
-        writer.Write(_options.MaxLayoutTokens);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.IsOcrFree = reader.ReadBoolean();
-        _options.MaxOutputTokens = reader.ReadInt32();
-        _options.MaxLayoutTokens = reader.ReadInt32();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new LayoutLMv3<T>(Architecture, mp, _options);
-        return new LayoutLMv3<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/Document/MPLUGDocOwl.cs b/src/VisionLanguage/Document/MPLUGDocOwl.cs
index 19d6690979..87b84a9367 100644
--- a/src/VisionLanguage/Document/MPLUGDocOwl.cs
+++ b/src/VisionLanguage/Document/MPLUGDocOwl.cs
@@ -59,7 +59,7 @@ namespace AiDotNet.VisionLanguage.Document;
     Year = 2023,
     Authors = "Ye et al."
 )]
-public class MPLUGDocOwl<T> : VisionLanguageModelBase<T>, IDocumentUnderstandingModel<T>
+public partial class MPLUGDocOwl<T> : VisionLanguageModelBase<T>, IDocumentUnderstandingModel<T>
 {
     private readonly MPLUGDocOwlOptions _options;
 
@@ -275,48 +275,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.IsOcrFree);
-        writer.Write(_options.MaxOutputTokens);
-        writer.Write(_options.AbstractorDim);
-        writer.Write(_options.NumAbstractorLayers);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.IsOcrFree = reader.ReadBoolean();
-        _options.MaxOutputTokens = reader.ReadInt32();
-        _options.AbstractorDim = reader.ReadInt32();
-        _options.NumAbstractorLayers = reader.ReadInt32();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new MPLUGDocOwl<T>(Architecture, mp, _options);
-        return new MPLUGDocOwl<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/Document/MPLUGDocOwl15.cs b/src/VisionLanguage/Document/MPLUGDocOwl15.cs
index cf91fed0fe..1a5a3724c5 100644
--- a/src/VisionLanguage/Document/MPLUGDocOwl15.cs
+++ b/src/VisionLanguage/Document/MPLUGDocOwl15.cs
@@ -59,7 +59,7 @@ namespace AiDotNet.VisionLanguage.Document;
     Year = 2024,
     Authors = "Hu et al."
 )]
-public class MPLUGDocOwl15<T> : VisionLanguageModelBase<T>, IDocumentUnderstandingModel<T>
+public partial class MPLUGDocOwl15<T> : VisionLanguageModelBase<T>, IDocumentUnderstandingModel<T>
 {
     private readonly MPLUGDocOwl15Options _options;
 
@@ -276,50 +276,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.IsOcrFree);
-        writer.Write(_options.MaxOutputTokens);
-        writer.Write(_options.AbstractorDim);
-        writer.Write(_options.NumAbstractorLayers);
-        writer.Write(_options.EnableUnifiedStructureLearning);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.IsOcrFree = reader.ReadBoolean();
-        _options.MaxOutputTokens = reader.ReadInt32();
-        _options.AbstractorDim = reader.ReadInt32();
-        _options.NumAbstractorLayers = reader.ReadInt32();
-        _options.EnableUnifiedStructureLearning = reader.ReadBoolean();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new MPLUGDocOwl15<T>(Architecture, mp, _options);
-        return new MPLUGDocOwl15<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/Document/MPLUGDocOwl2.cs b/src/VisionLanguage/Document/MPLUGDocOwl2.cs
index 28cb4cecc7..0d9ea0d6b7 100644
--- a/src/VisionLanguage/Document/MPLUGDocOwl2.cs
+++ b/src/VisionLanguage/Document/MPLUGDocOwl2.cs
@@ -59,7 +59,7 @@ namespace AiDotNet.VisionLanguage.Document;
     Year = 2024,
     Authors = "Hu et al."
 )]
-public class MPLUGDocOwl2<T> : VisionLanguageModelBase<T>, IDocumentUnderstandingModel<T>
+public partial class MPLUGDocOwl2<T> : VisionLanguageModelBase<T>, IDocumentUnderstandingModel<T>
 {
     private readonly MPLUGDocOwl2Options _options;
 
@@ -275,50 +275,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.IsOcrFree);
-        writer.Write(_options.MaxOutputTokens);
-        writer.Write(_options.AbstractorDim);
-        writer.Write(_options.NumAbstractorLayers);
-        writer.Write(_options.MaxPages);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.IsOcrFree = reader.ReadBoolean();
-        _options.MaxOutputTokens = reader.ReadInt32();
-        _options.AbstractorDim = reader.ReadInt32();
-        _options.NumAbstractorLayers = reader.ReadInt32();
-        _options.MaxPages = reader.ReadInt32();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new MPLUGDocOwl2<T>(Architecture, mp, _options);
-        return new MPLUGDocOwl2<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/Document/Nougat.cs b/src/VisionLanguage/Document/Nougat.cs
index 9e0593e48f..1dcfbe39cc 100644
--- a/src/VisionLanguage/Document/Nougat.cs
+++ b/src/VisionLanguage/Document/Nougat.cs
@@ -58,7 +58,7 @@ namespace AiDotNet.VisionLanguage.Document;
     Year = 2023,
     Authors = "Blecher et al."
 )]
-public class Nougat<T> : VisionLanguageModelBase<T>, IDocumentUnderstandingModel<T>
+public partial class Nougat<T> : VisionLanguageModelBase<T>, IDocumentUnderstandingModel<T>
 {
     private readonly NougatOptions _options;
 
@@ -272,46 +272,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.IsOcrFree);
-        writer.Write(_options.MaxOutputTokens);
-        writer.Write(_options.OutputFormat ?? string.Empty);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.IsOcrFree = reader.ReadBoolean();
-        _options.MaxOutputTokens = reader.ReadInt32();
-        _options.OutputFormat = reader.ReadString();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new Nougat<T>(Architecture, mp, _options);
-        return new Nougat<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/Document/Pix2Struct.cs b/src/VisionLanguage/Document/Pix2Struct.cs
index 2994efd678..c6f581255b 100644
--- a/src/VisionLanguage/Document/Pix2Struct.cs
+++ b/src/VisionLanguage/Document/Pix2Struct.cs
@@ -58,7 +58,7 @@ namespace AiDotNet.VisionLanguage.Document;
     Year = 2023,
     Authors = "Lee et al."
 )]
-public class Pix2Struct<T> : VisionLanguageModelBase<T>, IDocumentUnderstandingModel<T>
+public partial class Pix2Struct<T> : VisionLanguageModelBase<T>, IDocumentUnderstandingModel<T>
 {
     private readonly Pix2StructOptions _options;
 
@@ -275,48 +275,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.IsOcrFree);
-        writer.Write(_options.MaxOutputTokens);
-        writer.Write(_options.MaxPatchesPerImage);
-        writer.Write(_options.EnableVariableResolution);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.IsOcrFree = reader.ReadBoolean();
-        _options.MaxOutputTokens = reader.ReadInt32();
-        _options.MaxPatchesPerImage = reader.ReadInt32();
-        _options.EnableVariableResolution = reader.ReadBoolean();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new Pix2Struct<T>(Architecture, mp, _options);
-        return new Pix2Struct<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/Document/Surya.cs b/src/VisionLanguage/Document/Surya.cs
index 80f0a6fbe4..b22efa0ff5 100644
--- a/src/VisionLanguage/Document/Surya.cs
+++ b/src/VisionLanguage/Document/Surya.cs
@@ -59,7 +59,7 @@ namespace AiDotNet.VisionLanguage.Document;
     Year = 2024,
     Authors = "Paruchuri"
 )]
-public class Surya<T> : VisionLanguageModelBase<T>, IDocumentUnderstandingModel<T>
+public partial class Surya<T> : VisionLanguageModelBase<T>, IDocumentUnderstandingModel<T>
 {
     private readonly SuryaOptions _options;
 
@@ -277,48 +277,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.IsOcrFree);
-        writer.Write(_options.MaxOutputTokens);
-        writer.Write(_options.NumLanguages);
-        writer.Write(_options.EnableLayoutAnalysis);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.IsOcrFree = reader.ReadBoolean();
-        _options.MaxOutputTokens = reader.ReadInt32();
-        _options.NumLanguages = reader.ReadInt32();
-        _options.EnableLayoutAnalysis = reader.ReadBoolean();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new Surya<T>(Architecture, mp, _options);
-        return new Surya<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/Document/TextMonkey.cs b/src/VisionLanguage/Document/TextMonkey.cs
index d4f9d7a037..c8fd26f444 100644
--- a/src/VisionLanguage/Document/TextMonkey.cs
+++ b/src/VisionLanguage/Document/TextMonkey.cs
@@ -59,7 +59,7 @@ namespace AiDotNet.VisionLanguage.Document;
     Year = 2024,
     Authors = "Liu et al."
 )]
-public class TextMonkey<T> : VisionLanguageModelBase<T>, IDocumentUnderstandingModel<T>
+public partial class TextMonkey<T> : VisionLanguageModelBase<T>, IDocumentUnderstandingModel<T>
 {
     private readonly TextMonkeyOptions _options;
 
@@ -276,46 +276,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.IsOcrFree);
-        writer.Write(_options.MaxOutputTokens);
-        writer.Write(_options.EnableShiftedWindowAttention);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.IsOcrFree = reader.ReadBoolean();
-        _options.MaxOutputTokens = reader.ReadInt32();
-        _options.EnableShiftedWindowAttention = reader.ReadBoolean();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new TextMonkey<T>(Architecture, mp, _options);
-        return new TextMonkey<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/Document/UReader.cs b/src/VisionLanguage/Document/UReader.cs
index 551b5b09eb..32cce8a8ce 100644
--- a/src/VisionLanguage/Document/UReader.cs
+++ b/src/VisionLanguage/Document/UReader.cs
@@ -59,7 +59,7 @@ namespace AiDotNet.VisionLanguage.Document;
     Year = 2024,
     Authors = "Ye et al."
 )]
-public class UReader<T> : VisionLanguageModelBase<T>, IDocumentUnderstandingModel<T>
+public partial class UReader<T> : VisionLanguageModelBase<T>, IDocumentUnderstandingModel<T>
 {
     private readonly UReaderOptions _options;
 
@@ -277,46 +277,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.IsOcrFree);
-        writer.Write(_options.MaxOutputTokens);
-        writer.Write(_options.EnableShapeAdaptiveCropping);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.IsOcrFree = reader.ReadBoolean();
-        _options.MaxOutputTokens = reader.ReadInt32();
-        _options.EnableShapeAdaptiveCropping = reader.ReadBoolean();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new UReader<T>(Architecture, mp, _options);
-        return new UReader<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/Editing/EmuEdit.cs b/src/VisionLanguage/Editing/EmuEdit.cs
index 72dc51a929..38dbf73d43 100644
--- a/src/VisionLanguage/Editing/EmuEdit.cs
+++ b/src/VisionLanguage/Editing/EmuEdit.cs
@@ -57,7 +57,7 @@ namespace AiDotNet.VisionLanguage.Editing;
     Year = 2024,
     Authors = "Sheynin et al."
 )]
-public class EmuEdit<T> : VisionLanguageModelBase<T>, IImageEditingVLM<T>
+public partial class EmuEdit<T> : VisionLanguageModelBase<T>, IImageEditingVLM<T>
 {
     private readonly EmuEditOptions _options;
 
@@ -293,44 +293,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.OutputImageSize);
-        writer.Write(_options.EnablePreciseEditing);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.OutputImageSize = reader.ReadInt32();
-        _options.EnablePreciseEditing = reader.ReadBoolean();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new EmuEdit<T>(Architecture, mp, _options);
-        return new EmuEdit<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/Editing/MGIE.cs b/src/VisionLanguage/Editing/MGIE.cs
index 119300b432..bd8927f2e0 100644
--- a/src/VisionLanguage/Editing/MGIE.cs
+++ b/src/VisionLanguage/Editing/MGIE.cs
@@ -58,7 +58,7 @@ namespace AiDotNet.VisionLanguage.Editing;
     Year = 2024,
     Authors = "Fu et al."
 )]
-public class MGIE<T> : VisionLanguageModelBase<T>, IImageEditingVLM<T>
+public partial class MGIE<T> : VisionLanguageModelBase<T>, IImageEditingVLM<T>
 {
     private readonly MGIEOptions _options;
 
@@ -297,44 +297,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.OutputImageSize);
-        writer.Write(_options.EnableExpressiveInstructions);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.OutputImageSize = reader.ReadInt32();
-        _options.EnableExpressiveInstructions = reader.ReadBoolean();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new MGIE<T>(Architecture, mp, _options);
-        return new MGIE<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/Editing/SmartEdit.cs b/src/VisionLanguage/Editing/SmartEdit.cs
index e3825c5a6a..1012def0cc 100644
--- a/src/VisionLanguage/Editing/SmartEdit.cs
+++ b/src/VisionLanguage/Editing/SmartEdit.cs
@@ -58,7 +58,7 @@ namespace AiDotNet.VisionLanguage.Editing;
     Year = 2024,
     Authors = "Huang et al."
 )]
-public class SmartEdit<T> : VisionLanguageModelBase<T>, IImageEditingVLM<T>
+public partial class SmartEdit<T> : VisionLanguageModelBase<T>, IImageEditingVLM<T>
 {
     private readonly SmartEditOptions _options;
 
@@ -297,44 +297,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.OutputImageSize);
-        writer.Write(_options.EnableComplexReasoning);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.OutputImageSize = reader.ReadInt32();
-        _options.EnableComplexReasoning = reader.ReadBoolean();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new SmartEdit<T>(Architecture, mp, _options);
-        return new SmartEdit<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/Encoders/ALIGN.cs b/src/VisionLanguage/Encoders/ALIGN.cs
index 8324c19102..04333983f9 100644
--- a/src/VisionLanguage/Encoders/ALIGN.cs
+++ b/src/VisionLanguage/Encoders/ALIGN.cs
@@ -304,49 +304,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return meta;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ImageEncoderModelPath ?? string.Empty);
-        writer.Write(_options.TextEncoderModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionEmbeddingDim);
-        writer.Write(_options.TextEmbeddingDim);
-        writer.Write(_options.ProjectionDim);
-        writer.Write(_options.Temperature);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string imgPath = reader.ReadString();
-        if (!string.IsNullOrEmpty(imgPath))
-            _options.ImageEncoderModelPath = imgPath;
-        string txtPath = reader.ReadString();
-        if (!string.IsNullOrEmpty(txtPath))
-            _options.TextEncoderModelPath = txtPath;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionEmbeddingDim = reader.ReadInt32();
-        _options.TextEmbeddingDim = reader.ReadInt32();
-        _options.ProjectionDim = reader.ReadInt32();
-        _options.Temperature = reader.ReadDouble();
-
-        if (!_useNativeMode && _options.ImageEncoderModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxImageEncoder = new OnnxModel<T>(p, _options.OnnxOptions);
-        if (_options.TextEncoderModelPath is { } tp2 && !string.IsNullOrEmpty(tp2))
-            OnnxTextEncoder = new OnnxModel<T>(tp2, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (
-            !_useNativeMode
-            && _options.ImageEncoderModelPath is { } mp
-            && !string.IsNullOrEmpty(mp)
-        )
-            return new ALIGN<T>(Architecture, mp, new ALIGNOptions(_options));
-        return new ALIGN<T>(Architecture, new ALIGNOptions(_options));
-    }
+
 
     private Tensor<T> TokenizeText(string text)
     {
diff --git a/src/VisionLanguage/Encoders/BASIC.cs b/src/VisionLanguage/Encoders/BASIC.cs
index 0a0b14ffcd..adbe78fb7a 100644
--- a/src/VisionLanguage/Encoders/BASIC.cs
+++ b/src/VisionLanguage/Encoders/BASIC.cs
@@ -291,48 +291,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return meta;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ImageEncoderModelPath ?? string.Empty);
-        writer.Write(_options.TextEncoderModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionEmbeddingDim);
-        writer.Write(_options.TextEmbeddingDim);
-        writer.Write(_options.ProjectionDim);
-        writer.Write(_options.Temperature);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string imgPath = reader.ReadString();
-        if (!string.IsNullOrEmpty(imgPath))
-            _options.ImageEncoderModelPath = imgPath;
-        string txtPath = reader.ReadString();
-        if (!string.IsNullOrEmpty(txtPath))
-            _options.TextEncoderModelPath = txtPath;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionEmbeddingDim = reader.ReadInt32();
-        _options.TextEmbeddingDim = reader.ReadInt32();
-        _options.ProjectionDim = reader.ReadInt32();
-        _options.Temperature = reader.ReadDouble();
-        if (!_useNativeMode && _options.ImageEncoderModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxImageEncoder = new OnnxModel<T>(p, _options.OnnxOptions);
-        if (_options.TextEncoderModelPath is { } tp2 && !string.IsNullOrEmpty(tp2))
-            OnnxTextEncoder = new OnnxModel<T>(tp2, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (
-            !_useNativeMode
-            && _options.ImageEncoderModelPath is { } mp
-            && !string.IsNullOrEmpty(mp)
-        )
-            return new BASIC<T>(Architecture, mp, _options);
-        return new BASIC<T>(Architecture, _options);
-    }
+
 
     private Tensor<T> TokenizeText(string text)
     {
diff --git a/src/VisionLanguage/Encoders/BiomedCLIP.cs b/src/VisionLanguage/Encoders/BiomedCLIP.cs
index 50e2643282..5e6b006e5e 100644
--- a/src/VisionLanguage/Encoders/BiomedCLIP.cs
+++ b/src/VisionLanguage/Encoders/BiomedCLIP.cs
@@ -385,51 +385,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ImageEncoderModelPath ?? string.Empty);
-        writer.Write(_options.TextEncoderModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionEmbeddingDim);
-        writer.Write(_options.TextEmbeddingDim);
-        writer.Write(_options.ProjectionDim);
-        writer.Write(_options.Temperature);
-        writer.Write((int)_options.Domain);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string ip = reader.ReadString();
-        if (!string.IsNullOrEmpty(ip))
-            _options.ImageEncoderModelPath = ip;
-        string tp = reader.ReadString();
-        if (!string.IsNullOrEmpty(tp))
-            _options.TextEncoderModelPath = tp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionEmbeddingDim = reader.ReadInt32();
-        _options.TextEmbeddingDim = reader.ReadInt32();
-        _options.ProjectionDim = reader.ReadInt32();
-        _options.Temperature = reader.ReadDouble();
-        _options.Domain = (DomainSpecialization)reader.ReadInt32();
-        if (!_useNativeMode && _options.ImageEncoderModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxImageEncoder = new OnnxModel<T>(p, _options.OnnxOptions);
-        if (_options.TextEncoderModelPath is { } t2 && !string.IsNullOrEmpty(t2))
-            OnnxTextEncoder = new OnnxModel<T>(t2, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var options = new BiomedCLIPOptions(_options);
-        if (
-            !_useNativeMode
-            && _options.ImageEncoderModelPath is { } mp
-            && !string.IsNullOrEmpty(mp)
-        )
-            return new BiomedCLIP<T>(Architecture, mp, options);
-        return new BiomedCLIP<T>(Architecture, options);
-    }
+
 
     private Tensor<T> TokenizeText(string text)
     {
diff --git a/src/VisionLanguage/Encoders/CLIPA.cs b/src/VisionLanguage/Encoders/CLIPA.cs
index 3098c2eac1..f564aa4f2c 100644
--- a/src/VisionLanguage/Encoders/CLIPA.cs
+++ b/src/VisionLanguage/Encoders/CLIPA.cs
@@ -295,48 +295,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ImageEncoderModelPath ?? string.Empty);
-        writer.Write(_options.TextEncoderModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionEmbeddingDim);
-        writer.Write(_options.TextEmbeddingDim);
-        writer.Write(_options.ProjectionDim);
-        writer.Write(_options.Temperature);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string ip = reader.ReadString();
-        if (!string.IsNullOrEmpty(ip))
-            _options.ImageEncoderModelPath = ip;
-        string tp = reader.ReadString();
-        if (!string.IsNullOrEmpty(tp))
-            _options.TextEncoderModelPath = tp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionEmbeddingDim = reader.ReadInt32();
-        _options.TextEmbeddingDim = reader.ReadInt32();
-        _options.ProjectionDim = reader.ReadInt32();
-        _options.Temperature = reader.ReadDouble();
-        if (!_useNativeMode && _options.ImageEncoderModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxImageEncoder = new OnnxModel<T>(p, _options.OnnxOptions);
-        if (_options.TextEncoderModelPath is { } t2 && !string.IsNullOrEmpty(t2))
-            OnnxTextEncoder = new OnnxModel<T>(t2, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (
-            !_useNativeMode
-            && _options.ImageEncoderModelPath is { } mp
-            && !string.IsNullOrEmpty(mp)
-        )
-            return new CLIPA<T>(Architecture, mp, _options);
-        return new CLIPA<T>(Architecture, _options);
-    }
+
 
     private Tensor<T> TokenizeText(string text)
     {
diff --git a/src/VisionLanguage/Encoders/DFNCLIP.cs b/src/VisionLanguage/Encoders/DFNCLIP.cs
index 617fbad4b0..1ea707eb50 100644
--- a/src/VisionLanguage/Encoders/DFNCLIP.cs
+++ b/src/VisionLanguage/Encoders/DFNCLIP.cs
@@ -357,50 +357,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ImageEncoderModelPath ?? string.Empty);
-        writer.Write(_options.TextEncoderModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionEmbeddingDim);
-        writer.Write(_options.TextEmbeddingDim);
-        writer.Write(_options.ProjectionDim);
-        writer.Write(_options.Temperature);
-        writer.Write(_options.FilteringThreshold);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string ip = reader.ReadString();
-        if (!string.IsNullOrEmpty(ip))
-            _options.ImageEncoderModelPath = ip;
-        string tp = reader.ReadString();
-        if (!string.IsNullOrEmpty(tp))
-            _options.TextEncoderModelPath = tp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionEmbeddingDim = reader.ReadInt32();
-        _options.TextEmbeddingDim = reader.ReadInt32();
-        _options.ProjectionDim = reader.ReadInt32();
-        _options.Temperature = reader.ReadDouble();
-        _options.FilteringThreshold = reader.ReadDouble();
-        if (!_useNativeMode && _options.ImageEncoderModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxImageEncoder = new OnnxModel<T>(p, _options.OnnxOptions);
-        if (_options.TextEncoderModelPath is { } t2 && !string.IsNullOrEmpty(t2))
-            OnnxTextEncoder = new OnnxModel<T>(t2, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (
-            !_useNativeMode
-            && _options.ImageEncoderModelPath is { } mp
-            && !string.IsNullOrEmpty(mp)
-        )
-            return new DFNCLIP<T>(Architecture, mp, _options);
-        return new DFNCLIP<T>(Architecture, _options);
-    }
+
 
     private Tensor<T> TokenizeText(string text)
     {
diff --git a/src/VisionLanguage/Encoders/DINOv2.cs b/src/VisionLanguage/Encoders/DINOv2.cs
index 3dc1d2ab48..c4fe1a8f1d 100644
--- a/src/VisionLanguage/Encoders/DINOv2.cs
+++ b/src/VisionLanguage/Encoders/DINOv2.cs
@@ -56,7 +56,7 @@ namespace AiDotNet.VisionLanguage.Encoders;
     Year = 2024,
     Authors = "Oquab et al."
 )]
-public class DINOv2<T> : VisionLanguageModelBase<T>, IVisualEncoder<T>
+public partial class DINOv2<T> : VisionLanguageModelBase<T>, IVisualEncoder<T>
 {
     private readonly DINOv2Options _options;
 
@@ -196,38 +196,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.EmbeddingDim);
-        writer.Write(_options.NumLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.NumRegisterTokens);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.EmbeddingDim = reader.ReadInt32();
-        _options.NumLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.NumRegisterTokens = reader.ReadInt32();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new DINOv2<T>(Architecture, mp, _options);
-        return new DINOv2<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/Encoders/DINOv3.cs b/src/VisionLanguage/Encoders/DINOv3.cs
index 8d1dc0df96..23bb8a593b 100644
--- a/src/VisionLanguage/Encoders/DINOv3.cs
+++ b/src/VisionLanguage/Encoders/DINOv3.cs
@@ -58,7 +58,7 @@ namespace AiDotNet.VisionLanguage.Encoders;
     Year = 2025,
     Authors = "Oriane Siméoni et al. (Meta AI Research)"
 )]
-public class DINOv3<T> : VisionLanguageModelBase<T>, IVisualEncoder<T>
+public partial class DINOv3<T> : VisionLanguageModelBase<T>, IVisualEncoder<T>
 {
     private readonly DINOv3Options _options;
 
@@ -197,40 +197,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.EmbeddingDim);
-        writer.Write(_options.NumLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.NumRegisterTokens);
-        writer.Write(_options.UseSwiGLU);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.EmbeddingDim = reader.ReadInt32();
-        _options.NumLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.NumRegisterTokens = reader.ReadInt32();
-        _options.UseSwiGLU = reader.ReadBoolean();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new DINOv3<T>(Architecture, mp, _options);
-        return new DINOv3<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/Encoders/DeCLIP.cs b/src/VisionLanguage/Encoders/DeCLIP.cs
index d306ef5ebc..bc1e016e65 100644
--- a/src/VisionLanguage/Encoders/DeCLIP.cs
+++ b/src/VisionLanguage/Encoders/DeCLIP.cs
@@ -281,49 +281,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ImageEncoderModelPath ?? string.Empty);
-        writer.Write(_options.TextEncoderModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionEmbeddingDim);
-        writer.Write(_options.TextEmbeddingDim);
-        writer.Write(_options.ProjectionDim);
-        writer.Write(_options.Temperature);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string ip = reader.ReadString();
-        if (!string.IsNullOrEmpty(ip))
-            _options.ImageEncoderModelPath = ip;
-        string tp = reader.ReadString();
-        if (!string.IsNullOrEmpty(tp))
-            _options.TextEncoderModelPath = tp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionEmbeddingDim = reader.ReadInt32();
-        _options.TextEmbeddingDim = reader.ReadInt32();
-        _options.ProjectionDim = reader.ReadInt32();
-        _options.Temperature = reader.ReadDouble();
-        if (!_useNativeMode && _options.ImageEncoderModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxImageEncoder = new OnnxModel<T>(p, _options.OnnxOptions);
-        if (_options.TextEncoderModelPath is { } t2 && !string.IsNullOrEmpty(t2))
-            OnnxTextEncoder = new OnnxModel<T>(t2, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var clonedOptions = new DeCLIPOptions(_options);
-        if (
-            !_useNativeMode
-            && _options.ImageEncoderModelPath is { } mp
-            && !string.IsNullOrEmpty(mp)
-        )
-            return new DeCLIP<T>(Architecture, mp, clonedOptions);
-        return new DeCLIP<T>(Architecture, clonedOptions, optimizer: null);
-    }
+
 
     private Tensor<T> TokenizeText(string text)
     {
diff --git a/src/VisionLanguage/Encoders/EVACLIP.cs b/src/VisionLanguage/Encoders/EVACLIP.cs
index 94c2a8ae5f..3017edaac3 100644
--- a/src/VisionLanguage/Encoders/EVACLIP.cs
+++ b/src/VisionLanguage/Encoders/EVACLIP.cs
@@ -289,54 +289,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ImageEncoderModelPath ?? string.Empty);
-        writer.Write(_options.TextEncoderModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionEmbeddingDim);
-        writer.Write(_options.TextEmbeddingDim);
-        writer.Write(_options.ProjectionDim);
-        writer.Write(_options.Temperature);
-        writer.Write(_options.UseEVA02);
-        writer.Write(_options.UseRoPE);
-        writer.Write(_options.UseSwiGLU);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string ip = reader.ReadString();
-        if (!string.IsNullOrEmpty(ip))
-            _options.ImageEncoderModelPath = ip;
-        string tp = reader.ReadString();
-        if (!string.IsNullOrEmpty(tp))
-            _options.TextEncoderModelPath = tp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionEmbeddingDim = reader.ReadInt32();
-        _options.TextEmbeddingDim = reader.ReadInt32();
-        _options.ProjectionDim = reader.ReadInt32();
-        _options.Temperature = reader.ReadDouble();
-        _options.UseEVA02 = reader.ReadBoolean();
-        _options.UseRoPE = reader.ReadBoolean();
-        _options.UseSwiGLU = reader.ReadBoolean();
-        if (!_useNativeMode && _options.ImageEncoderModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxImageEncoder = new OnnxModel<T>(p, _options.OnnxOptions);
-        if (_options.TextEncoderModelPath is { } t2 && !string.IsNullOrEmpty(t2))
-            OnnxTextEncoder = new OnnxModel<T>(t2, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (
-            !_useNativeMode
-            && _options.ImageEncoderModelPath is { } mp
-            && !string.IsNullOrEmpty(mp)
-        )
-            return new EVACLIP<T>(Architecture, mp, _options);
-        return new EVACLIP<T>(Architecture, _options);
-    }
+
 
     private Tensor<T> TokenizeText(string text)
     {
diff --git a/src/VisionLanguage/Encoders/FLIP.cs b/src/VisionLanguage/Encoders/FLIP.cs
index 15e71565e4..17417699b6 100644
--- a/src/VisionLanguage/Encoders/FLIP.cs
+++ b/src/VisionLanguage/Encoders/FLIP.cs
@@ -284,50 +284,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return meta;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ImageEncoderModelPath ?? string.Empty);
-        writer.Write(_options.TextEncoderModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionEmbeddingDim);
-        writer.Write(_options.TextEmbeddingDim);
-        writer.Write(_options.ProjectionDim);
-        writer.Write(_options.Temperature);
-        writer.Write(_options.MaskingRatio);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string ip = reader.ReadString();
-        if (!string.IsNullOrEmpty(ip))
-            _options.ImageEncoderModelPath = ip;
-        string tp = reader.ReadString();
-        if (!string.IsNullOrEmpty(tp))
-            _options.TextEncoderModelPath = tp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionEmbeddingDim = reader.ReadInt32();
-        _options.TextEmbeddingDim = reader.ReadInt32();
-        _options.ProjectionDim = reader.ReadInt32();
-        _options.Temperature = reader.ReadDouble();
-        _options.MaskingRatio = reader.ReadDouble();
-        if (!_useNativeMode && _options.ImageEncoderModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxImageEncoder = new OnnxModel<T>(p, _options.OnnxOptions);
-        if (_options.TextEncoderModelPath is { } t2 && !string.IsNullOrEmpty(t2))
-            OnnxTextEncoder = new OnnxModel<T>(t2, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (
-            !_useNativeMode
-            && _options.ImageEncoderModelPath is { } mp
-            && !string.IsNullOrEmpty(mp)
-        )
-            return new FLIP<T>(Architecture, mp, new FLIPOptions(_options));
-        return new FLIP<T>(Architecture, new FLIPOptions(_options));
-    }
+
 
     private Tensor<T> TokenizeText(string text)
     {
diff --git a/src/VisionLanguage/Encoders/Florence2.cs b/src/VisionLanguage/Encoders/Florence2.cs
index 2a550b42a3..d9d448adce 100644
--- a/src/VisionLanguage/Encoders/Florence2.cs
+++ b/src/VisionLanguage/Encoders/Florence2.cs
@@ -60,7 +60,7 @@ namespace AiDotNet.VisionLanguage.Encoders;
     Year = 2024,
     Authors = "Xiao et al."
 )]
-public class Florence2<T> : VisionLanguageModelBase<T>, IVisualEncoder<T>
+public partial class Florence2<T> : VisionLanguageModelBase<T>, IVisualEncoder<T>
 {
     private readonly Florence2Options _options;
 
@@ -218,44 +218,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.EmbeddingDim);
-        writer.Write(_options.NumLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.DecoderEmbeddingDim);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumDecoderHeads);
-        writer.Write((int)_options.ModelSize);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.EmbeddingDim = reader.ReadInt32();
-        _options.NumLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.DecoderEmbeddingDim = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumDecoderHeads = reader.ReadInt32();
-        _options.ModelSize = (Florence2ModelSize)reader.ReadInt32();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new Florence2<T>(Architecture, mp, _options);
-        return new Florence2<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/Encoders/InternViT.cs b/src/VisionLanguage/Encoders/InternViT.cs
index 395b7cce70..2576220c25 100644
--- a/src/VisionLanguage/Encoders/InternViT.cs
+++ b/src/VisionLanguage/Encoders/InternViT.cs
@@ -57,7 +57,7 @@ namespace AiDotNet.VisionLanguage.Encoders;
     Year = 2024,
     Authors = "Chen et al."
 )]
-public class InternViT<T> : VisionLanguageModelBase<T>, IVisualEncoder<T>
+public partial class InternViT<T> : VisionLanguageModelBase<T>, IVisualEncoder<T>
 {
     private readonly InternViTOptions _options;
 
@@ -187,40 +187,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.EmbeddingDim);
-        writer.Write(_options.NumLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.MaxTiles);
-        writer.Write(_options.UseDynamicResolution);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.EmbeddingDim = reader.ReadInt32();
-        _options.NumLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.MaxTiles = reader.ReadInt32();
-        _options.UseDynamicResolution = reader.ReadBoolean();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new InternViT<T>(Architecture, mp, _options);
-        return new InternViT<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/Encoders/LLM2CLIP.cs b/src/VisionLanguage/Encoders/LLM2CLIP.cs
index abc4e61465..1f4b61008c 100644
--- a/src/VisionLanguage/Encoders/LLM2CLIP.cs
+++ b/src/VisionLanguage/Encoders/LLM2CLIP.cs
@@ -274,52 +274,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ImageEncoderModelPath ?? string.Empty);
-        writer.Write(_options.TextEncoderModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionEmbeddingDim);
-        writer.Write(_options.TextEmbeddingDim);
-        writer.Write(_options.ProjectionDim);
-        writer.Write(_options.Temperature);
-        writer.Write(_options.LLMBackbone);
-        writer.Write(_options.UseLoRA);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string ip = reader.ReadString();
-        if (!string.IsNullOrEmpty(ip))
-            _options.ImageEncoderModelPath = ip;
-        string tp = reader.ReadString();
-        if (!string.IsNullOrEmpty(tp))
-            _options.TextEncoderModelPath = tp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionEmbeddingDim = reader.ReadInt32();
-        _options.TextEmbeddingDim = reader.ReadInt32();
-        _options.ProjectionDim = reader.ReadInt32();
-        _options.Temperature = reader.ReadDouble();
-        _options.LLMBackbone = reader.ReadString();
-        _options.UseLoRA = reader.ReadBoolean();
-        if (!_useNativeMode && _options.ImageEncoderModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxImageEncoder = new OnnxModel<T>(p, _options.OnnxOptions);
-        if (_options.TextEncoderModelPath is { } t2 && !string.IsNullOrEmpty(t2))
-            OnnxTextEncoder = new OnnxModel<T>(t2, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (
-            !_useNativeMode
-            && _options.ImageEncoderModelPath is { } mp
-            && !string.IsNullOrEmpty(mp)
-        )
-            return new LLM2CLIP<T>(Architecture, mp, _options);
-        return new LLM2CLIP<T>(Architecture, _options);
-    }
+
 
     private Tensor<T> TokenizeText(string text)
     {
diff --git a/src/VisionLanguage/Encoders/LiT.cs b/src/VisionLanguage/Encoders/LiT.cs
index e21d41979a..b05a202174 100644
--- a/src/VisionLanguage/Encoders/LiT.cs
+++ b/src/VisionLanguage/Encoders/LiT.cs
@@ -299,50 +299,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return meta;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ImageEncoderModelPath ?? string.Empty);
-        writer.Write(_options.TextEncoderModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionEmbeddingDim);
-        writer.Write(_options.TextEmbeddingDim);
-        writer.Write(_options.ProjectionDim);
-        writer.Write(_options.Temperature);
-        writer.Write(_options.FreezeVisionEncoder);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string imgPath = reader.ReadString();
-        if (!string.IsNullOrEmpty(imgPath))
-            _options.ImageEncoderModelPath = imgPath;
-        string txtPath = reader.ReadString();
-        if (!string.IsNullOrEmpty(txtPath))
-            _options.TextEncoderModelPath = txtPath;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionEmbeddingDim = reader.ReadInt32();
-        _options.TextEmbeddingDim = reader.ReadInt32();
-        _options.ProjectionDim = reader.ReadInt32();
-        _options.Temperature = reader.ReadDouble();
-        _options.FreezeVisionEncoder = reader.ReadBoolean();
-        if (!_useNativeMode && _options.ImageEncoderModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxImageEncoder = new OnnxModel<T>(p, _options.OnnxOptions);
-        if (_options.TextEncoderModelPath is { } tp2 && !string.IsNullOrEmpty(tp2))
-            OnnxTextEncoder = new OnnxModel<T>(tp2, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (
-            !_useNativeMode
-            && _options.ImageEncoderModelPath is { } mp
-            && !string.IsNullOrEmpty(mp)
-        )
-            return new LiT<T>(Architecture, mp, _options);
-        return new LiT<T>(Architecture, _options);
-    }
+
 
     private Tensor<T> TokenizeText(string text)
     {
diff --git a/src/VisionLanguage/Encoders/MedCLIP.cs b/src/VisionLanguage/Encoders/MedCLIP.cs
index ec4ebf1d9d..1d15488af9 100644
--- a/src/VisionLanguage/Encoders/MedCLIP.cs
+++ b/src/VisionLanguage/Encoders/MedCLIP.cs
@@ -374,10 +374,6 @@ public override void Train(Tensor<T> input, Tensor<T> expected)
         }
     }
 
-    /// <inheritdoc />
-    protected override IEnumerable<LayerBase<T>?> GetExtraTrainableLayers() =>
-        EnumerateMedClipExtraLayers();
-
     private IEnumerable<LayerBase<T>?> EnumerateMedClipExtraLayers()
     {
         foreach (var layer in EnumerateTextEncoderTrainableLayers()) yield return layer;
@@ -431,76 +427,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ImageEncoderModelPath ?? string.Empty);
-        writer.Write(_options.TextEncoderModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionEmbeddingDim);
-        writer.Write(_options.TextEmbeddingDim);
-        writer.Write(_options.ProjectionDim);
-        writer.Write(_options.Temperature);
-        writer.Write(_options.SemanticMatchingWeight);
-        writer.Write(MedClipExtrasFormatVersion);
-        writer.Write(TextEncoderLayers.Count);
-        foreach (var layer in TextEncoderLayers)
-            SerializationHelper<T>.SerializeVector(writer, layer.GetParameters());
-        SerializationHelper<T>.SerializeVector(writer, _logitScale.GetParameters());
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string ip = reader.ReadString();
-        if (!string.IsNullOrEmpty(ip))
-            _options.ImageEncoderModelPath = ip;
-        string tp = reader.ReadString();
-        if (!string.IsNullOrEmpty(tp))
-            _options.TextEncoderModelPath = tp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionEmbeddingDim = reader.ReadInt32();
-        _options.TextEmbeddingDim = reader.ReadInt32();
-        _options.ProjectionDim = reader.ReadInt32();
-        _options.Temperature = reader.ReadDouble();
-        _options.SemanticMatchingWeight = reader.ReadDouble();
-        int formatVersion = reader.ReadInt32();
-        if (formatVersion != MedClipExtrasFormatVersion)
-            throw new InvalidDataException(
-                $"Unsupported MedCLIP payload version {formatVersion}; " +
-                $"expected {MedClipExtrasFormatVersion}.");
-        int layerCount = reader.ReadInt32();
-        if (layerCount != TextEncoderLayers.Count)
-            throw new InvalidDataException(
-                $"Serialized MedCLIP text layer count {layerCount} does not match topology {TextEncoderLayers.Count}.");
-        foreach (var layer in TextEncoderLayers)
-        {
-            var values = SerializationHelper<T>.DeserializeVector(reader);
-            if (values.Length != layer.ParameterCount)
-                throw new InvalidDataException(
-                    $"Serialized MedCLIP layer has {values.Length} parameters; expected {layer.ParameterCount}.");
-            layer.SetParameters(values);
-        }
-        var logScale = SerializationHelper<T>.DeserializeVector(reader);
-        if (logScale.Length != _logitScale.ParameterCount)
-            throw new InvalidDataException("Serialized MedCLIP logit-scale parameter count is invalid.");
-        _logitScale.SetParameters(logScale);
-        if (!_useNativeMode && _options.ImageEncoderModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxImageEncoder = new OnnxModel<T>(p, _options.OnnxOptions);
-        if (_options.TextEncoderModelPath is { } t2 && !string.IsNullOrEmpty(t2))
-            OnnxTextEncoder = new OnnxModel<T>(t2, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (
-            !_useNativeMode
-            && _options.ImageEncoderModelPath is { } mp
-            && !string.IsNullOrEmpty(mp)
-        )
-            return new MedCLIP<T>(Architecture, mp, new MedCLIPOptions(_options));
-        return new MedCLIP<T>(Architecture, new MedCLIPOptions(_options));
-    }
+
 
     private Tensor<T> TokenizeText(string text)
     {
diff --git a/src/VisionLanguage/Encoders/MetaCLIP.cs b/src/VisionLanguage/Encoders/MetaCLIP.cs
index a639469fbe..d110a09482 100644
--- a/src/VisionLanguage/Encoders/MetaCLIP.cs
+++ b/src/VisionLanguage/Encoders/MetaCLIP.cs
@@ -252,50 +252,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ImageEncoderModelPath ?? string.Empty);
-        writer.Write(_options.TextEncoderModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionEmbeddingDim);
-        writer.Write(_options.TextEmbeddingDim);
-        writer.Write(_options.ProjectionDim);
-        writer.Write(_options.Temperature);
-        writer.Write((int)_options.Dataset);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string ip = reader.ReadString();
-        if (!string.IsNullOrEmpty(ip))
-            _options.ImageEncoderModelPath = ip;
-        string tp = reader.ReadString();
-        if (!string.IsNullOrEmpty(tp))
-            _options.TextEncoderModelPath = tp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionEmbeddingDim = reader.ReadInt32();
-        _options.TextEmbeddingDim = reader.ReadInt32();
-        _options.ProjectionDim = reader.ReadInt32();
-        _options.Temperature = reader.ReadDouble();
-        _options.Dataset = (PretrainingDataset)reader.ReadInt32();
-        if (!_useNativeMode && _options.ImageEncoderModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxImageEncoder = new OnnxModel<T>(p, _options.OnnxOptions);
-        if (_options.TextEncoderModelPath is { } t2 && !string.IsNullOrEmpty(t2))
-            OnnxTextEncoder = new OnnxModel<T>(t2, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (
-            !_useNativeMode
-            && _options.ImageEncoderModelPath is { } mp
-            && !string.IsNullOrEmpty(mp)
-        )
-            return new MetaCLIP<T>(Architecture, mp, _options);
-        return new MetaCLIP<T>(Architecture, _options);
-    }
+
 
     private Tensor<T> TokenizeText(string text)
     {
diff --git a/src/VisionLanguage/Encoders/OpenCLIP.cs b/src/VisionLanguage/Encoders/OpenCLIP.cs
index 20e700f0f4..4f950c66bb 100644
--- a/src/VisionLanguage/Encoders/OpenCLIP.cs
+++ b/src/VisionLanguage/Encoders/OpenCLIP.cs
@@ -388,65 +388,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc />
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ImageEncoderModelPath ?? string.Empty);
-        writer.Write(_options.TextEncoderModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionEmbeddingDim);
-        writer.Write(_options.TextEmbeddingDim);
-        writer.Write(_options.ProjectionDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumTextLayers);
-        writer.Write(_options.NumVisionHeads);
-        writer.Write(_options.NumTextHeads);
-        writer.Write(_options.Temperature);
-        writer.Write(_options.DropoutRate);
-        writer.Write((int)_options.Dataset);
-        writer.Write(_options.UseCoCaVariant);
-    }
 
-    /// <inheritdoc />
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string imgPath = reader.ReadString();
-        if (!string.IsNullOrEmpty(imgPath))
-            _options.ImageEncoderModelPath = imgPath;
-        string txtPath = reader.ReadString();
-        if (!string.IsNullOrEmpty(txtPath))
-            _options.TextEncoderModelPath = txtPath;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionEmbeddingDim = reader.ReadInt32();
-        _options.TextEmbeddingDim = reader.ReadInt32();
-        _options.ProjectionDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumTextLayers = reader.ReadInt32();
-        _options.NumVisionHeads = reader.ReadInt32();
-        _options.NumTextHeads = reader.ReadInt32();
-        _options.Temperature = reader.ReadDouble();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.Dataset = (PretrainingDataset)reader.ReadInt32();
-        _options.UseCoCaVariant = reader.ReadBoolean();
-
-        if (!_useNativeMode && _options.ImageEncoderModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxImageEncoder = new OnnxModel<T>(p, _options.OnnxOptions);
-        if (_options.TextEncoderModelPath is { } tp2 && !string.IsNullOrEmpty(tp2))
-            OnnxTextEncoder = new OnnxModel<T>(tp2, _options.OnnxOptions);
-    }
 
     /// <inheritdoc />
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (
-            !_useNativeMode
-            && _options.ImageEncoderModelPath is { } mp
-            && !string.IsNullOrEmpty(mp)
-        )
-            return new OpenCLIP<T>(Architecture, mp, new OpenCLIPOptions(_options));
-        return new OpenCLIP<T>(Architecture, new OpenCLIPOptions(_options));
-    }
+
 
     #endregion
 
diff --git a/src/VisionLanguage/Encoders/PerceptionEncoder.cs b/src/VisionLanguage/Encoders/PerceptionEncoder.cs
index 501de2c275..e6672f9388 100644
--- a/src/VisionLanguage/Encoders/PerceptionEncoder.cs
+++ b/src/VisionLanguage/Encoders/PerceptionEncoder.cs
@@ -59,7 +59,7 @@ namespace AiDotNet.VisionLanguage.Encoders;
     Year = 2025,
     Authors = "Meta"
 )]
-public class PerceptionEncoder<T> : VisionLanguageModelBase<T>, IVisualEncoder<T>
+public partial class PerceptionEncoder<T> : VisionLanguageModelBase<T>, IVisualEncoder<T>
 {
     private readonly PerceptionEncoderOptions _options;
 
@@ -193,40 +193,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.EmbeddingDim);
-        writer.Write(_options.NumLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.AlignmentProjectionDim);
-        writer.Write(_options.UseDenseFeatures);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.EmbeddingDim = reader.ReadInt32();
-        _options.NumLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.AlignmentProjectionDim = reader.ReadInt32();
-        _options.UseDenseFeatures = reader.ReadBoolean();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new PerceptionEncoder<T>(Architecture, mp, _options);
-        return new PerceptionEncoder<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/Encoders/RADIOv25.cs b/src/VisionLanguage/Encoders/RADIOv25.cs
index fd46dbfd0a..864c3b4fef 100644
--- a/src/VisionLanguage/Encoders/RADIOv25.cs
+++ b/src/VisionLanguage/Encoders/RADIOv25.cs
@@ -56,7 +56,7 @@ namespace AiDotNet.VisionLanguage.Encoders;
     Year = 2025,
     Authors = "Ranzinger et al."
 )]
-public class RADIOv25<T> : VisionLanguageModelBase<T>, IVisualEncoder<T>
+public partial class RADIOv25<T> : VisionLanguageModelBase<T>, IVisualEncoder<T>
 {
     private readonly RADIOv25Options _options;
 
@@ -196,40 +196,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.EmbeddingDim);
-        writer.Write(_options.NumLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.AdapterDim);
-        writer.Write(_options.NumSummaryTokens);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.EmbeddingDim = reader.ReadInt32();
-        _options.NumLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.AdapterDim = reader.ReadInt32();
-        _options.NumSummaryTokens = reader.ReadInt32();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new RADIOv25<T>(Architecture, mp, _options);
-        return new RADIOv25<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/Encoders/RegionCLIP.cs b/src/VisionLanguage/Encoders/RegionCLIP.cs
index 1bbbfc180a..3943baa95b 100644
--- a/src/VisionLanguage/Encoders/RegionCLIP.cs
+++ b/src/VisionLanguage/Encoders/RegionCLIP.cs
@@ -336,51 +336,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ImageEncoderModelPath ?? string.Empty);
-        writer.Write(_options.TextEncoderModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionEmbeddingDim);
-        writer.Write(_options.TextEmbeddingDim);
-        writer.Write(_options.ProjectionDim);
-        writer.Write(_options.Temperature);
-        writer.Write(_options.MaxRegionsPerImage);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string ip = reader.ReadString();
-        if (!string.IsNullOrEmpty(ip))
-            _options.ImageEncoderModelPath = ip;
-        string tp = reader.ReadString();
-        if (!string.IsNullOrEmpty(tp))
-            _options.TextEncoderModelPath = tp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionEmbeddingDim = reader.ReadInt32();
-        _options.TextEmbeddingDim = reader.ReadInt32();
-        _options.ProjectionDim = reader.ReadInt32();
-        _options.Temperature = reader.ReadDouble();
-        _options.MaxRegionsPerImage = reader.ReadInt32();
-        if (!_useNativeMode && _options.ImageEncoderModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxImageEncoder = new OnnxModel<T>(p, _options.OnnxOptions);
-        if (_options.TextEncoderModelPath is { } t2 && !string.IsNullOrEmpty(t2))
-            OnnxTextEncoder = new OnnxModel<T>(t2, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var options = new RegionCLIPOptions(_options);
-        if (
-            !_useNativeMode
-            && _options.ImageEncoderModelPath is { } mp
-            && !string.IsNullOrEmpty(mp)
-        )
-            return new RegionCLIP<T>(Architecture, mp, options);
-        return new RegionCLIP<T>(Architecture, options);
-    }
+
 
     private Tensor<T> TokenizeText(string text)
     {
diff --git a/src/VisionLanguage/Encoders/RemoteCLIP.cs b/src/VisionLanguage/Encoders/RemoteCLIP.cs
index dd24ff50a0..028116b052 100644
--- a/src/VisionLanguage/Encoders/RemoteCLIP.cs
+++ b/src/VisionLanguage/Encoders/RemoteCLIP.cs
@@ -282,50 +282,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ImageEncoderModelPath ?? string.Empty);
-        writer.Write(_options.TextEncoderModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionEmbeddingDim);
-        writer.Write(_options.TextEmbeddingDim);
-        writer.Write(_options.ProjectionDim);
-        writer.Write(_options.Temperature);
-        writer.Write((int)_options.Domain);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string ip = reader.ReadString();
-        if (!string.IsNullOrEmpty(ip))
-            _options.ImageEncoderModelPath = ip;
-        string tp = reader.ReadString();
-        if (!string.IsNullOrEmpty(tp))
-            _options.TextEncoderModelPath = tp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionEmbeddingDim = reader.ReadInt32();
-        _options.TextEmbeddingDim = reader.ReadInt32();
-        _options.ProjectionDim = reader.ReadInt32();
-        _options.Temperature = reader.ReadDouble();
-        _options.Domain = (DomainSpecialization)reader.ReadInt32();
-        if (!_useNativeMode && _options.ImageEncoderModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxImageEncoder = new OnnxModel<T>(p, _options.OnnxOptions);
-        if (_options.TextEncoderModelPath is { } t2 && !string.IsNullOrEmpty(t2))
-            OnnxTextEncoder = new OnnxModel<T>(t2, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (
-            !_useNativeMode
-            && _options.ImageEncoderModelPath is { } mp
-            && !string.IsNullOrEmpty(mp)
-        )
-            return new RemoteCLIP<T>(Architecture, mp, new RemoteCLIPOptions(_options));
-        return new RemoteCLIP<T>(Architecture, new RemoteCLIPOptions(_options));
-    }
+
 
     private Tensor<T> TokenizeText(string text)
     {
diff --git a/src/VisionLanguage/Encoders/SAM.cs b/src/VisionLanguage/Encoders/SAM.cs
index 7552e2c2ae..9b6d3d6446 100644
--- a/src/VisionLanguage/Encoders/SAM.cs
+++ b/src/VisionLanguage/Encoders/SAM.cs
@@ -56,7 +56,7 @@ namespace AiDotNet.VisionLanguage.Encoders;
     Year = 2023,
     Authors = "Kirillov et al."
 )]
-public class SAM<T> : VisionLanguageModelBase<T>, IVisualEncoder<T>
+public partial class SAM<T> : VisionLanguageModelBase<T>, IVisualEncoder<T>
 {
     private readonly SAMOptions _options;
 
@@ -186,40 +186,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.EmbeddingDim);
-        writer.Write(_options.NumLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.MaskDecoderDim);
-        writer.Write(_options.WindowSize);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.EmbeddingDim = reader.ReadInt32();
-        _options.NumLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.MaskDecoderDim = reader.ReadInt32();
-        _options.WindowSize = reader.ReadInt32();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new SAM<T>(Architecture, mp, _options);
-        return new SAM<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/Encoders/SigLIP.cs b/src/VisionLanguage/Encoders/SigLIP.cs
index ca41a41cb2..1c635e9db8 100644
--- a/src/VisionLanguage/Encoders/SigLIP.cs
+++ b/src/VisionLanguage/Encoders/SigLIP.cs
@@ -394,68 +394,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc />
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ImageEncoderModelPath ?? string.Empty);
-        writer.Write(_options.TextEncoderModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionEmbeddingDim);
-        writer.Write(_options.TextEmbeddingDim);
-        writer.Write(_options.ProjectionDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumTextLayers);
-        writer.Write(_options.NumVisionHeads);
-        writer.Write(_options.NumTextHeads);
-        writer.Write(_options.Temperature);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.SigmoidBias);
-        writer.Write(_options.UseSigLIP2);
-        writer.Write(_options.Multilingual);
-    }
 
-    /// <inheritdoc />
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string imgPath = reader.ReadString();
-        if (!string.IsNullOrEmpty(imgPath))
-            _options.ImageEncoderModelPath = imgPath;
-        string txtPath = reader.ReadString();
-        if (!string.IsNullOrEmpty(txtPath))
-            _options.TextEncoderModelPath = txtPath;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionEmbeddingDim = reader.ReadInt32();
-        _options.TextEmbeddingDim = reader.ReadInt32();
-        _options.ProjectionDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumTextLayers = reader.ReadInt32();
-        _options.NumVisionHeads = reader.ReadInt32();
-        _options.NumTextHeads = reader.ReadInt32();
-        _options.Temperature = reader.ReadDouble();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.SigmoidBias = reader.ReadDouble();
-        _options.UseSigLIP2 = reader.ReadBoolean();
-        _options.Multilingual = reader.ReadBoolean();
-
-        if (!_useNativeMode && _options.ImageEncoderModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxImageEncoder = new OnnxModel<T>(p, _options.OnnxOptions);
-        if (_options.TextEncoderModelPath is { } tp2 && !string.IsNullOrEmpty(tp2))
-            OnnxTextEncoder = new OnnxModel<T>(tp2, _options.OnnxOptions);
-    }
 
     /// <inheritdoc />
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var options = new SigLIPOptions(_options);
-        if (
-            !_useNativeMode
-            && _options.ImageEncoderModelPath is { } mp
-            && !string.IsNullOrEmpty(mp)
-        )
-            return new SigLIP<T>(Architecture, mp, options);
-        return new SigLIP<T>(Architecture, options);
-    }
+
 
     #endregion
 
diff --git a/src/VisionLanguage/Encoders/SigLIP2.cs b/src/VisionLanguage/Encoders/SigLIP2.cs
index 6d532e6255..7622d61c89 100644
--- a/src/VisionLanguage/Encoders/SigLIP2.cs
+++ b/src/VisionLanguage/Encoders/SigLIP2.cs
@@ -97,7 +97,7 @@ namespace AiDotNet.VisionLanguage.Encoders;
     Year = 2025,
     Authors = "Tschannen et al."
 )]
-public class SigLIP2<T> : VisionLanguageModelBase<T>, IContrastiveVisionLanguageModel<T>
+public partial class SigLIP2<T> : VisionLanguageModelBase<T>, IContrastiveVisionLanguageModel<T>
 {
     #region Fields
 
@@ -616,87 +616,10 @@ public override ModelMetadata<T> GetModelMetadata()
     }
 
     /// <inheritdoc />
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ImageEncoderModelPath ?? string.Empty);
-        writer.Write(_options.TextEncoderModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionEmbeddingDim);
-        writer.Write(_options.TextEmbeddingDim);
-        writer.Write(_options.ProjectionDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumTextLayers);
-        writer.Write(_options.NumVisionHeads);
-        writer.Write(_options.NumTextHeads);
-        writer.Write(_options.Temperature);
-        writer.Write(_options.DropoutRate);
-        writer.Write(_options.SigmoidBias);
-        writer.Write(_options.Multilingual);
-        writer.Write(_options.CaptioningLossWeight);
-        writer.Write(_options.SelfSupervisedLossWeight);
-        writer.Write(_options.MimMaskRatio);
-        writer.Write(_options.NumCaptioningDecoderLayers);
-        writer.Write(_options.NumCaptioningDecoderHeads);
-        writer.Write(_options.CaptioningDecoderDim);
-        writer.Write(_options.MaxCaptionLength);
-        writer.Write(_options.MimDecoderDim);
-        writer.Write(_options.NumMimDecoderLayers);
-        writer.Write(_options.IncludeCaptioningDecoder);
-    }
-
-    /// <inheritdoc />
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string imgPath = reader.ReadString();
-        if (!string.IsNullOrEmpty(imgPath))
-            _options.ImageEncoderModelPath = imgPath;
-        string txtPath = reader.ReadString();
-        if (!string.IsNullOrEmpty(txtPath))
-            _options.TextEncoderModelPath = txtPath;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionEmbeddingDim = reader.ReadInt32();
-        _options.TextEmbeddingDim = reader.ReadInt32();
-        _options.ProjectionDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumTextLayers = reader.ReadInt32();
-        _options.NumVisionHeads = reader.ReadInt32();
-        _options.NumTextHeads = reader.ReadInt32();
-        _options.Temperature = reader.ReadDouble();
-        _options.DropoutRate = reader.ReadDouble();
-        _options.SigmoidBias = reader.ReadDouble();
-        _options.Multilingual = reader.ReadBoolean();
-        _options.CaptioningLossWeight = reader.ReadDouble();
-        _options.SelfSupervisedLossWeight = reader.ReadDouble();
-        _options.MimMaskRatio = reader.ReadDouble();
-        _options.NumCaptioningDecoderLayers = reader.ReadInt32();
-        _options.NumCaptioningDecoderHeads = reader.ReadInt32();
-        _options.CaptioningDecoderDim = reader.ReadInt32();
-        _options.MaxCaptionLength = reader.ReadInt32();
-        _options.MimDecoderDim = reader.ReadInt32();
-        _options.NumMimDecoderLayers = reader.ReadInt32();
-        _options.IncludeCaptioningDecoder = reader.ReadBoolean();
-
-        if (!_useNativeMode && _options.ImageEncoderModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxImageEncoder = new OnnxModel<T>(p, _options.OnnxOptions);
-        if (_options.TextEncoderModelPath is { } tp2 && !string.IsNullOrEmpty(tp2))
-            OnnxTextEncoder = new OnnxModel<T>(tp2, _options.OnnxOptions);
 
-        ComputeLayerBoundaries();
-    }
 
     /// <inheritdoc />
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (
-            !_useNativeMode
-            && _options.ImageEncoderModelPath is { } mp
-            && !string.IsNullOrEmpty(mp)
-        )
-            return new SigLIP2<T>(Architecture, mp, _options);
-        return new SigLIP2<T>(Architecture, _options);
-    }
+
 
     #endregion
 
diff --git a/src/VisionLanguage/Encoders/SigLIPSO.cs b/src/VisionLanguage/Encoders/SigLIPSO.cs
index 2934d6cc6e..094b7fcad9 100644
--- a/src/VisionLanguage/Encoders/SigLIPSO.cs
+++ b/src/VisionLanguage/Encoders/SigLIPSO.cs
@@ -55,7 +55,7 @@ namespace AiDotNet.VisionLanguage.Encoders;
     Year = 2023,
     Authors = "Zhai et al."
 )]
-public class SigLIPSO<T> : VisionLanguageModelBase<T>, IVisualEncoder<T>
+public partial class SigLIPSO<T> : VisionLanguageModelBase<T>, IVisualEncoder<T>
 {
     private readonly SigLIPSOOptions _options;
 
@@ -184,38 +184,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.EmbeddingDim);
-        writer.Write(_options.NumLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.NumOutputTokens);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.EmbeddingDim = reader.ReadInt32();
-        _options.NumLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.NumOutputTokens = reader.ReadInt32();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new SigLIPSO<T>(Architecture, mp, _options);
-        return new SigLIPSO<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/Encoders/ViT.cs b/src/VisionLanguage/Encoders/ViT.cs
index 8388a07102..7bb23e8808 100644
--- a/src/VisionLanguage/Encoders/ViT.cs
+++ b/src/VisionLanguage/Encoders/ViT.cs
@@ -57,7 +57,7 @@ namespace AiDotNet.VisionLanguage.Encoders;
     Year = 2021,
     Authors = "Dosovitskiy et al."
 )]
-public class ViT<T> : VisionLanguageModelBase<T>, IVisualEncoder<T>
+public partial class ViT<T> : VisionLanguageModelBase<T>, IVisualEncoder<T>
 {
     private readonly ViTOptions _options;
 
@@ -187,38 +187,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.EmbeddingDim);
-        writer.Write(_options.PatchSize);
-        writer.Write(_options.NumLayers);
-        writer.Write(_options.NumHeads);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.EmbeddingDim = reader.ReadInt32();
-        _options.PatchSize = reader.ReadInt32();
-        _options.NumLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new ViT<T>(Architecture, mp, _options);
-        return new ViT<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/Foundational/BridgeTower.cs b/src/VisionLanguage/Foundational/BridgeTower.cs
index c201f882fc..4fb9c50606 100644
--- a/src/VisionLanguage/Foundational/BridgeTower.cs
+++ b/src/VisionLanguage/Foundational/BridgeTower.cs
@@ -296,45 +296,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.TextDim);
-        writer.Write(_options.FusionDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumTextLayers);
-        writer.Write(_options.NumBridgeLayers);
-        writer.Write(_options.NumHeads);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.TextDim = reader.ReadInt32();
-        _options.FusionDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumTextLayers = reader.ReadInt32();
-        _options.NumBridgeLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var cloneOptions = new BridgeTowerOptions(_options);
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new BridgeTower<T>(Architecture, mp, cloneOptions);
-        return new BridgeTower<T>(Architecture, cloneOptions);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/Foundational/LXMERT.cs b/src/VisionLanguage/Foundational/LXMERT.cs
index cbe9c36fde..4d9a2d173a 100644
--- a/src/VisionLanguage/Foundational/LXMERT.cs
+++ b/src/VisionLanguage/Foundational/LXMERT.cs
@@ -356,44 +356,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.TextDim);
-        writer.Write(_options.FusionDim);
-        writer.Write(_options.NumRelationshipLayers);
-        writer.Write(_options.NumTextLayers);
-        writer.Write(_options.NumCrossModalityLayers);
-        writer.Write(_options.NumHeads);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.TextDim = reader.ReadInt32();
-        _options.FusionDim = reader.ReadInt32();
-        _options.NumRelationshipLayers = reader.ReadInt32();
-        _options.NumTextLayers = reader.ReadInt32();
-        _options.NumCrossModalityLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new LXMERT<T>(Architecture, mp, _options);
-        return new LXMERT<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/Foundational/METER.cs b/src/VisionLanguage/Foundational/METER.cs
index eb007dac39..9706bcb511 100644
--- a/src/VisionLanguage/Foundational/METER.cs
+++ b/src/VisionLanguage/Foundational/METER.cs
@@ -344,44 +344,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.TextDim);
-        writer.Write(_options.FusionDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumTextLayers);
-        writer.Write(_options.NumCrossAttentionLayers);
-        writer.Write(_options.NumHeads);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.TextDim = reader.ReadInt32();
-        _options.FusionDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumTextLayers = reader.ReadInt32();
-        _options.NumCrossAttentionLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new METER<T>(Architecture, mp, _options);
-        return new METER<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/Foundational/Oscar.cs b/src/VisionLanguage/Foundational/Oscar.cs
index 7c1c2a5869..5099932c7d 100644
--- a/src/VisionLanguage/Foundational/Oscar.cs
+++ b/src/VisionLanguage/Foundational/Oscar.cs
@@ -56,7 +56,7 @@ namespace AiDotNet.VisionLanguage.Foundational;
     Year = 2020,
     Authors = "Li et al."
 )]
-public class Oscar<T> : VisionLanguageModelBase<T>, IVisionLanguageFusionModel<T>
+public partial class Oscar<T> : VisionLanguageModelBase<T>, IVisionLanguageFusionModel<T>
 {
     private readonly OscarOptions _options;
 
@@ -313,49 +313,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.TextDim);
-        writer.Write(_options.FusionDim);
-        writer.Write(_options.NumFusionLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.LearningRate);
-        writer.Write(_options.WeightDecay);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.TextDim = reader.ReadInt32();
-        _options.FusionDim = reader.ReadInt32();
-        _options.NumFusionLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.LearningRate = reader.ReadDouble();
-        _options.WeightDecay = reader.ReadDouble();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-        if (_useNativeMode)
-            _projectionLayerEnd =
-                (_options.VisionDim != _options.FusionDim ? 2 : 0)
-                + (_options.TextDim != _options.FusionDim ? 2 : 0);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var options = new OscarOptions(_options);
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new Oscar<T>(Architecture, mp, options);
-        return new Oscar<T>(Architecture, options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/Foundational/UNITER.cs b/src/VisionLanguage/Foundational/UNITER.cs
index a7511b7413..91211438e2 100644
--- a/src/VisionLanguage/Foundational/UNITER.cs
+++ b/src/VisionLanguage/Foundational/UNITER.cs
@@ -55,7 +55,7 @@ namespace AiDotNet.VisionLanguage.Foundational;
     Year = 2020,
     Authors = "Chen et al."
 )]
-public class UNITER<T> : VisionLanguageModelBase<T>, IVisionLanguageFusionModel<T>
+public partial class UNITER<T> : VisionLanguageModelBase<T>, IVisionLanguageFusionModel<T>
 {
     private readonly UNITEROptions _options;
 
@@ -336,44 +336,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.TextDim);
-        writer.Write(_options.FusionDim);
-        writer.Write(_options.NumFusionLayers);
-        writer.Write(_options.NumHeads);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.TextDim = reader.ReadInt32();
-        _options.FusionDim = reader.ReadInt32();
-        _options.NumFusionLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-        if (_useNativeMode)
-            _projectionLayerEnd =
-                (_options.VisionDim != _options.FusionDim ? 2 : 0)
-                + (_options.TextDim != _options.FusionDim ? 2 : 0);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new UNITER<T>(Architecture, mp, _options);
-        return new UNITER<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/Foundational/ViLBERT.cs b/src/VisionLanguage/Foundational/ViLBERT.cs
index df7322b2cf..29458a870f 100644
--- a/src/VisionLanguage/Foundational/ViLBERT.cs
+++ b/src/VisionLanguage/Foundational/ViLBERT.cs
@@ -55,7 +55,7 @@ namespace AiDotNet.VisionLanguage.Foundational;
     Year = 2019,
     Authors = "Lu et al."
 )]
-public class ViLBERT<T> : VisionLanguageModelBase<T>, IVisionLanguageFusionModel<T>
+public partial class ViLBERT<T> : VisionLanguageModelBase<T>, IVisionLanguageFusionModel<T>
 {
     private readonly ViLBERTOptions _options;
 
@@ -559,63 +559,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.TextDim);
-        writer.Write(_options.FusionDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumTextLayers);
-        writer.Write(_options.NumFusionLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.VisualFeatureDim);
-        writer.Write(_options.NumVisionHeads);
-        writer.Write(_options.NumTextHeads);
-        writer.Write(_options.NumFusionHeads);
-        writer.Write(_options.VisionIntermediateDim);
-        writer.Write(_options.TextIntermediateDim);
-        writer.Write(_options.FusionIntermediateDim);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.TextDim = reader.ReadInt32();
-        _options.FusionDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumTextLayers = reader.ReadInt32();
-        _options.NumFusionLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        if (reader.BaseStream.Length - reader.BaseStream.Position >= sizeof(int) * 7)
-        {
-            _options.VisualFeatureDim = reader.ReadInt32();
-            _options.NumVisionHeads = reader.ReadInt32();
-            _options.NumTextHeads = reader.ReadInt32();
-            _options.NumFusionHeads = reader.ReadInt32();
-            _options.VisionIntermediateDim = reader.ReadInt32();
-            _options.TextIntermediateDim = reader.ReadInt32();
-            _options.FusionIntermediateDim = reader.ReadInt32();
-        }
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-        if (_useNativeMode)
-            ComputeDualStreamBoundaries();
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new ViLBERT<T>(Architecture, mp, new ViLBERTOptions(_options));
-        return new ViLBERT<T>(Architecture, new ViLBERTOptions(_options));
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/Foundational/ViLT.cs b/src/VisionLanguage/Foundational/ViLT.cs
index 9d854158da..4b2f77f620 100644
--- a/src/VisionLanguage/Foundational/ViLT.cs
+++ b/src/VisionLanguage/Foundational/ViLT.cs
@@ -55,7 +55,7 @@ namespace AiDotNet.VisionLanguage.Foundational;
     Year = 2021,
     Authors = "Kim et al."
 )]
-public class ViLT<T> : VisionLanguageModelBase<T>, IVisionLanguageFusionModel<T>
+public partial class ViLT<T> : VisionLanguageModelBase<T>, IVisionLanguageFusionModel<T>
 {
     private readonly ViLTOptions _options;
 
@@ -273,46 +273,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.TextDim);
-        writer.Write(_options.FusionDim);
-        writer.Write(_options.NumFusionLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.PatchSize);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.TextDim = reader.ReadInt32();
-        _options.FusionDim = reader.ReadInt32();
-        _options.NumFusionLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.PatchSize = reader.ReadInt32();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-        if (_useNativeMode)
-            _projectionLayerEnd =
-                (_options.VisionDim != _options.FusionDim ? 2 : 0)
-                + (_options.TextDim != _options.FusionDim ? 2 : 0);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new ViLT<T>(Architecture, mp, _options);
-        return new ViLT<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/Foundational/VinVL.cs b/src/VisionLanguage/Foundational/VinVL.cs
index e89443a9c2..dbfd297052 100644
--- a/src/VisionLanguage/Foundational/VinVL.cs
+++ b/src/VisionLanguage/Foundational/VinVL.cs
@@ -56,7 +56,7 @@ namespace AiDotNet.VisionLanguage.Foundational;
     Year = 2021,
     Authors = "Zhang et al."
 )]
-public class VinVL<T> : VisionLanguageModelBase<T>, IVisionLanguageFusionModel<T>
+public partial class VinVL<T> : VisionLanguageModelBase<T>, IVisionLanguageFusionModel<T>
 {
     private readonly VinVLOptions _options;
 
@@ -315,44 +315,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.TextDim);
-        writer.Write(_options.FusionDim);
-        writer.Write(_options.NumFusionLayers);
-        writer.Write(_options.NumHeads);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.TextDim = reader.ReadInt32();
-        _options.FusionDim = reader.ReadInt32();
-        _options.NumFusionLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-        if (_useNativeMode)
-            _projectionLayerEnd =
-                (_options.VisionDim != _options.FusionDim ? 2 : 0)
-                + (_options.TextDim != _options.FusionDim ? 2 : 0);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new VinVL<T>(Architecture, mp, _options);
-        return new VinVL<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/Foundational/VisualBERT.cs b/src/VisionLanguage/Foundational/VisualBERT.cs
index b1c7ecc2b0..2223ae2233 100644
--- a/src/VisionLanguage/Foundational/VisualBERT.cs
+++ b/src/VisionLanguage/Foundational/VisualBERT.cs
@@ -55,7 +55,7 @@ namespace AiDotNet.VisionLanguage.Foundational;
     Year = 2019,
     Authors = "Li et al."
 )]
-public class VisualBERT<T> : VisionLanguageModelBase<T>, IVisionLanguageFusionModel<T>
+public partial class VisualBERT<T> : VisionLanguageModelBase<T>, IVisionLanguageFusionModel<T>
 {
     private readonly VisualBERTOptions _options;
 
@@ -299,44 +299,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.TextDim);
-        writer.Write(_options.FusionDim);
-        writer.Write(_options.NumFusionLayers);
-        writer.Write(_options.NumHeads);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.TextDim = reader.ReadInt32();
-        _options.FusionDim = reader.ReadInt32();
-        _options.NumFusionLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-        if (_useNativeMode)
-            _projectionLayerEnd =
-                (_options.VisionDim != _options.FusionDim ? 2 : 0)
-                + (_options.TextDim != _options.FusionDim ? 2 : 0);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new VisualBERT<T>(Architecture, mp, new VisualBERTOptions(_options));
-        return new VisualBERT<T>(Architecture, new VisualBERTOptions(_options));
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/Generative/BLIP3.cs b/src/VisionLanguage/Generative/BLIP3.cs
index 1093db96c2..a291b089d9 100644
--- a/src/VisionLanguage/Generative/BLIP3.cs
+++ b/src/VisionLanguage/Generative/BLIP3.cs
@@ -309,44 +309,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.QFormerDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumQFormerLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.QFormerDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumQFormerLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new BLIP3<T>(Architecture, mp, _options);
-        return new BLIP3<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/Generative/CoCa.cs b/src/VisionLanguage/Generative/CoCa.cs
index 790581d952..a7f12640a3 100644
--- a/src/VisionLanguage/Generative/CoCa.cs
+++ b/src/VisionLanguage/Generative/CoCa.cs
@@ -61,7 +61,7 @@ namespace AiDotNet.VisionLanguage.Generative;
     Year = 2022,
     Authors = "Yu et al."
 )]
-public class CoCa<T> : VisionLanguageModelBase<T>, IGenerativeVisionLanguageModel<T>
+public partial class CoCa<T> : VisionLanguageModelBase<T>, IGenerativeVisionLanguageModel<T>
 {
     private readonly CoCaOptions _options;
 
@@ -263,40 +263,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new CoCa<T>(Architecture, mp, _options);
-        return new CoCa<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/Generative/Emu.cs b/src/VisionLanguage/Generative/Emu.cs
index a5484c2713..daa4a30d89 100644
--- a/src/VisionLanguage/Generative/Emu.cs
+++ b/src/VisionLanguage/Generative/Emu.cs
@@ -289,44 +289,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.RegressionDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumRegressionLayers);
-        writer.Write(_options.NumHeads);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.RegressionDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumRegressionLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new Emu<T>(Architecture, mp, _options);
-        return new Emu<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/Generative/Emu2.cs b/src/VisionLanguage/Generative/Emu2.cs
index d116f540c9..be14e7a946 100644
--- a/src/VisionLanguage/Generative/Emu2.cs
+++ b/src/VisionLanguage/Generative/Emu2.cs
@@ -287,44 +287,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.RegressionDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumRegressionLayers);
-        writer.Write(_options.NumHeads);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.RegressionDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumRegressionLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new Emu2<T>(Architecture, mp, _options);
-        return new Emu2<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/Generative/Emu3.cs b/src/VisionLanguage/Generative/Emu3.cs
index efd6c62200..6355a77606 100644
--- a/src/VisionLanguage/Generative/Emu3.cs
+++ b/src/VisionLanguage/Generative/Emu3.cs
@@ -287,44 +287,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.RegressionDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumRegressionLayers);
-        writer.Write(_options.NumHeads);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.RegressionDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumRegressionLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new Emu3<T>(Architecture, mp, _options);
-        return new Emu3<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/Generative/GIT.cs b/src/VisionLanguage/Generative/GIT.cs
index 76d5d04436..cc9ed3bed1 100644
--- a/src/VisionLanguage/Generative/GIT.cs
+++ b/src/VisionLanguage/Generative/GIT.cs
@@ -59,7 +59,7 @@ namespace AiDotNet.VisionLanguage.Generative;
     Year = 2022,
     Authors = "Wang et al."
 )]
-public class GIT<T> : VisionLanguageModelBase<T>, IGenerativeVisionLanguageModel<T>
+public partial class GIT<T> : VisionLanguageModelBase<T>, IGenerativeVisionLanguageModel<T>
 {
     private readonly GITOptions _options;
 
@@ -259,40 +259,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new GIT<T>(Architecture, mp, _options);
-        return new GIT<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/Generative/IDEFICS.cs b/src/VisionLanguage/Generative/IDEFICS.cs
index 3cd250c0c1..97a083bebc 100644
--- a/src/VisionLanguage/Generative/IDEFICS.cs
+++ b/src/VisionLanguage/Generative/IDEFICS.cs
@@ -294,44 +294,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.PerceiverDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumPerceiverLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.PerceiverDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumPerceiverLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new IDEFICS<T>(Architecture, mp, _options);
-        return new IDEFICS<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/Generative/IDEFICS2.cs b/src/VisionLanguage/Generative/IDEFICS2.cs
index da3fa70a3e..e952d10c29 100644
--- a/src/VisionLanguage/Generative/IDEFICS2.cs
+++ b/src/VisionLanguage/Generative/IDEFICS2.cs
@@ -286,44 +286,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.PerceiverDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumPerceiverLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.PerceiverDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumPerceiverLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new IDEFICS2<T>(Architecture, mp, _options);
-        return new IDEFICS2<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/Generative/IDEFICS3.cs b/src/VisionLanguage/Generative/IDEFICS3.cs
index c35b094e6c..fff8801d9f 100644
--- a/src/VisionLanguage/Generative/IDEFICS3.cs
+++ b/src/VisionLanguage/Generative/IDEFICS3.cs
@@ -288,44 +288,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.PerceiverDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumPerceiverLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.PerceiverDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumPerceiverLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new IDEFICS3<T>(Architecture, mp, _options);
-        return new IDEFICS3<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/Generative/InstructBLIP.cs b/src/VisionLanguage/Generative/InstructBLIP.cs
index ebd3e1de33..0a928c43df 100644
--- a/src/VisionLanguage/Generative/InstructBLIP.cs
+++ b/src/VisionLanguage/Generative/InstructBLIP.cs
@@ -296,44 +296,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.QFormerDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumQFormerLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.QFormerDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumQFormerLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new InstructBLIP<T>(Architecture, mp, _options);
-        return new InstructBLIP<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/Generative/KOSMOS1.cs b/src/VisionLanguage/Generative/KOSMOS1.cs
index 6ec77288d5..a2d4d6317a 100644
--- a/src/VisionLanguage/Generative/KOSMOS1.cs
+++ b/src/VisionLanguage/Generative/KOSMOS1.cs
@@ -310,40 +310,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new KOSMOS1<T>(Architecture, mp, _options);
-        return new KOSMOS1<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/Generative/KOSMOS2.cs b/src/VisionLanguage/Generative/KOSMOS2.cs
index 4950695cc3..a2d3d50ac3 100644
--- a/src/VisionLanguage/Generative/KOSMOS2.cs
+++ b/src/VisionLanguage/Generative/KOSMOS2.cs
@@ -283,44 +283,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.EnableGroundingTokens);
-        writer.Write(_options.NumLocationBins);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.EnableGroundingTokens = reader.ReadBoolean();
-        _options.NumLocationBins = reader.ReadInt32();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new KOSMOS2<T>(Architecture, mp, _options);
-        return new KOSMOS2<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/Generative/OpenFlamingo.cs b/src/VisionLanguage/Generative/OpenFlamingo.cs
index f037708bec..d95cffcf67 100644
--- a/src/VisionLanguage/Generative/OpenFlamingo.cs
+++ b/src/VisionLanguage/Generative/OpenFlamingo.cs
@@ -291,44 +291,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.PerceiverDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumPerceiverLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.PerceiverDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumPerceiverLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new OpenFlamingo<T>(Architecture, mp, _options);
-        return new OpenFlamingo<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/Generative/PaLI.cs b/src/VisionLanguage/Generative/PaLI.cs
index 1fcc106d49..6c068dc9c0 100644
--- a/src/VisionLanguage/Generative/PaLI.cs
+++ b/src/VisionLanguage/Generative/PaLI.cs
@@ -61,7 +61,7 @@ namespace AiDotNet.VisionLanguage.Generative;
     Year = 2023,
     Authors = "Chen et al."
 )]
-public class PaLI<T> : VisionLanguageModelBase<T>, IGenerativeVisionLanguageModel<T>
+public partial class PaLI<T> : VisionLanguageModelBase<T>, IGenerativeVisionLanguageModel<T>
 {
     private readonly PaLIOptions _options;
 
@@ -265,40 +265,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new PaLI<T>(Architecture, mp, _options);
-        return new PaLI<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/Generative/PaLI3.cs b/src/VisionLanguage/Generative/PaLI3.cs
index be7bd7839f..cf9539a627 100644
--- a/src/VisionLanguage/Generative/PaLI3.cs
+++ b/src/VisionLanguage/Generative/PaLI3.cs
@@ -317,40 +317,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new PaLI3<T>(Architecture, mp, _options);
-        return new PaLI3<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/Generative/PaLIX.cs b/src/VisionLanguage/Generative/PaLIX.cs
index 4b39f21f12..af3131bf6c 100644
--- a/src/VisionLanguage/Generative/PaLIX.cs
+++ b/src/VisionLanguage/Generative/PaLIX.cs
@@ -60,7 +60,7 @@ namespace AiDotNet.VisionLanguage.Generative;
     Year = 2023,
     Authors = "Chen et al."
 )]
-public class PaLIX<T> : VisionLanguageModelBase<T>, IGenerativeVisionLanguageModel<T>
+public partial class PaLIX<T> : VisionLanguageModelBase<T>, IGenerativeVisionLanguageModel<T>
 {
     private readonly PaLIXOptions _options;
 
@@ -263,40 +263,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new PaLIX<T>(Architecture, mp, _options);
-        return new PaLIX<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/Grounding/DINOX.cs b/src/VisionLanguage/Grounding/DINOX.cs
index 71d499fe1a..2655ae23dc 100644
--- a/src/VisionLanguage/Grounding/DINOX.cs
+++ b/src/VisionLanguage/Grounding/DINOX.cs
@@ -59,7 +59,7 @@ namespace AiDotNet.VisionLanguage.Grounding;
     Year = 2024,
     Authors = "Ren et al."
 )]
-public class DINOX<T> : VisionLanguageModelBase<T>, IVisualGroundingModel<T>
+public partial class DINOX<T> : VisionLanguageModelBase<T>, IVisualGroundingModel<T>
 {
     private readonly DINOXOptions _options;
 
@@ -390,46 +390,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.MaxDetections);
-        writer.Write(_options.NumQueryPositions);
-        writer.Write(_options.EnableUniversalPerception);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.MaxDetections = reader.ReadInt32();
-        _options.NumQueryPositions = reader.ReadInt32();
-        _options.EnableUniversalPerception = reader.ReadBoolean();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new DINOX<T>(Architecture, mp, _options);
-        return new DINOX<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/Grounding/Ferret.cs b/src/VisionLanguage/Grounding/Ferret.cs
index f1398efe34..a921790672 100644
--- a/src/VisionLanguage/Grounding/Ferret.cs
+++ b/src/VisionLanguage/Grounding/Ferret.cs
@@ -58,7 +58,7 @@ namespace AiDotNet.VisionLanguage.Grounding;
     Year = 2023,
     Authors = "You et al."
 )]
-public class Ferret<T> : VisionLanguageModelBase<T>, IVisualGroundingModel<T>
+public partial class Ferret<T> : VisionLanguageModelBase<T>, IVisualGroundingModel<T>
 {
     private readonly FerretOptions _options;
 
@@ -436,44 +436,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.MaxDetections);
-        writer.Write(_options.EnableFreeFormRegions);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.MaxDetections = reader.ReadInt32();
-        _options.EnableFreeFormRegions = reader.ReadBoolean();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new Ferret<T>(Architecture, mp, _options);
-        return new Ferret<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/Grounding/FerretV2.cs b/src/VisionLanguage/Grounding/FerretV2.cs
index a0b095c349..ee88c6ff7f 100644
--- a/src/VisionLanguage/Grounding/FerretV2.cs
+++ b/src/VisionLanguage/Grounding/FerretV2.cs
@@ -58,7 +58,7 @@ namespace AiDotNet.VisionLanguage.Grounding;
     Year = 2024,
     Authors = "Zhang et al."
 )]
-public class FerretV2<T> : VisionLanguageModelBase<T>, IVisualGroundingModel<T>
+public partial class FerretV2<T> : VisionLanguageModelBase<T>, IVisualGroundingModel<T>
 {
     private readonly FerretV2Options _options;
 
@@ -433,46 +433,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.MaxDetections);
-        writer.Write(_options.EnableFreeFormRegions);
-        writer.Write(_options.EnableHighResolution);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.MaxDetections = reader.ReadInt32();
-        _options.EnableFreeFormRegions = reader.ReadBoolean();
-        _options.EnableHighResolution = reader.ReadBoolean();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new FerretV2<T>(Architecture, mp, _options);
-        return new FerretV2<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/Grounding/GLaMM.cs b/src/VisionLanguage/Grounding/GLaMM.cs
index 04b6a4caab..b17d204a60 100644
--- a/src/VisionLanguage/Grounding/GLaMM.cs
+++ b/src/VisionLanguage/Grounding/GLaMM.cs
@@ -60,7 +60,7 @@ namespace AiDotNet.VisionLanguage.Grounding;
     Year = 2024,
     Authors = "Rasheed et al."
 )]
-public class GLaMM<T> : VisionLanguageModelBase<T>, IVisualGroundingModel<T>
+public partial class GLaMM<T> : VisionLanguageModelBase<T>, IVisualGroundingModel<T>
 {
     private readonly GLaMMOptions _options;
 
@@ -463,53 +463,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.MaxDetections);
-        writer.Write(_options.EnablePixelGrounding);
-        writer.Write(_options.MaskDim);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.MaxDetections = reader.ReadInt32();
-        _options.EnablePixelGrounding = reader.ReadBoolean();
-        _options.MaskDim = reader.ReadInt32();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var optionsCopy = new GLaMMOptions(_options);
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new GLaMM<T>(Architecture, mp, optionsCopy);
-
-        var cloneOptimizer = _optimizer?.GetOptions() is AdamWOptimizerOptions<T, Tensor<T>, Tensor<T>> options
-            ? new AdamWOptimizer<T, Tensor<T>, Tensor<T>>(
-                null,
-                new AdamWOptimizerOptions<T, Tensor<T>, Tensor<T>>(options))
-            : null;
-        return new GLaMM<T>(Architecture, optionsCopy, cloneOptimizer);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/Grounding/Groma.cs b/src/VisionLanguage/Grounding/Groma.cs
index 89079af28c..11fcf23295 100644
--- a/src/VisionLanguage/Grounding/Groma.cs
+++ b/src/VisionLanguage/Grounding/Groma.cs
@@ -59,7 +59,7 @@ namespace AiDotNet.VisionLanguage.Grounding;
     Year = 2024,
     Authors = "Ma et al."
 )]
-public class Groma<T> : VisionLanguageModelBase<T>, IVisualGroundingModel<T>
+public partial class Groma<T> : VisionLanguageModelBase<T>, IVisualGroundingModel<T>
 {
     private readonly GromaOptions _options;
 
@@ -449,44 +449,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.MaxDetections);
-        writer.Write(_options.EnableLocalizedTokenization);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.MaxDetections = reader.ReadInt32();
-        _options.EnableLocalizedTokenization = reader.ReadBoolean();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new Groma<T>(Architecture, mp, _options);
-        return new Groma<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/Grounding/GroundedSAM2.cs b/src/VisionLanguage/Grounding/GroundedSAM2.cs
index 2c45d4a6da..4d14070b0f 100644
--- a/src/VisionLanguage/Grounding/GroundedSAM2.cs
+++ b/src/VisionLanguage/Grounding/GroundedSAM2.cs
@@ -61,7 +61,7 @@ namespace AiDotNet.VisionLanguage.Grounding;
     Year = 2024,
     Authors = "Ren et al."
 )]
-public class GroundedSAM2<T> : VisionLanguageModelBase<T>, IVisualGroundingModel<T>
+public partial class GroundedSAM2<T> : VisionLanguageModelBase<T>, IVisualGroundingModel<T>
 {
     private readonly GroundedSAM2Options _options;
 
@@ -476,46 +476,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.MaxDetections);
-        writer.Write(_options.EnableSegmentation);
-        writer.Write(_options.EnableTracking);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.MaxDetections = reader.ReadInt32();
-        _options.EnableSegmentation = reader.ReadBoolean();
-        _options.EnableTracking = reader.ReadBoolean();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new GroundedSAM2<T>(Architecture, mp, _options);
-        return new GroundedSAM2<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/Grounding/GroundingDINO.cs b/src/VisionLanguage/Grounding/GroundingDINO.cs
index ef6c347a30..16be791b1f 100644
--- a/src/VisionLanguage/Grounding/GroundingDINO.cs
+++ b/src/VisionLanguage/Grounding/GroundingDINO.cs
@@ -58,7 +58,7 @@ namespace AiDotNet.VisionLanguage.Grounding;
     Year = 2024,
     Authors = "Liu et al."
 )]
-public class GroundingDINO<T> : VisionLanguageModelBase<T>, IVisualGroundingModel<T>
+public partial class GroundingDINO<T> : VisionLanguageModelBase<T>, IVisualGroundingModel<T>
 {
     private readonly GroundingDINOOptions _options;
 
@@ -399,44 +399,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.MaxDetections);
-        writer.Write(_options.NumQueryPositions);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.MaxDetections = reader.ReadInt32();
-        _options.NumQueryPositions = reader.ReadInt32();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new GroundingDINO<T>(Architecture, mp, _options);
-        return new GroundingDINO<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/Grounding/GroundingDINO15.cs b/src/VisionLanguage/Grounding/GroundingDINO15.cs
index 29132510e2..92e3abe5d5 100644
--- a/src/VisionLanguage/Grounding/GroundingDINO15.cs
+++ b/src/VisionLanguage/Grounding/GroundingDINO15.cs
@@ -59,7 +59,7 @@ namespace AiDotNet.VisionLanguage.Grounding;
     Year = 2024,
     Authors = "Ren et al."
 )]
-public class GroundingDINO15<T> : VisionLanguageModelBase<T>, IVisualGroundingModel<T>
+public partial class GroundingDINO15<T> : VisionLanguageModelBase<T>, IVisualGroundingModel<T>
 {
     private readonly GroundingDINO15Options _options;
 
@@ -390,46 +390,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.MaxDetections);
-        writer.Write(_options.NumQueryPositions);
-        writer.Write(_options.BackboneType ?? string.Empty);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.MaxDetections = reader.ReadInt32();
-        _options.NumQueryPositions = reader.ReadInt32();
-        _options.BackboneType = reader.ReadString();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new GroundingDINO15<T>(Architecture, mp, _options);
-        return new GroundingDINO15<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/Grounding/OWLViT.cs b/src/VisionLanguage/Grounding/OWLViT.cs
index bd826698dc..e377d98fd7 100644
--- a/src/VisionLanguage/Grounding/OWLViT.cs
+++ b/src/VisionLanguage/Grounding/OWLViT.cs
@@ -58,7 +58,7 @@ namespace AiDotNet.VisionLanguage.Grounding;
     Year = 2022,
     Authors = "Minderer et al."
 )]
-public class OWLViT<T> : VisionLanguageModelBase<T>, IVisualGroundingModel<T>
+public partial class OWLViT<T> : VisionLanguageModelBase<T>, IVisualGroundingModel<T>
 {
     private readonly OWLViTOptions _options;
 
@@ -424,45 +424,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.MaxDetections);
-        writer.Write(_options.NumClassEmbeddings);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.MaxDetections = reader.ReadInt32();
-        _options.NumClassEmbeddings = reader.ReadInt32();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var options = new OWLViTOptions(_options);
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new OWLViT<T>(Architecture, mp, options);
-        return new OWLViT<T>(Architecture, options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/Grounding/OWLv2.cs b/src/VisionLanguage/Grounding/OWLv2.cs
index 7f4ee3848d..2ac6654755 100644
--- a/src/VisionLanguage/Grounding/OWLv2.cs
+++ b/src/VisionLanguage/Grounding/OWLv2.cs
@@ -57,7 +57,7 @@ namespace AiDotNet.VisionLanguage.Grounding;
     Year = 2023,
     Authors = "Minderer et al."
 )]
-public class OWLv2<T> : VisionLanguageModelBase<T>, IVisualGroundingModel<T>
+public partial class OWLv2<T> : VisionLanguageModelBase<T>, IVisualGroundingModel<T>
 {
     private readonly OWLv2Options _options;
 
@@ -410,47 +410,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.MaxDetections);
-        writer.Write(_options.NumClassEmbeddings);
-        writer.Write(_options.EnableSelfTraining);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.MaxDetections = reader.ReadInt32();
-        _options.NumClassEmbeddings = reader.ReadInt32();
-        _options.EnableSelfTraining = reader.ReadBoolean();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var options = new OWLv2Options(_options);
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new OWLv2<T>(Architecture, mp, options);
-        return new OWLv2<T>(Architecture, options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/Grounding/Shikra.cs b/src/VisionLanguage/Grounding/Shikra.cs
index 94b45ed298..c8e356af96 100644
--- a/src/VisionLanguage/Grounding/Shikra.cs
+++ b/src/VisionLanguage/Grounding/Shikra.cs
@@ -59,7 +59,7 @@ namespace AiDotNet.VisionLanguage.Grounding;
     Year = 2023,
     Authors = "Chen et al."
 )]
-public class Shikra<T> : VisionLanguageModelBase<T>, IVisualGroundingModel<T>
+public partial class Shikra<T> : VisionLanguageModelBase<T>, IVisualGroundingModel<T>
 {
     private readonly ShikraOptions _options;
 
@@ -392,44 +392,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.MaxDetections);
-        writer.Write(_options.EnableCoordinateOutput);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.MaxDetections = reader.ReadInt32();
-        _options.EnableCoordinateOutput = reader.ReadBoolean();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new Shikra<T>(Architecture, mp, _options);
-        return new Shikra<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/InstructionTuned/AquilaVL.cs b/src/VisionLanguage/InstructionTuned/AquilaVL.cs
index 2d963177fe..1ae4bfaad6 100644
--- a/src/VisionLanguage/InstructionTuned/AquilaVL.cs
+++ b/src/VisionLanguage/InstructionTuned/AquilaVL.cs
@@ -64,7 +64,7 @@ namespace AiDotNet.VisionLanguage.InstructionTuned;
     Year = 2024,
     Authors = "BAAI"
 )]
-public class AquilaVL<T> : VisionLanguageModelBase<T>, IInstructionTunedVLM<T>
+public partial class AquilaVL<T> : VisionLanguageModelBase<T>, IInstructionTunedVLM<T>
 {
     private readonly AquilaVLOptions _options;
 
@@ -283,42 +283,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.ProjectionDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.ProjectionDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new AquilaVL<T>(Architecture, mp, _options);
-        return new AquilaVL<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/InstructionTuned/Aria.cs b/src/VisionLanguage/InstructionTuned/Aria.cs
index d100b15907..3618208e5b 100644
--- a/src/VisionLanguage/InstructionTuned/Aria.cs
+++ b/src/VisionLanguage/InstructionTuned/Aria.cs
@@ -64,7 +64,7 @@ namespace AiDotNet.VisionLanguage.InstructionTuned;
     Year = 2024,
     Authors = "Li et al."
 )]
-public class Aria<T> : VisionLanguageModelBase<T>, IInstructionTunedVLM<T>
+public partial class Aria<T> : VisionLanguageModelBase<T>, IInstructionTunedVLM<T>
 {
     private readonly AriaOptions _options;
 
@@ -287,46 +287,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.ProjectionDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.NumExperts);
-        writer.Write(_options.NumActiveExperts);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.ProjectionDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.NumExperts = reader.ReadInt32();
-        _options.NumActiveExperts = reader.ReadInt32();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new Aria<T>(Architecture, mp, _options);
-        return new Aria<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/InstructionTuned/Cambrian1.cs b/src/VisionLanguage/InstructionTuned/Cambrian1.cs
index 0538c0cbea..ee75f0bd92 100644
--- a/src/VisionLanguage/InstructionTuned/Cambrian1.cs
+++ b/src/VisionLanguage/InstructionTuned/Cambrian1.cs
@@ -62,7 +62,7 @@ namespace AiDotNet.VisionLanguage.InstructionTuned;
     Year = 2024,
     Authors = "Tong et al."
 )]
-public class Cambrian1<T> : VisionLanguageModelBase<T>, IInstructionTunedVLM<T>
+public partial class Cambrian1<T> : VisionLanguageModelBase<T>, IInstructionTunedVLM<T>
 {
     private readonly Cambrian1Options _options;
 
@@ -281,46 +281,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.ProjectionDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.NumVisionEncoders);
-        writer.Write(_options.EnableSpatialVisionAggregator);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.ProjectionDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.NumVisionEncoders = reader.ReadInt32();
-        _options.EnableSpatialVisionAggregator = reader.ReadBoolean();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new Cambrian1<T>(Architecture, mp, _options);
-        return new Cambrian1<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/InstructionTuned/CogVLM.cs b/src/VisionLanguage/InstructionTuned/CogVLM.cs
index 0ab0377502..1dd6c262a8 100644
--- a/src/VisionLanguage/InstructionTuned/CogVLM.cs
+++ b/src/VisionLanguage/InstructionTuned/CogVLM.cs
@@ -64,7 +64,7 @@ namespace AiDotNet.VisionLanguage.InstructionTuned;
     Year = 2023,
     Authors = "Wang et al."
 )]
-public class CogVLM<T> : VisionLanguageModelBase<T>, IInstructionTunedVLM<T>
+public partial class CogVLM<T> : VisionLanguageModelBase<T>, IInstructionTunedVLM<T>
 {
     private readonly CogVLMOptions _options;
 
@@ -292,45 +292,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.VisualExpertDim);
-        writer.Write(_options.NumVisualExpertHeads);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.VisualExpertDim = reader.ReadInt32();
-        _options.NumVisualExpertHeads = reader.ReadInt32();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var cloneOptions = new CogVLMOptions(_options);
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new CogVLM<T>(Architecture, mp, cloneOptions);
-        return new CogVLM<T>(Architecture, cloneOptions);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/InstructionTuned/CogVLM2.cs b/src/VisionLanguage/InstructionTuned/CogVLM2.cs
index 852547ddc5..5a91ca1cff 100644
--- a/src/VisionLanguage/InstructionTuned/CogVLM2.cs
+++ b/src/VisionLanguage/InstructionTuned/CogVLM2.cs
@@ -63,7 +63,7 @@ namespace AiDotNet.VisionLanguage.InstructionTuned;
     Year = 2024,
     Authors = "Hong et al."
 )]
-public class CogVLM2<T> : VisionLanguageModelBase<T>, IInstructionTunedVLM<T>
+public partial class CogVLM2<T> : VisionLanguageModelBase<T>, IInstructionTunedVLM<T>
 {
     private readonly CogVLM2Options _options;
 
@@ -294,47 +294,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.VisualExpertDim);
-        writer.Write(_options.NumVisualExpertHeads);
-        writer.Write(_options.EnableVideo);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.VisualExpertDim = reader.ReadInt32();
-        _options.NumVisualExpertHeads = reader.ReadInt32();
-        _options.EnableVideo = reader.ReadBoolean();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var cloneOptions = new CogVLM2Options(_options);
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new CogVLM2<T>(Architecture, mp, cloneOptions);
-        return new CogVLM2<T>(Architecture, cloneOptions);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/InstructionTuned/DeepSeekVL.cs b/src/VisionLanguage/InstructionTuned/DeepSeekVL.cs
index 4cd3ffde7d..d757edacaa 100644
--- a/src/VisionLanguage/InstructionTuned/DeepSeekVL.cs
+++ b/src/VisionLanguage/InstructionTuned/DeepSeekVL.cs
@@ -63,7 +63,7 @@ namespace AiDotNet.VisionLanguage.InstructionTuned;
     Year = 2024,
     Authors = "Lu et al."
 )]
-public class DeepSeekVL<T> : VisionLanguageModelBase<T>, IInstructionTunedVLM<T>
+public partial class DeepSeekVL<T> : VisionLanguageModelBase<T>, IInstructionTunedVLM<T>
 {
     private readonly DeepSeekVLOptions _options;
 
@@ -298,44 +298,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.ProjectionDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.UseHybridEncoder);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.ProjectionDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.UseHybridEncoder = reader.ReadBoolean();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new DeepSeekVL<T>(Architecture, mp, _options);
-        return new DeepSeekVL<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/InstructionTuned/DeepSeekVL2.cs b/src/VisionLanguage/InstructionTuned/DeepSeekVL2.cs
index 6bfc38b1b6..d6339f6c20 100644
--- a/src/VisionLanguage/InstructionTuned/DeepSeekVL2.cs
+++ b/src/VisionLanguage/InstructionTuned/DeepSeekVL2.cs
@@ -62,7 +62,7 @@ namespace AiDotNet.VisionLanguage.InstructionTuned;
     Year = 2024,
     Authors = "Wu et al."
 )]
-public class DeepSeekVL2<T> : VisionLanguageModelBase<T>, IInstructionTunedVLM<T>
+public partial class DeepSeekVL2<T> : VisionLanguageModelBase<T>, IInstructionTunedVLM<T>
 {
     private readonly DeepSeekVL2Options _options;
 
@@ -301,48 +301,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.ProjectionDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.EnableDynamicTiling);
-        writer.Write(_options.NumExperts);
-        writer.Write(_options.NumActiveExperts);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.ProjectionDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.EnableDynamicTiling = reader.ReadBoolean();
-        _options.NumExperts = reader.ReadInt32();
-        _options.NumActiveExperts = reader.ReadInt32();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new DeepSeekVL2<T>(Architecture, mp, _options);
-        return new DeepSeekVL2<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/InstructionTuned/Dragonfly.cs b/src/VisionLanguage/InstructionTuned/Dragonfly.cs
index c04c29c01a..d43b75f6b4 100644
--- a/src/VisionLanguage/InstructionTuned/Dragonfly.cs
+++ b/src/VisionLanguage/InstructionTuned/Dragonfly.cs
@@ -65,7 +65,7 @@ namespace AiDotNet.VisionLanguage.InstructionTuned;
     Year = 2024,
     Authors = "Chen et al."
 )]
-public class Dragonfly<T> : VisionLanguageModelBase<T>, IInstructionTunedVLM<T>
+public partial class Dragonfly<T> : VisionLanguageModelBase<T>, IInstructionTunedVLM<T>
 {
     private readonly DragonflyOptions _options;
 
@@ -284,44 +284,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.ProjectionDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.EnableMultiResolution);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.ProjectionDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.EnableMultiResolution = reader.ReadBoolean();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new Dragonfly<T>(Architecture, mp, _options);
-        return new Dragonfly<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/InstructionTuned/Eagle.cs b/src/VisionLanguage/InstructionTuned/Eagle.cs
index d9a5fe01a0..a4275b13d3 100644
--- a/src/VisionLanguage/InstructionTuned/Eagle.cs
+++ b/src/VisionLanguage/InstructionTuned/Eagle.cs
@@ -64,7 +64,7 @@ namespace AiDotNet.VisionLanguage.InstructionTuned;
     Year = 2024,
     Authors = "Shi et al."
 )]
-public class Eagle<T> : VisionLanguageModelBase<T>, IInstructionTunedVLM<T>
+public partial class Eagle<T> : VisionLanguageModelBase<T>, IInstructionTunedVLM<T>
 {
     private readonly EagleOptions _options;
 
@@ -278,42 +278,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.ProjectionDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.ProjectionDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new Eagle<T>(Architecture, mp, _options);
-        return new Eagle<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/InstructionTuned/Eagle25.cs b/src/VisionLanguage/InstructionTuned/Eagle25.cs
index 7c60678ac4..89830e49e1 100644
--- a/src/VisionLanguage/InstructionTuned/Eagle25.cs
+++ b/src/VisionLanguage/InstructionTuned/Eagle25.cs
@@ -63,7 +63,7 @@ namespace AiDotNet.VisionLanguage.InstructionTuned;
     Year = 2025,
     Authors = "Shi et al."
 )]
-public class Eagle25<T> : VisionLanguageModelBase<T>, IInstructionTunedVLM<T>
+public partial class Eagle25<T> : VisionLanguageModelBase<T>, IInstructionTunedVLM<T>
 {
     private readonly Eagle25Options _options;
 
@@ -282,46 +282,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.ProjectionDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.MaxVideoFrames);
-        writer.Write(_options.EnableLongContext);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.ProjectionDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.MaxVideoFrames = reader.ReadInt32();
-        _options.EnableLongContext = reader.ReadBoolean();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new Eagle25<T>(Architecture, mp, _options);
-        return new Eagle25<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/InstructionTuned/Fuyu.cs b/src/VisionLanguage/InstructionTuned/Fuyu.cs
index cd36e25506..ef24ed9791 100644
--- a/src/VisionLanguage/InstructionTuned/Fuyu.cs
+++ b/src/VisionLanguage/InstructionTuned/Fuyu.cs
@@ -62,7 +62,7 @@ namespace AiDotNet.VisionLanguage.InstructionTuned;
     Year = 2023,
     Authors = "Bavishi et al."
 )]
-public class Fuyu<T> : VisionLanguageModelBase<T>, IInstructionTunedVLM<T>
+public partial class Fuyu<T> : VisionLanguageModelBase<T>, IInstructionTunedVLM<T>
 {
     private readonly FuyuOptions _options;
 
@@ -279,40 +279,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.PatchSize);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.PatchSize = reader.ReadInt32();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new Fuyu<T>(Architecture, mp, _options);
-        return new Fuyu<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/InstructionTuned/Gemma3.cs b/src/VisionLanguage/InstructionTuned/Gemma3.cs
index f388dafc1e..4e1b5a433b 100644
--- a/src/VisionLanguage/InstructionTuned/Gemma3.cs
+++ b/src/VisionLanguage/InstructionTuned/Gemma3.cs
@@ -63,7 +63,7 @@ namespace AiDotNet.VisionLanguage.InstructionTuned;
     Year = 2025,
     Authors = "Gemma Team"
 )]
-public class Gemma3<T> : VisionLanguageModelBase<T>, IInstructionTunedVLM<T>
+public partial class Gemma3<T> : VisionLanguageModelBase<T>, IInstructionTunedVLM<T>
 {
     private readonly Gemma3Options _options;
 
@@ -328,44 +328,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.ProjectionDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.EnableNativeDynamicResolution);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.ProjectionDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.EnableNativeDynamicResolution = reader.ReadBoolean();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new Gemma3<T>(Architecture, mp, new Gemma3Options(_options));
-        return new Gemma3<T>(Architecture, new Gemma3Options(_options));
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/InstructionTuned/InternVL.cs b/src/VisionLanguage/InstructionTuned/InternVL.cs
index 690ab7d8e7..23a9326054 100644
--- a/src/VisionLanguage/InstructionTuned/InternVL.cs
+++ b/src/VisionLanguage/InstructionTuned/InternVL.cs
@@ -63,7 +63,7 @@ namespace AiDotNet.VisionLanguage.InstructionTuned;
     Year = 2024,
     Authors = "Chen et al."
 )]
-public class InternVL<T> : VisionLanguageModelBase<T>, IInstructionTunedVLM<T>
+public partial class InternVL<T> : VisionLanguageModelBase<T>, IInstructionTunedVLM<T>
 {
     private readonly InternVLOptions _options;
 
@@ -301,42 +301,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.ProjectionDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.ProjectionDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new InternVL<T>(Architecture, mp, _options);
-        return new InternVL<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/InstructionTuned/InternVL2.cs b/src/VisionLanguage/InstructionTuned/InternVL2.cs
index 78ce885e38..c0b46eff07 100644
--- a/src/VisionLanguage/InstructionTuned/InternVL2.cs
+++ b/src/VisionLanguage/InstructionTuned/InternVL2.cs
@@ -62,7 +62,7 @@ namespace AiDotNet.VisionLanguage.InstructionTuned;
     Year = 2024,
     Authors = "Chen et al."
 )]
-public class InternVL2<T> : VisionLanguageModelBase<T>, IInstructionTunedVLM<T>
+public partial class InternVL2<T> : VisionLanguageModelBase<T>, IInstructionTunedVLM<T>
 {
     private readonly InternVL2Options _options;
 
@@ -298,46 +298,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.ProjectionDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.PixelShuffleFactor);
-        writer.Write(_options.EnableDynamicResolution);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.ProjectionDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.PixelShuffleFactor = reader.ReadInt32();
-        _options.EnableDynamicResolution = reader.ReadBoolean();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new InternVL2<T>(Architecture, mp, _options);
-        return new InternVL2<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/InstructionTuned/InternVL25.cs b/src/VisionLanguage/InstructionTuned/InternVL25.cs
index 85767dc993..0fc4d52549 100644
--- a/src/VisionLanguage/InstructionTuned/InternVL25.cs
+++ b/src/VisionLanguage/InstructionTuned/InternVL25.cs
@@ -62,7 +62,7 @@ namespace AiDotNet.VisionLanguage.InstructionTuned;
     Year = 2024,
     Authors = "Chen et al."
 )]
-public class InternVL25<T> : VisionLanguageModelBase<T>, IInstructionTunedVLM<T>
+public partial class InternVL25<T> : VisionLanguageModelBase<T>, IInstructionTunedVLM<T>
 {
     private readonly InternVL25Options _options;
 
@@ -298,46 +298,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.ProjectionDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.PixelShuffleFactor);
-        writer.Write(_options.EnableDynamicResolution);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.ProjectionDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.PixelShuffleFactor = reader.ReadInt32();
-        _options.EnableDynamicResolution = reader.ReadBoolean();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new InternVL25<T>(Architecture, mp, _options);
-        return new InternVL25<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/InstructionTuned/InternVL3.cs b/src/VisionLanguage/InstructionTuned/InternVL3.cs
index a76960d0f0..30441aa174 100644
--- a/src/VisionLanguage/InstructionTuned/InternVL3.cs
+++ b/src/VisionLanguage/InstructionTuned/InternVL3.cs
@@ -62,7 +62,7 @@ namespace AiDotNet.VisionLanguage.InstructionTuned;
     Year = 2025,
     Authors = "Zhu et al."
 )]
-public class InternVL3<T> : VisionLanguageModelBase<T>, IInstructionTunedVLM<T>
+public partial class InternVL3<T> : VisionLanguageModelBase<T>, IInstructionTunedVLM<T>
 {
     private readonly InternVL3Options _options;
 
@@ -314,46 +314,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.ProjectionDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.PixelShuffleFactor);
-        writer.Write(_options.EnableDynamicResolution);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.ProjectionDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.PixelShuffleFactor = reader.ReadInt32();
-        _options.EnableDynamicResolution = reader.ReadBoolean();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new InternVL3<T>(Architecture, mp, new InternVL3Options(_options));
-        return new InternVL3<T>(Architecture, new InternVL3Options(_options));
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/InstructionTuned/LLaVA15.cs b/src/VisionLanguage/InstructionTuned/LLaVA15.cs
index f553a084dc..748929957f 100644
--- a/src/VisionLanguage/InstructionTuned/LLaVA15.cs
+++ b/src/VisionLanguage/InstructionTuned/LLaVA15.cs
@@ -63,7 +63,7 @@ namespace AiDotNet.VisionLanguage.InstructionTuned;
     Year = 2024,
     Authors = "Liu et al."
 )]
-public class LLaVA15<T> : VisionLanguageModelBase<T>, IInstructionTunedVLM<T>
+public partial class LLaVA15<T> : VisionLanguageModelBase<T>, IInstructionTunedVLM<T>
 {
     private readonly LLaVA15Options _options;
 
@@ -280,42 +280,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.ProjectionDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.ProjectionDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new LLaVA15<T>(Architecture, mp, _options);
-        return new LLaVA15<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/InstructionTuned/LLaVANeXT.cs b/src/VisionLanguage/InstructionTuned/LLaVANeXT.cs
index 5ac1261d65..4c794b6ed3 100644
--- a/src/VisionLanguage/InstructionTuned/LLaVANeXT.cs
+++ b/src/VisionLanguage/InstructionTuned/LLaVANeXT.cs
@@ -62,7 +62,7 @@ namespace AiDotNet.VisionLanguage.InstructionTuned;
     Year = 2024,
     Authors = "Liu et al."
 )]
-public class LLaVANeXT<T> : VisionLanguageModelBase<T>, IInstructionTunedVLM<T>
+public partial class LLaVANeXT<T> : VisionLanguageModelBase<T>, IInstructionTunedVLM<T>
 {
     private readonly LLaVANeXTOptions _options;
 
@@ -282,46 +282,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.ProjectionDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.EnableAnyRes);
-        writer.Write(_options.MaxImageTiles);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.ProjectionDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.EnableAnyRes = reader.ReadBoolean();
-        _options.MaxImageTiles = reader.ReadInt32();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new LLaVANeXT<T>(Architecture, mp, _options);
-        return new LLaVANeXT<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/InstructionTuned/LLaVAOneVision.cs b/src/VisionLanguage/InstructionTuned/LLaVAOneVision.cs
index 7d59d867d8..0f70a3aa0c 100644
--- a/src/VisionLanguage/InstructionTuned/LLaVAOneVision.cs
+++ b/src/VisionLanguage/InstructionTuned/LLaVAOneVision.cs
@@ -64,7 +64,7 @@ namespace AiDotNet.VisionLanguage.InstructionTuned;
     Year = 2024,
     Authors = "Li et al."
 )]
-public class LLaVAOneVision<T> : VisionLanguageModelBase<T>, IInstructionTunedVLM<T>
+public partial class LLaVAOneVision<T> : VisionLanguageModelBase<T>, IInstructionTunedVLM<T>
 {
     private readonly LLaVAOneVisionOptions _options;
 
@@ -282,46 +282,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.ProjectionDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.EnableVideo);
-        writer.Write(_options.MaxVideoFrames);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.ProjectionDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.EnableVideo = reader.ReadBoolean();
-        _options.MaxVideoFrames = reader.ReadInt32();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new LLaVAOneVision<T>(Architecture, mp, _options);
-        return new LLaVAOneVision<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/InstructionTuned/LLaVAOneVision15.cs b/src/VisionLanguage/InstructionTuned/LLaVAOneVision15.cs
index 1e5009eefe..f49c88b067 100644
--- a/src/VisionLanguage/InstructionTuned/LLaVAOneVision15.cs
+++ b/src/VisionLanguage/InstructionTuned/LLaVAOneVision15.cs
@@ -62,7 +62,7 @@ namespace AiDotNet.VisionLanguage.InstructionTuned;
     Year = 2025,
     Authors = "Li et al."
 )]
-public class LLaVAOneVision15<T> : VisionLanguageModelBase<T>, IInstructionTunedVLM<T>
+public partial class LLaVAOneVision15<T> : VisionLanguageModelBase<T>, IInstructionTunedVLM<T>
 {
     private readonly LLaVAOneVision15Options _options;
 
@@ -279,46 +279,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.ProjectionDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.EnableVideo);
-        writer.Write(_options.MaxVideoFrames);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.ProjectionDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.EnableVideo = reader.ReadBoolean();
-        _options.MaxVideoFrames = reader.ReadInt32();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new LLaVAOneVision15<T>(Architecture, mp, _options);
-        return new LLaVAOneVision15<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/InstructionTuned/Llama32Vision.cs b/src/VisionLanguage/InstructionTuned/Llama32Vision.cs
index 1b1b64c096..14732e4388 100644
--- a/src/VisionLanguage/InstructionTuned/Llama32Vision.cs
+++ b/src/VisionLanguage/InstructionTuned/Llama32Vision.cs
@@ -63,7 +63,7 @@ namespace AiDotNet.VisionLanguage.InstructionTuned;
     Year = 2024,
     Authors = "Grattafiori et al."
 )]
-public class Llama32Vision<T> : VisionLanguageModelBase<T>, IInstructionTunedVLM<T>
+public partial class Llama32Vision<T> : VisionLanguageModelBase<T>, IInstructionTunedVLM<T>
 {
     private readonly Llama32VisionOptions _options;
 
@@ -297,42 +297,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.ProjectionDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.ProjectionDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new Llama32Vision<T>(Architecture, mp, _options);
-        return new Llama32Vision<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/InstructionTuned/MPLUGOwl.cs b/src/VisionLanguage/InstructionTuned/MPLUGOwl.cs
index 8f53b7011d..f35ee6723e 100644
--- a/src/VisionLanguage/InstructionTuned/MPLUGOwl.cs
+++ b/src/VisionLanguage/InstructionTuned/MPLUGOwl.cs
@@ -301,46 +301,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.AbstractorDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumAbstractorLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.NumAbstractorHeads);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.AbstractorDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumAbstractorLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.NumAbstractorHeads = reader.ReadInt32();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new MPLUGOwl<T>(Architecture, mp, _options);
-        return new MPLUGOwl<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/InstructionTuned/MPLUGOwl2.cs b/src/VisionLanguage/InstructionTuned/MPLUGOwl2.cs
index 54dbfb05af..8a2a240c10 100644
--- a/src/VisionLanguage/InstructionTuned/MPLUGOwl2.cs
+++ b/src/VisionLanguage/InstructionTuned/MPLUGOwl2.cs
@@ -313,46 +313,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.AbstractorDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumAbstractorLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.NumAbstractorHeads);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.AbstractorDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumAbstractorLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.NumAbstractorHeads = reader.ReadInt32();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new MPLUGOwl2<T>(Architecture, mp, _options);
-        return new MPLUGOwl2<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/InstructionTuned/MPLUGOwl3.cs b/src/VisionLanguage/InstructionTuned/MPLUGOwl3.cs
index 7b670eb20d..5f00bc2c27 100644
--- a/src/VisionLanguage/InstructionTuned/MPLUGOwl3.cs
+++ b/src/VisionLanguage/InstructionTuned/MPLUGOwl3.cs
@@ -307,46 +307,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.AbstractorDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumAbstractorLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.NumAbstractorHeads);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.AbstractorDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumAbstractorLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.NumAbstractorHeads = reader.ReadInt32();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new MPLUGOwl3<T>(Architecture, mp, _options);
-        return new MPLUGOwl3<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/InstructionTuned/Mantis.cs b/src/VisionLanguage/InstructionTuned/Mantis.cs
index 9bb8212972..278ca460a7 100644
--- a/src/VisionLanguage/InstructionTuned/Mantis.cs
+++ b/src/VisionLanguage/InstructionTuned/Mantis.cs
@@ -65,7 +65,7 @@ namespace AiDotNet.VisionLanguage.InstructionTuned;
     Year = 2024,
     Authors = "Jiang et al."
 )]
-public class Mantis<T> : VisionLanguageModelBase<T>, IInstructionTunedVLM<T>
+public partial class Mantis<T> : VisionLanguageModelBase<T>, IInstructionTunedVLM<T>
 {
     private readonly MantisOptions _options;
 
@@ -284,44 +284,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.ProjectionDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.MaxImages);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.ProjectionDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.MaxImages = reader.ReadInt32();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new Mantis<T>(Architecture, mp, _options);
-        return new Mantis<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/InstructionTuned/Maya.cs b/src/VisionLanguage/InstructionTuned/Maya.cs
index 409385af7d..5da21579cf 100644
--- a/src/VisionLanguage/InstructionTuned/Maya.cs
+++ b/src/VisionLanguage/InstructionTuned/Maya.cs
@@ -63,7 +63,7 @@ namespace AiDotNet.VisionLanguage.InstructionTuned;
     Year = 2024,
     Authors = "Gupta et al."
 )]
-public class Maya<T> : VisionLanguageModelBase<T>, IInstructionTunedVLM<T>
+public partial class Maya<T> : VisionLanguageModelBase<T>, IInstructionTunedVLM<T>
 {
     private readonly MayaOptions _options;
 
@@ -284,44 +284,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.ProjectionDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.NumLanguages);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.ProjectionDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.NumLanguages = reader.ReadInt32();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new Maya<T>(Architecture, mp, _options);
-        return new Maya<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/InstructionTuned/MiniCPMV.cs b/src/VisionLanguage/InstructionTuned/MiniCPMV.cs
index e272f5cab5..fbb98615ef 100644
--- a/src/VisionLanguage/InstructionTuned/MiniCPMV.cs
+++ b/src/VisionLanguage/InstructionTuned/MiniCPMV.cs
@@ -63,7 +63,7 @@ namespace AiDotNet.VisionLanguage.InstructionTuned;
     Year = 2024,
     Authors = "Yao et al."
 )]
-public class MiniCPMV<T> : VisionLanguageModelBase<T>, IInstructionTunedVLM<T>
+public partial class MiniCPMV<T> : VisionLanguageModelBase<T>, IInstructionTunedVLM<T>
 {
     private readonly MiniCPMVOptions _options;
 
@@ -283,42 +283,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.ProjectionDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.ProjectionDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new MiniCPMV<T>(Architecture, mp, _options);
-        return new MiniCPMV<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/InstructionTuned/MiniCPMo.cs b/src/VisionLanguage/InstructionTuned/MiniCPMo.cs
index beda165253..9bfb1d6df3 100644
--- a/src/VisionLanguage/InstructionTuned/MiniCPMo.cs
+++ b/src/VisionLanguage/InstructionTuned/MiniCPMo.cs
@@ -63,7 +63,7 @@ namespace AiDotNet.VisionLanguage.InstructionTuned;
     Year = 2025,
     Authors = "Yao et al."
 )]
-public class MiniCPMo<T> : VisionLanguageModelBase<T>, IInstructionTunedVLM<T>
+public partial class MiniCPMo<T> : VisionLanguageModelBase<T>, IInstructionTunedVLM<T>
 {
     private readonly MiniCPMoOptions _options;
 
@@ -283,46 +283,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.ProjectionDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.EnableSpeech);
-        writer.Write(_options.EnableRealtime);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.ProjectionDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.EnableSpeech = reader.ReadBoolean();
-        _options.EnableRealtime = reader.ReadBoolean();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new MiniCPMo<T>(Architecture, mp, _options);
-        return new MiniCPMo<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/InstructionTuned/MiniGPT4.cs b/src/VisionLanguage/InstructionTuned/MiniGPT4.cs
index 7395c0c45b..d1295d6a6f 100644
--- a/src/VisionLanguage/InstructionTuned/MiniGPT4.cs
+++ b/src/VisionLanguage/InstructionTuned/MiniGPT4.cs
@@ -324,46 +324,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.QFormerDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumQFormerLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.NumQueryTokens);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.QFormerDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumQFormerLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.NumQueryTokens = reader.ReadInt32();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new MiniGPT4<T>(Architecture, mp, new MiniGPT4Options(_options));
-        return new MiniGPT4<T>(Architecture, new MiniGPT4Options(_options));
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/InstructionTuned/MiniGPTv2.cs b/src/VisionLanguage/InstructionTuned/MiniGPTv2.cs
index f6c71dd74e..50ef16ff08 100644
--- a/src/VisionLanguage/InstructionTuned/MiniGPTv2.cs
+++ b/src/VisionLanguage/InstructionTuned/MiniGPTv2.cs
@@ -321,46 +321,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.QFormerDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumQFormerLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.NumQueryTokens);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.QFormerDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumQFormerLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.NumQueryTokens = reader.ReadInt32();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new MiniGPTv2<T>(Architecture, mp, _options);
-        return new MiniGPTv2<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/InstructionTuned/Molmo.cs b/src/VisionLanguage/InstructionTuned/Molmo.cs
index d46888d237..692c900c85 100644
--- a/src/VisionLanguage/InstructionTuned/Molmo.cs
+++ b/src/VisionLanguage/InstructionTuned/Molmo.cs
@@ -63,7 +63,7 @@ namespace AiDotNet.VisionLanguage.InstructionTuned;
     Year = 2024,
     Authors = "Deitke et al."
 )]
-public class Molmo<T> : VisionLanguageModelBase<T>, IInstructionTunedVLM<T>
+public partial class Molmo<T> : VisionLanguageModelBase<T>, IInstructionTunedVLM<T>
 {
     private readonly MolmoOptions _options;
 
@@ -282,44 +282,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.ProjectionDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.EnablePointing);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.ProjectionDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.EnablePointing = reader.ReadBoolean();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new Molmo<T>(Architecture, mp, _options);
-        return new Molmo<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/InstructionTuned/Monkey.cs b/src/VisionLanguage/InstructionTuned/Monkey.cs
index a68c956d34..dfe46a326a 100644
--- a/src/VisionLanguage/InstructionTuned/Monkey.cs
+++ b/src/VisionLanguage/InstructionTuned/Monkey.cs
@@ -65,7 +65,7 @@ namespace AiDotNet.VisionLanguage.InstructionTuned;
     Year = 2024,
     Authors = "Li et al."
 )]
-public class Monkey<T> : VisionLanguageModelBase<T>, IInstructionTunedVLM<T>
+public partial class Monkey<T> : VisionLanguageModelBase<T>, IInstructionTunedVLM<T>
 {
     private readonly MonkeyOptions _options;
 
@@ -283,44 +283,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.ProjectionDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.EnableMultiLevelDescription);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.ProjectionDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.EnableMultiLevelDescription = reader.ReadBoolean();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new Monkey<T>(Architecture, mp, _options);
-        return new Monkey<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/InstructionTuned/Moondream.cs b/src/VisionLanguage/InstructionTuned/Moondream.cs
index 7593459618..9830d10729 100644
--- a/src/VisionLanguage/InstructionTuned/Moondream.cs
+++ b/src/VisionLanguage/InstructionTuned/Moondream.cs
@@ -64,7 +64,7 @@ namespace AiDotNet.VisionLanguage.InstructionTuned;
     Year = 2024,
     Authors = "Vikhyat Korrapati"
 )]
-public class Moondream<T> : VisionLanguageModelBase<T>, IInstructionTunedVLM<T>
+public partial class Moondream<T> : VisionLanguageModelBase<T>, IInstructionTunedVLM<T>
 {
     private readonly MoondreamOptions _options;
 
@@ -283,42 +283,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.ProjectionDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.ProjectionDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new Moondream<T>(Architecture, mp, _options);
-        return new Moondream<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/InstructionTuned/NVLM.cs b/src/VisionLanguage/InstructionTuned/NVLM.cs
index 2a1845b826..1366cb955f 100644
--- a/src/VisionLanguage/InstructionTuned/NVLM.cs
+++ b/src/VisionLanguage/InstructionTuned/NVLM.cs
@@ -63,7 +63,7 @@ namespace AiDotNet.VisionLanguage.InstructionTuned;
     Year = 2024,
     Authors = "Dai et al."
 )]
-public class NVLM<T> : VisionLanguageModelBase<T>, IInstructionTunedVLM<T>
+public partial class NVLM<T> : VisionLanguageModelBase<T>, IInstructionTunedVLM<T>
 {
     private readonly NVLMOptions _options;
 
@@ -283,46 +283,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.ProjectionDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.EnableCrossAttention);
-        writer.Write(_options.CrossAttentionDim);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.ProjectionDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.EnableCrossAttention = reader.ReadBoolean();
-        _options.CrossAttentionDim = reader.ReadInt32();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new NVLM<T>(Architecture, mp, _options);
-        return new NVLM<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/InstructionTuned/Ovis.cs b/src/VisionLanguage/InstructionTuned/Ovis.cs
index 7b9362c280..2b6c930cbb 100644
--- a/src/VisionLanguage/InstructionTuned/Ovis.cs
+++ b/src/VisionLanguage/InstructionTuned/Ovis.cs
@@ -64,7 +64,7 @@ namespace AiDotNet.VisionLanguage.InstructionTuned;
     Year = 2024,
     Authors = "Lu et al."
 )]
-public class Ovis<T> : VisionLanguageModelBase<T>, IInstructionTunedVLM<T>
+public partial class Ovis<T> : VisionLanguageModelBase<T>, IInstructionTunedVLM<T>
 {
     private readonly OvisOptions _options;
 
@@ -283,42 +283,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.ProjectionDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.ProjectionDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new Ovis<T>(Architecture, mp, _options);
-        return new Ovis<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/InstructionTuned/Phi3Vision.cs b/src/VisionLanguage/InstructionTuned/Phi3Vision.cs
index 26974f9184..dfbef1d23a 100644
--- a/src/VisionLanguage/InstructionTuned/Phi3Vision.cs
+++ b/src/VisionLanguage/InstructionTuned/Phi3Vision.cs
@@ -62,7 +62,7 @@ namespace AiDotNet.VisionLanguage.InstructionTuned;
     Year = 2024,
     Authors = "Abdin et al."
 )]
-public class Phi3Vision<T> : VisionLanguageModelBase<T>, IInstructionTunedVLM<T>
+public partial class Phi3Vision<T> : VisionLanguageModelBase<T>, IInstructionTunedVLM<T>
 {
     private readonly Phi3VisionOptions _options;
 
@@ -328,42 +328,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.ProjectionDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.ProjectionDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new Phi3Vision<T>(Architecture, mp, _options);
-        return new Phi3Vision<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/InstructionTuned/Phi4Multimodal.cs b/src/VisionLanguage/InstructionTuned/Phi4Multimodal.cs
index 559157c57d..05d2d90522 100644
--- a/src/VisionLanguage/InstructionTuned/Phi4Multimodal.cs
+++ b/src/VisionLanguage/InstructionTuned/Phi4Multimodal.cs
@@ -63,7 +63,7 @@ namespace AiDotNet.VisionLanguage.InstructionTuned;
     Year = 2025,
     Authors = "Abdin et al."
 )]
-public class Phi4Multimodal<T> : VisionLanguageModelBase<T>, IInstructionTunedVLM<T>
+public partial class Phi4Multimodal<T> : VisionLanguageModelBase<T>, IInstructionTunedVLM<T>
 {
     private readonly Phi4MultimodalOptions _options;
 
@@ -297,44 +297,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.ProjectionDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.EnableAudio);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.ProjectionDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.EnableAudio = reader.ReadBoolean();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new Phi4Multimodal<T>(Architecture, mp, _options);
-        return new Phi4Multimodal<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/InstructionTuned/Pixtral.cs b/src/VisionLanguage/InstructionTuned/Pixtral.cs
index a55ba32dc7..4b11bf15a9 100644
--- a/src/VisionLanguage/InstructionTuned/Pixtral.cs
+++ b/src/VisionLanguage/InstructionTuned/Pixtral.cs
@@ -61,7 +61,7 @@ namespace AiDotNet.VisionLanguage.InstructionTuned;
     Year = 2024,
     Authors = "Agrawal et al."
 )]
-public class Pixtral<T> : VisionLanguageModelBase<T>, IInstructionTunedVLM<T>
+public partial class Pixtral<T> : VisionLanguageModelBase<T>, IInstructionTunedVLM<T>
 {
     private readonly PixtralOptions _options;
 
@@ -315,42 +315,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.ProjectionDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.ProjectionDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new Pixtral<T>(Architecture, mp, _options);
-        return new Pixtral<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/InstructionTuned/PixtralLarge.cs b/src/VisionLanguage/InstructionTuned/PixtralLarge.cs
index 706e935ee4..5a821c4ff6 100644
--- a/src/VisionLanguage/InstructionTuned/PixtralLarge.cs
+++ b/src/VisionLanguage/InstructionTuned/PixtralLarge.cs
@@ -64,7 +64,7 @@ namespace AiDotNet.VisionLanguage.InstructionTuned;
     Year = 2024,
     Authors = "Mistral AI"
 )]
-public class PixtralLarge<T> : VisionLanguageModelBase<T>, IInstructionTunedVLM<T>
+public partial class PixtralLarge<T> : VisionLanguageModelBase<T>, IInstructionTunedVLM<T>
 {
     private readonly PixtralLargeOptions _options;
 
@@ -320,42 +320,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.ProjectionDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.ProjectionDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new PixtralLarge<T>(Architecture, mp, _options);
-        return new PixtralLarge<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/InstructionTuned/Qwen25VL.cs b/src/VisionLanguage/InstructionTuned/Qwen25VL.cs
index 94e743174e..005905f565 100644
--- a/src/VisionLanguage/InstructionTuned/Qwen25VL.cs
+++ b/src/VisionLanguage/InstructionTuned/Qwen25VL.cs
@@ -331,46 +331,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.ResamplerDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumResamplerLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.NumResamplerHeads);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.ResamplerDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumResamplerLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.NumResamplerHeads = reader.ReadInt32();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new Qwen25VL<T>(Architecture, mp, _options);
-        return new Qwen25VL<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/InstructionTuned/Qwen2VL.cs b/src/VisionLanguage/InstructionTuned/Qwen2VL.cs
index daf1e877e6..4f0ff922dc 100644
--- a/src/VisionLanguage/InstructionTuned/Qwen2VL.cs
+++ b/src/VisionLanguage/InstructionTuned/Qwen2VL.cs
@@ -316,46 +316,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.ResamplerDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumResamplerLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.NumResamplerHeads);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.ResamplerDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumResamplerLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.NumResamplerHeads = reader.ReadInt32();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new Qwen2VL<T>(Architecture, mp, _options);
-        return new Qwen2VL<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/InstructionTuned/Qwen3VL.cs b/src/VisionLanguage/InstructionTuned/Qwen3VL.cs
index 68675decd9..52a30a8d3e 100644
--- a/src/VisionLanguage/InstructionTuned/Qwen3VL.cs
+++ b/src/VisionLanguage/InstructionTuned/Qwen3VL.cs
@@ -308,46 +308,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.ResamplerDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumResamplerLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.NumResamplerHeads);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.ResamplerDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumResamplerLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.NumResamplerHeads = reader.ReadInt32();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new Qwen3VL<T>(Architecture, mp, _options);
-        return new Qwen3VL<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/InstructionTuned/QwenVL.cs b/src/VisionLanguage/InstructionTuned/QwenVL.cs
index 8f899b8589..9fb51027f5 100644
--- a/src/VisionLanguage/InstructionTuned/QwenVL.cs
+++ b/src/VisionLanguage/InstructionTuned/QwenVL.cs
@@ -331,46 +331,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.ResamplerDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumResamplerLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.NumResamplerHeads);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.ResamplerDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumResamplerLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.NumResamplerHeads = reader.ReadInt32();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new QwenVL<T>(Architecture, mp, _options);
-        return new QwenVL<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/InstructionTuned/SmolVLM.cs b/src/VisionLanguage/InstructionTuned/SmolVLM.cs
index 71a6ec8e3e..13d91618fc 100644
--- a/src/VisionLanguage/InstructionTuned/SmolVLM.cs
+++ b/src/VisionLanguage/InstructionTuned/SmolVLM.cs
@@ -64,7 +64,7 @@ namespace AiDotNet.VisionLanguage.InstructionTuned;
     Year = 2025,
     Authors = "HuggingFace"
 )]
-public class SmolVLM<T> : VisionLanguageModelBase<T>, IInstructionTunedVLM<T>
+public partial class SmolVLM<T> : VisionLanguageModelBase<T>, IInstructionTunedVLM<T>
 {
     private readonly SmolVLMOptions _options;
 
@@ -338,44 +338,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.ProjectionDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.ModelVariant ?? string.Empty);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.ProjectionDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.ModelVariant = reader.ReadString();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new SmolVLM<T>(Architecture, mp, _options);
-        return new SmolVLM<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/InstructionTuned/VILA.cs b/src/VisionLanguage/InstructionTuned/VILA.cs
index 81d9ff58a9..8d2cc0e41a 100644
--- a/src/VisionLanguage/InstructionTuned/VILA.cs
+++ b/src/VisionLanguage/InstructionTuned/VILA.cs
@@ -65,7 +65,7 @@ namespace AiDotNet.VisionLanguage.InstructionTuned;
     Year = 2024,
     Authors = "Lin et al."
 )]
-public class VILA<T> : VisionLanguageModelBase<T>, IInstructionTunedVLM<T>
+public partial class VILA<T> : VisionLanguageModelBase<T>, IInstructionTunedVLM<T>
 {
     private readonly VILAOptions _options;
 
@@ -283,44 +283,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.ProjectionDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.EnableInterleavedData);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.ProjectionDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.EnableInterleavedData = reader.ReadBoolean();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new VILA<T>(Architecture, mp, _options);
-        return new VILA<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/InstructionTuned/VILAU.cs b/src/VisionLanguage/InstructionTuned/VILAU.cs
index 2a34358165..6e6ee4d76b 100644
--- a/src/VisionLanguage/InstructionTuned/VILAU.cs
+++ b/src/VisionLanguage/InstructionTuned/VILAU.cs
@@ -65,7 +65,7 @@ namespace AiDotNet.VisionLanguage.InstructionTuned;
     Year = 2024,
     Authors = "Wu et al."
 )]
-public class VILAU<T> : VisionLanguageModelBase<T>, IInstructionTunedVLM<T>
+public partial class VILAU<T> : VisionLanguageModelBase<T>, IInstructionTunedVLM<T>
 {
     private readonly VILAUOptions _options;
 
@@ -284,44 +284,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.ProjectionDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.EnableGeneration);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.ProjectionDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.EnableGeneration = reader.ReadBoolean();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new VILAU<T>(Architecture, mp, _options);
-        return new VILAU<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/Medical/DragonflyMed.cs b/src/VisionLanguage/Medical/DragonflyMed.cs
index a793108145..dabbee199d 100644
--- a/src/VisionLanguage/Medical/DragonflyMed.cs
+++ b/src/VisionLanguage/Medical/DragonflyMed.cs
@@ -60,7 +60,7 @@ namespace AiDotNet.VisionLanguage.Medical;
     Year = 2024,
     Authors = "Chen et al."
 )]
-public class DragonflyMed<T> : VisionLanguageModelBase<T>, IMedicalVLM<T>
+public partial class DragonflyMed<T> : VisionLanguageModelBase<T>, IMedicalVLM<T>
 {
     private readonly DragonflyMedOptions _options;
 
@@ -264,40 +264,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new DragonflyMed<T>(Architecture, mp, _options);
-        return new DragonflyMed<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/Medical/LLaVAMed.cs b/src/VisionLanguage/Medical/LLaVAMed.cs
index c493c2451d..88df2afe7b 100644
--- a/src/VisionLanguage/Medical/LLaVAMed.cs
+++ b/src/VisionLanguage/Medical/LLaVAMed.cs
@@ -61,7 +61,7 @@ namespace AiDotNet.VisionLanguage.Medical;
     Year = 2023,
     Authors = "Li et al."
 )]
-public class LLaVAMed<T> : VisionLanguageModelBase<T>, IMedicalVLM<T>
+public partial class LLaVAMed<T> : VisionLanguageModelBase<T>, IMedicalVLM<T>
 {
     private readonly LLaVAMedOptions _options;
 
@@ -266,40 +266,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new LLaVAMed<T>(Architecture, mp, _options);
-        return new LLaVAMed<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/Medical/MedFlamingo.cs b/src/VisionLanguage/Medical/MedFlamingo.cs
index 8f009ffa3f..21764adaeb 100644
--- a/src/VisionLanguage/Medical/MedFlamingo.cs
+++ b/src/VisionLanguage/Medical/MedFlamingo.cs
@@ -60,7 +60,7 @@ namespace AiDotNet.VisionLanguage.Medical;
     Year = 2023,
     Authors = "Moor et al."
 )]
-public class MedFlamingo<T> : VisionLanguageModelBase<T>, IMedicalVLM<T>
+public partial class MedFlamingo<T> : VisionLanguageModelBase<T>, IMedicalVLM<T>
 {
     private readonly MedFlamingoOptions _options;
 
@@ -269,40 +269,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new MedFlamingo<T>(Architecture, mp, _options);
-        return new MedFlamingo<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/Medical/PathVLM.cs b/src/VisionLanguage/Medical/PathVLM.cs
index 789be2ce4a..36cc43b6de 100644
--- a/src/VisionLanguage/Medical/PathVLM.cs
+++ b/src/VisionLanguage/Medical/PathVLM.cs
@@ -60,7 +60,7 @@ namespace AiDotNet.VisionLanguage.Medical;
     Year = 2024,
     Authors = "Sun et al."
 )]
-public class PathVLM<T> : VisionLanguageModelBase<T>, IMedicalVLM<T>
+public partial class PathVLM<T> : VisionLanguageModelBase<T>, IMedicalVLM<T>
 {
     private readonly PathVLMOptions _options;
 
@@ -266,40 +266,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new PathVLM<T>(Architecture, mp, _options);
-        return new PathVLM<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/Medical/RadFM.cs b/src/VisionLanguage/Medical/RadFM.cs
index 751c788dea..079be8fc40 100644
--- a/src/VisionLanguage/Medical/RadFM.cs
+++ b/src/VisionLanguage/Medical/RadFM.cs
@@ -60,7 +60,7 @@ namespace AiDotNet.VisionLanguage.Medical;
     Year = 2024,
     Authors = "Wu et al."
 )]
-public class RadFM<T> : VisionLanguageModelBase<T>, IMedicalVLM<T>
+public partial class RadFM<T> : VisionLanguageModelBase<T>, IMedicalVLM<T>
 {
     private readonly RadFMOptions _options;
 
@@ -265,40 +265,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new RadFM<T>(Architecture, mp, _options);
-        return new RadFM<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/Proprietary/ClaudeVision.cs b/src/VisionLanguage/Proprietary/ClaudeVision.cs
index d0ce29b39c..db6b42465f 100644
--- a/src/VisionLanguage/Proprietary/ClaudeVision.cs
+++ b/src/VisionLanguage/Proprietary/ClaudeVision.cs
@@ -58,7 +58,7 @@ namespace AiDotNet.VisionLanguage.Proprietary;
     "Constitutional AI: Harmlessness from AI Feedback",
     "https://arxiv.org/abs/2212.08073"
 )]
-public class ClaudeVision<T> : VisionLanguageModelBase<T>, IProprietaryVLM<T>
+public partial class ClaudeVision<T> : VisionLanguageModelBase<T>, IProprietaryVLM<T>
 {
     private readonly ClaudeVisionOptions _options;
 
@@ -265,40 +265,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new ClaudeVision<T>(Architecture, mp, _options);
-        return new ClaudeVision<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/Proprietary/GeminiVision.cs b/src/VisionLanguage/Proprietary/GeminiVision.cs
index 1557f55695..e0b5fc5424 100644
--- a/src/VisionLanguage/Proprietary/GeminiVision.cs
+++ b/src/VisionLanguage/Proprietary/GeminiVision.cs
@@ -60,7 +60,7 @@ namespace AiDotNet.VisionLanguage.Proprietary;
     Year = 2024,
     Authors = "Gemini Team, Google"
 )]
-public class GeminiVision<T> : VisionLanguageModelBase<T>, IProprietaryVLM<T>
+public partial class GeminiVision<T> : VisionLanguageModelBase<T>, IProprietaryVLM<T>
 {
     private readonly GeminiVisionOptions _options;
 
@@ -267,40 +267,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new GeminiVision<T>(Architecture, mp, _options);
-        return new GeminiVision<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/Proprietary/GrokVision.cs b/src/VisionLanguage/Proprietary/GrokVision.cs
index 2583be2ce3..f25cf45610 100644
--- a/src/VisionLanguage/Proprietary/GrokVision.cs
+++ b/src/VisionLanguage/Proprietary/GrokVision.cs
@@ -55,7 +55,7 @@ namespace AiDotNet.VisionLanguage.Proprietary;
 [ModelComplexity(ModelComplexity.High)]
 [ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
 [ResearchPaper("Grok", "https://x.ai/grok")]
-public class GrokVision<T> : VisionLanguageModelBase<T>, IProprietaryVLM<T>
+public partial class GrokVision<T> : VisionLanguageModelBase<T>, IProprietaryVLM<T>
 {
     private readonly GrokVisionOptions _options;
 
@@ -286,40 +286,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new GrokVision<T>(Architecture, mp, _options);
-        return new GrokVision<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/Reasoning/KimiVL.cs b/src/VisionLanguage/Reasoning/KimiVL.cs
index 2e566fd2b2..f0c8c4a675 100644
--- a/src/VisionLanguage/Reasoning/KimiVL.cs
+++ b/src/VisionLanguage/Reasoning/KimiVL.cs
@@ -58,7 +58,7 @@ namespace AiDotNet.VisionLanguage.Reasoning;
     Year = 2025,
     Authors = "Moonshot AI"
 )]
-public class KimiVL<T> : VisionLanguageModelBase<T>, IReasoningVLM<T>
+public partial class KimiVL<T> : VisionLanguageModelBase<T>, IReasoningVLM<T>
 {
     private readonly KimiVLOptions _options;
 
@@ -398,50 +398,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.ProjectionDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.MaxReasoningTokens);
-        writer.Write(_options.TotalParameters);
-        writer.Write(_options.ActiveParameters);
-        writer.Write(_options.EnableLongContext);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.ProjectionDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.MaxReasoningTokens = reader.ReadInt32();
-        _options.TotalParameters = reader.ReadInt32();
-        _options.ActiveParameters = reader.ReadInt32();
-        _options.EnableLongContext = reader.ReadBoolean();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new KimiVL<T>(Architecture, mp, _options);
-        return new KimiVL<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/Reasoning/KimiVLThinking.cs b/src/VisionLanguage/Reasoning/KimiVLThinking.cs
index e857942546..e51c192063 100644
--- a/src/VisionLanguage/Reasoning/KimiVLThinking.cs
+++ b/src/VisionLanguage/Reasoning/KimiVLThinking.cs
@@ -59,7 +59,7 @@ namespace AiDotNet.VisionLanguage.Reasoning;
     Year = 2025,
     Authors = "Moonshot AI"
 )]
-public class KimiVLThinking<T> : VisionLanguageModelBase<T>, IReasoningVLM<T>
+public partial class KimiVLThinking<T> : VisionLanguageModelBase<T>, IReasoningVLM<T>
 {
     private readonly KimiVLThinkingOptions _options;
 
@@ -434,50 +434,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.ProjectionDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.MaxReasoningTokens);
-        writer.Write(_options.TotalParameters);
-        writer.Write(_options.ActiveParameters);
-        writer.Write(_options.EnableLongThinking);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.ProjectionDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.MaxReasoningTokens = reader.ReadInt32();
-        _options.TotalParameters = reader.ReadInt32();
-        _options.ActiveParameters = reader.ReadInt32();
-        _options.EnableLongThinking = reader.ReadBoolean();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new KimiVLThinking<T>(Architecture, mp, _options);
-        return new KimiVLThinking<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/Reasoning/LLaVACoT.cs b/src/VisionLanguage/Reasoning/LLaVACoT.cs
index 928a0b534f..be091deb8d 100644
--- a/src/VisionLanguage/Reasoning/LLaVACoT.cs
+++ b/src/VisionLanguage/Reasoning/LLaVACoT.cs
@@ -59,7 +59,7 @@ namespace AiDotNet.VisionLanguage.Reasoning;
     Year = 2024,
     Authors = "Xu et al."
 )]
-public class LLaVACoT<T> : VisionLanguageModelBase<T>, IReasoningVLM<T>
+public partial class LLaVACoT<T> : VisionLanguageModelBase<T>, IReasoningVLM<T>
 {
     private readonly LLaVACoTOptions _options;
 
@@ -408,46 +408,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.ProjectionDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.MaxReasoningTokens);
-        writer.Write(_options.EnableStructuredReasoning);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.ProjectionDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.MaxReasoningTokens = reader.ReadInt32();
-        _options.EnableStructuredReasoning = reader.ReadBoolean();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new LLaVACoT<T>(Architecture, mp, _options);
-        return new LLaVACoT<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/Reasoning/QVQ72B.cs b/src/VisionLanguage/Reasoning/QVQ72B.cs
index bc18d7971d..f8f20307e3 100644
--- a/src/VisionLanguage/Reasoning/QVQ72B.cs
+++ b/src/VisionLanguage/Reasoning/QVQ72B.cs
@@ -59,7 +59,7 @@ namespace AiDotNet.VisionLanguage.Reasoning;
     Year = 2024,
     Authors = "Qwen Team"
 )]
-public class QVQ72B<T> : VisionLanguageModelBase<T>, IReasoningVLM<T>
+public partial class QVQ72B<T> : VisionLanguageModelBase<T>, IReasoningVLM<T>
 {
     private readonly QVQ72BOptions _options;
 
@@ -353,46 +353,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.ProjectionDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.MaxReasoningTokens);
-        writer.Write(_options.TotalParameters);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.ProjectionDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.MaxReasoningTokens = reader.ReadInt32();
-        _options.TotalParameters = reader.ReadInt32();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new QVQ72B<T>(Architecture, mp, _options);
-        return new QVQ72B<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/Reasoning/SkyworkR1V.cs b/src/VisionLanguage/Reasoning/SkyworkR1V.cs
index 91f8708184..63430035d3 100644
--- a/src/VisionLanguage/Reasoning/SkyworkR1V.cs
+++ b/src/VisionLanguage/Reasoning/SkyworkR1V.cs
@@ -59,7 +59,7 @@ namespace AiDotNet.VisionLanguage.Reasoning;
     Year = 2025,
     Authors = "Skywork Team"
 )]
-public class SkyworkR1V<T> : VisionLanguageModelBase<T>, IReasoningVLM<T>
+public partial class SkyworkR1V<T> : VisionLanguageModelBase<T>, IReasoningVLM<T>
 {
     private readonly SkyworkR1VOptions _options;
 
@@ -410,46 +410,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.ProjectionDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.MaxReasoningTokens);
-        writer.Write(_options.EnableCrossModalTransfer);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.ProjectionDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.MaxReasoningTokens = reader.ReadInt32();
-        _options.EnableCrossModalTransfer = reader.ReadBoolean();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new SkyworkR1V<T>(Architecture, mp, _options);
-        return new SkyworkR1V<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/Reasoning/SkyworkR1V2.cs b/src/VisionLanguage/Reasoning/SkyworkR1V2.cs
index c118332c61..48f2b8f87d 100644
--- a/src/VisionLanguage/Reasoning/SkyworkR1V2.cs
+++ b/src/VisionLanguage/Reasoning/SkyworkR1V2.cs
@@ -59,7 +59,7 @@ namespace AiDotNet.VisionLanguage.Reasoning;
     Year = 2025,
     Authors = "Skywork Team"
 )]
-public class SkyworkR1V2<T> : VisionLanguageModelBase<T>, IReasoningVLM<T>
+public partial class SkyworkR1V2<T> : VisionLanguageModelBase<T>, IReasoningVLM<T>
 {
     private readonly SkyworkR1V2Options _options;
 
@@ -419,46 +419,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.ProjectionDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.MaxReasoningTokens);
-        writer.Write(_options.EnableHybridRL);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.ProjectionDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.MaxReasoningTokens = reader.ReadInt32();
-        _options.EnableHybridRL = reader.ReadBoolean();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new SkyworkR1V2<T>(Architecture, mp, _options);
-        return new SkyworkR1V2<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/RemoteSensing/GeoChat.cs b/src/VisionLanguage/RemoteSensing/GeoChat.cs
index 905dbcbd79..a534eb46bb 100644
--- a/src/VisionLanguage/RemoteSensing/GeoChat.cs
+++ b/src/VisionLanguage/RemoteSensing/GeoChat.cs
@@ -60,7 +60,7 @@ namespace AiDotNet.VisionLanguage.RemoteSensing;
     Year = 2024,
     Authors = "Kuckreja et al."
 )]
-public class GeoChat<T> : VisionLanguageModelBase<T>, IRemoteSensingVLM<T>
+public partial class GeoChat<T> : VisionLanguageModelBase<T>, IRemoteSensingVLM<T>
 {
     private readonly GeoChatOptions _options;
 
@@ -264,40 +264,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new GeoChat<T>(Architecture, mp, _options);
-        return new GeoChat<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/RemoteSensing/RSGPT.cs b/src/VisionLanguage/RemoteSensing/RSGPT.cs
index 519e74188b..ec667e7456 100644
--- a/src/VisionLanguage/RemoteSensing/RSGPT.cs
+++ b/src/VisionLanguage/RemoteSensing/RSGPT.cs
@@ -59,7 +59,7 @@ namespace AiDotNet.VisionLanguage.RemoteSensing;
     Year = 2023,
     Authors = "Hu et al."
 )]
-public class RSGPT<T> : VisionLanguageModelBase<T>, IRemoteSensingVLM<T>
+public partial class RSGPT<T> : VisionLanguageModelBase<T>, IRemoteSensingVLM<T>
 {
     private readonly RSGPTOptions _options;
 
@@ -267,40 +267,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new RSGPT<T>(Architecture, mp, _options);
-        return new RSGPT<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/RemoteSensing/SkyEyeGPT.cs b/src/VisionLanguage/RemoteSensing/SkyEyeGPT.cs
index 090aca3dc4..5cc82e6b0b 100644
--- a/src/VisionLanguage/RemoteSensing/SkyEyeGPT.cs
+++ b/src/VisionLanguage/RemoteSensing/SkyEyeGPT.cs
@@ -60,7 +60,7 @@ namespace AiDotNet.VisionLanguage.RemoteSensing;
     Year = 2024,
     Authors = "Zhan et al."
 )]
-public class SkyEyeGPT<T> : VisionLanguageModelBase<T>, IRemoteSensingVLM<T>
+public partial class SkyEyeGPT<T> : VisionLanguageModelBase<T>, IRemoteSensingVLM<T>
 {
     private readonly SkyEyeGPTOptions _options;
 
@@ -265,40 +265,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new SkyEyeGPT<T>(Architecture, mp, _options);
-        return new SkyEyeGPT<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/Robotics/GR00TN1.cs b/src/VisionLanguage/Robotics/GR00TN1.cs
index 21de2367e8..1e66329827 100644
--- a/src/VisionLanguage/Robotics/GR00TN1.cs
+++ b/src/VisionLanguage/Robotics/GR00TN1.cs
@@ -438,99 +438,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return meta;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.ActionDimension);
-        writer.Write(_options.NumJoints);
-        writer.Write(_options.System2LatentDim);
-        writer.Write(_options.System1HiddenDim);
-        writer.Write(_options.System1NumLayers);
-        writer.Write(_options.System1NumHeads);
-        writer.Write(_options.System1ToSystem2Ratio);
-        writer.Write(_options.FlowMatchingSteps);
-
-        // Persist the embedding CONFIGURATION (vocab size; DecoderDim is already written
-        // above) so deserialize can REBUILD _tokenizer + _tokenEmbedding to match the saved
-        // model's geometry before restoring weights — rather than failing to load whenever the
-        // reconstructing instance was created with a different VocabSize. DecoderDim drives the
-        // embedding width; VocabSize drives its row count.
-        writer.Write(_options.VocabSize);
-
-        // The instruction-token embedding lives outside Layers, so the base
-        // per-layer serialization never persists it — without this block a trained
-        // model's embedding table silently reverts to random init on load.
-        var embedParams = _tokenEmbedding.GetParameters();
-        writer.Write(embedParams.Length);
-        for (int i = 0; i < embedParams.Length; i++)
-            writer.Write(Convert.ToDouble(embedParams[i]));
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.ActionDimension = reader.ReadInt32();
-        _options.NumJoints = reader.ReadInt32();
-        _options.System2LatentDim = reader.ReadInt32();
-        _options.System1HiddenDim = reader.ReadInt32();
-        _options.System1NumLayers = reader.ReadInt32();
-        _options.System1NumHeads = reader.ReadInt32();
-        _options.System1ToSystem2Ratio = reader.ReadInt32();
-        _options.FlowMatchingSteps = reader.ReadInt32();
-
-        // Rebuild the tokenizer + token embedding from the just-deserialized configuration
-        // (VocabSize here, DecoderDim read above) BEFORE restoring weights. These are built in
-        // the constructor from the pre-deserialization options, so a model saved with a
-        // different VocabSize/DecoderDim would otherwise mismatch the restored weights. Rebuilding
-        // makes save/load robust to a reconstructing instance created with different options.
-        _options.VocabSize = reader.ReadInt32();
-        _tokenizer = ClipTokenizerFactory.CreateSimple(vocabSize: _options.VocabSize);
-        _tokenEmbedding = new EmbeddingLayer<T>(_options.VocabSize, _options.DecoderDim);
 
-        // Restore the trained instruction-token embedding written by
-        // SerializeNetworkSpecificData (it lives outside Layers, so the base
-        // per-layer restore never touches it).
-        int embedCount = reader.ReadInt32();
-        if (embedCount > 0)
-        {
-            if (embedCount != (int)_tokenEmbedding.ParameterCount)
-                throw new InvalidOperationException(
-                    $"Serialized GR00T-N1 token-embedding parameter count ({embedCount:N0}) does not match "
-                        + $"the embedding rebuilt from the deserialized VocabSize={_options.VocabSize}/"
-                        + $"DecoderDim={_options.DecoderDim} ({_tokenEmbedding.ParameterCount:N0}). The stream is corrupt."
-                );
-            var embedParams = new Vector<T>(embedCount);
-            for (int i = 0; i < embedCount; i++)
-                embedParams[i] = NumOps.FromDouble(reader.ReadDouble());
-            _tokenEmbedding.SetParameters(embedParams);
-        }
-
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new GR00TN1<T>(Architecture, mp, _options);
-        return new GR00TN1<T>(Architecture, _options);
-    }
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/Robotics/Helix.cs b/src/VisionLanguage/Robotics/Helix.cs
index 06c50308ff..99e0e09c96 100644
--- a/src/VisionLanguage/Robotics/Helix.cs
+++ b/src/VisionLanguage/Robotics/Helix.cs
@@ -445,81 +445,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return meta;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.ActionDimension);
-        writer.Write(_options.NumJoints);
-        writer.Write(_options.System2LatentDim);
-        writer.Write(_options.System1HiddenDim);
-        writer.Write(_options.System1NumLayers);
-        writer.Write(_options.System1NumHeads);
-        writer.Write(_options.System1ToSystem2Ratio);
-
-        // The instruction-token embedding lives outside Layers, so the base
-        // per-layer serialization never persists it — without this block a trained
-        // model's embedding table silently reverts to random init on load.
-        var embedParams = _tokenEmbedding.GetParameters();
-        writer.Write(embedParams.Length);
-        for (int i = 0; i < embedParams.Length; i++)
-            writer.Write(Convert.ToDouble(embedParams[i]));
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.ActionDimension = reader.ReadInt32();
-        _options.NumJoints = reader.ReadInt32();
-        _options.System2LatentDim = reader.ReadInt32();
-        _options.System1HiddenDim = reader.ReadInt32();
-        _options.System1NumLayers = reader.ReadInt32();
-        _options.System1NumHeads = reader.ReadInt32();
-        _options.System1ToSystem2Ratio = reader.ReadInt32();
-
-        // Restore the trained instruction-token embedding written by
-        // SerializeNetworkSpecificData (it lives outside Layers, so the base
-        // per-layer restore never touches it).
-        int embedCount = reader.ReadInt32();
-        if (embedCount > 0)
-        {
-            if (embedCount != (int)_tokenEmbedding.ParameterCount)
-                throw new InvalidOperationException(
-                    $"Serialized Helix token-embedding parameter count ({embedCount:N0}) does not match "
-                        + $"this instance's embedding ({_tokenEmbedding.ParameterCount:N0}). The model was saved with "
-                        + "a different VocabSize/DecoderDim configuration."
-                );
-            var embedParams = new Vector<T>(embedCount);
-            for (int i = 0; i < embedCount; i++)
-                embedParams[i] = NumOps.FromDouble(reader.ReadDouble());
-            _tokenEmbedding.SetParameters(embedParams);
-        }
 
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new Helix<T>(Architecture, mp, _options);
-        return new Helix<T>(Architecture, _options);
-    }
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/Robotics/Octo.cs b/src/VisionLanguage/Robotics/Octo.cs
index 6ac0c1deb8..e7d7898944 100644
--- a/src/VisionLanguage/Robotics/Octo.cs
+++ b/src/VisionLanguage/Robotics/Octo.cs
@@ -59,7 +59,7 @@ namespace AiDotNet.VisionLanguage.Robotics;
     Year = 2024,
     Authors = "Ghosh et al."
 )]
-public class Octo<T> : VisionLanguageModelBase<T>, IVisionLanguageAction<T>
+public partial class Octo<T> : VisionLanguageModelBase<T>, IVisionLanguageAction<T>
 {
     private readonly OctoOptions _options;
 
@@ -389,42 +389,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.ActionDimension);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.ActionDimension = reader.ReadInt32();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new Octo<T>(Architecture, mp, _options);
-        return new Octo<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/Robotics/PaLME.cs b/src/VisionLanguage/Robotics/PaLME.cs
index cee9f9849c..1abcdf30ae 100644
--- a/src/VisionLanguage/Robotics/PaLME.cs
+++ b/src/VisionLanguage/Robotics/PaLME.cs
@@ -505,42 +505,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.ActionDimension);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.ActionDimension = reader.ReadInt32();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new PaLME<T>(Architecture, mp, _options);
-        return new PaLME<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/Robotics/PiZero.cs b/src/VisionLanguage/Robotics/PiZero.cs
index 88efbe324d..aec8ad19e0 100644
--- a/src/VisionLanguage/Robotics/PiZero.cs
+++ b/src/VisionLanguage/Robotics/PiZero.cs
@@ -58,7 +58,7 @@ namespace AiDotNet.VisionLanguage.Robotics;
     Year = 2024,
     Authors = "Black et al."
 )]
-public class PiZero<T> : VisionLanguageModelBase<T>, IVisionLanguageAction<T>
+public partial class PiZero<T> : VisionLanguageModelBase<T>, IVisionLanguageAction<T>
 {
     private readonly PiZeroOptions _options;
 
@@ -359,42 +359,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.ActionDimension);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.ActionDimension = reader.ReadInt32();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new PiZero<T>(Architecture, mp, _options);
-        return new PiZero<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/Robotics/RT2.cs b/src/VisionLanguage/Robotics/RT2.cs
index 617911a485..8e119973dd 100644
--- a/src/VisionLanguage/Robotics/RT2.cs
+++ b/src/VisionLanguage/Robotics/RT2.cs
@@ -477,46 +477,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return meta;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.ActionDimension);
-        writer.Write(_options.VocabSize);
-        writer.Write(_options.PredictionHorizon);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.ActionDimension = reader.ReadInt32();
-        _options.VocabSize = reader.ReadInt32();
-        _options.PredictionHorizon = reader.ReadInt32();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new RT2<T>(Architecture, mp, _options);
-        return new RT2<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/Robotics/ThreeDVLA.cs b/src/VisionLanguage/Robotics/ThreeDVLA.cs
index b929f5e06d..a126f682ef 100644
--- a/src/VisionLanguage/Robotics/ThreeDVLA.cs
+++ b/src/VisionLanguage/Robotics/ThreeDVLA.cs
@@ -60,7 +60,7 @@ namespace AiDotNet.VisionLanguage.Robotics;
     Year = 2024,
     Authors = "Zhen et al."
 )]
-public class ThreeDVLA<T> : VisionLanguageModelBase<T>, IVisionLanguageAction<T>
+public partial class ThreeDVLA<T> : VisionLanguageModelBase<T>, IVisionLanguageAction<T>
 {
     private readonly ThreeDVLAOptions _options;
 
@@ -394,42 +394,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.ActionDimension);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.ActionDimension = reader.ReadInt32();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new ThreeDVLA<T>(Architecture, mp, _options);
-        return new ThreeDVLA<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/ThreeD/GPT4Point.cs b/src/VisionLanguage/ThreeD/GPT4Point.cs
index a504c81a2b..2cfa25d485 100644
--- a/src/VisionLanguage/ThreeD/GPT4Point.cs
+++ b/src/VisionLanguage/ThreeD/GPT4Point.cs
@@ -60,7 +60,7 @@ namespace AiDotNet.VisionLanguage.ThreeD;
     Year = 2024,
     Authors = "Qi et al."
 )]
-public class GPT4Point<T> : VisionLanguageModelBase<T>, IThreeDVisionLanguageModel<T>
+public partial class GPT4Point<T> : VisionLanguageModelBase<T>, IThreeDVisionLanguageModel<T>
 {
     private readonly GPT4PointOptions _options;
 
@@ -402,42 +402,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.MaxPoints);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.MaxPoints = reader.ReadInt32();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new GPT4Point<T>(Architecture, mp, _options);
-        return new GPT4Point<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/ThreeD/LEOVL.cs b/src/VisionLanguage/ThreeD/LEOVL.cs
index b783683a90..f4c0eacda2 100644
--- a/src/VisionLanguage/ThreeD/LEOVL.cs
+++ b/src/VisionLanguage/ThreeD/LEOVL.cs
@@ -58,7 +58,7 @@ namespace AiDotNet.VisionLanguage.ThreeD;
     Year = 2024,
     Authors = "Huang et al."
 )]
-public class LEOVL<T> : VisionLanguageModelBase<T>, IThreeDVisionLanguageModel<T>
+public partial class LEOVL<T> : VisionLanguageModelBase<T>, IThreeDVisionLanguageModel<T>
 {
     private readonly LEOVLOptions _options;
 
@@ -412,42 +412,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.MaxPoints);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.MaxPoints = reader.ReadInt32();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new LEOVL<T>(Architecture, mp, _options);
-        return new LEOVL<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/ThreeD/PointLLM.cs b/src/VisionLanguage/ThreeD/PointLLM.cs
index 438a010b2f..0578eea92b 100644
--- a/src/VisionLanguage/ThreeD/PointLLM.cs
+++ b/src/VisionLanguage/ThreeD/PointLLM.cs
@@ -60,7 +60,7 @@ namespace AiDotNet.VisionLanguage.ThreeD;
     Year = 2024,
     Authors = "Xu et al."
 )]
-public class PointLLM<T> : VisionLanguageModelBase<T>, IThreeDVisionLanguageModel<T>
+public partial class PointLLM<T> : VisionLanguageModelBase<T>, IThreeDVisionLanguageModel<T>
 {
     private readonly PointLLMOptions _options;
 
@@ -377,42 +377,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.MaxPoints);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.MaxPoints = reader.ReadInt32();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new PointLLM<T>(Architecture, mp, _options);
-        return new PointLLM<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/ThreeD/SceneLLM.cs b/src/VisionLanguage/ThreeD/SceneLLM.cs
index 5c23931ab7..07e7043554 100644
--- a/src/VisionLanguage/ThreeD/SceneLLM.cs
+++ b/src/VisionLanguage/ThreeD/SceneLLM.cs
@@ -60,7 +60,7 @@ namespace AiDotNet.VisionLanguage.ThreeD;
     Year = 2024,
     Authors = "Fu et al."
 )]
-public class SceneLLM<T> : VisionLanguageModelBase<T>, IThreeDVisionLanguageModel<T>
+public partial class SceneLLM<T> : VisionLanguageModelBase<T>, IThreeDVisionLanguageModel<T>
 {
     private readonly SceneLLMOptions _options;
 
@@ -435,42 +435,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.MaxPoints);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.MaxPoints = reader.ReadInt32();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new SceneLLM<T>(Architecture, mp, _options);
-        return new SceneLLM<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/ThreeD/ThreeDGraphLLM.cs b/src/VisionLanguage/ThreeD/ThreeDGraphLLM.cs
index 58ace722eb..647727b73e 100644
--- a/src/VisionLanguage/ThreeD/ThreeDGraphLLM.cs
+++ b/src/VisionLanguage/ThreeD/ThreeDGraphLLM.cs
@@ -60,7 +60,7 @@ namespace AiDotNet.VisionLanguage.ThreeD;
     Year = 2025,
     Authors = "Rygalev et al."
 )]
-public class ThreeDGraphLLM<T> : VisionLanguageModelBase<T>, IThreeDVisionLanguageModel<T>
+public partial class ThreeDGraphLLM<T> : VisionLanguageModelBase<T>, IThreeDVisionLanguageModel<T>
 {
     private readonly ThreeDGraphLLMOptions _options;
 
@@ -429,42 +429,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.MaxPoints);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.MaxPoints = reader.ReadInt32();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new ThreeDGraphLLM<T>(Architecture, mp, _options);
-        return new ThreeDGraphLLM<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/ThreeD/ThreeDLLM.cs b/src/VisionLanguage/ThreeD/ThreeDLLM.cs
index 00149ccb0c..7dc34a6a59 100644
--- a/src/VisionLanguage/ThreeD/ThreeDLLM.cs
+++ b/src/VisionLanguage/ThreeD/ThreeDLLM.cs
@@ -60,7 +60,7 @@ namespace AiDotNet.VisionLanguage.ThreeD;
     Year = 2023,
     Authors = "Hong et al."
 )]
-public class ThreeDLLM<T> : VisionLanguageModelBase<T>, IThreeDVisionLanguageModel<T>
+public partial class ThreeDLLM<T> : VisionLanguageModelBase<T>, IThreeDVisionLanguageModel<T>
 {
     private readonly ThreeDLLMOptions _options;
 
@@ -388,42 +388,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.MaxPoints);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.MaxPoints = reader.ReadInt32();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new ThreeDLLM<T>(Architecture, mp, _options);
-        return new ThreeDLLM<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/Unified/Chameleon.cs b/src/VisionLanguage/Unified/Chameleon.cs
index 152b063b70..42454cf772 100644
--- a/src/VisionLanguage/Unified/Chameleon.cs
+++ b/src/VisionLanguage/Unified/Chameleon.cs
@@ -59,7 +59,7 @@ namespace AiDotNet.VisionLanguage.Unified;
     Year = 2024,
     Authors = "Meta"
 )]
-public class Chameleon<T> : VisionLanguageModelBase<T>, IUnifiedVisionModel<T>
+public partial class Chameleon<T> : VisionLanguageModelBase<T>, IUnifiedVisionModel<T>
 {
     private readonly ChameleonOptions _options;
 
@@ -419,44 +419,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.SupportsGeneration);
-        writer.Write(_options.OutputImageSize);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.SupportsGeneration = reader.ReadBoolean();
-        _options.OutputImageSize = reader.ReadInt32();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new Chameleon<T>(Architecture, mp, _options);
-        return new Chameleon<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/Unified/Janus.cs b/src/VisionLanguage/Unified/Janus.cs
index f8eab07b7b..abd9503bc2 100644
--- a/src/VisionLanguage/Unified/Janus.cs
+++ b/src/VisionLanguage/Unified/Janus.cs
@@ -61,7 +61,7 @@ namespace AiDotNet.VisionLanguage.Unified;
     Year = 2024,
     Authors = "Wu et al."
 )]
-public class Janus<T> : VisionLanguageModelBase<T>, IUnifiedVisionModel<T>
+public partial class Janus<T> : VisionLanguageModelBase<T>, IUnifiedVisionModel<T>
 {
     private readonly JanusOptions _options;
 
@@ -388,46 +388,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.SupportsGeneration);
-        writer.Write(_options.OutputImageSize);
-        writer.Write(_options.EnableDecoupledEncoding);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.SupportsGeneration = reader.ReadBoolean();
-        _options.OutputImageSize = reader.ReadInt32();
-        _options.EnableDecoupledEncoding = reader.ReadBoolean();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new Janus<T>(Architecture, mp, _options);
-        return new Janus<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/Unified/JanusPro.cs b/src/VisionLanguage/Unified/JanusPro.cs
index e5e838bfb0..087b806dcd 100644
--- a/src/VisionLanguage/Unified/JanusPro.cs
+++ b/src/VisionLanguage/Unified/JanusPro.cs
@@ -1,708 +1,606 @@
-using System.Diagnostics.CodeAnalysis;
-using AiDotNet.ActivationFunctions;
-using AiDotNet.Attributes;
-using AiDotNet.Extensions;
-using AiDotNet.Helpers;
-using AiDotNet.Interfaces;
-using AiDotNet.Models.Options;
-using AiDotNet.NeuralNetworks;
-using AiDotNet.NeuralNetworks.Layers;
-using AiDotNet.Onnx;
-using AiDotNet.Optimizers;
-using AiDotNet.Tokenization;
-using AiDotNet.Tokenization.Interfaces;
-using AiDotNet.VisionLanguage.Interfaces;

+using System.Diagnostics.CodeAnalysis;
+using AiDotNet.ActivationFunctions;
+using AiDotNet.Attributes;
+using AiDotNet.Extensions;
+using AiDotNet.Helpers;
+using AiDotNet.Interfaces;
+using AiDotNet.Models.Options;
+using AiDotNet.NeuralNetworks;
+using AiDotNet.NeuralNetworks.Layers;
+using AiDotNet.Onnx;
+using AiDotNet.Optimizers;
+using AiDotNet.Tokenization;
+using AiDotNet.Tokenization.Interfaces;
+using AiDotNet.VisionLanguage.Interfaces;
+
 using System.Collections.Generic;
-
-namespace AiDotNet.VisionLanguage.Unified;
-
-/// <summary>
-/// Janus-Pro: unified multimodal understanding and generation with decoupled vision encoders
-/// (Chen et al., DeepSeek 2025, arXiv:2501.17811).
-/// </summary>
-/// <typeparam name="T">The numeric type used for calculations.</typeparam>
-/// <remarks>
-/// <para>
-/// Janus-Pro is the scaled-up successor to Janus (Wu et al. 2024, arXiv:2410.13848). Both
-/// models share Janus's central design insight: <b>vision encoding for understanding</b>
-/// (an image-to-language path that feeds SigLIP-style continuous features into the LLM) and
-/// <b>vision encoding for generation</b> (a VQ-VAE codebook that turns the LLM's output
-/// token stream back into pixels) are <i>fully decoupled</i>. The two paths converge only at
-/// the autoregressive transformer backbone in the middle. Janus-Pro adds: a 16384-entry VQ
-/// codebook (vs Janus's 8192), curriculum-based training, expanded synthetic data, and a
-/// 7B-parameter DeepSeek-LLM backbone.
-/// </para>
-/// <para><b>Paper-faithful pieces implemented here:</b></para>
-/// <list type="bullet">
-///   <item>Decoupled vision paths: <see cref="EncodeImage"/> uses the SigLIP-style understanding encoder; <see cref="GenerateImage"/> uses the VQ-VAE generation pipeline. They share NOTHING except the central LLM backbone, matching Janus §3.1.</item>
-///   <item>Janus-Pro 16384-entry VQ codebook via <see cref="JanusVQCodebook{T}"/> (paper Table 1; Janus uses 8192).</item>
-///   <item>Autoregressive VQ-token generation with classifier-free guidance (Ho &amp; Salimans 2022). Conditional and unconditional logits are interpolated by <see cref="CfgScale"/> at each step before greedy decode in the codebook-token window.</item>
-///   <item>VQ-VAE detokenizer: codebook lookup → deconvolutional upsampling stack (4 × 2× upsamples per Razavi et al. 2019 VQ-VAE-2) → 3-channel pixel output.</item>
-///   <item>Unified vocabulary layout: text tokens occupy <c>[0, VocabSize)</c>; VQ codebook tokens occupy <c>[VocabSize, VocabSize + CodebookSize)</c>, so the LLM head can emit either modality natively.</item>
-/// </list>
-/// <para><b>What is NOT verified in-session:</b></para>
-/// <list type="bullet">
-///   <item>Numerical parity against the DeepSeek public Janus-Pro-7B / Janus-Pro-1B checkpoints (weights are HuggingFace-public but loading them requires the full DeepSeek-LLM tokenizer + checkpoint converter beyond this PR's scope).</item>
-///   <item>FID / CLIP-Score image-quality metrics on GenEval / DPG-Bench (paper §4).</item>
-/// </list>
-/// <para><b>For Beginners:</b> Janus-Pro is the first model that does BOTH "understand image, answer
-/// in text" AND "describe in text, generate image" with one unified backbone — but it uses two
-/// completely different vision encoders for each direction, which the paper shows is much better than
-/// trying to share. Default values follow the published 1.5B configuration (scale up via
-/// <see cref="JanusProOptions"/> for the 7B variant).</para>
-/// </remarks>
-/// <example>
-/// <code>
-/// var arch = new NeuralNetworkArchitecture&lt;double&gt;(
-///     inputType: InputType.TwoDimensional,
-///     taskType: NeuralNetworkTaskType.Classification,
-///     inputHeight: 384, inputWidth: 384, inputDepth: 3, outputSize: 4096);
-/// var model = new JanusPro&lt;double&gt;(arch, new JanusProOptions());
-///
-/// // Understanding path
-/// var hidden = model.GenerateFromImage(image, "what do you see?");
-///
-/// // Generation path
-/// var generated = model.GenerateImage("a red apple on a wooden table");
-/// </code>
-/// </example>
-[ModelDomain(ModelDomain.Vision)]
-[ModelDomain(ModelDomain.Language)]
-[ModelDomain(ModelDomain.Multimodal)]
-[ModelCategory(ModelCategory.Transformer)]
-[ModelCategory(ModelCategory.FoundationModel)]
-[ModelTask(ModelTask.Classification)]
-[ModelTask(ModelTask.Generation)]
-[ModelComplexity(ModelComplexity.High)]
-[ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
-[ResearchPaper(
-    "Janus-Pro: Unified Multimodal Understanding and Generation with Data and Model Scaling",
-    "https://arxiv.org/abs/2501.17811",
-    Year = 2025,
-    Authors = "Chen et al."
-)]
-public partial class JanusPro<T> : VisionLanguageModelBase<T>, IUnifiedVisionModel<T>
-{
-    private readonly JanusProOptions _options;
-    private readonly IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer;
-    private readonly ITokenizer _tokenizer;
-
-    // Non-readonly so DeserializeNetworkSpecificData can rebuild it
-    // after NumVisualTokens / CodebookEmbeddingDim are overwritten —
-    // otherwise the codebook stays at the constructor-time
-    // dimensions and a deserialised model has shape mismatches every
-    // time GenerateImage tries to look up an embedding.
-    private JanusVQCodebook<T> _vqCodebook;
-
-    // Learned generation-path modules — replace the previous deterministic
-    // placeholders (sinusoidal prompt fabrication, fixed-cosine codebook
-    // projection, fixed sin/cos pixel decode). Rebuilt in
-    // DeserializeNetworkSpecificData alongside _vqCodebook so a round-tripped
-    // model carries the correct dimensions. Used out-of-band like _vqCodebook
-    // (Chen et al. DeepSeek 2025 §3 — generation uses a learned text embedding,
-    // a learned codebook→decoder projection, and a learned VQ-VAE pixel decoder).
-    private EmbeddingLayer<T> _tokenEmbedding;
-    private DenseLayer<T> _codebookProjection;
-    private DenseLayer<T> _pixelDecoderHidden;
-    private DenseLayer<T> _pixelDecoderOut;
-    private bool _useNativeMode;
-    private bool _disposed;
-    private int _encoderLayerEnd;
-
-    [MemberNotNull(
-        nameof(_tokenEmbedding),
-        nameof(_codebookProjection),
-        nameof(_pixelDecoderHidden),
-        nameof(_pixelDecoderOut)
-    )]
-    private void BuildGenerationModules()
-    {
-        // Typed locals so DenseLayer's IActivationFunction vs IVectorActivationFunction
-        // overloads resolve unambiguously (IdentityActivation implements both).
-        IActivationFunction<T> identity = new IdentityActivation<T>();
-        IActivationFunction<T> relu = new ReLUActivation<T>();
-        _tokenEmbedding = new EmbeddingLayer<T>(_options.VocabSize, _options.DecoderDim);
-        _codebookProjection = new DenseLayer<T>(_options.DecoderDim, identity);
-        // Learnable VQ-VAE pixel decoder applied per codebook-embedding cell:
-        // embedDim -> hidden (ReLU) -> 3 (identity, tanh-bounded at use site).
-        _pixelDecoderHidden = new DenseLayer<T>(_options.CodebookEmbeddingDim, relu);
-        _pixelDecoderOut = new DenseLayer<T>(3, identity);
-    }
-
-    public override ModelOptions GetOptions() => _options;
-
-    /// <summary>Number of generation-side VQ tokens in the output grid (24×24 for 384px output, matching paper §3.3).</summary>
-    public int GenerationTokenCount => _options.NumGenerationTokens;
-
-    /// <summary>Classifier-free guidance scale used during autoregressive image generation. Paper default 7.0 with light annealing.</summary>
-    public double CfgScale => _options.CfgScale;
-
-    /// <summary>VQ codebook used by the generation path. Internal —
-    /// it's a plumbing/helper type, not part of the public facade.
-    /// Test code accesses it via InternalsVisibleTo.</summary>
-    internal JanusVQCodebook<T> VQCodebook => _vqCodebook;
-
-    public JanusPro(
-        NeuralNetworkArchitecture<T> architecture,
-        string modelPath,
-        JanusProOptions? options = null
-    )
-        : base(architecture)
-    {
-        _options = options ?? new JanusProOptions();
-        _useNativeMode = false;
-        base.ImageSize = _options.ImageSize;
-        base.ImageChannels = 3;
-        base.EmbeddingDim = _options.DecoderDim;
-        if (string.IsNullOrWhiteSpace(modelPath))
-            throw new ArgumentException("Model path cannot be null or empty.", nameof(modelPath));
-        if (!File.Exists(modelPath))
-            throw new FileNotFoundException($"ONNX model not found: {modelPath}", modelPath);
-        _options.ModelPath = modelPath;
-        OnnxModel = new OnnxModel<T>(modelPath, _options.OnnxOptions);
-        _tokenizer = ClipTokenizerFactory.CreateSimple(vocabSize: _options.VocabSize);
-        _vqCodebook = new JanusVQCodebook<T>(
-            codebookSize: _options.NumVisualTokens,
-            embeddingDim: _options.CodebookEmbeddingDim
-        );
-        BuildGenerationModules();
-        InitializeLayers();
-    }
-
-    public JanusPro(
-        NeuralNetworkArchitecture<T> architecture,
-        JanusProOptions? options = null,
-        IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? optimizer = null
-    )
-        : base(architecture)
-    {
-        _options = options ?? new JanusProOptions();
-        _useNativeMode = true;
-        _optimizer = optimizer ?? new AdamWOptimizer<T, Tensor<T>, Tensor<T>>(this);
-        base.ImageSize = _options.ImageSize;
-        base.ImageChannels = 3;
-        base.EmbeddingDim = _options.DecoderDim;
-        _tokenizer = ClipTokenizerFactory.CreateSimple(vocabSize: _options.VocabSize);
-        _vqCodebook = new JanusVQCodebook<T>(
-            codebookSize: _options.NumVisualTokens,
-            embeddingDim: _options.CodebookEmbeddingDim
-        );
-        BuildGenerationModules();
-        InitializeLayers();
-    }
-
-    public int EmbeddingDimension => _options.DecoderDim;
-    int IVisualEncoder<T>.ImageSize => _options.ImageSize;
-    int IVisualEncoder<T>.ImageChannels => 3;
-    public int MaxGenerationLength => _options.MaxGenerationLength;
-    public int DecoderEmbeddingDim => _options.DecoderDim;
-    public bool SupportsGeneration => _options.SupportsGeneration;
-
-    /// <summary>
-    /// Janus-Pro <b>understanding</b> path: image → SigLIP-style continuous features → LLM hidden state.
-    /// Per the paper this path NEVER touches the VQ codebook; that is what "decoupled vision encoding"
-    /// means in the Janus name.
-    /// </summary>
-    public Tensor<T> EncodeImage(Tensor<T> image)
-    {
-        ThrowIfDisposed();
-        var preprocessed = PreprocessImage(image);
-        if (IsOnnxMode && OnnxModel is not null)
-            return L2Normalize(OnnxModel.Run(preprocessed));
-        var hidden = preprocessed;
-        for (int i = 0; i < _encoderLayerEnd; i++)
-            hidden = Layers[i].Forward(hidden);
-        return L2Normalize(hidden);
-    }
-
-    /// <summary>
-    /// Image-to-text (understanding) forward pass. Uses the decoupled SigLIP-style encoder per Janus §3.1
-    /// to produce continuous visual features that are concatenated with the prompt embedding and fed to
-    /// the unified LLM backbone.
-    /// </summary>
-    public Tensor<T> GenerateFromImage(Tensor<T> image, string? prompt = null)
-    {
-        ThrowIfDisposed();
-        var preprocessed = PreprocessImage(image);
-        if (IsOnnxMode && OnnxModel is not null)
-            return OnnxModel.Run(preprocessed);
-
-        var visual = preprocessed;
-        for (int i = 0; i < _encoderLayerEnd; i++)
-            visual = Layers[i].Forward(visual);
-
-        var fused = prompt is null
-            ? visual
-            : visual.ConcatenateTensors(EmbedPromptTokens(TokenizeText(prompt)));
-        var output = fused;
-        for (int i = _encoderLayerEnd; i < Layers.Count; i++)
-            output = Layers[i].Forward(output);
-        return output;
-    }
-
-    /// <summary>
-    /// Text-to-image (generation) forward pass. Autoregressively predicts <see cref="GenerationTokenCount"/>
-    /// VQ codebook tokens via classifier-free guidance (Ho &amp; Salimans 2022), looks up their continuous
-    /// codebook embeddings, and decodes the resulting grid to pixels via the VQ-VAE deconvolutional decoder.
-    /// </summary>
-    public Tensor<T> GenerateImage(string textDescription)
-    {
-        ThrowIfDisposed();
-        if (string.IsNullOrWhiteSpace(textDescription))
-            throw new ArgumentException(
-                "Text description cannot be null, empty, or whitespace. "
-                    + "Janus-Pro generation requires a non-empty prompt to condition on.",
-                nameof(textDescription)
-            );
-        // The codebook→decoder projection and the VQ-VAE pixel decoder are now
-        // genuine learnable modules (_codebookProjection / _pixelDecoderHidden /
-        // _pixelDecoderOut), but meaningful image generation still requires the VQ
-        // codebook entries to be loaded — VQCodebook.Lookup throws until then, and
-        // an untrained decoder produces noise. Fail fast in native mode until a real
-        // Janus-Pro checkpoint (codebook + trained generation weights) is loaded;
-        // ONNX mode below uses the bundled ONNX graph and is fine.
-        if (!IsOnnxMode && !_vqCodebook.IsLoaded)
-            throw new InvalidOperationException(
-                "Janus-Pro generation weights are not loaded. The native generation "
-                    + "modules (codebook projection + VQ-VAE pixel decoder) are learnable but "
-                    + "untrained, and the VQ codebook itself must be loaded before GenerateImage "
-                    + "produces paper-faithful output. Either load a published DeepSeek-AI/Janus-Pro "
-                    + "checkpoint, or use the ONNX-mode constructor to delegate to the bundled ONNX graph."
-            );
-        var conditionalTokens = TokenizeText(textDescription);
-        if (IsOnnxMode && OnnxModel is not null)
-            return OnnxModel.Run(conditionalTokens);
-
-        var conditionalEmbed = EmbedPromptTokens(conditionalTokens);
-
-        // Classifier-free guidance: paired conditional + unconditional contexts.
-        var unconditionalEmbed = EmbedPromptTokens(new Tensor<T>([0]));
-
-        int numGenTokens = _options.NumGenerationTokens;
-        var visualTokenIds = new int[numGenTokens];
-
-        var condCtx = conditionalEmbed;
-        var uncondCtx = unconditionalEmbed;
-
-        // 24×24 token grid for the default 384×384 output (paper §3.3 — patch size 16, output 384 → 24×24).
-        for (int t = 0; t < numGenTokens; t++)
-        {
-            var condHidden = condCtx;
-            var uncondHidden = uncondCtx;
-            for (int i = _encoderLayerEnd; i < Layers.Count; i++)
-            {
-                condHidden = Layers[i].Forward(condHidden);
-                uncondHidden = Layers[i].Forward(uncondHidden);
-            }
-
-            int chosenCodebookToken = GreedyCodebookTokenWithCfg(condHidden, uncondHidden);
-            visualTokenIds[t] = chosenCodebookToken;
-
-            var tokenEmbed = _vqCodebook.Lookup(chosenCodebookToken);
-            var projected = ProjectCodebookEmbeddingToDecoderDim(tokenEmbed);
-            condCtx = condCtx.ConcatenateTensors(projected);
-            uncondCtx = uncondCtx.ConcatenateTensors(projected);
-        }
-
-        return DetokenizeVQTokens(visualTokenIds);
-    }
-
-    private int GreedyCodebookTokenWithCfg(
-        Tensor<T> conditionalLogits,
-        Tensor<T> unconditionalLogits
-    )
-    {
-        int codebookStart = _options.VocabSize;
-        int codebookSize = _vqCodebook.CodebookSize;
-        int codebookEnd = Math.Min(conditionalLogits.Length, codebookStart + codebookSize);
-
-        // If the layer stack does not extend to the codebook window (small VocabSize, e.g.
-        // in tests), fall back to the entire output vector as a codebook-proxy.
-        int searchStart = codebookEnd > codebookStart ? codebookStart : 0;
-        int searchEnd =
-            codebookEnd > codebookStart
-                ? codebookEnd
-                : Math.Min(conditionalLogits.Length, codebookSize);
-
-        double cfgScale = _options.CfgScale;
-        int bestId = 0;
-        double bestScore = double.NegativeInfinity;
-        int outOffset = searchStart - (codebookEnd > codebookStart ? codebookStart : 0);
-
-        for (int idx = searchStart; idx < searchEnd; idx++)
-        {
-            double cond = NumOps.ToDouble(conditionalLogits[idx]);
-            double uncond =
-                idx < unconditionalLogits.Length ? NumOps.ToDouble(unconditionalLogits[idx]) : 0.0;
-            double guided = uncond + cfgScale * (cond - uncond);
-            if (guided > bestScore)
-            {
-                bestScore = guided;
-                bestId = idx - searchStart + outOffset;
-            }
-        }
-        return Math.Max(0, Math.Min(codebookSize - 1, bestId));
-    }
-
-    /// <summary>
-    /// Projects a VQ codebook embedding (dimension <see cref="JanusVQCodebook{T}.EmbeddingDim"/>) up to the
-    /// LLM decoder dimension through the learned <see cref="_codebookProjection"/> dense layer. Replaces the
-    /// previous fixed-cosine broadcasting placeholder with a genuine learnable projection (Chen et al.
-    /// DeepSeek 2025, §3 — generated codebook tokens are projected into the decoder stream by a learned map).
-    /// </summary>
-    private Tensor<T> ProjectCodebookEmbeddingToDecoderDim(Tensor<T> codebookEmbed)
-    {
-        return _codebookProjection.Forward(codebookEmbed);
-    }
-
-    /// <summary>
-    /// VQ-VAE detokenizer: token grid → codebook embeddings → deconv upsampling stack → pixels.
-    /// The deconv stack is initialised but un-trained; loading a public Janus-Pro checkpoint replaces
-    /// the projection weights so the output becomes photorealistic.
-    /// </summary>
-    private Tensor<T> DetokenizeVQTokens(int[] visualTokenIds)
-    {
-        int outSize = _options.OutputImageSize;
-        // Floor (not round) the side length so gridSize² ≤ token count — the
-        // token stream may carry trailing tokens that don't complete another
-        // full grid row, and rounding up would demand more tokens than exist.
-        int gridSize = (int)Math.Floor(Math.Sqrt(visualTokenIds.Length));
-        if (gridSize <= 0)
-            gridSize = 24;
-
-        // LookupGrid requires an exact gridSize×gridSize token count, so pass
-        // precisely the leading square block (explicit, not a silent truncation).
-        int gridTokenCount = gridSize * gridSize;
-        int[] gridTokenIds;
-        if (visualTokenIds.Length == gridTokenCount)
-        {
-            gridTokenIds = visualTokenIds;
-        }
-        else
-        {
-            gridTokenIds = new int[gridTokenCount];
-            Array.Copy(
-                visualTokenIds,
-                gridTokenIds,
-                Math.Min(gridTokenCount, visualTokenIds.Length)
-            );
-        }
-
-        // Look up each token's codebook embedding to form an [gridSize, gridSize, embedDim] feature map.
-        int embedDim = _vqCodebook.EmbeddingDim;
-        var embedGrid = _vqCodebook.LookupGrid(gridTokenIds, gridSize, gridSize);
-
-        // Learnable VQ-VAE pixel decoder (Chen et al. DeepSeek 2025; cf. Razavi et al. 2019 VQ-VAE-2):
-        // each grid cell's codebook embedding is decoded to an RGB value by a learned MLP
-        // (embedDim -> hidden(ReLU) -> 3), then nearest-neighbour upsampled across its output patch.
-        // Replaces the previous fixed sin/cos pixel fabrication with genuine learnable weights.
-        int patchSize = outSize / gridSize;
-        if (patchSize < 1)
-            patchSize = 1;
-
-        int outPixels = outSize * outSize * 3;
-        var result = new Tensor<T>([outPixels]);
-
-        for (int gy = 0; gy < gridSize; gy++)
-        {
-            for (int gx = 0; gx < gridSize; gx++)
-            {
-                int gridIdx = gy * gridSize + gx;
-                int baseEmbed = gridIdx * embedDim;
-
-                var cellEmbed = new Tensor<T>([embedDim]);
-                for (int e = 0; e < embedDim; e++)
-                    cellEmbed[e] = embedGrid[baseEmbed + e];
-
-                var rgb = _pixelDecoderOut.Forward(_pixelDecoderHidden.Forward(cellEmbed));
-                // Bound each channel to [0, 1] (image pixel range); tanh keeps gradients well-behaved.
-                double r = 0.5 + 0.5 * Math.Tanh(NumOps.ToDouble(rgb[0]));
-                double g = 0.5 + 0.5 * Math.Tanh(NumOps.ToDouble(rgb[1]));
-                double b = 0.5 + 0.5 * Math.Tanh(NumOps.ToDouble(rgb[2]));
-
-                for (int py = 0; py < patchSize; py++)
-                {
-                    for (int px = 0; px < patchSize; px++)
-                    {
-                        int imgY = gy * patchSize + py;
-                        int imgX = gx * patchSize + px;
-                        if (imgY >= outSize || imgX >= outSize)
-                            continue;
-                        int pixelIdx = (imgY * outSize + imgX) * 3;
-                        if (pixelIdx + 2 >= outPixels)
-                            continue;
-
-                        // Bilinear-style smoothing: 1.0 at patch centre, slightly reduced at edges.
-                        double cx = (px + 0.5) / patchSize - 0.5;
-                        double cy = (py + 0.5) / patchSize - 0.5;
-                        double smooth = 1.0 - 0.15 * (cx * cx + cy * cy);
-
-                        result[pixelIdx] = NumOps.FromDouble(r * smooth);
-                        result[pixelIdx + 1] = NumOps.FromDouble(g * smooth);
-                        result[pixelIdx + 2] = NumOps.FromDouble(b * smooth);
-                    }
-                }
-            }
-        }
-        return result;
-    }
-
-    /// <summary>
-    /// Looks up prompt-token embeddings through the learned <see cref="_tokenEmbedding"/>
-    /// table (Chen et al. DeepSeek 2025, §3). Replaces the previous deterministic
-    /// sinusoidal fabrication that derived sin/cos vectors from token IDs — those
-    /// weren't model-faithful and carried no training signal. Returns an empty-safe
-    /// <c>[DecoderDim]</c> tensor for a zero-length sequence so the conditional/
-    /// unconditional CFG contexts keep valid shapes.
-    /// </summary>
-    private Tensor<T> EmbedPromptTokens(Tensor<T> tokenIds)
-    {
-        if (tokenIds.Length == 0)
-            return new Tensor<T>([_options.DecoderDim]);
-        return _tokenEmbedding.Forward(tokenIds);
-    }
-
-    protected override void InitializeLayers()
-    {
-        if (!_useNativeMode)
-            return;
-        if (Architecture.Layers is not null && Architecture.Layers.Count > 0)
-        {
-            Layers.AddRange(Architecture.Layers);
-            _encoderLayerEnd = Layers.Count / 2;
-            ValidateEncoderDecoderBoundary(_encoderLayerEnd);
-            return;
-        }
-
-        Layers.AddRange(
-            LayerHelper<T>.CreateDefaultUnifiedBidirectionalLayers(
-                visionDim: _options.VisionDim,
-                sharedDim: _options.DecoderDim,
-                understandingDim: _options.DecoderDim,
-                generationDim: _options.DecoderDim,
-                numEncoderLayers: _options.NumVisionLayers,
-                numUnderstandingLayers: _options.NumDecoderLayers / 2,
-                numGenerationLayers: _options.NumDecoderLayers / 2,
-                numHeads: _options.NumHeads,
-                dropoutRate: _options.DropoutRate
-            )
-        );
-
-        // Vocabulary + codebook projection head: text tokens occupy [0, VocabSize), codebook tokens
-        // occupy [VocabSize, VocabSize + NumVisualTokens), so the LLM head can emit either modality.
-        IActivationFunction<T> headActivation = new IdentityActivation<T>();
-        Layers.Add(new LayerNormalizationLayer<T>());
-        Layers.Add(
-            new DenseLayer<T>(_options.VocabSize + _options.NumVisualTokens, headActivation)
-        );
-
-        ComputeEncoderDecoderBoundary();
-        ValidateEncoderDecoderBoundary(_encoderLayerEnd);
-    }
-
-    private void ComputeEncoderDecoderBoundary()
-    {
-        int layersPerBlock = TransformerBlockLayerCount(_options.DropoutRate);
-        _encoderLayerEnd =
-            1
-            + _options.NumVisionLayers * layersPerBlock
-            + (_options.VisionDim != _options.DecoderDim ? 1 : 0);
-    }
-
-    private Tensor<T> TokenizeText(string text)
-    {
-        if (_tokenizer is null)
-            throw new InvalidOperationException("Tokenizer not initialized.");
-        var encoding = _tokenizer.Encode(text);
-        int seqLen = Math.Min(encoding.TokenIds.Count, _options.MaxSequenceLength);
-        var tokens = new Tensor<T>([seqLen]);
-        for (int i = 0; i < seqLen; i++)
-            tokens[i] = NumOps.FromDouble(encoding.TokenIds[i]);
-        return tokens;
-    }
-
-    protected override Tensor<T> PredictCore(Tensor<T> input)
-    {
-        ThrowIfDisposed();
-        if (IsOnnxMode && OnnxModel is not null)
-            return OnnxModel.Run(input);
-        var hidden = input;
-        foreach (var layer in Layers)
-            hidden = layer.Forward(hidden);
-        return hidden;
-    }
-
-    public override void Train(Tensor<T> input, Tensor<T> expected)
-    {
-        if (IsOnnxMode)
-            throw new NotSupportedException("Training is not supported in ONNX mode.");
-        SetTrainingMode(true);
-        TrainWithTape(input, expected, _optimizer);
-        SetTrainingMode(false);
-    }
-
-    /// <summary>
-    /// The learned generation modules in their FIXED flat-parameter/serialization order.
-    /// They live outside <see cref="NeuralNetworkBase{T}.Layers"/> because they serve the
-    /// dedicated generation path (token-ID embedding, codebook projection, pixel decoding)
-    /// and cannot join the sequential Layers walk that Predict runs image tensors through.
-    /// </summary>
-    private ILayer<T>[] GenerationModules() =>
-        new ILayer<T>[]
-        {
-            _tokenEmbedding,
-            _codebookProjection,
-            _pixelDecoderHidden,
-            _pixelDecoderOut,
-        };
-
-    // The layer streams this model holds outside Layers are discovered by ModelParameterGenerator and surfaced automatically; the hand-written hook that used to sit here was an override wearing a different name.
-
-    // UpdateParameters folded one enumeration the base already folds. Removed under AIDN082.
-    protected override Tensor<T> PreprocessImage(Tensor<T> image) =>
-        NormalizeImage(image, _options.ImageMean, _options.ImageStd);
-
-    protected override Tensor<T> PostprocessOutput(Tensor<T> output) => output;
-
-    public override ModelMetadata<T> GetModelMetadata()
-    {
-        var meta = new ModelMetadata<T>
-        {
-            Name = _useNativeMode ? "Janus-Pro-Native" : "Janus-Pro-ONNX",
-            Description =
-                "Janus-Pro: unified multimodal understanding + generation via decoupled vision encoders (Chen et al. DeepSeek 2025, arXiv:2501.17811).",
-            FeatureCount = _options.DecoderDim,
-            Complexity = _options.NumVisionLayers + _options.NumDecoderLayers,
-        };
-        meta.AdditionalInfo["Architecture"] = "Janus-Pro";
-        meta.AdditionalInfo["LanguageModel"] = _options.LanguageModelName;
-        meta.AdditionalInfo["SupportsGeneration"] = _options.SupportsGeneration.ToString();
-        meta.AdditionalInfo["DecoupledEncoding"] = _options.EnableDecoupledEncoding.ToString();
-        meta.AdditionalInfo["VQCodebookSize"] = _vqCodebook.CodebookSize.ToString();
-        meta.AdditionalInfo["VQEmbeddingDim"] = _vqCodebook.EmbeddingDim.ToString();
-        meta.AdditionalInfo["GenerationTokens"] = _options.NumGenerationTokens.ToString();
-        meta.AdditionalInfo["CfgScale"] = _options.CfgScale.ToString();
-        return meta;
-    }
-
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.SupportsGeneration);
-        writer.Write(_options.OutputImageSize);
-        writer.Write(_options.EnableDecoupledEncoding);
-        writer.Write(_options.NumVisualTokens);
-        writer.Write(_options.NumGenerationTokens);
-        writer.Write(_options.CodebookEmbeddingDim);
-        writer.Write(_options.CfgScale);
-
-        // The learned generation modules live outside Layers, so the base per-layer
-        // serialization never persists them — without this block a trained model's
-        // generation path silently reverts to random init on load (the modules are
-        // rebuilt fresh in DeserializeNetworkSpecificData). Written per-module
-        // (count + values) in GenerationModules() order; lazily-uninitialized dense
-        // modules write count 0 and are restored as still-lazy.
-        foreach (var module in GenerationModules())
-        {
-            var p = module.GetParameters();
-            writer.Write(p.Length);
-            for (int i = 0; i < p.Length; i++)
-                writer.Write(Convert.ToDouble(p[i]));
-        }
-    }
-
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.SupportsGeneration = reader.ReadBoolean();
-        _options.OutputImageSize = reader.ReadInt32();
-        _options.EnableDecoupledEncoding = reader.ReadBoolean();
-        _options.NumVisualTokens = reader.ReadInt32();
-        _options.NumGenerationTokens = reader.ReadInt32();
-        _options.CodebookEmbeddingDim = reader.ReadInt32();
-        _options.CfgScale = reader.ReadDouble();
-        // Rebuild _vqCodebook against the just-deserialized dimensions —
-        // otherwise the constructor-time instance keeps its original
-        // codebookSize/embeddingDim and every subsequent Lookup throws
-        // (or worse, silently mis-indexes if the dims overlap). Codebook
-        // entries themselves are NOT serialized here, so consumers
-        // needing a fully usable model must follow this with a
-        // checkpoint load via VQCodebook.LoadCodebook(...).
-        _vqCodebook = new JanusVQCodebook<T>(
-            codebookSize: _options.NumVisualTokens,
-            embeddingDim: _options.CodebookEmbeddingDim
-        );
-        // Rebuild the learned generation modules against the just-deserialized
-        // dimensions (same rationale as _vqCodebook above), then restore their
-        // TRAINED parameters written by SerializeNetworkSpecificData — without
-        // this the rebuild left them at fresh random init, losing the trained
-        // generation path on every save/load round-trip.
-        BuildGenerationModules();
-        foreach (var module in GenerationModules())
-        {
-            int count = reader.ReadInt32();
-            if (count <= 0)
-                continue;
-            // Validate the serialized count against the freshly-rebuilt module before reading
-            // `count` doubles off the stream. A non-lazy module (ParameterCount already > 0 after
-            // BuildGenerationModules) whose stored count differs means the saved model's
-            // generation-module geometry no longer matches this build's — restoring it would
-            // either throw deep inside SetParameters or silently mis-shape the module. Fail fast
-            // with both counts (mirrors Helix's embedCount validation). Lazy modules
-            // (ParameterCount == 0 until first forward) legitimately resolve their shape from the
-            // vector length per the #1221 save/load contract, so they skip this check.
-            long expected = module.ParameterCount;
-            if (expected > 0 && count != expected)
-                throw new InvalidOperationException(
-                    $"JanusPro generation-module parameter count mismatch on deserialize: stream has "
-                        + $"{count} but the rebuilt {module.GetType().Name} expects {expected}. The saved "
-                        + $"model's generation-module configuration is incompatible with this build."
-                );
-            var p = new Vector<T>(count);
-            for (int i = 0; i < count; i++)
-                p[i] = NumOps.FromDouble(reader.ReadDouble());
-            // DenseLayer.SetParameters resolves lazy shapes from the vector length
-            // (the #1221 save/load contract), so still-lazy modules restore too.
-            module.SetParameters(p);
-        }
-        if (!_useNativeMode && _options.ModelPath is { } p2 && !string.IsNullOrEmpty(p2))
-            OnnxModel = new OnnxModel<T>(p2, _options.OnnxOptions);
-    }
-
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new JanusPro<T>(Architecture, mp, _options);
-        return new JanusPro<T>(Architecture, _options);
-    }
-
-    private void ThrowIfDisposed()
-    {
-        if (_disposed)
-            throw new ObjectDisposedException(GetType().FullName ?? nameof(JanusPro<T>));
-    }
-
-    protected override void Dispose(bool disposing)
-    {
-        if (_disposed)
-            return;
-        _disposed = true;
-        base.Dispose(disposing);
-    }
-}
+
+namespace AiDotNet.VisionLanguage.Unified;
+
+/// <summary>
+/// Janus-Pro: unified multimodal understanding and generation with decoupled vision encoders
+/// (Chen et al., DeepSeek 2025, arXiv:2501.17811).
+/// </summary>
+/// <typeparam name="T">The numeric type used for calculations.</typeparam>
+/// <remarks>
+/// <para>
+/// Janus-Pro is the scaled-up successor to Janus (Wu et al. 2024, arXiv:2410.13848). Both
+/// models share Janus's central design insight: <b>vision encoding for understanding</b>
+/// (an image-to-language path that feeds SigLIP-style continuous features into the LLM) and
+/// <b>vision encoding for generation</b> (a VQ-VAE codebook that turns the LLM's output
+/// token stream back into pixels) are <i>fully decoupled</i>. The two paths converge only at
+/// the autoregressive transformer backbone in the middle. Janus-Pro adds: a 16384-entry VQ
+/// codebook (vs Janus's 8192), curriculum-based training, expanded synthetic data, and a
+/// 7B-parameter DeepSeek-LLM backbone.
+/// </para>
+/// <para><b>Paper-faithful pieces implemented here:</b></para>
+/// <list type="bullet">
+///   <item>Decoupled vision paths: <see cref="EncodeImage"/> uses the SigLIP-style understanding encoder; <see cref="GenerateImage"/> uses the VQ-VAE generation pipeline. They share NOTHING except the central LLM backbone, matching Janus §3.1.</item>
+///   <item>Janus-Pro 16384-entry VQ codebook via <see cref="JanusVQCodebook{T}"/> (paper Table 1; Janus uses 8192).</item>
+///   <item>Autoregressive VQ-token generation with classifier-free guidance (Ho &amp; Salimans 2022). Conditional and unconditional logits are interpolated by <see cref="CfgScale"/> at each step before greedy decode in the codebook-token window.</item>
+///   <item>VQ-VAE detokenizer: codebook lookup → deconvolutional upsampling stack (4 × 2× upsamples per Razavi et al. 2019 VQ-VAE-2) → 3-channel pixel output.</item>
+///   <item>Unified vocabulary layout: text tokens occupy <c>[0, VocabSize)</c>; VQ codebook tokens occupy <c>[VocabSize, VocabSize + CodebookSize)</c>, so the LLM head can emit either modality natively.</item>
+/// </list>
+/// <para><b>What is NOT verified in-session:</b></para>
+/// <list type="bullet">
+///   <item>Numerical parity against the DeepSeek public Janus-Pro-7B / Janus-Pro-1B checkpoints (weights are HuggingFace-public but loading them requires the full DeepSeek-LLM tokenizer + checkpoint converter beyond this PR's scope).</item>
+///   <item>FID / CLIP-Score image-quality metrics on GenEval / DPG-Bench (paper §4).</item>
+/// </list>
+/// <para><b>For Beginners:</b> Janus-Pro is the first model that does BOTH "understand image, answer
+/// in text" AND "describe in text, generate image" with one unified backbone — but it uses two
+/// completely different vision encoders for each direction, which the paper shows is much better than
+/// trying to share. Default values follow the published 1.5B configuration (scale up via
+/// <see cref="JanusProOptions"/> for the 7B variant).</para>
+/// </remarks>
+/// <example>
+/// <code>
+/// var arch = new NeuralNetworkArchitecture&lt;double&gt;(
+///     inputType: InputType.TwoDimensional,
+///     taskType: NeuralNetworkTaskType.Classification,
+///     inputHeight: 384, inputWidth: 384, inputDepth: 3, outputSize: 4096);
+/// var model = new JanusPro&lt;double&gt;(arch, new JanusProOptions());
+///
+/// // Understanding path
+/// var hidden = model.GenerateFromImage(image, "what do you see?");
+///
+/// // Generation path
+/// var generated = model.GenerateImage("a red apple on a wooden table");
+/// </code>
+/// </example>
+[ModelDomain(ModelDomain.Vision)]
+[ModelDomain(ModelDomain.Language)]
+[ModelDomain(ModelDomain.Multimodal)]
+[ModelCategory(ModelCategory.Transformer)]
+[ModelCategory(ModelCategory.FoundationModel)]
+[ModelTask(ModelTask.Classification)]
+[ModelTask(ModelTask.Generation)]
+[ModelComplexity(ModelComplexity.High)]
+[ModelInput(typeof(Tensor<>), typeof(Tensor<>))]
+[ResearchPaper(
+    "Janus-Pro: Unified Multimodal Understanding and Generation with Data and Model Scaling",
+    "https://arxiv.org/abs/2501.17811",
+    Year = 2025,
+    Authors = "Chen et al."
+)]
+public partial class JanusPro<T> : VisionLanguageModelBase<T>, IUnifiedVisionModel<T>
+{
+    private readonly JanusProOptions _options;
+    private readonly IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? _optimizer;
+    private readonly ITokenizer _tokenizer;
+
+    // Non-readonly so DeserializeNetworkSpecificData can rebuild it
+    // after NumVisualTokens / CodebookEmbeddingDim are overwritten —
+    // otherwise the codebook stays at the constructor-time
+    // dimensions and a deserialised model has shape mismatches every
+    // time GenerateImage tries to look up an embedding.
+    private JanusVQCodebook<T> _vqCodebook;
+
+    // Learned generation-path modules — replace the previous deterministic
+    // placeholders (sinusoidal prompt fabrication, fixed-cosine codebook
+    // projection, fixed sin/cos pixel decode). Rebuilt in
+    // DeserializeNetworkSpecificData alongside _vqCodebook so a round-tripped
+    // model carries the correct dimensions. Used out-of-band like _vqCodebook
+    // (Chen et al. DeepSeek 2025 §3 — generation uses a learned text embedding,
+    // a learned codebook→decoder projection, and a learned VQ-VAE pixel decoder).
+    private EmbeddingLayer<T> _tokenEmbedding;
+    private DenseLayer<T> _codebookProjection;
+    private DenseLayer<T> _pixelDecoderHidden;
+    private DenseLayer<T> _pixelDecoderOut;
+    private bool _useNativeMode;
+    private bool _disposed;
+    private int _encoderLayerEnd;
+
+    [MemberNotNull(
+        nameof(_tokenEmbedding),
+        nameof(_codebookProjection),
+        nameof(_pixelDecoderHidden),
+        nameof(_pixelDecoderOut)
+    )]
+    private void BuildGenerationModules()
+    {
+        // Typed locals so DenseLayer's IActivationFunction vs IVectorActivationFunction
+        // overloads resolve unambiguously (IdentityActivation implements both).
+        IActivationFunction<T> identity = new IdentityActivation<T>();
+        IActivationFunction<T> relu = new ReLUActivation<T>();
+        _tokenEmbedding = new EmbeddingLayer<T>(_options.VocabSize, _options.DecoderDim);
+        _codebookProjection = new DenseLayer<T>(_options.DecoderDim, identity);
+        // Learnable VQ-VAE pixel decoder applied per codebook-embedding cell:
+        // embedDim -> hidden (ReLU) -> 3 (identity, tanh-bounded at use site).
+        _pixelDecoderHidden = new DenseLayer<T>(_options.CodebookEmbeddingDim, relu);
+        _pixelDecoderOut = new DenseLayer<T>(3, identity);
+    }
+
+    public override ModelOptions GetOptions() => _options;
+
+    /// <summary>Number of generation-side VQ tokens in the output grid (24×24 for 384px output, matching paper §3.3).</summary>
+    public int GenerationTokenCount => _options.NumGenerationTokens;
+
+    /// <summary>Classifier-free guidance scale used during autoregressive image generation. Paper default 7.0 with light annealing.</summary>
+    public double CfgScale => _options.CfgScale;
+
+    /// <summary>VQ codebook used by the generation path. Internal —
+    /// it's a plumbing/helper type, not part of the public facade.
+    /// Test code accesses it via InternalsVisibleTo.</summary>
+    internal JanusVQCodebook<T> VQCodebook => _vqCodebook;
+
+    public JanusPro(
+        NeuralNetworkArchitecture<T> architecture,
+        string modelPath,
+        JanusProOptions? options = null
+    )
+        : base(architecture)
+    {
+        _options = options ?? new JanusProOptions();
+        _useNativeMode = false;
+        base.ImageSize = _options.ImageSize;
+        base.ImageChannels = 3;
+        base.EmbeddingDim = _options.DecoderDim;
+        if (string.IsNullOrWhiteSpace(modelPath))
+            throw new ArgumentException("Model path cannot be null or empty.", nameof(modelPath));
+        if (!File.Exists(modelPath))
+            throw new FileNotFoundException($"ONNX model not found: {modelPath}", modelPath);
+        _options.ModelPath = modelPath;
+        OnnxModel = new OnnxModel<T>(modelPath, _options.OnnxOptions);
+        _tokenizer = ClipTokenizerFactory.CreateSimple(vocabSize: _options.VocabSize);
+        _vqCodebook = new JanusVQCodebook<T>(
+            codebookSize: _options.NumVisualTokens,
+            embeddingDim: _options.CodebookEmbeddingDim
+        );
+        BuildGenerationModules();
+        InitializeLayers();
+    }
+
+    public JanusPro(
+        NeuralNetworkArchitecture<T> architecture,
+        JanusProOptions? options = null,
+        IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? optimizer = null
+    )
+        : base(architecture)
+    {
+        _options = options ?? new JanusProOptions();
+        _useNativeMode = true;
+        _optimizer = optimizer ?? new AdamWOptimizer<T, Tensor<T>, Tensor<T>>(this);
+        base.ImageSize = _options.ImageSize;
+        base.ImageChannels = 3;
+        base.EmbeddingDim = _options.DecoderDim;
+        _tokenizer = ClipTokenizerFactory.CreateSimple(vocabSize: _options.VocabSize);
+        _vqCodebook = new JanusVQCodebook<T>(
+            codebookSize: _options.NumVisualTokens,
+            embeddingDim: _options.CodebookEmbeddingDim
+        );
+        BuildGenerationModules();
+        InitializeLayers();
+    }
+
+    public int EmbeddingDimension => _options.DecoderDim;
+    int IVisualEncoder<T>.ImageSize => _options.ImageSize;
+    int IVisualEncoder<T>.ImageChannels => 3;
+    public int MaxGenerationLength => _options.MaxGenerationLength;
+    public int DecoderEmbeddingDim => _options.DecoderDim;
+    public bool SupportsGeneration => _options.SupportsGeneration;
+
+    /// <summary>
+    /// Janus-Pro <b>understanding</b> path: image → SigLIP-style continuous features → LLM hidden state.
+    /// Per the paper this path NEVER touches the VQ codebook; that is what "decoupled vision encoding"
+    /// means in the Janus name.
+    /// </summary>
+    public Tensor<T> EncodeImage(Tensor<T> image)
+    {
+        ThrowIfDisposed();
+        var preprocessed = PreprocessImage(image);
+        if (IsOnnxMode && OnnxModel is not null)
+            return L2Normalize(OnnxModel.Run(preprocessed));
+        var hidden = preprocessed;
+        for (int i = 0; i < _encoderLayerEnd; i++)
+            hidden = Layers[i].Forward(hidden);
+        return L2Normalize(hidden);
+    }
+
+    /// <summary>
+    /// Image-to-text (understanding) forward pass. Uses the decoupled SigLIP-style encoder per Janus §3.1
+    /// to produce continuous visual features that are concatenated with the prompt embedding and fed to
+    /// the unified LLM backbone.
+    /// </summary>
+    public Tensor<T> GenerateFromImage(Tensor<T> image, string? prompt = null)
+    {
+        ThrowIfDisposed();
+        var preprocessed = PreprocessImage(image);
+        if (IsOnnxMode && OnnxModel is not null)
+            return OnnxModel.Run(preprocessed);
+
+        var visual = preprocessed;
+        for (int i = 0; i < _encoderLayerEnd; i++)
+            visual = Layers[i].Forward(visual);
+
+        var fused = prompt is null
+            ? visual
+            : visual.ConcatenateTensors(EmbedPromptTokens(TokenizeText(prompt)));
+        var output = fused;
+        for (int i = _encoderLayerEnd; i < Layers.Count; i++)
+            output = Layers[i].Forward(output);
+        return output;
+    }
+
+    /// <summary>
+    /// Text-to-image (generation) forward pass. Autoregressively predicts <see cref="GenerationTokenCount"/>
+    /// VQ codebook tokens via classifier-free guidance (Ho &amp; Salimans 2022), looks up their continuous
+    /// codebook embeddings, and decodes the resulting grid to pixels via the VQ-VAE deconvolutional decoder.
+    /// </summary>
+    public Tensor<T> GenerateImage(string textDescription)
+    {
+        ThrowIfDisposed();
+        if (string.IsNullOrWhiteSpace(textDescription))
+            throw new ArgumentException(
+                "Text description cannot be null, empty, or whitespace. "
+                    + "Janus-Pro generation requires a non-empty prompt to condition on.",
+                nameof(textDescription)
+            );
+        // The codebook→decoder projection and the VQ-VAE pixel decoder are now
+        // genuine learnable modules (_codebookProjection / _pixelDecoderHidden /
+        // _pixelDecoderOut), but meaningful image generation still requires the VQ
+        // codebook entries to be loaded — VQCodebook.Lookup throws until then, and
+        // an untrained decoder produces noise. Fail fast in native mode until a real
+        // Janus-Pro checkpoint (codebook + trained generation weights) is loaded;
+        // ONNX mode below uses the bundled ONNX graph and is fine.
+        if (!IsOnnxMode && !_vqCodebook.IsLoaded)
+            throw new InvalidOperationException(
+                "Janus-Pro generation weights are not loaded. The native generation "
+                    + "modules (codebook projection + VQ-VAE pixel decoder) are learnable but "
+                    + "untrained, and the VQ codebook itself must be loaded before GenerateImage "
+                    + "produces paper-faithful output. Either load a published DeepSeek-AI/Janus-Pro "
+                    + "checkpoint, or use the ONNX-mode constructor to delegate to the bundled ONNX graph."
+            );
+        var conditionalTokens = TokenizeText(textDescription);
+        if (IsOnnxMode && OnnxModel is not null)
+            return OnnxModel.Run(conditionalTokens);
+
+        var conditionalEmbed = EmbedPromptTokens(conditionalTokens);
+
+        // Classifier-free guidance: paired conditional + unconditional contexts.
+        var unconditionalEmbed = EmbedPromptTokens(new Tensor<T>([0]));
+
+        int numGenTokens = _options.NumGenerationTokens;
+        var visualTokenIds = new int[numGenTokens];
+
+        var condCtx = conditionalEmbed;
+        var uncondCtx = unconditionalEmbed;
+
+        // 24×24 token grid for the default 384×384 output (paper §3.3 — patch size 16, output 384 → 24×24).
+        for (int t = 0; t < numGenTokens; t++)
+        {
+            var condHidden = condCtx;
+            var uncondHidden = uncondCtx;
+            for (int i = _encoderLayerEnd; i < Layers.Count; i++)
+            {
+                condHidden = Layers[i].Forward(condHidden);
+                uncondHidden = Layers[i].Forward(uncondHidden);
+            }
+
+            int chosenCodebookToken = GreedyCodebookTokenWithCfg(condHidden, uncondHidden);
+            visualTokenIds[t] = chosenCodebookToken;
+
+            var tokenEmbed = _vqCodebook.Lookup(chosenCodebookToken);
+            var projected = ProjectCodebookEmbeddingToDecoderDim(tokenEmbed);
+            condCtx = condCtx.ConcatenateTensors(projected);
+            uncondCtx = uncondCtx.ConcatenateTensors(projected);
+        }
+
+        return DetokenizeVQTokens(visualTokenIds);
+    }
+
+    private int GreedyCodebookTokenWithCfg(
+        Tensor<T> conditionalLogits,
+        Tensor<T> unconditionalLogits
+    )
+    {
+        int codebookStart = _options.VocabSize;
+        int codebookSize = _vqCodebook.CodebookSize;
+        int codebookEnd = Math.Min(conditionalLogits.Length, codebookStart + codebookSize);
+
+        // If the layer stack does not extend to the codebook window (small VocabSize, e.g.
+        // in tests), fall back to the entire output vector as a codebook-proxy.
+        int searchStart = codebookEnd > codebookStart ? codebookStart : 0;
+        int searchEnd =
+            codebookEnd > codebookStart
+                ? codebookEnd
+                : Math.Min(conditionalLogits.Length, codebookSize);
+
+        double cfgScale = _options.CfgScale;
+        int bestId = 0;
+        double bestScore = double.NegativeInfinity;
+        int outOffset = searchStart - (codebookEnd > codebookStart ? codebookStart : 0);
+
+        for (int idx = searchStart; idx < searchEnd; idx++)
+        {
+            double cond = NumOps.ToDouble(conditionalLogits[idx]);
+            double uncond =
+                idx < unconditionalLogits.Length ? NumOps.ToDouble(unconditionalLogits[idx]) : 0.0;
+            double guided = uncond + cfgScale * (cond - uncond);
+            if (guided > bestScore)
+            {
+                bestScore = guided;
+                bestId = idx - searchStart + outOffset;
+            }
+        }
+        return Math.Max(0, Math.Min(codebookSize - 1, bestId));
+    }
+
+    /// <summary>
+    /// Projects a VQ codebook embedding (dimension <see cref="JanusVQCodebook{T}.EmbeddingDim"/>) up to the
+    /// LLM decoder dimension through the learned <see cref="_codebookProjection"/> dense layer. Replaces the
+    /// previous fixed-cosine broadcasting placeholder with a genuine learnable projection (Chen et al.
+    /// DeepSeek 2025, §3 — generated codebook tokens are projected into the decoder stream by a learned map).
+    /// </summary>
+    private Tensor<T> ProjectCodebookEmbeddingToDecoderDim(Tensor<T> codebookEmbed)
+    {
+        return _codebookProjection.Forward(codebookEmbed);
+    }
+
+    /// <summary>
+    /// VQ-VAE detokenizer: token grid → codebook embeddings → deconv upsampling stack → pixels.
+    /// The deconv stack is initialised but un-trained; loading a public Janus-Pro checkpoint replaces
+    /// the projection weights so the output becomes photorealistic.
+    /// </summary>
+    private Tensor<T> DetokenizeVQTokens(int[] visualTokenIds)
+    {
+        int outSize = _options.OutputImageSize;
+        // Floor (not round) the side length so gridSize² ≤ token count — the
+        // token stream may carry trailing tokens that don't complete another
+        // full grid row, and rounding up would demand more tokens than exist.
+        int gridSize = (int)Math.Floor(Math.Sqrt(visualTokenIds.Length));
+        if (gridSize <= 0)
+            gridSize = 24;
+
+        // LookupGrid requires an exact gridSize×gridSize token count, so pass
+        // precisely the leading square block (explicit, not a silent truncation).
+        int gridTokenCount = gridSize * gridSize;
+        int[] gridTokenIds;
+        if (visualTokenIds.Length == gridTokenCount)
+        {
+            gridTokenIds = visualTokenIds;
+        }
+        else
+        {
+            gridTokenIds = new int[gridTokenCount];
+            Array.Copy(
+                visualTokenIds,
+                gridTokenIds,
+                Math.Min(gridTokenCount, visualTokenIds.Length)
+            );
+        }
+
+        // Look up each token's codebook embedding to form an [gridSize, gridSize, embedDim] feature map.
+        int embedDim = _vqCodebook.EmbeddingDim;
+        var embedGrid = _vqCodebook.LookupGrid(gridTokenIds, gridSize, gridSize);
+
+        // Learnable VQ-VAE pixel decoder (Chen et al. DeepSeek 2025; cf. Razavi et al. 2019 VQ-VAE-2):
+        // each grid cell's codebook embedding is decoded to an RGB value by a learned MLP
+        // (embedDim -> hidden(ReLU) -> 3), then nearest-neighbour upsampled across its output patch.
+        // Replaces the previous fixed sin/cos pixel fabrication with genuine learnable weights.
+        int patchSize = outSize / gridSize;
+        if (patchSize < 1)
+            patchSize = 1;
+
+        int outPixels = outSize * outSize * 3;
+        var result = new Tensor<T>([outPixels]);
+
+        for (int gy = 0; gy < gridSize; gy++)
+        {
+            for (int gx = 0; gx < gridSize; gx++)
+            {
+                int gridIdx = gy * gridSize + gx;
+                int baseEmbed = gridIdx * embedDim;
+
+                var cellEmbed = new Tensor<T>([embedDim]);
+                for (int e = 0; e < embedDim; e++)
+                    cellEmbed[e] = embedGrid[baseEmbed + e];
+
+                var rgb = _pixelDecoderOut.Forward(_pixelDecoderHidden.Forward(cellEmbed));
+                // Bound each channel to [0, 1] (image pixel range); tanh keeps gradients well-behaved.
+                double r = 0.5 + 0.5 * Math.Tanh(NumOps.ToDouble(rgb[0]));
+                double g = 0.5 + 0.5 * Math.Tanh(NumOps.ToDouble(rgb[1]));
+                double b = 0.5 + 0.5 * Math.Tanh(NumOps.ToDouble(rgb[2]));
+
+                for (int py = 0; py < patchSize; py++)
+                {
+                    for (int px = 0; px < patchSize; px++)
+                    {
+                        int imgY = gy * patchSize + py;
+                        int imgX = gx * patchSize + px;
+                        if (imgY >= outSize || imgX >= outSize)
+                            continue;
+                        int pixelIdx = (imgY * outSize + imgX) * 3;
+                        if (pixelIdx + 2 >= outPixels)
+                            continue;
+
+                        // Bilinear-style smoothing: 1.0 at patch centre, slightly reduced at edges.
+                        double cx = (px + 0.5) / patchSize - 0.5;
+                        double cy = (py + 0.5) / patchSize - 0.5;
+                        double smooth = 1.0 - 0.15 * (cx * cx + cy * cy);
+
+                        result[pixelIdx] = NumOps.FromDouble(r * smooth);
+                        result[pixelIdx + 1] = NumOps.FromDouble(g * smooth);
+                        result[pixelIdx + 2] = NumOps.FromDouble(b * smooth);
+                    }
+                }
+            }
+        }
+        return result;
+    }
+
+    /// <summary>
+    /// Looks up prompt-token embeddings through the learned <see cref="_tokenEmbedding"/>
+    /// table (Chen et al. DeepSeek 2025, §3). Replaces the previous deterministic
+    /// sinusoidal fabrication that derived sin/cos vectors from token IDs — those
+    /// weren't model-faithful and carried no training signal. Returns an empty-safe
+    /// <c>[DecoderDim]</c> tensor for a zero-length sequence so the conditional/
+    /// unconditional CFG contexts keep valid shapes.
+    /// </summary>
+    private Tensor<T> EmbedPromptTokens(Tensor<T> tokenIds)
+    {
+        if (tokenIds.Length == 0)
+            return new Tensor<T>([_options.DecoderDim]);
+        return _tokenEmbedding.Forward(tokenIds);
+    }
+
+    protected override void InitializeLayers()
+    {
+        if (!_useNativeMode)
+            return;
+        if (Architecture.Layers is not null && Architecture.Layers.Count > 0)
+        {
+            Layers.AddRange(Architecture.Layers);
+            _encoderLayerEnd = Layers.Count / 2;
+            ValidateEncoderDecoderBoundary(_encoderLayerEnd);
+            return;
+        }
+
+        Layers.AddRange(
+            LayerHelper<T>.CreateDefaultUnifiedBidirectionalLayers(
+                visionDim: _options.VisionDim,
+                sharedDim: _options.DecoderDim,
+                understandingDim: _options.DecoderDim,
+                generationDim: _options.DecoderDim,
+                numEncoderLayers: _options.NumVisionLayers,
+                numUnderstandingLayers: _options.NumDecoderLayers / 2,
+                numGenerationLayers: _options.NumDecoderLayers / 2,
+                numHeads: _options.NumHeads,
+                dropoutRate: _options.DropoutRate
+            )
+        );
+
+        // Vocabulary + codebook projection head: text tokens occupy [0, VocabSize), codebook tokens
+        // occupy [VocabSize, VocabSize + NumVisualTokens), so the LLM head can emit either modality.
+        IActivationFunction<T> headActivation = new IdentityActivation<T>();
+        Layers.Add(new LayerNormalizationLayer<T>());
+        Layers.Add(
+            new DenseLayer<T>(_options.VocabSize + _options.NumVisualTokens, headActivation)
+        );
+
+        ComputeEncoderDecoderBoundary();
+        ValidateEncoderDecoderBoundary(_encoderLayerEnd);
+    }
+
+    private void ComputeEncoderDecoderBoundary()
+    {
+        int layersPerBlock = TransformerBlockLayerCount(_options.DropoutRate);
+        _encoderLayerEnd =
+            1
+            + _options.NumVisionLayers * layersPerBlock
+            + (_options.VisionDim != _options.DecoderDim ? 1 : 0);
+    }
+
+    private Tensor<T> TokenizeText(string text)
+    {
+        if (_tokenizer is null)
+            throw new InvalidOperationException("Tokenizer not initialized.");
+        var encoding = _tokenizer.Encode(text);
+        int seqLen = Math.Min(encoding.TokenIds.Count, _options.MaxSequenceLength);
+        var tokens = new Tensor<T>([seqLen]);
+        for (int i = 0; i < seqLen; i++)
+            tokens[i] = NumOps.FromDouble(encoding.TokenIds[i]);
+        return tokens;
+    }
+
+    protected override Tensor<T> PredictCore(Tensor<T> input)
+    {
+        ThrowIfDisposed();
+        if (IsOnnxMode && OnnxModel is not null)
+            return OnnxModel.Run(input);
+        var hidden = input;
+        foreach (var layer in Layers)
+            hidden = layer.Forward(hidden);
+        return hidden;
+    }
+
+    public override void Train(Tensor<T> input, Tensor<T> expected)
+    {
+        if (IsOnnxMode)
+            throw new NotSupportedException("Training is not supported in ONNX mode.");
+        SetTrainingMode(true);
+        TrainWithTape(input, expected, _optimizer);
+        SetTrainingMode(false);
+    }
+
+    /// <summary>
+    /// The learned generation modules in their FIXED flat-parameter/serialization order.
+    /// They live outside <see cref="NeuralNetworkBase{T}.Layers"/> because they serve the
+    /// dedicated generation path (token-ID embedding, codebook projection, pixel decoding)
+    /// and cannot join the sequential Layers walk that Predict runs image tensors through.
+    /// </summary>
+    private ILayer<T>[] GenerationModules() =>
+        new ILayer<T>[]
+        {
+            _tokenEmbedding,
+            _codebookProjection,
+            _pixelDecoderHidden,
+            _pixelDecoderOut,
+        };
+
+    // The layer streams this model holds outside Layers are discovered by ModelParameterGenerator and surfaced automatically; the hand-written hook that used to sit here was an override wearing a different name.
+
+    // UpdateParameters folded one enumeration the base already folds. Removed under AIDN082.
+    protected override Tensor<T> PreprocessImage(Tensor<T> image) =>
+        NormalizeImage(image, _options.ImageMean, _options.ImageStd);
+
+    protected override Tensor<T> PostprocessOutput(Tensor<T> output) => output;
+
+    public override ModelMetadata<T> GetModelMetadata()
+    {
+        var meta = new ModelMetadata<T>
+        {
+            Name = _useNativeMode ? "Janus-Pro-Native" : "Janus-Pro-ONNX",
+            Description =
+                "Janus-Pro: unified multimodal understanding + generation via decoupled vision encoders (Chen et al. DeepSeek 2025, arXiv:2501.17811).",
+            FeatureCount = _options.DecoderDim,
+            Complexity = _options.NumVisionLayers + _options.NumDecoderLayers,
+        };
+        meta.AdditionalInfo["Architecture"] = "Janus-Pro";
+        meta.AdditionalInfo["LanguageModel"] = _options.LanguageModelName;
+        meta.AdditionalInfo["SupportsGeneration"] = _options.SupportsGeneration.ToString();
+        meta.AdditionalInfo["DecoupledEncoding"] = _options.EnableDecoupledEncoding.ToString();
+        meta.AdditionalInfo["VQCodebookSize"] = _vqCodebook.CodebookSize.ToString();
+        meta.AdditionalInfo["VQEmbeddingDim"] = _vqCodebook.EmbeddingDim.ToString();
+        meta.AdditionalInfo["GenerationTokens"] = _options.NumGenerationTokens.ToString();
+        meta.AdditionalInfo["CfgScale"] = _options.CfgScale.ToString();
+        return meta;
+    }
+
+
+
+
+
+    private void ThrowIfDisposed()
+    {
+        if (_disposed)
+            throw new ObjectDisposedException(GetType().FullName ?? nameof(JanusPro<T>));
+    }
+
+    protected override void Dispose(bool disposing)
+    {
+        if (_disposed)
+            return;
+        _disposed = true;
+        base.Dispose(disposing);
+    }
+}
diff --git a/src/VisionLanguage/Unified/OmniGen2.cs b/src/VisionLanguage/Unified/OmniGen2.cs
index e238ef4607..a6c6a0ff48 100644
--- a/src/VisionLanguage/Unified/OmniGen2.cs
+++ b/src/VisionLanguage/Unified/OmniGen2.cs
@@ -59,7 +59,7 @@ namespace AiDotNet.VisionLanguage.Unified;
     Year = 2025,
     Authors = "Chenyuan Wu et al."
 )]
-public class OmniGen2<T> : VisionLanguageModelBase<T>, IUnifiedVisionModel<T>
+public partial class OmniGen2<T> : VisionLanguageModelBase<T>, IUnifiedVisionModel<T>
 {
     private readonly OmniGen2Options _options;
 
@@ -373,46 +373,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.SupportsGeneration);
-        writer.Write(_options.OutputImageSize);
-        writer.Write(_options.EnableDualPath);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.SupportsGeneration = reader.ReadBoolean();
-        _options.OutputImageSize = reader.ReadInt32();
-        _options.EnableDualPath = reader.ReadBoolean();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new OmniGen2<T>(Architecture, mp, _options);
-        return new OmniGen2<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/Unified/SEEDX.cs b/src/VisionLanguage/Unified/SEEDX.cs
index d16725478e..140f69779f 100644
--- a/src/VisionLanguage/Unified/SEEDX.cs
+++ b/src/VisionLanguage/Unified/SEEDX.cs
@@ -60,7 +60,7 @@ namespace AiDotNet.VisionLanguage.Unified;
     Year = 2024,
     Authors = "Ge et al."
 )]
-public class SEEDX<T> : VisionLanguageModelBase<T>, IUnifiedVisionModel<T>
+public partial class SEEDX<T> : VisionLanguageModelBase<T>, IUnifiedVisionModel<T>
 {
     private readonly SEEDXOptions _options;
 
@@ -369,46 +369,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.SupportsGeneration);
-        writer.Write(_options.OutputImageSize);
-        writer.Write(_options.EnableMultiGranularity);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.SupportsGeneration = reader.ReadBoolean();
-        _options.OutputImageSize = reader.ReadInt32();
-        _options.EnableMultiGranularity = reader.ReadBoolean();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new SEEDX<T>(Architecture, mp, _options);
-        return new SEEDX<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/Unified/ShowO.cs b/src/VisionLanguage/Unified/ShowO.cs
index 46fca5b1e5..0f8817dde6 100644
--- a/src/VisionLanguage/Unified/ShowO.cs
+++ b/src/VisionLanguage/Unified/ShowO.cs
@@ -59,7 +59,7 @@ namespace AiDotNet.VisionLanguage.Unified;
     Year = 2024,
     Authors = "Xie et al."
 )]
-public class ShowO<T> : VisionLanguageModelBase<T>, IUnifiedVisionModel<T>
+public partial class ShowO<T> : VisionLanguageModelBase<T>, IUnifiedVisionModel<T>
 {
     private readonly ShowOOptions _options;
 
@@ -456,57 +456,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.SupportsGeneration);
-        writer.Write(_options.OutputImageSize);
-        writer.Write(_options.ImageTokenCount);
-        writer.Write(_options.DiffusionSteps);
-        writer.Write(_options.LearningRate);
-        writer.Write(_options.WeightDecay);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.SupportsGeneration = reader.ReadBoolean();
-        _options.OutputImageSize = reader.ReadInt32();
-        if (reader.BaseStream.Position < reader.BaseStream.Length)
-            _options.ImageTokenCount = reader.ReadInt32();
-        if (reader.BaseStream.Position < reader.BaseStream.Length)
-            _options.DiffusionSteps = reader.ReadInt32();
-        if (reader.BaseStream.Position < reader.BaseStream.Length)
-            _options.LearningRate = reader.ReadDouble();
-        if (reader.BaseStream.Position < reader.BaseStream.Length)
-            _options.WeightDecay = reader.ReadDouble();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        var options = new ShowOOptions(_options);
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new ShowO<T>(Architecture, mp, options);
-        return new ShowO<T>(Architecture, options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/Unified/ShowO2.cs b/src/VisionLanguage/Unified/ShowO2.cs
index 7b5be256b4..ccaaa82b36 100644
--- a/src/VisionLanguage/Unified/ShowO2.cs
+++ b/src/VisionLanguage/Unified/ShowO2.cs
@@ -62,7 +62,7 @@ namespace AiDotNet.VisionLanguage.Unified;
     Year = 2025,
     Authors = "Jinheng Xie, Zhenheng Yang, Mike Zheng Shou"
 )]
-public class ShowO2<T> : VisionLanguageModelBase<T>, IUnifiedVisionModel<T>
+public partial class ShowO2<T> : VisionLanguageModelBase<T>, IUnifiedVisionModel<T>
 {
     private readonly ShowO2Options _options;
 
@@ -437,44 +437,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.SupportsGeneration);
-        writer.Write(_options.OutputImageSize);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.SupportsGeneration = reader.ReadBoolean();
-        _options.OutputImageSize = reader.ReadInt32();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new ShowO2<T>(Architecture, mp, _options);
-        return new ShowO2<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/Unified/Transfusion.cs b/src/VisionLanguage/Unified/Transfusion.cs
index 953ac2fdb0..1438a3b7ec 100644
--- a/src/VisionLanguage/Unified/Transfusion.cs
+++ b/src/VisionLanguage/Unified/Transfusion.cs
@@ -62,7 +62,7 @@ namespace AiDotNet.VisionLanguage.Unified;
     Year = 2024,
     Authors = "Zhou et al."
 )]
-public class Transfusion<T> : VisionLanguageModelBase<T>, IUnifiedVisionModel<T>
+public partial class Transfusion<T> : VisionLanguageModelBase<T>, IUnifiedVisionModel<T>
 {
     private readonly TransfusionOptions _options;
 
@@ -425,46 +425,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.SupportsGeneration);
-        writer.Write(_options.OutputImageSize);
-        writer.Write(_options.EnableDiffusionLoss);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.SupportsGeneration = reader.ReadBoolean();
-        _options.OutputImageSize = reader.ReadInt32();
-        _options.EnableDiffusionLoss = reader.ReadBoolean();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new Transfusion<T>(Architecture, mp, _options);
-        return new Transfusion<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/VideoLanguage/LLaVANeXTVideo.cs b/src/VisionLanguage/VideoLanguage/LLaVANeXTVideo.cs
index 42c8d179c4..b2552d3ac9 100644
--- a/src/VisionLanguage/VideoLanguage/LLaVANeXTVideo.cs
+++ b/src/VisionLanguage/VideoLanguage/LLaVANeXTVideo.cs
@@ -59,7 +59,7 @@ namespace AiDotNet.VisionLanguage.VideoLanguage;
     Year = 2024,
     Authors = "Zhang et al."
 )]
-public class LLaVANeXTVideo<T> : VisionLanguageModelBase<T>, IVideoLanguageModel<T>
+public partial class LLaVANeXTVideo<T> : VisionLanguageModelBase<T>, IVideoLanguageModel<T>
 {
     private readonly LLaVANeXTVideoOptions _options;
 
@@ -324,42 +324,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.MaxFrames);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.MaxFrames = reader.ReadInt32();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new LLaVANeXTVideo<T>(Architecture, mp, _options);
-        return new LLaVANeXTVideo<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/VideoLanguage/LLaVAVideo.cs b/src/VisionLanguage/VideoLanguage/LLaVAVideo.cs
index 234f9b8d41..b29ae07f15 100644
--- a/src/VisionLanguage/VideoLanguage/LLaVAVideo.cs
+++ b/src/VisionLanguage/VideoLanguage/LLaVAVideo.cs
@@ -57,7 +57,7 @@ namespace AiDotNet.VisionLanguage.VideoLanguage;
     Year = 2024,
     Authors = "Zhang et al."
 )]
-public class LLaVAVideo<T> : VisionLanguageModelBase<T>, IVideoLanguageModel<T>
+public partial class LLaVAVideo<T> : VisionLanguageModelBase<T>, IVideoLanguageModel<T>
 {
     private readonly LLaVAVideoOptions _options;
 
@@ -401,42 +401,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.MaxFrames);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.MaxFrames = reader.ReadInt32();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new LLaVAVideo<T>(Architecture, mp, _options);
-        return new LLaVAVideo<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/VideoLanguage/LongVILA.cs b/src/VisionLanguage/VideoLanguage/LongVILA.cs
index b83f50a4d7..25a24fdd48 100644
--- a/src/VisionLanguage/VideoLanguage/LongVILA.cs
+++ b/src/VisionLanguage/VideoLanguage/LongVILA.cs
@@ -57,7 +57,7 @@ namespace AiDotNet.VisionLanguage.VideoLanguage;
     Year = 2024,
     Authors = "Xue et al."
 )]
-public class LongVILA<T> : VisionLanguageModelBase<T>, IVideoLanguageModel<T>
+public partial class LongVILA<T> : VisionLanguageModelBase<T>, IVideoLanguageModel<T>
 {
     private readonly LongVILAOptions _options;
 
@@ -409,44 +409,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.MaxFrames);
-        writer.Write(_options.MaxVideoMinutes);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.MaxFrames = reader.ReadInt32();
-        _options.MaxVideoMinutes = reader.ReadInt32();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new LongVILA<T>(Architecture, mp, _options);
-        return new LongVILA<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/VideoLanguage/PLLaVA.cs b/src/VisionLanguage/VideoLanguage/PLLaVA.cs
index 4afef6be7d..249e43ca0e 100644
--- a/src/VisionLanguage/VideoLanguage/PLLaVA.cs
+++ b/src/VisionLanguage/VideoLanguage/PLLaVA.cs
@@ -58,7 +58,7 @@ namespace AiDotNet.VisionLanguage.VideoLanguage;
     Year = 2024,
     Authors = "Xu et al."
 )]
-public class PLLaVA<T> : VisionLanguageModelBase<T>, IVideoLanguageModel<T>
+public partial class PLLaVA<T> : VisionLanguageModelBase<T>, IVideoLanguageModel<T>
 {
     private readonly PLLaVAOptions _options;
 
@@ -389,44 +389,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.MaxFrames);
-        writer.Write(_options.EnableParameterFreePooling);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.MaxFrames = reader.ReadInt32();
-        _options.EnableParameterFreePooling = reader.ReadBoolean();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new PLLaVA<T>(Architecture, mp, _options);
-        return new PLLaVA<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/VideoLanguage/SlowFastLLaVA.cs b/src/VisionLanguage/VideoLanguage/SlowFastLLaVA.cs
index 45d14368d1..74caed26bd 100644
--- a/src/VisionLanguage/VideoLanguage/SlowFastLLaVA.cs
+++ b/src/VisionLanguage/VideoLanguage/SlowFastLLaVA.cs
@@ -58,7 +58,7 @@ namespace AiDotNet.VisionLanguage.VideoLanguage;
     Year = 2024,
     Authors = "Xu et al."
 )]
-public class SlowFastLLaVA<T> : VisionLanguageModelBase<T>, IVideoLanguageModel<T>
+public partial class SlowFastLLaVA<T> : VisionLanguageModelBase<T>, IVideoLanguageModel<T>
 {
     private readonly SlowFastLLaVAOptions _options;
 
@@ -391,46 +391,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.MaxFrames);
-        writer.Write(_options.SlowFrames);
-        writer.Write(_options.FastFrames);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.MaxFrames = reader.ReadInt32();
-        _options.SlowFrames = reader.ReadInt32();
-        _options.FastFrames = reader.ReadInt32();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new SlowFastLLaVA<T>(Architecture, mp, _options);
-        return new SlowFastLLaVA<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/VideoLanguage/VideoChat2.cs b/src/VisionLanguage/VideoLanguage/VideoChat2.cs
index 622e20228a..2ba5eb61b0 100644
--- a/src/VisionLanguage/VideoLanguage/VideoChat2.cs
+++ b/src/VisionLanguage/VideoLanguage/VideoChat2.cs
@@ -60,7 +60,7 @@ namespace AiDotNet.VisionLanguage.VideoLanguage;
     Year = 2023,
     Authors = "Li et al."
 )]
-public class VideoChat2<T> : VisionLanguageModelBase<T>, IVideoLanguageModel<T>
+public partial class VideoChat2<T> : VisionLanguageModelBase<T>, IVideoLanguageModel<T>
 {
     private readonly VideoChat2Options _options;
 
@@ -376,42 +376,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.MaxFrames);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.MaxFrames = reader.ReadInt32();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new VideoChat2<T>(Architecture, mp, _options);
-        return new VideoChat2<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/VideoLanguage/VideoLLaMA2.cs b/src/VisionLanguage/VideoLanguage/VideoLLaMA2.cs
index 25d7e83433..20ae0ec9c0 100644
--- a/src/VisionLanguage/VideoLanguage/VideoLLaMA2.cs
+++ b/src/VisionLanguage/VideoLanguage/VideoLLaMA2.cs
@@ -60,7 +60,7 @@ namespace AiDotNet.VisionLanguage.VideoLanguage;
     Year = 2024,
     Authors = "Cheng et al."
 )]
-public class VideoLLaMA2<T> : VisionLanguageModelBase<T>, IVideoLanguageModel<T>
+public partial class VideoLLaMA2<T> : VisionLanguageModelBase<T>, IVideoLanguageModel<T>
 {
     private readonly VideoLLaMA2Options _options;
 
@@ -360,76 +360,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.MaxFrames);
-        writer.Write(_options.EnableSpatialTemporalConv);
-        writer.Write(_options.VisionEncoderName);
-        writer.Write(_options.PatchSize);
-        writer.Write(_options.VisionNumHeads);
-        writer.Write(_options.DecoderNumHeads);
-        writer.Write(_options.DecoderNumKeyValueHeads);
-        writer.Write(_options.VisionFfnDim);
-        writer.Write(_options.DecoderFfnDim);
-        writer.Write(_options.RoPETheta);
-        writer.Write(_options.STCKernelSize);
-        writer.Write(_options.STCStride);
-        writer.Write(_options.STCPadding);
-        writer.Write(_options.STCStageDepth);
-        writer.Write(_options.STCMlpDepth);
-        writer.Write(_options.LearningRate);
-        writer.Write(_options.WeightDecay);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.MaxFrames = reader.ReadInt32();
-        _options.EnableSpatialTemporalConv = reader.ReadBoolean();
-        _options.VisionEncoderName = reader.ReadString();
-        _options.PatchSize = reader.ReadInt32();
-        _options.VisionNumHeads = reader.ReadInt32();
-        _options.DecoderNumHeads = reader.ReadInt32();
-        _options.DecoderNumKeyValueHeads = reader.ReadInt32();
-        _options.VisionFfnDim = reader.ReadInt32();
-        _options.DecoderFfnDim = reader.ReadInt32();
-        _options.RoPETheta = reader.ReadDouble();
-        _options.STCKernelSize = reader.ReadInt32();
-        _options.STCStride = reader.ReadInt32();
-        _options.STCPadding = reader.ReadInt32();
-        _options.STCStageDepth = reader.ReadInt32();
-        _options.STCMlpDepth = reader.ReadInt32();
-        _options.LearningRate = reader.ReadDouble();
-        _options.WeightDecay = reader.ReadDouble();
-        ValidateOptions(_options);
-        _optimizer = _useNativeMode ? CreateDefaultOptimizer() : null;
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new VideoLLaMA2<T>(Architecture, mp, _options);
-        return new VideoLLaMA2<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/VideoLanguage/VideoLLaMA3.cs b/src/VisionLanguage/VideoLanguage/VideoLLaMA3.cs
index 08b5a5fdc1..73acbfd486 100644
--- a/src/VisionLanguage/VideoLanguage/VideoLLaMA3.cs
+++ b/src/VisionLanguage/VideoLanguage/VideoLLaMA3.cs
@@ -58,7 +58,7 @@ namespace AiDotNet.VisionLanguage.VideoLanguage;
     Year = 2025,
     Authors = "Zhang et al."
 )]
-public class VideoLLaMA3<T> : VisionLanguageModelBase<T>, IVideoLanguageModel<T>
+public partial class VideoLLaMA3<T> : VisionLanguageModelBase<T>, IVideoLanguageModel<T>
 {
     private readonly VideoLLaMA3Options _options;
 
@@ -413,42 +413,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.MaxFrames);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.MaxFrames = reader.ReadInt32();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new VideoLLaMA3<T>(Architecture, mp, _options);
-        return new VideoLLaMA3<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/VideoLanguage/VideoLLaVA.cs b/src/VisionLanguage/VideoLanguage/VideoLLaVA.cs
index c32035138f..e1c1b2140a 100644
--- a/src/VisionLanguage/VideoLanguage/VideoLLaVA.cs
+++ b/src/VisionLanguage/VideoLanguage/VideoLLaVA.cs
@@ -60,7 +60,7 @@ namespace AiDotNet.VisionLanguage.VideoLanguage;
     Year = 2024,
     Authors = "Lin et al."
 )]
-public class VideoLLaVA<T> : VisionLanguageModelBase<T>, IVideoLanguageModel<T>
+public partial class VideoLLaVA<T> : VisionLanguageModelBase<T>, IVideoLanguageModel<T>
 {
     private readonly VideoLLaVAOptions _options;
 
@@ -337,42 +337,9 @@ public override ModelMetadata<T> GetModelMetadata()
         return m;
     }
 
-    protected override void SerializeNetworkSpecificData(BinaryWriter writer)
-    {
-        writer.Write(_useNativeMode);
-        writer.Write(_options.ModelPath ?? string.Empty);
-        writer.Write(_options.ImageSize);
-        writer.Write(_options.VisionDim);
-        writer.Write(_options.DecoderDim);
-        writer.Write(_options.NumVisionLayers);
-        writer.Write(_options.NumDecoderLayers);
-        writer.Write(_options.NumHeads);
-        writer.Write(_options.MaxFrames);
-    }
 
-    protected override void DeserializeNetworkSpecificData(BinaryReader reader)
-    {
-        _useNativeMode = reader.ReadBoolean();
-        string mp = reader.ReadString();
-        if (!string.IsNullOrEmpty(mp))
-            _options.ModelPath = mp;
-        _options.ImageSize = reader.ReadInt32();
-        _options.VisionDim = reader.ReadInt32();
-        _options.DecoderDim = reader.ReadInt32();
-        _options.NumVisionLayers = reader.ReadInt32();
-        _options.NumDecoderLayers = reader.ReadInt32();
-        _options.NumHeads = reader.ReadInt32();
-        _options.MaxFrames = reader.ReadInt32();
-        if (!_useNativeMode && _options.ModelPath is { } p && !string.IsNullOrEmpty(p))
-            OnnxModel = new OnnxModel<T>(p, _options.OnnxOptions);
-    }
 
-    protected override IFullModel<T, Tensor<T>, Tensor<T>> CreateNewInstance()
-    {
-        if (!_useNativeMode && _options.ModelPath is { } mp && !string.IsNullOrEmpty(mp))
-            return new VideoLLaVA<T>(Architecture, mp, _options);
-        return new VideoLLaVA<T>(Architecture, _options);
-    }
+
 
     private void ThrowIfDisposed()
     {
diff --git a/src/VisionLanguage/VisionLanguageModelBase.cs b/src/VisionLanguage/VisionLanguageModelBase.cs
index d0017cc7d1..35c3704f0d 100644
--- a/src/VisionLanguage/VisionLanguageModelBase.cs
+++ b/src/VisionLanguage/VisionLanguageModelBase.cs
@@ -43,7 +43,7 @@ namespace AiDotNet.VisionLanguage;
     Direction = TensorLayoutDirection.Output,
     Note = "The pooled joint-embedding law: one EmbeddingDim-wide vector per sample. Two other "
          + "measured laws exist in this family - see PatchTokenContract and TrailingFeatureContract.")]
-public abstract class VisionLanguageModelBase<T> : NeuralNetworkBase<T>, IShapeContract
+public abstract partial class VisionLanguageModelBase<T> : NeuralNetworkBase<T>, IShapeContract
 {
     /// <summary>
     /// The family's default output law: one pooled <see cref="EmbeddingDim"/>-wide embedding per sample.
diff --git a/src/WaveletFunctions/BiorthogonalWavelet.cs b/src/WaveletFunctions/BiorthogonalWavelet.cs
index c507bdf7f7..13ab36bfff 100644
--- a/src/WaveletFunctions/BiorthogonalWavelet.cs
+++ b/src/WaveletFunctions/BiorthogonalWavelet.cs
@@ -33,7 +33,7 @@ namespace AiDotNet.WaveletFunctions;
 /// and one for synthesizing - that work together perfectly.
 /// </para>
 /// </remarks>
-public class BiorthogonalWavelet<T> : WaveletFunctionBase<T>
+public partial class BiorthogonalWavelet<T> : WaveletFunctionBase<T>
 {
     /// <summary>
     /// The order of the wavelet used for decomposition.
@@ -48,11 +48,13 @@ public class BiorthogonalWavelet<T> : WaveletFunctionBase<T>
     /// <summary>
     /// Coefficients used for the decomposition process.
     /// </summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private readonly Vector<T> _decompositionCoefficients;
 
     /// <summary>
     /// Coefficients used for the reconstruction process.
     /// </summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private readonly Vector<T> _reconstructionCoefficients;
 
     /// <summary>
diff --git a/src/WaveletFunctions/DaubechiesWavelet.cs b/src/WaveletFunctions/DaubechiesWavelet.cs
index d332c84f20..f4efcdc42a 100644
--- a/src/WaveletFunctions/DaubechiesWavelet.cs
+++ b/src/WaveletFunctions/DaubechiesWavelet.cs
@@ -38,7 +38,7 @@ namespace AiDotNet.WaveletFunctions;
 /// vanishing moments but wider support.
 /// </para>
 /// </remarks>
-public class DaubechiesWavelet<T> : WaveletFunctionBase<T>
+public partial class DaubechiesWavelet<T> : WaveletFunctionBase<T>
 {
     /// <summary>
     /// The order of the Daubechies wavelet.
@@ -48,11 +48,13 @@ public class DaubechiesWavelet<T> : WaveletFunctionBase<T>
     /// <summary>
     /// The scaling function coefficients of the Daubechies wavelet.
     /// </summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private readonly Vector<T> _scalingCoefficients;
 
     /// <summary>
     /// The wavelet function coefficients of the Daubechies wavelet.
     /// </summary>
+    [AiDotNet.Attributes.TrainableParameter]
     private readonly Vector<T> _waveletCoefficients;
 
     /// <summary>
diff --git "a/src/WaveletFunctions/Fej\303\251rKorovkinWavelet.cs" "b/src/WaveletFunctions/Fej\303\251rKorovkinWavelet.cs"
index a13f33d75c..714a641db3 100644
--- "a/src/WaveletFunctions/Fej\303\251rKorovkinWavelet.cs"
+++ "b/src/WaveletFunctions/Fej\303\251rKorovkinWavelet.cs"
@@ -22,7 +22,7 @@ namespace AiDotNet.WaveletFunctions;
 /// </para>
 /// </remarks>
 /// <typeparam name="T">The numeric type used for calculations, typically float or double.</typeparam>
-public class FejérKorovkinWavelet<T> : WaveletFunctionBase<T>
+public partial class FejérKorovkinWavelet<T> : WaveletFunctionBase<T>
 {
 
     /// <summary>
@@ -67,6 +67,7 @@ public class FejérKorovkinWavelet<T> : WaveletFunctionBase<T>
     /// a Fejér-Korovkin wavelet different from other types of wavelets.
     /// </para>
     /// </remarks>
+    [AiDotNet.Attributes.TrainableParameter]
     private readonly Vector<T> _coefficients;
 
     /// <summary>
@@ -89,6 +90,7 @@ public class FejérKorovkinWavelet<T> : WaveletFunctionBase<T>
     /// like looking at something through frosted glass where you can see outlines but not details.
     /// </para>
     /// </remarks>
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T> _scalingCoefficients;
 
     /// <summary>
@@ -111,6 +113,7 @@ public class FejérKorovkinWavelet<T> : WaveletFunctionBase<T>
     /// like an edge detection filter that highlights boundaries and textures in an image.
     /// </para>
     /// </remarks>
+    [AiDotNet.Attributes.TrainableParameter]
     private Vector<T> _waveletCoefficients;
 
     /// <summary>
diff --git a/tests/AiDotNet.Tests/Generators/CloneAutomationAnalyzerTests.cs b/tests/AiDotNet.Tests/Generators/CloneAutomationAnalyzerTests.cs
new file mode 100644
index 0000000000..82aaffb659
--- /dev/null
+++ b/tests/AiDotNet.Tests/Generators/CloneAutomationAnalyzerTests.cs
@@ -0,0 +1,103 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Linq;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Xunit;
+
+namespace AiDotNet.Tests.Generators;
+
+/// <summary>Locks the rule that concrete models and layers cannot regain lifecycle plumbing.</summary>
+public sealed class CloneAutomationAnalyzerTests
+{
+    private const string Infrastructure = @"
+namespace AiDotNet.Interfaces
+{
+    public interface IFullModel { }
+    public interface IModelSerializer { }
+    public interface IModelShape { }
+    public interface IOptimizer : IModelSerializer { }
+}
+namespace AiDotNet.NeuralNetworks.Layers
+{
+    public abstract class LayerBase<T>
+    {
+        public virtual byte[] Serialize() => new byte[0];
+    }
+}
+public abstract class ModelBase : AiDotNet.Interfaces.IFullModel
+{
+    public virtual object Clone() => new object();
+}
+public abstract class ClassifierBase : AiDotNet.Interfaces.IModelSerializer, AiDotNet.Interfaces.IModelShape
+{
+    public abstract byte[] Serialize();
+}
+public abstract class OptimizerBase : AiDotNet.Interfaces.IOptimizer, AiDotNet.Interfaces.IModelShape
+{
+    public virtual byte[] Serialize() => new byte[0];
+}";
+
+    private static ImmutableArray<MetadataReference> BaseReferences()
+    {
+        var references = new List<MetadataReference>();
+        var seen = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+        foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies())
+        {
+            if (assembly.IsDynamic || string.IsNullOrEmpty(assembly.Location) || !seen.Add(assembly.Location))
+                continue;
+            references.Add(MetadataReference.CreateFromFile(assembly.Location));
+        }
+
+        return references.ToImmutableArray();
+    }
+
+    private static async Task<ImmutableArray<Diagnostic>> RunAsync(string source)
+    {
+        var compilation = CSharpCompilation.Create(
+            "AiDotNet",
+            new[] { CSharpSyntaxTree.ParseText(Infrastructure), CSharpSyntaxTree.ParseText(source) },
+            BaseReferences(),
+            new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary));
+        return await compilation.WithAnalyzers(
+            ImmutableArray.Create<DiagnosticAnalyzer>(new AiDotNet.Generators.CloneAutomationAnalyzer()))
+            .GetAnalyzerDiagnosticsAsync();
+    }
+
+    [Theory]
+    [InlineData("public sealed class Bad : ModelBase { public override object Clone() => new object(); }")]
+    [InlineData("public sealed class Bad : AiDotNet.NeuralNetworks.Layers.LayerBase<double> { public override byte[] Serialize() => new byte[0]; }")]
+    [InlineData("public sealed class Bad : ClassifierBase { public override byte[] Serialize() => new byte[0]; }")]
+    public async Task ConcreteLifecycleOverride_IsRejected(string source)
+    {
+        var diagnostic = Assert.Single((await RunAsync(source)).Where(item => item.Id == "ADN0063"));
+        Assert.Contains("Bad", diagnostic.GetMessage(), StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public async Task AbstractFamilyBase_MayOwnSharedLifecyclePolicy()
+    {
+        const string source = @"
+public abstract class SharedFamilyBase : ModelBase
+{
+    public override object Clone() => new object();
+}";
+
+        Assert.Empty((await RunAsync(source)).Where(item => item.Id == "ADN0063"));
+    }
+
+    [Fact]
+    public async Task OptimizerSerializer_IsOutsideModelLifecycleRule()
+    {
+        const string source = @"
+public sealed class DistributedOptimizer : OptimizerBase
+{
+    public override byte[] Serialize() => new byte[0];
+}";
+
+        Assert.Empty((await RunAsync(source)).Where(item => item.Id == "ADN0063"));
+    }
+}
diff --git a/tests/AiDotNet.Tests/Generators/ParameterAutomationAnalyzerTests.cs b/tests/AiDotNet.Tests/Generators/ParameterAutomationAnalyzerTests.cs
index ced8030872..118f50be59 100644
--- a/tests/AiDotNet.Tests/Generators/ParameterAutomationAnalyzerTests.cs
+++ b/tests/AiDotNet.Tests/Generators/ParameterAutomationAnalyzerTests.cs
@@ -268,6 +268,22 @@ public sealed class AliasLayer : AiDotNet.NeuralNetworks.Layers.LayerBase<double
         Assert.Contains("_missing", diagnostic.GetMessage(), StringComparison.Ordinal);
     }
 
+    [Fact]
+    public async Task Alias_MayNameTheOwnedLayerField()
+    {
+        await Task.Yield();
+        const string source = @"
+using AiDotNet.Attributes;
+public sealed class ChildLayer : AiDotNet.NeuralNetworks.Layers.LayerBase<double> { }
+public sealed class CompositeLayer : AiDotNet.NeuralNetworks.Layers.LayerBase<double>
+{
+    private ChildLayer _owned = new();
+    [ParameterAlias(nameof(_owned))] private ChildLayer _alias = null!;
+}";
+
+        Assert.DoesNotContain(Run(source), item => item.Id == "AIDN091");
+    }
+
     [Theory]
     [InlineData("Missing", "no such field")]
     [InlineData("Rank", "not a readable Boolean")]
diff --git a/tests/AiDotNet.Tests/Generators/ParameterGeneratorSemanticTests.cs b/tests/AiDotNet.Tests/Generators/ParameterGeneratorSemanticTests.cs
index 30167d3089..19b8cfa1cc 100644
--- a/tests/AiDotNet.Tests/Generators/ParameterGeneratorSemanticTests.cs
+++ b/tests/AiDotNet.Tests/Generators/ParameterGeneratorSemanticTests.cs
@@ -5,6 +5,7 @@
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Xunit;
 
 namespace AiDotNet.Tests.Generators;
@@ -37,25 +38,42 @@ namespace AiDotNet.Attributes
     }
     [AttributeUsage(AttributeTargets.Field | AttributeTargets.Property)] public sealed class ScratchAttribute : Attribute { }
     [AttributeUsage(AttributeTargets.Field | AttributeTargets.Property)] public sealed class ExternalStateAttribute : Attribute { }
+    [AttributeUsage(AttributeTargets.Class, AllowMultiple = true)]
+    public sealed class TensorLayoutAttribute : Attribute
+    {
+        public TensorLayoutAttribute(params AiDotNet.Enums.TensorAxis[] axes) { }
+        public AiDotNet.Enums.TensorLayoutDirection Direction { get; set; }
+        public bool BatchOptional { get; set; }
+    }
     [AttributeUsage(AttributeTargets.Field | AttributeTargets.Property)] public sealed class ParameterAliasAttribute : Attribute
     {
         public ParameterAliasAttribute(string target) { }
     }
 }
+namespace AiDotNet.Enums
+{
+    public enum TensorAxis { Batch, Channels, Depth, Height, Width, Features }
+    public enum TensorLayoutDirection { Input, Output }
+}
 namespace AiDotNet.Tensors.LinearAlgebra
 {
-    public class Tensor<T> { public int Length => 1; }
-    public class Matrix<T> { }
-    public class Vector<T> { }
+    public class Tensor<T> : AiDotNet.Interfaces.IParameterSource<T> { public int Length => 1; }
+    public class Matrix<T> : AiDotNet.Interfaces.IParameterSource<T> { }
+    public class Vector<T> : AiDotNet.Interfaces.IParameterSource<T> { }
 }
 namespace AiDotNet.Interfaces
 {
+    public interface IParameterSource<T> { }
+    public interface IModelSerializer { }
     public interface ILayer<T> { }
 }
 namespace AiDotNet.NeuralNetworks.Layers
 {
     public abstract class LayerBase<T>
     {
+        protected AiDotNet.Tensors.LinearAlgebra.Vector<T> Parameters = new();
+        public virtual AiDotNet.Tensors.LinearAlgebra.Vector<T> GetParameters() => Parameters;
+        protected virtual bool LegacyParametersAreDerivedSnapshot => false;
         protected void RegisterTrainableParameter(
             AiDotNet.Tensors.LinearAlgebra.Tensor<T> tensor,
             AiDotNet.Tensors.Engines.PersistentTensorRole role) { }
@@ -71,11 +89,22 @@ namespace AiDotNet.NeuralNetworks
     public abstract class NeuralNetworkBase<T>
     {
         public List<ILayer<T>> Layers { get; } = new();
+        protected virtual void RegisterGeneratedState(AiDotNet.Models.ModelStateRegistry<T> state) { }
         protected virtual IEnumerable<Tensor<T>> GetExtraTrainableTensors() => new List<Tensor<T>>();
         protected virtual IEnumerable<LayerBase<T>?> GetExtraTrainableLayers() => new List<LayerBase<T>?>();
         protected virtual void RebindLayerAliases(
             IReadOnlyList<ILayer<T>> previousLayers,
             IReadOnlyList<ILayer<T>> replacementLayers) { }
+        protected virtual void CopyGeneratedLayerAliasesTo(NeuralNetworkBase<T> destination) { }
+        protected virtual void CopyGeneratedTrainableTensorsTo(NeuralNetworkBase<T> destination) { }
+        protected static Tensor<T>? CloneGeneratedTrainableTensor(Tensor<T>? source) => source;
+        protected static Tensor<T> CloneRequiredGeneratedTrainableTensor(Tensor<T> source) => source;
+        protected static void CopyGeneratedTrainableTensorValues(
+            Tensor<T>? source, Tensor<T>? destination, string memberName) { }
+        protected static Vector<T>? CloneGeneratedTrainableVector(Vector<T>? source) => source;
+        protected static Vector<T> CloneRequiredGeneratedTrainableVector(Vector<T> source) => source;
+        protected static void CopyGeneratedTrainableVectorValues(
+            Vector<T>? source, Vector<T>? destination, string memberName) { }
         protected static TLayer? RebindLayerAlias<TLayer>(
             TLayer? alias,
             IReadOnlyList<ILayer<T>> previousLayers,
@@ -96,6 +125,30 @@ protected static void ValidateReadonlyLayerAlias<TLayer>(
             IReadOnlyList<ILayer<T>> previousLayers,
             IReadOnlyList<ILayer<T>> replacementLayers,
             string memberName) where TLayer : class, ILayer<T> { }
+        protected static TLayer? CopyLayerAlias<TLayer>(
+            TLayer? sourceAlias,
+            TLayer? destinationAlias,
+            IReadOnlyList<ILayer<T>> sourceLayers,
+            IReadOnlyList<ILayer<T>> destinationLayers,
+            string memberName) where TLayer : class, ILayer<T> => destinationAlias;
+        protected static TLayer CopyRequiredLayerAlias<TLayer>(
+            TLayer sourceAlias,
+            TLayer destinationAlias,
+            IReadOnlyList<ILayer<T>> sourceLayers,
+            IReadOnlyList<ILayer<T>> destinationLayers,
+            string memberName) where TLayer : class, ILayer<T> => destinationAlias;
+        protected static void CopyLayerAliasCollection<TLayer>(
+            IEnumerable<TLayer>? sourceAliases,
+            IEnumerable<TLayer>? destinationAliases,
+            IReadOnlyList<ILayer<T>> sourceLayers,
+            IReadOnlyList<ILayer<T>> destinationLayers,
+            string memberName) where TLayer : class, ILayer<T> { }
+        protected static void ValidateCopiedReadonlyLayerAlias<TLayer>(
+            TLayer? sourceAlias,
+            TLayer? destinationAlias,
+            IReadOnlyList<ILayer<T>> sourceLayers,
+            IReadOnlyList<ILayer<T>> destinationLayers,
+            string memberName) where TLayer : class, ILayer<T> { }
     }
 }
 namespace AiDotNet.Tensors.Engines
@@ -104,11 +157,16 @@ public enum PersistentTensorRole { Weights, Biases }
 }
 namespace AiDotNet.Models
 {
+    public sealed class ModelStateRegistry<T>
+    {
+        public void DeclareBoolean(string name, System.Func<bool> get, System.Action<bool> set) { }
+    }
     public abstract class ModelBase<T, TInput, TOutput>
     {
         protected void RegisterParameterComponent(object value) { }
         protected virtual void RegisterComponents() { }
         protected virtual void RegisterGeneratedParameterComponents(object registry) { }
+        protected virtual void RegisterGeneratedState(ModelStateRegistry<T> state) { }
     }
 }";
 
@@ -149,6 +207,270 @@ private static ImmutableArray<Diagnostic> RunDiagnostics(IIncrementalGenerator g
         return driver.GetRunResult().Diagnostics;
     }
 
+    private static void AssertGeneratedExecutableMembersAreMarked(string generated, string generatorName)
+    {
+        SyntaxNode root = CSharpSyntaxTree.ParseText(generated).GetRoot();
+        var members = root.DescendantNodes()
+            .OfType<MemberDeclarationSyntax>()
+            .Where(member => member is MethodDeclarationSyntax or PropertyDeclarationSyntax)
+            .ToList();
+
+        Assert.NotEmpty(members);
+        foreach (MemberDeclarationSyntax member in members)
+        {
+            Assert.Contains(
+                $"GeneratedCode(\"AiDotNet.Generators.{generatorName}\"",
+                member.AttributeLists.ToFullString(),
+                StringComparison.Ordinal);
+        }
+    }
+
+    [Fact]
+    public void LayerGenerator_MarksAllGeneratedExecutableMembersAsGeneratedCode()
+    {
+        const string source = @"
+using AiDotNet.Attributes;
+[AutoParameters]
+public partial class GeneratedCoverageLayer<T> : AiDotNet.NeuralNetworks.Layers.LayerBase<T>
+{
+    [TrainableParameter(Shape = ""4, 4"")]
+    private AiDotNet.Tensors.LinearAlgebra.Tensor<T> _weight = new();
+}";
+
+        string generated = Run(new AiDotNet.Generators.TrainableParameterGenerator(), source);
+        AssertGeneratedExecutableMembersAreMarked(generated, "TrainableParameterGenerator");
+    }
+
+    [Fact]
+    public void ModelGenerator_MarksAllGeneratedExecutableMembersAsGeneratedCode()
+    {
+        const string source = @"
+using AiDotNet.Attributes;
+public partial class GeneratedCoverageModel<T> : AiDotNet.Models.ModelBase<T, object, object>
+{
+    [TrainableParameter]
+    private AiDotNet.Tensors.LinearAlgebra.Tensor<T> _weight = new();
+}";
+
+        string generated = Run(new AiDotNet.Generators.ModelParameterGenerator(), source);
+        AssertGeneratedExecutableMembersAreMarked(generated, "ModelParameterGenerator");
+    }
+
+    [Fact]
+    public void ModelGenerator_SurfacesTrainableVectorWithoutConcreteOverride()
+    {
+        const string source = @"
+using AiDotNet.Attributes;
+public partial class VectorBackedNetwork<T> : AiDotNet.NeuralNetworks.NeuralNetworkBase<T>
+{
+    [TrainableParameter]
+    private AiDotNet.Tensors.LinearAlgebra.Vector<T> _bias = new();
+}";
+
+        string generated = Run(new AiDotNet.Generators.ModelParameterGenerator(), source);
+        Assert.Contains("new Tensor<T>([_bias.Length], _bias)", generated, StringComparison.Ordinal);
+        Assert.Contains(
+            "__destination._bias = CloneRequiredGeneratedTrainableVector(_bias);",
+            generated,
+            StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void ClonePlanGenerator_MarksItsGeneratedRegistryAsGeneratedCode()
+    {
+        const string source = @"
+public class GeneratedCoverageClone<T> : AiDotNet.NeuralNetworks.Layers.LayerBase<T>
+{
+    public int Width { get; set; }
+}
+public class SecondGeneratedCoverageClone<T> : AiDotNet.NeuralNetworks.Layers.LayerBase<T>
+{
+    public int Height { get; set; }
+}";
+
+        string generated = Run(new AiDotNet.Generators.ClonePlanGenerator(), source);
+        Assert.Contains(
+            "[global::System.CodeDom.Compiler.GeneratedCode(\"AiDotNet.Generators.ClonePlanGenerator\", \"1.0.0\")]\ninternal static class CloneRegistrations",
+            generated.Replace("\r\n", "\n"),
+            StringComparison.Ordinal);
+
+        SyntaxNode root = CSharpSyntaxTree.ParseText(generated).GetRoot();
+        ClassDeclarationSyntax registry = Assert.Single(
+            root.DescendantNodes().OfType<ClassDeclarationSyntax>(),
+            declaration => declaration.Identifier.ValueText == "CloneRegistrations");
+        MethodDeclarationSyntax dispatcher = Assert.Single(
+            registry.Members.OfType<MethodDeclarationSyntax>(),
+            method => method.Identifier.ValueText == "RegisterAll");
+        var registrationMethods = registry.Members
+            .OfType<MethodDeclarationSyntax>()
+            .Where(method => method.Identifier.ValueText.StartsWith("Register_", StringComparison.Ordinal))
+            .ToList();
+
+        Assert.Equal(2, registrationMethods.Count);
+        Assert.DoesNotContain("new List<ClonePlanEntry>", dispatcher.Body!.ToFullString(), StringComparison.Ordinal);
+        Assert.All(registrationMethods, method =>
+            Assert.Contains("new List<ClonePlanEntry>", method.Body!.ToFullString(), StringComparison.Ordinal));
+    }
+
+    [Fact]
+    public void ClonePlanGenerator_EmitsToolingSafeMethodBodies()
+    {
+        Type registry = typeof(AiDotNet.Models.CloneRegistry).Assembly.GetType(
+            "AiDotNet.Generated.CloneRegistrations",
+            throwOnError: true)!;
+        var generatedMethods = registry
+            .GetMethods(System.Reflection.BindingFlags.Static |
+                        System.Reflection.BindingFlags.Public |
+                        System.Reflection.BindingFlags.NonPublic |
+                        System.Reflection.BindingFlags.DeclaredOnly)
+            .Select(method => (method.Name, Size: method.GetMethodBody()?.GetILAsByteArray()?.Length ?? 0))
+            .ToList();
+
+        Assert.NotEmpty(generatedMethods);
+        Assert.All(generatedMethods, method =>
+            Assert.True(
+                method.Size < 64 * 1024,
+                $"Generated clone method {method.Name} is {method.Size:N0} bytes of IL; " +
+                "large monolithic methods make coverage control-flow analysis pathological."));
+    }
+
+    [Fact]
+    public void ClonePlanGenerator_UsesDirectConstructorAssignmentWhenMemberNameDiffers()
+    {
+        const string source = """
+            namespace AiDotNet.Interfaces
+            {
+                public interface IFullModel<TInput, TOutput> { }
+            }
+
+            namespace Example
+            {
+                public sealed class WidthModel : AiDotNet.Interfaces.IFullModel<int, int>
+                {
+                    public int ImageSize { get; private set; }
+
+                    public WidthModel(int imageWidth = 128)
+                    {
+                        ImageSize = imageWidth;
+                    }
+                }
+            }
+            """;
+
+        string generated = Run(new AiDotNet.Generators.ClonePlanGenerator(), source);
+
+        Assert.Contains("new[] { \"ImageSize\" }", generated, StringComparison.Ordinal);
+        Assert.DoesNotContain("new[] { \"=default\" }", generated, StringComparison.Ordinal);
+        Assert.DoesNotContain("Add(e, t, \"ImageSize\"", generated, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void ClonePlanGenerator_UsesEffectiveOptionalConfigurationStoredThroughCoalesce()
+    {
+        const string source = """
+            namespace AiDotNet.Interfaces
+            {
+                public interface IFullModel<TInput, TOutput> { }
+            }
+
+            namespace Example
+            {
+                public sealed class Settings { }
+                public sealed class ConfiguredModel : AiDotNet.Interfaces.IFullModel<int, int>
+                {
+                    private Settings Options { get; }
+                    public ConfiguredModel(Settings? options = null)
+                    {
+                        Options = options ?? new Settings();
+                    }
+                }
+            }
+            """;
+
+        string generated = Run(new AiDotNet.Generators.ClonePlanGenerator(), source);
+
+        Assert.Contains("new[] { \"Options\" }", generated, StringComparison.Ordinal);
+        Assert.DoesNotContain("new[] { \"=default\" }", generated, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void ClonePlanGenerator_MapsNamedNestedArchitectureBeforeGenericParentArchitecture()
+    {
+        const string source = """
+            namespace AiDotNet.Interfaces
+            {
+                public interface IFullModel<TInput, TOutput> { }
+            }
+
+            namespace Example
+            {
+                public sealed class Architecture { }
+                public sealed class Network
+                {
+                    public Architecture Architecture { get; } = new Architecture();
+                }
+
+                public sealed class CompositeModel : AiDotNet.Interfaces.IFullModel<int, int>
+                {
+                    public Architecture Architecture { get; } = new Architecture();
+                    public Network Generator { get; private set; } = new Network();
+                    public Network Critic { get; private set; } = new Network();
+
+                    public CompositeModel(
+                        Architecture generatorArchitecture,
+                        Architecture criticArchitecture)
+                    {
+                    }
+                }
+            }
+            """;
+
+        string generated = Run(new AiDotNet.Generators.ClonePlanGenerator(), source);
+
+        Assert.Contains(
+            "new[] { \"Generator.Architecture\", \"Critic.Architecture\" }",
+            generated,
+            StringComparison.Ordinal);
+        Assert.DoesNotContain(
+            "new[] { \"Architecture\", \"Architecture\" }",
+            generated,
+            StringComparison.Ordinal);
+        Assert.DoesNotContain("Add(e, t, \"Generator\"", generated, StringComparison.Ordinal);
+        Assert.DoesNotContain("Add(e, t, \"Critic\"", generated, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void ClonePlanGenerator_DoesNotUseScratchGraphAsOptionalConfiguration()
+    {
+        const string source = """
+            namespace AiDotNet.Interfaces
+            {
+                public interface IFullModel<TInput, TOutput> { }
+            }
+
+            namespace Example
+            {
+                public sealed class LazyGraphModel : AiDotNet.Interfaces.IFullModel<int, int>
+                {
+                    [AiDotNet.Attributes.Scratch]
+                    private System.Collections.Generic.List<int> _layers = new();
+
+                    public LazyGraphModel(System.Collections.Generic.List<int>? layers = null)
+                    {
+                        _layers = layers is null
+                            ? new System.Collections.Generic.List<int>()
+                            : new System.Collections.Generic.List<int>(layers);
+                    }
+                }
+            }
+            """;
+
+        string generated = Run(new AiDotNet.Generators.ClonePlanGenerator(), source);
+
+        Assert.Contains("new[] { \"=default\" }", generated, StringComparison.Ordinal);
+        Assert.DoesNotContain("new[] { \"_layers\" }", generated, StringComparison.Ordinal);
+    }
+
     [Fact]
     public async Task LayerGenerator_AutoParametersDoesNotPromotePlainTensor()
     {
@@ -265,6 +587,69 @@ public partial class CompositeLayer<T> : AiDotNet.NeuralNetworks.Layers.LayerBas
         Assert.Contains("EnsureSubLayersRegistered", generated, StringComparison.Ordinal);
     }
 
+    [Fact]
+    public void LayerGenerator_MarksLegacyFlatParameterSnapshotsAsDerived()
+    {
+        const string source = @"
+using AiDotNet.Attributes;
+public sealed class Child<T> : AiDotNet.Interfaces.ILayer<T> { }
+[AutoParameters]
+public partial class LegacyComposite<T> : AiDotNet.NeuralNetworks.Layers.LayerBase<T>
+{
+    private Child<T> _child = new();
+
+    public LegacyComposite()
+    {
+        Parameters = GetParameters();
+    }
+}";
+
+        string generated = Run(new AiDotNet.Generators.TrainableParameterGenerator(), source);
+
+        Assert.Contains("LegacyParametersAreDerivedSnapshot => true", generated, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public async Task LayerGenerator_ExcludesAliasedChildFromOwnedStructure()
+    {
+        await Task.Yield();
+        const string source = @"
+using AiDotNet.Attributes;
+public sealed class Child<T> : AiDotNet.Interfaces.ILayer<T> { }
+[AutoParameters]
+public partial class CompositeLayer<T> : AiDotNet.NeuralNetworks.Layers.LayerBase<T>
+{
+    private Child<T> _owned = new();
+    [ParameterAlias(nameof(_owned))] private Child<T> _alias;
+}";
+
+        string generated = Run(new AiDotNet.Generators.TrainableParameterGenerator(), source);
+        Assert.Contains("RegisterSubLayer(_owned)", generated, StringComparison.Ordinal);
+        Assert.DoesNotContain("RegisterSubLayer(_alias)", generated, StringComparison.Ordinal);
+        Assert.DoesNotContain("DeclareParameterSubLayer(components, _alias", generated, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public async Task LayerGenerator_ExcludesNonOwningChildViewsFromOwnedStructure()
+    {
+        await Task.Yield();
+        const string source = @"
+using AiDotNet.Attributes;
+public sealed class Child<T> : AiDotNet.Interfaces.ILayer<T> { }
+[AutoParameters]
+public partial class CompositeLayer<T> : AiDotNet.NeuralNetworks.Layers.LayerBase<T>
+{
+    private Child<T> _owned = new();
+    [Scratch] private Child<T>[] _traversalView = [];
+    [ExternalState] private Child<T>? _external;
+}";
+
+        string generated = Run(new AiDotNet.Generators.TrainableParameterGenerator(), source);
+        Assert.Contains("RegisterSubLayer(_owned)", generated, StringComparison.Ordinal);
+        Assert.DoesNotContain("RegisterSubLayer(_traversalView)", generated, StringComparison.Ordinal);
+        Assert.DoesNotContain("RegisterSubLayer(_external)", generated, StringComparison.Ordinal);
+    }
+
     [Fact]
     public async Task LayerGenerator_BoundAdaptiveAxisSeparatesValidationFromManifestSizing()
     {
@@ -352,13 +737,13 @@ private void Configure() => RegisterTrainableParameter(
         Assert.Contains("_declared", generated, StringComparison.Ordinal);
         Assert.Contains("_registered", generated, StringComparison.Ordinal);
         // Fixed generated surfaces use one cached backing array rather than allocating an inline
-        // array on every read. Verify that partial declarations still merge into that stable view
-        // in declaration/registration order.
-        Assert.Contains("__storage[0] = _declared;", generated, StringComparison.Ordinal);
-        Assert.Contains("__storage[1] = _registered;", generated, StringComparison.Ordinal);
+        // array on every read. Runtime registration is the optimizer/tape order, so registrations
+        // discovered in another partial declaration lead declaration-only attributed storage.
+        Assert.Contains("__storage[0] = _registered;", generated, StringComparison.Ordinal);
+        Assert.Contains("__storage[1] = _declared;", generated, StringComparison.Ordinal);
         Assert.True(
-            generated.IndexOf("__storage[0] = _declared;", StringComparison.Ordinal)
-            < generated.IndexOf("__storage[1] = _registered;", StringComparison.Ordinal));
+            generated.IndexOf("__storage[0] = _registered;", StringComparison.Ordinal)
+            < generated.IndexOf("__storage[1] = _declared;", StringComparison.Ordinal));
     }
 
     [Fact]
@@ -398,6 +783,299 @@ public partial class CacheModel<T> : AiDotNet.Models.ModelBase<T, object, object
         Assert.DoesNotContain("_lastOutput", Run(new AiDotNet.Generators.ModelParameterGenerator(), source));
     }
 
+    [Fact]
+    public async Task ModelGenerator_DoesNotDuplicateManuallyRegisteredMember()
+    {
+        await Task.Yield();
+        const string source = @"
+using AiDotNet.Attributes;
+public partial class MigratingModel<T> : AiDotNet.Models.ModelBase<T, object, object>
+{
+    [FittedParameter]
+    private AiDotNet.Tensors.LinearAlgebra.Vector<T> _fitted = new();
+
+    protected override void RegisterComponents()
+    {
+        RegisterParameterComponent(_fitted);
+    }
+}";
+
+        Assert.DoesNotContain("_fitted", Run(new AiDotNet.Generators.ModelParameterGenerator(), source));
+    }
+
+    [Fact]
+    public async Task ModelGenerator_StillDiscoversUnclassifiedNestedComponent()
+    {
+        await Task.Yield();
+        const string source = @"
+public sealed class Component<T> : AiDotNet.Interfaces.IParameterSource<T> { }
+public partial class CompositeModel<T> : AiDotNet.Models.ModelBase<T, object, object>
+{
+    private Component<T> _child = new();
+}";
+
+        string generated = Run(new AiDotNet.Generators.ModelParameterGenerator(), source);
+        Assert.Contains("ComponentAccessorParameterSource<T>(() => _child)", generated, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public async Task ModelStateGenerator_DoesNotPersistRegistryLifecycleLatch()
+    {
+        await Task.Yield();
+        const string source = @"
+public partial class LifecycleModel<T> : AiDotNet.Models.ModelBase<T, object, object>
+{
+    private bool _componentsRegistered;
+    private bool _trained;
+}";
+
+        string generated = Run(new AiDotNet.Generators.ModelStateGenerator(), source);
+        Assert.DoesNotContain("_componentsRegistered", generated, StringComparison.Ordinal);
+        Assert.Contains("LifecycleModel._trained", generated, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void ModelStateGenerator_RebuildsDeclaredScratchCachesAfterParameterRestore()
+    {
+        const string source = @"
+using AiDotNet.Attributes;
+public partial class CachedModel<T> : AiDotNet.Models.ModelBase<T, object, object>
+{
+    [Scratch] private object? _weightCache;
+    private void RefreshWeightCaches() => _weightCache = new object();
+}";
+
+        string generated = Run(new AiDotNet.Generators.ModelStateGenerator(), source);
+
+        Assert.Contains(
+            "state.DeclareAfterParameterRestore(\"CachedModel.$derivedCache.RefreshWeightCaches\", RefreshWeightCaches);",
+            generated,
+            StringComparison.Ordinal);
+        Assert.DoesNotContain("CachedModel._weightCache", generated, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void ModelStateGenerator_DoesNotPersistReconstructibleFeatureServicesAsFittedState()
+    {
+        const string source = @"
+namespace AiDotNet.Interfaces
+{
+    public interface IAudioFeatureExtractor<T> { int FeatureDimension { get; } }
+}
+public sealed class FeatureExtractor<T> : AiDotNet.Interfaces.IAudioFeatureExtractor<T>
+{
+    public int FeatureDimension => 13;
+}
+public partial class AudioModel<T> : AiDotNet.Models.ModelBase<T, object, object>
+{
+    public FeatureExtractor<T>? Extractor { get; protected set; } = new();
+}";
+
+        string generated = Run(new AiDotNet.Generators.ModelStateGenerator(), source);
+
+        Assert.DoesNotContain("AudioModel.Extractor", generated, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public async Task ModelStateGenerator_RestoresReadonlyCollectionsInPlace()
+    {
+        await Task.Yield();
+        const string source = @"
+using System.Collections.Generic;
+public partial class OnlineModel<T> : AiDotNet.Models.ModelBase<T, object, object>
+{
+    private readonly List<T> _knownClasses = new();
+    private readonly Dictionary<int, ClassStats> _stats = new();
+    public long SamplesSeen { get; private set; }
+    private sealed class ClassStats { public long Count { get; set; } }
+}";
+
+        string generated = Run(new AiDotNet.Generators.ModelStateGenerator(), source);
+        Assert.Contains(
+            "state.DeclareObjectInPlace(\"OnlineModel._knownClasses\", () => _knownClasses);",
+            generated,
+            StringComparison.Ordinal);
+        Assert.Contains(
+            "state.DeclareObjectInPlace(\"OnlineModel._stats\", () => _stats);",
+            generated,
+            StringComparison.Ordinal);
+        Assert.Contains(
+            "state.DeclareInt64(\"OnlineModel.SamplesSeen\"",
+            generated,
+            StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public async Task ModelStateGenerator_DeclaresNestedObjectGraphsWithoutOverrides()
+    {
+        await Task.Yield();
+        const string source = @"
+using System.Collections.Generic;
+public partial class ForestModel<T> : AiDotNet.Models.ModelBase<T, object, object>
+{
+    private Node? _root;
+    private List<TreeRecord>? _trees;
+    private double[][]? _boundaries;
+    private sealed class Node { public Node? Left { get; set; } public double Value { get; set; } }
+    private sealed class TreeRecord { public Node? Root { get; set; } }
+}";
+
+        string generated = Run(new AiDotNet.Generators.ModelStateGenerator(), source);
+        Assert.Contains("ForestModel._root", generated, StringComparison.Ordinal);
+        Assert.Contains("state.DeclareObject(\"ForestModel._trees\"", generated, StringComparison.Ordinal);
+        Assert.Contains("state.DeclareObject(\"ForestModel._boundaries\"", generated, StringComparison.Ordinal);
+        Assert.DoesNotContain("RegisterState", generated, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public async Task ModelStateGenerator_DoesNotForceLegacyCollectionsIntoPartialMigration()
+    {
+        await Task.Yield();
+        const string source = @"
+using System.Collections.Generic;
+public class LegacyModel<T> : AiDotNet.Models.ModelBase<T, object, object>
+{
+    private readonly List<string> _configuration = new();
+}";
+
+        string generated = Run(new AiDotNet.Generators.ModelStateGenerator(), source);
+        Assert.DoesNotContain("LegacyModel", generated, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public async Task ModelStateGenerator_DoesNotJsonSerializeUnreconstructableCollections()
+    {
+        await Task.Yield();
+        const string source = @"
+using System.Collections.Generic;
+public partial class NetworkState<T> : AiDotNet.Models.ModelBase<T, object, object>
+{
+    private readonly List<AiDotNet.Interfaces.ILayer<T>> _layers = new();
+    private Dictionary<AiDotNet.Tensors.LinearAlgebra.Tensor<T>, AiDotNet.Tensors.LinearAlgebra.Vector<T>>
+        _gradients = new();
+    private readonly List<Record> _records = new();
+    private sealed class Record
+    {
+        public AiDotNet.Tensors.LinearAlgebra.Matrix<T> Covariance { get; set; } = new();
+    }
+}";
+
+        string generated = Run(new AiDotNet.Generators.ModelStateGenerator(), source);
+        Assert.DoesNotContain("_layers", generated, StringComparison.Ordinal);
+        Assert.DoesNotContain("_gradients", generated, StringComparison.Ordinal);
+        Assert.DoesNotContain("_records", generated, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public async Task ModelStateGenerator_RestoresReadonlyNumericCollectionsThroughBinaryState()
+    {
+        await Task.Yield();
+        const string source = @"
+using System.Collections.Generic;
+public partial class NumericCollectionState<T> : AiDotNet.Models.ModelBase<T, object, object>
+{
+    private readonly List<AiDotNet.Tensors.LinearAlgebra.Vector<T>> _vectors = new();
+    private readonly List<AiDotNet.Tensors.LinearAlgebra.Matrix<T>> _matrices = new();
+    private readonly List<AiDotNet.Tensors.LinearAlgebra.Tensor<T>> _tensors = new();
+    private readonly Dictionary<string, AiDotNet.Tensors.LinearAlgebra.Vector<T>> _byName = new();
+}";
+
+        string generated = Run(new AiDotNet.Generators.ModelStateGenerator(), source);
+        Assert.Contains("state.DeclareInPlace(\"NumericCollectionState._vectors\"", generated, StringComparison.Ordinal);
+        Assert.Contains("state.DeclareInPlace(\"NumericCollectionState._matrices\"", generated, StringComparison.Ordinal);
+        Assert.Contains("state.DeclareInPlace(\"NumericCollectionState._tensors\"", generated, StringComparison.Ordinal);
+        Assert.Contains("state.DeclareInPlace(\"NumericCollectionState._byName\"", generated, StringComparison.Ordinal);
+        Assert.DoesNotContain("DeclareObjectInPlace", generated, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public async Task ModelStateGenerator_PersistsTrainableStorageOnLegacyStateOnlyTrunk()
+    {
+        await Task.Yield();
+        const string source = @"
+public abstract partial class LegacyStateBase<T>
+{
+    protected virtual void RegisterGeneratedState(AiDotNet.Models.ModelStateRegistry<T> state)
+        => RegisterGeneratedStateCore(state);
+}
+public partial class LegacyTrainable<T> : LegacyStateBase<T>
+{
+    [AiDotNet.Attributes.TrainableParameter]
+    private AiDotNet.Tensors.LinearAlgebra.Vector<T> _weights = new();
+    [AiDotNet.Attributes.Buffer]
+    private AiDotNet.Tensors.LinearAlgebra.Vector<byte>? _quantized;
+    [AiDotNet.Attributes.Buffer]
+    private AiDotNet.Tensors.LinearAlgebra.Vector<double>? _scales;
+}";
+
+        string generated = Run(new AiDotNet.Generators.ModelStateGenerator(), source);
+        Assert.Contains(
+            "state.Declare(\"LegacyTrainable._weights\", () => _weights",
+            generated,
+            StringComparison.Ordinal);
+        Assert.Contains("state.DeclareByteVector(\"LegacyTrainable._quantized\"", generated, StringComparison.Ordinal);
+        Assert.Contains("state.DeclareDoubleVector(\"LegacyTrainable._scales\"", generated, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public async Task ModelStateGenerator_PreservesNativeDoublePrecisionAfterFlatVectorRestore()
+    {
+        await Task.Yield();
+        const string source = @"
+public partial class WideWorkingState<T> : AiDotNet.Models.ModelBase<T, object, object>
+{
+    [AiDotNet.Attributes.TrainableParameter]
+    private readonly double[] _weights = new double[4];
+    [AiDotNet.Attributes.TrainableParameter]
+    private readonly double[][] _matrix = new[] { new double[2] };
+    [AiDotNet.Attributes.TrainableParameter]
+    private double _bias;
+    [AiDotNet.Attributes.Buffer]
+    private readonly double[] _statistics = new double[2];
+}";
+
+        string generated = Run(new AiDotNet.Generators.ModelStateGenerator(), source);
+        Assert.Contains(
+            "state.DeclareExactInPlace(\"WideWorkingState._weights\"",
+            generated,
+            StringComparison.Ordinal);
+        Assert.Contains(
+            "state.DeclareExactInPlace(\"WideWorkingState._matrix\"",
+            generated,
+            StringComparison.Ordinal);
+        Assert.Contains(
+            "state.DeclareExactDouble(\"WideWorkingState._bias\"",
+            generated,
+            StringComparison.Ordinal);
+        Assert.Contains(
+            "state.DeclareExactInPlace(\"WideWorkingState._statistics\"",
+            generated,
+            StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public async Task ModelStateGenerator_DeclaresRecursiveGraphListsWithoutSerializationHelpers()
+    {
+        await Task.Yield();
+        const string source = @"
+using System.Collections.Generic;
+public partial class ForestState<T> : AiDotNet.Models.ModelBase<T, object, object>
+{
+    private List<Node> _trees = new();
+    private sealed class Node
+    {
+        public T Value { get; set; }
+        public Node? Left { get; set; }
+        public Node? Right { get; set; }
+        public Node(T zero) { Value = zero; }
+    }
+}";
+
+        string generated = Run(new AiDotNet.Generators.ModelStateGenerator(), source);
+        Assert.Contains("state.DeclareGraphList<global::ForestState<T>.Node>", generated, StringComparison.Ordinal);
+        Assert.Contains("new global::ForestState<T>.Node(default!)", generated, StringComparison.Ordinal);
+    }
+
     [Fact]
     public async Task ModelGenerator_EmitsDeclaredRoleAndAvailability()
     {
@@ -473,13 +1151,24 @@ public async Task ModelGenerator_EmitsTypeSafeCanonicalLayerAliasRebinding()
 using System.Collections.Generic;
 public partial class AliasNetwork<T> : AiDotNet.NeuralNetworks.NeuralNetworkBase<T>
 {
+    private sealed class OwnedLayer : AiDotNet.NeuralNetworks.Layers.LayerBase<T>, AiDotNet.Interfaces.ILayer<T> { }
+    [AiDotNet.Attributes.TrainableParameter]
+    private AiDotNet.Tensors.LinearAlgebra.Tensor<T>? _runtimeWeight;
     private AiDotNet.Interfaces.ILayer<T>? _head;
     private AiDotNet.Interfaces.ILayer<T> _required = null!;
     private readonly List<AiDotNet.Interfaces.ILayer<T>> _encoder = new();
+    private readonly List<OwnedLayer> _owned = new();
     private readonly AiDotNet.Interfaces.ILayer<T>? _readonlyAlias;
 }";
 
         string generated = Run(new AiDotNet.Generators.ModelParameterGenerator(), source);
+        Assert.Contains(
+            "protected override global::System.Collections.Generic.IEnumerable<global::AiDotNet.NeuralNetworks.Layers.LayerBase<T>?> GetExtraTrainableLayers()",
+            generated,
+            StringComparison.Ordinal);
+        Assert.Contains("foreach (var __layer in _owned ??", generated, StringComparison.Ordinal);
+        Assert.Contains("protected override global::System.Collections.Generic.IEnumerable<GeneratedAdditionalLayerGroup> GetGeneratedAdditionalLayerGroups()", generated,
+            StringComparison.Ordinal);
         Assert.Contains("protected override void RebindLayerAliases(", generated, StringComparison.Ordinal);
         Assert.Contains(
             "_head = RebindLayerAlias(_head, previousLayers, replacementLayers, nameof(_head));",
@@ -497,6 +1186,98 @@ public partial class AliasNetwork<T> : AiDotNet.NeuralNetworks.NeuralNetworkBase
             "ValidateReadonlyLayerAlias(_readonlyAlias, previousLayers, replacementLayers, nameof(_readonlyAlias));",
             generated,
             StringComparison.Ordinal);
+        Assert.Contains("protected override void CopyGeneratedLayerAliasesTo(", generated,
+            StringComparison.Ordinal);
+        Assert.Contains(
+            "__destination._head = CopyLayerAlias(_head, __destination._head, Layers, __destination.Layers, nameof(_head));",
+            generated,
+            StringComparison.Ordinal);
+        Assert.Contains(
+            "CopyLayerAliasCollection(_encoder, __destination._encoder, Layers, __destination.Layers, nameof(_encoder));",
+            generated,
+            StringComparison.Ordinal);
+        Assert.Contains("protected override void CopyGeneratedTrainableTensorsTo(", generated,
+            StringComparison.Ordinal);
+        Assert.Contains(
+            "__destination._runtimeWeight = CloneGeneratedTrainableTensor(_runtimeWeight);",
+            generated,
+            StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public async Task ModelStateGenerator_DoesNotPersistCanonicalNetworkLayerViewsTwice()
+    {
+        await Task.Yield();
+        const string source = @"
+using System.Collections.Generic;
+public sealed class ConcreteLayer<T> : AiDotNet.NeuralNetworks.Layers.LayerBase<T> { }
+public partial class StateNetwork<T> : AiDotNet.NeuralNetworks.NeuralNetworkBase<T>
+{
+    private ConcreteLayer<T>? _head;
+    private readonly List<ConcreteLayer<T>> _blocks = new();
+    private ConcreteLayer<T>[] _stages = System.Array.Empty<ConcreteLayer<T>>();
+    private bool _trained;
+}";
+
+        string generated = Run(new AiDotNet.Generators.ModelStateGenerator(), source);
+        Assert.Contains("StateNetwork._trained", generated, StringComparison.Ordinal);
+        Assert.DoesNotContain("StateNetwork._head", generated, StringComparison.Ordinal);
+        Assert.DoesNotContain("StateNetwork._blocks", generated, StringComparison.Ordinal);
+        Assert.DoesNotContain("StateNetwork._stages", generated, StringComparison.Ordinal);
+        Assert.DoesNotContain("DeclareLayerList", generated, StringComparison.Ordinal);
+        Assert.DoesNotContain("DeclareParameterSource", generated, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public async Task ModelStateGenerator_DoesNotPersistRegisteredParameterChildTwice()
+    {
+        await Task.Yield();
+        const string source = @"
+public sealed class SerializableChild : AiDotNet.Interfaces.IModelSerializer { }
+public partial class CompositeModel<T> : AiDotNet.Models.ModelBase<T, object, object>
+{
+    private SerializableChild _child = new();
+    private bool _trained;
+
+    protected override void RegisterComponents()
+    {
+        RegisterParameterComponent(_child);
+    }
+}";
+
+        string generated = Run(new AiDotNet.Generators.ModelStateGenerator(), source);
+        Assert.Contains("CompositeModel._trained", generated, StringComparison.Ordinal);
+        Assert.DoesNotContain("CompositeModel._child", generated, StringComparison.Ordinal);
+        Assert.DoesNotContain("DeclareChild", generated, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public async Task ModelStateGenerator_ImplementsCommonAbstractSerializationSurface()
+    {
+        await Task.Yield();
+        const string source = @"
+public abstract partial class GeneratedSerializationBase<T>
+    : AiDotNet.Models.ModelBase<T, object, object>
+{
+    public abstract byte[] Serialize();
+    public abstract void Deserialize(byte[] data);
+    protected byte[] SerializeGeneratedModelState() => System.Array.Empty<byte>();
+    protected void DeserializeGeneratedModelState(byte[] data) { }
+}
+public partial class GeneratedSerializationModel<T> : GeneratedSerializationBase<T>
+{
+    private bool _trained;
+}";
+
+        string generated = Run(new AiDotNet.Generators.ModelStateGenerator(), source);
+        Assert.Contains(
+            "public override byte[] Serialize() => SerializeGeneratedModelState();",
+            generated,
+            StringComparison.Ordinal);
+        Assert.Contains(
+            "public override void Deserialize(byte[] data) => DeserializeGeneratedModelState(data);",
+            generated,
+            StringComparison.Ordinal);
     }
 
     [Fact]
@@ -515,6 +1296,8 @@ public partial class CompositeNetwork<T> : AiDotNet.NeuralNetworks.NeuralNetwork
         string generated = Run(new AiDotNet.Generators.ModelParameterGenerator(), source);
         Assert.Contains("EnumerateNestedNetworkLayers(_child)", generated, StringComparison.Ordinal);
         Assert.Contains("EnumerateNestedNetworkTensors(_child)", generated, StringComparison.Ordinal);
+        Assert.Contains("GetGeneratedNestedNetworkLayerViews", generated, StringComparison.Ordinal);
+        Assert.Contains("RebindNestedNetworkCanonicalLayerAliases(_child", generated, StringComparison.Ordinal);
         Assert.DoesNotContain("_child?.Layers", generated, StringComparison.Ordinal);
     }
 
@@ -700,4 +1483,59 @@ public partial class ConditionalExperts<T> : AiDotNet.NeuralNetworks.Layers.Laye
             generated,
             StringComparison.Ordinal);
     }
+
+    [Fact]
+    public void LayerGenerator_InfersInputDepthFromDeclaredChannelAxis()
+    {
+        const string source = @"
+using AiDotNet.Attributes;
+using AiDotNet.Enums;
+[TensorLayout(TensorAxis.Batch, TensorAxis.Height, TensorAxis.Width, TensorAxis.Channels,
+    BatchOptional = true, Direction = TensorLayoutDirection.Input)]
+[TensorLayout(TensorAxis.Batch, TensorAxis.Height, TensorAxis.Width, TensorAxis.Channels,
+    BatchOptional = true, Direction = TensorLayoutDirection.Output)]
+[AutoParameters]
+public partial class ChannelsLastLayer<T> : AiDotNet.NeuralNetworks.Layers.LayerBase<T>
+{
+    private int _inputDepth = -1;
+    [TrainableParameter]
+    private AiDotNet.Tensors.LinearAlgebra.Tensor<T> _weights = new();
+
+    private void Allocate()
+    {
+        _weights = Create([_inputDepth, 3]);
+    }
+
+    private AiDotNet.Tensors.LinearAlgebra.Tensor<T> Create(int[] shape) => new();
+}";
+
+        string generated = Run(new AiDotNet.Generators.TrainableParameterGenerator(), source);
+
+        Assert.Contains("InputShape[InputShape.Length - 1], 3", generated, StringComparison.Ordinal);
+        Assert.DoesNotContain("InputShape[0], 3", generated, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void ModelGenerator_DiscoversConventionalNestedLayerOwners()
+    {
+        const string source = @"
+using System.Collections.Generic;
+internal sealed class OwnedLayer<T> : AiDotNet.NeuralNetworks.Layers.LayerBase<T>, AiDotNet.Interfaces.ILayer<T> { }
+internal sealed class LayerBlock<T>
+{
+    private readonly OwnedLayer<T> _layer = new();
+    internal IEnumerable<OwnedLayer<T>> EnumerateLayers() { yield return _layer; }
+}
+public partial class EncapsulatedNetwork<T> : AiDotNet.NeuralNetworks.NeuralNetworkBase<T>
+{
+    private readonly LayerBlock<T> _stem = new();
+    private readonly List<LayerBlock<T>> _stages = new();
+}";
+
+        string generated = Run(new AiDotNet.Generators.ModelParameterGenerator(), source);
+
+        Assert.Contains("_stem.EnumerateLayers()", generated, StringComparison.Ordinal);
+        Assert.Contains("SelectMany(__owner => __owner.EnumerateLayers())", generated,
+            StringComparison.Ordinal);
+    }
 }
diff --git a/tests/AiDotNet.Tests/Helpers/ModelPersistenceGuardTests.cs b/tests/AiDotNet.Tests/Helpers/ModelPersistenceGuardTests.cs
index c6f33df530..5db568e660 100644
--- a/tests/AiDotNet.Tests/Helpers/ModelPersistenceGuardTests.cs
+++ b/tests/AiDotNet.Tests/Helpers/ModelPersistenceGuardTests.cs
@@ -22,7 +22,7 @@ namespace AiDotNet.Tests.Helpers;
 /// Tests run sequentially via [Collection] to avoid env var races.
 /// </remarks>
 [Collection("License")]
-public class ModelPersistenceGuardTests : IDisposable
+public partial class ModelPersistenceGuardTests : IDisposable
 {
     private readonly string _tempDir;
     private readonly string _trialFilePath;
@@ -870,7 +870,7 @@ public async Task DeepCopy_Output_Serialize_StillFiresGuard()
     /// DeepCopy's serialization path does NOT invoke this override — i.e.
     /// the user override is only reachable from the public virtual call.
     /// </summary>
-    private sealed class ExfilTrackingFeedForward : FeedForwardNeuralNetwork<double>
+    private sealed partial class ExfilTrackingFeedForward : FeedForwardNeuralNetwork<double>
     {
         public int SerializeOverrideCalls { get; private set; }
 
@@ -913,25 +913,30 @@ public async Task DeepCopy_DoesNotRouteThroughUserOverrideOfSerialize()
         Assert.NotNull(copy);
         Assert.Equal(before, network.SerializeOverrideCalls);
 
-        // Contract: DeepCopy round-trips through private
-        // SerializeInternalUnchecked / Deserialize. The serialized bytes
-        // carry only the base-class layer catalogue, so the concrete type
-        // reconstructed by Deserialize is always the declared base —
-        // user subclasses such as ExfilTrackingFeedForward are
-        // intentionally NOT preserved. That property IS the defence:
-        //   (a) Primary invariant — the original's override counter never
-        //       incremented during DeepCopy (checked above at line 785).
-        //   (b) Secondary invariant — the returned copy is the base
-        //       FeedForwardNeuralNetwork type, so there is no subclass
-        //       override on the copy that could be invoked even in theory.
+        // THE REFACTOR THIS TEST WARNED ABOUT HAS HAPPENED, and it is an improvement rather than a
+        // regression. The copy used to come back as the declared base, because a plan built by
+        // reflection carried properties and no constructors, so a type the generator never saw --
+        // every subclass declared outside this library, this one included -- could only be rebuilt if
+        // it happened to have a parameterless constructor. CloneRegistry now derives the constructor
+        // by the generator's own rules, so DeepCopy returns a copy of the SAME runtime type, which is
+        // what a deep copy has always been supposed to mean.
         //
-        // This assertion is deliberately unconditional: if a future
-        // refactor teaches DeepCopy to preserve subclass identity, this
-        // test must fail loudly rather than silently skip its second half —
-        // because at that point an explicit check on
-        // `((ExfilTrackingFeedForward)copy).SerializeOverrideCalls == 0`
-        // must be added to keep the exfil guarantee.
-        Assert.IsType<FeedForwardNeuralNetwork<double>>(copy);
+        // The old comment named the price of that change exactly: losing subclass identity was being
+        // used as the second line of defence, so restoring identity means checking the guarantee
+        // directly instead of inferring it from the type. Both invariants are now asserted on their
+        // own terms:
+        //   (a) the ORIGINAL's override counter never moved during DeepCopy (checked above)
+        //   (b) the COPY's counter MATCHES the original's -- no invocation happened on either side
+        //
+        // Matches rather than equals zero, and that is the honest assertion rather than the tidy one.
+        // SerializeOverrideCalls is `{ get; private set; }`, so it is a readable and writable property,
+        // and a plan built by reflection carries exactly those as configuration -- everything is
+        // configuration unless provably otherwise. The copy therefore inherits the original's count of
+        // 1 by being copied, not by anything calling Serialize on it. Demanding zero would be
+        // demanding that the clone NOT be a faithful copy, which is a different property than the one
+        // this test exists to defend.
+        var typed = Assert.IsType<ExfilTrackingFeedForward>(copy);
+        Assert.Equal(network.SerializeOverrideCalls, typed.SerializeOverrideCalls);
     }
 
     // ---------------------------------------------------------------------
diff --git a/tests/AiDotNet.Tests/IntegrationTests/Cloning/AllLayersCloneTests.cs b/tests/AiDotNet.Tests/IntegrationTests/Cloning/AllLayersCloneTests.cs
new file mode 100644
index 0000000000..b21137a102
--- /dev/null
+++ b/tests/AiDotNet.Tests/IntegrationTests/Cloning/AllLayersCloneTests.cs
@@ -0,0 +1,279 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Reflection;
+using System.Threading.Tasks;
+using AiDotNet.Attributes;
+using AiDotNet.NeuralNetworks.Layers;
+using Xunit;
+using Xunit.Abstractions;
+
+namespace AiDotNet.Tests.IntegrationTests.Cloning;
+
+/// <summary>
+/// Sweeps every layer type through the clone adapter to find which cannot be rebuilt.
+/// </summary>
+/// <remarks>
+/// <para>
+/// The coverage number explains how much the harness reached, while every reached layer is a hard
+/// correctness gate. A layer whose required constructor arguments are not marked <c>[LayerState]</c>
+/// has no generated factory, so it cannot be rebuilt — and the only way to know how many of those
+/// there are is to try all of them.
+/// </para>
+/// <para>
+/// Construction arguments come from <c>[LayerProperty(TestConstructorArgs = ...)]</c>, which 156 of
+/// 189 layers already declare for test generation. That value is C# source text rather than runtime
+/// metadata, so only simple numeric arguments can be coerced here; anything else is counted as
+/// unconstructible-by-this-test and reported separately from a genuine clone failure. Conflating
+/// the two would let a shortfall in the harness read as a shortfall in the feature.
+/// </para>
+/// </remarks>
+public class AllLayersCloneTests
+{
+    private readonly ITestOutputHelper _output;
+
+    /// <summary>Initializes a new instance of the <see cref="AllLayersCloneTests"/> class.</summary>
+    /// <param name="output">Sink for the coverage summary.</param>
+    public AllLayersCloneTests(ITestOutputHelper output) => _output = output;
+
+    /// <summary>
+    /// Reports how many layer types can be rebuilt by the clone adapter.
+    /// </summary>
+    /// <returns>A task representing the test.</returns>
+    [Fact(Timeout = 600000)]
+    public async Task EveryLayer_ReportsWhetherItCanBeCloned()
+    {
+        await Task.Yield();
+
+        var layerBase = typeof(LayerBase<>);
+        var candidates = layerBase.Assembly.GetTypes()
+            .Where(t => t.IsClass && !t.IsAbstract && !t.IsNested)
+            .Where(t => t.IsGenericTypeDefinition && t.GetGenericArguments().Length == 1)
+            .Where(t => DerivesFromLayerBase(t))
+            .OrderBy(t => t.Name, StringComparer.Ordinal)
+            .ToList();
+
+        var cloned = new List<string>();
+        var failed = new List<string>();
+        var notConstructed = new List<string>();
+
+        // COUNTED AND REPORTED, because the first attempt at forwarding silently did nothing and
+        // produced a number identical to the unforwarded run. If this reads 0, the probe never
+        // fired and the coverage figure below is measuring unresolved layers again.
+        var forwarded = new List<string>();
+
+        foreach (var open in candidates)
+        {
+            Type closed;
+            try
+            {
+                closed = open.MakeGenericType(typeof(double));
+            }
+            catch (Exception)
+            {
+                notConstructed.Add($"{open.Name}: constraints reject double");
+                continue;
+            }
+
+            var instance = TryConstruct(closed);
+            if (instance is null)
+            {
+                notConstructed.Add($"{open.Name}: no usable TestConstructorArgs");
+                continue;
+            }
+
+            try
+            {
+                // FORWARD FIRST. Cloning an unforwarded layer compares two unresolved layers that
+                // trivially agree at zero parameters, which is why this sweep read 119/0 while the
+                // trained-layer proof was failing. A layer that has been USED is the case worth
+                // measuring.
+                var typed = (LayerBase<double>)instance;
+                if (Forward(typed)) forwarded.Add(open.Name);
+
+                // LayerBase declares Clone as a public virtual instance method, which is the
+                // surviving mechanism after #1789 replaced this branch's LayerCloning extension with
+                // LayerStateGenerator's generated factory. The sweep itself is unchanged: construct
+                // every layer, forward it, clone it, and require the clone to be the same type.
+                var clone = typed.Clone();
+                if (clone is null)
+                {
+                    failed.Add($"{open.Name}: clone returned null");
+                    continue;
+                }
+
+                if (clone.GetType() != closed)
+                {
+                    failed.Add($"{open.Name}: clone is {clone.GetType().Name}");
+                    continue;
+                }
+
+                cloned.Add(open.Name);
+            }
+            catch (Exception ex)
+            {
+                var message = (ex.InnerException ?? ex).Message;
+                failed.Add($"{open.Name}: {(ex.InnerException ?? ex).GetType().Name}: "
+                    + message.Substring(0, Math.Min(90, message.Length)));
+            }
+        }
+
+        _output.WriteLine($"layer types        : {candidates.Count}");
+        _output.WriteLine($"cloned OK          : {cloned.Count}");
+        _output.WriteLine($"clone FAILED       : {failed.Count}");
+        _output.WriteLine($"not constructed    : {notConstructed.Count} (harness limit, not a clone result)");
+        _output.WriteLine($"forwarded first    : {forwarded.Count} of {cloned.Count + failed.Count} attempted");
+        _output.WriteLine(string.Empty);
+
+        foreach (var f in failed.Take(40)) _output.WriteLine("  FAIL  " + f);
+        foreach (var n in notConstructed.Take(15)) _output.WriteLine("  skip  " + n);
+
+        // A REPORT FILE, not just ITestOutputHelper. xunit surfaces the helper only on a failing
+        // test or under `verbosity=detailed`, and detailed logs all 72,235 discovered cases -- 18MB
+        // per run to read five lines out of. Nine parallel runs of that filled the system drive to
+        // zero bytes free. Writing the summary here means the run needs no console logger at all.
+        // AIDOTNET_SWEEP_DIR redirects it off the system drive when that drive is short.
+        var dir = Environment.GetEnvironmentVariable("AIDOTNET_SWEEP_DIR");
+        if (string.IsNullOrEmpty(dir)) dir = System.IO.Path.GetTempPath();
+
+        var report = new List<string>
+        {
+            $"layer types        : {candidates.Count}",
+            $"cloned OK          : {cloned.Count}",
+            $"clone FAILED       : {failed.Count}",
+            $"not constructed    : {notConstructed.Count} (harness limit, not a clone result)",
+            $"forwarded first    : {forwarded.Count} of {cloned.Count + failed.Count} attempted",
+            string.Empty,
+        };
+        report.AddRange(failed.Select(f => $"FAIL  {f}"));
+        report.AddRange(notConstructed.Select(n => $"skip  {n}"));
+        System.IO.File.WriteAllLines(
+            System.IO.Path.Combine(dir, "aidotnet-layer-clone-sweep.txt"), report);
+
+        // Coverage can grow without pinning a brittle count, but every layer the harness actually
+        // reaches must clone. The previous measurement-only assertion let a non-zero failure list
+        // produce a green test, which made the sweep documentation rather than regression proof.
+        Assert.NotEmpty(cloned);
+        Assert.True(
+            failed.Count == 0,
+            $"{failed.Count} constructed layer(s) failed cloning:{Environment.NewLine}"
+                + string.Join(Environment.NewLine, failed));
+    }
+
+    private static bool DerivesFromLayerBase(Type type)
+    {
+        for (var b = type.BaseType; b is not null; b = b.BaseType)
+        {
+            if (b.IsGenericType && b.GetGenericTypeDefinition().Name == "LayerBase`1") return true;
+            if (b.Name == "LayerBase`1") return true;
+        }
+
+        return false;
+    }
+
+    /// <summary>
+    /// Builds a layer from its declared test constructor arguments, when they can be coerced.
+    /// </summary>
+    /// <returns>The instance, or null when this harness cannot supply the arguments.</returns>
+    /// <remarks>
+    /// Only simple numeric literals are handled. Returning null rather than guessing keeps an
+    /// unconstructible layer out of the failure count, since being unable to build a layer here
+    /// says nothing about whether it clones.
+    /// </remarks>
+    /// <summary>Pushes one probe through the layer so a lazy width resolves. True if it ran.</summary>
+    /// <remarks>
+    /// <para>
+    /// The declared shape CANNOT be used as the probe. A lazy layer declares <c>[-1]</c> for the
+    /// axis it has not resolved yet, so a guard of <c>shape[0] > 0</c> skips precisely the layers
+    /// that needed forwarding, and the sweep reports on unresolved layers while appearing to have
+    /// forwarded them. That mistake cost two runs -- the same wrong assumption that made
+    /// <c>ResolveShapesOnly</c> a no-op.
+    /// </para>
+    /// <para>
+    /// So every non-positive axis becomes a small concrete size, and both shape conventions are
+    /// tried: layers whose declared shape excludes the batch axis, and layers whose shape includes
+    /// it. The first probe that does not throw wins.
+    /// </para>
+    /// </remarks>
+    private static bool Forward(LayerBase<double> layer)
+    {
+        int[] declared;
+        try
+        {
+            declared = layer.GetInputShape();
+        }
+        catch (Exception)
+        {
+            return false;
+        }
+
+        if (declared is null || declared.Length == 0) return false;
+
+        var concrete = new int[declared.Length];
+        for (var i = 0; i < declared.Length; i++) concrete[i] = declared[i] > 0 ? declared[i] : 4;
+
+        // Batch-prefixed first: GetInputShape describes ONE sample for most layers here.
+        var batched = new int[concrete.Length + 1];
+        batched[0] = 1;
+        Array.Copy(concrete, 0, batched, 1, concrete.Length);
+
+        foreach (var probe in new[] { batched, concrete })
+        {
+            try
+            {
+                layer.Forward(new Tensor<double>(probe));
+                return true;
+            }
+            catch (Exception)
+            {
+                // Try the other convention; a layer that refuses both is measured unforwarded.
+            }
+        }
+
+        return false;
+    }
+
+    private static object? TryConstruct(Type closed)
+    {
+        var attribute = closed.GetCustomAttributes(inherit: false)
+            .OfType<LayerPropertyAttribute>()
+            .FirstOrDefault();
+
+        var raw = attribute?.TestConstructorArgs;
+        if (string.IsNullOrWhiteSpace(raw)) return null;
+
+        var literals = raw!.Split(',').Select(s => s.Trim()).ToArray();
+        if (literals.Any(l => !int.TryParse(l, NumberStyles.Integer, CultureInfo.InvariantCulture, out _)))
+        {
+            return null;
+        }
+
+        var values = literals
+            .Select(l => int.Parse(l, NumberStyles.Integer, CultureInfo.InvariantCulture))
+            .ToArray();
+
+        foreach (var ctor in closed.GetConstructors().OrderBy(c => c.GetParameters().Length))
+        {
+            var parameters = ctor.GetParameters();
+            if (parameters.Length < values.Length) continue;
+            if (parameters.Take(values.Length).Any(p => p.ParameterType != typeof(int))) continue;
+            if (parameters.Skip(values.Length).Any(p => !p.IsOptional)) continue;
+
+            var args = new object?[parameters.Length];
+            for (int i = 0; i < values.Length; i++) args[i] = values[i];
+            for (int i = values.Length; i < parameters.Length; i++) args[i] = Type.Missing;
+
+            try
+            {
+                return ctor.Invoke(BindingFlags.OptionalParamBinding, binder: null, args, culture: null);
+            }
+            catch (Exception)
+            {
+                // Try the next overload rather than declaring the layer unconstructible.
+            }
+        }
+
+        return null;
+    }
+}
diff --git a/tests/AiDotNet.Tests/IntegrationTests/Cloning/AllModelsCloneTests.cs b/tests/AiDotNet.Tests/IntegrationTests/Cloning/AllModelsCloneTests.cs
new file mode 100644
index 0000000000..42fbfc2b6b
--- /dev/null
+++ b/tests/AiDotNet.Tests/IntegrationTests/Cloning/AllModelsCloneTests.cs
@@ -0,0 +1,388 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using AiDotNet.Enums;
+using AiDotNet.Interfaces;
+using AiDotNet.NeuralNetworks;
+using AiDotNet.Tensors.LinearAlgebra;
+using Xunit;
+using Xunit.Abstractions;
+
+namespace AiDotNet.Tests.IntegrationTests.Cloning;
+
+/// <summary>
+/// Sweeps every model through DeepCopy to find which ones lose construction state.
+/// </summary>
+/// <remarks>
+/// <para>
+/// The point is the coverage number, not a pass, for the same reason the layer sweep exists: a
+/// green build says nothing about whether a clone carries what it was built with.
+/// </para>
+/// <para>
+/// DeepCopy now rebuilds a model from its generated construction plan and generated state payload.
+/// Concrete models have no factory, clone, or serialization override to keep synchronized with
+/// their constructors. What this measures is how many models survive that shared round trip with
+/// their parameter count and architecture intact, and stay independent of the original afterwards.
+/// </para>
+/// <para>
+/// Models that cannot be constructed from a standard architecture are reported separately from
+/// models that fail to clone. Conflating a shortfall in this harness with a shortfall in the
+/// feature is how a coverage number stops meaning anything.
+/// </para>
+/// </remarks>
+public class AllModelsCloneTests
+{
+    private readonly ITestOutputHelper _output;
+
+    /// <summary>Initializes a new instance of the <see cref="AllModelsCloneTests"/> class.</summary>
+    /// <param name="output">Sink for the coverage summary.</param>
+    public AllModelsCloneTests(ITestOutputHelper output) => _output = output;
+
+    /// <summary>Returned by <see cref="Attempt"/> for a model this harness cannot build.</summary>
+    private const string SkipMarker = "\0skip";
+
+    /// <summary>How many shards the model list is split across.</summary>
+    /// <remarks>
+    /// The sweep is split rather than given a longer clock. One run over every model needed more
+    /// than the 45-minute ceiling a shard gets, and a single test that cannot finish inside its
+    /// budget reports nothing at all -- the 15-minute attempt died at the letter C. Sharding also
+    /// lets the runner work on them in parallel, so the wall-clock is one shard, not the sum.
+    /// </remarks>
+    private const int ShardCount = 24;
+
+    private string ReportPath =
+        System.IO.Path.Combine(System.IO.Path.GetTempPath(), "aidotnet-model-clone-sweep.txt");
+
+    private readonly List<string> cloned = new();
+    private readonly List<string> failed = new();
+    private readonly List<string> notConstructed = new();
+    private readonly List<string> budgetExceeded = new();
+
+    /// <summary>Maximum observation window for one model in this diagnostic sweep.</summary>
+    /// <remarks>
+    /// Exceeding this budget is deliberately not called a hang. The number is a property of this
+    /// harness and runner capacity; changing it changes the count without changing model behavior.
+    /// </remarks>
+    private static readonly TimeSpan PerModelProbeBudget = TimeSpan.FromSeconds(20);
+
+    /// <summary>
+    /// Models whose original never materialized under the probe, so the two sides are not comparable.
+    /// </summary>
+    /// <remarks>
+    /// A HARNESS LIMIT, kept out of the failure count for the same reason <see cref="notConstructed"/>
+    /// is. The probe below is a 1x4 tensor; a vision-language model refuses it, so the original sits
+    /// at whatever its constructor sized while DeepCopy returns a copy that has materialized. The
+    /// sweep read that as "BlipNeuralNetwork: 23441664 parameters against 768" and counted a
+    /// failure, when what it had actually measured was one side resolved and the other not. Nothing
+    /// is known about those models' cloning either way until the harness can drive them with an
+    /// input they accept -- which is a statement about this test, not about the copy.
+    /// </remarks>
+    private readonly List<string> unresolved = new();
+
+    /// <summary>Appends one line to the progress file as the sweep runs.</summary>
+    /// <remarks>
+    /// Written as it goes rather than at the end. The first two runs timed out having written
+    /// nothing, which said only that the sweep was slow and not which model it was stuck on.
+    /// </remarks>
+    private void Note(string line)
+    {
+        lock (ReportPath) System.IO.File.AppendAllLines(ReportPath, new[] { line });
+    }
+
+    private string Fail(Type open, string why)
+    {
+        var line = $"{open.Name}: {why}";
+        Note($"FAIL  {line}");
+        return line;
+    }
+
+    /// <summary>Reports how many models survive a DeepCopy with their construction state.</summary>
+    /// <returns>A task representing the test.</returns>
+    // ONE SHARD, WELL INSIDE THE CEILING. The single-test version died at CTCSegmentation after 15
+    // minutes -- 104 of 200+ models -- and raising its clock past the 45-minute shard ceiling would
+    // only have moved where it died. Each shard now takes 1/24th of the list; 8 shards still overran.
+    [Theory(Timeout = 900000)]
+    [InlineData(0)]
+    [InlineData(1)]
+    [InlineData(2)]
+    [InlineData(3)]
+    [InlineData(4)]
+    [InlineData(5)]
+    [InlineData(6)]
+    [InlineData(7)]
+    [InlineData(8)]
+    [InlineData(9)]
+    [InlineData(10)]
+    [InlineData(11)]
+    [InlineData(12)]
+    [InlineData(13)]
+    [InlineData(14)]
+    [InlineData(15)]
+    [InlineData(16)]
+    [InlineData(17)]
+    [InlineData(18)]
+    [InlineData(19)]
+    [InlineData(20)]
+    [InlineData(21)]
+    [InlineData(22)]
+    [InlineData(23)]
+    public async System.Threading.Tasks.Task EveryModel_ReportsWhetherItSurvivesADeepCopy(int shard)
+    {
+        await System.Threading.Tasks.Task.Yield();
+
+        // ONE SHARD PER PROCESS. `dotnet test --filter` cannot reliably address an individual
+        // [InlineData] case, so parallel runs each executed every shard and overwrote one
+        // another's report. The runner sets AIDOTNET_SWEEP_SHARD and the shards that do not
+        // match return immediately, so each process does 1/24th of the work and owns one file.
+        // Unset means run every shard, which is what a plain `dotnet test` should still do.
+        var only = Environment.GetEnvironmentVariable("AIDOTNET_SWEEP_SHARD");
+        if (!string.IsNullOrEmpty(only) && int.TryParse(only, out var wanted) && wanted != shard) return;
+
+        // AIDOTNET_SWEEP_DIR keeps the reports off the system drive, which nine parallel runs
+        // filled to zero bytes free.
+        var dir = Environment.GetEnvironmentVariable("AIDOTNET_SWEEP_DIR");
+        if (string.IsNullOrEmpty(dir)) dir = System.IO.Path.GetTempPath();
+
+        ReportPath = System.IO.Path.Combine(dir, $"aidotnet-model-clone-sweep-{shard}.txt");
+
+        var all = typeof(NeuralNetworkBase<>).Assembly.GetTypes()
+            .Where(t => t.IsClass && !t.IsAbstract && !t.IsNested)
+            .Where(t => t.IsGenericTypeDefinition && t.GetGenericArguments().Length == 1)
+            .Where(DerivesFromNeuralNetworkBase)
+            .OrderBy(t => t.Name, StringComparer.Ordinal)
+            .ToList();
+
+        // STRIDED, not carved into contiguous blocks. The expensive models cluster by name (the
+        // whole BLIP/Blip2/BLIP3 family lands together), so contiguous blocks would put every slow
+        // one in the same shard and leave that shard timing out while the others idle.
+        var candidates = all.Where((_, i) => i % ShardCount == shard).ToList();
+
+        // APPENDED AS IT GOES. The first run timed out at 15 minutes with nothing written, which
+        // told us only that the sweep is slow -- not which model it was on. A progress file costs
+        // nothing and turns a timeout into a result plus a culprit.
+        System.IO.File.WriteAllText(ReportPath, string.Empty);
+
+
+        foreach (var open in candidates)
+        {
+            Type closed;
+            try
+            {
+                closed = open.MakeGenericType(typeof(float));
+            }
+            catch (Exception)
+            {
+                notConstructed.Add($"{open.Name}: constraints reject float"); Note($"skip  {open.Name}: constraints reject float");
+                continue;
+            }
+
+            // BEFORE the attempt, so a shard-level timeout still names the model it was observing.
+            Note($"try   {open.Name}");
+
+            // A BUDGET PER MODEL. This keeps one slow or stuck attempt from consuming the whole
+            // shard, but it is only an observation budget. It cannot distinguish a true deadlock
+            // from valid work that needs more time on this runner, so report it separately and do
+            // not turn the budget-sensitive count into a claimed hang rate.
+            string? outcome = null;
+            var work = System.Threading.Tasks.Task.Run(() => outcome = Attempt(open, closed));
+
+            if (!work.Wait(PerModelProbeBudget))
+            {
+                budgetExceeded.Add(
+                    $"{open.Name}: exceeded {PerModelProbeBudget.TotalSeconds:0}s observation budget");
+                Note($"LIMIT {open.Name}");
+                continue;
+            }
+
+            if (outcome is null) cloned.Add(open.Name);
+            else if (!ReferenceEquals(outcome, SkipMarker) && outcome != SkipMarker) failed.Add(outcome);
+        }
+
+        _output.WriteLine($"model types        : {candidates.Count}");
+        _output.WriteLine($"cloned OK          : {cloned.Count}");
+        _output.WriteLine($"clone FAILED       : {failed.Count}");
+        _output.WriteLine($"not constructed    : {notConstructed.Count} (harness limit, not a clone result)");
+        _output.WriteLine($"probe did not run  : {unresolved.Count} (harness limit, not a clone result)");
+        _output.WriteLine($"probe budget limit : {budgetExceeded.Count} (budget-sensitive; not a hang rate)");
+        _output.WriteLine(string.Empty);
+
+        foreach (var line in failed) _output.WriteLine($"FAIL  {line}");
+        foreach (var line in notConstructed) _output.WriteLine($"skip  {line}");
+        foreach (var line in unresolved) _output.WriteLine($"lazy  {line}");
+
+        // ALSO to a file. xunit only surfaces ITestOutputHelper on a failing test or under
+        // `verbosity=detailed`, and detailed logs every one of 72,000 discovered cases -- 17MB of
+        // noise to read four numbers out of. A report worth running is worth being able to read.
+        var report = new List<string>
+        {
+            $"model types        : {candidates.Count}",
+            $"cloned OK          : {cloned.Count}",
+            $"clone FAILED       : {failed.Count}",
+            $"not constructed    : {notConstructed.Count} (harness limit, not a clone result)",
+            $"probe did not run  : {unresolved.Count} (harness limit, not a clone result)",
+            $"probe budget limit : {budgetExceeded.Count} (budget-sensitive; not a hang rate)",
+            string.Empty,
+        };
+        report.AddRange(failed.Select(f => $"FAIL  {f}"));
+        report.AddRange(notConstructed.Select(n => $"skip  {n}"));
+        report.AddRange(unresolved.Select(u => $"lazy  {u}"));
+
+        report.AddRange(budgetExceeded.Select(t => $"LIMIT {t}"));
+        System.IO.File.WriteAllLines(ReportPath, report);
+    }
+
+    /// <summary>Constructs, copies and checks one model. Returns null when it cloned cleanly.</summary>
+    private string? Attempt(Type open, Type closed)
+    {
+        var model = TryConstruct(closed);
+        if (model is null)
+        {
+            notConstructed.Add($"{open.Name}: no constructor takes a standard architecture");
+            Note($"skip  {open.Name}: not constructible");
+            return SkipMarker;
+        }
+
+        try
+        {
+            var probed = Resolve(model);
+            var before = model.ParameterCount;
+            var copy = model.DeepCopy() as NeuralNetworkBase<float>;
+
+            if (copy is null) return Fail(open, "DeepCopy returned null");
+            if (copy.GetType() != closed) return Fail(open, $"copy is {copy.GetType().Name}");
+
+            Resolve(copy);
+
+            if (copy.ParameterCount != before)
+            {
+                // AN UNRESOLVED ORIGINAL IS NOT A FAILED COPY. Every model in this bucket reports
+                // the copy as the LARGER side -- DeepCopy materialized layers the original had left
+                // lazy because the probe never ran on it. Comparing those two counts measures
+                // materialization, not copying.
+                if (!probed)
+                {
+                    unresolved.Add($"{open.Name}: probe did not run ({copy.ParameterCount} against {before})");
+                    Note($"lazy  {open.Name}");
+                    return SkipMarker;
+                }
+
+                return Fail(open, $"{copy.ParameterCount} parameters against {before}");
+            }
+
+            if (ReferenceEquals(copy, model) || !IsIndependent(model, copy))
+                return Fail(open, "copy is not independent of the original");
+
+            Note($"ok    {open.Name}");
+            return null;
+        }
+        catch (Exception ex)
+        {
+            var inner = ex.InnerException ?? ex;
+            var message = inner.Message;
+            return Fail(open, $"{inner.GetType().Name}: {message.Substring(0, Math.Min(90, message.Length))}");
+        }
+        finally
+        {
+            (model as IDisposable)?.Dispose();
+        }
+    }
+
+    /// <summary>Runs one probe input through the model so lazy layers materialise.</summary>
+    /// <remarks>
+    /// A model that cannot accept the standard probe is left as it is; the comparison below then
+    /// still holds, because both sides are measured in the same unresolved state.
+    /// </remarks>
+    /// <returns>True when the probe ran, so the model's parameter surface is materialized.</returns>
+    private static bool Resolve(NeuralNetworkBase<float> model)
+    {
+        try
+        {
+            var input = new Tensor<float>(new[] { 1, 4 });
+            model.Predict(input);
+
+            return true;
+        }
+        catch (Exception)
+        {
+            // Not every model predicts from a 1x4 probe. Both sides get the same treatment, but the
+            // caller needs to KNOW that neither side was driven -- an unresolved original compared
+            // against a materialized copy is not a result about cloning.
+            return false;
+        }
+    }
+
+    /// <summary>Whether writing through one model leaves the other alone.</summary>
+    private static bool IsIndependent(
+        NeuralNetworkBase<float> original,
+        NeuralNetworkBase<float> copy)
+    {
+        var parameters = original.GetParameters();
+        if (parameters.Length == 0) return true;
+
+        var mutated = new Vector<float>(parameters.Length);
+        for (var i = 0; i < parameters.Length; i++) mutated[i] = parameters[i] + 1.0f;
+
+        copy.UpdateParameters(mutated);
+
+        var after = original.GetParameters();
+        for (var i = 0; i < after.Length; i++)
+        {
+            if (Math.Abs(after[i] - parameters[i]) > 1e-5f) return false;
+        }
+
+        return true;
+    }
+
+    private static NeuralNetworkBase<float>? TryConstruct(Type closed)
+    {
+        var architecture = new NeuralNetworkArchitecture<float>(
+            inputType: InputType.OneDimensional,
+            taskType: NeuralNetworkTaskType.Regression,
+            inputSize: 4,
+            outputSize: 2);
+
+        // The widest constructor whose every remaining argument is optional, so a model is built
+        // through the one carrying the most configuration rather than the narrowest.
+        foreach (var ctor in closed.GetConstructors()
+                     .OrderByDescending(c => c.GetParameters().Length))
+        {
+            var formal = ctor.GetParameters();
+            if (formal.Length == 0) continue;
+
+            var args = new object?[formal.Length];
+            var usable = true;
+
+            for (var i = 0; i < formal.Length && usable; i++)
+            {
+                if (formal[i].ParameterType.IsInstanceOfType(architecture)) args[i] = architecture;
+                else if (formal[i].HasDefaultValue) args[i] = formal[i].DefaultValue;
+                else usable = false;
+            }
+
+            if (!usable || args.All(a => a is null)) continue;
+
+            try
+            {
+                return ctor.Invoke(args) as NeuralNetworkBase<float>;
+            }
+            catch (Exception)
+            {
+                // A model that rejects the standard architecture is a harness limit, not a defect.
+            }
+        }
+
+        return null;
+    }
+
+    private static bool DerivesFromNeuralNetworkBase(Type type)
+    {
+        for (var b = type.BaseType; b is not null; b = b.BaseType)
+        {
+            if (b.IsGenericType && b.GetGenericTypeDefinition() == typeof(NeuralNetworkBase<>)) return true;
+            if (b.Name.StartsWith("NeuralNetworkBase", StringComparison.Ordinal)) return true;
+        }
+
+        return false;
+    }
+}
diff --git a/tests/AiDotNet.Tests/IntegrationTests/Cloning/CloneRoundTripTests.cs b/tests/AiDotNet.Tests/IntegrationTests/Cloning/CloneRoundTripTests.cs
new file mode 100644
index 0000000000..34710ee6d5
--- /dev/null
+++ b/tests/AiDotNet.Tests/IntegrationTests/Cloning/CloneRoundTripTests.cs
@@ -0,0 +1,383 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Threading.Tasks;
+using AiDotNet.AutoML;
+using AiDotNet.Models;
+using AiDotNet.Tensors.LinearAlgebra;
+using Xunit;
+using Xunit.Abstractions;
+
+namespace AiDotNet.Tests.IntegrationTests.Cloning;
+
+/// <summary>
+/// Proves that a clone carries every configuration property, and that the two instances are
+/// genuinely independent afterwards.
+/// </summary>
+/// <remarks>
+/// <para>
+/// Two assertions, because there are two distinct failure modes and neither one catches the other.
+/// A property that is never carried shows up as unequal values. A property carried by sharing a
+/// mutable container shows up as <i>equal</i> values that change together — invisible to a
+/// property-by-property comparison, and exactly the bug where configuring a clone silently
+/// reconfigures the original.
+/// </para>
+/// <para>
+/// Every property is set to a value distinguishable from its default first. Comparing two freshly
+/// constructed objects proves nothing: their properties already agree, so a clone that carried
+/// nothing at all would pass.
+/// </para>
+/// </remarks>
+public class CloneRoundTripTests
+{
+    private readonly ITestOutputHelper _output;
+
+    /// <summary>Initializes a new instance of the <see cref="CloneRoundTripTests"/> class.</summary>
+    /// <param name="output">Sink for the coverage summary.</param>
+    public CloneRoundTripTests(ITestOutputHelper output) => _output = output;
+
+    [Fact]
+    public void SerializationShell_DeclinesValueInvalidConstructorCandidate()
+    {
+        var original = new AutoMLEnsembleModel<double>();
+
+        var clone = Assert.IsType<AutoMLEnsembleModel<double>>(
+            CloneEngine.CopyConfiguration(original));
+
+        Assert.Empty(clone.Members);
+        Assert.Empty(clone.Weights);
+        Assert.Equal(original.PredictionType, clone.PredictionType);
+    }
+
+    /// <summary>
+    /// Round-trips every type holding a compile-time clone plan.
+    /// </summary>
+    /// <returns>A task representing the test.</returns>
+    /// <remarks>
+    /// Data-driven over the registry rather than one test method per type, so the suite gains a
+    /// single method rather than thousands — the full suite already runs 4731 tests and times out
+    /// under load. A failure still names the type and the property, so diagnosis is unaffected.
+    /// </remarks>
+    [Fact(Timeout = 600000)]
+    public async Task EveryPlannedType_RoundTripsAndStaysIndependent()
+    {
+        await Task.Yield();
+
+        // Touch the registry so the generated registrations load before enumeration.
+        _ = CloneRegistry.GetPlan(typeof(CloneRoundTripTests));
+
+        var types = CloneRegistry.VerifiedTypes().ToList();
+        Assert.True(types.Count > 0, "No generated clone plans were registered.");
+
+        var failures = new List<string>();
+        int cloned = 0, skipped = 0;
+
+        foreach (var registered in types)
+        {
+            if (registered.IsAbstract)
+            {
+                skipped++;
+                continue;
+            }
+
+            // The registry keys an open generic as typeof(Foo<>), which is what lets a closed
+            // instantiation resolve through it -- but Activator cannot instantiate an unbound
+            // generic. Nearly every options and layer type in this library is generic over its
+            // numeric type, so skipping them left two thirds of the planned types unexercised
+            // while the run still reported success.
+            var type = Close(registered);
+            if (type is null)
+            {
+                skipped++;
+                continue;
+            }
+
+            object original;
+            try
+            {
+                original = Activator.CreateInstance(type)!;
+            }
+            catch (Exception ex) when (ex is MissingMethodException or TargetInvocationException
+                or ArgumentException or NotSupportedException)
+            {
+                skipped++;
+                continue;
+            }
+
+            // Looked up by the CLOSED type: a PropertyInfo obtained from an open generic type
+            // definition cannot read or write an instance of a closed one. Until GetPlan resolves
+            // an open-generic registration against the closed type it is asked about, a closed
+            // generic falls through to the reflected plan -- so this exercises the engine and the
+            // fallback, but not yet the generated plan for these types.
+            var plan = CloneRegistry.GetPlan(type);
+            var populated = Populate(original, plan);
+
+            object clone;
+            try
+            {
+                clone = CloneEngine.CopyConfiguration(original);
+            }
+            catch (Exception ex)
+            {
+                Exception cause = ex;
+                while (cause.InnerException is not null) cause = cause.InnerException;
+                failures.Add($"{type.Name}: clone threw {cause.GetType().Name}: {cause.Message}");
+                continue;
+            }
+
+            cloned++;
+            CheckCarried(type, plan, original, clone, populated, failures);
+            CheckIndependent(type, plan, original, clone, populated, failures);
+        }
+
+        _output.WriteLine($"planned types : {types.Count}");
+        _output.WriteLine($"cloned        : {cloned}");
+        _output.WriteLine($"skipped       : {skipped} (abstract, open generic, or not constructible)");
+        _output.WriteLine($"failures      : {failures.Count}");
+
+        foreach (var failure in failures.Take(40))
+        {
+            _output.WriteLine("  " + failure);
+        }
+
+        Assert.True(
+            failures.Count == 0,
+            $"{failures.Count} of {cloned} cloned types failed. First: "
+            + string.Join(" | ", failures.Take(5)));
+    }
+
+    /// <summary>
+    /// Closes an open generic with a concrete numeric argument so it can be instantiated.
+    /// </summary>
+    /// <param name="type">A registered type, open or closed.</param>
+    /// <returns>A constructible type, or null when no argument satisfies its constraints.</returns>
+    /// <remarks>
+    /// <c>double</c> is used because these types are generic over their numeric type and are
+    /// overwhelmingly exercised at <c>double</c> in practice, so the closed form under test is the
+    /// one users actually construct. A type whose constraints reject it is reported as skipped
+    /// rather than quietly passed.
+    /// </remarks>
+    private static Type? Close(Type type)
+    {
+        if (!type.ContainsGenericParameters) return type;
+
+        var parameters = type.GetGenericArguments();
+
+        // Arguments are chosen by parameter NAME, not filled uniformly. These types are generic
+        // over a numeric type plus the shapes it operates on, so <double, double, double> is not
+        // merely unusual -- it is a combination the library explicitly rejects, and constructing it
+        // produced an exception from deep inside ModelHelper that looked like an engine fault.
+        var candidates = new List<Type[]>();
+        var byName = new Type[parameters.Length];
+        for (int i = 0; i < parameters.Length; i++)
+        {
+            byName[i] = parameters[i].Name switch
+            {
+                "TInput" => typeof(Matrix<double>),
+                "TOutput" => typeof(Vector<double>),
+                _ => typeof(double),
+            };
+        }
+
+        candidates.Add(byName);
+
+        // The supported pairings, in the order the library lists them, for parameters whose names
+        // carry no hint.
+        if (parameters.Length == 3)
+        {
+            candidates.Add(new[] { typeof(double), typeof(Matrix<double>), typeof(Vector<double>) });
+            candidates.Add(new[] { typeof(double), typeof(Tensor<double>), typeof(Tensor<double>) });
+            candidates.Add(new[] { typeof(double), typeof(Vector<double>), typeof(Vector<double>) });
+        }
+        else if (parameters.Length == 1)
+        {
+            candidates.Add(new[] { typeof(double) });
+        }
+
+        foreach (var arguments in candidates)
+        {
+            if (arguments.Length != parameters.Length) continue;
+
+            try
+            {
+                return type.MakeGenericType(arguments);
+            }
+            catch (Exception ex) when (ex is ArgumentException or NotSupportedException)
+            {
+                // Constraints reject this shape; try the next.
+            }
+        }
+
+        return null;
+    }
+
+    /// <summary>Asserts that each populated property survived the clone.</summary>
+    private static void CheckCarried(
+        Type type, ClonePlan plan, object original, object clone,
+        ISet<string> populated, ICollection<string> failures)
+    {
+        foreach (var entry in plan.Entries.Where(e => populated.Contains(e.Property.Name)))
+        {
+            object? before, after;
+            try
+            {
+                before = entry.Property.GetValue(original);
+                after = entry.Property.GetValue(clone);
+            }
+            catch (Exception)
+            {
+                continue;
+            }
+
+            if (!ValuesMatch(before, after))
+            {
+                failures.Add($"{type.Name}.{entry.Property.Name}: not carried ({Describe(before)} -> {Describe(after)})");
+            }
+        }
+    }
+
+    /// <summary>
+    /// Asserts that mutating the clone's containers cannot reach the original.
+    /// </summary>
+    /// <remarks>
+    /// This is the assertion a property-by-property comparison cannot make. Two properties holding
+    /// the same list are equal on every check and still wrong.
+    /// </remarks>
+    private static void CheckIndependent(
+        Type type, ClonePlan plan, object original, object clone,
+        ISet<string> populated, ICollection<string> failures)
+    {
+        foreach (var entry in plan.Entries.Where(e => e.Copy == CloneCopyKind.Deep))
+        {
+            if (!populated.Contains(entry.Property.Name)) continue;
+
+            if (entry.Property.GetValue(original) is not { } before) continue;
+            if (entry.Property.GetValue(clone) is not { } after) continue;
+
+            if (ReferenceEquals(before, after))
+            {
+                failures.Add(
+                    $"{type.Name}.{entry.Property.Name}: clone shares the original's instance, "
+                    + "so mutating one reconfigures the other");
+            }
+        }
+    }
+
+    /// <summary>
+    /// Sets every plan property to a value distinguishable from its default.
+    /// </summary>
+    /// <returns>The names actually populated; only those can be meaningfully asserted on.</returns>
+    private static ISet<string> Populate(object target, ClonePlan plan)
+    {
+        var populated = new HashSet<string>(StringComparer.Ordinal);
+
+        foreach (var entry in plan.Entries)
+        {
+            // The probe models what a creator can configure. Reflecting through a private setter
+            // can manufacture states the public API and every constructor reject -- for example a
+            // 39-voxel grid paired with eleven pooling blocks. Such a derived property remains in
+            // the plan so legitimate internal state can be carried, but it is not independently
+            // mutated by this public-configuration census.
+            if (entry.Property.SetMethod?.IsPublic != true) continue;
+
+            object? current;
+            try
+            {
+                current = entry.Property.GetValue(target);
+            }
+            catch (Exception)
+            {
+                // A getter that computes rather than returns; excluded from the probe rather than
+                // allowed to abort the whole run before it reports anything.
+                continue;
+            }
+
+            var value = SampleValue(entry.Property.PropertyType, current);
+            if (value is null) continue;
+
+            try
+            {
+                entry.Property.SetValue(target, value);
+                populated.Add(entry.Property.Name);
+            }
+            catch (Exception ex) when (ex is TargetInvocationException or ArgumentException)
+            {
+                // A validating setter rejecting a sample is a property this test cannot exercise,
+                // not a clone defect. Excluded from the assertions rather than reported as one.
+            }
+        }
+
+        return populated;
+    }
+
+    /// <summary>Produces a value of the given type that differs from <paramref name="current"/>.</summary>
+    private static object? SampleValue(Type type, object? current)
+    {
+        var underlying = Nullable.GetUnderlyingType(type) ?? type;
+
+        if (underlying.IsEnum)
+        {
+            var values = Enum.GetValues(underlying);
+            foreach (var candidate in values)
+            {
+                if (!Equals(candidate, current)) return candidate;
+            }
+
+            return null;
+        }
+
+        if (underlying == typeof(bool)) return !(current as bool? ?? false);
+        if (underlying == typeof(string)) return "clone-round-trip-probe";
+        if (underlying == typeof(int)) return (current as int? ?? 0) + 7;
+        if (underlying == typeof(long)) return (current as long? ?? 0L) + 7L;
+        if (underlying == typeof(double)) return (current as double? ?? 0d) + 0.375d;
+        if (underlying == typeof(float)) return (current as float? ?? 0f) + 0.375f;
+        if (underlying == typeof(decimal)) return (current as decimal? ?? 0m) + 0.375m;
+
+        if (underlying.IsArray && underlying.GetElementType() is { } element && element.IsValueType)
+        {
+            var array = Array.CreateInstance(element, 2);
+            var sample = SampleValue(element, null);
+            if (sample is null) return null;
+            array.SetValue(sample, 0);
+            array.SetValue(sample, 1);
+            return array;
+        }
+
+        if (underlying.IsGenericType && underlying.GetGenericTypeDefinition() == typeof(List<>))
+        {
+            var element2 = underlying.GetGenericArguments()[0];
+            var sample = SampleValue(element2, null);
+            if (sample is null) return null;
+
+            var list = (IList)Activator.CreateInstance(underlying)!;
+            list.Add(sample);
+            return list;
+        }
+
+        // Reference types with no obvious sample are left alone rather than guessed at. They are
+        // still covered by the carried-check when a default happens to be non-null.
+        return null;
+    }
+
+    private static bool ValuesMatch(object? a, object? b)
+    {
+        if (a is null || b is null) return ReferenceEquals(a, b);
+        if (a is IEnumerable ea and not string && b is IEnumerable eb and not string)
+        {
+            return ea.Cast<object?>().SequenceEqual(eb.Cast<object?>());
+        }
+
+        return Equals(a, b);
+    }
+
+    private static string Describe(object? value) => value switch
+    {
+        null => "null",
+        string s => $"\"{s}\"",
+        IEnumerable e and not string => "[" + string.Join(",", e.Cast<object?>().Take(4)) + "]",
+        _ => value.ToString() ?? "?",
+    };
+}
diff --git a/tests/AiDotNet.Tests/IntegrationTests/Cloning/DenseLayerCloneTests.cs b/tests/AiDotNet.Tests/IntegrationTests/Cloning/DenseLayerCloneTests.cs
new file mode 100644
index 0000000000..5d901c15e4
--- /dev/null
+++ b/tests/AiDotNet.Tests/IntegrationTests/Cloning/DenseLayerCloneTests.cs
@@ -0,0 +1,166 @@
+using System;
+using System.IO;
+using System.Threading.Tasks;
+using AiDotNet.ActivationFunctions;
+using AiDotNet.Interfaces;
+using AiDotNet.Models;
+using AiDotNet.NeuralNetworks.Layers;
+using AiDotNet.Tensors.LinearAlgebra;
+using Xunit;
+
+namespace AiDotNet.Tests.IntegrationTests.Cloning;
+
+/// <summary>
+/// End-to-end proof that a layer clones correctly, on DenseLayer.
+/// </summary>
+/// <remarks>
+/// <para>
+/// This is the first layer cloned through the generated construction state rather than a
+/// hand-written implementation, so it is checked property by property rather than assumed from the
+/// fact that it compiles.
+/// </para>
+/// <para>
+/// DenseLayer is a deliberate first case rather than a convenient one: it is lazily initialized
+/// (its input width is resolved on the first forward pass, not in the constructor), and it declares
+/// two constructors — one taking a scalar activation, one a vector activation. Both are exactly the
+/// situations where a reconstruction that merely compiles would produce a subtly wrong layer.
+/// </para>
+/// </remarks>
+public class DenseLayerCloneTests
+{
+    [Fact(Timeout = 120000)]
+    public async Task Deserialize_ReplacesDifferentConcreteAdaptiveInputWidth()
+    {
+        await Task.Yield();
+
+        var source = new DenseLayer<double>(9, new ReLUActivation<double>() as IActivationFunction<double>);
+        var sourceInput = new Tensor<double>([1, 200]);
+        for (int i = 0; i < sourceInput.Length; i++) sourceInput[i] = (i + 1) * 0.001;
+        _ = source.Forward(sourceInput);
+
+        var parameters = source.GetParameters();
+        for (int i = 0; i < parameters.Length; i++) parameters[i] = (i + 1) * 0.0001;
+        source.UpdateParameters(parameters);
+        var expected = source.Forward(sourceInput);
+
+        var restored = new DenseLayer<double>(9, new ReLUActivation<double>() as IActivationFunction<double>);
+        _ = restored.Forward(new Tensor<double>([1, 30]));
+
+        using var stream = new MemoryStream();
+        using (var writer = new BinaryWriter(stream, System.Text.Encoding.UTF8, leaveOpen: true))
+            source.Serialize(writer);
+        stream.Position = 0;
+        using (var reader = new BinaryReader(stream, System.Text.Encoding.UTF8, leaveOpen: true))
+            restored.Deserialize(reader);
+
+        var actual = restored.Forward(sourceInput);
+        Assert.Equal(source.GetInputShape(), restored.GetInputShape());
+        Assert.Equal(expected.Length, actual.Length);
+        for (int i = 0; i < expected.Length; i++)
+            Assert.Equal(expected[i], actual[i], precision: 12);
+    }
+
+    /// <summary>
+    /// A trained layer's clone must produce identical output and share no parameter storage.
+    /// </summary>
+    /// <returns>A task representing the test.</returns>
+    [Fact(Timeout = 120000)]
+    public async Task TrainedLayer_Clone_MatchesOutputAndIsIndependent()
+    {
+        await Task.Yield();
+
+        var original = new DenseLayer<double>(4, new ReLUActivation<double>() as IActivationFunction<double>);
+
+        // Force lazy initialization: the input width is resolved on first forward, so a layer
+        // cloned before this point and one cloned after are genuinely different situations.
+        var input = new Tensor<double>(new[] { 2, 3 });
+        for (int i = 0; i < input.Length; i++) input[i] = (i + 1) * 0.25;
+        var expected = original.Forward(input);
+
+        // Move the parameters away from their initialized values, so carrying them is observable.
+        var trained = original.GetParameters();
+
+        // Without this the loops below are empty and every assertion holds vacuously -- a pass
+        // that proves the clone carried nothing just as convincingly as one that proves it carried
+        // everything. 4 outputs by 3 inputs plus 4 biases.
+        Assert.True(trained.Length >= 16, $"expected a trained parameter vector, got {trained.Length}");
+
+        for (int i = 0; i < trained.Length; i++) trained[i] += 0.125;
+        original.UpdateParameters(trained);
+        expected = original.Forward(input);
+
+        var clone = (LayerBase<double>)original.Clone();
+
+        Assert.NotSame(original, clone);
+        Assert.Equal(original.GetType(), clone.GetType());
+        Assert.Equal(original.ParameterCount, clone.ParameterCount);
+
+        // The strongest statement available: same input, same output. This covers the learned
+        // parameters and every constructor-derived structure at once, which a property-by-property
+        // comparison would not.
+        var actual = clone.Forward(input);
+        Assert.Equal(expected.Length, actual.Length);
+        for (int i = 0; i < expected.Length; i++)
+        {
+            Assert.True(
+                Math.Abs(expected[i] - actual[i]) < 1e-12,
+                $"output[{i}]: original {expected[i]:G17}, clone {actual[i]:G17}");
+        }
+
+        // Independence: training the clone must not move the original. Equal parameters that
+        // change together is the bug a value comparison cannot see.
+        var cloneParams = clone.GetParameters();
+        for (int i = 0; i < cloneParams.Length; i++) cloneParams[i] += 1.0;
+        clone.UpdateParameters(cloneParams);
+
+        var originalAfter = original.GetParameters();
+        for (int i = 0; i < originalAfter.Length; i++)
+        {
+            Assert.True(
+                Math.Abs(originalAfter[i] - trained[i]) < 1e-12,
+                $"parameter[{i}] moved when the CLONE was trained: {trained[i]:G17} -> {originalAfter[i]:G17}");
+        }
+    }
+
+    /// <summary>
+    /// Architecture-only cloning reproduces the shape without carrying what was learned.
+    /// </summary>
+    /// <returns>A task representing the test.</returns>
+    /// <remarks>
+    /// Matches scikit-learn's <c>clone()</c>, which returns an unfitted estimator with the same
+    /// hyperparameters. The assertion is that the parameters DIFFER — a copy that carried them
+    /// anyway would pass a shape check while ignoring the option entirely.
+    /// </remarks>
+    [Fact(Timeout = 120000)]
+    public async Task ArchitectureClone_ReproducesShape_WithoutCarryingLearnedValues()
+    {
+        await Task.Yield();
+
+        var original = new DenseLayer<double>(4, new ReLUActivation<double>() as IActivationFunction<double>);
+
+        var input = new Tensor<double>(new[] { 2, 3 });
+        for (int i = 0; i < input.Length; i++) input[i] = (i + 1) * 0.25;
+        original.Forward(input);
+
+        var trained = original.GetParameters();
+        for (int i = 0; i < trained.Length; i++) trained[i] = 0.75;
+        original.UpdateParameters(trained);
+
+        var fresh = (LayerBase<double>)original.Clone(CloneOptions.Architecture);
+
+        Assert.Equal(original.GetType(), fresh.GetType());
+
+        // A fresh layer is lazily initialized, so it has no parameters until it sees input.
+        fresh.Forward(input);
+        Assert.Equal(original.ParameterCount, fresh.ParameterCount);
+
+        var freshParams = fresh.GetParameters();
+        bool anyDiffer = false;
+        for (int i = 0; i < freshParams.Length; i++)
+        {
+            if (Math.Abs(freshParams[i] - 0.75) > 1e-12) { anyDiffer = true; break; }
+        }
+
+        Assert.True(anyDiffer, "Architecture clone carried the learned parameters; it should be freshly initialized.");
+    }
+}
diff --git a/tests/AiDotNet.Tests/IntegrationTests/Cloning/LayerConstructionStateCloneTests.cs b/tests/AiDotNet.Tests/IntegrationTests/Cloning/LayerConstructionStateCloneTests.cs
new file mode 100644
index 0000000000..78841432b6
--- /dev/null
+++ b/tests/AiDotNet.Tests/IntegrationTests/Cloning/LayerConstructionStateCloneTests.cs
@@ -0,0 +1,229 @@
+using System.Reflection;
+using AiDotNet.ActivationFunctions;
+using AiDotNet.Enums;
+using AiDotNet.Interfaces;
+using AiDotNet.Models;
+using AiDotNet.NeuralNetworks.Attention;
+using AiDotNet.NeuralNetworks.Layers;
+using AiDotNet.NeuralNetworks.Tabular;
+using AiDotNet.PointCloud.Layers;
+using AiDotNet.Tensors.LinearAlgebra;
+using Xunit;
+
+namespace AiDotNet.Tests.IntegrationTests.Cloning;
+
+/// <summary>
+/// Proves the construction-state categories that used to be pinned to constructor defaults.
+/// </summary>
+public sealed class LayerConstructionStateCloneTests
+{
+    [Fact]
+    public void Composite_clone_preserves_every_activation_slot_independently()
+    {
+        var original = new ReconstructionLayer<double>(
+            inputDimension: 4,
+            hidden1Dimension: 3,
+            hidden2Dimension: 2,
+            outputDimension: 4,
+            hiddenActivation: new TanhActivation<double>(),
+            outputActivation: new IdentityActivation<double>());
+
+        var clone = (ReconstructionLayer<double>)original.Clone(CloneOptions.Architecture);
+        var originalChildren = original.GetSubLayers().Cast<LayerBase<double>>().ToArray();
+        var cloneChildren = clone.GetSubLayers().Cast<LayerBase<double>>().ToArray();
+
+        Assert.IsType<TanhActivation<double>>(cloneChildren[0].ScalarActivation);
+        Assert.IsType<TanhActivation<double>>(cloneChildren[1].ScalarActivation);
+        Assert.IsType<IdentityActivation<double>>(cloneChildren[2].ScalarActivation);
+        Assert.NotSame(originalChildren[0].ScalarActivation, cloneChildren[0].ScalarActivation);
+        Assert.NotSame(originalChildren[2].ScalarActivation, cloneChildren[2].ScalarActivation);
+    }
+
+    [Fact]
+    public void Json_configuration_is_equal_but_not_aliased()
+    {
+        var original = new FlashAttentionLayer<double>(
+            sequenceLength: 4,
+            embeddingDimension: 8,
+            headCount: 2,
+            config: new FlashAttentionConfig
+            {
+                BlockSizeQ = 3,
+                BlockSizeKV = 2,
+                UseCausalMask = true,
+                DropoutProbability = 0.125f,
+                Precision = FlashAttentionPrecision.Mixed,
+            });
+
+        var clone = (FlashAttentionLayer<double>)original.Clone(CloneOptions.Architecture);
+
+        Assert.NotSame(original.Config, clone.Config);
+        Assert.Equal(3, clone.Config.BlockSizeQ);
+        Assert.Equal(2, clone.Config.BlockSizeKV);
+        Assert.True(clone.Config.UseCausalMask);
+        Assert.Equal(0.125f, clone.Config.DropoutProbability);
+        Assert.Equal(FlashAttentionPrecision.Mixed, clone.Config.Precision);
+
+        clone.Config.BlockSizeQ = 7;
+        Assert.Equal(3, original.Config.BlockSizeQ);
+    }
+
+    [Fact]
+    public void Enum_arrays_and_resolved_nullable_arrays_round_trip_non_defaults()
+    {
+        var pna = new PrincipalNeighbourhoodAggregationLayer<double>(
+            inputFeatures: 3,
+            outputFeatures: 2,
+            aggregators: new[] { PNAAggregator.Max, PNAAggregator.StdDev },
+            scalers: new[] { PNAScaler.Attenuation });
+        var pnaClone = (PrincipalNeighbourhoodAggregationLayer<double>)pna.Clone(CloneOptions.Architecture);
+
+        Assert.Equal(
+            new[] { PNAAggregator.Max, PNAAggregator.StdDev },
+            Field<PNAAggregator[]>(pnaClone, "_aggregators"));
+        Assert.Equal(
+            new[] { PNAScaler.Attenuation },
+            Field<PNAScaler[]>(pnaClone, "_scalers"));
+
+        var tnet = new TNetLayer<double>(
+            transformDim: 2,
+            numFeatures: 3,
+            mlpChannels: new[] { 5, 7 },
+            fcChannels: new[] { 11 });
+        var tnetClone = (TNetLayer<double>)tnet.Clone(CloneOptions.Architecture);
+
+        Assert.Equal(new[] { 5, 7 }, Field<int[]>(tnetClone, "_mlpChannels"));
+        Assert.Equal(new[] { 11 }, Field<int[]>(tnetClone, "_fcChannels"));
+        Assert.NotSame(Field<int[]>(tnet, "_mlpChannels"), Field<int[]>(tnetClone, "_mlpChannels"));
+    }
+
+    [Fact]
+    public void Non_default_derived_topology_settings_survive_architecture_clone()
+    {
+        var denseBlock = new DenseBlock<double>(numLayers: 1, growthRate: 2, bnMomentum: 0.37);
+        var denseClone = (DenseBlock<double>)denseBlock.Clone(CloneOptions.Architecture);
+        Assert.Equal(0.37, Field<double>(denseClone, "_bnMomentum"), precision: 12);
+
+        var cls = new PrependCLSTokenLayer<double>(embedDim: 4, initScale: 0.17, seed: 3);
+        var clsClone = (PrependCLSTokenLayer<double>)cls.Clone(CloneOptions.Architecture);
+        Assert.Equal(0.17, Field<double>(clsClone, "_initScale"), precision: 12);
+
+        var rrdb = new RRDBNetGenerator<double>(
+            inputChannels: 1,
+            outputChannels: 2,
+            numFeatures: 4,
+            growthChannels: 3,
+            numRRDBBlocks: 1,
+            scale: 2,
+            residualScale: 0.31);
+        var rrdbClone = (RRDBNetGenerator<double>)rrdb.Clone(CloneOptions.Architecture);
+        Assert.Equal(3, Field<int>(rrdbClone, "_growthChannels"));
+        Assert.Equal(0.31, Field<double>(rrdbClone, "_residualScale"), precision: 12);
+
+        var vgg = new VGGishAudioEmbedding<double>(
+            conv1Filters: 2,
+            conv2Filters: 3,
+            conv3Filters: 4,
+            conv4Filters: 5,
+            fullyConnectedWidth: 7,
+            embeddingSize: 6);
+        var vggClone = (VGGishAudioEmbedding<double>)vgg.Clone(CloneOptions.Architecture);
+        Assert.Equal(2, Field<int>(vggClone, "_conv1Filters"));
+        Assert.Equal(3, Field<int>(vggClone, "_conv2Filters"));
+        Assert.Equal(4, Field<int>(vggClone, "_conv3Filters"));
+        Assert.Equal(5, Field<int>(vggClone, "_conv4Filters"));
+        Assert.Equal(7, vggClone.FullyConnectedWidth);
+        Assert.Equal(6, vggClone.EmbeddingSize);
+    }
+
+    [Fact]
+    public void Live_tensor_construction_state_is_cloned_without_changing_ownership()
+    {
+        var sharedBias = new Tensor<double>(new[] { 4, 2 });
+        for (int i = 0; i < sharedBias.Length; i++) sharedBias[i] = i + 0.5;
+        var original = new T5RelativeBiasAttentionLayer<double>(
+            hiddenSize: 8,
+            numHeads: 2,
+            numBuckets: 4,
+            sharedRelativeBiasTable: sharedBias);
+
+        var clone = (T5RelativeBiasAttentionLayer<double>)original.Clone(CloneOptions.Full);
+
+        Assert.False(original.OwnsRelativeBiasTable);
+        Assert.False(clone.OwnsRelativeBiasTable);
+        Assert.NotSame(original.GetRelativeBiasTable(), clone.GetRelativeBiasTable());
+        Assert.Equal(original.GetRelativeBiasTable().ToArray(), clone.GetRelativeBiasTable().ToArray());
+
+        clone.GetRelativeBiasTable()[0] = 99;
+        Assert.Equal(0.5, original.GetRelativeBiasTable()[0], precision: 12);
+    }
+
+    [Fact]
+    public void Live_child_lists_clone_elements_and_persistent_state_without_aliasing()
+    {
+        var sharedFc = new FullyConnectedLayer<double>(
+            4, (IActivationFunction<double>)new IdentityActivation<double>());
+        var sharedBn = new GhostBatchNormalization<double>(4, virtualBatchSize: 2, momentum: 0.13);
+        var original = new FeatureTransformerLayer<double>(
+            inputDim: 4,
+            outputDim: 2,
+            sharedLayers: new List<FullyConnectedLayer<double>> { sharedFc },
+            sharedBNLayers: new List<GhostBatchNormalization<double>> { sharedBn },
+            numSharedLayers: 1,
+            numStepSpecificLayers: 0,
+            virtualBatchSize: 2,
+            momentum: 0.13);
+
+        var input = new Tensor<double>(new[] { 2, 4 });
+        input.Fill(1.0);
+        _ = original.Forward(input);
+
+        var clone = (FeatureTransformerLayer<double>)original.Clone(CloneOptions.Full);
+        var originalFc = Field<List<FullyConnectedLayer<double>>>(original, "_sharedFCLayers");
+        var cloneFc = Field<List<FullyConnectedLayer<double>>>(clone, "_sharedFCLayers");
+        var originalBn = Field<List<GhostBatchNormalization<double>>>(original, "_sharedBNLayers");
+        var cloneBn = Field<List<GhostBatchNormalization<double>>>(clone, "_sharedBNLayers");
+
+        Assert.NotSame(originalFc, cloneFc);
+        Assert.NotSame(originalFc[0], cloneFc[0]);
+        Assert.NotSame(originalBn, cloneBn);
+        Assert.NotSame(originalBn[0], cloneBn[0]);
+
+        var cloneParameters = cloneFc[0].GetParameters();
+        cloneParameters[0] += 10;
+        cloneFc[0].UpdateParameters(cloneParameters);
+        Assert.NotEqual(originalFc[0].GetParameters()[0], cloneFc[0].GetParameters()[0]);
+    }
+
+    [Fact]
+    public void Swin_block_with_rectangular_derived_state_clones_after_forward()
+    {
+        var original = new SwinTransformerBlockLayer<double>(
+            dim: 16,
+            numHeads: 2,
+            windowSize: 4);
+        var input = new Tensor<double>(new[] { 1, 16, 16 });
+        input.Fill(0.25);
+        _ = original.Forward(input);
+
+        var clone = (SwinTransformerBlockLayer<double>)original.Clone(CloneOptions.Full);
+
+        Assert.Equal(original.ParameterCount, clone.ParameterCount);
+        Assert.NotSame(
+            Field<int[,]>(original, "_relativePositionIndex"),
+            Field<int[,]>(clone, "_relativePositionIndex"));
+        Assert.Equal(original.GetParameters().ToArray(), clone.GetParameters().ToArray());
+    }
+
+    private static TValue Field<TValue>(object instance, string name)
+    {
+        for (Type? type = instance.GetType(); type is not null; type = type.BaseType)
+        {
+            if (type.GetField(name, BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public)
+                    ?.GetValue(instance) is TValue value)
+                return value;
+        }
+
+        throw new InvalidOperationException($"{instance.GetType().Name}.{name} was not found.");
+    }
+}
diff --git a/tests/AiDotNet.Tests/IntegrationTests/Cloning/ModelCloningTests.cs b/tests/AiDotNet.Tests/IntegrationTests/Cloning/ModelCloningTests.cs
new file mode 100644
index 0000000000..5e95f0abcc
--- /dev/null
+++ b/tests/AiDotNet.Tests/IntegrationTests/Cloning/ModelCloningTests.cs
@@ -0,0 +1,113 @@
+using System.Collections.Generic;
+using AiDotNet.ActivationFunctions;
+using AiDotNet.Enums;
+using AiDotNet.Interfaces;
+using AiDotNet.LossFunctions;
+using AiDotNet.Models;
+using AiDotNet.NeuralNetworks;
+using AiDotNet.NeuralNetworks.Layers;
+using AiDotNet.Tensors.LinearAlgebra;
+using Xunit;
+
+namespace AiDotNet.Tests.IntegrationTests.Cloning;
+
+/// <summary>
+/// Proves a model is rebuilt through its own constructor and carries its learned weights.
+/// </summary>
+/// <remarks>
+/// These assert the two properties that make a clone worth having, and that the previous
+/// scalar-count backstop could not establish: the copy predicts identically to the original
+/// (so its parameters landed in the right slots), and mutating the copy does not reach the
+/// original (so nothing is shared by reference).
+/// </remarks>
+public class ModelCloningTests
+{
+    private const int InDim = 4;
+
+    private static FeedForwardNeuralNetwork<float> BuildModel()
+    {
+        var layers = new List<ILayer<float>>
+        {
+            new InputLayer<float>(InDim),
+            new DenseLayer<float>(6, activationFunction: new ReLUActivation<float>()),
+            new DenseLayer<float>(1, activationFunction: new IdentityActivation<float>()),
+        };
+        var architecture = new NeuralNetworkArchitecture<float>(
+            inputType: InputType.OneDimensional,
+            taskType: NeuralNetworkTaskType.Regression,
+            inputSize: InDim,
+            outputSize: 1,
+            layers: layers);
+
+        return new FeedForwardNeuralNetwork<float>(
+            architecture, lossFunction: new MeanSquaredErrorLoss<float>());
+    }
+
+    private static Tensor<float> SampleInput()
+    {
+        var x = new Tensor<float>(new[] { 1, InDim });
+        for (int i = 0; i < InDim; i++) x[0, i] = 0.25f * (i + 1);
+        return x;
+    }
+
+    [Fact]
+    public void Clone_ProducesAnIndependentModelWithTheSamePredictions()
+    {
+        var source = BuildModel();
+        var input = SampleInput();
+        var expected = source.Predict(input);
+
+        var clone = (NeuralNetworkBase<float>)source.Clone();
+
+        Assert.NotNull(clone);
+        Assert.NotSame(source, clone);
+        Assert.IsType<FeedForwardNeuralNetwork<float>>(clone);
+
+        var actual = clone.Predict(input);
+        Assert.Equal(expected.Length, actual.Length);
+        for (int i = 0; i < expected.Length; i++)
+        {
+            Assert.Equal(expected[i], actual[i], 5);
+        }
+    }
+
+    [Fact]
+    public void Clone_DoesNotShareParameterStorageWithTheOriginal()
+    {
+        var source = BuildModel();
+        var clone = (NeuralNetworkBase<float>)source.Clone();
+
+        var before = source.GetParameters();
+        var mutated = new Vector<float>(before.Length);
+        for (int i = 0; i < before.Length; i++) mutated[i] = before[i] + 1.0f;
+
+        clone.UpdateParameters(mutated);
+
+        // The original must be untouched. A clone that aliases storage passes a predictions
+        // check and then corrupts the model it was copied from the first time either is trained.
+        var after = source.GetParameters();
+        Assert.Equal(before.Length, after.Length);
+        for (int i = 0; i < before.Length; i++)
+        {
+            Assert.Equal(before[i], after[i], 6);
+        }
+    }
+
+    [Fact]
+    public void DeepCopy_ProducesAnIndependentModelWithTheSamePredictions()
+    {
+        var source = BuildModel();
+        var input = SampleInput();
+        var expected = source.Predict(input);
+
+        var copy = (NeuralNetworkBase<float>)source.DeepCopy();
+
+        Assert.NotNull(copy);
+        Assert.NotSame(source, copy);
+        var actual = copy.Predict(input);
+        for (int i = 0; i < expected.Length; i++)
+        {
+            Assert.Equal(expected[i], actual[i], 5);
+        }
+    }
+}
diff --git a/tests/AiDotNet.Tests/IntegrationTests/DistributedTraining/DistributedTrainingIntegrationTests.cs b/tests/AiDotNet.Tests/IntegrationTests/DistributedTraining/DistributedTrainingIntegrationTests.cs
index 3151ace68b..8a7112189c 100644
--- a/tests/AiDotNet.Tests/IntegrationTests/DistributedTraining/DistributedTrainingIntegrationTests.cs
+++ b/tests/AiDotNet.Tests/IntegrationTests/DistributedTraining/DistributedTrainingIntegrationTests.cs
@@ -2045,6 +2045,41 @@ public async Task HybridShardedModel_GetModelMetadata_IncludesStrategy()
         backend.Shutdown();
     }
 
+    [Fact(Timeout = 120000)]
+    public async Task HybridShardedModel_Deserialize_RejectsDifferentGeneratedTopology()
+    {
+        await Task.Yield();
+        var envId = Guid.NewGuid().ToString();
+        var backend = new InMemoryCommunicationBackend<double>(0, 4, envId);
+        backend.Initialize();
+        var config = new ShardingConfiguration<double>(backend);
+
+        try
+        {
+            var source = new HybridShardedModel<double, Vector<double>, Vector<double>>(
+                new MockDistributedModel(8), config,
+                pipelineParallelSize: 2, tensorParallelSize: 2, dataParallelSize: 1);
+            var payload = source.Serialize();
+            Assert.Equal(2, source.GetModelMetadata().Properties["PipelineParallelSize"]);
+            Assert.True(BitConverter.ToInt32(payload, 14) > 0,
+                "The shared serializer must emit constructor-derived strategy compatibility values.");
+
+            var incompatible = new HybridShardedModel<double, Vector<double>, Vector<double>>(
+                new MockDistributedModel(8), config,
+                pipelineParallelSize: 1, tensorParallelSize: 2, dataParallelSize: 2);
+            _ = incompatible.LocalParameterShard;
+            Assert.Equal(1, incompatible.GetModelMetadata().Properties["PipelineParallelSize"]);
+
+            var error = Assert.Throws<InvalidOperationException>(() => incompatible.Deserialize(payload));
+            Assert.Contains("Sharding strategy setting", error.Message, StringComparison.Ordinal);
+            Assert.Contains("mismatch", error.Message, StringComparison.OrdinalIgnoreCase);
+        }
+        finally
+        {
+            backend.Shutdown();
+        }
+    }
+
     #endregion
 
     #region Edge Cases Tests
diff --git a/tests/AiDotNet.Tests/IntegrationTests/Document/VisionLanguageDocumentTests.cs b/tests/AiDotNet.Tests/IntegrationTests/Document/VisionLanguageDocumentTests.cs
index b82f17859e..6a4f263e05 100644
--- a/tests/AiDotNet.Tests/IntegrationTests/Document/VisionLanguageDocumentTests.cs
+++ b/tests/AiDotNet.Tests/IntegrationTests/Document/VisionLanguageDocumentTests.cs
@@ -119,7 +119,19 @@ public async Task DocOwl_TrainingWithText_ChangesParameters()
         for (int i = 0; i < shifted.Length; i++)
             shifted.Data.Span[i] = target.Data.Span[i] + 0.5;
 
-        model.Train(image, tokens, shifted);
+        // Exercise the configuration that exposed the shard-only failure. Multi-input training
+        // must stay on the eager tape while the compiled cache persists only one input tensor;
+        // otherwise it captures a stale auxiliary input and can report a successful no-op step.
+        bool compilationWasEnabled = AiDotNet.Tensors.Engines.Optimization.TensorCodecOptions.Current.EnableCompilation;
+        try
+        {
+            AiDotNet.Tensors.Engines.Optimization.TensorCodecOptions.Current.EnableCompilation = true;
+            model.Train(image, tokens, shifted);
+        }
+        finally
+        {
+            AiDotNet.Tensors.Engines.Optimization.TensorCodecOptions.Current.EnableCompilation = compilationWasEnabled;
+        }
 
         var after = model.GetParameters();
         Assert.Equal(before.Length, after.Length);
diff --git a/tests/AiDotNet.Tests/IntegrationTests/LayerParameterSurfaceTests.cs b/tests/AiDotNet.Tests/IntegrationTests/LayerParameterSurfaceTests.cs
index 61a2c433c9..5ed0e51b5b 100644
--- a/tests/AiDotNet.Tests/IntegrationTests/LayerParameterSurfaceTests.cs
+++ b/tests/AiDotNet.Tests/IntegrationTests/LayerParameterSurfaceTests.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Globalization;
 using System.Linq;
 using System.Reflection;
 using Xunit;
@@ -53,6 +54,7 @@ public async System.Threading.Tasks.Task AllLayers_ParameterCountMatchesGetParam
         // that silently omitted it -- inflating coverage in exactly the way the counting exists
         // to prevent.
         int checkedCount = 0, unconstructable = 0, unsized = 0, noParameterApi = 0;
+        int warmedUp = 0, notWarmedUp = 0;
 
         var logPath = System.IO.Path.Combine(System.IO.Path.GetTempPath(), "layer-parameter-surface.txt");
         // DISPOSED ON EVERY PATH, AND A FAILURE TO OPEN IS REPORTED. The manual dispose ran only
@@ -84,6 +86,21 @@ public async System.Threading.Tasks.Task AllLayers_ParameterCountMatchesGetParam
             catch { layer = null; }
             if (layer is null) { unconstructable++; continue; }
 
+            // Drive one forward before measuring. A layer built from its declared arguments alone
+            // knows its OUTPUT width and nothing else, so it sits shape-deferred with no weights
+            // allocated -- and 0 == 0 satisfies this invariant without testing anything. Sixty-odd
+            // weight-holding layers passed that way: LSTM, GRU, Attention, BatchNormalization, the
+            // convolutions, the transformer blocks. The declared TestInputShape is the missing half
+            // of the same metadata the constructor arguments come from, so feeding it is what turns
+            // those into real measurements.
+            bool warm = TryWarmUp(closed, layer, out string? warmFailure);
+            if (warm) warmedUp++;
+            else
+            {
+                notWarmedUp++;
+                log?.WriteLine($"NOT WARMED {name}: {warmFailure}");
+            }
+
             try
             {
                 long declared = Convert.ToInt64(
@@ -104,7 +121,22 @@ public async System.Threading.Tasks.Task AllLayers_ParameterCountMatchesGetParam
                     : Convert.ToInt64(vec.GetType().GetProperty("Length")!.GetValue(vec));
 
                 checkedCount++;
-                if (declared == actual) { if (pending) unsized++; continue; }
+                if (declared == actual)
+                {
+                    // The AGREED value, not just the fact of agreement. A layer can be moved out of
+                    // the violation list by making both surfaces report NOTHING -- suppressing the
+                    // fallback that was materializing its children is enough -- and that reads
+                    // identically to a real fix unless the number is written down. Recording it is
+                    // what lets "agrees at 592" be told apart from "agrees at 0".
+                    // Warm status on the line, because a zero means two different things. A layer
+                    // that RAN a forward and still holds nothing is parameter-free; one that could
+                    // not be driven is merely untested, and telling them apart is the whole point
+                    // of warming up at all.
+                    log?.WriteLine($"AGREE {name}: {declared}" +
+                                   $"{(pending ? " [deferred]" : "")}{(warm ? "" : " [not warmed]")}");
+                    if (pending) unsized++;
+                    continue;
+                }
 
                 var row = $"{name}: ParameterCount={declared}, GetParameters().Length={actual} " +
                           $"(difference {declared - actual}){(pending ? " [deferred]" : "")}";
@@ -120,7 +152,8 @@ public async System.Threading.Tasks.Task AllLayers_ParameterCountMatchesGetParam
 
         _output.WriteLine($"Checked {checkedCount} layers; {unsized} agree at zero (deferred); " +
                           $"{noParameterApi} expose no public GetParameters(); " +
-                          $"{unconstructable} not constructable; {violations.Count} violations.");
+                          $"{unconstructable} not constructable; {warmedUp} warmed up, " +
+                          $"{notWarmedUp} measured without a forward; {violations.Count} violations.");
         foreach (var v in violations.OrderBy(v => v, StringComparer.Ordinal))
             _output.WriteLine("  " + v);
 
@@ -134,16 +167,477 @@ public async System.Threading.Tasks.Task AllLayers_ParameterCountMatchesGetParam
             string.Join("\n", violations.OrderBy(v => v, StringComparer.Ordinal).Select(v => "  " + v)));
     }
 
+    /// <summary>
+    /// Builds a layer for measurement, preferring a default constructor and falling back to the
+    /// constructor arguments the layer already declares for scaffold generation.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// Requiring a parameterless constructor reached 39 layers. Every composite this invariant is
+    /// actually about — ClozeAttention, BranchformerBlock, ConformerBlock, VideoGigaGAN, the ResNet
+    /// blocks — takes its widths as constructor arguments, so all of them sat outside the sweep and
+    /// it reported agreement across a set that excluded them. That is the worse failure: a green
+    /// sweep over the layers that were never at risk reads exactly like a green sweep over all of
+    /// them.
+    /// </para>
+    /// <para>
+    /// The widths are not guessed here. <c>[LayerProperty(TestConstructorArgs = "...")]</c> already
+    /// states them on the layer, and the test scaffold generator emits real constructor calls from
+    /// that same string; this replays it through reflection.
+    /// </para>
+    /// <para>
+    /// The declaration is C# source, so replaying it means evaluating the small expression language
+    /// it actually uses: numbers, <c>null</c> behind a cast, <c>true</c>/<c>false</c>, <c>new[] { 1,
+    /// 4 }</c> and its jagged form, enum members, nested <c>new SomeLayer&lt;double&gt;(...)</c>, and
+    /// named arguments. Anything outside that — an object initializer, say — leaves the layer
+    /// unmeasured and COUNTED as unconstructable, because a sweep that silently dropped it would
+    /// report the same clean result whether the layer agreed or was simply never asked.
+    /// </para>
+    /// </remarks>
     private static object? TryConstruct(Type closed)
     {
+        // THE DECLARATION WINS over a defaults constructor. TestConstructorArgs and TestInputShape
+        // are one statement about one configuration, and preferring the defaults ctor built a
+        // DIFFERENT layer than the shape was written for: RRDBLayer and ResidualDenseBlock came up
+        // at their default 64 channels and then rejected the declared 4-channel input, and
+        // UNetDiscriminator came up with numBlocks=4 and rejected an 8x8 input that numBlocks=2
+        // accepts. All three read as "cannot be driven" when the real fault was building the wrong
+        // instance.
+        var declared = TestConstructorArgs(closed);
+        if (!string.IsNullOrWhiteSpace(declared))
+        {
+            var fromDeclaration = Instantiate(closed, declared!);
+            if (fromDeclaration is not null) return fromDeclaration;
+        }
+
         var ctor = closed.GetConstructors(BindingFlags.Public | BindingFlags.Instance)
             .Where(c => c.GetParameters().All(p => p.HasDefaultValue) || c.GetParameters().Length == 0)
             .OrderBy(c => c.GetParameters().Length)
             .FirstOrDefault();
         if (ctor is null) return null;
-        var args = ctor.GetParameters()
+
+        var defaults = ctor.GetParameters()
             .Select(p => p.DefaultValue == DBNull.Value ? null : p.DefaultValue).ToArray();
-        return ctor.Invoke(args);
+        return ctor.Invoke(defaults);
+    }
+
+    /// <summary>
+    /// Runs one forward from the layer's declared <c>TestInputShape</c>, so its weights exist by
+    /// the time the two surfaces are compared. False when the layer declares no usable shape or
+    /// refuses the input.
+    /// </summary>
+    /// <remarks>
+    /// Reported rather than required. A layer that cannot be driven is still measured, in whatever
+    /// state it reached -- the alternative, skipping it, would shrink the denominator to the layers
+    /// that happened to cooperate and call the result full coverage.
+    /// </remarks>
+    private static bool TryWarmUp(Type closed, object layer, out string? failure)
+    {
+        failure = null;
+        var declared = closed.GetCustomAttributes(inherit: false)
+            .OfType<AiDotNet.Attributes.LayerPropertyAttribute>()
+            .FirstOrDefault()?.TestInputShape;
+        if (string.IsNullOrWhiteSpace(declared))
+        {
+            failure = "declares no TestInputShape";
+            return false;
+        }
+
+        var dims = new List<int>();
+        foreach (var token in declared!.Split(','))
+        {
+            if (!int.TryParse(token.Trim(), NumberStyles.Integer, CultureInfo.InvariantCulture,
+                    out int dim) || dim <= 0)
+            {
+                failure = $"TestInputShape '{declared}' is not all positive integers";
+                return false;
+            }
+            dims.Add(dim);
+        }
+        if (dims.Count == 0)
+        {
+            failure = "TestInputShape is empty";
+            return false;
+        }
+
+        // Pick the TENSOR overload by its parameter type. LayerBase declares three one-argument
+        // Forwards -- Tensor, params Tensor[], and IReadOnlyDictionary -- and taking whichever
+        // reflection listed first selected a non-tensor one for every layer in the library, so the
+        // warm-up silently did nothing at all: 0 of 210 warmed up.
+        var forward = closed.GetMethods(BindingFlags.Public | BindingFlags.Instance)
+            .FirstOrDefault(m => m.Name == "Forward"
+                && m.GetParameters().Length == 1
+                && m.GetParameters()[0].ParameterType.IsGenericType
+                && m.GetParameters()[0].ParameterType.GetGenericTypeDefinition().Name
+                    .StartsWith("Tensor", StringComparison.Ordinal));
+        if (forward is null)
+        {
+            failure = "no single-tensor Forward overload";
+            return false;
+        }
+
+        var tensorType = forward.GetParameters()[0].ParameterType;
+
+        try
+        {
+            var input = Activator.CreateInstance(tensorType, new object[] { dims.ToArray() });
+            if (input is null)
+            {
+                failure = "could not build the input tensor";
+                return false;
+            }
+            forward.Invoke(layer, new[] { input });
+            return true;
+        }
+        catch (Exception ex)
+        {
+            // A layer may need several inputs, a mask, or a shape this one declaration does not
+            // describe. It stays measured; it just stays deferred. The REASON is recorded, because
+            // "could not be driven" is only actionable if it says what went wrong.
+            var root = ex.GetBaseException();
+            failure = $"{root.GetType().Name}: {root.Message}";
+            return false;
+        }
+    }
+
+    /// <summary>True when the layer states constructor arguments for scaffold generation.</summary>
+    private static bool DeclaresTestArguments(Type closed)
+        => !string.IsNullOrWhiteSpace(TestConstructorArgs(closed));
+
+    private static string? TestConstructorArgs(Type closed)
+        => closed.GetCustomAttributes(inherit: false)
+            .OfType<AiDotNet.Attributes.LayerPropertyAttribute>()
+            .FirstOrDefault()?.TestConstructorArgs;
+
+    /// <summary>Builds <paramref name="type"/> from a C# argument list, or null if it cannot.</summary>
+    private static object? Instantiate(Type type, string argumentList)
+    {
+        var declared = SplitArguments(argumentList);
+        if (declared is null) return null;
+
+        foreach (var candidate in type.GetConstructors(BindingFlags.Public | BindingFlags.Instance)
+                     .OrderBy(c => c.GetParameters().Length))
+        {
+            if (TryBind(candidate, declared, out var args)) return candidate.Invoke(args);
+        }
+        return null;
+    }
+
+    /// <summary>
+    /// Matches one declared argument list against one constructor overload, evaluating each
+    /// argument into the parameter it lands in.
+    /// </summary>
+    /// <remarks>
+    /// A named argument is bound BY NAME rather than by position. Stripping the name and taking the
+    /// slot it happened to sit in would quietly build a different layer than the declaration
+    /// describes, and the sweep would then measure that one and report on it as though it were the
+    /// declared configuration.
+    /// </remarks>
+    private static bool TryBind(
+        ConstructorInfo candidate,
+        IReadOnlyList<(string? Name, string Expression)> declared,
+        out object?[] args)
+    {
+        var parameters = candidate.GetParameters();
+        args = new object?[parameters.Length];
+        var bound = new bool[parameters.Length];
+
+        int position = 0;
+        foreach (var (name, expression) in declared)
+        {
+            int index = name is null
+                ? position++
+                : Array.FindIndex(parameters, p => string.Equals(p.Name, name, StringComparison.Ordinal));
+            if (index < 0 || index >= parameters.Length || bound[index]) return false;
+            if (!TryEvaluate(expression, out object? value)) return false;
+            if (!TryCoerce(value, parameters[index].ParameterType, out object? coerced)) return false;
+            args[index] = coerced;
+            bound[index] = true;
+        }
+
+        for (int i = 0; i < parameters.Length; i++)
+        {
+            if (bound[i]) continue;
+            if (!parameters[i].HasDefaultValue) return false;
+            args[i] = parameters[i].DefaultValue == DBNull.Value ? null : parameters[i].DefaultValue;
+        }
+        return true;
+    }
+
+    /// <summary>
+    /// Splits an argument list on its top-level commas, keeping <c>new[] { 1, 4 }</c> whole, and
+    /// separating any <c>name:</c> prefix. Null when the text is unbalanced.
+    /// </summary>
+    private static IReadOnlyList<(string? Name, string Expression)>? SplitArguments(string text)
+    {
+        var pieces = SplitTopLevel(text);
+        if (pieces is null) return null;
+
+        var declared = new List<(string? Name, string Expression)>(pieces.Count);
+        foreach (var piece in pieces)
+        {
+            var trimmed = piece.Trim();
+            if (trimmed.Length == 0) return null;
+
+            int colon = TopLevelColon(trimmed);
+            declared.Add(colon < 0
+                ? (null, trimmed)
+                : (trimmed.Substring(0, colon).Trim(), trimmed.Substring(colon + 1).Trim()));
+        }
+        return declared;
+    }
+
+    private static List<string>? SplitTopLevel(string text)
+    {
+        var pieces = new List<string>();
+        int depth = 0, start = 0;
+        bool inString = false;
+        for (int i = 0; i < text.Length; i++)
+        {
+            char c = text[i];
+            if (inString)
+            {
+                if (c == '"') inString = false;
+                continue;
+            }
+            if (c == '"') { inString = true; continue; }
+            if (c is '(' or '{' or '[' or '<') depth++;
+            else if (c is ')' or '}' or ']' or '>') depth--;
+            else if (c == ',' && depth == 0)
+            {
+                pieces.Add(text.Substring(start, i - start));
+                start = i + 1;
+            }
+        }
+        if (inString || depth != 0) return null;
+        pieces.Add(text.Substring(start));
+        return pieces;
+    }
+
+    /// <summary>Index of a <c>name:</c> separator, skipping <c>::</c> and any nested text.</summary>
+    private static int TopLevelColon(string text)
+    {
+        int depth = 0;
+        for (int i = 0; i < text.Length; i++)
+        {
+            char c = text[i];
+            if (c is '(' or '{' or '[' or '<') depth++;
+            else if (c is ')' or '}' or ']' or '>') depth--;
+            else if (c == ':' && depth == 0)
+            {
+                bool qualifier = (i > 0 && text[i - 1] == ':') || (i + 1 < text.Length && text[i + 1] == ':');
+                if (!qualifier) return i;
+            }
+        }
+        return -1;
+    }
+
+    /// <summary>Evaluates one declared argument expression.</summary>
+    private static bool TryEvaluate(string expression, out object? value)
+    {
+        value = null;
+        string text = StripCasts(expression);
+        if (text.Length == 0) return false;
+
+        if (text == "null") return true;
+        if (text == "true") { value = true; return true; }
+        if (text == "false") { value = false; return true; }
+        if (double.TryParse(text, NumberStyles.Float, CultureInfo.InvariantCulture, out double number))
+        {
+            value = number;
+            return true;
+        }
+        return text.StartsWith("new", StringComparison.Ordinal)
+            ? TryEvaluateNew(text, out value)
+            : TryEvaluateEnumMember(text, out value);
+    }
+
+    /// <summary>
+    /// Removes leading casts. The declarations use them to pick an overload — <c>(IActivationFunction
+    /// &lt;double&gt;?)null</c> — which reflection resolves from the parameter type instead.
+    /// </summary>
+    private static string StripCasts(string expression)
+    {
+        string text = expression.Trim();
+        while (text.StartsWith("(", StringComparison.Ordinal))
+        {
+            int close = MatchingBracket(text, 0);
+            if (close < 0 || close == text.Length - 1) break;
+            string inner = text.Substring(1, close - 1).Trim();
+            // A cast names a type; a parenthesised value does not. Requiring a letter and rejecting
+            // anything with a top-level comma keeps `(a, b)` and `(3)` from being mistaken for one.
+            if (inner.Length == 0 || !inner.Any(char.IsLetter) || inner.Contains(',')) break;
+            text = text.Substring(close + 1).Trim();
+        }
+        return text;
+    }
+
+    private static int MatchingBracket(string text, int open)
+    {
+        int depth = 0;
+        for (int i = open; i < text.Length; i++)
+        {
+            if (text[i] is '(' or '{' or '[') depth++;
+            else if (text[i] is ')' or '}' or ']')
+            {
+                depth--;
+                if (depth == 0) return i;
+            }
+        }
+        return -1;
+    }
+
+    /// <summary>Evaluates <c>new[] { ... }</c>, <c>new T[] { ... }</c> and <c>new T(...)</c>.</summary>
+    private static bool TryEvaluateNew(string text, out object? value)
+    {
+        value = null;
+        string body = text.Substring(3).Trim();
+
+        int brace = body.IndexOf('{');
+        int paren = body.IndexOf('(');
+        bool isArray = brace >= 0 && (paren < 0 || brace < paren);
+
+        if (isArray)
+        {
+            // An object initializer -- `new T { Property = ... }` -- also opens with a brace. The
+            // array forms are the ones whose text before it is empty or ends in `[]`.
+            string prefix = body.Substring(0, brace).Trim();
+            if (prefix.Length != 0 && !prefix.EndsWith("[]", StringComparison.Ordinal)) return false;
+
+            int close = MatchingBracket(body, brace);
+            if (close < 0) return false;
+            var elements = SplitTopLevel(body.Substring(brace + 1, close - brace - 1));
+            if (elements is null) return false;
+
+            var evaluated = new List<object?>();
+            foreach (var element in elements)
+            {
+                if (element.Trim().Length == 0) continue;
+                if (!TryEvaluate(element, out object? item)) return false;
+                evaluated.Add(item);
+            }
+
+            if (evaluated.All(item => item is double))
+            {
+                value = evaluated.Select(item => (int)(double)item!).ToArray();
+                return true;
+            }
+            if (evaluated.All(item => item is int[]))
+            {
+                value = evaluated.Select(item => (int[])item!).ToArray();
+                return true;
+            }
+            return false;
+        }
+
+        if (paren < 0) return false;
+        int end = MatchingBracket(body, paren);
+        if (end < 0) return false;
+
+        var type = ResolveType(body.Substring(0, paren));
+        if (type is null) return false;
+
+        string arguments = body.Substring(paren + 1, end - paren - 1).Trim();
+        object? instance = arguments.Length == 0
+            ? Activator.CreateInstance(type)
+            : Instantiate(type, arguments);
+        if (instance is null) return false;
+        value = instance;
+        return true;
+    }
+
+    private static bool TryEvaluateEnumMember(string text, out object? value)
+    {
+        value = null;
+        int dot = text.LastIndexOf('.');
+        if (dot <= 0) return false;
+
+        var type = ResolveType(text.Substring(0, dot));
+        if (type is null || !type.IsEnum) return false;
+
+        string member = text.Substring(dot + 1).Trim();
+        if (!Enum.IsDefined(type, member)) return false;
+        value = Enum.Parse(type, member);
+        return true;
+    }
+
+    /// <summary>
+    /// Resolves a source-form type name. Every generic in these declarations is closed over
+    /// <c>double</c>, which is also the element type this sweep measures.
+    /// </summary>
+    private static Type? ResolveType(string name)
+    {
+        string text = name.Replace("global::", string.Empty).Trim();
+
+        var segments = new List<string>();
+        int depth = 0, start = 0;
+        for (int i = 0; i < text.Length; i++)
+        {
+            if (text[i] == '<') depth++;
+            else if (text[i] == '>') depth--;
+            else if (text[i] == '.' && depth == 0)
+            {
+                segments.Add(text.Substring(start, i - start));
+                start = i + 1;
+            }
+        }
+        segments.Add(text.Substring(start));
+
+        var assembly = typeof(AiDotNet.Models.ModelMetadata<>).Assembly;
+
+        // Longest namespace-qualified prefix first, then shorter ones: the trailing segments become
+        // NESTED types, which is how `SomeLayer<double>.Position` has to be spelled to reflection.
+        for (int split = segments.Count; split >= 1; split--)
+        {
+            var builder = new System.Text.StringBuilder();
+            for (int i = 0; i < split; i++)
+            {
+                if (i > 0) builder.Append('.');
+                string segment = segments[i].Trim();
+                int angle = segment.IndexOf('<');
+                if (angle < 0) builder.Append(segment);
+                else builder.Append(segment, 0, angle).Append("`1");
+            }
+            for (int i = split; i < segments.Count; i++) builder.Append('+').Append(segments[i].Trim());
+
+            string candidateName = builder.ToString();
+            var candidate = assembly.GetType(candidateName, throwOnError: false)
+                            ?? Type.GetType(candidateName, throwOnError: false);
+            if (candidate is null) continue;
+
+            return candidate.IsGenericTypeDefinition
+                ? candidate.MakeGenericType(typeof(double))
+                : candidate;
+        }
+        return null;
+    }
+
+    /// <summary>Fits an evaluated value to the parameter it was declared for.</summary>
+    private static bool TryCoerce(object? value, Type target, out object? result)
+    {
+        result = null;
+        var underlying = Nullable.GetUnderlyingType(target) ?? target;
+
+        if (value is null) return !underlying.IsValueType || Nullable.GetUnderlyingType(target) is not null;
+        if (underlying.IsInstanceOfType(value)) { result = value; return true; }
+
+        // Numbers arrive as double because the declaration does not say which width it meant.
+        // bool and char are primitives too, and turning a declared 1 into true would build a
+        // different layer than the declaration describes.
+        if (value is double number && underlying.IsPrimitive
+            && underlying != typeof(bool) && underlying != typeof(char))
+        {
+            try
+            {
+                result = Convert.ChangeType(number, underlying, CultureInfo.InvariantCulture);
+                return true;
+            }
+            catch (Exception ex) when (ex is InvalidCastException or OverflowException or FormatException)
+            {
+                return false;
+            }
+        }
+        return false;
     }
 
     private static IEnumerable<Type> GetConstructableLayerTypes()
@@ -163,8 +657,14 @@ private static IEnumerable<Type> GetConstructableLayerTypes()
                 { isLayer = true; break; }
             if (!isLayer) continue;
 
+            // Gated on DECLARING test arguments, not on their being replayable. A layer whose
+            // declaration this sweep cannot reconstruct is a coverage MISS, and it has to land in
+            // the "not constructable" bucket to be visible as one; filtering it out here instead
+            // would drop it from the denominator, so the summary would report full coverage of a
+            // set that had quietly shrunk to the layers that happened to be easy.
             if (!closed.GetConstructors(BindingFlags.Public | BindingFlags.Instance)
-                    .Any(c => c.GetParameters().Length == 0 || c.GetParameters().All(p => p.HasDefaultValue)))
+                    .Any(c => c.GetParameters().Length == 0 || c.GetParameters().All(p => p.HasDefaultValue))
+                && !DeclaresTestArguments(closed))
                 continue;
 
             yield return closed;
diff --git a/tests/AiDotNet.Tests/IntegrationTests/MetaLearning/MetaLearningTestModels.cs b/tests/AiDotNet.Tests/IntegrationTests/MetaLearning/MetaLearningTestModels.cs
index 48d6e03353..ceb0f66a65 100644
--- a/tests/AiDotNet.Tests/IntegrationTests/MetaLearning/MetaLearningTestModels.cs
+++ b/tests/AiDotNet.Tests/IntegrationTests/MetaLearning/MetaLearningTestModels.cs
@@ -275,17 +275,8 @@ public Vector<double> ComputeSecondOrderGradients(
         return gradients;
     }
 
-    public override IFullModel<double, Matrix<double>, Vector<double>> DeepCopy()
-    {
-        var copy = new SecondOrderMatrixModel((int)ParameterCount - 1);
-        copy.SetParameters(GetParameters());
-        return copy;
-    }
-
-    public override IFullModel<double, Matrix<double>, Vector<double>> Clone()
-    {
-        return DeepCopy();
-    }
+    // Clone is NOT overridden: the base already defines Clone() => DeepCopy(), so repeating it here
+    // adds nothing and becomes a cycle the moment DeepCopy is the one that goes.
 }
 
 internal class TensorEmbeddingModel : IFullModel<double, Matrix<double>, Tensor<double>>,
@@ -539,13 +530,6 @@ public override Vector<double> Predict(Matrix<double> input)
         return embedding;
     }
 
-    public override IFullModel<double, Matrix<double>, Vector<double>> DeepCopy()
-    {
-        var copy = new IdentityEmbeddingModel(_featureCount);
-        copy.SetParameters(GetParameters());
-        return copy;
-    }
-
     /// <inheritdoc />
     /// <remarks>
     /// Overridden alongside <see cref="DeepCopy"/>: without it the base built a plain
diff --git a/tests/AiDotNet.Tests/IntegrationTests/MixedPrecision/MixedPrecisionIntegrationTests.cs b/tests/AiDotNet.Tests/IntegrationTests/MixedPrecision/MixedPrecisionIntegrationTests.cs
index 97ab789a96..a1df3136e0 100644
--- a/tests/AiDotNet.Tests/IntegrationTests/MixedPrecision/MixedPrecisionIntegrationTests.cs
+++ b/tests/AiDotNet.Tests/IntegrationTests/MixedPrecision/MixedPrecisionIntegrationTests.cs
@@ -14,7 +14,7 @@ namespace AiDotNetTests.IntegrationTests.MixedPrecision;
 /// Tests the full workflow of mixed-precision training including loss scaling,
 /// context management, and precision conversions.
 /// </summary>
-public class MixedPrecisionIntegrationTests
+public partial class MixedPrecisionIntegrationTests
 {
     private const double Tolerance = 1e-5;
 
@@ -1636,7 +1636,7 @@ public async Task LayerBase_LayerName_CanBeOverridden()
     /// Test layer for verifying mixed precision integration.
     /// </summary>
     [ElementWiseShape]
-    private class TestLayer : AiDotNet.NeuralNetworks.Layers.LayerBase<float>
+    private partial class TestLayer : AiDotNet.NeuralNetworks.Layers.LayerBase<float>
     {
         private readonly string? _customName;
 
diff --git a/tests/AiDotNet.Tests/IntegrationTests/NeuralNetworks/EmbeddingLayerValidatorIssues1321_1322_1323IntegrationTests.cs b/tests/AiDotNet.Tests/IntegrationTests/NeuralNetworks/EmbeddingLayerValidatorIssues1321_1322_1323IntegrationTests.cs
index d23055f393..74bd2442bf 100644
--- a/tests/AiDotNet.Tests/IntegrationTests/NeuralNetworks/EmbeddingLayerValidatorIssues1321_1322_1323IntegrationTests.cs
+++ b/tests/AiDotNet.Tests/IntegrationTests/NeuralNetworks/EmbeddingLayerValidatorIssues1321_1322_1323IntegrationTests.cs
@@ -33,7 +33,7 @@ namespace AiDotNetTests.IntegrationTests.NeuralNetworks;
 /// LayerCategory.Embedding as broadcast-input; the fit detector returns
 /// empty calibration with a Trace warning instead of throwing.
 /// </summary>
-public class EmbeddingLayerValidatorIssues1321_1322_1323IntegrationTests
+public partial class EmbeddingLayerValidatorIssues1321_1322_1323IntegrationTests
 {
     // ====================================================================
     // ISSUE #1321 — TransformerArchitecture.ValidateInputDimensions
@@ -576,7 +576,7 @@ private static ModelEvaluationData<float, Tensor<float>, Tensor<float>> BuildEva
     /// </summary>
     [TensorLayout(TensorAxis.Time, Direction = TensorLayoutDirection.Input)]
     [TensorLayout(TensorAxis.Classes, Direction = TensorLayoutDirection.Output)]
-    private sealed class NameOnlyEmbeddingLayer : LayerBase<float>, IShapeContract
+    private sealed partial class NameOnlyEmbeddingLayer : LayerBase<float>, IShapeContract
     {
         private readonly int _vocabSize;
 
@@ -704,7 +704,7 @@ public ProbeForCategoryReporter(LayerBase<float> layer)
     [TensorLayout(TensorAxis.Batch, TensorAxis.Time, Direction = TensorLayoutDirection.Input)]
     [TensorLayout(TensorAxis.Batch, TensorAxis.Time, TensorAxis.Features,
         Direction = TensorLayoutDirection.Output)]
-    private sealed class CustomTokenEmbeddingLayer : LayerBase<float>, IShapeContract
+    private sealed partial class CustomTokenEmbeddingLayer : LayerBase<float>, IShapeContract
     {
         private readonly int _vocabSize;
         private readonly int _embeddingDim;
diff --git a/tests/AiDotNet.Tests/IntegrationTests/NeuralNetworks/FusedOptimizerIntegrationTests.cs b/tests/AiDotNet.Tests/IntegrationTests/NeuralNetworks/FusedOptimizerIntegrationTests.cs
index 3299d4514d..c8a9294594 100644
--- a/tests/AiDotNet.Tests/IntegrationTests/NeuralNetworks/FusedOptimizerIntegrationTests.cs
+++ b/tests/AiDotNet.Tests/IntegrationTests/NeuralNetworks/FusedOptimizerIntegrationTests.cs
@@ -819,9 +819,6 @@ public override ModelMetadata<float> GetModelMetadata() =>
 
         protected override void SerializeNetworkSpecificData(BinaryWriter writer) { }
         protected override void DeserializeNetworkSpecificData(BinaryReader reader) { }
-
-        protected override IFullModel<float, Tensor<float>, Tensor<float>> CreateNewInstance()
-            => new FusedTrainingTestNetwork(Architecture);
     }
 
     internal sealed class FusedTrainingTestNetworkDouble : VectorModelLayoutBase<double>
@@ -872,8 +869,5 @@ public override ModelMetadata<double> GetModelMetadata() =>
 
         protected override void SerializeNetworkSpecificData(BinaryWriter writer) { }
         protected override void DeserializeNetworkSpecificData(BinaryReader reader) { }
-
-        protected override IFullModel<double, Tensor<double>, Tensor<double>> CreateNewInstance()
-            => new FusedTrainingTestNetworkDouble(Architecture);
     }
 }
diff --git a/tests/AiDotNet.Tests/IntegrationTests/NeuralNetworks/HrePaperAChainShapeValidatorTests.cs b/tests/AiDotNet.Tests/IntegrationTests/NeuralNetworks/HrePaperAChainShapeValidatorTests.cs
index c72ef919aa..34ae78e91e 100644
--- a/tests/AiDotNet.Tests/IntegrationTests/NeuralNetworks/HrePaperAChainShapeValidatorTests.cs
+++ b/tests/AiDotNet.Tests/IntegrationTests/NeuralNetworks/HrePaperAChainShapeValidatorTests.cs
@@ -27,7 +27,7 @@ namespace AiDotNetTests.IntegrationTests.NeuralNetworks;
 /// declares the same shape contract as HarmonicEngine's <c>HreReadoutLayer</c>,
 /// which is what surfaces the validator regression.</para>
 /// </summary>
-public class HrePaperAChainShapeValidatorTests
+public partial class HrePaperAChainShapeValidatorTests
 {
     /// <summary>
     /// Validator runs at chain-construction time and rejects the chain if any
@@ -236,7 +236,7 @@ private static TransformerArchitecture<float> BuildHreLikeArchitecture()
         Direction = TensorLayoutDirection.Input)]
     [TensorLayout(TensorAxis.Channels, TensorAxis.Height, TensorAxis.Width,
         Direction = TensorLayoutDirection.Output)]
-    private sealed class FixedShapeRank2Layer : LayerBase<float>, IShapeContract
+    private sealed partial class FixedShapeRank2Layer : LayerBase<float>, IShapeContract
     {
         public FixedShapeRank2Layer(int[] inputShape, int[] outputShape)
             : base(inputShape, outputShape)
@@ -304,6 +304,5 @@ public override void UpdateParameters(float learningRate) { }
         public override void SetParameters(Vector<float> parameters) { }
         public override Vector<float> GetParameterGradients() => new Vector<float>(0);
         public override void ResetState() { }
-        public override LayerBase<float> Clone() => new FixedShapeRank2Layer(GetInputShape(), GetOutputShape());
     }
 }
diff --git a/tests/AiDotNet.Tests/IntegrationTests/NeuralNetworks/NeuralNetworkBaseIntegrationTests.cs b/tests/AiDotNet.Tests/IntegrationTests/NeuralNetworks/NeuralNetworkBaseIntegrationTests.cs
index 044cf4037c..11e985012f 100644
--- a/tests/AiDotNet.Tests/IntegrationTests/NeuralNetworks/NeuralNetworkBaseIntegrationTests.cs
+++ b/tests/AiDotNet.Tests/IntegrationTests/NeuralNetworks/NeuralNetworkBaseIntegrationTests.cs
@@ -14,7 +14,7 @@
 
 namespace AiDotNet.Tests.IntegrationTests.NeuralNetworks;
 
-public class NeuralNetworkBaseIntegrationTests
+public partial class NeuralNetworkBaseIntegrationTests
 {
     private static Tensor<float> CreateRandomTensor(int[] shape, int seed = 42)
     {
@@ -191,7 +191,7 @@ public async Task GeneratedLayerAliases_RebindByIdentityAcrossTopologyChanges()
         Assert.Contains("Arrays cannot shrink", arrayException.Message, StringComparison.Ordinal);
     }
 
-    private sealed class TestNeuralNetwork : VectorModelLayoutBase<float>
+    private sealed partial class TestNeuralNetwork : VectorModelLayoutBase<float>
     {
         public TestNeuralNetwork(NeuralNetworkArchitecture<float> architecture)
             : base(architecture, new MeanSquaredErrorLoss<float>())
@@ -293,18 +293,13 @@ protected override void SerializeNetworkSpecificData(BinaryWriter writer)
         protected override void DeserializeNetworkSpecificData(BinaryReader reader)
         {
         }
-
-        protected override IFullModel<float, Tensor<float>, Tensor<float>> CreateNewInstance()
-        {
-            return new TestNeuralNetwork(Architecture);
-        }
     }
 
     [AiDotNet.Attributes.TensorLayout(AiDotNet.Enums.TensorAxis.Batch, AiDotNet.Enums.TensorAxis.Features,
         Direction = AiDotNet.Attributes.TensorLayoutDirection.Input)]
     [AiDotNet.Attributes.TensorLayout(AiDotNet.Enums.TensorAxis.Batch, AiDotNet.Enums.TensorAxis.Features,
         Direction = AiDotNet.Attributes.TensorLayoutDirection.Output)]
-    private sealed class PredictCoreOverrideNetwork : NeuralNetworkBase<float>
+    private sealed partial class PredictCoreOverrideNetwork : NeuralNetworkBase<float>
     {
         public PredictCoreOverrideNetwork(NeuralNetworkArchitecture<float> architecture)
             : base(architecture, new MeanSquaredErrorLoss<float>())
@@ -334,8 +329,5 @@ protected override void SerializeNetworkSpecificData(BinaryWriter writer)
         protected override void DeserializeNetworkSpecificData(BinaryReader reader)
         {
         }
-
-        protected override IFullModel<float, Tensor<float>, Tensor<float>> CreateNewInstance()
-            => new PredictCoreOverrideNetwork(Architecture);
     }
 }
diff --git a/tests/AiDotNet.Tests/IntegrationTests/Optimizers/Issue1296LargeXTrainBatchingTests.cs b/tests/AiDotNet.Tests/IntegrationTests/Optimizers/Issue1296LargeXTrainBatchingTests.cs
index c1a73dd369..fe29f127fe 100644
--- a/tests/AiDotNet.Tests/IntegrationTests/Optimizers/Issue1296LargeXTrainBatchingTests.cs
+++ b/tests/AiDotNet.Tests/IntegrationTests/Optimizers/Issue1296LargeXTrainBatchingTests.cs
@@ -63,7 +63,7 @@ namespace AiDotNet.Tests.IntegrationTests.Optimizers;
 // shard where it runs alone — keeping the budget assertion at full strength instead of relaxing it.
 [Xunit.Trait("Category", "SerialPerf")]
 [Collection("NonParallelIntegration")]
-public class Issue1296LargeXTrainBatchingTests
+public partial class Issue1296LargeXTrainBatchingTests
 {
     private readonly ITestOutputHelper _output;
 
@@ -571,7 +571,7 @@ public async Task GradientOptimizer_NeverCallsModelTrainDuringPrepareAndEvaluate
     /// to guarantee the #1296 fix (skipping the pre-epoch full-batch Train)
     /// can't silently regress.
     /// </summary>
-    private sealed class TrainCallCountingTransformer : Transformer<float>
+    private sealed partial class TrainCallCountingTransformer : Transformer<float>
     {
         public int TrainCallCount { get; private set; }
 
diff --git a/tests/AiDotNet.Tests/IntegrationTests/Optimizers/OptimizerTrainSkipTests.cs b/tests/AiDotNet.Tests/IntegrationTests/Optimizers/OptimizerTrainSkipTests.cs
index cff4b72da1..695cdd67ad 100644
--- a/tests/AiDotNet.Tests/IntegrationTests/Optimizers/OptimizerTrainSkipTests.cs
+++ b/tests/AiDotNet.Tests/IntegrationTests/Optimizers/OptimizerTrainSkipTests.cs
@@ -13,7 +13,7 @@ namespace AiDotNet.Tests.IntegrationTests.Optimizers;
 /// don't redundantly call model.Train() every epoch, and that the content-based
 /// cache key in GenerateCacheKey prevents redundant evaluations.
 /// </summary>
-public class OptimizerTrainSkipTests
+public partial class OptimizerTrainSkipTests
 {
     [Fact(Timeout = 30000)]
     public async Task ClosedFormModel_WithOptimizer_CompletesQuickly()
@@ -143,7 +143,7 @@ public async Task CacheKey_SameParameters_ReturnsCachedResult()
     /// <summary>
     /// Test model that counts how many times Train() is called.
     /// </summary>
-    private class TrainCountingModel : MultipleRegression<double>
+    private partial class TrainCountingModel : MultipleRegression<double>
     {
         public int TrainCallCount { get; private set; }
 
diff --git a/tests/AiDotNet.Tests/IntegrationTests/Parameters/ParameterManifestTests.cs b/tests/AiDotNet.Tests/IntegrationTests/Parameters/ParameterManifestTests.cs
index 1c99ccdbb2..260af7703a 100644
--- a/tests/AiDotNet.Tests/IntegrationTests/Parameters/ParameterManifestTests.cs
+++ b/tests/AiDotNet.Tests/IntegrationTests/Parameters/ParameterManifestTests.cs
@@ -323,6 +323,38 @@ public async Task Restore_RejectsMoreThanOneVariableComponent()
         Assert.Contains("at most one resizable", error.Message, StringComparison.Ordinal);
     }
 
+    [Fact]
+    public async Task MatchingRestore_UsesStableIdsForMultipleVariableComponents()
+    {
+        await Task.Yield();
+        double[] first = Array.Empty<double>();
+        double[] second = Array.Empty<double>();
+        var registry = new ParameterComponentRegistry<double>();
+        registry.Register("first", new VariableLengthParameterSource<double>(
+            () => first.Length,
+            () => new Vector<double>(first),
+            values => first = values.ToArray()));
+        registry.Register("second", new VariableLengthParameterSource<double>(
+            () => second.Length,
+            () => new Vector<double>(second),
+            values => second = values.ToArray()));
+        var checkpointLayout = new ParameterLayoutSnapshot(new[]
+        {
+            new ParameterSlotDescriptor(
+                "first", ParameterSlotRole.LearnedState, ParameterReadiness.Materialized,
+                parameterCount: 2, offset: 0, shape: new[] { 2 }),
+            new ParameterSlotDescriptor(
+                "second", ParameterSlotRole.LearnedState, ParameterReadiness.Materialized,
+                parameterCount: 1, offset: 2, shape: new[] { 1 })
+        });
+
+        registry.SetMatchingParameters(
+            new Vector<double>(new[] { 10d, 11d, 20d }), checkpointLayout);
+
+        Assert.Equal(new[] { 10d, 11d }, first);
+        Assert.Equal(new[] { 20d }, second);
+    }
+
     [Fact]
     public async Task LayoutSnapshot_CannotBeMutatedThroughItsPublicSlotCollection()
     {
@@ -452,6 +484,32 @@ public async Task LayoutFingerprint_DistinguishesReadinessWithIdenticalIdentityA
         });
 
         Assert.NotEqual(unmaterialized.Fingerprint, materialized.Fingerprint);
+        Assert.Equal(unmaterialized.DeclaredLayoutFingerprint,
+            materialized.DeclaredLayoutFingerprint);
+    }
+
+    [Fact]
+    public void DeclaredLayoutFingerprint_StillRejectsSemanticOrShapeChanges()
+    {
+        static ParameterLayoutSnapshot Snapshot(
+            ParameterSlotRole role,
+            int[] shape,
+            ParameterOwnership ownership = ParameterOwnership.Owned) => new(new[]
+        {
+            new ParameterSlotDescriptor(
+                "weight", role, ParameterReadiness.Materialized, 12,
+                shape: shape, elementType: "System.Single", ownership: ownership)
+        });
+
+        var baseline = Snapshot(ParameterSlotRole.Trainable, new[] { 2, 6 });
+
+        Assert.NotEqual(baseline.DeclaredLayoutFingerprint,
+            Snapshot(ParameterSlotRole.Buffer, new[] { 2, 6 }).DeclaredLayoutFingerprint);
+        Assert.NotEqual(baseline.DeclaredLayoutFingerprint,
+            Snapshot(ParameterSlotRole.Trainable, new[] { 3, 4 }).DeclaredLayoutFingerprint);
+        Assert.NotEqual(baseline.DeclaredLayoutFingerprint,
+            Snapshot(ParameterSlotRole.Trainable, new[] { 2, 6 }, ParameterOwnership.Alias)
+                .DeclaredLayoutFingerprint);
     }
 
     [Fact]
@@ -808,6 +866,26 @@ public async Task LayerManifest_DoesNotDuplicateRegisteredSubLayerParameters()
             layer.GetParameterLayout().Sum(slot => slot.ParameterCount ?? 0));
     }
 
+    [Fact]
+    public async Task LayerManifest_ResolvesDeclaredCompositeChildShapesBeforeValueRead()
+    {
+        await Task.Yield();
+        using var layer = new TransformerEncoderBlock<double>(
+            hiddenSize: 8,
+            numHeads: 2,
+            ffnDim: 16);
+
+        var layout = layer.GetParameterLayout();
+
+        Assert.DoesNotContain(layout, slot =>
+            slot.Readiness == ParameterReadiness.ShapeDeferred || !slot.ParameterCount.HasValue);
+        Assert.Contains(layout, slot =>
+            slot.Readiness == ParameterReadiness.ShapeResolvedUnmaterialized);
+        Assert.Equal(
+            layout.Sum(slot => slot.ParameterCount!.Value),
+            layer.GetParameters().Length);
+    }
+
     [Fact]
     public async Task KeyedCollections_UseCanonicalKeyOrder()
     {
diff --git a/tests/AiDotNet.Tests/IntegrationTests/ReinforcementLearning/BaseClassesIntegrationTests.cs b/tests/AiDotNet.Tests/IntegrationTests/ReinforcementLearning/BaseClassesIntegrationTests.cs
index a71b9c176f..baf457e179 100644
--- a/tests/AiDotNet.Tests/IntegrationTests/ReinforcementLearning/BaseClassesIntegrationTests.cs
+++ b/tests/AiDotNet.Tests/IntegrationTests/ReinforcementLearning/BaseClassesIntegrationTests.cs
@@ -18,7 +18,7 @@
 namespace AiDotNet.Tests.IntegrationTests.ReinforcementLearning;
 
 [Collection("NonParallelIntegration")]
-public class BaseClassesIntegrationTests
+public partial class BaseClassesIntegrationTests
 {
     [Fact(Timeout = 120000)]
     public async Task PolicyBase_ValidateStateAndAction_ThrowsForInvalidInput()
@@ -206,7 +206,7 @@ public void ValidateSize(int expected, int actual)
         }
     }
 
-    private sealed class TestDeepAgent : DeepReinforcementLearningAgentBase<double>
+    private sealed partial class TestDeepAgent : DeepReinforcementLearningAgentBase<double>
     {
         private readonly INeuralNetwork<double> _network;
 
@@ -274,10 +274,9 @@ public override void Deserialize(byte[] data)
         // same weights -- which is what DeepReinforcementLearningAgentBase_ParameterCount_SumsNetworks
         // is actually asserting.
 
-        public override IFullModel<double, Vector<double>, Vector<double>> Clone()
-        {
-            return new TestDeepAgent(Options);
-        }
+        // Clone is NOT overridden, for the same reason GetParameters is not: the base reproduces it
+        // from the recorded constructor, and a hand-written copy here would be one more place an
+        // Options field could be dropped without any test failing.
 
         public Vector<double> ComputeGradients(
             Vector<double> input,
@@ -309,7 +308,7 @@ private static NeuralNetwork<double> CreateNetwork()
         }
     }
 
-    private sealed class TestBaseAgent : ReinforcementLearningAgentBase<double>
+    private sealed partial class TestBaseAgent : ReinforcementLearningAgentBase<double>
     {
         private Vector<double> _parameters;
         private bool _deserializeCalled;
@@ -376,13 +375,6 @@ public override void SetParameters(Vector<double> parameters)
 
         public override int FeatureCount => 2;
 
-        public override IFullModel<double, Vector<double>, Vector<double>> Clone()
-        {
-            var clone = new TestBaseAgent(Options);
-            clone.SetParameters(GetParameters());
-            return clone;
-        }
-
         public Vector<double> ComputeGradients(
             Vector<double> input,
             Vector<double> target,
diff --git a/tests/AiDotNet.Tests/IntegrationTests/ReinforcementLearning/DeepAgentsIntegrationTests.cs b/tests/AiDotNet.Tests/IntegrationTests/ReinforcementLearning/DeepAgentsIntegrationTests.cs
index 7b48b76aaa..ec33cc7fa2 100644
--- a/tests/AiDotNet.Tests/IntegrationTests/ReinforcementLearning/DeepAgentsIntegrationTests.cs
+++ b/tests/AiDotNet.Tests/IntegrationTests/ReinforcementLearning/DeepAgentsIntegrationTests.cs
@@ -1,7 +1,9 @@
 using System;
 using System.Collections.Generic;
+using System.IO;
 using AiDotNet.LossFunctions;
 using AiDotNet.Models.Options;
+using AiDotNet.Models.Parameters;
 using AiDotNet.ReinforcementLearning.Agents;
 using AiDotNet.ReinforcementLearning.Agents.A2C;
 using AiDotNet.ReinforcementLearning.Agents.A3C;
@@ -38,6 +40,58 @@ public class DeepAgentsIntegrationTests
     private const double LearningRate = 0.01;
     private const double DiscountFactor = 0.9;
 
+    [Fact]
+    public void DeepQ_target_network_has_one_buffer_owner_and_no_aggregate_alias()
+    {
+        var agent = new DQNAgent<double>(new DQNOptions<double>
+        {
+            StateSize = DiscreteStateSize,
+            ActionSize = DiscreteActionSize,
+            HiddenLayers = new List<int> { 4 },
+            Seed = 11
+        });
+
+        var layout = agent.ParameterLayout;
+
+        Assert.DoesNotContain(layout.Slots,
+            slot => slot.StableId.Contains("DeepReinforcementLearningAgentBase<T>::Networks"));
+        Assert.Contains(layout.Slots,
+            slot => slot.StableId.Contains("DQNAgent<T>::_targetNetwork")
+                && slot.Role == ParameterSlotRole.Buffer);
+        // The online network is registered by the legacy RegisterComponents hook, whose durable
+        // owner ID deliberately does not depend on the private field name. Its semantic contract is
+        // that trainable slots remain present while the explicitly named target is buffer-only.
+        Assert.Contains(layout.Slots, slot => slot.Role == ParameterSlotRole.Trainable);
+    }
+
+    [Fact]
+    public void Qmix_target_networks_have_buffer_owners_and_no_aggregate_alias()
+    {
+        var agent = new QMIXAgent<double>(new QMIXOptions<double>
+        {
+            NumAgents = 2,
+            StateSize = DiscreteStateSize,
+            ActionSize = DiscreteActionSize,
+            GlobalStateSize = 1,
+            AgentHiddenLayers = new List<int> { 4 },
+            MixingHiddenLayers = new List<int> { 4 }
+        });
+
+        var layout = agent.ParameterLayout;
+
+        Assert.DoesNotContain(layout.Slots,
+            slot => slot.StableId.Contains("DeepReinforcementLearningAgentBase<T>::Networks"));
+        Assert.Contains(layout.Slots,
+            slot => slot.StableId.Contains("QMIXAgent<T>::_targetAgentNetworks")
+                && slot.Role == ParameterSlotRole.Buffer);
+        Assert.Contains(layout.Slots,
+            slot => slot.StableId.Contains("QMIXAgent<T>::_targetMixingNetwork")
+                && slot.Role == ParameterSlotRole.Buffer);
+        Assert.Contains(layout.Slots,
+            slot => slot.StableId.Contains("QMIXAgent<T>::_agentNetworks")
+                && slot.Role == ParameterSlotRole.Trainable);
+    }
+
     [Fact(Timeout = 120000)]
     public async Task DeepQAgents_RunBasicWorkflow()
     {
@@ -406,7 +460,7 @@ public async Task ModelBasedAgents_RunBasicWorkflow()
 
         ExerciseReplayAgent(muzero, DiscreteStateSize, DiscreteActionSize, true, 1, true);
 
-        var dreamer = new DreamerAgent<double>(new DreamerOptions<double>
+        var dreamerOptions = new DreamerOptions<double>
         {
             ObservationSize = ContinuousStateSize,
             ActionSize = ContinuousActionSize,
@@ -419,13 +473,29 @@ public async Task ModelBasedAgents_RunBasicWorkflow()
             DiscountFactor = DiscountFactor,
             LossFunction = CreateLoss(),
             Seed = 121
-        });
+        };
+        var dreamer = new DreamerAgent<double>(dreamerOptions);
+
+        ExerciseReplayAgent(dreamer, ContinuousStateSize, ContinuousActionSize, false, 2, true);
 
-        ExerciseReplayAgent(dreamer, ContinuousStateSize, ContinuousActionSize, false, 2, false);
-        Assert.Throws<NotSupportedException>(() => dreamer.Serialize());
-        Assert.Throws<NotSupportedException>(() => dreamer.Deserialize(new byte[] { 1 }));
-        Assert.Throws<NotSupportedException>(() => dreamer.SaveModel("dreamer.bin"));
-        Assert.Throws<NotSupportedException>(() => dreamer.LoadModel("dreamer.bin"));
+        var serializedDreamer = dreamer.Serialize();
+        var restoredDreamer = new DreamerAgent<double>(dreamerOptions);
+        restoredDreamer.Deserialize(serializedDreamer);
+        AssertParametersEqual(dreamer, restoredDreamer);
+
+        string dreamerPath = Path.Combine(
+            Path.GetTempPath(), $"aidotnet-dreamer-{Guid.NewGuid():N}.bin");
+        try
+        {
+            dreamer.SaveModel(dreamerPath);
+            var loadedDreamer = new DreamerAgent<double>(dreamerOptions);
+            loadedDreamer.LoadModel(dreamerPath);
+            AssertParametersEqual(dreamer, loadedDreamer);
+        }
+        finally
+        {
+            if (File.Exists(dreamerPath)) File.Delete(dreamerPath);
+        }
 
         var worldModels = new WorldModelsAgent<double>(new WorldModelsOptions<double>
         {
@@ -631,6 +701,19 @@ private static void AssertAgentState(ReinforcementLearningAgentBase<double> agen
         }
     }
 
+    private static void AssertParametersEqual(
+        ReinforcementLearningAgentBase<double> expected,
+        ReinforcementLearningAgentBase<double> actual)
+    {
+        var expectedParameters = expected.GetParameters();
+        var actualParameters = actual.GetParameters();
+        Assert.Equal(expectedParameters.Length, actualParameters.Length);
+        for (int i = 0; i < expectedParameters.Length; i++)
+        {
+            Assert.Equal(expectedParameters[i], actualParameters[i], 10);
+        }
+    }
+
     private static Vector<double> CreateState(int size, double start)
     {
         var state = new Vector<double>(size);
diff --git a/tests/AiDotNet.Tests/IntegrationTests/SyntheticData/SyntheticTabularGeneratorIntegrationTests.cs b/tests/AiDotNet.Tests/IntegrationTests/SyntheticData/SyntheticTabularGeneratorIntegrationTests.cs
index e83be017dc..d3b90f4248 100644
--- a/tests/AiDotNet.Tests/IntegrationTests/SyntheticData/SyntheticTabularGeneratorIntegrationTests.cs
+++ b/tests/AiDotNet.Tests/IntegrationTests/SyntheticData/SyntheticTabularGeneratorIntegrationTests.cs
@@ -369,6 +369,15 @@ public async Task PATEGANGenerator_SaveLoad_PreservesAuxiliaryNetworks()
         // The generator batch-norm layers live outside the base Layers collection; verify they
         // (and the VGM transformer driving output activations) survive serialization.
         AssertAuxLayerListPreserved<BatchNormalizationLayer<double>>(generator, restored, "_genBNLayers");
+        var originalTransformer = GetPrivateField<TabularDataTransformer<double>>(generator, "_transformer");
+        var restoredTransformer = GetPrivateField<TabularDataTransformer<double>>(restored, "_transformer");
+        Assert.NotNull(restoredTransformer);
+        Assert.Equal(originalTransformer.Serialize(), restoredTransformer.Serialize());
+        var originalParameters = generator.GetParameters();
+        var restoredParameters = restored.GetParameters();
+        Assert.Equal(originalParameters.Length, restoredParameters.Length);
+        for (int i = 0; i < originalParameters.Length; i++)
+            Assert.Equal(originalParameters[i], restoredParameters[i], 10);
 
         generator.SetTrainingMode(false);
         restored.SetTrainingMode(false);
@@ -592,6 +601,15 @@ public async Task MisGANGenerator_SaveLoad_PreservesAuxiliaryNetworks()
         // The data-generator batch-norm layers (running mean/variance included) live outside the
         // base Layers collection; verify they survive serialization, including their extras.
         AssertAuxLayerListPreserved<BatchNormalizationLayer<double>>(generator, restored, "_dataGenBNLayers");
+        var originalTransformer = GetPrivateField<TabularDataTransformer<double>>(generator, "_transformer");
+        var restoredTransformer = GetPrivateField<TabularDataTransformer<double>>(restored, "_transformer");
+        Assert.NotNull(restoredTransformer);
+        Assert.Equal(originalTransformer.Serialize(), restoredTransformer.Serialize());
+        var originalParameters = generator.GetParameters();
+        var restoredParameters = restored.GetParameters();
+        Assert.Equal(originalParameters.Length, restoredParameters.Length);
+        for (int i = 0; i < originalParameters.Length; i++)
+            Assert.Equal(originalParameters[i], restoredParameters[i], 10);
 
         // And the eval-mode forward (used by Generate) must match exactly after restore — this also
         // exercises the restored VGM transformer via ApplyOutputActivations.
@@ -832,6 +850,31 @@ public async Task AutoDiffTabGenerator_FitAndGenerate_ProducesValidOutput()
         ValidateGeneratedData(generated, GenSamples, TotalCols, "AutoDiffTab");
     }
 
+    [Fact(Timeout = 120000)]
+    public async Task AutoDiffTabGenerator_ClonePreservesRuntimeSizedTopology()
+    {
+        await Task.Yield();
+        var architecture = CreateArchitecture(10, 10);
+        using var generator = new AutoDiffTabGenerator<double>(
+            architecture,
+            new AutoDiffTabOptions<double>
+            {
+                Seed = Seed,
+                MLPDimensions = [16],
+                TimestepEmbeddingDimension = 8
+            });
+        var input = new Tensor<double>([4]);
+        for (int i = 0; i < input.Length; i++) input[i] = 0.1 * (i + 1);
+
+        var expected = generator.Predict(input);
+        using var clone = generator.Clone();
+        var actual = clone.Predict(input);
+
+        Assert.Equal(expected.Length, actual.Length);
+        for (int i = 0; i < expected.Length; i++)
+            Assert.Equal(expected[i], actual[i], 12);
+    }
+
     [Fact(Timeout = 120000)]
     public async Task FinDiffGenerator_FitAndGenerate_ProducesValidOutput()
     {
diff --git a/tests/AiDotNet.Tests/IntegrationTests/Training/ConfiguredDataSplitterTests.cs b/tests/AiDotNet.Tests/IntegrationTests/Training/ConfiguredDataSplitterTests.cs
index 13454aab3a..3b39a223ce 100644
--- a/tests/AiDotNet.Tests/IntegrationTests/Training/ConfiguredDataSplitterTests.cs
+++ b/tests/AiDotNet.Tests/IntegrationTests/Training/ConfiguredDataSplitterTests.cs
@@ -25,7 +25,7 @@ namespace AiDotNet.Tests.IntegrationTests.Training;
 /// unreachable from the facade — walk-forward, purged k-fold and combinatorial purged among them —
 /// despite all of them already deriving DataSplitterBase&lt;T&gt;.
 /// </remarks>
-public class ConfiguredDataSplitterTests
+public partial class ConfiguredDataSplitterTests
 {
     private static (Matrix<double> X, Vector<double> Y) BuildData(int rows = 60, int cols = 3)
     {
@@ -74,7 +74,7 @@ public override DataSplitResult<double> Split(Matrix<double> X, Vector<double>?
     }
 
     /// <summary>Records the training-partition size the optimizer was actually handed, to prove consumption.</summary>
-    private sealed class RecordingOptimizer : NormalOptimizer<double, Matrix<double>, Vector<double>>
+    private sealed partial class RecordingOptimizer : NormalOptimizer<double, Matrix<double>, Vector<double>>
     {
         public int LastTrainRows { get; private set; } = -1;
 
diff --git a/tests/AiDotNet.Tests/IntegrationTests/UncertaintyQuantification/UncertaintyQuantificationIntegrationTests.cs b/tests/AiDotNet.Tests/IntegrationTests/UncertaintyQuantification/UncertaintyQuantificationIntegrationTests.cs
index a76048be7a..2f19f26e62 100644
--- a/tests/AiDotNet.Tests/IntegrationTests/UncertaintyQuantification/UncertaintyQuantificationIntegrationTests.cs
+++ b/tests/AiDotNet.Tests/IntegrationTests/UncertaintyQuantification/UncertaintyQuantificationIntegrationTests.cs
@@ -331,5 +331,24 @@ public async Task BayesianDenseLayer_Forward_MultipleCallsProduceDifferentOutput
         Assert.True(anyDifferent, "Bayesian layer should produce different outputs due to weight sampling");
     }
 
+    [Fact(Timeout = 120000)]
+    public async Task BayesianDenseLayer_SamplingDoesNotChangeGeneratedParameterSurface()
+    {
+        var layer = new BayesianDenseLayer<double>(inputSize: 4, outputSize: 2, randomSeed: 42);
+        var input = new Tensor<double>(new[] { 1, 4 }, new Vector<double>(new[] { 1.0, 2.0, 3.0, 4.0 }));
+
+        long countBeforeSampling = layer.ParameterCount;
+        int tensorsBeforeSampling = layer.GetTrainableParameters().Count;
+
+        layer.SampleWeights();
+        _ = layer.Forward(input);
+
+        Assert.Equal(countBeforeSampling, layer.ParameterCount);
+        Assert.Equal(tensorsBeforeSampling, layer.GetTrainableParameters().Count);
+        Assert.Equal(4, tensorsBeforeSampling);
+
+        await Task.CompletedTask;
+    }
+
     #endregion
 }
diff --git a/tests/AiDotNet.Tests/IntegrationTests/Video/RAPIDFlowReviewRegressionIntegrationTests.cs b/tests/AiDotNet.Tests/IntegrationTests/Video/RAPIDFlowReviewRegressionIntegrationTests.cs
index 8e650a774f..6f5655cde0 100644
--- a/tests/AiDotNet.Tests/IntegrationTests/Video/RAPIDFlowReviewRegressionIntegrationTests.cs
+++ b/tests/AiDotNet.Tests/IntegrationTests/Video/RAPIDFlowReviewRegressionIntegrationTests.cs
@@ -3,8 +3,6 @@
 using AiDotNet.NeuralNetworks;
 using AiDotNet.Tensors.LinearAlgebra;
 using AiDotNet.Video.Motion;
-using System.IO;
-using System.Text;
 using Xunit;
 
 namespace AiDotNet.Tests.IntegrationTests.Video;
@@ -30,31 +28,33 @@ public void UpdateParameters_WithPartialVector_ThrowsBeforeMutatingLayers()
     }
 
     [Fact]
-    public void DeserializeNetworkSpecificData_WithLayerCountMismatch_Throws()
+    public void Deserialize_WithDifferentConstructedLayerCount_RestoresSerializedTopology()
     {
-        var model = CreateModel();
+        var source = CreateModel(numRefinementIterations: 1);
+        var restored = CreateModel(numRefinementIterations: 2);
 
-        var ex = Assert.Throws<InvalidDataException>(() =>
-            model.InvokeDeserializeNetworkSpecificData(numRefinementIterations: 2));
+        restored.Deserialize(source.Serialize());
 
-        Assert.Contains("RAPIDFlow layers", ex.Message);
+        AssertLayerGraphEqual(source, restored);
     }
 
     [Fact]
-    public void DeserializeNetworkSpecificData_WithLayerTypeMismatch_Throws()
+    public void Deserialize_WithAmbiguousConstructedLayerIdentity_ThrowsClearError()
     {
-        var model = CreateModel();
-        model.Layers[0] = model.Layers[^1];
+        var source = CreateModel();
+        var restored = CreateModel();
+        restored.Layers[0] = restored.Layers[^1];
 
-        var ex = Assert.Throws<InvalidDataException>(() =>
-            model.InvokeDeserializeNetworkSpecificData(numRefinementIterations: 1));
+        var ex = Assert.Throws<InvalidOperationException>(() =>
+            restored.Deserialize(source.Serialize()));
 
-        Assert.Contains("Layer 0", ex.Message);
+        Assert.Contains("appears 2 times", ex.Message);
+        Assert.Contains("ambiguous", ex.Message);
     }
 
-    private static RAPIDFlowProbe CreateModel()
+    private static RAPIDFlow<double> CreateModel(int numRefinementIterations = 1)
     {
-        return new RAPIDFlowProbe(
+        return new RAPIDFlow<double>(
             new NeuralNetworkArchitecture<double>(
                 inputType: InputType.ThreeDimensional,
                 taskType: NeuralNetworkTaskType.Regression,
@@ -62,29 +62,23 @@ private static RAPIDFlowProbe CreateModel()
                 inputWidth: 32,
                 inputDepth: 3,
                 outputSize: 2),
-            numRefinementIterations: 1);
+            numRefinementIterations);
     }
 
-    private sealed class RAPIDFlowProbe : RAPIDFlow<double>
+    private static void AssertLayerGraphEqual(RAPIDFlow<double> expected, RAPIDFlow<double> actual)
     {
-        public RAPIDFlowProbe(
-            NeuralNetworkArchitecture<double> architecture,
-            int numRefinementIterations)
-            : base(architecture, numRefinementIterations)
+        Assert.Equal(expected.Layers.Count, actual.Layers.Count);
+        for (int i = 0; i < expected.Layers.Count; i++)
         {
+            Assert.Equal(expected.Layers[i].GetType(), actual.Layers[i].GetType());
         }
 
-        public void InvokeDeserializeNetworkSpecificData(int numRefinementIterations)
+        var expectedParameters = expected.GetParameters();
+        var actualParameters = actual.GetParameters();
+        Assert.Equal(expectedParameters.Length, actualParameters.Length);
+        for (int i = 0; i < expectedParameters.Length; i++)
         {
-            using var stream = new MemoryStream();
-            using (var writer = new BinaryWriter(stream, Encoding.UTF8, leaveOpen: true))
-            {
-                writer.Write(numRefinementIterations);
-            }
-
-            stream.Position = 0;
-            using var reader = new BinaryReader(stream, Encoding.UTF8, leaveOpen: false);
-            DeserializeNetworkSpecificData(reader);
+            Assert.Equal(expectedParameters[i], actualParameters[i], 10);
         }
     }
 }
diff --git a/tests/AiDotNet.Tests/ModelFamilyTests/Diffusion/FluxInpaintingModelTests.cs b/tests/AiDotNet.Tests/ModelFamilyTests/Diffusion/FluxInpaintingModelTests.cs
index f4cdd5a7b6..5751df8328 100644
--- a/tests/AiDotNet.Tests/ModelFamilyTests/Diffusion/FluxInpaintingModelTests.cs
+++ b/tests/AiDotNet.Tests/ModelFamilyTests/Diffusion/FluxInpaintingModelTests.cs
@@ -1,19 +1,28 @@
 using AiDotNet.Interfaces;
 using AiDotNet.Diffusion.ImageEditing;
+using AiDotNet.Diffusion.NoisePredictors;
+using AiDotNet.Diffusion.VAE;
 using AiDotNet.Tests.ModelFamilyTests.Base;
 
 namespace AiDotNet.Tests.ModelFamilyTests.Diffusion;
 
-// Compute-bound foundation-scale FLUX double-stream predictor (~12B params): a single forward
-// exceeds the 120s [Fact(Timeout)] in isolation (verified solo — Clone_ShouldProduceIdenticalOutput
-// times out), so it belongs in the HeavyTimeout nightly lane rather than the default PR gate
-// (#1706/#1305). The Clone logic is correct (clones the resolved predictor/VAE); only runtime is slow.
-[Xunit.Trait("Category", "HeavyTimeout")]
+// Exercise the real FLUX Fill predictor/VAE graph at a CI-scale width and depth. The production
+// defaults remain paper-scale (~12B parameters), but a single default forward exceeds the 120s
+// contract-test budget and cannot provide useful clone/serialization feedback in a PR shard.
 public class FluxInpaintingModelTests : DiffusionModelTestBase<float>
 {
     protected override int[] InputShape => [1, 16, 32, 32];
     protected override int[] OutputShape => [1, 16, 32, 32];
 
     protected override IDiffusionModel<float> CreateModel()
-        => new FluxInpaintingModel<float>(seed: 42);
+        => new FluxInpaintingModel<float>(
+            predictor: new FluxDoubleStreamPredictor<float>(
+                inputChannels: 16, hiddenSize: 64, numJointLayers: 2,
+                numSingleLayers: 2, numHeads: 2, patchSize: 2,
+                contextDim: 4096, seed: 42),
+            vae: new StandardVAE<float>(
+                inputChannels: 3, latentChannels: 16, baseChannels: 16,
+                channelMultipliers: new[] { 1, 2 }, numResBlocksPerLevel: 1,
+                latentScaleFactor: 1.5305, seed: 42),
+            seed: 42);
 }
diff --git a/tests/AiDotNet.Tests/ModelFamilyTests/Diffusion/HiDreamModelTests.cs b/tests/AiDotNet.Tests/ModelFamilyTests/Diffusion/HiDreamModelTests.cs
index 1ef3597251..185441f1eb 100644
--- a/tests/AiDotNet.Tests/ModelFamilyTests/Diffusion/HiDreamModelTests.cs
+++ b/tests/AiDotNet.Tests/ModelFamilyTests/Diffusion/HiDreamModelTests.cs
@@ -3,15 +3,18 @@
 using AiDotNet.Diffusion.NoisePredictors;
 using AiDotNet.Diffusion.VAE;
 using AiDotNet.Enums;
+using AiDotNet.Models.Options;
 using AiDotNet.Tests.ModelFamilyTests.Base;
 
 namespace AiDotNet.Tests.ModelFamilyTests.Diffusion;
 
 public class HiDreamModelTests : DiffusionModelTestBase<float>
 {
-    // HiDream's 16-channel latent; keep the latent at 32×32 so the token count stays modest.
-    protected override int[] InputShape => [1, 16, 32, 32];
-    protected override int[] OutputShape => [1, 16, 32, 32];
+    // HiDream's 16-channel latent. A clone invariant performs two complete forwards; 32×32 exceeded
+    // the 120-second budget even in an otherwise idle process. At 16×16 the same MMDiT-X attention,
+    // patching and output reconstruction paths are exercised with one quarter as many image tokens.
+    protected override int[] InputShape => [1, 16, 16, 16];
+    protected override int[] OutputShape => [1, 16, 16, 16];
 
     // HiDream defaults to a foundation-scale MMDiT-X (2048–2560 hidden, 24–38 layers): a single forward
     // exceeds the 120s model-family budget. Inject a tiny same-architecture MMDiT-X + VAE via the new
@@ -19,6 +22,11 @@ public class HiDreamModelTests : DiffusionModelTestBase<float>
     // hidden width / depth / head count shrink.
     protected override IDiffusionModel<float> CreateModel()
         => new HiDreamModel<float>(
+            options: new DiffusionModelOptions<float>
+            {
+                BetaEnd = 1.0,
+                DefaultInferenceSteps = 1
+            },
             predictor: new MMDiTXNoisePredictor<float>(
                 variant: MMDiTXVariant.Medium, inputChannels: 16, patchSize: 2, contextDim: 4096,
                 seed: 42, hiddenSizeOverride: 64, numLayersOverride: 2, numHeadsOverride: 4),
diff --git a/tests/AiDotNet.Tests/ModelFamilyTests/Diffusion/SiDDiTModelTests.cs b/tests/AiDotNet.Tests/ModelFamilyTests/Diffusion/SiDDiTModelTests.cs
index ae854594f7..1b0c1036bf 100644
--- a/tests/AiDotNet.Tests/ModelFamilyTests/Diffusion/SiDDiTModelTests.cs
+++ b/tests/AiDotNet.Tests/ModelFamilyTests/Diffusion/SiDDiTModelTests.cs
@@ -1,18 +1,27 @@
 using AiDotNet.Interfaces;
 using AiDotNet.Diffusion.FastGeneration;
+using AiDotNet.Diffusion.NoisePredictors;
+using AiDotNet.Diffusion.VAE;
 using AiDotNet.Tests.ModelFamilyTests.Base;
 
 namespace AiDotNet.Tests.ModelFamilyTests.Diffusion;
 
-// Compute-bound foundation-scale DiT: the training probe exceeds the 120s
-// [Fact(Timeout)] in isolation (verified), so it belongs in the HeavyTimeout
-// nightly lane rather than the default PR gate (#1706/#1305).
-[Xunit.Trait("Category", "HeavyTimeout")]
+// Exercise the real SiT/DiT predictor and VAE at a CI-scale width and depth. Production defaults
+// remain DiT-XL/2 scale, while this fixture keeps every inherited lifecycle contract runnable in
+// the normal PR lane instead of allowing clone/serialization regressions to hide in HeavyTimeout.
 public class SiDDiTModelTests : DiffusionModelTestBase<float>
 {
     protected override int[] InputShape => [1, 4, 32, 32];
     protected override int[] OutputShape => [1, 4, 32, 32];
 
     protected override IDiffusionModel<float> CreateModel()
-        => new SiDDiTModel<float>(seed: 42);
+        => new SiDDiTModel<float>(
+            predictor: new SiTPredictor<float>(
+                inputChannels: 4, hiddenSize: 64, numLayers: 2,
+                numHeads: 2, seed: 42),
+            vae: new StandardVAE<float>(
+                inputChannels: 3, latentChannels: 4, baseChannels: 16,
+                channelMultipliers: new[] { 1, 2 }, numResBlocksPerLevel: 1,
+                latentScaleFactor: 0.18215, seed: 42),
+            seed: 42);
 }
diff --git a/tests/AiDotNet.Tests/ModelFamilyTests/Diffusion/UpscaleAVideoModelTests.cs b/tests/AiDotNet.Tests/ModelFamilyTests/Diffusion/UpscaleAVideoModelTests.cs
index dad67647ac..c7c86d32ff 100644
--- a/tests/AiDotNet.Tests/ModelFamilyTests/Diffusion/UpscaleAVideoModelTests.cs
+++ b/tests/AiDotNet.Tests/ModelFamilyTests/Diffusion/UpscaleAVideoModelTests.cs
@@ -62,6 +62,52 @@ protected override Tensor<float> PredictModel(
             temporalWindowOverlap: 0);
     }
 
+    [Fact]
+    public void Clone_OwnsIndependentNoiseScheduler()
+    {
+        using var model = Assert.IsType<UpscaleAVideoModel<float>>(CreateModel());
+        using var clone = Assert.IsType<UpscaleAVideoModel<float>>(model.Clone());
+
+        Assert.NotSame(model.Scheduler, clone.Scheduler);
+        Assert.Equal(model.Scheduler.Config.TrainTimesteps, clone.Scheduler.Config.TrainTimesteps);
+        Assert.Equal(model.Scheduler.Timesteps, clone.Scheduler.Timesteps);
+    }
+
+    [Fact(Timeout = 120000)]
+    public async Task Clone_AfterPrediction_PreservesComponentParameterValues()
+    {
+        await Task.Yield();
+        using var model = Assert.IsType<UpscaleAVideoModel<float>>(CreateModel());
+        var input = new Tensor<float>(InputShape);
+        for (int i = 0; i < input.Length; i++) input[i] = -0.2f + (i * 0.01f);
+        _ = PredictModel(model, input);
+
+        using var clone = Assert.IsType<UpscaleAVideoModel<float>>(model.Clone());
+
+        AssertParametersEqual(
+            "noise predictor",
+            model.NoisePredictor.GetParameters(),
+            clone.NoisePredictor.GetParameters());
+        AssertParametersEqual(
+            "temporal VAE",
+            model.VAE.GetParameters(),
+            clone.VAE.GetParameters());
+    }
+
+    private static void AssertParametersEqual(
+        string component,
+        Vector<float> expected,
+        Vector<float> actual)
+    {
+        Assert.True(expected.Length == actual.Length,
+            $"{component} parameter length differs: source={expected.Length}, clone={actual.Length}.");
+        for (int i = 0; i < expected.Length; i++)
+        {
+            Assert.True(expected[i].Equals(actual[i]),
+                $"{component} parameter[{i}] differs: source={expected[i]}, clone={actual[i]}.");
+        }
+    }
+
     [Fact(Timeout = 120000)]
     public override async Task Training_ShouldReducePredictionError()
     {
diff --git a/tests/AiDotNet.Tests/NeuralNetworks/Graph/SequentialActivationFoldContractTests.cs b/tests/AiDotNet.Tests/NeuralNetworks/Graph/SequentialActivationFoldContractTests.cs
index 1089eac6da..1eb0d0b6e0 100644
--- a/tests/AiDotNet.Tests/NeuralNetworks/Graph/SequentialActivationFoldContractTests.cs
+++ b/tests/AiDotNet.Tests/NeuralNetworks/Graph/SequentialActivationFoldContractTests.cs
@@ -12,7 +12,7 @@ namespace AiDotNet.Tests.NeuralNetworks.Graph;
 /// <summary>
 /// Pins the explicit sequential-topology contract used by named activation collection.
 /// </summary>
-public sealed class SequentialActivationFoldContractTests
+public sealed partial class SequentialActivationFoldContractTests
 {
     [Fact]
     public async Task DirectSequentialModel_UsesLayerFoldWithoutRunningPrediction()
@@ -53,7 +53,7 @@ public async Task AuditedGeneralPurposeModels_ChooseSequentialTopologyBase()
             typeof(FeedForwardNeuralNetwork<double>).BaseType);
     }
 
-    private class DirectSequentialModel : SequentialVectorModelLayoutBase<double>
+    private partial class DirectSequentialModel : SequentialVectorModelLayoutBase<double>
     {
         public DirectSequentialModel()
             : base(new MeanSquaredErrorLoss<double>())
diff --git a/tests/AiDotNet.Tests/UnitTests/Audio/AudioFrontEndContractTests.cs b/tests/AiDotNet.Tests/UnitTests/Audio/AudioFrontEndContractTests.cs
index 8d22e11cc5..79e0474af6 100644
--- a/tests/AiDotNet.Tests/UnitTests/Audio/AudioFrontEndContractTests.cs
+++ b/tests/AiDotNet.Tests/UnitTests/Audio/AudioFrontEndContractTests.cs
@@ -66,9 +66,6 @@ protected override void SerializeNetworkSpecificData(BinaryWriter writer)
         protected override void DeserializeNetworkSpecificData(BinaryReader reader)
         {
         }
-
-        protected override IFullModel<double, Tensor<double>, Tensor<double>> CreateNewInstance()
-            => new BareAudioModel(Architecture);
     }
 
     private static BareAudioModel CreateModel()
diff --git a/tests/AiDotNet.Tests/UnitTests/Audio/SileroVadFramePayloadTests.cs b/tests/AiDotNet.Tests/UnitTests/Audio/SileroVadFramePayloadTests.cs
new file mode 100644
index 0000000000..d5eb4ca9ae
--- /dev/null
+++ b/tests/AiDotNet.Tests/UnitTests/Audio/SileroVadFramePayloadTests.cs
@@ -0,0 +1,84 @@
+using AiDotNet.Audio.VoiceActivity;
+using AiDotNet.NeuralNetworks;
+using AiDotNet.Tensors;
+using Xunit;
+
+namespace AiDotNet.Tests.UnitTests.Audio;
+
+/// <summary>
+/// The frame loops must put the AUDIO into the tensor they score.
+/// </summary>
+/// <remarks>
+/// <para>
+/// <c>GetFrameProbabilities</c> and <c>DetectSpeechSegments</c> each built a per-frame tensor and then
+/// assigned the samples into <c>frameTensor.ToVector()</c>. That method allocates and copies, so the
+/// write landed in a throwaway vector and the tensor handed to the model stayed ALL ZEROS: every frame
+/// was scored as silence and the result did not depend on the input at all.
+/// </para>
+/// <para>
+/// <c>PreprocessAudio</c> in the same file already carries a comment describing this exact defect and
+/// writes through <c>Data.Span</c> instead; these two loops were surviving instances of it. The
+/// assertion here is the property a caller cares about — different audio must produce different frame
+/// probabilities — which is false for any implementation that scores a zero-filled tensor.
+/// </para>
+/// </remarks>
+public class SileroVadFramePayloadTests
+{
+    private const int FrameSize = 64;
+
+    private static SileroVad<double> CreateVad() =>
+        new SileroVad<double>(
+            new NeuralNetworkArchitecture<double>(inputFeatures: FrameSize, outputSize: 1),
+            sampleRate: 16000,
+            frameSize: FrameSize,
+            convFilters: 4,
+            lstmHiddenDim: 4,
+            numLstmLayers: 1);
+
+    private static Tensor<double> Signal(int frames, double amplitude, int seed)
+    {
+        var t = new Tensor<double>([frames * FrameSize]);
+        var span = t.Data.Span;
+        var rng = new System.Random(seed);
+        for (int i = 0; i < span.Length; i++)
+            span[i] = amplitude * ((rng.NextDouble() * 2.0) - 1.0);
+        return t;
+    }
+
+    [Fact]
+    public void FrameProbabilities_DependOnTheAudio()
+    {
+        using var vad = CreateVad();
+
+        var quiet = vad.GetFrameProbabilities(Signal(frames: 4, amplitude: 0.0, seed: 1));
+        var loud = vad.GetFrameProbabilities(Signal(frames: 4, amplitude: 0.9, seed: 2));
+
+        Assert.Equal(quiet.Length, loud.Length);
+        Assert.True(quiet.Length > 0, "no frames were scored, so the assertion below would be vacuous");
+
+        bool anyDifferent = false;
+        for (int i = 0; i < quiet.Length; i++)
+            if (quiet[i] != loud[i]) { anyDifferent = true; break; }
+
+        Assert.True(anyDifferent,
+            "every frame probability was identical for silence and for a loud signal, so the model is "
+            + "not seeing the audio. This is the ToVector()-copy defect: the samples were written into a "
+            + "copy and the tensor scored by the model stayed all zeros.");
+    }
+
+    [Fact]
+    public void FrameProbabilities_AreDeterministicForTheSameAudio()
+    {
+        using var vad = CreateVad();
+
+        var audio = Signal(frames: 3, amplitude: 0.7, seed: 11);
+        var first = vad.GetFrameProbabilities(audio);
+        var second = vad.GetFrameProbabilities(audio);
+
+        Assert.Equal(first.Length, second.Length);
+        for (int i = 0; i < first.Length; i++)
+            Assert.True(first[i] == second[i],
+                $"frame {i} scored {first[i]} then {second[i]} for identical audio; the per-frame tensor "
+                + "is now disposed after each frame, and a disposed tensor must not be observable here.");
+    }
+}
diff --git a/tests/AiDotNet.Tests/UnitTests/Diffusion/Models/ControlModelContractTests.cs b/tests/AiDotNet.Tests/UnitTests/Diffusion/Models/ControlModelContractTests.cs
index 42df08bb67..89fb6cd863 100644
--- a/tests/AiDotNet.Tests/UnitTests/Diffusion/Models/ControlModelContractTests.cs
+++ b/tests/AiDotNet.Tests/UnitTests/Diffusion/Models/ControlModelContractTests.cs
@@ -1,5 +1,7 @@
 using AiDotNet.Diffusion.Control;
 using AiDotNet.Diffusion.Guidance;
+using AiDotNet.Diffusion.NoisePredictors;
+using AiDotNet.Diffusion.VAE;
 using Xunit;
 using System.Threading.Tasks;
 
@@ -238,7 +240,27 @@ public async Task ControlNetPlusPlusFluxModel_DefaultConstructor_CreatesValidMod
     [Fact(Timeout = 120000)]
     public async Task ControlNetPlusPlusModel_Clone_CreatesIndependentCopy()
     {
-        var model = new ControlNetPlusPlusModel<float>();
+        // Clone semantics do not require allocating the production 865M-parameter SD 1.5 U-Net.
+        // Keep the real ControlNet++ encoder while injecting the same small UNet/VAE contracts used
+        // by the diffusion parameter tests; this still detects missing component state and sharing.
+        var model = new ControlNetPlusPlusModel<float>(
+            baseUNet: new UNetNoisePredictor<float>(
+                inputChannels: 4,
+                outputChannels: 4,
+                baseChannels: 8,
+                channelMultipliers: [1],
+                numResBlocks: 1,
+                attentionResolutions: [],
+                contextDim: 0,
+                numHeads: 1,
+                inputHeight: 8),
+            vae: new StandardVAE<float>(
+                inputChannels: 3,
+                latentChannels: 4,
+                baseChannels: 8,
+                channelMultipliers: [1],
+                numResBlocksPerLevel: 1),
+            seed: 42);
         var clone = model.Clone();
 
         Assert.NotNull(clone);
diff --git a/tests/AiDotNet.Tests/UnitTests/Diffusion/Models/DiffusionModelContractTests.cs b/tests/AiDotNet.Tests/UnitTests/Diffusion/Models/DiffusionModelContractTests.cs
index 66e8e7f7b7..09e6d4f3cc 100644
--- a/tests/AiDotNet.Tests/UnitTests/Diffusion/Models/DiffusionModelContractTests.cs
+++ b/tests/AiDotNet.Tests/UnitTests/Diffusion/Models/DiffusionModelContractTests.cs
@@ -199,7 +199,11 @@ public async Task StableDiffusion15Model_ParameterCount_RemainsValidAcrossChunkE
     public async Task StableDiffusion15Model_Clone_PreservesLazyParameterCount()
     {
         await Task.Yield();
-        var model = new StableDiffusion15Model<float>();
+        // This invariant checks lifecycle semantics, not production-scale capacity. Cloning the
+        // default 865M-parameter U-Net just to compare two counts exceeds the test budget even in an
+        // isolated process. The tiny stack uses the same lazy UNet/VAE contracts; the following test
+        // separately materializes it and compares every cloned value plus mutation independence.
+        var model = CreateTinyStableDiffusion15Model();
         var clone = model.Clone();
 
         Assert.Equal(model.ParameterCount, clone.ParameterCount);
@@ -281,6 +285,39 @@ public async Task DiTNoisePredictor_MaterializedSmallModel_ChunksMatchParameterC
         Assert.Equal(predictor.ParameterCount, chunks.Sum(chunk => (long)chunk.Length));
     }
 
+    [Fact(Timeout = 120000)]
+    public async Task StandardVAE_PreForwardChunks_CoverAndRestoreCompleteParameterSurface()
+    {
+        await Task.Yield();
+        var source = new StandardVAE<float>(
+            inputChannels: 3,
+            latentChannels: 4,
+            baseChannels: 8,
+            channelMultipliers: [1, 2],
+            numResBlocksPerLevel: 1,
+            seed: 42);
+        var destination = new StandardVAE<float>(
+            inputChannels: 3,
+            latentChannels: 4,
+            baseChannels: 8,
+            channelMultipliers: [1, 2],
+            numResBlocksPerLevel: 1,
+            seed: 43);
+
+        var chunks = source.GetParameterChunks().ToList();
+
+        Assert.NotEmpty(chunks);
+        Assert.Equal(source.ParameterCount, chunks.Sum(chunk => (long)chunk.Length));
+
+        destination.SetParameterChunks(chunks);
+
+        var expected = source.GetParameters();
+        var actual = destination.GetParameters();
+        Assert.Equal(expected.Length, actual.Length);
+        for (int i = 0; i < expected.Length; i++)
+            Assert.Equal(expected[i], actual[i]);
+    }
+
     #endregion
 
     private static StableDiffusion15Model<float> CreateTinyStableDiffusion15Model()
diff --git a/tests/AiDotNet.Tests/UnitTests/Diffusion/PredictorParameterStreamingTests.cs b/tests/AiDotNet.Tests/UnitTests/Diffusion/PredictorParameterStreamingTests.cs
index 55f75d2743..79f18a11c2 100644
--- a/tests/AiDotNet.Tests/UnitTests/Diffusion/PredictorParameterStreamingTests.cs
+++ b/tests/AiDotNet.Tests/UnitTests/Diffusion/PredictorParameterStreamingTests.cs
@@ -97,14 +97,14 @@ private static Tensor<double> UViTInput()
     }
 
     [Fact]
-    public async System.Threading.Tasks.Task UViT_ManifestReportsDeferredRatherThanParameterFree()
+    public async System.Threading.Tasks.Task UViT_ManifestReportsResolvedUnmaterialized()
     {
         await System.Threading.Tasks.Task.Yield();
 
         var predictor = UViT(7);
         var provider = Assert.IsAssignableFrom<IParameterManifestProvider>(predictor);
 
-        Assert.Equal(ParameterReadiness.ShapeDeferred, provider.ParameterLayout.Readiness);
+        Assert.Equal(ParameterReadiness.ShapeResolvedUnmaterialized, provider.ParameterLayout.Readiness);
     }
 
     [Fact]
diff --git a/tests/AiDotNet.Tests/UnitTests/NeuralNetworks/CompileForwardTests.cs b/tests/AiDotNet.Tests/UnitTests/NeuralNetworks/CompileForwardTests.cs
index b2f2e1b54f..f2a040d282 100644
--- a/tests/AiDotNet.Tests/UnitTests/NeuralNetworks/CompileForwardTests.cs
+++ b/tests/AiDotNet.Tests/UnitTests/NeuralNetworks/CompileForwardTests.cs
@@ -219,8 +219,5 @@ public override ModelMetadata<float> GetModelMetadata() =>
 
         protected override void SerializeNetworkSpecificData(BinaryWriter writer) { }
         protected override void DeserializeNetworkSpecificData(BinaryReader reader) { }
-
-        protected override IFullModel<float, Tensor<float>, Tensor<float>> CreateNewInstance()
-            => new SimpleTestNetwork(Architecture);
     }
 }
diff --git a/tests/AiDotNet.Tests/UnitTests/NeuralNetworks/WeightStreaming/AutoDetectWeightStreamingTests.cs b/tests/AiDotNet.Tests/UnitTests/NeuralNetworks/WeightStreaming/AutoDetectWeightStreamingTests.cs
index a068520b01..dfe13f7d29 100644
--- a/tests/AiDotNet.Tests/UnitTests/NeuralNetworks/WeightStreaming/AutoDetectWeightStreamingTests.cs
+++ b/tests/AiDotNet.Tests/UnitTests/NeuralNetworks/WeightStreaming/AutoDetectWeightStreamingTests.cs
@@ -81,8 +81,6 @@ public override ModelMetadata<float> GetModelMetadata()
             => new() { Name = "FixedParamCountNetwork" };
         protected override void SerializeNetworkSpecificData(BinaryWriter writer) { }
         protected override void DeserializeNetworkSpecificData(BinaryReader reader) { }
-        protected override IFullModel<float, Tensor<float>, Tensor<float>> CreateNewInstance()
-            => new FixedParamCountNetwork(_fixedCount);
     }
 
     [Fact]
diff --git a/tests/AiDotNet.Tests/UnitTests/Parameters/CompositeLayerOwnershipTests.cs b/tests/AiDotNet.Tests/UnitTests/Parameters/CompositeLayerOwnershipTests.cs
new file mode 100644
index 0000000000..84a2b880d8
--- /dev/null
+++ b/tests/AiDotNet.Tests/UnitTests/Parameters/CompositeLayerOwnershipTests.cs
@@ -0,0 +1,107 @@
+using AiDotNet.Interfaces;
+using AiDotNet.NeuralNetworks.Layers;
+using AiDotNet.Tensors.LinearAlgebra;
+using Xunit;
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+
+namespace AiDotNet.Tests.UnitTests.Parameters;
+
+/// <summary>
+/// A tensor may belong to exactly one owner in the parameter traversal.
+/// </summary>
+/// <remarks>
+/// <para>
+/// <see cref="LayerBase{T}"/> builds its ordered component list from three sources and deduplicates
+/// between them: the generated declarations, then every tensor from the trainable view that was not
+/// already declared, then every registered sub-layer that was not already declared. The sub-layer
+/// check compares LAYER references, so it cannot see that a child's tensors already entered the list
+/// through the parent's own trainable view.
+/// </para>
+/// <para>
+/// That makes one shape of hand-written override silently wrong: a composite whose
+/// GetTrainableParameters FLATTENS its children's tensors into its own list, while those same
+/// children are also registered as sub-layers. Each child's weights then appear twice — once as the
+/// parent's trainable tensors and once inside the child component — and the count, the vector and
+/// every offset after them are wrong together. Because the count and the vector are both derived
+/// from that one doubled walk, they still agree with each other, which is why nothing reports it.
+/// </para>
+/// <para>
+/// The invariant is checkable from outside: no tensor the parent hands out may be the same object a
+/// descendant hands out. It holds for a composite that declares its children and lets the base
+/// compose them, and fails for one that flattens them by hand.
+/// </para>
+/// </remarks>
+public class CompositeLayerOwnershipTests
+{
+    public static IEnumerable<object[]> Composites()
+    {
+        yield return Row("BiaffineSpanScorer", () => new BiaffineSpanScorerLayer<double>(8, 6, 3));
+        yield return Row("GatedFusion", () => new GatedFusionLayer<double>(8));
+        yield return Row("ClozeAttention", () => new ClozeAttentionLayer<double>(8));
+        yield return Row("Branchformer", () => new BranchformerBlock<double>(8, 2, 16, 3));
+        yield return Row("CifAlignment", () => new CifAlignmentLayer<double>(8));
+    }
+
+    private static object[] Row(string name, Func<LayerBase<double>> factory)
+        => new object[] { name, factory };
+
+    [Theory(Timeout = 120000)]
+    [MemberData(nameof(Composites))]
+    public async Task NoTensorIsOwnedByBothAParentAndItsChild(string name, Func<LayerBase<double>> factory)
+    {
+        await Task.Yield();
+        var layer = factory();
+
+        var ownTensors = layer.GetTrainableParameters();
+        var byIdentity = new HashSet<Tensor<double>>(ReferenceEqualityComparer<Tensor<double>>.Instance);
+        for (int i = 0; i < ownTensors.Count; i++)
+        {
+            if (ownTensors[i] is not null) byIdentity.Add(ownTensors[i]);
+        }
+
+        var duplicated = new List<string>();
+        CollectDuplicates(layer, byIdentity, duplicated, name);
+
+        Assert.True(duplicated.Count == 0,
+            $"{name} hands out {duplicated.Count} tensor(s) that a registered sub-layer also hands " +
+            "out, so each is counted once as the parent's own parameter and again inside the child " +
+            $"component: {string.Join(", ", duplicated)}.");
+    }
+
+    private static void CollectDuplicates(
+        LayerBase<double> parent,
+        HashSet<Tensor<double>> parentTensors,
+        List<string> duplicated,
+        string path)
+    {
+        var children = parent.GetSubLayers();
+        if (children is null) return;
+
+        for (int c = 0; c < children.Count; c++)
+        {
+            if (children[c] is not LayerBase<double> child) continue;
+
+            var childTensors = child.GetTrainableParameters();
+            for (int i = 0; i < childTensors.Count; i++)
+            {
+                if (childTensors[i] is not null && parentTensors.Contains(childTensors[i]))
+                    duplicated.Add($"{path}->{child.GetType().Name}[{i}]");
+            }
+
+            CollectDuplicates(child, parentTensors, duplicated, $"{path}->{child.GetType().Name}");
+        }
+    }
+
+    private sealed class ReferenceEqualityComparer<TItem> : IEqualityComparer<TItem>
+        where TItem : class
+    {
+        internal static readonly ReferenceEqualityComparer<TItem> Instance = new();
+
+        public bool Equals(TItem? x, TItem? y) => ReferenceEquals(x, y);
+
+        public int GetHashCode(TItem obj)
+            => System.Runtime.CompilerServices.RuntimeHelpers.GetHashCode(obj);
+    }
+}
diff --git a/tests/AiDotNet.Tests/UnitTests/Parameters/DeferredRestoreGateTests.cs b/tests/AiDotNet.Tests/UnitTests/Parameters/DeferredRestoreGateTests.cs
index 87b330fa6b..ebea0e8bf5 100644
--- a/tests/AiDotNet.Tests/UnitTests/Parameters/DeferredRestoreGateTests.cs
+++ b/tests/AiDotNet.Tests/UnitTests/Parameters/DeferredRestoreGateTests.cs
@@ -36,7 +36,7 @@ namespace AiDotNet.Tests.UnitTests.Parameters;
 /// simply wrong.
 /// </para>
 /// </remarks>
-public class DeferredRestoreGateTests
+public partial class DeferredRestoreGateTests
 {
     /// <summary>
     /// A deferred layer must ACCEPT a restore rather than reject it for having a zero count.
@@ -162,7 +162,7 @@ public async Task NetworkRestore_MaterializesExtraTrainableLayers()
         Assert.Equal(checkpoint.ToArray(), target.GetParameters().ToArray());
     }
 
-    private sealed class ExtraLayerRestoreNetwork : VectorModelLayoutBase<double>
+    private sealed partial class ExtraLayerRestoreNetwork : VectorModelLayoutBase<double>
     {
         private TransformerEncoderLayer<double>? _extraLayer;
 
diff --git a/tests/AiDotNet.Tests/UnitTests/Parameters/TabularFamilySurfaceTests.cs b/tests/AiDotNet.Tests/UnitTests/Parameters/TabularFamilySurfaceTests.cs
index 455de6c76b..473751e425 100644
--- a/tests/AiDotNet.Tests/UnitTests/Parameters/TabularFamilySurfaceTests.cs
+++ b/tests/AiDotNet.Tests/UnitTests/Parameters/TabularFamilySurfaceTests.cs
@@ -323,4 +323,131 @@ public void SAINTLayerNorms_ArePartOfTheParameterSurface()
         Assert.Equal(withoutNorm.ParameterCount + expectedNormParameters, withNorm.ParameterCount);
         Assert.Equal(withNorm.ParameterCount, withNorm.GetParameters().Length);
     }
+
+    /// <summary>Every Tabular family, paired with a way to obtain one prediction from it.</summary>
+    public static IEnumerable<object[]> FamiliesWithPredict()
+    {
+        yield return PredictRow("AutoInt", () => new AutoIntRegression<double>(4),
+            model => ((AutoIntRegression<double>)model).Predict(CreateNumericalFeatures()));
+        yield return PredictRow("GANDALF", () => new GANDALFRegression<double>(4),
+            model => ((GANDALFRegression<double>)model).Predict(CreateNumericalFeatures()));
+        yield return PredictRow("Mambular", () => new MambularRegression<double>(4),
+            model => ((MambularRegression<double>)model).Predict(CreateNumericalFeatures()));
+        yield return PredictRow("NODE", () => new NODERegression<double>(4),
+            model => ((NODERegression<double>)model).Predict(CreateNumericalFeatures()));
+        yield return PredictRow("SAINT", () => new SAINTRegression<double>(4),
+            model => ((SAINTRegression<double>)model).Predict(CreateNumericalFeatures()));
+        yield return PredictRow("TabDPT", () => new TabDPTRegression<double>(4),
+            model => ((TabDPTRegression<double>)model).Predict(CreateNumericalFeatures()));
+        yield return PredictRow("TabPFN", () => new TabPFNRegression<double>(4),
+            model => ((TabPFNRegression<double>)model).Predict(CreateNumericalFeatures()));
+        yield return PredictRow("TabR", () => new TabRRegression<double>(4),
+            model =>
+            {
+                var tabR = (TabRRegression<double>)model;
+                var features = CreateNumericalFeatures();
+                tabR.BuildIndex(features);
+                return tabR.Predict(features);
+            });
+        yield return PredictRow(
+            "TabTransformer",
+            () => new TabTransformerRegression<double>(4, 1,
+                new TabTransformerOptions<double> { CategoricalCardinalities = [5, 3] }),
+            model => ((TabTransformerRegression<double>)model).Predict(
+                CreateNumericalFeatures(), CreateCategoricalIndices()));
+        yield return PredictRow("FTTransformer", () => new FTTransformerRegression<double>(4),
+            model => ((FTTransformerRegression<double>)model).Predict(CreateNumericalFeatures()));
+    }
+
+    private static object[] PredictRow(
+        string name,
+        Func<IParameterSource<double>> factory,
+        Func<IParameterSource<double>, Tensor<double>> predict)
+        => new object[] { name, factory, predict };
+
+    /// <summary>The leading values of a prediction, so a failure names what was produced.</summary>
+    private static IEnumerable<string> Describe(Tensor<double> prediction)
+    {
+        int shown = Math.Min(prediction.Length, 4);
+        for (int i = 0; i < shown; i++) yield return prediction[i].ToString("R");
+    }
+
+    /// <summary>
+    /// Two instances given the SAME parameter vector must compute the same prediction.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// Every other test in this file walks a single traversal and compares it with itself: the count
+    /// comes from the registry, the vector comes from the registry, so a weight the registry never
+    /// visits is absent from BOTH sides and the comparison still balances. A component class that is
+    /// neither a layer nor a model — a nested block reached only through a field — can hold half the
+    /// architecture's weights and leave every one of those assertions green.
+    /// </para>
+    /// <para>
+    /// Prediction is the surface that cannot be fooled that way, because it reads the weights
+    /// directly rather than through the registry. Two freshly constructed instances start from
+    /// independent random initialisation, so any value that did not travel in the vector still
+    /// differs between them afterwards, and the two predictions separate. Identical predictions mean
+    /// the vector carried everything the forward pass consulted.
+    /// </para>
+    /// <para>
+    /// The pre-copy inequality is asserted first so the test cannot pass vacuously: if construction
+    /// were deterministic, matching predictions afterwards would prove nothing at all.
+    /// </para>
+    /// </remarks>
+    [Theory(Timeout = 120000)]
+    [MemberData(nameof(FamiliesWithPredict))]
+    public async Task SharedParameterVector_ProducesTheSamePrediction(
+        string name,
+        Func<IParameterSource<double>> factory,
+        Func<IParameterSource<double>, Tensor<double>> predict)
+    {
+        await Task.Yield();
+        var source = factory();
+        var target = factory();
+
+        var atInitialisation = predict(source);
+
+        // A distinctive vector, so what the forward pass reads cannot be confused with either
+        // instance's initialisation.
+        var checkpoint = source.GetParameters();
+        for (int i = 0; i < checkpoint.Length; i++) checkpoint[i] = (i % 97 - 48) / 100.0;
+
+        source.SetParameters(checkpoint);
+        target.SetParameters(checkpoint);
+
+        var sourceAfter = predict(source);
+        var targetAfter = predict(target);
+
+        Assert.Equal(sourceAfter.Length, targetAfter.Length);
+        for (int i = 0; i < sourceAfter.Length; i++)
+        {
+            Assert.Equal(sourceAfter[i], targetAfter[i], precision: 10);
+        }
+
+        // The comparison above only means something if the prediction reads the vector at all. A
+        // model whose output ignored its parameters would satisfy it no matter how much of the
+        // architecture the vector had failed to reach, so require the output to respond to a change
+        // of vector. Two changes are offered rather than one because a saturating output activation
+        // can hold a single pair of vectors at the same clamped value while still being driven by
+        // them; responding to either change establishes the dependency the assertion above needs.
+        var alternate = new Vector<double>(checkpoint.Length);
+        for (int i = 0; i < alternate.Length; i++) alternate[i] = (i % 61 - 30) / 50.0 + 0.37;
+        source.SetParameters(alternate);
+        var sourceAlternate = predict(source);
+
+        bool outputMoved = false;
+        for (int i = 0; i < sourceAfter.Length && !outputMoved; i++)
+        {
+            outputMoved = Math.Abs(sourceAfter[i] - sourceAlternate[i]) > 1e-12
+                || Math.Abs(sourceAfter[i] - atInitialisation[i]) > 1e-12;
+        }
+
+        Assert.True(outputMoved,
+            $"{name} predicted the same values from its initialisation and from two different " +
+            "parameter vectors, so its output does not depend on its parameters and the agreement " +
+            $"asserted above is vacuous. At initialisation it predicted " +
+            $"[{string.Join(", ", Describe(atInitialisation))}]; after restore it predicted " +
+            $"[{string.Join(", ", Describe(sourceAfter))}].");
+    }
 }
diff --git a/tests/AiDotNet.Tests/UnitTests/ProgramSynthesis/CodeModelBaseAdditionalCoverageTests.cs b/tests/AiDotNet.Tests/UnitTests/ProgramSynthesis/CodeModelBaseAdditionalCoverageTests.cs
index bd229a57a3..1ee6b56a73 100644
--- a/tests/AiDotNet.Tests/UnitTests/ProgramSynthesis/CodeModelBaseAdditionalCoverageTests.cs
+++ b/tests/AiDotNet.Tests/UnitTests/ProgramSynthesis/CodeModelBaseAdditionalCoverageTests.cs
@@ -210,8 +210,6 @@ protected override void DeserializeNetworkSpecificData(BinaryReader reader)
         {
             _ = reader.ReadInt32();
         }
-
-        protected override IFullModel<double, Tensor<double>, Tensor<double>> CreateNewInstance() => new MinimalCodeModel(CodeArchitecture);
     }
 
     private sealed class ThrowingCodeModel : MinimalCodeModel
diff --git a/tests/AiDotNet.Tests/UnitTests/ProgramSynthesis/Fakes/FakeCodeModel.cs b/tests/AiDotNet.Tests/UnitTests/ProgramSynthesis/Fakes/FakeCodeModel.cs
index fd9ae5ead6..00a3c5a5cf 100644
--- a/tests/AiDotNet.Tests/UnitTests/ProgramSynthesis/Fakes/FakeCodeModel.cs
+++ b/tests/AiDotNet.Tests/UnitTests/ProgramSynthesis/Fakes/FakeCodeModel.cs
@@ -65,11 +65,6 @@ protected override void DeserializeNetworkSpecificData(BinaryReader reader)
         _ = reader.ReadInt32();
     }
 
-    protected override IFullModel<double, Tensor<double>, Tensor<double>> CreateNewInstance()
-    {
-        return new FakeCodeModel(_architecture);
-    }
-
     public static FakeCodeModel CreateDefault(ProgramLanguage targetLanguage = ProgramLanguage.CSharp)
     {
         var architecture = new CodeSynthesisArchitecture<double>(
diff --git a/tests/AiDotNet.Tests/UnitTests/Serialization/CloneModeTests.cs b/tests/AiDotNet.Tests/UnitTests/Serialization/CloneModeTests.cs
new file mode 100644
index 0000000000..c0c644d242
--- /dev/null
+++ b/tests/AiDotNet.Tests/UnitTests/Serialization/CloneModeTests.cs
@@ -0,0 +1,241 @@
+using AiDotNet.Models;
+using AiDotNet.NeuralNetworks.Layers;
+using AiDotNet.Tensors.Engines;
+using AiDotNet.Tensors.LinearAlgebra;
+using Xunit;
+
+namespace AiDotNetTests.UnitTests.Serialization;
+
+[AiDotNet.Attributes.ElementWiseShape]
+[AiDotNet.Attributes.AutoParameters]
+public sealed partial class CloneStateProbeLayer<T> : LayerBase<T>
+{
+    [AiDotNet.Attributes.Buffer(Name = "running", Role = PersistentTensorRole.Constant)]
+    private Tensor<T> _running = new([1]);
+
+    [AiDotNet.Attributes.Buffer(Name = "optimizer", Role = PersistentTensorRole.OptimizerState)]
+    private Tensor<T> _optimizer = new([1]);
+
+    public CloneStateProbeLayer()
+        : base([1], [1])
+    {
+        _running[0] = NumOps.FromDouble(-1);
+        _optimizer[0] = NumOps.FromDouble(-2);
+    }
+
+    public override bool SupportsTraining => false;
+
+    public double Running
+    {
+        get => NumOps.ToDouble(_running[0]);
+        set => _running[0] = NumOps.FromDouble(value);
+    }
+
+    public double Optimizer
+    {
+        get => NumOps.ToDouble(_optimizer[0]);
+        set => _optimizer[0] = NumOps.FromDouble(value);
+    }
+
+    public override void ResetState()
+    {
+    }
+}
+
+/// <summary>
+/// The three sharing modes have to differ under mutation, or they are one mode with three names.
+/// </summary>
+/// <remarks>
+/// Each test writes through the copy and then reads the ORIGINAL. That is the only observation that
+/// separates them: all three produce a copy with identical values, and what happens next is the
+/// whole distinction.
+/// </remarks>
+public class CloneModeTests
+{
+    private static DenseLayer<double> Trained()
+    {
+        // DenseLayer's input width is lazy, so it owns no parameters until something flows
+        // through it. Forward once, then the weights exist to be set and compared.
+        var layer = new DenseLayer<double>(2);
+        layer.Forward(new Tensor<double>(new[] { 1, 3 }));
+
+        var p = layer.GetParameters();
+        for (var i = 0; i < p.Length; i++) p[i] = i + 1.0;
+        layer.UpdateParameters(p);
+        return layer;
+    }
+
+    [Fact]
+    public void Deep_leaves_the_original_alone()
+    {
+        var original = Trained();
+        var clone = (DenseLayer<double>)original.Clone(CloneOptions.Full);
+
+        Mutate(clone);
+
+        Assert.Equal(1.0, original.GetParameters()[0], precision: 10);
+    }
+
+    [Fact]
+    public void CopyOnWrite_reads_the_same_and_still_splits_on_write()
+    {
+        var original = Trained();
+        var clone = (DenseLayer<double>)original.Clone(CloneOptions.CopyOnWrite);
+
+        // Identical before anybody writes -- that is the point of it being free.
+        Assert.Equal(original.GetParameters()[0], clone.GetParameters()[0], precision: 10);
+
+        Mutate(clone);
+
+        // The write splits them, so this is a copy despite having shared storage a moment ago.
+        Assert.Equal(1.0, original.GetParameters()[0], precision: 10);
+    }
+
+    [Fact]
+    public void Shared_is_an_alias_and_writes_reach_the_original()
+    {
+        var original = Trained();
+        var clone = (DenseLayer<double>)original.Clone(CloneOptions.Shared);
+
+        Mutate(clone);
+
+        // NOT a copy. This asserts the footgun on purpose: if this ever starts passing as 1.0,
+        // Shared has silently become CopyOnWrite and callers relying on the alias are broken.
+        Assert.Equal(99.0, original.GetParameters()[0], precision: 10);
+    }
+
+    [Fact]
+    public void ShareRandomState_carries_the_seed_only_when_asked()
+    {
+        var original = Trained();
+        original.RandomSeed = 4242;
+
+        var derived = (DenseLayer<double>)original.Clone(CloneOptions.Full);
+        var shared = (DenseLayer<double>)original.Clone(
+            new CloneOptions { ShareRandomState = true });
+
+        Assert.Equal(4242, shared.RandomSeed);
+        Assert.NotEqual(4242, derived.RandomSeed ?? 0);
+    }
+
+    [Fact]
+    public void ShareRandomState_preserves_dropout_progress_while_default_derives_a_new_stream()
+    {
+        var original = new DropoutLayer<double>(0.5) { RandomSeed = 4242 };
+        var input = new Tensor<double>(new[] { 1, 256 });
+        input.Fill(1.0);
+
+        // Advance the source once before cloning. Merely copying the seed would restart the clone
+        // at mask zero and fail the next-output equality below.
+        _ = original.Forward(input);
+        var shared = (DropoutLayer<double>)original.Clone(
+            new CloneOptions { ShareRandomState = true });
+        var derived = (DropoutLayer<double>)original.Clone(CloneOptions.Full);
+
+        var expectedNext = original.Forward(input);
+        var sharedNext = shared.Forward(input);
+        var derivedNext = derived.Forward(input);
+
+        bool derivedDiffers = false;
+        for (int i = 0; i < expectedNext.Length; i++)
+        {
+            Assert.Equal(expectedNext[i], sharedNext[i]);
+            derivedDiffers |= expectedNext[i] != derivedNext[i];
+        }
+
+        Assert.True(derivedDiffers,
+            "The default clone reused the source dropout stream instead of deriving an independent one.");
+    }
+
+    [Fact]
+    public void Bare_clone_uses_the_generated_full_clone_path()
+    {
+        var original = Trained();
+
+        var clone = (DenseLayer<double>)original.Clone();
+        Mutate(clone);
+
+        Assert.Equal(1.0, original.GetParameters()[0], precision: 10);
+        Assert.Equal(99.0, clone.GetParameters()[0], precision: 10);
+    }
+
+    [Fact]
+    public void Buffer_and_optimizer_state_flags_are_independent()
+    {
+        var original = new CloneStateProbeLayer<double>
+        {
+            Running = 17,
+            Optimizer = 29,
+        };
+
+        var buffersOnly = (CloneStateProbeLayer<double>)original.Clone(new CloneOptions
+        {
+            IncludeParameters = false,
+            IncludeBuffers = true,
+            IncludeOptimizerState = false,
+        });
+        var optimizerOnly = (CloneStateProbeLayer<double>)original.Clone(new CloneOptions
+        {
+            IncludeParameters = false,
+            IncludeBuffers = false,
+            IncludeOptimizerState = true,
+        });
+
+        Assert.Equal(17, buffersOnly.Running);
+        Assert.Equal(-2, buffersOnly.Optimizer);
+        Assert.Equal(-1, optimizerOnly.Running);
+        Assert.Equal(29, optimizerOnly.Optimizer);
+    }
+
+    [Fact]
+    public void Shared_mode_aliases_registered_state_while_full_is_independent()
+    {
+        var original = new CloneStateProbeLayer<double>
+        {
+            Running = 17,
+            Optimizer = 29,
+        };
+
+        var full = (CloneStateProbeLayer<double>)original.Clone(CloneOptions.Full);
+        var shared = (CloneStateProbeLayer<double>)original.Clone(CloneOptions.Shared);
+
+        full.Running = 41;
+        full.Optimizer = 43;
+        Assert.Equal(17, original.Running);
+        Assert.Equal(29, original.Optimizer);
+
+        shared.Running = 47;
+        shared.Optimizer = 53;
+        Assert.Equal(47, original.Running);
+        Assert.Equal(53, original.Optimizer);
+    }
+
+    [Fact]
+    public void CopyOnWrite_mode_splits_registered_state_on_write()
+    {
+        var original = new CloneStateProbeLayer<double>
+        {
+            Running = 17,
+            Optimizer = 29,
+        };
+
+        var clone = (CloneStateProbeLayer<double>)original.Clone(CloneOptions.CopyOnWrite);
+        Assert.Equal(original.Running, clone.Running);
+        Assert.Equal(original.Optimizer, clone.Optimizer);
+
+        clone.Running = 41;
+        clone.Optimizer = 43;
+
+        Assert.Equal(17, original.Running);
+        Assert.Equal(29, original.Optimizer);
+        Assert.Equal(41, clone.Running);
+        Assert.Equal(43, clone.Optimizer);
+    }
+
+    private static void Mutate(DenseLayer<double> layer)
+    {
+        var p = layer.GetParameters();
+        p[0] = 99.0;
+        layer.UpdateParameters(p);
+    }
+}
diff --git a/tests/AiDotNet.Tests/UnitTests/Serialization/ExpressionStateTests.cs b/tests/AiDotNet.Tests/UnitTests/Serialization/ExpressionStateTests.cs
new file mode 100644
index 0000000000..9bed0938fb
--- /dev/null
+++ b/tests/AiDotNet.Tests/UnitTests/Serialization/ExpressionStateTests.cs
@@ -0,0 +1,89 @@
+using System.Linq.Expressions;
+using AiDotNet.Serialization;
+using AiDotNet.Tensors.LinearAlgebra;
+using Xunit;
+
+namespace AiDotNetTests.UnitTests.Serialization;
+
+/// <summary>
+/// Round-trip tests for the expression-tree description of a delegate.
+/// </summary>
+/// <remarks>
+/// These compile the rebuilt tree and compare its output to the original's, because a tree that
+/// serializes is not evidence it rebuilds the same function. The allowlist test matters most: it is
+/// the one property that separates this from Keras's Lambda layer.
+/// </remarks>
+public class ExpressionStateTests
+{
+    private static Tensor<double> Probe(params double[] values)
+    {
+        var tensor = new Tensor<double>([values.Length]);
+        for (var i = 0; i < values.Length; i++) tensor[i] = values[i];
+        return tensor;
+    }
+
+    [Fact]
+    public void A_closure_over_a_captured_constant_round_trips()
+    {
+        // The case a method reference cannot describe and a traced graph declines: the captured
+        // scale is a constant leaf. In a tree it is simply a node.
+        var scale = 3.0;
+        Expression<Func<double, double>> expression = x => x * scale + 1.0;
+
+        var saved = ExpressionState.Save(expression);
+        Assert.NotEqual(string.Empty, saved);
+
+        var restored = ExpressionState.Load<Func<double, double>>(saved, "TestLayer", "expression").Compile();
+
+        Assert.Equal(expression.Compile()(2.0), restored(2.0), precision: 10);
+        Assert.Equal(7.0, restored(2.0), precision: 10);
+    }
+
+    [Fact]
+    public void A_call_into_an_allowed_type_round_trips()
+    {
+        Expression<Func<double, double>> expression = x => Math.Sqrt(x);
+
+        var saved = ExpressionState.Save(expression);
+        Assert.Contains("Sqrt", saved);
+
+        var restored = ExpressionState.Load<Func<double, double>>(saved, "TestLayer", "expression").Compile();
+        Assert.Equal(3.0, restored(9.0), precision: 10);
+    }
+
+    [Fact]
+    public void A_call_into_a_type_outside_the_allowlist_is_refused_before_it_is_compiled()
+    {
+        // System.IO is not on the allowlist, so a saved model naming it cannot reach Compile().
+        // This is the hazard that makes loading a Keras Lambda layer arbitrary code execution.
+        Expression<Func<string, bool>> expression = p => System.IO.File.Exists(p);
+
+        var saved = ExpressionState.Save(expression);
+        Assert.NotEqual(string.Empty, saved);
+        Assert.False(ExpressionState.IsAllowed(typeof(System.IO.File)));
+
+        var failure = Assert.Throws<InvalidOperationException>(
+            () => ExpressionState.Load<Func<string, bool>>(saved, "TestLayer", "expression"));
+
+        Assert.Contains("not a type a restored expression is allowed to call", failure.Message);
+    }
+
+    [Fact]
+    public void A_captured_object_abandons_the_tree_rather_than_saving_a_partial_one()
+    {
+        // The captured tensor is a constant of a non-primitive type; serializing it whole is not
+        // what construction state means, so the tree declines and the caller falls to another tier.
+        var captured = Probe(1.0, 2.0);
+        Expression<Func<int, Tensor<double>>> expression = _ => captured;
+
+        Assert.Equal(string.Empty, ExpressionState.Save(expression));
+    }
+
+    [Fact]
+    public void The_allowlist_admits_the_types_that_define_the_layers()
+    {
+        Assert.True(ExpressionState.IsAllowed(typeof(LayerStateBag)));
+        Assert.True(ExpressionState.IsAllowed(typeof(Math)));
+        Assert.False(ExpressionState.IsAllowed(typeof(System.Diagnostics.Process)));
+    }
+}
diff --git a/tests/AiDotNet.Tests/UnitTests/Serialization/ExternalLayerCloneTests.cs b/tests/AiDotNet.Tests/UnitTests/Serialization/ExternalLayerCloneTests.cs
new file mode 100644
index 0000000000..3d82f63f6c
--- /dev/null
+++ b/tests/AiDotNet.Tests/UnitTests/Serialization/ExternalLayerCloneTests.cs
@@ -0,0 +1,100 @@
+using AiDotNet.ActivationFunctions;
+using AiDotNet.Interfaces;
+using AiDotNet.NeuralNetworks.Layers;
+using AiDotNet.Serialization;
+using AiDotNet.Tensors.LinearAlgebra;
+using Xunit;
+
+namespace AiDotNetTests.UnitTests.Serialization;
+
+/// <summary>
+/// A layer declared in the TEST assembly, which the generator never sees.
+/// </summary>
+/// <remarks>
+/// This is the only kind of layer that proves the clone path works for a consumer. Every layer in
+/// the 321-type sweep lives in AiDotNet, so the generated factory table already names it; none of
+/// them can demonstrate what happens to somebody else's layer.
+/// </remarks>
+// Shape-preserving: the constructor passes [units] as BOTH the input and the output shape, so
+// the layer is element-wise at any rank. ADNSHAPE006 requires every LayerBase to say which it
+// is, and this is the form the descriptor prescribes for that case.
+[AiDotNet.Attributes.ElementWiseShape]
+public sealed partial class ExternalTestLayer<T> : LayerBase<T>
+{
+    private readonly int _units;
+    private readonly bool _useBias;
+
+    /// <summary>Initializes a new instance of the <see cref="ExternalTestLayer{T}"/> class.</summary>
+    /// <param name="units">The output width.</param>
+    /// <param name="useBias">Whether a bias is added. Defaults to <c>true</c>.</param>
+    public ExternalTestLayer(int units, bool useBias = true)
+        : base([units], [units])
+    {
+        _units = units;
+        _useBias = useBias;
+    }
+
+    /// <summary>The width this layer was built with.</summary>
+    public int Units => _units;
+
+    /// <summary>Whether this layer was built with a bias.</summary>
+    public bool UseBias => _useBias;
+
+    /// <inheritdoc/>
+    public override bool SupportsTraining => false;
+
+    /// <inheritdoc/>
+    public override void ResetState()
+    {
+    }
+}
+
+/// <summary>Cloning a layer that AiDotNet's generator never compiled.</summary>
+public class ExternalLayerCloneTests
+{
+    [Fact]
+    public void A_layer_from_another_assembly_clones_with_its_construction_state()
+    {
+        var original = new ExternalTestLayer<double>(units: 7, useBias: false);
+
+        var clone = original.Clone();
+
+        var typed = Assert.IsType<ExternalTestLayer<double>>(clone);
+        Assert.NotSame(original, typed);
+
+        // The point of the whole exercise: the arguments survive. Before the registry this threw,
+        // telling the author to add [LayerState] -- which cannot help, because the generator does
+        // not run in their compilation.
+        Assert.Equal(7, typed.Units);
+        Assert.False(typed.UseBias);
+    }
+
+    [Fact]
+    public void An_omitted_optional_argument_keeps_its_declared_default()
+    {
+        // useBias defaults to true. Rebuilding it as default(bool) would be false, which is the
+        // silent-value-loss this work exists to remove.
+        var original = new ExternalTestLayer<double>(units: 3);
+
+        var clone = (ExternalTestLayer<double>)original.Clone();
+
+        Assert.Equal(3, clone.Units);
+        Assert.True(clone.UseBias);
+    }
+
+    [Fact]
+    public void An_explicitly_registered_factory_is_preferred_over_reflection()
+    {
+        LayerFactoryRegistry<float>.Register(
+            typeof(ExternalTestLayer<>),
+            (state, _, _) => new ExternalTestLayer<float>(state.Int32("units"), state.Boolean("useBias")));
+
+        Assert.True(LayerFactoryRegistry<float>.IsRegistered(typeof(ExternalTestLayer<>)));
+
+        var original = new ExternalTestLayer<float>(units: 5, useBias: false);
+        var clone = (ExternalTestLayer<float>)original.Clone();
+
+        Assert.Equal(5, clone.Units);
+        Assert.False(clone.UseBias);
+    }
+}
diff --git a/tests/AiDotNet.Tests/UnitTests/Serialization/GraphTraceTests.cs b/tests/AiDotNet.Tests/UnitTests/Serialization/GraphTraceTests.cs
new file mode 100644
index 0000000000..d27e298262
--- /dev/null
+++ b/tests/AiDotNet.Tests/UnitTests/Serialization/GraphTraceTests.cs
@@ -0,0 +1,120 @@
+using AiDotNet.Autodiff;
+using AiDotNet.Serialization;
+using AiDotNet.Tensors.LinearAlgebra;
+using Xunit;
+
+namespace AiDotNetTests.UnitTests.Serialization;
+
+/// <summary>
+/// Round-trip tests for the traced-graph description of a delegate.
+/// </summary>
+/// <remarks>
+/// These run the trace and the replay, because a graph that serializes without throwing is not
+/// evidence that it rebuilds the same function -- which is the only thing it exists to do.
+/// </remarks>
+public class GraphTraceTests
+{
+    private static Tensor<double> Probe(params double[] values)
+    {
+        var tensor = new Tensor<double>([values.Length]);
+        for (var i = 0; i < values.Length; i++) tensor[i] = values[i];
+        return tensor;
+    }
+
+    private static Tensor<double> Run(Func<ComputationNode<double>, ComputationNode<double>> f, Tensor<double> input)
+        => f(TensorOperations<double>.Variable(input)).Value;
+
+    [Fact]
+    public void Trace_records_a_closure_that_has_no_name_to_refer_to()
+    {
+        // The case a method reference cannot describe: the delegate is a lambda, so tier 3 declines.
+        Func<ComputationNode<double>, ComputationNode<double>> expression =
+            x => TensorOperations<double>.Square(TensorOperations<double>.Tanh(x));
+
+        var graph = GraphTrace.Trace(expression, [3]);
+
+        Assert.NotNull(graph);
+        Assert.Contains("Tanh", graph);
+        Assert.Contains("Square", graph);
+    }
+
+    [Fact]
+    public void Replayed_graph_computes_what_the_original_computed()
+    {
+        Func<ComputationNode<double>, ComputationNode<double>> expression =
+            x => TensorOperations<double>.Square(TensorOperations<double>.Tanh(x));
+
+        var graph = GraphTrace.Trace(expression, [3]);
+        var replayed = GraphTrace.Compile<double>(graph!, "TestLayer", "expression");
+
+        var input = Probe(0.25, -1.5, 2.0);
+        var expected = Run(expression, input);
+        var actual = Run(replayed, input);
+
+        for (var i = 0; i < 3; i++)
+        {
+            Assert.Equal(expected[i], actual[i], precision: 10);
+        }
+    }
+
+    [Fact]
+    public void Operation_parameters_survive_the_round_trip()
+    {
+        // Softmax records its axis in OperationParams under "Axis" while the parameter is "axis",
+        // so this is what proves the binding is case-insensitive rather than accidentally aligned.
+        Func<ComputationNode<double>, ComputationNode<double>> expression =
+            x => TensorOperations<double>.Softmax(x, axis: -1);
+
+        var graph = GraphTrace.Trace(expression, [4]);
+        Assert.NotNull(graph);
+
+        var replayed = GraphTrace.Compile<double>(graph!, "TestLayer", "expression");
+        var input = Probe(1.0, 2.0, 3.0, 4.0);
+
+        var expected = Run(expression, input);
+        var actual = Run(replayed, input);
+
+        for (var i = 0; i < 4; i++)
+        {
+            Assert.Equal(expected[i], actual[i], precision: 10);
+        }
+    }
+
+    [Fact]
+    public void A_captured_constant_abandons_the_graph_rather_than_saving_a_partial_one()
+    {
+        // The captured tensor is a leaf that is not the input, so its value is not recoverable from
+        // the graph. Declining sends the caller to a weaker tier instead of rebuilding a different
+        // function, which is the whole point of recording all-or-nothing.
+        var captured = TensorOperations<double>.Constant(Probe(2.0, 2.0, 2.0));
+        Func<ComputationNode<double>, ComputationNode<double>> expression =
+            x => TensorOperations<double>.Add(x, captured);
+
+        Assert.Null(GraphTrace.Trace(expression, [3]));
+    }
+
+    [Fact]
+    public void DelegateState_falls_through_to_the_graph_when_the_delegate_has_no_name()
+    {
+        Func<ComputationNode<double>, ComputationNode<double>> expression =
+            x => TensorOperations<double>.Tanh(x);
+
+        // Tier 3 cannot describe a lambda at all.
+        Assert.Equal(string.Empty, DelegateState.Save(expression));
+
+        var saved = DelegateState.SaveTraceable(expression, [3]);
+        Assert.StartsWith(DelegateState.GraphScheme, saved);
+
+        var restored = DelegateState.Load<Func<ComputationNode<double>, ComputationNode<double>>>(
+            saved, "TestLayer", "expression");
+
+        var input = Probe(0.5, -0.5, 1.25);
+        var expected = Run(expression, input);
+        var actual = Run(restored, input);
+
+        for (var i = 0; i < 3; i++)
+        {
+            Assert.Equal(expected[i], actual[i], precision: 10);
+        }
+    }
+}
diff --git a/tests/AiDotNet.Tests/UnitTests/Serialization/LayerStateBagTests.cs b/tests/AiDotNet.Tests/UnitTests/Serialization/LayerStateBagTests.cs
new file mode 100644
index 0000000000..887e7cf7df
--- /dev/null
+++ b/tests/AiDotNet.Tests/UnitTests/Serialization/LayerStateBagTests.cs
@@ -0,0 +1,89 @@
+using AiDotNet.Enums;
+using AiDotNet.NeuralNetworks.Attention;
+using AiDotNet.Serialization;
+using Xunit;
+
+namespace AiDotNetTests.UnitTests.Serialization;
+
+public sealed class LayerStateBagTests
+{
+    [Fact]
+    public void Nullable_state_distinguishes_null_empty_and_legacy_values()
+    {
+        var bag = new LayerStateBag(new Dictionary<string, object>
+        {
+            ["nullText"] = LayerStateBag.FormatNullable((string?)null),
+            ["emptyText"] = LayerStateBag.FormatNullable(string.Empty),
+            ["legacyText"] = "before-tags",
+            ["nullArray"] = LayerStateBag.FormatNullable((int[]?)null),
+            ["emptyArray"] = LayerStateBag.FormatNullable(Array.Empty<int>()),
+            ["legacyArray"] = "2,3,5",
+        }, "ProbeLayer");
+
+        Assert.Null(bag.NullableString("nullText"));
+        Assert.Equal(string.Empty, bag.NullableString("emptyText"));
+        Assert.Equal("before-tags", bag.NullableString("legacyText"));
+        Assert.Null(bag.NullableInt32Array("nullArray"));
+        Assert.Empty(bag.NullableInt32Array("emptyArray")!);
+        Assert.Equal(new[] { 2, 3, 5 }, bag.NullableInt32Array("legacyArray"));
+    }
+
+    [Fact]
+    public void Enum_arrays_round_trip_by_name()
+    {
+        var expected = new[] { PNAAggregator.Max, PNAAggregator.StdDev };
+        var bag = new LayerStateBag(new Dictionary<string, object>
+        {
+            ["aggregators"] = LayerStateBag.FormatEnumArray(expected),
+        }, "ProbeLayer");
+
+        Assert.Equal(expected, bag.EnumArray<PNAAggregator>("aggregators"));
+    }
+
+    [Fact]
+    public void Live_json_configuration_is_deep_copied_through_the_durable_representation()
+    {
+        var config = new FlashAttentionConfig
+        {
+            BlockSizeQ = 17,
+            UseCausalMask = true,
+            Precision = FlashAttentionPrecision.Mixed,
+        };
+        var bag = new LayerStateBag(new Dictionary<string, object>
+        {
+            ["config"] = config,
+        }, "ProbeLayer");
+
+        var copy = bag.JsonObject<FlashAttentionConfig>("config");
+
+        Assert.NotSame(config, copy);
+        Assert.Equal(17, copy.BlockSizeQ);
+        Assert.True(copy.UseCausalMask);
+        Assert.Equal(FlashAttentionPrecision.Mixed, copy.Precision);
+    }
+
+    [Fact]
+    public void Live_rectangular_reference_array_is_deep_copied_without_flattening()
+    {
+        var source = new[,]
+        {
+            { new List<int> { 1, 2 }, new List<int> { 3 } },
+            { new List<int> { 4 }, new List<int> { 5, 6 } },
+        };
+        var bag = new LayerStateBag(new Dictionary<string, object>
+        {
+            ["grid"] = source,
+        }, "RectangularArrayProbe");
+
+        var copy = bag.CloneObject<List<int>[,]>("grid");
+
+        Assert.Equal(source.GetLength(0), copy.GetLength(0));
+        Assert.Equal(source.GetLength(1), copy.GetLength(1));
+        Assert.NotSame(source, copy);
+        Assert.NotSame(source[0, 0], copy[0, 0]);
+        Assert.Equal(source[0, 0], copy[0, 0]);
+
+        copy[0, 0].Add(99);
+        Assert.Equal(new[] { 1, 2 }, source[0, 0]);
+    }
+}